max_stars_repo_path stringlengths 4 261 | max_stars_repo_name stringlengths 6 106 | max_stars_count int64 0 38.8k | id stringlengths 1 6 | text stringlengths 7 1.05M |
|---|---|---|---|---|
malban/Release/VRelease/Release.History/VRelease_2017_04_23/Song/track_0A_08.asm | mikepea/vectrex-playground | 5 | 4481 | <reponame>mikepea/vectrex-playground
dw $0040
track_0A_08:
db $FF, $18, $97, $DE, $63, $FE, $1A, $7E, $E6, $34
db $ED, $FC, $70, $30, $FF, $BC, $9E, $3F, $18, $F9
db $DE, $8E, $3D, $6F, $27, $8F, $FD, $E8, $E9, $C4
db $BE, $EA, $A3, $EE, $FD, $2F, $3F, $A8, $F6, $8C
db $4B, $AC, $E1, $D3, $48, $F5, $3C, $86, $F7, $B1
db $E4, $F1, $77, $77, $F7, $BB, $1C, $2E, $EF, $51
db $E7, $B9, $E3, $E4, $79, $EE, $EE, $F9, $1E, $79
db $9E, $3B, $C7, $9D, $A7, $8F, $7E, $F7, $99, $E3
db $7B, $DC, $0C, $0F, $FD, $E8, $E9, $C4, $BE, $EA
db $A3, $EE, $FD, $2F, $3F, $A8, $F6, $8C, $4B, $AC
db $E1, $D3, $48, $F5, $3C, $86, $F7, $B1, $E4, $F1
db $77, $77, $F7, $BB, $1C, $2E, $E0 |
10 Adapted from others/11 Rich Walsh/03 Files/Reveal target audio file in finder.applescript | streth11/Qlab-Scripts | 0 | 2691 | <gh_stars>0
-- @description Reveal target audio file in finder
-- @author <NAME>
-- @link bensmithsound.uk
-- @source <NAME>
-- @version 1.0
-- @testedmacos 10.13.6
-- @testedqlab 4.6.9
-- @about Reveals the target audio file of the selected cue in finder
-- @separateprocess FALSE
-- @changelog
-- v1.0 + init
set editCue to last item of (selected of front workspace as list)
if q type of editCue is "Audio" then
set fileTarget to file target of editCue
tell application "Finder"
reveal fileTarget
activate
end tell
end if |
huffman/huffman-types.agda | heades/AUGL | 0 | 10148 | ----------------------------------------------------------------------------------
-- Types for parse trees
----------------------------------------------------------------------------------
module huffman-types where
open import lib
open import parse-tree
posinfo = string
character = string
character-bar-3 = string
character-bar-4 = string
character-bar-5 = string
character-bar-6 = string
character-bar-7 = string
character-range-1 = string
character-range-2 = string
word = string
mutual
data bvlit : Set where
BvlitCons : digit → bvlit → bvlit
BvlitStart : digit → bvlit
data cmd : Set where
Decode : codes → bvlit → cmd
Encode : words → cmd
data code : Set where
Code : word → bvlit → code
data codes : Set where
CodesNext : code → codes → codes
CodesStart : code → codes
data digit : Set where
One : digit
Zero : digit
data start : Set where
File : cmd → start
data words : Set where
WordsNext : word → words → words
WordsStart : word → words
-- embedded types:
data ParseTreeT : Set where
parsed-bvlit : bvlit → ParseTreeT
parsed-cmd : cmd → ParseTreeT
parsed-code : code → ParseTreeT
parsed-codes : codes → ParseTreeT
parsed-digit : digit → ParseTreeT
parsed-start : start → ParseTreeT
parsed-words : words → ParseTreeT
parsed-posinfo : posinfo → ParseTreeT
parsed-character : character → ParseTreeT
parsed-character-bar-3 : character-bar-3 → ParseTreeT
parsed-character-bar-4 : character-bar-4 → ParseTreeT
parsed-character-bar-5 : character-bar-5 → ParseTreeT
parsed-character-bar-6 : character-bar-6 → ParseTreeT
parsed-character-bar-7 : character-bar-7 → ParseTreeT
parsed-character-range-1 : character-range-1 → ParseTreeT
parsed-character-range-2 : character-range-2 → ParseTreeT
parsed-word : word → ParseTreeT
parsed-aws : ParseTreeT
parsed-aws-bar-8 : ParseTreeT
parsed-aws-bar-9 : ParseTreeT
parsed-ows : ParseTreeT
parsed-ows-star-11 : ParseTreeT
parsed-ws : ParseTreeT
parsed-ws-plus-10 : ParseTreeT
------------------------------------------
-- Parse tree printing functions
------------------------------------------
posinfoToString : posinfo → string
posinfoToString x = "(posinfo " ^ x ^ ")"
characterToString : character → string
characterToString x = "(character " ^ x ^ ")"
character-bar-3ToString : character-bar-3 → string
character-bar-3ToString x = "(character-bar-3 " ^ x ^ ")"
character-bar-4ToString : character-bar-4 → string
character-bar-4ToString x = "(character-bar-4 " ^ x ^ ")"
character-bar-5ToString : character-bar-5 → string
character-bar-5ToString x = "(character-bar-5 " ^ x ^ ")"
character-bar-6ToString : character-bar-6 → string
character-bar-6ToString x = "(character-bar-6 " ^ x ^ ")"
character-bar-7ToString : character-bar-7 → string
character-bar-7ToString x = "(character-bar-7 " ^ x ^ ")"
character-range-1ToString : character-range-1 → string
character-range-1ToString x = "(character-range-1 " ^ x ^ ")"
character-range-2ToString : character-range-2 → string
character-range-2ToString x = "(character-range-2 " ^ x ^ ")"
wordToString : word → string
wordToString x = "(word " ^ x ^ ")"
mutual
bvlitToString : bvlit → string
bvlitToString (BvlitCons x0 x1) = "(BvlitCons" ^ " " ^ (digitToString x0) ^ " " ^ (bvlitToString x1) ^ ")"
bvlitToString (BvlitStart x0) = "(BvlitStart" ^ " " ^ (digitToString x0) ^ ")"
cmdToString : cmd → string
cmdToString (Decode x0 x1) = "(Decode" ^ " " ^ (codesToString x0) ^ " " ^ (bvlitToString x1) ^ ")"
cmdToString (Encode x0) = "(Encode" ^ " " ^ (wordsToString x0) ^ ")"
codeToString : code → string
codeToString (Code x0 x1) = "(Code" ^ " " ^ (wordToString x0) ^ " " ^ (bvlitToString x1) ^ ")"
codesToString : codes → string
codesToString (CodesNext x0 x1) = "(CodesNext" ^ " " ^ (codeToString x0) ^ " " ^ (codesToString x1) ^ ")"
codesToString (CodesStart x0) = "(CodesStart" ^ " " ^ (codeToString x0) ^ ")"
digitToString : digit → string
digitToString (One) = "One" ^ ""
digitToString (Zero) = "Zero" ^ ""
startToString : start → string
startToString (File x0) = "(File" ^ " " ^ (cmdToString x0) ^ ")"
wordsToString : words → string
wordsToString (WordsNext x0 x1) = "(WordsNext" ^ " " ^ (wordToString x0) ^ " " ^ (wordsToString x1) ^ ")"
wordsToString (WordsStart x0) = "(WordsStart" ^ " " ^ (wordToString x0) ^ ")"
ParseTreeToString : ParseTreeT → string
ParseTreeToString (parsed-bvlit t) = bvlitToString t
ParseTreeToString (parsed-cmd t) = cmdToString t
ParseTreeToString (parsed-code t) = codeToString t
ParseTreeToString (parsed-codes t) = codesToString t
ParseTreeToString (parsed-digit t) = digitToString t
ParseTreeToString (parsed-start t) = startToString t
ParseTreeToString (parsed-words t) = wordsToString t
ParseTreeToString (parsed-posinfo t) = posinfoToString t
ParseTreeToString (parsed-character t) = characterToString t
ParseTreeToString (parsed-character-bar-3 t) = character-bar-3ToString t
ParseTreeToString (parsed-character-bar-4 t) = character-bar-4ToString t
ParseTreeToString (parsed-character-bar-5 t) = character-bar-5ToString t
ParseTreeToString (parsed-character-bar-6 t) = character-bar-6ToString t
ParseTreeToString (parsed-character-bar-7 t) = character-bar-7ToString t
ParseTreeToString (parsed-character-range-1 t) = character-range-1ToString t
ParseTreeToString (parsed-character-range-2 t) = character-range-2ToString t
ParseTreeToString (parsed-word t) = wordToString t
ParseTreeToString parsed-aws = "[aws]"
ParseTreeToString parsed-aws-bar-8 = "[aws-bar-8]"
ParseTreeToString parsed-aws-bar-9 = "[aws-bar-9]"
ParseTreeToString parsed-ows = "[ows]"
ParseTreeToString parsed-ows-star-11 = "[ows-star-11]"
ParseTreeToString parsed-ws = "[ws]"
ParseTreeToString parsed-ws-plus-10 = "[ws-plus-10]"
------------------------------------------
-- Reorganizing rules
------------------------------------------
mutual
{-# NO_TERMINATION_CHECK #-}
norm-words : (x : words) → words
norm-words x = x
{-# NO_TERMINATION_CHECK #-}
norm-start : (x : start) → start
norm-start x = x
{-# NO_TERMINATION_CHECK #-}
norm-posinfo : (x : posinfo) → posinfo
norm-posinfo x = x
{-# NO_TERMINATION_CHECK #-}
norm-digit : (x : digit) → digit
norm-digit x = x
{-# NO_TERMINATION_CHECK #-}
norm-codes : (x : codes) → codes
norm-codes x = x
{-# NO_TERMINATION_CHECK #-}
norm-code : (x : code) → code
norm-code x = x
{-# NO_TERMINATION_CHECK #-}
norm-cmd : (x : cmd) → cmd
norm-cmd x = x
{-# NO_TERMINATION_CHECK #-}
norm-bvlit : (x : bvlit) → bvlit
norm-bvlit x = x
isParseTree : ParseTreeT → 𝕃 char → string → Set
isParseTree p l s = ⊤ {- this will be ignored since we are using simply typed runs -}
ptr : ParseTreeRec
ptr = record { ParseTreeT = ParseTreeT ; isParseTree = isParseTree ; ParseTreeToString = ParseTreeToString }
|
programs/oeis/332/A332056.asm | jmorken/loda | 1 | 16559 | ; A332056: a(1) = 1, then a(n+1) = a(n) - (-1)^a(n) Sum_{k=1..n} a(k): if a(n) is odd, add the partial sum, else subtract.
; 1,2,-1,1,4,-3,1,6,-5,1,8,-7,1,10,-9,1,12,-11,1,14,-13,1,16,-15,1,18,-17,1,20,-19,1,22,-21,1,24,-23,1,26,-25,1,28,-27,1,30,-29,1,32,-31,1,34,-33,1,36,-35,1,38,-37,1,40,-39
mul $0,4
mov $1,4
lpb $0
sub $0,3
add $1,4
lpe
mul $1,$0
div $1,8
add $1,1
|
common/dlists/playfieldDlist.asm | laoo/TimePilot | 24 | 174119 |
org dataPlayfieldDlist
dta b($50),b($c7),a(bufScreenTxt)
dta b($45)
adrBufScreen0 equ *+1
dta a(bufScreen0),b($5),b($85),b($5),b($5),b($85),b($5),b($5),b($85),b($5),b($5)
dta b($85),b($10)
dta b($4d),a(bufProgressBar),b($d),b($d),b($d),b($d),b($d),b($d),b($d)
dta b($41),a(dataPlayfieldDlist)
org dataPlayfieldDlist2 ; titleScreen transition
dta b($50),b($45)
dta a(bufScreen0)
dta b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($5),b($10)
dta b($41),a(dataPlayfieldDlist2)
|
sh.asm | mur1ll0/xv6-stride | 0 | 240141 |
_sh: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
return 0;
}
int
main(void)
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 51 push %ecx
e: 83 ec 04 sub $0x4,%esp
static char buf[100];
int fd;
// Ensure that three file descriptors are open.
while((fd = open("console", O_RDWR)) >= 0){
11: eb 0e jmp 21 <main+0x21>
13: 90 nop
14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(fd >= 3){
18: 83 f8 02 cmp $0x2,%eax
1b: 0f 8f c9 00 00 00 jg ea <main+0xea>
while((fd = open("console", O_RDWR)) >= 0){
21: 83 ec 08 sub $0x8,%esp
24: 6a 02 push $0x2
26: 68 f1 11 00 00 push $0x11f1
2b: e8 f2 0c 00 00 call d22 <open>
30: 83 c4 10 add $0x10,%esp
33: 85 c0 test %eax,%eax
35: 79 e1 jns 18 <main+0x18>
37: eb 25 jmp 5e <main+0x5e>
39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
}
// Read and run input commands.
while(getcmd(buf, sizeof(buf)) >= 0){
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
40: 80 3d 02 18 00 00 20 cmpb $0x20,0x1802
47: 74 60 je a9 <main+0xa9>
49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
buf[strlen(buf)-1] = 0; // chop \n
if(chdir(buf+3) < 0)
printf(2, "cannot cd %s\n", buf+3);
continue;
}
if(fork1() == 0)
50: e8 1b 01 00 00 call 170 <fork1>
55: 85 c0 test %eax,%eax
57: 74 36 je 8f <main+0x8f>
runcmd(parsecmd(buf));
wait();
59: e8 8c 0c 00 00 call cea <wait>
while(getcmd(buf, sizeof(buf)) >= 0){
5e: 83 ec 08 sub $0x8,%esp
61: 6a 64 push $0x64
63: 68 00 18 00 00 push $0x1800
68: e8 93 00 00 00 call 100 <getcmd>
6d: 83 c4 10 add $0x10,%esp
70: 85 c0 test %eax,%eax
72: 78 30 js a4 <main+0xa4>
if(buf[0] == 'c' && buf[1] == 'd' && buf[2] == ' '){
74: 80 3d 00 18 00 00 63 cmpb $0x63,0x1800
7b: 75 d3 jne 50 <main+0x50>
7d: 80 3d 01 18 00 00 64 cmpb $0x64,0x1801
84: 74 ba je 40 <main+0x40>
if(fork1() == 0)
86: e8 e5 00 00 00 call 170 <fork1>
8b: 85 c0 test %eax,%eax
8d: 75 ca jne 59 <main+0x59>
runcmd(parsecmd(buf));
8f: 83 ec 0c sub $0xc,%esp
92: 68 00 18 00 00 push $0x1800
97: e8 94 09 00 00 call a30 <parsecmd>
9c: 89 04 24 mov %eax,(%esp)
9f: e8 fc 00 00 00 call 1a0 <runcmd>
}
exit();
a4: e8 39 0c 00 00 call ce2 <exit>
buf[strlen(buf)-1] = 0; // chop \n
a9: 83 ec 0c sub $0xc,%esp
ac: 68 00 18 00 00 push $0x1800
b1: e8 6a 0a 00 00 call b20 <strlen>
if(chdir(buf+3) < 0)
b6: c7 04 24 03 18 00 00 movl $0x1803,(%esp)
buf[strlen(buf)-1] = 0; // chop \n
bd: c6 80 ff 17 00 00 00 movb $0x0,0x17ff(%eax)
if(chdir(buf+3) < 0)
c4: e8 89 0c 00 00 call d52 <chdir>
c9: 83 c4 10 add $0x10,%esp
cc: 85 c0 test %eax,%eax
ce: 79 8e jns 5e <main+0x5e>
printf(2, "cannot cd %s\n", buf+3);
d0: 50 push %eax
d1: 68 03 18 00 00 push $0x1803
d6: 68 f9 11 00 00 push $0x11f9
db: 6a 02 push $0x2
dd: e8 4e 0d 00 00 call e30 <printf>
e2: 83 c4 10 add $0x10,%esp
e5: e9 74 ff ff ff jmp 5e <main+0x5e>
close(fd);
ea: 83 ec 0c sub $0xc,%esp
ed: 50 push %eax
ee: e8 17 0c 00 00 call d0a <close>
break;
f3: 83 c4 10 add $0x10,%esp
f6: e9 63 ff ff ff jmp 5e <main+0x5e>
fb: 66 90 xchg %ax,%ax
fd: 66 90 xchg %ax,%ax
ff: 90 nop
00000100 <getcmd>:
{
100: 55 push %ebp
101: 89 e5 mov %esp,%ebp
103: 56 push %esi
104: 53 push %ebx
105: 8b 75 0c mov 0xc(%ebp),%esi
108: 8b 5d 08 mov 0x8(%ebp),%ebx
printf(2, "$ ");
10b: 83 ec 08 sub $0x8,%esp
10e: 68 50 11 00 00 push $0x1150
113: 6a 02 push $0x2
115: e8 16 0d 00 00 call e30 <printf>
memset(buf, 0, nbuf);
11a: 83 c4 0c add $0xc,%esp
11d: 56 push %esi
11e: 6a 00 push $0x0
120: 53 push %ebx
121: e8 2a 0a 00 00 call b50 <memset>
gets(buf, nbuf);
126: 58 pop %eax
127: 5a pop %edx
128: 56 push %esi
129: 53 push %ebx
12a: e8 81 0a 00 00 call bb0 <gets>
if(buf[0] == 0) // EOF
12f: 83 c4 10 add $0x10,%esp
132: 31 c0 xor %eax,%eax
134: 80 3b 00 cmpb $0x0,(%ebx)
137: 0f 94 c0 sete %al
}
13a: 8d 65 f8 lea -0x8(%ebp),%esp
if(buf[0] == 0) // EOF
13d: f7 d8 neg %eax
}
13f: 5b pop %ebx
140: 5e pop %esi
141: 5d pop %ebp
142: c3 ret
143: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
149: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000150 <panic>:
}
void
panic(char *s)
{
150: 55 push %ebp
151: 89 e5 mov %esp,%ebp
153: 83 ec 0c sub $0xc,%esp
printf(2, "%s\n", s);
156: ff 75 08 pushl 0x8(%ebp)
159: 68 ed 11 00 00 push $0x11ed
15e: 6a 02 push $0x2
160: e8 cb 0c 00 00 call e30 <printf>
exit();
165: e8 78 0b 00 00 call ce2 <exit>
16a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000170 <fork1>:
}
int
fork1(void)
{
170: 55 push %ebp
171: 89 e5 mov %esp,%ebp
173: 83 ec 14 sub $0x14,%esp
int pid;
pid = fork(50);
176: 6a 32 push $0x32
178: e8 5d 0b 00 00 call cda <fork>
if(pid == -1)
17d: 83 c4 10 add $0x10,%esp
180: 83 f8 ff cmp $0xffffffff,%eax
183: 74 02 je 187 <fork1+0x17>
panic("fork");
return pid;
}
185: c9 leave
186: c3 ret
panic("fork");
187: 83 ec 0c sub $0xc,%esp
18a: 68 53 11 00 00 push $0x1153
18f: e8 bc ff ff ff call 150 <panic>
194: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
19a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000001a0 <runcmd>:
{
1a0: 55 push %ebp
1a1: 89 e5 mov %esp,%ebp
1a3: 53 push %ebx
1a4: 83 ec 14 sub $0x14,%esp
1a7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(cmd == 0)
1aa: 85 db test %ebx,%ebx
1ac: 74 64 je 212 <runcmd+0x72>
switch(cmd->type){
1ae: 83 3b 05 cmpl $0x5,(%ebx)
1b1: 0f 87 d8 00 00 00 ja 28f <runcmd+0xef>
1b7: 8b 03 mov (%ebx),%eax
1b9: ff 24 85 08 12 00 00 jmp *0x1208(,%eax,4)
if(pipe(p) < 0)
1c0: 8d 45 f0 lea -0x10(%ebp),%eax
1c3: 83 ec 0c sub $0xc,%esp
1c6: 50 push %eax
1c7: e8 26 0b 00 00 call cf2 <pipe>
1cc: 83 c4 10 add $0x10,%esp
1cf: 85 c0 test %eax,%eax
1d1: 0f 88 c5 00 00 00 js 29c <runcmd+0xfc>
if(fork1() == 0){
1d7: e8 94 ff ff ff call 170 <fork1>
1dc: 85 c0 test %eax,%eax
1de: 0f 84 08 01 00 00 je 2ec <runcmd+0x14c>
if(fork1() == 0){
1e4: e8 87 ff ff ff call 170 <fork1>
1e9: 85 c0 test %eax,%eax
1eb: 0f 84 cd 00 00 00 je 2be <runcmd+0x11e>
close(p[0]);
1f1: 83 ec 0c sub $0xc,%esp
1f4: ff 75 f0 pushl -0x10(%ebp)
1f7: e8 0e 0b 00 00 call d0a <close>
close(p[1]);
1fc: 58 pop %eax
1fd: ff 75 f4 pushl -0xc(%ebp)
200: e8 05 0b 00 00 call d0a <close>
wait();
205: e8 e0 0a 00 00 call cea <wait>
wait();
20a: e8 db 0a 00 00 call cea <wait>
break;
20f: 83 c4 10 add $0x10,%esp
exit();
212: e8 cb 0a 00 00 call ce2 <exit>
if(fork1() == 0)
217: e8 54 ff ff ff call 170 <fork1>
21c: 85 c0 test %eax,%eax
21e: 75 f2 jne 212 <runcmd+0x72>
220: eb 62 jmp 284 <runcmd+0xe4>
if(ecmd->argv[0] == 0)
222: 8b 43 04 mov 0x4(%ebx),%eax
225: 85 c0 test %eax,%eax
227: 74 e9 je 212 <runcmd+0x72>
exec(ecmd->argv[0], ecmd->argv);
229: 52 push %edx
22a: 52 push %edx
22b: 8d 53 04 lea 0x4(%ebx),%edx
22e: 52 push %edx
22f: 50 push %eax
230: e8 e5 0a 00 00 call d1a <exec>
printf(2, "exec %s failed\n", ecmd->argv[0]);
235: 83 c4 0c add $0xc,%esp
238: ff 73 04 pushl 0x4(%ebx)
23b: 68 5f 11 00 00 push $0x115f
240: 6a 02 push $0x2
242: e8 e9 0b 00 00 call e30 <printf>
break;
247: 83 c4 10 add $0x10,%esp
24a: eb c6 jmp 212 <runcmd+0x72>
if(fork1() == 0)
24c: e8 1f ff ff ff call 170 <fork1>
251: 85 c0 test %eax,%eax
253: 74 2f je 284 <runcmd+0xe4>
wait();
255: e8 90 0a 00 00 call cea <wait>
runcmd(lcmd->right);
25a: 83 ec 0c sub $0xc,%esp
25d: ff 73 08 pushl 0x8(%ebx)
260: e8 3b ff ff ff call 1a0 <runcmd>
close(rcmd->fd);
265: 83 ec 0c sub $0xc,%esp
268: ff 73 14 pushl 0x14(%ebx)
26b: e8 9a 0a 00 00 call d0a <close>
if(open(rcmd->file, rcmd->mode) < 0){
270: 59 pop %ecx
271: 58 pop %eax
272: ff 73 10 pushl 0x10(%ebx)
275: ff 73 08 pushl 0x8(%ebx)
278: e8 a5 0a 00 00 call d22 <open>
27d: 83 c4 10 add $0x10,%esp
280: 85 c0 test %eax,%eax
282: 78 25 js 2a9 <runcmd+0x109>
runcmd(bcmd->cmd);
284: 83 ec 0c sub $0xc,%esp
287: ff 73 04 pushl 0x4(%ebx)
28a: e8 11 ff ff ff call 1a0 <runcmd>
panic("runcmd");
28f: 83 ec 0c sub $0xc,%esp
292: 68 58 11 00 00 push $0x1158
297: e8 b4 fe ff ff call 150 <panic>
panic("pipe");
29c: 83 ec 0c sub $0xc,%esp
29f: 68 7f 11 00 00 push $0x117f
2a4: e8 a7 fe ff ff call 150 <panic>
printf(2, "open %s failed\n", rcmd->file);
2a9: 52 push %edx
2aa: ff 73 08 pushl 0x8(%ebx)
2ad: 68 6f 11 00 00 push $0x116f
2b2: 6a 02 push $0x2
2b4: e8 77 0b 00 00 call e30 <printf>
exit();
2b9: e8 24 0a 00 00 call ce2 <exit>
close(0);
2be: 83 ec 0c sub $0xc,%esp
2c1: 6a 00 push $0x0
2c3: e8 42 0a 00 00 call d0a <close>
dup(p[0]);
2c8: 5a pop %edx
2c9: ff 75 f0 pushl -0x10(%ebp)
2cc: e8 89 0a 00 00 call d5a <dup>
close(p[0]);
2d1: 59 pop %ecx
2d2: ff 75 f0 pushl -0x10(%ebp)
2d5: e8 30 0a 00 00 call d0a <close>
close(p[1]);
2da: 58 pop %eax
2db: ff 75 f4 pushl -0xc(%ebp)
2de: e8 27 0a 00 00 call d0a <close>
runcmd(pcmd->right);
2e3: 58 pop %eax
2e4: ff 73 08 pushl 0x8(%ebx)
2e7: e8 b4 fe ff ff call 1a0 <runcmd>
close(1);
2ec: 83 ec 0c sub $0xc,%esp
2ef: 6a 01 push $0x1
2f1: e8 14 0a 00 00 call d0a <close>
dup(p[1]);
2f6: 58 pop %eax
2f7: ff 75 f4 pushl -0xc(%ebp)
2fa: e8 5b 0a 00 00 call d5a <dup>
close(p[0]);
2ff: 58 pop %eax
300: ff 75 f0 pushl -0x10(%ebp)
303: e8 02 0a 00 00 call d0a <close>
close(p[1]);
308: 58 pop %eax
309: ff 75 f4 pushl -0xc(%ebp)
30c: e8 f9 09 00 00 call d0a <close>
runcmd(pcmd->left);
311: 58 pop %eax
312: ff 73 04 pushl 0x4(%ebx)
315: e8 86 fe ff ff call 1a0 <runcmd>
31a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000320 <execcmd>:
//PAGEBREAK!
// Constructors
struct cmd*
execcmd(void)
{
320: 55 push %ebp
321: 89 e5 mov %esp,%ebp
323: 53 push %ebx
324: 83 ec 10 sub $0x10,%esp
struct execcmd *cmd;
cmd = malloc(sizeof(*cmd));
327: 6a 54 push $0x54
329: e8 42 0d 00 00 call 1070 <malloc>
memset(cmd, 0, sizeof(*cmd));
32e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
331: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
333: 6a 54 push $0x54
335: 6a 00 push $0x0
337: 50 push %eax
338: e8 13 08 00 00 call b50 <memset>
cmd->type = EXEC;
33d: c7 03 01 00 00 00 movl $0x1,(%ebx)
return (struct cmd*)cmd;
}
343: 89 d8 mov %ebx,%eax
345: 8b 5d fc mov -0x4(%ebp),%ebx
348: c9 leave
349: c3 ret
34a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000350 <redircmd>:
struct cmd*
redircmd(struct cmd *subcmd, char *file, char *efile, int mode, int fd)
{
350: 55 push %ebp
351: 89 e5 mov %esp,%ebp
353: 53 push %ebx
354: 83 ec 10 sub $0x10,%esp
struct redircmd *cmd;
cmd = malloc(sizeof(*cmd));
357: 6a 18 push $0x18
359: e8 12 0d 00 00 call 1070 <malloc>
memset(cmd, 0, sizeof(*cmd));
35e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
361: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
363: 6a 18 push $0x18
365: 6a 00 push $0x0
367: 50 push %eax
368: e8 e3 07 00 00 call b50 <memset>
cmd->type = REDIR;
cmd->cmd = subcmd;
36d: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = REDIR;
370: c7 03 02 00 00 00 movl $0x2,(%ebx)
cmd->cmd = subcmd;
376: 89 43 04 mov %eax,0x4(%ebx)
cmd->file = file;
379: 8b 45 0c mov 0xc(%ebp),%eax
37c: 89 43 08 mov %eax,0x8(%ebx)
cmd->efile = efile;
37f: 8b 45 10 mov 0x10(%ebp),%eax
382: 89 43 0c mov %eax,0xc(%ebx)
cmd->mode = mode;
385: 8b 45 14 mov 0x14(%ebp),%eax
388: 89 43 10 mov %eax,0x10(%ebx)
cmd->fd = fd;
38b: 8b 45 18 mov 0x18(%ebp),%eax
38e: 89 43 14 mov %eax,0x14(%ebx)
return (struct cmd*)cmd;
}
391: 89 d8 mov %ebx,%eax
393: 8b 5d fc mov -0x4(%ebp),%ebx
396: c9 leave
397: c3 ret
398: 90 nop
399: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000003a0 <pipecmd>:
struct cmd*
pipecmd(struct cmd *left, struct cmd *right)
{
3a0: 55 push %ebp
3a1: 89 e5 mov %esp,%ebp
3a3: 53 push %ebx
3a4: 83 ec 10 sub $0x10,%esp
struct pipecmd *cmd;
cmd = malloc(sizeof(*cmd));
3a7: 6a 0c push $0xc
3a9: e8 c2 0c 00 00 call 1070 <malloc>
memset(cmd, 0, sizeof(*cmd));
3ae: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
3b1: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
3b3: 6a 0c push $0xc
3b5: 6a 00 push $0x0
3b7: 50 push %eax
3b8: e8 93 07 00 00 call b50 <memset>
cmd->type = PIPE;
cmd->left = left;
3bd: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = PIPE;
3c0: c7 03 03 00 00 00 movl $0x3,(%ebx)
cmd->left = left;
3c6: 89 43 04 mov %eax,0x4(%ebx)
cmd->right = right;
3c9: 8b 45 0c mov 0xc(%ebp),%eax
3cc: 89 43 08 mov %eax,0x8(%ebx)
return (struct cmd*)cmd;
}
3cf: 89 d8 mov %ebx,%eax
3d1: 8b 5d fc mov -0x4(%ebp),%ebx
3d4: c9 leave
3d5: c3 ret
3d6: 8d 76 00 lea 0x0(%esi),%esi
3d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000003e0 <listcmd>:
struct cmd*
listcmd(struct cmd *left, struct cmd *right)
{
3e0: 55 push %ebp
3e1: 89 e5 mov %esp,%ebp
3e3: 53 push %ebx
3e4: 83 ec 10 sub $0x10,%esp
struct listcmd *cmd;
cmd = malloc(sizeof(*cmd));
3e7: 6a 0c push $0xc
3e9: e8 82 0c 00 00 call 1070 <malloc>
memset(cmd, 0, sizeof(*cmd));
3ee: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
3f1: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
3f3: 6a 0c push $0xc
3f5: 6a 00 push $0x0
3f7: 50 push %eax
3f8: e8 53 07 00 00 call b50 <memset>
cmd->type = LIST;
cmd->left = left;
3fd: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = LIST;
400: c7 03 04 00 00 00 movl $0x4,(%ebx)
cmd->left = left;
406: 89 43 04 mov %eax,0x4(%ebx)
cmd->right = right;
409: 8b 45 0c mov 0xc(%ebp),%eax
40c: 89 43 08 mov %eax,0x8(%ebx)
return (struct cmd*)cmd;
}
40f: 89 d8 mov %ebx,%eax
411: 8b 5d fc mov -0x4(%ebp),%ebx
414: c9 leave
415: c3 ret
416: 8d 76 00 lea 0x0(%esi),%esi
419: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000420 <backcmd>:
struct cmd*
backcmd(struct cmd *subcmd)
{
420: 55 push %ebp
421: 89 e5 mov %esp,%ebp
423: 53 push %ebx
424: 83 ec 10 sub $0x10,%esp
struct backcmd *cmd;
cmd = malloc(sizeof(*cmd));
427: 6a 08 push $0x8
429: e8 42 0c 00 00 call 1070 <malloc>
memset(cmd, 0, sizeof(*cmd));
42e: 83 c4 0c add $0xc,%esp
cmd = malloc(sizeof(*cmd));
431: 89 c3 mov %eax,%ebx
memset(cmd, 0, sizeof(*cmd));
433: 6a 08 push $0x8
435: 6a 00 push $0x0
437: 50 push %eax
438: e8 13 07 00 00 call b50 <memset>
cmd->type = BACK;
cmd->cmd = subcmd;
43d: 8b 45 08 mov 0x8(%ebp),%eax
cmd->type = BACK;
440: c7 03 05 00 00 00 movl $0x5,(%ebx)
cmd->cmd = subcmd;
446: 89 43 04 mov %eax,0x4(%ebx)
return (struct cmd*)cmd;
}
449: 89 d8 mov %ebx,%eax
44b: 8b 5d fc mov -0x4(%ebp),%ebx
44e: c9 leave
44f: c3 ret
00000450 <gettoken>:
char whitespace[] = " \t\r\n\v";
char symbols[] = "<|>&;()";
int
gettoken(char **ps, char *es, char **q, char **eq)
{
450: 55 push %ebp
451: 89 e5 mov %esp,%ebp
453: 57 push %edi
454: 56 push %esi
455: 53 push %ebx
456: 83 ec 0c sub $0xc,%esp
char *s;
int ret;
s = *ps;
459: 8b 45 08 mov 0x8(%ebp),%eax
{
45c: 8b 5d 0c mov 0xc(%ebp),%ebx
45f: 8b 7d 10 mov 0x10(%ebp),%edi
s = *ps;
462: 8b 30 mov (%eax),%esi
while(s < es && strchr(whitespace, *s))
464: 39 de cmp %ebx,%esi
466: 72 0f jb 477 <gettoken+0x27>
468: eb 25 jmp 48f <gettoken+0x3f>
46a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
s++;
470: 83 c6 01 add $0x1,%esi
while(s < es && strchr(whitespace, *s))
473: 39 f3 cmp %esi,%ebx
475: 74 18 je 48f <gettoken+0x3f>
477: 0f be 06 movsbl (%esi),%eax
47a: 83 ec 08 sub $0x8,%esp
47d: 50 push %eax
47e: 68 f8 17 00 00 push $0x17f8
483: e8 e8 06 00 00 call b70 <strchr>
488: 83 c4 10 add $0x10,%esp
48b: 85 c0 test %eax,%eax
48d: 75 e1 jne 470 <gettoken+0x20>
if(q)
48f: 85 ff test %edi,%edi
491: 74 02 je 495 <gettoken+0x45>
*q = s;
493: 89 37 mov %esi,(%edi)
ret = *s;
495: 0f be 06 movsbl (%esi),%eax
switch(*s){
498: 3c 29 cmp $0x29,%al
49a: 7f 54 jg 4f0 <gettoken+0xa0>
49c: 3c 28 cmp $0x28,%al
49e: 0f 8d c8 00 00 00 jge 56c <gettoken+0x11c>
4a4: 31 ff xor %edi,%edi
4a6: 84 c0 test %al,%al
4a8: 0f 85 e2 00 00 00 jne 590 <gettoken+0x140>
ret = 'a';
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
s++;
break;
}
if(eq)
4ae: 8b 55 14 mov 0x14(%ebp),%edx
4b1: 85 d2 test %edx,%edx
4b3: 74 05 je 4ba <gettoken+0x6a>
*eq = s;
4b5: 8b 45 14 mov 0x14(%ebp),%eax
4b8: 89 30 mov %esi,(%eax)
while(s < es && strchr(whitespace, *s))
4ba: 39 f3 cmp %esi,%ebx
4bc: 77 09 ja 4c7 <gettoken+0x77>
4be: eb 1f jmp 4df <gettoken+0x8f>
s++;
4c0: 83 c6 01 add $0x1,%esi
while(s < es && strchr(whitespace, *s))
4c3: 39 f3 cmp %esi,%ebx
4c5: 74 18 je 4df <gettoken+0x8f>
4c7: 0f be 06 movsbl (%esi),%eax
4ca: 83 ec 08 sub $0x8,%esp
4cd: 50 push %eax
4ce: 68 f8 17 00 00 push $0x17f8
4d3: e8 98 06 00 00 call b70 <strchr>
4d8: 83 c4 10 add $0x10,%esp
4db: 85 c0 test %eax,%eax
4dd: 75 e1 jne 4c0 <gettoken+0x70>
*ps = s;
4df: 8b 45 08 mov 0x8(%ebp),%eax
4e2: 89 30 mov %esi,(%eax)
return ret;
}
4e4: 8d 65 f4 lea -0xc(%ebp),%esp
4e7: 89 f8 mov %edi,%eax
4e9: 5b pop %ebx
4ea: 5e pop %esi
4eb: 5f pop %edi
4ec: 5d pop %ebp
4ed: c3 ret
4ee: 66 90 xchg %ax,%ax
switch(*s){
4f0: 3c 3e cmp $0x3e,%al
4f2: 75 1c jne 510 <gettoken+0xc0>
if(*s == '>'){
4f4: 80 7e 01 3e cmpb $0x3e,0x1(%esi)
4f8: 0f 84 82 00 00 00 je 580 <gettoken+0x130>
s++;
4fe: 83 c6 01 add $0x1,%esi
501: bf 3e 00 00 00 mov $0x3e,%edi
506: eb a6 jmp 4ae <gettoken+0x5e>
508: 90 nop
509: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
switch(*s){
510: 7f 56 jg 568 <gettoken+0x118>
512: 8d 48 c5 lea -0x3b(%eax),%ecx
515: 80 f9 01 cmp $0x1,%cl
518: 76 52 jbe 56c <gettoken+0x11c>
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
51a: 39 f3 cmp %esi,%ebx
51c: 77 24 ja 542 <gettoken+0xf2>
51e: eb 7a jmp 59a <gettoken+0x14a>
520: 0f be 06 movsbl (%esi),%eax
523: 83 ec 08 sub $0x8,%esp
526: 50 push %eax
527: 68 f0 17 00 00 push $0x17f0
52c: e8 3f 06 00 00 call b70 <strchr>
531: 83 c4 10 add $0x10,%esp
534: 85 c0 test %eax,%eax
536: 75 1f jne 557 <gettoken+0x107>
s++;
538: 83 c6 01 add $0x1,%esi
while(s < es && !strchr(whitespace, *s) && !strchr(symbols, *s))
53b: 39 f3 cmp %esi,%ebx
53d: 74 5b je 59a <gettoken+0x14a>
53f: 0f be 06 movsbl (%esi),%eax
542: 83 ec 08 sub $0x8,%esp
545: 50 push %eax
546: 68 f8 17 00 00 push $0x17f8
54b: e8 20 06 00 00 call b70 <strchr>
550: 83 c4 10 add $0x10,%esp
553: 85 c0 test %eax,%eax
555: 74 c9 je 520 <gettoken+0xd0>
ret = 'a';
557: bf 61 00 00 00 mov $0x61,%edi
55c: e9 4d ff ff ff jmp 4ae <gettoken+0x5e>
561: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
switch(*s){
568: 3c 7c cmp $0x7c,%al
56a: 75 ae jne 51a <gettoken+0xca>
ret = *s;
56c: 0f be f8 movsbl %al,%edi
s++;
56f: 83 c6 01 add $0x1,%esi
break;
572: e9 37 ff ff ff jmp 4ae <gettoken+0x5e>
577: 89 f6 mov %esi,%esi
579: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
s++;
580: 83 c6 02 add $0x2,%esi
ret = '+';
583: bf 2b 00 00 00 mov $0x2b,%edi
588: e9 21 ff ff ff jmp 4ae <gettoken+0x5e>
58d: 8d 76 00 lea 0x0(%esi),%esi
switch(*s){
590: 3c 26 cmp $0x26,%al
592: 0f 85 82 ff ff ff jne 51a <gettoken+0xca>
598: eb d2 jmp 56c <gettoken+0x11c>
if(eq)
59a: 8b 45 14 mov 0x14(%ebp),%eax
59d: bf 61 00 00 00 mov $0x61,%edi
5a2: 85 c0 test %eax,%eax
5a4: 0f 85 0b ff ff ff jne 4b5 <gettoken+0x65>
5aa: e9 30 ff ff ff jmp 4df <gettoken+0x8f>
5af: 90 nop
000005b0 <peek>:
int
peek(char **ps, char *es, char *toks)
{
5b0: 55 push %ebp
5b1: 89 e5 mov %esp,%ebp
5b3: 57 push %edi
5b4: 56 push %esi
5b5: 53 push %ebx
5b6: 83 ec 0c sub $0xc,%esp
5b9: 8b 7d 08 mov 0x8(%ebp),%edi
5bc: 8b 75 0c mov 0xc(%ebp),%esi
char *s;
s = *ps;
5bf: 8b 1f mov (%edi),%ebx
while(s < es && strchr(whitespace, *s))
5c1: 39 f3 cmp %esi,%ebx
5c3: 72 12 jb 5d7 <peek+0x27>
5c5: eb 28 jmp 5ef <peek+0x3f>
5c7: 89 f6 mov %esi,%esi
5c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
s++;
5d0: 83 c3 01 add $0x1,%ebx
while(s < es && strchr(whitespace, *s))
5d3: 39 de cmp %ebx,%esi
5d5: 74 18 je 5ef <peek+0x3f>
5d7: 0f be 03 movsbl (%ebx),%eax
5da: 83 ec 08 sub $0x8,%esp
5dd: 50 push %eax
5de: 68 f8 17 00 00 push $0x17f8
5e3: e8 88 05 00 00 call b70 <strchr>
5e8: 83 c4 10 add $0x10,%esp
5eb: 85 c0 test %eax,%eax
5ed: 75 e1 jne 5d0 <peek+0x20>
*ps = s;
5ef: 89 1f mov %ebx,(%edi)
return *s && strchr(toks, *s);
5f1: 0f be 13 movsbl (%ebx),%edx
5f4: 31 c0 xor %eax,%eax
5f6: 84 d2 test %dl,%dl
5f8: 74 17 je 611 <peek+0x61>
5fa: 83 ec 08 sub $0x8,%esp
5fd: 52 push %edx
5fe: ff 75 10 pushl 0x10(%ebp)
601: e8 6a 05 00 00 call b70 <strchr>
606: 83 c4 10 add $0x10,%esp
609: 85 c0 test %eax,%eax
60b: 0f 95 c0 setne %al
60e: 0f b6 c0 movzbl %al,%eax
}
611: 8d 65 f4 lea -0xc(%ebp),%esp
614: 5b pop %ebx
615: 5e pop %esi
616: 5f pop %edi
617: 5d pop %ebp
618: c3 ret
619: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000620 <parseredirs>:
return cmd;
}
struct cmd*
parseredirs(struct cmd *cmd, char **ps, char *es)
{
620: 55 push %ebp
621: 89 e5 mov %esp,%ebp
623: 57 push %edi
624: 56 push %esi
625: 53 push %ebx
626: 83 ec 1c sub $0x1c,%esp
629: 8b 75 0c mov 0xc(%ebp),%esi
62c: 8b 5d 10 mov 0x10(%ebp),%ebx
62f: 90 nop
int tok;
char *q, *eq;
while(peek(ps, es, "<>")){
630: 83 ec 04 sub $0x4,%esp
633: 68 a1 11 00 00 push $0x11a1
638: 53 push %ebx
639: 56 push %esi
63a: e8 71 ff ff ff call 5b0 <peek>
63f: 83 c4 10 add $0x10,%esp
642: 85 c0 test %eax,%eax
644: 74 6a je 6b0 <parseredirs+0x90>
tok = gettoken(ps, es, 0, 0);
646: 6a 00 push $0x0
648: 6a 00 push $0x0
64a: 53 push %ebx
64b: 56 push %esi
64c: e8 ff fd ff ff call 450 <gettoken>
651: 89 c7 mov %eax,%edi
if(gettoken(ps, es, &q, &eq) != 'a')
653: 8d 45 e4 lea -0x1c(%ebp),%eax
656: 50 push %eax
657: 8d 45 e0 lea -0x20(%ebp),%eax
65a: 50 push %eax
65b: 53 push %ebx
65c: 56 push %esi
65d: e8 ee fd ff ff call 450 <gettoken>
662: 83 c4 20 add $0x20,%esp
665: 83 f8 61 cmp $0x61,%eax
668: 75 51 jne 6bb <parseredirs+0x9b>
panic("missing file for redirection");
switch(tok){
66a: 83 ff 3c cmp $0x3c,%edi
66d: 74 31 je 6a0 <parseredirs+0x80>
66f: 83 ff 3e cmp $0x3e,%edi
672: 74 05 je 679 <parseredirs+0x59>
674: 83 ff 2b cmp $0x2b,%edi
677: 75 b7 jne 630 <parseredirs+0x10>
break;
case '>':
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
break;
case '+': // >>
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
679: 83 ec 0c sub $0xc,%esp
67c: 6a 01 push $0x1
67e: 68 01 02 00 00 push $0x201
683: ff 75 e4 pushl -0x1c(%ebp)
686: ff 75 e0 pushl -0x20(%ebp)
689: ff 75 08 pushl 0x8(%ebp)
68c: e8 bf fc ff ff call 350 <redircmd>
break;
691: 83 c4 20 add $0x20,%esp
cmd = redircmd(cmd, q, eq, O_WRONLY|O_CREATE, 1);
694: 89 45 08 mov %eax,0x8(%ebp)
break;
697: eb 97 jmp 630 <parseredirs+0x10>
699: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
cmd = redircmd(cmd, q, eq, O_RDONLY, 0);
6a0: 83 ec 0c sub $0xc,%esp
6a3: 6a 00 push $0x0
6a5: 6a 00 push $0x0
6a7: eb da jmp 683 <parseredirs+0x63>
6a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
}
return cmd;
}
6b0: 8b 45 08 mov 0x8(%ebp),%eax
6b3: 8d 65 f4 lea -0xc(%ebp),%esp
6b6: 5b pop %ebx
6b7: 5e pop %esi
6b8: 5f pop %edi
6b9: 5d pop %ebp
6ba: c3 ret
panic("missing file for redirection");
6bb: 83 ec 0c sub $0xc,%esp
6be: 68 84 11 00 00 push $0x1184
6c3: e8 88 fa ff ff call 150 <panic>
6c8: 90 nop
6c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000006d0 <parseexec>:
return cmd;
}
struct cmd*
parseexec(char **ps, char *es)
{
6d0: 55 push %ebp
6d1: 89 e5 mov %esp,%ebp
6d3: 57 push %edi
6d4: 56 push %esi
6d5: 53 push %ebx
6d6: 83 ec 30 sub $0x30,%esp
6d9: 8b 75 08 mov 0x8(%ebp),%esi
6dc: 8b 7d 0c mov 0xc(%ebp),%edi
char *q, *eq;
int tok, argc;
struct execcmd *cmd;
struct cmd *ret;
if(peek(ps, es, "("))
6df: 68 a4 11 00 00 push $0x11a4
6e4: 57 push %edi
6e5: 56 push %esi
6e6: e8 c5 fe ff ff call 5b0 <peek>
6eb: 83 c4 10 add $0x10,%esp
6ee: 85 c0 test %eax,%eax
6f0: 0f 85 92 00 00 00 jne 788 <parseexec+0xb8>
6f6: 89 c3 mov %eax,%ebx
return parseblock(ps, es);
ret = execcmd();
6f8: e8 23 fc ff ff call 320 <execcmd>
cmd = (struct execcmd*)ret;
argc = 0;
ret = parseredirs(ret, ps, es);
6fd: 83 ec 04 sub $0x4,%esp
ret = execcmd();
700: 89 45 d0 mov %eax,-0x30(%ebp)
ret = parseredirs(ret, ps, es);
703: 57 push %edi
704: 56 push %esi
705: 50 push %eax
706: e8 15 ff ff ff call 620 <parseredirs>
70b: 83 c4 10 add $0x10,%esp
70e: 89 45 d4 mov %eax,-0x2c(%ebp)
711: eb 18 jmp 72b <parseexec+0x5b>
713: 90 nop
714: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cmd->argv[argc] = q;
cmd->eargv[argc] = eq;
argc++;
if(argc >= MAXARGS)
panic("too many args");
ret = parseredirs(ret, ps, es);
718: 83 ec 04 sub $0x4,%esp
71b: 57 push %edi
71c: 56 push %esi
71d: ff 75 d4 pushl -0x2c(%ebp)
720: e8 fb fe ff ff call 620 <parseredirs>
725: 83 c4 10 add $0x10,%esp
728: 89 45 d4 mov %eax,-0x2c(%ebp)
while(!peek(ps, es, "|)&;")){
72b: 83 ec 04 sub $0x4,%esp
72e: 68 bb 11 00 00 push $0x11bb
733: 57 push %edi
734: 56 push %esi
735: e8 76 fe ff ff call 5b0 <peek>
73a: 83 c4 10 add $0x10,%esp
73d: 85 c0 test %eax,%eax
73f: 75 67 jne 7a8 <parseexec+0xd8>
if((tok=gettoken(ps, es, &q, &eq)) == 0)
741: 8d 45 e4 lea -0x1c(%ebp),%eax
744: 50 push %eax
745: 8d 45 e0 lea -0x20(%ebp),%eax
748: 50 push %eax
749: 57 push %edi
74a: 56 push %esi
74b: e8 00 fd ff ff call 450 <gettoken>
750: 83 c4 10 add $0x10,%esp
753: 85 c0 test %eax,%eax
755: 74 51 je 7a8 <parseexec+0xd8>
if(tok != 'a')
757: 83 f8 61 cmp $0x61,%eax
75a: 75 6b jne 7c7 <parseexec+0xf7>
cmd->argv[argc] = q;
75c: 8b 45 e0 mov -0x20(%ebp),%eax
75f: 8b 55 d0 mov -0x30(%ebp),%edx
762: 89 44 9a 04 mov %eax,0x4(%edx,%ebx,4)
cmd->eargv[argc] = eq;
766: 8b 45 e4 mov -0x1c(%ebp),%eax
769: 89 44 9a 2c mov %eax,0x2c(%edx,%ebx,4)
argc++;
76d: 83 c3 01 add $0x1,%ebx
if(argc >= MAXARGS)
770: 83 fb 0a cmp $0xa,%ebx
773: 75 a3 jne 718 <parseexec+0x48>
panic("too many args");
775: 83 ec 0c sub $0xc,%esp
778: 68 ad 11 00 00 push $0x11ad
77d: e8 ce f9 ff ff call 150 <panic>
782: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return parseblock(ps, es);
788: 83 ec 08 sub $0x8,%esp
78b: 57 push %edi
78c: 56 push %esi
78d: e8 5e 01 00 00 call 8f0 <parseblock>
792: 83 c4 10 add $0x10,%esp
795: 89 45 d4 mov %eax,-0x2c(%ebp)
}
cmd->argv[argc] = 0;
cmd->eargv[argc] = 0;
return ret;
}
798: 8b 45 d4 mov -0x2c(%ebp),%eax
79b: 8d 65 f4 lea -0xc(%ebp),%esp
79e: 5b pop %ebx
79f: 5e pop %esi
7a0: 5f pop %edi
7a1: 5d pop %ebp
7a2: c3 ret
7a3: 90 nop
7a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
7a8: 8b 45 d0 mov -0x30(%ebp),%eax
7ab: 8d 04 98 lea (%eax,%ebx,4),%eax
cmd->argv[argc] = 0;
7ae: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
cmd->eargv[argc] = 0;
7b5: c7 40 2c 00 00 00 00 movl $0x0,0x2c(%eax)
}
7bc: 8b 45 d4 mov -0x2c(%ebp),%eax
7bf: 8d 65 f4 lea -0xc(%ebp),%esp
7c2: 5b pop %ebx
7c3: 5e pop %esi
7c4: 5f pop %edi
7c5: 5d pop %ebp
7c6: c3 ret
panic("syntax");
7c7: 83 ec 0c sub $0xc,%esp
7ca: 68 a6 11 00 00 push $0x11a6
7cf: e8 7c f9 ff ff call 150 <panic>
7d4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
7da: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
000007e0 <parsepipe>:
{
7e0: 55 push %ebp
7e1: 89 e5 mov %esp,%ebp
7e3: 57 push %edi
7e4: 56 push %esi
7e5: 53 push %ebx
7e6: 83 ec 14 sub $0x14,%esp
7e9: 8b 5d 08 mov 0x8(%ebp),%ebx
7ec: 8b 75 0c mov 0xc(%ebp),%esi
cmd = parseexec(ps, es);
7ef: 56 push %esi
7f0: 53 push %ebx
7f1: e8 da fe ff ff call 6d0 <parseexec>
if(peek(ps, es, "|")){
7f6: 83 c4 0c add $0xc,%esp
cmd = parseexec(ps, es);
7f9: 89 c7 mov %eax,%edi
if(peek(ps, es, "|")){
7fb: 68 c0 11 00 00 push $0x11c0
800: 56 push %esi
801: 53 push %ebx
802: e8 a9 fd ff ff call 5b0 <peek>
807: 83 c4 10 add $0x10,%esp
80a: 85 c0 test %eax,%eax
80c: 75 12 jne 820 <parsepipe+0x40>
}
80e: 8d 65 f4 lea -0xc(%ebp),%esp
811: 89 f8 mov %edi,%eax
813: 5b pop %ebx
814: 5e pop %esi
815: 5f pop %edi
816: 5d pop %ebp
817: c3 ret
818: 90 nop
819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
gettoken(ps, es, 0, 0);
820: 6a 00 push $0x0
822: 6a 00 push $0x0
824: 56 push %esi
825: 53 push %ebx
826: e8 25 fc ff ff call 450 <gettoken>
cmd = pipecmd(cmd, parsepipe(ps, es));
82b: 58 pop %eax
82c: 5a pop %edx
82d: 56 push %esi
82e: 53 push %ebx
82f: e8 ac ff ff ff call 7e0 <parsepipe>
834: 89 7d 08 mov %edi,0x8(%ebp)
837: 89 45 0c mov %eax,0xc(%ebp)
83a: 83 c4 10 add $0x10,%esp
}
83d: 8d 65 f4 lea -0xc(%ebp),%esp
840: 5b pop %ebx
841: 5e pop %esi
842: 5f pop %edi
843: 5d pop %ebp
cmd = pipecmd(cmd, parsepipe(ps, es));
844: e9 57 fb ff ff jmp 3a0 <pipecmd>
849: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000850 <parseline>:
{
850: 55 push %ebp
851: 89 e5 mov %esp,%ebp
853: 57 push %edi
854: 56 push %esi
855: 53 push %ebx
856: 83 ec 14 sub $0x14,%esp
859: 8b 5d 08 mov 0x8(%ebp),%ebx
85c: 8b 75 0c mov 0xc(%ebp),%esi
cmd = parsepipe(ps, es);
85f: 56 push %esi
860: 53 push %ebx
861: e8 7a ff ff ff call 7e0 <parsepipe>
while(peek(ps, es, "&")){
866: 83 c4 10 add $0x10,%esp
cmd = parsepipe(ps, es);
869: 89 c7 mov %eax,%edi
while(peek(ps, es, "&")){
86b: eb 1b jmp 888 <parseline+0x38>
86d: 8d 76 00 lea 0x0(%esi),%esi
gettoken(ps, es, 0, 0);
870: 6a 00 push $0x0
872: 6a 00 push $0x0
874: 56 push %esi
875: 53 push %ebx
876: e8 d5 fb ff ff call 450 <gettoken>
cmd = backcmd(cmd);
87b: 89 3c 24 mov %edi,(%esp)
87e: e8 9d fb ff ff call 420 <backcmd>
883: 83 c4 10 add $0x10,%esp
886: 89 c7 mov %eax,%edi
while(peek(ps, es, "&")){
888: 83 ec 04 sub $0x4,%esp
88b: 68 c2 11 00 00 push $0x11c2
890: 56 push %esi
891: 53 push %ebx
892: e8 19 fd ff ff call 5b0 <peek>
897: 83 c4 10 add $0x10,%esp
89a: 85 c0 test %eax,%eax
89c: 75 d2 jne 870 <parseline+0x20>
if(peek(ps, es, ";")){
89e: 83 ec 04 sub $0x4,%esp
8a1: 68 be 11 00 00 push $0x11be
8a6: 56 push %esi
8a7: 53 push %ebx
8a8: e8 03 fd ff ff call 5b0 <peek>
8ad: 83 c4 10 add $0x10,%esp
8b0: 85 c0 test %eax,%eax
8b2: 75 0c jne 8c0 <parseline+0x70>
}
8b4: 8d 65 f4 lea -0xc(%ebp),%esp
8b7: 89 f8 mov %edi,%eax
8b9: 5b pop %ebx
8ba: 5e pop %esi
8bb: 5f pop %edi
8bc: 5d pop %ebp
8bd: c3 ret
8be: 66 90 xchg %ax,%ax
gettoken(ps, es, 0, 0);
8c0: 6a 00 push $0x0
8c2: 6a 00 push $0x0
8c4: 56 push %esi
8c5: 53 push %ebx
8c6: e8 85 fb ff ff call 450 <gettoken>
cmd = listcmd(cmd, parseline(ps, es));
8cb: 58 pop %eax
8cc: 5a pop %edx
8cd: 56 push %esi
8ce: 53 push %ebx
8cf: e8 7c ff ff ff call 850 <parseline>
8d4: 89 7d 08 mov %edi,0x8(%ebp)
8d7: 89 45 0c mov %eax,0xc(%ebp)
8da: 83 c4 10 add $0x10,%esp
}
8dd: 8d 65 f4 lea -0xc(%ebp),%esp
8e0: 5b pop %ebx
8e1: 5e pop %esi
8e2: 5f pop %edi
8e3: 5d pop %ebp
cmd = listcmd(cmd, parseline(ps, es));
8e4: e9 f7 fa ff ff jmp 3e0 <listcmd>
8e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000008f0 <parseblock>:
{
8f0: 55 push %ebp
8f1: 89 e5 mov %esp,%ebp
8f3: 57 push %edi
8f4: 56 push %esi
8f5: 53 push %ebx
8f6: 83 ec 10 sub $0x10,%esp
8f9: 8b 5d 08 mov 0x8(%ebp),%ebx
8fc: 8b 75 0c mov 0xc(%ebp),%esi
if(!peek(ps, es, "("))
8ff: 68 a4 11 00 00 push $0x11a4
904: 56 push %esi
905: 53 push %ebx
906: e8 a5 fc ff ff call 5b0 <peek>
90b: 83 c4 10 add $0x10,%esp
90e: 85 c0 test %eax,%eax
910: 74 4a je 95c <parseblock+0x6c>
gettoken(ps, es, 0, 0);
912: 6a 00 push $0x0
914: 6a 00 push $0x0
916: 56 push %esi
917: 53 push %ebx
918: e8 33 fb ff ff call 450 <gettoken>
cmd = parseline(ps, es);
91d: 58 pop %eax
91e: 5a pop %edx
91f: 56 push %esi
920: 53 push %ebx
921: e8 2a ff ff ff call 850 <parseline>
if(!peek(ps, es, ")"))
926: 83 c4 0c add $0xc,%esp
cmd = parseline(ps, es);
929: 89 c7 mov %eax,%edi
if(!peek(ps, es, ")"))
92b: 68 e0 11 00 00 push $0x11e0
930: 56 push %esi
931: 53 push %ebx
932: e8 79 fc ff ff call 5b0 <peek>
937: 83 c4 10 add $0x10,%esp
93a: 85 c0 test %eax,%eax
93c: 74 2b je 969 <parseblock+0x79>
gettoken(ps, es, 0, 0);
93e: 6a 00 push $0x0
940: 6a 00 push $0x0
942: 56 push %esi
943: 53 push %ebx
944: e8 07 fb ff ff call 450 <gettoken>
cmd = parseredirs(cmd, ps, es);
949: 83 c4 0c add $0xc,%esp
94c: 56 push %esi
94d: 53 push %ebx
94e: 57 push %edi
94f: e8 cc fc ff ff call 620 <parseredirs>
}
954: 8d 65 f4 lea -0xc(%ebp),%esp
957: 5b pop %ebx
958: 5e pop %esi
959: 5f pop %edi
95a: 5d pop %ebp
95b: c3 ret
panic("parseblock");
95c: 83 ec 0c sub $0xc,%esp
95f: 68 c4 11 00 00 push $0x11c4
964: e8 e7 f7 ff ff call 150 <panic>
panic("syntax - missing )");
969: 83 ec 0c sub $0xc,%esp
96c: 68 cf 11 00 00 push $0x11cf
971: e8 da f7 ff ff call 150 <panic>
976: 8d 76 00 lea 0x0(%esi),%esi
979: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000980 <nulterminate>:
// NUL-terminate all the counted strings.
struct cmd*
nulterminate(struct cmd *cmd)
{
980: 55 push %ebp
981: 89 e5 mov %esp,%ebp
983: 53 push %ebx
984: 83 ec 04 sub $0x4,%esp
987: 8b 5d 08 mov 0x8(%ebp),%ebx
struct execcmd *ecmd;
struct listcmd *lcmd;
struct pipecmd *pcmd;
struct redircmd *rcmd;
if(cmd == 0)
98a: 85 db test %ebx,%ebx
98c: 74 20 je 9ae <nulterminate+0x2e>
return 0;
switch(cmd->type){
98e: 83 3b 05 cmpl $0x5,(%ebx)
991: 77 1b ja 9ae <nulterminate+0x2e>
993: 8b 03 mov (%ebx),%eax
995: ff 24 85 20 12 00 00 jmp *0x1220(,%eax,4)
99c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
nulterminate(lcmd->right);
break;
case BACK:
bcmd = (struct backcmd*)cmd;
nulterminate(bcmd->cmd);
9a0: 83 ec 0c sub $0xc,%esp
9a3: ff 73 04 pushl 0x4(%ebx)
9a6: e8 d5 ff ff ff call 980 <nulterminate>
break;
9ab: 83 c4 10 add $0x10,%esp
}
return cmd;
}
9ae: 89 d8 mov %ebx,%eax
9b0: 8b 5d fc mov -0x4(%ebp),%ebx
9b3: c9 leave
9b4: c3 ret
9b5: 8d 76 00 lea 0x0(%esi),%esi
nulterminate(lcmd->left);
9b8: 83 ec 0c sub $0xc,%esp
9bb: ff 73 04 pushl 0x4(%ebx)
9be: e8 bd ff ff ff call 980 <nulterminate>
nulterminate(lcmd->right);
9c3: 58 pop %eax
9c4: ff 73 08 pushl 0x8(%ebx)
9c7: e8 b4 ff ff ff call 980 <nulterminate>
}
9cc: 89 d8 mov %ebx,%eax
break;
9ce: 83 c4 10 add $0x10,%esp
}
9d1: 8b 5d fc mov -0x4(%ebp),%ebx
9d4: c9 leave
9d5: c3 ret
9d6: 8d 76 00 lea 0x0(%esi),%esi
9d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
for(i=0; ecmd->argv[i]; i++)
9e0: 8b 4b 04 mov 0x4(%ebx),%ecx
9e3: 8d 43 08 lea 0x8(%ebx),%eax
9e6: 85 c9 test %ecx,%ecx
9e8: 74 c4 je 9ae <nulterminate+0x2e>
9ea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
*ecmd->eargv[i] = 0;
9f0: 8b 50 24 mov 0x24(%eax),%edx
9f3: 83 c0 04 add $0x4,%eax
9f6: c6 02 00 movb $0x0,(%edx)
for(i=0; ecmd->argv[i]; i++)
9f9: 8b 50 fc mov -0x4(%eax),%edx
9fc: 85 d2 test %edx,%edx
9fe: 75 f0 jne 9f0 <nulterminate+0x70>
}
a00: 89 d8 mov %ebx,%eax
a02: 8b 5d fc mov -0x4(%ebp),%ebx
a05: c9 leave
a06: c3 ret
a07: 89 f6 mov %esi,%esi
a09: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
nulterminate(rcmd->cmd);
a10: 83 ec 0c sub $0xc,%esp
a13: ff 73 04 pushl 0x4(%ebx)
a16: e8 65 ff ff ff call 980 <nulterminate>
*rcmd->efile = 0;
a1b: 8b 43 0c mov 0xc(%ebx),%eax
break;
a1e: 83 c4 10 add $0x10,%esp
*rcmd->efile = 0;
a21: c6 00 00 movb $0x0,(%eax)
}
a24: 89 d8 mov %ebx,%eax
a26: 8b 5d fc mov -0x4(%ebp),%ebx
a29: c9 leave
a2a: c3 ret
a2b: 90 nop
a2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000a30 <parsecmd>:
{
a30: 55 push %ebp
a31: 89 e5 mov %esp,%ebp
a33: 56 push %esi
a34: 53 push %ebx
es = s + strlen(s);
a35: 8b 5d 08 mov 0x8(%ebp),%ebx
a38: 83 ec 0c sub $0xc,%esp
a3b: 53 push %ebx
a3c: e8 df 00 00 00 call b20 <strlen>
cmd = parseline(&s, es);
a41: 59 pop %ecx
es = s + strlen(s);
a42: 01 c3 add %eax,%ebx
cmd = parseline(&s, es);
a44: 8d 45 08 lea 0x8(%ebp),%eax
a47: 5e pop %esi
a48: 53 push %ebx
a49: 50 push %eax
a4a: e8 01 fe ff ff call 850 <parseline>
a4f: 89 c6 mov %eax,%esi
peek(&s, es, "");
a51: 8d 45 08 lea 0x8(%ebp),%eax
a54: 83 c4 0c add $0xc,%esp
a57: 68 6e 11 00 00 push $0x116e
a5c: 53 push %ebx
a5d: 50 push %eax
a5e: e8 4d fb ff ff call 5b0 <peek>
if(s != es){
a63: 8b 45 08 mov 0x8(%ebp),%eax
a66: 83 c4 10 add $0x10,%esp
a69: 39 c3 cmp %eax,%ebx
a6b: 75 12 jne a7f <parsecmd+0x4f>
nulterminate(cmd);
a6d: 83 ec 0c sub $0xc,%esp
a70: 56 push %esi
a71: e8 0a ff ff ff call 980 <nulterminate>
}
a76: 8d 65 f8 lea -0x8(%ebp),%esp
a79: 89 f0 mov %esi,%eax
a7b: 5b pop %ebx
a7c: 5e pop %esi
a7d: 5d pop %ebp
a7e: c3 ret
printf(2, "leftovers: %s\n", s);
a7f: 52 push %edx
a80: 50 push %eax
a81: 68 e2 11 00 00 push $0x11e2
a86: 6a 02 push $0x2
a88: e8 a3 03 00 00 call e30 <printf>
panic("syntax");
a8d: c7 04 24 a6 11 00 00 movl $0x11a6,(%esp)
a94: e8 b7 f6 ff ff call 150 <panic>
a99: 66 90 xchg %ax,%ax
a9b: 66 90 xchg %ax,%ax
a9d: 66 90 xchg %ax,%ax
a9f: 90 nop
00000aa0 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, const char *t)
{
aa0: 55 push %ebp
aa1: 89 e5 mov %esp,%ebp
aa3: 53 push %ebx
aa4: 8b 45 08 mov 0x8(%ebp),%eax
aa7: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
aaa: 89 c2 mov %eax,%edx
aac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ab0: 83 c1 01 add $0x1,%ecx
ab3: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
ab7: 83 c2 01 add $0x1,%edx
aba: 84 db test %bl,%bl
abc: 88 5a ff mov %bl,-0x1(%edx)
abf: 75 ef jne ab0 <strcpy+0x10>
;
return os;
}
ac1: 5b pop %ebx
ac2: 5d pop %ebp
ac3: c3 ret
ac4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
aca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000ad0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
ad0: 55 push %ebp
ad1: 89 e5 mov %esp,%ebp
ad3: 56 push %esi
ad4: 53 push %ebx
ad5: 8b 55 08 mov 0x8(%ebp),%edx
ad8: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
adb: 0f b6 02 movzbl (%edx),%eax
ade: 0f b6 19 movzbl (%ecx),%ebx
ae1: 84 c0 test %al,%al
ae3: 75 1e jne b03 <strcmp+0x33>
ae5: eb 29 jmp b10 <strcmp+0x40>
ae7: 89 f6 mov %esi,%esi
ae9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
af0: 83 c2 01 add $0x1,%edx
while(*p && *p == *q)
af3: 0f b6 02 movzbl (%edx),%eax
p++, q++;
af6: 8d 71 01 lea 0x1(%ecx),%esi
while(*p && *p == *q)
af9: 0f b6 59 01 movzbl 0x1(%ecx),%ebx
afd: 84 c0 test %al,%al
aff: 74 0f je b10 <strcmp+0x40>
b01: 89 f1 mov %esi,%ecx
b03: 38 d8 cmp %bl,%al
b05: 74 e9 je af0 <strcmp+0x20>
return (uchar)*p - (uchar)*q;
b07: 29 d8 sub %ebx,%eax
}
b09: 5b pop %ebx
b0a: 5e pop %esi
b0b: 5d pop %ebp
b0c: c3 ret
b0d: 8d 76 00 lea 0x0(%esi),%esi
while(*p && *p == *q)
b10: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
b12: 29 d8 sub %ebx,%eax
}
b14: 5b pop %ebx
b15: 5e pop %esi
b16: 5d pop %ebp
b17: c3 ret
b18: 90 nop
b19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000b20 <strlen>:
uint
strlen(const char *s)
{
b20: 55 push %ebp
b21: 89 e5 mov %esp,%ebp
b23: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
b26: 80 39 00 cmpb $0x0,(%ecx)
b29: 74 12 je b3d <strlen+0x1d>
b2b: 31 d2 xor %edx,%edx
b2d: 8d 76 00 lea 0x0(%esi),%esi
b30: 83 c2 01 add $0x1,%edx
b33: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
b37: 89 d0 mov %edx,%eax
b39: 75 f5 jne b30 <strlen+0x10>
;
return n;
}
b3b: 5d pop %ebp
b3c: c3 ret
for(n = 0; s[n]; n++)
b3d: 31 c0 xor %eax,%eax
}
b3f: 5d pop %ebp
b40: c3 ret
b41: eb 0d jmp b50 <memset>
b43: 90 nop
b44: 90 nop
b45: 90 nop
b46: 90 nop
b47: 90 nop
b48: 90 nop
b49: 90 nop
b4a: 90 nop
b4b: 90 nop
b4c: 90 nop
b4d: 90 nop
b4e: 90 nop
b4f: 90 nop
00000b50 <memset>:
void*
memset(void *dst, int c, uint n)
{
b50: 55 push %ebp
b51: 89 e5 mov %esp,%ebp
b53: 57 push %edi
b54: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
b57: 8b 4d 10 mov 0x10(%ebp),%ecx
b5a: 8b 45 0c mov 0xc(%ebp),%eax
b5d: 89 d7 mov %edx,%edi
b5f: fc cld
b60: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
b62: 89 d0 mov %edx,%eax
b64: 5f pop %edi
b65: 5d pop %ebp
b66: c3 ret
b67: 89 f6 mov %esi,%esi
b69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000b70 <strchr>:
char*
strchr(const char *s, char c)
{
b70: 55 push %ebp
b71: 89 e5 mov %esp,%ebp
b73: 53 push %ebx
b74: 8b 45 08 mov 0x8(%ebp),%eax
b77: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
b7a: 0f b6 10 movzbl (%eax),%edx
b7d: 84 d2 test %dl,%dl
b7f: 74 1d je b9e <strchr+0x2e>
if(*s == c)
b81: 38 d3 cmp %dl,%bl
b83: 89 d9 mov %ebx,%ecx
b85: 75 0d jne b94 <strchr+0x24>
b87: eb 17 jmp ba0 <strchr+0x30>
b89: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
b90: 38 ca cmp %cl,%dl
b92: 74 0c je ba0 <strchr+0x30>
for(; *s; s++)
b94: 83 c0 01 add $0x1,%eax
b97: 0f b6 10 movzbl (%eax),%edx
b9a: 84 d2 test %dl,%dl
b9c: 75 f2 jne b90 <strchr+0x20>
return (char*)s;
return 0;
b9e: 31 c0 xor %eax,%eax
}
ba0: 5b pop %ebx
ba1: 5d pop %ebp
ba2: c3 ret
ba3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
ba9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000bb0 <gets>:
char*
gets(char *buf, int max)
{
bb0: 55 push %ebp
bb1: 89 e5 mov %esp,%ebp
bb3: 57 push %edi
bb4: 56 push %esi
bb5: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
bb6: 31 f6 xor %esi,%esi
cc = read(0, &c, 1);
bb8: 8d 7d e7 lea -0x19(%ebp),%edi
{
bbb: 83 ec 1c sub $0x1c,%esp
for(i=0; i+1 < max; ){
bbe: eb 29 jmp be9 <gets+0x39>
cc = read(0, &c, 1);
bc0: 83 ec 04 sub $0x4,%esp
bc3: 6a 01 push $0x1
bc5: 57 push %edi
bc6: 6a 00 push $0x0
bc8: e8 2d 01 00 00 call cfa <read>
if(cc < 1)
bcd: 83 c4 10 add $0x10,%esp
bd0: 85 c0 test %eax,%eax
bd2: 7e 1d jle bf1 <gets+0x41>
break;
buf[i++] = c;
bd4: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
bd8: 8b 55 08 mov 0x8(%ebp),%edx
bdb: 89 de mov %ebx,%esi
if(c == '\n' || c == '\r')
bdd: 3c 0a cmp $0xa,%al
buf[i++] = c;
bdf: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
be3: 74 1b je c00 <gets+0x50>
be5: 3c 0d cmp $0xd,%al
be7: 74 17 je c00 <gets+0x50>
for(i=0; i+1 < max; ){
be9: 8d 5e 01 lea 0x1(%esi),%ebx
bec: 3b 5d 0c cmp 0xc(%ebp),%ebx
bef: 7c cf jl bc0 <gets+0x10>
break;
}
buf[i] = '\0';
bf1: 8b 45 08 mov 0x8(%ebp),%eax
bf4: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
bf8: 8d 65 f4 lea -0xc(%ebp),%esp
bfb: 5b pop %ebx
bfc: 5e pop %esi
bfd: 5f pop %edi
bfe: 5d pop %ebp
bff: c3 ret
buf[i] = '\0';
c00: 8b 45 08 mov 0x8(%ebp),%eax
for(i=0; i+1 < max; ){
c03: 89 de mov %ebx,%esi
buf[i] = '\0';
c05: c6 04 30 00 movb $0x0,(%eax,%esi,1)
}
c09: 8d 65 f4 lea -0xc(%ebp),%esp
c0c: 5b pop %ebx
c0d: 5e pop %esi
c0e: 5f pop %edi
c0f: 5d pop %ebp
c10: c3 ret
c11: eb 0d jmp c20 <stat>
c13: 90 nop
c14: 90 nop
c15: 90 nop
c16: 90 nop
c17: 90 nop
c18: 90 nop
c19: 90 nop
c1a: 90 nop
c1b: 90 nop
c1c: 90 nop
c1d: 90 nop
c1e: 90 nop
c1f: 90 nop
00000c20 <stat>:
int
stat(const char *n, struct stat *st)
{
c20: 55 push %ebp
c21: 89 e5 mov %esp,%ebp
c23: 56 push %esi
c24: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
c25: 83 ec 08 sub $0x8,%esp
c28: 6a 00 push $0x0
c2a: ff 75 08 pushl 0x8(%ebp)
c2d: e8 f0 00 00 00 call d22 <open>
if(fd < 0)
c32: 83 c4 10 add $0x10,%esp
c35: 85 c0 test %eax,%eax
c37: 78 27 js c60 <stat+0x40>
return -1;
r = fstat(fd, st);
c39: 83 ec 08 sub $0x8,%esp
c3c: ff 75 0c pushl 0xc(%ebp)
c3f: 89 c3 mov %eax,%ebx
c41: 50 push %eax
c42: e8 f3 00 00 00 call d3a <fstat>
close(fd);
c47: 89 1c 24 mov %ebx,(%esp)
r = fstat(fd, st);
c4a: 89 c6 mov %eax,%esi
close(fd);
c4c: e8 b9 00 00 00 call d0a <close>
return r;
c51: 83 c4 10 add $0x10,%esp
}
c54: 8d 65 f8 lea -0x8(%ebp),%esp
c57: 89 f0 mov %esi,%eax
c59: 5b pop %ebx
c5a: 5e pop %esi
c5b: 5d pop %ebp
c5c: c3 ret
c5d: 8d 76 00 lea 0x0(%esi),%esi
return -1;
c60: be ff ff ff ff mov $0xffffffff,%esi
c65: eb ed jmp c54 <stat+0x34>
c67: 89 f6 mov %esi,%esi
c69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000c70 <atoi>:
int
atoi(const char *s)
{
c70: 55 push %ebp
c71: 89 e5 mov %esp,%ebp
c73: 53 push %ebx
c74: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
c77: 0f be 11 movsbl (%ecx),%edx
c7a: 8d 42 d0 lea -0x30(%edx),%eax
c7d: 3c 09 cmp $0x9,%al
c7f: b8 00 00 00 00 mov $0x0,%eax
c84: 77 1f ja ca5 <atoi+0x35>
c86: 8d 76 00 lea 0x0(%esi),%esi
c89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
c90: 8d 04 80 lea (%eax,%eax,4),%eax
c93: 83 c1 01 add $0x1,%ecx
c96: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
while('0' <= *s && *s <= '9')
c9a: 0f be 11 movsbl (%ecx),%edx
c9d: 8d 5a d0 lea -0x30(%edx),%ebx
ca0: 80 fb 09 cmp $0x9,%bl
ca3: 76 eb jbe c90 <atoi+0x20>
return n;
}
ca5: 5b pop %ebx
ca6: 5d pop %ebp
ca7: c3 ret
ca8: 90 nop
ca9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
00000cb0 <memmove>:
void*
memmove(void *vdst, const void *vsrc, int n)
{
cb0: 55 push %ebp
cb1: 89 e5 mov %esp,%ebp
cb3: 56 push %esi
cb4: 53 push %ebx
cb5: 8b 5d 10 mov 0x10(%ebp),%ebx
cb8: 8b 45 08 mov 0x8(%ebp),%eax
cbb: 8b 75 0c mov 0xc(%ebp),%esi
char *dst;
const char *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
cbe: 85 db test %ebx,%ebx
cc0: 7e 14 jle cd6 <memmove+0x26>
cc2: 31 d2 xor %edx,%edx
cc4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
cc8: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
ccc: 88 0c 10 mov %cl,(%eax,%edx,1)
ccf: 83 c2 01 add $0x1,%edx
while(n-- > 0)
cd2: 39 da cmp %ebx,%edx
cd4: 75 f2 jne cc8 <memmove+0x18>
return vdst;
}
cd6: 5b pop %ebx
cd7: 5e pop %esi
cd8: 5d pop %ebp
cd9: c3 ret
00000cda <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
cda: b8 01 00 00 00 mov $0x1,%eax
cdf: cd 40 int $0x40
ce1: c3 ret
00000ce2 <exit>:
SYSCALL(exit)
ce2: b8 02 00 00 00 mov $0x2,%eax
ce7: cd 40 int $0x40
ce9: c3 ret
00000cea <wait>:
SYSCALL(wait)
cea: b8 03 00 00 00 mov $0x3,%eax
cef: cd 40 int $0x40
cf1: c3 ret
00000cf2 <pipe>:
SYSCALL(pipe)
cf2: b8 04 00 00 00 mov $0x4,%eax
cf7: cd 40 int $0x40
cf9: c3 ret
00000cfa <read>:
SYSCALL(read)
cfa: b8 05 00 00 00 mov $0x5,%eax
cff: cd 40 int $0x40
d01: c3 ret
00000d02 <write>:
SYSCALL(write)
d02: b8 10 00 00 00 mov $0x10,%eax
d07: cd 40 int $0x40
d09: c3 ret
00000d0a <close>:
SYSCALL(close)
d0a: b8 15 00 00 00 mov $0x15,%eax
d0f: cd 40 int $0x40
d11: c3 ret
00000d12 <kill>:
SYSCALL(kill)
d12: b8 06 00 00 00 mov $0x6,%eax
d17: cd 40 int $0x40
d19: c3 ret
00000d1a <exec>:
SYSCALL(exec)
d1a: b8 07 00 00 00 mov $0x7,%eax
d1f: cd 40 int $0x40
d21: c3 ret
00000d22 <open>:
SYSCALL(open)
d22: b8 0f 00 00 00 mov $0xf,%eax
d27: cd 40 int $0x40
d29: c3 ret
00000d2a <mknod>:
SYSCALL(mknod)
d2a: b8 11 00 00 00 mov $0x11,%eax
d2f: cd 40 int $0x40
d31: c3 ret
00000d32 <unlink>:
SYSCALL(unlink)
d32: b8 12 00 00 00 mov $0x12,%eax
d37: cd 40 int $0x40
d39: c3 ret
00000d3a <fstat>:
SYSCALL(fstat)
d3a: b8 08 00 00 00 mov $0x8,%eax
d3f: cd 40 int $0x40
d41: c3 ret
00000d42 <link>:
SYSCALL(link)
d42: b8 13 00 00 00 mov $0x13,%eax
d47: cd 40 int $0x40
d49: c3 ret
00000d4a <mkdir>:
SYSCALL(mkdir)
d4a: b8 14 00 00 00 mov $0x14,%eax
d4f: cd 40 int $0x40
d51: c3 ret
00000d52 <chdir>:
SYSCALL(chdir)
d52: b8 09 00 00 00 mov $0x9,%eax
d57: cd 40 int $0x40
d59: c3 ret
00000d5a <dup>:
SYSCALL(dup)
d5a: b8 0a 00 00 00 mov $0xa,%eax
d5f: cd 40 int $0x40
d61: c3 ret
00000d62 <getpid>:
SYSCALL(getpid)
d62: b8 0b 00 00 00 mov $0xb,%eax
d67: cd 40 int $0x40
d69: c3 ret
00000d6a <sbrk>:
SYSCALL(sbrk)
d6a: b8 0c 00 00 00 mov $0xc,%eax
d6f: cd 40 int $0x40
d71: c3 ret
00000d72 <sleep>:
SYSCALL(sleep)
d72: b8 0d 00 00 00 mov $0xd,%eax
d77: cd 40 int $0x40
d79: c3 ret
00000d7a <uptime>:
SYSCALL(uptime)
d7a: b8 0e 00 00 00 mov $0xe,%eax
d7f: cd 40 int $0x40
d81: c3 ret
d82: 66 90 xchg %ax,%ax
d84: 66 90 xchg %ax,%ax
d86: 66 90 xchg %ax,%ax
d88: 66 90 xchg %ax,%ax
d8a: 66 90 xchg %ax,%ax
d8c: 66 90 xchg %ax,%ax
d8e: 66 90 xchg %ax,%ax
00000d90 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
d90: 55 push %ebp
d91: 89 e5 mov %esp,%ebp
d93: 57 push %edi
d94: 56 push %esi
d95: 53 push %ebx
d96: 89 c6 mov %eax,%esi
d98: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
d9b: 8b 5d 08 mov 0x8(%ebp),%ebx
d9e: 85 db test %ebx,%ebx
da0: 74 7e je e20 <printint+0x90>
da2: 89 d0 mov %edx,%eax
da4: c1 e8 1f shr $0x1f,%eax
da7: 84 c0 test %al,%al
da9: 74 75 je e20 <printint+0x90>
neg = 1;
x = -xx;
dab: 89 d0 mov %edx,%eax
neg = 1;
dad: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
x = -xx;
db4: f7 d8 neg %eax
db6: 89 75 c0 mov %esi,-0x40(%ebp)
} else {
x = xx;
}
i = 0;
db9: 31 ff xor %edi,%edi
dbb: 8d 5d d7 lea -0x29(%ebp),%ebx
dbe: 89 ce mov %ecx,%esi
dc0: eb 08 jmp dca <printint+0x3a>
dc2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
do{
buf[i++] = digits[x % base];
dc8: 89 cf mov %ecx,%edi
dca: 31 d2 xor %edx,%edx
dcc: 8d 4f 01 lea 0x1(%edi),%ecx
dcf: f7 f6 div %esi
dd1: 0f b6 92 40 12 00 00 movzbl 0x1240(%edx),%edx
}while((x /= base) != 0);
dd8: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
dda: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
ddd: 75 e9 jne dc8 <printint+0x38>
if(neg)
ddf: 8b 45 c4 mov -0x3c(%ebp),%eax
de2: 8b 75 c0 mov -0x40(%ebp),%esi
de5: 85 c0 test %eax,%eax
de7: 74 08 je df1 <printint+0x61>
buf[i++] = '-';
de9: c6 44 0d d8 2d movb $0x2d,-0x28(%ebp,%ecx,1)
dee: 8d 4f 02 lea 0x2(%edi),%ecx
while(--i >= 0)
df1: 8d 79 ff lea -0x1(%ecx),%edi
df4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
df8: 0f b6 44 3d d8 movzbl -0x28(%ebp,%edi,1),%eax
write(fd, &c, 1);
dfd: 83 ec 04 sub $0x4,%esp
while(--i >= 0)
e00: 83 ef 01 sub $0x1,%edi
write(fd, &c, 1);
e03: 6a 01 push $0x1
e05: 53 push %ebx
e06: 56 push %esi
e07: 88 45 d7 mov %al,-0x29(%ebp)
e0a: e8 f3 fe ff ff call d02 <write>
while(--i >= 0)
e0f: 83 c4 10 add $0x10,%esp
e12: 83 ff ff cmp $0xffffffff,%edi
e15: 75 e1 jne df8 <printint+0x68>
putc(fd, buf[i]);
}
e17: 8d 65 f4 lea -0xc(%ebp),%esp
e1a: 5b pop %ebx
e1b: 5e pop %esi
e1c: 5f pop %edi
e1d: 5d pop %ebp
e1e: c3 ret
e1f: 90 nop
x = xx;
e20: 89 d0 mov %edx,%eax
neg = 0;
e22: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
e29: eb 8b jmp db6 <printint+0x26>
e2b: 90 nop
e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000e30 <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, const char *fmt, ...)
{
e30: 55 push %ebp
e31: 89 e5 mov %esp,%ebp
e33: 57 push %edi
e34: 56 push %esi
e35: 53 push %ebx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
e36: 8d 45 10 lea 0x10(%ebp),%eax
{
e39: 83 ec 2c sub $0x2c,%esp
for(i = 0; fmt[i]; i++){
e3c: 8b 75 0c mov 0xc(%ebp),%esi
{
e3f: 8b 7d 08 mov 0x8(%ebp),%edi
for(i = 0; fmt[i]; i++){
e42: 89 45 d0 mov %eax,-0x30(%ebp)
e45: 0f b6 1e movzbl (%esi),%ebx
e48: 83 c6 01 add $0x1,%esi
e4b: 84 db test %bl,%bl
e4d: 0f 84 b0 00 00 00 je f03 <printf+0xd3>
e53: 31 d2 xor %edx,%edx
e55: eb 39 jmp e90 <printf+0x60>
e57: 89 f6 mov %esi,%esi
e59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
e60: 83 f8 25 cmp $0x25,%eax
e63: 89 55 d4 mov %edx,-0x2c(%ebp)
state = '%';
e66: ba 25 00 00 00 mov $0x25,%edx
if(c == '%'){
e6b: 74 18 je e85 <printf+0x55>
write(fd, &c, 1);
e6d: 8d 45 e2 lea -0x1e(%ebp),%eax
e70: 83 ec 04 sub $0x4,%esp
e73: 88 5d e2 mov %bl,-0x1e(%ebp)
e76: 6a 01 push $0x1
e78: 50 push %eax
e79: 57 push %edi
e7a: e8 83 fe ff ff call d02 <write>
e7f: 8b 55 d4 mov -0x2c(%ebp),%edx
e82: 83 c4 10 add $0x10,%esp
e85: 83 c6 01 add $0x1,%esi
for(i = 0; fmt[i]; i++){
e88: 0f b6 5e ff movzbl -0x1(%esi),%ebx
e8c: 84 db test %bl,%bl
e8e: 74 73 je f03 <printf+0xd3>
if(state == 0){
e90: 85 d2 test %edx,%edx
c = fmt[i] & 0xff;
e92: 0f be cb movsbl %bl,%ecx
e95: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
e98: 74 c6 je e60 <printf+0x30>
} else {
putc(fd, c);
}
} else if(state == '%'){
e9a: 83 fa 25 cmp $0x25,%edx
e9d: 75 e6 jne e85 <printf+0x55>
if(c == 'd'){
e9f: 83 f8 64 cmp $0x64,%eax
ea2: 0f 84 f8 00 00 00 je fa0 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
ea8: 81 e1 f7 00 00 00 and $0xf7,%ecx
eae: 83 f9 70 cmp $0x70,%ecx
eb1: 74 5d je f10 <printf+0xe0>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
eb3: 83 f8 73 cmp $0x73,%eax
eb6: 0f 84 84 00 00 00 je f40 <printf+0x110>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
ebc: 83 f8 63 cmp $0x63,%eax
ebf: 0f 84 ea 00 00 00 je faf <printf+0x17f>
putc(fd, *ap);
ap++;
} else if(c == '%'){
ec5: 83 f8 25 cmp $0x25,%eax
ec8: 0f 84 c2 00 00 00 je f90 <printf+0x160>
write(fd, &c, 1);
ece: 8d 45 e7 lea -0x19(%ebp),%eax
ed1: 83 ec 04 sub $0x4,%esp
ed4: c6 45 e7 25 movb $0x25,-0x19(%ebp)
ed8: 6a 01 push $0x1
eda: 50 push %eax
edb: 57 push %edi
edc: e8 21 fe ff ff call d02 <write>
ee1: 83 c4 0c add $0xc,%esp
ee4: 8d 45 e6 lea -0x1a(%ebp),%eax
ee7: 88 5d e6 mov %bl,-0x1a(%ebp)
eea: 6a 01 push $0x1
eec: 50 push %eax
eed: 57 push %edi
eee: 83 c6 01 add $0x1,%esi
ef1: e8 0c fe ff ff call d02 <write>
for(i = 0; fmt[i]; i++){
ef6: 0f b6 5e ff movzbl -0x1(%esi),%ebx
write(fd, &c, 1);
efa: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
efd: 31 d2 xor %edx,%edx
for(i = 0; fmt[i]; i++){
eff: 84 db test %bl,%bl
f01: 75 8d jne e90 <printf+0x60>
}
}
}
f03: 8d 65 f4 lea -0xc(%ebp),%esp
f06: 5b pop %ebx
f07: 5e pop %esi
f08: 5f pop %edi
f09: 5d pop %ebp
f0a: c3 ret
f0b: 90 nop
f0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printint(fd, *ap, 16, 0);
f10: 83 ec 0c sub $0xc,%esp
f13: b9 10 00 00 00 mov $0x10,%ecx
f18: 6a 00 push $0x0
f1a: 8b 5d d0 mov -0x30(%ebp),%ebx
f1d: 89 f8 mov %edi,%eax
f1f: 8b 13 mov (%ebx),%edx
f21: e8 6a fe ff ff call d90 <printint>
ap++;
f26: 89 d8 mov %ebx,%eax
f28: 83 c4 10 add $0x10,%esp
state = 0;
f2b: 31 d2 xor %edx,%edx
ap++;
f2d: 83 c0 04 add $0x4,%eax
f30: 89 45 d0 mov %eax,-0x30(%ebp)
f33: e9 4d ff ff ff jmp e85 <printf+0x55>
f38: 90 nop
f39: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
s = (char*)*ap;
f40: 8b 45 d0 mov -0x30(%ebp),%eax
f43: 8b 18 mov (%eax),%ebx
ap++;
f45: 83 c0 04 add $0x4,%eax
f48: 89 45 d0 mov %eax,-0x30(%ebp)
if(s == 0)
f4b: 85 db test %ebx,%ebx
f4d: 74 7c je fcb <printf+0x19b>
while(*s != 0){
f4f: 0f b6 03 movzbl (%ebx),%eax
f52: 84 c0 test %al,%al
f54: 74 29 je f7f <printf+0x14f>
f56: 8d 76 00 lea 0x0(%esi),%esi
f59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
f60: 88 45 e3 mov %al,-0x1d(%ebp)
write(fd, &c, 1);
f63: 8d 45 e3 lea -0x1d(%ebp),%eax
f66: 83 ec 04 sub $0x4,%esp
f69: 6a 01 push $0x1
s++;
f6b: 83 c3 01 add $0x1,%ebx
write(fd, &c, 1);
f6e: 50 push %eax
f6f: 57 push %edi
f70: e8 8d fd ff ff call d02 <write>
while(*s != 0){
f75: 0f b6 03 movzbl (%ebx),%eax
f78: 83 c4 10 add $0x10,%esp
f7b: 84 c0 test %al,%al
f7d: 75 e1 jne f60 <printf+0x130>
state = 0;
f7f: 31 d2 xor %edx,%edx
f81: e9 ff fe ff ff jmp e85 <printf+0x55>
f86: 8d 76 00 lea 0x0(%esi),%esi
f89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
write(fd, &c, 1);
f90: 83 ec 04 sub $0x4,%esp
f93: 88 5d e5 mov %bl,-0x1b(%ebp)
f96: 8d 45 e5 lea -0x1b(%ebp),%eax
f99: 6a 01 push $0x1
f9b: e9 4c ff ff ff jmp eec <printf+0xbc>
printint(fd, *ap, 10, 1);
fa0: 83 ec 0c sub $0xc,%esp
fa3: b9 0a 00 00 00 mov $0xa,%ecx
fa8: 6a 01 push $0x1
faa: e9 6b ff ff ff jmp f1a <printf+0xea>
putc(fd, *ap);
faf: 8b 5d d0 mov -0x30(%ebp),%ebx
write(fd, &c, 1);
fb2: 83 ec 04 sub $0x4,%esp
putc(fd, *ap);
fb5: 8b 03 mov (%ebx),%eax
write(fd, &c, 1);
fb7: 6a 01 push $0x1
putc(fd, *ap);
fb9: 88 45 e4 mov %al,-0x1c(%ebp)
write(fd, &c, 1);
fbc: 8d 45 e4 lea -0x1c(%ebp),%eax
fbf: 50 push %eax
fc0: 57 push %edi
fc1: e8 3c fd ff ff call d02 <write>
fc6: e9 5b ff ff ff jmp f26 <printf+0xf6>
while(*s != 0){
fcb: b8 28 00 00 00 mov $0x28,%eax
s = "(null)";
fd0: bb 38 12 00 00 mov $0x1238,%ebx
fd5: eb 89 jmp f60 <printf+0x130>
fd7: 66 90 xchg %ax,%ax
fd9: 66 90 xchg %ax,%ax
fdb: 66 90 xchg %ax,%ax
fdd: 66 90 xchg %ax,%ax
fdf: 90 nop
00000fe0 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
fe0: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
fe1: a1 64 18 00 00 mov 0x1864,%eax
{
fe6: 89 e5 mov %esp,%ebp
fe8: 57 push %edi
fe9: 56 push %esi
fea: 53 push %ebx
feb: 8b 5d 08 mov 0x8(%ebp),%ebx
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
fee: 8b 10 mov (%eax),%edx
bp = (Header*)ap - 1;
ff0: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
ff3: 39 c8 cmp %ecx,%eax
ff5: 73 19 jae 1010 <free+0x30>
ff7: 89 f6 mov %esi,%esi
ff9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
1000: 39 d1 cmp %edx,%ecx
1002: 72 1c jb 1020 <free+0x40>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
1004: 39 d0 cmp %edx,%eax
1006: 73 18 jae 1020 <free+0x40>
{
1008: 89 d0 mov %edx,%eax
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
100a: 39 c8 cmp %ecx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
100c: 8b 10 mov (%eax),%edx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
100e: 72 f0 jb 1000 <free+0x20>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
1010: 39 d0 cmp %edx,%eax
1012: 72 f4 jb 1008 <free+0x28>
1014: 39 d1 cmp %edx,%ecx
1016: 73 f0 jae 1008 <free+0x28>
1018: 90 nop
1019: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
break;
if(bp + bp->s.size == p->s.ptr){
1020: 8b 73 fc mov -0x4(%ebx),%esi
1023: 8d 3c f1 lea (%ecx,%esi,8),%edi
1026: 39 fa cmp %edi,%edx
1028: 74 19 je 1043 <free+0x63>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
102a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
102d: 8b 50 04 mov 0x4(%eax),%edx
1030: 8d 34 d0 lea (%eax,%edx,8),%esi
1033: 39 f1 cmp %esi,%ecx
1035: 74 23 je 105a <free+0x7a>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
1037: 89 08 mov %ecx,(%eax)
freep = p;
1039: a3 64 18 00 00 mov %eax,0x1864
}
103e: 5b pop %ebx
103f: 5e pop %esi
1040: 5f pop %edi
1041: 5d pop %ebp
1042: c3 ret
bp->s.size += p->s.ptr->s.size;
1043: 03 72 04 add 0x4(%edx),%esi
1046: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
1049: 8b 10 mov (%eax),%edx
104b: 8b 12 mov (%edx),%edx
104d: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
1050: 8b 50 04 mov 0x4(%eax),%edx
1053: 8d 34 d0 lea (%eax,%edx,8),%esi
1056: 39 f1 cmp %esi,%ecx
1058: 75 dd jne 1037 <free+0x57>
p->s.size += bp->s.size;
105a: 03 53 fc add -0x4(%ebx),%edx
freep = p;
105d: a3 64 18 00 00 mov %eax,0x1864
p->s.size += bp->s.size;
1062: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
1065: 8b 53 f8 mov -0x8(%ebx),%edx
1068: 89 10 mov %edx,(%eax)
}
106a: 5b pop %ebx
106b: 5e pop %esi
106c: 5f pop %edi
106d: 5d pop %ebp
106e: c3 ret
106f: 90 nop
00001070 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
1070: 55 push %ebp
1071: 89 e5 mov %esp,%ebp
1073: 57 push %edi
1074: 56 push %esi
1075: 53 push %ebx
1076: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
1079: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
107c: 8b 15 64 18 00 00 mov 0x1864,%edx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
1082: 8d 78 07 lea 0x7(%eax),%edi
1085: c1 ef 03 shr $0x3,%edi
1088: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
108b: 85 d2 test %edx,%edx
108d: 0f 84 93 00 00 00 je 1126 <malloc+0xb6>
1093: 8b 02 mov (%edx),%eax
1095: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
1098: 39 cf cmp %ecx,%edi
109a: 76 64 jbe 1100 <malloc+0x90>
109c: 81 ff 00 10 00 00 cmp $0x1000,%edi
10a2: bb 00 10 00 00 mov $0x1000,%ebx
10a7: 0f 43 df cmovae %edi,%ebx
p = sbrk(nu * sizeof(Header));
10aa: 8d 34 dd 00 00 00 00 lea 0x0(,%ebx,8),%esi
10b1: eb 0e jmp 10c1 <malloc+0x51>
10b3: 90 nop
10b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
10b8: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
10ba: 8b 48 04 mov 0x4(%eax),%ecx
10bd: 39 cf cmp %ecx,%edi
10bf: 76 3f jbe 1100 <malloc+0x90>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
10c1: 39 05 64 18 00 00 cmp %eax,0x1864
10c7: 89 c2 mov %eax,%edx
10c9: 75 ed jne 10b8 <malloc+0x48>
p = sbrk(nu * sizeof(Header));
10cb: 83 ec 0c sub $0xc,%esp
10ce: 56 push %esi
10cf: e8 96 fc ff ff call d6a <sbrk>
if(p == (char*)-1)
10d4: 83 c4 10 add $0x10,%esp
10d7: 83 f8 ff cmp $0xffffffff,%eax
10da: 74 1c je 10f8 <malloc+0x88>
hp->s.size = nu;
10dc: 89 58 04 mov %ebx,0x4(%eax)
free((void*)(hp + 1));
10df: 83 ec 0c sub $0xc,%esp
10e2: 83 c0 08 add $0x8,%eax
10e5: 50 push %eax
10e6: e8 f5 fe ff ff call fe0 <free>
return freep;
10eb: 8b 15 64 18 00 00 mov 0x1864,%edx
if((p = morecore(nunits)) == 0)
10f1: 83 c4 10 add $0x10,%esp
10f4: 85 d2 test %edx,%edx
10f6: 75 c0 jne 10b8 <malloc+0x48>
return 0;
10f8: 31 c0 xor %eax,%eax
10fa: eb 1c jmp 1118 <malloc+0xa8>
10fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->s.size == nunits)
1100: 39 cf cmp %ecx,%edi
1102: 74 1c je 1120 <malloc+0xb0>
p->s.size -= nunits;
1104: 29 f9 sub %edi,%ecx
1106: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
1109: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
110c: 89 78 04 mov %edi,0x4(%eax)
freep = prevp;
110f: 89 15 64 18 00 00 mov %edx,0x1864
return (void*)(p + 1);
1115: 83 c0 08 add $0x8,%eax
}
}
1118: 8d 65 f4 lea -0xc(%ebp),%esp
111b: 5b pop %ebx
111c: 5e pop %esi
111d: 5f pop %edi
111e: 5d pop %ebp
111f: c3 ret
prevp->s.ptr = p->s.ptr;
1120: 8b 08 mov (%eax),%ecx
1122: 89 0a mov %ecx,(%edx)
1124: eb e9 jmp 110f <malloc+0x9f>
base.s.ptr = freep = prevp = &base;
1126: c7 05 64 18 00 00 68 movl $0x1868,0x1864
112d: 18 00 00
1130: c7 05 68 18 00 00 68 movl $0x1868,0x1868
1137: 18 00 00
base.s.size = 0;
113a: b8 68 18 00 00 mov $0x1868,%eax
113f: c7 05 6c 18 00 00 00 movl $0x0,0x186c
1146: 00 00 00
1149: e9 4e ff ff ff jmp 109c <malloc+0x2c>
|
oeis/192/A192355.asm | neoneye/loda-programs | 11 | 4637 | <filename>oeis/192/A192355.asm
; A192355: Constant term of the reduction of the polynomial p(n,x)=(1/2)((x+2)^n+(x-2)^n) by x^2->x+2.
; Submitted by <NAME>
; 1,0,6,2,70,90,926,2002,13110,37130,194446,640002,2973350,10653370,46333566,174174002,730176790,2820264810,11582386286,45425564002,184414199430,729520967450,2942491360606,11696742970002,47006639297270,187367554937290,751447226504526,2999857885752002,12017224603806310,48015519232830330,192222214478506046,768408445272470002,3075075019014542550,12295976362284182570,49196876590458693166,196748592937868884002,787111112023373201990,3148094227277799810010,12593427571558278233886,50370558298891875954002
mov $1,-3
pow $1,$0
mov $2,$0
trn $0,1
add $1,1
add $2,$0
mov $0,2
pow $0,$2
add $0,$1
div $0,3
|
Groups/FreeGroup/Definition.agda | Smaug123/agdaproofs | 4 | 15917 | {-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Setoids.Setoids
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Numbers.Naturals.Semiring
open import Numbers.Naturals.Order
open import Sets.FinSet.Definition
open import Groups.Definition
open import Groups.SymmetricGroups.Definition
open import Decidable.Sets
open import Boolean.Definition
module Groups.FreeGroup.Definition where
data FreeCompletion {a : _} (A : Set a) : Set a where
ofLetter : A → FreeCompletion A
ofInv : A → FreeCompletion A
freeCompletionMap : {a b : _} {A : Set a} {B : Set b} (f : A → B) (w : FreeCompletion A) → FreeCompletion B
freeCompletionMap f (ofLetter x) = ofLetter (f x)
freeCompletionMap f (ofInv x) = ofInv (f x)
freeInverse : {a : _} {A : Set a} (l : FreeCompletion A) → FreeCompletion A
freeInverse (ofLetter x) = ofInv x
freeInverse (ofInv x) = ofLetter x
ofLetterInjective : {a : _} {A : Set a} {x y : A} → (ofLetter x ≡ ofLetter y) → x ≡ y
ofLetterInjective refl = refl
ofInvInjective : {a : _} {A : Set a} {x y : A} → (ofInv x ≡ ofInv y) → x ≡ y
ofInvInjective refl = refl
ofLetterOfInv : {a : _} {A : Set a} {x y : A} → ofLetter x ≡ ofInv y → False
ofLetterOfInv ()
decidableFreeCompletion : {a : _} {A : Set a} → DecidableSet A → DecidableSet (FreeCompletion A)
decidableFreeCompletion {A = A} dec = pr
where
pr : (a b : FreeCompletion A) → (a ≡ b) || (a ≡ b → False)
pr (ofLetter x) (ofLetter y) with dec x y
... | inl refl = inl refl
... | inr x!=y = inr λ p → x!=y (ofLetterInjective p)
pr (ofLetter x) (ofInv y) = inr λ ()
pr (ofInv x) (ofLetter y) = inr λ ()
pr (ofInv x) (ofInv y) with dec x y
... | inl refl = inl refl
... | inr x!=y = inr λ p → x!=y (ofInvInjective p)
freeCompletionEqual : {a : _} {A : Set a} (dec : DecidableSet A) (x y : FreeCompletion A) → Bool
freeCompletionEqual dec x y with decidableFreeCompletion dec x y
freeCompletionEqual dec x y | inl x₁ = BoolTrue
freeCompletionEqual dec x y | inr x₁ = BoolFalse
freeCompletionEqualFalse : {a : _} {A : Set a} (dec : DecidableSet A) {x y : FreeCompletion A} → ((x ≡ y) → False) → (freeCompletionEqual dec x y) ≡ BoolFalse
freeCompletionEqualFalse dec {x = x} {y} x!=y with decidableFreeCompletion dec x y
freeCompletionEqualFalse dec {x} {y} x!=y | inl x=y = exFalso (x!=y x=y)
freeCompletionEqualFalse dec {x} {y} x!=y | inr _ = refl
freeCompletionEqualFalse' : {a : _} {A : Set a} (dec : DecidableSet A) {x y : FreeCompletion A} → .((freeCompletionEqual dec x y) ≡ BoolFalse) → (x ≡ y) → False
freeCompletionEqualFalse' dec {x} {y} pr with decidableFreeCompletion dec x y
freeCompletionEqualFalse' dec {x} {y} () | inl x₁
freeCompletionEqualFalse' dec {x} {y} pr | inr ans = ans
|
oeis/239/A239171.asm | neoneye/loda-programs | 11 | 173759 | ; A239171: Number of (n+1) X (1+1) 0..2 arrays with no element greater than all horizontal neighbors or equal to all vertical neighbors.
; Submitted by <NAME>
; 6,12,36,96,264,720,1968,5376,14688,40128,109632,299520,818304,2235648,6107904,16687104,45590016,124554240,340288512,929685504,2539948032,6939267072,18958430208,51795394560,141507649536,386606088192,1056227475456,2885667127296,7883789205504,21538912665600,58845403742208,160768632815616,439228073115648,1199993411862528,3278442969956352,8956872763637760,24470631467188224,66855008461651968,182651279857680384,499012576638664704,1363327712992690176,3724680579262709760,10176016584510799872
mov $3,1
lpb $0
sub $0,1
mov $2,$3
add $3,$1
mov $1,$2
mul $3,2
lpe
mov $0,$3
mul $0,6
|
org.alloytools.alloy.diff/misc/inheritance/subset1.als | jringert/alloy-diff | 1 | 215 | sig A {
a : some A
}
sig C {
c : some C
}
sig B in A + C {
b : some A
}
sig D in B {
d : some C
}
run {no B}
|
source/variable/variable/create.asm | paulscottrobson/6502-basic | 3 | 5637 | <filename>source/variable/variable/create.asm
; ************************************************************************************************
; ************************************************************************************************
;
; Name: create.asm
; Purpose: Create a new variable.
; Created: 1st March 2021
; Reviewed: 9th March 2021
; Author: <NAME> (<EMAIL>)
;
; ************************************************************************************************
; ************************************************************************************************
.section code
; ************************************************************************************************
;
; +0,+1 Link to next variable or $0000
; +2,+3 Address of variable name in code
; +4 Hash value for this
; +5 .... Data
;
; ************************************************************************************************
;
; (codePtr),y points to the variable and it is already setup
;
; ************************************************************************************************
CreateVariable:
tya ; push Y on the stack twice.
pha ; position in code of the new variable.
pha
ldx varType ; get var type 0-5 from the var type
lda _CVSize-$3A,x ; the bytes required for this new variable.
pha ; save length
;
lda lowMemory ; set low Memory ptr to temp0
sta temp0 ; (address of the new variable)
lda lowMemory+1
sta temp0+1
;
pla ; get length
clc ; add to low memory.
adc lowMemory
sta lowMemory
bcc _CVNoCarry
inc lowMemory+1
lda lowMemory+1 ; check out of memory.
cmp highMemory+1
bcs _CVMemory
_CVNoCarry:
lda varHash ; store hash at offset 4.
ldy #4
sta (temp0),y
pla ; offset, work out where the variable name is.
clc
adc codePtr
ldy #2 ; copy that into slots 2 + 3.
sta (temp0),y
lda codePtr+1
adc #0
iny
sta (temp0),y
cmp basePage+1 ; compare against the program base.
bcs _CVNotImmediate
jsr CloneVariableName ; we need to clone the variable name (immediate mode)
_CVNotImmediate:
;
ldy #0 ; copy current hash pointer in link
lda (hashList),y ; so we're inserting it in the front of a linked list
sta (temp0),y
iny
lda (hashList),y
sta (temp0),y
;
lda temp0+1 ; set new link
sta (hashList),y
dey
lda temp0
sta (hashList),y
lda varType ; type in A
ldy #5 ; offset in Y
jsr ZeroTemp0Y ; zero (temp0),y with whatever type.
.puly ; restore Y
rts
_CVMemory:
.throw Memory
;
; Size look up table.
;
_CVSize:.byte VarHSize+VarISize,VarHSize+VarASize ; <storage for integer>
.byte VarHSize+VarSSize,VarHSize+VarASize ; <storage for string>
.byte VarHSize+VarFSize,VarHSize+VarASize ; <storage for float>
; ************************************************************************************************
;
; Write a blank at (temp0),y, allowing for type A.
;
; ************************************************************************************************
ZeroTemp0Y:
lsr a ; bit 0 in carry
asl a
bcs _ZTExit ; we don't initialise arrays.
;
cmp #$3C ; check string
beq _ZTWriteNullString ; write "" string
cmp #$3E ; check float
beq _ZTWriteFloat
;
; Null Integer.
;
.pshy
lda #0
sta (temp0),y
iny
sta (temp0),y
iny
sta (temp0),y
iny
sta (temp0),y
.puly
_ZTExit:
rts
;
; Null string at (temp0),Y
;
_ZTWriteNullString:
lda #0 ; put a reference to null string as the default value.
sta NullString
lda #NullString & $FF
sta (temp0),y
lda #NullString >> 8
iny
sta (temp0),y
dey
rts
;
; Float write done by floating point module.
;
_ZTWriteFloat:
.pshx
.floatingpoint_setzero
.pulx
rts
; ************************************************************************************************
;
; Clone the variable name at (temp0),2/3
; Required when a new variable is defined from the command line, as we cannot then use the
; "in code" address.
;
; ************************************************************************************************
CloneVariableName:
ldy #2 ; copy vname address to temp2
lda (temp0),y
sta temp2
iny
lda (temp0),y
sta temp2+1
;
lda lowMemory+1 ; copy lowMemory address to (temp0),2/3
sta (temp0),y
dey
lda lowMemory
sta (temp0),y
;
ldy #0 ; copy data from (temp2) to (lowMemory)
_CVNCopy:
lda (temp2),y
sta (lowMemory),y
iny
cmp #$3A ; until the whole name has been copied.
bcc _CVNCopy
;
tya ; add Y to low memory
clc
adc lowMemory
sta lowMemory
bcc _CVNNoCarry
inc lowMemory+1
_CVNNoCarry:
rts
.send code
; ************************************************************************************************
;
; Changes and Updates
;
; ************************************************************************************************
;
; Date Notes
; ==== =====
; 07-Mar-21 Pre code read v0.01
;
; ************************************************************************************************
|
fileManagement/unlink.asm | slowy07/learnAsm | 1 | 80943 | <gh_stars>1-10
section .text
global _start
section .data
fileName 'impFile.txt', 0h
_start:
mov ebx, fileName
mov eax, 10
int 80h
call quit |
grammars/BigDataScriptLexerRules.g4 | augustand/BigDataScript | 0 | 6712 | <filename>grammars/BigDataScriptLexerRules.g4<gh_stars>0
lexer grammar BigDataScriptLexerRules;
//------------------------------------------------------------------------------
// Lexer
//------------------------------------------------------------------------------
//---
// Lexer Fragments
//---
fragment IntegerNumber
: '0'
| '1'..'9' ('0'..'9')*
| '0' ('0'..'7')+
| HexPrefix HexDigit+
;
fragment EscapeSequence
: '\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\"' | '\'' | '\\'
| ('0'..'3') ('0'..'7') ('0'..'7')
| ('0'..'7') ('0'..'7')
| ('0'..'7')
)
;
fragment EscapedNewLine : '\\' ( '\r' | '\n' | '\r\n');
fragment Exponent : ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ ;
fragment HexPrefix : '0x' | '0X' ;
fragment HexDigit : ('0'..'9'|'a'..'f'|'A'..'F') ;
fragment NonIntegerNumber
: ('0' .. '9')+ '.' ('0' .. '9')* Exponent?
| '.' ( '0' .. '9' )+ Exponent?
| ('0' .. '9')+ Exponent
| ('0' .. '9')+
;
fragment SysMultiLine : ( EscapedNewLine | ~( '\r' | '\n') )*;
//---
// Lexer tokens
//---
// Number literals
BOOL_LITERAL : 'true' | 'false' ;
INT_LITERAL : IntegerNumber ;
REAL_LITERAL : NonIntegerNumber ;
// String literal: Any character except quote or backslash OR a backslash
// followed by any char (this allows to escape the quote character)
// Note: String literals can be multi-line
STRING_LITERAL : '"' ( (~( '"' | '\\' ) | ('\\' .) )* ) '"' ;
// Single quote string literal (un-interpolated)
STRING_LITERAL_SINGLE
: '\'' (~( '\'' ))* '\'' ;
// 'sys' literal. Everything after a sys statement.
// Note: It can be multi-line by escaping before the end of line
HELP_LITERAL : 'help' ( ' ' | '\t' )+ SysMultiLine;
SYS_LITERAL : 'sys' ( ' ' | '\t' )+ SysMultiLine;
TASK_LITERAL : 'task' ( ' ' | '\t' )+ ~('(' | '{' | '\r' | '\n' ) SysMultiLine;
// Comments
COMMENT : '/*' .*? '*/' { skip(); };
COMMENT_LINE : '//' ~('\n'|'\r')* { skip(); };
COMMENT_LINE_HASH : '#' ~('\n'|'\r')* { skip(); };
// Identifier
ID : ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'0'..'9'|'_')*;
// Newline and white space
WS : ( ' ' | '\t' | '\r' | '\\\n' | '\\\r\n' | '\u000C' ) { skip(); } ;
|
test/Succeed/Issue3256.agda | shlevy/agda | 1,989 | 14220 | <filename>test/Succeed/Issue3256.agda<gh_stars>1000+
-- Jesper, 2018-11-23: Unsolved metas are turned into postulates
-- when --allow-unsolved-metas is enabled, but there was no internal
-- representation of postulated sorts.
module Issue3256 where
open import Issue3256.B
-- WAS:
-- An internal error has occurred. Please report this as a bug.
-- Location of the error: src/full/Agda/TypeChecking/Reduce.hs:149
|
programs/oeis/267/A267882.asm | neoneye/loda | 22 | 93574 | ; A267882: Total number of ON (black) cells after n iterations of the "Rule 233" elementary cellular automaton starting with a single ON (black) cell.
; 1,1,4,10,19,30,43,58,75,94,115,138,163,190,219,250,283,318,355,394,435,478,523,570,619,670,723,778,835,894,955,1018,1083,1150,1219,1290,1363,1438,1515,1594,1675,1758,1843,1930,2019,2110,2203,2298,2395,2494,2595,2698,2803,2910,3019,3130,3243,3358,3475,3594,3715,3838,3963,4090,4219,4350,4483,4618,4755,4894,5035,5178,5323,5470,5619,5770,5923,6078,6235,6394,6555,6718,6883,7050,7219,7390,7563,7738,7915,8094,8275,8458,8643,8830,9019,9210,9403,9598,9795,9994
mov $1,4
mov $2,$0
cmp $2,0
add $0,$2
div $1,$0
add $0,1
pow $0,2
trn $1,1
add $0,$1
sub $0,6
|
source/lean/extract.asm | paulscottrobson/lean | 2 | 20539 | ; ******************************************************************************
; ******************************************************************************
;
; Name : extract.asm
; Purpose : Extract elements from the translated buffer
; Author : <NAME> (<EMAIL>)
; Created : 27th October 2019
;
; ******************************************************************************
; ******************************************************************************
; ******************************************************************************
;
; Extract a following identifier -> YX
;
; ******************************************************************************
EGetUnknownIdentifier:
ldx genPos ; get next character
lda lineBuffer,x
and #$7F
jsr PLTCheckCharacter ; is it an identifier ?
bcc _EUIError ; no
;
phx ; save start position on stack.
_EGetFindEnd: ; skip past the identifier end
lda lineBuffer,x
inx
asl a
bcc _EGetFindEnd
stx genPos ; points to the next thing.
;
pla ; offset
ldy #lineBuffer >> 8 ; make address in YX
clc
adc #lineBuffer & $FF
tax
bcc _EGetNoCarry
iny
_EGetNoCarry:
rts
_EUIError:
derror "IDENTIFIER ?"
; ******************************************************************************
;
; Check the next character is A
;
; ******************************************************************************
EGetSyntaxCheck:
pha
phx
ldx genPos ; position of next
eor lineBuffer,x ; bits 0-6 will be zero if match
and #$7F
bne _EGSFail ; different
inc genPos ; skip it and exit
plx
pla
rts
_EGSFail:
derror "MISSING ?"
; ******************************************************************************
;
; Get next character or whatever into A
;
; ******************************************************************************
EGLookNext:
phx
ldx genPos ; position of next
lda lineBuffer,x
plx
rts
; ******************************************************************************
;
; Skip over next character
;
; ******************************************************************************
EGSkipNext:
inc genPos
rts
|
programs/oeis/038/A038213.asm | karttu/loda | 0 | 83372 | ; A038213: Top line of 3-wave sequence A038196, also bisection of A006356.
; 1,3,14,70,353,1782,8997,45425,229347,1157954,5846414,29518061,149034250,752461609,3799116465,19181424995,96845429254,488964567014,2468741680809,12464472679038,62932092237197,317738931708801
mov $1,1
lpb $0,1
sub $0,1
add $2,$1
add $3,$2
add $2,$3
add $1,$2
lpe
|
solutions/32-inventory report/compare and count.asm | Ernesto-Alvarez/HRM-Puzzles | 0 | 86765 | -- HUMAN RESOURCE MACHINE PROGRAM --
a:
COPYFROM 14
COPYTO 16
COPYTO 17
INBOX
COPYTO 15
b:
COPYFROM [16]
JUMPZ d
SUB 15
JUMPZ c
BUMPDN 17
c:
BUMPUP 17
BUMPUP 16
JUMP b
d:
COPYFROM 17
OUTBOX
JUMP a
DEFINE LABEL 15
<KEY>;
DEFINE LABEL 16
<KEY>
Y<KEY>UNwygYBaOAbAAAaPZOoQ;
DEFINE LABEL 17
<KEY>;
|
oeis/239/A239443.asm | neoneye/loda-programs | 11 | 95045 | ; A239443: a(n) = phi(n^9), where phi = A000010.
; 1,256,13122,131072,1562500,3359232,34588806,67108864,258280326,400000000,2143588810,1719926784,9788768652,8854734336,20503125000,34359738368,111612119056,66119763456,305704134738,204800000000,453874312332,548758735360,1722841676182,880602513408,3051757812500,2505924774912,5083731656658,4533623980032,14006899562908,5248800000000,25586731123230,17592186044416,28128172364820,28572702478336,54045009375000,33853318889472,126449260341156,78260258492928,128448222251544,104857600000000,319397009164840
mov $3,$0
seq $0,10 ; Euler totient function phi(n): count numbers <= n and prime to n.
add $1,$0
add $3,1
sub $2,$3
mul $2,2
pow $2,4
mul $1,$2
mul $1,$2
div $1,64
sub $1,3
div $1,4
add $1,1
mov $0,$1
|
alloy4fun_models/trainstlt/models/8/TGT45vnmwpFfdotNj.als | Kaixi26/org.alloytools.alloy | 0 | 3201 | <gh_stars>0
open main
pred idTGT45vnmwpFfdotNj_prop9 {
(all t:Train| eventually (no t.pos and after one t.pos:>Entry))
}
pred __repair { idTGT45vnmwpFfdotNj_prop9 }
check __repair { idTGT45vnmwpFfdotNj_prop9 <=> prop9o } |
test/Succeed/AbsurdPattern.agda | shlevy/agda | 1,989 | 12703 | <filename>test/Succeed/AbsurdPattern.agda<gh_stars>1000+
-- Pattern matching on a (decidably) empty type allows you to omit the
-- right-hand side.
module AbsurdPattern where
data Empty : Set where
elim-Empty : {A : Set} -> Empty -> A
elim-Empty ()
|
programs/oeis/326/A326354.asm | jmorken/loda | 1 | 91861 | <filename>programs/oeis/326/A326354.asm<gh_stars>1-10
; A326354: a(n) is the number of fractions reduced to lowest terms with numerator and denominator less than or equal to n in absolute value.
; 1,3,7,15,23,39,47,71,87,111,127,167,183,231,255,287,319,383,407,479,511,559,599,687,719,799,847,919,967,1079,1111,1231,1295,1375,1439,1535,1583,1727,1799,1895,1959,2119,2167,2335,2415,2511,2599,2783,2847,3015,3095
mov $2,$0
add $2,1
mov $4,$0
lpb $2
mov $0,$4
sub $2,1
sub $0,$2
trn $0,1
mov $3,1
lpb $0
mov $3,$0
cal $3,10 ; Euler totient function phi(n): count numbers <= n and prime to n.
mov $0,1
lpe
mul $3,2
add $3,$0
sub $3,1
mul $3,4
add $1,$3
lpe
sub $1,4
div $1,4
mul $1,2
add $1,1
|
grad/programming-languages/ada-programming-assignment/Matrix_Mult.adb | positivevaib/nyu-archive | 0 | 18475 | package body Matrix_Mult is
procedure Mat_Mult(A: in Mat; B: in Mat; C: out Mat) is
task type Dot_Product is
entry Dot(Row_Index: Integer; Col_Index: Integer);
entry Dot_Done;
end Dot_Product;
task body Dot_Product is
Row: Integer;
Col: Integer;
begin
accept Dot(Row_Index: Integer; Col_Index: Integer) do
Row := Row_Index;
Col := Col_Index;
end Dot;
C(Row, Col) := 0;
for i in 1..Size loop
C(Row, Col) := C(Row, Col) + A(Row, i)*B(i, Col);
end loop;
accept Dot_Done do
null;
end Dot_Done;
end Dot_Product;
Tasks_Mat: array(1..Size, 1..Size) of Dot_Product;
begin
for i in 1..Size loop
for j in 1..Size loop
Tasks_Mat(i, j).Dot(i, j);
end loop;
end loop;
for i in 1..Size loop
for j in 1..Size loop
Tasks_Mat(i, j).Dot_Done;
end loop;
end loop;
end Mat_Mult;
end Matrix_Mult;
|
testsuite/utils/src/wire_simulation.adb | rocher/Ada_Drivers_Library | 192 | 20901 | ------------------------------------------------------------------------------
-- --
-- Copyright (C) 2017-2018, AdaCore --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions are --
-- met: --
-- 1. Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- 2. Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in --
-- the documentation and/or other materials provided with the --
-- distribution. --
-- 3. Neither the name of the copyright holder nor the names of its --
-- contributors may be used to endorse or promote products derived --
-- from this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT --
-- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, --
-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY --
-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT --
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE --
-- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
package body Wire_Simulation is
-----------
-- Point --
-----------
function Point
(This : in out Virtual_Wire;
Id : Positive)
return Any_GPIO_Point
is
begin
This.Points (Id).Wire := This'Unchecked_Access;
return This.Points (Id)'Unchecked_Access;
end Point;
--------------
-- Set_Mode --
--------------
overriding procedure Set_Mode
(This : in out Wire_Point;
Mode : GPIO_Config_Mode)
is
begin
This.Current_Mode := Input;
if Mode = Output and then This.Wire.At_Least_One_Output then
raise Invalid_Configuration;
end if;
This.Current_Mode := Mode;
This.Wire.Update_Wire_State;
end Set_Mode;
-----------------------
-- Set_Pull_Resistor --
-----------------------
overriding procedure Set_Pull_Resistor
(This : in out Wire_Point;
Pull : GPIO_Pull_Resistor)
is
begin
This.Current_Pull := Floating;
if Pull = Pull_Down
and then
(This.Wire.At_Least_One_Pull_Up
or else
This.Wire.Default_Pull = Pull_Up)
then
raise Invalid_Configuration;
elsif Pull = Pull_Up
and then
(This.Wire.At_Least_One_Pull_Down
or else
This.Wire.Default_Pull = Pull_Down)
then
raise Invalid_Configuration;
else
This.Current_Pull := Pull;
This.Wire.Update_Wire_State;
end if;
end Set_Pull_Resistor;
---------
-- Set --
---------
overriding function Set
(This : Wire_Point)
return Boolean
is
begin
case This.Wire.State is
when Unknown =>
raise Unknown_State;
when High =>
return True;
when Low =>
return False;
end case;
end Set;
---------
-- Set --
---------
overriding procedure Set
(This : in out Wire_Point)
is
begin
This.Current_State := True;
This.Wire.Update_Wire_State;
end Set;
-----------
-- Clear --
-----------
overriding procedure Clear
(This : in out Wire_Point)
is
begin
This.Current_State := False;
This.Wire.Update_Wire_State;
end Clear;
------------
-- Toggle --
------------
overriding procedure Toggle
(This : in out Wire_Point)
is
begin
This.Current_State := not This.Current_State;
This.Wire.Update_Wire_State;
end Toggle;
-----------------------
-- Update_Wire_State --
-----------------------
procedure Update_Wire_State (This : in out Virtual_Wire) is
Has_Pull_Up : constant Boolean :=
This.At_Least_One_Pull_Up or This.Default_Pull = Pull_Up;
Has_Pull_Down : constant Boolean :=
This.At_Least_One_Pull_Down or This.Default_Pull = Pull_Down;
State : Wire_State := Unknown;
begin
pragma Assert ((Has_Pull_Down /= Has_Pull_Up) or else not Has_Pull_Up,
"Invalid config. This should've been caught before");
if Has_Pull_Down then
State := Low;
elsif Has_Pull_Up then
State := High;
end if;
for Pt of This.Points loop
if Pt.Current_Mode = Output then
if Pt.Current_State then
State := High;
else
State := Low;
end if;
exit;
end if;
end loop;
This.State := State;
end Update_Wire_State;
-------------------------
-- At_Least_One_Output --
-------------------------
function At_Least_One_Output (This : Virtual_Wire) return Boolean is
(for some Pt of This.Points => Pt.Current_Mode = Output);
--------------------------
-- At_Least_One_Pull_Up --
--------------------------
function At_Least_One_Pull_Up (This : Virtual_Wire) return Boolean is
(for some Pt of This.Points => Pt.Current_Pull = Pull_Up);
----------------------------
-- At_Least_One_Pull_Down --
----------------------------
function At_Least_One_Pull_Down (This : Virtual_Wire) return Boolean is
(for some Pt of This.Points => Pt.Current_Pull = Pull_Down);
end Wire_Simulation;
|
src/code/init.asm | Hacktix/gb-tictactoe | 8 | 21988 | <gh_stars>1-10
SECTION "Initialization", ROM0
;==============================================================
; Initializes all registers to a playable state after
; initial startup of the game.
;==============================================================
BaseInit::
; Check if running on CGB
xor BOOTUP_A_CGB
ld [wCGBFlag], a
; Clear pending interrupts
xor a
ld [rIF], a
; Wait for VBlank
.waitVBlank
ldh a, [rLY]
cp SCRN_Y
jr c, .waitVBlank
; Disable LCD
xor a
ld [rLCDC], a
; Copy OAM DMA routine to HRAM
ld hl, OAMDMARoutine
ld b, OAMDMARoutine.end - OAMDMARoutine
ld c, LOW(hOAMDMA)
.copyOAMDMA
ld a, [hli]
ldh [c], a
inc c
dec b
jr nz, .copyOAMDMA
; Initialize Palettes
ld a, DEFAULT_DMG_PALETTE
ldh [rBGP], a
ldh [rOBP0], a
ldh [rOBP1], a
; Initialize HRAM Variables
xor a
ldh [hStartAddrOAM], a
ldh [hPressedButtons], a
ldh [hHeldButtons], a
; Clear OAM Memory and VRAM
call ClearOAM
ld a, GAMEPLAY_TILE_EMPTY
call ClearTilemaps
; Initialize sound
ld a, $ff
ld [rNR50], a
ld [rNR51], a
ld [rNR52], a
ret |
agda/Prelude.agda | anqurvanillapy/fpl | 1 | 15555 | <filename>agda/Prelude.agda
{-
- Prelude: Play with some basic theorems...
-}
{-# OPTIONS --rewriting #-}
module Prelude where
open import Agda.Builtin.Equality public
open import Agda.Builtin.Nat renaming (Nat to ℕ) public
{-# BUILTIN REWRITE _≡_ #-}
-- Identity function
id : ∀ {ℓ} {A : Set ℓ} → A → A
id x = x
_ : id 42 ≡ 42
_ = refl
-- Composition
_∘_ :
∀ {ℓ m n}
{A : Set ℓ}
{B : Set m}
{C : B → Set n}
(g : (b : B) → C b)
(f : A → B)
→ ---------
(a : A) → C (f a)
(g ∘ f) x = g (f x)
_ : (id ∘ id) 42 ≡ id (id 42)
_ = refl
-- Transitivity
trans :
∀ {ℓ}
{A : Set ℓ}
{x y z : A}
(q : y ≡ z)
(p : x ≡ y)
→ ---------
x ≡ z
trans n refl = n
-- Symmetry
symm :
∀ {ℓ}
{A : Set ℓ}
{x y : A}
(p : x ≡ y)
→ ---------
y ≡ x
symm refl = refl
-- Congruence
cong :
∀ {ℓ ℓ′}
{A : Set ℓ}
{B : Set ℓ′}
(f : A → B)
{x y : A}
(p : x ≡ y)
→ ---------
f x ≡ f y
cong _ refl = refl
cong₂ :
∀ {ℓ ℓ′}
{A A′ : Set ℓ}
{B : Set ℓ′}
(f : A → A′ → B)
{x y : A}
{x′ y′ : A′}
(p : x ≡ y)
(q : x′ ≡ y′)
→ -----------
f x x′ ≡ f y y′
cong₂ _ refl refl = refl
-- Substitution
subst :
∀ {ℓ ℓ′}
{A : Set ℓ}
(B : A → Set ℓ′)
{x y : A}
(p : x ≡ y)
→ ---------
B x → B y
subst _ refl = λ a → a
-- Type coercion
coe :
∀ {ℓ}
{A B : Set ℓ}
→ -----------
A ≡ B → A → B
coe r a = subst id r a
|
tmp/sample/a.asm | fishyoukun/dshell | 1 | 103405 |
a.out: file format elf64-x86-64
Disassembly of section .interp:
0000000000400238 <.interp>:
400238: 2f (bad)
400239: 6c insb (%dx),%es:(%rdi)
40023a: 69 62 36 34 2f 6c 64 imul $0x646c2f34,0x36(%rdx),%esp
400241: 2d 6c 69 6e 75 sub $0x756e696c,%eax
400246: 78 2d js 400275 <_init-0x1fb>
400248: 78 38 js 400282 <_init-0x1ee>
40024a: 36 2d 36 34 2e 73 ss sub $0x732e3436,%eax
400250: 6f outsl %ds:(%rsi),(%dx)
400251: 2e 32 00 xor %cs:(%rax),%al
Disassembly of section .note.ABI-tag:
0000000000400254 <.note.ABI-tag>:
400254: 04 00 add $0x0,%al
400256: 00 00 add %al,(%rax)
400258: 10 00 adc %al,(%rax)
40025a: 00 00 add %al,(%rax)
40025c: 01 00 add %eax,(%rax)
40025e: 00 00 add %al,(%rax)
400260: 47 rex.RXB
400261: 4e 55 rex.WRX push %rbp
400263: 00 00 add %al,(%rax)
400265: 00 00 add %al,(%rax)
400267: 00 02 add %al,(%rdx)
400269: 00 00 add %al,(%rax)
40026b: 00 06 add %al,(%rsi)
40026d: 00 00 add %al,(%rax)
40026f: 00 20 add %ah,(%rax)
400271: 00 00 add %al,(%rax)
...
Disassembly of section .note.gnu.build-id:
0000000000400274 <.note.gnu.build-id>:
400274: 04 00 add $0x0,%al
400276: 00 00 add %al,(%rax)
400278: 14 00 adc $0x0,%al
40027a: 00 00 add %al,(%rax)
40027c: 03 00 add (%rax),%eax
40027e: 00 00 add %al,(%rax)
400280: 47 rex.RXB
400281: 4e 55 rex.WRX push %rbp
400283: 00 af ed 8a 5b be add %ch,-0x41a47513(%rdi)
400289: 26 6a 4f es pushq $0x4f
40028c: d4 (bad)
40028d: 6f outsl %ds:(%rsi),(%dx)
40028e: 15 3b 25 2b 80 adc $0x802b253b,%eax
400293: c8 72 c2 10 enterq $0xc272,$0x10
400297: ea (bad)
Disassembly of section .gnu.hash:
0000000000400298 <.gnu.hash>:
400298: 01 00 add %eax,(%rax)
40029a: 00 00 add %al,(%rax)
40029c: 01 00 add %eax,(%rax)
40029e: 00 00 add %al,(%rax)
4002a0: 01 00 add %eax,(%rax)
...
Disassembly of section .dynsym:
00000000004002b8 <.dynsym>:
...
4002d0: 10 00 adc %al,(%rax)
4002d2: 00 00 add %al,(%rax)
4002d4: 12 00 adc (%rax),%al
...
4002e6: 00 00 add %al,(%rax)
4002e8: 0b 00 or (%rax),%eax
4002ea: 00 00 add %al,(%rax)
4002ec: 12 00 adc (%rax),%al
...
4002fe: 00 00 add %al,(%rax)
400300: 18 00 sbb %al,(%rax)
400302: 00 00 add %al,(%rax)
400304: 12 00 adc (%rax),%al
...
400316: 00 00 add %al,(%rax)
400318: 25 00 00 00 12 and $0x12000000,%eax
...
40032d: 00 00 add %al,(%rax)
40032f: 00 37 add %dh,(%rdi)
400331: 00 00 add %al,(%rax)
400333: 00 20 add %ah,(%rax)
...
400345: 00 00 add %al,(%rax)
400347: 00 1f add %bl,(%rdi)
400349: 00 00 add %al,(%rax)
40034b: 00 12 add %dl,(%rdx)
...
Disassembly of section .dynstr:
0000000000400360 <.dynstr>:
400360: 00 6c 69 62 add %ch,0x62(%rcx,%rbp,2)
400364: 63 2e movslq (%rsi),%ebp
400366: 73 6f jae 4003d7 <_init-0x99>
400368: 2e 36 00 70 75 cs add %dh,%ss:0x75(%rax)
40036d: 74 73 je 4003e2 <_init-0x8e>
40036f: 00 70 75 add %dh,0x75(%rax)
400372: 74 63 je 4003d7 <_init-0x99>
400374: 68 61 72 00 70 pushq $0x70007261
400379: 72 69 jb 4003e4 <_init-0x8c>
40037b: 6e outsb %ds:(%rsi),(%dx)
40037c: 74 66 je 4003e4 <_init-0x8c>
40037e: 00 73 6c add %dh,0x6c(%rbx)
400381: 65 65 70 00 gs gs jo 400385 <_init-0xeb>
400385: 5f pop %rdi
400386: 5f pop %rdi
400387: 6c insb (%dx),%es:(%rdi)
400388: 69 62 63 5f 73 74 61 imul $0x6174735f,0x63(%rdx),%esp
40038f: 72 74 jb 400405 <_init-0x6b>
400391: 5f pop %rdi
400392: 6d insl (%dx),%es:(%rdi)
400393: 61 (bad)
400394: 69 6e 00 5f 5f 67 6d imul $0x6d675f5f,0x0(%rsi),%ebp
40039b: 6f outsl %ds:(%rsi),(%dx)
40039c: 6e outsb %ds:(%rsi),(%dx)
40039d: 5f pop %rdi
40039e: 73 74 jae 400414 <_init-0x5c>
4003a0: 61 (bad)
4003a1: 72 74 jb 400417 <_init-0x59>
4003a3: 5f pop %rdi
4003a4: 5f pop %rdi
4003a5: 00 47 4c add %al,0x4c(%rdi)
4003a8: 49 rex.WB
4003a9: 42 rex.X
4003aa: 43 5f rex.XB pop %r15
4003ac: 32 2e xor (%rsi),%ch
4003ae: 32 2e xor (%rsi),%ch
4003b0: 35 .byte 0x35
...
Disassembly of section .gnu.version:
00000000004003b2 <.gnu.version>:
4003b2: 00 00 add %al,(%rax)
4003b4: 02 00 add (%rax),%al
4003b6: 02 00 add (%rax),%al
4003b8: 02 00 add (%rax),%al
4003ba: 02 00 add (%rax),%al
4003bc: 00 00 add %al,(%rax)
4003be: 02 00 add (%rax),%al
Disassembly of section .gnu.version_r:
00000000004003c0 <.gnu.version_r>:
4003c0: 01 00 add %eax,(%rax)
4003c2: 01 00 add %eax,(%rax)
4003c4: 01 00 add %eax,(%rax)
4003c6: 00 00 add %al,(%rax)
4003c8: 10 00 adc %al,(%rax)
4003ca: 00 00 add %al,(%rax)
4003cc: 00 00 add %al,(%rax)
4003ce: 00 00 add %al,(%rax)
4003d0: 75 1a jne 4003ec <_init-0x84>
4003d2: 69 09 00 00 02 00 imul $0x20000,(%rcx),%ecx
4003d8: 46 00 00 rex.RX add %r8b,(%rax)
4003db: 00 00 add %al,(%rax)
4003dd: 00 00 add %al,(%rax)
...
Disassembly of section .rela.dyn:
00000000004003e0 <.rela.dyn>:
4003e0: f8 clc
4003e1: 0f 60 00 punpcklbw (%rax),%mm0
4003e4: 00 00 add %al,(%rax)
4003e6: 00 00 add %al,(%rax)
4003e8: 06 (bad)
4003e9: 00 00 add %al,(%rax)
4003eb: 00 05 00 00 00 00 add %al,0x0(%rip) # 4003f1 <_init-0x7f>
4003f1: 00 00 add %al,(%rax)
4003f3: 00 00 add %al,(%rax)
4003f5: 00 00 add %al,(%rax)
...
Disassembly of section .rela.plt:
00000000004003f8 <.rela.plt>:
4003f8: 18 10 sbb %dl,(%rax)
4003fa: 60 (bad)
4003fb: 00 00 add %al,(%rax)
4003fd: 00 00 add %al,(%rax)
4003ff: 00 07 add %al,(%rdi)
400401: 00 00 add %al,(%rax)
400403: 00 01 add %al,(%rcx)
...
40040d: 00 00 add %al,(%rax)
40040f: 00 20 add %ah,(%rax)
400411: 10 60 00 adc %ah,0x0(%rax)
400414: 00 00 add %al,(%rax)
400416: 00 00 add %al,(%rax)
400418: 07 (bad)
400419: 00 00 add %al,(%rax)
40041b: 00 02 add %al,(%rdx)
...
400425: 00 00 add %al,(%rax)
400427: 00 28 add %ch,(%rax)
400429: 10 60 00 adc %ah,0x0(%rax)
40042c: 00 00 add %al,(%rax)
40042e: 00 00 add %al,(%rax)
400430: 07 (bad)
400431: 00 00 add %al,(%rax)
400433: 00 03 add %al,(%rbx)
...
40043d: 00 00 add %al,(%rax)
40043f: 00 30 add %dh,(%rax)
400441: 10 60 00 adc %ah,0x0(%rax)
400444: 00 00 add %al,(%rax)
400446: 00 00 add %al,(%rax)
400448: 07 (bad)
400449: 00 00 add %al,(%rax)
40044b: 00 04 00 add %al,(%rax,%rax,1)
...
400456: 00 00 add %al,(%rax)
400458: 38 10 cmp %dl,(%rax)
40045a: 60 (bad)
40045b: 00 00 add %al,(%rax)
40045d: 00 00 add %al,(%rax)
40045f: 00 07 add %al,(%rdi)
400461: 00 00 add %al,(%rax)
400463: 00 06 add %al,(%rsi)
...
Disassembly of section .init:
0000000000400470 <_init>:
400470: 48 83 ec 08 sub $0x8,%rsp
400474: 48 8b 05 7d 0b 20 00 mov 0x200b7d(%rip),%rax # 600ff8 <_DYNAMIC+0x1d0>
40047b: 48 85 c0 test %rax,%rax
40047e: 74 05 je 400485 <_init+0x15>
400480: e8 6b 00 00 00 callq 4004f0 <sleep@plt+0x10>
400485: 48 83 c4 08 add $0x8,%rsp
400489: c3 retq
Disassembly of section .plt:
0000000000400490 <putchar@plt-0x10>:
400490: ff 35 72 0b 20 00 pushq 0x200b72(%rip) # 601008 <_GLOBAL_OFFSET_TABLE_+0x8>
400496: ff 25 74 0b 20 00 jmpq *0x200b74(%rip) # 601010 <_GLOBAL_OFFSET_TABLE_+0x10>
40049c: 0f 1f 40 00 nopl 0x0(%rax)
00000000004004a0 <putchar@plt>:
4004a0: ff 25 72 0b 20 00 jmpq *0x200b72(%rip) # 601018 <_GLOBAL_OFFSET_TABLE_+0x18>
4004a6: 68 00 00 00 00 pushq $0x0
4004ab: e9 e0 ff ff ff jmpq 400490 <_init+0x20>
00000000004004b0 <puts@plt>:
4004b0: ff 25 6a 0b 20 00 jmpq *0x200b6a(%rip) # 601020 <_GLOBAL_OFFSET_TABLE_+0x20>
4004b6: 68 01 00 00 00 pushq $0x1
4004bb: e9 d0 ff ff ff jmpq 400490 <_init+0x20>
00000000004004c0 <printf@plt>:
4004c0: ff 25 62 0b 20 00 jmpq *0x200b62(%rip) # 601028 <_GLOBAL_OFFSET_TABLE_+0x28>
4004c6: 68 02 00 00 00 pushq $0x2
4004cb: e9 c0 ff ff ff jmpq 400490 <_init+0x20>
00000000004004d0 <__libc_start_main@plt>:
4004d0: ff 25 5a 0b 20 00 jmpq *0x200b5a(%rip) # 601030 <_GLOBAL_OFFSET_TABLE_+0x30>
4004d6: 68 03 00 00 00 pushq $0x3
4004db: e9 b0 ff ff ff jmpq 400490 <_init+0x20>
00000000004004e0 <sleep@plt>:
4004e0: ff 25 52 0b 20 00 jmpq *0x200b52(%rip) # 601038 <_GLOBAL_OFFSET_TABLE_+0x38>
4004e6: 68 04 00 00 00 pushq $0x4
4004eb: e9 a0 ff ff ff jmpq 400490 <_init+0x20>
Disassembly of section .plt.got:
00000000004004f0 <.plt.got>:
4004f0: ff 25 02 0b 20 00 jmpq *0x200b02(%rip) # 600ff8 <_DYNAMIC+0x1d0>
4004f6: 66 90 xchg %ax,%ax
Disassembly of section .text:
0000000000400500 <_start>:
400500: 31 ed xor %ebp,%ebp
400502: 49 89 d1 mov %rdx,%r9
400505: 5e pop %rsi
400506: 48 89 e2 mov %rsp,%rdx
400509: 48 83 e4 f0 and $0xfffffffffffffff0,%rsp
40050d: 50 push %rax
40050e: 54 push %rsp
40050f: 49 c7 c0 f0 08 40 00 mov $0x4008f0,%r8
400516: 48 c7 c1 80 08 40 00 mov $0x400880,%rcx
40051d: 48 c7 c7 b9 06 40 00 mov $0x4006b9,%rdi
400524: e8 a7 ff ff ff callq 4004d0 <__libc_start_main@plt>
400529: f4 hlt
40052a: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
0000000000400530 <deregister_tm_clones>:
400530: b8 67 10 60 00 mov $0x601067,%eax
400535: 55 push %rbp
400536: 48 2d 60 10 60 00 sub $0x601060,%rax
40053c: 48 83 f8 0e cmp $0xe,%rax
400540: 48 89 e5 mov %rsp,%rbp
400543: 76 1b jbe 400560 <deregister_tm_clones+0x30>
400545: b8 00 00 00 00 mov $0x0,%eax
40054a: 48 85 c0 test %rax,%rax
40054d: 74 11 je 400560 <deregister_tm_clones+0x30>
40054f: 5d pop %rbp
400550: bf 60 10 60 00 mov $0x601060,%edi
400555: ff e0 jmpq *%rax
400557: 66 0f 1f 84 00 00 00 nopw 0x0(%rax,%rax,1)
40055e: 00 00
400560: 5d pop %rbp
400561: c3 retq
400562: 0f 1f 40 00 nopl 0x0(%rax)
400566: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
40056d: 00 00 00
0000000000400570 <register_tm_clones>:
400570: be 60 10 60 00 mov $0x601060,%esi
400575: 55 push %rbp
400576: 48 81 ee 60 10 60 00 sub $0x601060,%rsi
40057d: 48 c1 fe 03 sar $0x3,%rsi
400581: 48 89 e5 mov %rsp,%rbp
400584: 48 89 f0 mov %rsi,%rax
400587: 48 c1 e8 3f shr $0x3f,%rax
40058b: 48 01 c6 add %rax,%rsi
40058e: 48 d1 fe sar %rsi
400591: 74 15 je 4005a8 <register_tm_clones+0x38>
400593: b8 00 00 00 00 mov $0x0,%eax
400598: 48 85 c0 test %rax,%rax
40059b: 74 0b je 4005a8 <register_tm_clones+0x38>
40059d: 5d pop %rbp
40059e: bf 60 10 60 00 mov $0x601060,%edi
4005a3: ff e0 jmpq *%rax
4005a5: 0f 1f 00 nopl (%rax)
4005a8: 5d pop %rbp
4005a9: c3 retq
4005aa: 66 0f 1f 44 00 00 nopw 0x0(%rax,%rax,1)
00000000004005b0 <__do_global_dtors_aux>:
4005b0: 80 3d a9 0a 20 00 00 cmpb $0x0,0x200aa9(%rip) # 601060 <__TMC_END__>
4005b7: 75 11 jne 4005ca <__do_global_dtors_aux+0x1a>
4005b9: 55 push %rbp
4005ba: 48 89 e5 mov %rsp,%rbp
4005bd: e8 6e ff ff ff callq 400530 <deregister_tm_clones>
4005c2: 5d pop %rbp
4005c3: c6 05 96 0a 20 00 01 movb $0x1,0x200a96(%rip) # 601060 <__TMC_END__>
4005ca: f3 c3 repz retq
4005cc: 0f 1f 40 00 nopl 0x0(%rax)
00000000004005d0 <frame_dummy>:
4005d0: bf 20 0e 60 00 mov $0x600e20,%edi
4005d5: 48 83 3f 00 cmpq $0x0,(%rdi)
4005d9: 75 05 jne 4005e0 <frame_dummy+0x10>
4005db: eb 93 jmp 400570 <register_tm_clones>
4005dd: 0f 1f 00 nopl (%rax)
4005e0: b8 00 00 00 00 mov $0x0,%eax
4005e5: 48 85 c0 test %rax,%rax
4005e8: 74 f1 je 4005db <frame_dummy+0xb>
4005ea: 55 push %rbp
4005eb: 48 89 e5 mov %rsp,%rbp
4005ee: ff d0 callq *%rax
4005f0: 5d pop %rbp
4005f1: e9 7a ff ff ff jmpq 400570 <register_tm_clones>
00000000004005f6 <func>:
static int s;
int m = 6;
const char *string = "nece to meet you";
const char array[] = "glad to talk to you";
int func()
{
4005f6: 55 push %rbp
4005f7: 48 89 e5 mov %rsp,%rbp
printf("func called\n");
4005fa: bf 44 09 40 00 mov $0x400944,%edi
4005ff: e8 ac fe ff ff callq 4004b0 <puts@plt>
return 0;
400604: b8 00 00 00 00 mov $0x0,%eax
}
400609: 5d pop %rbp
40060a: c3 retq
000000000040060b <dumphex>:
int dumphex(unsigned char *start,unsigned int length)
{
40060b: 55 push %rbp
40060c: 48 89 e5 mov %rsp,%rbp
40060f: 48 83 ec 20 sub $0x20,%rsp
400613: 48 89 7d e8 mov %rdi,-0x18(%rbp)
400617: 89 75 e4 mov %esi,-0x1c(%rbp)
int i = 0;
40061a: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%rbp)
int len = length;
400621: 8b 45 e4 mov -0x1c(%rbp),%eax
400624: 89 45 f4 mov %eax,-0xc(%rbp)
unsigned char *p = NULL;
400627: 48 c7 45 f8 00 00 00 movq $0x0,-0x8(%rbp)
40062e: 00
p = start;
40062f: 48 8b 45 e8 mov -0x18(%rbp),%rax
400633: 48 89 45 f8 mov %rax,-0x8(%rbp)
for (i = 0;i < len;i++) {
400637: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%rbp)
40063e: eb 6e jmp 4006ae <dumphex+0xa3>
if ((i % 16) == 0)
400640: 8b 45 f0 mov -0x10(%rbp),%eax
400643: 83 e0 0f and $0xf,%eax
400646: 85 c0 test %eax,%eax
400648: 75 1f jne 400669 <dumphex+0x5e>
printf("0x%p:",(p+i));
40064a: 8b 45 f0 mov -0x10(%rbp),%eax
40064d: 48 63 d0 movslq %eax,%rdx
400650: 48 8b 45 f8 mov -0x8(%rbp),%rax
400654: 48 01 d0 add %rdx,%rax
400657: 48 89 c6 mov %rax,%rsi
40065a: bf 50 09 40 00 mov $0x400950,%edi
40065f: b8 00 00 00 00 mov $0x0,%eax
400664: e8 57 fe ff ff callq 4004c0 <printf@plt>
printf("%02x ",*(p+i));
400669: 8b 45 f0 mov -0x10(%rbp),%eax
40066c: 48 63 d0 movslq %eax,%rdx
40066f: 48 8b 45 f8 mov -0x8(%rbp),%rax
400673: 48 01 d0 add %rdx,%rax
400676: 0f b6 00 movzbl (%rax),%eax
400679: 0f b6 c0 movzbl %al,%eax
40067c: 89 c6 mov %eax,%esi
40067e: bf 56 09 40 00 mov $0x400956,%edi
400683: b8 00 00 00 00 mov $0x0,%eax
400688: e8 33 fe ff ff callq 4004c0 <printf@plt>
if ((i % 16) == 15)
40068d: 8b 45 f0 mov -0x10(%rbp),%eax
400690: 99 cltd
400691: c1 ea 1c shr $0x1c,%edx
400694: 01 d0 add %edx,%eax
400696: 83 e0 0f and $0xf,%eax
400699: 29 d0 sub %edx,%eax
40069b: 83 f8 0f cmp $0xf,%eax
40069e: 75 0a jne 4006aa <dumphex+0x9f>
printf("\n");
4006a0: bf 0a 00 00 00 mov $0xa,%edi
4006a5: e8 f6 fd ff ff callq 4004a0 <putchar@plt>
int i = 0;
int len = length;
unsigned char *p = NULL;
p = start;
for (i = 0;i < len;i++) {
4006aa: 83 45 f0 01 addl $0x1,-0x10(%rbp)
4006ae: 8b 45 f0 mov -0x10(%rbp),%eax
4006b1: 3b 45 f4 cmp -0xc(%rbp),%eax
4006b4: 7c 8a jl 400640 <dumphex+0x35>
if ((i % 16) == 15)
printf("\n");
}
}
4006b6: 90 nop
4006b7: c9 leaveq
4006b8: c3 retq
00000000004006b9 <main>:
typedef int (*ft)();
int main()
{
4006b9: 55 push %rbp
4006ba: 48 89 e5 mov %rsp,%rbp
4006bd: 48 83 ec 20 sub $0x20,%rsp
int a = 1;
4006c1: c7 45 ec 01 00 00 00 movl $0x1,-0x14(%rbp)
int b = 2;
4006c8: c7 45 f0 02 00 00 00 movl $0x2,-0x10(%rbp)
int c = a+b;
4006cf: 8b 55 ec mov -0x14(%rbp),%edx
4006d2: 8b 45 f0 mov -0x10(%rbp),%eax
4006d5: 01 d0 add %edx,%eax
4006d7: 89 45 f4 mov %eax,-0xc(%rbp)
static int count;
ft pf = NULL;
4006da: 48 c7 45 f8 00 00 00 movq $0x0,-0x8(%rbp)
4006e1: 00
pf = (ft )0x4005f6;
4006e2: 48 c7 45 f8 f6 05 40 movq $0x4005f6,-0x8(%rbp)
4006e9: 00
dumphex((unsigned char *)0x600000,0x1000);
4006ea: be 00 10 00 00 mov $0x1000,%esi
4006ef: bf 00 00 60 00 mov $0x600000,%edi
4006f4: e8 12 ff ff ff callq 40060b <dumphex>
dumphex((unsigned char *)0x400000,0x1000);
4006f9: be 00 10 00 00 mov $0x1000,%esi
4006fe: bf 00 00 40 00 mov $0x400000,%edi
400703: e8 03 ff ff ff callq 40060b <dumphex>
dumphex((unsigned char *)0x601000,0x1000);
400708: be 00 10 00 00 mov $0x1000,%esi
40070d: bf 00 10 60 00 mov $0x601000,%edi
400712: e8 f4 fe ff ff callq 40060b <dumphex>
while (1) {
count++;
400717: 8b 05 4b 09 20 00 mov 0x20094b(%rip),%eax # 601068 <count.2910>
40071d: 83 c0 01 add $0x1,%eax
400720: 89 05 42 09 20 00 mov %eax,0x200942(%rip) # 601068 <count.2910>
g = count + 4;
400726: 8b 05 3c 09 20 00 mov 0x20093c(%rip),%eax # 601068 <count.2910>
40072c: 83 c0 04 add $0x4,%eax
40072f: 89 05 37 09 20 00 mov %eax,0x200937(%rip) # 60106c <g>
printf("=============begin================\n");
400735: bf 60 09 40 00 mov $0x400960,%edi
40073a: e8 71 fd ff ff callq 4004b0 <puts@plt>
printf("count = %d\n",count);
40073f: 8b 05 23 09 20 00 mov 0x200923(%rip),%eax # 601068 <count.2910>
400745: 89 c6 mov %eax,%esi
400747: bf 83 09 40 00 mov $0x400983,%edi
40074c: b8 00 00 00 00 mov $0x0,%eax
400751: e8 6a fd ff ff callq 4004c0 <printf@plt>
printf("main %p\n",&main);
400756: be b9 06 40 00 mov $0x4006b9,%esi
40075b: bf 8f 09 40 00 mov $0x40098f,%edi
400760: b8 00 00 00 00 mov $0x0,%eax
400765: e8 56 fd ff ff callq 4004c0 <printf@plt>
printf("g addr %p,value %d\n",&g, g);
40076a: 8b 05 fc 08 20 00 mov 0x2008fc(%rip),%eax # 60106c <g>
400770: 89 c2 mov %eax,%edx
400772: be 6c 10 60 00 mov $0x60106c,%esi
400777: bf 98 09 40 00 mov $0x400998,%edi
40077c: b8 00 00 00 00 mov $0x0,%eax
400781: e8 3a fd ff ff callq 4004c0 <printf@plt>
printf("f addr %p, value %d\n",&f,f);
400786: b8 00 00 00 00 mov $0x0,%eax
40078b: 89 c2 mov %eax,%edx
40078d: be 10 09 40 00 mov $0x400910,%esi
400792: bf ac 09 40 00 mov $0x4009ac,%edi
400797: b8 00 00 00 00 mov $0x0,%eax
40079c: e8 1f fd ff ff callq 4004c0 <printf@plt>
printf("m addr %p, value %d\n",&m,m);
4007a1: 8b 05 a9 08 20 00 mov 0x2008a9(%rip),%eax # 601050 <m>
4007a7: 89 c2 mov %eax,%edx
4007a9: be 50 10 60 00 mov $0x601050,%esi
4007ae: bf c1 09 40 00 mov $0x4009c1,%edi
4007b3: b8 00 00 00 00 mov $0x0,%eax
4007b8: e8 03 fd ff ff callq 4004c0 <printf@plt>
printf("func addr %p\n",&func);
4007bd: be f6 05 40 00 mov $0x4005f6,%esi
4007c2: bf d6 09 40 00 mov $0x4009d6,%edi
4007c7: b8 00 00 00 00 mov $0x0,%eax
4007cc: e8 ef fc ff ff callq 4004c0 <printf@plt>
printf("string addr %p, content %s value 0x%llx\n",&string,string,(unsigned long long )string);
4007d1: 48 8b 05 80 08 20 00 mov 0x200880(%rip),%rax # 601058 <string>
4007d8: 48 89 c2 mov %rax,%rdx
4007db: 48 8b 05 76 08 20 00 mov 0x200876(%rip),%rax # 601058 <string>
4007e2: 48 89 d1 mov %rdx,%rcx
4007e5: 48 89 c2 mov %rax,%rdx
4007e8: be 58 10 60 00 mov $0x601058,%esi
4007ed: bf e8 09 40 00 mov $0x4009e8,%edi
4007f2: b8 00 00 00 00 mov $0x0,%eax
4007f7: e8 c4 fc ff ff callq 4004c0 <printf@plt>
printf("s addr %p, s value %d\n",&s,s);
4007fc: 8b 05 62 08 20 00 mov 0x200862(%rip),%eax # 601064 <s>
400802: 89 c2 mov %eax,%edx
400804: be 64 10 60 00 mov $0x601064,%esi
400809: bf 11 0a 40 00 mov $0x400a11,%edi
40080e: b8 00 00 00 00 mov $0x0,%eax
400813: e8 a8 fc ff ff callq 4004c0 <printf@plt>
printf("string again %s\n",(char *)0x400914);
400818: be 14 09 40 00 mov $0x400914,%esi
40081d: bf 28 0a 40 00 mov $0x400a28,%edi
400822: b8 00 00 00 00 mov $0x0,%eax
400827: e8 94 fc ff ff callq 4004c0 <printf@plt>
printf("array addr %p,content %s value 0x%llx\n",&array,array,(unsigned long long)array);
40082c: b8 30 09 40 00 mov $0x400930,%eax
400831: 48 89 c1 mov %rax,%rcx
400834: ba 30 09 40 00 mov $0x400930,%edx
400839: be 30 09 40 00 mov $0x400930,%esi
40083e: bf 40 0a 40 00 mov $0x400a40,%edi
400843: b8 00 00 00 00 mov $0x0,%eax
400848: e8 73 fc ff ff callq 4004c0 <printf@plt>
pf();
40084d: 48 8b 55 f8 mov -0x8(%rbp),%rdx
400851: b8 00 00 00 00 mov $0x0,%eax
400856: ff d2 callq *%rdx
printf("=============end================\n");
400858: bf 68 0a 40 00 mov $0x400a68,%edi
40085d: e8 4e fc ff ff callq 4004b0 <puts@plt>
sleep(10);
400862: bf 0a 00 00 00 mov $0xa,%edi
400867: e8 74 fc ff ff callq 4004e0 <sleep@plt>
}
40086c: e9 a6 fe ff ff jmpq 400717 <main+0x5e>
400871: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
400878: 00 00 00
40087b: 0f 1f 44 00 00 nopl 0x0(%rax,%rax,1)
0000000000400880 <__libc_csu_init>:
400880: 41 57 push %r15
400882: 41 56 push %r14
400884: 41 89 ff mov %edi,%r15d
400887: 41 55 push %r13
400889: 41 54 push %r12
40088b: 4c 8d 25 7e 05 20 00 lea 0x20057e(%rip),%r12 # 600e10 <__frame_dummy_init_array_entry>
400892: 55 push %rbp
400893: 48 8d 2d 7e 05 20 00 lea 0x20057e(%rip),%rbp # 600e18 <__init_array_end>
40089a: 53 push %rbx
40089b: 49 89 f6 mov %rsi,%r14
40089e: 49 89 d5 mov %rdx,%r13
4008a1: 4c 29 e5 sub %r12,%rbp
4008a4: 48 83 ec 08 sub $0x8,%rsp
4008a8: 48 c1 fd 03 sar $0x3,%rbp
4008ac: e8 bf fb ff ff callq 400470 <_init>
4008b1: 48 85 ed test %rbp,%rbp
4008b4: 74 20 je 4008d6 <__libc_csu_init+0x56>
4008b6: 31 db xor %ebx,%ebx
4008b8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1)
4008bf: 00
4008c0: 4c 89 ea mov %r13,%rdx
4008c3: 4c 89 f6 mov %r14,%rsi
4008c6: 44 89 ff mov %r15d,%edi
4008c9: 41 ff 14 dc callq *(%r12,%rbx,8)
4008cd: 48 83 c3 01 add $0x1,%rbx
4008d1: 48 39 eb cmp %rbp,%rbx
4008d4: 75 ea jne 4008c0 <__libc_csu_init+0x40>
4008d6: 48 83 c4 08 add $0x8,%rsp
4008da: 5b pop %rbx
4008db: 5d pop %rbp
4008dc: 41 5c pop %r12
4008de: 41 5d pop %r13
4008e0: 41 5e pop %r14
4008e2: 41 5f pop %r15
4008e4: c3 retq
4008e5: 90 nop
4008e6: 66 2e 0f 1f 84 00 00 nopw %cs:0x0(%rax,%rax,1)
4008ed: 00 00 00
00000000004008f0 <__libc_csu_fini>:
4008f0: f3 c3 repz retq
Disassembly of section .fini:
00000000004008f4 <_fini>:
4008f4: 48 83 ec 08 sub $0x8,%rsp
4008f8: 48 83 c4 08 add $0x8,%rsp
4008fc: c3 retq
Disassembly of section .rodata:
0000000000400900 <_IO_stdin_used>:
400900: 01 00 add %eax,(%rax)
400902: 02 00 add (%rax),%al
...
0000000000400910 <f>:
400910: 00 00 add %al,(%rax)
400912: 00 00 add %al,(%rax)
400914: 6e outsb %ds:(%rsi),(%dx)
400915: 65 63 65 20 movslq %gs:0x20(%rbp),%esp
400919: 74 6f je 40098a <array+0x5a>
40091b: 20 6d 65 and %ch,0x65(%rbp)
40091e: 65 74 20 gs je 400941 <array+0x11>
400921: 79 6f jns 400992 <array+0x62>
400923: 75 00 jne 400925 <f+0x15>
...
0000000000400930 <array>:
400930: 67 6c insb (%dx),%es:(%edi)
400932: 61 (bad)
400933: 64 20 74 6f 20 and %dh,%fs:0x20(%rdi,%rbp,2)
400938: 74 61 je 40099b <array+0x6b>
40093a: 6c insb (%dx),%es:(%rdi)
40093b: 6b 20 74 imul $0x74,(%rax),%esp
40093e: 6f outsl %ds:(%rsi),(%dx)
40093f: 20 79 6f and %bh,0x6f(%rcx)
400942: 75 00 jne 400944 <array+0x14>
400944: 66 75 6e data16 jne 4009b5 <array+0x85>
400947: 63 20 movslq (%rax),%esp
400949: 63 61 6c movslq 0x6c(%rcx),%esp
40094c: 6c insb (%dx),%es:(%rdi)
40094d: 65 64 00 30 gs add %dh,%fs:(%rax)
400951: 78 25 js 400978 <array+0x48>
400953: 70 3a jo 40098f <array+0x5f>
400955: 00 25 30 32 78 20 add %ah,0x20783230(%rip) # 20b83b8b <_end+0x20582b1b>
40095b: 00 00 add %al,(%rax)
40095d: 00 00 add %al,(%rax)
40095f: 00 3d 3d 3d 3d 3d add %bh,0x3d3d3d3d(%rip) # 3d7d46a2 <_end+0x3d1d3632>
400965: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
40096a: 3d 3d 3d 62 65 cmp $0x65623d3d,%eax
40096f: 67 69 6e 3d 3d 3d 3d imul $0x3d3d3d3d,0x3d(%esi),%ebp
400976: 3d
400977: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
40097c: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
400981: 3d 00 63 6f 75 cmp $0x756f6300,%eax
400986: 6e outsb %ds:(%rsi),(%dx)
400987: 74 20 je 4009a9 <array+0x79>
400989: 3d 20 25 64 0a cmp $0xa642520,%eax
40098e: 00 6d 61 add %ch,0x61(%rbp)
400991: 69 6e 20 25 70 0a 00 imul $0xa7025,0x20(%rsi),%ebp
400998: 67 20 61 64 and %ah,0x64(%ecx)
40099c: 64 72 20 fs jb 4009bf <array+0x8f>
40099f: 25 70 2c 76 61 and $0x61762c70,%eax
4009a4: 6c insb (%dx),%es:(%rdi)
4009a5: 75 65 jne 400a0c <array+0xdc>
4009a7: 20 25 64 0a 00 66 and %ah,0x66000a64(%rip) # 66401411 <_end+0x65e003a1>
4009ad: 20 61 64 and %ah,0x64(%rcx)
4009b0: 64 72 20 fs jb 4009d3 <array+0xa3>
4009b3: 25 70 2c 20 76 and $0x76202c70,%eax
4009b8: 61 (bad)
4009b9: 6c insb (%dx),%es:(%rdi)
4009ba: 75 65 jne 400a21 <array+0xf1>
4009bc: 20 25 64 0a 00 6d and %ah,0x6d000a64(%rip) # 6d401426 <_end+0x6ce003b6>
4009c2: 20 61 64 and %ah,0x64(%rcx)
4009c5: 64 72 20 fs jb 4009e8 <array+0xb8>
4009c8: 25 70 2c 20 76 and $0x76202c70,%eax
4009cd: 61 (bad)
4009ce: 6c insb (%dx),%es:(%rdi)
4009cf: 75 65 jne 400a36 <array+0x106>
4009d1: 20 25 64 0a 00 66 and %ah,0x66000a64(%rip) # 6640143b <_end+0x65e003cb>
4009d7: 75 6e jne 400a47 <array+0x117>
4009d9: 63 20 movslq (%rax),%esp
4009db: 61 (bad)
4009dc: 64 64 72 20 fs fs jb 400a00 <array+0xd0>
4009e0: 25 70 0a 00 00 and $0xa70,%eax
4009e5: 00 00 add %al,(%rax)
4009e7: 00 73 74 add %dh,0x74(%rbx)
4009ea: 72 69 jb 400a55 <array+0x125>
4009ec: 6e outsb %ds:(%rsi),(%dx)
4009ed: 67 20 61 64 and %ah,0x64(%ecx)
4009f1: 64 72 20 fs jb 400a14 <array+0xe4>
4009f4: 25 70 2c 20 63 and $0x63202c70,%eax
4009f9: 6f outsl %ds:(%rsi),(%dx)
4009fa: 6e outsb %ds:(%rsi),(%dx)
4009fb: 74 65 je 400a62 <array+0x132>
4009fd: 6e outsb %ds:(%rsi),(%dx)
4009fe: 74 20 je 400a20 <array+0xf0>
400a00: 25 73 20 76 61 and $0x61762073,%eax
400a05: 6c insb (%dx),%es:(%rdi)
400a06: 75 65 jne 400a6d <array+0x13d>
400a08: 20 30 and %dh,(%rax)
400a0a: 78 25 js 400a31 <array+0x101>
400a0c: 6c insb (%dx),%es:(%rdi)
400a0d: 6c insb (%dx),%es:(%rdi)
400a0e: 78 0a js 400a1a <array+0xea>
400a10: 00 73 20 add %dh,0x20(%rbx)
400a13: 61 (bad)
400a14: 64 64 72 20 fs fs jb 400a38 <array+0x108>
400a18: 25 70 2c 20 73 and $0x73202c70,%eax
400a1d: 20 76 61 and %dh,0x61(%rsi)
400a20: 6c insb (%dx),%es:(%rdi)
400a21: 75 65 jne 400a88 <array+0x158>
400a23: 20 25 64 0a 00 73 and %ah,0x73000a64(%rip) # 7340148d <_end+0x72e0041d>
400a29: 74 72 je 400a9d <__GNU_EH_FRAME_HDR+0x11>
400a2b: 69 6e 67 20 61 67 61 imul $0x61676120,0x67(%rsi),%ebp
400a32: 69 6e 20 25 73 0a 00 imul $0xa7325,0x20(%rsi),%ebp
400a39: 00 00 add %al,(%rax)
400a3b: 00 00 add %al,(%rax)
400a3d: 00 00 add %al,(%rax)
400a3f: 00 61 72 add %ah,0x72(%rcx)
400a42: 72 61 jb 400aa5 <__GNU_EH_FRAME_HDR+0x19>
400a44: 79 20 jns 400a66 <array+0x136>
400a46: 61 (bad)
400a47: 64 64 72 20 fs fs jb 400a6b <array+0x13b>
400a4b: 25 70 2c 63 6f and $0x6f632c70,%eax
400a50: 6e outsb %ds:(%rsi),(%dx)
400a51: 74 65 je 400ab8 <__GNU_EH_FRAME_HDR+0x2c>
400a53: 6e outsb %ds:(%rsi),(%dx)
400a54: 74 20 je 400a76 <array+0x146>
400a56: 25 73 20 76 61 and $0x61762073,%eax
400a5b: 6c insb (%dx),%es:(%rdi)
400a5c: 75 65 jne 400ac3 <__GNU_EH_FRAME_HDR+0x37>
400a5e: 20 30 and %dh,(%rax)
400a60: 78 25 js 400a87 <array+0x157>
400a62: 6c insb (%dx),%es:(%rdi)
400a63: 6c insb (%dx),%es:(%rdi)
400a64: 78 0a js 400a70 <array+0x140>
400a66: 00 00 add %al,(%rax)
400a68: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
400a6d: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
400a72: 3d 3d 3d 65 6e cmp $0x6e653d3d,%eax
400a77: 64 3d 3d 3d 3d 3d fs cmp $0x3d3d3d3d,%eax
400a7d: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
400a82: 3d 3d 3d 3d 3d cmp $0x3d3d3d3d,%eax
400a87: 3d .byte 0x3d
...
Disassembly of section .eh_frame_hdr:
0000000000400a8c <__GNU_EH_FRAME_HDR>:
400a8c: 01 1b add %ebx,(%rbx)
400a8e: 03 3b add (%rbx),%edi
400a90: 40 00 00 add %al,(%rax)
400a93: 00 07 add %al,(%rdi)
400a95: 00 00 add %al,(%rax)
400a97: 00 04 fa add %al,(%rdx,%rdi,8)
400a9a: ff (bad)
400a9b: ff 8c 00 00 00 74 fa decl -0x58c0000(%rax,%rax,1)
400aa2: ff (bad)
400aa3: ff 5c 00 00 lcall *0x0(%rax,%rax,1)
400aa7: 00 6a fb add %ch,-0x5(%rdx)
400aaa: ff (bad)
400aab: ff b4 00 00 00 7f fb pushq -0x4810000(%rax,%rax,1)
400ab2: ff (bad)
400ab3: ff d4 callq *%rsp
400ab5: 00 00 add %al,(%rax)
400ab7: 00 2d fc ff ff f4 add %ch,-0xb000004(%rip) # fffffffff5400ab9 <_end+0xfffffffff4dffa49>
400abd: 00 00 add %al,(%rax)
400abf: 00 f4 add %dh,%ah
400ac1: fd std
400ac2: ff (bad)
400ac3: ff 14 01 callq *(%rcx,%rax,1)
400ac6: 00 00 add %al,(%rax)
400ac8: 64 fe fs (bad)
400aca: ff (bad)
400acb: ff 5c 01 00 lcall *0x0(%rcx,%rax,1)
...
Disassembly of section .eh_frame:
0000000000400ad0 <__FRAME_END__-0x130>:
400ad0: 14 00 adc $0x0,%al
400ad2: 00 00 add %al,(%rax)
400ad4: 00 00 add %al,(%rax)
400ad6: 00 00 add %al,(%rax)
400ad8: 01 7a 52 add %edi,0x52(%rdx)
400adb: 00 01 add %al,(%rcx)
400add: 78 10 js 400aef <__GNU_EH_FRAME_HDR+0x63>
400adf: 01 1b add %ebx,(%rbx)
400ae1: 0c 07 or $0x7,%al
400ae3: 08 90 01 07 10 14 or %dl,0x14100701(%rax)
400ae9: 00 00 add %al,(%rax)
400aeb: 00 1c 00 add %bl,(%rax,%rax,1)
400aee: 00 00 add %al,(%rax)
400af0: 10 fa adc %bh,%dl
400af2: ff (bad)
400af3: ff 2a ljmp *(%rdx)
...
400afd: 00 00 add %al,(%rax)
400aff: 00 14 00 add %dl,(%rax,%rax,1)
400b02: 00 00 add %al,(%rax)
400b04: 00 00 add %al,(%rax)
400b06: 00 00 add %al,(%rax)
400b08: 01 7a 52 add %edi,0x52(%rdx)
400b0b: 00 01 add %al,(%rcx)
400b0d: 78 10 js 400b1f <__GNU_EH_FRAME_HDR+0x93>
400b0f: 01 1b add %ebx,(%rbx)
400b11: 0c 07 or $0x7,%al
400b13: 08 90 01 00 00 24 or %dl,0x24000001(%rax)
400b19: 00 00 add %al,(%rax)
400b1b: 00 1c 00 add %bl,(%rax,%rax,1)
400b1e: 00 00 add %al,(%rax)
400b20: 70 f9 jo 400b1b <__GNU_EH_FRAME_HDR+0x8f>
400b22: ff (bad)
400b23: ff 60 00 jmpq *0x0(%rax)
400b26: 00 00 add %al,(%rax)
400b28: 00 0e add %cl,(%rsi)
400b2a: 10 46 0e adc %al,0xe(%rsi)
400b2d: 18 4a 0f sbb %cl,0xf(%rdx)
400b30: 0b 77 08 or 0x8(%rdi),%esi
400b33: 80 00 3f addb $0x3f,(%rax)
400b36: 1a 3b sbb (%rbx),%bh
400b38: 2a 33 sub (%rbx),%dh
400b3a: 24 22 and $0x22,%al
400b3c: 00 00 add %al,(%rax)
400b3e: 00 00 add %al,(%rax)
400b40: 1c 00 sbb $0x0,%al
400b42: 00 00 add %al,(%rax)
400b44: 44 00 00 add %r8b,(%rax)
400b47: 00 ae fa ff ff 15 add %ch,0x15fffffa(%rsi)
400b4d: 00 00 add %al,(%rax)
400b4f: 00 00 add %al,(%rax)
400b51: 41 0e rex.B (bad)
400b53: 10 86 02 43 0d 06 adc %al,0x60d4302(%rsi)
400b59: 50 push %rax
400b5a: 0c 07 or $0x7,%al
400b5c: 08 00 or %al,(%rax)
400b5e: 00 00 add %al,(%rax)
400b60: 1c 00 sbb $0x0,%al
400b62: 00 00 add %al,(%rax)
400b64: 64 00 00 add %al,%fs:(%rax)
400b67: 00 a3 fa ff ff ae add %ah,-0x51000006(%rbx)
400b6d: 00 00 add %al,(%rax)
400b6f: 00 00 add %al,(%rax)
400b71: 41 0e rex.B (bad)
400b73: 10 86 02 43 0d 06 adc %al,0x60d4302(%rsi)
400b79: 02 a9 0c 07 08 00 add 0x8070c(%rcx),%ch
400b7f: 00 1c 00 add %bl,(%rax,%rax,1)
400b82: 00 00 add %al,(%rax)
400b84: 84 00 test %al,(%rax)
400b86: 00 00 add %al,(%rax)
400b88: 31 fb xor %edi,%ebx
400b8a: ff (bad)
400b8b: ff (bad)
400b8c: b8 01 00 00 00 mov $0x1,%eax
400b91: 41 0e rex.B (bad)
400b93: 10 86 02 43 0d 06 adc %al,0x60d4302(%rsi)
400b99: 00 00 add %al,(%rax)
400b9b: 00 00 add %al,(%rax)
400b9d: 00 00 add %al,(%rax)
400b9f: 00 44 00 00 add %al,0x0(%rax,%rax,1)
400ba3: 00 a4 00 00 00 d8 fc add %ah,-0x3280000(%rax,%rax,1)
400baa: ff (bad)
400bab: ff 65 00 jmpq *0x0(%rbp)
400bae: 00 00 add %al,(%rax)
400bb0: 00 42 0e add %al,0xe(%rdx)
400bb3: 10 8f 02 42 0e 18 adc %cl,0x180e4202(%rdi)
400bb9: 8e 03 mov (%rbx),%es
400bbb: 45 0e rex.RB (bad)
400bbd: 20 8d 04 42 0e 28 and %cl,0x280e4204(%rbp)
400bc3: 8c 05 48 0e 30 86 mov %es,-0x79cff1b8(%rip) # ffffffff86701a11 <_end+0xffffffff861009a1>
400bc9: 06 (bad)
400bca: 48 0e rex.W (bad)
400bcc: 38 83 07 4d 0e 40 cmp %al,0x400e4d07(%rbx)
400bd2: 72 0e jb 400be2 <__GNU_EH_FRAME_HDR+0x156>
400bd4: 38 41 0e cmp %al,0xe(%rcx)
400bd7: 30 41 0e xor %al,0xe(%rcx)
400bda: 28 42 0e sub %al,0xe(%rdx)
400bdd: 20 42 0e and %al,0xe(%rdx)
400be0: 18 42 0e sbb %al,0xe(%rdx)
400be3: 10 42 0e adc %al,0xe(%rdx)
400be6: 08 00 or %al,(%rax)
400be8: 14 00 adc $0x0,%al
400bea: 00 00 add %al,(%rax)
400bec: ec in (%dx),%al
400bed: 00 00 add %al,(%rax)
400bef: 00 00 add %al,(%rax)
400bf1: fd std
400bf2: ff (bad)
400bf3: ff 02 incl (%rdx)
...
0000000000400c00 <__FRAME_END__>:
400c00: 00 00 add %al,(%rax)
...
Disassembly of section .init_array:
0000000000600e10 <__frame_dummy_init_array_entry>:
600e10: d0 05 40 00 00 00 rolb 0x40(%rip) # 600e56 <_DYNAMIC+0x2e>
...
Disassembly of section .fini_array:
0000000000600e18 <__do_global_dtors_aux_fini_array_entry>:
600e18: b0 05 mov $0x5,%al
600e1a: 40 00 00 add %al,(%rax)
600e1d: 00 00 add %al,(%rax)
...
Disassembly of section .jcr:
0000000000600e20 <__JCR_END__>:
...
Disassembly of section .dynamic:
0000000000600e28 <_DYNAMIC>:
600e28: 01 00 add %eax,(%rax)
600e2a: 00 00 add %al,(%rax)
600e2c: 00 00 add %al,(%rax)
600e2e: 00 00 add %al,(%rax)
600e30: 01 00 add %eax,(%rax)
600e32: 00 00 add %al,(%rax)
600e34: 00 00 add %al,(%rax)
600e36: 00 00 add %al,(%rax)
600e38: 0c 00 or $0x0,%al
600e3a: 00 00 add %al,(%rax)
600e3c: 00 00 add %al,(%rax)
600e3e: 00 00 add %al,(%rax)
600e40: 70 04 jo 600e46 <_DYNAMIC+0x1e>
600e42: 40 00 00 add %al,(%rax)
600e45: 00 00 add %al,(%rax)
600e47: 00 0d 00 00 00 00 add %cl,0x0(%rip) # 600e4d <_DYNAMIC+0x25>
600e4d: 00 00 add %al,(%rax)
600e4f: 00 f4 add %dh,%ah
600e51: 08 40 00 or %al,0x0(%rax)
600e54: 00 00 add %al,(%rax)
600e56: 00 00 add %al,(%rax)
600e58: 19 00 sbb %eax,(%rax)
600e5a: 00 00 add %al,(%rax)
600e5c: 00 00 add %al,(%rax)
600e5e: 00 00 add %al,(%rax)
600e60: 10 0e adc %cl,(%rsi)
600e62: 60 (bad)
600e63: 00 00 add %al,(%rax)
600e65: 00 00 add %al,(%rax)
600e67: 00 1b add %bl,(%rbx)
600e69: 00 00 add %al,(%rax)
600e6b: 00 00 add %al,(%rax)
600e6d: 00 00 add %al,(%rax)
600e6f: 00 08 add %cl,(%rax)
600e71: 00 00 add %al,(%rax)
600e73: 00 00 add %al,(%rax)
600e75: 00 00 add %al,(%rax)
600e77: 00 1a add %bl,(%rdx)
600e79: 00 00 add %al,(%rax)
600e7b: 00 00 add %al,(%rax)
600e7d: 00 00 add %al,(%rax)
600e7f: 00 18 add %bl,(%rax)
600e81: 0e (bad)
600e82: 60 (bad)
600e83: 00 00 add %al,(%rax)
600e85: 00 00 add %al,(%rax)
600e87: 00 1c 00 add %bl,(%rax,%rax,1)
600e8a: 00 00 add %al,(%rax)
600e8c: 00 00 add %al,(%rax)
600e8e: 00 00 add %al,(%rax)
600e90: 08 00 or %al,(%rax)
600e92: 00 00 add %al,(%rax)
600e94: 00 00 add %al,(%rax)
600e96: 00 00 add %al,(%rax)
600e98: f5 cmc
600e99: fe (bad)
600e9a: ff 6f 00 ljmp *0x0(%rdi)
600e9d: 00 00 add %al,(%rax)
600e9f: 00 98 02 40 00 00 add %bl,0x4002(%rax)
600ea5: 00 00 add %al,(%rax)
600ea7: 00 05 00 00 00 00 add %al,0x0(%rip) # 600ead <_DYNAMIC+0x85>
600ead: 00 00 add %al,(%rax)
600eaf: 00 60 03 add %ah,0x3(%rax)
600eb2: 40 00 00 add %al,(%rax)
600eb5: 00 00 add %al,(%rax)
600eb7: 00 06 add %al,(%rsi)
600eb9: 00 00 add %al,(%rax)
600ebb: 00 00 add %al,(%rax)
600ebd: 00 00 add %al,(%rax)
600ebf: 00 b8 02 40 00 00 add %bh,0x4002(%rax)
600ec5: 00 00 add %al,(%rax)
600ec7: 00 0a add %cl,(%rdx)
600ec9: 00 00 add %al,(%rax)
600ecb: 00 00 add %al,(%rax)
600ecd: 00 00 add %al,(%rax)
600ecf: 00 52 00 add %dl,0x0(%rdx)
600ed2: 00 00 add %al,(%rax)
600ed4: 00 00 add %al,(%rax)
600ed6: 00 00 add %al,(%rax)
600ed8: 0b 00 or (%rax),%eax
600eda: 00 00 add %al,(%rax)
600edc: 00 00 add %al,(%rax)
600ede: 00 00 add %al,(%rax)
600ee0: 18 00 sbb %al,(%rax)
600ee2: 00 00 add %al,(%rax)
600ee4: 00 00 add %al,(%rax)
600ee6: 00 00 add %al,(%rax)
600ee8: 15 00 00 00 00 adc $0x0,%eax
...
600ef5: 00 00 add %al,(%rax)
600ef7: 00 03 add %al,(%rbx)
...
600f01: 10 60 00 adc %ah,0x0(%rax)
600f04: 00 00 add %al,(%rax)
600f06: 00 00 add %al,(%rax)
600f08: 02 00 add (%rax),%al
600f0a: 00 00 add %al,(%rax)
600f0c: 00 00 add %al,(%rax)
600f0e: 00 00 add %al,(%rax)
600f10: 78 00 js 600f12 <_DYNAMIC+0xea>
600f12: 00 00 add %al,(%rax)
600f14: 00 00 add %al,(%rax)
600f16: 00 00 add %al,(%rax)
600f18: 14 00 adc $0x0,%al
600f1a: 00 00 add %al,(%rax)
600f1c: 00 00 add %al,(%rax)
600f1e: 00 00 add %al,(%rax)
600f20: 07 (bad)
600f21: 00 00 add %al,(%rax)
600f23: 00 00 add %al,(%rax)
600f25: 00 00 add %al,(%rax)
600f27: 00 17 add %dl,(%rdi)
600f29: 00 00 add %al,(%rax)
600f2b: 00 00 add %al,(%rax)
600f2d: 00 00 add %al,(%rax)
600f2f: 00 f8 add %bh,%al
600f31: 03 40 00 add 0x0(%rax),%eax
600f34: 00 00 add %al,(%rax)
600f36: 00 00 add %al,(%rax)
600f38: 07 (bad)
600f39: 00 00 add %al,(%rax)
600f3b: 00 00 add %al,(%rax)
600f3d: 00 00 add %al,(%rax)
600f3f: 00 e0 add %ah,%al
600f41: 03 40 00 add 0x0(%rax),%eax
600f44: 00 00 add %al,(%rax)
600f46: 00 00 add %al,(%rax)
600f48: 08 00 or %al,(%rax)
600f4a: 00 00 add %al,(%rax)
600f4c: 00 00 add %al,(%rax)
600f4e: 00 00 add %al,(%rax)
600f50: 18 00 sbb %al,(%rax)
600f52: 00 00 add %al,(%rax)
600f54: 00 00 add %al,(%rax)
600f56: 00 00 add %al,(%rax)
600f58: 09 00 or %eax,(%rax)
600f5a: 00 00 add %al,(%rax)
600f5c: 00 00 add %al,(%rax)
600f5e: 00 00 add %al,(%rax)
600f60: 18 00 sbb %al,(%rax)
600f62: 00 00 add %al,(%rax)
600f64: 00 00 add %al,(%rax)
600f66: 00 00 add %al,(%rax)
600f68: fe (bad)
600f69: ff (bad)
600f6a: ff 6f 00 ljmp *0x0(%rdi)
600f6d: 00 00 add %al,(%rax)
600f6f: 00 c0 add %al,%al
600f71: 03 40 00 add 0x0(%rax),%eax
600f74: 00 00 add %al,(%rax)
600f76: 00 00 add %al,(%rax)
600f78: ff (bad)
600f79: ff (bad)
600f7a: ff 6f 00 ljmp *0x0(%rdi)
600f7d: 00 00 add %al,(%rax)
600f7f: 00 01 add %al,(%rcx)
600f81: 00 00 add %al,(%rax)
600f83: 00 00 add %al,(%rax)
600f85: 00 00 add %al,(%rax)
600f87: 00 f0 add %dh,%al
600f89: ff (bad)
600f8a: ff 6f 00 ljmp *0x0(%rdi)
600f8d: 00 00 add %al,(%rax)
600f8f: 00 b2 03 40 00 00 add %dh,0x4003(%rdx)
...
Disassembly of section .got:
0000000000600ff8 <.got>:
...
Disassembly of section .got.plt:
0000000000601000 <_GLOBAL_OFFSET_TABLE_>:
601000: 28 0e sub %cl,(%rsi)
601002: 60 (bad)
...
601017: 00 a6 04 40 00 00 add %ah,0x4004(%rsi)
60101d: 00 00 add %al,(%rax)
60101f: 00 b6 04 40 00 00 add %dh,0x4004(%rsi)
601025: 00 00 add %al,(%rax)
601027: 00 c6 add %al,%dh
601029: 04 40 add $0x40,%al
60102b: 00 00 add %al,(%rax)
60102d: 00 00 add %al,(%rax)
60102f: 00 d6 add %dl,%dh
601031: 04 40 add $0x40,%al
601033: 00 00 add %al,(%rax)
601035: 00 00 add %al,(%rax)
601037: 00 e6 add %ah,%dh
601039: 04 40 add $0x40,%al
60103b: 00 00 add %al,(%rax)
60103d: 00 00 add %al,(%rax)
...
Disassembly of section .data:
0000000000601040 <__data_start>:
...
0000000000601048 <__dso_handle>:
...
0000000000601050 <m>:
601050: 06 (bad)
601051: 00 00 add %al,(%rax)
601053: 00 00 add %al,(%rax)
601055: 00 00 add %al,(%rax)
...
0000000000601058 <string>:
601058: 14 09 adc $0x9,%al
60105a: 40 00 00 add %al,(%rax)
60105d: 00 00 add %al,(%rax)
...
Disassembly of section .bss:
0000000000601060 <__bss_start>:
601060: 00 00 add %al,(%rax)
...
0000000000601064 <s>:
601064: 00 00 add %al,(%rax)
...
0000000000601068 <count.2910>:
601068: 00 00 add %al,(%rax)
...
000000000060106c <g>:
60106c: 00 00 add %al,(%rax)
...
Disassembly of section .comment:
0000000000000000 <.comment>:
0: 47 rex.RXB
1: 43 rex.XB
2: 43 3a 20 rex.XB cmp (%r8),%spl
5: 28 55 62 sub %dl,0x62(%rbp)
8: 75 6e jne 78 <_init-0x4003f8>
a: 74 75 je 81 <_init-0x4003ef>
c: 20 35 2e 34 2e 30 and %dh,0x302e342e(%rip) # 302e3440 <_end+0x2fce23d0>
12: 2d 36 75 62 75 sub $0x75627536,%eax
17: 6e outsb %ds:(%rsi),(%dx)
18: 74 75 je 8f <_init-0x4003e1>
1a: 31 7e 31 xor %edi,0x31(%rsi)
1d: 36 2e 30 34 2e ss xor %dh,%cs:(%rsi,%rbp,1)
22: 31 32 xor %esi,(%rdx)
24: 29 20 sub %esp,(%rax)
26: 35 2e 34 2e 30 xor $0x302e342e,%eax
2b: 20 32 and %dh,(%rdx)
2d: 30 31 xor %dh,(%rcx)
2f: 36 30 36 xor %dh,%ss:(%rsi)
32: 30 39 xor %bh,(%rcx)
...
Disassembly of section .debug_aranges:
0000000000000000 <.debug_aranges>:
0: 2c 00 sub $0x0,%al
2: 00 00 add %al,(%rax)
4: 02 00 add (%rax),%al
6: 00 00 add %al,(%rax)
8: 00 00 add %al,(%rax)
a: 08 00 or %al,(%rax)
c: 00 00 add %al,(%rax)
e: 00 00 add %al,(%rax)
10: f6 05 40 00 00 00 00 testb $0x0,0x40(%rip) # 57 <_init-0x400419>
17: 00 7b 02 add %bh,0x2(%rbx)
...
Disassembly of section .debug_info:
0000000000000000 <.debug_info>:
0: 15 02 00 00 04 adc $0x4000002,%eax
5: 00 00 add %al,(%rax)
7: 00 00 add %al,(%rax)
9: 00 08 add %cl,(%rax)
b: 01 56 00 add %edx,0x0(%rsi)
e: 00 00 add %al,(%rax)
10: 0c 61 or $0x61,%al
12: 2e 63 00 movslq %cs:(%rax),%eax
15: b7 00 mov $0x0,%bh
17: 00 00 add %al,(%rax)
19: f6 05 40 00 00 00 00 testb $0x0,0x40(%rip) # 60 <_init-0x400410>
20: 00 7b 02 add %bh,0x2(%rbx)
...
2b: 00 00 add %al,(%rax)
2d: 02 08 add (%rax),%cl
2f: 07 (bad)
30: 21 00 and %eax,(%rax)
32: 00 00 add %al,(%rax)
34: 02 01 add (%rcx),%al
36: 08 13 or %dl,(%rbx)
38: 00 00 add %al,(%rax)
3a: 00 02 add %al,(%rdx)
3c: 02 07 add (%rdi),%al
3e: 33 00 xor (%rax),%eax
40: 00 00 add %al,(%rax)
42: 02 04 07 add (%rdi,%rax,1),%al
45: 26 00 00 add %al,%es:(%rax)
48: 00 02 add %al,(%rdx)
4a: 01 06 add %eax,(%rsi)
4c: 15 00 00 00 02 adc $0x2000000,%eax
51: 02 05 c3 00 00 00 add 0xc3(%rip),%al # 11a <_init-0x400356>
57: 03 04 05 69 6e 74 00 add 0x746e69(,%rax,1),%eax
5e: 02 08 add (%rax),%cl
60: 05 cd 00 00 00 add $0xcd,%eax
65: 02 08 add (%rax),%cl
67: 07 (bad)
68: ae scas %es:(%rdi),%al
69: 00 00 add %al,(%rax)
6b: 00 02 add %al,(%rdx)
6d: 01 06 add %eax,(%rsi)
6f: 1c 00 sbb $0x0,%al
71: 00 00 add %al,(%rax)
73: 04 08 add $0x8,%al
75: 79 00 jns 77 <_init-0x4003f9>
77: 00 00 add %al,(%rax)
79: 05 6c 00 00 00 add $0x6c,%eax
7e: 06 (bad)
7f: 66 74 00 data16 je 82 <_init-0x4003ee>
82: 01 1f add %ebx,(%rdi)
84: 88 00 mov %al,(%rax)
86: 00 00 add %al,(%rax)
88: 04 08 add $0x8,%al
8a: 8e 00 mov (%rax),%es
8c: 00 00 add %al,(%rax)
8e: 07 (bad)
8f: 57 push %rdi
90: 00 00 add %al,(%rax)
92: 00 99 00 00 00 08 add %bl,0x8000000(%rcx)
98: 00 09 add %cl,(%rcx)
9a: 4c 00 00 rex.WR add %r8b,(%rax)
9d: 00 01 add %al,(%rcx)
9f: 09 57 00 or %edx,0x0(%rdi)
a2: 00 00 add %al,(%rax)
a4: f6 05 40 00 00 00 00 testb $0x0,0x40(%rip) # eb <_init-0x400385>
ab: 00 15 00 00 00 00 add %dl,0x0(%rip) # b1 <_init-0x4003bf>
b1: 00 00 add %al,(%rax)
b3: 00 01 add %al,(%rcx)
b5: 9c pushfq
b6: 0a a6 00 00 00 01 or 0x1000000(%rsi),%ah
bc: 0e (bad)
bd: 57 push %rdi
be: 00 00 add %al,(%rax)
c0: 00 0b add %cl,(%rbx)
c2: 06 (bad)
c3: 40 00 00 add %al,(%rax)
c6: 00 00 add %al,(%rax)
c8: 00 ae 00 00 00 00 add %ch,0x0(%rsi)
ce: 00 00 add %al,(%rax)
d0: 00 01 add %al,(%rcx)
d2: 9c pushfq
d3: 1a 01 sbb (%rcx),%al
d5: 00 00 add %al,(%rax)
d7: 0b 06 or (%rsi),%eax
d9: 00 00 add %al,(%rax)
db: 00 01 add %al,(%rcx)
dd: 0e (bad)
de: 1a 01 sbb (%rcx),%al
e0: 00 00 add %al,(%rax)
e2: 02 91 58 0b d6 00 add 0xd60b58(%rcx),%dl
e8: 00 00 add %al,(%rax)
ea: 01 0e add %ecx,(%rsi)
ec: 42 00 00 rex.X add %al,(%rax)
ef: 00 02 add %al,(%rdx)
f1: 91 xchg %eax,%ecx
f2: 54 push %rsp
f3: 0c 69 or $0x69,%al
f5: 00 01 add %al,(%rcx)
f7: 10 57 00 adc %dl,0x0(%rdi)
fa: 00 00 add %al,(%rax)
fc: 02 91 60 0c 6c 65 add 0x656c0c60(%rcx),%dl
102: 6e outsb %ds:(%rsi),(%dx)
103: 00 01 add %al,(%rcx)
105: 11 57 00 adc %edx,0x0(%rdi)
108: 00 00 add %al,(%rax)
10a: 02 91 64 0c 70 00 add 0x700c64(%rcx),%dl
110: 01 13 add %edx,(%rbx)
112: 1a 01 sbb (%rcx),%al
114: 00 00 add %al,(%rax)
116: 02 91 68 00 04 08 add 0x8040068(%rcx),%dl
11c: 34 00 xor $0x0,%al
11e: 00 00 add %al,(%rax)
120: 0d 51 00 00 00 or $0x51,%eax
125: 01 20 add %esp,(%rax)
127: 57 push %rdi
128: 00 00 add %al,(%rax)
12a: 00 b9 06 40 00 00 add %bh,0x4006(%rcx)
130: 00 00 add %al,(%rax)
132: 00 b8 01 00 00 00 add %bh,0x1(%rax)
138: 00 00 add %al,(%rax)
13a: 00 01 add %al,(%rcx)
13c: 9c pushfq
13d: 88 01 mov %al,(%rcx)
13f: 00 00 add %al,(%rax)
141: 0c 61 or $0x61,%al
143: 00 01 add %al,(%rcx)
145: 22 57 00 and 0x0(%rdi),%dl
148: 00 00 add %al,(%rax)
14a: 02 91 5c 0c 62 00 add 0x620c5c(%rcx),%dl
150: 01 23 add %esp,(%rbx)
152: 57 push %rdi
153: 00 00 add %al,(%rax)
155: 00 02 add %al,(%rdx)
157: 91 xchg %eax,%ecx
158: 60 (bad)
159: 0c 63 or $0x63,%al
15b: 00 01 add %al,(%rcx)
15d: 24 57 and $0x57,%al
15f: 00 00 add %al,(%rax)
161: 00 02 add %al,(%rdx)
163: 91 xchg %eax,%ecx
164: 64 0e fs (bad)
166: 00 00 add %al,(%rax)
168: 00 00 add %al,(%rax)
16a: 01 25 57 00 00 00 add %esp,0x57(%rip) # 1c7 <_init-0x4002a9>
170: 09 03 or %eax,(%rbx)
172: 68 10 60 00 00 pushq $0x6010
177: 00 00 add %al,(%rax)
179: 00 0c 70 add %cl,(%rax,%rsi,2)
17c: 66 00 01 data16 add %al,(%rcx)
17f: 26 7e 00 es jle 182 <_init-0x4002ee>
182: 00 00 add %al,(%rax)
184: 02 91 68 00 0c 73 add 0x730c0068(%rcx),%dl
18a: 00 01 add %al,(%rcx)
18c: 05 57 00 00 00 add $0x57,%eax
191: 09 03 or %eax,(%rbx)
193: 64 10 60 00 adc %ah,%fs:0x0(%rax)
197: 00 00 add %al,(%rax)
199: 00 00 add %al,(%rax)
19b: 0f 67 00 packuswb (%rax),%mm0
19e: 01 03 add %eax,(%rbx)
1a0: 57 push %rdi
1a1: 00 00 add %al,(%rax)
1a3: 00 09 add %cl,(%rcx)
1a5: 03 6c 10 60 add 0x60(%rax,%rdx,1),%ebp
1a9: 00 00 add %al,(%rax)
1ab: 00 00 add %al,(%rax)
1ad: 00 0f add %cl,(%rdi)
1af: 66 00 01 data16 add %al,(%rcx)
1b2: 04 c1 add $0xc1,%al
1b4: 01 00 add %eax,(%rax)
1b6: 00 09 add %cl,(%rcx)
1b8: 03 10 add (%rax),%edx
1ba: 09 40 00 or %eax,0x0(%rax)
1bd: 00 00 add %al,(%rax)
1bf: 00 00 add %al,(%rax)
1c1: 05 57 00 00 00 add $0x57,%eax
1c6: 0f 6d (bad)
1c8: 00 01 add %al,(%rcx)
1ca: 06 (bad)
1cb: 57 push %rdi
1cc: 00 00 add %al,(%rax)
1ce: 00 09 add %cl,(%rcx)
1d0: 03 50 10 add 0x10(%rax),%edx
1d3: 60 (bad)
1d4: 00 00 add %al,(%rax)
1d6: 00 00 add %al,(%rax)
1d8: 00 10 add %dl,(%rax)
1da: 0c 00 or $0x0,%al
1dc: 00 00 add %al,(%rax)
1de: 01 07 add %eax,(%rdi)
1e0: 73 00 jae 1e2 <_init-0x40028e>
1e2: 00 00 add %al,(%rax)
1e4: 09 03 or %eax,(%rbx)
1e6: 58 pop %rax
1e7: 10 60 00 adc %ah,0x0(%rax)
1ea: 00 00 add %al,(%rax)
1ec: 00 00 add %al,(%rax)
1ee: 11 79 00 adc %edi,0x0(%rcx)
1f1: 00 00 add %al,(%rax)
1f3: fe 01 incb (%rcx)
1f5: 00 00 add %al,(%rax)
1f7: 12 65 00 adc 0x0(%rbp),%ah
1fa: 00 00 add %al,(%rax)
1fc: 13 00 adc (%rax),%eax
1fe: 10 46 00 adc %al,0x0(%rsi)
201: 00 00 add %al,(%rax)
203: 01 08 add %ecx,(%rax)
205: 13 02 adc (%rdx),%eax
207: 00 00 add %al,(%rax)
209: 09 03 or %eax,(%rbx)
20b: 30 09 xor %cl,(%rcx)
20d: 40 00 00 add %al,(%rax)
210: 00 00 add %al,(%rax)
212: 00 05 ee 01 00 00 add %al,0x1ee(%rip) # 406 <_init-0x40006a>
...
Disassembly of section .debug_abbrev:
0000000000000000 <.debug_abbrev>:
0: 01 11 add %edx,(%rcx)
2: 01 25 0e 13 0b 03 add %esp,0x30b130e(%rip) # 30b1316 <_end+0x2ab02a6>
8: 08 1b or %bl,(%rbx)
a: 0e (bad)
b: 11 01 adc %eax,(%rcx)
d: 12 07 adc (%rdi),%al
f: 10 17 adc %dl,(%rdi)
11: 00 00 add %al,(%rax)
13: 02 24 00 add (%rax,%rax,1),%ah
16: 0b 0b or (%rbx),%ecx
18: 3e 0b 03 or %ds:(%rbx),%eax
1b: 0e (bad)
1c: 00 00 add %al,(%rax)
1e: 03 24 00 add (%rax,%rax,1),%esp
21: 0b 0b or (%rbx),%ecx
23: 3e 0b 03 or %ds:(%rbx),%eax
26: 08 00 or %al,(%rax)
28: 00 04 0f add %al,(%rdi,%rcx,1)
2b: 00 0b add %cl,(%rbx)
2d: 0b 49 13 or 0x13(%rcx),%ecx
30: 00 00 add %al,(%rax)
32: 05 26 00 49 13 add $0x13490026,%eax
37: 00 00 add %al,(%rax)
39: 06 (bad)
3a: 16 (bad)
3b: 00 03 add %al,(%rbx)
3d: 08 3a or %bh,(%rdx)
3f: 0b 3b or (%rbx),%edi
41: 0b 49 13 or 0x13(%rcx),%ecx
44: 00 00 add %al,(%rax)
46: 07 (bad)
47: 15 01 49 13 01 adc $0x1134901,%eax
4c: 13 00 adc (%rax),%eax
4e: 00 08 add %cl,(%rax)
50: 18 00 sbb %al,(%rax)
52: 00 00 add %al,(%rax)
54: 09 2e or %ebp,(%rsi)
56: 00 3f add %bh,(%rdi)
58: 19 03 sbb %eax,(%rbx)
5a: 0e (bad)
5b: 3a 0b cmp (%rbx),%cl
5d: 3b 0b cmp (%rbx),%ecx
5f: 49 13 11 adc (%r9),%rdx
62: 01 12 add %edx,(%rdx)
64: 07 (bad)
65: 40 18 96 42 19 00 00 sbb %dl,0x1942(%rsi)
6c: 0a 2e or (%rsi),%ch
6e: 01 3f add %edi,(%rdi)
70: 19 03 sbb %eax,(%rbx)
72: 0e (bad)
73: 3a 0b cmp (%rbx),%cl
75: 3b 0b cmp (%rbx),%ecx
77: 27 (bad)
78: 19 49 13 sbb %ecx,0x13(%rcx)
7b: 11 01 adc %eax,(%rcx)
7d: 12 07 adc (%rdi),%al
7f: 40 18 96 42 19 01 13 sbb %dl,0x13011942(%rsi)
86: 00 00 add %al,(%rax)
88: 0b 05 00 03 0e 3a or 0x3a0e0300(%rip),%eax # 3a0e038e <_end+0x39adf31e>
8e: 0b 3b or (%rbx),%edi
90: 0b 49 13 or 0x13(%rcx),%ecx
93: 02 18 add (%rax),%bl
95: 00 00 add %al,(%rax)
97: 0c 34 or $0x34,%al
99: 00 03 add %al,(%rbx)
9b: 08 3a or %bh,(%rdx)
9d: 0b 3b or (%rbx),%edi
9f: 0b 49 13 or 0x13(%rcx),%ecx
a2: 02 18 add (%rax),%bl
a4: 00 00 add %al,(%rax)
a6: 0d 2e 01 3f 19 or $0x193f012e,%eax
ab: 03 0e add (%rsi),%ecx
ad: 3a 0b cmp (%rbx),%cl
af: 3b 0b cmp (%rbx),%ecx
b1: 49 13 11 adc (%r9),%rdx
b4: 01 12 add %edx,(%rdx)
b6: 07 (bad)
b7: 40 18 96 42 19 01 13 sbb %dl,0x13011942(%rsi)
be: 00 00 add %al,(%rax)
c0: 0e (bad)
c1: 34 00 xor $0x0,%al
c3: 03 0e add (%rsi),%ecx
c5: 3a 0b cmp (%rbx),%cl
c7: 3b 0b cmp (%rbx),%ecx
c9: 49 13 02 adc (%r10),%rax
cc: 18 00 sbb %al,(%rax)
ce: 00 0f add %cl,(%rdi)
d0: 34 00 xor $0x0,%al
d2: 03 08 add (%rax),%ecx
d4: 3a 0b cmp (%rbx),%cl
d6: 3b 0b cmp (%rbx),%ecx
d8: 49 13 3f adc (%r15),%rdi
db: 19 02 sbb %eax,(%rdx)
dd: 18 00 sbb %al,(%rax)
df: 00 10 add %dl,(%rax)
e1: 34 00 xor $0x0,%al
e3: 03 0e add (%rsi),%ecx
e5: 3a 0b cmp (%rbx),%cl
e7: 3b 0b cmp (%rbx),%ecx
e9: 49 13 3f adc (%r15),%rdi
ec: 19 02 sbb %eax,(%rdx)
ee: 18 00 sbb %al,(%rax)
f0: 00 11 add %dl,(%rcx)
f2: 01 01 add %eax,(%rcx)
f4: 49 13 01 adc (%r9),%rax
f7: 13 00 adc (%rax),%eax
f9: 00 12 add %dl,(%rdx)
fb: 21 00 and %eax,(%rax)
fd: 49 13 2f adc (%r15),%rbp
100: 0b 00 or (%rax),%eax
...
Disassembly of section .debug_line:
0000000000000000 <.debug_line>:
0: bd 00 00 00 02 mov $0x2000000,%ebp
5: 00 1a add %bl,(%rdx)
7: 00 00 add %al,(%rax)
9: 00 01 add %al,(%rcx)
b: 01 fb add %edi,%ebx
d: 0e (bad)
e: 0d 00 01 01 01 or $0x1010100,%eax
13: 01 00 add %eax,(%rax)
15: 00 00 add %al,(%rax)
17: 01 00 add %eax,(%rax)
19: 00 01 add %al,(%rcx)
1b: 00 61 2e add %ah,0x2e(%rcx)
1e: 63 00 movslq (%rax),%eax
20: 00 00 add %al,(%rax)
22: 00 00 add %al,(%rax)
24: 00 09 add %cl,(%rcx)
26: 02 f6 add %dh,%dh
28: 05 40 00 00 00 add $0x40,%eax
2d: 00 00 add %al,(%rax)
2f: 03 09 add (%rcx),%ecx
31: 01 4b 9f add %ecx,-0x61(%rbx)
34: 59 pop %rcx
35: 30 e5 xor %ah,%ch
37: 75 68 jne a1 <_init-0x4003cf>
39: 83 83 91 9f 08 d7 02 addl $0x2,-0x28f7606f(%rbx)
40: 24 13 and $0x13,%al
42: 08 2f or %ch,(%rdi)
44: 00 02 add %al,(%rdx)
46: 04 02 add $0x2,%al
48: 99 cltd
49: 00 02 add %al,(%rdx)
4b: 04 01 add $0x1,%al
4d: 06 (bad)
4e: 4a 06 rex.WX (bad)
50: 03 09 add (%rcx),%ecx
52: 82 (bad)
53: 3f (bad)
54: 83 75 75 ae xorl $0xffffffae,0x75(%rbp)
58: 83 83 e5 e5 00 02 04 addl $0x4,0x200e5e5(%rbx)
5f: 01 e6 add %esp,%esi
61: 00 02 add %al,(%rdx)
63: 04 01 add $0x1,%al
65: e5 00 in $0x0,%eax
67: 02 04 01 add (%rcx,%rax,1),%al
6a: e5 00 in $0x0,%eax
6c: 02 04 01 add (%rcx,%rax,1),%al
6f: 9f lahf
70: 00 02 add %al,(%rdx)
72: 04 01 add $0x1,%al
74: 08 67 00 or %ah,0x0(%rdi)
77: 02 04 01 add (%rcx,%rax,1),%al
7a: 08 3d 00 02 04 01 or %bh,0x1040200(%rip) # 1040280 <_end+0xa3f210>
80: 08 ad 00 02 04 01 or %ch,0x1040200(%rbp)
86: 08 9f 00 02 04 01 or %bl,0x1040200(%rdi)
8c: 08 ad 00 02 04 01 or %ch,0x1040200(%rbp)
92: 08 3d 00 02 04 01 or %bh,0x1040200(%rip) # 1040298 <_end+0xa3f228>
98: 02 2b add (%rbx),%ch
9a: 13 00 adc (%rax),%eax
9c: 02 04 01 add (%rcx,%rax,1),%al
9f: 08 ad 00 02 04 01 or %ch,0x1040200(%rbp)
a5: 08 3d 00 02 04 01 or %bh,0x1040200(%rip) # 10402ab <_end+0xa3f23b>
ab: 08 f4 or %dh,%ah
ad: 00 02 add %al,(%rdx)
af: 04 01 add $0x1,%al
b1: ad lods %ds:(%rsi),%eax
b2: 00 02 add %al,(%rdx)
b4: 04 01 add $0x1,%al
b6: 9f lahf
b7: 00 02 add %al,(%rdx)
b9: 04 01 add $0x1,%al
bb: 9f lahf
bc: 02 .byte 0x2
bd: 05 .byte 0x5
be: 00 01 add %al,(%rcx)
c0: 01 .byte 0x1
Disassembly of section .debug_str:
0000000000000000 <.debug_str>:
0: 63 6f 75 movslq 0x75(%rdi),%ebp
3: 6e outsb %ds:(%rsi),(%dx)
4: 74 00 je 6 <_init-0x40046a>
6: 73 74 jae 7c <_init-0x4003f4>
8: 61 (bad)
9: 72 74 jb 7f <_init-0x4003f1>
b: 00 73 74 add %dh,0x74(%rbx)
e: 72 69 jb 79 <_init-0x4003f7>
10: 6e outsb %ds:(%rsi),(%dx)
11: 67 00 75 6e add %dh,0x6e(%ebp)
15: 73 69 jae 80 <_init-0x4003f0>
17: 67 6e outsb %ds:(%esi),(%dx)
19: 65 64 20 63 68 gs and %ah,%fs:0x68(%rbx)
1e: 61 (bad)
1f: 72 00 jb 21 <_init-0x40044f>
21: 6c insb (%dx),%es:(%rdi)
22: 6f outsl %ds:(%rsi),(%dx)
23: 6e outsb %ds:(%rsi),(%dx)
24: 67 20 75 6e and %dh,0x6e(%ebp)
28: 73 69 jae 93 <_init-0x4003dd>
2a: 67 6e outsb %ds:(%esi),(%dx)
2c: 65 64 20 69 6e gs and %ch,%fs:0x6e(%rcx)
31: 74 00 je 33 <_init-0x40043d>
33: 73 68 jae 9d <_init-0x4003d3>
35: 6f outsl %ds:(%rsi),(%dx)
36: 72 74 jb ac <_init-0x4003c4>
38: 20 75 6e and %dh,0x6e(%rbp)
3b: 73 69 jae a6 <_init-0x4003ca>
3d: 67 6e outsb %ds:(%esi),(%dx)
3f: 65 64 20 69 6e gs and %ch,%fs:0x6e(%rcx)
44: 74 00 je 46 <_init-0x40042a>
46: 61 (bad)
47: 72 72 jb bb <_init-0x4003b5>
49: 61 (bad)
4a: 79 00 jns 4c <_init-0x400424>
4c: 66 75 6e data16 jne bd <_init-0x4003b3>
4f: 63 00 movslq (%rax),%eax
51: 6d insl (%dx),%es:(%rdi)
52: 61 (bad)
53: 69 6e 00 47 4e 55 20 imul $0x20554e47,0x0(%rsi),%ebp
5a: 43 31 31 rex.XB xor %esi,(%r9)
5d: 20 35 2e 34 2e 30 and %dh,0x302e342e(%rip) # 302e3491 <_end+0x2fce2421>
63: 20 32 and %dh,(%rdx)
65: 30 31 xor %dh,(%rcx)
67: 36 30 36 xor %dh,%ss:(%rsi)
6a: 30 39 xor %bh,(%rcx)
6c: 20 2d 6d 74 75 6e and %ch,0x6e75746d(%rip) # 6e7574df <_end+0x6e15646f>
72: 65 3d 67 65 6e 65 gs cmp $0x656e6567,%eax
78: 72 69 jb e3 <_init-0x40038d>
7a: 63 20 movslq (%rax),%esp
7c: 2d 6d 61 72 63 sub $0x6372616d,%eax
81: 68 3d 78 38 36 pushq $0x3638783d
86: 2d 36 34 20 2d sub $0x2d203436,%eax
8b: 67 20 2d 66 73 74 61 and %ch,0x61747366(%eip) # 617473f8 <_end+0x61146388>
92: 63 6b 2d movslq 0x2d(%rbx),%ebp
95: 70 72 jo 109 <_init-0x400367>
97: 6f outsl %ds:(%rsi),(%dx)
98: 74 65 je ff <_init-0x400371>
9a: 63 74 6f 72 movslq 0x72(%rdi,%rbp,2),%esi
9e: 2d 73 74 72 6f sub $0x6f727473,%eax
a3: 6e outsb %ds:(%rsi),(%dx)
a4: 67 00 64 75 6d add %ah,0x6d(%ebp,%esi,2)
a9: 70 68 jo 113 <_init-0x40035d>
ab: 65 78 00 gs js ae <_init-0x4003c2>
ae: 73 69 jae 119 <_init-0x400357>
b0: 7a 65 jp 117 <_init-0x400359>
b2: 74 79 je 12d <_init-0x400343>
b4: 70 65 jo 11b <_init-0x400355>
b6: 00 2f add %ch,(%rdi)
b8: 72 6f jb 129 <_init-0x400347>
ba: 6f outsl %ds:(%rsi),(%dx)
bb: 74 2f je ec <_init-0x400384>
bd: 73 68 jae 127 <_init-0x400349>
bf: 61 (bad)
c0: 72 65 jb 127 <_init-0x400349>
c2: 00 73 68 add %dh,0x68(%rbx)
c5: 6f outsl %ds:(%rsi),(%dx)
c6: 72 74 jb 13c <_init-0x400334>
c8: 20 69 6e and %ch,0x6e(%rcx)
cb: 74 00 je cd <_init-0x4003a3>
cd: 6c insb (%dx),%es:(%rdi)
ce: 6f outsl %ds:(%rsi),(%dx)
cf: 6e outsb %ds:(%rsi),(%dx)
d0: 67 20 69 6e and %ch,0x6e(%ecx)
d4: 74 00 je d6 <_init-0x40039a>
d6: 6c insb (%dx),%es:(%rdi)
d7: 65 6e outsb %gs:(%rsi),(%dx)
d9: 67 74 68 addr32 je 144 <_init-0x40032c>
...
|
kernel/src/loader.asm | e-wiki/jsos | 834 | 21811 | global loader
global end_of_image
global kstack_max
extern kmain
section .text
align 4
MultiBootHeader:
FLAGS equ 3
MAGIC equ 0x1BADB002
CHECKSUM equ -(MAGIC + FLAGS)
dd MAGIC
dd FLAGS
dd CHECKSUM
STACKSIZE equ 1024*1024 ; 1 MiB
loader:
mov esp, kstack_max+STACKSIZE
push eax ; multiboot magic number
push ebx ; pointer to multiboot struct
fninit
mov eax, cr0
or eax, 1 << 5 ; FPU NE bit
mov cr0, eax
push 0
jmp kmain
section .bss
align 4
resb 64*1024
; 64 KiB slack space. we can detect a looming stack overflow by comparing
; the address of a local variable against the address of kstack_max
kstack_max:
resb STACKSIZE
section .end_of_image
end_of_image: |
source/image/required/s-widcha.ads | ytomino/drake | 33 | 15118 | <reponame>ytomino/drake
pragma License (Unrestricted);
-- implementation unit required by compiler
package System.Wid_Char is
pragma Pure;
-- required for Character'Width by compiler (s-widboo.ads)
function Width_Character (Lo, Hi : Character) return Natural;
-- compiler return 12 ("Reserved_153") for statically character types
end System.Wid_Char;
|
Commands/Miscellaneous Commands suite/system info/CPU type of (get system info).applescript | looking-for-a-job/applescript-examples | 1 | 3312 | <filename>Commands/Miscellaneous Commands suite/system info/CPU type of (get system info).applescript
#!/usr/bin/osascript
CPU type of (get system info) |
dv3/q40/fd/wait.asm | olifink/smsqe | 0 | 2594 | ; DV3 Q40 Wait for Ticks 1994 <NAME>
section fd
xdef fd_wait
include 'dev8_keys_sys'
include 'dev8_keys_q40'
;+++
; Wait for ticks
;
; d0 c r number of ticks / 0
;
;---
fd_wait
move.l d1,-(sp)
move.w sr,d1 ; are interrupts disabled?
and.w #$0700,d1
beq.s fdw_mpoll ; ... no, count missing polls
fdw_wframe
btst #Q40..frame,q40_ir ; frame interrupt?
beq.s fdw_wframe ; ... no
st q40_fack ; clear interrupt flag
subq.w #1,d0 ; one gone
bpl.s fdw_wframe
bra.s fdw_exit
fdw_mpoll
add.w sys_pict(a6),d0
bvc.s fdw_mploop ; ok
sub.w sys_pict(a6),d0 ; ... bad
sub.w d0,sys_pict(a6) ; ... backspace the counter a bit
bra.s fdw_mpoll
fdw_mploop
cmp.w sys_pict(a6),d0
bhi.s fdw_mploop
fdw_exit
move.l (sp)+,d1
moveq #0,d0
rts
end
|
Cubical/Structures/Queue.agda | borsiemir/cubical | 0 | 7812 | {-# OPTIONS --cubical --no-exact-split --safe #-}
module Cubical.Structures.Queue where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.HLevels
open import Cubical.Foundations.FunExtEquiv
open import Cubical.Foundations.Equiv
open import Cubical.Foundations.SIP renaming (SNS-PathP to SNS)
open import Cubical.Structures.Pointed
open import Cubical.Data.Unit
open import Cubical.Data.Sum
open import Cubical.Data.Prod.Base hiding (_×_) renaming (_×Σ_ to _×_)
-- Developing Queues as a standard notion of structure, see
-- https://github.com/ecavallo/cubical/blob/queue/Cubical/Experiments/Queue.agda
-- for the original development
variable
ℓ ℓ' : Level
-- We start fixing a set A on which we define what it means for a type Q to have
-- a Queue structure (wrt. A)
module Queues-on (A : Type ℓ) (Aset : isSet A) where
-- A Queue structure has three components, the empty Queue, a push function and a pop function
-- We first deal with push and pop as separate structures
left-action-structure : Type ℓ → Type ℓ
left-action-structure X = A → X → X
Left-Action : Type (ℓ-suc ℓ)
Left-Action = TypeWithStr ℓ left-action-structure
left-action-iso : StrIso left-action-structure ℓ
left-action-iso (X , l) (Y , m) e = ∀ a x → e .fst (l a x) ≡ m a (e .fst x)
Left-Action-is-SNS : SNS {ℓ} left-action-structure left-action-iso
Left-Action-is-SNS = SNS-≡→SNS-PathP left-action-iso ((λ _ _ → funExt₂Equiv))
-- Now for the pop-map as a structure
-- First, a few preliminary results that we will need later
pop-map-forward : {X Y : Type ℓ} → (X → Y)
→ Unit ⊎ (X × A) → Unit ⊎ (Y × A)
pop-map-forward f (inl tt) = inl tt
pop-map-forward f (inr (x , a)) = inr (f x , a)
pop-map-forward-∘ :{B C D : Type ℓ}
(g : C → D) (f : B → C)
→ ∀ r → pop-map-forward {X = C} g (pop-map-forward f r) ≡ pop-map-forward (λ b → g (f b)) r
pop-map-forward-∘ g f (inl tt) = refl
pop-map-forward-∘ g f (inr (b , a)) = refl
pop-map-lemma : {X : Type ℓ} → idfun (Unit ⊎ (X × A)) ≡ pop-map-forward (idfun X)
pop-map-lemma {X = X} = funExt γ
where
γ : ∀ z → z ≡ pop-map-forward (idfun X) z
γ (inl tt) = refl
γ (inr xa) = refl
pop-structure : Type ℓ → Type ℓ
pop-structure X = X → Unit ⊎ (X × A)
Pop : Type (ℓ-suc ℓ)
Pop = TypeWithStr ℓ pop-structure
pop-iso : StrIso pop-structure ℓ
pop-iso (X , p) (Y , q) e = ∀ x → pop-map-forward (e .fst) (p x) ≡ q (e .fst x)
Pop-is-SNS : SNS {ℓ} pop-structure pop-iso
Pop-is-SNS = SNS-≡→SNS-PathP pop-iso (λ p q → (subst (λ f → (∀ x → f (p x) ≡ q x) ≃ (p ≡ q)) pop-map-lemma funExtEquiv))
-- Now we can do Queues:
queue-structure : Type ℓ → Type ℓ
queue-structure Q = Q × (A → Q → Q) × (Q → Unit ⊎ (Q × A))
Queue : Type (ℓ-suc ℓ)
Queue = TypeWithStr ℓ queue-structure
queue-iso : StrIso queue-structure ℓ
queue-iso (Q₁ , emp₁ , push₁ , pop₁) (Q₂ , emp₂ , push₂ , pop₂) e =
(e .fst emp₁ ≡ emp₂)
× (∀ a q → e .fst (push₁ a q) ≡ push₂ a (e .fst q))
× (∀ q → pop-map-forward (e .fst) (pop₁ q) ≡ pop₂ (e .fst q))
Queue-is-SNS : SNS {ℓ₁ = ℓ} queue-structure queue-iso
Queue-is-SNS = join-SNS pointed-structure pointed-iso pointed-is-SNS
(λ X → (left-action-structure X) × (pop-structure X))
(λ B C e → (∀ a q → e .fst (B .snd .fst a q) ≡ C .snd .fst a (e .fst q))
× (∀ q → pop-map-forward (e .fst) (B .snd .snd q) ≡ C .snd .snd (e .fst q)))
(join-SNS left-action-structure left-action-iso Left-Action-is-SNS
pop-structure pop-iso Pop-is-SNS )
-- Should we add further axioms for Queues?
-- Some suggestions:
queue-axioms : (Q : Type ℓ) → queue-structure Q → Type ℓ
queue-axioms Q (emp , push , pop) = (isSet Q)
× (pop emp ≡ inl tt)
× ∀ a → pop (push a emp) ≡ inr (emp , a)
-- etc.
|
programs/oeis/004/A004347.asm | neoneye/loda | 22 | 88885 | ; A004347: Binomial coefficient C(5n,n-5).
; 1,30,595,9880,148995,2118760,28989675,386206920,5047381560,65033528560,828931106355,10477677064400,131567066917650,1643385429346680,20439879147794485,253338471349988640,3130921572628162950,38601232498698200100,474959279180489235825,5834104414094383310520,71559315489039423215775,876646059135717719992000,10728151764776102231289000,131169217511293618831944000,1602503880445016501255082000,19564640595300216439731236256,238720087699602214770528249555,2911276305593923505026079973920,35488172808133897719996506527380,432428265078344582933058815962320,5267395152923620012242567009116910,64142739456288770385700282458424800,780881087753394098784080373348357615
mov $1,5
mul $1,$0
add $1,25
bin $1,$0
mov $0,$1
|
oeis/337/A337728.asm | neoneye/loda-programs | 11 | 18721 | ; A337728: a(n) = (4*n+1)! * Sum_{k=0..n} 1 / (4*k+1)!.
; Submitted by <NAME>
; 1,121,365905,6278929801,358652470233121,51516840824285500441,15640512874253077933887601,8915467710633236496186345872425,8755702529258688898174686554391144001,13878488965077362598718732163634314533105081,33731389859841228248933904149069928786421237268881
mul $0,4
add $0,1
seq $0,330045 ; Expansion of e.g.f. exp(x) / (1 - x^4).
div $0,4
mul $0,4
add $0,1
|
oeis/094/A094052.asm | neoneye/loda-programs | 11 | 88980 | ; A094052: Number of walks of length n between two adjacent nodes in the cycle graph C_7.
; Submitted by <NAME>
; 0,1,0,3,0,10,1,35,9,126,55,462,286,1717,1365,6451,6188,24463,27132,93518,116281,360031,490337,1394582,2043275,5430530,8439210,21242341,34621041,83411715,141290436,328589491,574274008,1297937234,2326683921
mov $1,1
lpb $0
sub $0,1
mov $2,$1
mul $2,2
sub $3,$1
add $1,$3
mul $3,2
sub $3,$4
mov $4,$2
mov $2,$3
add $5,$4
mov $3,$5
add $4,$1
add $5,$2
lpe
mov $0,$3
div $0,2
|
leader_election.als | septract/alloy-ring-election | 0 | 3706 | <reponame>septract/alloy-ring-election<gh_stars>0
module leaderElection
open util/ordering[Time]
abstract sig Msg {}
one sig Request, Vote extends Msg {}
sig Node {}
sig Time {
msg: Node -> Msg -> Node,
alreadyvoted: set Node,
leader: set Node,
voters: Node -> Node,
}
pred init (t: Time) {
no t.msg
no t.alreadyvoted
no t.leader
no t.voters
}
pred step (t1, t2: Time) {
some n : Node | {
client_request [n, t1, t2]
||
recv [n, t1, t2]
}
||
skip[t1, t2]
}
pred client_request ( n: Node, t1, t2: Time ) {
not n in t1.alreadyvoted
t2.msg = t1.msg + (n -> Request -> (Node - n))
t2.alreadyvoted = t1.alreadyvoted + n
t2.voters = t1.voters
t2.leader = t1.leader
}
pred recv ( n: Node, t1, t2: Time ) {
some src: Node | {
{ (src -> Request -> n) in t1.msg
&&
handle_request[n, src, t1, t2] }
||
{ (src -> Vote -> n) in t1.msg
&&
handle_vote[n, src, t1, t2] }
}
}
pred handle_request ( n, src: Node, t1, t2: Time ) {
not n in t1.alreadyvoted
t2.msg = (t1.msg - (src -> Request -> n)) + (n -> Vote -> src)
t2.alreadyvoted = t1.alreadyvoted + n
t2.voters = t1.voters
t2.leader = t1.leader
}
pred handle_vote ( n, src: Node, t1, t2: Time ) {
t2.msg = t1.msg - (src -> Vote -> n)
t2.alreadyvoted = t1.alreadyvoted
t2.voters = t1.voters + (n -> src)
{
( quorum[ t1.voters[n] ] && t2.leader = t1.leader + n )
||
( (not quorum[ t1.voters[n] ]) && t2.leader = t1.leader )
}
}
// Note we count the nodes before updating
pred quorum ( s: set Node ) {
#s >= (#Node).div[2]
}
pred skip ( t1, t2: Time ) {
some t1.leader // Only if we've found a leader
t2.msg = t1.msg
t2.alreadyvoted = t1.alreadyvoted
t2.voters = t1.voters
t2.leader = t1.leader
}
pred trace {
init [ first ]
all t: Time - last | step[t, next[t]]
}
// run {
// trace
// some Time.leader
// } for 10 but exactly 3 Node, 10 Time
check {
trace => no t: Time | #(t.leader) > 1
} for 10
run trace for 10
|
repsych.asm | juliusdedekind/REpsych | 733 | 246600 | <reponame>juliusdedekind/REpsych
; REpsych
; domas @xoreaxeaxeax
USE32
%include "gen/gen.asm"
%include "gfx/image.asm"
%include "code/code.asm"
global _start
_start:
call code
call main
mov eax, 1
mov edx, 0
int 0x80
; Tie nodes together, or use the newer switch opening,
; which avoids the need for tight tying.
%ifdef TIE
%assign TIED 1
%else
%assign TIED 0
%endif
; max instructions in a node, picked to match width
%assign instructions 26
; insert a wider instructure to make nodes larger to emphasize contrast
%macro widen 0
; any arbitrary long instruction that won't fault
; don't use a long nop, ida will decode the graph differently
; wide+4 prevents instruction from shortening due to existing symbol
vfmaddsub132ps xmm0,xmm1,[cs:edi+esi*4+wide+4]
;mov dword [eax+4*edx+0x11111111], 0x11111111
;lea eax, [eax+4*edx+0x11111111]
;mov dword [edi+4*esi+wide+4], 0x11111111
%endmacro
; widen instruction setup, if necessary
section .data
wide: dd 0, 0, 0
section .text
%macro init_widen 0
xor edi, edi
xor esi, esi
%endmacro
%macro invert 0
%assign pixel 255-pixel
%endmacro
%macro check 2
%assign pixel pixel_%1_%2
%endmacro
%macro block_fill 2
; force column filled to ensure all rows have at least 1 pixel on
%if %2 == 0
%assign pixel 255
%else
; adjust for all on column
%assign T %2 - 1
check T, %1
%endif
widen
%assign lines pixel*instructions/255
; junk code, should not branch or interfere with execution
%rep lines
rand_insn
%endrep
%endmacro
%macro diag 5 ; row, column, width, height, done
%assign r %1
%assign c %2
%assign width %3
%assign height %4
%rep 256 ; max size
%assign nr r+1
%if TIED
%assign nc c+1
%else
%assign nc c
%endif
%if TIED
%if nc >= width
; create orphan jump to node to get right side aligned
widen
jmp e_%+r%+_%+c
%endif
%endif
e_%+r%+_%+c:
%if nr >= height
block_fill r, c
%elif TIED && nc >= width
block_fill r, c
je e_%+nr%+_%+c
%else
%if c == 0
; force unconditional jmp in column 0
block_fill r, c
jmp e_%+nr%+_%+nc
%if TIED
; warning: exitrep doesn't take effect until endrep is reached
%exitrep
%endif
%else
block_fill r, c
%if TIED
je e_%+nr%+_%+nc
%else
jmp e_%+nr%+_%+nc
%endif
%endif
%endif
%assign r r+1
%if TIED
%assign c c-1
%endif
%if r>=height
jmp %5
%exitrep
%endif
%endrep
%endmacro
; table for opening switch
s:
%assign c 0
%rep WIDTH+1
dd e_0_%+c
%assign c c+1
%endrep
global main
main:
init_widen
nop ; prevent ida from thinking this is a thunk, if no code above us
mov eax, 0
jmp [s+eax*4]
; adjust for adding all on column
%assign WIDTH WIDTH+1
%assign CC 0
%rep WIDTH
diag 0, CC, WIDTH, HEIGHT, done
%assign CC CC+1
%endrep
%if TIED
%assign RC 1
%rep HEIGHT-1
diag RC, WIDTH-1, WIDTH, HEIGHT, done
%assign RC RC+1
%endrep
%endif
done:
ret
|
src/setup.asm | freem/freem_pong | 1 | 244398 | <gh_stars>1-10
; Program Setup
;==============================================================================;
ProgramSetup:
; lots of this will differ for PCE/NES.
;==============================================================================;
; NES-specific section
;==============================================================================;
.ifdef __NES__
;-- set palette --;
ldx #>$3F00
ldy #<$3F00
stx PPU_ADDR
sty PPU_ADDR
; 32 values in tbl_paletteNES
ldy #0
@Reset_nes_LoadPalette:
lda tbl_paletteNES,y
sta PPU_DATA
iny
cpy #32
bne @Reset_nes_LoadPalette
; reset PPU addresses
ldx #$3F
ldy #$00
stx PPU_ADDR ; palette 1/2
sty PPU_ADDR ; palette 2/2
sty PPU_ADDR ; regular ppu 1/2
sty PPU_ADDR ; regular ppu 2/2
;-- clear nametables --;
;jsr ppu_ClearNT_All
;-- load CHR data --;
; BG tiles
ldx #<nes_tilesBG
ldy #>nes_tilesBG
stx tmp00
sty tmp01
lda #80 ; 80 2BPP NES tiles
sta tmp02
jsr nes_LoadTiles
; sprite tiles
ldx #>$1000
ldy #<$0000
stx PPU_ADDR
sty PPU_ADDR
ldx #<nes_tilesSPR
ldy #>nes_tilesSPR
stx tmp00
sty tmp01
lda #7 ; 7 8x8 sprite tiles
sta tmp02
jsr nes_LoadTiles
; reset PPU address
lda #0
sta PPU_ADDR
sta PPU_ADDR
;-- reset scroll --;
sta PPU_SCROLL
sta PPU_SCROLL
.endif
;==============================================================================;
; PCE-specific section
;==============================================================================;
.ifdef __PCE__
;-- set palette --;
; first 16 background colors tbl_palettePCE_BG1
ldx #<VCE_BGPAL_START
ldy #>VCE_BGPAL_START
stx VCE_ADDR_LO
sty VCE_ADDR_HI
tia tbl_palettePCE_BG1,VCE_DATA_LO,4*2
; second 16 background colors tbl_palettePCE_BG2
ldx #<VCE_BGPAL_START+(VCE_PALSET_SIZE*1)
ldy #>VCE_BGPAL_START+(VCE_PALSET_SIZE*1)
stx VCE_ADDR_LO
sty VCE_ADDR_HI
tia tbl_palettePCE_BG2,VCE_DATA_LO,4*2
; third 16 background colors tbl_palettePCE_BG3
ldx #<VCE_BGPAL_START+(VCE_PALSET_SIZE*2)
ldy #>VCE_BGPAL_START+(VCE_PALSET_SIZE*2)
stx VCE_ADDR_LO
sty VCE_ADDR_HI
tia tbl_palettePCE_BG3,VCE_DATA_LO,4*2
; first 16 sprite colors tbl_palettePCE_SPR
ldx #<VCE_SPRPAL_START
ldy #>VCE_SPRPAL_START
stx VCE_ADDR_LO
sty VCE_ADDR_HI
tia tbl_palettePCE_SPR,VCE_DATA_LO,10*2
;-- set up self-modifying transfer code --;
ldx #$E3 ; TIA opcode
ldy #$60 ; RTS opcode
stx pce_quickTIA
sty pce_quickTIA+7
;-- load BG tiles --;
; BAT takes up first $0800 of VRAM, so put BG tiles at $1000
ldx #<pce_tilesBG
ldy #>pce_tilesBG
stx tmp00
sty tmp01
ldx #<$1000
ldy #>$1000
stx tmp02
sty tmp03
lda #80 ; 80 4BPP BG tiles
sta tmp04
jsr pce_LoadTilesBG
;-- load SPR tiles --;
; put SPR tiles at $2000
ldx #<pce_tilesSPR
ldy #>pce_tilesSPR
stx tmp00
sty tmp01
ldx #<$2000
ldy #>$2000
stx tmp02
sty tmp03
lda #5 ; 5 16x16 sprite tiles
sta tmp04
jsr pce_LoadTilesSPR
;-- clear BAT --;
; BG characters are loaded, fill the BAT with the first tile ($0100).
ldx #<$0100
ldy #>$0100
stx tmp00
sty tmp01
jsr vdc_ClearBat
.endif
;==============================================================================;
; execution is handed to the program
|
libtool/src/gmp-6.1.2/mpn/x86/atom/rshift.asm | kroggen/aergo | 1,602 | 167891 | dnl Intel Atom mpn_rshift -- mpn right shift.
dnl Copyright 2011 Free Software Foundation, Inc.
dnl Converted from AMD64 by <NAME>.
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 mp_limb_t mpn_rshift (mp_ptr dst, mp_srcptr src, mp_size_t size,
C unsigned cnt);
C cycles/limb
C P5
C P6 model 0-8,10-12
C P6 model 9 (Banias)
C P6 model 13 (Dothan)
C P4 model 0 (Willamette)
C P4 model 1 (?)
C P4 model 2 (Northwood)
C P4 model 3 (Prescott)
C P4 model 4 (Nocona)
C Intel Atom 5
C AMD K6
C AMD K7
C AMD K8
C AMD K10
defframe(PARAM_CNT, 16)
defframe(PARAM_SIZE,12)
defframe(PARAM_SRC, 8)
defframe(PARAM_DST, 4)
dnl re-use parameter space
define(SAVE_UP,`PARAM_CNT')
define(VAR_COUNT,`PARAM_SIZE')
define(SAVE_EBX,`PARAM_SRC')
define(SAVE_EBP,`PARAM_DST')
define(`rp', `%edi')
define(`up', `%esi')
define(`cnt', `%ecx')
ASM_START()
TEXT
ALIGN(8)
deflit(`FRAME',0)
PROLOGUE(mpn_rshift)
mov PARAM_CNT, cnt
mov PARAM_SIZE, %edx
mov up, SAVE_UP
mov PARAM_SRC, up
push rp FRAME_pushl()
mov PARAM_DST, rp
mov %ebx, SAVE_EBX
shr %edx
mov (up), %eax
mov %edx, VAR_COUNT
jnc L(evn)
mov %eax, %ebx
shr %cl, %ebx
neg cnt
shl %cl, %eax
test %edx, %edx
jnz L(gt1)
mov %ebx, (rp)
jmp L(quit)
L(gt1): mov %ebp, SAVE_EBP
push %eax
mov 4(up), %eax
mov %eax, %ebp
shl %cl, %eax
jmp L(lo1)
L(evn): mov %ebp, SAVE_EBP
neg cnt
mov %eax, %ebp
mov 4(up), %edx
shl %cl, %eax
mov %edx, %ebx
shl %cl, %edx
neg cnt
decl VAR_COUNT
lea -4(rp), rp
lea 4(up), up
jz L(end)
push %eax FRAME_pushl()
ALIGN(8)
L(top): shr %cl, %ebp
or %ebp, %edx
shr %cl, %ebx
neg cnt
mov 4(up), %eax
mov %eax, %ebp
mov %edx, 4(rp)
shl %cl, %eax
lea 8(rp), rp
L(lo1): mov 8(up), %edx
or %ebx, %eax
mov %edx, %ebx
shl %cl, %edx
lea 8(up), up
neg cnt
mov %eax, (rp)
decl VAR_COUNT
jg L(top)
pop %eax FRAME_popl()
L(end):
shr %cl, %ebp
shr %cl, %ebx
or %ebp, %edx
mov SAVE_EBP, %ebp
mov %edx, 4(rp)
mov %ebx, 8(rp)
L(quit):
mov SAVE_UP, up
mov SAVE_EBX, %ebx
pop rp FRAME_popl()
ret
EPILOGUE()
ASM_END()
|
src/foundation/HispanoAO/FoundationValues.asm | Dunkansdk/AoW | 2 | 243496 | ;//////////////////////////////////////////////////////////////////////
;/// This file is subject to the terms and conditions defined in ///
;/// file 'LICENSE.txt', which is part of this source code package. ///
;//////////////////////////////////////////////////////////////////////
[SEGMENT .text]
;////////////////////////////////////////////////////
;///!< Default filename
;////////////////////////////////////////////////////
__szFilename DB "HispanoAO.exe", 0x00
;////////////////////////////////////////////////////
;///!< Packets header
;////////////////////////////////////////////////////
__szPacketCharacterStat DB "", 0x00
;////////////////////////////////////////////////////
;///!< Max interval of the speedhack
;////////////////////////////////////////////////////
SPEEDHACK_MAX_INTERVAL: EQU 0x00000010
;////////////////////////////////////////////////////
;///!< Cooldown of potions
;////////////////////////////////////////////////////
POTION_MAX_INTERVAL: EQU 0x00000000
|
src/tom/library/sl/ada/allsstrategy.ads | rewriting/tom | 36 | 15568 | with ObjectPack, AbstractStrategyCombinatorPackage, IntrospectorPackage, StrategyPackage;
use ObjectPack, AbstractStrategyCombinatorPackage, IntrospectorPackage, StrategyPackage;
package AllsStrategy is
ARG : constant Integer := 0;
type Alls is new AbstractStrategyCombinator and Object with null record;
----------------------------------------------------------------------------
-- Object implementation
----------------------------------------------------------------------------
function toString(o: Alls) return String;
----------------------------------------------------------------------------
-- Strategy implementation
----------------------------------------------------------------------------
function visitLight(str:access Alls; any: ObjectPtr; intro: access Introspector'Class) return ObjectPtr;
function visit(str: access Alls; intro: access Introspector'Class) return Integer;
----------------------------------------------------------------------------
procedure makeAlls(i : in out Alls; v: StrategyPtr);
function newAlls(v: StrategyPtr) return StrategyPtr;
----------------------------------------------------------------------------
end AllsStrategy;
|
imeoffesc.applescript | rcmdnk/AppleScript | 11 | 2836 | property DEBUG : false
property LOG_FILE : "~/imeoffesc.log"
property JP_LIST : {"ひらがな"}
on echo(txt)
if DEBUG then
do shell script "echo \"" & txt & "\" >> " & LOG_FILE
end if
end echo
echo("imeoffsec")
echo("Check IME")
set imeOn to false
tell application "System Events"
tell process "SystemUIServer"
set imeStatus to value of first menu bar item of menu bar 1 whose description is "text input"
end tell
end tell
echo("imeStatus: " & imeStatus)
repeat with j in JP_LIST
if imeStatus starts with j then
set imeOn to true
exit repeat
end if
end repeat
echo("imeOn: " & imeOn)
tell application "System Events"
set pList to name of every process whose frontmost is true
set appName to item 1 of pList
tell process appName
-- 53: ESC
-- 102: EISU
if imeOn then
key code 53
key code 102
key code 53
else
log ("send ESC")
key code 53
end if
end tell
end tell
|
src/nso-json-gnoga_object.ads | SSOCsoft/Log_Reporter | 0 | 23752 | Pragma Ada_2012;
With
Gnoga.Gui.Base
;
Package NSO.JSON.Gnoga_Object is --with Elaborate_Body is
Use Gnoga.Gui.Base;
Subtype JSON_Class is NSO.JSON.Instance'Class;
-- Returns the JSON format of the form parameters from the given object.
-- NOTE: This method does NOT work with multi-select selections; when
-- such is attempted, later values overwrite the former values.
Function Get_JSON( Object : Base_Type'Class ) return JSON_Class;
Type Form_Object is new Base_Type with private;
Function As_Form (Object : Base_Type'Class) return Form_Object;
Function Parameters (Object : Form_Object) return JSON_Class;
-- REPORT_VIEW
-- This function ties together four types:
-- (1) A Form-type, which is the ultimate data-source;
-- (2) The Params-type, which represents the data submitted by the form;
-- (3) The Report-type, which is the filtered/processed Params; and
-- (4) The View-type, which is the rendering-media for the report.
--
-- As an example, consider the situation of the daily-log, within this setup
-- the form has Weather-reports which must be processed (filtered/colated)
-- into an actual report. After this, the report is processed into HTML and
-- sent in an email.
--
-- Process: [HTML_FORM] -> [PARAMETERS] -> [REPORT_OBJECT] -> [HTML_VIEW].
Generic
Type Form (<>) is new Form_Object with private;
Type Params(<>) is limited private;
Type Report(<>) is limited private;
Type View (<>) is limited private;
-- Retrieve the submitted form data.
with Function Submission(Object : Form ) return Params is <>;
-- Filter data and [re]construct the report.
with Function Parameters(Object : Params) return Report is <>;
-- Transform the report-data into some viewable data.
with Function Processing(Object : Report) return View is <>;
Function Report_View (Object : Form_Object'Class) Return View;
-- GENERIC_REPORTER
--
Generic
Type Form (<>) is new Form_Object with private;
Type Params(<>) is limited private;
-- Retrieve the submitted form data.
with Function Parameters(Object : Form) return Params is <>;
This : in Form_Object'Class;
Package Generic_Reporter is
Original_Parameters : Constant Params := Parameters( Form(This) );
Generic
-- The particular report we are getting.
Type Report(<>) is limited private;
-- The type for the final display.
Type View (<>) is limited private;
-- Filter the data and [re]construct the report.
with Function Get_Report(Object : Params:= Original_Parameters) return Report is <>;
-- Transform the report-data into some viewable data.
with Function Processing(Object : Report:= Get_Report) return View is <>;
Function Generate_Report return View;
End Generic_Reporter;
Private
Type Form_Object is new Base_Type with null record;
End NSO.JSON.Gnoga_Object;
|
oeis/170/A170203.asm | neoneye/loda-programs | 11 | 84356 | ; A170203: Number of reduced words of length n in Coxeter group on 50 generators S_i with relations (S_i)^2 = (S_i S_j)^39 = I.
; 1,50,2450,120050,5882450,288240050,14123762450,692064360050,33911153642450,1661646528480050,81420679895522450,3989613314880600050,195491052429149402450,9579061569028320720050,469374016882387715282450
add $0,1
mov $3,1
lpb $0
sub $0,1
add $2,$3
div $3,$2
mul $2,49
lpe
mov $0,$2
div $0,49
|
MIPS/Pre/1.asm | JJLeo/BUAA-CO-2020 | 9 | 9149 | .data
str: .asciiz "Hello World"
.text
la $a0,str
li $v0,4
syscall
li $v0,10
syscall |
tests/src/orka_tests.adb | onox/orka | 52 | 25440 | <gh_stars>10-100
with AUnit.Reporter.Text;
with AUnit.Run;
with AUnit.Test_Suites;
with Test_SIMD_SSE_Arithmetic;
with Test_SIMD_SSE_Compare;
with Test_SIMD_SSE_Logical;
with Test_SIMD_SSE_Math;
with Test_SIMD_SSE_Swizzle;
with Test_SIMD_SSE4_1_Math;
with Test_SIMD_AVX_Arithmetic;
with Test_SIMD_AVX_Compare;
with Test_SIMD_AVX_Math;
with Test_SIMD_AVX_Swizzle;
with Test_SIMD_AVX2_Swizzle;
with Test_SIMD_FMA_Singles_Arithmetic;
with Test_SIMD_FMA_Doubles_Arithmetic;
with Test_Transforms_Singles_Matrices;
with Test_Transforms_Singles_Quaternions;
with Test_Transforms_Singles_Vectors;
with Test_Transforms_Doubles_Matrices;
with Test_Transforms_Doubles_Vectors;
with Test_Scene_Trees;
procedure Orka_Tests is
function Suite return AUnit.Test_Suites.Access_Test_Suite;
function Suite return AUnit.Test_Suites.Access_Test_Suite is
Result : constant AUnit.Test_Suites.Access_Test_Suite :=
AUnit.Test_Suites.New_Suite;
begin
-- SIMD > SSE (Single)
Result.Add_Test (Test_SIMD_SSE_Arithmetic.Suite);
Result.Add_Test (Test_SIMD_SSE_Compare.Suite);
Result.Add_Test (Test_SIMD_SSE_Logical.Suite);
Result.Add_Test (Test_SIMD_SSE_Math.Suite);
Result.Add_Test (Test_SIMD_SSE_Swizzle.Suite);
-- SIMD > SSE4.1 (Singles)
Result.Add_Test (Test_SIMD_SSE4_1_Math.Suite);
-- SIMD > AVX (Doubles)
Result.Add_Test (Test_SIMD_AVX_Arithmetic.Suite);
Result.Add_Test (Test_SIMD_AVX_Compare.Suite);
Result.Add_Test (Test_SIMD_AVX_Math.Suite);
Result.Add_Test (Test_SIMD_AVX_Swizzle.Suite);
-- SIMD > AVX2 (Doubles)
Result.Add_Test (Test_SIMD_AVX2_Swizzle.Suite);
-- SIMD > FMA (Singles)
Result.Add_Test (Test_SIMD_FMA_Singles_Arithmetic.Suite);
-- SIMD > FMA (Doubles)
Result.Add_Test (Test_SIMD_FMA_Doubles_Arithmetic.Suite);
-- Transforms (Singles)
Result.Add_Test (Test_Transforms_Singles_Matrices.Suite);
Result.Add_Test (Test_Transforms_Singles_Vectors.Suite);
Result.Add_Test (Test_Transforms_Singles_Quaternions.Suite);
-- Transforms (Doubles)
Result.Add_Test (Test_Transforms_Doubles_Matrices.Suite);
Result.Add_Test (Test_Transforms_Doubles_Vectors.Suite);
-- Trees
Result.Add_Test (Test_Scene_Trees.Suite);
return Result;
end Suite;
procedure Runner is new AUnit.Run.Test_Runner (Suite);
Reporter : AUnit.Reporter.Text.Text_Reporter;
begin
Reporter.Set_Use_ANSI_Colors (True);
Runner (Reporter);
end Orka_Tests;
|
Ada/inc/Problem_52.ads | Tim-Tom/project-euler | 0 | 24711 | <filename>Ada/inc/Problem_52.ads
package Problem_52 is
procedure Solve;
end Problem_52;
|
src/test/resources/test/hello2.g4 | prs1022/antlr_query | 1 | 930 | grammar hello2;
STRING : [a-zA-Z ]+;
HW:'hello world';
root:STRING #h1
|HW #h2
; |
Ada/finalize/object.ads | egustafson/sandbox | 2 | 6983 | with Ada.Finalization;
package Object is
type Object is new Ada.Finalization.Controlled with private;
function New_Object( X : in Integer ) return Object;
procedure Put( O : Object );
private
type Object is new Ada.Finalization.Controlled with
record
X : Integer := 0;
end record;
|
test/succeed/builtinInModule.agda | asr/agda-kanso | 1 | 1450 | <reponame>asr/agda-kanso<filename>test/succeed/builtinInModule.agda
module builtinInModule where
module Int where
postulate I : Set
{-# BUILTIN INTEGER I #-}
primitive primIntegerPlus : I -> I -> I
|
programs/oeis/204/A204095.asm | karttu/loda | 0 | 3523 | ; A204095: Numbers whose base 10 digits are a subset of {0, 8}.
; 0,8,80,88,800,808,880,888,8000,8008,8080,8088,8800,8808,8880,8888,80000,80008,80080,80088,80800,80808,80880,80888,88000,88008,88080,88088,88800,88808,88880,88888,800000,800008,800080,800088,800800,800808,800880,800888,808000,808008,808080,808088,808800,808808,808880,808888,880000,880008,880080,880088,880800,880808,880880,880888,888000,888008,888080,888088,888800,888808,888880,888888,8000000,8000008,8000080,8000088,8000800,8000808,8000880,8000888,8008000,8008008,8008080,8008088,8008800,8008808,8008880,8008888,8080000,8080008,8080080,8080088,8080800,8080808,8080880,8080888,8088000,8088008,8088080,8088088,8088800,8088808,8088880,8088888,8800000,8800008,8800080,8800088,8800800,8800808,8800880,8800888,8808000,8808008,8808080,8808088,8808800,8808808,8808880,8808888,8880000,8880008,8880080,8880088,8880800,8880808,8880880,8880888,8888000,8888008,8888080,8888088,8888800,8888808,8888880,8888888,80000000,80000008,80000080,80000088,80000800,80000808,80000880,80000888,80008000,80008008,80008080,80008088,80008800,80008808,80008880,80008888,80080000,80080008,80080080,80080088,80080800,80080808,80080880,80080888,80088000,80088008,80088080,80088088,80088800,80088808,80088880,80088888,80800000,80800008,80800080,80800088,80800800,80800808,80800880,80800888,80808000,80808008,80808080,80808088,80808800,80808808,80808880,80808888,80880000,80880008,80880080,80880088,80880800,80880808,80880880,80880888,80888000,80888008,80888080,80888088,80888800,80888808,80888880,80888888,88000000,88000008,88000080,88000088,88000800,88000808,88000880,88000888,88008000,88008008,88008080,88008088,88008800,88008808,88008880,88008888,88080000,88080008,88080080,88080088,88080800,88080808,88080880,88080888,88088000,88088008,88088080,88088088,88088800,88088808,88088880,88088888,88800000,88800008,88800080,88800088,88800800,88800808,88800880,88800888,88808000,88808008,88808080,88808088,88808800,88808808,88808880,88808888,88880000,88880008,88880080,88880088,88880800,88880808,88880880,88880888,88888000,88888008
cal $0,99820 ; Even nonnegative integers in base 2 (bisection of A007088).
mov $1,$0
div $1,10
mul $1,8
|
src/fltk-widgets-clocks-updated.ads | micahwelf/FLTK-Ada | 1 | 27160 |
package FLTK.Widgets.Clocks.Updated is
type Updated_Clock is new Clock with private;
type Updated_Clock_Reference (Data : not null access Updated_Clock'Class) is
limited null record with Implicit_Dereference => Data;
package Forge is
function Create
(X, Y, W, H : in Integer;
Text : in String)
return Updated_Clock;
function Create
(Kind : in Box_Kind;
X, Y, W, H : in Integer;
Text : in String)
return Updated_Clock;
end Forge;
procedure Draw
(This : in out Updated_Clock);
procedure Draw
(This : in out Clock;
X, Y, W, H : in Integer);
function Handle
(This : in out Updated_Clock;
Event : in Event_Kind)
return Event_Outcome;
private
type Updated_Clock is new Clock with null record;
overriding procedure Finalize
(This : in out Updated_Clock);
pragma Inline (Draw);
pragma Inline (Handle);
end FLTK.Widgets.Clocks.Updated;
|
Assembly/textbox/casino_slotMachine.asm | WildGenie/Ninokuni | 14 | 23050 | <gh_stars>10-100
;;----------------------------------------------------------------------------;;
;; Align the position of the numbers in slot machines of casino.
;; Copyright 2015 <NAME> (aka pleonex)
;;
;; Licensed under the Apache License, Version 2.0 (the "License");
;; you may not use this file except in compliance with the License.
;; You may obtain a copy of the License at
;;
;; http://www.apache.org/licenses/LICENSE-2.0
;;
;; Unless required by applicable law or agreed to in writing, software
;; distributed under the License is distributed on an "AS IS" BASIS,
;; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
;; See the License for the specific language governing permissions and
;; limitations under the License.
;;----------------------------------------------------------------------------;;
; # Position of total round number and (shared) won round number
.arm
.org 0x0207E9F4
MOV R1, #0x40 + 20 ; X pos
MOV R2, #0xAD ; Y pos
; # Separation between chars
.org 0x0207EA20
MOV R1, #1
; # Relative position for won round number
.arm
.org 0x0207D444
MOV R1, #0x4E + 1
; # Format strings
.org 0x0207D470
.word 0x2092DE8 ; "%03d" (total rounds >= 999)
.word 0x2092DF0 - 8 ; "%3d" (total rounds < 999)
.word 0x2092DF4 ; "%03d" (won rounds >= 999)
.word 0x2092DFC - 8 ; "%3d" (won rounds < 999)
|
programs/oeis/273/A273678.asm | karttu/loda | 0 | 171589 | <gh_stars>0
; A273678: First differences of number of active (ON,black) cells in n-th stage of growth of two-dimensional cellular automaton defined by "Rule 833", based on the 5-celled von Neumann neighborhood.
; 3,13,16,23,29,35,41,47,53,59,65,71,77,83,89,95,101,107,113,119,125,131,137,143,149,155,161,167,173,179,185,191,197,203,209,215,221,227,233,239,245,251,257,263,269,275,281,287,293,299,305,311,317,323,329,335,341,347,353,359,365,371,377,383,389,395,401,407,413,419,425,431,437,443,449,455,461,467,473,479,485,491,497,503,509,515,521,527,533,539,545,551,557,563,569,575,581,587,593,599,605,611,617,623,629,635,641,647,653,659,665,671,677,683,689,695,701,707,713,719,725,731,737,743,749,755,761,767
mov $5,$0
lpb $0,1
sub $0,1
gcd $3,4
mov $4,$3
mul $3,$0
add $3,1
lpe
mov $1,$4
add $1,3
mov $2,$5
mul $2,6
add $1,$2
|
programs/oeis/158/A158121.asm | karttu/loda | 1 | 93319 | ; A158121: Given n points in the complex plane, let M(n) the number of distinct Moebius transformations that take 3 distinct points to 3 distinct points. Note that the triples may have some or all of the points in common.
; 6,93,591,2381,7316,18761,42253,86281,163186,290181,490491,794613,1241696,1881041,2773721,3994321,5632798,7796461,10612071,14228061,18816876,24577433,31737701,40557401,51330826,64389781,80106643,98897541,121225656,147604641,178602161,214843553,257015606,305870461,362229631,426988141,501118788,585676521,681802941,790730921,913789346,1052407973,1208122411,1382579221,1577541136,1794892401,2036644233,2304940401,2602062926,2930437901,3292641431,3691405693,4129625116,4610362681,5136856341,5712525561,6340977978,7026016181,7771644611,8582076581,9461741416,10415291713,11447610721,12563819841,13769286246,15069630621,16470735023,17978750861,19600106996,21341517961,23209992301,25212841033,27357686226,29652469701,32105461851,34725270581,37520850368,40501511441,43676929081,47057153041,50652617086,54474148653,58532978631,62840751261,67409534156,72251828441,77380579013,82809184921,88551509866,94621892821,101035158771,107806629573,114952134936,122488023521,130431174161,138799007201,147609495958,156881178301,166633168351,176885168301,187657480356,198971018793,210847322141,223308565481,236377572866,250077829861,264433496203,279469418581,295211143536,311684930481,328917764841,346937371313,365772227246,385451576141,406005441271,427464639421,449860794748,473226352761,497594594421,522999650361,549476515226,577061062133,605790057251,635701174501,666833010376,699225098881,732917926593,767952947841,804372600006,842220318941,881540554511,922378786253,964781539156,1008796399561,1054472031181,1101858191241,1151005746738,1201966690821,1254794159291,1309542447221,1366267025696,1425024558673,1485872919961,1548871210321,1614079774686,1681560219501,1751375430183,1823589588701,1898268191276,1975478066201,2055287391781,2137765714393,2222983966666,2311014485781,2401931031891,2495808806661,2592724471928,2692756168481,2795983534961,2902487726881,3012351435766,3125658908413,3242495966271,3362950024941,3487110113796,3615066895721,3746912686973,3882741477161,4022648949346,4166732500261,4315091260651,4467826115733,4625039725776,4786836546801,4953322851401,5124606749681,5300798210318,5482009081741,5668353113431,5859945977341,6056905289436,6259350631353,6467403572181,6681187690361,6900828595706,7126453951541,7358193496963,7596179069221,7840544626216,8091426269121,8348962265121,8613293070273,8884561352486,9162912014621,9448492217711,9741451404301,10041941321908,10350116046601,10666132006701,10990148006601,11322325250706,11662827367493,12011820433691,12369472998581,12735956108416,13111443330961,13496110780153,13890137140881,14293703693886,14706994340781,15130195629191,15563496778013,16007089702796,16461169041241,16925932178821,17401579274521,17888313286698,18386339999061,18895868046771,19417108942661,19950277103576,20495589876833,21053267566801,21623533461601,22206613859926,22802738097981,23412138576543,24035050788141,24671713344356,25322368003241,25987259696861,26666636558953,27360749952706,28069854498661,28794208102731,29534071984341,30289710704688,31061392195121,31849387785641,32653972233521,33475423752046,34314024039373,35170058307511,36043815311421,36935587378236,37845670436601,38774364046133,39721971427001,40688799489626,41675158864501
mov $1,6
mov $2,$0
add $2,3
bin $2,3
mul $1,$2
bin $1,2
sub $1,15
div $1,3
add $1,6
|
oeis/012/A012814.asm | neoneye/loda-programs | 11 | 17264 | ; A012814: Take every 5th term of Padovan sequence A000931, beginning with the third term.
; Submitted by <NAME>
; 0,1,5,21,86,351,1432,5842,23833,97229,396655,1618192,6601569,26931732,109870576,448227521,1828587033,7459895657,30433357674,124155792775,506505428836,2066337330754,8429820731201,34390259761825,140298353215075,572360547759276,2334999585697905,9525854090667496,38861632658305136,158539746514553601,646778056030214957,2638592926751165517,10764392156149521358,43914367129773159679,179152859951018878480,730871223392151275042,2981659044286454020969,12163963187814683883157,49624050985319754606951
mov $2,1
mov $3,$0
lpb $3
add $4,$2
add $1,$4
add $2,$1
sub $3,1
add $4,$1
lpe
mov $0,$1
|
programming/fpu/lab6/source.asm | tonykozlovsky/bsu | 113 | 80637 | <reponame>tonykozlovsky/bsu<gh_stars>100-1000
.386
.model flat
.data
res dq 10 dup (?)
.code
_func@8 proc
finit
push ebp
mov ebp, esp
fld qword ptr [ebp+8]
lea ebx,res
fld1
fadd st(0),st(1)
fstp qword ptr [ebx]
fld st(0)
fsin
fstp qword ptr [ebx+8]
fld1
fxch
fyl2x
fstp qword ptr [ebx+16]
lea eax,res
pop ebp
ret 8
_func@8 endp
end
|
programs/oeis/323/A323239.asm | neoneye/loda | 22 | 84563 | ; A323239: a(n) = 1 if n is odd and squarefree, otherwise a(n) = 0.
; 0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,0,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,0
mov $1,$0
trn $1,1
seq $1,7913 ; Squarefree part of n: a(n) is the smallest positive number m such that n/m is a square.
dif $1,2
sub $0,$1
cmp $0,0
|
Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_1278.asm | ljhsiun2/medusa | 9 | 5476 | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0xe5ac, %rsi
lea addresses_WC_ht+0x82fc, %rdi
nop
nop
nop
xor %rbx, %rbx
mov $47, %rcx
rep movsl
add $39422, %r11
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r13
push %r14
push %r15
push %r8
// Faulty Load
lea addresses_US+0x17f1c, %r11
and %r13, %r13
vmovaps (%r11), %ymm4
vextracti128 $0, %ymm4, %xmm4
vpextrq $0, %xmm4, %r15
lea oracles, %r13
and $0xff, %r15
shlq $12, %r15
mov (%r13,%r15,1), %r15
pop %r8
pop %r15
pop %r14
pop %r13
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'AVXalign': False, 'congruent': 0, 'size': 1, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'AVXalign': True, 'congruent': 0, 'size': 32, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 4, 'same': False}}
{'00': 21829}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
|
common/c32slr.asm | DigitalMars/optlink | 28 | 15878 | <filename>common/c32slr.asm
TITLE SLR-SUBS Copyright (c) SLR Systems, Inc 1990
INCLUDE MACROS
INCLUDE SLR32
PUBLIC FLUSHSTUFF_SLR32,PUTSTUFF_SMALL_SLR32,PUTSTUFF_SLR32,FIX_BUFFERS_SLR32
PACK_SLR SEGMENT PARA PUBLIC 'UNPACK_DATA'
SOFT EXTB POS_TABLE
SOFT EXTA POS_TABLE_LEN
PACK_SLR ENDS
.DATA
SOFT EXTD SLRBUF_PTR
.CODE PASS2_TEXT
SOFT EXTP MOVE_DSSI_TO_FINAL_HIGH_WATER,DOT
ASSUME DS:NOTHING
FLUSHSTUFF_SLR32 PROC NEAR
;
;END OF DATA, FLUSH OUT EVERYTHING
;
MOV AX,SLR_EOF
CALL PUTSTUFF_SLR32
MOV DI,SLR_TMP_PTR.OFFS
CALL FLUSH_MINI_SLR ;FLUSH PARTIAL BUFFER
CALL DO_SENDBLOCK ;DUMP BLOCK
LES DI,HUF_PUT_PTR
XOR BX,BX
MOV AL,7
CALL PUTBITS ;FLUSH LAST BYTE
MOV PUTBYTE_TEMP,DI
MOV DI,PUTBYTE_ADDR1
JMP FIX_OUTPUT
FLUSHSTUFF_SLR32 ENDP
PUTSTUFF_SMALL_SLR32 PROC NEAR
;
;AL IS CHARACTER TO OUTPUT
;
MOV DI,SLR_TMP_PTR.OFFS
STOSB
XOR AH,AH
MOV BX,AX
ADD BX,BX
INC ES:HUF_FREQ_CHAR[BX]
SHR SLR_MASK,1
JZ 51$
MOV SLR_TMP_PTR.OFFS,DI
RET
PUTSTUFF_SLR32:
;
;AX IS REPEAT COUNT
;BX IS DISTANCE
;
MOV DI,AX ;FIRST UPDATE FREQ COUNTER
if limited_charset
CMP AX,CHARSET_SIZE
JNC 1$
endif
ADD DI,DI
INC ES:HUF_FREQ_CHAR[DI] ;CHARACTER FREQUENCY
19$:
;
;NOW STORE CHAR
;
MOV DI,SLR_TMP_PTR.OFFS
STOSB
CMP AX,SLR_FIX_BUFFERS
JAE 2$
XCHG AX,BX ;IF COUNT = 2, JUST USE 1 BYTE OFFSET
OR BL,BL
JNZ 3$
STOSB
2$:
MOV SLR_TMP_PTR.OFFS,DI ;AND DON'T COUNT ANY FREQUENCY
JMP 4$
if limited_charset
1$:
INC ES:HUF_FREQ_CHAR[(CHARSET_SIZE-1)*2]
JMP 19$
endif
3$:
STOSW
XCHG AX,DI
MOV SLR_TMP_PTR.OFFS,AX
;
;HANDLE FREQ COUNTER ON OFFSET
;
SHRI DI,HARD_CODED
ADD DI,DI
INC ES:HUF_FREQ_POS[DI]
;
;UPDATE FLAGS
;
4$:
MOV AX,SLR_MASK
MOV BX,SLR_CPOS
OR ES:WPTR [BX],AX
SHR SLR_MASK,1
JZ 5$
RET
5$:
MOV DI,SLR_TMP_PTR.OFFS
;
;NEED NEW MASK
;
51$:
MOV SLR_MASK,8000H
CMP DI,HUF_MINI_BUFFER+HMB_SIZE-52
JA FLUSH_MINI_SLR
52$:
MOV SLR_CPOS,DI
XOR AX,AX
STOSW
MOV SLR_TMP_PTR.OFFS,DI
RET
FLUSH_MINI_SLR:
;
;MINI_BUFFER IS FULL, FLUSH IT TO BIG BUFFER
;
PUSHM DS,SI
MOV SLR_TMP_PTR.OFFS,DI
MOV CX,DI
MOV SI,HUF_MINI_BUFFER
SUB CX,SI ;# TO MOVE TO REAL BUFFER
LES DI,SLRBUF_PTR
ADD DI,CX ;WILL WE OVERFLOW?
JC 6$
CMP DI,MAXBUF
JA 6$
SUB DI,CX
MOV DS,SLR_VARS
OPTI_MOVSB
MOV SLRBUF_PTR.OFFS,DI
MOV DI,HUF_MINI_BUFFER
PUSH DS
POP ES
POPM SI,DS
JMP 51$
6$:
;
;BIG BUFFER IS FULL, FLUSH IT ALL
;
CALL DO_SENDBLOCK
POPM SI,DS
RET
PUTSTUFF_SMALL_SLR32 ENDP
DO_SENDBLOCK PROC NEAR
;
;FLUSH LARGE AND SMALL BUFFERS
;
MOV DS,SLR_VARS
MOV ES,SLR_VARS
CALL SENDBLOCK ;FLUSH THAT BLOCK
MOV ES,SLR_VARS
MOV DS,SLR_DATA
MOV DI,HUF_MINI_BUFFER
MOV SLR_CPOS,DI
XOR AX,AX
STOSW
MOV SLR_TMP_PTR.OFFS,DI
MOV SLRBUF_PTR.OFFS,AX
RET
DO_SENDBLOCK ENDP
MAKETREE_CHAR PROC NEAR
;
;DETERMINE HUFFMAN ENCODING FOR CHARACTERS
;
CALL INIT_HUF_INSTALL ;INITIALIZE POINTERS
LEA DI,DS:HUF_FREQ_CHAR
MOV CX,CHARSET_SIZE
XOR AX,AX
01$:
REPNE SCASW ;SKIP ANY NONZERO
JNZ 09$
LEA BX,-HUF_FREQ_CHAR-2[DI]
SHR BX,1
MOV HUF_FREQ_CHAR_LB[BX],1
JCXZ 09$
JMP 01$
09$:
LEA SI,DS:HUF_FREQ_CHAR
MOV CX,CHARSET_SIZE ;# TO CHECK
;
;BUILD TABLE OF CHARS SORTED BY FREQUENCY
;
1$:
; LODSW ;ALL HAVE AT LEAST _LB PRESENT
; OR AX,AX
; JZ 2$
PUSHM SI,CX
LEA AX,-(HUF_FREQ_CHAR)[SI]
CALL HUF_INSTALL_CHAR
POPM CX,SI
ADD SI,2
2$:
LOOP 1$
MOV HUF_AVAIL,CHARSET_SIZE*2
;
;IF TABLE LESS THAN TWO (0 OR 1), RETURN THAT FACT
;
; MOV DI,HUF_HEAP_END
; SUB DI,HUF_HEAP+2
; CMP DI,2
; JA 3$
; MOV HUF_BITLEN_CHAR[DI],0
; MOV AX,DI
; NOT AX
; RET
3$:
;
;WHILE AT LEAST TWO ENTRIES, REMOVE 2, INSTALL NEW WITH
;COMBINED FREQ, BUILD LEFT & RIGHT TABLES
;
LEA SI,DS:HUF_HEAP+4
LEA DI,DS:HUF_HEAP
PUSHM WPTR [DI],WPTR 2[DI]
MOV CX,HUF_HEAP_END
SUB CX,SI
SHR CX,1
REP MOVSW
MOV HUF_HEAP_END,DI
POPM DI,SI
MOV BX,HUF_AVAIL
SHR BX,1
SHR SI,1
SHR DI,1
MOV AL,HUF_FREQ_CHAR_LB[SI]
ADD AL,HUF_FREQ_CHAR_LB[DI]
MOV HUF_FREQ_CHAR_LB[BX],AL
PUSHF
ADD BX,BX
ADD SI,SI
ADD DI,DI
POPF
MOV AX,HUF_FREQ_CHAR[SI]
ADC AX,HUF_FREQ_CHAR[DI]
MOV HUF_FREQ_CHAR[BX],AX
ADD HUF_AVAIL,2
MOV HUF_LEFT_CHAR[BX],SI
MOV HUF_RIGHT_CHAR[BX],DI
XCHG AX,BX
CALL HUF_INSTALL_CHAR
CMP HUF_HEAP_END,OFF HUF_HEAP+2
JA 3$
;
;ZERO OUT BITLEN ARRAY
;
LEA DI,DS:HUF_BITLEN_CHAR
MOV CX,CHARSET_SIZE
XOR AX,AX
REP STOSW ;MAYBE HALF THIS IF BYTES
MOV BX,HUF_AVAIL
DEC BX
DEC BX
PUSH BX
CALL FINDBITLEN_CHAR ;USE AVAIL-2
4$:
CALL MAKECODE_CHAR ;MAKES HUF_CODEWORD TABLE
CMP BX,MAXBITLEN
JBE 5$
CALL ADJUSTLENGTH_CHAR
JMP 4$
5$:
POP AX
RET
MAKETREE_CHAR ENDP
MAKETREE_POS PROC NEAR
;
;DETERMINE HUFFMAN ENCODING FOR POSITIONS
;
CALL INIT_HUF_INSTALL ;INITIALIZE POINTERS
LEA DI,DS:HUF_FREQ_POS
MOV CX,1 SHL POS_BITS
XOR AX,AX
01$:
REPNE SCASW ;SKIP ANY NON-ZERO
JNZ 09$
LEA BX,-HUF_FREQ_POS-2[DI]
SHR BX,1
MOV HUF_FREQ_POS_LB[BX],1
JCXZ 09$
JMP 01$
09$:
LEA SI,DS:HUF_FREQ_POS
MOV CX,1 SHL POS_BITS ;# TO CHECK
;
;BUILD TABLE OF CHARS SORTED BY FREQUENCY
;
1$:
; LODSW ;ALL HAVE AT LEAST _LB PRESENT
; OR AX,AX
; JZ 2$
PUSHM SI,CX
LEA AX,-(HUF_FREQ_POS)[SI]
CALL HUF_INSTALL_POS
POPM CX,SI
ADD SI,2
2$:
LOOP 1$
MOV HUF_AVAIL,(1 SHL POS_BITS)*2
;
;IF TABLE LESS THAN TWO (0 OR 1), RETURN THAT FACT
;
; MOV DI,HUF_HEAP_END
; SUB DI,HUF_HEAP+2
; CMP DI,2
; JA 3$
; MOV HUF_BITLEN_POS[DI],0
; MOV AX,DI
; NOT AX
; RET
3$:
;
;WHILE AT LEAST TWO ENTRIES, REMOVE 2, INSTALL NEW WITH
;COMBINED FREQ, BUILD LEFT & RIGHT TABLES
;
LEA SI,DS:HUF_HEAP+4
LEA DI,DS:HUF_HEAP
PUSHM WPTR [DI],WPTR 2[DI]
MOV CX,HUF_HEAP_END
SUB CX,SI
SHR CX,1
REP MOVSW
MOV HUF_HEAP_END,DI
POPM DI,SI
MOV BX,HUF_AVAIL
SHR BX,1
SHR SI,1
SHR DI,1
MOV AL,HUF_FREQ_POS_LB[SI]
ADD AL,HUF_FREQ_POS_LB[DI]
MOV HUF_FREQ_POS_LB[BX],AL
PUSHF
ADD BX,BX
ADD SI,SI
ADD DI,DI
POPF
MOV AX,HUF_FREQ_POS[SI]
ADC AX,HUF_FREQ_POS[DI]
MOV HUF_FREQ_POS[BX],AX
ADD HUF_AVAIL,2
MOV HUF_LEFT_POS[BX],SI
MOV HUF_RIGHT_POS[BX],DI
XCHG AX,BX
CALL HUF_INSTALL_POS
CMP HUF_HEAP_END,OFF HUF_HEAP+2
JA 3$
;
;ZERO OUT BITLEN ARRAY
;
LEA DI,DS:HUF_BITLEN_POS
MOV CX,1 SHL POS_BITS
XOR AX,AX
REP STOSW ;MAYBE HALF THIS IF BYTES
MOV BX,HUF_AVAIL
DEC BX
DEC BX
PUSH BX
CALL FINDBITLEN_POS ;USE AVAIL-2
4$:
CALL MAKECODE_POS ;MAKES HUF_CODEWORD TABLE
CMP BX,MAXBITLEN
JBE 5$
CALL ADJUSTLENGTH_POS
JMP 4$
5$:
;
;RETURN
;
POP AX
RET
MAKETREE_POS ENDP
ALIGN 4
FINDBITLEN_CHAR PROC NEAR
;
;BX IS CHAR(*2) TO CALC BITLEN
;
CMP BX,CHARSET_SIZE*2
JAE 5$
MOV HUF_BITLEN_CHAR[BX],CX
RET
ALIGN 4
5$:
PUSH HUF_RIGHT_CHAR[BX]
INC CX ;HUF_DEPTH
MOV BX,HUF_LEFT_CHAR[BX]
CALL FINDBITLEN_CHAR
POP BX
CALL FINDBITLEN_CHAR
DEC CX ;HUF_DEPTH
RET
FINDBITLEN_CHAR ENDP
ALIGN 4
FINDBITLEN_POS PROC NEAR
;
;BX IS CHAR(*2) TO CALC BITLEN
;
CMP BX,(1 SHL POS_BITS)*2
JAE 5$
MOV HUF_BITLEN_POS[BX],CX
RET
ALIGN 4
5$:
PUSH HUF_RIGHT_POS[BX]
INC CX ;HUF_DEPTH
MOV BX,HUF_LEFT_POS[BX]
CALL FINDBITLEN_POS
POP BX
CALL FINDBITLEN_POS
DEC CX ;HUF_DEPTH
RET
FINDBITLEN_POS ENDP
MAKECODE_CHAR PROC NEAR
;
;BUILDS CODEWORD ARRAY FROM BITLEN ARRAY
;RETURNS MAXLEN IN BX
;
XOR SI,SI ;HIGH
XOR BX,BX ;LOW
MOV HUF_CODETEMP_LOW,BX
MOV DX,8000H ;D=8000
MOV AX,1 ;LEN=1
1$:
MOV DI,HUF_BITLEN_CHAR ;I = 0
MOV CX,CHARSET_SIZE
2$:
REPNE SCASW
JNZ 29$
MOV HUF_CODEWORD_CHAR-2-HUF_BITLEN_CHAR[DI],SI
; MOV HUF_CODEWORD_CHAR_LOW-2-HUF_BITLEN_CHAR[DI],BX
ADD BX,HUF_CODETEMP_LOW
ADC SI,DX
JNZ 2$
OR BX,BX
JNZ 2$
XCHG AX,BX
RET
29$:
INC AX ;INCREASE BITLEN
SHR DX,1
RCR HUF_CODETEMP_LOW,1
JMP 1$
MAKECODE_CHAR ENDP
MAKECODE_POS PROC NEAR
;
;BUILDS CODEWORD ARRAY FROM BITLEN ARRAY
;RETURNS MAXLEN IN BX
;
XOR SI,SI ;CODE HIGH
XOR BX,BX ;CODE LOW
MOV DX,8000H ;TEMP_HIGH
MOV HUF_CODETEMP_LOW,BX
MOV AX,1 ;LEN=1
1$:
MOV DI,HUF_BITLEN_POS ;I = 0
MOV CX,1 SHL POS_BITS
2$:
REPNE SCASW
JNZ 29$
MOV HUF_CODEWORD_POS-2-HUF_BITLEN_POS[DI],SI
; MOV HUF_CODEWORD_POS_LOW-2-HUF_BITLEN_POS[DI],BX
ADD BX,HUF_CODETEMP_LOW
ADC SI,DX
JNZ 2$
OR BX,BX
JNZ 2$
XCHG AX,BX
RET
29$:
INC AX
SHR DX,1
RCR HUF_CODETEMP_LOW,1
JMP 1$
MAKECODE_POS ENDP
ADJUSTLENGTH_CHAR PROC NEAR
;
;HANDLE CODES LONGER THAN MAXBITLEN
;
LEA DI,ES:HUF_BITLEN_CHAR
MOV CX,CHARSET_SIZE
XOR BX,BX ;CODE COUNTER
MOV AX,MAXBITLEN
;
;MARK AND COUNT ANY ABOVE OR EQUAL MAXBITLEN
;
1$:
SCASW ;ABOVE OR EQUAL?
JA 2$
DEC BX
MOV -2[DI],AX ;SET TO MAXBITLEN LENGTH
2$:
LOOP 1$
;
;NOW EXPAND SHORTER BIT PATTERNS TO MAXBITLEN LENGTH TILL ENOUGH CODES LEFT
;
MOV DX,AX
STD
LEA SI,DS:HUF_HEAP
3$:
DEC AX
LEA DI,ES:HUF_BITLEN_CHAR+CHARSET_SIZE*2-2
MOV CX,CHARSET_SIZE
4$:
REPNE SCASW
JNZ 3$
MOV 2[DI],DX ;SET TO MAXBITLEN
MOV [SI],DI ;STACK IT FOR LATER IF NEEDED
INC SI
INC SI
DEC BX
CMP HUF_CODEWORD_CHAR[DI-(HUF_BITLEN_CHAR-2)],BX
JA 4$
;
;ADD CODE TO SAVE AS MUCH AS POSSIBLE OF UNEVEN DIFFERENCE
;
JZ 8$
MOV DX,HUF_CODEWORD_CHAR[DI-(HUF_BITLEN_CHAR-2)] ;CURRENT CODE...
SUB BX,DX ;# OF BITS TO USE UP...
5$:
INC BX
MOV AX,BX
XOR CX,CX
;
;GET NEXT BITLEN TO USE
;
51$:
ADD AX,AX
INC CX
JNC 51$
;
;MAKE DI POINT TO 2 PAST ITEM TO CHANGE
;
CMP SI,HUF_HEAP
JZ 52$
DEC SI
DEC SI
MOV DI,[SI] ;PTS TO BITLEN
CMP SI,HUF_HEAP
JNZ 53$
MOV 2[DI],CX ;NEW BITLEN
MOV HUF_CODEWORD_CHAR[DI-(HUF_BITLEN_CHAR-2)],DX
LEA DI,DS:HUF_BITLEN_CHAR+CHARSET_SIZE*2-2
JMP 54$
52$:
PUSHM CX
MOV CX,CHARSET_SIZE
MOV AX,MAXBITLEN
REPNE SCASW
POPM CX
53$:
MOV 2[DI],CX ;NEW BITLEN
MOV HUF_CODEWORD_CHAR[DI-(HUF_BITLEN_CHAR-2)],DX
54$:
MOV AX,1
ROR AX,CL
ADD DX,AX
XOR BX,AX
JNZ 5$
8$: ;EXIT
XOR BX,BX
LEA DI,ES:HUF_BITLEN_CHAR+CHARSET_SIZE*2-2
MOV CX,CHARSET_SIZE
MOV AX,MAXBITLEN
81$:
REPNE SCASW
JNZ 82$
DEC BX
MOV HUF_CODEWORD_CHAR[DI-(HUF_BITLEN_CHAR-2)],BX
JMP 81$
82$:
CLD
RET
ADJUSTLENGTH_CHAR ENDP
ADJUSTLENGTH_POS PROC NEAR
;
;HANDLE CODES LONGER THAN MAXBITLEN
;
LEA DI,ES:HUF_BITLEN_POS
MOV CX,1 SHL POS_BITS
XOR BX,BX ;CODE COUNTER
MOV AX,MAXBITLEN
;
;MARK AND COUNT ANY ABOVE OR EQUAL MAXBITLEN
;
1$:
SCASW
JA 2$
DEC BX
MOV -2[DI],AX
2$:
LOOP 1$
;
;NOW EXPAND SHORTER BIT PATTERNS TO MAXBITLEN LENGTH TILL ENOUGH CODES LEFT
;
MOV DX,AX
STD
LEA SI,DS:HUF_HEAP
3$:
DEC AX
LEA DI,ES:HUF_BITLEN_POS+(1 SHL POS_BITS)*2-2
MOV CX,1 SHL POS_BITS
4$:
REPNE SCASW
JNZ 3$
MOV 2[DI],DX ;SET TO MAXBITLEN
MOV [SI],DI
INC SI
INC SI
DEC BX
CMP HUF_CODEWORD_POS[DI-(HUF_BITLEN_POS-2)],BX
JA 4$
;
;ADD CODE TO SAVE AS MUCH AS POSSIBLE OF UNEVEN DIFFERENCE
;
JZ 8$
MOV DX,HUF_CODEWORD_POS[DI-(HUF_BITLEN_POS-2)] ;CURRENT CODE...
SUB BX,DX ;# OF BITS TO USE UP...
5$:
INC BX
MOV AX,BX
XOR CX,CX
;
;GET NEXT BITLEN TO USE
;
51$:
ADD AX,AX
INC CX
JNC 51$
;
;MAKE DI POINT TO 2 PAST ITEM TO CHANGE
;
CMP SI,HUF_HEAP
JZ 52$
DEC SI
DEC SI
MOV DI,[SI] ;PTS TO BITLEN
CMP SI,HUF_HEAP
JNZ 53$
MOV 2[DI],CX ;NEW BITLEN
MOV HUF_CODEWORD_POS[DI-(HUF_BITLEN_POS-2)],DX
LEA DI,DS:HUF_BITLEN_POS+(1 SHL POS_BITS)*2-2
JMP 54$
52$:
PUSHM CX
MOV CX,1 SHL POS_BITS
MOV AX,MAXBITLEN
REPNE SCASW
POPM CX
53$:
MOV 2[DI],CX ;NEW BITLEN
MOV HUF_CODEWORD_POS[DI-(HUF_BITLEN_POS-2)],DX
54$:
MOV AX,1
ROR AX,CL
ADD DX,AX
XOR BX,AX
JNZ 5$
8$: ;EXIT
XOR BX,BX
LEA DI,ES:HUF_BITLEN_POS+(1 SHL POS_BITS)*2-2
MOV CX,1 SHL POS_BITS
MOV AX,MAXBITLEN
81$:
REPNE SCASW
JNZ 82$
DEC BX
MOV HUF_CODEWORD_POS[DI-(HUF_BITLEN_POS-2)],BX
JMP 81$
82$:
CLD
RET
ADJUSTLENGTH_POS ENDP
SENDBLOCK PROC NEAR
;
;ds and es are SLR_VARS
;
;
;DETERMINE IF WE ARE USING A NEW HUFFMAN TABLE, OR THE OLD ONE...
;
if limited_charset
INC DS:HUF_FREQ_CHAR[(CHARSET_SIZE-1)*2]
else
INC DS:HUF_FREQ_CHAR[SLR_BLOCK_END*2]
endif
MOV HUF_TOTALS.HW,-1 ;IN CASE FIRST TIME
BITT HUF_FIRST_TIME
JZ 0$
MOV DI,HUF_PUT_PTR.OFFS
MOV AX,SLR_BLOCK_END
CALL ENCODE_CHARACTER
MOV HUF_PUT_PTR.OFFS,DI
MOV SI,HUF_BITLEN_CHAR ;SAVE OLD BITLEN STUFF
MOV DI,HUF_BITLEN_CHAR_OLD
MOV CX,CHARSET_SIZE
REP MOVSW
; MOV DI,HUF_BITLEN_CHAR ;CAN'T USE IF ANY ZERO
; MOV CX,CHARSET_SIZE
; XOR AX,AX
;01$:
; REPNE SCASW
; JNZ 04$
; CMP (HUF_FREQ_CHAR-HUF_BITLEN_CHAR-2)[DI],AX
; JNZ 0$
; CMP AX,DI
; JMP 01$
;
;04$:
CALL CALC_SIZE_CHAR ;CALC # OF BITS REQUIRED
0$:
PUSHM HUF_TOTALS.HW,HUF_TOTALS.LW
CALL MAKETREE_CHAR ;HANDLE HUFMAN ENCODING
;
;TELL THEM HOW MANY CHARS TO EXPECT
;
MOV DI,HUF_PUT_PTR.OFFS
; OR AX,AX
; JS 1$
; XCHG AX,BX
; MOV BX,HUF_FREQ_CHAR[BX]
; MOV HUF_SIZE,BX
; MOV AX,BUFBITS ;16
; CALL PUTBITS
;
;NOW DETERMINE WHICH TABLE SAVES MORE BITS...
;
CALL CALC_SIZE_CHAR
PUSH DI
MOV CX,CHARSET_SIZE
MOV DI,HUF_BITLEN_CHAR
CALL GET_HUFTABLE_SIZE ;IN DX:AX
MOV HUF_TREESIZE_CHAR,AX
POP DI
ADD AX,HUF_TOTALS.LW
ADC DX,HUF_TOTALS.HW
POPM BX,CX
CMP DX,CX
JA 05$ ;USE OLD
JB 06$ ;USE NEW
CMP AX,BX
JA 05$
06$:
;
;USING A NEW TABLE
;
MOV AL,1
CALL PUTBIT
CALL WRITETREE_CHAR
JMP 2$
05$:
;
;USING PREVIOUS TABLE...
;
MOV AL,0
CALL PUTBIT
;
;RESTORE OLD TABLE
;
PUSH DI
MOV DI,HUF_BITLEN_CHAR ;SAVE OLD BITLEN STUFF
MOV SI,HUF_BITLEN_CHAR_OLD
MOV CX,CHARSET_SIZE
REP MOVSW
CALL MAKECODE_CHAR
POP DI
; JMP 2$
;
;1$:
; NOT AX
; XCHG AX,BX
; PUSH BX
; MOV BX,HUF_FREQ_CHAR[BX]
; MOV HUF_SIZE,BX
; MOV AX,BUFBITS ;16
; CALL PUTBITS
; MOV AL,1 ;NEW TABLE COMING...
; CALL PUTBIT
; MOV CX,3
;11$:
; PUSH CX
; MOV BX,1 SHL LENFIELD
; MOV AX,LENFIELD+1
; CALL PUTBITS
; POP CX
; LOOP 11$
; POP BX
; MOV AX,9
; CALL PUTBITS
2$:
MOV HUF_PUT_PTR.OFFS,DI
;
;NOW DETERMINE SMALLEST POSSIBILITY FOR POSITION TREE
;
;READYMADE AND MAKECODE ALREADY DONE...
;
; MOV DI,HUF_FREQ_POS
; MOV CX,1 SHL POS_BITS
; XOR AX,AX
;20$:
; REPNE SCASW
; JNZ 201$
; INC WPTR -2[DI]
; JMP 20$
;201$:
MOV HUF_TOTALS.HW,-1 ;CAN'T USE OLD IF FIRST TIME
BITT HUF_FIRST_TIME
JZ 21$
MOV SI,HUF_BITLEN_POS ;SAVE OLD BITLEN STUFF
MOV DI,HUF_BITLEN_POS_OLD
MOV CX,1 SHL POS_BITS
REP MOVSW
;
;CAN'T USE OLD IF IT HAS A ZERO WHERE I NEED SOMETHING NOW...
;
; MOV DI,HUF_BITLEN_POS ;CAN'T USE IF ANY ZERO
; MOV CX,1 SHL POS_BITS
; XOR AX,AX
;202$:
; REPNE SCASW
; JNZ 205$
; CMP (HUF_FREQ_POS-HUF_BITLEN_POS-2)[DI],AX
; JNZ 21$
; CMP AX,DI
; JMP 202$
;
;205$:
CALL CALC_SIZE_POS
21$:
PUSHM HUF_TOTALS.HW,HUF_TOTALS.LW
CALL FIX_READY
CALL CALC_SIZE_POS
PUSHM HUF_TOTALS.HW,HUF_TOTALS.LW
CALL MAKETREE_POS
MOV HUF_MAKETREE_POS_FLAGS,AX
CALL CALC_SIZE_POS
MOV CX,(1 SHL POS_BITS)
MOV DI,HUF_BITLEN_POS
CALL GET_HUFTABLE_SIZE ;IN DX:AX
MOV HUF_TREESIZE_POS,AX
ADD AX,HUF_TOTALS.LW
ADC DX,HUF_TOTALS.HW
;
;OK, I WANT THE SMALLEST, PREFERABLY PREVIOUS TREE
;
MOV DI,HUF_PUT_PTR.OFFS
POPM BX,CX ;READY MADE
CMP CX,DX
JA 26$ ;NEW SMALLER THAN READY-MADE
JB 27$ ;READY-MADE SMALLER THAN NEW
CMP BX,AX
JB 27$ ;READY-MADE SMALLER THAN NEW
26$:
;
;HERE NEW (DX:AX) IS SMALLER THAN READY-MADE
;
POPM BX,CX ;PREVIOUS TREE
CMP CX,DX
JA 30$ ;USE NEW
JB 31$ ;USE PREVIOUS
CMP BX,AX
JA 30$ ;USE NEW
JMP 31$ ;USE PREVIOUS
27$:
;
;HERE READY-MADE (CX:BX) IS SMALLER THAN NEW
;
POPM AX,DX ;PREVIOUS TREE
CMP CX,DX
JA 31$ ;USE PREVIOUS
JB 32$ ;USE READY-MADE
CMP BX,AX
JAE 31$ ;USE PREVIOUS
JMP 32$ ;USE READY-MADE
30$:
;
;USE NEW TREE
;
MOV AL,1
CALL PUTBIT
MOV AX,HUF_MAKETREE_POS_FLAGS
; OR AX,AX
; JS 4$
CALL WRITETREE_POS
JMP 5$
31$:
;
;USE PREVIOUS TREE
;
MOV BL,0
MOV AL,2
CALL PUTBITS
PUSH DI
MOV DI,HUF_BITLEN_POS ;SAVE OLD BITLEN STUFF
MOV SI,HUF_BITLEN_POS_OLD
MOV CX,1 SHL POS_BITS
REP MOVSW
JMP 39$ ;GO REBUILD CODES
32$:
;
;USE READY-MADE
;
MOV BL,1
MOV AL,2
CALL PUTBITS
PUSH DI
CALL FIX_READY
39$:
CALL MAKECODE_POS
POP DI
; JMP 5$
;
;4$:
; PUSH AX
; MOV DX,3
;41$:
; MOV AX,LENFIELD+1
; MOV BX,1 SHL LENFIELD
; CALL PUTBITS
; DEC DX
; JNZ 41$
; POP BX
; NOT BX
; MOV AL,POS_BITS
; CALL PUTBITS
5$:
SETT HUF_FIRST_TIME
LDS SI,SLRBUF_PTR
MOV DO_STUFF_LIMIT,SI
XOR SI,SI
CALL DO_STUFF
LDS SI,SLR_TMP_PTR
MOV DO_STUFF_LIMIT,SI
MOV SI,HUF_MINI_BUFFER
CALL DO_STUFF
;
;NOW ZERO OUT FREQUENCIES
;
MOV HUF_PUT_PTR.OFFS,DI
MOV DI,HUF_FREQ_CHAR
MOV CX,CHARSET_SIZE*3
XOR AX,AX
REP STOSW
MOV DI,HUF_FREQ_POS
MOV CX,(1 SHL POS_BITS)*3
REP STOSW
RET
SENDBLOCK ENDP
DO_STUFF PROC NEAR
;
;DS:SI IS DATA SOURCE...
;
LODSW
XCHG AX,DX
MOV CX,16
CMP DO_STUFF_LIMIT,SI
JBE 9$
EVEN
1$:
ADD DX,DX
JC 5$
LODSB
XOR AH,AH
PUSHM DX,CX
CALL ENCODE_CHARACTER
19$:
POPM CX,DX
CMP DO_STUFF_LIMIT,SI
JBE 9$
LOOP 1$
JMP DO_STUFF
5$:
LODSB
MOV AH,1
PUSHM DX,CX,AX
CALL ENCODE_CHARACTER
POPM AX
OR AL,AL
JZ 6$
CMP AL,SLR_FIX_BUFFERS-256
JAE 19$
LODSW
CALL ENCODE_POSITION
JMP 19$
6$:
LODSB
; XOR AH,AH
; XCHG AX,BX
; MOV AX,T2_BITS
; CALL PUTBITS
CALL PUTBYTE
JMP 19$
9$:
RET
DO_STUFF ENDP
GET_HUFTABLE_SIZE PROC NEAR
;
;CX IS SIZE OF TABLE
;DI IS POINTER TO TABLE
;
;RETURN IN DX:AX AS BITS
;
MOV DX,8 ;ONE BYTE FOR BYTE-COUNT
1$:
MOV BX,CX
MOV AX,[DI]
REPE SCASW
JZ 11$
DEC DI
DEC DI
INC CX
11$:
SUB BX,CX ;# OF ITEMS THIS BITLEN
ADD BX,15
AND BX,0FFF0H
SHR BX,1
ADD DX,BX
JCXZ 9$
JMP 1$
9$:
XCHG AX,DX
XOR DX,DX
RET
; MOV DX,CX
; XOR AX,AX
;1$:
; SCASW
; JZ 2$
; ADD DX,4
;2$:
; LOOP 1$
; XCHG AX,DX
; RET
GET_HUFTABLE_SIZE ENDP
CALC_SIZE_CHAR PROC NEAR
;
;FOR I = 0 THRU CHARSET_SIZE-1, SUM UP BITLEN*FREQ
;
XOR SI,SI ;PTR
XOR BX,BX ;CX:BX IS TOTAL # OF BITS USED
XOR CX,CX
MOV HUF_TOTALS.LW,CX
MOV HUF_TOTALS.HW,CX
1$:
MOV AX,HUF_FREQ_CHAR[SI] ;FREQUENCY
MUL HUF_BITLEN_CHAR[SI] ;* BITLEN
ADD BX,AX
ADC CX,DX
ADD SI,2
CMP SI,CHARSET_SIZE*2
JNZ 1$
MOV SI,512
2$:
MOV AX,HARD_CODED ;BITLEN
MUL HUF_FREQ_CHAR[SI] ;* FREQUENCY
ADD BX,AX
ADC CX,DX
ADD SI,2
CMP SI,CHARSET_SIZE*2-3*2
JNZ 2$
MOV HUF_TOTALS.LW,BX
MOV HUF_TOTALS.HW,CX
RET
CALC_SIZE_CHAR ENDP
CALC_SIZE_POS PROC NEAR
;
;FOR I = 0 THRU 1 SHL POS_BITS, SUM UP BITLEN*FREQ
;
XOR SI,SI
XOR BX,BX
XOR CX,CX
MOV HUF_TOTALS.LW,CX
MOV HUF_TOTALS.HW,CX
1$:
MOV AX,HUF_FREQ_POS[SI]
MUL HUF_BITLEN_POS[SI]
ADD BX,AX
ADC CX,DX
ADD SI,2
CMP SI,(1 SHL POS_BITS)*2
JNZ 1$
MOV HUF_TOTALS.LW,BX
MOV HUF_TOTALS.HW,CX
RET
CALC_SIZE_POS ENDP
ALIGN 4
ENCODE_CHARACTER PROC NEAR
;
;MUST PRESERVE DX AND SI AND DI
;
PUSH AX
ADD AX,AX
if limited_charset
CMP AX,CHARSET_SIZE*2
JB 1$
MOV AX,CHARSET_SIZE*2-2
1$:
endif
XCHG AX,BX
MOV AX,ES:HUF_BITLEN_CHAR[BX]
MOV BX,ES:HUF_CODEWORD_CHAR[BX]
CALL PUTCODE ;FROM MSB
POP BX
if limited_charset
SUB BX,CHARSET_SIZE-1
JNC 2$
endif
RET
if limited_charset
2$:
MOV AX,BX
JMP PUTBYTE
endif
ENCODE_CHARACTER ENDP
ENCODE_POSITION PROC NEAR
;
;AX IS POSITION
;
PUSH AX
MOV CL,HARD_CODED-1
SHR AX,CL
AND AL,0FEH
XCHG AX,BX
MOV AX,ES:HUF_BITLEN_POS[BX]
MOV BX,ES:HUF_CODEWORD_POS[BX]
CALL PUTCODE
; POP BX
; AND BX,(1 SHL HARD_CODED)-1
; MOV AX,HARD_CODED
; JMP PUTBITS
POP AX
JMP PUTBYTE
ENCODE_POSITION ENDP
PUTBYTE PROC NEAR
STOSB
RET
PUTBYTE ENDP
; XCHG AX,BX
; XOR BH,BH
; MOV AX,8
; JMP PUTBITS
ALIGN 4,,3
PUTBIT:
XCHG AX,BX
MOV AL,1
PUTBITS PROC NEAR
;
;DATA RIGHT JUSTIFIED IN BX
;
MOV CL,16
SUB CL,AL
SHL BX,CL
PUTCODE:
;
;DATA LEFT JUSTIFIED IN BX
;AX IS # OF BITS
;
MOV CX,SLR_WORD ;# OF BITS IN TARGET
MOV DX,BX ;SAVE COPY
SHR BX,CL
OR CH,BH
ADD CL,AL
CMP CL,8
JB 9$
;
;OUTPUT CHAR IN CH
;
CALL PUTBITS_CH
SUB CL,8 ;CL IS # OF BITS LEFT IN BL
MOV CH,BL
CMP CL,8
JAE 4$
9$:
MOV SLR_WORD,CX
RET
4$:
;
;OUTPUT CHAR IN CH
;
CALL PUTBITS_CH
;
;
SUB CL,8 ;# OF BITS TO RESCUE FROM DX
SUB AL,CL
XCHG AX,CX
SHL DX,CL
MOV AH,DH
MOV SLR_WORD,AX
RET
PUTBITS ENDP
PUTBITS_CH PROC NEAR
;
;STORE BYTE IN CH
;
MOV PUTBYTE_TEMP,DI
MOV DI,PUTBYTE_ADDR1
MOV ES:[DI],CH
CMP DI,HUF_PUT_BUF+HPB_SIZE-18-CHARSET_SIZE-(1 SHL POS_BITS) ;BUFFER FULL?
JAE 2$
29$:
MOV DI,PUTBYTE_ADDR2
MOV PUTBYTE_ADDR1,DI
MOV DI,PUTBYTE_TEMP
MOV PUTBYTE_ADDR2,DI
INC DI
RET
2$:
INC DI
CALL FIX_OUTPUT
JMP 29$
PUTBITS_CH ENDP
HUF_INSTALL_POS:
MOV SI,HUF_FREQ_POS
MOV DI,HUF_FREQ_POS_LB
JMP HUF_INSTALL
HUF_INSTALL_CHAR PROC NEAR
;
;STICK THIS GUY AT CORRECT PLACE IN HEAP
;
MOV SI,HUF_FREQ_CHAR
MOV DI,HUF_FREQ_CHAR_LB
HUF_INSTALL:
PUSH AX
MOV BX,AX
MOV DX,[BX+SI] ;FREQUENCY FOR THIS ENTRY HIGH-WORD
SHR BX,1
MOV CL,[BX+DI] ;LOW BYTE
MOV BX,HUF_HEAP_END
ADD HUF_HEAP_END,2
JMP 4$
EVEN
2$:
MOV AX,[BX] ;CURRENT CHARACTER
XCHG AX,BX
CMP [BX+SI],DX ;COMPARE HIGH WORD FREQ
JA 3$
JB 5$
SHR BX,1
CMP [BX+DI],CL
JBE 5$
ADD BX,BX
3$:
XCHG AX,BX
MOV 2[BX],AX
4$:
SUB BX,2
CMP BX,HUF_HEAP
JAE 2$
XCHG AX,BX
5$:
XCHG AX,BX
POP AX
MOV 2[BX],AX
RET
HUF_INSTALL_CHAR ENDP
INIT_HUF_INSTALL PROC NEAR
; MOV HUF_HEAP_START,HUF_HEAP
MOV HUF_HEAP_END,HUF_HEAP
RET
INIT_HUF_INSTALL ENDP
FIX_BUFFERS_SLR32 PROC NEAR
MOV AX,SLR_FIX_BUFFERS
CALL PUTSTUFF_SLR32
CALL DOT
RET
FIX_BUFFERS_SLR32 ENDP
FIX_OUTPUT PROC NEAR
;
;FLUSH STUFF FROM HUF_PUT_BUF
;
PUSHM DS,SI,ES,DX,CX,BX,AX
MOV CX,DI
MOV SI,HUF_PUT_BUF
SUB CX,SI
JZ 9$
PUSH ES
POP DS
PUSH CX
CALL MOVE_DSSI_TO_FINAL_HIGH_WATER
POP CX
9$:
;
;ADJUST PTRS
;
MOV DS,SLR_VARS
MOV ES,SLR_VARS
SUB PUTBYTE_ADDR2,CX
MOV SI,HUF_PUT_BUF
MOV DI,SI
ADD SI,CX
MOV CX,PUTBYTE_TEMP
SUB CX,SI
REP MOVSB
MOV PUTBYTE_TEMP,DI
POPM AX,BX,CX,DX,ES,SI,DS
RET
FIX_OUTPUT ENDP
WRITETREE_CHAR PROC NEAR
;
;WRITE OUT HUFMAN CODE TABLE
;
MOV AX,HUF_TREESIZE_CHAR
MOV CL,3
SHR AX,CL
DEC AX
DEC AX
STOSB
;
MOV SI,HUF_BITLEN_CHAR
MOV CX,CHARSET_SIZE
1$:
XCHG SI,DI
MOV BX,CX
MOV AX,[DI]
REPE SCASW
JZ 11$
DEC DI
DEC DI
INC CX
11$:
DEC AX ;BITLEN - 1
XCHG SI,DI
SUB BX,CX ;# OF ITEMS THIS BITLEN
15$:
AND AL,0FH
;
;OUTPUT 16 AT A TIME...
;
MOV DX,16
CMP BX,DX
JA 2$
MOV DX,BX
2$:
SUB BX,DX
DEC DX
SHLI DX,4
OR AL,DL
STOSB
OR BX,BX
JNZ 15$
JCXZ 9$
JMP 1$
9$:
RET
; MOV BX,[SI]
; OR BX,BX
; MOV AL,1
; JZ 2$
; ADD BX,(1 SHL LENFIELD)-1
; ADD AL,LENFIELD
;2$:
;; MOV AL,LENFIELD
; CALL PUTBITS
; INC SI
; INC SI
; CMP SI,HUF_BITLEN_CHAR+2*CHARSET_SIZE
; JNZ 1$
; RET
WRITETREE_CHAR ENDP
WRITETREE_POS PROC NEAR
;
;WRITE OUT HUFMAN CODE TABLE
;
MOV AX,HUF_TREESIZE_POS
MOV CL,3
SHR AX,CL
DEC AX
DEC AX
STOSB
;
MOV SI,HUF_BITLEN_POS
MOV CX,1 SHL POS_BITS
1$:
XCHG SI,DI
MOV BX,CX
MOV AX,[DI]
REPE SCASW
JZ 11$
DEC DI
DEC DI
INC CX
11$:
DEC AX ;BITLEN - 1
XCHG SI,DI
SUB BX,CX ;# OF ITEMS THIS BITLEN
15$:
AND AL,0FH
;
;OUTPUT 16 AT A TIME...
;
MOV DX,16
CMP BX,DX
JA 2$
MOV DX,BX
2$:
SUB BX,DX
DEC DX
SHLI DX,4
OR AL,DL
STOSB
OR BX,BX
JNZ 15$
JCXZ 9$
JMP 1$
9$:
RET
; MOV SI,HUF_BITLEN_POS
;1$:
; MOV BX,[SI]
; OR BX,BX
; MOV AL,1
; JZ 2$
; ADD BX,(1 SHL LENFIELD)-1
; ADD AL,LENFIELD
;2$:
; MOV AL,LENFIELD
; CALL PUTBITS
; INC SI
; INC SI
; CMP SI,HUF_BITLEN_POS+2*(1 SHL POS_BITS)
; JNZ 1$
; RET
WRITETREE_POS ENDP
FIX_READY PROC NEAR
;
;
;
PUSH DS
MOV AX,PACK_SLR
MOV DS,AX
LEA SI,POS_TABLE
MOV DI,HUF_BITLEN_POS
MOV AX,1
MOV DX,POS_TABLE_LEN
XOR CH,CH
1$:
MOV CL,[SI]
INC SI
REP STOSW
INC AX
DEC DX
JNZ 1$
POP DS
RET
FIX_READY ENDP
END
|
gcc-gcc-7_3_0-release/gcc/testsuite/ada/acats/tests/ce/ce2401c.ada | best08618/asylo | 7 | 4103 | -- CE2401C.ADA
-- Grant of Unlimited Rights
--
-- Under contracts F33600-87-D-0337, F33600-84-D-0280, MDA903-79-C-0687,
-- F08630-91-C-0015, and DCA100-97-D-0025, the U.S. Government obtained
-- unlimited rights in the software and documentation contained herein.
-- Unlimited rights are defined in DFAR 252.227-7013(a)(19). By making
-- this public release, the Government intends to confer upon all
-- recipients unlimited rights equal to those held by the Government.
-- These rights include rights to use, duplicate, release or disclose the
-- released technical data and computer software in whole or in part, in
-- any manner and for any purpose whatsoever, and to have or permit others
-- to do so.
--
-- DISCLAIMER
--
-- ALL MATERIALS OR INFORMATION HEREIN RELEASED, MADE AVAILABLE OR
-- DISCLOSED ARE AS IS. THE GOVERNMENT MAKES NO EXPRESS OR IMPLIED
-- WARRANTY AS TO ANY MATTER WHATSOEVER, INCLUDING THE CONDITIONS OF THE
-- SOFTWARE, DOCUMENTATION OR OTHER INFORMATION RELEASED, MADE AVAILABLE
-- OR DISCLOSED, OR THE OWNERSHIP, MERCHANTABILITY, OR FITNESS FOR A
-- PARTICULAR PURPOSE OF SAID MATERIAL.
--*
-- OBJECTIVE:
-- CHECK READ (WITH AND WITHOUT PARAMETER FROM), WRITE (WITH
-- AND WITHOUT PARAMETER TO), SET_INDEX, INDEX, SIZE, AND
-- END_OF_FILE ARE IMPLEMENTED FOR DIRECT FILES WITH
-- ELEMENT_TYPE CONSTRAINED ARRAY, AND RECORD WITHOUT DISCRIMINANTS.
-- APPLICABILITY CRITERIA:
-- THIS TEST IS ONLY APPLICABLE TO IMPLEMENTATIONS WHICH SUPPORT
-- DIRECT FILES.
-- HISTORY:
-- ABW 08/18/82
-- SPS 09/20/82
-- SPS 11/09/82
-- JBG 05/02/83
-- JRK 03/26/84
-- EG 05/16/85
-- TBN 11/04/86 REVISED TEST TO OUTPUT A NON_APPLICABLE
-- RESULT WHEN FILES ARE NOT SUPPORTED.
-- DWC 08/10/87 ISOLATED EXCEPTIONS.
WITH REPORT; USE REPORT;
WITH DIRECT_IO;
PROCEDURE CE2401C IS
END_SUBTEST: EXCEPTION;
BEGIN
TEST ("CE2401C" , "CHECK READ, WRITE, SET_INDEX " &
"INDEX, SIZE, AND END_OF_FILE FOR " &
"DIRECT FILES FOR CONSTRAINED ARRAY TYPES, " &
"AND RECORD TYPES WITHOUT DISCRIMINANTS");
DECLARE
TYPE ARR_CN IS ARRAY (1..5) OF BOOLEAN;
PACKAGE DIR_ARR_CN IS NEW DIRECT_IO (ARR_CN);
USE DIR_ARR_CN;
FILE : FILE_TYPE;
BEGIN
BEGIN
CREATE (FILE, INOUT_FILE, LEGAL_FILE_NAME);
EXCEPTION
WHEN USE_ERROR | NAME_ERROR =>
NOT_APPLICABLE ("USE_ERROR | NAME_ERROR RAISED " &
"ON CREATE - CONSTRAINED ARRAY");
RAISE END_SUBTEST;
WHEN OTHERS =>
FAILED ("UNEXPECTED ERROR RAISED ON " &
"CREATE - CONSTRAINED ARRAY");
RAISE END_SUBTEST;
END;
DECLARE
ARR : ARR_CN := (TRUE,TRUE,FALSE,TRUE,TRUE);
ITEM : ARR_CN;
ONE : POSITIVE_COUNT := 1;
TWO : POSITIVE_COUNT := 2;
BEGIN
BEGIN
WRITE (FILE,ARR);
EXCEPTION
WHEN OTHERS =>
FAILED ("EXCEPTION RAISED ON WRITE FOR " &
"CONTRAINED ARRAY - 1");
END;
BEGIN
WRITE (FILE,ARR,TWO);
EXCEPTION
WHEN OTHERS =>
FAILED ("EXCEPTION RAISED ON WRITE FOR " &
"CONSTRAINED ARRAY - 2");
END;
BEGIN
IF SIZE (FILE) /= TWO THEN
FAILED ("SIZE FOR TYPE CONSTRAINED ARRAY");
END IF;
IF NOT END_OF_FILE (FILE) THEN
FAILED ("WRONG END_OF_FILE VALUE FOR TYPE " &
"CONSTRAINED ARRAY");
END IF;
SET_INDEX (FILE,ONE);
IF INDEX (FILE) /= ONE THEN
FAILED ("WRONG INDEX VALUE FOR TYPE " &
"CONSTRAINED ARRAY");
END IF;
END;
CLOSE (FILE);
BEGIN
OPEN (FILE, IN_FILE, LEGAL_FILE_NAME);
EXCEPTION
WHEN USE_ERROR =>
NOT_APPLICABLE ("OPEN FOR IN_FILE MODE " &
"NOT SUPPORTED - 1");
RAISE END_SUBTEST;
END;
BEGIN
READ (FILE,ITEM);
IF ITEM /= ARR THEN
FAILED ("INCORRECT ARRAY VALUES READ " &
"- 1");
END IF;
EXCEPTION
WHEN OTHERS =>
FAILED ("READ WITHOUT FROM FOR " &
"TYPE CONSTRAINED ARRAY");
END;
BEGIN
READ (FILE,ITEM,ONE);
IF ITEM /= ARR THEN
FAILED ("INCORRECT ARRAY VALUES READ " &
"- 2");
END IF;
EXCEPTION
WHEN OTHERS =>
FAILED ("READ WITH FROM FOR " &
"TYPE CONSTRAINED ARRAY");
END;
END;
BEGIN
DELETE (FILE);
EXCEPTION
WHEN USE_ERROR =>
NULL;
END;
EXCEPTION
WHEN END_SUBTEST =>
NULL;
END;
DECLARE
TYPE REC IS
RECORD
ONE : INTEGER;
TWO : INTEGER;
END RECORD;
PACKAGE DIR_REC IS NEW DIRECT_IO (REC);
USE DIR_REC;
FILE : FILE_TYPE;
BEGIN
BEGIN
CREATE (FILE, INOUT_FILE, LEGAL_FILE_NAME(2));
EXCEPTION
WHEN USE_ERROR | NAME_ERROR =>
NOT_APPLICABLE ("USE_ERROR | NAME_ERROR RAISED " &
"ON CREATE - RECORD");
RAISE END_SUBTEST;
WHEN OTHERS =>
FAILED ("UNEXPECTED ERROR RAISED ON CREATE - " &
"RECORD");
END;
DECLARE
REC1 : REC := REC'(ONE=>18,TWO=>36);
ITEM : REC;
ONE : POSITIVE_COUNT := 1;
TWO : POSITIVE_COUNT := 2;
BEGIN
BEGIN
WRITE (FILE,REC1);
EXCEPTION
WHEN OTHERS =>
FAILED ("EXCEPTION RAISED ON WRITE FOR - " &
"RECORD - 1");
END;
BEGIN
WRITE (FILE,REC1,TWO);
EXCEPTION
WHEN OTHERS =>
FAILED ("EXCEPTION RAISED ON WRITE FOR - " &
"RECORD - 2");
END;
BEGIN
IF SIZE (FILE) /= TWO THEN
FAILED ("SIZE FOR TYPE RECORD");
END IF;
IF NOT END_OF_FILE (FILE) THEN
FAILED ("WRONG END_OF_FILE VALUE FOR RECORD");
END IF;
SET_INDEX (FILE,ONE);
IF INDEX (FILE) /= ONE THEN
FAILED ("WRONG INDEX VALUE FOR TYPE RECORD");
END IF;
END;
CLOSE (FILE);
BEGIN
OPEN (FILE, IN_FILE, LEGAL_FILE_NAME(2));
EXCEPTION
WHEN USE_ERROR =>
NOT_APPLICABLE ("OPEN FOR IN_FILE MODE " &
"NOT SUPPORTED - 2");
RAISE END_SUBTEST;
END;
BEGIN
READ (FILE,ITEM);
IF ITEM /= REC1 THEN
FAILED ("INCORRECT RECORD VALUES READ " &
"- 1");
END IF;
EXCEPTION
WHEN OTHERS =>
FAILED ("READ WITHOUT FROM FOR RECORD");
END;
BEGIN
READ (FILE,ITEM,ONE);
IF ITEM /= REC1 THEN
FAILED ("INCORRECT RECORD VALUES READ " &
"- 2");
END IF;
EXCEPTION
WHEN OTHERS =>
FAILED ("READ WITH FROM FOR " &
"TYPE RECORD");
END;
END;
BEGIN
DELETE (FILE);
EXCEPTION
WHEN USE_ERROR =>
NULL;
END;
EXCEPTION
WHEN END_SUBTEST =>
NULL;
END;
RESULT;
END CE2401C;
|
grammer/Peaze.g4 | pzque/peaze | 8 | 248 | grammar Peaze;
program : topunit+;
topunit
: define # DefineTopunit
| apply # ApplyTopunit
;
define
: '(' DEFINE '(' ID paramList ')' sequence ')' # ProcDefine
| '(' DEFINE ID lambda ')' # LambdaDefine
| '(' DEFINE ID expr ')' # VarDefine
;
apply
: '(' procedure expr*')'
;
expr
: if_ # IfExpr
| literal # LiteralExpr
| apply # ApplyExpr
| lambda # LambdaExpr
| varRef # VarRefExpr
;
if_
: '(' 'if' cond expr else_body ')' # FullIf
| '(' 'if' cond expr ')' # PartialIf
;
lambda
: '(' LAMBDA '(' paramList ')' sequence ')'
;
varRef
: ID
;
literal
: Digits # IntegerLiteral
| BooleanLiteral # BooleanLiteral
| DecimalLiteral # DecimalLiteral
;
sequence
: (define|expr)+
;
procedure : expr;
cond : expr;
else_body : expr;
paramList
: ID*
;
// Keywords
LAMBDA : 'lambda';
DEFINE : 'define';
// Separators
LPAREN : '(';
RPAREN : ')';
// Operators
// Integer Literals
Digits : [0-9]+;
BooleanLiteral
: '#t'
| '#f'
;
DecimalLiteral
: Digits '.' Digits
;
ID
: [a-zA-Z0-9!$%&*+-./:<=>?@^_~]+
;
// Whitespace and comments
WS : [ \t\r\n\u000C]+ -> skip
;
COMMENT
: '/*' .*? '*/' -> skip
;
COMMENT1
: '#|' .*? '|#' -> skip
;
LINE_COMMENT
: '//' ~[\r\n]* -> skip
;
LINE_COMMENT1
: ';;;' ~[\r\n]* -> skip
; |
RADWIMPS.adb | Clapp-project/RADWIMPS | 262 | 19067 | with Ada.Text_IO;
use Ada.Text_IO;
procedure RADWIMPS is
package Rad_Package is
type Rad is tagged null record;
procedure se(Self: in Rad);
function t_hen(Self: in Rad) return Rad;
end Rad_Package;
package body Rad_Package is
procedure se(Self: in Rad) is
begin
put_line("世");
end se;
function t_hen(Self: in Rad) return Rad is
begin
put("前");
return Self;
end t_hen;
end Rad_Package;
use Rad_Package;
RADWIMPS: Rad;
begin
RADWIMPS.t_hen.t_hen.t_hen.se;
end RADWIMPS;
|
asm/globals.asm | hansbonini/smd_castlevania_bloodlines | 1 | 101118 |
// ********************************************************
// * DEBUG FLAGS: *
// * *
// * - DEBUG_STAGE(INT STAGE_NUM): *
// * Enable Stage Select *
// * *
// * - DEBUG_SUBSTAGE(INT SUBSTAGE_NUM): *
// * Select Substage: Default 1 *
// * *
// * - DEBUG_INVENCIBILITY(BOOL ENABLE): *
// * Disable Player Collision: Default 0 *
// ********************************************************
define DEBUG(0)
define DEBUG_STAGE(0)
define DEBUG_SUBSTAGE(1)
define DEBUG_INVENCIBILITY(1)
// ********************************************************
// * SEGA GENESIS CONSTANTS: *
// * - VDP_DATA(INT OFFSET): *
// * Default SEGA GENESIS VDP Data Port *
// * *
// * - VDP_CTRL(INT OFFSET): *
// * Default SEGA GENESIS VDP Ctrl Port *
// * *
// * - M68K_RAM(INT OFFSET): *
// * Default SEGA GENESIS RAM Addr *
// ********************************************************
define VDP_DATA($00C00000)
define VDP_CTRL($00C00004)
define M68K_RAM($00FF0000)
// ********************************************************
// * GAME CONSTANTS: *
// * - GFX_FONT_SCORE(INT OFFSET): *
// * Default address of GAME FONT used in SCORE *
// * *
// * - GFX_FONT_DEFAULT(INT OFFSET): *
// * Default address of GAME FONT used in *
// * TITLE SCREEN, MENUS, COPYRIGHT *
// * *
// * - GFX_INGAME_FONT(INT OFFSET): *
// * Default address of GAME FONT used in INGAME *
// * messages like "STAGE 1 START" *
// * *
// * - STAGE_COUNTER(INT OFFSET): *
// * Count number of stages, used to know current *
// * stage on Stage Call Screen *
// ********************************************************
define GFX_FONT_SCORE($000ACA18)
define GFX_FONT_DEFAULT($000A8336)
define GFX_INGAME_FONT($00073B94)
define GFX_INTRO_FONT($000AC6CE)
define STAGE_COUNTER($FF90EC)
// ********************************************************
// * GAME FUNCTIONS: *
// * - loadCompressedGFXandSaveRegisters(INT OFFSET) *
// * *
// * - loadCompressedGFXandIncrementPointer(INT OFFSET) *
// * *
// * - loadCompressedGFX(INT OFFSET) *
// * *
// * - drawTilemap(INT OFFSET) *
// ********************************************************
define loadCompressedGFXandSaveRegisters($26E4)
define loadCompressedGFXandIncrementPointer($2628)
define loadCompressedGFX($262A)
define drawTilemap($AB7A) |
target/cos_117/disasm/iop_overlay1/DKSTAT.asm | jrrk2/cray-sim | 49 | 244194 | 0x0000 (0x000000) 0x2104- f:00020 d: 260 | A = OR[260]
0x0001 (0x000002) 0x290D- f:00024 d: 269 | OR[269] = A
0x0002 (0x000004) 0x2104- f:00020 d: 260 | A = OR[260]
0x0003 (0x000006) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0004 (0x000008) 0x1A00-0xFFFC f:00015 d: 0 | A = A & 65532 (0xFFFC)
0x0006 (0x00000C) 0x2904- f:00024 d: 260 | OR[260] = A
0x0007 (0x00000E) 0x2104- f:00020 d: 260 | A = OR[260]
0x0008 (0x000010) 0x291D- f:00024 d: 285 | OR[285] = A
0x0009 (0x000012) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x000A (0x000014) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x000B (0x000016) 0x2504- f:00022 d: 260 | A = A + OR[260]
0x000C (0x000018) 0x2904- f:00024 d: 260 | OR[260] = A
0x000D (0x00001A) 0x2104- f:00020 d: 260 | A = OR[260]
0x000E (0x00001C) 0x2705- f:00023 d: 261 | A = A - OR[261]
0x000F (0x00001E) 0xB234- f:00131 d: 52 | R = OR[52], C = 1
0x0010 (0x000020) 0x000B- f:00000 d: 11 | PASS | **** non-standard encoding with D:0x000B ****
0x0011 (0x000022) 0x210D- f:00020 d: 269 | A = OR[269]
0x0012 (0x000024) 0x3904- f:00034 d: 260 | (OR[260]) = A
0x0013 (0x000026) 0x2D04- f:00026 d: 260 | OR[260] = OR[260] + 1
0x0014 (0x000028) 0x211D- f:00020 d: 285 | A = OR[285]
0x0015 (0x00002A) 0x1428- f:00012 d: 40 | A = A + 40 (0x0028)
0x0016 (0x00002C) 0x2921- f:00024 d: 289 | OR[289] = A
0x0017 (0x00002E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0018 (0x000030) 0x291E- f:00024 d: 286 | OR[286] = A
0x0019 (0x000032) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x001A (0x000034) 0x2923- f:00024 d: 291 | OR[291] = A
0x001B (0x000036) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x001C (0x000038) 0x2920- f:00024 d: 288 | OR[288] = A
0x001D (0x00003A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x001E (0x00003C) 0x291F- f:00024 d: 287 | OR[287] = A
0x001F (0x00003E) 0x7E03-0x036F f:00077 d: 3 | R = OR[3]+879 (0x036F)
0x0021 (0x000042) 0x2003- f:00020 d: 3 | A = OR[3]
0x0022 (0x000044) 0x1C00-0x049A f:00016 d: 0 | A = A + 1178 (0x049A)
0x0024 (0x000048) 0x2913- f:00024 d: 275 | OR[275] = A
0x0025 (0x00004A) 0x1012- f:00010 d: 18 | A = 18 (0x0012)
0x0026 (0x00004C) 0x2914- f:00024 d: 276 | OR[276] = A
0x0027 (0x00004E) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x0028 (0x000050) 0x2915- f:00024 d: 277 | OR[277] = A
0x0029 (0x000052) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x002B (0x000056) 0x2102- f:00020 d: 258 | A = OR[258]
0x002C (0x000058) 0x1417- f:00012 d: 23 | A = A + 23 (0x0017)
0x002D (0x00005A) 0x2908- f:00024 d: 264 | OR[264] = A
0x002E (0x00005C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x002F (0x00005E) 0x2924- f:00024 d: 292 | OR[292] = A
0x0030 (0x000060) 0x2124- f:00020 d: 292 | A = OR[292]
0x0031 (0x000062) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x0032 (0x000064) 0x2913- f:00024 d: 275 | OR[275] = A
0x0033 (0x000066) 0x2113- f:00020 d: 275 | A = OR[275]
0x0034 (0x000068) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0035 (0x00006A) 0x290D- f:00024 d: 269 | OR[269] = A
0x0036 (0x00006C) 0x1024- f:00010 d: 36 | A = 36 (0x0024)
0x0037 (0x00006E) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x0038 (0x000070) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x0039 (0x000072) 0x290E- f:00024 d: 270 | OR[270] = A
0x003A (0x000074) 0x1024- f:00010 d: 36 | A = 36 (0x0024)
0x003B (0x000076) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x003C (0x000078) 0x2908- f:00024 d: 264 | OR[264] = A
0x003D (0x00007A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x003E (0x00007C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x003F (0x00007E) 0x8607- f:00103 d: 7 | P = P + 7 (0x0046), A # 0
0x0040 (0x000080) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0041 (0x000082) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0042 (0x000084) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0043 (0x000086) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0044 (0x000088) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0045 (0x00008A) 0x7006- f:00070 d: 6 | P = P + 6 (0x004B)
0x0046 (0x00008C) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0047 (0x00008E) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x0049 (0x000092) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x004A (0x000094) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x004B (0x000096) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x004D (0x00009A) 0x2003- f:00020 d: 3 | A = OR[3]
0x004E (0x00009C) 0x1C00-0x04A4 f:00016 d: 0 | A = A + 1188 (0x04A4)
0x0050 (0x0000A0) 0x2913- f:00024 d: 275 | OR[275] = A
0x0051 (0x0000A2) 0x1016- f:00010 d: 22 | A = 22 (0x0016)
0x0052 (0x0000A4) 0x2914- f:00024 d: 276 | OR[276] = A
0x0053 (0x0000A6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0054 (0x0000A8) 0x2915- f:00024 d: 277 | OR[277] = A
0x0055 (0x0000AA) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x0057 (0x0000AE) 0x2082- f:00020 d: 130 | A = OR[130]
0x0058 (0x0000B0) 0x140A- f:00012 d: 10 | A = A + 10 (0x000A)
0x0059 (0x0000B2) 0x2908- f:00024 d: 264 | OR[264] = A
0x005A (0x0000B4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x005B (0x0000B6) 0x2913- f:00024 d: 275 | OR[275] = A
0x005C (0x0000B8) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x005D (0x0000BA) 0x2914- f:00024 d: 276 | OR[276] = A
0x005E (0x0000BC) 0x1017- f:00010 d: 23 | A = 23 (0x0017)
0x005F (0x0000BE) 0x2915- f:00024 d: 277 | OR[277] = A
0x0060 (0x0000C0) 0x7E03-0x02EC f:00077 d: 3 | R = OR[3]+748 (0x02EC)
0x0062 (0x0000C4) 0x2003- f:00020 d: 3 | A = OR[3]
0x0063 (0x0000C6) 0x1C00-0x04B0 f:00016 d: 0 | A = A + 1200 (0x04B0)
0x0065 (0x0000CA) 0x2913- f:00024 d: 275 | OR[275] = A
0x0066 (0x0000CC) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0067 (0x0000CE) 0x2914- f:00024 d: 276 | OR[276] = A
0x0068 (0x0000D0) 0x1046- f:00010 d: 70 | A = 70 (0x0046)
0x0069 (0x0000D2) 0x2915- f:00024 d: 277 | OR[277] = A
0x006A (0x0000D4) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x006C (0x0000D8) 0x211A- f:00020 d: 282 | A = OR[282]
0x006D (0x0000DA) 0x2913- f:00024 d: 275 | OR[275] = A
0x006E (0x0000DC) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x006F (0x0000DE) 0x2914- f:00024 d: 276 | OR[276] = A
0x0070 (0x0000E0) 0x104C- f:00010 d: 76 | A = 76 (0x004C)
0x0071 (0x0000E2) 0x2915- f:00024 d: 277 | OR[277] = A
0x0072 (0x0000E4) 0x7E03-0x02EC f:00077 d: 3 | R = OR[3]+748 (0x02EC)
0x0074 (0x0000E8) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x0076 (0x0000EC) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x0078 (0x0000F0) 0x2003- f:00020 d: 3 | A = OR[3]
0x0079 (0x0000F2) 0x1C00-0x04B3 f:00016 d: 0 | A = A + 1203 (0x04B3)
0x007B (0x0000F6) 0x2913- f:00024 d: 275 | OR[275] = A
0x007C (0x0000F8) 0x1039- f:00010 d: 57 | A = 57 (0x0039)
0x007D (0x0000FA) 0x2914- f:00024 d: 276 | OR[276] = A
0x007E (0x0000FC) 0x1012- f:00010 d: 18 | A = 18 (0x0012)
0x007F (0x0000FE) 0x2915- f:00024 d: 277 | OR[277] = A
0x0080 (0x000100) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x0082 (0x000104) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x0084 (0x000108) 0x2003- f:00020 d: 3 | A = OR[3]
0x0085 (0x00010A) 0x1C00-0x04D0 f:00016 d: 0 | A = A + 1232 (0x04D0)
0x0087 (0x00010E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0088 (0x000110) 0x104E- f:00010 d: 78 | A = 78 (0x004E)
0x0089 (0x000112) 0x2914- f:00024 d: 276 | OR[276] = A
0x008A (0x000114) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x008B (0x000116) 0x2915- f:00024 d: 277 | OR[277] = A
0x008C (0x000118) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x008E (0x00011C) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x0090 (0x000120) 0x2003- f:00020 d: 3 | A = OR[3]
0x0091 (0x000122) 0x1C00-0x04F8 f:00016 d: 0 | A = A + 1272 (0x04F8)
0x0093 (0x000126) 0x2913- f:00024 d: 275 | OR[275] = A
0x0094 (0x000128) 0x104E- f:00010 d: 78 | A = 78 (0x004E)
0x0095 (0x00012A) 0x2914- f:00024 d: 276 | OR[276] = A
0x0096 (0x00012C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0097 (0x00012E) 0x2915- f:00024 d: 277 | OR[277] = A
0x0098 (0x000130) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x009A (0x000134) 0x7E03-0x0357 f:00077 d: 3 | R = OR[3]+855 (0x0357)
0x009C (0x000138) 0x101A- f:00010 d: 26 | A = 26 (0x001A)
0x009D (0x00013A) 0x2927- f:00024 d: 295 | OR[295] = A
0x009E (0x00013C) 0x111C- f:00010 d: 284 | A = 284 (0x011C)
0x009F (0x00013E) 0x2928- f:00024 d: 296 | OR[296] = A
0x00A0 (0x000140) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x00A1 (0x000142) 0x5800- f:00054 d: 0 | B = A
0x00A2 (0x000144) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00A3 (0x000146) 0x7C09- f:00076 d: 9 | R = OR[9]
0x00A4 (0x000148) 0x2913- f:00024 d: 275 | OR[275] = A
0x00A5 (0x00014A) 0x8602- f:00103 d: 2 | P = P + 2 (0x00A7), A # 0
0x00A6 (0x00014C) 0x7004- f:00070 d: 4 | P = P + 4 (0x00AA)
0x00A7 (0x00014E) 0x7E03-0x0391 f:00077 d: 3 | R = OR[3]+913 (0x0391)
0x00A9 (0x000152) 0x7044- f:00070 d: 68 | P = P + 68 (0x00ED)
0x00AA (0x000154) 0x211C- f:00020 d: 284 | A = OR[284]
0x00AB (0x000156) 0x291F- f:00024 d: 287 | OR[287] = A
0x00AC (0x000158) 0x211C- f:00020 d: 284 | A = OR[284]
0x00AD (0x00015A) 0x290E- f:00024 d: 270 | OR[270] = A
0x00AE (0x00015C) 0x1800-0x0800 f:00014 d: 0 | A = 2048 (0x0800)
0x00B0 (0x000160) 0x290D- f:00024 d: 269 | OR[269] = A
0x00B1 (0x000162) 0x210D- f:00020 d: 269 | A = OR[269]
0x00B2 (0x000164) 0x8406- f:00102 d: 6 | P = P + 6 (0x00B8), A = 0
0x00B3 (0x000166) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00B4 (0x000168) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x00B5 (0x00016A) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x00B6 (0x00016C) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x00B7 (0x00016E) 0x7206- f:00071 d: 6 | P = P - 6 (0x00B1)
0x00B8 (0x000170) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x00B9 (0x000172) 0x2927- f:00024 d: 295 | OR[295] = A
0x00BA (0x000174) 0x1800-0x0039 f:00014 d: 0 | A = 57 (0x0039)
0x00BC (0x000178) 0x2928- f:00024 d: 296 | OR[296] = A
0x00BD (0x00017A) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x00BE (0x00017C) 0x2929- f:00024 d: 297 | OR[297] = A
0x00BF (0x00017E) 0x2124- f:00020 d: 292 | A = OR[292]
0x00C0 (0x000180) 0x292A- f:00024 d: 298 | OR[298] = A
0x00C1 (0x000182) 0x211C- f:00020 d: 284 | A = OR[284]
0x00C2 (0x000184) 0x292B- f:00024 d: 299 | OR[299] = A
0x00C3 (0x000186) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00C4 (0x000188) 0x292C- f:00024 d: 300 | OR[300] = A
0x00C5 (0x00018A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00C6 (0x00018C) 0x292D- f:00024 d: 301 | OR[301] = A
0x00C7 (0x00018E) 0x1800-0x0200 f:00014 d: 0 | A = 512 (0x0200)
0x00C9 (0x000192) 0x292E- f:00024 d: 302 | OR[302] = A
0x00CA (0x000194) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x00CB (0x000196) 0x292F- f:00024 d: 303 | OR[303] = A
0x00CC (0x000198) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x00CD (0x00019A) 0x5800- f:00054 d: 0 | B = A
0x00CE (0x00019C) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x00D0 (0x0001A0) 0x7C09- f:00076 d: 9 | R = OR[9]
0x00D1 (0x0001A2) 0x2913- f:00024 d: 275 | OR[275] = A
0x00D2 (0x0001A4) 0x8602- f:00103 d: 2 | P = P + 2 (0x00D4), A # 0
0x00D3 (0x0001A6) 0x7004- f:00070 d: 4 | P = P + 4 (0x00D7)
0x00D4 (0x0001A8) 0x7E03-0x0391 f:00077 d: 3 | R = OR[3]+913 (0x0391)
0x00D6 (0x0001AC) 0x7017- f:00070 d: 23 | P = P + 23 (0x00ED)
0x00D7 (0x0001AE) 0x211C- f:00020 d: 284 | A = OR[284]
0x00D8 (0x0001B0) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x00D9 (0x0001B2) 0x2908- f:00024 d: 264 | OR[264] = A
0x00DA (0x0001B4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00DB (0x0001B6) 0x2922- f:00024 d: 290 | OR[290] = A
0x00DC (0x0001B8) 0x2122- f:00020 d: 290 | A = OR[290]
0x00DD (0x0001BA) 0x271B- f:00023 d: 283 | A = A - OR[283]
0x00DE (0x0001BC) 0x2923- f:00024 d: 291 | OR[291] = A
0x00DF (0x0001BE) 0x2122- f:00020 d: 290 | A = OR[290]
0x00E0 (0x0001C0) 0x271B- f:00023 d: 283 | A = A - OR[283]
0x00E1 (0x0001C2) 0x8203- f:00101 d: 3 | P = P + 3 (0x00E4), C = 1
0x00E2 (0x0001C4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00E3 (0x0001C6) 0x2923- f:00024 d: 291 | OR[291] = A
0x00E4 (0x0001C8) 0x211F- f:00020 d: 287 | A = OR[287]
0x00E5 (0x0001CA) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x00E6 (0x0001CC) 0x291C- f:00024 d: 284 | OR[284] = A
0x00E7 (0x0001CE) 0x211B- f:00020 d: 283 | A = OR[283]
0x00E8 (0x0001D0) 0x8405- f:00102 d: 5 | P = P + 5 (0x00ED), A = 0
0x00E9 (0x0001D2) 0x1027- f:00010 d: 39 | A = 39 (0x0027)
0x00EA (0x0001D4) 0x2B1C- f:00025 d: 284 | OR[284] = A + OR[284]
0x00EB (0x0001D6) 0x2F1B- f:00027 d: 283 | OR[283] = OR[283] - 1
0x00EC (0x0001D8) 0x7205- f:00071 d: 5 | P = P - 5 (0x00E7)
0x00ED (0x0001DA) 0x211E- f:00020 d: 286 | A = OR[286]
0x00EE (0x0001DC) 0x2719- f:00023 d: 281 | A = A - OR[281]
0x00EF (0x0001DE) 0xAC03-0x02CD f:00126 d: 3 | P = OR[3]+717 (0x02CD), A = 0
0x00F1 (0x0001E2) 0x2123- f:00020 d: 291 | A = OR[291]
0x00F2 (0x0001E4) 0x8603- f:00103 d: 3 | P = P + 3 (0x00F5), A # 0
0x00F3 (0x0001E6) 0x7A03-0x02BB f:00075 d: 3 | P = OR[3]+699 (0x02BB)
0x00F5 (0x0001EA) 0x211C- f:00020 d: 284 | A = OR[284]
0x00F6 (0x0001EC) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x00F7 (0x0001EE) 0x2908- f:00024 d: 264 | OR[264] = A
0x00F8 (0x0001F0) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00F9 (0x0001F2) 0x13FF- f:00011 d: 511 | A = A & 511 (0x01FF)
0x00FA (0x0001F4) 0x2913- f:00024 d: 275 | OR[275] = A
0x00FB (0x0001F6) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x00FC (0x0001F8) 0x2914- f:00024 d: 276 | OR[276] = A
0x00FD (0x0001FA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00FE (0x0001FC) 0x2915- f:00024 d: 277 | OR[277] = A
0x00FF (0x0001FE) 0x7E03-0x0307 f:00077 d: 3 | R = OR[3]+775 (0x0307)
0x0101 (0x000202) 0x211C- f:00020 d: 284 | A = OR[284]
0x0102 (0x000204) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x0103 (0x000206) 0x2908- f:00024 d: 264 | OR[264] = A
0x0104 (0x000208) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0105 (0x00020A) 0x0809- f:00004 d: 9 | A = A > 9 (0x0009)
0x0106 (0x00020C) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x0107 (0x00020E) 0x2926- f:00024 d: 294 | OR[294] = A
0x0108 (0x000210) 0x2126- f:00020 d: 294 | A = OR[294]
0x0109 (0x000212) 0x8407- f:00102 d: 7 | P = P + 7 (0x0110), A = 0
0x010A (0x000214) 0x2126- f:00020 d: 294 | A = OR[294]
0x010B (0x000216) 0x1607- f:00013 d: 7 | A = A - 7 (0x0007)
0x010C (0x000218) 0x8003- f:00100 d: 3 | P = P + 3 (0x010F), C = 0
0x010D (0x00021A) 0x8402- f:00102 d: 2 | P = P + 2 (0x010F), A = 0
0x010E (0x00021C) 0x7002- f:00070 d: 2 | P = P + 2 (0x0110)
0x010F (0x00021E) 0x7003- f:00070 d: 3 | P = P + 3 (0x0112)
0x0110 (0x000220) 0x7C34- f:00076 d: 52 | R = OR[52]
0x0111 (0x000222) 0x0047- f:00000 d: 71 | PASS | **** non-standard encoding with D:0x0047 ****
0x0112 (0x000224) 0x1800-0x0574 f:00014 d: 0 | A = 1396 (0x0574)
0x0114 (0x000228) 0x2526- f:00022 d: 294 | A = A + OR[294]
0x0115 (0x00022A) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0116 (0x00022C) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x0117 (0x00022E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0118 (0x000230) 0x3113- f:00030 d: 275 | A = (OR[275])
0x0119 (0x000232) 0x2913- f:00024 d: 275 | OR[275] = A
0x011A (0x000234) 0x2113- f:00020 d: 275 | A = OR[275]
0x011B (0x000236) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x011C (0x000238) 0x2913- f:00024 d: 275 | OR[275] = A
0x011D (0x00023A) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x011E (0x00023C) 0x2914- f:00024 d: 276 | OR[276] = A
0x011F (0x00023E) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x0120 (0x000240) 0x2915- f:00024 d: 277 | OR[277] = A
0x0121 (0x000242) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x0123 (0x000246) 0x2126- f:00020 d: 294 | A = OR[294]
0x0124 (0x000248) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0125 (0x00024A) 0x8602- f:00103 d: 2 | P = P + 2 (0x0127), A # 0
0x0126 (0x00024C) 0x7009- f:00070 d: 9 | P = P + 9 (0x012F)
0x0127 (0x00024E) 0x2126- f:00020 d: 294 | A = OR[294]
0x0128 (0x000250) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0129 (0x000252) 0x8602- f:00103 d: 2 | P = P + 2 (0x012B), A # 0
0x012A (0x000254) 0x7005- f:00070 d: 5 | P = P + 5 (0x012F)
0x012B (0x000256) 0x7E03-0x03AB f:00077 d: 3 | R = OR[3]+939 (0x03AB)
0x012D (0x00025A) 0x7A03-0x02B6 f:00075 d: 3 | P = OR[3]+694 (0x02B6)
0x012F (0x00025E) 0x211C- f:00020 d: 284 | A = OR[284]
0x0130 (0x000260) 0x1400- f:00012 d: 0 | A = A + 0 (0x0000)
0x0131 (0x000262) 0x2908- f:00024 d: 264 | OR[264] = A
0x0132 (0x000264) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0133 (0x000266) 0x2917- f:00024 d: 279 | OR[279] = A
0x0134 (0x000268) 0x2117- f:00020 d: 279 | A = OR[279]
0x0135 (0x00026A) 0x1A00-0x03FF f:00015 d: 0 | A = A & 1023 (0x03FF)
0x0137 (0x00026E) 0x2917- f:00024 d: 279 | OR[279] = A
0x0138 (0x000270) 0x2117- f:00020 d: 279 | A = OR[279]
0x0139 (0x000272) 0x8402- f:00102 d: 2 | P = P + 2 (0x013B), A = 0
0x013A (0x000274) 0x7005- f:00070 d: 5 | P = P + 5 (0x013F)
0x013B (0x000276) 0x1800-0x0526 f:00014 d: 0 | A = 1318 (0x0526)
0x013D (0x00027A) 0x2913- f:00024 d: 275 | OR[275] = A
0x013E (0x00027C) 0x7073- f:00070 d: 115 | P = P + 115 (0x01B1)
0x013F (0x00027E) 0x2117- f:00020 d: 279 | A = OR[279]
0x0140 (0x000280) 0x1A00-0x0250 f:00015 d: 0 | A = A & 592 (0x0250)
0x0142 (0x000284) 0x2908- f:00024 d: 264 | OR[264] = A
0x0143 (0x000286) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0144 (0x000288) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0145 (0x00028A) 0x8602- f:00103 d: 2 | P = P + 2 (0x0147), A # 0
0x0146 (0x00028C) 0x7026- f:00070 d: 38 | P = P + 38 (0x016C)
0x0147 (0x00028E) 0x2117- f:00020 d: 279 | A = OR[279]
0x0148 (0x000290) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0149 (0x000292) 0x2908- f:00024 d: 264 | OR[264] = A
0x014A (0x000294) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x014B (0x000296) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x014C (0x000298) 0x8602- f:00103 d: 2 | P = P + 2 (0x014E), A # 0
0x014D (0x00029A) 0x7005- f:00070 d: 5 | P = P + 5 (0x0152)
0x014E (0x00029C) 0x1800-0x053A f:00014 d: 0 | A = 1338 (0x053A)
0x0150 (0x0002A0) 0x2913- f:00024 d: 275 | OR[275] = A
0x0151 (0x0002A2) 0x701A- f:00070 d: 26 | P = P + 26 (0x016B)
0x0152 (0x0002A4) 0x2117- f:00020 d: 279 | A = OR[279]
0x0153 (0x0002A6) 0x1202- f:00011 d: 2 | A = A & 2 (0x0002)
0x0154 (0x0002A8) 0x2908- f:00024 d: 264 | OR[264] = A
0x0155 (0x0002AA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0156 (0x0002AC) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0157 (0x0002AE) 0x8602- f:00103 d: 2 | P = P + 2 (0x0159), A # 0
0x0158 (0x0002B0) 0x7005- f:00070 d: 5 | P = P + 5 (0x015D)
0x0159 (0x0002B2) 0x1800-0x053E f:00014 d: 0 | A = 1342 (0x053E)
0x015B (0x0002B6) 0x2913- f:00024 d: 275 | OR[275] = A
0x015C (0x0002B8) 0x700F- f:00070 d: 15 | P = P + 15 (0x016B)
0x015D (0x0002BA) 0x2117- f:00020 d: 279 | A = OR[279]
0x015E (0x0002BC) 0x1208- f:00011 d: 8 | A = A & 8 (0x0008)
0x015F (0x0002BE) 0x2908- f:00024 d: 264 | OR[264] = A
0x0160 (0x0002C0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0161 (0x0002C2) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0162 (0x0002C4) 0x8602- f:00103 d: 2 | P = P + 2 (0x0164), A # 0
0x0163 (0x0002C6) 0x7005- f:00070 d: 5 | P = P + 5 (0x0168)
0x0164 (0x0002C8) 0x1800-0x0542 f:00014 d: 0 | A = 1346 (0x0542)
0x0166 (0x0002CC) 0x2913- f:00024 d: 275 | OR[275] = A
0x0167 (0x0002CE) 0x7004- f:00070 d: 4 | P = P + 4 (0x016B)
0x0168 (0x0002D0) 0x1800-0x054E f:00014 d: 0 | A = 1358 (0x054E)
0x016A (0x0002D4) 0x2913- f:00024 d: 275 | OR[275] = A
0x016B (0x0002D6) 0x7046- f:00070 d: 70 | P = P + 70 (0x01B1)
0x016C (0x0002D8) 0x2117- f:00020 d: 279 | A = OR[279]
0x016D (0x0002DA) 0x1220- f:00011 d: 32 | A = A & 32 (0x0020)
0x016E (0x0002DC) 0x2908- f:00024 d: 264 | OR[264] = A
0x016F (0x0002DE) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0170 (0x0002E0) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0171 (0x0002E2) 0x8602- f:00103 d: 2 | P = P + 2 (0x0173), A # 0
0x0172 (0x0002E4) 0x7010- f:00070 d: 16 | P = P + 16 (0x0182)
0x0173 (0x0002E6) 0x2117- f:00020 d: 279 | A = OR[279]
0x0174 (0x0002E8) 0x1202- f:00011 d: 2 | A = A & 2 (0x0002)
0x0175 (0x0002EA) 0x2908- f:00024 d: 264 | OR[264] = A
0x0176 (0x0002EC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0177 (0x0002EE) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0178 (0x0002F0) 0x8602- f:00103 d: 2 | P = P + 2 (0x017A), A # 0
0x0179 (0x0002F2) 0x7005- f:00070 d: 5 | P = P + 5 (0x017E)
0x017A (0x0002F4) 0x1800-0x054A f:00014 d: 0 | A = 1354 (0x054A)
0x017C (0x0002F8) 0x2913- f:00024 d: 275 | OR[275] = A
0x017D (0x0002FA) 0x7004- f:00070 d: 4 | P = P + 4 (0x0181)
0x017E (0x0002FC) 0x1800-0x0546 f:00014 d: 0 | A = 1350 (0x0546)
0x0180 (0x000300) 0x2913- f:00024 d: 275 | OR[275] = A
0x0181 (0x000302) 0x7030- f:00070 d: 48 | P = P + 48 (0x01B1)
0x0182 (0x000304) 0x2117- f:00020 d: 279 | A = OR[279]
0x0183 (0x000306) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0184 (0x000308) 0x2908- f:00024 d: 264 | OR[264] = A
0x0185 (0x00030A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0186 (0x00030C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0187 (0x00030E) 0x8602- f:00103 d: 2 | P = P + 2 (0x0189), A # 0
0x0188 (0x000310) 0x7005- f:00070 d: 5 | P = P + 5 (0x018D)
0x0189 (0x000312) 0x1800-0x052A f:00014 d: 0 | A = 1322 (0x052A)
0x018B (0x000316) 0x2913- f:00024 d: 275 | OR[275] = A
0x018C (0x000318) 0x7025- f:00070 d: 37 | P = P + 37 (0x01B1)
0x018D (0x00031A) 0x2117- f:00020 d: 279 | A = OR[279]
0x018E (0x00031C) 0x1202- f:00011 d: 2 | A = A & 2 (0x0002)
0x018F (0x00031E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0190 (0x000320) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0191 (0x000322) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0192 (0x000324) 0x8602- f:00103 d: 2 | P = P + 2 (0x0194), A # 0
0x0193 (0x000326) 0x7005- f:00070 d: 5 | P = P + 5 (0x0198)
0x0194 (0x000328) 0x1800-0x052E f:00014 d: 0 | A = 1326 (0x052E)
0x0196 (0x00032C) 0x2913- f:00024 d: 275 | OR[275] = A
0x0197 (0x00032E) 0x701A- f:00070 d: 26 | P = P + 26 (0x01B1)
0x0198 (0x000330) 0x2117- f:00020 d: 279 | A = OR[279]
0x0199 (0x000332) 0x1204- f:00011 d: 4 | A = A & 4 (0x0004)
0x019A (0x000334) 0x2908- f:00024 d: 264 | OR[264] = A
0x019B (0x000336) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x019C (0x000338) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x019D (0x00033A) 0x8602- f:00103 d: 2 | P = P + 2 (0x019F), A # 0
0x019E (0x00033C) 0x7005- f:00070 d: 5 | P = P + 5 (0x01A3)
0x019F (0x00033E) 0x1800-0x0532 f:00014 d: 0 | A = 1330 (0x0532)
0x01A1 (0x000342) 0x2913- f:00024 d: 275 | OR[275] = A
0x01A2 (0x000344) 0x700F- f:00070 d: 15 | P = P + 15 (0x01B1)
0x01A3 (0x000346) 0x2117- f:00020 d: 279 | A = OR[279]
0x01A4 (0x000348) 0x1208- f:00011 d: 8 | A = A & 8 (0x0008)
0x01A5 (0x00034A) 0x2908- f:00024 d: 264 | OR[264] = A
0x01A6 (0x00034C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01A7 (0x00034E) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x01A8 (0x000350) 0x8602- f:00103 d: 2 | P = P + 2 (0x01AA), A # 0
0x01A9 (0x000352) 0x7005- f:00070 d: 5 | P = P + 5 (0x01AE)
0x01AA (0x000354) 0x1800-0x0536 f:00014 d: 0 | A = 1334 (0x0536)
0x01AC (0x000358) 0x2913- f:00024 d: 275 | OR[275] = A
0x01AD (0x00035A) 0x7004- f:00070 d: 4 | P = P + 4 (0x01B1)
0x01AE (0x00035C) 0x1800-0x0556 f:00014 d: 0 | A = 1366 (0x0556)
0x01B0 (0x000360) 0x2913- f:00024 d: 275 | OR[275] = A
0x01B1 (0x000362) 0x2113- f:00020 d: 275 | A = OR[275]
0x01B2 (0x000364) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x01B3 (0x000366) 0x2913- f:00024 d: 275 | OR[275] = A
0x01B4 (0x000368) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x01B5 (0x00036A) 0x2914- f:00024 d: 276 | OR[276] = A
0x01B6 (0x00036C) 0x1009- f:00010 d: 9 | A = 9 (0x0009)
0x01B7 (0x00036E) 0x2915- f:00024 d: 277 | OR[277] = A
0x01B8 (0x000370) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x01BA (0x000374) 0x211C- f:00020 d: 284 | A = OR[284]
0x01BB (0x000376) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x01BC (0x000378) 0x2908- f:00024 d: 264 | OR[264] = A
0x01BD (0x00037A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01BE (0x00037C) 0x080F- f:00004 d: 15 | A = A > 15 (0x000F)
0x01BF (0x00037E) 0x2916- f:00024 d: 278 | OR[278] = A
0x01C0 (0x000380) 0x211C- f:00020 d: 284 | A = OR[284]
0x01C1 (0x000382) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x01C2 (0x000384) 0x2908- f:00024 d: 264 | OR[264] = A
0x01C3 (0x000386) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01C4 (0x000388) 0x0805- f:00004 d: 5 | A = A > 5 (0x0005)
0x01C5 (0x00038A) 0x2917- f:00024 d: 279 | OR[279] = A
0x01C6 (0x00038C) 0x2116- f:00020 d: 278 | A = OR[278]
0x01C7 (0x00038E) 0x8602- f:00103 d: 2 | P = P + 2 (0x01C9), A # 0
0x01C8 (0x000390) 0x700D- f:00070 d: 13 | P = P + 13 (0x01D5)
0x01C9 (0x000392) 0x1800-0x055A f:00014 d: 0 | A = 1370 (0x055A)
0x01CB (0x000396) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x01CC (0x000398) 0x2913- f:00024 d: 275 | OR[275] = A
0x01CD (0x00039A) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x01CE (0x00039C) 0x2914- f:00024 d: 276 | OR[276] = A
0x01CF (0x00039E) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x01D0 (0x0003A0) 0x2915- f:00024 d: 277 | OR[277] = A
0x01D1 (0x0003A2) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x01D3 (0x0003A6) 0x7A03-0x0233 f:00075 d: 3 | P = OR[3]+563 (0x0233)
0x01D5 (0x0003AA) 0x2117- f:00020 d: 279 | A = OR[279]
0x01D6 (0x0003AC) 0x1E00-0x0336 f:00017 d: 0 | A = A - 822 (0x0336)
0x01D8 (0x0003B0) 0x8003- f:00100 d: 3 | P = P + 3 (0x01DB), C = 0
0x01D9 (0x0003B2) 0x8402- f:00102 d: 2 | P = P + 2 (0x01DB), A = 0
0x01DA (0x0003B4) 0x7002- f:00070 d: 2 | P = P + 2 (0x01DC)
0x01DB (0x0003B6) 0x7010- f:00070 d: 16 | P = P + 16 (0x01EB)
0x01DC (0x0003B8) 0x2126- f:00020 d: 294 | A = OR[294]
0x01DD (0x0003BA) 0x8602- f:00103 d: 2 | P = P + 2 (0x01DF), A # 0
0x01DE (0x0003BC) 0x700D- f:00070 d: 13 | P = P + 13 (0x01EB)
0x01DF (0x0003BE) 0x1800-0x0556 f:00014 d: 0 | A = 1366 (0x0556)
0x01E1 (0x0003C2) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x01E2 (0x0003C4) 0x2913- f:00024 d: 275 | OR[275] = A
0x01E3 (0x0003C6) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x01E4 (0x0003C8) 0x2914- f:00024 d: 276 | OR[276] = A
0x01E5 (0x0003CA) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x01E6 (0x0003CC) 0x2915- f:00024 d: 277 | OR[277] = A
0x01E7 (0x0003CE) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x01E9 (0x0003D2) 0x7A03-0x0233 f:00075 d: 3 | P = OR[3]+563 (0x0233)
0x01EB (0x0003D6) 0x2117- f:00020 d: 279 | A = OR[279]
0x01EC (0x0003D8) 0x179A- f:00013 d: 410 | A = A - 410 (0x019A)
0x01ED (0x0003DA) 0x8003- f:00100 d: 3 | P = P + 3 (0x01F0), C = 0
0x01EE (0x0003DC) 0x8402- f:00102 d: 2 | P = P + 2 (0x01F0), A = 0
0x01EF (0x0003DE) 0x7003- f:00070 d: 3 | P = P + 3 (0x01F2)
0x01F0 (0x0003E0) 0x7A03-0x0207 f:00075 d: 3 | P = OR[3]+519 (0x0207)
0x01F2 (0x0003E4) 0x2126- f:00020 d: 294 | A = OR[294]
0x01F3 (0x0003E6) 0x8403- f:00102 d: 3 | P = P + 3 (0x01F6), A = 0
0x01F4 (0x0003E8) 0x7A03-0x0207 f:00075 d: 3 | P = OR[3]+519 (0x0207)
0x01F6 (0x0003EC) 0x1800-0x0556 f:00014 d: 0 | A = 1366 (0x0556)
0x01F8 (0x0003F0) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x01F9 (0x0003F2) 0x2913- f:00024 d: 275 | OR[275] = A
0x01FA (0x0003F4) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x01FB (0x0003F6) 0x2914- f:00024 d: 276 | OR[276] = A
0x01FC (0x0003F8) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x01FD (0x0003FA) 0x2915- f:00024 d: 277 | OR[277] = A
0x01FE (0x0003FC) 0x7E03-0x0322 f:00077 d: 3 | R = OR[3]+802 (0x0322)
0x0200 (0x000400) 0x702D- f:00070 d: 45 | P = P + 45 (0x022D)
0x0201 (0x000402) 0x2117- f:00020 d: 279 | A = OR[279]
0x0202 (0x000404) 0x2913- f:00024 d: 275 | OR[275] = A
0x0203 (0x000406) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x0204 (0x000408) 0x2914- f:00024 d: 276 | OR[276] = A
0x0205 (0x00040A) 0x1016- f:00010 d: 22 | A = 22 (0x0016)
0x0206 (0x00040C) 0x2915- f:00024 d: 277 | OR[277] = A
0x0207 (0x00040E) 0x74FA- f:00072 d: 250 | R = P + 250 (0x0301)
0x0208 (0x000410) 0x102F- f:00010 d: 47 | A = 47 (0x002F)
0x0209 (0x000412) 0x2913- f:00024 d: 275 | OR[275] = A
0x020A (0x000414) 0x2113- f:00020 d: 275 | A = OR[275]
0x020B (0x000416) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x020C (0x000418) 0x290D- f:00024 d: 269 | OR[269] = A
0x020D (0x00041A) 0x101A- f:00010 d: 26 | A = 26 (0x001A)
0x020E (0x00041C) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x020F (0x00041E) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x0210 (0x000420) 0x290E- f:00024 d: 270 | OR[270] = A
0x0211 (0x000422) 0x101A- f:00010 d: 26 | A = 26 (0x001A)
0x0212 (0x000424) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0213 (0x000426) 0x2908- f:00024 d: 264 | OR[264] = A
0x0214 (0x000428) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0215 (0x00042A) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0216 (0x00042C) 0x8607- f:00103 d: 7 | P = P + 7 (0x021D), A # 0
0x0217 (0x00042E) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0218 (0x000430) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0219 (0x000432) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x021A (0x000434) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x021B (0x000436) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x021C (0x000438) 0x7006- f:00070 d: 6 | P = P + 6 (0x0222)
0x021D (0x00043A) 0x310E- f:00030 d: 270 | A = (OR[270])
0x021E (0x00043C) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x0220 (0x000440) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0221 (0x000442) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0222 (0x000444) 0x211C- f:00020 d: 284 | A = OR[284]
0x0223 (0x000446) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0224 (0x000448) 0x2908- f:00024 d: 264 | OR[264] = A
0x0225 (0x00044A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0226 (0x00044C) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x0227 (0x00044E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0228 (0x000450) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x0229 (0x000452) 0x2914- f:00024 d: 276 | OR[276] = A
0x022A (0x000454) 0x101B- f:00010 d: 27 | A = 27 (0x001B)
0x022B (0x000456) 0x2915- f:00024 d: 277 | OR[277] = A
0x022C (0x000458) 0x74D5- f:00072 d: 213 | R = P + 213 (0x0301)
0x022D (0x00045A) 0x211C- f:00020 d: 284 | A = OR[284]
0x022E (0x00045C) 0x140F- f:00012 d: 15 | A = A + 15 (0x000F)
0x022F (0x00045E) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0230 (0x000460) 0x2913- f:00024 d: 275 | OR[275] = A
0x0231 (0x000462) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0232 (0x000464) 0x2927- f:00024 d: 295 | OR[295] = A
0x0233 (0x000466) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0235 (0x00046A) 0x2928- f:00024 d: 296 | OR[296] = A
0x0236 (0x00046C) 0x2113- f:00020 d: 275 | A = OR[275]
0x0237 (0x00046E) 0x2929- f:00024 d: 297 | OR[297] = A
0x0238 (0x000470) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0239 (0x000472) 0x292A- f:00024 d: 298 | OR[298] = A
0x023A (0x000474) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x023B (0x000476) 0x292B- f:00024 d: 299 | OR[299] = A
0x023C (0x000478) 0x211D- f:00020 d: 285 | A = OR[285]
0x023D (0x00047A) 0x292C- f:00024 d: 300 | OR[300] = A
0x023E (0x00047C) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x023F (0x00047E) 0x292D- f:00024 d: 301 | OR[301] = A
0x0240 (0x000480) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0241 (0x000482) 0x292E- f:00024 d: 302 | OR[302] = A
0x0242 (0x000484) 0x100A- f:00010 d: 10 | A = 10 (0x000A)
0x0243 (0x000486) 0x292F- f:00024 d: 303 | OR[303] = A
0x0244 (0x000488) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0245 (0x00048A) 0x5800- f:00054 d: 0 | B = A
0x0246 (0x00048C) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0248 (0x000490) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0249 (0x000492) 0x211C- f:00020 d: 284 | A = OR[284]
0x024A (0x000494) 0x1413- f:00012 d: 19 | A = A + 19 (0x0013)
0x024B (0x000496) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x024C (0x000498) 0x2913- f:00024 d: 275 | OR[275] = A
0x024D (0x00049A) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x024E (0x00049C) 0x2927- f:00024 d: 295 | OR[295] = A
0x024F (0x00049E) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0251 (0x0004A2) 0x2928- f:00024 d: 296 | OR[296] = A
0x0252 (0x0004A4) 0x2113- f:00020 d: 275 | A = OR[275]
0x0253 (0x0004A6) 0x2929- f:00024 d: 297 | OR[297] = A
0x0254 (0x0004A8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0255 (0x0004AA) 0x292A- f:00024 d: 298 | OR[298] = A
0x0256 (0x0004AC) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x0257 (0x0004AE) 0x292B- f:00024 d: 299 | OR[299] = A
0x0258 (0x0004B0) 0x211D- f:00020 d: 285 | A = OR[285]
0x0259 (0x0004B2) 0x292C- f:00024 d: 300 | OR[300] = A
0x025A (0x0004B4) 0x102C- f:00010 d: 44 | A = 44 (0x002C)
0x025B (0x0004B6) 0x292D- f:00024 d: 301 | OR[301] = A
0x025C (0x0004B8) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x025D (0x0004BA) 0x292E- f:00024 d: 302 | OR[302] = A
0x025E (0x0004BC) 0x100A- f:00010 d: 10 | A = 10 (0x000A)
0x025F (0x0004BE) 0x292F- f:00024 d: 303 | OR[303] = A
0x0260 (0x0004C0) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0261 (0x0004C2) 0x5800- f:00054 d: 0 | B = A
0x0262 (0x0004C4) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0264 (0x0004C8) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0265 (0x0004CA) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0266 (0x0004CC) 0x2927- f:00024 d: 295 | OR[295] = A
0x0267 (0x0004CE) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0269 (0x0004D2) 0x2928- f:00024 d: 296 | OR[296] = A
0x026A (0x0004D4) 0x211C- f:00020 d: 284 | A = OR[284]
0x026B (0x0004D6) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x026C (0x0004D8) 0x2929- f:00024 d: 297 | OR[297] = A
0x026D (0x0004DA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x026E (0x0004DC) 0x292A- f:00024 d: 298 | OR[298] = A
0x026F (0x0004DE) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x0270 (0x0004E0) 0x292B- f:00024 d: 299 | OR[299] = A
0x0271 (0x0004E2) 0x211D- f:00020 d: 285 | A = OR[285]
0x0272 (0x0004E4) 0x292C- f:00024 d: 300 | OR[300] = A
0x0273 (0x0004E6) 0x1039- f:00010 d: 57 | A = 57 (0x0039)
0x0274 (0x0004E8) 0x292D- f:00024 d: 301 | OR[301] = A
0x0275 (0x0004EA) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0276 (0x0004EC) 0x292E- f:00024 d: 302 | OR[302] = A
0x0277 (0x0004EE) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0278 (0x0004F0) 0x292F- f:00024 d: 303 | OR[303] = A
0x0279 (0x0004F2) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x027A (0x0004F4) 0x5800- f:00054 d: 0 | B = A
0x027B (0x0004F6) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x027D (0x0004FA) 0x7C09- f:00076 d: 9 | R = OR[9]
0x027E (0x0004FC) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x027F (0x0004FE) 0x2927- f:00024 d: 295 | OR[295] = A
0x0280 (0x000500) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0282 (0x000504) 0x2928- f:00024 d: 296 | OR[296] = A
0x0283 (0x000506) 0x211C- f:00020 d: 284 | A = OR[284]
0x0284 (0x000508) 0x1410- f:00012 d: 16 | A = A + 16 (0x0010)
0x0285 (0x00050A) 0x2929- f:00024 d: 297 | OR[297] = A
0x0286 (0x00050C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0287 (0x00050E) 0x292A- f:00024 d: 298 | OR[298] = A
0x0288 (0x000510) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x0289 (0x000512) 0x292B- f:00024 d: 299 | OR[299] = A
0x028A (0x000514) 0x211D- f:00020 d: 285 | A = OR[285]
0x028B (0x000516) 0x292C- f:00024 d: 300 | OR[300] = A
0x028C (0x000518) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x028D (0x00051A) 0x292D- f:00024 d: 301 | OR[301] = A
0x028E (0x00051C) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x028F (0x00051E) 0x292E- f:00024 d: 302 | OR[302] = A
0x0290 (0x000520) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0291 (0x000522) 0x292F- f:00024 d: 303 | OR[303] = A
0x0292 (0x000524) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0293 (0x000526) 0x5800- f:00054 d: 0 | B = A
0x0294 (0x000528) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0296 (0x00052C) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0297 (0x00052E) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0298 (0x000530) 0x2927- f:00024 d: 295 | OR[295] = A
0x0299 (0x000532) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x029B (0x000536) 0x2928- f:00024 d: 296 | OR[296] = A
0x029C (0x000538) 0x211C- f:00020 d: 284 | A = OR[284]
0x029D (0x00053A) 0x1411- f:00012 d: 17 | A = A + 17 (0x0011)
0x029E (0x00053C) 0x2929- f:00024 d: 297 | OR[297] = A
0x029F (0x00053E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02A0 (0x000540) 0x292A- f:00024 d: 298 | OR[298] = A
0x02A1 (0x000542) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x02A2 (0x000544) 0x292B- f:00024 d: 299 | OR[299] = A
0x02A3 (0x000546) 0x211D- f:00020 d: 285 | A = OR[285]
0x02A4 (0x000548) 0x292C- f:00024 d: 300 | OR[300] = A
0x02A5 (0x00054A) 0x1049- f:00010 d: 73 | A = 73 (0x0049)
0x02A6 (0x00054C) 0x292D- f:00024 d: 301 | OR[301] = A
0x02A7 (0x00054E) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02A8 (0x000550) 0x292E- f:00024 d: 302 | OR[302] = A
0x02A9 (0x000552) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x02AA (0x000554) 0x292F- f:00024 d: 303 | OR[303] = A
0x02AB (0x000556) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02AC (0x000558) 0x5800- f:00054 d: 0 | B = A
0x02AD (0x00055A) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x02AF (0x00055E) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02B0 (0x000560) 0x74A1- f:00072 d: 161 | R = P + 161 (0x0351)
0x02B1 (0x000562) 0x1027- f:00010 d: 39 | A = 39 (0x0027)
0x02B2 (0x000564) 0x2B1C- f:00025 d: 284 | OR[284] = A + OR[284]
0x02B3 (0x000566) 0x2F23- f:00027 d: 291 | OR[291] = OR[291] - 1
0x02B4 (0x000568) 0x7012- f:00070 d: 18 | P = P + 18 (0x02C6)
0x02B5 (0x00056A) 0x2120- f:00020 d: 288 | A = OR[288]
0x02B6 (0x00056C) 0x8402- f:00102 d: 2 | P = P + 2 (0x02B8), A = 0
0x02B7 (0x00056E) 0x700E- f:00070 d: 14 | P = P + 14 (0x02C5)
0x02B8 (0x000570) 0x2003- f:00020 d: 3 | A = OR[3]
0x02B9 (0x000572) 0x1C00-0x0520 f:00016 d: 0 | A = A + 1312 (0x0520)
0x02BB (0x000576) 0x2913- f:00024 d: 275 | OR[275] = A
0x02BC (0x000578) 0x100B- f:00010 d: 11 | A = 11 (0x000B)
0x02BD (0x00057A) 0x2914- f:00024 d: 276 | OR[276] = A
0x02BE (0x00057C) 0x1023- f:00010 d: 35 | A = 35 (0x0023)
0x02BF (0x00057E) 0x2915- f:00024 d: 277 | OR[277] = A
0x02C0 (0x000580) 0x745C- f:00072 d: 92 | R = P + 92 (0x031C)
0x02C1 (0x000582) 0x7490- f:00072 d: 144 | R = P + 144 (0x0351)
0x02C2 (0x000584) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02C3 (0x000586) 0x2920- f:00024 d: 288 | OR[288] = A
0x02C4 (0x000588) 0x7002- f:00070 d: 2 | P = P + 2 (0x02C6)
0x02C5 (0x00058A) 0x748C- f:00072 d: 140 | R = P + 140 (0x0351)
0x02C6 (0x00058C) 0x73D9- f:00071 d: 473 | P = P - 473 (0x00ED)
0x02C7 (0x00058E) 0x2F04- f:00027 d: 260 | OR[260] = OR[260] - 1
0x02C8 (0x000590) 0x3104- f:00030 d: 260 | A = (OR[260])
0x02C9 (0x000592) 0x2904- f:00024 d: 260 | OR[260] = A
0x02CA (0x000594) 0x2104- f:00020 d: 260 | A = OR[260]
0x02CB (0x000596) 0x2706- f:00023 d: 262 | A = A - OR[262]
0x02CC (0x000598) 0x8007- f:00100 d: 7 | P = P + 7 (0x02D3), C = 0
0x02CD (0x00059A) 0x2104- f:00020 d: 260 | A = OR[260]
0x02CE (0x00059C) 0x2705- f:00023 d: 261 | A = A - OR[261]
0x02CF (0x00059E) 0x8003- f:00100 d: 3 | P = P + 3 (0x02D2), C = 0
0x02D0 (0x0005A0) 0x8402- f:00102 d: 2 | P = P + 2 (0x02D2), A = 0
0x02D1 (0x0005A2) 0x7002- f:00070 d: 2 | P = P + 2 (0x02D3)
0x02D2 (0x0005A4) 0x7003- f:00070 d: 3 | P = P + 3 (0x02D5)
0x02D3 (0x0005A6) 0x7C34- f:00076 d: 52 | R = OR[52]
0x02D4 (0x0005A8) 0x000B- f:00000 d: 11 | PASS | **** non-standard encoding with D:0x000B ****
0x02D5 (0x0005AA) 0x211F- f:00020 d: 287 | A = OR[287]
0x02D6 (0x0005AC) 0x8602- f:00103 d: 2 | P = P + 2 (0x02D8), A # 0
0x02D7 (0x0005AE) 0x7009- f:00070 d: 9 | P = P + 9 (0x02E0)
0x02D8 (0x0005B0) 0x101B- f:00010 d: 27 | A = 27 (0x001B)
0x02D9 (0x0005B2) 0x2927- f:00024 d: 295 | OR[295] = A
0x02DA (0x0005B4) 0x211F- f:00020 d: 287 | A = OR[287]
0x02DB (0x0005B6) 0x2928- f:00024 d: 296 | OR[296] = A
0x02DC (0x0005B8) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02DD (0x0005BA) 0x5800- f:00054 d: 0 | B = A
0x02DE (0x0005BC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02DF (0x0005BE) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02E0 (0x0005C0) 0x102A- f:00010 d: 42 | A = 42 (0x002A)
0x02E1 (0x0005C2) 0x2927- f:00024 d: 295 | OR[295] = A
0x02E2 (0x0005C4) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02E3 (0x0005C6) 0x5800- f:00054 d: 0 | B = A
0x02E4 (0x0005C8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02E5 (0x0005CA) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02E6 (0x0005CC) 0x2113- f:00020 d: 275 | A = OR[275]
0x02E7 (0x0005CE) 0x3921- f:00034 d: 289 | (OR[289]) = A
0x02E8 (0x0005D0) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x02E9 (0x0005D2) 0x2927- f:00024 d: 295 | OR[295] = A
0x02EA (0x0005D4) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x02EC (0x0005D8) 0x2928- f:00024 d: 296 | OR[296] = A
0x02ED (0x0005DA) 0x2121- f:00020 d: 289 | A = OR[289]
0x02EE (0x0005DC) 0x2929- f:00024 d: 297 | OR[297] = A
0x02EF (0x0005DE) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02F0 (0x0005E0) 0x292A- f:00024 d: 298 | OR[298] = A
0x02F1 (0x0005E2) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x02F2 (0x0005E4) 0x292B- f:00024 d: 299 | OR[299] = A
0x02F3 (0x0005E6) 0x211D- f:00020 d: 285 | A = OR[285]
0x02F4 (0x0005E8) 0x292C- f:00024 d: 300 | OR[300] = A
0x02F5 (0x0005EA) 0x2115- f:00020 d: 277 | A = OR[277]
0x02F6 (0x0005EC) 0x292D- f:00024 d: 301 | OR[301] = A
0x02F7 (0x0005EE) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x02F8 (0x0005F0) 0x292E- f:00024 d: 302 | OR[302] = A
0x02F9 (0x0005F2) 0x2114- f:00020 d: 276 | A = OR[276]
0x02FA (0x0005F4) 0x292F- f:00024 d: 303 | OR[303] = A
0x02FB (0x0005F6) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02FC (0x0005F8) 0x5800- f:00054 d: 0 | B = A
0x02FD (0x0005FA) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x02FF (0x0005FE) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0300 (0x000600) 0x0200- f:00001 d: 0 | EXIT
0x0301 (0x000602) 0x2113- f:00020 d: 275 | A = OR[275]
0x0302 (0x000604) 0x3921- f:00034 d: 289 | (OR[289]) = A
0x0303 (0x000606) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0304 (0x000608) 0x2927- f:00024 d: 295 | OR[295] = A
0x0305 (0x00060A) 0x1800-0x0011 f:00014 d: 0 | A = 17 (0x0011)
0x0307 (0x00060E) 0x2928- f:00024 d: 296 | OR[296] = A
0x0308 (0x000610) 0x2121- f:00020 d: 289 | A = OR[289]
0x0309 (0x000612) 0x2929- f:00024 d: 297 | OR[297] = A
0x030A (0x000614) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x030B (0x000616) 0x292A- f:00024 d: 298 | OR[298] = A
0x030C (0x000618) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x030D (0x00061A) 0x292B- f:00024 d: 299 | OR[299] = A
0x030E (0x00061C) 0x211D- f:00020 d: 285 | A = OR[285]
0x030F (0x00061E) 0x292C- f:00024 d: 300 | OR[300] = A
0x0310 (0x000620) 0x2115- f:00020 d: 277 | A = OR[277]
0x0311 (0x000622) 0x292D- f:00024 d: 301 | OR[301] = A
0x0312 (0x000624) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0313 (0x000626) 0x292E- f:00024 d: 302 | OR[302] = A
0x0314 (0x000628) 0x2114- f:00020 d: 276 | A = OR[276]
0x0315 (0x00062A) 0x292F- f:00024 d: 303 | OR[303] = A
0x0316 (0x00062C) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0317 (0x00062E) 0x5800- f:00054 d: 0 | B = A
0x0318 (0x000630) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x031A (0x000634) 0x7C09- f:00076 d: 9 | R = OR[9]
0x031B (0x000636) 0x0200- f:00001 d: 0 | EXIT
0x031C (0x000638) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x031D (0x00063A) 0x2916- f:00024 d: 278 | OR[278] = A
0x031E (0x00063C) 0x2116- f:00020 d: 278 | A = OR[278]
0x031F (0x00063E) 0x2714- f:00023 d: 276 | A = A - OR[276]
0x0320 (0x000640) 0x8430- f:00102 d: 48 | P = P + 48 (0x0350), A = 0
0x0321 (0x000642) 0x2116- f:00020 d: 278 | A = OR[278]
0x0322 (0x000644) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x0323 (0x000646) 0x2513- f:00022 d: 275 | A = A + OR[275]
0x0324 (0x000648) 0x290D- f:00024 d: 269 | OR[269] = A
0x0325 (0x00064A) 0x310D- f:00030 d: 269 | A = (OR[269])
0x0326 (0x00064C) 0x290D- f:00024 d: 269 | OR[269] = A
0x0327 (0x00064E) 0x2116- f:00020 d: 278 | A = OR[278]
0x0328 (0x000650) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0329 (0x000652) 0x2908- f:00024 d: 264 | OR[264] = A
0x032A (0x000654) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x032B (0x000656) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x032C (0x000658) 0x8604- f:00103 d: 4 | P = P + 4 (0x0330), A # 0
0x032D (0x00065A) 0x210D- f:00020 d: 269 | A = OR[269]
0x032E (0x00065C) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x032F (0x00065E) 0x290D- f:00024 d: 269 | OR[269] = A
0x0330 (0x000660) 0x210D- f:00020 d: 269 | A = OR[269]
0x0331 (0x000662) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0332 (0x000664) 0x2917- f:00024 d: 279 | OR[279] = A
0x0333 (0x000666) 0x2D16- f:00026 d: 278 | OR[278] = OR[278] + 1
0x0334 (0x000668) 0x8602- f:00103 d: 2 | P = P + 2 (0x0336), A # 0
0x0335 (0x00066A) 0x0200- f:00001 d: 0 | EXIT
0x0336 (0x00066C) 0x2117- f:00020 d: 279 | A = OR[279]
0x0337 (0x00066E) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0338 (0x000670) 0x290D- f:00024 d: 269 | OR[269] = A
0x0339 (0x000672) 0x2115- f:00020 d: 277 | A = OR[277]
0x033A (0x000674) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x033B (0x000676) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x033C (0x000678) 0x290E- f:00024 d: 270 | OR[270] = A
0x033D (0x00067A) 0x2115- f:00020 d: 277 | A = OR[277]
0x033E (0x00067C) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x033F (0x00067E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0340 (0x000680) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0341 (0x000682) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0342 (0x000684) 0x8607- f:00103 d: 7 | P = P + 7 (0x0349), A # 0
0x0343 (0x000686) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0344 (0x000688) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0345 (0x00068A) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0346 (0x00068C) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0347 (0x00068E) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0348 (0x000690) 0x7006- f:00070 d: 6 | P = P + 6 (0x034E)
0x0349 (0x000692) 0x310E- f:00030 d: 270 | A = (OR[270])
0x034A (0x000694) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x034C (0x000698) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x034D (0x00069A) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x034E (0x00069C) 0x2D15- f:00026 d: 277 | OR[277] = OR[277] + 1
0x034F (0x00069E) 0x7231- f:00071 d: 49 | P = P - 49 (0x031E)
0x0350 (0x0006A0) 0x0200- f:00001 d: 0 | EXIT
0x0351 (0x0006A2) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0352 (0x0006A4) 0x2927- f:00024 d: 295 | OR[295] = A
0x0353 (0x0006A6) 0x1800-0x0123 f:00014 d: 0 | A = 291 (0x0123)
0x0355 (0x0006AA) 0x2928- f:00024 d: 296 | OR[296] = A
0x0356 (0x0006AC) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0357 (0x0006AE) 0x2929- f:00024 d: 297 | OR[297] = A
0x0358 (0x0006B0) 0x2118- f:00020 d: 280 | A = OR[280]
0x0359 (0x0006B2) 0x251E- f:00022 d: 286 | A = A + OR[286]
0x035A (0x0006B4) 0x292A- f:00024 d: 298 | OR[298] = A
0x035B (0x0006B6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x035C (0x0006B8) 0x292B- f:00024 d: 299 | OR[299] = A
0x035D (0x0006BA) 0x211D- f:00020 d: 285 | A = OR[285]
0x035E (0x0006BC) 0x292C- f:00024 d: 300 | OR[300] = A
0x035F (0x0006BE) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0360 (0x0006C0) 0x292D- f:00024 d: 301 | OR[301] = A
0x0361 (0x0006C2) 0x1050- f:00010 d: 80 | A = 80 (0x0050)
0x0362 (0x0006C4) 0x292E- f:00024 d: 302 | OR[302] = A
0x0363 (0x0006C6) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0364 (0x0006C8) 0x5800- f:00054 d: 0 | B = A
0x0365 (0x0006CA) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0367 (0x0006CE) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0368 (0x0006D0) 0x2D1E- f:00026 d: 286 | OR[286] = OR[286] + 1
0x0369 (0x0006D2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x036A (0x0006D4) 0x2913- f:00024 d: 275 | OR[275] = A
0x036B (0x0006D6) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x036C (0x0006D8) 0x2914- f:00024 d: 276 | OR[276] = A
0x036D (0x0006DA) 0x2113- f:00020 d: 275 | A = OR[275]
0x036E (0x0006DC) 0x1650- f:00013 d: 80 | A = A - 80 (0x0050)
0x036F (0x0006DE) 0x841B- f:00102 d: 27 | P = P + 27 (0x038A), A = 0
0x0370 (0x0006E0) 0x2114- f:00020 d: 276 | A = OR[276]
0x0371 (0x0006E2) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0372 (0x0006E4) 0x290D- f:00024 d: 269 | OR[269] = A
0x0373 (0x0006E6) 0x2113- f:00020 d: 275 | A = OR[275]
0x0374 (0x0006E8) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x0375 (0x0006EA) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x0376 (0x0006EC) 0x290E- f:00024 d: 270 | OR[270] = A
0x0377 (0x0006EE) 0x2113- f:00020 d: 275 | A = OR[275]
0x0378 (0x0006F0) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0379 (0x0006F2) 0x2908- f:00024 d: 264 | OR[264] = A
0x037A (0x0006F4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x037B (0x0006F6) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x037C (0x0006F8) 0x8607- f:00103 d: 7 | P = P + 7 (0x0383), A # 0
0x037D (0x0006FA) 0x310E- f:00030 d: 270 | A = (OR[270])
0x037E (0x0006FC) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x037F (0x0006FE) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0380 (0x000700) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0381 (0x000702) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0382 (0x000704) 0x7006- f:00070 d: 6 | P = P + 6 (0x0388)
0x0383 (0x000706) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0384 (0x000708) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x0386 (0x00070C) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0387 (0x00070E) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0388 (0x000710) 0x2D13- f:00026 d: 275 | OR[275] = OR[275] + 1
0x0389 (0x000712) 0x721C- f:00071 d: 28 | P = P - 28 (0x036D)
0x038A (0x000714) 0x0200- f:00001 d: 0 | EXIT
0x038B (0x000716) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x038C (0x000718) 0x2927- f:00024 d: 295 | OR[295] = A
0x038D (0x00071A) 0x1800-0x014F f:00014 d: 0 | A = 335 (0x014F)
0x038F (0x00071E) 0x2928- f:00024 d: 296 | OR[296] = A
0x0390 (0x000720) 0x2113- f:00020 d: 275 | A = OR[275]
0x0391 (0x000722) 0x2929- f:00024 d: 297 | OR[297] = A
0x0392 (0x000724) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0393 (0x000726) 0x292A- f:00024 d: 298 | OR[298] = A
0x0394 (0x000728) 0x211D- f:00020 d: 285 | A = OR[285]
0x0395 (0x00072A) 0x1410- f:00012 d: 16 | A = A + 16 (0x0010)
0x0396 (0x00072C) 0x292D- f:00024 d: 301 | OR[301] = A
0x0397 (0x00072E) 0x1050- f:00010 d: 80 | A = 80 (0x0050)
0x0398 (0x000730) 0x1620- f:00013 d: 32 | A = A - 32 (0x0020)
0x0399 (0x000732) 0x292E- f:00024 d: 302 | OR[302] = A
0x039A (0x000734) 0x1019- f:00010 d: 25 | A = 25 (0x0019)
0x039B (0x000736) 0x292F- f:00024 d: 303 | OR[303] = A
0x039C (0x000738) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x039D (0x00073A) 0x5800- f:00054 d: 0 | B = A
0x039E (0x00073C) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x03A0 (0x000740) 0x7C09- f:00076 d: 9 | R = OR[9]
0x03A1 (0x000742) 0x7650- f:00073 d: 80 | R = P - 80 (0x0351)
0x03A2 (0x000744) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x03A3 (0x000746) 0x2920- f:00024 d: 288 | OR[288] = A
0x03A4 (0x000748) 0x0200- f:00001 d: 0 | EXIT
0x03A5 (0x00074A) 0x311C- f:00030 d: 284 | A = (OR[284])
0x03A6 (0x00074C) 0x2917- f:00024 d: 279 | OR[279] = A
0x03A7 (0x00074E) 0x2117- f:00020 d: 279 | A = OR[279]
0x03A8 (0x000750) 0x0807- f:00004 d: 7 | A = A > 7 (0x0007)
0x03A9 (0x000752) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x03AA (0x000754) 0x8602- f:00103 d: 2 | P = P + 2 (0x03AC), A # 0
0x03AB (0x000756) 0x7005- f:00070 d: 5 | P = P + 5 (0x03B0)
0x03AC (0x000758) 0x1800-0x054E f:00014 d: 0 | A = 1358 (0x054E)
0x03AE (0x00075C) 0x2913- f:00024 d: 275 | OR[275] = A
0x03AF (0x00075E) 0x7033- f:00070 d: 51 | P = P + 51 (0x03E2)
0x03B0 (0x000760) 0x2117- f:00020 d: 279 | A = OR[279]
0x03B1 (0x000762) 0x8402- f:00102 d: 2 | P = P + 2 (0x03B3), A = 0
0x03B2 (0x000764) 0x7005- f:00070 d: 5 | P = P + 5 (0x03B7)
0x03B3 (0x000766) 0x1800-0x0526 f:00014 d: 0 | A = 1318 (0x0526)
0x03B5 (0x00076A) 0x2913- f:00024 d: 275 | OR[275] = A
0x03B6 (0x00076C) 0x702C- f:00070 d: 44 | P = P + 44 (0x03E2)
0x03B7 (0x00076E) 0x2117- f:00020 d: 279 | A = OR[279]
0x03B8 (0x000770) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x03B9 (0x000772) 0x8402- f:00102 d: 2 | P = P + 2 (0x03BB), A = 0
0x03BA (0x000774) 0x7005- f:00070 d: 5 | P = P + 5 (0x03BF)
0x03BB (0x000776) 0x1800-0x052A f:00014 d: 0 | A = 1322 (0x052A)
0x03BD (0x00077A) 0x2913- f:00024 d: 275 | OR[275] = A
0x03BE (0x00077C) 0x7024- f:00070 d: 36 | P = P + 36 (0x03E2)
0x03BF (0x00077E) 0x2117- f:00020 d: 279 | A = OR[279]
0x03C0 (0x000780) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x03C1 (0x000782) 0x8402- f:00102 d: 2 | P = P + 2 (0x03C3), A = 0
0x03C2 (0x000784) 0x7005- f:00070 d: 5 | P = P + 5 (0x03C7)
0x03C3 (0x000786) 0x1800-0x052E f:00014 d: 0 | A = 1326 (0x052E)
0x03C5 (0x00078A) 0x2913- f:00024 d: 275 | OR[275] = A
0x03C6 (0x00078C) 0x701C- f:00070 d: 28 | P = P + 28 (0x03E2)
0x03C7 (0x00078E) 0x2117- f:00020 d: 279 | A = OR[279]
0x03C8 (0x000790) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x03C9 (0x000792) 0x8402- f:00102 d: 2 | P = P + 2 (0x03CB), A = 0
0x03CA (0x000794) 0x7005- f:00070 d: 5 | P = P + 5 (0x03CF)
0x03CB (0x000796) 0x1800-0x0532 f:00014 d: 0 | A = 1330 (0x0532)
0x03CD (0x00079A) 0x2913- f:00024 d: 275 | OR[275] = A
0x03CE (0x00079C) 0x7014- f:00070 d: 20 | P = P + 20 (0x03E2)
0x03CF (0x00079E) 0x2117- f:00020 d: 279 | A = OR[279]
0x03D0 (0x0007A0) 0x1608- f:00013 d: 8 | A = A - 8 (0x0008)
0x03D1 (0x0007A2) 0x8402- f:00102 d: 2 | P = P + 2 (0x03D3), A = 0
0x03D2 (0x0007A4) 0x7005- f:00070 d: 5 | P = P + 5 (0x03D7)
0x03D3 (0x0007A6) 0x1800-0x0536 f:00014 d: 0 | A = 1334 (0x0536)
0x03D5 (0x0007AA) 0x2913- f:00024 d: 275 | OR[275] = A
0x03D6 (0x0007AC) 0x700C- f:00070 d: 12 | P = P + 12 (0x03E2)
0x03D7 (0x0007AE) 0x2117- f:00020 d: 279 | A = OR[279]
0x03D8 (0x0007B0) 0x1610- f:00013 d: 16 | A = A - 16 (0x0010)
0x03D9 (0x0007B2) 0x8402- f:00102 d: 2 | P = P + 2 (0x03DB), A = 0
0x03DA (0x0007B4) 0x7005- f:00070 d: 5 | P = P + 5 (0x03DF)
0x03DB (0x0007B6) 0x1800-0x0552 f:00014 d: 0 | A = 1362 (0x0552)
0x03DD (0x0007BA) 0x2913- f:00024 d: 275 | OR[275] = A
0x03DE (0x0007BC) 0x7004- f:00070 d: 4 | P = P + 4 (0x03E2)
0x03DF (0x0007BE) 0x1800-0x0556 f:00014 d: 0 | A = 1366 (0x0556)
0x03E1 (0x0007C2) 0x2913- f:00024 d: 275 | OR[275] = A
0x03E2 (0x0007C4) 0x2113- f:00020 d: 275 | A = OR[275]
0x03E3 (0x0007C6) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x03E4 (0x0007C8) 0x2913- f:00024 d: 275 | OR[275] = A
0x03E5 (0x0007CA) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x03E6 (0x0007CC) 0x2914- f:00024 d: 276 | OR[276] = A
0x03E7 (0x0007CE) 0x1009- f:00010 d: 9 | A = 9 (0x0009)
0x03E8 (0x0007D0) 0x2915- f:00024 d: 277 | OR[277] = A
0x03E9 (0x0007D2) 0x76CD- f:00073 d: 205 | R = P - 205 (0x031C)
0x03EA (0x0007D4) 0x211C- f:00020 d: 284 | A = OR[284]
0x03EB (0x0007D6) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x03EC (0x0007D8) 0x2908- f:00024 d: 264 | OR[264] = A
0x03ED (0x0007DA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x03EE (0x0007DC) 0x080F- f:00004 d: 15 | A = A > 15 (0x000F)
0x03EF (0x0007DE) 0x8403- f:00102 d: 3 | P = P + 3 (0x03F2), A = 0
0x03F0 (0x0007E0) 0x7A03-0x043C f:00075 d: 3 | P = OR[3]+1084 (0x043C)
0x03F2 (0x0007E4) 0x2126- f:00020 d: 294 | A = OR[294]
0x03F3 (0x0007E6) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x03F4 (0x0007E8) 0x8406- f:00102 d: 6 | P = P + 6 (0x03FA), A = 0
0x03F5 (0x0007EA) 0x2126- f:00020 d: 294 | A = OR[294]
0x03F6 (0x0007EC) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x03F7 (0x0007EE) 0x8403- f:00102 d: 3 | P = P + 3 (0x03FA), A = 0
0x03F8 (0x0007F0) 0x7A03-0x040B f:00075 d: 3 | P = OR[3]+1035 (0x040B)
0x03FA (0x0007F4) 0x211C- f:00020 d: 284 | A = OR[284]
0x03FB (0x0007F6) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x03FC (0x0007F8) 0x2908- f:00024 d: 264 | OR[264] = A
0x03FD (0x0007FA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x03FE (0x0007FC) 0x080E- f:00004 d: 14 | A = A > 14 (0x000E)
0x03FF (0x0007FE) 0x2913- f:00024 d: 275 | OR[275] = A
0x0400 (0x000800) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0401 (0x000802) 0x2914- f:00024 d: 276 | OR[276] = A
0x0402 (0x000804) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x0403 (0x000806) 0x2915- f:00024 d: 277 | OR[277] = A
0x0404 (0x000808) 0x7703- f:00073 d: 259 | R = P - 259 (0x0301)
0x0405 (0x00080A) 0x211C- f:00020 d: 284 | A = OR[284]
0x0406 (0x00080C) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0407 (0x00080E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0408 (0x000810) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0409 (0x000812) 0x2913- f:00024 d: 275 | OR[275] = A
0x040A (0x000814) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x040B (0x000816) 0x2914- f:00024 d: 276 | OR[276] = A
0x040C (0x000818) 0x1016- f:00010 d: 22 | A = 22 (0x0016)
0x040D (0x00081A) 0x2915- f:00024 d: 277 | OR[277] = A
0x040E (0x00081C) 0x770D- f:00073 d: 269 | R = P - 269 (0x0301)
0x040F (0x00081E) 0x102F- f:00010 d: 47 | A = 47 (0x002F)
0x0410 (0x000820) 0x2913- f:00024 d: 275 | OR[275] = A
0x0411 (0x000822) 0x2113- f:00020 d: 275 | A = OR[275]
0x0412 (0x000824) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0413 (0x000826) 0x290D- f:00024 d: 269 | OR[269] = A
0x0414 (0x000828) 0x101A- f:00010 d: 26 | A = 26 (0x001A)
0x0415 (0x00082A) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x0416 (0x00082C) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x0417 (0x00082E) 0x290E- f:00024 d: 270 | OR[270] = A
0x0418 (0x000830) 0x101A- f:00010 d: 26 | A = 26 (0x001A)
0x0419 (0x000832) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x041A (0x000834) 0x2908- f:00024 d: 264 | OR[264] = A
0x041B (0x000836) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x041C (0x000838) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x041D (0x00083A) 0x8607- f:00103 d: 7 | P = P + 7 (0x0424), A # 0
0x041E (0x00083C) 0x310E- f:00030 d: 270 | A = (OR[270])
0x041F (0x00083E) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0420 (0x000840) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0421 (0x000842) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0422 (0x000844) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0423 (0x000846) 0x7006- f:00070 d: 6 | P = P + 6 (0x0429)
0x0424 (0x000848) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0425 (0x00084A) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x0427 (0x00084E) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0428 (0x000850) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0429 (0x000852) 0x211C- f:00020 d: 284 | A = OR[284]
0x042A (0x000854) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x042B (0x000856) 0x2908- f:00024 d: 264 | OR[264] = A
0x042C (0x000858) 0x3108- f:00030 d: 264 | A = (OR[264])
0x042D (0x00085A) 0x0809- f:00004 d: 9 | A = A > 9 (0x0009)
0x042E (0x00085C) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x042F (0x00085E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0430 (0x000860) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x0431 (0x000862) 0x2914- f:00024 d: 276 | OR[276] = A
0x0432 (0x000864) 0x101B- f:00010 d: 27 | A = 27 (0x001B)
0x0433 (0x000866) 0x2915- f:00024 d: 277 | OR[277] = A
0x0434 (0x000868) 0x7733- f:00073 d: 307 | R = P - 307 (0x0301)
0x0435 (0x00086A) 0x700A- f:00070 d: 10 | P = P + 10 (0x043F)
0x0436 (0x00086C) 0x1800-0x055A f:00014 d: 0 | A = 1370 (0x055A)
0x0438 (0x000870) 0x2403- f:00022 d: 3 | A = A + OR[3]
0x0439 (0x000872) 0x2913- f:00024 d: 275 | OR[275] = A
0x043A (0x000874) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x043B (0x000876) 0x2914- f:00024 d: 276 | OR[276] = A
0x043C (0x000878) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x043D (0x00087A) 0x2915- f:00024 d: 277 | OR[277] = A
0x043E (0x00087C) 0x7722- f:00073 d: 290 | R = P - 290 (0x031C)
0x043F (0x00087E) 0x211C- f:00020 d: 284 | A = OR[284]
0x0440 (0x000880) 0x1410- f:00012 d: 16 | A = A + 16 (0x0010)
0x0441 (0x000882) 0x2913- f:00024 d: 275 | OR[275] = A
0x0442 (0x000884) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0443 (0x000886) 0x2927- f:00024 d: 295 | OR[295] = A
0x0444 (0x000888) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0446 (0x00088C) 0x2928- f:00024 d: 296 | OR[296] = A
0x0447 (0x00088E) 0x2113- f:00020 d: 275 | A = OR[275]
0x0448 (0x000890) 0x2929- f:00024 d: 297 | OR[297] = A
0x0449 (0x000892) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x044A (0x000894) 0x292A- f:00024 d: 298 | OR[298] = A
0x044B (0x000896) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x044C (0x000898) 0x292B- f:00024 d: 299 | OR[299] = A
0x044D (0x00089A) 0x211D- f:00020 d: 285 | A = OR[285]
0x044E (0x00089C) 0x292C- f:00024 d: 300 | OR[300] = A
0x044F (0x00089E) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x0450 (0x0008A0) 0x292D- f:00024 d: 301 | OR[301] = A
0x0451 (0x0008A2) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0452 (0x0008A4) 0x292E- f:00024 d: 302 | OR[302] = A
0x0453 (0x0008A6) 0x100A- f:00010 d: 10 | A = 10 (0x000A)
0x0454 (0x0008A8) 0x292F- f:00024 d: 303 | OR[303] = A
0x0455 (0x0008AA) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0456 (0x0008AC) 0x5800- f:00054 d: 0 | B = A
0x0457 (0x0008AE) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0459 (0x0008B2) 0x7C09- f:00076 d: 9 | R = OR[9]
0x045A (0x0008B4) 0x211C- f:00020 d: 284 | A = OR[284]
0x045B (0x0008B6) 0x1412- f:00012 d: 18 | A = A + 18 (0x0012)
0x045C (0x0008B8) 0x2913- f:00024 d: 275 | OR[275] = A
0x045D (0x0008BA) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x045E (0x0008BC) 0x2927- f:00024 d: 295 | OR[295] = A
0x045F (0x0008BE) 0x1800-0x000F f:00014 d: 0 | A = 15 (0x000F)
0x0461 (0x0008C2) 0x2928- f:00024 d: 296 | OR[296] = A
0x0462 (0x0008C4) 0x2113- f:00020 d: 275 | A = OR[275]
0x0463 (0x0008C6) 0x2929- f:00024 d: 297 | OR[297] = A
0x0464 (0x0008C8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0465 (0x0008CA) 0x292A- f:00024 d: 298 | OR[298] = A
0x0466 (0x0008CC) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x0467 (0x0008CE) 0x292B- f:00024 d: 299 | OR[299] = A
0x0468 (0x0008D0) 0x211D- f:00020 d: 285 | A = OR[285]
0x0469 (0x0008D2) 0x292C- f:00024 d: 300 | OR[300] = A
0x046A (0x0008D4) 0x102C- f:00010 d: 44 | A = 44 (0x002C)
0x046B (0x0008D6) 0x292D- f:00024 d: 301 | OR[301] = A
0x046C (0x0008D8) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x046D (0x0008DA) 0x292E- f:00024 d: 302 | OR[302] = A
0x046E (0x0008DC) 0x100A- f:00010 d: 10 | A = 10 (0x000A)
0x046F (0x0008DE) 0x292F- f:00024 d: 303 | OR[303] = A
0x0470 (0x0008E0) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x0471 (0x0008E2) 0x5800- f:00054 d: 0 | B = A
0x0472 (0x0008E4) 0x1800-0x1F18 f:00014 d: 0 | A = 7960 (0x1F18)
0x0474 (0x0008E8) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0475 (0x0008EA) 0x211C- f:00020 d: 284 | A = OR[284]
0x0476 (0x0008EC) 0x1417- f:00012 d: 23 | A = A + 23 (0x0017)
0x0477 (0x0008EE) 0x2908- f:00024 d: 264 | OR[264] = A
0x0478 (0x0008F0) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0479 (0x0008F2) 0x2913- f:00024 d: 275 | OR[275] = A
0x047A (0x0008F4) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x047B (0x0008F6) 0x2914- f:00024 d: 276 | OR[276] = A
0x047C (0x0008F8) 0x1039- f:00010 d: 57 | A = 57 (0x0039)
0x047D (0x0008FA) 0x2915- f:00024 d: 277 | OR[277] = A
0x047E (0x0008FC) 0x7798- f:00073 d: 408 | R = P - 408 (0x02E6)
0x047F (0x0008FE) 0x211C- f:00020 d: 284 | A = OR[284]
0x0480 (0x000900) 0x141C- f:00012 d: 28 | A = A + 28 (0x001C)
0x0481 (0x000902) 0x2908- f:00024 d: 264 | OR[264] = A
0x0482 (0x000904) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0483 (0x000906) 0x2913- f:00024 d: 275 | OR[275] = A
0x0484 (0x000908) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x0485 (0x00090A) 0x2914- f:00024 d: 276 | OR[276] = A
0x0486 (0x00090C) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x0487 (0x00090E) 0x2915- f:00024 d: 277 | OR[277] = A
0x0488 (0x000910) 0x77A2- f:00073 d: 418 | R = P - 418 (0x02E6)
0x0489 (0x000912) 0x211C- f:00020 d: 284 | A = OR[284]
0x048A (0x000914) 0x141D- f:00012 d: 29 | A = A + 29 (0x001D)
0x048B (0x000916) 0x2908- f:00024 d: 264 | OR[264] = A
0x048C (0x000918) 0x3108- f:00030 d: 264 | A = (OR[264])
0x048D (0x00091A) 0x2913- f:00024 d: 275 | OR[275] = A
0x048E (0x00091C) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x048F (0x00091E) 0x2914- f:00024 d: 276 | OR[276] = A
0x0490 (0x000920) 0x1049- f:00010 d: 73 | A = 73 (0x0049)
0x0491 (0x000922) 0x2915- f:00024 d: 277 | OR[277] = A
0x0492 (0x000924) 0x77AC- f:00073 d: 428 | R = P - 428 (0x02E6)
0x0493 (0x000926) 0x0200- f:00001 d: 0 | EXIT
0x0494 (0x000928) 0x494F- f:00044 d: 335 | A = A > B | **** non-standard encoding with D:0x014F ****
0x0495 (0x00092A) 0x502D- f:00050 d: 45 | A = B | **** non-standard encoding with D:0x002D ****
0x0496 (0x00092C) 0x3120- f:00030 d: 288 | A = (OR[288])
0x0497 (0x00092E) 0x4449- f:00042 d: 73 | C = 1, IOB = DN | **** non-standard encoding with D:0x0049 ****
0x0498 (0x000930) 0x534B- f:00051 d: 331 | A = A & B | **** non-standard encoding with D:0x014B ****
0x0499 (0x000932) 0x2044- f:00020 d: 68 | A = OR[68]
0x049A (0x000934) 0x4953- f:00044 d: 339 | A = A > B | **** non-standard encoding with D:0x0153 ****
0x049B (0x000936) 0x504C- f:00050 d: 76 | A = B | **** non-standard encoding with D:0x004C ****
0x049C (0x000938) 0x4159- f:00040 d: 345 | C = 1, io 0531 = DN
0x049D (0x00093A) 0x0000- f:00000 d: 0 | PASS
0x049E (0x00093C) 0x4F55- f:00047 d: 341 | A = A << B | **** non-standard encoding with D:0x0155 ****
0x049F (0x00093E) 0x5453- f:00052 d: 83 | A = A + B | **** non-standard encoding with D:0x0053 ****
0x04A0 (0x000940) 0x5441- f:00052 d: 65 | A = A + B | **** non-standard encoding with D:0x0041 ****
0x04A1 (0x000942) 0x4E44- f:00047 d: 68 | A = A << B | **** non-standard encoding with D:0x0044 ****
0x04A2 (0x000944) 0x494E- f:00044 d: 334 | A = A > B | **** non-standard encoding with D:0x014E ****
0x04A3 (0x000946) 0x4720- f:00043 d: 288 | C = 1, IOB = BZ | **** non-standard encoding with D:0x0120 ****
0x04A4 (0x000948) 0x4449- f:00042 d: 73 | C = 1, IOB = DN | **** non-standard encoding with D:0x0049 ****
0x04A5 (0x00094A) 0x534B- f:00051 d: 331 | A = A & B | **** non-standard encoding with D:0x014B ****
0x04A6 (0x00094C) 0x2052- f:00020 d: 82 | A = OR[82]
0x04A7 (0x00094E) 0x4551- f:00042 d: 337 | C = 1, IOB = DN | **** non-standard encoding with D:0x0151 ****
0x04A8 (0x000950) 0x533A- f:00051 d: 314 | A = A & B | **** non-standard encoding with D:0x013A ****
0x04A9 (0x000952) 0x0000- f:00000 d: 0 | PASS
0x04AA (0x000954) 0x4652- f:00043 d: 82 | C = 1, IOB = BZ | **** non-standard encoding with D:0x0052 ****
0x04AB (0x000956) 0x414D- f:00040 d: 333 | C = 1, io 0515 = DN
0x04AC (0x000958) 0x4500- f:00042 d: 256 | C = 1, IOB = DN | **** non-standard encoding with D:0x0100 ****
0x04AD (0x00095A) 0x4355- f:00041 d: 341 | C = 1, io 0525 = BZ
0x04AE (0x00095C) 0x5252- f:00051 d: 82 | A = A & B | **** non-standard encoding with D:0x0052 ****
0x04AF (0x00095E) 0x454E- f:00042 d: 334 | C = 1, IOB = DN | **** non-standard encoding with D:0x014E ****
0x04B0 (0x000960) 0x5420- f:00052 d: 32 | A = A + B | **** non-standard encoding with D:0x0020 ****
0x04B1 (0x000962) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B2 (0x000964) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B3 (0x000966) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B4 (0x000968) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B5 (0x00096A) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B6 (0x00096C) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B7 (0x00096E) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B8 (0x000970) 0x2020- f:00020 d: 32 | A = OR[32]
0x04B9 (0x000972) 0x5345- f:00051 d: 325 | A = A & B | **** non-standard encoding with D:0x0145 ****
0x04BA (0x000974) 0x4354- f:00041 d: 340 | C = 1, io 0524 = BZ
0x04BB (0x000976) 0x4F52- f:00047 d: 338 | A = A << B | **** non-standard encoding with D:0x0152 ****
0x04BC (0x000978) 0x5320- f:00051 d: 288 | A = A & B | **** non-standard encoding with D:0x0120 ****
0x04BD (0x00097A) 0x4143- f:00040 d: 323 | C = 1, io 0503 = DN
0x04BE (0x00097C) 0x4345- f:00041 d: 325 | C = 1, io 0505 = BZ
0x04BF (0x00097E) 0x5353- f:00051 d: 339 | A = A & B | **** non-standard encoding with D:0x0153 ****
0x04C0 (0x000980) 0x4544- f:00042 d: 324 | C = 1, IOB = DN | **** non-standard encoding with D:0x0144 ****
0x04C1 (0x000982) 0x2020- f:00020 d: 32 | A = OR[32]
0x04C2 (0x000984) 0x2020- f:00020 d: 32 | A = OR[32]
0x04C3 (0x000986) 0x2020- f:00020 d: 32 | A = OR[32]
0x04C4 (0x000988) 0x2020- f:00020 d: 32 | A = OR[32]
0x04C5 (0x00098A) 0x2020- f:00020 d: 32 | A = OR[32]
0x04C6 (0x00098C) 0x2045- f:00020 d: 69 | A = OR[69]
0x04C7 (0x00098E) 0x5252- f:00051 d: 82 | A = A & B | **** non-standard encoding with D:0x0052 ****
0x04C8 (0x000990) 0x4F52- f:00047 d: 338 | A = A << B | **** non-standard encoding with D:0x0152 ****
0x04C9 (0x000992) 0x5300- f:00051 d: 256 | A = A & B | **** non-standard encoding with D:0x0100 ****
0x04CA (0x000994) 0x4348- f:00041 d: 328 | C = 1, io 0510 = BZ
0x04CB (0x000996) 0x2054- f:00020 d: 84 | A = OR[84]
0x04CC (0x000998) 0x5950- f:00054 d: 336 | B = A | **** non-standard encoding with D:0x0150 ****
0x04CD (0x00099A) 0x4520- f:00042 d: 288 | C = 1, IOB = DN | **** non-standard encoding with D:0x0120 ****
0x04CE (0x00099C) 0x2053- f:00020 d: 83 | A = OR[83]
0x04CF (0x00099E) 0x5441- f:00052 d: 65 | A = A + B | **** non-standard encoding with D:0x0041 ****
0x04D0 (0x0009A0) 0x5455- f:00052 d: 85 | A = A + B | **** non-standard encoding with D:0x0055 ****
0x04D1 (0x0009A2) 0x5320- f:00051 d: 288 | A = A & B | **** non-standard encoding with D:0x0120 ****
0x04D2 (0x0009A4) 0x2055- f:00020 d: 85 | A = OR[85]
0x04D3 (0x0009A6) 0x4E49- f:00047 d: 73 | A = A << B | **** non-standard encoding with D:0x0049 ****
0x04D4 (0x0009A8) 0x5420- f:00052 d: 32 | A = A + B | **** non-standard encoding with D:0x0020 ****
0x04D5 (0x0009AA) 0x2043- f:00020 d: 67 | A = OR[67]
0x04D6 (0x0009AC) 0x594C- f:00054 d: 332 | B = A | **** non-standard encoding with D:0x014C ****
0x04D7 (0x0009AE) 0x2F48- f:00027 d: 328 | OR[328] = OR[328] - 1
0x04D8 (0x0009B0) 0x4420- f:00042 d: 32 | C = 1, IOB = DN | **** non-standard encoding with D:0x0020 ****
0x04D9 (0x0009B2) 0x2020- f:00020 d: 32 | A = OR[32]
0x04DA (0x0009B4) 0x2020- f:00020 d: 32 | A = OR[32]
0x04DB (0x0009B6) 0x2020- f:00020 d: 32 | A = OR[32]
0x04DC (0x0009B8) 0x2052- f:00020 d: 82 | A = OR[82]
0x04DD (0x0009BA) 0x4541- f:00042 d: 321 | C = 1, IOB = DN | **** non-standard encoding with D:0x0141 ****
0x04DE (0x0009BC) 0x4453- f:00042 d: 83 | C = 1, IOB = DN | **** non-standard encoding with D:0x0053 ****
0x04DF (0x0009BE) 0x2020- f:00020 d: 32 | A = OR[32]
0x04E0 (0x0009C0) 0x2020- f:00020 d: 32 | A = OR[32]
0x04E1 (0x0009C2) 0x2020- f:00020 d: 32 | A = OR[32]
0x04E2 (0x0009C4) 0x5752- f:00053 d: 338 | A = A - B | **** non-standard encoding with D:0x0152 ****
0x04E3 (0x0009C6) 0x4954- f:00044 d: 340 | A = A > B | **** non-standard encoding with D:0x0154 ****
0x04E4 (0x0009C8) 0x4553- f:00042 d: 339 | C = 1, IOB = DN | **** non-standard encoding with D:0x0153 ****
0x04E5 (0x0009CA) 0x2020- f:00020 d: 32 | A = OR[32]
0x04E6 (0x0009CC) 0x2020- f:00020 d: 32 | A = OR[32]
0x04E7 (0x0009CE) 0x522E- f:00051 d: 46 | A = A & B | **** non-standard encoding with D:0x002E ****
0x04E8 (0x0009D0) 0x412E- f:00040 d: 302 | C = 1, io 0456 = DN
0x04E9 (0x0009D2) 0x2020- f:00020 d: 32 | A = OR[32]
0x04EA (0x0009D4) 0x2020- f:00020 d: 32 | A = OR[32]
0x04EB (0x0009D6) 0x544F- f:00052 d: 79 | A = A + B | **** non-standard encoding with D:0x004F ****
0x04EC (0x0009D8) 0x5441- f:00052 d: 65 | A = A + B | **** non-standard encoding with D:0x0041 ****
0x04ED (0x0009DA) 0x4C20- f:00046 d: 32 | A = A >> B | **** non-standard encoding with D:0x0020 ****
0x04EE (0x0009DC) 0x2055- f:00020 d: 85 | A = OR[85]
0x04EF (0x0009DE) 0x4E52- f:00047 d: 82 | A = A << B | **** non-standard encoding with D:0x0052 ****
0x04F0 (0x0009E0) 0x4543- f:00042 d: 323 | C = 1, IOB = DN | **** non-standard encoding with D:0x0143 ****
0x04F1 (0x0009E2) 0x0000- f:00000 d: 0 | PASS
0x04F2 (0x0009E4) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04F3 (0x0009E6) 0x202D- f:00020 d: 45 | A = OR[45]
0x04F4 (0x0009E8) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04F5 (0x0009EA) 0x2D20- f:00026 d: 288 | OR[288] = OR[288] + 1
0x04F6 (0x0009EC) 0x202D- f:00020 d: 45 | A = OR[45]
0x04F7 (0x0009EE) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04F8 (0x0009F0) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04F9 (0x0009F2) 0x2D20- f:00026 d: 288 | OR[288] = OR[288] + 1
0x04FA (0x0009F4) 0x202D- f:00020 d: 45 | A = OR[45]
0x04FB (0x0009F6) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04FC (0x0009F8) 0x2D20- f:00026 d: 288 | OR[288] = OR[288] + 1
0x04FD (0x0009FA) 0x202D- f:00020 d: 45 | A = OR[45]
0x04FE (0x0009FC) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x04FF (0x0009FE) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0500 (0x000A00) 0x2D20- f:00026 d: 288 | OR[288] = OR[288] + 1
0x0501 (0x000A02) 0x2020- f:00020 d: 32 | A = OR[32]
0x0502 (0x000A04) 0x2020- f:00020 d: 32 | A = OR[32]
0x0503 (0x000A06) 0x2020- f:00020 d: 32 | A = OR[32]
0x0504 (0x000A08) 0x202D- f:00020 d: 45 | A = OR[45]
0x0505 (0x000A0A) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0506 (0x000A0C) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0507 (0x000A0E) 0x2020- f:00020 d: 32 | A = OR[32]
0x0508 (0x000A10) 0x2020- f:00020 d: 32 | A = OR[32]
0x0509 (0x000A12) 0x2020- f:00020 d: 32 | A = OR[32]
0x050A (0x000A14) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x050B (0x000A16) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x050C (0x000A18) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x050D (0x000A1A) 0x2020- f:00020 d: 32 | A = OR[32]
0x050E (0x000A1C) 0x2020- f:00020 d: 32 | A = OR[32]
0x050F (0x000A1E) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0510 (0x000A20) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0511 (0x000A22) 0x2020- f:00020 d: 32 | A = OR[32]
0x0512 (0x000A24) 0x2020- f:00020 d: 32 | A = OR[32]
0x0513 (0x000A26) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0514 (0x000A28) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0515 (0x000A2A) 0x2D20- f:00026 d: 288 | OR[288] = OR[288] + 1
0x0516 (0x000A2C) 0x202D- f:00020 d: 45 | A = OR[45]
0x0517 (0x000A2E) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0518 (0x000A30) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0519 (0x000A32) 0x0000- f:00000 d: 0 | PASS
0x051A (0x000A34) 0x454E- f:00042 d: 334 | C = 1, IOB = DN | **** non-standard encoding with D:0x014E ****
0x051B (0x000A36) 0x4420- f:00042 d: 32 | C = 1, IOB = DN | **** non-standard encoding with D:0x0020 ****
0x051C (0x000A38) 0x4F46- f:00047 d: 326 | A = A << B | **** non-standard encoding with D:0x0146 ****
0x051D (0x000A3A) 0x2044- f:00020 d: 68 | A = OR[68]
0x051E (0x000A3C) 0x4154- f:00040 d: 340 | C = 1, io 0524 = DN
0x051F (0x000A3E) 0x4100- f:00040 d: 256 | C = 1, io 0400 = DN
0x0520 (0x000A40) 0x4944- f:00044 d: 324 | A = A > B | **** non-standard encoding with D:0x0144 ****
0x0521 (0x000A42) 0x4C45- f:00046 d: 69 | A = A >> B | **** non-standard encoding with D:0x0045 ****
0x0522 (0x000A44) 0x2020- f:00020 d: 32 | A = OR[32]
0x0523 (0x000A46) 0x2000- f:00020 d: 0 | A = OR[0]
0x0524 (0x000A48) 0x5245- f:00051 d: 69 | A = A & B | **** non-standard encoding with D:0x0045 ****
0x0525 (0x000A4A) 0x4144- f:00040 d: 324 | C = 1, io 0504 = DN
0x0526 (0x000A4C) 0x2020- f:00020 d: 32 | A = OR[32]
0x0527 (0x000A4E) 0x2000- f:00020 d: 0 | A = OR[0]
0x0528 (0x000A50) 0x5752- f:00053 d: 338 | A = A - B | **** non-standard encoding with D:0x0152 ****
0x0529 (0x000A52) 0x4954- f:00044 d: 340 | A = A > B | **** non-standard encoding with D:0x0154 ****
0x052A (0x000A54) 0x4520- f:00042 d: 288 | C = 1, IOB = DN | **** non-standard encoding with D:0x0120 ****
0x052B (0x000A56) 0x2000- f:00020 d: 0 | A = OR[0]
0x052C (0x000A58) 0x522E- f:00051 d: 46 | A = A & B | **** non-standard encoding with D:0x002E ****
0x052D (0x000A5A) 0x412E- f:00040 d: 302 | C = 1, io 0456 = DN
0x052E (0x000A5C) 0x2020- f:00020 d: 32 | A = OR[32]
0x052F (0x000A5E) 0x2000- f:00020 d: 0 | A = OR[0]
0x0530 (0x000A60) 0x5345- f:00051 d: 325 | A = A & B | **** non-standard encoding with D:0x0145 ****
0x0531 (0x000A62) 0x454B- f:00042 d: 331 | C = 1, IOB = DN | **** non-standard encoding with D:0x014B ****
0x0532 (0x000A64) 0x2020- f:00020 d: 32 | A = OR[32]
0x0533 (0x000A66) 0x2000- f:00020 d: 0 | A = OR[0]
0x0534 (0x000A68) 0x4552- f:00042 d: 338 | C = 1, IOB = DN | **** non-standard encoding with D:0x0152 ****
0x0535 (0x000A6A) 0x2D52- f:00026 d: 338 | OR[338] = OR[338] + 1
0x0536 (0x000A6C) 0x4541- f:00042 d: 321 | C = 1, IOB = DN | **** non-standard encoding with D:0x0141 ****
0x0537 (0x000A6E) 0x4400- f:00042 d: 0 | C = 1, IOB = DN
0x0538 (0x000A70) 0x4552- f:00042 d: 338 | C = 1, IOB = DN | **** non-standard encoding with D:0x0152 ****
0x0539 (0x000A72) 0x2D57- f:00026 d: 343 | OR[343] = OR[343] + 1
0x053A (0x000A74) 0x5254- f:00051 d: 84 | A = A & B | **** non-standard encoding with D:0x0054 ****
0x053B (0x000A76) 0x2000- f:00020 d: 0 | A = OR[0]
0x053C (0x000A78) 0x4552- f:00042 d: 338 | C = 1, IOB = DN | **** non-standard encoding with D:0x0152 ****
0x053D (0x000A7A) 0x2D53- f:00026 d: 339 | OR[339] = OR[339] + 1
0x053E (0x000A7C) 0x4545- f:00042 d: 325 | C = 1, IOB = DN | **** non-standard encoding with D:0x0145 ****
0x053F (0x000A7E) 0x4B00- f:00045 d: 256 | A = A < B | **** non-standard encoding with D:0x0100 ****
0x0540 (0x000A80) 0x572D- f:00053 d: 301 | A = A - B | **** non-standard encoding with D:0x012D ****
0x0541 (0x000A82) 0x4255- f:00041 d: 85 | C = 1, io 0125 = BZ
0x0542 (0x000A84) 0x4646- f:00043 d: 70 | C = 1, IOB = BZ | **** non-standard encoding with D:0x0046 ****
0x0543 (0x000A86) 0x2000- f:00020 d: 0 | A = OR[0]
0x0544 (0x000A88) 0x572D- f:00053 d: 301 | A = A - B | **** non-standard encoding with D:0x012D ****
0x0545 (0x000A8A) 0x4441- f:00042 d: 65 | C = 1, IOB = DN | **** non-standard encoding with D:0x0041 ****
0x0546 (0x000A8C) 0x5441- f:00052 d: 65 | A = A + B | **** non-standard encoding with D:0x0041 ****
0x0547 (0x000A8E) 0x2000- f:00020 d: 0 | A = OR[0]
0x0548 (0x000A90) 0x4552- f:00042 d: 338 | C = 1, IOB = DN | **** non-standard encoding with D:0x0152 ****
0x0549 (0x000A92) 0x524F- f:00051 d: 79 | A = A & B | **** non-standard encoding with D:0x004F ****
0x054A (0x000A94) 0x5220- f:00051 d: 32 | A = A & B | **** non-standard encoding with D:0x0020 ****
0x054B (0x000A96) 0x2000- f:00020 d: 0 | A = OR[0]
0x054C (0x000A98) 0x4845- f:00044 d: 69 | A = A > B | **** non-standard encoding with D:0x0045 ****
0x054D (0x000A9A) 0x4144- f:00040 d: 324 | C = 1, io 0504 = DN
0x054E (0x000A9C) 0x5345- f:00051 d: 325 | A = A & B | **** non-standard encoding with D:0x0145 ****
0x054F (0x000A9E) 0x4C00- f:00046 d: 0 | A = A >> B
0x0550 (0x000AA0) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0551 (0x000AA2) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0552 (0x000AA4) 0x2D2D- f:00026 d: 301 | OR[301] = OR[301] + 1
0x0553 (0x000AA6) 0x2D00- f:00026 d: 256 | OR[256] = OR[256] + 1
0x0554 (0x000AA8) 0x4445- f:00042 d: 69 | C = 1, IOB = DN | **** non-standard encoding with D:0x0045 ****
0x0555 (0x000AAA) 0x5345- f:00051 d: 325 | A = A & B | **** non-standard encoding with D:0x0145 ****
0x0556 (0x000AAC) 0x4C45- f:00046 d: 69 | A = A >> B | **** non-standard encoding with D:0x0045 ****
0x0557 (0x000AAE) 0x4354- f:00041 d: 340 | C = 1, io 0524 = BZ
0x0558 (0x000AB0) 0x0000- f:00000 d: 0 | PASS
0x0559 (0x000AB2) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x055A (0x000AB4) 0x3139- f:00030 d: 313 | A = (OR[313])
0x055B (0x000AB6) 0x0000- f:00000 d: 0 | PASS
0x055C (0x000AB8) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x055D (0x000ABA) 0x3239- f:00031 d: 57 | A = A & (OR[57])
0x055E (0x000ABC) 0x0000- f:00000 d: 0 | PASS
0x055F (0x000ABE) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x0560 (0x000AC0) 0x3439- f:00032 d: 57 | A = A + (OR[57])
0x0561 (0x000AC2) 0x0000- f:00000 d: 0 | PASS
0x0562 (0x000AC4) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x0563 (0x000AC6) 0x3339- f:00031 d: 313 | A = A & (OR[313])
0x0564 (0x000AC8) 0x0000- f:00000 d: 0 | PASS
0x0565 (0x000ACA) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x0566 (0x000ACC) 0x3130- f:00030 d: 304 | A = (OR[304])
0x0567 (0x000ACE) 0x0000- f:00000 d: 0 | PASS
0x0568 (0x000AD0) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x0569 (0x000AD2) 0x3430- f:00032 d: 48 | A = A + (OR[48])
0x056A (0x000AD4) 0x0000- f:00000 d: 0 | PASS
0x056B (0x000AD6) 0x4444- f:00042 d: 68 | C = 1, IOB = DN | **** non-standard encoding with D:0x0044 ****
0x056C (0x000AD8) 0x3530- f:00032 d: 304 | A = A + (OR[304])
0x056D (0x000ADA) 0x0000- f:00000 d: 0 | PASS
0x056E (0x000ADC) 0x055F- f:00002 d: 351 | I = 0 | **** non-standard encoding with D:0x015F ****
0x056F (0x000ADE) 0x0562- f:00002 d: 354 | I = 0 | **** non-standard encoding with D:0x0162 ****
0x0570 (0x000AE0) 0x0565- f:00002 d: 357 | I = 0 | **** non-standard encoding with D:0x0165 ****
0x0571 (0x000AE2) 0x0568- f:00002 d: 360 | I = 0 | **** non-standard encoding with D:0x0168 ****
0x0572 (0x000AE4) 0x056B- f:00002 d: 363 | I = 0 | **** non-standard encoding with D:0x016B ****
0x0573 (0x000AE6) 0x056E- f:00002 d: 366 | I = 0 | **** non-standard encoding with D:0x016E ****
0x0574 (0x000AE8) 0x0571- f:00002 d: 369 | I = 0 | **** non-standard encoding with D:0x0171 ****
0x0575 (0x000AEA) 0x0000- f:00000 d: 0 | PASS
0x0576 (0x000AEC) 0x0000- f:00000 d: 0 | PASS
0x0577 (0x000AEE) 0x0000- f:00000 d: 0 | PASS
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0_notsx.log_21829_559.asm | ljhsiun2/medusa | 9 | 26786 | <gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r15
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_normal_ht+0x1e5ab, %rsi
lea addresses_A_ht+0x10fd3, %rdi
nop
nop
nop
nop
sub $41139, %r10
mov $95, %rcx
rep movsw
nop
add %r14, %r14
lea addresses_WT_ht+0x10c2b, %rdx
nop
nop
nop
nop
nop
cmp %r15, %r15
movb $0x61, (%rdx)
nop
nop
sub %r15, %r15
lea addresses_A_ht+0xf7ab, %rsi
nop
nop
nop
add %rdx, %rdx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm3
movups %xmm3, (%rsi)
nop
nop
and $30662, %r15
lea addresses_UC_ht+0xe9e8, %rcx
nop
nop
nop
nop
add %rdi, %rdi
movw $0x6162, (%rcx)
nop
nop
nop
nop
cmp $36058, %r15
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r15
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r15
push %r8
push %rax
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_WT+0x1333, %rax
nop
nop
dec %rdx
movb $0x51, (%rax)
nop
nop
nop
nop
nop
xor %rsi, %rsi
// Store
lea addresses_WC+0x5eab, %rbp
nop
nop
nop
sub %rcx, %rcx
movb $0x51, (%rbp)
nop
dec %rsi
// REPMOV
lea addresses_PSE+0x135ab, %rsi
lea addresses_WT+0x1e9ab, %rdi
nop
nop
nop
nop
nop
dec %r8
mov $50, %rcx
rep movsw
nop
nop
nop
nop
nop
inc %rax
// Faulty Load
lea addresses_normal+0x1e5ab, %rdi
cmp %rsi, %rsi
movb (%rdi), %cl
lea oracles, %rdx
and $0xff, %rcx
shlq $12, %rcx
mov (%rdx,%rcx,1), %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r8
pop %r15
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 5}}
{'src': {'type': 'addresses_PSE', 'congruent': 11, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT', 'congruent': 10, 'same': False}}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_normal_ht', 'congruent': 10, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 16, 'NT': False, 'same': False, 'congruent': 9}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 0}}
{'34': 21829}
34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34 34
*/
|
CS35101/mzrimsek/Project 2/average.asm | mzrimsek/school | 0 | 91480 | #Computer Architecture
#Project 2
#<NAME>
.data
prompt: .asciiz "\nEnter number: " #Prompt to get user input of number
.align 2
numPrompt: .asciiz "\nHow many numbers: " #Prompt to determine how many numbers to enter
.align 2
currentVal: .asciiz "\nValue of numbers entered: " #String to display after each time a number is entered
.align 2
average: .asciiz "\nMean of numbers: " #String to display after average of numbers has been calculated
.align 2
.text
.globl main
main:
la $a0, numPrompt #print numPrompt string
li $v0, 4
syscall
la $a0, numPrompt #prompt for enter amount of numbers (integer)
li $v0, 5
syscall
addi $s1, $v0, 0 #s1: n = amount of numbers to be entered
addi $s0, $0, 0 #s0: i = 0 : loop counter
#for loop to get user input
for:
la $a0, prompt #print prompt string
li $v0, 4
syscall
li $v0, 6 #prompt to enter number (float)
syscall
add.s $f1, $f1, $f0 #f1 = f0 + f1 : add newly entered number to current $f0 value
la $a0, currentVal #print currentVal string
li $v0, 4
syscall
la $v0, 2 #print current value of numbers entered
mov.s $f12, $f1
syscall
addi $s0, $s0, 1 #i++ : increment the loop counter
slt $t0, $s0, $s1 #check i >= n
bne $t0, $0, for #if i >= n break, else loop again
#get average of inputted values
mtc1 $s1, $f3 #move s1 value to f3 : need to convert the amount of numbers entered to a float so can do proper division
cvt.s.w $f3, $f3 #convert value to float
div.s $f2, $f1, $f3 #f2 = f1/f3 : divide sum of numbers entered by amount of numbers entered
la $a0, average #print average string
li $v0, 4
syscall
la $v0, 2 #print average value
mov.s $f12, $f2
syscall
#exit gracefully
li $v0, 10
syscall
|
libsrc/_DEVELOPMENT/adt/wv_stack/c/sccz80/wv_stack_capacity.asm | jpoikela/z88dk | 640 | 168490 |
; size_t wv_stack_capacity(wv_stack_t *s)
SECTION code_clib
SECTION code_adt_wv_stack
PUBLIC wv_stack_capacity
EXTERN asm_wv_stack_capacity
defc wv_stack_capacity = asm_wv_stack_capacity
; SDCC bridge for Classic
IF __CLASSIC
PUBLIC _wv_stack_capacity
defc _wv_stack_capacity = wv_stack_capacity
ENDIF
|
src/x86_16/setjmp.asm | dargueta/metalc | 0 | 648 | bits 16
%include "metalc/setjmp.inc"
global mclib_setjmp
global mclib_longjmp
mclib_setjmp:
mov cx, bp
mov bp, sp
; Save return address in AX because we won't be able to access it after we
; make bp point at the jmp_buf struct.
mov ax, [bp]
mov bp, [bp + 2]
mov [bp + tJmpBuf.j_return], ax
mov [bp + tJmpBuf.j_bx], bx
mov [bp + tJmpBuf.j_sp], sp
mov [bp + tJmpBuf.j_si], si
mov [bp + tJmpBuf.j_di], di
mov [bp + tJmpBuf.j_bp], cx ; Remember, we saved BP into CX earlier
; Set BP back to its original value
mov bp, cx
; Always return 0. Assuming an integer is 32 bits we return it in DX:AX so
; we need to clear both.
xor ax, ax
xor dx, dx
ret 2
mclib_longjmp:
mov bp, sp
; Set the return value first before we overwrite BP. It's a 32-bit integer
; so we need to set DX:AX.
mov ax, [bp + 4]
mov dx, [bp + 6]
; Point bp to the jmp_buf struct
mov bp, [bp + 2]
; Overwrite the return address
mov cx, [bp + tJmpBuf.j_return]
mov si, sp
mov [si], cx
; Reset all the registers we saved
mov bx, [bp + tJmpBuf.j_bx]
mov sp, [bp + tJmpBuf.j_sp]
mov si, [bp + tJmpBuf.j_si]
mov di, [bp + tJmpBuf.j_di]
mov bp, [bp + tJmpBuf.j_bp]
ret 6
|
oeis/065/A065995.asm | neoneye/loda-programs | 11 | 90114 | <reponame>neoneye/loda-programs
; A065995: a(n) = prime(prime(n) + n).
; Submitted by <NAME>
; 5,11,19,31,53,67,89,103,131,167,181,227,251,269,293,347,383,401,443,467,491,547,577,617,673,709,733,761,787,823,929,967,1013,1031,1097,1117,1181,1229,1277,1303,1373,1409,1481,1489,1531,1553,1627,1741,1783,1801,1861,1901,1931,2011,2069,2113,2161,2207,2267,2293,2311,2389,2531,2557,2593,2647,2729,2789,2861,2897,2939,3001,3079,3163,3209,3253,3313,3371,3413,3499,3571,3593,3677,3701,3767,3803,3863,3929,3989,4007,4049,4153,4231,4261,4349,4397,4457,4567,4597,4759
mov $2,$0
seq $0,40 ; The prime numbers.
add $0,$2
seq $0,40 ; The prime numbers.
|
Default Firmware/Ocelot_Unmanaged-1.0.1_SourceCode/Ocelot_Unmanaged-1.0.1/src/switch/pidrv.a51 | botblox/GigaBlox-Rugged-FW | 1 | 11254 | <gh_stars>1-10
;*
;*
;* Copyright (c) 2017 Microsemi Corporation "Microsemi".
;*
;* 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.
;*
;*
;*
$NOMOD51
$INCLUDE (REG52.INC)
$INCLUDE (hwconf.inc)
NAME PIDRV
$IF (USE_PI = 1)
PUBLIC _pi_read, _pi_write
PROG SEGMENT CODE
RSEG PROG
;* ************************************************************************ */
;ulong pi_read (void *addr) small;
_pi_read:
;* ------------------------------------------------------------------------ --
;* Purpose : Read specified register.
;* Remarks : r2: block mask plus subblock
;* r1: register address within block
;* Restrictions: Not c-compatible. Must be called via h2io.a51
;* See also :
;* Example :
;* ************************************************************************ */
;*
;* Build 17-bit address:
;* A16-A14: block id
;* A13-A10: subblock
;* A9 - A2: register address
;* A1 - A0: zeros
;* Save A16 in carry and A15-A0 in dptr
;*
mov a, r1 ; Get reg. addr.
rlc a ; Shift one bit left, C gets MSB
mov r1, a ; Save 7 bits from reg. addr. temporarily
mov a, r2 ; Get block id mask (7:5) and subblock (3:0).
anl a, #0FH ; Isolate subblock
addc a, r2 ; Add subblock, ie. shift subblock 1 bit left,
; and with C to get MSB of reg. addr.
xch a, r1 ; Save temp. and get rem. bits of reg. addr.
rlc a ; Shift one bit more to the left, C gets MSB
anl a, #0FCH ; Reset A1 and A0
mov dpl, a ; Save A7-A0 in dpl
mov a, r1 ; Get A16-A9.
rlc a ; Shift one bit left to get A16 in C and
; to get yet another reg. addr. bit.
mov dph, a ; Save A15-A8 in dph
SELECT_SWITCH ; Select switch and set A16 according to C
; Determine whether it is a fast or slow register by checking block
; id (Carry holds most significant bit of block id, acc holds
; remaining 2 bits in bit 7 and 6.
jnc L2_1 ; Blocks 1-3 are all slow
anl a, #0C0H ; Isolate bit 7 and 6
jz L2_2 ; Block 4 is fast
cjne a, #0C0H, L2_1 ; Block 5 and 6 are slow
jmp L2_2 ; Block 7 is fast
L2_1: ; Slow register.
; Do a dummy read from right address, then read result from the
; SLOWDATA register
movx a, @dptr ; Dummy read
SET_SWITCH_ADDR_MSB ; Most significant bit of SLOWDATA register
mov dptr, #SLOWDATA_ADDR; Remaining address bits of SLOWDATA register
L2_2: ; Fast register
movx a, @dptr ; Read 1st byte
mov r4, a
inc dptr
movx a, @dptr ; Read 2nd byte
mov r5, a
inc dptr
movx a, @dptr ; Read 3rd byte
mov r6, a
inc dptr
movx a, @dptr ; Read 4th byte
mov r7, a
DESELECT_SWITCH
ret
;* ************************************************************************ */
; void pi_write (void *addr, ulong value) small;
_pi_write:
;* ------------------------------------------------------------------------ --
;* Purpose : Write a value to specified register
;* Remarks : r2: block mask plus subblock
;* r1: register address within block
;* r4-7: 32-bit value
;* Restrictions: Not C-compatible. Must be called via h2io.a51
;* See also :
;* Example :
; * ************************************************************************ */
;*
;* Build 17-bit address:
;* A16-A14: block id
;* A13-A10; subblock
;* A9 - A2: register address
;* A1 - A0: zeros
;* Save A16 in carry and A15-A0 in dptr
;*
mov a, r1 ; Get reg. addr.
rlc a ; Shift one bit left, C gets MSB
mov r1, a ; Save 7 bits from reg. addr. temporarily
mov a, r2 ; Get block id mask (7:5) and subblock (3:0).
anl a, #0FH ; Isolate subblock
addc a, r2 ; Add subblock, ie. shift subblock 1 bit left,
; and with C to get MSB of reg. addr.
xch a, r1 ; Save temp. and get rem. bits of reg. addr.
rlc a ; Shift one bit more to the left, C gets MSB
anl a, #0FCH ; Reset A1 and A0
mov dpl, a ; Save A7-A0 in dpl
mov a, r1 ; Get A16-A9.
rlc a ; Shift one bit left to get A16 in C and
; to get yet another reg. addr. bit.
mov dph, a ; Save A15-A8 in dph
SELECT_SWITCH ; Select switch and set A16 according to C
mov a, r4
movx @dptr, a ; Write 1st byte
inc dptr
mov a, r5
movx @dptr, a ; Write 2nd byte
inc dptr
mov a, r6
movx @dptr, a ; Write 3rd byte
inc dptr
mov a, r7
movx @dptr, a ; Write 4th byte
DESELECT_SWITCH
ret
$ENDIF
END
|
Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_1095.asm | ljhsiun2/medusa | 9 | 9823 | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %r15
push %rbp
push %rcx
push %rdx
lea addresses_D_ht+0xc561, %r12
clflush (%r12)
xor $14721, %r14
mov (%r12), %r15d
nop
nop
nop
cmp %rbp, %rbp
lea addresses_normal_ht+0xa9b1, %rcx
xor %r11, %r11
mov $0x6162636465666768, %rdx
movq %rdx, %xmm0
vmovups %ymm0, (%rcx)
sub %rbp, %rbp
lea addresses_UC_ht+0x59a1, %rdx
nop
nop
nop
nop
nop
inc %r11
movb $0x61, (%rdx)
nop
nop
cmp $9813, %rdx
pop %rdx
pop %rcx
pop %rbp
pop %r15
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r8
push %rax
push %rbx
push %rdx
// Load
lea addresses_A+0xd5a1, %r10
nop
nop
add $26397, %r12
mov (%r10), %r11d
nop
nop
and %r11, %r11
// Store
lea addresses_A+0x1fe79, %rdx
nop
nop
xor %rax, %rax
movl $0x51525354, (%rdx)
// Exception!!!
nop
nop
nop
mov (0), %r12
nop
nop
nop
nop
sub $39125, %r12
// Faulty Load
lea addresses_PSE+0xc1a1, %rdx
nop
nop
nop
nop
cmp $11192, %r8
movb (%rdx), %r11b
lea oracles, %rax
and $0xff, %r11
shlq $12, %r11
mov (%rax,%r11,1), %r11
pop %rdx
pop %rbx
pop %rax
pop %r8
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 0, 'same': False, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 6, 'same': False, 'type': 'addresses_A'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3, 'same': False, 'type': 'addresses_A'}, 'OP': 'STOR'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 6, 'same': True, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 2, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 11, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'STOR'}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
|
src/nes/input.asm | apvilkko/jane8-musicdisk | 0 | 246058 | <filename>src/nes/input.asm<gh_stars>0
ReadJoy:
lda #$01
sta JOY1
sta buttons
lsr a
sta JOY1
joyloop:
lda JOY1
lsr a
rol buttons
bcc joyloop
rts
|
notes/fixed-points/LFPs/N.agda | asr/fotc | 11 | 15382 | <reponame>asr/fotc<gh_stars>10-100
------------------------------------------------------------------------------
-- Equivalence: N as the least fixed-point and N using Agda's data constructor
------------------------------------------------------------------------------
{-# OPTIONS --exact-split #-}
{-# OPTIONS --no-sized-types #-}
{-# OPTIONS --no-universe-polymorphism #-}
{-# OPTIONS --without-K #-}
module LFPs.N where
open import FOTC.Base
open import FOTC.Base.PropertiesI
------------------------------------------------------------------------------
-- Auxiliary definitions and properties
flip : {A B C : Set} → (A → B → C) → B → A → C
flip f b a = f a b
cong : (f : D → D) → ∀ {x y} → x ≡ y → f x ≡ f y
cong f refl = refl
------------------------------------------------------------------------------
module LFP where
infixl 9 _+_
-- N is a least fixed-point of a functor
-- The functor.
NatF : (D → Set) → D → Set
NatF A n = n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n')
-- The natural numbers are the least fixed-point of NatF.
postulate
N : D → Set
-- N is a pre-fixed point of NatF, i.e.
--
-- NatF N ≤ N.
--
-- Peter: It corresponds to the introduction rules.
N-in : ∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ N n') → N n
-- The higher-order version.
N-in-ho : ∀ {n} → NatF N n → N n
-- N is the least pre-fixed point of NatF, i.e.
--
-- ∀ A. NatF A ≤ A ⇒ N ≤ A.
--
-- Peter: It corresponds to the elimination rule of an inductively
-- defined predicate.
N-ind :
(A : D → Set) →
(∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n') → A n) →
∀ {n} → N n → A n
-- Higher-order version.
N-ind-ho :
(A : D → Set) → (∀ {n} → NatF A n → A n) → ∀ {n} → N n → A n
----------------------------------------------------------------------------
-- N-in and N-in-ho are equivalents
N-in₁ : ∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ N n') → N n
N-in₁ = N-in-ho
N-in-ho₁ : ∀ {n} → NatF N n → N n
N-in-ho₁ = N-in₁
----------------------------------------------------------------------------
-- N-ind and N-ind-ho are equivalents
N-ind-fo :
(A : D → Set) →
(∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n') → A n) →
∀ {n} → N n → A n
N-ind-fo = N-ind-ho
N-ind-ho' :
(A : D → Set) → (∀ {n} → NatF A n → A n) → ∀ {n} → N n → A n
N-ind-ho' = N-ind
----------------------------------------------------------------------------
-- The data constructors of N.
nzero : N zero
nzero = N-in (inj₁ refl)
nsucc : ∀ {n} → N n → N (succ₁ n)
nsucc Nn = N-in (inj₂ (_ , refl , Nn))
----------------------------------------------------------------------------
-- Because N is the least pre-fixed point of NatF (i.e. N-in and
-- N-ind), we can proof that N is also a post-fixed point of NatF.
-- N is a post-fixed point of NatF.
N-out : ∀ {n} → N n → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ N n')
N-out = N-ind A h
where
A : D → Set
A m = m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ N m')
h : ∀ {m} → m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ A m') → A m
h (inj₁ m≡0) = inj₁ m≡0
h (inj₂ (m' , prf , Am')) = inj₂ (m' , prf , helper Am')
where
helper : A m' → N m'
helper (inj₁ prf') = subst N (sym prf') nzero
helper (inj₂ (m'' , prf' , Am'')) = subst N (sym prf') (nsucc Am'')
-- The higher-order version.
N-out-ho : ∀ {n} → N n → NatF N n
N-out-ho = N-out
----------------------------------------------------------------------------
-- The induction principle for N *with* the hypothesis N n in the
-- induction step using N-ind.
N-ind₁ : (A : D → Set) →
A zero →
(∀ {n} → N n → A n → A (succ₁ n)) →
∀ {n} → N n → A n
N-ind₁ A A0 h Nn = ∧-proj₂ (N-ind B h' Nn)
where
B : D → Set
B n = N n ∧ A n
h' : ∀ {m} → m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ B m') → B m
h' (inj₁ m≡0) = subst B (sym m≡0) (nzero , A0)
h' (inj₂ (m' , prf , Nm' , Am')) =
(subst N (sym prf) (nsucc Nm')) , subst A (sym prf) (h Nm' Am')
----------------------------------------------------------------------------
-- The induction principle for N *without* the hypothesis N n in the
-- induction step using N-ind
N-ind₂ : (A : D → Set) →
A zero →
(∀ {n} → A n → A (succ₁ n)) →
∀ {n} → N n → A n
N-ind₂ A A0 h = N-ind A h'
where
h' : ∀ {m} → m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ A m') → A m
h' (inj₁ m≡0) = subst A (sym m≡0) A0
h' (inj₂ (m' , prf , Am')) = subst A (sym prf) (h Am')
----------------------------------------------------------------------------
-- Example: We will use N-ind as the induction principle on N.
postulate
_+_ : D → D → D
+-0x : ∀ d → zero + d ≡ d
+-Sx : ∀ d e → (succ₁ d) + e ≡ succ₁ (d + e)
+-leftIdentity : ∀ n → zero + n ≡ n
+-leftIdentity n = +-0x n
+-N : ∀ {m n} → N m → N n → N (m + n)
+-N {n = n} Nm Nn = N-ind A h Nm
where
A : D → Set
A i = N (i + n)
h : ∀ {m} → m ≡ zero ∨ (∃[ m' ] m ≡ succ₁ m' ∧ A m') → A m
h (inj₁ m≡0) = subst N (cong (flip _+_ n) (sym m≡0)) A0
where
A0 : A zero
A0 = subst N (sym (+-leftIdentity n)) Nn
h (inj₂ (m' , prf , Am')) =
subst N (cong (flip _+_ n) (sym prf)) (is Am')
where
is : ∀ {i} → A i → A (succ₁ i)
is {i} Ai = subst N (sym (+-Sx i n)) (nsucc Ai)
----------------------------------------------------------------------------
-- Example: A proof using N-out.
pred-N : ∀ {n} → N n → N (pred₁ n)
pred-N {n} Nn = case h₁ h₂ (N-out Nn)
where
h₁ : n ≡ zero → N (pred₁ n)
h₁ n≡0 = subst N (sym (trans (predCong n≡0) pred-0)) nzero
h₂ : ∃[ n' ] n ≡ succ₁ n' ∧ N n' → N (pred₁ n)
h₂ (n' , prf , Nn') = subst N (sym (trans (predCong prf) (pred-S n'))) Nn'
----------------------------------------------------------------------------
-- From/to N as a least fixed-point to/from N as data type.
data N' : D → Set where
nzero' : N' zero
nsucc' : ∀ {n} → N' n → N' (succ₁ n)
N'→N : ∀ {n} → N' n → N n
N'→N nzero' = nzero
N'→N (nsucc' Nn) = nsucc (N'→N Nn)
-- Using N-ind₁.
N→N' : ∀ {n} → N n → N' n
N→N' = N-ind₁ N' nzero' (λ _ → nsucc')
-- Using N-ind₂.
N→N'₁ : ∀ {n} → N n → N' n
N→N'₁ = N-ind₂ N' nzero' nsucc'
------------------------------------------------------------------------------
module Data where
data N : D → Set where
nzero : N zero
nsucc : ∀ {n} → N n → N (succ₁ n)
-- The induction principle for N *with* the hypothesis N n in the
-- induction step.
N-ind₁ : (A : D → Set) →
A zero →
(∀ {n} → N n → A n → A (succ₁ n)) →
∀ {n} → N n → A n
N-ind₁ A A0 h nzero = A0
N-ind₁ A A0 h (nsucc Nn) = h Nn (N-ind₁ A A0 h Nn)
-- The induction principle for N *without* the hypothesis N n in the
-- induction step.
N-ind₂ : (A : D → Set) →
A zero →
(∀ {n} → A n → A (succ₁ n)) →
∀ {n} → N n → A n
N-ind₂ A A0 h nzero = A0
N-ind₂ A A0 h (nsucc Nn) = h (N-ind₂ A A0 h Nn)
----------------------------------------------------------------------------
-- N-in.
N-in : ∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ N n') → N n
N-in {n} h = case prf₁ prf₂ h
where
prf₁ : n ≡ zero → N n
prf₁ n≡0 = subst N (sym n≡0) nzero
prf₂ : ∃[ n' ] n ≡ succ₁ n' ∧ N n' → N n
prf₂ (n' , prf , Nn') = subst N (sym prf) (nsucc Nn')
----------------------------------------------------------------------------
-- From N-ind₂ to N-ind.
N-ind' :
(A : D → Set) →
(∀ {n} → n ≡ zero ∨ (∃[ n' ] n ≡ succ₁ n' ∧ A n') → A n) →
∀ {n} → N n → A n
N-ind' A h = N-ind₂ A h₁ h₂
where
h₁ : A zero
h₁ = h (inj₁ refl)
h₂ : ∀ {m} → A m → A (succ₁ m)
h₂ {m} Am = h (inj₂ (m , refl , Am))
|
songdata.asm | enthusi/VBeat | 6 | 102654 | <filename>songdata.asm
;all sources Licensed under the 3-Clause BSD License
;Copyright 2021, Martin 'enthusi' Wendt / PriorArt
;-----------------------------------------------------------
;Demo tune VBDemo01.s3m is Licensed under the 3-Clause BSD License
;Copyright 2021, Kamil 'jammer' Wolnikowski
begin_instruments
EVEN 4
INSTRUMENT_TABLE
dw 0;dummy script_instrument0 ;0
dw instrument_kick1 ;1
dw instrument_bass1; 2
dw instrument_hihatbass1; 3
dw instrument_stickbass1 ;4
dw instrument_rhodes1 ;5
dw instrument_rhodes1delay ;6
dw instrument_rhodes2 ;7
dw instrument_rhodes3 ;8
dw instrument_noisesnare1 ;9
dw instrument_snare1 ;10
dw instrument_brass1; 11
dw instrument_brass1legato; 12
dw instrument_brass1echo; 13
dw instrument_brass2; 14
dw instrument_funkyguitar1; 15
dw instrument_shortfunkyguitar1; 16
dw instrument_shortfunkyguitar2; 17
dw instrument_shortfunkyguitar3; 18
dw instrument_funkyguitardirt1; 19
dw instrument_funkyguitardirt2; 20
dw instrument_funkyguitardirt3; 21
dw instrument_piano1; 22
;techdemo instruments
dw example_plain ;23/9
dw example_vibrato ;24/;10
dw example_instrument ;25/11
dw example_instrument_2 ;26/12
dw example_instrument_3 ;27/13
dw example_simplewave; 28/14
;-----------------------------------------------------------
;in this order:
HARDNOTE equ 64 ;8 affects BASENOTE
VOL equ 8 ;8 (4)
WAVE equ 4 ;8 (3)
NOTE_OFF equ 16 ;8 based on BASENOTE (not touching BASENOTE!)
FREQ_OFF equ 32 ;8 based on BASENOTE (not in combo with NOTE_OFF!)
LOOPER equ 128 ;8
;-----------------------------------------------------------
EVEN 4
script_instrument0
db 1, VOL, 0
db 0
instrument_kick1
db 1, HARDNOTE | VOL | WAVE, 20, 1, 63, 0
db 1, HARDNOTE | VOL | WAVE, 14, 0, 63, 0
db 1, HARDNOTE | VOL | WAVE, 10, 1, 63, 0
db 1, HARDNOTE | VOL | WAVE, 5, 0, 48, 0
db 1, HARDNOTE | VOL | WAVE, 0, 1, 32, 0
db 1, VOL, 0
db 0
instrument_snare1
db 1, HARDNOTE | VOL | WAVE, 24, 2, 63, 0
db 1, HARDNOTE | VOL | WAVE, 20, 2, 63, 0
db 1, HARDNOTE | VOL | WAVE, 18, 2, 63, 0
db 1, HARDNOTE | VOL | WAVE, 16, 2, 63, 0
db 1, HARDNOTE | VOL | WAVE, 12, 2, 63, 0
db 1, VOL, 0
db 0
instrument_bass1
db 1, VOL | WAVE | NOTE_OFF, 63, $87, 26
db 1, VOL, 32
db 1, VOL, 16
db 8, VOL, 12
db 1, VOL, 0
db 0
instrument_hihatbass1
db 1, HARDNOTE | VOL | WAVE, 95, 0, 16, $81
db 1, VOL | WAVE | NOTE_OFF, 63, $87, 26
db 1, VOL, 32
db 1, VOL, 16
db 8, VOL, 12
db 1, VOL, 0
db 0
instrument_stickbass1
db 1, HARDNOTE | VOL | WAVE, 60, 0, 63, $84
db 1, HARDNOTE | VOL | WAVE, 60, 0, 63, $81
db 1, VOL | WAVE | NOTE_OFF, 63, $87, 26
db 1, VOL, 32
db 1, VOL, 16
db 8, VOL, 12
db 1, VOL, 0
db 0
instrument_noisesnare1
db 1, HARDNOTE | VOL | WAVE, 90, 0, 63, $80
db 1, HARDNOTE | VOL | WAVE, 60, 0, 63, $80
db 1, VOL, 32
db 1, VOL, 16
db 3, VOL, 8
db 1, VOL, 0
db 0
instrument_rhodes1
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (0 & 255)
db 1, VOL, 40
db 1, VOL, 38
db 1, VOL, 36
db 1, VOL, 34
db 1, VOL, 32
db 1, VOL, 30
db 1, VOL, 28
db 1, VOL, 26
db 1, VOL, 24
db 1, VOL, 20
db 1, VOL, 18
db 1, VOL, 14
db 1, VOL, 12
instrument_rhodes1_loopstart
db 1, FREQ_OFF, (2 & $ff)
db 1, FREQ_OFF, (4 & $ff)
db 1, FREQ_OFF, (6 & $ff)
db 1, FREQ_OFF, (4 & $ff)
db 1, FREQ_OFF, (2 & $ff)
db 1, FREQ_OFF, (0 & $ff)
db 1, FREQ_OFF, (-2 & $ff)
db 1, FREQ_OFF, (-4 & $ff)
db 1, FREQ_OFF, (-6 & $ff)
db 1, FREQ_OFF, (-4 & $ff)
db 1, FREQ_OFF, (-2 & $ff)
db 1, FREQ_OFF, (0 & $ff)
instrument_rhodes1_loopend
db 1, LOOPER, (instrument_rhodes1_loopend - instrument_rhodes1_loopstart)
instrument_rhodes1delay
db 4, VOL, 63
instrument_rhodes1delay_loopend
db 1, LOOPER, (instrument_rhodes1delay_loopend - instrument_rhodes1)
instrument_rhodes2
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (-12 & 255)
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (24 & 255)
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (-12 & 255)
db 1, VOL, 40
db 1, VOL, 38
db 1, VOL, 36
db 1, VOL, 34
db 1, VOL, 32
db 1, VOL, 28
db 1, VOL, 24
db 1, VOL, 20
db 1, VOL, 16
db 1, VOL, 12
instrument_rhodes2_loopend
db 1, LOOPER, (instrument_rhodes2_loopend - instrument_rhodes1_loopstart)
instrument_rhodes3
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (12 & 255)
db 1, VOL | WAVE | NOTE_OFF, 63, 2, (-12 & 255)
instrument_rhodes3_loopend
db 1, LOOPER, (instrument_rhodes3_loopend - instrument_rhodes1_loopstart)
instrument_piano1
db 1, VOL | WAVE | NOTE_OFF, 48, 1, (0 & 255)
db 1, VOL, 63
db 1, VOL, 48
db 1, VOL, 34
db 1, VOL, 32
db 1, VOL, 30
db 1, VOL, 28
db 1, VOL, 26
db 1, VOL, 24
db 1, VOL, 20
db 1, VOL, 18
db 1, VOL, 14
db 1, VOL, 12
db 1, VOL, 10
db 1, VOL, 08
instrument_piano1_loopend
db 1, LOOPER, (instrument_piano1_loopend - instrument_rhodes1_loopstart)
instrument_brass1
db 1, VOL | WAVE | NOTE_OFF, 60, 4, 0
db 1, VOL, 63
db 1, VOL, 62
db 6, VOL, 60
instrument_brass1_loopstart
db 1, FREQ_OFF, (8 & $ff)
db 1, FREQ_OFF, (16 & $ff)
db 1, FREQ_OFF, (8 & $ff)
db 1, FREQ_OFF, (0 & $ff)
db 1, FREQ_OFF, (-8 & $ff)
db 1, FREQ_OFF, (-16 & $ff)
db 1, FREQ_OFF, (-8 & $ff)
db 1, FREQ_OFF, (0 & $ff)
instrument_brass1_loopend
db 1, LOOPER, (instrument_brass1_loopend - instrument_brass1_loopstart)
instrument_brass1legato
db 1, VOL | WAVE | NOTE_OFF, 56, 4, 0
db 0
instrument_brass1echo
db 1, WAVE | NOTE_OFF, 4, 0
db 0
instrument_brass2
db 3, VOL | WAVE | NOTE_OFF, 63, 3, (-2 & 255)
db 3, VOL | WAVE | NOTE_OFF, 63, 3, (1 & 255)
db 1, VOL | WAVE | NOTE_OFF, 63, 3, (1 & 255)
instrument_brass2_loopstart
db 1, VOL, 32
db 1, VOL, 63
instrument_brass2_loopend
db 1, LOOPER, (instrument_brass2_loopend - instrument_brass2_loopstart)
instrument_funkyguitar1
db 1, VOL | WAVE | NOTE_OFF, 63, 3, (0 & 255)
db 1, VOL | WAVE, 63, 2
db 1, VOL | WAVE, 56, 1
db 1, VOL | WAVE, 48, 2
db 1, VOL | WAVE, 32, 3
db 0
instrument_shortfunkyguitar1
db 1, VOL | WAVE | NOTE_OFF, 63, 3, (0 & 255)
db 1, VOL | WAVE, 48, 2
db 3, VOL | WAVE, 32, 1
db 1, VOL, 0
db 0
instrument_shortfunkyguitar2
db 1, VOL | WAVE | NOTE_OFF, 63, 1, (0 & 255)
db 1, VOL | WAVE, 48, 2
db 3, VOL | WAVE, 32, 3
db 1, VOL, 0
db 0
instrument_shortfunkyguitar3
db 1, VOL | WAVE | NOTE_OFF, 63, 2, (0 & 255)
db 1, VOL | WAVE, 48, 1
db 3, VOL | WAVE, 32, 3
db 1, VOL, 0
db 0
instrument_funkyguitardirt1
db 1, VOL | WAVE | NOTE_OFF, 64, 2, (0 & 255)
db 1, VOL | WAVE, 32, 3
db 1, VOL, 0
db 0
instrument_funkyguitardirt2
db 1, VOL | WAVE | NOTE_OFF, 32, 2, (0 & 255)
db 1, VOL, 0
db 0
instrument_funkyguitardirt3
db 1, VOL | WAVE | NOTE_OFF, 32, 3, (0 & 255)
db 1, VOL, 0
db 0
;examples
example_plain
db 35, WAVE, 0
db 1, VOL, 0
db 0
example_vibrato
db 2, WAVE | NOTE_OFF, 1, 1
_loopstart1
db 1, FREQ_OFF, (-5 & $ff)
db 1, FREQ_OFF, (-7 & $ff)
db 1, FREQ_OFF, (-9 & $ff)
db 1, FREQ_OFF, (-7 & $ff)
db 1, FREQ_OFF, (-5 & $ff)
db 1, FREQ_OFF, (-3 & $ff)
db 1, FREQ_OFF, (-1 & $ff)
db 1, FREQ_OFF, ( 1 & $ff)
db 1, FREQ_OFF, (-1 & $ff)
_loopend1
db 1, LOOPER, (_loopend1 - _loopstart1 )
db 0
example_instrument
db 3, WAVE, 0
db 3, WAVE, 1
db 3, WAVE, 2
db 3, WAVE, 3
db 3, WAVE, 4
db 3, WAVE, 5
db 0
example_instrument_2
db 1, WAVE, 1
db 0
example_instrument_3
db 1, WAVE, 1
_loopstart3
db 1, FREQ_OFF, 0
db 1, FREQ_OFF, 2
db 1, FREQ_OFF, 4
db 1, FREQ_OFF, 6
db 1, FREQ_OFF, 8
db 1, FREQ_OFF, 10
db 1, FREQ_OFF, 12
db 1, FREQ_OFF, 14
db 1, FREQ_OFF, 12
db 1, FREQ_OFF, 10
db 1, FREQ_OFF, 8
db 1, FREQ_OFF, 6
db 1, FREQ_OFF, 4
db 1, FREQ_OFF, 2
_loopend3
db 1, LOOPER, (_loopend3 - _loopstart3 )
db 0
example_simplewave
db 1, WAVE, 0
db 0
end_instruments
;-----------------------------------------------------------
EVEN 4
WAVESET_TABLE
db 0, 1, 2, 3, 4, 0, 0, 0; d#2 ;used by song
db -1, 5, 6,-1,-1, 0, 0, 0; e-2 ;used by song
db 10,-1,-1,-1,-1, 0, 0, 0 ;f-2
db 9,-1,-1,-1,-1, 0, 0, 0 ;f#2 set all waves to default
db 8,-1,-1,-1,-1, 0, 0, 0 ;g-2
db 7,-1,-1,-1,-1, 0, 0, 0 ;g#2
db 1,-1,-1,-1,-1, 0, 0, 0 ;a-2
db 3,-1,-1,-1,-1, 0, 0, 0 ;a#2
db 11,-1,-1,-1,-1, 0, 0, 0 ;b-2
db -1,-1,-1,-1,-1, 0, 0, 0 ; example change NOTHING -1 = skip
EVEN 4
MY_WAVE_0
LIBBIN Waveforms/sine.dat ;d#2 ; 0
LIBBIN Waveforms/WaveRhodes01.dat ;e-2 ; 1
LIBBIN Waveforms/WaveRhodes02.dat ;f-2 ; 2
LIBBIN Waveforms/WaveFunkyGuitar04.dat ;f#2 ; 3
LIBBIN Waveforms/WaveBrass02.dat ;g-2 ; 4
LIBBIN Waveforms/WaveFunkyGuitar06.dat ;g#2 ; 5
LIBBIN Waveforms/WaveFunkyGuitar05.dat ;a-2 ; 6
LIBBIN Waveforms/saw.dat ;a#2 ; 7
LIBBIN Waveforms/square.dat ;b-2 ; 8
LIBBIN Waveforms/deltapeak.dat ;c-3 ; 9
LIBBIN Waveforms/wario.dat ;c#3 ;10
LIBBIN Waveforms/flute.dat ;d-3 ;11
beginaudiodata
NOTES_LO
LIBBIN note_timelo_0.bin
NOTES_HI
LIBBIN note_timehi_0.bin
;------------------------------------------------
audio_data
EVEN 4
COL_TABLE dw COL_PTR0, COL_PTR1, COL_PTR2
dw COL_PTR3, COL_PTR4, COL_PTR5
COL_OFF_TABLE dw COL_OFFSETS0, COL_OFFSETS1, COL_OFFSETS2
dw COL_OFFSETS3, COL_OFFSETS4, COL_OFFSETS5
EVEN 4
PLAYLIST
LIBBIN VBDemo01_playlist.bin
db $ff ;end marker
;----------------------------------------------------
EVEN 4
COL_PTR0
LIBBIN col_ptr0.dat
EVEN 4
COL_PTR1
LIBBIN col_ptr1.dat
EVEN 4
COL_PTR2
LIBBIN col_ptr2.dat
EVEN 4
COL_PTR3
LIBBIN col_ptr3.dat
EVEN 4
COL_PTR4
LIBBIN col_ptr4.dat
EVEN 4
COL_PTR5
LIBBIN col_ptr5.dat
;----------------------------------------------------
EVEN 4
COL_OFFSETS0
LIBBIN col_offsets0.dat
EVEN 4
COL_OFFSETS1
LIBBIN col_offsets1.dat
EVEN 4
COL_OFFSETS2
LIBBIN col_offsets2.dat
EVEN 4
COL_OFFSETS3
LIBBIN col_offsets3.dat
EVEN 4
COL_OFFSETS4
LIBBIN col_offsets4.dat
EVEN 4
COL_OFFSETS5
LIBBIN col_offsets5.dat
;----------------------------------------------------
EVEN 4
CHANNEL0
LIBBIN channel0_stream4.dat
; EVEN 4
CHANNEL1
LIBBIN channel1_stream4.dat
; EVEN 4
CHANNEL2
LIBBIN channel2_stream4.dat
;EVEN 4
CHANNEL3
LIBBIN channel3_stream4.dat
;EVEN 4
CHANNEL4
LIBBIN channel4_stream4.dat
;EVEN 4
CHANNEL5
LIBBIN channel5_stream4.dat
EVEN 4
CHANNEL_START equ CHANNEL0
CHANNEL_TABLE dw CHANNEL0-CHANNEL0+CHANNEL_START, CHANNEL1-CHANNEL0+CHANNEL_START, CHANNEL2-CHANNEL0+CHANNEL_START
dw CHANNEL3-CHANNEL0+CHANNEL_START, CHANNEL4-CHANNEL0+CHANNEL_START, CHANNEL5-CHANNEL0+CHANNEL_START
endaudiodata
|
Chrome2safari.applescript | vacnex/ChromePassword2Safari | 0 | 3686 | <gh_stars>0
set theFile to (choose file with prompt "Select the CSV file")
set f to read theFile
set recs to paragraphs of f
tell application "System Events"
tell application process "Safari"
set frontmost to true
keystroke "," using command down
tell window 1
click button "Passwords" of toolbar 1 of it
repeat until (exists button "Add" of group 1 of group 1 of it)
if not (exists button "Add" of group 1 of group 1 of it) then
display dialog "To begin importing, unlock Safari passwords then click OK. Please do not use your computer until the process has completed." with title "CSV to iCloud Keychain"
end if
end repeat
end tell
end tell
end tell
set vals to {}
set AppleScript's text item delimiters to ","
repeat with i from 1 to length of recs
set end of vals to text items of (item i of recs)
set kcURL to text item 1 of (item i of recs)
set kcUsername to text item 2 of (item i of recs)
set kcPassword to text item 3 of (item i of recs)
tell application "System Events"
tell application process "Safari"
set frontmost to true
tell window 1
click button "Add" of group 1 of group 1 of it
tell application "System Events" to keystroke kcURL
keystroke tab
tell application "System Events" to keystroke kcUsername
keystroke tab
tell application "System Events" to keystroke kcPassword
keystroke tab
click button "Add Password" of sheet of it
end tell
end tell
end tell
end repeat
|
src/gfx/InitStdPalette.asm | beckadamtheinventor/BOSos | 1 | 94142 |
;@DOES Initialise the standard (8bpp) XLibC palette
;@DESTROYS DE,BC,AF
gfx_InitStdPalette:
; setup common items
ld a,$27
ld (LCD_CTRL),a
ld de,LCD_PAL ; address of mmio palette
ld b,e ; b = 0
.loop:
ld a,b
rrca
xor a,b
and a,224
xor a,b
ld (de),a
inc de
ld a,b
rla
rla
rla
ld a,b
rra
ld (de),a
inc de
inc b
jr nz,.loop ; loop for 256 times to fill palette
ret
|
oeis/219/A219259.asm | neoneye/loda-programs | 11 | 7245 | <gh_stars>10-100
; A219259: Numbers k such that 25*k+1 is a square.
; 0,23,27,96,104,219,231,392,408,615,635,888,912,1211,1239,1584,1616,2007,2043,2480,2520,3003,3047,3576,3624,4199,4251,4872,4928,5595,5655,6368,6432,7191,7259,8064,8136,8987,9063,9960,10040,10983,11067,12056,12144,13179,13271,14352,14448,15575,15675,16848,16952,18171,18279,19544,19656,20967,21083,22440,22560,23963,24087,25536,25664,27159,27291,28832,28968,30555,30695,32328,32472,34151,34299,36024,36176,37947,38103,39920,40080,41943,42107,44016,44184,46139,46311,48312,48488,50535,50715,52808,52992
mov $2,3
mov $3,2
mov $4,$0
mov $5,$0
lpb $3
lpb $5
add $1,1
trn $5,$3
lpe
pow $1,2
mov $3,$2
mul $3,7
mul $1,$3
mov $3,$5
lpe
add $1,$4
mov $6,$4
mul $6,$4
add $1,$6
mov $0,$1
|
Lambda.agda | bens/hwlc | 0 | 11657 | module Lambda where
open import Data.Bool using (true; false)
open import Data.Nat renaming (_≟_ to _≟N_)
import Data.Stream as S
open import Data.Vec using ([]; _∷_)
open import Relation.Binary.PropositionalEquality
open import Check
open import Eval
open import Operations.Combinatorial
open import Operations.Stateful
open import Types
open import Utils
ex₀ : S.take 5 ([] ⟦ alternator bitO ⟧) ≡ false ∷ true ∷ false ∷ true ∷ false ∷ []
ex₀ = refl
ex₁ : S.take 5 ([] ⟦ constant bitI ⟧) ≡ true ∷ true ∷ true ∷ true ∷ true ∷ []
ex₁ = refl
|
test/Fail/LostTypeError.agda | shlevy/agda | 1,989 | 1318 | <gh_stars>1000+
-- There was a bug with the new constraint machinery
-- where a type error could be ignored and checking
-- continued.
module LostTypeError where
postulate
Wrap : (A : Set) (P : A → Set) → A → Set
wrap : ∀ A (P : A → Set) (x : A) → P x → Wrap A P x
A : Set
data Box : Set where
box : A → Box
data Dummy : Set where
box : Dummy
postulate
x y : A
P : Box → Set
px : P (box x)
bad : Wrap Box P (box y)
bad = wrap _ (λ a → P _) (box x) px
|
src/firmware-tests/Platform/PowerManagement/ClockSwitching/ClockSwitchingTest.asm | pete-restall/Cluck2Sesame-Prototype | 1 | 98710 | #include "Platform.inc"
#include "FarCalls.inc"
#include "PowerManagement.inc"
#include "TestFixture.inc"
radix decimal
udata
global numberOfEnsureFastClockCalls
global numberOfAllowSlowClockCalls
global expectedOsccon
numberOfEnsureFastClockCalls res 1
numberOfAllowSlowClockCalls res 1
expectedOsccon res 1
ClockSwitchingTest code
global testArrange
testArrange:
fcall initialisePowerManagement
testAct:
banksel numberOfEnsureFastClockCalls
movf numberOfEnsureFastClockCalls
btfsc STATUS, Z
goto callAllowSlowClock
callEnsureFastClock:
fcall ensureFastClock
banksel numberOfEnsureFastClockCalls
decfsz numberOfEnsureFastClockCalls
goto callEnsureFastClock
callAllowSlowClock:
banksel numberOfAllowSlowClockCalls
movf numberOfAllowSlowClockCalls
btfsc STATUS, Z
goto testAssert
callAllowSlowClockInLoop:
fcall allowSlowClock
banksel numberOfAllowSlowClockCalls
decfsz numberOfAllowSlowClockCalls
goto callAllowSlowClockInLoop
testAssert:
.aliasForAssert OSCCON, _a
.aliasForAssert expectedOsccon, _b
.assert "_a == _b, 'OSCCON expectation failure.'"
return
end
|
programs/oeis/135/A135416.asm | jmorken/loda | 1 | 244620 | <reponame>jmorken/loda<filename>programs/oeis/135/A135416.asm<gh_stars>1-10
; A135416: a(n) = A036987(n)*(n+1)/2.
; 1,0,2,0,0,0,4,0,0,0,0,0,0,0,8,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,32,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,64,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
add $0,1
mov $2,$0
mov $3,1
lpb $2
lpb $0
trn $0,$3
mov $1,$3
mul $3,2
lpe
sub $3,2
mov $2,$3
lpe
|
S-F200VX_20180920_WithFactory/WIFI_SmartCfg.asm | xcwk/8-Pads-WiFi-Fat-Scale | 1 | 83899 | ;========================================================================
;======= WIFI_SmartCfg.ASM
;========================================================================
F_WIFI_SmartCfg:
BTFSS Wifi_SmartCfg,B_Wifi_SmartCfg_EN
GOTO F_WIFI_SmartCfg_END
F_WIFI_SmartCfg_ChkAck:
BTFSS SysFlag1,B_SysFlag1_DataOk
GOTO F_WIFI_SmartCfg_ChkAck_END
BSF UART_TX_EVENT,B_UART_TX_EVENT_unlock
BCF UART_TX_EVENT,B_UART_TX_EVENT_CFG
BTFSC Wifi_SmartCfg,B_Wifi_SmartCfg_Ack
GOTO F_WIFI_SmartCfg_ChkAck_END
BSF UART_TX_EVENT,B_UART_TX_EVENT_CFG
BCF UART_TX_EVENT,B_UART_TX_EVENT_unlock
F_WIFI_SmartCfg_ChkAck_END:
F_WIFI_SmartCfg_FLASH:
BTFSS Wifi_SmartCfg,B_Wifi_SmartCfg_T
GOTO F_WIFI_SmartCfg_FLASH_END
BCF Wifi_SmartCfg,B_Wifi_SmartCfg_T
INCF Wifi_SmartCfgTimer,F
MOVLW 10
SUBWF Wifi_SmartCfgTimer,W
BTFSS STATUS,C
GOTO F_WIFI_SmartCfg_FLASH_END
CLRF Wifi_SmartCfgTimer
;---
MOVLW 04H
XORWF Wifi_SmartCfg,F
F_WIFI_SmartCfg_FLASH_END:
F_WIFI_SmartCfg_END:
RETURN
F_WIFI_SmartCfg_TRG:
CLRF Wifi_SmartCfg
BSF Wifi_SmartCfg,B_Wifi_SmartCfg_EN
CLRF Wifi_SmartCfgTimer
BSF UART_TX_EVENT,B_UART_TX_EVENT_CFG
BSF FlyLink_Flag,B_FlyLink_Flag_En
RETURN
F_WIFI_SmartCfg_Disable:
;BTFSC Wifi_SmartCfg,B_Wifi_SmartCfg_EN
CLRF Wifi_SmartCfg
BCF FlyLink_Flag,B_FlyLink_Flag_En
RETURN
|
projects/batfish/src/main/antlr4/org/batfish/grammar/palo_alto/PaloAlto_tag.g4 | zabrewer/batfish | 763 | 6732 | parser grammar PaloAlto_tag;
import PaloAlto_common;
options {
tokenVocab = PaloAltoLexer;
}
s_tag
:
TAG name = variable
(
st_color
| st_comments
)?
;
st_comments
:
COMMENTS comments = variable
;
st_color
:
COLOR null_rest_of_line
;
|
models/hol/sygus/hackers_del/hd_09.als | johnwickerson/alloystar | 2 | 2337 | <filename>models/hol/sygus/hackers_del/hd_09.als
/**
* NOTE: make sure to set "Options -> Prevent overflows" to "No"
*
* Absolute value function
*/
module hd_09
open ../synth2[spec]
--------------------------------------------------------------------------------
-- Variables
--------------------------------------------------------------------------------
one sig X extends IntVar {}
one sig Lit0, Lit1, /*LitFFFFFFFF, */Lit0000001F extends IntLit {}
fact {
IntLit<:val = Lit0->0 + Lit1->1 + Lit0000001F->0x0000001F
}
--------------------------------------------------------------------------------
-- Specification
--------------------------------------------------------------------------------
pred spec[root: Node, eval: Node -> Int] {
let x = eval[X] |
bveq[hd09[x], eval[root]]
}
--------------------------------------------------------------------------------
-- Helpers
--------------------------------------------------------------------------------
fun hd09[x: Int]: Int {
bvsub[bvxor[x, bvsha[x, 0x0000001F]],
bvsha[x, 0x0000001F]]
}
--------------------------------------------------------------------------------
-- Commands
--------------------------------------------------------------------------------
-- (https://github.com/rishabhs/sygus-comp14/blob/master/benchmarks/hackers_del/hd-09-d0-prog.sl)
run synthIntNodeI for 0 but {bitwidth: 32, atoms: [literals, bw(7)]} Int, 6 IntVarVal,
exactly 1 BvSub, exactly 1 BvXor, exactly 1 BvSha
// TOO SLOW
-- (https://github.com/rishabhs/sygus-comp14/blob/master/benchmarks/hackers_del/hd-09-d1-prog.sl)
run synthIntNodeI for 0 but {bitwidth: 32, atoms: [literals, bw(7)]} Int, 6 IntVarVal,
exactly 1 BvAdd, exactly 1 BvSub, exactly 1 BvNot, exactly 1 BvNeg, exactly 1 BvAnd, exactly 1 BvOr, exactly 1 BvXor
// TOO SLOW
-- (https://github.com/rishabhs/sygus-comp14/blob/master/benchmarks/hackers_del/hd-09-d5-prog.sl)
run synth for 0 but {bitwidth: 32, atoms: bw(7)} Int, 6 IntVarVal,
exactly 3 BinaryIntOp, exactly 2 UnaryIntOp
|
programs/oeis/033/A033364.asm | karttu/loda | 1 | 97376 | <reponame>karttu/loda
; A033364: [ 44/n ].
; 44,22,14,11,8,7,6,5,4,4,4,3,3,3,2,2,2,2,2,2,2,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0
add $0,1
mov $1,44
div $1,$0
|
programs/oeis/066/A066014.asm | karttu/loda | 1 | 10333 | ; A066014: Highest minimal Euclidean norm of any Type 4^Z self-dual code of length n over Z/4Z which does not have all Euclidean norms divisible by 8, that is, is strictly Type I. Compare A105682.
; 4,4,4,4,4,4,4,4,4,4,4,8,4,8,8,8,8,8,8,8,8,8,12,12
mov $1,$0
gcd $0,3
sub $1,$0
div $1,10
mul $1,4
add $1,4
|
3-mid/opengl/source/opengl-server.ads | charlie5/lace | 20 | 15494 | package openGL.Server
--
-- Provides functions to query the GL server.
--
is
type a_Version is
record
Major : Integer;
Minor : Integer;
end record;
function Version return a_Version;
function Version return String;
end openGL.Server;
|
intf/src/main/antlr4/imports/MonsoonPrimitivesLexer.g4 | groupon/monsoon | 32 | 2359 | <reponame>groupon/monsoon<filename>intf/src/main/antlr4/imports/MonsoonPrimitivesLexer.g4
/*
* Copyright (c) 2016, 2017, Groupon, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 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 GROUPON nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
* IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
* PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
* TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
lexer grammar MonsoonPrimitivesLexer;
@header {
import java.util.regex.Matcher;
import java.util.regex.Pattern;
}
@members {
private static final Pattern SPECIAL = Pattern.compile("\\\\([\\\\abtnvfr'\"/]"
+ "|[0-7][0-7][0-7]"
+ "|[0-7][0-7]"
+ "|[0-7]"
+ "|x[0-9a-fA-F][0-9a-fA-F]"
+ "|u[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F]"
+ "|U[0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F][0-9a-fA-F])");
private static String handleEscapes(String s) {
final StringBuilder result = new StringBuilder(s.length());
Matcher matcher = SPECIAL.matcher(s);
int b = 0;
while (matcher.find()) {
result.append(s, b, matcher.start());
b = matcher.end();
switch (s.charAt(matcher.start() + 1)) {
default:
throw new IllegalStateException("Programmer error: unhandled sequence " + s.substring(matcher.start(), matcher.end()));
case '\\':
result.append('\\');
break;
case 'a':
result.append('\007'); // Unknown to java.
break;
case 'b':
result.append('\010'); // Unknown to java.
break;
case 't':
result.append('\t');
break;
case 'n':
result.append('\n');
break;
case 'v':
result.append('\013'); // Unknown to java.
break;
case 'f':
result.append('\f');
break;
case 'r':
result.append('\r');
break;
case '/':
result.append('/');
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
final String octal_part = s.substring(matcher.start() + 1, matcher.end());
final int ch_int = Integer.parseInt(octal_part, 8);
if (ch_int > 127)
throw new NumberFormatException("Invalid octal escape: " + octal_part);
result.append((char) ch_int);
break;
case 'x':
case 'u':
case 'U':
final String hex_part = s.substring(matcher.start() + 2, matcher.end());
final int unicode_int = Integer.parseInt(hex_part, 16);
if (unicode_int > 0x10ffff)
throw new NumberFormatException("Invalid hex escape: " + hex_part);
result.append(Character.toChars(unicode_int));
break;
}
}
result.append(s, b, s.length());
return result.toString();
}
}
WS : (' '|'\n'|'\t')+
{ skip(); }
;
ID : ('_'|'a'..'z'|'A'..'Z') ('_'|'a'..'z'|'A'..'Z'|'0'..'9')*
;
FP_DECIMAL : ('0'..'9')+ (('e'|'E') '-'? ('0'..'9')+)
| ('0'..'9')* '.' ('0'..'9')+ (('e'|'E') ('0'..'9')+)?
;
FP_HEX : '0x' ('0'..'9'|'a'..'f'|'A'..'F')+ ('.' ('0'..'9'|'a'..'f'|'A'..'F')*)
| '0x' ('0'..'9'|'a'..'f'|'A'..'F')+ ('.' ('0'..'9'|'a'..'f'|'A'..'F')*)? (('p'|'P') '-'? ('0'..'9'|'a'..'f'|'A'..'F')+)
;
DIGITS : ('1'..'9') ('0'..'9')*
;
HEXDIGITS : '0x' ('0'..'9'|'a'..'f'|'A'..'F')+
;
OCTDIGITS : '0' ('0'..'7')*
;
/*
* String logic.
*
* Strings are enclosed in double quotes and may contain escape sequences.
* Strings are sensitive to white space.
*/
QSTRING : '"'
( ~('\\'|'"'|'\u0000'..'\u001f')
| '\\\\'
| '\\a'
| '\\b'
| '\\t'
| '\\n'
| '\\v'
| '\\f'
| '\\r'
| '\\\''
| '\\"'
| '\\/'
| '\\' ('0'..'7') ('0'..'7') ('0'..'7')
| '\\' ('0'..'7') ('0'..'7')
| '\\' ('0'..'7')
| '\\x' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
| '\\u' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
| '\\U' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
)*
'"'
{ setText(handleEscapes(getText().substring(1, getText().length() - 1))); }
;
SQSTRING : '\''
( ~('\\'|'\''|'\u0000'..'\u001f')
| '\\\\'
| '\\a'
| '\\b'
| '\\t'
| '\\n'
| '\\v'
| '\\f'
| '\\r'
| '\\\''
| '\\"'
| '\\/'
| '\\' ('0'..'7') ('0'..'7') ('0'..'7')
| '\\' ('0'..'7') ('0'..'7')
| '\\' ('0'..'7')
| '\\x' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
| '\\u' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
| '\\U' ('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
('0'..'9' | 'a'..'f' | 'A'..'F')
)*
'\''
{ setText(handleEscapes(getText().substring(1, getText().length() - 1))); }
;
REGEX : '//'
( '/' (~('/'|'\\') | '\\' .)
| '\\' .
| ~('/')
)*
'//'
{ setText(getText().substring(2, getText().length() - 2).replace("\\/", "/")); }
;
SQBRACE_OPEN_LIT: '['
;
SQBRACE_CLOSE_LIT
: ']'
;
DASH_LIT : '-'
;
DOT_DOT_LIT : '..'
;
EQ_KW : '='
;
|
boards/OpenMV2/src/openmv.adb | rocher/Ada_Drivers_Library | 192 | 3608 | ------------------------------------------------------------------------------
-- --
-- Copyright (C) 2015-2018, AdaCore --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions are --
-- met: --
-- 1. Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- 2. Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in --
-- the documentation and/or other materials provided with the --
-- distribution. --
-- 3. Neither the name of the copyright holder nor the names of its --
-- contributors may be used to endorse or promote products derived --
-- from this software without specific prior written permission. --
-- --
-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS --
-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT --
-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR --
-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT --
-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, --
-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT --
-- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, --
-- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY --
-- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT --
-- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE --
-- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --
-- --
------------------------------------------------------------------------------
with HAL.SPI;
package body OpenMV is
---------------------
-- Initialize_LEDs --
---------------------
procedure Initialize_LEDs is
begin
Enable_Clock (All_LEDs);
Configure_IO
(All_LEDs,
(Mode => Mode_Out,
Output_Type => Push_Pull,
Speed => Speed_100MHz,
Resistors => Floating));
end Initialize_LEDs;
-----------------
-- Set_RGB_LED --
-----------------
procedure Set_RGB_LED (C : LED_Color) is
begin
-- Clear to turn on LED
-- Set to turn off
case C is
when White | Red | Yellow | Magenta =>
Clear (Red_LED);
when others =>
Set (Red_LED);
end case;
case C is
when White | Green | Yellow | Cyan =>
Clear (Green_LED);
when others =>
Set (Green_LED);
end case;
case C is
when White | Cyan | Blue | Magenta =>
Clear (Blue_LED);
when others =>
Set (Blue_LED);
end case;
end Set_RGB_LED;
----------------
-- Turn_On_IR --
----------------
procedure Turn_On_IR is
begin
Set (IR_LED);
end Turn_On_IR;
-----------------
-- Turn_Off_IR --
-----------------
procedure Turn_Off_IR is
begin
Clear (IR_LED);
end Turn_Off_IR;
---------------------------
-- Initialize_Shield_SPI --
---------------------------
procedure Initialize_Shield_SPI is
SPI_Conf : STM32.SPI.SPI_Configuration;
GPIO_Conf : STM32.GPIO.GPIO_Port_Configuration;
procedure Initialize_DMA;
--------------------
-- Initialize_DMA --
--------------------
procedure Initialize_DMA is
Config : DMA_Stream_Configuration;
begin
Enable_Clock (Shield_SPI_DMA);
Config.Channel := Shield_SPI_DMA_Chan;
Config.Direction := Memory_To_Peripheral;
Config.Increment_Peripheral_Address := False;
Config.Increment_Memory_Address := True;
Config.Peripheral_Data_Format := Bytes;
Config.Memory_Data_Format := Bytes;
Config.Operation_Mode := Normal_Mode;
Config.Priority := Priority_High;
Config.FIFO_Enabled := True;
Config.FIFO_Threshold := FIFO_Threshold_Full_Configuration;
Config.Memory_Burst_Size := Memory_Burst_Inc4;
Config.Peripheral_Burst_Size := Peripheral_Burst_Single;
Configure (Shield_SPI_DMA, Shield_SPI_DMA_Stream, Config);
Shield_SPI.Set_TX_DMA_Handler (Shield_SPI_DMA_Int'Access);
end Initialize_DMA;
begin
Initialize_DMA;
STM32.Device.Enable_Clock (Shield_SPI_Points);
GPIO_Conf := (Mode => STM32.GPIO.Mode_AF,
AF => GPIO_AF_SPI2_5,
Resistors => STM32.GPIO.Pull_Down, -- SPI low polarity
AF_Speed => STM32.GPIO.Speed_100MHz,
AF_Output_Type => STM32.GPIO.Push_Pull);
STM32.GPIO.Configure_IO (Shield_SPI_Points, GPIO_Conf);
STM32.Device.Enable_Clock (Shield_SPI);
Shield_SPI.Disable;
SPI_Conf.Direction := STM32.SPI.D2Lines_FullDuplex;
SPI_Conf.Mode := STM32.SPI.Master;
SPI_Conf.Data_Size := HAL.SPI.Data_Size_8b;
SPI_Conf.Clock_Polarity := STM32.SPI.Low;
SPI_Conf.Clock_Phase := STM32.SPI.P1Edge;
SPI_Conf.Slave_Management := STM32.SPI.Software_Managed;
SPI_Conf.Baud_Rate_Prescaler := STM32.SPI.BRP_2;
SPI_Conf.First_Bit := STM32.SPI.MSB;
SPI_Conf.CRC_Poly := 7;
Shield_SPI.Configure (SPI_Conf);
Shield_SPI.Enable;
end Initialize_Shield_SPI;
-----------------------------
-- Initialize_Shield_USART --
-----------------------------
procedure Initialize_Shield_USART (Baud : STM32.USARTs.Baud_Rates) is
Configuration : GPIO_Port_Configuration;
begin
Enable_Clock (Shield_USART);
Enable_Clock (Shield_USART_Points);
Configuration := (Mode => STM32.GPIO.Mode_AF,
AF => Shield_USART_AF,
Resistors => STM32.GPIO.Pull_Up,
AF_Speed => STM32.GPIO.Speed_50MHz,
AF_Output_Type => STM32.GPIO.Push_Pull);
Configure_IO (Shield_USART_Points, Configuration);
Disable (Shield_USART);
Set_Baud_Rate (Shield_USART, Baud);
Set_Mode (Shield_USART, Tx_Rx_Mode);
Set_Stop_Bits (Shield_USART, Stopbits_1);
Set_Word_Length (Shield_USART, Word_Length_8);
Set_Parity (Shield_USART, No_Parity);
Set_Flow_Control (Shield_USART, No_Flow_Control);
Enable (Shield_USART);
end Initialize_Shield_USART;
----------------------
-- Get_Shield_USART --
----------------------
function Get_Shield_USART return not null HAL.UART.Any_UART_Port is
(USART_3'Access);
end OpenMV;
|
data/pokemon/base_stats/raitora.asm | AtmaBuster/pokeplat-gen2 | 6 | 169787 | db 0 ; species ID placeholder
db 115, 85, 65, 70, 85, 80
; hp atk def spd sat sdf
db ELECTRIC, ELECTRIC ; type
db 45 ; catch rate
db 179 ; base exp
db PRZCUREBERRY, NO_ITEM ; items
db GENDER_F50 ; gender ratio
db 20 ; step cycles to hatch
INCBIN "gfx/pokemon/raitora/front.dimensions"
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_GROUND, EGG_GROUND ; egg groups
db 70 ; happiness
; tm/hm learnset
tmhm
; end
|
oeis/313/A313614.asm | neoneye/loda-programs | 11 | 168048 | ; A313614: Coordination sequence Gal.5.129.3 where G.u.t.v denotes the coordination sequence for a vertex of type v in tiling number t in the Galebach list of u-uniform tilings.
; Submitted by <NAME>(s2)
; 1,5,10,14,20,24,30,34,39,44,49,54,58,64,68,74,78,83,88,93,98,102,108,112,118,122,127,132,137,142,146,152,156,162,166,171,176,181,186,190,196,200,206,210,215,220,225,230,234,240
mul $0,22
mov $2,$0
add $0,3
div $0,9
add $0,1
sub $2,4
div $2,9
add $2,$0
mov $0,$2
|
OSDev/Try-12/boot/16/disk.asm | Ashwin-Paudel/Tries | 0 | 7235 | <filename>OSDev/Try-12/boot/16/disk.asm
;
; disk.asm
; KripayaOS Project
; Author(s): [Ashwin: <EMAIL>]
;
[bits 16]
disk_load:
; Save the registers
push ax
push bx
push cx
push dx
push cx
; Allow Reading the disk
mov ah, 0x02
; Configure a few registers for BIOS interrupt
mov al, cl
mov cl, bl
mov bx, dx
; You have to change when reading from an actual drive
mov ch, 0x00 ; Cylinder
mov dh, 0x00 ; Cylinder Head
; Load the drive and call the BIOS interrupt
mov dl, byte[boot_drive]
int 0x13
; If we encounter any errors
jc .disk_error
; Check for more errors
pop bx
cmp al, bl
jne .disk_error
; If there aren't any errors, print a message
mov bx, disk_success_msg
call print16
; Restore all the registers and return
pop dx
pop cx
pop bx
pop ax
ret
.disk_error:
mov bx, disk_error_msg
call print16
shr ax, 8
mov bx, ax
call print_hex16
jmp $
disk_error_msg: db `\r\nError Loading Sectors! Code: `, 0
disk_success_msg: db `\r\nSectors Loaded Successfully!\r\n`, 0 |
etude.asm | shepheb/hork | 0 | 29327 | <reponame>shepheb/hork<filename>etude.asm
Resident data ends at 61c, program starts at 61c, file ends at 4a0c
Starting analysis pass at address 61c
End of analysis pass, low address = 61c, high address = 20b6
[Start of code at 61c]
Main routine 61c, 0 locals
61d: e0 3f 05 6b ff CALL_VS 15ac -> Gef
622: ba QUIT
Routine 624, 2 locals
625: e0 17 07 a1 32 00 01 CALL_VS 1e84 (#32,#00) -> L00
62c: e0 17 07 a1 32 01 02 CALL_VS 1e84 (#32,#01) -> L01
633: a0 01 4b JZ L00 [FALSE] 63f
636: a0 02 48 JZ L01 [FALSE] 63f
639: 8d 08 46 PRINT_PADDR S003
63c: 8c 00 1f JUMP 65c
63f: 8d 08 55 PRINT_PADDR S004
642: e6 bf 01 PRINT_NUM L00
645: b2 ... PRINT "."
648: e6 bf 02 PRINT_NUM L01
64b: b2 ... PRINT " of the Z-Spec.
"
65c: e0 17 07 a1 00 01 01 CALL_VS 1e84 (#00,#01) -> L00
663: 49 01 01 00 AND L00,#01 -> -(SP)
667: a0 00 c8 JZ (SP)+ [TRUE] 670
66a: 8d 08 5d PRINT_PADDR S005
66d: 8c 00 05 JUMP 673
670: 8d 08 67 PRINT_PADDR S006
673: 49 01 04 00 AND L00,#04 -> -(SP)
677: a0 00 c8 JZ (SP)+ [TRUE] 680
67a: 8d 08 72 PRINT_PADDR S007
67d: 8c 00 05 JUMP 683
680: 8d 08 7e PRINT_PADDR S008
683: 49 01 08 00 AND L00,#08 -> -(SP)
687: a0 00 c8 JZ (SP)+ [TRUE] 690
68a: 8d 08 8b PRINT_PADDR S009
68d: 8c 00 05 JUMP 693
690: 8d 08 98 PRINT_PADDR S010
693: 49 01 10 00 AND L00,#10 -> -(SP)
697: a0 00 c8 JZ (SP)+ [TRUE] 6a0
69a: 8d 08 a6 PRINT_PADDR S011
69d: 8c 00 05 JUMP 6a3
6a0: 8d 08 b1 PRINT_PADDR S012
6a3: 49 01 20 00 AND L00,#20 -> -(SP)
6a7: a0 00 c8 JZ (SP)+ [TRUE] 6b0
6aa: 8d 08 bd PRINT_PADDR S013
6ad: 8c 00 05 JUMP 6b3
6b0: 8d 08 c7 PRINT_PADDR S014
6b3: 49 01 80 00 AND L00,#80 -> -(SP)
6b7: a0 00 c8 JZ (SP)+ [TRUE] 6c0
6ba: 8d 08 d2 PRINT_PADDR S015
6bd: 8c 00 05 JUMP 6c3
6c0: 8d 08 dc PRINT_PADDR S016
6c3: bb NEW_LINE
6c4: e0 17 07 a1 10 01 01 CALL_VS 1e84 (#10,#01) -> L00
6cb: 49 01 10 00 AND L00,#10 -> -(SP)
6cf: a0 00 c8 JZ (SP)+ [TRUE] 6d8
6d2: 8d 08 e7 PRINT_PADDR S017
6d5: 8c 00 05 JUMP 6db
6d8: 8d 08 f0 PRINT_PADDR S018
6db: b0 RTRUE
Routine 6dc, 4 locals
6dd: e0 17 07 a1 00 01 01 CALL_VS 1e84 (#00,#01) -> L00
6e4: 49 01 01 00 AND L00,#01 -> -(SP)
6e8: a0 00 cb JZ (SP)+ [TRUE] 6f4
6eb: 8d 09 06 PRINT_PADDR S029
6ee: 0d 04 01 STORE L03,#01
6f1: 8c 00 08 JUMP 6fa
6f4: 8d 09 10 PRINT_PADDR S030
6f7: 0d 04 00 STORE L03,#00
6fa: a0 04 c8 JZ L03 [TRUE] 703
6fd: 8d 09 1b PRINT_PADDR S031
700: 8c 00 05 JUMP 706
703: 8d 09 22 PRINT_PADDR S032
706: 8d 09 2b PRINT_PADDR S033
709: 0f 00 08 ff LOADW #00,#08 -> Gef
70d: 28 02 ff ff OR #02,Gef -> Gef
711: e1 5b 00 08 ff STOREW #00,#08,Gef
716: bb NEW_LINE
717: b2 ... PRINT "Bk Rd Gr Yl Bl Mg Cy Wh
"
72e: 0d 02 02 STORE L01,#02
731: 42 02 0a 00 47 JL L01,#0a [FALSE] 77b
736: 0d 03 02 STORE L02,#02
739: 42 03 0a 4f JL L02,#0a [FALSE] 74a
73d: 7b 02 03 SET_COLOUR L01,L02
740: b2 ... PRINT "## "
745: 95 03 INC L02
747: 8c ff f1 JUMP 739
74a: 1b 01 01 SET_COLOUR #01,#01
74d: b2 ... PRINT ": "
750: 42 02 00 c6 JL L01,#00 [TRUE] 758
754: 42 02 0a d2 JL L01,#0a [TRUE] 768
758: fa 19 5f 06 55 1d 02 09 01 00
CALL_VN2 1954 (#1d,L01,#09,#01,#00)
762: e8 7f 00 PUSH #00
765: 8c 00 08 JUMP 76e
768: cf 2f 04 e8 02 00 LOADW #04e8,L01 -> -(SP)
76e: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
773: b2 ... PRINT "
"
776: 95 02 INC L01
778: 8c ff b8 JUMP 731
77b: 0f 00 08 ff LOADW #00,#08 -> Gef
77f: c9 2f ff fd ff ff AND #fffd,Gef -> Gef
785: e1 5b 00 08 ff STOREW #00,#08,Gef
78a: b0 RTRUE
Routine 78c, 1 local
78d: e0 17 07 a1 00 01 01 CALL_VS 1e84 (#00,#01) -> L00
794: 49 01 04 00 AND L00,#04 -> -(SP)
798: a0 00 c8 JZ (SP)+ [TRUE] 7a1
79b: 8d 09 47 PRINT_PADDR S034
79e: 8c 00 05 JUMP 7a4
7a1: 8d 09 53 PRINT_PADDR S035
7a4: 49 01 08 00 AND L00,#08 -> -(SP)
7a8: a0 00 c8 JZ (SP)+ [TRUE] 7b1
7ab: 8d 09 60 PRINT_PADDR S036
7ae: 8c 00 05 JUMP 7b4
7b1: 8d 09 6d PRINT_PADDR S037
7b4: 49 01 10 00 AND L00,#10 -> -(SP)
7b8: a0 00 c8 JZ (SP)+ [TRUE] 7c1
7bb: 8d 09 7b PRINT_PADDR S038
7be: 8c 00 05 JUMP 7c4
7c1: 8d 09 86 PRINT_PADDR S039
7c4: bb NEW_LINE
7c5: f1 7f 02 SET_TEXT_STYLE BOLDFACE
7c8: b2 ... PRINT "Test of emphasized (bold)
text."
7e1: f1 7f 00 SET_TEXT_STYLE ROMAN
7e4: b2 ... PRINT "
...normal font...
"
7f7: f1 7f 04 SET_TEXT_STYLE EMPHASIS
7fa: 8d 09 92 PRINT_PADDR S040
7fd: f1 7f 00 SET_TEXT_STYLE ROMAN
800: b2 ... PRINT "
...normal font...
"
813: f1 7f 01 SET_TEXT_STYLE REVERSE
816: b2 ... PRINT "Test of reverse-video text."
82b: f1 7f 00 SET_TEXT_STYLE ROMAN
82e: b2 ... PRINT "
...normal font...
"
841: 0f 00 08 ff LOADW #00,#08 -> Gef
845: 28 02 ff ff OR #02,Gef -> Gef
849: e1 5b 00 08 ff STOREW #00,#08,Gef
84e: 8d 09 99 PRINT_PADDR S041
851: 0f 00 08 ff LOADW #00,#08 -> Gef
855: c9 2f ff fd ff ff AND #fffd,Gef -> Gef
85b: e1 5b 00 08 ff STOREW #00,#08,Gef
860: b2 ... PRINT "
...normal font...
"
873: f1 7f 08 SET_TEXT_STYLE FIXED_FONT
876: 8d 09 a6 PRINT_PADDR S042
879: f1 7f 00 SET_TEXT_STYLE ROMAN
87c: bb NEW_LINE
87d: 8d 09 b1 PRINT_PADDR S043
880: f1 7f 02 SET_TEXT_STYLE BOLDFACE
883: f1 7f 04 SET_TEXT_STYLE EMPHASIS
886: b2 ... PRINT "Test of bold, italic text."
89b: f1 7f 00 SET_TEXT_STYLE ROMAN
89e: bb NEW_LINE
89f: f1 7f 02 SET_TEXT_STYLE BOLDFACE
8a2: f1 7f 01 SET_TEXT_STYLE REVERSE
8a5: b2 ... PRINT "Test of bold, reverse text."
8ba: f1 7f 00 SET_TEXT_STYLE ROMAN
8bd: bb NEW_LINE
8be: f1 7f 04 SET_TEXT_STYLE EMPHASIS
8c1: f1 7f 01 SET_TEXT_STYLE REVERSE
8c4: b2 ... PRINT "Test of italic, reverse text."
8db: f1 7f 00 SET_TEXT_STYLE ROMAN
8de: bb NEW_LINE
8df: f1 7f 02 SET_TEXT_STYLE BOLDFACE
8e2: f1 7f 04 SET_TEXT_STYLE EMPHASIS
8e5: f1 7f 01 SET_TEXT_STYLE REVERSE
8e8: 8d 09 d0 PRINT_PADDR S044
8eb: f1 7f 00 SET_TEXT_STYLE ROMAN
8ee: bb NEW_LINE
8ef: 8d 09 d7 PRINT_PADDR S045
8f2: 0f 00 08 ff LOADW #00,#08 -> Gef
8f6: 28 02 ff ff OR #02,Gef -> Gef
8fa: e1 5b 00 08 ff STOREW #00,#08,Gef
8ff: f1 7f 02 SET_TEXT_STYLE BOLDFACE
902: b2 ... PRINT "Test of fixed, bold text."
917: f1 7f 00 SET_TEXT_STYLE ROMAN
91a: bb NEW_LINE
91b: f1 7f 04 SET_TEXT_STYLE EMPHASIS
91e: b2 ... PRINT "Test of fixed, italic text."
933: f1 7f 00 SET_TEXT_STYLE ROMAN
936: bb NEW_LINE
937: f1 7f 01 SET_TEXT_STYLE REVERSE
93a: b2 ... PRINT "Test of fixed, reverse text."
951: f1 7f 00 SET_TEXT_STYLE ROMAN
954: bb NEW_LINE
955: f1 7f 02 SET_TEXT_STYLE BOLDFACE
958: f1 7f 04 SET_TEXT_STYLE EMPHASIS
95b: 8d 09 ef PRINT_PADDR S046
95e: f1 7f 00 SET_TEXT_STYLE ROMAN
961: bb NEW_LINE
962: f1 7f 02 SET_TEXT_STYLE BOLDFACE
965: f1 7f 01 SET_TEXT_STYLE REVERSE
968: 8d 09 f6 PRINT_PADDR S047
96b: f1 7f 00 SET_TEXT_STYLE ROMAN
96e: bb NEW_LINE
96f: f1 7f 04 SET_TEXT_STYLE EMPHASIS
972: f1 7f 01 SET_TEXT_STYLE REVERSE
975: 8d 09 fd PRINT_PADDR S048
978: f1 7f 00 SET_TEXT_STYLE ROMAN
97b: bb NEW_LINE
97c: f1 7f 02 SET_TEXT_STYLE BOLDFACE
97f: f1 7f 04 SET_TEXT_STYLE EMPHASIS
982: f1 7f 01 SET_TEXT_STYLE REVERSE
985: 8d 0a 04 PRINT_PADDR S049
988: f1 7f 00 SET_TEXT_STYLE ROMAN
98b: bb NEW_LINE
98c: 0f 00 08 ff LOADW #00,#08 -> Gef
990: c9 2f ff fd ff ff AND #fffd,Gef -> Gef
996: e1 5b 00 08 ff STOREW #00,#08,Gef
99b: b2 ... PRINT "
End of styles test.
"
9ae: b0 RTRUE
Routine 9b0, 3 locals
9b1: da 2f 07 dd 01 CALL_2N 1f74 (L00)
9b6: b2 ... PRINT " = "
9bb: e6 bf 02 PRINT_NUM L01
9be: 61 02 03 4c JE L01,L02 [FALSE] 9cc
9c2: b2 ... PRINT " (ok)
"
9c9: 8c 00 20 JUMP 9ea
9cc: b2 ... PRINT " (ERROR, should be "
9df: e6 bf 03 PRINT_NUM L02
9e2: b2 ... PRINT "!)
"
9e7: 0d 10 01 STORE G00,#01
9ea: b0 RTRUE
Routine 9ec, 3 locals
9ed: 8d 0a 0c PRINT_PADDR S050
9f0: 8d 0a 31 PRINT_PADDR S051
9f3: 0d 10 00 STORE G00,#00
9f6: 0d 01 0d STORE L00,#0d
9f9: 0d 02 05 STORE L01,#05
9fc: 76 01 02 03 MUL L00,L01 -> L02
a00: f9 09 02 6c 0a 81 03 41 CALL_VN 9b0 (S052,L02,#41)
a08: 0d 01 0d STORE L00,#0d
a0b: cd 4f 02 ff fb STORE L01,#fffb
a10: 76 01 02 03 MUL L00,L01 -> L02
a14: f9 08 02 6c 0a 83 03 ff bf
CALL_VN 9b0 (S053,L02,#ffbf)
a1d: cd 4f 01 ff f3 STORE L00,#fff3
a22: 0d 02 05 STORE L01,#05
a25: 76 01 02 03 MUL L00,L01 -> L02
a29: f9 08 02 6c 0a 86 03 ff bf
CALL_VN 9b0 (S054,L02,#ffbf)
a32: cd 4f 01 ff f3 STORE L00,#fff3
a37: cd 4f 02 ff fb STORE L01,#fffb
a3c: 76 01 02 03 MUL L00,L01 -> L02
a40: f9 09 02 6c 0a 89 03 41 CALL_VN 9b0 (S055,L02,#41)
a48: 0d 01 0d STORE L00,#0d
a4b: 0d 02 05 STORE L01,#05
a4e: 2d ff 01 STORE Gef,L00
a51: 2d fe 02 STORE Gee,L01
a54: a0 fe 49 JZ Gee [FALSE] a5e
a57: f9 1f 06 55 14 CALL_VN 1954 (#14)
a5c: 95 fe INC Gee
a5e: 77 ff fe 03 DIV Gef,Gee -> L02
a62: f9 09 02 6c 0a 8c 03 02 CALL_VN 9b0 (S056,L02,#02)
a6a: 0d 01 0d STORE L00,#0d
a6d: cd 4f 02 ff fb STORE L01,#fffb
a72: 2d ff 01 STORE Gef,L00
a75: 2d fe 02 STORE Gee,L01
a78: a0 fe 49 JZ Gee [FALSE] a82
a7b: f9 1f 06 55 14 CALL_VN 1954 (#14)
a80: 95 fe INC Gee
a82: 77 ff fe 03 DIV Gef,Gee -> L02
a86: f9 08 02 6c 0a 8e 03 ff fe
CALL_VN 9b0 (S057,L02,#fffe)
a8f: cd 4f 01 ff f3 STORE L00,#fff3
a94: 0d 02 05 STORE L01,#05
a97: 2d ff 01 STORE Gef,L00
a9a: 2d fe 02 STORE Gee,L01
a9d: a0 fe 49 JZ Gee [FALSE] aa7
aa0: f9 1f 06 55 14 CALL_VN 1954 (#14)
aa5: 95 fe INC Gee
aa7: 77 ff fe 03 DIV Gef,Gee -> L02
aab: f9 08 02 6c 0a 90 03 ff fe
CALL_VN 9b0 (S058,L02,#fffe)
ab4: cd 4f 01 ff f3 STORE L00,#fff3
ab9: cd 4f 02 ff fb STORE L01,#fffb
abe: 2d ff 01 STORE Gef,L00
ac1: 2d fe 02 STORE Gee,L01
ac4: a0 fe 49 JZ Gee [FALSE] ace
ac7: f9 1f 06 55 14 CALL_VN 1954 (#14)
acc: 95 fe INC Gee
ace: 77 ff fe 03 DIV Gef,Gee -> L02
ad2: f9 09 02 6c 0a 92 03 02 CALL_VN 9b0 (S059,L02,#02)
ada: 0d 01 0d STORE L00,#0d
add: 0d 02 05 STORE L01,#05
ae0: 2d ff 01 STORE Gef,L00
ae3: 2d fe 02 STORE Gee,L01
ae6: a0 fe 49 JZ Gee [FALSE] af0
ae9: f9 1f 06 55 14 CALL_VN 1954 (#14)
aee: 95 fe INC Gee
af0: 78 ff fe 03 MOD Gef,Gee -> L02
af4: f9 09 02 6c 0a 95 03 03 CALL_VN 9b0 (S060,L02,#03)
afc: 0d 01 0d STORE L00,#0d
aff: cd 4f 02 ff fb STORE L01,#fffb
b04: 2d ff 01 STORE Gef,L00
b07: 2d fe 02 STORE Gee,L01
b0a: a0 fe 49 JZ Gee [FALSE] b14
b0d: f9 1f 06 55 14 CALL_VN 1954 (#14)
b12: 95 fe INC Gee
b14: 78 ff fe 03 MOD Gef,Gee -> L02
b18: f9 09 02 6c 0a 97 03 03 CALL_VN 9b0 (S061,L02,#03)
b20: cd 4f 01 ff f3 STORE L00,#fff3
b25: 0d 02 05 STORE L01,#05
b28: 2d ff 01 STORE Gef,L00
b2b: 2d fe 02 STORE Gee,L01
b2e: a0 fe 49 JZ Gee [FALSE] b38
b31: f9 1f 06 55 14 CALL_VN 1954 (#14)
b36: 95 fe INC Gee
b38: 78 ff fe 03 MOD Gef,Gee -> L02
b3c: f9 08 02 6c 0a 9a 03 ff fd
CALL_VN 9b0 (S062,L02,#fffd)
b45: cd 4f 01 ff f3 STORE L00,#fff3
b4a: cd 4f 02 ff fb STORE L01,#fffb
b4f: 2d ff 01 STORE Gef,L00
b52: 2d fe 02 STORE Gee,L01
b55: a0 fe 49 JZ Gee [FALSE] b5f
b58: f9 1f 06 55 14 CALL_VN 1954 (#14)
b5d: 95 fe INC Gee
b5f: 78 ff fe 03 MOD Gef,Gee -> L02
b63: f9 08 02 6c 0a 9d 03 ff fd
CALL_VN 9b0 (S063,L02,#fffd)
b6c: a0 10 4e JZ G00 [FALSE] b7b
b6f: b2 ... PRINT "
"
b72: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
b78: 8c 00 0b JUMP b84
b7b: b2 ... PRINT "
"
b7e: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
b84: b0 RTRUE
Routine b88, 2 locals
b89: 8d 0b 7a PRINT_PADDR S133
b8c: 8d 0b 98 PRINT_PADDR S134
b8f: 8d 0b e2 PRINT_PADDR S135
b92: 0d 02 00 STORE L01,#00
b95: 90 01 80 df JZ #01 [TRUE] c76
b99: 42 02 00 80 a7 JL L01,#00 [TRUE] c43
b9e: 49 02 04 00 AND L01,#04 -> -(SP)
ba2: a0 00 cf JZ (SP)+ [TRUE] bb2
ba5: 0f 00 08 ff LOADW #00,#08 -> Gef
ba9: 28 02 ff ff OR #02,Gef -> Gef
bad: e1 5b 00 08 ff STOREW #00,#08,Gef
bb2: 49 02 02 00 AND L01,#02 -> -(SP)
bb6: a0 00 c5 JZ (SP)+ [TRUE] bbc
bb9: f1 7f 04 SET_TEXT_STYLE EMPHASIS
bbc: 49 02 01 00 AND L01,#01 -> -(SP)
bc0: a0 00 c5 JZ (SP)+ [TRUE] bc6
bc3: f1 7f 02 SET_TEXT_STYLE BOLDFACE
bc6: 0d 01 01 STORE L00,#01
bc9: 02 00 00 c6 JL #00,#00 [TRUE] bd1
bcd: 02 00 46 d2 JL #00,#46 [TRUE] be1
bd1: fa 15 5f 06 55 1d 00 45 03 01
CALL_VN2 1954 (#1d,#00,#45,#03,#01)
bdb: e8 7f 00 PUSH #00
bde: 8c 00 08 JUMP be7
be1: cf 1f 04 fc 00 00 LOADW #04fc,#00 -> -(SP)
be7: 63 01 00 f8 JG L00,(SP)+ [TRUE] c21
beb: 42 01 00 c6 JL L00,#00 [TRUE] bf3
bef: 42 01 46 d2 JL L00,#46 [TRUE] c03
bf3: fa 19 5f 06 55 1d 01 45 03 01
CALL_VN2 1954 (#1d,L00,#45,#03,#01)
bfd: e8 7f 00 PUSH #00
c00: 8c 00 08 JUMP c09
c03: cf 2f 04 fc 01 00 LOADW #04fc,L00 -> -(SP)
c09: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
c0e: 58 01 04 00 MOD L00,#04 -> -(SP)
c12: a0 00 46 JZ (SP)+ [FALSE] c19
c15: bb NEW_LINE
c16: 8c 00 05 JUMP c1c
c19: b2 ... PRINT " "
c1c: 95 01 INC L00
c1e: 8c ff aa JUMP bc9
c21: 49 02 04 00 AND L01,#04 -> -(SP)
c25: a0 00 d1 JZ (SP)+ [TRUE] c37
c28: 0f 00 08 ff LOADW #00,#08 -> Gef
c2c: c9 2f ff fd ff ff AND #fffd,Gef -> Gef
c32: e1 5b 00 08 ff STOREW #00,#08,Gef
c37: 49 02 03 00 AND L01,#03 -> -(SP)
c3b: a0 00 c5 JZ (SP)+ [TRUE] c41
c3e: f1 7f 00 SET_TEXT_STYLE ROMAN
c41: bb NEW_LINE
c42: bb NEW_LINE
c43: 8d 0c 3c PRINT_PADDR S136
c46: 8d 0c 4e PRINT_PADDR S137
c49: b2 ... PRINT "
Accents> "
c54: f6 7f 01 01 READ_CHAR #01 -> L00
c58: bb NEW_LINE
c59: 41 01 2e 43 JE L00,#2e [FALSE] c5e
c5d: b0 RTRUE
c5e: bb NEW_LINE
c5f: 42 01 30 cd JL L00,#30 [TRUE] c6e
c63: 43 01 37 c9 JG L00,#37 [TRUE] c6e
c67: 55 01 30 02 SUB L00,#30 -> L01
c6b: 8c 00 07 JUMP c73
c6e: cd 4f 02 ff ff STORE L01,#ffff
c73: 8c ff 21 JUMP b95
c76: b0 RTRUE
Routine c78, 3 locals
c79: 0d 03 00 STORE L02,#00
c7c: 41 01 08 4b JE L00,#08 [FALSE] c89
c80: 8d 0c 6a PRINT_PADDR S138
c83: 0d 03 02 STORE L02,#02
c86: 8c 01 fa JUMP e81
c89: 41 01 0d 4b JE L00,#0d [FALSE] c96
c8d: 8d 0c 74 PRINT_PADDR S139
c90: 0d 03 02 STORE L02,#02
c93: 8c 01 ed JUMP e81
c96: 41 01 1b 4b JE L00,#1b [FALSE] ca3
c9a: 8d 0c 7e PRINT_PADDR S140
c9d: 0d 03 02 STORE L02,#02
ca0: 8c 01 e0 JUMP e81
ca3: 42 01 20 69 JL L00,#20 [FALSE] cce
ca7: b2 ... PRINT "control character 'ctrl-"
cba: 54 01 40 00 ADD L00,#40 -> -(SP)
cbe: da 2f 07 d0 00 CALL_2N 1f40 ((SP)+)
cc3: b2 ... PRINT "'"
cc6: cd 4f 03 ff ff STORE L02,#ffff
ccb: 8c 01 b5 JUMP e81
cce: 41 01 7f 5f JE L00,#7f [FALSE] cef
cd2: b2 ... PRINT "control character 'delete'"
ce7: cd 4f 03 ff ff STORE L02,#ffff
cec: 8c 01 94 JUMP e81
cef: 41 01 80 59 JE L00,#80 [FALSE] d0a
cf3: b2 ... PRINT "undefined character"
d02: cd 4f 03 ff ff STORE L02,#ffff
d07: 8c 01 79 JUMP e81
d0a: 42 01 80 5e JL L00,#80 [FALSE] d2a
d0e: b2 ... PRINT "ASCII character '"
d1f: da 2f 07 d0 01 CALL_2N 1f40 (L00)
d24: b2 ... PRINT "'"
d27: 8c 01 59 JUMP e81
d2a: 42 01 9b 00 a3 JL L00,#9b [FALSE] dd0
d2f: 0d 03 02 STORE L02,#02
d32: 2d ff 01 STORE Gef,L00
d35: 41 ff 81 4c JE Gef,#81 [FALSE] d43
d39: b2 ... PRINT "cursor up"
d40: 8c 00 8c JUMP dcd
d43: 41 ff 82 4e JE Gef,#82 [FALSE] d53
d47: b2 ... PRINT "cursor down"
d50: 8c 00 7c JUMP dcd
d53: 41 ff 83 4e JE Gef,#83 [FALSE] d63
d57: b2 ... PRINT "cursor left"
d60: 8c 00 6c JUMP dcd
d63: 41 ff 84 4e JE Gef,#84 [FALSE] d73
d67: b2 ... PRINT "cursor right"
d70: 8c 00 5c JUMP dcd
d73: c1 95 ff 85 86 87 d7 JE Gef,#85,#86,#87 [TRUE] d8f
d7a: c1 95 ff 88 89 8a d0 JE Gef,#88,#89,#8a [TRUE] d8f
d81: c1 95 ff 8b 8c 8d c9 JE Gef,#8b,#8c,#8d [TRUE] d8f
d88: c1 95 ff 8e 8f 90 57 JE Gef,#8e,#8f,#90 [FALSE] da4
d8f: b2 ... PRINT "function key "
d9a: 55 01 84 00 SUB L00,#84 -> -(SP)
d9e: e6 bf 00 PRINT_NUM (SP)+
da1: 8c 00 2b JUMP dcd
da4: c1 95 ff 91 92 93 d4 JE Gef,#91,#92,#93 [TRUE] dbd
dab: c1 95 ff 94 95 96 cd JE Gef,#94,#95,#96 [TRUE] dbd
db2: c1 95 ff 97 98 99 c6 JE Gef,#97,#98,#99 [TRUE] dbd
db9: 41 ff 9a 52 JE Gef,#9a [FALSE] dcd
dbd: b2 ... PRINT "keypad key "
dc6: 55 01 91 00 SUB L00,#91 -> -(SP)
dca: e6 bf 00 PRINT_NUM (SP)+
dcd: 8c 00 b3 JUMP e81
dd0: 42 01 e0 79 JL L00,#e0 [FALSE] e0b
dd4: 55 01 9b 00 SUB L00,#9b -> -(SP)
dd8: 54 00 01 00 ADD (SP)+,#01 -> -(SP)
ddc: e9 7f fe PULL Gee
ddf: e8 bf fe PUSH Gee
de2: 42 fe 00 c6 JL Gee,#00 [TRUE] dea
de6: 42 fe 46 d5 JL Gee,#46 [TRUE] dfd
dea: fa 19 5f 06 55 1d fe 45 03 01
CALL_VN2 1954 (#1d,Gee,#45,#03,#01)
df4: a0 00 42 JZ (SP)+ [FALSE] df7
df7: e8 7f 00 PUSH #00
dfa: 8c 00 08 JUMP e03
dfd: cf 2f 04 fc 00 00 LOADW #04fc,(SP)+ -> -(SP)
e03: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
e08: 8c 00 78 JUMP e81
e0b: 42 01 fc 59 JL L00,#fc [FALSE] e26
e0f: b2 ... PRINT "undefined character"
e1e: cd 4f 03 ff ff STORE L02,#ffff
e23: 8c 00 5d JUMP e81
e26: 42 01 ff 00 44 JL L00,#ff [FALSE] e6d
e2b: 0d 03 02 STORE L02,#02
e2e: 2d ff 01 STORE Gef,L00
e31: 41 ff fc 4e JE Gef,#fc [FALSE] e41
e35: b2 ... PRINT "menu click"
e3e: 8c 00 2b JUMP e6a
e41: 41 ff fd 54 JE Gef,#fd [FALSE] e57
e45: b2 ... PRINT "mouse double-click"
e54: 8c 00 15 JUMP e6a
e57: 41 ff fe 51 JE Gef,#fe [FALSE] e6a
e5b: b2 ... PRINT "mouse single-click"
e6a: 8c 00 16 JUMP e81
e6d: cd 4f 03 ff ff STORE L02,#ffff
e72: b2 ... PRINT "undefined character"
e81: 41 02 01 69 JE L01,#01 [FALSE] eac
e85: 2d ff 03 STORE Gef,L02
e88: c1 8f ff ff ff 56 JE Gef,#ffff [FALSE] ea2
e8e: b2 ... PRINT " (should NOT occur)"
e9f: 8c 00 09 JUMP ea9
ea2: 41 ff 02 45 JE Gef,#02 [FALSE] ea9
ea6: 8d 0c 88 PRINT_PADDR S141
ea9: 8c 00 20 JUMP eca
eac: 41 02 02 5c JE L01,#02 [FALSE] eca
eb0: 2d ff 03 STORE Gef,L02
eb3: c1 8f ff ff ff 53 JE Gef,#ffff [FALSE] eca
eb9: b2 ... PRINT " (should NOT occur)"
eca: b0 RTRUE
Routine ecc, 4 locals
ecd: 8d 0c 90 PRINT_PADDR S142
ed0: 8d 0c bf PRINT_PADDR S143
ed3: 90 01 80 71 JZ #01 [TRUE] f46
ed7: b2 ... PRINT "
AccentedInput> "
ee8: d5 1f 00 50 03 00 SUB #0050,#03 -> -(SP)
eee: f9 06 07 b2 05 c2 00 00 CALL_VN 1ec8 (#05c2,#00,(SP)+)
ef6: f9 05 07 b2 05 c2 01 00 CALL_VN 1ec8 (#05c2,#01,#00)
efe: cd 4f 01 05 c2 STORE L00,#05c2
f03: 0d 02 00 STORE L01,#00
f06: e4 bf 01 02 READ L00 -> L01
f0a: bb NEW_LINE
f0b: e0 07 07 a1 05 c2 01 04 CALL_VS 1e84 (#05c2,#01) -> L03
f13: a0 04 43 JZ L03 [FALSE] f17
f16: b0 RTRUE
f17: 0d 02 00 STORE L01,#00
f1a: 62 02 04 67 JL L01,L03 [FALSE] f43
f1e: 34 02 02 00 ADD #02,L01 -> -(SP)
f22: e0 0b 07 a1 05 c2 00 03 CALL_VS 1e84 (#05c2,(SP)+) -> L02
f2a: b2 ... PRINT "code="
f31: e6 bf 03 PRINT_NUM L02
f34: b2 ... PRINT ": "
f37: f9 27 03 1e 03 01 CALL_VN c78 (L02,#01)
f3d: bb NEW_LINE
f3e: 95 02 INC L01
f40: 8c ff d9 JUMP f1a
f43: 8c ff 8f JUMP ed3
f46: b0 RTRUE
Routine f48, 1 local
f49: 8d 0c c8 PRINT_PADDR S144
f4c: 90 01 80 44 JZ #01 [TRUE] f92
f50: b2 ... PRINT "AccentedInput> "
f5f: 88 06 29 01 CALL_1S 18a4 -> L00
f63: 41 01 2e 54 JE L00,#2e [FALSE] f79
f67: b2 ... PRINT "
Test finished.
"
f78: b0 RTRUE
f79: b2 ... PRINT "
code="
f82: e6 bf 01 PRINT_NUM L00
f85: b2 ... PRINT ": "
f88: f9 27 03 1e 01 02 CALL_VN c78 (L00,#02)
f8e: bb NEW_LINE
f8f: 8c ff bc JUMP f4c
f92: b0 RTRUE
Routine f94, 2 locals
f95: e0 17 07 a1 00 01 02 CALL_VS 1e84 (#00,#01) -> L01
f9c: 49 02 80 00 AND L01,#80 -> -(SP)
fa0: a0 00 cb JZ (SP)+ [TRUE] fac
fa3: 0d 01 01 STORE L00,#01
fa6: 8d 0c e9 PRINT_PADDR S145
fa9: 8c 00 08 JUMP fb2
fac: 0d 01 00 STORE L00,#00
faf: 8d 0c f8 PRINT_PADDR S146
fb2: 8d 0d 08 PRINT_PADDR S147
fb5: 90 01 80 79 JZ #01 [TRUE] 1030
fb9: 8d 0d 44 PRINT_PADDR S148
fbc: b2 ... PRINT "TimedKey> "
fc7: 88 06 29 02 CALL_1S 18a4 -> L01
fcb: 41 02 2e 43 JE L01,#2e [FALSE] fd0
fcf: b0 RTRUE
fd0: bb NEW_LINE
fd1: 0d 12 00 STORE G02,#00
fd4: cd 4f 11 ff a3 STORE G01,#ffa3
fd9: f6 53 01 0a 04 0d 02 READ_CHAR #01,#0a,1034 -> L01
fe0: bb NEW_LINE
fe1: c1 8f 11 ff a3 60 JE G01,#ffa3 [FALSE] 1005
fe7: 8d 0d 5b PRINT_PADDR S149
fea: a0 01 4e JZ L00 [FALSE] ff9
fed: 8d 0d 89 PRINT_PADDR S150
ff0: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
ff6: 8c 00 0b JUMP 1002
ff9: 8d 0d 92 PRINT_PADDR S151
ffc: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1002: 8c 00 29 JUMP 102c
1005: a0 11 5d JZ G01 [FALSE] 1023
1008: 8d 0d 9b PRINT_PADDR S152
100b: a0 01 4e JZ L00 [FALSE] 101a
100e: 8d 0d a8 PRINT_PADDR S153
1011: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1017: 8c 00 08 JUMP 1020
101a: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
1020: 8c 00 0b JUMP 102c
1023: 8d 0d b8 PRINT_PADDR S154
1026: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
102c: bb NEW_LINE
102d: 8c ff 87 JUMP fb5
1030: b0 RTRUE
Routine 1034, 1 local
1035: 2d 11 01 STORE G01,L00
1038: b2 ... PRINT "* "
103d: 95 12 INC G02
103f: 41 12 0a 46 JE G02,#0a [FALSE] 1047
1043: bb NEW_LINE
1044: 0d 12 00 STORE G02,#00
1047: b1 RFALSE
Routine 1048, 3 locals
1049: e0 17 07 a1 00 01 03 CALL_VS 1e84 (#00,#01) -> L02
1050: 49 03 80 00 AND L02,#80 -> -(SP)
1054: a0 00 cb JZ (SP)+ [TRUE] 1060
1057: 0d 01 01 STORE L00,#01
105a: 8d 0d c5 PRINT_PADDR S155
105d: 8c 00 08 JUMP 1066
1060: 0d 01 00 STORE L00,#00
1063: 8d 0d d4 PRINT_PADDR S156
1066: 8d 0d e4 PRINT_PADDR S157
1069: 8d 0e 17 PRINT_PADDR S158
106c: 8d 0e 40 PRINT_PADDR S159
106f: b2 ... PRINT "TimedString> "
107c: 88 06 29 03 CALL_1S 18a4 -> L02
1080: 41 03 2e 43 JE L02,#2e [FALSE] 1085
1084: b0 RTRUE
1085: bb NEW_LINE
1086: b2 ... PRINT "Beginning test...
"
1099: cd 4f 11 ff a3 STORE G01,#ffa3
109e: 0d 12 00 STORE G02,#00
10a1: 90 01 80 9e JZ #01 [TRUE] 1141
10a5: b2 ... PRINT "TimedString> "
10b2: d5 1f 00 50 03 00 SUB #0050,#03 -> -(SP)
10b8: f9 06 07 b2 05 c2 00 00 CALL_VN 1ec8 (#05c2,#00,(SP)+)
10c0: f9 05 07 b2 05 c2 01 00 CALL_VN 1ec8 (#05c2,#01,#00)
10c8: cd 4f 02 05 c2 STORE L01,#05c2
10cd: 0d 03 00 STORE L02,#00
10d0: e4 94 02 00 0a 04 67 03 READ L01,#00,#0a,119c -> L02
10d8: bb NEW_LINE
10d9: e0 07 07 a1 05 c2 01 00 CALL_VS 1e84 (#05c2,#01) -> -(SP)
10e1: a0 00 48 JZ (SP)+ [FALSE] 10ea
10e4: 8d 0e 57 PRINT_PADDR S160
10e7: 8c 00 3b JUMP 1123
10ea: b2 ... PRINT "You just typed ""
10f7: 0d 03 00 STORE L02,#00
10fa: e0 07 07 a1 05 c2 01 00 CALL_VS 1e84 (#05c2,#01) -> -(SP)
1102: 62 03 00 58 JL L02,(SP)+ [FALSE] 111c
1106: 34 02 03 00 ADD #02,L02 -> -(SP)
110a: e0 0b 07 a1 05 c2 00 00 CALL_VS 1e84 (#05c2,(SP)+) -> -(SP)
1112: da 2f 07 d0 00 CALL_2N 1f40 ((SP)+)
1117: 95 03 INC L02
1119: 8c ff e0 JUMP 10fa
111c: b2 ... PRINT "".
"
1123: e0 07 07 a1 05 c2 01 00 CALL_VS 1e84 (#05c2,#01) -> -(SP)
112b: 41 00 01 51 JE (SP)+,#01 [FALSE] 113e
112f: e0 07 07 a1 05 c2 02 00 CALL_VS 1e84 (#05c2,#02) -> -(SP)
1137: 41 00 2e 45 JE (SP)+,#2e [FALSE] 113e
113b: 8c 00 05 JUMP 1141
113e: 8c ff 62 JUMP 10a1
1141: b2 ... PRINT "Test terminated.
"
1150: c1 8f 11 ff a3 60 JE G01,#ffa3 [FALSE] 1174
1156: 8d 0e 63 PRINT_PADDR S161
1159: a0 01 4e JZ L00 [FALSE] 1168
115c: 8d 0e 91 PRINT_PADDR S162
115f: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
1165: 8c 00 0b JUMP 1171
1168: 8d 0e 9a PRINT_PADDR S163
116b: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1171: 8c 00 29 JUMP 119b
1174: a0 11 5d JZ G01 [FALSE] 1192
1177: 8d 0e a3 PRINT_PADDR S164
117a: a0 01 4e JZ L00 [FALSE] 1189
117d: 8d 0e b0 PRINT_PADDR S165
1180: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1186: 8c 00 08 JUMP 118f
1189: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
118f: 8c 00 0b JUMP 119b
1192: 8d 0e c0 PRINT_PADDR S166
1195: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
119b: b0 RTRUE
Routine 119c, 1 local
119d: 2d 11 01 STORE G01,L00
11a0: 95 12 INC G02
11a2: 41 12 03 48 JE G02,#03 [FALSE] 11ac
11a6: 0d 12 00 STORE G02,#00
11a9: 8d 0e cd PRINT_PADDR S167
11ac: b1 RFALSE
Routine 11b0, 2 locals
11b1: 8d 0e d7 PRINT_PADDR S168
11b4: 8d 0f 08 PRINT_PADDR S169
11b7: 8d 0f 2d PRINT_PADDR S170
11ba: b2 ... PRINT "Preload> Given"
11c9: d5 1f 00 50 03 00 SUB #0050,#03 -> -(SP)
11cf: f9 06 07 b2 05 c2 00 00 CALL_VN 1ec8 (#05c2,#00,(SP)+)
11d7: f9 05 07 b2 05 c2 01 05 CALL_VN 1ec8 (#05c2,#01,#05)
11df: f9 05 07 b2 05 c2 02 47 CALL_VN 1ec8 (#05c2,#02,#47)
11e7: f9 05 07 b2 05 c2 03 69 CALL_VN 1ec8 (#05c2,#03,#69)
11ef: f9 05 07 b2 05 c2 04 76 CALL_VN 1ec8 (#05c2,#04,#76)
11f7: f9 05 07 b2 05 c2 05 65 CALL_VN 1ec8 (#05c2,#05,#65)
11ff: f9 05 07 b2 05 c2 06 6e CALL_VN 1ec8 (#05c2,#06,#6e)
1207: cd 4f 02 05 c2 STORE L01,#05c2
120c: 0d 01 00 STORE L00,#00
120f: e4 bf 02 01 READ L01 -> L00
1213: e0 07 07 a1 05 c2 01 00 CALL_VS 1e84 (#05c2,#01) -> -(SP)
121b: a0 00 5c JZ (SP)+ [FALSE] 1238
121e: b2 ... PRINT "You just typed a blank line.
"
1235: 8c 00 39 JUMP 126f
1238: b2 ... PRINT "You just typed ""
1245: 0d 01 00 STORE L00,#00
1248: e0 07 07 a1 05 c2 01 00 CALL_VS 1e84 (#05c2,#01) -> -(SP)
1250: 62 01 00 58 JL L00,(SP)+ [FALSE] 126a
1254: 34 02 01 00 ADD #02,L00 -> -(SP)
1258: e0 0b 07 a1 05 c2 00 00 CALL_VS 1e84 (#05c2,(SP)+) -> -(SP)
1260: da 2f 07 d0 00 CALL_2N 1f40 ((SP)+)
1265: 95 01 INC L00
1267: 8c ff e0 JUMP 1248
126a: b2 ... PRINT "".
"
126f: b0 RTRUE
Routine 1270, 4 locals
1271: 8d 0f 49 PRINT_PADDR S171
1274: e0 17 07 a1 10 01 02 CALL_VS 1e84 (#10,#01) -> L01
127b: 49 02 10 00 AND L01,#10 -> -(SP)
127f: a0 00 c8 JZ (SP)+ [TRUE] 1288
1282: 0d 01 01 STORE L00,#01
1285: 8c 00 05 JUMP 128b
1288: 0d 01 00 STORE L00,#00
128b: a0 01 c8 JZ L00 [TRUE] 1294
128e: 8d 0f 58 PRINT_PADDR S172
1291: 8c 00 05 JUMP 1297
1294: 8d 0f 66 PRINT_PADDR S173
1297: 0d 03 01 STORE L02,#01
129a: 0d 04 00 STORE L03,#00
129d: b2 ... PRINT "Simulating first move...
"
12b2: be 09 ff 02 SAVE_UNDO -> L01
12b6: 2d ff 02 STORE Gef,L01
12b9: c1 8f ff ff ff 50 JE Gef,#ffff [FALSE] 12cd
12bf: 8d 0f 75 PRINT_PADDR S174
12c2: 0d 03 00 STORE L02,#00
12c5: cd 4f 04 ff ff STORE L03,#ffff
12ca: 8c 00 71 JUMP 133c
12cd: 41 ff 00 58 JE Gef,#00 [FALSE] 12e7
12d1: b2 ... PRINT "Save failed.
"
12de: 0d 03 00 STORE L02,#00
12e1: 0d 04 00 STORE L03,#00
12e4: 8c 00 57 JUMP 133c
12e7: 41 ff 01 54 JE Gef,#01 [FALSE] 12fd
12eb: b2 ... PRINT "Save succeeded.
"
12fa: 8c 00 41 JUMP 133c
12fd: 41 ff 02 4e JE Gef,#02 [FALSE] 130d
1301: 8d 0f 82 PRINT_PADDR S175
1304: 0d 03 00 STORE L02,#00
1307: 0d 04 02 STORE L03,#02
130a: 8c 00 31 JUMP 133c
130d: b2 ... PRINT "Save gave unknown result code
"
1324: e6 bf 02 PRINT_NUM L01
1327: b2 ... PRINT " -- ERROR.
"
1336: 0d 03 00 STORE L02,#00
1339: 0d 04 00 STORE L03,#00
133c: a0 03 81 1d JZ L02 [TRUE] 145b
1340: b2 ... PRINT "
Simulating second move...
"
1357: be 09 ff 02 SAVE_UNDO -> L01
135b: 2d ff 02 STORE Gef,L01
135e: c1 8f ff ff ff 50 JE Gef,#ffff [FALSE] 1372
1364: 8d 0f 89 PRINT_PADDR S176
1367: 0d 03 00 STORE L02,#00
136a: cd 4f 04 ff ff STORE L03,#ffff
136f: 8c 00 eb JUMP 145b
1372: 41 ff 00 58 JE Gef,#00 [FALSE] 138c
1376: b2 ... PRINT "Save failed.
"
1383: 0d 03 00 STORE L02,#00
1386: 0d 04 00 STORE L03,#00
1389: 8c 00 d1 JUMP 145b
138c: 41 ff 01 54 JE Gef,#01 [FALSE] 13a2
1390: b2 ... PRINT "Save succeeded.
"
139f: 8c 00 bb JUMP 145b
13a2: 41 ff 02 00 87 JE Gef,#02 [FALSE] 142c
13a7: 8d 0f 96 PRINT_PADDR S177
13aa: 8d 0f 9d PRINT_PADDR S178
13ad: b2 ... PRINT "MultipleUndo> "
13bc: 88 06 29 02 CALL_1S 18a4 -> L01
13c0: bb NEW_LINE
13c1: 41 02 2e 4b JE L01,#2e [FALSE] 13ce
13c5: 0d 03 00 STORE L02,#00
13c8: 0d 04 01 STORE L03,#01
13cb: 8c 00 8f JUMP 145b
13ce: b2 ... PRINT "
Second undo...
"
13df: be 0a ff 02 RESTORE_UNDO -> L01
13e3: 2d ff 02 STORE Gef,L01
13e6: 41 ff 00 52 JE Gef,#00 [FALSE] 13fa
13ea: b2 ... PRINT "Undo failed.
"
13f7: 8c 00 2b JUMP 1423
13fa: b2 ... PRINT "Undo gave unknown result code
"
1411: e6 bf 02 PRINT_NUM L01
1414: b2 ... PRINT " -- ERROR.
"
1423: 0d 04 00 STORE L03,#00
1426: 0d 03 00 STORE L02,#00
1429: 8c 00 31 JUMP 145b
142c: b2 ... PRINT "Save gave unknown result code
"
1443: e6 bf 02 PRINT_NUM L01
1446: b2 ... PRINT " -- ERROR.
"
1455: 0d 03 00 STORE L02,#00
1458: 0d 04 00 STORE L03,#00
145b: a0 03 80 85 JZ L02 [TRUE] 14e2
145f: 8d 0f d2 PRINT_PADDR S179
1462: b2 ... PRINT "SingleUndo> "
146f: 88 06 29 02 CALL_1S 18a4 -> L01
1473: bb NEW_LINE
1474: 41 02 2e 4d JE L01,#2e [FALSE] 1483
1478: 0d 03 00 STORE L02,#00
147b: cd 4f 04 ff fe STORE L03,#fffe
1480: 8c 00 61 JUMP 14e2
1483: b2 ... PRINT "
First undo...
"
1492: be 0a ff 02 RESTORE_UNDO -> L01
1496: 2d ff 02 STORE Gef,L01
1499: 41 ff 00 58 JE Gef,#00 [FALSE] 14b3
149d: b2 ... PRINT "Undo failed.
"
14aa: 0d 03 00 STORE L02,#00
14ad: 0d 04 00 STORE L03,#00
14b0: 8c 00 31 JUMP 14e2
14b3: b2 ... PRINT "Undo gave unknown result code
"
14ca: e6 bf 02 PRINT_NUM L01
14cd: b2 ... PRINT " -- ERROR.
"
14dc: 0d 03 00 STORE L02,#00
14df: 0d 04 00 STORE L03,#00
14e2: bb NEW_LINE
14e3: 2d ff 04 STORE Gef,L03
14e6: c1 8f ff ff fe 54 JE Gef,#fffe [FALSE] 14fe
14ec: b2 ... PRINT "Test cancelled.
"
14fb: 8c 00 7d JUMP 1579
14fe: c1 8f ff ff ff 5d JE Gef,#ffff [FALSE] 151f
1504: a0 01 ce JZ L00 [TRUE] 1513
1507: 8d 0f de PRINT_PADDR S180
150a: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1510: 8c 00 0b JUMP 151c
1513: 8d 0f f8 PRINT_PADDR S181
1516: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
151c: 8c 00 5c JUMP 1579
151f: 41 ff 00 5d JE Gef,#00 [FALSE] 153e
1523: a0 01 ce JZ L00 [TRUE] 1532
1526: 8d 10 0c PRINT_PADDR S182
1529: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
152f: 8c 00 0b JUMP 153b
1532: 8d 10 18 PRINT_PADDR S183
1535: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
153b: 8c 00 3d JUMP 1579
153e: 41 ff 01 5d JE Gef,#01 [FALSE] 155d
1542: a0 01 ce JZ L00 [TRUE] 1551
1545: 8d 10 34 PRINT_PADDR S184
1548: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
154e: 8c 00 0b JUMP 155a
1551: 8d 10 3f PRINT_PADDR S185
1554: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
155a: 8c 00 1e JUMP 1579
155d: 41 ff 02 5a JE Gef,#02 [FALSE] 1579
1561: a0 01 ce JZ L00 [TRUE] 1570
1564: 8d 10 4d PRINT_PADDR S186
1567: da 0f 07 dd 08 2f CALL_2N 1f74 (S001)
156d: 8c 00 0b JUMP 1579
1570: 8d 10 5f PRINT_PADDR S187
1573: da 0f 07 dd 08 3b CALL_2N 1f74 (S002)
1579: b0 RTRUE
Routine 157c, 1 local
157d: 8d 10 74 PRINT_PADDR S188
1580: 8d 10 a4 PRINT_PADDR S189
1583: b2 ... PRINT "ClosingText> "
1590: 88 06 29 01 CALL_1S 18a4 -> L00
1594: 41 01 2e 52 JE L00,#2e [FALSE] 15a8
1598: b2 ... PRINT "
Test aborted.
"
15a7: b0 RTRUE
15a8: 8d 10 cc PRINT_PADDR S190
15ab: ba QUIT
Routine 15ac, 0 locals
15ad: bb NEW_LINE
15ae: 8f 06 2b CALL_1N 18ac
15b1: bb NEW_LINE
15b2: 8f 05 70 CALL_1N 15c0
15b5: b2 ... PRINT "Goodbye.
"
15be: ba QUIT
Routine 15c0, 7 locals
15c1: 02 00 00 c6 JL #00,#00 [TRUE] 15c9
15c5: 02 00 1d d2 JL #00,#1d [TRUE] 15d9
15c9: fa 15 5f 06 55 1d 00 1c 03 02
CALL_VN2 1954 (#1d,#00,#1c,#03,#02)
15d3: e8 7f 00 PUSH #00
15d6: 8c 00 08 JUMP 15df
15d9: cf 1f 05 88 00 00 LOADW #0588,#00 -> -(SP)
15df: 57 00 02 03 DIV (SP)+,#02 -> L02
15e3: 0d 01 01 STORE L00,#01
15e6: 90 01 82 b9 JZ #01 [TRUE] 18a1
15ea: a0 01 80 74 JZ L00 [TRUE] 1660
15ee: 8d 11 0b PRINT_PADDR S205
15f1: b2 ... PRINT " . (period): Exit TerpEtude
"
160c: 0d 04 00 STORE L03,#00
160f: 62 04 03 00 4b JL L03,L02 [FALSE] 165d
1614: b2 ... PRINT " "
1617: 54 04 01 00 ADD L03,#01 -> -(SP)
161b: e6 bf 00 PRINT_NUM (SP)+
161e: b2 ... PRINT ": "
1621: 56 04 02 00 MUL L03,#02 -> -(SP)
1625: 54 00 01 00 ADD (SP)+,#01 -> -(SP)
1629: e9 7f fe PULL Gee
162c: e8 bf fe PUSH Gee
162f: 42 fe 00 c6 JL Gee,#00 [TRUE] 1637
1633: 42 fe 1d d5 JL Gee,#1d [TRUE] 164a
1637: fa 19 5f 06 55 1d fe 1c 03 02
CALL_VN2 1954 (#1d,Gee,#1c,#03,#02)
1641: a0 00 42 JZ (SP)+ [FALSE] 1644
1644: e8 7f 00 PUSH #00
1647: 8c 00 08 JUMP 1650
164a: cf 2f 05 88 00 00 LOADW #0588,(SP)+ -> -(SP)
1650: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
1655: b2 ... PRINT "
"
1658: 95 04 INC L03
165a: 8c ff b4 JUMP 160f
165d: 0d 01 00 STORE L00,#00
1660: b2 ... PRINT "
> "
1667: 02 00 00 c6 JL #00,#00 [TRUE] 166f
166b: 02 00 50 cf JL #00,#50 [TRUE] 167c
166f: fa 15 5f 06 55 1e 00 4f 00 03
CALL_VN2 1954 (#1e,#00,#4f,#00,#03)
1679: 8c 00 08 JUMP 1682
167c: e2 17 05 c2 00 4d STOREB #05c2,#00,#4d
1682: 02 01 00 c6 JL #01,#00 [TRUE] 168a
1686: 02 01 50 cf JL #01,#50 [TRUE] 1697
168a: fa 15 5f 06 55 1e 01 4f 00 03
CALL_VN2 1954 (#1e,#01,#4f,#00,#03)
1694: 8c 00 08 JUMP 169d
1697: e2 17 05 c2 01 00 STOREB #05c2,#01,#00
169d: cd 4f 02 05 c2 STORE L01,#05c2
16a2: 0d 04 00 STORE L03,#00
16a5: e4 bf 02 04 READ L01 -> L03
16a9: bb NEW_LINE
16aa: 02 01 00 c6 JL #01,#00 [TRUE] 16b2
16ae: 02 01 50 cf JL #01,#50 [TRUE] 16bf
16b2: fa 15 5f 06 55 1c 01 4f 00 03
CALL_VN2 1954 (#1c,#01,#4f,#00,#03)
16bc: 8c 00 08 JUMP 16c5
16bf: d0 1f 05 c2 01 06 LOADB #05c2,#01 -> L05
16c5: 0d 05 00 STORE L04,#00
16c8: 62 05 06 76 JL L04,L05 [FALSE] 1700
16cc: 34 02 05 00 ADD #02,L04 -> -(SP)
16d0: e9 7f fe PULL Gee
16d3: e8 bf fe PUSH Gee
16d6: 42 fe 00 c6 JL Gee,#00 [TRUE] 16de
16da: 42 fe 50 d5 JL Gee,#50 [TRUE] 16f1
16de: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
16e8: a0 00 42 JZ (SP)+ [FALSE] 16eb
16eb: e8 7f 00 PUSH #00
16ee: 8c 00 08 JUMP 16f7
16f1: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
16f7: 41 00 20 47 JE (SP)+,#20 [FALSE] 1700
16fb: 95 05 INC L04
16fd: 8c ff ca JUMP 16c8
1700: 62 05 06 74 JL L04,L05 [FALSE] 1736
1704: 34 02 05 00 ADD #02,L04 -> -(SP)
1708: e9 7f fe PULL Gee
170b: e8 bf fe PUSH Gee
170e: 42 fe 00 c6 JL Gee,#00 [TRUE] 1716
1712: 42 fe 50 d5 JL Gee,#50 [TRUE] 1729
1716: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
1720: a0 00 42 JZ (SP)+ [FALSE] 1723
1723: e8 7f 00 PUSH #00
1726: 8c 00 08 JUMP 172f
1729: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
172f: 41 00 2e 45 JE (SP)+,#2e [FALSE] 1736
1733: 8c 01 6d JUMP 18a1
1736: 61 05 06 80 60 JE L04,L05 [TRUE] 1799
173b: 34 02 05 00 ADD #02,L04 -> -(SP)
173f: e9 7f fe PULL Gee
1742: e8 bf fe PUSH Gee
1745: 42 fe 00 c6 JL Gee,#00 [TRUE] 174d
1749: 42 fe 50 d5 JL Gee,#50 [TRUE] 1760
174d: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
1757: a0 00 42 JZ (SP)+ [FALSE] 175a
175a: e8 7f 00 PUSH #00
175d: 8c 00 08 JUMP 1766
1760: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
1766: 42 00 30 f1 JL (SP)+,#30 [TRUE] 1799
176a: 34 02 05 00 ADD #02,L04 -> -(SP)
176e: e9 7f fe PULL Gee
1771: e8 bf fe PUSH Gee
1774: 42 fe 00 c6 JL Gee,#00 [TRUE] 177c
1778: 42 fe 50 d5 JL Gee,#50 [TRUE] 178f
177c: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
1786: a0 00 42 JZ (SP)+ [FALSE] 1789
1789: e8 7f 00 PUSH #00
178c: 8c 00 08 JUMP 1795
178f: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
1795: 43 00 39 48 JG (SP)+,#39 [FALSE] 179f
1799: 0d 01 01 STORE L00,#01
179c: 8c fe 49 JUMP 15e6
179f: 0d 07 00 STORE L06,#00
17a2: 62 05 06 00 9e JL L04,L05 [FALSE] 1843
17a7: 34 02 05 00 ADD #02,L04 -> -(SP)
17ab: e9 7f fe PULL Gee
17ae: e8 bf fe PUSH Gee
17b1: 42 fe 00 c6 JL Gee,#00 [TRUE] 17b9
17b5: 42 fe 50 d5 JL Gee,#50 [TRUE] 17cc
17b9: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
17c3: a0 00 42 JZ (SP)+ [FALSE] 17c6
17c6: e8 7f 00 PUSH #00
17c9: 8c 00 08 JUMP 17d2
17cc: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
17d2: 42 00 30 80 6e JL (SP)+,#30 [TRUE] 1843
17d7: 34 02 05 00 ADD #02,L04 -> -(SP)
17db: e9 7f fe PULL Gee
17de: e8 bf fe PUSH Gee
17e1: 42 fe 00 c6 JL Gee,#00 [TRUE] 17e9
17e5: 42 fe 50 d5 JL Gee,#50 [TRUE] 17fc
17e9: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
17f3: a0 00 42 JZ (SP)+ [FALSE] 17f6
17f6: e8 7f 00 PUSH #00
17f9: 8c 00 08 JUMP 1802
17fc: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
1802: 43 00 39 80 3e JG (SP)+,#39 [TRUE] 1843
1807: 34 02 05 00 ADD #02,L04 -> -(SP)
180b: e9 7f fe PULL Gee
180e: e8 bf fe PUSH Gee
1811: 42 fe 00 c6 JL Gee,#00 [TRUE] 1819
1815: 42 fe 50 d5 JL Gee,#50 [TRUE] 182c
1819: fa 19 5f 06 55 1c fe 4f 00 03
CALL_VN2 1954 (#1c,Gee,#4f,#00,#03)
1823: a0 00 42 JZ (SP)+ [FALSE] 1826
1826: e8 7f 00 PUSH #00
1829: 8c 00 08 JUMP 1832
182c: d0 2f 05 c2 00 00 LOADB #05c2,(SP)+ -> -(SP)
1832: 55 00 30 00 SUB (SP)+,#30 -> -(SP)
1836: 56 07 0a 00 MUL L06,#0a -> -(SP)
183a: 74 00 00 07 ADD (SP)+,(SP)+ -> L06
183e: 95 05 INC L04
1840: 8c ff 61 JUMP 17a2
1843: 42 07 01 c6 JL L06,#01 [TRUE] 184b
1847: 63 07 03 62 JG L06,L02 [FALSE] 186b
184b: b2 ... PRINT "Please enter a value from 1 to
"
1862: e6 bf 03 PRINT_NUM L02
1865: 8d 11 15 PRINT_PADDR S206
1868: 8c fd 7d JUMP 15e6
186b: 56 07 02 00 MUL L06,#02 -> -(SP)
186f: e9 7f fe PULL Gee
1872: e8 bf fe PUSH Gee
1875: 42 fe 00 c6 JL Gee,#00 [TRUE] 187d
1879: 42 fe 1d d2 JL Gee,#1d [TRUE] 188d
187d: fa 19 5f 06 55 1d fe 1c 03 02
CALL_VN2 1954 (#1d,Gee,#1c,#03,#02)
1887: a0 00 42 JZ (SP)+ [FALSE] 188a
188a: 8c 00 08 JUMP 1893
188d: cf 2f 05 88 00 04 LOADW #0588,(SP)+ -> L03
1893: a0 04 48 JZ L03 [FALSE] 189c
1896: 8d 11 23 PRINT_PADDR S207
1899: 8c fd 4c JUMP 15e6
189c: af 04 CALL_1N L03
189e: 8c fd 47 JUMP 15e6
18a1: b0 RTRUE
Routine 18a4, 1 local
18a5: f6 7f 01 01 READ_CHAR #01 -> L00
18a9: ab 01 RET L00
Routine 18ac, 0 locals
18ad: 8d 11 2a PRINT_PADDR S208
18b0: 8d 11 33 PRINT_PADDR S209
18b3: b2 ... PRINT "Release "
18ba: e0 17 07 a9 00 01 00 CALL_VS 1ea4 (#00,#01) -> -(SP)
18c1: c9 8f 00 03 ff 00 AND (SP)+,#03ff -> -(SP)
18c7: e6 bf 00 PRINT_NUM (SP)+
18ca: b2 ... PRINT " / built with Inform v"
18db: 10 00 3c ff LOADB #00,#3c -> Gef
18df: e5 bf ff PRINT_CHAR Gef
18e2: 10 00 3d ff LOADB #00,#3d -> Gef
18e6: e5 bf ff PRINT_CHAR Gef
18e9: 10 00 3e ff LOADB #00,#3e -> Gef
18ed: e5 bf ff PRINT_CHAR Gef
18f0: 10 00 3f ff LOADB #00,#3f -> Gef
18f4: e5 bf ff PRINT_CHAR Gef
18f7: bb NEW_LINE
18f8: 8d 11 3c PRINT_PADDR S210
18fb: bb NEW_LINE
18fc: 8d 11 48 PRINT_PADDR S211
18ff: 8d 11 67 PRINT_PADDR S212
1902: b0 RTRUE
Routine 1904, 0 locals
1905: 8d 11 9d PRINT_PADDR S213
1908: 8d 11 ab PRINT_PADDR S214
190b: 8d 11 c0 PRINT_PADDR S215
190e: 8d 11 d0 PRINT_PADDR S216
1911: 8d 11 e5 PRINT_PADDR S217
1914: b2 ... PRINT "
Upcoming Test Features:
"
192d: 8d 11 fd PRINT_PADDR S218
1930: b2 ... PRINT "
Credits:
"
193d: b2 ... PRINT "Title: <NAME>
"
194e: 8d 12 08 PRINT_PADDR S219
1951: b0 RTRUE
Routine 1954, 6 locals
1955: b2 ... PRINT "
[** Programming error: "
196e: 42 01 00 45 JL L00,#00 [FALSE] 1975
1972: 8c 03 d2 JUMP 1d45
1975: 41 01 01 4e JE L00,#01 [FALSE] 1985
1979: b2 ... PRINT "class "
197e: aa 02 PRINT_OBJ L01
1980: 8d 12 13 PRINT_PADDR S220
1983: bb NEW_LINE
1984: b0 RTRUE
1985: 41 01 20 4f JE L00,#20 [FALSE] 1996
1989: 8d 12 1d PRINT_PADDR S221
198c: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1991: 8d 12 24 PRINT_PADDR S222
1994: bb NEW_LINE
1995: b0 RTRUE
1996: 41 01 21 5b JE L00,#21 [FALSE] 19b3
199a: b2 ... PRINT "tried to print (char) "
19ab: e6 bf 02 PRINT_NUM L01
19ae: 8d 12 2e PRINT_PADDR S223
19b1: bb NEW_LINE
19b2: b0 RTRUE
19b3: 41 01 22 60 JE L00,#22 [FALSE] 19d5
19b7: 8d 12 3b PRINT_PADDR S224
19ba: b3 ... PRINT_RET "byte address of a string **]"
19d5: 41 01 23 54 JE L00,#23 [FALSE] 19eb
19d9: 8d 12 43 PRINT_PADDR S225
19dc: b3 ... PRINT_RET "string **]"
19eb: 41 01 24 5a JE L00,#24 [FALSE] 1a07
19ef: 8d 12 4b PRINT_PADDR S226
19f2: b3 ... PRINT_RET "object or class **]"
1a07: 42 01 20 03 3b JL L00,#20 [FALSE] 1d45
1a0c: b2 ... PRINT "tried to "
1a13: 42 01 1c 80 d1 JL L00,#1c [TRUE] 1ae7
1a18: c1 97 01 1c 1d 4e JE L00,#1c,#1d [FALSE] 1a2a
1a1e: b2 ... PRINT "read from "
1a27: 8c 00 09 JUMP 1a31
1a2a: b2 ... PRINT "write to "
1a31: c1 97 01 1d 1f 45 JE L00,#1d,#1f [FALSE] 1a3a
1a37: b2 ... PRINT "-"
1a3a: b2 ... PRINT "->"
1a3f: e6 bf 02 PRINT_NUM L01
1a42: b2 ... PRINT " in the"
1a49: 49 04 07 00 AND L03,#07 -> -(SP)
1a4d: e9 7f ff PULL Gef
1a50: c1 97 ff 00 01 48 JE Gef,#00,#01 [FALSE] 1a5c
1a56: 0d 06 00 STORE L05,#00
1a59: 8c 00 30 JUMP 1a8a
1a5c: 41 ff 02 4f JE Gef,#02 [FALSE] 1a6d
1a60: b2 ... PRINT " string"
1a67: 0d 06 01 STORE L05,#01
1a6a: 8c 00 1f JUMP 1a8a
1a6d: 41 ff 03 4d JE Gef,#03 [FALSE] 1a7c
1a71: b2 ... PRINT " table"
1a76: 0d 06 01 STORE L05,#01
1a79: 8c 00 10 JUMP 1a8a
1a7c: 41 ff 04 4c JE Gef,#04 [FALSE] 1a8a
1a80: b2 ... PRINT " buffer"
1a87: 0d 06 02 STORE L05,#02
1a8a: 49 04 10 00 AND L03,#10 -> -(SP)
1a8e: a0 00 cb JZ (SP)+ [TRUE] 1a9a
1a91: b2 ... PRINT " (->)"
1a9a: 49 04 08 00 AND L03,#08 -> -(SP)
1a9e: a0 00 cd JZ (SP)+ [TRUE] 1aac
1aa1: b2 ... PRINT " (-->)"
1aac: b2 ... PRINT " array ""
1ab3: cf 2f 03 00 05 00 LOADW #0300,L04 -> -(SP)
1ab9: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
1abe: b2 ... PRINT "", which has entries "
1acf: e6 bf 06 PRINT_NUM L05
1ad2: b2 ... PRINT " up to "
1ad9: e6 bf 03 PRINT_NUM L02
1adc: b3 ... PRINT_RET " **]"
1ae7: 42 01 18 80 56 JL L00,#18 [TRUE] 1b40
1aec: 43 01 1b 80 51 JG L00,#1b [TRUE] 1b40
1af1: 43 01 19 ca JG L00,#19 [TRUE] 1afd
1af5: b2 ... PRINT "read"
1afa: 8c 00 07 JUMP 1b02
1afd: b2 ... PRINT "write"
1b02: b2 ... PRINT " outside memory using "
1b13: 2d ff 01 STORE Gef,L00
1b16: c1 97 ff 18 1a 51 JE Gef,#18,#1a [FALSE] 1b2b
1b1c: b3 ... PRINT_RET "-> **]"
1b2b: c1 97 ff 19 1b 51 JE Gef,#19,#1b [FALSE] 1b40
1b31: b3 ... PRINT_RET "--> **]"
1b40: 42 01 04 4a JL L00,#04 [FALSE] 1b4c
1b44: b2 ... PRINT "test "
1b49: 8c 00 1d JUMP 1b67
1b4c: 42 01 0c c6 JL L00,#0c [TRUE] 1b54
1b50: 43 01 14 4c JG L00,#14 [FALSE] 1b5e
1b54: b2 ... PRINT "find the "
1b5b: 8c 00 0b JUMP 1b67
1b5e: 42 01 0e 47 JL L00,#0e [FALSE] 1b67
1b62: b2 ... PRINT "use "
1b67: 41 01 14 55 JE L00,#14 [FALSE] 1b7e
1b6b: b3 ... PRINT_RET "divide by zero **]"
1b7e: b2 ... PRINT """
1b81: 2d ff 01 STORE Gef,L00
1b84: 41 ff 02 50 JE Gef,#02 [FALSE] 1b96
1b88: b2 ... PRINT "in" or "notin"
1b93: 8c 01 9c JUMP 1d30
1b96: 41 ff 03 52 JE Gef,#03 [FALSE] 1baa
1b9a: b2 ... PRINT "has" or "hasnt"
1ba7: 8c 01 88 JUMP 1d30
1baa: 41 ff 04 4a JE Gef,#04 [FALSE] 1bb6
1bae: b2 ... PRINT "parent"
1bb3: 8c 01 7c JUMP 1d30
1bb6: 41 ff 05 4a JE Gef,#05 [FALSE] 1bc2
1bba: b2 ... PRINT "eldest"
1bbf: 8c 01 70 JUMP 1d30
1bc2: 41 ff 06 4a JE Gef,#06 [FALSE] 1bce
1bc6: b2 ... PRINT "child"
1bcb: 8c 01 64 JUMP 1d30
1bce: 41 ff 07 4c JE Gef,#07 [FALSE] 1bdc
1bd2: b2 ... PRINT "younger"
1bd9: 8c 01 56 JUMP 1d30
1bdc: 41 ff 08 4c JE Gef,#08 [FALSE] 1bea
1be0: b2 ... PRINT "sibling"
1be7: 8c 01 48 JUMP 1d30
1bea: 41 ff 09 4c JE Gef,#09 [FALSE] 1bf8
1bee: b2 ... PRINT "children"
1bf5: 8c 01 3a JUMP 1d30
1bf8: 41 ff 0a 4c JE Gef,#0a [FALSE] 1c06
1bfc: b2 ... PRINT "youngest"
1c03: 8c 01 2c JUMP 1d30
1c06: 41 ff 0b 4a JE Gef,#0b [FALSE] 1c12
1c0a: b2 ... PRINT "elder"
1c0f: 8c 01 20 JUMP 1d30
1c12: 41 ff 0c 4e JE Gef,#0c [FALSE] 1c22
1c16: b2 ... PRINT "objectloop"
1c1f: 8c 01 10 JUMP 1d30
1c22: 41 ff 0d 5a JE Gef,#0d [FALSE] 1c3e
1c26: b2 ... PRINT "}" at end of "objectloop"
1c3b: 8c 00 f4 JUMP 1d30
1c3e: 41 ff 0e 63 JE Gef,#0e [FALSE] 1c63
1c42: b2 ... PRINT "give" an attribute to "
1c53: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1c58: b3 ... PRINT_RET " **]"
1c63: 41 ff 0f 59 JE Gef,#0f [FALSE] 1c7e
1c67: b2 ... PRINT "remove" "
1c6e: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1c73: b3 ... PRINT_RET " **]"
1c7e: c1 95 ff 10 11 12 00 76 JE Gef,#10,#11,#12 [FALSE] 1cfa
1c86: b2 ... PRINT "move" "
1c8d: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1c92: b2 ... PRINT " to "
1c97: da 2f 07 e3 03 CALL_2N 1f8c (L02)
1c9c: 41 01 12 00 50 JE L00,#12 [FALSE] 1cef
1ca1: b2 ... PRINT ", which would make a loop: "
1cb6: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1cbb: 2d 05 03 STORE L04,L02
1cbe: 61 05 02 48 JE L04,L01 [FALSE] 1cc8
1cc2: 2d 05 02 STORE L04,L01
1cc5: 8c 00 14 JUMP 1cda
1cc8: b2 ... PRINT " in "
1ccd: da 2f 07 e3 05 CALL_2N 1f8c (L04)
1cd2: a3 05 05 GET_PARENT L04 -> L04
1cd5: 61 05 02 3f f0 JE L04,L01 [FALSE] 1cc8
1cda: b2 ... PRINT " in "
1cdf: da 2f 07 e3 05 CALL_2N 1f8c (L04)
1ce4: b3 ... PRINT_RET " **]"
1cef: b3 ... PRINT_RET " **]"
1cfa: 41 ff 13 55 JE Gef,#13 [FALSE] 1d11
1cfe: 8d 12 53 PRINT_PADDR S227
1d01: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1d06: b3 ... PRINT_RET " **]"
1d11: 41 ff 15 4a JE Gef,#15 [FALSE] 1d1d
1d15: b2 ... PRINT ".&"
1d1a: 8c 00 15 JUMP 1d30
1d1d: 41 ff 16 4a JE Gef,#16 [FALSE] 1d29
1d21: b2 ... PRINT ".#"
1d26: 8c 00 09 JUMP 1d30
1d29: 41 ff 17 45 JE Gef,#17 [FALSE] 1d30
1d2d: b2 ... PRINT "."
1d30: b2 ... PRINT "" of "
1d35: da 2f 07 e3 02 CALL_2N 1f8c (L01)
1d3a: b3 ... PRINT_RET " **]"
1d45: 42 02 00 ea JL L01,#00 [TRUE] 1d71
1d49: d5 1f 01 03 ff 00 SUB #0103,#ff -> -(SP)
1d4f: 63 02 00 e0 JG L01,(SP)+ [TRUE] 1d71
1d53: a0 02 cb JZ L01 [TRUE] 1d5f
1d56: 46 02 01 47 JIN L01,"Class" [FALSE] 1d5f
1d5a: b2 ... PRINT "class "
1d5f: a0 02 c7 JZ L01 [TRUE] 1d67
1d62: aa 02 PRINT_OBJ L01
1d64: 8c 00 09 JUMP 1d6e
1d67: b2 ... PRINT "nothing"
1d6e: b2 ... PRINT " "
1d71: b2 ... PRINT "(object number "
1d7e: e6 bf 02 PRINT_NUM L01
1d81: b2 ... PRINT ") "
1d84: 42 03 00 5b JL L02,#00 [FALSE] 1da1
1d88: b2 ... PRINT "is not of class "
1d95: 35 00 03 00 SUB #00,L02 -> -(SP)
1d99: da 2f 07 e3 00 CALL_2N 1f8c ((SP)+)
1d9e: 8c 00 55 JUMP 1df4
1da1: a0 04 d8 JZ L03 [TRUE] 1dba
1da4: b2 ... PRINT "has a property "
1daf: da 2f 07 fa 03 CALL_2N 1fe8 (L02)
1db4: 8d 12 5f PRINT_PADDR S228
1db7: 8c 00 3c JUMP 1df4
1dba: b2 ... PRINT " has no property "
1dc7: da 2f 07 fa 03 CALL_2N 1fe8 (L02)
1dcc: cd 4f 05 02 10 STORE L04,#0210
1dd1: 4f 05 00 04 LOADW L04,#00 -> L03
1dd5: 42 03 00 c6 JL L02,#00 [TRUE] 1ddd
1dd9: 62 03 04 d9 JL L02,L03 [TRUE] 1df4
1ddd: b2 ... PRINT " (and nor has any other
object)"
1df4: b2 ... PRINT " to "
1df9: da 2f 07 dd 01 CALL_2N 1f74 (L00)
1dfe: b2 ... PRINT " **]
"
1e09: b0 RTRUE
Routine 1e0c, 2 locals
1e0d: c1 93 01 00 ff ff c0 JE L00,#00,#ffff [TRUE] RFALSE
1e14: 2d 02 01 STORE L01,L00
1e17: 0f 1a 00 00 LOADW #1a,#00 -> -(SP)
1e1b: e0 2b 07 95 02 00 00 CALL_VS 1e54 (L01,(SP)+) -> -(SP)
1e22: 42 00 00 40 JL (SP)+,#00 [FALSE] RFALSE
1e26: 42 01 01 cc JL L00,#01 [TRUE] 1e34
1e2a: d5 1f 01 03 ff 00 SUB #0103,#ff -> -(SP)
1e30: 63 01 00 41 JG L00,(SP)+ [FALSE] RTRUE
1e34: e0 23 07 95 01 08 2f 00 CALL_VS 1e54 (L00,S001) -> -(SP)
1e3c: 42 00 00 c4 JL (SP)+,#00 [TRUE] 1e42
1e40: 9b 03 RET #03
1e42: e0 23 07 95 01 01 87 00 CALL_VS 1e54 (L00,#0187) -> -(SP)
1e4a: 42 00 00 c4 JL (SP)+,#00 [TRUE] 1e50
1e4e: 9b 02 RET #02
1e50: b1 RFALSE
Routine 1e54, 4 locals
1e55: 61 01 02 43 JE L00,L01 [FALSE] 1e5a
1e59: b1 RFALSE
1e5a: 42 01 00 47 JL L00,#00 [FALSE] 1e63
1e5e: 42 02 00 c3 JL L01,#00 [TRUE] 1e63
1e62: b0 RTRUE
1e63: 42 01 00 c9 JL L00,#00 [TRUE] 1e6e
1e67: 42 02 00 45 JL L01,#00 [FALSE] 1e6e
1e6b: 8b ff ff RET #ffff
1e6e: c9 8f 01 7f ff 03 AND L00,#7fff -> L02
1e74: c9 8f 02 7f ff 04 AND L01,#7fff -> L03
1e7a: 63 03 04 43 JG L02,L03 [FALSE] 1e7f
1e7e: b0 RTRUE
1e7f: 8b ff ff RET #ffff
Routine 1e84, 4 locals
1e85: 74 01 02 03 ADD L00,L01 -> L02
1e89: e0 23 07 95 03 06 1c 00 CALL_VS 1e54 (L02," b js/zzik ") ->
-(SP)
1e91: 42 00 00 c9 JL (SP)+,#00 [TRUE] 1e9c
1e95: d9 1f 06 55 18 00 CALL_2S 1954 (#18) -> -(SP)
1e9b: b8 RET_POPPED
1e9c: 70 01 02 04 LOADB L00,L01 -> L03
1ea0: ab 04 RET L03
Routine 1ea4, 4 locals
1ea5: 36 02 02 00 MUL #02,L01 -> -(SP)
1ea9: 74 01 00 03 ADD L00,(SP)+ -> L02
1ead: e0 23 07 95 03 06 1c 00 CALL_VS 1e54 (L02," b js/zzik ") ->
-(SP)
1eb5: 42 00 00 c9 JL (SP)+,#00 [TRUE] 1ec0
1eb9: d9 1f 06 55 19 00 CALL_2S 1954 (#19) -> -(SP)
1ebf: b8 RET_POPPED
1ec0: 6f 01 02 04 LOADW L00,L01 -> L03
1ec4: ab 04 RET L03
Routine 1ec8, 5 locals
1ec9: 74 01 02 04 ADD L00,L01 -> L03
1ecd: e0 23 07 95 04 04 e8 00 CALL_VS 1e54 (L03,#04e8) -> -(SP)
1ed5: 42 00 00 d4 JL (SP)+,#00 [TRUE] 1eeb
1ed9: e0 23 07 95 04 06 13 00 CALL_VS 1e54 (L03,#0613) -> -(SP)
1ee1: 42 00 00 48 JL (SP)+,#00 [FALSE] 1eeb
1ee5: 0d 05 01 STORE L04,#01
1ee8: 8c 00 45 JUMP 1f2e
1eeb: e0 23 07 95 04 01 c0 00 CALL_VS 1e54 (L03,#01c0) -> -(SP)
1ef3: 42 00 00 d4 JL (SP)+,#00 [TRUE] 1f09
1ef7: e0 23 07 95 04 02 06 00 CALL_VS 1e54 (L03,#0206) -> -(SP)
1eff: 42 00 00 48 JL (SP)+,#00 [FALSE] 1f09
1f03: 0d 05 01 STORE L04,#01
1f06: 8c 00 27 JUMP 1f2e
1f09: e0 23 07 95 04 03 08 00 CALL_VS 1e54 (L03,#0308) -> -(SP)
1f11: 42 00 00 d4 JL (SP)+,#00 [TRUE] 1f27
1f15: e0 23 07 95 04 03 08 00 CALL_VS 1e54 (L03,#0308) -> -(SP)
1f1d: 42 00 00 48 JL (SP)+,#00 [FALSE] 1f27
1f21: 0d 05 01 STORE L04,#01
1f24: 8c 00 09 JUMP 1f2e
1f27: 41 04 11 45 JE L03,#11 [FALSE] 1f2e
1f2b: 0d 05 01 STORE L04,#01
1f2e: a0 05 49 JZ L04 [FALSE] 1f38
1f31: d9 1f 06 55 1a 00 CALL_2S 1954 (#1a) -> -(SP)
1f37: b8 RET_POPPED
1f38: e2 ab 01 02 03 STOREB L00,L01,L02
1f3d: b0 RTRUE
Routine 1f40, 2 locals
1f41: c1 95 01 00 09 0b c6 JE L00,#00,#09,#0b [TRUE] 1f4c
1f48: 41 01 0d 45 JE L00,#0d [FALSE] 1f4f
1f4c: 0d 02 01 STORE L01,#01
1f4f: 42 01 20 c9 JL L00,#20 [TRUE] 1f5a
1f53: 43 01 7e c5 JG L00,#7e [TRUE] 1f5a
1f57: 0d 02 01 STORE L01,#01
1f5a: 42 01 9b c9 JL L00,#9b [TRUE] 1f65
1f5e: 43 01 fb c5 JG L00,#fb [TRUE] 1f65
1f62: 0d 02 01 STORE L01,#01
1f65: a0 02 4a JZ L01 [FALSE] 1f70
1f68: e0 1b 06 55 21 01 00 CALL_VS 1954 (#21,L00) -> -(SP)
1f6f: b8 RET_POPPED
1f70: e5 bf 01 PRINT_CHAR L00
1f73: b0 RTRUE
Routine 1f74, 1 local
1f75: d9 2f 07 83 01 00 CALL_2S 1e0c (L00) -> -(SP)
1f7b: 41 00 03 c9 JE (SP)+,#03 [TRUE] 1f86
1f7f: d9 1f 06 55 23 00 CALL_2S 1954 (#23) -> -(SP)
1f85: b8 RET_POPPED
1f86: ad 01 PRINT_PADDR L00
1f88: b0 RTRUE
Routine 1f8c, 1 local
1f8d: e0 2f 08 24 01 00 CALL_VS 2090 (L00) -> -(SP)
1f93: e9 7f ff PULL Gef
1f96: 41 ff 00 4c JE Gef,#00 [FALSE] 1fa4
1f9a: b2 ... PRINT "nothing"
1fa1: 8c 00 44 JUMP 1fe6
1fa4: 41 ff 02 47 JE Gef,#02 [FALSE] 1fad
1fa8: aa 01 PRINT_OBJ L00
1faa: 8c 00 3b JUMP 1fe6
1fad: 41 ff 01 4c JE Gef,#01 [FALSE] 1fbb
1fb1: b2 ... PRINT "class "
1fb6: aa 01 PRINT_OBJ L00
1fb8: 8c 00 2d JUMP 1fe6
1fbb: 41 ff 03 56 JE Gef,#03 [FALSE] 1fd3
1fbf: b2 ... PRINT "(routine at "
1fca: e6 bf 01 PRINT_NUM L00
1fcd: b2 ... PRINT ")"
1fd0: 8c 00 15 JUMP 1fe6
1fd3: 41 ff 04 51 JE Gef,#04 [FALSE] 1fe6
1fd7: b2 ... PRINT "(string at "
1fe0: e6 bf 01 PRINT_NUM L00
1fe3: b2 ... PRINT ")"
1fe6: b0 RTRUE
Routine 1fe8, 5 locals
1fe9: c9 8f 01 c0 00 00 AND L00,#c000 -> -(SP)
1fef: a0 00 80 67 JZ (SP)+ [TRUE] 2058
1ff3: 49 01 ff 00 AND L00,#ff -> -(SP)
1ff7: cf 2f 02 06 00 04 LOADW #0206,(SP)+ -> L03
1ffd: da 2f 07 e3 04 CALL_2N 1f8c (L03)
2002: b2 ... PRINT "::"
2007: c9 8f 01 80 00 00 AND L00,#8000 -> -(SP)
200d: a0 00 51 JZ (SP)+ [FALSE] 201f
2010: c9 8f 01 3f 00 00 AND L00,#3f00 -> -(SP)
2016: d7 8f 00 01 00 01 DIV (SP)+,#0100 -> L00
201c: 8c 00 3b JUMP 2058
201f: c9 8f 01 7f 00 00 AND L00,#7f00 -> -(SP)
2025: d7 8f 00 01 00 01 DIV (SP)+,#0100 -> L00
202b: 51 04 03 ff GET_PROP L03,#03 -> Gef
202f: 2d 05 ff STORE L04,Gef
2032: 4f 05 00 00 LOADW L04,#00 -> -(SP)
2036: a0 00 d7 JZ (SP)+ [TRUE] 204e
2039: 43 01 00 53 JG L00,#00 [FALSE] 204e
203d: 50 05 02 00 LOADB L04,#02 -> -(SP)
2041: 74 05 00 00 ADD L04,(SP)+ -> -(SP)
2045: 54 00 03 05 ADD (SP)+,#03 -> L04
2049: 96 01 DEC L00
204b: 8c ff e6 JUMP 2032
204e: 4f 05 00 00 LOADW L04,#00 -> -(SP)
2052: c9 8f 00 7f ff 01 AND (SP)+,#7fff -> L00
2058: cd 4f 02 02 10 STORE L01,#0210
205d: 4f 02 00 03 LOADW L01,#00 -> L02
2061: 43 01 00 4d JG L00,#00 [FALSE] 2070
2065: 62 01 03 49 JL L00,L02 [FALSE] 2070
2069: 6f 02 01 00 LOADW L01,L00 -> -(SP)
206d: a0 00 56 JZ (SP)+ [FALSE] 2084
2070: b2 ... PRINT "<number "
2079: e6 bf 01 PRINT_NUM L00
207c: b2 ... PRINT ">"
2081: 8c 00 0b JUMP 208d
2084: 6f 02 01 00 LOADW L01,L00 -> -(SP)
2088: da 2f 07 dd 00 CALL_2N 1f74 ((SP)+)
208d: b0 RTRUE
Routine 2090, 1 local
2091: d9 2f 07 83 01 00 CALL_2S 1e0c (L00) -> -(SP)
2097: e9 7f ff PULL Gef
209a: 41 ff 02 44 JE Gef,#02 [FALSE] 20a0
209e: 9b 03 RET #03
20a0: 41 ff 03 44 JE Gef,#03 [FALSE] 20a6
20a4: 9b 04 RET #04
20a6: 41 ff 01 4d JE Gef,#01 [FALSE] 20b5
20aa: 46 01 01 c6 JIN L00,"Class" [TRUE] 20b2
20ae: 43 01 04 c3 JG L00,#04 [TRUE] 20b3
20b2: b0 RTRUE
20b3: 9b 02 RET #02
20b5: b1 RFALSE
Routine 20b8, 2 locals
20b9: b1 RFALSE
[End of code at 20ba]
[Start of text at 20bc]
20bc: S001 "This aspect of your interpreter appears to behave according to
spec.
"
20ec: S002 "This aspect of your interpreter appears to behave WRONG.
"
2118: S003 "Your interpreter does not claim to follow any particular version
of the Z-Spec.
"
2154: S004 "Your interpreter claims to follow revision "
2174: S005 "Interpreter claims that colored text IS available.
"
219c: S006 "Interpreter claims that colored text IS NOT available.
"
21c8: S007 "Interpreter claims that emphasized (bold) text IS available.
"
21f8: S008 "Interpreter claims that emphasized (bold) text IS NOT available.
"
222c: S009 "Interpreter claims that italic (or underlined) text IS available.
"
2260: S010 "Interpreter claims that italic (or underlined) text IS NOT
available.
"
2298: S011 "Interpreter claims that fixed-width text IS available.
"
22c4: S012 "Interpreter claims that fixed-width text IS NOT available.
"
22f4: S013 "Interpreter claims that sound effects ARE available.
"
231c: S014 "Interpreter claims that sound effects ARE NOT available.
"
2348: S015 "Interpreter claims that timed input IS available.
"
2370: S016 "Interpreter claims that timed input IS NOT available.
"
239c: S017 "Interpreter claims that "undo" IS available.
"
23c0: S018 "Interpreter claims that "undo" IS NOT available.
"
23e8: S019 ""
23ec: S020 ""
23f0: S021 "Black"
23f4: S022 "Red"
23f8: S023 "Green"
23fc: S024 "Yellow"
2404: S025 "Blue"
2408: S026 "Magenta"
2410: S027 "Cyan"
2414: S028 "White"
2418: S029 "Interpreter claims that colored text IS available.
"
2440: S030 "Interpreter claims that colored text IS NOT available.
"
246c: S031 "
In the square below, you should see"
2488: S032 "
If it was, in the square below, you would see"
24ac: S033 " vertical stripes of background color (matching the column
headers) and horizontal rows of foreground color (that is, all # marks in a row
the same color.)
"
251c: S034 "Interpreter claims that emphasized (bold) text IS available.
"
254c: S035 "Interpreter claims that emphasized (bold) text IS NOT available.
"
2580: S036 "Interpreter claims that italic (or underlined) text IS available.
"
25b4: S037 "Interpreter claims that italic (or underlined) text IS NOT
available.
"
25ec: S038 "Interpreter claims that fixed-width text IS available.
"
2618: S039 "Interpreter claims that fixed-width text IS NOT available.
"
2648: S040 "Test of italic (or underlined) text."
2664: S041 "Test of fixed-width text (using "font off", which sets a header
bit)."
2698: S042 "Test of fixed-width text (using "@set_text_style 8")."
26c4: S043 "
Now we will try combining styles. The Z-Spec does not require interpreters to
display combined styles, so the lines below may not have all the styles they
say they do.
"
2740: S044 "Test of bold, italic, reverse text."
275c: S045 "
The following are all printed with "font off" (that is, the header bit remains
set, even though "style roman" statements occur.)
"
27bc: S046 "Test of fixed, bold, italic text."
27d8: S047 "Test of fixed, bold, reverse text."
27f4: S048 "Test of fixed, italic, reverse text."
2810: S049 "Test of fixed, bold, italic, reverse text."
2830: S050 "This tests signed multiplication, division, and modulo operations.
All these operations are supposed to be signed. (The Z-Spec 0.2 erroneously
says they are unsigned; this is corrected in 0.99.)
"
28c4: S051 "I am assuming the convention that division always rounds towards
zero (not towards negative infinity), and (A % B) always has the same sign as
A. These conventions seem to be common among existing C/C++ compilers. The
Infocom interpreters also follow these conventions. (But they are not
guaranteed by the C and C++ standards. Those only require that (A/B)*B + (A%B)
== A, for all A and all nonzero B.)
"
2a04: S052 "13 * 5"
2a0c: S053 "13 * -5"
2a18: S054 "-13 * 5"
2a24: S055 "-13 * -5"
2a30: S056 "13 / 5"
2a38: S057 "13 / -5"
2a40: S058 "-13 / 5"
2a48: S059 "-13 / -5"
2a54: S060 "13 % 5"
2a5c: S061 "13 % -5"
2a68: S062 "-13 % 5"
2a74: S063 "-13 % -5"
2a80: S064 "a-umlaut:ae"
2a8c: S065 "o-umlaut:oe"
2a98: S066 "u-umlaut:ue"
2aa4: S067 "A-umlaut:Ae"
2ab0: S068 "O-umlaut:Oe"
2abc: S069 "U-umlaut:Ue"
2ac8: S070 "sz-ligature:ss"
2ad4: S071 ">>-quotes:>>"
2ae4: S072 "<<-quotes:<<"
2af4: S073 "e-umlaut:e"
2b00: S074 "i-umlaut:i"
2b0c: S075 "y-umlaut:y"
2b18: S076 "E-umlaut:E"
2b24: S077 "I-umlaut:I"
2b30: S078 "a-acute:a"
2b3c: S079 "e-acute:e"
2b48: S080 "i-acute:i"
2b54: S081 "o-acute:o"
2b60: S082 "u-acute:u"
2b6c: S083 "y-acute:y"
2b78: S084 "A-acute:A"
2b84: S085 "E-acute:E"
2b90: S086 "I-acute:I"
2b9c: S087 "O-acute:O"
2ba8: S088 "U-acute:U"
2bb4: S089 "Y-acute:Y"
2bc0: S090 "a-grave:a"
2bcc: S091 "e-grave:e"
2bd8: S092 "i-grave:i"
2be4: S093 "o-grave:o"
2bf0: S094 "u-grave:u"
2bfc: S095 "A-grave:A"
2c08: S096 "E-grave:E"
2c14: S097 "I-grave:I"
2c20: S098 "O-grave:O"
2c2c: S099 "U-grave:U"
2c38: S100 "a-circumflex:a"
2c48: S101 "e-circumflex:e"
2c58: S102 "i-circumflex:i"
2c68: S103 "o-circumflex:o"
2c78: S104 "u-circumflex:u"
2c88: S105 "A-circumflex:A"
2c98: S106 "E-circumflex:E"
2ca8: S107 "I-circumflex:I"
2cb8: S108 "O-circumflex:O"
2cc8: S109 "U-circumflex:U"
2cd8: S110 "a-ring:a"
2ce4: S111 "A-ring:A"
2cf0: S112 "o-slash:o"
2cfc: S113 "O-slash:O"
2d08: S114 "a-tilde:a"
2d14: S115 "n-tilde:n"
2d20: S116 "o-tilde:o"
2d2c: S117 "A-tilde:A"
2d38: S118 "N-tilde:N"
2d44: S119 "O-tilde:O"
2d50: S120 "ae-ligature:ae"
2d5c: S121 "AE-ligature:AE"
2d6c: S122 "c-cedilla:c"
2d78: S123 "C-cedilla:C"
2d84: S124 "thorn:th"
2d8c: S125 "eth:th"
2d94: S126 "Thorn:Th"
2d9c: S127 "Eth:Th"
2da4: S128 "pound-symbol:L"
2db4: S129 "oe-ligature:oe"
2dc0: S130 "OE-ligature:OE"
2dd0: S131 "inverse-!:!"
2ddc: S132 "inverse-?:?"
2de8: S133 "This displays all the accented characters (encoding values 155 to
223). You will have to inspect your interpreter's display to make sure they
appear correctly.
"
2e60: S134 "For the record, an umlaut is two dots; an acute accent is the one
that slants up to the right; a grave accent is the one that slants down to the
right; a circumflex is a pointy hat; a tilde is a squiggly hat; a ring is a
ring; a cedilla is the little hook that hangs down below the C. Thorn looks
like a capital D whose vertical bar extends both up and down, and Eth looks
like a D with a little cross-stroke.
"
2f88: S135 "NOTE: Inform 6.11 contradicts the Z-Spec 0.99 document, on the
subject of the European angle-quotes (the ones that look like '>>' and '<<').
The Z-Spec says that the character '>>' is code 162, and '<<' is 163. However,
Inform 6.11 (following the Z-Spec 0.2) compiles '@>>' as 163, and '@<<' as 162.
The concensus is that the Z-Spec 0.2 and Inform 6.11 are wrong, and Z-Spec 0.99
and later are correct.
"
30f0: S136 "Type a digit (0..7) to repeat this list in a different text style,
or "." to end this test.
"
3138: S137 "Options: 0: normal; 1: bold; 2: italic; 3: bold italic; 4:
fixed-width; 5: fixed bold; 6: fixed italic; 7: fixed bold italic.
"
31a8: S138 "control character 'ctrl-H' (z-machine 'delete')"
31d0: S139 "control character 'ctrl-M' (z-machine 'newline')"
31f8: S140 "control character 'ctrl-[' (z-machine 'escape')"
3220: S141 " (should NOT occur in full-line input)"
3240: S142 "This tests input of accented (actually, all) characters. Enter a
line of text; it will be broken down, and you will see a list of what
characters your interpreter thought you typed. Remember that the interpreter is
supposed to reduce everything to lower-case.
"
32fc: S143 "Hit Enter by itself to return to the main menu.
"
3320: S144 "This tests input of accented (actually, all) characters. Type
characters; you will see what characters your interpreter thought you typed.
Hit "." to return to the main menu.
"
33a4: S145 "Your interpreter claims (by its header bit) that it DOES support
timed input.
"
33e0: S146 "Your interpreter claims (by its header bit) that it DOES NOT
support timed input.
"
3420: S147 "When you begin this test, asterisks should appear at the rate of
one per second. If they appear at the rate of one every ten seconds, your
interpreter is using the incorrect timing rate caused by an old bug in ZIP. If
an entire line of ten asterisks appears all at once every ten seconds, your
interpreter is not properly flushing its buffer.
"
3510: S148 "Hit "." to return to the main menu, or any other key to begin the
test. Hit any key to stop the test while it is running.
"
356c: S149 "The timing interrupt function was not called at all. Either your
interpreter does not support timed input, or you terminated the test before one
second elapsed. (Or your interpreter has the "slow" bug and you terminated the
test before ten seconds elapsed.)
"
3624: S150 "Your interpreter claims to not support timed input. "
3648: S151 "Your interpreter claims to support timed input. "
366c: S152 "Your interpreter calls the timing interrupt function with no
arguments. "
36a0: S153 "This is correct, except that your interpreter claims not to
support timed input at all. "
36e0: S154 "Your interpreter calls the timing interrupt function with an
argument. "
3714: S155 "Your interpreter claims (by its header bit) that it DOES support
timed input.
"
3750: S156 "Your interpreter claims (by its header bit) that it DOES NOT
support timed input.
"
3790: S157 "When you begin this test, you should be able to enter a line of
input in the usual fashion. Every three seconds, a line of text will appear.
(If the lines appear at the rate of one every thirty seconds, your interpreter
is using the incorrect timing rate caused by an old bug in ZIP.)
"
385c: S158 "Interrupts actually are occuring once per second; every third
interrupt prints a line of text, and the other two have no visible effect.
After each line, your input should be redrawn so that you can continue typing
and editing it.
"
3900: S159 "Hit "." to return to the main menu, or any other key to begin the
test. Type "." on a line by itself to stop the test.
"
395c: S160 "You just typed a blank line. (Type "." to stop this test.)
"
398c: S161 "The timing interrupt function was not called at all. Either your
interpreter does not support timed input, or you terminated the test before one
second elapsed. (Or your interpreter has the "slow" bug and you terminated the
test before ten seconds elapsed.)
"
3a44: S162 "Your interpreter claims to not support timed input. "
3a68: S163 "Your interpreter claims to support timed input. "
3a8c: S164 "Your interpreter calls the timing interrupt function with no
arguments. "
3ac0: S165 "This is correct, except that your interpreter claims not to
support timed input at all. "
3b00: S166 "Your interpreter calls the timing interrupt function with an
argument. "
3b34: S167 "
[Every three seconds....]
TimedString> "
3b5c: S168 "This tests whether your interpreter supports being handed input by
the game file. (For example, after a function key is hit in Beyond Zork, the
command prompt appears with text already in place -- whatever text you had
typed before you interrupted it with the function key.)
"
3c20: S169 "The command prompt below should appear with the word "Given"
already visible after it. You should be able to type more characters, or go
back and edit the given character as if you had typed them yourself.
"
3cb4: S170 "If you see the word "Given" twice, your interpreter is printing
the given characters, which it shouldn't (that's the responsibility of the game
file.)
"
3d24: S171 "This tests the interpreter's ability to do single and multiple
"undo" commands.
"
3d60: S172 "Your interpreter claims (by its header bit) that it DOES support
undo.
"
3d98: S173 "Your interpreter claims (by its header bit) that it DOES NOT
support undo.
"
3dd4: S174 "Save failed -- interpreter claims that it does not support "undo".
"
3e08: S175 "Undo succeeded (undid first move).
"
3e24: S176 "Save failed -- interpreter claims that it does not support "undo".
"
3e58: S177 "Undo succeeded (undid second move).
"
3e74: S178 "
Hit "." to abort this test, or any other key to try a second "undo". (In many
interpreters, executing the second "undo" will return to exactly the same point
as the first one. If this occurs, and you see this message a second time (or
more), your interpreter only supports single-move undo.)
"
3f48: S179 "
Hit "." to abort this test, or any other key to try "undo".
"
3f78: S180 "Your interpreter claims to support "undo", but the @save_undo
opcode returned -1, indicating that the interpreter does not support "undo". "
3fe0: S181 "Your interpreter claims to not support "undo", and the @save_undo
opcode returned -1, corroborating this. "
4030: S182 "Your interpreter claims to support "undo", but it didn't work. "
4060: S183 "Your interpreter claims to not support "undo", and in fact "undo"
failed. However, it did not return -1 from the @save_undo opcode, which it
should. "
40d0: S184 "Your interpreter claims to support "undo", and it does. "
40fc: S185 "Your interpreter claims to not support "undo", but in fact it does
anyway. "
4134: S186 "Your interpreter claims to support "undo", and it does. In fact,
it supports multiple "undo". "
417c: S187 "Your interpreter claims to not support "undo", but in fact it does
anyway. In fact, it supports multiple "undo". "
41d0: S188 "This tests if you can read text which is displayed immediately
before the program quits. (It is not clear whether this is covered by the
Z-Spec. However, some games -- including some original Infocom games -- display
important closing text and then immediately quit.)
"
4290: S189 "Hit "." to return to the main menu, or any other key to print a
line of text and then quit. If the line of text does not appear, or appears and
vanishes too quickly to read, your interpreter will have trouble with those
games.
"
4330: S190 "
This is a final line of text. Goodbye.
"
4350: S191 "Version"
4358: S192 "Recent changes to TerpEtude"
436c: S193 "Header flags analysis"
437c: S194 "Styled text"
4384: S195 "Colored text"
4390: S196 "Multiplication, division, remainder"
43ac: S197 "Accented character output"
43c0: S198 "Single-key input"
43cc: S199 "Full-line input"
43d8: S200 "Timed single-key input"
43e8: S201 "Timed full-line input"
43f8: S202 "Pre-loading of input line"
440c: S203 "Undo capability"
4418: S204 "Printing before quitting"
442c: S205 "Options: (hit Enter by itself to display this menu)
"
4454: S206 ", or "." to exit, or hit Enter by itself to display the menu of
options.
"
448c: S207 "That option is not yet implemented.
"
44a8: S208 "TerpEtude: A Z-machine Interpreter Exerciser
"
44cc: S209 "By <NAME> (<EMAIL>)
"
44f0: S210 "Tests compliance with Z-Machine Standards Document 0.99.
"
4520: S211 "NOTE: This program does not test everything in the Z-Spec. Passing
all the tests in this program does NOT guarantee that your interpreter is
Z-Spec-compliant.
"
459c: S212 "For that matter, this program may have mistakes in it. I don't
think it does, but you should not assume it is the Fount of All Z-Machineness.
If you find something strange, check the Z-Spec, check existing interpreters,
check Infocom's interpreters, and then send me mail if you're still confused.
"
4674: S213 "In the beginning, TerpEtude was written. That was release DRAFT-1.
"
46ac: S214 " Release 2:
Accented-out test: Added ability to display characters in bold, underline, and
fixed-width styles.
"
4700: S215 "Accented-out test: Noted that >> and << are, in fact, tested
correctly.
"
4740: S216 "Given-text test: It's the game file's job to print the given text
before it calls @read. Fixed test to do this.
"
4794: S217 "Timed-string test: Changed test to do both "invisible" and
"visible" interrupts (only one interrupt in three actually prints text.)
"
47f4: S218 "List of terminating characters
Fonts
Stream 3 nesting
"
4820: S219 "Spec Aid: Graham, SJ, PDD, and the rest of the crowd
"
484c: S220 ": 'create' can have 0 to 3 parameters only **]"
4874: S221 "objectloop broken because the object "
4890: S222 " was moved while the loop passed through it **]"
48b8: S223 ", which is not a valid ZSCII character code for output **]"
48ec: S224 "tried to print (address) on something not the "
490c: S225 "tried to print (string) on something not a "
492c: S226 "tried to print (object) on something not an "
494c: S227 "give" or test "has" or "hasnt" with a non-attribute on the object
"
497c: S228 ", but it is longer than 2 bytes so you cannot use ".""
49a4: S229 "<unknown attribute>"
49b8: S230 "name"
49bc: S231 "create"
49c0: S232 "recreate"
49c8: S233 "destroy"
49d0: S234 "remaining"
49d8: S235 "copy"
49dc: S236 "call"
49e0: S237 "print"
49e4: S238 "print_to_array"
49f0: S239 "colortab"
49f8: S240 "AccentList"
4a00: S241 "optionlist"
4a08: S242 "inbuf"
[End of text at 4a0c]
[End of file]
|
Transynther/x86/_processed/US/_ht_/i3-7100_9_0x84_notsx.log_63_2655.asm | ljhsiun2/medusa | 9 | 241806 | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %r8
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_WT_ht+0x1a3ad, %r14
nop
nop
nop
nop
lfence
mov $0x6162636465666768, %r11
movq %r11, %xmm6
movups %xmm6, (%r14)
nop
nop
nop
nop
nop
inc %rcx
lea addresses_A_ht+0x1ac1f, %rsi
lea addresses_D_ht+0x11eed, %rdi
and $1603, %rbp
mov $83, %rcx
rep movsq
nop
nop
xor %r14, %r14
lea addresses_UC_ht+0x35ad, %rcx
nop
nop
nop
nop
sub %rbp, %rbp
movb $0x61, (%rcx)
nop
nop
nop
nop
xor $46691, %rcx
lea addresses_WT_ht+0x116ad, %rcx
nop
nop
nop
nop
sub $52050, %rsi
and $0xffffffffffffffc0, %rcx
vmovaps (%rcx), %ymm1
vextracti128 $1, %ymm1, %xmm1
vpextrq $1, %xmm1, %r11
nop
nop
nop
and %rcx, %rcx
lea addresses_normal_ht+0xccad, %r14
nop
nop
nop
nop
cmp %rdi, %rdi
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
movups %xmm5, (%r14)
nop
nop
nop
nop
and %rdi, %rdi
lea addresses_A_ht+0x114ad, %r14
clflush (%r14)
nop
add $27487, %r8
movw $0x6162, (%r14)
nop
nop
xor %rbp, %rbp
lea addresses_WT_ht+0x1eabd, %rsi
lea addresses_WC_ht+0x1c78d, %rdi
nop
nop
nop
nop
nop
add $9969, %r12
mov $17, %rcx
rep movsq
nop
nop
xor $20624, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r8
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r14
push %r8
push %rax
push %rbx
push %rsi
// Faulty Load
lea addresses_US+0x88ad, %r13
nop
nop
nop
nop
nop
add %rbx, %rbx
vmovups (%r13), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $1, %xmm5, %r14
lea oracles, %rbx
and $0xff, %r14
shlq $12, %r14
mov (%rbx,%r14,1), %r14
pop %rsi
pop %rbx
pop %rax
pop %r8
pop %r14
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_US', 'same': False, 'size': 2, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'type': 'addresses_US', 'same': True, 'size': 32, 'congruent': 0, 'NT': False, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'dst': {'type': 'addresses_WT_ht', 'same': False, 'size': 16, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM'}
{'dst': {'type': 'addresses_UC_ht', 'same': False, 'size': 1, 'congruent': 8, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WT_ht', 'same': False, 'size': 32, 'congruent': 7, 'NT': False, 'AVXalign': True}, 'OP': 'LOAD'}
{'dst': {'type': 'addresses_normal_ht', 'same': False, 'size': 16, 'congruent': 10, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'dst': {'type': 'addresses_A_ht', 'same': False, 'size': 2, 'congruent': 7, 'NT': False, 'AVXalign': False}, 'OP': 'STOR'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM'}
{'49': 34, '45': 29}
49 45 45 49 45 45 49 49 45 45 49 45 49 49 49 45 49 49 49 45 45 49 49 49 45 49 45 49 49 45 45 45 49 45 45 45 45 45 49 49 49 49 49 49 45 45 49 45 45 49 49 49 49 45 45 45 45 49 49 49 49 49 45
*/
|
src/svd/sam_svd.ads | Fabien-Chouteau/samd51-hal | 1 | 8800 | <reponame>Fabien-Chouteau/samd51-hal<filename>src/svd/sam_svd.ads<gh_stars>1-10
pragma Style_Checks (Off);
-- This spec has been automatically generated from ATSAMD51G19A.svd
pragma Restrictions (No_Elaboration_Code);
with System;
-- Microchip ATSAMD51G19A Microcontroller
package SAM_SVD is
pragma Preelaborate;
--------------------
-- Base addresses --
--------------------
AC_Base : constant System.Address := System'To_Address (16#42002000#);
ADC0_Base : constant System.Address := System'To_Address (16#43001C00#);
ADC1_Base : constant System.Address := System'To_Address (16#43002000#);
AES_Base : constant System.Address := System'To_Address (16#42002400#);
CCL_Base : constant System.Address := System'To_Address (16#42003800#);
CMCC_Base : constant System.Address := System'To_Address (16#41006000#);
DAC_Base : constant System.Address := System'To_Address (16#43002400#);
DMAC_Base : constant System.Address := System'To_Address (16#4100A000#);
DSU_Base : constant System.Address := System'To_Address (16#41002000#);
EIC_Base : constant System.Address := System'To_Address (16#40002800#);
EVSYS_Base : constant System.Address := System'To_Address (16#4100E000#);
FREQM_Base : constant System.Address := System'To_Address (16#40002C00#);
GCLK_Base : constant System.Address := System'To_Address (16#40001C00#);
HMATRIX_Base : constant System.Address := System'To_Address (16#4100C000#);
ICM_Base : constant System.Address := System'To_Address (16#42002C00#);
MCLK_Base : constant System.Address := System'To_Address (16#40000800#);
NVMCTRL_Base : constant System.Address := System'To_Address (16#41004000#);
OSCCTRL_Base : constant System.Address := System'To_Address (16#40001000#);
OSC32KCTRL_Base : constant System.Address := System'To_Address (16#40001400#);
PAC_Base : constant System.Address := System'To_Address (16#40000000#);
PCC_Base : constant System.Address := System'To_Address (16#43002C00#);
PDEC_Base : constant System.Address := System'To_Address (16#42001C00#);
PM_Base : constant System.Address := System'To_Address (16#40000400#);
PORT_Base : constant System.Address := System'To_Address (16#41008000#);
QSPI_Base : constant System.Address := System'To_Address (16#42003400#);
RAMECC_Base : constant System.Address := System'To_Address (16#41020000#);
RSTC_Base : constant System.Address := System'To_Address (16#40000C00#);
RTC_Base : constant System.Address := System'To_Address (16#40002400#);
SDHC0_Base : constant System.Address := System'To_Address (16#45000000#);
SERCOM0_Base : constant System.Address := System'To_Address (16#40003000#);
SERCOM1_Base : constant System.Address := System'To_Address (16#40003400#);
SERCOM2_Base : constant System.Address := System'To_Address (16#41012000#);
SERCOM3_Base : constant System.Address := System'To_Address (16#41014000#);
SERCOM4_Base : constant System.Address := System'To_Address (16#43000000#);
SERCOM5_Base : constant System.Address := System'To_Address (16#43000400#);
SUPC_Base : constant System.Address := System'To_Address (16#40001800#);
TC0_Base : constant System.Address := System'To_Address (16#40003800#);
TC1_Base : constant System.Address := System'To_Address (16#40003C00#);
TC2_Base : constant System.Address := System'To_Address (16#4101A000#);
TC3_Base : constant System.Address := System'To_Address (16#4101C000#);
TCC0_Base : constant System.Address := System'To_Address (16#41016000#);
TCC1_Base : constant System.Address := System'To_Address (16#41018000#);
TCC2_Base : constant System.Address := System'To_Address (16#42000C00#);
TRNG_Base : constant System.Address := System'To_Address (16#42002800#);
USB_Base : constant System.Address := System'To_Address (16#41000000#);
WDT_Base : constant System.Address := System'To_Address (16#40002000#);
CoreDebug_Base : constant System.Address := System'To_Address (16#E000EDF0#);
DWT_Base : constant System.Address := System'To_Address (16#E0001000#);
ETM_Base : constant System.Address := System'To_Address (16#E0041000#);
FPU_Base : constant System.Address := System'To_Address (16#E000EF30#);
ITM_Base : constant System.Address := System'To_Address (16#E0000000#);
MPU_Base : constant System.Address := System'To_Address (16#E000ED90#);
NVIC_Base : constant System.Address := System'To_Address (16#E000E100#);
SysTick_Base : constant System.Address := System'To_Address (16#E000E010#);
SystemControl_Base : constant System.Address := System'To_Address (16#E000E000#);
TPI_Base : constant System.Address := System'To_Address (16#E0040000#);
end SAM_SVD;
|
parser-examples/antlr-examples/antlr-visitor-example1/src/main/antlr4/com/arjunsk/parser/antlr/Calculator.g4 | arjunsk/codekrypt-compiler | 11 | 33 | grammar Calculator;
operation : left=NUMBER operator='+' right=NUMBER
| left=NUMBER operator='-' right=NUMBER
| left=NUMBER operator='*' right=NUMBER
| left=NUMBER operator='/' right=NUMBER;
NUMBER
: ('0' .. '9') + ('.' ('0' .. '9') +)? ;
WS : (' ' | '\t')+ -> channel(HIDDEN); |
libsrc/_DEVELOPMENT/target/yaz180/device/8255/8255_read_byte.asm | jpoikela/z88dk | 640 | 100670 | <reponame>jpoikela/z88dk
INCLUDE "config_private.inc"
SECTION code_driver
PUBLIC ide_read_byte
;Do a read bus cycle to the drive, using the 8255.
;input A = ide register address
;output A = lower byte read from IDE drive
ide_read_byte:
push bc
push de
ld d, a ;copy address to D
ld bc, __IO_PIO_IDE_CTL
out (c), a ;drive address onto control lines
or __IO_IDE_RD_LINE
out (c), a ;and assert read pin
ld bc, __IO_PIO_IDE_LSB
in e, (c) ;read the lower byte
ld bc, __IO_PIO_IDE_CTL
out (c), d ;deassert read pin
xor a
out (c), a ;deassert all control pins
ld a, e
pop de
pop bc
ret
|
programs/oeis/193/A193337.asm | neoneye/loda | 22 | 175827 | ; A193337: Sum of odd divisors of sigma(n).
; 1,4,1,8,4,4,1,24,14,13,4,8,8,4,4,32,13,56,6,32,1,13,4,24,32,32,6,8,24,13,1,104,4,40,4,112,20,24,8,78,32,4,12,32,56,13,4,32,80,128,13,57,40,24,13,24,6,78,24,32,32,4,14,128,32,13,18,104,4,13,13,336,38,80,32,48,4,32,6,128,133,104,32,8,40,48,24,78,78,182,8,32,1,13,24,104,57,260,56,256
seq $0,2659 ; a(n) = 2*sigma(n) - 1.
seq $0,593 ; Sum of odd divisors of n.
|
oeis/199/A199042.asm | neoneye/loda-programs | 11 | 173504 | ; A199042: Expansion of e.g.f. exp(arctan(1+2*x) - Pi/4).
; Submitted by <NAME>
; 1,1,-1,-1,17,-95,175,3775,-63775,533825,108575,-98151425,2037293425,-20945772575,-111991234225,10648024541375,-261756393325375,3003396413226625,43283396332525375,-3352997476533082625,94455063540276700625,-1135469395905648529375,-32788008141700838820625,2459058071909955310429375,-77476148996546740082849375,926578891449106121179890625,47569013114849888161604609375,-3630572227741182253775692890625,125633433657033416471218851640625,-1420413642792170338208189189609375
mov $3,1
lpb $0
sub $0,1
mul $1,$0
mov $2,$3
mul $2,$0
mul $2,-2
add $3,$1
mov $1,$2
add $3,$2
lpe
mov $0,$3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.