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
|
|---|---|---|---|---|
oeis/004/A004983.asm
|
neoneye/loda-programs
| 11 |
160334
|
<reponame>neoneye/loda-programs
; A004983: a(n) = (2^n/n!) * Product_{k=0..n-1} (4*k - 3).
; Submitted by <NAME>(s4)
; 1,-6,-6,-20,-90,-468,-2652,-15912,-99450,-640900,-4229940,-28455960,-194449060,-1346185800,-9423300600,-66591324240,-474463185210,-3404971093860,-24591457900100,-178611641590200,-1303864983608460,-9561676546462040,-70408709114856840,-520412197805463600,-3859723800390521700,-28716345074905481448,-214268113251217823112,-1603042921360962972912,-12022821910207222296840,-90378454359488774507280,-680851022841482101288176,-5139327075642155216175264,-38866161009543798822325434
mov $1,1
mov $3,$0
mov $0,14
lpb $3
sub $0,8
mul $1,$0
sub $2,1
div $1,$2
sub $3,1
lpe
mov $0,$1
|
libsrc/_DEVELOPMENT/arch/sms/SMSlib/z80/asm_SMSlib_finalizeSprites.asm
|
jpoikela/z88dk
| 640 |
83335
|
; **************************************************
; SMSlib - C programming library for the SMS/GG
; ( part of devkitSMS - github.com/sverx/devkitSMS )
; **************************************************
INCLUDE "SMSlib_private.inc"
SECTION code_clib
SECTION code_SMSlib
PUBLIC asm_SMSlib_finalizeSprites
EXTERN __SMSlib_SpriteNextFree, __SMSlib_SpriteTableY
asm_SMSlib_finalizeSprites:
; void SMS_finalizeSprites (void)
;
; uses : af, hl
ld a,(__SMSlib_SpriteNextFree)
IF MAXSPRITES = 64
cp MAXSPRITES
ret nc
ENDIF
add a,__SMSlib_SpriteTableY&0xff
ld l,a
ld a,0
adc a,__SMSlib_SpriteTableY/256
ld h,a
ld (hl),0xd0
ret
|
libsrc/math/daimath32/c/asm/___dai32_xln.asm
|
ahjelm/z88dk
| 640 |
95524
|
<filename>libsrc/math/daimath32/c/asm/___dai32_xln.asm
SECTION code_fp_dai32
PUBLIC ___dai32_xln
EXTERN xln
defc ___dai32_xln = xln
|
programs/oeis/335/A335439.asm
|
jmorken/loda
| 1 |
92859
|
; A335439: a(n) = n*(n-1)/2 + 2^(n-1) - 1.
; 0,2,6,13,25,46,84,155,291,556,1078,2113,4173,8282,16488,32887,65671,131224,262314,524477,1048785,2097382,4194556,8388883,16777515,33554756,67109214,134218105,268435861,536871346,1073742288,2147484143,4294967823,8589935152,17179869778,34359738997,68719477401,137438954174,274877907684,549755814667,1099511628595,2199023256412,4398046512006,8796093023153,17592186045405,35184372089866,70368744178744,140737488356455,281474976711831,562949953422536,1125899906843898,2251799813686573,4503599627371873,9007199254742422
mov $1,2
pow $1,$0
lpb $0
add $1,$0
sub $0,1
lpe
sub $1,1
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/dynamic_bound.adb
|
best08618/asylo
| 7 |
26664
|
-- { dg-do compile }
-- { dg-options "-gnato" }
procedure Dynamic_Bound is
procedure Define (Count : Integer) is
type Count_T is new Integer range 0 .. Count * 1000;
type Obj_T is record
Count : Count_T;
end record;
type T is access Obj_T ;
procedure Create (S : in out T) is
begin
S := new Obj_T'(Count => 0);
end;
procedure Add (To : in out T) is
begin
To.Count := To.Count + 1;
end;
My_T : T;
begin
Create (My_T);
end;
begin
Define (1);
end;
|
grep.asm
|
willtran98/MIT_xv6
| 0 |
82947
|
<gh_stars>0
_grep: file format elf32-i386
Disassembly of section .text:
00000000 <matchstar>:
return 0;
}
// matchstar: search for c*re at beginning of text
int matchstar(int c, char *re, char *text)
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 57 push %edi
4: 56 push %esi
5: 53 push %ebx
6: 83 ec 1c sub $0x1c,%esp
9: 8b 75 08 mov 0x8(%ebp),%esi
c: 8b 7d 0c mov 0xc(%ebp),%edi
f: 8b 5d 10 mov 0x10(%ebp),%ebx
12: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
do{ // a * matches zero or more instances
if(matchhere(re, text))
18: 89 5c 24 04 mov %ebx,0x4(%esp)
1c: 89 3c 24 mov %edi,(%esp)
1f: e8 3c 00 00 00 call 60 <matchhere>
24: 85 c0 test %eax,%eax
26: 75 20 jne 48 <matchstar+0x48>
return 1;
}while(*text!='\0' && (*text++==c || c=='.'));
28: 0f b6 03 movzbl (%ebx),%eax
2b: 84 c0 test %al,%al
2d: 74 0f je 3e <matchstar+0x3e>
2f: 0f be c0 movsbl %al,%eax
32: 83 c3 01 add $0x1,%ebx
35: 39 f0 cmp %esi,%eax
37: 74 df je 18 <matchstar+0x18>
39: 83 fe 2e cmp $0x2e,%esi
3c: 74 da je 18 <matchstar+0x18>
return 0;
}
3e: 83 c4 1c add $0x1c,%esp
int matchstar(int c, char *re, char *text)
{
do{ // a * matches zero or more instances
if(matchhere(re, text))
return 1;
}while(*text!='\0' && (*text++==c || c=='.'));
41: 31 c0 xor %eax,%eax
return 0;
}
43: 5b pop %ebx
44: 5e pop %esi
45: 5f pop %edi
46: 5d pop %ebp
47: c3 ret
48: 83 c4 1c add $0x1c,%esp
// matchstar: search for c*re at beginning of text
int matchstar(int c, char *re, char *text)
{
do{ // a * matches zero or more instances
if(matchhere(re, text))
4b: b8 01 00 00 00 mov $0x1,%eax
return 1;
}while(*text!='\0' && (*text++==c || c=='.'));
return 0;
}
50: 5b pop %ebx
51: 5e pop %esi
52: 5f pop %edi
53: 5d pop %ebp
54: c3 ret
55: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
59: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000060 <matchhere>:
return 0;
}
// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
60: 55 push %ebp
61: 89 e5 mov %esp,%ebp
63: 56 push %esi
64: 53 push %ebx
65: 83 ec 10 sub $0x10,%esp
68: 8b 55 08 mov 0x8(%ebp),%edx
6b: 8b 4d 0c mov 0xc(%ebp),%ecx
if(re[0] == '\0')
6e: 0f b6 02 movzbl (%edx),%eax
71: 84 c0 test %al,%al
73: 75 1c jne 91 <matchhere+0x31>
75: eb 51 jmp c8 <matchhere+0x68>
77: 90 nop
return 1;
if(re[1] == '*')
return matchstar(re[0], re+2, text);
if(re[0] == '$' && re[1] == '\0')
return *text == '\0';
if(*text!='\0' && (re[0]=='.' || re[0]==*text))
78: 0f b6 19 movzbl (%ecx),%ebx
7b: 84 db test %bl,%bl
7d: 74 39 je b8 <matchhere+0x58>
7f: 3c 2e cmp $0x2e,%al
81: 74 04 je 87 <matchhere+0x27>
83: 38 d8 cmp %bl,%al
85: 75 31 jne b8 <matchhere+0x58>
}
// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
87: 0f b6 02 movzbl (%edx),%eax
8a: 84 c0 test %al,%al
8c: 74 3a je c8 <matchhere+0x68>
if(re[1] == '*')
return matchstar(re[0], re+2, text);
if(re[0] == '$' && re[1] == '\0')
return *text == '\0';
if(*text!='\0' && (re[0]=='.' || re[0]==*text))
return matchhere(re+1, text+1);
8e: 83 c1 01 add $0x1,%ecx
// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
return 1;
if(re[1] == '*')
91: 0f b6 5a 01 movzbl 0x1(%edx),%ebx
95: 8d 72 01 lea 0x1(%edx),%esi
98: 80 fb 2a cmp $0x2a,%bl
9b: 74 3b je d8 <matchhere+0x78>
return matchstar(re[0], re+2, text);
if(re[0] == '$' && re[1] == '\0')
9d: 3c 24 cmp $0x24,%al
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
return 1;
if(re[1] == '*')
return matchstar(re[0], re+2, text);
9f: 89 f2 mov %esi,%edx
if(re[0] == '$' && re[1] == '\0')
a1: 75 d5 jne 78 <matchhere+0x18>
a3: 84 db test %bl,%bl
a5: 75 d1 jne 78 <matchhere+0x18>
return *text == '\0';
a7: 31 c0 xor %eax,%eax
a9: 80 39 00 cmpb $0x0,(%ecx)
ac: 0f 94 c0 sete %al
af: eb 09 jmp ba <matchhere+0x5a>
b1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
}
// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
b8: 31 c0 xor %eax,%eax
if(re[0] == '$' && re[1] == '\0')
return *text == '\0';
if(*text!='\0' && (re[0]=='.' || re[0]==*text))
return matchhere(re+1, text+1);
return 0;
}
ba: 83 c4 10 add $0x10,%esp
bd: 5b pop %ebx
be: 5e pop %esi
bf: 5d pop %ebp
c0: c3 ret
c1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
c8: 83 c4 10 add $0x10,%esp
}
// matchhere: search for re at beginning of text
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
cb: b8 01 00 00 00 mov $0x1,%eax
if(re[0] == '$' && re[1] == '\0')
return *text == '\0';
if(*text!='\0' && (re[0]=='.' || re[0]==*text))
return matchhere(re+1, text+1);
return 0;
}
d0: 5b pop %ebx
d1: 5e pop %esi
d2: 5d pop %ebp
d3: c3 ret
d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
int matchhere(char *re, char *text)
{
if(re[0] == '\0')
return 1;
if(re[1] == '*')
return matchstar(re[0], re+2, text);
d8: 83 c2 02 add $0x2,%edx
db: 0f be c0 movsbl %al,%eax
de: 89 4c 24 08 mov %ecx,0x8(%esp)
e2: 89 54 24 04 mov %edx,0x4(%esp)
e6: 89 04 24 mov %eax,(%esp)
e9: e8 12 ff ff ff call 0 <matchstar>
if(re[0] == '$' && re[1] == '\0')
return *text == '\0';
if(*text!='\0' && (re[0]=='.' || re[0]==*text))
return matchhere(re+1, text+1);
return 0;
}
ee: 83 c4 10 add $0x10,%esp
f1: 5b pop %ebx
f2: 5e pop %esi
f3: 5d pop %ebp
f4: c3 ret
f5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000100 <match>:
int matchhere(char*, char*);
int matchstar(int, char*, char*);
int
match(char *re, char *text)
{
100: 55 push %ebp
101: 89 e5 mov %esp,%ebp
103: 56 push %esi
104: 53 push %ebx
105: 83 ec 10 sub $0x10,%esp
108: 8b 75 08 mov 0x8(%ebp),%esi
10b: 8b 5d 0c mov 0xc(%ebp),%ebx
if(re[0] == '^')
10e: 80 3e 5e cmpb $0x5e,(%esi)
111: 75 08 jne 11b <match+0x1b>
113: eb 2f jmp 144 <match+0x44>
115: 8d 76 00 lea 0x0(%esi),%esi
return matchhere(re+1, text);
do{ // must look at empty string
if(matchhere(re, text))
return 1;
}while(*text++ != '\0');
118: 83 c3 01 add $0x1,%ebx
match(char *re, char *text)
{
if(re[0] == '^')
return matchhere(re+1, text);
do{ // must look at empty string
if(matchhere(re, text))
11b: 89 5c 24 04 mov %ebx,0x4(%esp)
11f: 89 34 24 mov %esi,(%esp)
122: e8 39 ff ff ff call 60 <matchhere>
127: 85 c0 test %eax,%eax
129: 75 0d jne 138 <match+0x38>
return 1;
}while(*text++ != '\0');
12b: 80 3b 00 cmpb $0x0,(%ebx)
12e: 75 e8 jne 118 <match+0x18>
return 0;
}
130: 83 c4 10 add $0x10,%esp
133: 5b pop %ebx
134: 5e pop %esi
135: 5d pop %ebp
136: c3 ret
137: 90 nop
138: 83 c4 10 add $0x10,%esp
if(re[0] == '^')
return matchhere(re+1, text);
do{ // must look at empty string
if(matchhere(re, text))
return 1;
}while(*text++ != '\0');
13b: b8 01 00 00 00 mov $0x1,%eax
return 0;
}
140: 5b pop %ebx
141: 5e pop %esi
142: 5d pop %ebp
143: c3 ret
int
match(char *re, char *text)
{
if(re[0] == '^')
return matchhere(re+1, text);
144: 83 c6 01 add $0x1,%esi
147: 89 75 08 mov %esi,0x8(%ebp)
do{ // must look at empty string
if(matchhere(re, text))
return 1;
}while(*text++ != '\0');
return 0;
}
14a: 83 c4 10 add $0x10,%esp
14d: 5b pop %ebx
14e: 5e pop %esi
14f: 5d pop %ebp
int
match(char *re, char *text)
{
if(re[0] == '^')
return matchhere(re+1, text);
150: e9 0b ff ff ff jmp 60 <matchhere>
155: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
159: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000160 <grep>:
char buf[1024];
int match(char*, char*);
void
grep(char *pattern, int fd)
{
160: 55 push %ebp
161: 89 e5 mov %esp,%ebp
163: 57 push %edi
164: 56 push %esi
165: 53 push %ebx
166: 83 ec 2c sub $0x2c,%esp
169: 8b 7d 08 mov 0x8(%ebp),%edi
16c: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
173: 90 nop
174: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
int n, m;
char *p, *q;
m = 0;
while((n = read(fd, buf+m, sizeof(buf)-m-1)) > 0){
178: b8 ff 03 00 00 mov $0x3ff,%eax
17d: 2b 45 e4 sub -0x1c(%ebp),%eax
180: 89 44 24 08 mov %eax,0x8(%esp)
184: 8b 45 e4 mov -0x1c(%ebp),%eax
187: 05 c0 0a 00 00 add $0xac0,%eax
18c: 89 44 24 04 mov %eax,0x4(%esp)
190: 8b 45 0c mov 0xc(%ebp),%eax
193: 89 04 24 mov %eax,(%esp)
196: e8 e2 03 00 00 call 57d <read>
19b: 85 c0 test %eax,%eax
19d: 0f 8e b9 00 00 00 jle 25c <grep+0xfc>
m += n;
1a3: 01 45 e4 add %eax,-0x1c(%ebp)
buf[m] = '\0';
1a6: be c0 0a 00 00 mov $0xac0,%esi
1ab: 8b 45 e4 mov -0x1c(%ebp),%eax
1ae: c6 80 c0 0a 00 00 00 movb $0x0,0xac0(%eax)
1b5: 8d 76 00 lea 0x0(%esi),%esi
p = buf;
while((q = strchr(p, '\n')) != 0){
1b8: c7 44 24 04 0a 00 00 movl $0xa,0x4(%esp)
1bf: 00
1c0: 89 34 24 mov %esi,(%esp)
1c3: e8 38 02 00 00 call 400 <strchr>
1c8: 85 c0 test %eax,%eax
1ca: 89 c3 mov %eax,%ebx
1cc: 74 42 je 210 <grep+0xb0>
*q = 0;
1ce: c6 03 00 movb $0x0,(%ebx)
if(match(pattern, p)){
1d1: 89 74 24 04 mov %esi,0x4(%esp)
1d5: 89 3c 24 mov %edi,(%esp)
1d8: e8 23 ff ff ff call 100 <match>
1dd: 85 c0 test %eax,%eax
1df: 75 07 jne 1e8 <grep+0x88>
1e1: 83 c3 01 add $0x1,%ebx
*q = '\n';
write(1, p, q+1 - p);
1e4: 89 de mov %ebx,%esi
1e6: eb d0 jmp 1b8 <grep+0x58>
buf[m] = '\0';
p = buf;
while((q = strchr(p, '\n')) != 0){
*q = 0;
if(match(pattern, p)){
*q = '\n';
1e8: c6 03 0a movb $0xa,(%ebx)
write(1, p, q+1 - p);
1eb: 83 c3 01 add $0x1,%ebx
1ee: 89 d8 mov %ebx,%eax
1f0: 29 f0 sub %esi,%eax
1f2: 89 74 24 04 mov %esi,0x4(%esp)
1f6: 89 de mov %ebx,%esi
1f8: 89 44 24 08 mov %eax,0x8(%esp)
1fc: c7 04 24 01 00 00 00 movl $0x1,(%esp)
203: e8 7d 03 00 00 call 585 <write>
208: eb ae jmp 1b8 <grep+0x58>
20a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
p = q+1;
}
if(p == buf)
210: 81 fe c0 0a 00 00 cmp $0xac0,%esi
216: 74 38 je 250 <grep+0xf0>
m = 0;
if(m > 0){
218: 8b 45 e4 mov -0x1c(%ebp),%eax
21b: 85 c0 test %eax,%eax
21d: 0f 8e 55 ff ff ff jle 178 <grep+0x18>
m -= p - buf;
223: 81 45 e4 c0 0a 00 00 addl $0xac0,-0x1c(%ebp)
22a: 29 75 e4 sub %esi,-0x1c(%ebp)
memmove(buf, p, m);
22d: 8b 45 e4 mov -0x1c(%ebp),%eax
230: 89 74 24 04 mov %esi,0x4(%esp)
234: c7 04 24 c0 0a 00 00 movl $0xac0,(%esp)
23b: 89 44 24 08 mov %eax,0x8(%esp)
23f: e8 3c 02 00 00 call 480 <memmove>
244: e9 2f ff ff ff jmp 178 <grep+0x18>
249: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
250: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
257: e9 1c ff ff ff jmp 178 <grep+0x18>
}
}
}
25c: 83 c4 2c add $0x2c,%esp
25f: 5b pop %ebx
260: 5e pop %esi
261: 5f pop %edi
262: 5d pop %ebp
263: c3 ret
264: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
26a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000270 <main>:
int
main(int argc, char *argv[])
{
270: 55 push %ebp
271: 89 e5 mov %esp,%ebp
273: 83 e4 f0 and $0xfffffff0,%esp
276: 57 push %edi
277: 56 push %esi
278: 53 push %ebx
279: 83 ec 24 sub $0x24,%esp
27c: 8b 7d 08 mov 0x8(%ebp),%edi
27f: 8b 5d 0c mov 0xc(%ebp),%ebx
int fd, i;
char *pattern;
if(argc <= 1){
282: 83 ff 01 cmp $0x1,%edi
285: 0f 8e 95 00 00 00 jle 320 <main+0xb0>
printf(2, "usage: grep pattern [file ...]\n");
exit();
}
pattern = argv[1];
28b: 8b 43 04 mov 0x4(%ebx),%eax
if(argc <= 2){
28e: 83 ff 02 cmp $0x2,%edi
if(argc <= 1){
printf(2, "usage: grep pattern [file ...]\n");
exit();
}
pattern = argv[1];
291: 89 44 24 1c mov %eax,0x1c(%esp)
if(argc <= 2){
295: 74 71 je 308 <main+0x98>
grep(pattern, 0);
exit();
297: 83 c3 08 add $0x8,%ebx
29a: be 02 00 00 00 mov $0x2,%esi
29f: 90 nop
}
for(i = 2; i < argc; i++){
if((fd = open(argv[i], 0)) < 0){
2a0: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
2a7: 00
2a8: 8b 03 mov (%ebx),%eax
2aa: 89 04 24 mov %eax,(%esp)
2ad: e8 f3 02 00 00 call 5a5 <open>
2b2: 85 c0 test %eax,%eax
2b4: 78 32 js 2e8 <main+0x78>
printf(1, "grep: cannot open %s\n", argv[i]);
exit();
}
grep(pattern, fd);
2b6: 8b 54 24 1c mov 0x1c(%esp),%edx
if(argc <= 2){
grep(pattern, 0);
exit();
}
for(i = 2; i < argc; i++){
2ba: 83 c6 01 add $0x1,%esi
2bd: 83 c3 04 add $0x4,%ebx
if((fd = open(argv[i], 0)) < 0){
printf(1, "grep: cannot open %s\n", argv[i]);
exit();
}
grep(pattern, fd);
2c0: 89 44 24 04 mov %eax,0x4(%esp)
2c4: 89 44 24 18 mov %eax,0x18(%esp)
2c8: 89 14 24 mov %edx,(%esp)
2cb: e8 90 fe ff ff call 160 <grep>
close(fd);
2d0: 8b 44 24 18 mov 0x18(%esp),%eax
2d4: 89 04 24 mov %eax,(%esp)
2d7: e8 b1 02 00 00 call 58d <close>
if(argc <= 2){
grep(pattern, 0);
exit();
}
for(i = 2; i < argc; i++){
2dc: 39 f7 cmp %esi,%edi
2de: 7f c0 jg 2a0 <main+0x30>
exit();
}
grep(pattern, fd);
close(fd);
}
exit();
2e0: e8 80 02 00 00 call 565 <exit>
2e5: 8d 76 00 lea 0x0(%esi),%esi
exit();
}
for(i = 2; i < argc; i++){
if((fd = open(argv[i], 0)) < 0){
printf(1, "grep: cannot open %s\n", argv[i]);
2e8: 8b 03 mov (%ebx),%eax
2ea: c7 44 24 04 58 0a 00 movl $0xa58,0x4(%esp)
2f1: 00
2f2: c7 04 24 01 00 00 00 movl $0x1,(%esp)
2f9: 89 44 24 08 mov %eax,0x8(%esp)
2fd: e8 be 03 00 00 call 6c0 <printf>
exit();
302: e8 5e 02 00 00 call 565 <exit>
307: 90 nop
exit();
}
pattern = argv[1];
if(argc <= 2){
grep(pattern, 0);
308: 89 04 24 mov %eax,(%esp)
30b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
312: 00
313: e8 48 fe ff ff call 160 <grep>
exit();
318: e8 48 02 00 00 call 565 <exit>
31d: 8d 76 00 lea 0x0(%esi),%esi
{
int fd, i;
char *pattern;
if(argc <= 1){
printf(2, "usage: grep pattern [file ...]\n");
320: c7 44 24 04 38 0a 00 movl $0xa38,0x4(%esp)
327: 00
328: c7 04 24 02 00 00 00 movl $0x2,(%esp)
32f: e8 8c 03 00 00 call 6c0 <printf>
exit();
334: e8 2c 02 00 00 call 565 <exit>
339: 66 90 xchg %ax,%ax
33b: 66 90 xchg %ax,%ax
33d: 66 90 xchg %ax,%ax
33f: 90 nop
00000340 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
340: 55 push %ebp
341: 31 d2 xor %edx,%edx
343: 89 e5 mov %esp,%ebp
345: 8b 45 08 mov 0x8(%ebp),%eax
348: 53 push %ebx
349: 8b 5d 0c mov 0xc(%ebp),%ebx
34c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
char *os;
os = s;
while((*s++ = *t++) != 0)
350: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx
354: 88 0c 10 mov %cl,(%eax,%edx,1)
357: 83 c2 01 add $0x1,%edx
35a: 84 c9 test %cl,%cl
35c: 75 f2 jne 350 <strcpy+0x10>
;
return os;
}
35e: 5b pop %ebx
35f: 5d pop %ebp
360: c3 ret
361: eb 0d jmp 370 <strcmp>
363: 90 nop
364: 90 nop
365: 90 nop
366: 90 nop
367: 90 nop
368: 90 nop
369: 90 nop
36a: 90 nop
36b: 90 nop
36c: 90 nop
36d: 90 nop
36e: 90 nop
36f: 90 nop
00000370 <strcmp>:
int
strcmp(const char *p, const char *q)
{
370: 55 push %ebp
371: 89 e5 mov %esp,%ebp
373: 53 push %ebx
374: 8b 4d 08 mov 0x8(%ebp),%ecx
377: 8b 55 0c mov 0xc(%ebp),%edx
while(*p && *p == *q)
37a: 0f b6 01 movzbl (%ecx),%eax
37d: 84 c0 test %al,%al
37f: 75 14 jne 395 <strcmp+0x25>
381: eb 25 jmp 3a8 <strcmp+0x38>
383: 90 nop
384: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p++, q++;
388: 83 c1 01 add $0x1,%ecx
38b: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
38e: 0f b6 01 movzbl (%ecx),%eax
391: 84 c0 test %al,%al
393: 74 13 je 3a8 <strcmp+0x38>
395: 0f b6 1a movzbl (%edx),%ebx
398: 38 d8 cmp %bl,%al
39a: 74 ec je 388 <strcmp+0x18>
39c: 0f b6 db movzbl %bl,%ebx
39f: 0f b6 c0 movzbl %al,%eax
3a2: 29 d8 sub %ebx,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
}
3a4: 5b pop %ebx
3a5: 5d pop %ebp
3a6: c3 ret
3a7: 90 nop
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3a8: 0f b6 1a movzbl (%edx),%ebx
3ab: 31 c0 xor %eax,%eax
3ad: 0f b6 db movzbl %bl,%ebx
3b0: 29 d8 sub %ebx,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
}
3b2: 5b pop %ebx
3b3: 5d pop %ebp
3b4: c3 ret
3b5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
3b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000003c0 <strlen>:
uint
strlen(char *s)
{
3c0: 55 push %ebp
int n;
for(n = 0; s[n]; n++)
3c1: 31 d2 xor %edx,%edx
return (uchar)*p - (uchar)*q;
}
uint
strlen(char *s)
{
3c3: 89 e5 mov %esp,%ebp
int n;
for(n = 0; s[n]; n++)
3c5: 31 c0 xor %eax,%eax
return (uchar)*p - (uchar)*q;
}
uint
strlen(char *s)
{
3c7: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
3ca: 80 39 00 cmpb $0x0,(%ecx)
3cd: 74 0c je 3db <strlen+0x1b>
3cf: 90 nop
3d0: 83 c2 01 add $0x1,%edx
3d3: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
3d7: 89 d0 mov %edx,%eax
3d9: 75 f5 jne 3d0 <strlen+0x10>
;
return n;
}
3db: 5d pop %ebp
3dc: c3 ret
3dd: 8d 76 00 lea 0x0(%esi),%esi
000003e0 <memset>:
void*
memset(void *dst, int c, uint n)
{
3e0: 55 push %ebp
3e1: 89 e5 mov %esp,%ebp
3e3: 8b 55 08 mov 0x8(%ebp),%edx
3e6: 57 push %edi
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
3e7: 8b 4d 10 mov 0x10(%ebp),%ecx
3ea: 8b 45 0c mov 0xc(%ebp),%eax
3ed: 89 d7 mov %edx,%edi
3ef: fc cld
3f0: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
3f2: 89 d0 mov %edx,%eax
3f4: 5f pop %edi
3f5: 5d pop %ebp
3f6: c3 ret
3f7: 89 f6 mov %esi,%esi
3f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000400 <strchr>:
char*
strchr(const char *s, char c)
{
400: 55 push %ebp
401: 89 e5 mov %esp,%ebp
403: 8b 45 08 mov 0x8(%ebp),%eax
406: 0f b6 4d 0c movzbl 0xc(%ebp),%ecx
for(; *s; s++)
40a: 0f b6 10 movzbl (%eax),%edx
40d: 84 d2 test %dl,%dl
40f: 75 11 jne 422 <strchr+0x22>
411: eb 15 jmp 428 <strchr+0x28>
413: 90 nop
414: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
418: 83 c0 01 add $0x1,%eax
41b: 0f b6 10 movzbl (%eax),%edx
41e: 84 d2 test %dl,%dl
420: 74 06 je 428 <strchr+0x28>
if(*s == c)
422: 38 ca cmp %cl,%dl
424: 75 f2 jne 418 <strchr+0x18>
return (char*)s;
return 0;
}
426: 5d pop %ebp
427: c3 ret
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
428: 31 c0 xor %eax,%eax
if(*s == c)
return (char*)s;
return 0;
}
42a: 5d pop %ebp
42b: 90 nop
42c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
430: c3 ret
431: eb 0d jmp 440 <atoi>
433: 90 nop
434: 90 nop
435: 90 nop
436: 90 nop
437: 90 nop
438: 90 nop
439: 90 nop
43a: 90 nop
43b: 90 nop
43c: 90 nop
43d: 90 nop
43e: 90 nop
43f: 90 nop
00000440 <atoi>:
return r;
}
int
atoi(const char *s)
{
440: 55 push %ebp
int n;
n = 0;
while('0' <= *s && *s <= '9')
441: 31 c0 xor %eax,%eax
return r;
}
int
atoi(const char *s)
{
443: 89 e5 mov %esp,%ebp
445: 8b 4d 08 mov 0x8(%ebp),%ecx
448: 53 push %ebx
int n;
n = 0;
while('0' <= *s && *s <= '9')
449: 0f b6 11 movzbl (%ecx),%edx
44c: 8d 5a d0 lea -0x30(%edx),%ebx
44f: 80 fb 09 cmp $0x9,%bl
452: 77 1c ja 470 <atoi+0x30>
454: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
n = n*10 + *s++ - '0';
458: 0f be d2 movsbl %dl,%edx
45b: 83 c1 01 add $0x1,%ecx
45e: 8d 04 80 lea (%eax,%eax,4),%eax
461: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
465: 0f b6 11 movzbl (%ecx),%edx
468: 8d 5a d0 lea -0x30(%edx),%ebx
46b: 80 fb 09 cmp $0x9,%bl
46e: 76 e8 jbe 458 <atoi+0x18>
n = n*10 + *s++ - '0';
return n;
}
470: 5b pop %ebx
471: 5d pop %ebp
472: c3 ret
473: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
479: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000480 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
480: 55 push %ebp
481: 89 e5 mov %esp,%ebp
483: 56 push %esi
484: 8b 45 08 mov 0x8(%ebp),%eax
487: 53 push %ebx
488: 8b 5d 10 mov 0x10(%ebp),%ebx
48b: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
48e: 85 db test %ebx,%ebx
490: 7e 14 jle 4a6 <memmove+0x26>
n = n*10 + *s++ - '0';
return n;
}
void*
memmove(void *vdst, void *vsrc, int n)
492: 31 d2 xor %edx,%edx
494: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
*dst++ = *src++;
498: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
49c: 88 0c 10 mov %cl,(%eax,%edx,1)
49f: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
4a2: 39 da cmp %ebx,%edx
4a4: 75 f2 jne 498 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
4a6: 5b pop %ebx
4a7: 5e pop %esi
4a8: 5d pop %ebp
4a9: c3 ret
4aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
000004b0 <stat>:
return buf;
}
int
stat(char *n, struct stat *st)
{
4b0: 55 push %ebp
4b1: 89 e5 mov %esp,%ebp
4b3: 83 ec 18 sub $0x18,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
4b6: 8b 45 08 mov 0x8(%ebp),%eax
return buf;
}
int
stat(char *n, struct stat *st)
{
4b9: 89 5d f8 mov %ebx,-0x8(%ebp)
4bc: 89 75 fc mov %esi,-0x4(%ebp)
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
4bf: be ff ff ff ff mov $0xffffffff,%esi
stat(char *n, struct stat *st)
{
int fd;
int r;
fd = open(n, O_RDONLY);
4c4: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
4cb: 00
4cc: 89 04 24 mov %eax,(%esp)
4cf: e8 d1 00 00 00 call 5a5 <open>
if(fd < 0)
4d4: 85 c0 test %eax,%eax
stat(char *n, struct stat *st)
{
int fd;
int r;
fd = open(n, O_RDONLY);
4d6: 89 c3 mov %eax,%ebx
if(fd < 0)
4d8: 78 19 js 4f3 <stat+0x43>
return -1;
r = fstat(fd, st);
4da: 8b 45 0c mov 0xc(%ebp),%eax
4dd: 89 1c 24 mov %ebx,(%esp)
4e0: 89 44 24 04 mov %eax,0x4(%esp)
4e4: e8 d4 00 00 00 call 5bd <fstat>
close(fd);
4e9: 89 1c 24 mov %ebx,(%esp)
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
r = fstat(fd, st);
4ec: 89 c6 mov %eax,%esi
close(fd);
4ee: e8 9a 00 00 00 call 58d <close>
return r;
}
4f3: 89 f0 mov %esi,%eax
4f5: 8b 5d f8 mov -0x8(%ebp),%ebx
4f8: 8b 75 fc mov -0x4(%ebp),%esi
4fb: 89 ec mov %ebp,%esp
4fd: 5d pop %ebp
4fe: c3 ret
4ff: 90 nop
00000500 <gets>:
return 0;
}
char*
gets(char *buf, int max)
{
500: 55 push %ebp
501: 89 e5 mov %esp,%ebp
503: 57 push %edi
504: 56 push %esi
505: 31 f6 xor %esi,%esi
507: 53 push %ebx
508: 83 ec 2c sub $0x2c,%esp
50b: 8b 7d 08 mov 0x8(%ebp),%edi
int i, cc;
char c;
for(i=0; i+1 < max; ){
50e: eb 06 jmp 516 <gets+0x16>
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
510: 3c 0a cmp $0xa,%al
512: 74 39 je 54d <gets+0x4d>
514: 89 de mov %ebx,%esi
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
516: 8d 5e 01 lea 0x1(%esi),%ebx
519: 3b 5d 0c cmp 0xc(%ebp),%ebx
51c: 7d 31 jge 54f <gets+0x4f>
cc = read(0, &c, 1);
51e: 8d 45 e7 lea -0x19(%ebp),%eax
521: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
528: 00
529: 89 44 24 04 mov %eax,0x4(%esp)
52d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
534: e8 44 00 00 00 call 57d <read>
if(cc < 1)
539: 85 c0 test %eax,%eax
53b: 7e 12 jle 54f <gets+0x4f>
break;
buf[i++] = c;
53d: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
541: 88 44 1f ff mov %al,-0x1(%edi,%ebx,1)
if(c == '\n' || c == '\r')
545: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
549: 3c 0d cmp $0xd,%al
54b: 75 c3 jne 510 <gets+0x10>
54d: 89 de mov %ebx,%esi
break;
}
buf[i] = '\0';
54f: c6 04 37 00 movb $0x0,(%edi,%esi,1)
return buf;
}
553: 89 f8 mov %edi,%eax
555: 83 c4 2c add $0x2c,%esp
558: 5b pop %ebx
559: 5e pop %esi
55a: 5f pop %edi
55b: 5d pop %ebp
55c: c3 ret
0000055d <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
55d: b8 01 00 00 00 mov $0x1,%eax
562: cd 40 int $0x40
564: c3 ret
00000565 <exit>:
SYSCALL(exit)
565: b8 02 00 00 00 mov $0x2,%eax
56a: cd 40 int $0x40
56c: c3 ret
0000056d <wait>:
SYSCALL(wait)
56d: b8 03 00 00 00 mov $0x3,%eax
572: cd 40 int $0x40
574: c3 ret
00000575 <pipe>:
SYSCALL(pipe)
575: b8 04 00 00 00 mov $0x4,%eax
57a: cd 40 int $0x40
57c: c3 ret
0000057d <read>:
SYSCALL(read)
57d: b8 05 00 00 00 mov $0x5,%eax
582: cd 40 int $0x40
584: c3 ret
00000585 <write>:
SYSCALL(write)
585: b8 10 00 00 00 mov $0x10,%eax
58a: cd 40 int $0x40
58c: c3 ret
0000058d <close>:
SYSCALL(close)
58d: b8 15 00 00 00 mov $0x15,%eax
592: cd 40 int $0x40
594: c3 ret
00000595 <kill>:
SYSCALL(kill)
595: b8 06 00 00 00 mov $0x6,%eax
59a: cd 40 int $0x40
59c: c3 ret
0000059d <exec>:
SYSCALL(exec)
59d: b8 07 00 00 00 mov $0x7,%eax
5a2: cd 40 int $0x40
5a4: c3 ret
000005a5 <open>:
SYSCALL(open)
5a5: b8 0f 00 00 00 mov $0xf,%eax
5aa: cd 40 int $0x40
5ac: c3 ret
000005ad <mknod>:
SYSCALL(mknod)
5ad: b8 11 00 00 00 mov $0x11,%eax
5b2: cd 40 int $0x40
5b4: c3 ret
000005b5 <unlink>:
SYSCALL(unlink)
5b5: b8 12 00 00 00 mov $0x12,%eax
5ba: cd 40 int $0x40
5bc: c3 ret
000005bd <fstat>:
SYSCALL(fstat)
5bd: b8 08 00 00 00 mov $0x8,%eax
5c2: cd 40 int $0x40
5c4: c3 ret
000005c5 <link>:
SYSCALL(link)
5c5: b8 13 00 00 00 mov $0x13,%eax
5ca: cd 40 int $0x40
5cc: c3 ret
000005cd <mkdir>:
SYSCALL(mkdir)
5cd: b8 14 00 00 00 mov $0x14,%eax
5d2: cd 40 int $0x40
5d4: c3 ret
000005d5 <chdir>:
SYSCALL(chdir)
5d5: b8 09 00 00 00 mov $0x9,%eax
5da: cd 40 int $0x40
5dc: c3 ret
000005dd <dup>:
SYSCALL(dup)
5dd: b8 0a 00 00 00 mov $0xa,%eax
5e2: cd 40 int $0x40
5e4: c3 ret
000005e5 <getpid>:
SYSCALL(getpid)
5e5: b8 0b 00 00 00 mov $0xb,%eax
5ea: cd 40 int $0x40
5ec: c3 ret
000005ed <sbrk>:
SYSCALL(sbrk)
5ed: b8 0c 00 00 00 mov $0xc,%eax
5f2: cd 40 int $0x40
5f4: c3 ret
000005f5 <sleep>:
SYSCALL(sleep)
5f5: b8 0d 00 00 00 mov $0xd,%eax
5fa: cd 40 int $0x40
5fc: c3 ret
000005fd <uptime>:
SYSCALL(uptime)
5fd: b8 0e 00 00 00 mov $0xe,%eax
602: cd 40 int $0x40
604: c3 ret
00000605 <date>:
SYSCALL(date)
605: b8 16 00 00 00 mov $0x16,%eax
60a: cd 40 int $0x40
60c: c3 ret
0000060d <alarm>:
SYSCALL(alarm)
60d: b8 17 00 00 00 mov $0x17,%eax
612: cd 40 int $0x40
614: c3 ret
615: 66 90 xchg %ax,%ax
617: 66 90 xchg %ax,%ax
619: 66 90 xchg %ax,%ax
61b: 66 90 xchg %ax,%ax
61d: 66 90 xchg %ax,%ax
61f: 90 nop
00000620 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
620: 55 push %ebp
621: 89 e5 mov %esp,%ebp
623: 57 push %edi
624: 89 cf mov %ecx,%edi
626: 56 push %esi
627: 89 c6 mov %eax,%esi
629: 53 push %ebx
62a: 83 ec 4c sub $0x4c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
62d: 8b 4d 08 mov 0x8(%ebp),%ecx
630: 85 c9 test %ecx,%ecx
632: 74 04 je 638 <printint+0x18>
634: 85 d2 test %edx,%edx
636: 78 70 js 6a8 <printint+0x88>
neg = 1;
x = -xx;
} else {
x = xx;
638: 89 d0 mov %edx,%eax
63a: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
641: 31 c9 xor %ecx,%ecx
643: 8d 5d d7 lea -0x29(%ebp),%ebx
646: 66 90 xchg %ax,%ax
}
i = 0;
do{
buf[i++] = digits[x % base];
648: 31 d2 xor %edx,%edx
64a: f7 f7 div %edi
64c: 0f b6 92 75 0a 00 00 movzbl 0xa75(%edx),%edx
653: 88 14 0b mov %dl,(%ebx,%ecx,1)
656: 83 c1 01 add $0x1,%ecx
}while((x /= base) != 0);
659: 85 c0 test %eax,%eax
65b: 75 eb jne 648 <printint+0x28>
if(neg)
65d: 8b 45 c4 mov -0x3c(%ebp),%eax
660: 85 c0 test %eax,%eax
662: 74 08 je 66c <printint+0x4c>
buf[i++] = '-';
664: c6 44 0d d7 2d movb $0x2d,-0x29(%ebp,%ecx,1)
669: 83 c1 01 add $0x1,%ecx
while(--i >= 0)
66c: 8d 79 ff lea -0x1(%ecx),%edi
66f: 01 fb add %edi,%ebx
671: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
678: 0f b6 03 movzbl (%ebx),%eax
67b: 83 ef 01 sub $0x1,%edi
67e: 83 eb 01 sub $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
681: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
688: 00
689: 89 34 24 mov %esi,(%esp)
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
68c: 88 45 e7 mov %al,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
68f: 8d 45 e7 lea -0x19(%ebp),%eax
692: 89 44 24 04 mov %eax,0x4(%esp)
696: e8 ea fe ff ff call 585 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
69b: 83 ff ff cmp $0xffffffff,%edi
69e: 75 d8 jne 678 <printint+0x58>
putc(fd, buf[i]);
}
6a0: 83 c4 4c add $0x4c,%esp
6a3: 5b pop %ebx
6a4: 5e pop %esi
6a5: 5f pop %edi
6a6: 5d pop %ebp
6a7: c3 ret
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
6a8: 89 d0 mov %edx,%eax
6aa: f7 d8 neg %eax
6ac: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
6b3: eb 8c jmp 641 <printint+0x21>
6b5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
6b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000006c0 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
6c0: 55 push %ebp
6c1: 89 e5 mov %esp,%ebp
6c3: 57 push %edi
6c4: 56 push %esi
6c5: 53 push %ebx
6c6: 83 ec 3c sub $0x3c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
6c9: 8b 45 0c mov 0xc(%ebp),%eax
6cc: 0f b6 10 movzbl (%eax),%edx
6cf: 84 d2 test %dl,%dl
6d1: 0f 84 c9 00 00 00 je 7a0 <printf+0xe0>
char *s;
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
6d7: 8d 4d 10 lea 0x10(%ebp),%ecx
6da: 31 ff xor %edi,%edi
6dc: 89 4d d4 mov %ecx,-0x2c(%ebp)
6df: 31 db xor %ebx,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
6e1: 8d 75 e7 lea -0x19(%ebp),%esi
6e4: eb 1e jmp 704 <printf+0x44>
6e6: 66 90 xchg %ax,%ax
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
6e8: 83 fa 25 cmp $0x25,%edx
6eb: 0f 85 b7 00 00 00 jne 7a8 <printf+0xe8>
6f1: 66 bf 25 00 mov $0x25,%di
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
6f5: 83 c3 01 add $0x1,%ebx
6f8: 0f b6 14 18 movzbl (%eax,%ebx,1),%edx
6fc: 84 d2 test %dl,%dl
6fe: 0f 84 9c 00 00 00 je 7a0 <printf+0xe0>
c = fmt[i] & 0xff;
if(state == 0){
704: 85 ff test %edi,%edi
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
706: 0f b6 d2 movzbl %dl,%edx
if(state == 0){
709: 74 dd je 6e8 <printf+0x28>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
70b: 83 ff 25 cmp $0x25,%edi
70e: 75 e5 jne 6f5 <printf+0x35>
if(c == 'd'){
710: 83 fa 64 cmp $0x64,%edx
713: 0f 84 47 01 00 00 je 860 <printf+0x1a0>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
719: 83 fa 70 cmp $0x70,%edx
71c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
720: 0f 84 aa 00 00 00 je 7d0 <printf+0x110>
726: 83 fa 78 cmp $0x78,%edx
729: 0f 84 a1 00 00 00 je 7d0 <printf+0x110>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
72f: 83 fa 73 cmp $0x73,%edx
732: 0f 84 c0 00 00 00 je 7f8 <printf+0x138>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
738: 83 fa 63 cmp $0x63,%edx
73b: 90 nop
73c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
740: 0f 84 42 01 00 00 je 888 <printf+0x1c8>
putc(fd, *ap);
ap++;
} else if(c == '%'){
746: 83 fa 25 cmp $0x25,%edx
749: 0f 84 01 01 00 00 je 850 <printf+0x190>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
74f: 8b 4d 08 mov 0x8(%ebp),%ecx
752: 89 55 cc mov %edx,-0x34(%ebp)
755: c6 45 e7 25 movb $0x25,-0x19(%ebp)
759: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
760: 00
761: 89 74 24 04 mov %esi,0x4(%esp)
765: 89 0c 24 mov %ecx,(%esp)
768: e8 18 fe ff ff call 585 <write>
76d: 8b 55 cc mov -0x34(%ebp),%edx
770: 88 55 e7 mov %dl,-0x19(%ebp)
773: 8b 45 08 mov 0x8(%ebp),%eax
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
776: 83 c3 01 add $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
779: 31 ff xor %edi,%edi
77b: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
782: 00
783: 89 74 24 04 mov %esi,0x4(%esp)
787: 89 04 24 mov %eax,(%esp)
78a: e8 f6 fd ff ff call 585 <write>
78f: 8b 45 0c mov 0xc(%ebp),%eax
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
792: 0f b6 14 18 movzbl (%eax,%ebx,1),%edx
796: 84 d2 test %dl,%dl
798: 0f 85 66 ff ff ff jne 704 <printf+0x44>
79e: 66 90 xchg %ax,%ax
putc(fd, c);
}
state = 0;
}
}
}
7a0: 83 c4 3c add $0x3c,%esp
7a3: 5b pop %ebx
7a4: 5e pop %esi
7a5: 5f pop %edi
7a6: 5d pop %ebp
7a7: c3 ret
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
7a8: 8b 45 08 mov 0x8(%ebp),%eax
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
7ab: 88 55 e7 mov %dl,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
7ae: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
7b5: 00
7b6: 89 74 24 04 mov %esi,0x4(%esp)
7ba: 89 04 24 mov %eax,(%esp)
7bd: e8 c3 fd ff ff call 585 <write>
7c2: 8b 45 0c mov 0xc(%ebp),%eax
7c5: e9 2b ff ff ff jmp 6f5 <printf+0x35>
7ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
7d0: 8b 45 d4 mov -0x2c(%ebp),%eax
7d3: b9 10 00 00 00 mov $0x10,%ecx
ap++;
7d8: 31 ff xor %edi,%edi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
7da: c7 04 24 00 00 00 00 movl $0x0,(%esp)
7e1: 8b 10 mov (%eax),%edx
7e3: 8b 45 08 mov 0x8(%ebp),%eax
7e6: e8 35 fe ff ff call 620 <printint>
7eb: 8b 45 0c mov 0xc(%ebp),%eax
ap++;
7ee: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
7f2: e9 fe fe ff ff jmp 6f5 <printf+0x35>
7f7: 90 nop
} else if(c == 's'){
s = (char*)*ap;
7f8: 8b 55 d4 mov -0x2c(%ebp),%edx
ap++;
if(s == 0)
7fb: b9 6e 0a 00 00 mov $0xa6e,%ecx
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
s = (char*)*ap;
800: 8b 3a mov (%edx),%edi
ap++;
802: 83 c2 04 add $0x4,%edx
805: 89 55 d4 mov %edx,-0x2c(%ebp)
if(s == 0)
808: 85 ff test %edi,%edi
80a: 0f 44 f9 cmove %ecx,%edi
s = "(null)";
while(*s != 0){
80d: 0f b6 17 movzbl (%edi),%edx
810: 84 d2 test %dl,%dl
812: 74 33 je 847 <printf+0x187>
814: 89 5d d0 mov %ebx,-0x30(%ebp)
817: 8b 5d 08 mov 0x8(%ebp),%ebx
81a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
putc(fd, *s);
s++;
820: 83 c7 01 add $0x1,%edi
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
823: 88 55 e7 mov %dl,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
826: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
82d: 00
82e: 89 74 24 04 mov %esi,0x4(%esp)
832: 89 1c 24 mov %ebx,(%esp)
835: e8 4b fd ff ff call 585 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
83a: 0f b6 17 movzbl (%edi),%edx
83d: 84 d2 test %dl,%dl
83f: 75 df jne 820 <printf+0x160>
841: 8b 5d d0 mov -0x30(%ebp),%ebx
844: 8b 45 0c mov 0xc(%ebp),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
847: 31 ff xor %edi,%edi
849: e9 a7 fe ff ff jmp 6f5 <printf+0x35>
84e: 66 90 xchg %ax,%ax
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
ap++;
} else if(c == '%'){
850: c6 45 e7 25 movb $0x25,-0x19(%ebp)
854: e9 1a ff ff ff jmp 773 <printf+0xb3>
859: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
860: 8b 45 d4 mov -0x2c(%ebp),%eax
863: b9 0a 00 00 00 mov $0xa,%ecx
ap++;
868: 66 31 ff xor %di,%di
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
86b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
872: 8b 10 mov (%eax),%edx
874: 8b 45 08 mov 0x8(%ebp),%eax
877: e8 a4 fd ff ff call 620 <printint>
87c: 8b 45 0c mov 0xc(%ebp),%eax
ap++;
87f: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
883: e9 6d fe ff ff jmp 6f5 <printf+0x35>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
888: 8b 55 d4 mov -0x2c(%ebp),%edx
putc(fd, *ap);
ap++;
88b: 31 ff xor %edi,%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
88d: 8b 4d 08 mov 0x8(%ebp),%ecx
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
890: 8b 02 mov (%edx),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
892: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
899: 00
89a: 89 74 24 04 mov %esi,0x4(%esp)
89e: 89 0c 24 mov %ecx,(%esp)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
8a1: 88 45 e7 mov %al,-0x19(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
8a4: e8 dc fc ff ff call 585 <write>
8a9: 8b 45 0c mov 0xc(%ebp),%eax
putc(fd, *s);
s++;
}
} else if(c == 'c'){
putc(fd, *ap);
ap++;
8ac: 83 45 d4 04 addl $0x4,-0x2c(%ebp)
8b0: e9 40 fe ff ff jmp 6f5 <printf+0x35>
8b5: 66 90 xchg %ax,%ax
8b7: 66 90 xchg %ax,%ax
8b9: 66 90 xchg %ax,%ax
8bb: 66 90 xchg %ax,%ax
8bd: 66 90 xchg %ax,%ax
8bf: 90 nop
000008c0 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
8c0: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
8c1: a1 a8 0a 00 00 mov 0xaa8,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
8c6: 89 e5 mov %esp,%ebp
8c8: 57 push %edi
8c9: 56 push %esi
8ca: 53 push %ebx
8cb: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
bp = (Header*)ap - 1;
8ce: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
8d1: 39 c8 cmp %ecx,%eax
8d3: 73 1d jae 8f2 <free+0x32>
8d5: 8d 76 00 lea 0x0(%esi),%esi
8d8: 8b 10 mov (%eax),%edx
8da: 39 d1 cmp %edx,%ecx
8dc: 72 1a jb 8f8 <free+0x38>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
8de: 39 d0 cmp %edx,%eax
8e0: 72 08 jb 8ea <free+0x2a>
8e2: 39 c8 cmp %ecx,%eax
8e4: 72 12 jb 8f8 <free+0x38>
8e6: 39 d1 cmp %edx,%ecx
8e8: 72 0e jb 8f8 <free+0x38>
8ea: 89 d0 mov %edx,%eax
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
8ec: 39 c8 cmp %ecx,%eax
8ee: 66 90 xchg %ax,%ax
8f0: 72 e6 jb 8d8 <free+0x18>
8f2: 8b 10 mov (%eax),%edx
8f4: eb e8 jmp 8de <free+0x1e>
8f6: 66 90 xchg %ax,%ax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
8f8: 8b 71 04 mov 0x4(%ecx),%esi
8fb: 8d 3c f1 lea (%ecx,%esi,8),%edi
8fe: 39 d7 cmp %edx,%edi
900: 74 19 je 91b <free+0x5b>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
902: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
905: 8b 50 04 mov 0x4(%eax),%edx
908: 8d 34 d0 lea (%eax,%edx,8),%esi
90b: 39 ce cmp %ecx,%esi
90d: 74 23 je 932 <free+0x72>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
90f: 89 08 mov %ecx,(%eax)
freep = p;
911: a3 a8 0a 00 00 mov %eax,0xaa8
}
916: 5b pop %ebx
917: 5e pop %esi
918: 5f pop %edi
919: 5d pop %ebp
91a: c3 ret
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
bp->s.size += p->s.ptr->s.size;
91b: 03 72 04 add 0x4(%edx),%esi
91e: 89 71 04 mov %esi,0x4(%ecx)
bp->s.ptr = p->s.ptr->s.ptr;
921: 8b 10 mov (%eax),%edx
923: 8b 12 mov (%edx),%edx
925: 89 53 f8 mov %edx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
928: 8b 50 04 mov 0x4(%eax),%edx
92b: 8d 34 d0 lea (%eax,%edx,8),%esi
92e: 39 ce cmp %ecx,%esi
930: 75 dd jne 90f <free+0x4f>
p->s.size += bp->s.size;
932: 03 51 04 add 0x4(%ecx),%edx
935: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
938: 8b 53 f8 mov -0x8(%ebx),%edx
93b: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
93d: a3 a8 0a 00 00 mov %eax,0xaa8
}
942: 5b pop %ebx
943: 5e pop %esi
944: 5f pop %edi
945: 5d pop %ebp
946: c3 ret
947: 89 f6 mov %esi,%esi
949: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000950 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
950: 55 push %ebp
951: 89 e5 mov %esp,%ebp
953: 57 push %edi
954: 56 push %esi
955: 53 push %ebx
956: 83 ec 2c sub $0x2c,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
959: 8b 5d 08 mov 0x8(%ebp),%ebx
if((prevp = freep) == 0){
95c: 8b 0d a8 0a 00 00 mov 0xaa8,%ecx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
962: 83 c3 07 add $0x7,%ebx
965: c1 eb 03 shr $0x3,%ebx
968: 83 c3 01 add $0x1,%ebx
if((prevp = freep) == 0){
96b: 85 c9 test %ecx,%ecx
96d: 0f 84 9b 00 00 00 je a0e <malloc+0xbe>
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
973: 8b 01 mov (%ecx),%eax
if(p->s.size >= nunits){
975: 8b 50 04 mov 0x4(%eax),%edx
978: 39 d3 cmp %edx,%ebx
97a: 76 27 jbe 9a3 <malloc+0x53>
p->s.size -= nunits;
p += p->s.size;
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
97c: 8d 3c dd 00 00 00 00 lea 0x0(,%ebx,8),%edi
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
983: be 00 80 00 00 mov $0x8000,%esi
988: 89 7d e4 mov %edi,-0x1c(%ebp)
98b: 90 nop
98c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
990: 3b 05 a8 0a 00 00 cmp 0xaa8,%eax
996: 74 30 je 9c8 <malloc+0x78>
998: 89 c1 mov %eax,%ecx
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
99a: 8b 01 mov (%ecx),%eax
if(p->s.size >= nunits){
99c: 8b 50 04 mov 0x4(%eax),%edx
99f: 39 d3 cmp %edx,%ebx
9a1: 77 ed ja 990 <malloc+0x40>
if(p->s.size == nunits)
9a3: 39 d3 cmp %edx,%ebx
9a5: 74 61 je a08 <malloc+0xb8>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
9a7: 29 da sub %ebx,%edx
9a9: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
9ac: 8d 04 d0 lea (%eax,%edx,8),%eax
p->s.size = nunits;
9af: 89 58 04 mov %ebx,0x4(%eax)
}
freep = prevp;
9b2: 89 0d a8 0a 00 00 mov %ecx,0xaa8
return (void*)(p + 1);
9b8: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
9bb: 83 c4 2c add $0x2c,%esp
9be: 5b pop %ebx
9bf: 5e pop %esi
9c0: 5f pop %edi
9c1: 5d pop %ebp
9c2: c3 ret
9c3: 90 nop
9c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
morecore(uint nu)
{
char *p;
Header *hp;
if(nu < 4096)
9c8: 8b 45 e4 mov -0x1c(%ebp),%eax
9cb: 81 fb 00 10 00 00 cmp $0x1000,%ebx
9d1: bf 00 10 00 00 mov $0x1000,%edi
9d6: 0f 43 fb cmovae %ebx,%edi
9d9: 0f 42 c6 cmovb %esi,%eax
nu = 4096;
p = sbrk(nu * sizeof(Header));
9dc: 89 04 24 mov %eax,(%esp)
9df: e8 09 fc ff ff call 5ed <sbrk>
if(p == (char*)-1)
9e4: 83 f8 ff cmp $0xffffffff,%eax
9e7: 74 18 je a01 <malloc+0xb1>
return 0;
hp = (Header*)p;
hp->s.size = nu;
9e9: 89 78 04 mov %edi,0x4(%eax)
free((void*)(hp + 1));
9ec: 83 c0 08 add $0x8,%eax
9ef: 89 04 24 mov %eax,(%esp)
9f2: e8 c9 fe ff ff call 8c0 <free>
return freep;
9f7: 8b 0d a8 0a 00 00 mov 0xaa8,%ecx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
9fd: 85 c9 test %ecx,%ecx
9ff: 75 99 jne 99a <malloc+0x4a>
if((prevp = freep) == 0){
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){
a01: 31 c0 xor %eax,%eax
a03: eb b6 jmp 9bb <malloc+0x6b>
a05: 8d 76 00 lea 0x0(%esi),%esi
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
a08: 8b 10 mov (%eax),%edx
a0a: 89 11 mov %edx,(%ecx)
a0c: eb a4 jmp 9b2 <malloc+0x62>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
a0e: c7 05 a8 0a 00 00 a0 movl $0xaa0,0xaa8
a15: 0a 00 00
base.s.size = 0;
a18: b9 a0 0a 00 00 mov $0xaa0,%ecx
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
a1d: c7 05 a0 0a 00 00 a0 movl $0xaa0,0xaa0
a24: 0a 00 00
base.s.size = 0;
a27: c7 05 a4 0a 00 00 00 movl $0x0,0xaa4
a2e: 00 00 00
a31: e9 3d ff ff ff jmp 973 <malloc+0x23>
|
oeis/030/A030631.asm
|
neoneye/loda-programs
| 11 |
11519
|
; A030631: Numbers with 13 divisors.
; Submitted by <NAME>
; 4096,531441,244140625,13841287201,3138428376721,23298085122481,582622237229761,2213314919066161,21914624432020321,353814783205469041,787662783788549761,6582952005840035281,22563490300366186081,39959630797262576401,116191483108948578241,491258904256726154641,1779197418239532716881,2654348974297586158321,8182718904632857144561,16409682740640811134241,22902048046490258711521,59091511031674153381441,106890007738661124410161,246990403565262140303521,693842360995438000295041,1126825030131969720661201
mul $0,2
max $0,1
seq $0,173919 ; Numbers that are prime or one less than a prime.
pow $0,12
|
other.7z/SFC.7z/SFC/ソースデータ/ゼルダの伝説神々のトライフォース/ドイツ_PAL/Ger_asm/z11_char0.asm
|
prismotizm/gigaleak
| 0 |
5600
|
<reponame>prismotizm/gigaleak<filename>other.7z/SFC.7z/SFC/ソースデータ/ゼルダの伝説神々のトライフォース/ドイツ_PAL/Ger_asm/z11_char0.asm<gh_stars>0
Name: z11_char0.asm
Type: file
Size: 109786
Last-Modified: '2016-05-13T04:23:03Z'
SHA-1: F55283280B463784FB5E4A340B83AAB5856BD0A5
Description: null
|
Lists/SortList.agda
|
Smaug123/agdaproofs
| 4 |
927
|
<reponame>Smaug123/agdaproofs<gh_stars>1-10
{-# OPTIONS --safe --warning=error --without-K #-}
open import LogicalFormulae
open import Numbers.Naturals.Definition
open import Numbers.Naturals.Order
open import Numbers.Naturals.Naturals -- for length
open import Lists.Lists
open import Orders.Partial.Definition
open import Orders.Total.Definition
open import Functions.Definition
open import Agda.Primitive using (Level; lzero; lsuc; _⊔_)
open import Groups.FinitePermutations
open import Boolean.Definition
module Lists.SortList where
isSorted : {a b : _} {A : Set a} (ord : TotalOrder A) (l : List A) → Set (a ⊔ b)
isSorted ord [] = True'
isSorted ord (x :: []) = True'
isSorted ord (x :: (y :: l)) = (TotalOrder._≤_ ord x y) && (isSorted ord (y :: l))
sortedTailIsSorted : {a b : _} {A : Set a} (ord : TotalOrder A) → (x : A) → (l : List A) → (isSorted ord (x :: l)) → isSorted ord l
sortedTailIsSorted ord x [] pr = record {}
sortedTailIsSorted ord x (y :: l) (fst ,, snd) = snd
insert : {a b : _} {A : Set a} (ord : TotalOrder A) → (l : List A) → (isSorted ord l) → (x : A) → List A
insert ord [] pr x = [ x ]
insert ord (y :: l) pr x with TotalOrder.totality ord x y
insert ord (y :: l) pr x | inl (inl x<y) = x :: (y :: l)
insert ord (y :: l) pr x | inl (inr y<x) = y :: insert ord l (sortedTailIsSorted ord y l pr) x
insert ord (y :: l) pr x | inr x=y = x :: (y :: l)
insertionIncreasesLength : {a b : _} {A : Set a} (ord : TotalOrder A) → (l : List A) → (x : A) → (pr : isSorted ord l) → length (insert ord l pr x) ≡ succ (length l)
insertionIncreasesLength ord [] x pr = refl
insertionIncreasesLength ord (y :: l) x pr with TotalOrder.totality ord x y
insertionIncreasesLength ord (y :: l) x pr | inl (inl x<y) = refl
insertionIncreasesLength ord (y :: l) x pr | inl (inr y<x) = applyEquality succ (insertionIncreasesLength ord l x (sortedTailIsSorted ord y l pr))
insertionIncreasesLength ord (y :: l) x pr | inr x=y = refl
isEmpty : {a : _} {A : Set a} (l : List A) → Bool
isEmpty [] = BoolTrue
isEmpty (x :: l) = BoolFalse
minList : {a b : _} {A : Set a} (ord : TotalOrder A) → (l : List A) → (isEmpty l ≡ BoolFalse) → A
minList ord [] ()
minList ord (x :: []) pr = x
minList ord (x :: (y :: l)) refl with minList ord (y :: l) refl
minList ord (x :: (y :: l)) refl | minSoFar with TotalOrder.totality ord x minSoFar
minList ord (x :: (y :: l)) refl | minSoFar | inl (inl x<m) = x
minList ord (x :: (y :: l)) refl | minSoFar | inl (inr m<x) = minSoFar
minList ord (x :: (y :: l)) refl | minSoFar | inr x=m = x
insertionSorts : {a b : _} {A : Set a} (ord : TotalOrder A) → (l : List A) → (pr : isSorted ord l) → (x : A) → isSorted ord (insert ord l pr x)
insertionSorts ord [] _ _ = record {}
insertionSorts ord (y :: l) pr x with TotalOrder.totality ord x y
insertionSorts ord (y :: l) pr x | inl (inl x<y) = inl x<y ,, pr
insertionSorts ord (y :: l) pr x | inl (inr y<x) with insertionSorts ord l (sortedTailIsSorted ord y l pr) x
... | bl = {!!}
insertionSorts ord (y :: l) pr x | inr x=y = inr x=y ,, pr
orderNotLessThanAndEqual : {a b : _} {A : Set a} (ord : TotalOrder A) → {x y : A} → (x ≡ y) → TotalOrder._<_ ord x y → False
orderNotLessThanAndEqual ord {x} {y} x=y x<y rewrite x=y = PartialOrder.irreflexive (TotalOrder.order ord) x<y
orderToDecidableEquality : {a b : _} {A : Set a} (ord : TotalOrder A) → {x y : A} → (x ≡ y) || ((x ≡ y) → False)
orderToDecidableEquality ord {x} {y} with TotalOrder.totality ord x y
orderToDecidableEquality ord {x} {y} | inl (inl x<y) = inr λ x=y → orderNotLessThanAndEqual ord x=y x<y
orderToDecidableEquality ord {x} {y} | inl (inr y<x) = inr λ x=y → orderNotLessThanAndEqual ord (equalityCommutative x=y) y<x
orderToDecidableEquality ord {x} {y} | inr x=y = inl x=y
--SortingAlgorithm : {a b : _} → Set (lsuc a ⊔ lsuc b)
--SortingAlgorithm {a} {b} = {A : Set a} → (ord : TotalOrder {a} {b} A) → (input : List A) → Sg (List A) (λ l → isSorted ord l && isPermutation (orderToDecidableEquality ord) l input)
insertionSort : {a b : _} {A : Set a} (ord : TotalOrder A) (l : List A) → List A
insertionSortIsSorted : {a b : _} {A : Set a} (ord : TotalOrder A) (l : List A) → isSorted ord (insertionSort ord l)
insertionSort ord [] = []
insertionSort ord (x :: l) = insert ord (insertionSort ord l) (insertionSortIsSorted ord l) x
insertionSortIsSorted ord [] = record {}
insertionSortIsSorted ord (x :: l) = insertionSorts ord (insertionSort ord l) (insertionSortIsSorted ord l) x
insertionSortLength : {a b : _} {A : Set a} (ord : TotalOrder A) (l : List A) → length l ≡ length (insertionSort ord l)
insertionSortLength ord [] = refl
insertionSortLength ord (x :: l) rewrite insertionIncreasesLength ord (insertionSort ord l) x (insertionSortIsSorted ord l) = {!!} --applyEquality succ (insertionSortLength ord l)
isPermutation : {a b : _} {A : Set a} (ord : TotalOrder A) → (l m : List A) → Set a
isPermutation ord l m = insertionSort ord l ≡ insertionSort ord m
--insertionSort : {a b : _} → SortingAlgorithm {a} {b}
--insertionSort {A = A} ord l = {!!}
-- where
-- lemma : Sg (List A) (isSorted ord) → (x : A) → Sg (List A) (isSorted ord)
-- lemma (l , b) x = insert ord l b x , insertionSorts ord l b x
--InsertionSort : {a b : _} → SortingAlgorithm {a} {b}
--InsertionSort ord l = insertionSort ord l
lexicographicOrderRel : {a b : _} {A : Set a} → (TotalOrder A) → Rel {a} {a ⊔ b} (List A)
lexicographicOrderRel _ [] [] = False'
lexicographicOrderRel _ [] (x :: l2) = True'
lexicographicOrderRel _ (x :: l1) [] = False'
lexicographicOrderRel order (x :: l1) (y :: l2) = (TotalOrder._<_ order x y) || ((x ≡ y) && lexicographicOrderRel order l1 l2)
lexIrrefl : {a b : _} {A : Set a} (o : TotalOrder A) → {x : List A} → lexicographicOrderRel o x x → False
lexIrrefl o {[]} ()
lexIrrefl o {x :: l} (inl x<x) = PartialOrder.irreflexive (TotalOrder.order o) x<x
lexIrrefl o {x :: l} (inr (pr ,, l=l)) = lexIrrefl o {l} l=l
lexTransitive : {a b : _} {A : Set a} (o : TotalOrder A) → {x y z : List A} → lexicographicOrderRel o x y → lexicographicOrderRel o y z → lexicographicOrderRel o x z
lexTransitive o {[]} {[]} {z} x<y y<z = y<z
lexTransitive o {[]} {x :: y} {[]} record {} y<z = y<z
lexTransitive o {[]} {x :: y} {x₁ :: z} record {} y<z = record {}
lexTransitive o {x :: xs} {[]} {z} () y<z
lexTransitive o {x :: xs} {y :: ys} {[]} (inl x<y) ()
lexTransitive o {x :: xs} {y :: ys} {z :: zs} (inl x<y) (inl y<z) = inl (PartialOrder.<Transitive (TotalOrder.order o) x<y y<z)
lexTransitive o {x :: xs} {y :: ys} {.y :: zs} (inl x<y) (inr (refl ,, ys<zs)) = inl x<y
lexTransitive o {x :: xs} {.x :: ys} {[]} (inr (refl ,, xs<ys)) ()
lexTransitive o {x :: xs} {.x :: ys} {z :: zs} (inr (refl ,, xs<ys)) (inl y<z) = inl y<z
lexTransitive o {x :: xs} {.x :: ys} {.x :: zs} (inr (refl ,, xs<ys)) (inr (refl ,, u)) = inr (refl ,, lexTransitive o xs<ys u)
lexTotal : {a b : _} {A : Set a} (o : TotalOrder A) → (x y : List A) → ((lexicographicOrderRel o x y) || (lexicographicOrderRel o y x)) || (x ≡ y)
lexTotal o [] [] = inr refl
lexTotal o [] (x :: y) = inl (inl (record {}))
lexTotal o (x :: xs) [] = inl (inr (record {}))
lexTotal o (x :: xs) (y :: ys) with TotalOrder.totality o x y
lexTotal o (x :: xs) (y :: ys) | inl (inl x<y) = inl (inl (inl x<y))
lexTotal o (x :: xs) (y :: ys) | inl (inr y<x) = inl (inr (inl y<x))
lexTotal o (x :: xs) (y :: ys) | inr x=y with lexTotal o xs ys
lexTotal o (x :: xs) (y :: ys) | inr x=y | inl (inl xs<ys) = inl (inl (inr (x=y ,, xs<ys)))
lexTotal o (x :: xs) (y :: ys) | inr x=y | inl (inr ys<xs) = inl (inr (inr (equalityCommutative x=y ,, ys<xs)))
lexTotal o (x :: xs) (y :: ys) | inr x=y | inr xs=ys rewrite x=y | xs=ys = inr refl
lexicographicOrder : {a b : _} {A : Set a} → (TotalOrder A) → TotalOrder (List A)
PartialOrder._<_ (TotalOrder.order (lexicographicOrder order)) = lexicographicOrderRel order
PartialOrder.irreflexive (TotalOrder.order (lexicographicOrder order)) = lexIrrefl order
PartialOrder.<Transitive (TotalOrder.order (lexicographicOrder order)) = lexTransitive order
TotalOrder.totality (lexicographicOrder order) = lexTotal order
badSort : {a b : _} {A : Set a} (order : TotalOrder A) → ℕ → List A → List A
badSortLength : {a b : _} {A : Set a} (order : TotalOrder A) → (n : ℕ) → (l : List A) → length (badSort order n l) ≡ length l
allTrueRespectsBadsort : {a b c : _} {A : Set a} (order : TotalOrder A) → (n : ℕ) → (l : List A) → (pred : A → Set c) → allTrue pred l → allTrue pred (badSort order n l)
badSort order zero = insertionSort order
badSort order (succ n) [] = []
badSort {A = A} order (succ n) (x :: l) = head (badSort (lexicographicOrder order) n (permutations (x :: l))) bsNonempty
where
bs : List (List A)
bs = badSort (lexicographicOrder order) n (permutations (x :: l))
bsNonempty : 0 <N length bs
bsNonempty with bs
bsNonempty | [] = {!!}
bsNonempty | bl :: _ = succIsPositive _
allTrueRespectsBadsort order n [] pred record {} = {!!}
allTrueRespectsBadsort order n (x :: l) pred (fst ,, snd) = {!!}
badSortLength order zero [] = refl
badSortLength order zero (x :: l) = transitivity (insertionIncreasesLength order (insertionSort order l) x (insertionSortIsSorted order l)) (applyEquality succ (equalityCommutative (insertionSortLength order l)))
badSortLength order (succ n) [] = refl
badSortLength order (succ n) (x :: l) = {!!}
where
allLen : allTrue (λ i → length i ≡ succ (length l)) (badSort (lexicographicOrder order) n (flatten (map (allInsertions x) (permutations l))))
allLen = {!!}
-- TODO: show that insertion sort actually produces a permutation
|
programs/oeis/326/A326658.asm
|
karttu/loda
| 1 |
22643
|
<reponame>karttu/loda<filename>programs/oeis/326/A326658.asm
; A326658: a(n) = 6*floor(n/2) + ceiling((n-1)^2/2).
; 1,0,7,8,17,20,31,36,49,56,71,80,97,108,127,140,161,176,199,216,241,260,287,308,337,360,391,416,449,476,511,540,577,608,647,680,721,756,799,836,881,920,967,1008,1057,1100,1151,1196,1249,1296,1351,1400,1457,1508,1567,1620,1681,1736,1799,1856,1921,1980,2047,2108,2177,2240,2311,2376,2449,2516,2591,2660,2737,2808,2887,2960,3041,3116,3199,3276,3361,3440,3527,3608,3697,3780,3871,3956,4049,4136,4231,4320,4417,4508,4607,4700,4801,4896,4999,5096,5201,5300,5407,5508,5617,5720,5831,5936,6049,6156,6271,6380,6497,6608,6727,6840,6961,7076,7199,7316,7441,7560,7687,7808,7937,8060,8191,8316,8449,8576,8711,8840,8977,9108,9247,9380,9521,9656,9799,9936,10081,10220,10367,10508,10657,10800,10951,11096,11249,11396,11551,11700,11857,12008,12167,12320,12481,12636,12799,12956,13121,13280,13447,13608,13777,13940,14111,14276,14449,14616,14791,14960,15137,15308,15487,15660,15841,16016,16199,16376,16561,16740,16927,17108,17297,17480,17671,17856,18049,18236,18431,18620,18817,19008,19207,19400,19601,19796,19999,20196,20401,20600,20807,21008,21217,21420,21631,21836,22049,22256,22471,22680,22897,23108,23327,23540,23761,23976,24199,24416,24641,24860,25087,25308,25537,25760,25991,26216,26449,26676,26911,27140,27377,27608,27847,28080,28321,28556,28799,29036,29281,29520,29767,30008,30257,30500,30751,30996,31249,31496
add $0,1
mov $1,$0
gcd $0,2
pow $0,3
add $1,1
pow $1,2
sub $1,1
sub $1,$0
sub $1,2
div $1,2
mul $1,2
add $1,2
div $1,2
|
lib/server-core/src/main/antlr4/org/apache/olingo/server/core/uri/antlr/UriParser.g4
|
mtaal/olingo-odata4-jpa
| 0 |
4407
|
<reponame>mtaal/olingo-odata4-jpa
/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.
******************************************************************************/
grammar UriParser;
//------------------------------------------------------------------------------
// This grammar refers to the "odata-abnf-construction-rules.txt" Revision 517.
// URL: https://tools.oasis-open.org/version-control/browse/wsvn/odata/trunk/spec/ABNF/odata-abnf-construction-rules.txt?rev=517
// While contructing this grammar we tried to keep it close to the ABNF.
// However this is not really possible in order to support
// - percent decoding
// - operator precedence
// - having a context free grammar ( without java snipplets to add context)
// - generating the parser in different target languages
// Currently not supported are
// - $search
// - geometry data
// - json data in url
//------------------------------------------------------------------------------
options {
language = Java;
tokenVocab = UriLexer;
}
//;------------------------------------------------------------------------------
//; 0. URI
//;------------------------------------------------------------------------------
batchEOF : BATCH EOF;
entityEOF : vNS=namespace vODI=odataIdentifier;
metadataEOF : METADATA EOF;
//;------------------------------------------------------------------------------
//; 1. Resource Path
//;------------------------------------------------------------------------------
//resourcePathEOF : vlPS=pathSegments EOF;
crossjoinEOF : CROSSJOIN OPEN WSP? vlODI+=odataIdentifier WSP? ( COMMA WSP? vlODI+=odataIdentifier WSP?)* CLOSE EOF;
allEOF : ALL;
pathSegmentEOF : (pathSegment | constSegment) EOF;
pathSegments : vlPS+=pathSegment (SLASH vlPS+=pathSegment)* (SLASH vCS=constSegment)?;
pathSegment : vNS=namespace? vODI=odataIdentifier vlNVO+=nameValueOptList*;
nameValueOptList : OPEN (vVO=commonExpr | vNVL=nameValueList)? CLOSE;
nameValueList : WSP* vlNVP+=nameValuePair WSP* ( COMMA WSP* vlNVP+=nameValuePair WSP*)* ;
nameValuePair : vODI=odataIdentifier EQ (AT vALI=odataIdentifier | vCOM=commonExpr /*TODO | val2=enumX*/);
constSegment : (vV=value | vC=count | vR=ref | vAll=allExpr | vAny=anyExpr);
count : COUNT;
ref : REF;
value : VALUE;
//;------------------------------------------------------------------------------
//; 2. Query Options
//;------------------------------------------------------------------------------
queryOptions : vlQO+=queryOption ( AMP vlQO+=queryOption )*;//TODO can this be removed
queryOption : systemQueryOption;
systemQueryOption : expand
| filter
| inlinecount
| orderBy
| search
| select
| skip
| skiptoken
| top
;
skiptoken : SKIPTOKEN EQ REST;
expand : EXPAND EQ expandItems;
expandItemsEOF : expandItems EOF;
expandItems : vlEI+=expandItem ( COMMA vlEI+=expandItem )*;
expandItem : vS=STAR ( SLASH vR=ref | OPEN LEVELS EQ ( vL=INT | vM=MAX) CLOSE )?
| vEP=expandPath vEPE=expandPathExtension?;
expandPath : vlPS+=pathSegment (SLASH vlPS+=pathSegment)*;
expandPathExtension : OPEN vlEO+=expandOption ( SEMI vlEO+=expandOption )* CLOSE
| SLASH vR=ref ( OPEN vlEOR+=expandRefOption ( SEMI vlEOR+=expandRefOption )* CLOSE )?
| SLASH vC=count ( OPEN vlEOC+=expandCountOption ( SEMI vlEOC+=expandCountOption )* CLOSE )?
;
expandCountOption : filter
| search
;
expandRefOption : expandCountOption
| orderBy
| skip
| top
| inlinecount
;
expandOption : expandRefOption
| select
| expand
| levels;
levels : LEVELS EQ ( INT | MAX );
filter : FILTER EQ commonExpr;
filterExpressionEOF : commonExpr EOF;
orderBy : ORDERBY EQ orderList;
orderByEOF : orderList EOF;
orderList : vlOI+=orderByItem ( WSP* COMMA WSP* vlOI+=orderByItem )*;
orderByItem : vC=commonExpr ( WSP ( vA=ASC | vD=DESC ) )?;
skip : SKIP_QO EQ INT;
top : TOP EQ INT;
//format : FORMAT EQ ( ATOM | JSON | XML | PCHARS SLASH PCHARS);
inlinecount : COUNT EQ booleanNonCase;
search : SEARCH searchSpecialToken;
searchInline : SEARCH_INLINE searchSpecialToken;
searchSpecialToken : EQ WSP? searchExpr;
searchExpr : (NOT WSP) searchExpr
| searchExpr searchExpr
| searchExpr WSP searchExpr
| searchExpr ( WSP AND WSP) searchExpr
| searchExpr ( WSP OR WSP) searchExpr
| searchPhrase
| searchWord
;
searchPhrase : SEARCHPHRASE;
searchWord : SEARCHWORD;
select : SELECT EQ vlSI+=selectItem ( COMMA vlSI+=selectItem )*;
selectEOF : vlSI+=selectItem ( COMMA vlSI+=selectItem )*;
selectItem : vlSS+=selectSegment ( SLASH vlSS+=selectSegment ) *;
selectSegment : vNS=namespace? ( vODI=odataIdentifier | vS=STAR );
aliasAndValue : vODI=ODATAIDENTIFIER EQ vV=parameterValue;
parameterValue : commonExpr //TODO json not supported arrayOrObject
;
//;------------------------------------------------------------------------------
//; 3. Context URL Fragments
//;------------------------------------------------------------------------------
contextFragment : REST; // the context fragment is only required on the client side
//;------------------------------------------------------------------------------
//; 4. Expressions
//;------------------------------------------------------------------------------
commonExpr : OPEN commonExpr CLOSE #altPharenthesis
| vE1=commonExpr (WSP HAS WSP) vE2=commonExpr #altHas
| methodCallExpr #altMethod
| ( unary WSP? ) commonExpr #altUnary
| anyExpr #altAny
| allExpr #altAll
| memberExpr #altMember
| vE1=commonExpr (WSP vO=MUL WSP | WSP vO=DIV WSP | WSP vO=MOD WSP ) vE2=commonExpr #altMult
| vE1=commonExpr (WSP vO=ADD WSP | WSP vO=SUB WSP) vE2=commonExpr #altAdd
| vE1=commonExpr (WSP vO=GT WSP | WSP vO=GE WSP | WSP vO=LT WSP
| WSP vO=LE WSP ) vE2=commonExpr #altComparism
| vE1=commonExpr (WSP vO=EQ_ALPHA WSP | WSP vO=NE WSP) vE2=commonExpr #altEquality
| vE1=commonExpr (WSP AND WSP) vE2=commonExpr #altAnd
| vE1=commonExpr (WSP OR WSP) vE2=commonExpr #altOr
| rootExpr #altRoot // $...
| AT odataIdentifier #altAlias // @...
| primitiveLiteral #altLiteral // ...
;
unary : (MINUS| NOT) ;
rootExpr : ROOT vPs=pathSegments;
memberExpr : vIt=IT ( SLASH (vANY=anyExpr | vALL=allExpr))?
| vIts=ITSLASH? vPs=pathSegments ( SLASH (vANY=anyExpr | vALL=allExpr))?;
anyExpr : ANY_LAMDA OPEN WSP? ( vLV=odataIdentifier WSP? COLON WSP? vLE=commonExpr WSP? )? CLOSE;
allExpr : ALL_LAMDA OPEN WSP? vLV=odataIdentifier WSP? COLON WSP? vLE=commonExpr WSP? CLOSE;
methodCallExpr : indexOfMethodCallExpr
| toLowerMethodCallExpr
| toUpperMethodCallExpr
| trimMethodCallExpr
| substringMethodCallExpr
| concatMethodCallExpr
| lengthMethodCallExpr
| yearMethodCallExpr
| monthMethodCallExpr
| dayMethodCallExpr
| hourMethodCallExpr
| minuteMethodCallExpr
| secondMethodCallExpr
| fractionalsecondsMethodCallExpr
| totalsecondsMethodCallExpr
| dateMethodCallExpr
| timeMethodCallExpr
| roundMethodCallExpr
| floorMethodCallExpr
| ceilingMethodCallExpr
| geoDistanceMethodCallExpr
| geoLengthMethodCallExpr
| totalOffsetMinutesMethodCallExpr
| minDateTimeMethodCallExpr
| maxDateTimeMethodCallExpr
| nowMethodCallExpr
//from boolean
| isofExpr
| castExpr
| endsWithMethodCallExpr
| startsWithMethodCallExpr
| containsMethodCallExpr
| geoIntersectsMethodCallExpr
;
containsMethodCallExpr : CONTAINS_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
startsWithMethodCallExpr : STARTSWITH_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
endsWithMethodCallExpr : ENDSWITH_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
lengthMethodCallExpr : LENGTH_WORD WSP? vE1=commonExpr WSP? CLOSE;
indexOfMethodCallExpr : INDEXOF_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
substringMethodCallExpr : SUBSTRING_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? ( COMMA WSP? vE3=commonExpr WSP? )? CLOSE;
toLowerMethodCallExpr : TOLOWER_WORD WSP? vE1=commonExpr WSP? CLOSE;
toUpperMethodCallExpr : TOUPPER_WORD WSP? vE1=commonExpr WSP? CLOSE;
trimMethodCallExpr : TRIM_WORD WSP? vE1=commonExpr WSP? CLOSE;
concatMethodCallExpr : CONCAT_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
yearMethodCallExpr : YEAR_WORD WSP? vE1=commonExpr WSP? CLOSE;
monthMethodCallExpr : MONTH_WORD WSP? vE1=commonExpr WSP? CLOSE;
dayMethodCallExpr : DAY_WORD WSP? vE1=commonExpr WSP? CLOSE;
hourMethodCallExpr : HOUR_WORD WSP? vE1=commonExpr WSP? CLOSE;
minuteMethodCallExpr : MINUTE_WORD WSP? vE1=commonExpr WSP? CLOSE;
secondMethodCallExpr : SECOND_WORD WSP? vE1=commonExpr WSP? CLOSE;
fractionalsecondsMethodCallExpr : FRACTIONALSECONDS_WORD WSP? vE1=commonExpr WSP? CLOSE;
totalsecondsMethodCallExpr : TOTALSECONDS_WORD WSP? vE1=commonExpr WSP? CLOSE;
dateMethodCallExpr : DATE_WORD WSP? vE1=commonExpr WSP? CLOSE;
timeMethodCallExpr : TIME_WORD WSP? vE1=commonExpr WSP? CLOSE;
totalOffsetMinutesMethodCallExpr : TOTALOFFSETMINUTES_WORD WSP? vE1=commonExpr WSP? CLOSE;
minDateTimeMethodCallExpr : MINDATETIME_WORD WSP? CLOSE;
maxDateTimeMethodCallExpr : MAXDATETIME_WORD WSP? CLOSE;
nowMethodCallExpr : NOW_WORD WSP? CLOSE;
roundMethodCallExpr : ROUND_WORD WSP? vE1=commonExpr WSP? CLOSE;
floorMethodCallExpr : FLOOR_WORD WSP? vE1=commonExpr WSP? CLOSE;
ceilingMethodCallExpr : CEILING_WORD WSP? vE1=commonExpr WSP? CLOSE;
geoDistanceMethodCallExpr : GEO_DISTANCE_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
geoLengthMethodCallExpr : GEO_LENGTH_WORD WSP? vE1=commonExpr WSP? CLOSE;
geoIntersectsMethodCallExpr : GEO_INTERSECTS_WORD WSP? vE1=commonExpr WSP? COMMA WSP? vE2=commonExpr WSP? CLOSE;
isofExpr : ISOF_WORD WSP? ( vE1=commonExpr WSP? COMMA WSP? )? vNS=namespace vODI=odataIdentifier WSP? CLOSE;
castExpr : CAST_WORD WSP? ( vE1=commonExpr WSP? COMMA WSP? )? vNS=namespace vODI=odataIdentifier WSP? CLOSE;
//;------------------------------------------------------------------------------
//; 5. JSON format for function parameters
//;------------------------------------------------------------------------------
//; Note: the query part of a URI needs to be partially percent-decoded before
//; applying these rules, see comment at the top of this file
//;------------------------------------------------------------------------------
arrayOrObject : json_array
| json_object;
json_array : BEGIN_ARRAY json_value ( WSP? COMMA WSP? json_value)* END_ARRAY;
json_value : jsonPrimitiv
| rootExpr
| json_object
| json_array;
json_object : BEGIN_OBJECT
STRING_IN_JSON
WSP? COLON WSP?
json_value
END_OBJECT;
//; JSON syntax: adapted to URI restrictions from [RFC4627]
jsonPrimitiv : STRING_IN_JSON
| number_in_json
| TRUE
| FALSE
| 'null'
;
number_in_json : INT | DECIMAL;
//;------------------------------------------------------------------------------
//; 6. Names and identifiers
//;------------------------------------------------------------------------------
qualifiedtypename : namespace odataIdentifier
| 'collection' OPEN ( namespace odataIdentifier ) CLOSE
;
namespace : (odataIdentifier POINT)+;
odataIdentifier : ODATAIDENTIFIER;
//;------------------------------------------------------------------------------
//; 7. Literal Data Values
//;------------------------------------------------------------------------------
primitiveLiteral : nullrule
| booleanNonCase
| DECIMAL //includes double and single literals
| naninfinity
| INT //includes int16/int32 and int64 literals
| BINARY
| DATE
| DATETIMEOFFSET
| DURATION
| GUID
| string
| TIMEOFDAY
| enumLit
| geographyCollection
| geographyLineString
| geographyMultilineString
| geographyMultipoint
| geographyMultipolygon
| geographyPoint
| geographyPolygon
| geometryCollection
| geometryLineString
| geometryMultilineString
| geometryMultipoint
| geometryMultipolygon
| geometryPoint
| geometryPolygon
;
naninfinity : NANINFINITY;
nullrule : NULLVALUE;
booleanNonCase : BOOLEAN | TRUE | FALSE;
string : STRING;
enumLit : vNS=namespace vODI=odataIdentifier vValues=STRING;
enumValues : vlODI+=odataIdentifier ( COMMA vlODI+=odataIdentifier )*;
geographyCollection : GEOGRAPHY fullCollectionLiteral SQUOTE;
fullCollectionLiteral : sridLiteral collectionLiteral;
collectionLiteral : (COLLECTION ) OPEN geoLiteral ( COMMA geoLiteral )* CLOSE;
geoLiteral : collectionLiteral
| lineStringLiteral
| multipointLiteral
| multilineStringLiteral
| multipolygonLiteral
| pointLiteral
| polygonLiteral;
geographyLineString : GEOGRAPHY fullLineStringLiteral SQUOTE;
fullLineStringLiteral : sridLiteral lineStringLiteral;
lineStringLiteral : LINESTRING lineStringData;
lineStringData : OPEN positionLiteral ( COMMA positionLiteral )* CLOSE;
geographyMultilineString : GEOGRAPHY fullMultilineStringLiteral SQUOTE;
fullMultilineStringLiteral : sridLiteral multilineStringLiteral;
multilineStringLiteral : MULTILINESTRING OPEN ( lineStringData ( COMMA lineStringData )* )? CLOSE;
geographyMultipoint : GEOGRAPHY fullMultipointLiteral SQUOTE;
fullMultipointLiteral : sridLiteral multipointLiteral;
multipointLiteral : MULTIPOINT OPEN ( pointData ( COMMA pointData )* )? CLOSE ;
geographyMultipolygon : GEOGRAPHY fullmultipolygonLiteral SQUOTE;
fullmultipolygonLiteral : sridLiteral multipolygonLiteral;
multipolygonLiteral : MULTIPOLYGON OPEN ( polygonData ( COMMA polygonData )* )? CLOSE;
geographyPoint : GEOGRAPHY fullpointLiteral SQUOTE;
fullpointLiteral : sridLiteral pointLiteral;
pointLiteral : GEO_POINT pointData;
pointData : OPEN positionLiteral CLOSE;
positionLiteral : (DECIMAL | INT ) WSP (DECIMAL | INT ); //; longitude, then latitude
geographyPolygon : GEOGRAPHY fullPolygonLiteral SQUOTE;
fullPolygonLiteral : sridLiteral polygonLiteral;
polygonLiteral : POLYGON polygonData;
polygonData : OPEN ringLiteral ( COMMA ringLiteral )* CLOSE;
ringLiteral : OPEN positionLiteral ( COMMA positionLiteral )* CLOSE;
geometryCollection : GEOMETRY fullCollectionLiteral SQUOTE;
geometryLineString : GEOMETRY fullLineStringLiteral SQUOTE;
geometryMultilineString : GEOMETRY fullMultilineStringLiteral SQUOTE;
geometryMultipoint : GEOMETRY fullMultipointLiteral SQUOTE;
geometryMultipolygon : GEOMETRY fullmultipolygonLiteral SQUOTE;
geometryPoint : GEOMETRY fullpointLiteral SQUOTE;
geometryPolygon : GEOMETRY fullPolygonLiteral SQUOTE;
sridLiteral : SRID EQ INT SEMI;
|
oeis/066/A066343.asm
|
neoneye/loda-programs
| 11 |
4492
|
<reponame>neoneye/loda-programs<gh_stars>10-100
; A066343: Beatty sequence for log_2(10).
; Submitted by <NAME>
; 3,6,9,13,16,19,23,26,29,33,36,39,43,46,49,53,56,59,63,66,69,73,76,79,83,86,89,93,96,99,102,106,109,112,116,119,122,126,129,132,136,139,142,146,149,152,156,159,162,166,169,172,176,179,182,186,189,192,195,199,202,205,209,212,215,219,222,225,229,232,235,239,242,245,249,252,255,259,262,265,269,272,275,279,282,285,289,292,295,298,302,305,308,312,315,318,322,325,328,332
seq $0,199685 ; a(n) = 5*10^n+1.
mov $2,1
lpb $0
div $0,2
add $2,1
lpe
mov $0,$2
sub $0,1
|
examples/object_hierarchy/labels.adb
|
glencornell/ada-object-framework
| 0 |
852
|
<gh_stars>0
with Ada.Text_Io;
with Ada.Strings.Unbounded;
package body Labels is
procedure Paint_Event (This : in out Label'Class) is
begin
Ada.Text_Io.Put_Line("Labels.Paint_Event() called");
Ada.Text_Io.Put_Line(" Label_Text = """ & Ada.Strings.Unbounded.To_String(This.Label_Text.Get) & """");
end;
end Labels;
|
sources/int.asm
|
gpont/TSU_ASM
| 0 |
99953
|
<reponame>gpont/TSU_ASM
global change_int
section .text
change_int:
; r8 = x / 100 * 100
mov rax, rdi
mov rbx, 100
xor rdx, rdx
div rbx
mul rbx
mov r8, rax
; r8 += x % 10 * 10
mov rax, rdi ; rax = x
mov rbx, 10
xor rdx, rdx
idiv rbx
mov rax, rdx
mul rbx
add r8, rax
; r8 += x % 100 / 10
mov rax, rdi ; rax = x
mov rbx, 100
xor rdx, rdx
idiv rbx
mov rax, rdx
mov rbx, 10
xor rdx, rdx
div rbx
add r8, rax
mov rax, r8
ret
|
2A/S7/SysConc/TP/TP6/b__lr-main.ads
|
MOUDDENEHamza/ENSEEIHT
| 4 |
26394
|
pragma Ada_95;
pragma Warnings (Off);
with System;
package ada_main is
gnat_argc : Integer;
gnat_argv : System.Address;
gnat_envp : System.Address;
pragma Import (C, gnat_argc);
pragma Import (C, gnat_argv);
pragma Import (C, gnat_envp);
gnat_exit_status : Integer;
pragma Import (C, gnat_exit_status);
GNAT_Version : constant String :=
"GNAT Version: 7.5.0" & ASCII.NUL;
pragma Export (C, GNAT_Version, "__gnat_version");
Ada_Main_Program_Name : constant String := "_ada_lr__main" & ASCII.NUL;
pragma Export (C, Ada_Main_Program_Name, "__gnat_ada_main_program_name");
procedure adainit;
pragma Export (C, adainit, "adainit");
procedure adafinal;
pragma Export (C, adafinal, "adafinal");
function main
(argc : Integer;
argv : System.Address;
envp : System.Address)
return Integer;
pragma Export (C, main, "main");
type Version_32 is mod 2 ** 32;
u00001 : constant Version_32 := 16#b3f00408#;
pragma Export (C, u00001, "lr__mainB");
u00002 : constant Version_32 := 16#b6df930e#;
pragma Export (C, u00002, "system__standard_libraryB");
u00003 : constant Version_32 := 16#7ec093d3#;
pragma Export (C, u00003, "system__standard_libraryS");
u00004 : constant Version_32 := 16#76789da1#;
pragma Export (C, u00004, "adaS");
u00005 : constant Version_32 := 16#c0061b29#;
pragma Export (C, u00005, "ada__command_lineB");
u00006 : constant Version_32 := 16#9c1a321d#;
pragma Export (C, u00006, "ada__command_lineS");
u00007 : constant Version_32 := 16#4635ec04#;
pragma Export (C, u00007, "systemS");
u00008 : constant Version_32 := 16#30ad09e5#;
pragma Export (C, u00008, "system__secondary_stackB");
u00009 : constant Version_32 := 16#fca7137e#;
pragma Export (C, u00009, "system__secondary_stackS");
u00010 : constant Version_32 := 16#b01dad17#;
pragma Export (C, u00010, "system__parametersB");
u00011 : constant Version_32 := 16#381fe17b#;
pragma Export (C, u00011, "system__parametersS");
u00012 : constant Version_32 := 16#4e7785b8#;
pragma Export (C, u00012, "system__soft_linksB");
u00013 : constant Version_32 := 16#d8b13451#;
pragma Export (C, u00013, "system__soft_linksS");
u00014 : constant Version_32 := 16#c2326fda#;
pragma Export (C, u00014, "ada__exceptionsB");
u00015 : constant Version_32 := 16#6e98a13f#;
pragma Export (C, u00015, "ada__exceptionsS");
u00016 : constant Version_32 := 16#e947e6a9#;
pragma Export (C, u00016, "ada__exceptions__last_chance_handlerB");
u00017 : constant Version_32 := 16#41e5552e#;
pragma Export (C, u00017, "ada__exceptions__last_chance_handlerS");
u00018 : constant Version_32 := 16#87a448ff#;
pragma Export (C, u00018, "system__exception_tableB");
u00019 : constant Version_32 := 16#1b9b8546#;
pragma Export (C, u00019, "system__exception_tableS");
u00020 : constant Version_32 := 16#ce4af020#;
pragma Export (C, u00020, "system__exceptionsB");
u00021 : constant Version_32 := 16#2e5681f2#;
pragma Export (C, u00021, "system__exceptionsS");
u00022 : constant Version_32 := 16#843d48dc#;
pragma Export (C, u00022, "system__exceptions__machineS");
u00023 : constant Version_32 := 16#aa0563fc#;
pragma Export (C, u00023, "system__exceptions_debugB");
u00024 : constant Version_32 := 16#38bf15c0#;
pragma Export (C, u00024, "system__exceptions_debugS");
u00025 : constant Version_32 := 16#6c2f8802#;
pragma Export (C, u00025, "system__img_intB");
u00026 : constant Version_32 := 16#44ee0cc6#;
pragma Export (C, u00026, "system__img_intS");
u00027 : constant Version_32 := 16#f103f468#;
pragma Export (C, u00027, "system__storage_elementsB");
u00028 : constant Version_32 := 16#6bf6a600#;
pragma Export (C, u00028, "system__storage_elementsS");
u00029 : constant Version_32 := 16#39df8c17#;
pragma Export (C, u00029, "system__tracebackB");
u00030 : constant Version_32 := 16#181732c0#;
pragma Export (C, u00030, "system__tracebackS");
u00031 : constant Version_32 := 16#9ed49525#;
pragma Export (C, u00031, "system__traceback_entriesB");
u00032 : constant Version_32 := 16#466e1a74#;
pragma Export (C, u00032, "system__traceback_entriesS");
u00033 : constant Version_32 := 16#6fd210f2#;
pragma Export (C, u00033, "system__traceback__symbolicB");
u00034 : constant Version_32 := 16#dd19f67a#;
pragma Export (C, u00034, "system__traceback__symbolicS");
u00035 : constant Version_32 := 16#701f9d88#;
pragma Export (C, u00035, "ada__exceptions__tracebackB");
u00036 : constant Version_32 := 16#20245e75#;
pragma Export (C, u00036, "ada__exceptions__tracebackS");
u00037 : constant Version_32 := 16#9f00b3d3#;
pragma Export (C, u00037, "system__address_imageB");
u00038 : constant Version_32 := 16#e7d9713e#;
pragma Export (C, u00038, "system__address_imageS");
u00039 : constant Version_32 := 16#8c33a517#;
pragma Export (C, u00039, "system__wch_conB");
u00040 : constant Version_32 := 16#5d48ced6#;
pragma Export (C, u00040, "system__wch_conS");
u00041 : constant Version_32 := 16#9721e840#;
pragma Export (C, u00041, "system__wch_stwB");
u00042 : constant Version_32 := 16#7059e2d7#;
pragma Export (C, u00042, "system__wch_stwS");
u00043 : constant Version_32 := 16#a831679c#;
pragma Export (C, u00043, "system__wch_cnvB");
u00044 : constant Version_32 := 16#52ff7425#;
pragma Export (C, u00044, "system__wch_cnvS");
u00045 : constant Version_32 := 16#5ab55268#;
pragma Export (C, u00045, "interfacesS");
u00046 : constant Version_32 := 16#ece6fdb6#;
pragma Export (C, u00046, "system__wch_jisB");
u00047 : constant Version_32 := 16#d28f6d04#;
pragma Export (C, u00047, "system__wch_jisS");
u00048 : constant Version_32 := 16#41837d1e#;
pragma Export (C, u00048, "system__stack_checkingB");
u00049 : constant Version_32 := 16#c88a87ec#;
pragma Export (C, u00049, "system__stack_checkingS");
u00050 : constant Version_32 := 16#3d17c74c#;
pragma Export (C, u00050, "ada__tagsB");
u00051 : constant Version_32 := 16#5a4e344a#;
pragma Export (C, u00051, "ada__tagsS");
u00052 : constant Version_32 := 16#c3335bfd#;
pragma Export (C, u00052, "system__htableB");
u00053 : constant Version_32 := 16#c2f75fee#;
pragma Export (C, u00053, "system__htableS");
u00054 : constant Version_32 := 16#089f5cd0#;
pragma Export (C, u00054, "system__string_hashB");
u00055 : constant Version_32 := 16#60a93490#;
pragma Export (C, u00055, "system__string_hashS");
u00056 : constant Version_32 := 16#72b39087#;
pragma Export (C, u00056, "system__unsigned_typesS");
u00057 : constant Version_32 := 16#afdbf393#;
pragma Export (C, u00057, "system__val_lluB");
u00058 : constant Version_32 := 16#0841c7f5#;
pragma Export (C, u00058, "system__val_lluS");
u00059 : constant Version_32 := 16#27b600b2#;
pragma Export (C, u00059, "system__val_utilB");
u00060 : constant Version_32 := 16#ea955afa#;
pragma Export (C, u00060, "system__val_utilS");
u00061 : constant Version_32 := 16#d1060688#;
pragma Export (C, u00061, "system__case_utilB");
u00062 : constant Version_32 := 16#623c85d3#;
pragma Export (C, u00062, "system__case_utilS");
u00063 : constant Version_32 := 16#1d1c6062#;
pragma Export (C, u00063, "ada__text_ioB");
u00064 : constant Version_32 := 16#e1e47390#;
pragma Export (C, u00064, "ada__text_ioS");
u00065 : constant Version_32 := 16#10558b11#;
pragma Export (C, u00065, "ada__streamsB");
u00066 : constant Version_32 := 16#67e31212#;
pragma Export (C, u00066, "ada__streamsS");
u00067 : constant Version_32 := 16#92d882c5#;
pragma Export (C, u00067, "ada__io_exceptionsS");
u00068 : constant Version_32 := 16#4c01b69c#;
pragma Export (C, u00068, "interfaces__c_streamsB");
u00069 : constant Version_32 := 16#b1330297#;
pragma Export (C, u00069, "interfaces__c_streamsS");
u00070 : constant Version_32 := 16#36a43a0a#;
pragma Export (C, u00070, "system__crtlS");
u00071 : constant Version_32 := 16#4db84b5a#;
pragma Export (C, u00071, "system__file_ioB");
u00072 : constant Version_32 := 16#e1440d61#;
pragma Export (C, u00072, "system__file_ioS");
u00073 : constant Version_32 := 16#86c56e5a#;
pragma Export (C, u00073, "ada__finalizationS");
u00074 : constant Version_32 := 16#95817ed8#;
pragma Export (C, u00074, "system__finalization_rootB");
u00075 : constant Version_32 := 16#09c79f94#;
pragma Export (C, u00075, "system__finalization_rootS");
u00076 : constant Version_32 := 16#769e25e6#;
pragma Export (C, u00076, "interfaces__cB");
u00077 : constant Version_32 := 16#70be4e8c#;
pragma Export (C, u00077, "interfaces__cS");
u00078 : constant Version_32 := 16#cc2ce7a7#;
pragma Export (C, u00078, "system__os_libB");
u00079 : constant Version_32 := 16#c1e9580f#;
pragma Export (C, u00079, "system__os_libS");
u00080 : constant Version_32 := 16#1a817b8e#;
pragma Export (C, u00080, "system__stringsB");
u00081 : constant Version_32 := 16#388afd62#;
pragma Export (C, u00081, "system__stringsS");
u00082 : constant Version_32 := 16#bbaa76ac#;
pragma Export (C, u00082, "system__file_control_blockS");
u00083 : constant Version_32 := 16#1dc17f27#;
pragma Export (C, u00083, "gdkS");
u00084 : constant Version_32 := 16#28f464b7#;
pragma Export (C, u00084, "glibB");
u00085 : constant Version_32 := 16#1f2a5709#;
pragma Export (C, u00085, "glibS");
u00086 : constant Version_32 := 16#56258f93#;
pragma Export (C, u00086, "interfaces__c__stringsB");
u00087 : constant Version_32 := 16#603c1c44#;
pragma Export (C, u00087, "interfaces__c__stringsS");
u00088 : constant Version_32 := 16#6abe5dbe#;
pragma Export (C, u00088, "system__finalization_mastersB");
u00089 : constant Version_32 := 16#1dc9d5ce#;
pragma Export (C, u00089, "system__finalization_mastersS");
u00090 : constant Version_32 := 16#7268f812#;
pragma Export (C, u00090, "system__img_boolB");
u00091 : constant Version_32 := 16#b3ec9def#;
pragma Export (C, u00091, "system__img_boolS");
u00092 : constant Version_32 := 16#d7aac20c#;
pragma Export (C, u00092, "system__ioB");
u00093 : constant Version_32 := 16#d8771b4b#;
pragma Export (C, u00093, "system__ioS");
u00094 : constant Version_32 := 16#6d4d969a#;
pragma Export (C, u00094, "system__storage_poolsB");
u00095 : constant Version_32 := 16#65d872a9#;
pragma Export (C, u00095, "system__storage_poolsS");
u00096 : constant Version_32 := 16#5a895de2#;
pragma Export (C, u00096, "system__pool_globalB");
u00097 : constant Version_32 := 16#7141203e#;
pragma Export (C, u00097, "system__pool_globalS");
u00098 : constant Version_32 := 16#a6359005#;
pragma Export (C, u00098, "system__memoryB");
u00099 : constant Version_32 := 16#1f488a30#;
pragma Export (C, u00099, "system__memoryS");
u00100 : constant Version_32 := 16#3c420900#;
pragma Export (C, u00100, "system__stream_attributesB");
u00101 : constant Version_32 := 16#8bc30a4e#;
pragma Export (C, u00101, "system__stream_attributesS");
u00102 : constant Version_32 := 16#4a3bb5b9#;
pragma Export (C, u00102, "gdk__threadsS");
u00103 : constant Version_32 := 16#f77d0a23#;
pragma Export (C, u00103, "gtkS");
u00104 : constant Version_32 := 16#39d7ffc5#;
pragma Export (C, u00104, "glib__objectB");
u00105 : constant Version_32 := 16#39b9e54c#;
pragma Export (C, u00105, "glib__objectS");
u00106 : constant Version_32 := 16#398f61a7#;
pragma Export (C, u00106, "glib__type_conversion_hooksB");
u00107 : constant Version_32 := 16#a1077887#;
pragma Export (C, u00107, "glib__type_conversion_hooksS");
u00108 : constant Version_32 := 16#a2250034#;
pragma Export (C, u00108, "system__storage_pools__subpoolsB");
u00109 : constant Version_32 := 16#cc5a1856#;
pragma Export (C, u00109, "system__storage_pools__subpoolsS");
u00110 : constant Version_32 := 16#9aad1ff1#;
pragma Export (C, u00110, "system__storage_pools__subpools__finalizationB");
u00111 : constant Version_32 := 16#fe2f4b3a#;
pragma Export (C, u00111, "system__storage_pools__subpools__finalizationS");
u00112 : constant Version_32 := 16#57aea1c7#;
pragma Export (C, u00112, "gtkadaS");
u00113 : constant Version_32 := 16#2d37d0e9#;
pragma Export (C, u00113, "gtkada__bindingsB");
u00114 : constant Version_32 := 16#41ee9189#;
pragma Export (C, u00114, "gtkada__bindingsS");
u00115 : constant Version_32 := 16#fd2ad2f1#;
pragma Export (C, u00115, "gnatS");
u00116 : constant Version_32 := 16#b48102f5#;
pragma Export (C, u00116, "gnat__ioB");
u00117 : constant Version_32 := 16#6227e843#;
pragma Export (C, u00117, "gnat__ioS");
u00118 : constant Version_32 := 16#b4645806#;
pragma Export (C, u00118, "gnat__stringsS");
u00119 : constant Version_32 := 16#b24069f0#;
pragma Export (C, u00119, "glib__typesB");
u00120 : constant Version_32 := 16#be0fd491#;
pragma Export (C, u00120, "glib__typesS");
u00121 : constant Version_32 := 16#da6548be#;
pragma Export (C, u00121, "glib__valuesB");
u00122 : constant Version_32 := 16#9a712d6b#;
pragma Export (C, u00122, "glib__valuesS");
u00123 : constant Version_32 := 16#100afe53#;
pragma Export (C, u00123, "gtkada__cB");
u00124 : constant Version_32 := 16#2f8a78b7#;
pragma Export (C, u00124, "gtkada__cS");
u00125 : constant Version_32 := 16#6fb6efdc#;
pragma Export (C, u00125, "gtkada__typesB");
u00126 : constant Version_32 := 16#d40fa06f#;
pragma Export (C, u00126, "gtkada__typesS");
u00127 : constant Version_32 := 16#52f1910f#;
pragma Export (C, u00127, "system__assertionsB");
u00128 : constant Version_32 := 16#8bb8c090#;
pragma Export (C, u00128, "system__assertionsS");
u00129 : constant Version_32 := 16#4d2a14c0#;
pragma Export (C, u00129, "glib__glistB");
u00130 : constant Version_32 := 16#eebfbf6a#;
pragma Export (C, u00130, "glib__glistS");
u00131 : constant Version_32 := 16#5d07bab0#;
pragma Export (C, u00131, "glib__gslistB");
u00132 : constant Version_32 := 16#1e2c1f6a#;
pragma Export (C, u00132, "glib__gslistS");
u00133 : constant Version_32 := 16#96654b76#;
pragma Export (C, u00133, "gtk__mainB");
u00134 : constant Version_32 := 16#93840c30#;
pragma Export (C, u00134, "gtk__mainS");
u00135 : constant Version_32 := 16#b4d788c2#;
pragma Export (C, u00135, "gdk__deviceB");
u00136 : constant Version_32 := 16#c9780f0d#;
pragma Export (C, u00136, "gdk__deviceS");
u00137 : constant Version_32 := 16#3872f91d#;
pragma Export (C, u00137, "system__fat_lfltS");
u00138 : constant Version_32 := 16#525494e7#;
pragma Export (C, u00138, "gdk__displayB");
u00139 : constant Version_32 := 16#17ea0596#;
pragma Export (C, u00139, "gdk__displayS");
u00140 : constant Version_32 := 16#8864eae5#;
pragma Export (C, u00140, "gtk__argumentsB");
u00141 : constant Version_32 := 16#0c59c504#;
pragma Export (C, u00141, "gtk__argumentsS");
u00142 : constant Version_32 := 16#b2f795ff#;
pragma Export (C, u00142, "cairoB");
u00143 : constant Version_32 := 16#6d761559#;
pragma Export (C, u00143, "cairoS");
u00144 : constant Version_32 := 16#50ae1241#;
pragma Export (C, u00144, "cairo__regionB");
u00145 : constant Version_32 := 16#02f4aa20#;
pragma Export (C, u00145, "cairo__regionS");
u00146 : constant Version_32 := 16#e6b5eeff#;
pragma Export (C, u00146, "gdk__eventB");
u00147 : constant Version_32 := 16#42740b8b#;
pragma Export (C, u00147, "gdk__eventS");
u00148 : constant Version_32 := 16#4a5104bd#;
pragma Export (C, u00148, "gdk__rectangleB");
u00149 : constant Version_32 := 16#9777a203#;
pragma Export (C, u00149, "gdk__rectangleS");
u00150 : constant Version_32 := 16#3a352b4e#;
pragma Export (C, u00150, "gdk__typesS");
u00151 : constant Version_32 := 16#f7b4e583#;
pragma Export (C, u00151, "glib__generic_propertiesB");
u00152 : constant Version_32 := 16#1b85bc6f#;
pragma Export (C, u00152, "glib__generic_propertiesS");
u00153 : constant Version_32 := 16#c8a0f177#;
pragma Export (C, u00153, "gdk__rgbaB");
u00154 : constant Version_32 := 16#831a93c5#;
pragma Export (C, u00154, "gdk__rgbaS");
u00155 : constant Version_32 := 16#289449ee#;
pragma Export (C, u00155, "gtk__dialogB");
u00156 : constant Version_32 := 16#1fbe37eb#;
pragma Export (C, u00156, "gtk__dialogS");
u00157 : constant Version_32 := 16#767ee440#;
pragma Export (C, u00157, "gtk__settingsB");
u00158 : constant Version_32 := 16#13108370#;
pragma Export (C, u00158, "gtk__settingsS");
u00159 : constant Version_32 := 16#b53f0479#;
pragma Export (C, u00159, "gdk__screenB");
u00160 : constant Version_32 := 16#d8d13641#;
pragma Export (C, u00160, "gdk__screenS");
u00161 : constant Version_32 := 16#cf3c2289#;
pragma Export (C, u00161, "gdk__visualB");
u00162 : constant Version_32 := 16#d31693cd#;
pragma Export (C, u00162, "gdk__visualS");
u00163 : constant Version_32 := 16#9d1ec083#;
pragma Export (C, u00163, "glib__propertiesB");
u00164 : constant Version_32 := 16#9a0498d3#;
pragma Export (C, u00164, "glib__propertiesS");
u00165 : constant Version_32 := 16#1e40f010#;
pragma Export (C, u00165, "system__fat_fltS");
u00166 : constant Version_32 := 16#68deb447#;
pragma Export (C, u00166, "gtk__enumsB");
u00167 : constant Version_32 := 16#a2c26854#;
pragma Export (C, u00167, "gtk__enumsS");
u00168 : constant Version_32 := 16#0afdbaf0#;
pragma Export (C, u00168, "gtk__style_providerB");
u00169 : constant Version_32 := 16#25d000b8#;
pragma Export (C, u00169, "gtk__style_providerS");
u00170 : constant Version_32 := 16#f92cef61#;
pragma Export (C, u00170, "gtk__widgetB");
u00171 : constant Version_32 := 16#8773c891#;
pragma Export (C, u00171, "gtk__widgetS");
u00172 : constant Version_32 := 16#07a81f6e#;
pragma Export (C, u00172, "gdk__colorB");
u00173 : constant Version_32 := 16#91d65177#;
pragma Export (C, u00173, "gdk__colorS");
u00174 : constant Version_32 := 16#e5a592cc#;
pragma Export (C, u00174, "gdk__drag_contextsB");
u00175 : constant Version_32 := 16#3906662b#;
pragma Export (C, u00175, "gdk__drag_contextsS");
u00176 : constant Version_32 := 16#3eedb1c2#;
pragma Export (C, u00176, "gdk__frame_clockB");
u00177 : constant Version_32 := 16#a8f4a3b7#;
pragma Export (C, u00177, "gdk__frame_clockS");
u00178 : constant Version_32 := 16#4ac70f16#;
pragma Export (C, u00178, "gdk__frame_timingsB");
u00179 : constant Version_32 := 16#4eb30498#;
pragma Export (C, u00179, "gdk__frame_timingsS");
u00180 : constant Version_32 := 16#1d8d9dbe#;
pragma Export (C, u00180, "gdk__pixbufB");
u00181 : constant Version_32 := 16#f051d9d2#;
pragma Export (C, u00181, "gdk__pixbufS");
u00182 : constant Version_32 := 16#20806ff5#;
pragma Export (C, u00182, "glib__errorB");
u00183 : constant Version_32 := 16#2d79486e#;
pragma Export (C, u00183, "glib__errorS");
u00184 : constant Version_32 := 16#24434f97#;
pragma Export (C, u00184, "gtk__accel_groupB");
u00185 : constant Version_32 := 16#3041db6e#;
pragma Export (C, u00185, "gtk__accel_groupS");
u00186 : constant Version_32 := 16#d31518ac#;
pragma Export (C, u00186, "gtk__builderB");
u00187 : constant Version_32 := 16#517b6593#;
pragma Export (C, u00187, "gtk__builderS");
u00188 : constant Version_32 := 16#4ec6555e#;
pragma Export (C, u00188, "gtk__selection_dataB");
u00189 : constant Version_32 := 16#98a70ff4#;
pragma Export (C, u00189, "gtk__selection_dataS");
u00190 : constant Version_32 := 16#3584cd94#;
pragma Export (C, u00190, "gtk__styleB");
u00191 : constant Version_32 := 16#2075db88#;
pragma Export (C, u00191, "gtk__styleS");
u00192 : constant Version_32 := 16#ebab9896#;
pragma Export (C, u00192, "gtk__target_listB");
u00193 : constant Version_32 := 16#8cb2d7c1#;
pragma Export (C, u00193, "gtk__target_listS");
u00194 : constant Version_32 := 16#23663df0#;
pragma Export (C, u00194, "gtk__target_entryB");
u00195 : constant Version_32 := 16#b383f43e#;
pragma Export (C, u00195, "gtk__target_entryS");
u00196 : constant Version_32 := 16#fb66f5a7#;
pragma Export (C, u00196, "pangoS");
u00197 : constant Version_32 := 16#0eadcbfe#;
pragma Export (C, u00197, "pango__contextB");
u00198 : constant Version_32 := 16#2f5ce6b8#;
pragma Export (C, u00198, "pango__contextS");
u00199 : constant Version_32 := 16#92e19fe5#;
pragma Export (C, u00199, "pango__enumsB");
u00200 : constant Version_32 := 16#a3ba3947#;
pragma Export (C, u00200, "pango__enumsS");
u00201 : constant Version_32 := 16#0dea3ffa#;
pragma Export (C, u00201, "pango__fontB");
u00202 : constant Version_32 := 16#57d69fea#;
pragma Export (C, u00202, "pango__fontS");
u00203 : constant Version_32 := 16#f6b33a30#;
pragma Export (C, u00203, "pango__font_metricsB");
u00204 : constant Version_32 := 16#f605b2d0#;
pragma Export (C, u00204, "pango__font_metricsS");
u00205 : constant Version_32 := 16#386a0309#;
pragma Export (C, u00205, "pango__languageB");
u00206 : constant Version_32 := 16#8384ee22#;
pragma Export (C, u00206, "pango__languageS");
u00207 : constant Version_32 := 16#348ec1a2#;
pragma Export (C, u00207, "pango__font_familyB");
u00208 : constant Version_32 := 16#fc4b6f8c#;
pragma Export (C, u00208, "pango__font_familyS");
u00209 : constant Version_32 := 16#898184a4#;
pragma Export (C, u00209, "pango__font_faceB");
u00210 : constant Version_32 := 16#e7c62a99#;
pragma Export (C, u00210, "pango__font_faceS");
u00211 : constant Version_32 := 16#fe9b77cd#;
pragma Export (C, u00211, "pango__fontsetB");
u00212 : constant Version_32 := 16#f7b038c8#;
pragma Export (C, u00212, "pango__fontsetS");
u00213 : constant Version_32 := 16#6bd7fbbf#;
pragma Export (C, u00213, "pango__matrixB");
u00214 : constant Version_32 := 16#8b067d50#;
pragma Export (C, u00214, "pango__matrixS");
u00215 : constant Version_32 := 16#b472cdd9#;
pragma Export (C, u00215, "pango__layoutB");
u00216 : constant Version_32 := 16#eb534802#;
pragma Export (C, u00216, "pango__layoutS");
u00217 : constant Version_32 := 16#9b9cb30a#;
pragma Export (C, u00217, "pango__attributesB");
u00218 : constant Version_32 := 16#714b4367#;
pragma Export (C, u00218, "pango__attributesS");
u00219 : constant Version_32 := 16#1d473b3c#;
pragma Export (C, u00219, "pango__tabsB");
u00220 : constant Version_32 := 16#50ccb767#;
pragma Export (C, u00220, "pango__tabsS");
u00221 : constant Version_32 := 16#05e806d2#;
pragma Export (C, u00221, "gtk__boxB");
u00222 : constant Version_32 := 16#48dfb2ea#;
pragma Export (C, u00222, "gtk__boxS");
u00223 : constant Version_32 := 16#a725c286#;
pragma Export (C, u00223, "gtk__buildableB");
u00224 : constant Version_32 := 16#546056ab#;
pragma Export (C, u00224, "gtk__buildableS");
u00225 : constant Version_32 := 16#03f298f3#;
pragma Export (C, u00225, "gtk__containerB");
u00226 : constant Version_32 := 16#9ad4c955#;
pragma Export (C, u00226, "gtk__containerS");
u00227 : constant Version_32 := 16#1ab53bdf#;
pragma Export (C, u00227, "gtk__adjustmentB");
u00228 : constant Version_32 := 16#4de01f48#;
pragma Export (C, u00228, "gtk__adjustmentS");
u00229 : constant Version_32 := 16#41a8435f#;
pragma Export (C, u00229, "gtk__orientableB");
u00230 : constant Version_32 := 16#191f503d#;
pragma Export (C, u00230, "gtk__orientableS");
u00231 : constant Version_32 := 16#0b37eb58#;
pragma Export (C, u00231, "gtk__windowB");
u00232 : constant Version_32 := 16#936a5d67#;
pragma Export (C, u00232, "gtk__windowS");
u00233 : constant Version_32 := 16#aba0a54c#;
pragma Export (C, u00233, "gdk__windowB");
u00234 : constant Version_32 := 16#2fa06393#;
pragma Export (C, u00234, "gdk__windowS");
u00235 : constant Version_32 := 16#3c5c22b4#;
pragma Export (C, u00235, "gtk__binB");
u00236 : constant Version_32 := 16#024d6654#;
pragma Export (C, u00236, "gtk__binS");
u00237 : constant Version_32 := 16#1fff18dd#;
pragma Export (C, u00237, "gtk__gentryB");
u00238 : constant Version_32 := 16#ae764efa#;
pragma Export (C, u00238, "gtk__gentryS");
u00239 : constant Version_32 := 16#28a6ff74#;
pragma Export (C, u00239, "glib__g_iconB");
u00240 : constant Version_32 := 16#2723f310#;
pragma Export (C, u00240, "glib__g_iconS");
u00241 : constant Version_32 := 16#5c9da0d0#;
pragma Export (C, u00241, "glib__variantB");
u00242 : constant Version_32 := 16#31cee850#;
pragma Export (C, u00242, "glib__variantS");
u00243 : constant Version_32 := 16#653c21b7#;
pragma Export (C, u00243, "glib__stringB");
u00244 : constant Version_32 := 16#ff06d256#;
pragma Export (C, u00244, "glib__stringS");
u00245 : constant Version_32 := 16#4c4fc67f#;
pragma Export (C, u00245, "gtk__cell_editableB");
u00246 : constant Version_32 := 16#5b5de7c4#;
pragma Export (C, u00246, "gtk__cell_editableS");
u00247 : constant Version_32 := 16#3334053c#;
pragma Export (C, u00247, "gtk__editableB");
u00248 : constant Version_32 := 16#2d3d3e6c#;
pragma Export (C, u00248, "gtk__editableS");
u00249 : constant Version_32 := 16#a7b80108#;
pragma Export (C, u00249, "gtk__entry_bufferB");
u00250 : constant Version_32 := 16#186cb4bb#;
pragma Export (C, u00250, "gtk__entry_bufferS");
u00251 : constant Version_32 := 16#ce7d9fff#;
pragma Export (C, u00251, "gtk__entry_completionB");
u00252 : constant Version_32 := 16#96bfa476#;
pragma Export (C, u00252, "gtk__entry_completionS");
u00253 : constant Version_32 := 16#d73ed825#;
pragma Export (C, u00253, "gtk__cell_areaB");
u00254 : constant Version_32 := 16#f0bdde24#;
pragma Export (C, u00254, "gtk__cell_areaS");
u00255 : constant Version_32 := 16#3834c88d#;
pragma Export (C, u00255, "gtk__cell_area_contextB");
u00256 : constant Version_32 := 16#5ae477f5#;
pragma Export (C, u00256, "gtk__cell_area_contextS");
u00257 : constant Version_32 := 16#568c9832#;
pragma Export (C, u00257, "gtk__cell_layoutB");
u00258 : constant Version_32 := 16#880e6795#;
pragma Export (C, u00258, "gtk__cell_layoutS");
u00259 : constant Version_32 := 16#4dab946b#;
pragma Export (C, u00259, "gtk__cell_rendererB");
u00260 : constant Version_32 := 16#366ad98b#;
pragma Export (C, u00260, "gtk__cell_rendererS");
u00261 : constant Version_32 := 16#41c01b28#;
pragma Export (C, u00261, "gtk__tree_modelB");
u00262 : constant Version_32 := 16#af9b16ea#;
pragma Export (C, u00262, "gtk__tree_modelS");
u00263 : constant Version_32 := 16#4e4f7925#;
pragma Export (C, u00263, "gtk__imageB");
u00264 : constant Version_32 := 16#248aa263#;
pragma Export (C, u00264, "gtk__imageS");
u00265 : constant Version_32 := 16#ee72d7e5#;
pragma Export (C, u00265, "gtk__icon_setB");
u00266 : constant Version_32 := 16#3ee2c25f#;
pragma Export (C, u00266, "gtk__icon_setS");
u00267 : constant Version_32 := 16#72511980#;
pragma Export (C, u00267, "gtk__icon_sourceB");
u00268 : constant Version_32 := 16#5e9b44d9#;
pragma Export (C, u00268, "gtk__icon_sourceS");
u00269 : constant Version_32 := 16#85ad8b33#;
pragma Export (C, u00269, "gtk__style_contextB");
u00270 : constant Version_32 := 16#37dc5bb6#;
pragma Export (C, u00270, "gtk__style_contextS");
u00271 : constant Version_32 := 16#411b189c#;
pragma Export (C, u00271, "gtk__css_sectionB");
u00272 : constant Version_32 := 16#28a72b90#;
pragma Export (C, u00272, "gtk__css_sectionS");
u00273 : constant Version_32 := 16#15153448#;
pragma Export (C, u00273, "gtk__miscB");
u00274 : constant Version_32 := 16#b01e6275#;
pragma Export (C, u00274, "gtk__miscS");
u00275 : constant Version_32 := 16#78f0cf19#;
pragma Export (C, u00275, "gtk__notebookB");
u00276 : constant Version_32 := 16#fa70b8ae#;
pragma Export (C, u00276, "gtk__notebookS");
u00277 : constant Version_32 := 16#17f40da4#;
pragma Export (C, u00277, "gtk__print_operationB");
u00278 : constant Version_32 := 16#e59916a9#;
pragma Export (C, u00278, "gtk__print_operationS");
u00279 : constant Version_32 := 16#7d882d81#;
pragma Export (C, u00279, "gtk__page_setupB");
u00280 : constant Version_32 := 16#b471b6f6#;
pragma Export (C, u00280, "gtk__page_setupS");
u00281 : constant Version_32 := 16#82306508#;
pragma Export (C, u00281, "glib__key_fileB");
u00282 : constant Version_32 := 16#b3f25f3a#;
pragma Export (C, u00282, "glib__key_fileS");
u00283 : constant Version_32 := 16#9cbbb65d#;
pragma Export (C, u00283, "gtk__paper_sizeB");
u00284 : constant Version_32 := 16#7ba2b2ed#;
pragma Export (C, u00284, "gtk__paper_sizeS");
u00285 : constant Version_32 := 16#ea16d9b2#;
pragma Export (C, u00285, "gtk__print_contextB");
u00286 : constant Version_32 := 16#f5d4d495#;
pragma Export (C, u00286, "gtk__print_contextS");
u00287 : constant Version_32 := 16#06234c48#;
pragma Export (C, u00287, "pango__font_mapB");
u00288 : constant Version_32 := 16#e7dfb649#;
pragma Export (C, u00288, "pango__font_mapS");
u00289 : constant Version_32 := 16#263d2f99#;
pragma Export (C, u00289, "gtk__print_operation_previewB");
u00290 : constant Version_32 := 16#f7e7c39e#;
pragma Export (C, u00290, "gtk__print_operation_previewS");
u00291 : constant Version_32 := 16#68847913#;
pragma Export (C, u00291, "gtk__print_settingsB");
u00292 : constant Version_32 := 16#3fccceec#;
pragma Export (C, u00292, "gtk__print_settingsS");
u00293 : constant Version_32 := 16#99703c4e#;
pragma Export (C, u00293, "gtk__status_barB");
u00294 : constant Version_32 := 16#df2627ce#;
pragma Export (C, u00294, "gtk__status_barS");
u00295 : constant Version_32 := 16#dbc619df#;
pragma Export (C, u00295, "gtk__text_iterB");
u00296 : constant Version_32 := 16#9a9513ee#;
pragma Export (C, u00296, "gtk__text_iterS");
u00297 : constant Version_32 := 16#f27ddfea#;
pragma Export (C, u00297, "gtk__text_attributesB");
u00298 : constant Version_32 := 16#8e96d59b#;
pragma Export (C, u00298, "gtk__text_attributesS");
u00299 : constant Version_32 := 16#987fc972#;
pragma Export (C, u00299, "gtk__text_tagB");
u00300 : constant Version_32 := 16#cb5f3703#;
pragma Export (C, u00300, "gtk__text_tagS");
u00301 : constant Version_32 := 16#400998c9#;
pragma Export (C, u00301, "lrS");
u00302 : constant Version_32 := 16#20e463fb#;
pragma Export (C, u00302, "lr__afficB");
u00303 : constant Version_32 := 16#b2fdfc54#;
pragma Export (C, u00303, "lr__afficS");
u00304 : constant Version_32 := 16#cd2959fb#;
pragma Export (C, u00304, "ada__numericsS");
u00305 : constant Version_32 := 16#0470cbe4#;
pragma Export (C, u00305, "gtk__buttonB");
u00306 : constant Version_32 := 16#37eaab3a#;
pragma Export (C, u00306, "gtk__buttonS");
u00307 : constant Version_32 := 16#fae1470f#;
pragma Export (C, u00307, "gtk__actionB");
u00308 : constant Version_32 := 16#86624a8b#;
pragma Export (C, u00308, "gtk__actionS");
u00309 : constant Version_32 := 16#6d6ee6b5#;
pragma Export (C, u00309, "gtk__actionableB");
u00310 : constant Version_32 := 16#a08f7f0e#;
pragma Export (C, u00310, "gtk__actionableS");
u00311 : constant Version_32 := 16#56635bf0#;
pragma Export (C, u00311, "gtk__activatableB");
u00312 : constant Version_32 := 16#6bde0753#;
pragma Export (C, u00312, "gtk__activatableS");
u00313 : constant Version_32 := 16#07aa8b37#;
pragma Export (C, u00313, "gtk__grangeB");
u00314 : constant Version_32 := 16#d7bc118a#;
pragma Export (C, u00314, "gtk__grangeS");
u00315 : constant Version_32 := 16#87d816bd#;
pragma Export (C, u00315, "gtk__labelB");
u00316 : constant Version_32 := 16#3ea1bd12#;
pragma Export (C, u00316, "gtk__labelS");
u00317 : constant Version_32 := 16#da191d4a#;
pragma Export (C, u00317, "gtk__menuB");
u00318 : constant Version_32 := 16#568e6ba8#;
pragma Export (C, u00318, "gtk__menuS");
u00319 : constant Version_32 := 16#9eada4cc#;
pragma Export (C, u00319, "glib__menu_modelB");
u00320 : constant Version_32 := 16#0c9f64f8#;
pragma Export (C, u00320, "glib__menu_modelS");
u00321 : constant Version_32 := 16#6eceeadf#;
pragma Export (C, u00321, "gtk__menu_itemB");
u00322 : constant Version_32 := 16#606ad29c#;
pragma Export (C, u00322, "gtk__menu_itemS");
u00323 : constant Version_32 := 16#b6004737#;
pragma Export (C, u00323, "gtk__menu_shellB");
u00324 : constant Version_32 := 16#15e87f24#;
pragma Export (C, u00324, "gtk__menu_shellS");
u00325 : constant Version_32 := 16#d03aa2c1#;
pragma Export (C, u00325, "gtkada__builderB");
u00326 : constant Version_32 := 16#d02afbbc#;
pragma Export (C, u00326, "gtkada__builderS");
u00327 : constant Version_32 := 16#7fe2f6aa#;
pragma Export (C, u00327, "gtk__handlersB");
u00328 : constant Version_32 := 16#ff3371d1#;
pragma Export (C, u00328, "gtk__handlersS");
u00329 : constant Version_32 := 16#baed3164#;
pragma Export (C, u00329, "gtk__marshallersB");
u00330 : constant Version_32 := 16#daf42a3e#;
pragma Export (C, u00330, "gtk__marshallersS");
u00331 : constant Version_32 := 16#0ffcb0cd#;
pragma Export (C, u00331, "gtk__tree_view_columnB");
u00332 : constant Version_32 := 16#eca95213#;
pragma Export (C, u00332, "gtk__tree_view_columnS");
u00333 : constant Version_32 := 16#8ff5a2da#;
pragma Export (C, u00333, "gtkada__handlersS");
u00334 : constant Version_32 := 16#18e0e51c#;
pragma Export (C, u00334, "system__img_enum_newB");
u00335 : constant Version_32 := 16#2779eac4#;
pragma Export (C, u00335, "system__img_enum_newS");
u00336 : constant Version_32 := 16#179d7d28#;
pragma Export (C, u00336, "ada__containersS");
u00337 : constant Version_32 := 16#c164a034#;
pragma Export (C, u00337, "ada__containers__hash_tablesS");
u00338 : constant Version_32 := 16#bcec81df#;
pragma Export (C, u00338, "ada__containers__helpersB");
u00339 : constant Version_32 := 16#4adfc5eb#;
pragma Export (C, u00339, "ada__containers__helpersS");
u00340 : constant Version_32 := 16#020a3f4d#;
pragma Export (C, u00340, "system__atomic_countersB");
u00341 : constant Version_32 := 16#f269c189#;
pragma Export (C, u00341, "system__atomic_countersS");
u00342 : constant Version_32 := 16#c24eaf4d#;
pragma Export (C, u00342, "ada__containers__prime_numbersB");
u00343 : constant Version_32 := 16#6d3af8ed#;
pragma Export (C, u00343, "ada__containers__prime_numbersS");
u00344 : constant Version_32 := 16#e6d4fa36#;
pragma Export (C, u00344, "ada__stringsS");
u00345 : constant Version_32 := 16#3791e504#;
pragma Export (C, u00345, "ada__strings__unboundedB");
u00346 : constant Version_32 := 16#9fdb1809#;
pragma Export (C, u00346, "ada__strings__unboundedS");
u00347 : constant Version_32 := 16#60da0992#;
pragma Export (C, u00347, "ada__strings__searchB");
u00348 : constant Version_32 := 16#c1ab8667#;
pragma Export (C, u00348, "ada__strings__searchS");
u00349 : constant Version_32 := 16#e2ea8656#;
pragma Export (C, u00349, "ada__strings__mapsB");
u00350 : constant Version_32 := 16#1e526bec#;
pragma Export (C, u00350, "ada__strings__mapsS");
u00351 : constant Version_32 := 16#e95cd909#;
pragma Export (C, u00351, "system__bit_opsB");
u00352 : constant Version_32 := 16#0765e3a3#;
pragma Export (C, u00352, "system__bit_opsS");
u00353 : constant Version_32 := 16#5b4659fa#;
pragma Export (C, u00353, "ada__charactersS");
u00354 : constant Version_32 := 16#4b7bb96a#;
pragma Export (C, u00354, "ada__characters__latin_1S");
u00355 : constant Version_32 := 16#933d1555#;
pragma Export (C, u00355, "system__compare_array_unsigned_8B");
u00356 : constant Version_32 := 16#ef369d89#;
pragma Export (C, u00356, "system__compare_array_unsigned_8S");
u00357 : constant Version_32 := 16#97d13ec4#;
pragma Export (C, u00357, "system__address_operationsB");
u00358 : constant Version_32 := 16#55395237#;
pragma Export (C, u00358, "system__address_operationsS");
u00359 : constant Version_32 := 16#217daf40#;
pragma Export (C, u00359, "ada__strings__unbounded__hashB");
u00360 : constant Version_32 := 16#9c644680#;
pragma Export (C, u00360, "ada__strings__unbounded__hashS");
u00361 : constant Version_32 := 16#7c9380ff#;
pragma Export (C, u00361, "system__strings__stream_opsB");
u00362 : constant Version_32 := 16#55d4bd57#;
pragma Export (C, u00362, "system__strings__stream_opsS");
u00363 : constant Version_32 := 16#63d47364#;
pragma Export (C, u00363, "ada__streams__stream_ioB");
u00364 : constant Version_32 := 16#31fc8e02#;
pragma Export (C, u00364, "ada__streams__stream_ioS");
u00365 : constant Version_32 := 16#5de653db#;
pragma Export (C, u00365, "system__communicationB");
u00366 : constant Version_32 := 16#5f55b9d6#;
pragma Export (C, u00366, "system__communicationS");
u00367 : constant Version_32 := 16#d19565b6#;
pragma Export (C, u00367, "lr__simuB");
u00368 : constant Version_32 := 16#a848d720#;
pragma Export (C, u00368, "lr__simuS");
u00369 : constant Version_32 := 16#87cd2ab9#;
pragma Export (C, u00369, "ada__calendar__delaysB");
u00370 : constant Version_32 := 16#b27fb9e9#;
pragma Export (C, u00370, "ada__calendar__delaysS");
u00371 : constant Version_32 := 16#0d7f1a43#;
pragma Export (C, u00371, "ada__calendarB");
u00372 : constant Version_32 := 16#5b279c75#;
pragma Export (C, u00372, "ada__calendarS");
u00373 : constant Version_32 := 16#d083f760#;
pragma Export (C, u00373, "system__os_primitivesB");
u00374 : constant Version_32 := 16#ccbafd72#;
pragma Export (C, u00374, "system__os_primitivesS");
u00375 : constant Version_32 := 16#ee80728a#;
pragma Export (C, u00375, "system__tracesB");
u00376 : constant Version_32 := 16#b42884ae#;
pragma Export (C, u00376, "system__tracesS");
u00377 : constant Version_32 := 16#140e9851#;
pragma Export (C, u00377, "lr__tasksB");
u00378 : constant Version_32 := 16#07263366#;
pragma Export (C, u00378, "lr__tasksS");
u00379 : constant Version_32 := 16#a562f09d#;
pragma Export (C, u00379, "lr__synchroB");
u00380 : constant Version_32 := 16#6f87cbb4#;
pragma Export (C, u00380, "lr__synchroS");
u00381 : constant Version_32 := 16#98e98f0c#;
pragma Export (C, u00381, "lr__synchro__fifoB");
u00382 : constant Version_32 := 16#6a0b4988#;
pragma Export (C, u00382, "lr__synchro__fifoS");
u00383 : constant Version_32 := 16#402b6a67#;
pragma Export (C, u00383, "ada__real_timeB");
u00384 : constant Version_32 := 16#c3d451b0#;
pragma Export (C, u00384, "ada__real_timeS");
u00385 : constant Version_32 := 16#888154ba#;
pragma Export (C, u00385, "system__taskingB");
u00386 : constant Version_32 := 16#c03b1874#;
pragma Export (C, u00386, "system__taskingS");
u00387 : constant Version_32 := 16#08881467#;
pragma Export (C, u00387, "system__task_primitivesS");
u00388 : constant Version_32 := 16#decff30d#;
pragma Export (C, u00388, "system__os_interfaceB");
u00389 : constant Version_32 := 16#dac51a48#;
pragma Export (C, u00389, "system__os_interfaceS");
u00390 : constant Version_32 := 16#3dce974e#;
pragma Export (C, u00390, "system__linuxS");
u00391 : constant Version_32 := 16#69418a44#;
pragma Export (C, u00391, "system__os_constantsS");
u00392 : constant Version_32 := 16#35461298#;
pragma Export (C, u00392, "system__task_primitives__operationsB");
u00393 : constant Version_32 := 16#28930186#;
pragma Export (C, u00393, "system__task_primitives__operationsS");
u00394 : constant Version_32 := 16#66645a25#;
pragma Export (C, u00394, "system__interrupt_managementB");
u00395 : constant Version_32 := 16#f8b85fd3#;
pragma Export (C, u00395, "system__interrupt_managementS");
u00396 : constant Version_32 := 16#f65595cf#;
pragma Export (C, u00396, "system__multiprocessorsB");
u00397 : constant Version_32 := 16#7e997377#;
pragma Export (C, u00397, "system__multiprocessorsS");
u00398 : constant Version_32 := 16#375a3ef7#;
pragma Export (C, u00398, "system__task_infoB");
u00399 : constant Version_32 := 16#c01cd21c#;
pragma Export (C, u00399, "system__task_infoS");
u00400 : constant Version_32 := 16#58108132#;
pragma Export (C, u00400, "system__tasking__debugB");
u00401 : constant Version_32 := 16#72bfd9bc#;
pragma Export (C, u00401, "system__tasking__debugS");
u00402 : constant Version_32 := 16#fd83e873#;
pragma Export (C, u00402, "system__concat_2B");
u00403 : constant Version_32 := 16#44953bd4#;
pragma Export (C, u00403, "system__concat_2S");
u00404 : constant Version_32 := 16#2b70b149#;
pragma Export (C, u00404, "system__concat_3B");
u00405 : constant Version_32 := 16#4d45b0a1#;
pragma Export (C, u00405, "system__concat_3S");
u00406 : constant Version_32 := 16#9dca6636#;
pragma Export (C, u00406, "system__img_lliB");
u00407 : constant Version_32 := 16#577ab9d5#;
pragma Export (C, u00407, "system__img_lliS");
u00408 : constant Version_32 := 16#118e865d#;
pragma Export (C, u00408, "system__stack_usageB");
u00409 : constant Version_32 := 16#3a3ac346#;
pragma Export (C, u00409, "system__stack_usageS");
u00410 : constant Version_32 := 16#40fbb80f#;
pragma Export (C, u00410, "system__tasking__rendezvousB");
u00411 : constant Version_32 := 16#ea18a31e#;
pragma Export (C, u00411, "system__tasking__rendezvousS");
u00412 : constant Version_32 := 16#100eaf58#;
pragma Export (C, u00412, "system__restrictionsB");
u00413 : constant Version_32 := 16#aab42239#;
pragma Export (C, u00413, "system__restrictionsS");
u00414 : constant Version_32 := 16#d8038a64#;
pragma Export (C, u00414, "system__tasking__entry_callsB");
u00415 : constant Version_32 := 16#df420580#;
pragma Export (C, u00415, "system__tasking__entry_callsS");
u00416 : constant Version_32 := 16#c5fb5685#;
pragma Export (C, u00416, "system__tasking__initializationB");
u00417 : constant Version_32 := 16#efd25374#;
pragma Export (C, u00417, "system__tasking__initializationS");
u00418 : constant Version_32 := 16#312b97cd#;
pragma Export (C, u00418, "system__soft_links__taskingB");
u00419 : constant Version_32 := 16#5ae92880#;
pragma Export (C, u00419, "system__soft_links__taskingS");
u00420 : constant Version_32 := 16#17d21067#;
pragma Export (C, u00420, "ada__exceptions__is_null_occurrenceB");
u00421 : constant Version_32 := 16#e1d7566f#;
pragma Export (C, u00421, "ada__exceptions__is_null_occurrenceS");
u00422 : constant Version_32 := 16#a4a31ee6#;
pragma Export (C, u00422, "system__tasking__task_attributesB");
u00423 : constant Version_32 := 16#6bc95a13#;
pragma Export (C, u00423, "system__tasking__task_attributesS");
u00424 : constant Version_32 := 16#c8081f14#;
pragma Export (C, u00424, "system__tasking__protected_objectsB");
u00425 : constant Version_32 := 16#a9001c61#;
pragma Export (C, u00425, "system__tasking__protected_objectsS");
u00426 : constant Version_32 := 16#547d8eae#;
pragma Export (C, u00426, "system__tasking__protected_objects__entriesB");
u00427 : constant Version_32 := 16#427cf21f#;
pragma Export (C, u00427, "system__tasking__protected_objects__entriesS");
u00428 : constant Version_32 := 16#5e1f99be#;
pragma Export (C, u00428, "system__tasking__protected_objects__operationsB");
u00429 : constant Version_32 := 16#ba36ad85#;
pragma Export (C, u00429, "system__tasking__protected_objects__operationsS");
u00430 : constant Version_32 := 16#e8f87c58#;
pragma Export (C, u00430, "system__tasking__queuingB");
u00431 : constant Version_32 := 16#d1ba2fcb#;
pragma Export (C, u00431, "system__tasking__queuingS");
u00432 : constant Version_32 := 16#bad2cea3#;
pragma Export (C, u00432, "system__tasking__utilitiesB");
u00433 : constant Version_32 := 16#9b15eab5#;
pragma Export (C, u00433, "system__tasking__utilitiesS");
u00434 : constant Version_32 := 16#bd6fc52e#;
pragma Export (C, u00434, "system__traces__taskingB");
u00435 : constant Version_32 := 16#09f07b39#;
pragma Export (C, u00435, "system__traces__taskingS");
u00436 : constant Version_32 := 16#149dbb7c#;
pragma Export (C, u00436, "system__tasking__stagesB");
u00437 : constant Version_32 := 16#a2ee1060#;
pragma Export (C, u00437, "system__tasking__stagesS");
u00438 : constant Version_32 := 16#d34f9f29#;
pragma Export (C, u00438, "system__random_numbersB");
u00439 : constant Version_32 := 16#852d5c9e#;
pragma Export (C, u00439, "system__random_numbersS");
u00440 : constant Version_32 := 16#ec78c2bf#;
pragma Export (C, u00440, "system__img_unsB");
u00441 : constant Version_32 := 16#ed47ac70#;
pragma Export (C, u00441, "system__img_unsS");
u00442 : constant Version_32 := 16#40a8df0e#;
pragma Export (C, u00442, "system__random_seedB");
u00443 : constant Version_32 := 16#1d25c55f#;
pragma Export (C, u00443, "system__random_seedS");
u00444 : constant Version_32 := 16#1d9142a4#;
pragma Export (C, u00444, "system__val_unsB");
u00445 : constant Version_32 := 16#621b7dbc#;
pragma Export (C, u00445, "system__val_unsS");
u00446 : constant Version_32 := 16#d763507a#;
pragma Export (C, u00446, "system__val_intB");
u00447 : constant Version_32 := 16#0e90c63b#;
pragma Export (C, u00447, "system__val_intS");
-- BEGIN ELABORATION ORDER
-- ada%s
-- ada.characters%s
-- ada.characters.latin_1%s
-- gnat%s
-- gnat.io%s
-- gnat.io%b
-- interfaces%s
-- system%s
-- system.address_operations%s
-- system.address_operations%b
-- system.atomic_counters%s
-- system.atomic_counters%b
-- system.case_util%s
-- system.case_util%b
-- system.img_bool%s
-- system.img_bool%b
-- system.img_enum_new%s
-- system.img_enum_new%b
-- system.img_int%s
-- system.img_int%b
-- system.img_lli%s
-- system.img_lli%b
-- system.io%s
-- system.io%b
-- system.os_primitives%s
-- system.os_primitives%b
-- system.parameters%s
-- system.parameters%b
-- system.crtl%s
-- interfaces.c_streams%s
-- interfaces.c_streams%b
-- system.restrictions%s
-- system.restrictions%b
-- system.storage_elements%s
-- system.storage_elements%b
-- system.stack_checking%s
-- system.stack_checking%b
-- system.stack_usage%s
-- system.stack_usage%b
-- system.string_hash%s
-- system.string_hash%b
-- system.htable%s
-- system.htable%b
-- system.strings%s
-- system.strings%b
-- gnat.strings%s
-- system.traceback_entries%s
-- system.traceback_entries%b
-- system.traces%s
-- system.traces%b
-- system.unsigned_types%s
-- system.fat_flt%s
-- system.fat_lflt%s
-- system.img_uns%s
-- system.img_uns%b
-- system.wch_con%s
-- system.wch_con%b
-- system.wch_jis%s
-- system.wch_jis%b
-- system.wch_cnv%s
-- system.wch_cnv%b
-- system.compare_array_unsigned_8%s
-- system.compare_array_unsigned_8%b
-- system.concat_2%s
-- system.concat_2%b
-- system.concat_3%s
-- system.concat_3%b
-- system.traceback%s
-- system.traceback%b
-- system.wch_stw%s
-- system.standard_library%s
-- system.exceptions_debug%s
-- system.exceptions_debug%b
-- ada.exceptions%s
-- system.wch_stw%b
-- ada.exceptions.traceback%s
-- ada.exceptions.last_chance_handler%s
-- system.soft_links%s
-- system.exception_table%s
-- system.exception_table%b
-- system.exceptions%s
-- system.exceptions%b
-- system.secondary_stack%s
-- system.address_image%s
-- system.memory%s
-- system.memory%b
-- ada.exceptions.traceback%b
-- system.traceback.symbolic%s
-- system.traceback.symbolic%b
-- system.exceptions.machine%s
-- ada.exceptions.last_chance_handler%b
-- system.soft_links%b
-- system.secondary_stack%b
-- system.address_image%b
-- system.standard_library%b
-- ada.exceptions%b
-- ada.command_line%s
-- ada.command_line%b
-- ada.containers%s
-- ada.containers.prime_numbers%s
-- ada.containers.prime_numbers%b
-- ada.exceptions.is_null_occurrence%s
-- ada.exceptions.is_null_occurrence%b
-- ada.io_exceptions%s
-- ada.numerics%s
-- ada.strings%s
-- interfaces.c%s
-- interfaces.c%b
-- interfaces.c.strings%s
-- interfaces.c.strings%b
-- system.linux%s
-- system.multiprocessors%s
-- system.multiprocessors%b
-- system.os_constants%s
-- system.os_interface%s
-- system.os_interface%b
-- system.os_lib%s
-- system.os_lib%b
-- system.task_info%s
-- system.task_info%b
-- system.task_primitives%s
-- system.interrupt_management%s
-- system.interrupt_management%b
-- system.val_util%s
-- system.val_util%b
-- system.val_llu%s
-- system.val_llu%b
-- ada.tags%s
-- ada.tags%b
-- ada.streams%s
-- ada.streams%b
-- system.communication%s
-- system.communication%b
-- system.file_control_block%s
-- system.finalization_root%s
-- system.finalization_root%b
-- ada.finalization%s
-- ada.containers.helpers%s
-- ada.containers.helpers%b
-- ada.containers.hash_tables%s
-- system.file_io%s
-- system.file_io%b
-- ada.streams.stream_io%s
-- ada.streams.stream_io%b
-- system.storage_pools%s
-- system.storage_pools%b
-- system.finalization_masters%s
-- system.finalization_masters%b
-- system.storage_pools.subpools%s
-- system.storage_pools.subpools.finalization%s
-- system.storage_pools.subpools.finalization%b
-- system.storage_pools.subpools%b
-- system.stream_attributes%s
-- system.stream_attributes%b
-- system.val_uns%s
-- system.val_uns%b
-- system.val_int%s
-- system.val_int%b
-- ada.calendar%s
-- ada.calendar%b
-- ada.calendar.delays%s
-- ada.calendar.delays%b
-- ada.text_io%s
-- ada.text_io%b
-- system.assertions%s
-- system.assertions%b
-- system.bit_ops%s
-- system.bit_ops%b
-- ada.strings.maps%s
-- ada.strings.maps%b
-- ada.strings.search%s
-- ada.strings.search%b
-- ada.strings.unbounded%s
-- ada.strings.unbounded%b
-- ada.strings.unbounded.hash%s
-- ada.strings.unbounded.hash%b
-- system.tasking%s
-- system.task_primitives.operations%s
-- system.tasking.debug%s
-- system.tasking%b
-- system.task_primitives.operations%b
-- system.tasking.debug%b
-- system.traces.tasking%s
-- system.traces.tasking%b
-- ada.real_time%s
-- ada.real_time%b
-- system.pool_global%s
-- system.pool_global%b
-- system.random_seed%s
-- system.random_seed%b
-- system.random_numbers%s
-- system.random_numbers%b
-- system.soft_links.tasking%s
-- system.soft_links.tasking%b
-- system.strings.stream_ops%s
-- system.strings.stream_ops%b
-- system.tasking.initialization%s
-- system.tasking.task_attributes%s
-- system.tasking.initialization%b
-- system.tasking.task_attributes%b
-- system.tasking.protected_objects%s
-- system.tasking.protected_objects%b
-- system.tasking.protected_objects.entries%s
-- system.tasking.protected_objects.entries%b
-- system.tasking.queuing%s
-- system.tasking.queuing%b
-- system.tasking.utilities%s
-- system.tasking.utilities%b
-- system.tasking.entry_calls%s
-- system.tasking.rendezvous%s
-- system.tasking.protected_objects.operations%s
-- system.tasking.protected_objects.operations%b
-- system.tasking.entry_calls%b
-- system.tasking.rendezvous%b
-- system.tasking.stages%s
-- system.tasking.stages%b
-- glib%s
-- glib%b
-- glib.error%s
-- glib.error%b
-- gtkada%s
-- gtkada.types%s
-- gtkada.types%b
-- gdk%s
-- gdk.frame_timings%s
-- gdk.frame_timings%b
-- gdk.threads%s
-- glib.glist%s
-- glib.glist%b
-- gdk.visual%s
-- gdk.visual%b
-- glib.gslist%s
-- glib.gslist%b
-- gtkada.c%s
-- gtkada.c%b
-- glib.object%s
-- glib.values%s
-- glib.values%b
-- glib.types%s
-- glib.type_conversion_hooks%s
-- glib.type_conversion_hooks%b
-- gtkada.bindings%s
-- glib.types%b
-- gtkada.bindings%b
-- glib.object%b
-- cairo%s
-- cairo%b
-- cairo.region%s
-- cairo.region%b
-- gdk.rectangle%s
-- gdk.rectangle%b
-- glib.generic_properties%s
-- glib.generic_properties%b
-- gdk.color%s
-- gdk.color%b
-- gdk.rgba%s
-- gdk.rgba%b
-- gdk.types%s
-- gdk.event%s
-- gdk.event%b
-- glib.key_file%s
-- glib.key_file%b
-- glib.properties%s
-- glib.properties%b
-- glib.string%s
-- glib.string%b
-- glib.variant%s
-- glib.variant%b
-- glib.g_icon%s
-- glib.g_icon%b
-- gtk%s
-- gtk.actionable%s
-- gtk.actionable%b
-- gtk.builder%s
-- gtk.builder%b
-- gtk.buildable%s
-- gtk.buildable%b
-- gtk.cell_area_context%s
-- gtk.cell_area_context%b
-- gtk.css_section%s
-- gtk.css_section%b
-- gtk.enums%s
-- gtk.enums%b
-- gtk.orientable%s
-- gtk.orientable%b
-- gtk.paper_size%s
-- gtk.paper_size%b
-- gtk.page_setup%s
-- gtk.page_setup%b
-- gtk.print_settings%s
-- gtk.print_settings%b
-- gtk.target_entry%s
-- gtk.target_entry%b
-- gtk.target_list%s
-- gtk.target_list%b
-- lr%s
-- lr.synchro%s
-- lr.synchro.fifo%s
-- lr.synchro%b
-- lr.synchro.fifo%b
-- pango%s
-- pango.enums%s
-- pango.enums%b
-- pango.attributes%s
-- pango.attributes%b
-- pango.font_metrics%s
-- pango.font_metrics%b
-- pango.language%s
-- pango.language%b
-- pango.font%s
-- pango.font%b
-- gtk.text_attributes%s
-- gtk.text_attributes%b
-- gtk.text_tag%s
-- gtk.text_tag%b
-- pango.font_face%s
-- pango.font_face%b
-- pango.font_family%s
-- pango.font_family%b
-- pango.fontset%s
-- pango.fontset%b
-- pango.matrix%s
-- pango.matrix%b
-- pango.context%s
-- pango.context%b
-- pango.font_map%s
-- pango.font_map%b
-- pango.tabs%s
-- pango.tabs%b
-- pango.layout%s
-- pango.layout%b
-- gtk.print_context%s
-- gtk.print_context%b
-- gdk.display%s
-- gtk.print_operation_preview%s
-- gtk.tree_model%s
-- gtk.entry_buffer%s
-- gtk.editable%s
-- gtk.cell_editable%s
-- gtk.adjustment%s
-- gtk.style%s
-- gtk.accel_group%s
-- gdk.frame_clock%s
-- gdk.pixbuf%s
-- gtk.icon_source%s
-- gtk.icon_source%b
-- gdk.pixbuf%b
-- gdk.screen%s
-- gdk.screen%b
-- gdk.device%s
-- gdk.drag_contexts%s
-- gdk.drag_contexts%b
-- gdk.device%b
-- gtk.text_iter%s
-- gtk.text_iter%b
-- gdk.window%s
-- gdk.window%b
-- gtk.selection_data%s
-- gtk.selection_data%b
-- gtk.widget%s
-- gtk.misc%s
-- gtk.misc%b
-- gtk.style_provider%s
-- gtk.style_provider%b
-- gtk.settings%s
-- gtk.settings%b
-- gtk.style_context%s
-- gtk.icon_set%s
-- gtk.icon_set%b
-- gtk.image%s
-- gtk.image%b
-- gtk.cell_renderer%s
-- gtk.container%s
-- gtk.bin%s
-- gtk.bin%b
-- gtk.box%s
-- gtk.box%b
-- gtk.status_bar%s
-- gtk.notebook%s
-- gtk.cell_layout%s
-- gtk.cell_layout%b
-- gtk.cell_area%s
-- gtk.entry_completion%s
-- gtk.window%s
-- gtk.dialog%s
-- gtk.print_operation%s
-- gtk.gentry%s
-- gtk.arguments%s
-- gtk.status_bar%b
-- gtk.print_operation_preview%b
-- gtk.print_operation%b
-- gtk.notebook%b
-- gtk.style_context%b
-- gtk.gentry%b
-- gtk.tree_model%b
-- gtk.cell_area%b
-- gtk.entry_completion%b
-- gtk.cell_renderer%b
-- gtk.entry_buffer%b
-- gtk.editable%b
-- gtk.cell_editable%b
-- gtk.window%b
-- gtk.dialog%b
-- gtk.adjustment%b
-- gtk.container%b
-- gtk.style%b
-- gtk.widget%b
-- gtk.accel_group%b
-- gdk.frame_clock%b
-- gtk.arguments%b
-- gdk.display%b
-- glib.menu_model%s
-- glib.menu_model%b
-- gtk.action%s
-- gtk.action%b
-- gtk.activatable%s
-- gtk.activatable%b
-- gtk.button%s
-- gtk.button%b
-- gtk.grange%s
-- gtk.grange%b
-- gtk.main%s
-- gtk.main%b
-- gtk.marshallers%s
-- gtk.marshallers%b
-- gtk.menu_item%s
-- gtk.menu_item%b
-- gtk.menu_shell%s
-- gtk.menu_shell%b
-- gtk.menu%s
-- gtk.menu%b
-- gtk.label%s
-- gtk.label%b
-- gtk.tree_view_column%s
-- gtk.tree_view_column%b
-- gtk.handlers%s
-- gtk.handlers%b
-- gtkada.handlers%s
-- gtkada.builder%s
-- gtkada.builder%b
-- lr.tasks%s
-- lr.simu%s
-- lr.simu%b
-- lr.affic%s
-- lr.tasks%b
-- lr.affic%b
-- lr.main%b
-- END ELABORATION ORDER
end ada_main;
|
programs/Desktop: Show.applescript
|
Strajk/setup
| 50 |
146
|
do shell script "defaults delete com.apple.finder CreateDesktop;killall Finder"
|
target/cos_117/disasm/iop_overlay1/STUBPR.asm
|
jrrk2/cray-sim
| 49 |
96768
|
0x0000 (0x000000) 0x1800-0x0000 f:00014 d: 0 | A = 0 (0x0000)
0x0002 (0x000004) 0x2919- f:00024 d: 281 | OR[281] = A
0x0003 (0x000006) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0004 (0x000008) 0x2927- f:00024 d: 295 | OR[295] = A
0x0005 (0x00000A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0006 (0x00000C) 0x2928- f:00024 d: 296 | OR[296] = A
0x0007 (0x00000E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0008 (0x000010) 0x2931- f:00024 d: 305 | OR[305] = A
0x0009 (0x000012) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x000A (0x000014) 0x291A- f:00024 d: 282 | OR[282] = A
0x000B (0x000016) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x000C (0x000018) 0x291C- f:00024 d: 284 | OR[284] = A
0x000D (0x00001A) 0x1018- f:00010 d: 24 | A = 24 (0x0018)
0x000E (0x00001C) 0x2934- f:00024 d: 308 | OR[308] = A
0x000F (0x00001E) 0x10BE- f:00010 d: 190 | A = 190 (0x00BE)
0x0010 (0x000020) 0x2935- f:00024 d: 309 | OR[309] = A
0x0011 (0x000022) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0012 (0x000024) 0x2936- f:00024 d: 310 | OR[310] = A
0x0013 (0x000026) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0014 (0x000028) 0x2937- f:00024 d: 311 | OR[311] = A
0x0015 (0x00002A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0016 (0x00002C) 0x2938- f:00024 d: 312 | OR[312] = A
0x0017 (0x00002E) 0x111A- f:00010 d: 282 | A = 282 (0x011A)
0x0018 (0x000030) 0x2939- f:00024 d: 313 | OR[313] = A
0x0019 (0x000032) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x001A (0x000034) 0x5800- f:00054 d: 0 | B = A
0x001B (0x000036) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x001C (0x000038) 0x7C09- f:00076 d: 9 | R = OR[9]
0x001D (0x00003A) 0x8602- f:00103 d: 2 | P = P + 2 (0x001F), A # 0
0x001E (0x00003C) 0x700B- f:00070 d: 11 | P = P + 11 (0x0029)
0x001F (0x00003E) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x0020 (0x000040) 0x2934- f:00024 d: 308 | OR[308] = A
0x0021 (0x000042) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0022 (0x000044) 0x2935- f:00024 d: 309 | OR[309] = A
0x0023 (0x000046) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0024 (0x000048) 0x5800- f:00054 d: 0 | B = A
0x0025 (0x00004A) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0027 (0x00004E) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0028 (0x000050) 0x721B- f:00071 d: 27 | P = P - 27 (0x000D)
0x0029 (0x000052) 0x211A- f:00020 d: 282 | A = OR[282]
0x002A (0x000054) 0x1458- f:00012 d: 88 | A = A + 88 (0x0058)
0x002B (0x000056) 0x291B- f:00024 d: 283 | OR[283] = A
0x002C (0x000058) 0x2118- f:00020 d: 280 | A = OR[280]
0x002D (0x00005A) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x002E (0x00005C) 0x2908- f:00024 d: 264 | OR[264] = A
0x002F (0x00005E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0030 (0x000060) 0x2929- f:00024 d: 297 | OR[297] = A
0x0031 (0x000062) 0x2129- f:00020 d: 297 | A = OR[297]
0x0032 (0x000064) 0x8602- f:00103 d: 2 | P = P + 2 (0x0034), A # 0
0x0033 (0x000066) 0x7005- f:00070 d: 5 | P = P + 5 (0x0038)
0x0034 (0x000068) 0x7E03-0x0299 f:00077 d: 3 | R = OR[3]+665 (0x0299)
0x0036 (0x00006C) 0x7E03-0x0321 f:00077 d: 3 | R = OR[3]+801 (0x0321)
0x0038 (0x000070) 0x74A9- f:00072 d: 169 | R = P + 169 (0x00E1)
0x0039 (0x000072) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x003A (0x000074) 0x291D- f:00024 d: 285 | OR[285] = A
0x003B (0x000076) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x003C (0x000078) 0x2924- f:00024 d: 292 | OR[292] = A
0x003D (0x00007A) 0x211D- f:00020 d: 285 | A = OR[285]
0x003E (0x00007C) 0x1E00-0xFFFF f:00017 d: 0 | A = A - 65535 (0xFFFF)
0x0040 (0x000080) 0x8405- f:00102 d: 5 | P = P + 5 (0x0045), A = 0
0x0041 (0x000082) 0x7458- f:00072 d: 88 | R = P + 88 (0x0099)
0x0042 (0x000084) 0x7513- f:00072 d: 275 | R = P + 275 (0x0155)
0x0043 (0x000086) 0x2D1D- f:00026 d: 285 | OR[285] = OR[285] + 1
0x0044 (0x000088) 0x7207- f:00071 d: 7 | P = P - 7 (0x003D)
0x0045 (0x00008A) 0x211C- f:00020 d: 284 | A = OR[284]
0x0046 (0x00008C) 0x8602- f:00103 d: 2 | P = P + 2 (0x0048), A # 0
0x0047 (0x00008E) 0x7003- f:00070 d: 3 | P = P + 3 (0x004A)
0x0048 (0x000090) 0x7E03-0x0254 f:00077 d: 3 | R = OR[3]+596 (0x0254)
0x004A (0x000094) 0x211A- f:00020 d: 282 | A = OR[282]
0x004B (0x000096) 0x8602- f:00103 d: 2 | P = P + 2 (0x004D), A # 0
0x004C (0x000098) 0x7009- f:00070 d: 9 | P = P + 9 (0x0055)
0x004D (0x00009A) 0x1019- f:00010 d: 25 | A = 25 (0x0019)
0x004E (0x00009C) 0x2934- f:00024 d: 308 | OR[308] = A
0x004F (0x00009E) 0x211A- f:00020 d: 282 | A = OR[282]
0x0050 (0x0000A0) 0x2935- f:00024 d: 309 | OR[309] = A
0x0051 (0x0000A2) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0052 (0x0000A4) 0x5800- f:00054 d: 0 | B = A
0x0053 (0x0000A6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0054 (0x0000A8) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0055 (0x0000AA) 0x2127- f:00020 d: 295 | A = OR[295]
0x0056 (0x0000AC) 0x8602- f:00103 d: 2 | P = P + 2 (0x0058), A # 0
0x0057 (0x0000AE) 0x7009- f:00070 d: 9 | P = P + 9 (0x0060)
0x0058 (0x0000B0) 0x1019- f:00010 d: 25 | A = 25 (0x0019)
0x0059 (0x0000B2) 0x2934- f:00024 d: 308 | OR[308] = A
0x005A (0x0000B4) 0x2127- f:00020 d: 295 | A = OR[295]
0x005B (0x0000B6) 0x2935- f:00024 d: 309 | OR[309] = A
0x005C (0x0000B8) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x005D (0x0000BA) 0x5800- f:00054 d: 0 | B = A
0x005E (0x0000BC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x005F (0x0000BE) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0060 (0x0000C0) 0x2128- f:00020 d: 296 | A = OR[296]
0x0061 (0x0000C2) 0x8602- f:00103 d: 2 | P = P + 2 (0x0063), A # 0
0x0062 (0x0000C4) 0x7009- f:00070 d: 9 | P = P + 9 (0x006B)
0x0063 (0x0000C6) 0x1019- f:00010 d: 25 | A = 25 (0x0019)
0x0064 (0x0000C8) 0x2934- f:00024 d: 308 | OR[308] = A
0x0065 (0x0000CA) 0x2128- f:00020 d: 296 | A = OR[296]
0x0066 (0x0000CC) 0x2935- f:00024 d: 309 | OR[309] = A
0x0067 (0x0000CE) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0068 (0x0000D0) 0x5800- f:00054 d: 0 | B = A
0x0069 (0x0000D2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x006A (0x0000D4) 0x7C09- f:00076 d: 9 | R = OR[9]
0x006B (0x0000D6) 0x2131- f:00020 d: 305 | A = OR[305]
0x006C (0x0000D8) 0x8602- f:00103 d: 2 | P = P + 2 (0x006E), A # 0
0x006D (0x0000DA) 0x700D- f:00070 d: 13 | P = P + 13 (0x007A)
0x006E (0x0000DC) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x006F (0x0000DE) 0x2934- f:00024 d: 308 | OR[308] = A
0x0070 (0x0000E0) 0x2132- f:00020 d: 306 | A = OR[306]
0x0071 (0x0000E2) 0x2935- f:00024 d: 309 | OR[309] = A
0x0072 (0x0000E4) 0x2133- f:00020 d: 307 | A = OR[307]
0x0073 (0x0000E6) 0x2936- f:00024 d: 310 | OR[310] = A
0x0074 (0x0000E8) 0x2131- f:00020 d: 305 | A = OR[305]
0x0075 (0x0000EA) 0x2937- f:00024 d: 311 | OR[311] = A
0x0076 (0x0000EC) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0077 (0x0000EE) 0x5800- f:00054 d: 0 | B = A
0x0078 (0x0000F0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0079 (0x0000F2) 0x7C09- f:00076 d: 9 | R = OR[9]
0x007A (0x0000F4) 0x1029- f:00010 d: 41 | A = 41 (0x0029)
0x007B (0x0000F6) 0x2934- f:00024 d: 308 | OR[308] = A
0x007C (0x0000F8) 0x1800-0x0168 f:00014 d: 0 | A = 360 (0x0168)
0x007E (0x0000FC) 0x2935- f:00024 d: 309 | OR[309] = A
0x007F (0x0000FE) 0x2119- f:00020 d: 281 | A = OR[281]
0x0080 (0x000100) 0x2936- f:00024 d: 310 | OR[310] = A
0x0081 (0x000102) 0x2118- f:00020 d: 280 | A = OR[280]
0x0082 (0x000104) 0x2937- f:00024 d: 311 | OR[311] = A
0x0083 (0x000106) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0084 (0x000108) 0x5800- f:00054 d: 0 | B = A
0x0085 (0x00010A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0086 (0x00010C) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0087 (0x00010E) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0088 (0x000110) 0x2934- f:00024 d: 308 | OR[308] = A
0x0089 (0x000112) 0x1800-0x0157 f:00014 d: 0 | A = 343 (0x0157)
0x008B (0x000116) 0x2935- f:00024 d: 309 | OR[309] = A
0x008C (0x000118) 0x2118- f:00020 d: 280 | A = OR[280]
0x008D (0x00011A) 0x2936- f:00024 d: 310 | OR[310] = A
0x008E (0x00011C) 0x211E- f:00020 d: 286 | A = OR[286]
0x008F (0x00011E) 0x2937- f:00024 d: 311 | OR[311] = A
0x0090 (0x000120) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0091 (0x000122) 0x5800- f:00054 d: 0 | B = A
0x0092 (0x000124) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0094 (0x000128) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0095 (0x00012A) 0x1800-0xA05F f:00014 d: 0 | A = 41055 (0xA05F)
0x0097 (0x00012E) 0x2919- f:00024 d: 281 | OR[281] = A
0x0098 (0x000130) 0x7253- f:00071 d: 83 | P = P - 83 (0x0045)
0x0099 (0x000132) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x009A (0x000134) 0x2934- f:00024 d: 308 | OR[308] = A
0x009B (0x000136) 0x1800-0x0168 f:00014 d: 0 | A = 360 (0x0168)
0x009D (0x00013A) 0x2935- f:00024 d: 309 | OR[309] = A
0x009E (0x00013C) 0x1800-0x484C f:00014 d: 0 | A = 18508 (0x484C)
0x00A0 (0x000140) 0x2936- f:00024 d: 310 | OR[310] = A
0x00A1 (0x000142) 0x2118- f:00020 d: 280 | A = OR[280]
0x00A2 (0x000144) 0x2937- f:00024 d: 311 | OR[311] = A
0x00A3 (0x000146) 0x211D- f:00020 d: 285 | A = OR[285]
0x00A4 (0x000148) 0x2938- f:00024 d: 312 | OR[312] = A
0x00A5 (0x00014A) 0x1013- f:00010 d: 19 | A = 19 (0x0013)
0x00A6 (0x00014C) 0x2939- f:00024 d: 313 | OR[313] = A
0x00A7 (0x00014E) 0x1014- f:00010 d: 20 | A = 20 (0x0014)
0x00A8 (0x000150) 0x293A- f:00024 d: 314 | OR[314] = A
0x00A9 (0x000152) 0x1015- f:00010 d: 21 | A = 21 (0x0015)
0x00AA (0x000154) 0x293B- f:00024 d: 315 | OR[315] = A
0x00AB (0x000156) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x00AC (0x000158) 0x5800- f:00054 d: 0 | B = A
0x00AD (0x00015A) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x00AF (0x00015E) 0x7C09- f:00076 d: 9 | R = OR[9]
0x00B0 (0x000160) 0x2919- f:00024 d: 281 | OR[281] = A
0x00B1 (0x000162) 0x2119- f:00020 d: 281 | A = OR[281]
0x00B2 (0x000164) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x00B3 (0x000166) 0x8402- f:00102 d: 2 | P = P + 2 (0x00B5), A = 0
0x00B4 (0x000168) 0x7009- f:00070 d: 9 | P = P + 9 (0x00BD)
0x00B5 (0x00016A) 0x2123- f:00020 d: 291 | A = OR[291]
0x00B6 (0x00016C) 0x8602- f:00103 d: 2 | P = P + 2 (0x00B8), A # 0
0x00B7 (0x00016E) 0x7005- f:00070 d: 5 | P = P + 5 (0x00BC)
0x00B8 (0x000170) 0x1800-0x0175 f:00014 d: 0 | A = 373 (0x0175)
0x00BA (0x000174) 0x291E- f:00024 d: 286 | OR[286] = A
0x00BB (0x000176) 0x7234- f:00071 d: 52 | P = P - 52 (0x0087)
0x00BC (0x000178) 0x701D- f:00070 d: 29 | P = P + 29 (0x00D9)
0x00BD (0x00017A) 0x2119- f:00020 d: 281 | A = OR[281]
0x00BE (0x00017C) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x00BF (0x00017E) 0x8402- f:00102 d: 2 | P = P + 2 (0x00C1), A = 0
0x00C0 (0x000180) 0x700E- f:00070 d: 14 | P = P + 14 (0x00CE)
0x00C1 (0x000182) 0x2123- f:00020 d: 291 | A = OR[291]
0x00C2 (0x000184) 0x8402- f:00102 d: 2 | P = P + 2 (0x00C4), A = 0
0x00C3 (0x000186) 0x7006- f:00070 d: 6 | P = P + 6 (0x00C9)
0x00C4 (0x000188) 0x1800-0x016A f:00014 d: 0 | A = 362 (0x016A)
0x00C6 (0x00018C) 0x291E- f:00024 d: 286 | OR[286] = A
0x00C7 (0x00018E) 0x7240- f:00071 d: 64 | P = P - 64 (0x0087)
0x00C8 (0x000190) 0x7005- f:00070 d: 5 | P = P + 5 (0x00CD)
0x00C9 (0x000192) 0x1800-0x805F f:00014 d: 0 | A = 32863 (0x805F)
0x00CB (0x000196) 0x2919- f:00024 d: 281 | OR[281] = A
0x00CC (0x000198) 0x7287- f:00071 d: 135 | P = P - 135 (0x0045)
0x00CD (0x00019A) 0x700C- f:00070 d: 12 | P = P + 12 (0x00D9)
0x00CE (0x00019C) 0x2119- f:00020 d: 281 | A = OR[281]
0x00CF (0x00019E) 0x1603- f:00013 d: 3 | A = A - 3 (0x0003)
0x00D0 (0x0001A0) 0x8402- f:00102 d: 2 | P = P + 2 (0x00D2), A = 0
0x00D1 (0x0001A2) 0x7006- f:00070 d: 6 | P = P + 6 (0x00D7)
0x00D2 (0x0001A4) 0x1800-0x0000 f:00014 d: 0 | A = 0 (0x0000)
0x00D4 (0x0001A8) 0x2919- f:00024 d: 281 | OR[281] = A
0x00D5 (0x0001AA) 0x7290- f:00071 d: 144 | P = P - 144 (0x0045)
0x00D6 (0x0001AC) 0x7003- f:00070 d: 3 | P = P + 3 (0x00D9)
0x00D7 (0x0001AE) 0x7C34- f:00076 d: 52 | R = OR[52]
0x00D8 (0x0001B0) 0x0000- f:00000 d: 0 | PASS
0x00D9 (0x0001B2) 0x2120- f:00020 d: 288 | A = OR[288]
0x00DA (0x0001B4) 0x391A- f:00034 d: 282 | (OR[282]) = A
0x00DB (0x0001B6) 0x211A- f:00020 d: 282 | A = OR[282]
0x00DC (0x0001B8) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x00DD (0x0001BA) 0x2908- f:00024 d: 264 | OR[264] = A
0x00DE (0x0001BC) 0x2121- f:00020 d: 289 | A = OR[289]
0x00DF (0x0001BE) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00E0 (0x0001C0) 0x0200- f:00001 d: 0 | EXIT
0x00E1 (0x0001C2) 0x1800-0xFFFF f:00014 d: 0 | A = 65535 (0xFFFF)
0x00E3 (0x0001C6) 0x290D- f:00024 d: 269 | OR[269] = A
0x00E4 (0x0001C8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00E5 (0x0001CA) 0x290E- f:00024 d: 270 | OR[270] = A
0x00E6 (0x0001CC) 0x2006- f:00020 d: 6 | A = OR[6]
0x00E7 (0x0001CE) 0x2910- f:00024 d: 272 | OR[272] = A
0x00E8 (0x0001D0) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x00E9 (0x0001D2) 0x2934- f:00024 d: 308 | OR[308] = A
0x00EA (0x0001D4) 0x1800-0x00A9 f:00014 d: 0 | A = 169 (0x00A9)
0x00EC (0x0001D8) 0x2935- f:00024 d: 309 | OR[309] = A
0x00ED (0x0001DA) 0x1800-0x5052 f:00014 d: 0 | A = 20562 (0x5052)
0x00EF (0x0001DE) 0x2936- f:00024 d: 310 | OR[310] = A
0x00F0 (0x0001E0) 0x210D- f:00020 d: 269 | A = OR[269]
0x00F1 (0x0001E2) 0x2937- f:00024 d: 311 | OR[311] = A
0x00F2 (0x0001E4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00F3 (0x0001E6) 0x2938- f:00024 d: 312 | OR[312] = A
0x00F4 (0x0001E8) 0x210E- f:00020 d: 270 | A = OR[270]
0x00F5 (0x0001EA) 0x2939- f:00024 d: 313 | OR[313] = A
0x00F6 (0x0001EC) 0x210F- f:00020 d: 271 | A = OR[271]
0x00F7 (0x0001EE) 0x293A- f:00024 d: 314 | OR[314] = A
0x00F8 (0x0001F0) 0x2110- f:00020 d: 272 | A = OR[272]
0x00F9 (0x0001F2) 0x293B- f:00024 d: 315 | OR[315] = A
0x00FA (0x0001F4) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x00FB (0x0001F6) 0x293C- f:00024 d: 316 | OR[316] = A
0x00FC (0x0001F8) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x00FD (0x0001FA) 0x5800- f:00054 d: 0 | B = A
0x00FE (0x0001FC) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0100 (0x000200) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0101 (0x000202) 0x2919- f:00024 d: 281 | OR[281] = A
0x0102 (0x000204) 0x2119- f:00020 d: 281 | A = OR[281]
0x0103 (0x000206) 0x8602- f:00103 d: 2 | P = P + 2 (0x0105), A # 0
0x0104 (0x000208) 0x7003- f:00070 d: 3 | P = P + 3 (0x0107)
0x0105 (0x00020A) 0x7A03-0x027F f:00075 d: 3 | P = OR[3]+639 (0x027F)
0x0107 (0x00020E) 0x2118- f:00020 d: 280 | A = OR[280]
0x0108 (0x000210) 0x1418- f:00012 d: 24 | A = A + 24 (0x0018)
0x0109 (0x000212) 0x2908- f:00024 d: 264 | OR[264] = A
0x010A (0x000214) 0x211C- f:00020 d: 284 | A = OR[284]
0x010B (0x000216) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x010C (0x000218) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x010D (0x00021A) 0x2934- f:00024 d: 308 | OR[308] = A
0x010E (0x00021C) 0x1800-0x013F f:00014 d: 0 | A = 319 (0x013F)
0x0110 (0x000220) 0x2935- f:00024 d: 309 | OR[309] = A
0x0111 (0x000222) 0x2118- f:00020 d: 280 | A = OR[280]
0x0112 (0x000224) 0x2936- f:00024 d: 310 | OR[310] = A
0x0113 (0x000226) 0x211C- f:00020 d: 284 | A = OR[284]
0x0114 (0x000228) 0x2937- f:00024 d: 311 | OR[311] = A
0x0115 (0x00022A) 0x211B- f:00020 d: 283 | A = OR[283]
0x0116 (0x00022C) 0x2938- f:00024 d: 312 | OR[312] = A
0x0117 (0x00022E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0118 (0x000230) 0x2939- f:00024 d: 313 | OR[313] = A
0x0119 (0x000232) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x011A (0x000234) 0x5800- f:00054 d: 0 | B = A
0x011B (0x000236) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x011D (0x00023A) 0x7C09- f:00076 d: 9 | R = OR[9]
0x011E (0x00023C) 0x2919- f:00024 d: 281 | OR[281] = A
0x011F (0x00023E) 0x2119- f:00020 d: 281 | A = OR[281]
0x0120 (0x000240) 0x8602- f:00103 d: 2 | P = P + 2 (0x0122), A # 0
0x0121 (0x000242) 0x7003- f:00070 d: 3 | P = P + 3 (0x0124)
0x0122 (0x000244) 0x7A03-0x027F f:00075 d: 3 | P = OR[3]+639 (0x027F)
0x0124 (0x000248) 0x211A- f:00020 d: 282 | A = OR[282]
0x0125 (0x00024A) 0x290E- f:00024 d: 270 | OR[270] = A
0x0126 (0x00024C) 0x10BE- f:00010 d: 190 | A = 190 (0x00BE)
0x0127 (0x00024E) 0x290D- f:00024 d: 269 | OR[269] = A
0x0128 (0x000250) 0x210D- f:00020 d: 269 | A = OR[269]
0x0129 (0x000252) 0x8406- f:00102 d: 6 | P = P + 6 (0x012F), A = 0
0x012A (0x000254) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x012B (0x000256) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x012C (0x000258) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x012D (0x00025A) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x012E (0x00025C) 0x7206- f:00071 d: 6 | P = P - 6 (0x0128)
0x012F (0x00025E) 0x2118- f:00020 d: 280 | A = OR[280]
0x0130 (0x000260) 0x141B- f:00012 d: 27 | A = A + 27 (0x001B)
0x0131 (0x000262) 0x2908- f:00024 d: 264 | OR[264] = A
0x0132 (0x000264) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0133 (0x000266) 0x2922- f:00024 d: 290 | OR[290] = A
0x0134 (0x000268) 0x2122- f:00020 d: 290 | A = OR[290]
0x0135 (0x00026A) 0x1E00-0x4E43 f:00017 d: 0 | A = A - 20035 (0x4E43)
0x0137 (0x00026E) 0x8402- f:00102 d: 2 | P = P + 2 (0x0139), A = 0
0x0138 (0x000270) 0x7008- f:00070 d: 8 | P = P + 8 (0x0140)
0x0139 (0x000272) 0x211A- f:00020 d: 282 | A = OR[282]
0x013A (0x000274) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x013B (0x000276) 0x2908- f:00024 d: 264 | OR[264] = A
0x013C (0x000278) 0x211B- f:00020 d: 283 | A = OR[283]
0x013D (0x00027A) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x013E (0x00027C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x013F (0x00027E) 0x7006- f:00070 d: 6 | P = P + 6 (0x0145)
0x0140 (0x000280) 0x211A- f:00020 d: 282 | A = OR[282]
0x0141 (0x000282) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x0142 (0x000284) 0x2908- f:00024 d: 264 | OR[264] = A
0x0143 (0x000286) 0x211B- f:00020 d: 283 | A = OR[283]
0x0144 (0x000288) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0145 (0x00028A) 0x211A- f:00020 d: 282 | A = OR[282]
0x0146 (0x00028C) 0x1408- f:00012 d: 8 | A = A + 8 (0x0008)
0x0147 (0x00028E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0148 (0x000290) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0149 (0x000292) 0x0A02- f:00005 d: 2 | A = A < 2 (0x0002)
0x014A (0x000294) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x014B (0x000296) 0x0C02- f:00006 d: 2 | A = A >> 2 (0x0002)
0x014C (0x000298) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x014D (0x00029A) 0x211A- f:00020 d: 282 | A = OR[282]
0x014E (0x00029C) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x014F (0x00029E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0150 (0x0002A0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0151 (0x0002A2) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0152 (0x0002A4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0153 (0x0002A6) 0x2923- f:00024 d: 291 | OR[291] = A
0x0154 (0x0002A8) 0x0200- f:00001 d: 0 | EXIT
0x0155 (0x0002AA) 0x2124- f:00020 d: 292 | A = OR[292]
0x0156 (0x0002AC) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x0157 (0x0002AE) 0x8602- f:00103 d: 2 | P = P + 2 (0x0159), A # 0
0x0158 (0x0002B0) 0x7013- f:00070 d: 19 | P = P + 19 (0x016B)
0x0159 (0x0002B2) 0x2122- f:00020 d: 290 | A = OR[290]
0x015A (0x0002B4) 0x1E00-0x4E43 f:00017 d: 0 | A = A - 20035 (0x4E43)
0x015C (0x0002B8) 0x8402- f:00102 d: 2 | P = P + 2 (0x015E), A = 0
0x015D (0x0002BA) 0x7007- f:00070 d: 7 | P = P + 7 (0x0164)
0x015E (0x0002BC) 0x211A- f:00020 d: 282 | A = OR[282]
0x015F (0x0002BE) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0160 (0x0002C0) 0x2908- f:00024 d: 264 | OR[264] = A
0x0161 (0x0002C2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0162 (0x0002C4) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0163 (0x0002C6) 0x7006- f:00070 d: 6 | P = P + 6 (0x0169)
0x0164 (0x0002C8) 0x211A- f:00020 d: 282 | A = OR[282]
0x0165 (0x0002CA) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0166 (0x0002CC) 0x2908- f:00024 d: 264 | OR[264] = A
0x0167 (0x0002CE) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0168 (0x0002D0) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0169 (0x0002D2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x016A (0x0002D4) 0x391B- f:00034 d: 283 | (OR[283]) = A
0x016B (0x0002D6) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x016C (0x0002D8) 0x2934- f:00024 d: 308 | OR[308] = A
0x016D (0x0002DA) 0x1800-0x017E f:00014 d: 0 | A = 382 (0x017E)
0x016F (0x0002DE) 0x2935- f:00024 d: 309 | OR[309] = A
0x0170 (0x0002E0) 0x211A- f:00020 d: 282 | A = OR[282]
0x0171 (0x0002E2) 0x2936- f:00024 d: 310 | OR[310] = A
0x0172 (0x0002E4) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0173 (0x0002E6) 0x5800- f:00054 d: 0 | B = A
0x0174 (0x0002E8) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0176 (0x0002EC) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0177 (0x0002EE) 0x211A- f:00020 d: 282 | A = OR[282]
0x0178 (0x0002F0) 0x1406- f:00012 d: 6 | A = A + 6 (0x0006)
0x0179 (0x0002F2) 0x2908- f:00024 d: 264 | OR[264] = A
0x017A (0x0002F4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x017B (0x0002F6) 0x2924- f:00024 d: 292 | OR[292] = A
0x017C (0x0002F8) 0x2124- f:00020 d: 292 | A = OR[292]
0x017D (0x0002FA) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x017E (0x0002FC) 0x8405- f:00102 d: 5 | P = P + 5 (0x0183), A = 0
0x017F (0x0002FE) 0x2124- f:00020 d: 292 | A = OR[292]
0x0180 (0x000300) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0181 (0x000302) 0x8402- f:00102 d: 2 | P = P + 2 (0x0183), A = 0
0x0182 (0x000304) 0x7015- f:00070 d: 21 | P = P + 21 (0x0197)
0x0183 (0x000306) 0x2124- f:00020 d: 292 | A = OR[292]
0x0184 (0x000308) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0185 (0x00030A) 0x8402- f:00102 d: 2 | P = P + 2 (0x0187), A = 0
0x0186 (0x00030C) 0x7003- f:00070 d: 3 | P = P + 3 (0x0189)
0x0187 (0x00030E) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0188 (0x000310) 0x2923- f:00024 d: 291 | OR[291] = A
0x0189 (0x000312) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x018A (0x000314) 0x2934- f:00024 d: 308 | OR[308] = A
0x018B (0x000316) 0x2120- f:00020 d: 288 | A = OR[288]
0x018C (0x000318) 0x2935- f:00024 d: 309 | OR[309] = A
0x018D (0x00031A) 0x2121- f:00020 d: 289 | A = OR[289]
0x018E (0x00031C) 0x2936- f:00024 d: 310 | OR[310] = A
0x018F (0x00031E) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0190 (0x000320) 0x2937- f:00024 d: 311 | OR[311] = A
0x0191 (0x000322) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0192 (0x000324) 0x5800- f:00054 d: 0 | B = A
0x0193 (0x000326) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0194 (0x000328) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0195 (0x00032A) 0x0200- f:00001 d: 0 | EXIT
0x0196 (0x00032C) 0x7056- f:00070 d: 86 | P = P + 86 (0x01EC)
0x0197 (0x00032E) 0x2124- f:00020 d: 292 | A = OR[292]
0x0198 (0x000330) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0199 (0x000332) 0x8402- f:00102 d: 2 | P = P + 2 (0x019B), A = 0
0x019A (0x000334) 0x7010- f:00070 d: 16 | P = P + 16 (0x01AA)
0x019B (0x000336) 0x211B- f:00020 d: 283 | A = OR[283]
0x019C (0x000338) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x019D (0x00033A) 0x2908- f:00024 d: 264 | OR[264] = A
0x019E (0x00033C) 0x1800-0x2F45 f:00014 d: 0 | A = 12101 (0x2F45)
0x01A0 (0x000340) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01A1 (0x000342) 0x211B- f:00020 d: 283 | A = OR[283]
0x01A2 (0x000344) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x01A3 (0x000346) 0x2908- f:00024 d: 264 | OR[264] = A
0x01A4 (0x000348) 0x1800-0x4F46 f:00014 d: 0 | A = 20294 (0x4F46)
0x01A6 (0x00034C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01A7 (0x00034E) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x01A8 (0x000350) 0x2925- f:00024 d: 293 | OR[293] = A
0x01A9 (0x000352) 0x7043- f:00070 d: 67 | P = P + 67 (0x01EC)
0x01AA (0x000354) 0x2124- f:00020 d: 292 | A = OR[292]
0x01AB (0x000356) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x01AC (0x000358) 0x8402- f:00102 d: 2 | P = P + 2 (0x01AE), A = 0
0x01AD (0x00035A) 0x7006- f:00070 d: 6 | P = P + 6 (0x01B3)
0x01AE (0x00035C) 0x1800-0x0104 f:00014 d: 0 | A = 260 (0x0104)
0x01B0 (0x000360) 0x291E- f:00024 d: 286 | OR[286] = A
0x01B1 (0x000362) 0x732A- f:00071 d: 298 | P = P - 298 (0x0087)
0x01B2 (0x000364) 0x703A- f:00070 d: 58 | P = P + 58 (0x01EC)
0x01B3 (0x000366) 0x211A- f:00020 d: 282 | A = OR[282]
0x01B4 (0x000368) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x01B5 (0x00036A) 0x2908- f:00024 d: 264 | OR[264] = A
0x01B6 (0x00036C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01B7 (0x00036E) 0x2926- f:00024 d: 294 | OR[294] = A
0x01B8 (0x000370) 0x2126- f:00020 d: 294 | A = OR[294]
0x01B9 (0x000372) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x01BA (0x000374) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x01BB (0x000376) 0x2925- f:00024 d: 293 | OR[293] = A
0x01BC (0x000378) 0x2122- f:00020 d: 290 | A = OR[290]
0x01BD (0x00037A) 0x1E00-0x4E43 f:00017 d: 0 | A = A - 20035 (0x4E43)
0x01BF (0x00037E) 0x8602- f:00103 d: 2 | P = P + 2 (0x01C1), A # 0
0x01C0 (0x000380) 0x7002- f:00070 d: 2 | P = P + 2 (0x01C2)
0x01C1 (0x000382) 0x2F25- f:00027 d: 293 | OR[293] = OR[293] - 1
0x01C2 (0x000384) 0x2125- f:00020 d: 293 | A = OR[293]
0x01C3 (0x000386) 0x1642- f:00013 d: 66 | A = A - 66 (0x0042)
0x01C4 (0x000388) 0x8003- f:00100 d: 3 | P = P + 3 (0x01C7), C = 0
0x01C5 (0x00038A) 0x8402- f:00102 d: 2 | P = P + 2 (0x01C7), A = 0
0x01C6 (0x00038C) 0x7002- f:00070 d: 2 | P = P + 2 (0x01C8)
0x01C7 (0x00038E) 0x7003- f:00070 d: 3 | P = P + 3 (0x01CA)
0x01C8 (0x000390) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x01C9 (0x000392) 0x2925- f:00024 d: 293 | OR[293] = A
0x01CA (0x000394) 0x2126- f:00020 d: 294 | A = OR[294]
0x01CB (0x000396) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x01CC (0x000398) 0x2908- f:00024 d: 264 | OR[264] = A
0x01CD (0x00039A) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x01CE (0x00039C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x01CF (0x00039E) 0x8402- f:00102 d: 2 | P = P + 2 (0x01D1), A = 0
0x01D0 (0x0003A0) 0x701C- f:00070 d: 28 | P = P + 28 (0x01EC)
0x01D1 (0x0003A2) 0x211B- f:00020 d: 283 | A = OR[283]
0x01D2 (0x0003A4) 0x2525- f:00022 d: 293 | A = A + OR[293]
0x01D3 (0x0003A6) 0x2913- f:00024 d: 275 | OR[275] = A
0x01D4 (0x0003A8) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x01D5 (0x0003AA) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x01D6 (0x0003AC) 0x290D- f:00024 d: 269 | OR[269] = A
0x01D7 (0x0003AE) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x01D8 (0x0003B0) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x01D9 (0x0003B2) 0x2513- f:00022 d: 275 | A = A + OR[275]
0x01DA (0x0003B4) 0x290E- f:00024 d: 270 | OR[270] = A
0x01DB (0x0003B6) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x01DC (0x0003B8) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x01DD (0x0003BA) 0x2908- f:00024 d: 264 | OR[264] = A
0x01DE (0x0003BC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01DF (0x0003BE) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x01E0 (0x0003C0) 0x8607- f:00103 d: 7 | P = P + 7 (0x01E7), A # 0
0x01E1 (0x0003C2) 0x310E- f:00030 d: 270 | A = (OR[270])
0x01E2 (0x0003C4) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x01E3 (0x0003C6) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x01E4 (0x0003C8) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x01E5 (0x0003CA) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x01E6 (0x0003CC) 0x7006- f:00070 d: 6 | P = P + 6 (0x01EC)
0x01E7 (0x0003CE) 0x310E- f:00030 d: 270 | A = (OR[270])
0x01E8 (0x0003D0) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x01EA (0x0003D4) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x01EB (0x0003D6) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x01EC (0x0003D8) 0x2129- f:00020 d: 297 | A = OR[297]
0x01ED (0x0003DA) 0x8403- f:00102 d: 3 | P = P + 3 (0x01F0), A = 0
0x01EE (0x0003DC) 0x7A03-0x020E f:00075 d: 3 | P = OR[3]+526 (0x020E)
0x01F0 (0x0003E0) 0x211C- f:00020 d: 284 | A = OR[284]
0x01F1 (0x0003E2) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x01F2 (0x0003E4) 0x2908- f:00024 d: 264 | OR[264] = A
0x01F3 (0x0003E6) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01F4 (0x0003E8) 0x290D- f:00024 d: 269 | OR[269] = A
0x01F5 (0x0003EA) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x01F6 (0x0003EC) 0x2934- f:00024 d: 308 | OR[308] = A
0x01F7 (0x0003EE) 0x210D- f:00020 d: 269 | A = OR[269]
0x01F8 (0x0003F0) 0x2935- f:00024 d: 309 | OR[309] = A
0x01F9 (0x0003F2) 0x211C- f:00020 d: 284 | A = OR[284]
0x01FA (0x0003F4) 0x2936- f:00024 d: 310 | OR[310] = A
0x01FB (0x0003F6) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x01FC (0x0003F8) 0x2937- f:00024 d: 311 | OR[311] = A
0x01FD (0x0003FA) 0x211B- f:00020 d: 283 | A = OR[283]
0x01FE (0x0003FC) 0x2938- f:00024 d: 312 | OR[312] = A
0x01FF (0x0003FE) 0x2125- f:00020 d: 293 | A = OR[293]
0x0200 (0x000400) 0x2939- f:00024 d: 313 | OR[313] = A
0x0201 (0x000402) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0202 (0x000404) 0x5800- f:00054 d: 0 | B = A
0x0203 (0x000406) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0205 (0x00040A) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0206 (0x00040C) 0x2919- f:00024 d: 281 | OR[281] = A
0x0207 (0x00040E) 0x7036- f:00070 d: 54 | P = P + 54 (0x023D)
0x0208 (0x000410) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0209 (0x000412) 0x2919- f:00024 d: 281 | OR[281] = A
0x020A (0x000414) 0x2128- f:00020 d: 296 | A = OR[296]
0x020B (0x000416) 0x290E- f:00024 d: 270 | OR[270] = A
0x020C (0x000418) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x020D (0x00041A) 0x290D- f:00024 d: 269 | OR[269] = A
0x020E (0x00041C) 0x210D- f:00020 d: 269 | A = OR[269]
0x020F (0x00041E) 0x8406- f:00102 d: 6 | P = P + 6 (0x0215), A = 0
0x0210 (0x000420) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0211 (0x000422) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0212 (0x000424) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x0213 (0x000426) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x0214 (0x000428) 0x7206- f:00071 d: 6 | P = P - 6 (0x020E)
0x0215 (0x00042A) 0x2122- f:00020 d: 290 | A = OR[290]
0x0216 (0x00042C) 0x1E00-0x4E43 f:00017 d: 0 | A = A - 20035 (0x4E43)
0x0218 (0x000430) 0x8602- f:00103 d: 2 | P = P + 2 (0x021A), A # 0
0x0219 (0x000432) 0x7011- f:00070 d: 17 | P = P + 17 (0x022A)
0x021A (0x000434) 0x311B- f:00030 d: 283 | A = (OR[283])
0x021B (0x000436) 0x1630- f:00013 d: 48 | A = A - 48 (0x0030)
0x021C (0x000438) 0x8402- f:00102 d: 2 | P = P + 2 (0x021E), A = 0
0x021D (0x00043A) 0x7003- f:00070 d: 3 | P = P + 3 (0x0220)
0x021E (0x00043C) 0x7588- f:00072 d: 392 | R = P + 392 (0x03A6)
0x021F (0x00043E) 0x700B- f:00070 d: 11 | P = P + 11 (0x022A)
0x0220 (0x000440) 0x311B- f:00030 d: 283 | A = (OR[283])
0x0221 (0x000442) 0x1631- f:00013 d: 49 | A = A - 49 (0x0031)
0x0222 (0x000444) 0x8402- f:00102 d: 2 | P = P + 2 (0x0224), A = 0
0x0223 (0x000446) 0x7007- f:00070 d: 7 | P = P + 7 (0x022A)
0x0224 (0x000448) 0x2130- f:00020 d: 304 | A = OR[304]
0x0225 (0x00044A) 0x8405- f:00102 d: 5 | P = P + 5 (0x022A), A = 0
0x0226 (0x00044C) 0x2119- f:00020 d: 281 | A = OR[281]
0x0227 (0x00044E) 0x8603- f:00103 d: 3 | P = P + 3 (0x022A), A # 0
0x0228 (0x000450) 0x757E- f:00072 d: 382 | R = P + 382 (0x03A6)
0x0229 (0x000452) 0x7205- f:00071 d: 5 | P = P - 5 (0x0224)
0x022A (0x000454) 0x2119- f:00020 d: 281 | A = OR[281]
0x022B (0x000456) 0x8402- f:00102 d: 2 | P = P + 2 (0x022D), A = 0
0x022C (0x000458) 0x7011- f:00070 d: 17 | P = P + 17 (0x023D)
0x022D (0x00045A) 0x211B- f:00020 d: 283 | A = OR[283]
0x022E (0x00045C) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x022F (0x00045E) 0x290D- f:00024 d: 269 | OR[269] = A
0x0230 (0x000460) 0x2128- f:00020 d: 296 | A = OR[296]
0x0231 (0x000462) 0x290E- f:00024 d: 270 | OR[270] = A
0x0232 (0x000464) 0x2125- f:00020 d: 293 | A = OR[293]
0x0233 (0x000466) 0x290F- f:00024 d: 271 | OR[271] = A
0x0234 (0x000468) 0x7006- f:00070 d: 6 | P = P + 6 (0x023A)
0x0235 (0x00046A) 0x310D- f:00030 d: 269 | A = (OR[269])
0x0236 (0x00046C) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0237 (0x00046E) 0x2D0D- f:00026 d: 269 | OR[269] = OR[269] + 1
0x0238 (0x000470) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x0239 (0x000472) 0x2F0F- f:00027 d: 271 | OR[271] = OR[271] - 1
0x023A (0x000474) 0x210F- f:00020 d: 271 | A = OR[271]
0x023B (0x000476) 0x8E06- f:00107 d: 6 | P = P - 6 (0x0235), A # 0
0x023C (0x000478) 0x756A- f:00072 d: 362 | R = P + 362 (0x03A6)
0x023D (0x00047A) 0x2119- f:00020 d: 281 | A = OR[281]
0x023E (0x00047C) 0x8602- f:00103 d: 2 | P = P + 2 (0x0240), A # 0
0x023F (0x00047E) 0x700E- f:00070 d: 14 | P = P + 14 (0x024D)
0x0240 (0x000480) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x0241 (0x000482) 0x2934- f:00024 d: 308 | OR[308] = A
0x0242 (0x000484) 0x2120- f:00020 d: 288 | A = OR[288]
0x0243 (0x000486) 0x2935- f:00024 d: 309 | OR[309] = A
0x0244 (0x000488) 0x2121- f:00020 d: 289 | A = OR[289]
0x0245 (0x00048A) 0x2936- f:00024 d: 310 | OR[310] = A
0x0246 (0x00048C) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0247 (0x00048E) 0x2937- f:00024 d: 311 | OR[311] = A
0x0248 (0x000490) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0249 (0x000492) 0x5800- f:00054 d: 0 | B = A
0x024A (0x000494) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x024B (0x000496) 0x7C09- f:00076 d: 9 | R = OR[9]
0x024C (0x000498) 0x702D- f:00070 d: 45 | P = P + 45 (0x0279)
0x024D (0x00049A) 0x72F8- f:00071 d: 248 | P = P - 248 (0x0155)
0x024E (0x00049C) 0x2129- f:00020 d: 297 | A = OR[297]
0x024F (0x00049E) 0x8602- f:00103 d: 2 | P = P + 2 (0x0251), A # 0
0x0250 (0x0004A0) 0x7018- f:00070 d: 24 | P = P + 24 (0x0268)
0x0251 (0x0004A2) 0x2119- f:00020 d: 281 | A = OR[281]
0x0252 (0x0004A4) 0x1E00-0x805F f:00017 d: 0 | A = A - 32863 (0x805F)
0x0254 (0x0004A8) 0x8402- f:00102 d: 2 | P = P + 2 (0x0256), A = 0
0x0255 (0x0004AA) 0x7013- f:00070 d: 19 | P = P + 19 (0x0268)
0x0256 (0x0004AC) 0x2128- f:00020 d: 296 | A = OR[296]
0x0257 (0x0004AE) 0x290E- f:00024 d: 270 | OR[270] = A
0x0258 (0x0004B0) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x0259 (0x0004B2) 0x290D- f:00024 d: 269 | OR[269] = A
0x025A (0x0004B4) 0x210D- f:00020 d: 269 | A = OR[269]
0x025B (0x0004B6) 0x8406- f:00102 d: 6 | P = P + 6 (0x0261), A = 0
0x025C (0x0004B8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x025D (0x0004BA) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x025E (0x0004BC) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x025F (0x0004BE) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x0260 (0x0004C0) 0x7206- f:00071 d: 6 | P = P - 6 (0x025A)
0x0261 (0x0004C2) 0x2130- f:00020 d: 304 | A = OR[304]
0x0262 (0x0004C4) 0x8403- f:00102 d: 3 | P = P + 3 (0x0265), A = 0
0x0263 (0x0004C6) 0x7543- f:00072 d: 323 | R = P + 323 (0x03A6)
0x0264 (0x0004C8) 0x7203- f:00071 d: 3 | P = P - 3 (0x0261)
0x0265 (0x0004CA) 0x1800-0x805F f:00014 d: 0 | A = 32863 (0x805F)
0x0267 (0x0004CE) 0x2919- f:00024 d: 281 | OR[281] = A
0x0268 (0x0004D0) 0x1006- f:00010 d: 6 | A = 6 (0x0006)
0x0269 (0x0004D2) 0x290D- f:00024 d: 269 | OR[269] = A
0x026A (0x0004D4) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x026B (0x0004D6) 0x2934- f:00024 d: 308 | OR[308] = A
0x026C (0x0004D8) 0x1800-0x00A5 f:00014 d: 0 | A = 165 (0x00A5)
0x026E (0x0004DC) 0x2935- f:00024 d: 309 | OR[309] = A
0x026F (0x0004DE) 0x211C- f:00020 d: 284 | A = OR[284]
0x0270 (0x0004E0) 0x2936- f:00024 d: 310 | OR[310] = A
0x0271 (0x0004E2) 0x210D- f:00020 d: 269 | A = OR[269]
0x0272 (0x0004E4) 0x2937- f:00024 d: 311 | OR[311] = A
0x0273 (0x0004E6) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0274 (0x0004E8) 0x5800- f:00054 d: 0 | B = A
0x0275 (0x0004EA) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0277 (0x0004EE) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0278 (0x0004F0) 0x0200- f:00001 d: 0 | EXIT
0x0279 (0x0004F2) 0x2119- f:00020 d: 281 | A = OR[281]
0x027A (0x0004F4) 0x1605- f:00013 d: 5 | A = A - 5 (0x0005)
0x027B (0x0004F6) 0x8405- f:00102 d: 5 | P = P + 5 (0x0280), A = 0
0x027C (0x0004F8) 0x2119- f:00020 d: 281 | A = OR[281]
0x027D (0x0004FA) 0x1603- f:00013 d: 3 | A = A - 3 (0x0003)
0x027E (0x0004FC) 0x8402- f:00102 d: 2 | P = P + 2 (0x0280), A = 0
0x027F (0x0004FE) 0x7007- f:00070 d: 7 | P = P + 7 (0x0286)
0x0280 (0x000500) 0x1800-0x905F f:00014 d: 0 | A = 36959 (0x905F)
0x0282 (0x000504) 0x2919- f:00024 d: 281 | OR[281] = A
0x0283 (0x000506) 0x7A03-0x004B f:00075 d: 3 | P = OR[3]+75 (0x004B)
0x0285 (0x00050A) 0x700C- f:00070 d: 12 | P = P + 12 (0x0291)
0x0286 (0x00050C) 0x2119- f:00020 d: 281 | A = OR[281]
0x0287 (0x00050E) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0288 (0x000510) 0x8402- f:00102 d: 2 | P = P + 2 (0x028A), A = 0
0x0289 (0x000512) 0x7005- f:00070 d: 5 | P = P + 5 (0x028E)
0x028A (0x000514) 0x1800-0x0194 f:00014 d: 0 | A = 404 (0x0194)
0x028C (0x000518) 0x291E- f:00024 d: 286 | OR[286] = A
0x028D (0x00051A) 0x7004- f:00070 d: 4 | P = P + 4 (0x0291)
0x028E (0x00051C) 0x1800-0x014A f:00014 d: 0 | A = 330 (0x014A)
0x0290 (0x000520) 0x291E- f:00024 d: 286 | OR[286] = A
0x0291 (0x000522) 0x7A03-0x008D f:00075 d: 3 | P = OR[3]+141 (0x008D)
0x0293 (0x000526) 0x2118- f:00020 d: 280 | A = OR[280]
0x0294 (0x000528) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x0295 (0x00052A) 0x2913- f:00024 d: 275 | OR[275] = A
0x0296 (0x00052C) 0x2003- f:00020 d: 3 | A = OR[3]
0x0297 (0x00052E) 0x1C00-0x03E3 f:00016 d: 0 | A = A + 995 (0x03E3)
0x0299 (0x000532) 0x2914- f:00024 d: 276 | OR[276] = A
0x029A (0x000534) 0x3114- f:00030 d: 276 | A = (OR[276])
0x029B (0x000536) 0x8439- f:00102 d: 57 | P = P + 57 (0x02D4), A = 0
0x029C (0x000538) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x029D (0x00053A) 0x290E- f:00024 d: 270 | OR[270] = A
0x029E (0x00053C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x029F (0x00053E) 0x290F- f:00024 d: 271 | OR[271] = A
0x02A0 (0x000540) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x02A1 (0x000542) 0x2910- f:00024 d: 272 | OR[272] = A
0x02A2 (0x000544) 0x702C- f:00070 d: 44 | P = P + 44 (0x02CE)
0x02A3 (0x000546) 0x210E- f:00020 d: 270 | A = OR[270]
0x02A4 (0x000548) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x02A5 (0x00054A) 0x2513- f:00022 d: 275 | A = A + OR[275]
0x02A6 (0x00054C) 0x290D- f:00024 d: 269 | OR[269] = A
0x02A7 (0x00054E) 0x310D- f:00030 d: 269 | A = (OR[269])
0x02A8 (0x000550) 0x290D- f:00024 d: 269 | OR[269] = A
0x02A9 (0x000552) 0x210E- f:00020 d: 270 | A = OR[270]
0x02AA (0x000554) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x02AB (0x000556) 0x2908- f:00024 d: 264 | OR[264] = A
0x02AC (0x000558) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02AD (0x00055A) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x02AE (0x00055C) 0x8604- f:00103 d: 4 | P = P + 4 (0x02B2), A # 0
0x02AF (0x00055E) 0x210D- f:00020 d: 269 | A = OR[269]
0x02B0 (0x000560) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x02B1 (0x000562) 0x290D- f:00024 d: 269 | OR[269] = A
0x02B2 (0x000564) 0x210D- f:00020 d: 269 | A = OR[269]
0x02B3 (0x000566) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x02B4 (0x000568) 0x2911- f:00024 d: 273 | OR[273] = A
0x02B5 (0x00056A) 0x210F- f:00020 d: 271 | A = OR[271]
0x02B6 (0x00056C) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x02B7 (0x00056E) 0x2514- f:00022 d: 276 | A = A + OR[276]
0x02B8 (0x000570) 0x290D- f:00024 d: 269 | OR[269] = A
0x02B9 (0x000572) 0x310D- f:00030 d: 269 | A = (OR[269])
0x02BA (0x000574) 0x290D- f:00024 d: 269 | OR[269] = A
0x02BB (0x000576) 0x210F- f:00020 d: 271 | A = OR[271]
0x02BC (0x000578) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x02BD (0x00057A) 0x2908- f:00024 d: 264 | OR[264] = A
0x02BE (0x00057C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02BF (0x00057E) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x02C0 (0x000580) 0x8604- f:00103 d: 4 | P = P + 4 (0x02C4), A # 0
0x02C1 (0x000582) 0x210D- f:00020 d: 269 | A = OR[269]
0x02C2 (0x000584) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x02C3 (0x000586) 0x290D- f:00024 d: 269 | OR[269] = A
0x02C4 (0x000588) 0x210D- f:00020 d: 269 | A = OR[269]
0x02C5 (0x00058A) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x02C6 (0x00058C) 0x2912- f:00024 d: 274 | OR[274] = A
0x02C7 (0x00058E) 0x2111- f:00020 d: 273 | A = OR[273]
0x02C8 (0x000590) 0x2712- f:00023 d: 274 | A = A - OR[274]
0x02C9 (0x000592) 0x8402- f:00102 d: 2 | P = P + 2 (0x02CB), A = 0
0x02CA (0x000594) 0x7007- f:00070 d: 7 | P = P + 7 (0x02D1)
0x02CB (0x000596) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x02CC (0x000598) 0x2D0F- f:00026 d: 271 | OR[271] = OR[271] + 1
0x02CD (0x00059A) 0x2F10- f:00027 d: 272 | OR[272] = OR[272] - 1
0x02CE (0x00059C) 0x2110- f:00020 d: 272 | A = OR[272]
0x02CF (0x00059E) 0x8E2C- f:00107 d: 44 | P = P - 44 (0x02A3), A # 0
0x02D0 (0x0005A0) 0x7009- f:00070 d: 9 | P = P + 9 (0x02D9)
0x02D1 (0x0005A2) 0x1005- f:00010 d: 5 | A = 5 (0x0005)
0x02D2 (0x0005A4) 0x2B14- f:00025 d: 276 | OR[276] = A + OR[276]
0x02D3 (0x0005A6) 0x7239- f:00071 d: 57 | P = P - 57 (0x029A)
0x02D4 (0x0005A8) 0x1800-0x0134 f:00014 d: 0 | A = 308 (0x0134)
0x02D6 (0x0005AC) 0x291E- f:00024 d: 286 | OR[286] = A
0x02D7 (0x0005AE) 0x7A03-0x008D f:00075 d: 3 | P = OR[3]+141 (0x008D)
0x02D9 (0x0005B2) 0x1004- f:00010 d: 4 | A = 4 (0x0004)
0x02DA (0x0005B4) 0x2B14- f:00025 d: 276 | OR[276] = A + OR[276]
0x02DB (0x0005B6) 0x3114- f:00030 d: 276 | A = (OR[276])
0x02DC (0x0005B8) 0x2913- f:00024 d: 275 | OR[275] = A
0x02DD (0x0005BA) 0x102B- f:00010 d: 43 | A = 43 (0x002B)
0x02DE (0x0005BC) 0x2934- f:00024 d: 308 | OR[308] = A
0x02DF (0x0005BE) 0x2113- f:00020 d: 275 | A = OR[275]
0x02E0 (0x0005C0) 0x2935- f:00024 d: 309 | OR[309] = A
0x02E1 (0x0005C2) 0x112C- f:00010 d: 300 | A = 300 (0x012C)
0x02E2 (0x0005C4) 0x2936- f:00024 d: 310 | OR[310] = A
0x02E3 (0x0005C6) 0x112D- f:00010 d: 301 | A = 301 (0x012D)
0x02E4 (0x0005C8) 0x2937- f:00024 d: 311 | OR[311] = A
0x02E5 (0x0005CA) 0x1125- f:00010 d: 293 | A = 293 (0x0125)
0x02E6 (0x0005CC) 0x2938- f:00024 d: 312 | OR[312] = A
0x02E7 (0x0005CE) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x02E8 (0x0005D0) 0x5800- f:00054 d: 0 | B = A
0x02E9 (0x0005D2) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02EA (0x0005D4) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02EB (0x0005D6) 0xB634- f:00133 d: 52 | R = OR[52], A # 0
0x02EC (0x0005D8) 0x0000- f:00000 d: 0 | PASS
0x02ED (0x0005DA) 0x1018- f:00010 d: 24 | A = 24 (0x0018)
0x02EE (0x0005DC) 0x2934- f:00024 d: 308 | OR[308] = A
0x02EF (0x0005DE) 0x2125- f:00020 d: 293 | A = OR[293]
0x02F0 (0x0005E0) 0x0A02- f:00005 d: 2 | A = A < 2 (0x0002)
0x02F1 (0x0005E2) 0x2935- f:00024 d: 309 | OR[309] = A
0x02F2 (0x0005E4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02F3 (0x0005E6) 0x2936- f:00024 d: 310 | OR[310] = A
0x02F4 (0x0005E8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02F5 (0x0005EA) 0x2937- f:00024 d: 311 | OR[311] = A
0x02F6 (0x0005EC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02F7 (0x0005EE) 0x2938- f:00024 d: 312 | OR[312] = A
0x02F8 (0x0005F0) 0x1127- f:00010 d: 295 | A = 295 (0x0127)
0x02F9 (0x0005F2) 0x2939- f:00024 d: 313 | OR[313] = A
0x02FA (0x0005F4) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x02FB (0x0005F6) 0x5800- f:00054 d: 0 | B = A
0x02FC (0x0005F8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02FD (0x0005FA) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02FE (0x0005FC) 0x8602- f:00103 d: 2 | P = P + 2 (0x0300), A # 0
0x02FF (0x0005FE) 0x700B- f:00070 d: 11 | P = P + 11 (0x030A)
0x0300 (0x000600) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x0301 (0x000602) 0x2934- f:00024 d: 308 | OR[308] = A
0x0302 (0x000604) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0303 (0x000606) 0x2935- f:00024 d: 309 | OR[309] = A
0x0304 (0x000608) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0305 (0x00060A) 0x5800- f:00054 d: 0 | B = A
0x0306 (0x00060C) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0308 (0x000610) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0309 (0x000612) 0x721C- f:00071 d: 28 | P = P - 28 (0x02ED)
0x030A (0x000614) 0x1026- f:00010 d: 38 | A = 38 (0x0026)
0x030B (0x000616) 0x2934- f:00024 d: 308 | OR[308] = A
0x030C (0x000618) 0x212C- f:00020 d: 300 | A = OR[300]
0x030D (0x00061A) 0x2935- f:00024 d: 309 | OR[309] = A
0x030E (0x00061C) 0x212D- f:00020 d: 301 | A = OR[301]
0x030F (0x00061E) 0x2936- f:00024 d: 310 | OR[310] = A
0x0310 (0x000620) 0x2127- f:00020 d: 295 | A = OR[295]
0x0311 (0x000622) 0x2937- f:00024 d: 311 | OR[311] = A
0x0312 (0x000624) 0x2125- f:00020 d: 293 | A = OR[293]
0x0313 (0x000626) 0x2938- f:00024 d: 312 | OR[312] = A
0x0314 (0x000628) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0315 (0x00062A) 0x2939- f:00024 d: 313 | OR[313] = A
0x0316 (0x00062C) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0317 (0x00062E) 0x5800- f:00054 d: 0 | B = A
0x0318 (0x000630) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0319 (0x000632) 0x7C09- f:00076 d: 9 | R = OR[9]
0x031A (0x000634) 0x0200- f:00001 d: 0 | EXIT
0x031B (0x000636) 0x1018- f:00010 d: 24 | A = 24 (0x0018)
0x031C (0x000638) 0x2934- f:00024 d: 308 | OR[308] = A
0x031D (0x00063A) 0x1042- f:00010 d: 66 | A = 66 (0x0042)
0x031E (0x00063C) 0x2935- f:00024 d: 309 | OR[309] = A
0x031F (0x00063E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0320 (0x000640) 0x2936- f:00024 d: 310 | OR[310] = A
0x0321 (0x000642) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0322 (0x000644) 0x2937- f:00024 d: 311 | OR[311] = A
0x0323 (0x000646) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0324 (0x000648) 0x2938- f:00024 d: 312 | OR[312] = A
0x0325 (0x00064A) 0x1128- f:00010 d: 296 | A = 296 (0x0128)
0x0326 (0x00064C) 0x2939- f:00024 d: 313 | OR[313] = A
0x0327 (0x00064E) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0328 (0x000650) 0x5800- f:00054 d: 0 | B = A
0x0329 (0x000652) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x032A (0x000654) 0x7C09- f:00076 d: 9 | R = OR[9]
0x032B (0x000656) 0x8602- f:00103 d: 2 | P = P + 2 (0x032D), A # 0
0x032C (0x000658) 0x700B- f:00070 d: 11 | P = P + 11 (0x0337)
0x032D (0x00065A) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x032E (0x00065C) 0x2934- f:00024 d: 308 | OR[308] = A
0x032F (0x00065E) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0330 (0x000660) 0x2935- f:00024 d: 309 | OR[309] = A
0x0331 (0x000662) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0332 (0x000664) 0x5800- f:00054 d: 0 | B = A
0x0333 (0x000666) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0335 (0x00066A) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0336 (0x00066C) 0x721B- f:00071 d: 27 | P = P - 27 (0x031B)
0x0337 (0x00066E) 0x2127- f:00020 d: 295 | A = OR[295]
0x0338 (0x000670) 0x1408- f:00012 d: 8 | A = A + 8 (0x0008)
0x0339 (0x000672) 0x2908- f:00024 d: 264 | OR[264] = A
0x033A (0x000674) 0x3108- f:00030 d: 264 | A = (OR[264])
0x033B (0x000676) 0x2913- f:00024 d: 275 | OR[275] = A
0x033C (0x000678) 0x2127- f:00020 d: 295 | A = OR[295]
0x033D (0x00067A) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x033E (0x00067C) 0x2908- f:00024 d: 264 | OR[264] = A
0x033F (0x00067E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0340 (0x000680) 0x292E- f:00024 d: 302 | OR[302] = A
0x0341 (0x000682) 0x2113- f:00020 d: 275 | A = OR[275]
0x0342 (0x000684) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x0343 (0x000686) 0x0803- f:00004 d: 3 | A = A > 3 (0x0003)
0x0344 (0x000688) 0x292F- f:00024 d: 303 | OR[303] = A
0x0345 (0x00068A) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0346 (0x00068C) 0x2934- f:00024 d: 308 | OR[308] = A
0x0347 (0x00068E) 0x1800-0x0030 f:00014 d: 0 | A = 48 (0x0030)
0x0349 (0x000692) 0x2935- f:00024 d: 309 | OR[309] = A
0x034A (0x000694) 0x212F- f:00020 d: 303 | A = OR[303]
0x034B (0x000696) 0x2936- f:00024 d: 310 | OR[310] = A
0x034C (0x000698) 0x212E- f:00020 d: 302 | A = OR[302]
0x034D (0x00069A) 0x2937- f:00024 d: 311 | OR[311] = A
0x034E (0x00069C) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x034F (0x00069E) 0x2938- f:00024 d: 312 | OR[312] = A
0x0350 (0x0006A0) 0x101F- f:00010 d: 31 | A = 31 (0x001F)
0x0351 (0x0006A2) 0x2939- f:00024 d: 313 | OR[313] = A
0x0352 (0x0006A4) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0353 (0x0006A6) 0x5800- f:00054 d: 0 | B = A
0x0354 (0x0006A8) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x0356 (0x0006AC) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0357 (0x0006AE) 0x11FF- f:00010 d: 511 | A = 511 (0x01FF)
0x0358 (0x0006B0) 0x2B2B- f:00025 d: 299 | OR[299] = A + OR[299]
0x0359 (0x0006B2) 0x8002- f:00100 d: 2 | P = P + 2 (0x035B), C = 0
0x035A (0x0006B4) 0x2D2A- f:00026 d: 298 | OR[298] = OR[298] + 1
0x035B (0x0006B6) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x035C (0x0006B8) 0x1609- f:00013 d: 9 | A = A - 9 (0x0009)
0x035D (0x0006BA) 0x5800- f:00054 d: 0 | B = A
0x035E (0x0006BC) 0x212A- f:00020 d: 298 | A = OR[298]
0x035F (0x0006BE) 0x4A00- f:00045 d: 0 | A = A < B
0x0360 (0x0006C0) 0x290D- f:00024 d: 269 | OR[269] = A
0x0361 (0x0006C2) 0x1009- f:00010 d: 9 | A = 9 (0x0009)
0x0362 (0x0006C4) 0x5800- f:00054 d: 0 | B = A
0x0363 (0x0006C6) 0x212A- f:00020 d: 298 | A = OR[298]
0x0364 (0x0006C8) 0x4800- f:00044 d: 0 | A = A > B
0x0365 (0x0006CA) 0x292A- f:00024 d: 298 | OR[298] = A
0x0366 (0x0006CC) 0x212B- f:00020 d: 299 | A = OR[299]
0x0367 (0x0006CE) 0x4800- f:00044 d: 0 | A = A > B
0x0368 (0x0006D0) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0369 (0x0006D2) 0x292B- f:00024 d: 299 | OR[299] = A
0x036A (0x0006D4) 0x212B- f:00020 d: 299 | A = OR[299]
0x036B (0x0006D6) 0x2731- f:00023 d: 305 | A = A - OR[305]
0x036C (0x0006D8) 0x8433- f:00102 d: 51 | P = P + 51 (0x039F), A = 0
0x036D (0x0006DA) 0x101D- f:00010 d: 29 | A = 29 (0x001D)
0x036E (0x0006DC) 0x2934- f:00024 d: 308 | OR[308] = A
0x036F (0x0006DE) 0x212B- f:00020 d: 299 | A = OR[299]
0x0370 (0x0006E0) 0x2935- f:00024 d: 309 | OR[309] = A
0x0371 (0x0006E2) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0372 (0x0006E4) 0x5800- f:00054 d: 0 | B = A
0x0373 (0x0006E6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0374 (0x0006E8) 0x7C09- f:00076 d: 9 | R = OR[9]
0x0375 (0x0006EA) 0x2006- f:00020 d: 6 | A = OR[6]
0x0376 (0x0006EC) 0x140C- f:00012 d: 12 | A = A + 12 (0x000C)
0x0377 (0x0006EE) 0x2908- f:00024 d: 264 | OR[264] = A
0x0378 (0x0006F0) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0379 (0x0006F2) 0x2932- f:00024 d: 306 | OR[306] = A
0x037A (0x0006F4) 0x2006- f:00020 d: 6 | A = OR[6]
0x037B (0x0006F6) 0x140D- f:00012 d: 13 | A = A + 13 (0x000D)
0x037C (0x0006F8) 0x2908- f:00024 d: 264 | OR[264] = A
0x037D (0x0006FA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x037E (0x0006FC) 0x2933- f:00024 d: 307 | OR[307] = A
0x037F (0x0006FE) 0x2006- f:00020 d: 6 | A = OR[6]
0x0380 (0x000700) 0x140E- f:00012 d: 14 | A = A + 14 (0x000E)
0x0381 (0x000702) 0x2908- f:00024 d: 264 | OR[264] = A
0x0382 (0x000704) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0383 (0x000706) 0x2931- f:00024 d: 305 | OR[305] = A
0x0384 (0x000708) 0x2006- f:00020 d: 6 | A = OR[6]
0x0385 (0x00070A) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x0386 (0x00070C) 0x2908- f:00024 d: 264 | OR[264] = A
0x0387 (0x00070E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0388 (0x000710) 0x8605- f:00103 d: 5 | P = P + 5 (0x038D), A # 0
0x0389 (0x000712) 0x212B- f:00020 d: 299 | A = OR[299]
0x038A (0x000714) 0x2731- f:00023 d: 305 | A = A - OR[305]
0x038B (0x000716) 0x8602- f:00103 d: 2 | P = P + 2 (0x038D), A # 0
0x038C (0x000718) 0x7012- f:00070 d: 18 | P = P + 18 (0x039E)
0x038D (0x00071A) 0x2131- f:00020 d: 305 | A = OR[305]
0x038E (0x00071C) 0x8602- f:00103 d: 2 | P = P + 2 (0x0390), A # 0
0x038F (0x00071E) 0x700F- f:00070 d: 15 | P = P + 15 (0x039E)
0x0390 (0x000720) 0x101E- f:00010 d: 30 | A = 30 (0x001E)
0x0391 (0x000722) 0x2934- f:00024 d: 308 | OR[308] = A
0x0392 (0x000724) 0x2132- f:00020 d: 306 | A = OR[306]
0x0393 (0x000726) 0x2935- f:00024 d: 309 | OR[309] = A
0x0394 (0x000728) 0x2133- f:00020 d: 307 | A = OR[307]
0x0395 (0x00072A) 0x2936- f:00024 d: 310 | OR[310] = A
0x0396 (0x00072C) 0x2131- f:00020 d: 305 | A = OR[305]
0x0397 (0x00072E) 0x2937- f:00024 d: 311 | OR[311] = A
0x0398 (0x000730) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x0399 (0x000732) 0x5800- f:00054 d: 0 | B = A
0x039A (0x000734) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x039B (0x000736) 0x7C09- f:00076 d: 9 | R = OR[9]
0x039C (0x000738) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x039D (0x00073A) 0x2931- f:00024 d: 305 | OR[305] = A
0x039E (0x00073C) 0x7234- f:00071 d: 52 | P = P - 52 (0x036A)
0x039F (0x00073E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x03A0 (0x000740) 0x2930- f:00024 d: 304 | OR[304] = A
0x03A1 (0x000742) 0x2132- f:00020 d: 306 | A = OR[306]
0x03A2 (0x000744) 0x292C- f:00024 d: 300 | OR[300] = A
0x03A3 (0x000746) 0x2133- f:00020 d: 307 | A = OR[307]
0x03A4 (0x000748) 0x292D- f:00024 d: 301 | OR[301] = A
0x03A5 (0x00074A) 0x0200- f:00001 d: 0 | EXIT
0x03A6 (0x00074C) 0x1027- f:00010 d: 39 | A = 39 (0x0027)
0x03A7 (0x00074E) 0x2934- f:00024 d: 308 | OR[308] = A
0x03A8 (0x000750) 0x212C- f:00020 d: 300 | A = OR[300]
0x03A9 (0x000752) 0x2935- f:00024 d: 309 | OR[309] = A
0x03AA (0x000754) 0x212D- f:00020 d: 301 | A = OR[301]
0x03AB (0x000756) 0x2936- f:00024 d: 310 | OR[310] = A
0x03AC (0x000758) 0x2128- f:00020 d: 296 | A = OR[296]
0x03AD (0x00075A) 0x2937- f:00024 d: 311 | OR[311] = A
0x03AE (0x00075C) 0x212F- f:00020 d: 303 | A = OR[303]
0x03AF (0x00075E) 0x2938- f:00024 d: 312 | OR[312] = A
0x03B0 (0x000760) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x03B1 (0x000762) 0x2939- f:00024 d: 313 | OR[313] = A
0x03B2 (0x000764) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x03B3 (0x000766) 0x5800- f:00054 d: 0 | B = A
0x03B4 (0x000768) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x03B5 (0x00076A) 0x7C09- f:00076 d: 9 | R = OR[9]
0x03B6 (0x00076C) 0x212D- f:00020 d: 301 | A = OR[301]
0x03B7 (0x00076E) 0x252F- f:00022 d: 303 | A = A + OR[303]
0x03B8 (0x000770) 0x292D- f:00024 d: 301 | OR[301] = A
0x03B9 (0x000772) 0x8002- f:00100 d: 2 | P = P + 2 (0x03BB), C = 0
0x03BA (0x000774) 0x2D2C- f:00026 d: 300 | OR[300] = OR[300] + 1
0x03BB (0x000776) 0x2D30- f:00026 d: 304 | OR[304] = OR[304] + 1
0x03BC (0x000778) 0x2130- f:00020 d: 304 | A = OR[304]
0x03BD (0x00077A) 0x272E- f:00023 d: 302 | A = A - OR[302]
0x03BE (0x00077C) 0x8402- f:00102 d: 2 | P = P + 2 (0x03C0), A = 0
0x03BF (0x00077E) 0x701B- f:00070 d: 27 | P = P + 27 (0x03DA)
0x03C0 (0x000780) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x03C1 (0x000782) 0x2934- f:00024 d: 308 | OR[308] = A
0x03C2 (0x000784) 0x1800-0x017D f:00014 d: 0 | A = 381 (0x017D)
0x03C4 (0x000788) 0x2935- f:00024 d: 309 | OR[309] = A
0x03C5 (0x00078A) 0x211C- f:00020 d: 284 | A = OR[284]
0x03C6 (0x00078C) 0x2936- f:00024 d: 310 | OR[310] = A
0x03C7 (0x00078E) 0x2127- f:00020 d: 295 | A = OR[295]
0x03C8 (0x000790) 0x2937- f:00024 d: 311 | OR[311] = A
0x03C9 (0x000792) 0x2132- f:00020 d: 306 | A = OR[306]
0x03CA (0x000794) 0x2938- f:00024 d: 312 | OR[312] = A
0x03CB (0x000796) 0x2133- f:00020 d: 307 | A = OR[307]
0x03CC (0x000798) 0x2939- f:00024 d: 313 | OR[313] = A
0x03CD (0x00079A) 0x1134- f:00010 d: 308 | A = 308 (0x0134)
0x03CE (0x00079C) 0x5800- f:00054 d: 0 | B = A
0x03CF (0x00079E) 0x1800-0x3918 f:00014 d: 0 | A = 14616 (0x3918)
0x03D1 (0x0007A2) 0x7C09- f:00076 d: 9 | R = OR[9]
0x03D2 (0x0007A4) 0x2919- f:00024 d: 281 | OR[281] = A
0x03D3 (0x0007A6) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x03D4 (0x0007A8) 0x2930- f:00024 d: 304 | OR[304] = A
0x03D5 (0x0007AA) 0x2132- f:00020 d: 306 | A = OR[306]
0x03D6 (0x0007AC) 0x292C- f:00024 d: 300 | OR[300] = A
0x03D7 (0x0007AE) 0x2133- f:00020 d: 307 | A = OR[307]
0x03D8 (0x0007B0) 0x292D- f:00024 d: 301 | OR[301] = A
0x03D9 (0x0007B2) 0x7003- f:00070 d: 3 | P = P + 3 (0x03DC)
0x03DA (0x0007B4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x03DB (0x0007B6) 0x2919- f:00024 d: 281 | OR[281] = A
0x03DC (0x0007B8) 0x0200- f:00001 d: 0 | EXIT
0x03DD (0x0007BA) 0x4638- f:00043 d: 56 | C = 1, IOB = BZ | **** non-standard encoding with D:0x0038 ****
0x03DE (0x0007BC) 0x3000- f:00030 d: 0 | A = (OR[0])
0x03DF (0x0007BE) 0x0000- f:00000 d: 0 | PASS
0x03E0 (0x0007C0) 0x0000- f:00000 d: 0 | PASS
0x03E1 (0x0007C2) 0x0138- f:00000 d: 312 | PASS | **** non-standard encoding with D:0x0138 ****
0x03E2 (0x0007C4) 0x4631- f:00043 d: 49 | C = 1, IOB = BZ | **** non-standard encoding with D:0x0031 ****
0x03E3 (0x0007C6) 0x3332- f:00031 d: 306 | A = A & (OR[306])
0x03E4 (0x0007C8) 0x0000- f:00000 d: 0 | PASS
0x03E5 (0x0007CA) 0x0000- f:00000 d: 0 | PASS
0x03E6 (0x0007CC) 0x0139- f:00000 d: 313 | PASS | **** non-standard encoding with D:0x0139 ****
0x03E7 (0x0007CE) 0x0000- f:00000 d: 0 | PASS
0x03E8 (0x0007D0) 0x0000- f:00000 d: 0 | PASS
0x03E9 (0x0007D2) 0x0000- f:00000 d: 0 | PASS
0x03EA (0x0007D4) 0x0000- f:00000 d: 0 | PASS
0x03EB (0x0007D6) 0x0000- f:00000 d: 0 | PASS
|
Transynther/x86/_processed/NONE/_ht_st_zr_un_/i7-8650U_0xd2.log_7342_1584.asm
|
ljhsiun2/medusa
| 9 |
82008
|
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r13
push %r8
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x1ba6f, %r10
clflush (%r10)
nop
nop
nop
cmp %r8, %r8
mov $0x6162636465666768, %rdx
movq %rdx, (%r10)
nop
nop
nop
nop
cmp $20040, %r13
lea addresses_UC_ht+0x1b4d3, %rdx
nop
nop
nop
nop
and $59937, %r11
mov $0x6162636465666768, %r13
movq %r13, %xmm2
vmovups %ymm2, (%rdx)
cmp $37219, %r10
lea addresses_D_ht+0x1c377, %rsi
lea addresses_A_ht+0x1c837, %rdi
clflush (%rsi)
nop
nop
sub %r10, %r10
mov $88, %rcx
rep movsq
nop
nop
nop
nop
nop
cmp $55761, %rsi
lea addresses_D_ht+0xfbf7, %rsi
lea addresses_UC_ht+0xa8d7, %rdi
clflush (%rdi)
nop
nop
nop
and %rdx, %rdx
mov $77, %rcx
rep movsb
nop
nop
nop
nop
sub %rdx, %rdx
lea addresses_UC_ht+0x15a37, %rsi
lea addresses_D_ht+0x157f7, %rdi
nop
nop
cmp %r11, %r11
mov $33, %rcx
rep movsq
nop
nop
nop
nop
and %r8, %r8
lea addresses_WT_ht+0xb637, %rsi
lea addresses_D_ht+0x8f37, %rdi
xor %r11, %r11
mov $60, %rcx
rep movsl
nop
nop
nop
nop
cmp %r13, %r13
lea addresses_A_ht+0x1e1f7, %rdi
nop
xor $25453, %rdx
movl $0x61626364, (%rdi)
nop
nop
nop
sub $40933, %r10
lea addresses_WC_ht+0x183cf, %rsi
lea addresses_WC_ht+0x337, %rdi
nop
add $4117, %r11
mov $45, %rcx
rep movsw
nop
nop
nop
nop
xor %rdx, %rdx
lea addresses_D_ht+0xb417, %rsi
lea addresses_D_ht+0x3337, %rdi
nop
nop
sub $43457, %r8
mov $51, %rcx
rep movsb
nop
nop
nop
nop
nop
and %rsi, %rsi
lea addresses_WT_ht+0xcb37, %rsi
lea addresses_UC_ht+0x19d7, %rdi
clflush (%rsi)
sub %r11, %r11
mov $4, %rcx
rep movsb
nop
nop
nop
cmp %rdx, %rdx
lea addresses_WC_ht+0x26cf, %rsi
lea addresses_normal_ht+0x10477, %rdi
clflush (%rdi)
nop
nop
nop
cmp %rdx, %rdx
mov $127, %rcx
rep movsq
nop
nop
nop
nop
nop
cmp $2558, %rsi
lea addresses_A_ht+0x15f21, %rdi
xor $57272, %r11
vmovups (%rdi), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $1, %xmm6, %r8
nop
nop
nop
nop
nop
cmp %rdi, %rdi
lea addresses_WC_ht+0x737, %r10
nop
nop
inc %r13
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
and $0xffffffffffffffc0, %r10
movntdq %xmm5, (%r10)
nop
nop
nop
add $58632, %r11
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r8
pop %r13
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r15
push %r8
push %r9
push %rcx
push %rdi
// Faulty Load
lea addresses_WC+0xb37, %r9
sub $16158, %r11
vmovups (%r9), %ymm3
vextracti128 $0, %ymm3, %xmm3
vpextrq $0, %xmm3, %rcx
lea oracles, %r9
and $0xff, %rcx
shlq $12, %rcx
mov (%r9,%rcx,1), %rcx
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_WC', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False, 'NT': True, 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 6, 'same': True}, 'dst': {'type': 'addresses_A_ht', 'congruent': 8, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 6, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 8, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 5, 'same': True}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_D_ht', 'congruent': 4, 'same': True}, 'dst': {'type': 'addresses_D_ht', 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}, 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': False}}
{'00': 5345, '46': 236, 'ff': 1315, '47': 200, '48': 189, '49': 21, '02': 13, '52': 13, '04': 5, '45': 2, 'c0': 1, '80': 1, '24': 1}
00 46 ff 00 ff 00 00 00 ff 00 46 00 00 00 ff 47 00 00 00 00 00 00 00 00 ff 00 00 00 00 48 00 00 ff 00 00 00 00 00 00 00 46 00 ff 46 ff ff ff 00 ff 00 00 00 00 00 46 ff ff ff 00 47 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 ff ff 00 00 00 00 00 00 00 00 ff 00 ff 00 00 00 ff 00 47 00 46 ff ff 00 00 00 ff 00 00 00 ff 00 00 46 00 ff 00 47 00 ff 00 ff ff 46 00 00 47 00 00 00 ff 00 00 00 00 ff ff 00 49 00 00 00 00 00 00 00 00 00 00 ff 00 ff ff 00 ff ff ff 00 00 00 ff 00 00 00 00 00 46 00 00 48 00 47 00 00 00 00 00 00 00 00 ff 00 00 00 00 ff ff ff ff 00 46 00 ff 00 ff 46 48 00 00 00 00 00 02 ff 00 00 ff 00 00 00 00 ff ff 00 00 00 00 00 00 00 00 00 ff 48 00 00 00 00 00 ff 00 00 00 ff 00 ff ff 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 ff 00 00 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 ff 00 ff ff 00 00 ff 00 00 47 ff 46 ff ff 48 00 00 00 00 00 00 00 ff ff 00 00 00 00 ff 48 00 00 00 48 00 00 00 00 00 00 00 00 00 00 00 00 00 00 02 ff 46 00 00 48 00 00 00 00 00 00 00 00 00 ff 48 00 00 ff ff 48 00 00 ff 00 00 00 00 46 ff 00 46 00 00 ff 00 00 00 00 00 00 00 00 ff 00 ff ff 00 00 00 48 00 00 00 00 00 00 00 ff ff 00 ff 00 00 00 00 00 00 00 00 00 ff ff 00 ff 47 ff 00 ff 00 00 47 48 00 00 00 48 00 46 00 00 00 ff 00 00 00 00 00 ff ff 47 00 00 00 ff ff 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 46 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 00 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 00 00 47 00 00 00 00 00 00 00 47 00 00 00 ff 00 00 46 ff ff 00 00 00 ff ff 00 00 47 00 00 00 48 ff ff 00 ff 00 00 00 ff 00 00 00 ff 00 00 48 00 00 47 00 00 00 48 ff 00 00 00 00 00 00 ff 00 00 00 ff ff 00 47 00 47 00 00 00 00 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 ff 00 ff ff ff 00 00 00 46 47 46 48 00 ff 00 00 00 ff ff 00 00 46 00 00 00 00 00 46 00 ff ff 00 00 00 47 00 47 00 00 00 ff 00 ff ff 00 00 00 00 00 00 47 ff 00 00 48 ff 00 48 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 00 ff 00 ff 00 00 00 ff 00 00 00 00 00 00 00 00 ff ff ff ff 00 00 00 00 00 00 47 ff 00 00 00 00 00 00 00 00 00 00 00 46 00 00 00 ff 00 ff ff 00 00 00 ff 00 00 00 00 00 48 00 ff ff 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 ff 00 00 00 46 00 00 00 ff 00 00 48 00 00 00 00 00 00 00 ff 00 00 46 47 00 00 47 00 00 00 00 00 00 00 00 00 00 00 ff ff 00 00 00 00 00 00 47 00 00 00 00 00 00 00 00 ff 48 00 00 00 00 ff 00 00 00 00 ff 00 00 00 00 00 00 00 46 00 00 00 00 00 ff 00 00 00 00 00 00 00 00 00 00 00 46 00 48 00 00 00 00 00 00 ff 00 00 00 00 00 00 00 00 ff 47 00 00 00 00 00 48 00 00 00 00 00 ff 00 00 00 ff ff ff 00 00 00 00 ff 00 00 00 00 ff 48 00 ff 49 00 00 00 00 00 00 00 00 00 00 49 ff 00 00 00 00 00 46 00 00 00 00 00 00 47 00 00 00 00 00 00 00 00 00 00 00 00 46 00 47 00 00 00 47 00 47 ff 00 00 00 00 00 00 00 00 00 00 00 00 00 48 00 00 00 00 00 ff 00 ff 00 00 00 00 ff 46 00 00 00 00 00 00 00 00 00 00 00 00 00 49 00 00 ff 48 ff 46 00 00 00 00 00 00 48 00 00 00 00 00 00 48 00 ff ff 00 ff 00 ff 00 00
*/
|
oeis/173/A173102.asm
|
neoneye/loda-programs
| 11 |
80809
|
<gh_stars>10-100
; A173102: Number of partitions x + y = z with {x,y,z} in {1,2,3,..,3n} and z > y >= x.
; 2,9,20,36,56,81,110,144,182,225,272,324,380,441,506,576,650,729,812,900,992,1089,1190,1296,1406,1521,1640,1764,1892,2025,2162,2304,2450,2601,2756,2916,3080,3249,3422,3600,3782,3969,4160,4356,4556,4761,4970,5184,5402,5625,5852,6084,6320,6561,6806,7056,7310,7569,7832,8100,8372,8649,8930,9216,9506,9801,10100,10404,10712,11025,11342,11664,11990,12321,12656,12996,13340,13689,14042,14400,14762,15129,15500,15876,16256,16641,17030,17424,17822,18225,18632,19044,19460,19881,20306,20736,21170,21609,22052
add $0,1
mul $0,3
pow $0,2
div $0,4
|
src/main/antlr/org/antlr/jetbrains/sample/parser/SampleLanguage.g4
|
educationwarehouse/jetbrains-plugin-sample
| 0 |
117
|
/** A simple language for use with this sample plugin.
* It's C-like but without semicolons. Symbol resolution semantics are
* C-like: resolve symbol in current scope. If not in this scope, ask
* enclosing scope to resolve (recurse up tree until no more scopes or found).
* Forward refs allowed for functions but not variables. Globals must
* appear first syntactically.
*
* Generate the parser via "mvn compile" from root dir of project.
*/
grammar SampleLanguage;
/** The start rule must be whatever you would normally use, such as script
* or compilationUnit, etc...
*/
script
: (function|define_behavior|statement|install_behavior)* EOF
;
function
: 'def' ID '(' formal_args? ')' block
;
define_behavior
: 'behavior' CAMELID paren_args? block ;
install_behavior
: 'install' CAMELID paren_kwargs? ;
// argument list
formal_args : formal_arg (',' formal_arg)* ;
kwargs: kwarg (',' kwarg)* ;
// parenthesized arguments:
paren_args : '(' formal_args? ')' ;
paren_kwargs : '(' kwargs ')' ;
// non-typed arguments:
formal_arg : ID ;
kwarg : ID ':' expr ;
block
: BLOCK_START? statement* BLOCK_END;
statement
: 'if' '('? expr ')'? statement ('else' statement)? # If
| 'while' '(' expr ')' statement # While
| var_def # Assign
| ID '[' expr ']' TO expr # ElementAssign
| call_expr # CallStatement
| 'print' '(' expr? ')' # Print
| 'log' expr # Log
| 'return' expr # Return
| BLOCK_END # NestedBlockEnd
;
var_def : SET ID TO expr ;
expr
: expr operator expr # Op
| '-' expr # Negate
| '!' expr # Not
| call_expr # Call
| ID '[' expr ']' # Index
| LPAREN expr RPAREN # Parens
| primary # Atom
;
operator : MUL|DIV|ADD|SUB|GT|GE|LT|LE|EQUAL_EQUAL|NOT_EQUAL|OR|AND|DOT ; // no implicit precedence
call_expr
: ID LPAREN expr_list? RPAREN ;
expr_list : expr (',' expr)* ;
dictpair : expr BLOCK_START expr ;
expr_dict : dictpair (',' dictpair)* ;
primary
: ID # Identifier
| INT # Integer
| FLOAT # Float
| STRING # String
| array # ArrayItem
| dict # DictItem
| 'true' # TrueLiteral
| 'false' # FalseLiteral
;
array : '[' expr_list ']' ;
dict : '{' expr_dict '}' ;
// custom (custom rules also at the end?):
LPAREN : '(' ;
RPAREN : ')' ;
COLON : 'COLON' ;
COMMA : ',' ;
LBRACK : '[' ;
RBRACK : ']' ;
BLOCK_START : ':' ;
BLOCK_END : 'end' ;
IF : 'if' ;
ELSE : 'else' ;
WHILE : 'while' ;
SET : 'set' ; // Var_defContext
TO : 'to' ;
RETURN : 'return' ;
DEF : 'def' ; // FunctionContext
BEHAVIOR : 'behavior' ; // FunctionContext
PRINT : 'print' ;
LOG : 'log' ;
TYPEINT : 'int' ;
TYPEFLOAT : 'float' ;
TYPESTRING : 'string' ;
TYPEBOOLEAN : 'boolean' ;
TRUE : 'true' ;
FALSE : 'false' ;
SUB : '-' ;
BANG : '!' ;
MUL : '*' ;
DIV : '/' ;
ADD : '+' ;
LT : '<' ;
LE : '<=' ;
EQUAL_EQUAL : '==' ;
NOT_EQUAL : '!=' ;
GT : '>' ;
GE : '>=' ;
OR : '||' ;
AND : '&&' ;
DOT : ' . ' ;
COMMENT : '---' .*? '---' -> channel(HIDDEN) ;
LINE_COMMENT : '--' .*? ('\n'|EOF) -> channel(HIDDEN) ;
ID : [a-z] [a-zA-Z0-9_]* ;
CAMELID : [A-Z] [a-zA-Z0-9_]* ;
INT : [0-9]+ ;
FLOAT
: '-'? INT '.' INT EXP? // 1.35, 1.35E-9, 0.3, -4.5
| '-'? INT EXP // 1e10 -3e4
;
fragment EXP : [Ee] [+\-]? INT ;
STRING : (STRING_BASIC|STRING_ALT|STRING_INTERPOL) ;
fragment STRING_BASIC : '"' STRING_CONTENT '"' ; // "string"
fragment STRING_ALT : '\'' STRING_CONTENT '\'' ; // 'string'
fragment STRING_INTERPOL : '`' STRING_CONTENT '`' ; // `string`
fragment STRING_CONTENT : (ESC | ~["\\])*;
fragment ESC : '\\' ["\bfnrt] ;
WS : [ \t\n\r]+ -> channel(HIDDEN) ;
/** "catch all" rule for any char not matche in a token rule of your
* grammar. Lexers in Intellij must return all tokens good and bad.
* There must be a token to cover all characters, which makes sense, for
* an IDE. The parser however should not see these bad tokens because
* it just confuses the issue. Hence, the hidden channel.
*/
ERRCHAR
: . -> channel(HIDDEN)
;
|
gcc-gcc-7_3_0-release/gcc/ada/s-mmap.ads
|
best08618/asylo
| 7 |
19667
|
<filename>gcc-gcc-7_3_0-release/gcc/ada/s-mmap.ads
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME COMPONENTS --
-- --
-- S Y S T E M . M M A P --
-- --
-- S p e c --
-- --
-- Copyright (C) 2007-2016, AdaCore --
-- --
-- This library is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 3, or (at your option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
-- This package provides memory mapping of files. Depending on your operating
-- system, this might provide a more efficient method for accessing the
-- contents of files.
-- A description of memory-mapping is available on the sqlite page, at:
-- http://www.sqlite.org/mmap.html
--
-- The traditional method for reading a file is to allocate a buffer in the
-- application address space, then open the file and copy its contents. When
-- memory mapping is available though, the application asks the operating
-- system to return a pointer to the requested page, if possible. If the
-- requested page has been or can be mapped into the application address
-- space, the system returns a pointer to that page for the application to
-- use without having to copy anything. Skipping the copy step is what makes
-- memory mapped I/O faster.
--
-- When memory mapping is not available, this package automatically falls
-- back to the traditional copy method.
--
-- Example of use for this package, when reading a file that can be fully
-- mapped
--
-- declare
-- File : Mapped_File;
-- Str : Str_Access;
-- begin
-- File := Open_Read ("/tmp/file_on_disk");
-- Read (File); -- read the whole file
-- Str := Data (File);
-- for S in 1 .. Last (File) loop
-- Put (Str (S));
-- end loop;
-- Close (File);
-- end;
--
-- When the file is big, or you only want to access part of it at a given
-- time, you can use the following type of code.
-- declare
-- File : Mapped_File;
-- Str : Str_Access;
-- Offs : File_Size := 0;
-- Page : constant Integer := Get_Page_Size;
-- begin
-- File := Open_Read ("/tmp/file_on_disk");
-- while Offs < Length (File) loop
-- Read (File, Offs, Length => Long_Integer (Page) * 4);
-- Str := Data (File);
--
-- -- Print characters for this chunk:
-- for S in Integer (Offs - Offset (File)) + 1 .. Last (File) loop
-- Put (Str (S));
-- end loop;
--
-- -- Since we are reading multiples of Get_Page_Size, we can simplify
-- -- with
-- -- for S in 1 .. Last (File) loop ...
--
-- Offs := Offs + Long_Integer (Last (File));
-- end loop;
with Interfaces.C;
with System.Strings;
package System.Mmap is
type Mapped_File is private;
-- File to be mapped in memory.
-- This package will use the fastest possible algorithm to load the
-- file in memory. On systems that support it, the file is not really
-- loaded in memory. Instead, a call to the mmap() system call (or
-- CreateFileMapping()) will keep the file on disk, but make it
-- accessible as if it was in memory.
-- When the system does not support it, the file is actually loaded in
-- memory through calls to read(), and written back with write() when you
-- close it. This is of course much slower.
-- Legacy: each mapped file has a "default" mapped region in it.
type Mapped_Region is private;
-- A representation of part of a file in memory. Actual reading/writing
-- is done through a mapped region. After being returned by Read, a mapped
-- region must be free'd when done. If the original Mapped_File was open
-- for reading, it can be closed before the mapped region is free'd.
Invalid_Mapped_File : constant Mapped_File;
Invalid_Mapped_Region : constant Mapped_Region;
type Unconstrained_String is new String (Positive);
type Str_Access is access all Unconstrained_String;
pragma No_Strict_Aliasing (Str_Access);
type File_Size is new Interfaces.C.size_t;
function To_Str_Access
(Str : System.Strings.String_Access) return Str_Access;
-- Convert Str. The returned value points to the same memory block, but no
-- longer includes the bounds, which you need to manage yourself
function Open_Read
(Filename : String;
Use_Mmap_If_Available : Boolean := True) return Mapped_File;
-- Open a file for reading. The same file can be shared by multiple
-- processes, that will see each others's changes as they occur.
-- Any attempt to write the data might result in a segmentation fault,
-- depending on how the file is open.
-- Name_Error is raised if the file does not exist.
-- Filename should be compatible with the filesystem.
function Open_Read_No_Exception
(Filename : String;
Use_Mmap_If_Available : Boolean := True) return Mapped_File;
-- Like Open_Read but return Invalid_Mapped_File in case of error
function Open_Write
(Filename : String;
Use_Mmap_If_Available : Boolean := True) return Mapped_File;
-- Open a file for writing.
-- You cannot change the length of the file.
-- Name_Error is raised if the file does not exist
-- Filename should be compatible with the filesystem.
procedure Close (File : in out Mapped_File);
-- Close the file, and unmap the memory that is used for the region
-- contained in File. If the system does not support the unmmap() system
-- call or equivalent, or these were not available for the file itself,
-- then the file is written back to the disk if it was opened for writing.
procedure Free (Region : in out Mapped_Region);
-- Unmap the memory that is used for this region and deallocate the region
procedure Read
(File : Mapped_File;
Region : in out Mapped_Region;
Offset : File_Size := 0;
Length : File_Size := 0;
Mutable : Boolean := False);
-- Read a specific part of File and set Region to the corresponding mapped
-- region, or re-use it if possible.
-- Offset is the number of bytes since the beginning of the file at which
-- we should start reading. Length is the number of bytes that should be
-- read. If set to 0, as much of the file as possible is read (presumably
-- the whole file unless you are reading a _huge_ file).
-- Note that no (un)mapping is is done if that part of the file is already
-- available through Region.
-- If the file was opened for writing, any modification you do to the
-- data stored in File will be stored on disk (either immediately when the
-- file is opened through a mmap() system call, or when the file is closed
-- otherwise).
-- Mutable is processed only for reading files. If set to True, the
-- data can be modified, even through it will not be carried through the
-- underlying file, nor it is guaranteed to be carried through remapping.
-- This function takes care of page size alignment issues. The accessors
-- below only expose the region that has been requested by this call, even
-- if more bytes were actually mapped by this function.
-- TODO??? Enable to have a private copy for readable files
function Read
(File : Mapped_File;
Offset : File_Size := 0;
Length : File_Size := 0;
Mutable : Boolean := False) return Mapped_Region;
-- Likewise, return a new mapped region
procedure Read
(File : Mapped_File;
Offset : File_Size := 0;
Length : File_Size := 0;
Mutable : Boolean := False);
-- Likewise, use the legacy "default" region in File
function Length (File : Mapped_File) return File_Size;
-- Size of the file on the disk
function Offset (Region : Mapped_Region) return File_Size;
-- Return the offset, in the physical file on disk, corresponding to the
-- requested mapped region. The first byte in the file has offest 0.
function Offset (File : Mapped_File) return File_Size;
-- Likewise for the region contained in File
function Last (Region : Mapped_Region) return Integer;
-- Return the number of requested bytes mapped in this region. It is
-- erroneous to access Data for indices outside 1 .. Last (Region).
-- Such accesses may cause Storage_Error to be raised.
function Last (File : Mapped_File) return Integer;
-- Return the number of requested bytes mapped in the region contained in
-- File. It is erroneous to access Data for indices outside of 1 .. Last
-- (File); such accesses may cause Storage_Error to be raised.
function Data (Region : Mapped_Region) return Str_Access;
-- The data mapped in Region as requested. The result is an unconstrained
-- string, so you cannot use the usual 'First and 'Last attributes.
-- Instead, these are respectively 1 and Size.
function Data (File : Mapped_File) return Str_Access;
-- Likewise for the region contained in File
function Is_Mutable (Region : Mapped_Region) return Boolean;
-- Return whether it is safe to change bytes in Data (Region). This is true
-- for regions from writeable files, for regions mapped with the "Mutable"
-- flag set, and for regions that are copied in a buffer. Note that it is
-- not specified whether empty regions are mutable or not, since there is
-- no byte no modify.
function Is_Mmapped (File : Mapped_File) return Boolean;
-- Whether regions for this file are opened through an mmap() system call
-- or equivalent. This is in general irrelevant to your application, unless
-- the file can be accessed by multiple concurrent processes or tasks. In
-- such a case, and if the file is indeed mmap-ed, then the various parts
-- of the file can be written simulatenously, and thus you cannot ensure
-- the integrity of the file. If the file is not mmapped, the latest
-- process to Close it overwrite what other processes have done.
function Get_Page_Size return Integer;
-- Returns the number of bytes in a page. Once a file is mapped from the
-- disk, its offset and Length should be multiples of this page size (which
-- is ensured by this package in any case). Knowing this page size allows
-- you to map as much memory as possible at once, thus potentially reducing
-- the number of system calls to read the file by chunks.
function Read_Whole_File
(Filename : String;
Empty_If_Not_Found : Boolean := False)
return System.Strings.String_Access;
-- Returns the whole contents of the file.
-- The returned string must be freed by the user.
-- This is a convenience function, which is of course slower than the ones
-- above since we also need to allocate some memory, actually read the file
-- and copy the bytes.
-- If the file does not exist, null is returned. However, if
-- Empty_If_Not_Found is True, then the empty string is returned instead.
-- Filename should be compatible with the filesystem.
private
pragma Inline (Data, Length, Last, Offset, Is_Mmapped, To_Str_Access);
type Mapped_File_Record;
type Mapped_File is access Mapped_File_Record;
type Mapped_Region_Record;
type Mapped_Region is access Mapped_Region_Record;
Invalid_Mapped_File : constant Mapped_File := null;
Invalid_Mapped_Region : constant Mapped_Region := null;
end System.Mmap;
|
gcc-gcc-7_3_0-release/gcc/testsuite/gnat.dg/test_time_stamp.adb
|
best08618/asylo
| 7 |
523
|
-- { dg-do run }
with GNAT.Time_Stamp;
use GNAT.Time_Stamp;
procedure test_time_stamp is
S : constant String := Current_Time;
function NN (S : String) return Boolean is
begin
for J in S'Range loop
if S (J) not in '0' .. '9' then
return True;
end if;
end loop;
return False;
end NN;
begin
if S'Length /= 22
or else S (5) /= '-'
or else S (8) /= '-'
or else S (11) /= ' '
or else S (14) /= ':'
or else S (17) /= ':'
or else S (20) /= '.'
or else NN (S (1 .. 4))
or else NN (S (6 .. 7))
or else NN (S (9 .. 10))
or else NN (S (12 .. 13))
or else NN (S (15 .. 16))
or else NN (S (18 .. 19))
or else NN (S (21 .. 22))
then
raise Program_Error;
end if;
end;
|
type-assignment-unicity.agda
|
hazelgrove/hazelnut-agda
| 0 |
1864
|
<filename>type-assignment-unicity.agda
open import Nat
open import Prelude
open import dynamics-core
open import contexts
module type-assignment-unicity where
-- type assignment only assigns one type
type-assignment-unicity : {Γ : tctx} {d : ihexp} {τ' τ : htyp} {Δ : hctx} →
Δ , Γ ⊢ d :: τ →
Δ , Γ ⊢ d :: τ' →
τ == τ'
type-assignment-unicity TANum TANum = refl
type-assignment-unicity (TAPlus x x₁) (TAPlus x₂ x₃) = refl
type-assignment-unicity {Γ = Γ} (TAVar x₁) (TAVar x₂) = ctxunicity {Γ = Γ} x₁ x₂
type-assignment-unicity (TALam _ d1) (TALam _ d2)
with type-assignment-unicity d1 d2
... | refl = refl
type-assignment-unicity (TAAp x x₁) (TAAp y y₁)
with type-assignment-unicity x y
... | refl = refl
type-assignment-unicity (TAInl x) (TAInl y)
with type-assignment-unicity x y
... | refl = refl
type-assignment-unicity (TAInr x) (TAInr y)
with type-assignment-unicity x y
... | refl = refl
type-assignment-unicity (TACase d _ x _ y) (TACase d₁ _ x₁ _ y₁)
with type-assignment-unicity d d₁
... | refl with type-assignment-unicity x x₁
... | refl = refl
type-assignment-unicity (TAEHole {Δ = Δ} x y) (TAEHole x₁ x₂)
with ctxunicity {Γ = Δ} x x₁
... | refl = refl
type-assignment-unicity (TANEHole {Δ = Δ} x d1 y) (TANEHole x₁ d2 x₂)
with ctxunicity {Γ = Δ} x₁ x
... | refl = refl
type-assignment-unicity (TACast d1 x) (TACast d2 x₁)
with type-assignment-unicity d1 d2
... | refl = refl
type-assignment-unicity (TAFailedCast x x₁ x₂ x₃) (TAFailedCast y x₄ x₅ x₆)
with type-assignment-unicity x y
... | refl = refl
type-assignment-unicity (TAPair x x₁) (TAPair y y₁)
with type-assignment-unicity x y
... | refl with type-assignment-unicity x₁ y₁
... | refl = refl
type-assignment-unicity (TAFst x) (TAFst y)
with type-assignment-unicity x y
... | refl = refl
type-assignment-unicity (TASnd x) (TASnd y)
with type-assignment-unicity x y
... | refl = refl
|
tests/test build script and options/opt syntax/syntax_b.asm
|
fengjixuchui/sjasmplus
| 220 |
96641
|
<filename>tests/test build script and options/opt syntax/syntax_b.asm
; Thorough tests for memory accessing instructions with --syntax=b
; default bracket syntax (relaxed one)
OPT reset --zxnext --syntax=a
; 3x OK: val, mem, mem
ld a,0 : ld a,(1) : ld a,[2]
; 2x OK: val, val, ---
ld b,3 : ld b,(4) : ld b,[5]
; 2x OK: val, val, ---
bit 3,a : bit (3),a : bit [3],a
; 2x OK: val, val, ---
add a,6 : add a,(7) : add a,[8]
adc a,6 : adc a,(7) : adc a,[8]
sub a,6 : sub a,(7) : sub a,[8] ; this syntax works because --syntax=A was used
sbc a,6 : sbc a,(7) : sbc a,[8]
and a,6 : and a,(7) : and a,[8]
xor a,6 : xor a,(7) : xor a,[8]
or a,6 : or a,(7) : or a,[8]
cp a,6 : cp a,(7) : cp a,[8]
; 2x OK: val, val, ---
im 1 : im (1) : im [1]
; 2x OK: val, val, ---
ld (hl),9 : ld (hl),(10) : ld (hl),[11]
; 2x OK: val, val, ---
ld (ix),12 : ld (ix),(13) : ld (ix),[14]
; 2x OK: val, val, ---
ld ixl,15 : ld ixl,(16) : ld ixl,[17]
; 2x OK: val, val, ---
ldd (hl),18 : ldd (hl),(19) : ldd (hl),[20] ; Fake instructions
; 2x OK: val, val, ---
ldd (ix),21 : ldd (ix),(22) : ldd (ix),[23] ; Fake instructions
; 2x OK: val, val, ---
ldi (hl),24 : ldi (hl),(25) : ldi (hl),[26] ; Fake instructions
; 2x OK: val, val, ---
ldi (ix),27 : ldi (ix),(28) : ldi (ix),[29] ; Fake instructions
; 2x OK: val, val, ---
nextreg 30,31 : nextreg (32),(33) : nextreg [34],[35]
; 2x OK: val, val, ---
out (c),0 : out (c),(0) : out (c),[0]
; 2x OK: val, val, ---
res 7,a : res (7),a : res [7],a
; 2x OK: val, val, ---
rst 16 : rst (16) : rst [16]
; 2x OK: val, val, ---
set 6,a : set (6),a : set [6],a
; 2x OK: val, val, ---
test 36 : test (37) : test [38]
;; 16 bit immediates (none of them on regular Z80, always ambiguous val+mem combination)
; 2x OK: val, val, ---
add hl,100 : add hl,(101) : add hl,[102]
add bc,103 : add bc,(104) : add bc,[105]
add de,106 : add de,(107) : add de,[108]
push 109 : push (110) : push [111]
OPT --syntax=b
; 3x OK: val, mem, mem
ld a,0 : ld a,(1) : ld a,[2]
; 1x OK: val, ---, ---
ld b,3 : ld b,(4) : ld b,[5]
; 1x OK: val, ---, ---
bit 3,a : bit (3),a : bit [3],a
; 1x OK: val, ---, ---
add a,6 : add a,(7) : add a,[8]
adc a,6 : adc a,(7) : adc a,[8]
sub a,6 : sub a,(7) : sub a,[8] ; this syntax works because --syntax=A was used
sbc a,6 : sbc a,(7) : sbc a,[8]
and a,6 : and a,(7) : and a,[8]
xor a,6 : xor a,(7) : xor a,[8]
or a,6 : or a,(7) : or a,[8]
cp a,6 : cp a,(7) : cp a,[8]
; 1x OK: val, ---, ---
im 1 : im (1) : im [1]
; 1x OK: val, ---, ---
ld (hl),9 : ld (hl),(10) : ld (hl),[11]
; 1x OK: val, ---, ---
ld (ix),12 : ld (ix),(13) : ld (ix),[14]
; 1x OK: val, ---, ---
ld ixl,15 : ld ixl,(16) : ld ixl,[17]
; 1x OK: val, ---, ---
ldd (hl),18 : ldd (hl),(19) : ldd (hl),[20] ; Fake instructions
; 1x OK: val, ---, ---
ldd (ix),21 : ldd (ix),(22) : ldd (ix),[23] ; Fake instructions
; 1x OK: val, ---, ---
ldi (hl),24 : ldi (hl),(25) : ldi (hl),[26] ; Fake instructions
; 1x OK: val, ---, ---
ldi (ix),27 : ldi (ix),(28) : ldi (ix),[29] ; Fake instructions
; 1x OK: val, ---, ---
nextreg 30,31 : nextreg (32),(33) : nextreg [34],[35]
; 1x OK: val, ---, ---
out (c),0 : out (c),(0) : out (c),[0]
; 1x OK: val, ---, ---
res 7,a : res (7),a : res [7],a
; 1x OK: val, ---, ---
rst 16 : rst (16) : rst [16]
; 1x OK: val, ---, ---
set 6,a : set (6),a : set [6],a
; 1x OK: val, ---, ---
test 36 : test (37) : test [38]
; 1x OK: val, ---, ---
add hl,100 : add hl,(101) : add hl,[102]
add bc,103 : add bc,(104) : add bc,[105]
add de,106 : add de,(107) : add de,[108]
push 109 : push (110) : push [111]
someLabel:
ld b,(someLabel) ; just make super sure it does catch the original real world annoyance
;; Docs example from command line options section
OPT reset --syntax=abfw
label: dw 15
ld b,(label)
sub a,b
|
programs/oeis/000/A000918.asm
|
neoneye/loda
| 22 |
29196
|
<gh_stars>10-100
; A000918: a(n) = 2^n - 2.
; -1,0,2,6,14,30,62,126,254,510,1022,2046,4094,8190,16382,32766,65534,131070,262142,524286,1048574,2097150,4194302,8388606,16777214,33554430,67108862,134217726,268435454,536870910,1073741822,2147483646,4294967294,8589934590,17179869182,34359738366,68719476734,137438953470,274877906942,549755813886,1099511627774,2199023255550,4398046511102,8796093022206,17592186044414,35184372088830,70368744177662,140737488355326,281474976710654,562949953421310,1125899906842622,2251799813685246,4503599627370494,9007199254740990,18014398509481982,36028797018963966,72057594037927934,144115188075855870,288230376151711742,576460752303423486,1152921504606846974,2305843009213693950,4611686018427387902,9223372036854775806,18446744073709551614,36893488147419103230,73786976294838206462,147573952589676412926,295147905179352825854,590295810358705651710,1180591620717411303422,2361183241434822606846,4722366482869645213694,9444732965739290427390,18889465931478580854782,37778931862957161709566,75557863725914323419134,151115727451828646838270,302231454903657293676542,604462909807314587353086,1208925819614629174706174,2417851639229258349412350,4835703278458516698824702,9671406556917033397649406,19342813113834066795298814,38685626227668133590597630,77371252455336267181195262,154742504910672534362390526,309485009821345068724781054,618970019642690137449562110,1237940039285380274899124222,2475880078570760549798248446,4951760157141521099596496894,9903520314283042199192993790,19807040628566084398385987582,39614081257132168796771975166,79228162514264337593543950334,158456325028528675187087900670,316912650057057350374175801342,633825300114114700748351602686
mov $1,2
pow $1,$0
sub $1,2
mov $0,$1
|
src/game.asm
|
drwuro/teleporter64
| 3 |
529
|
str_lost
!scr "you failed"
!byte $FF
str_won
!scr "congratulations!"
!byte $FF
str_skills1
!scr "you have great"
!byte $FF
str_skills2
!scr "teleportation skills"
!byte $FF
str_attempts
!scr "total number of attempts: "
!byte $FF
str_attempts99
!scr "it took you over 99 attempts..."
!byte $FF
;-------------------------------
!zone
update
;-- counter for teleporter animation (we need this everywhere so we do it here)
inc tel_anim
lda tel_anim
cmp #24
bne +
lda #0
sta tel_anim
+
;-- update game or title depending on state
lda state
cmp #STATE_GAME
bne +
jsr update_game
rts
+ cmp #STATE_TITLE
bne +
jsr update_title
+
rts
;-------------------------------
;-- game functions
!zone
;-- start game from beginning
;--
reset_game
lda #0
sta level_number
sta num_attempts
;-- init and switch to "GAME" state
;--
init_game
lda #STATE_GAME
sta state
;--
lda #0
sta SPR_ENAB ;-- turn off sprites
jsr clear_screen
lda #LBL
jsr clear_color_ram
jsr init_level
;-- clear joy list
lda #$FF
ldx #0
.clearloop
sta JOY_LIST, x
dex
bne .clearloop
;-- reset game related variables
lda #0
sta gamestate
sta curve_index
sta tele_delay
;-- always set first direction to "right"
ldx #$0
stx joy_index
lda #DIR_RIGHT
sta playerdir
sta JOY_LIST, x
;-- init player sprite
lda #SP_GUY
sta SPRITE_0
lda #GRN
sta SPRITE_0C
;-- increment number of attempts (only relevant in tourist mode)
lda num_attempts
cmp #$FF
beq +
sed ;-- turn on decimal mode
lda num_attempts
clc
adc #1 ;-- we cannot just use "inc" in decimal mode :'(
sta num_attempts
cld ;-- turn off decimal mode again
bcc +
lda #$FF ;-- we use this little hacky solution if the player
sta num_attempts ;-- needs over 99 attempts (close-to-deadline solution)
+
rts
;-- switch to next level
;--
next_level
inc level_number
lda level_number
cmp #NUM_LEVELS
bne +
lda #0
sta level_number
+ jsr init_game
rts
;-- the game's update function (called once a frame)
;--
.tempx !word 0
update_game
+DEBUG_BORDER RED
;-- check for run/stop
lda key
cmp #KEY_RUNSTOP
bne +
lda #0
sta key
jsr init_title ;-- back to title
rts
+
;-- choose pathcolor
lda #0
sta pathcolor ;-- black path is default
lda gamestate
bne .no_color
;-- change pathcolor if gamestate is 0 (GS_WALK)
lda tick
lsr
lsr
and #%00000111
tax
lda T_PATHCOLOR, x
sta pathcolor
.no_color
;-- draw level on screen
jsr draw_level
;-- update game depending on gamestate
lda gamestate
bne +
jmp .gs_walk
+ cmp #GS_PLAY
bne +
jmp .gs_play
+ cmp #GS_NEXT
bne +
jmp .gs_next
+ cmp #GS_LOST
bne +
jmp .gs_lost
+ cmp #GS_WON
bne +
jmp .gs_won
+
jmp .gs_end
;--
;-- WALK: player walks towards the first teleporter
.gs_walk
;-- move player every 4th frame
lda tick
and #%00000011
bne +
inc playerx
;-- set initial joy dir (if joy is pushed while walking)
+ jsr get_joy_dir
cmp #DIR_STOP
beq +
sta JOY_LIST
clc
adc #TL_LEFT ;-- direction + left arrow = arrow tile number
sta SCR_BASE + 40 * 24 ;-- put arrow on screen
;-- check if player reached teleporter
+ jsr get_tile_at_playerpos
and #%01111111 ;-- check if we're on a space char, but inverted is ok too
cmp #' '
beq .not_reached
inc gamestate ;-- switch to next gamestate (GS_PLAY)
lda #0
sta tele_delay
+PLAY_SFX
.not_reached
jmp .gs_end
;--
;-- PLAY: teleportation phase
.gs_play
;-- handle joystick input
jsr get_joy_dir
cmp #DIR_STOP
beq .no_joy
ldx joy_index
cmp JOY_LIST, x ;-- check if state is different than previously
beq .no_joy
;-- add direction to list and increment joy index
+ inx
sta JOY_LIST, x
stx joy_index
;-- add arrow symbol to screen
clc
adc #TL_LEFT ;-- direction + left arrow = arrow tile number
sta SCR_BASE + 40 * 24, x
.no_joy
;-- player movement
lda tele_delay ;-- check if we're still in waiting phase
cmp #TELE_DELAY
beq .move_player
;-- waiting phase
inc tele_delay
lda tele_delay ;-- check if waiting phase will be over
cmp #TELE_DELAY
bne +
ldx #0
lda JOY_LIST ;-- load and set initial player direction
sta playerdir
clc
adc #TL_LEFT
sta SCR_BASE + 40 * 24, x
lda #WHT
sta COL_BASE + 40 * 24, x ;-- make first arrow white
+ jmp .update_sprite_pos
;-- move player
.move_player
lda playerdir
cmp #DIR_LEFT
bne .check_right
+SUB_16_8 playerx, playerspeed
jmp .endmove
.check_right
cmp #DIR_RIGHT
bne .check_up
+ADD_16_8 playerx, playerspeed
jmp .endmove
.check_up
cmp #DIR_UP
bne .check_down
sec
lda playery
sbc playerspeed
sta playery
jmp .endmove
.check_down
cmp #DIR_DOWN
bne .endmove
clc
lda playery
adc playerspeed
sta playery
.endmove
;-- check for tile collision
;-- make sure player is exactly on a tile (xy position / 8)
lda playerx
and #%00000111
bne .no_curve
lda playery
and #%00000111
bne .no_curve
jsr get_tile_at_playerpos
;-- check if player is located on a curve
cmp #70
beq .curve
cmp #71
beq .curve
cmp #72
beq .curve
cmp #73
beq .curve
;-- check if player is located on a teleporter
cmp #TL_TELE
beq .on_teleporter
cmp #TL_TELE +1
beq .on_teleporter
cmp #TL_TELE +2
beq .on_teleporter
jmp .no_curve
.on_teleporter
;-- make sure it's the teleporter on the right
cpx #RIGHT_PLAT_X ;-- x is still playerx / 8 at this point so we can utilize this
bne .no_curve
inc gamestate ;-- switch to next gamestate (GS_NEXT)
rts
.curve
ldx curve_index
;-- get next value from joy list and apply to player's moving direction
inx
lda JOY_LIST, x
cmp #$FF
beq .no_curve
sta playerdir
;-- make arrow white on screen
lda #WHT
sta COL_BASE + 40*24, x
stx curve_index
.no_curve
;-- check if player leaves the screen
lda playerx +1
clc
ror
lda playerx
ror
beq .dead ;-- x = 0
cmp #160
beq .dead
lda playery
cmp #0
beq .dead
cmp #200
beq .dead
jmp .no_border
.dead
;-- player is dead
lda #GS_LOST
sta gamestate
rts
.no_border
;-- draw player as teleportation schwurbel
lda tel_anim
lsr
lsr
lsr
and #%00000011
clc
adc #SP_TELE
sta SPRITE_0
lda #%00000000
sta SPR_PRIO ;-- during teleportation phase, sprite shall be in front of chars
jmp .update_sprite_pos
;--
;-- NEXT: player walks towards end of screen (next level)
.gs_next
;-- move player every 4th frame
lda tick
and #%00000011
bne +
+INC_16 playerx
+
;-- check if player is standing next to a computer
lda playerx +1
clc
ror
lda playerx
ror
lsr
lsr
tax
inx
lda playery
lsr
lsr
lsr
tay
jsr get_tile
cmp #TL_COMP
bne .no_computer
lda #GS_WON
sta gamestate
jmp .gs_end
.no_computer
;-- check if player reached end of screen
lda playerx +1
beq .gs_end
lda playerx
cmp #<(RIGHT_PLAT_X + PLAT_W) * 8
bne .gs_end
;-- go to next level
jsr next_level
rts
;--
;-- LOST: show message, wait for fire, restart
.gs_lost
+STRING_OUTPUT str_lost, 14, 12, LBL
lda #%00000000
sta SPR_ENAB
lda $DC00 ;-- read joystick in port 2
and #JOY_FIRE
bne .no_fire
;-- restart level
lda game_mode
beq .challenge_mode
jsr init_game ;-- restart current level
rts
.challenge_mode
jsr init_title ;-- go back to title
.no_fire
rts
;--
;-- WON: show message, wait for fire, restart
.gs_won
jsr draw_win_message
lda $DC00 ;-- read joystick in port 2
and #JOY_FIRE
bne .gs_end
;-- restart game TODO
lda #0
sta level_number
jsr init_title
rts
.gs_end
;-- draw player as guy
lda tick
lsr
lsr
and #%00000011
clc
adc #SP_GUY
sta SPRITE_0
lda #%00000001
sta SPR_PRIO ;-- during walking phase, sprite shall be behind chars
sta SPR_ENAB ;-- make sure sprite is visible
.update_sprite_pos
;-- add sprite border offset to playerx
+ADD_16_8C playerx, SPR_XOFF, .tempx
;-- set low byte of sprite x position
lda .tempx
sta SPRITE_0X
;-- set high bit of sprite x position
lda .tempx +1
beq .no_overflow
lda SPRITE_XF
ora SPR_OV
jmp .end_overflow
.no_overflow
lda SPRITE_XF
and SPR_NO
.end_overflow
sta SPRITE_XF
;-- set sprite y position
lda playery
clc
adc #SPR_YOFF
sta SPRITE_0Y
+DEBUG_BORDER BLK
rts
;-------------------------------
;-- level functions
!zone
.levaddr = $20
.scraddr = $22
.coladdr = $24
.color = $26
.curdir !byte 0
.olddir !byte 0
init_level
lda level_number
asl
tax
;-- load level address
lda T_LEVELS, x
sta .levaddr
lda T_LEVELS +1, x
sta .levaddr +1
;-- unpack level path
jsr unpack_path
;-- set player x pos
lda #(LEFT_PLAT_X -1) * 8
sta playerx
lda #0
sta playerx +1
;-- determine player y pos
ldy #0
lda (.levaddr), y ;-- y of left platform
tax
dex ;-- player is 1 row above platform
txa
asl
asl
asl
sta playery
rts
;-- unpack compressed path into memory
;--
.count = $27
unpack_path
ldy #4 ;-- offset of path start in level data
ldx #0
.read
lda (.levaddr), y ;-- read number
cmp #$FF
beq .end_unpack
sta .count
iny
lda (.levaddr), y ;-- read direction (l, r, u, d)
.writeloop
sta UNPACKED_PATH, x ;-- write direction number of times
inx
dec .count
bne .writeloop
iny
jmp .read
.end_unpack
lda #'$'
sta UNPACKED_PATH, x ;-- write end character ($)
rts
;-- draw level on screen
;--
draw_level
;-- draw platforms and teleporters
ldx #LEFT_PLAT_X
ldy #0
lda (.levaddr), y ;-- y of left platform
jsr draw_platform
ldx #RIGHT_PLAT_X
ldy #1
lda (.levaddr), y ;-- y of right platform
jsr draw_platform
;-- draw teleportation path
lda gamestate
cmp #GS_WON ;-- don't draw path on "won" screen to avoid glitches
beq .no_draw
cmp #GS_LOST ;-- don't draw path on "lost" screen to avoid glitches
beq .no_draw
lda pathcolor
sta .color
jsr draw_path
.no_draw
rts
;-- draw a platform (this code is a bit messy, it detects a few times
;-- which of the two platforms it has to draw)
;--
draw_platform
tay
lda T_SCREENLINES_L, y
sta .scraddr
lda T_SCREENLINES_H, y
sta .scraddr +1
lda T_COLORLINES_L, y
sta .coladdr
lda T_COLORLINES_H, y
sta .coladdr +1
txa
tay
lda #TL_WALL
;-- draw wall tiles
sta (.scraddr), y
!for i, 0, PLAT_W -2 {
iny
sta (.scraddr), y
}
;-- draw color
lda #BRN
sta (.coladdr), y
!for i, 0, PLAT_W -2 {
dey
sta (.coladdr), y
}
;-- note: the following code is a bit messy
;-- draw teleporter
+SUB_16_8C .scraddr, 40 ;-- teleporter is 1 char row above walls
+SUB_16_8C .coladdr, 40
jsr get_teleporter_tile
cpx #LEFT_PLAT_X ;-- check whether drawing left or right teleporter
bne +
!for i, 0, PLAT_W -2 { iny } ;-- move a few chars to the right for left teleporter
+ sta (.scraddr), y
lda #LBL
sta (.coladdr), y
;-- draw black square (to make player sprite disappear behind)
txa
tay
dey
cpx #LEFT_PLAT_X ;-- check whether drawing left or right teleporter
beq +
!for i, 0, PLAT_W { iny } ;-- move a few chars to the right for right teleporter
;-- check if we have to draw a computer instead (last level)
lda level_number
cmp #NUM_LEVELS -1
bne +
;-- draw computer
dey
lda #TL_COMP
sta (.scraddr), y
lda #WHT
sta (.coladdr), y
rts
;-- draw black square
+ lda #' ' + 128 ;-- inverted space char
sta (.scraddr), y
lda #BLK
sta (.coladdr), y
rts
;-- draw the teleportation vortex path
;--
draw_path
ldy #3
lda (.levaddr), y ;-- path start y position
tay
lda T_SCREENLINES_L, y
sta .scraddr
lda T_SCREENLINES_H, y
sta .scraddr +1
lda T_COLORLINES_L, y
sta .coladdr
lda T_COLORLINES_H, y
sta .coladdr +1
ldy #2
lda (.levaddr), y ;-- path start x position
tay
;-- load path start address (level address + 4)
;-- +ADD_16_8C .levaddr, 4, .o1 +1
;-- draw path loop
ldx #$FF
.loop
inx
lda .curdir
sta .olddir ;-- store previous direction
.o1 lda UNPACKED_PATH, x
sta .curdir
;-- determine path direction from current path char
cmp #'l'
beq .left
cmp #'r'
beq .right
cmp #'u'
beq .up
cmp #'d'
beq .down
;-- if path char is not l, r, u or d, path drawing is finished
jmp .end
;-- path goes left
.left
lda .olddir
cmp #'u'
beq .ul ;-- previous direction was 'up'
cmp #'d'
beq .dl ;-- previous direction was 'down'
lda #69
jmp .writeleft
.ul lda #71
jmp .writeleft
.dl lda #73
.writeleft
;-- write char to screen
sta (.scraddr), y
lda .color
sta (.coladdr), y
;-- go one char to the left for next char
dey
jmp .loop
;-- path goes right
.right
lda .olddir
cmp #'u'
beq .ur ;-- previous direction was 'up'
cmp #'d'
beq .dr ;-- previous direction was 'down'
lda #69
jmp .writeright
.ur lda #70
jmp .writeright
.dr lda #72
jmp .writeright
.writeright
;-- write char to screen
sta (.scraddr), y
lda .color
sta (.coladdr), y
;-- go one char to the right for next char
iny
jmp .loop
;-- path goes up
.up
lda .olddir
cmp #'l' ;-- previous direction was 'left'
beq .lu
cmp #'r' ;-- previous direction was 'right'
beq .ru
lda #68
jmp .writeup
.lu lda #72
jmp .writeup
.ru lda #73
.writeup
;-- write char to screen
sta (.scraddr), y
lda .color
sta (.coladdr), y
;-- go one char line up for next char
jmp .scrlineup
;-- path goes down
.down
lda .olddir
cmp #'l' ;-- previous direction was 'left'
beq .ld
cmp #'r' ;-- previous direction was 'right'
beq .rd
lda #68
jmp .writedown
.ld lda #70
jmp .writedown
.rd lda #71
.writedown
;-- write char to screen
sta (.scraddr), y
lda .color
sta (.coladdr), y
;-- go one char line down for next char
jmp .scrlinedown
.scrlineup
+SUB_16_8C .scraddr, 40
+SUB_16_8C .coladdr, 40
jmp .loop
.scrlinedown
+ADD_16_8C .scraddr, 40
+ADD_16_8C .coladdr, 40
jmp .loop
.end
rts
;-- return tile (char) at pos x/y
;--
.tempaddr = $29
get_tile_at_playerpos
;-- divide x by 8
lda playerx +1 ;-- high bit needs to be taken along
clc
ror
lda playerx
ror
lsr
lsr
tax ;-- x is now playerx / 8
;-- divide y by 8
lda playery
lsr
lsr
lsr
tay ;-- y is now playery / 8
get_tile ;-- can be called independently
lda T_SCREENLINES_L, y
sta .tempaddr
lda T_SCREENLINES_H, y
sta .tempaddr +1
txa
tay
lda (.tempaddr), y
rts
;-- show win message
;--
draw_win_message
+STRING_OUTPUT str_won, 12, 9, LBL
lda game_mode
beq +
;-- tourist mode
lda num_attempts
cmp #$FF
beq .over99
+STRING_OUTPUT str_attempts, 6, 12, GR2
;-- display score
lda num_attempts ;-- number is in decimal mode
lsr
lsr
lsr
lsr
clc
adc #48 ;-- add 48 (= petscii zero) to display first digit
sta SCR_BASE + 40 * 12 + 32
lda num_attempts
and #%00001111
clc
adc #48 ;-- add 48 (= petscii zero) to display second digit
sta SCR_BASE + 40 * 12 + 33
rts
.over99
+STRING_OUTPUT str_attempts99, 5, 12, GR2
rts
+ ;-- challenge mode
+STRING_OUTPUT str_skills1, 13, 12, GR2
+STRING_OUTPUT str_skills2, 10, 14, GR2
rts
|
ada-assertions.ads
|
mgrojo/adalib
| 15 |
18376
|
<reponame>mgrojo/adalib<gh_stars>10-100
-- Standard Ada library specification
-- Copyright (c) 2003-2018 <NAME> <<EMAIL>>
-- Copyright (c) 2004-2016 AXE Consultants
-- Copyright (c) 2004, 2005, 2006 Ada-Europe
-- Copyright (c) 2000 The MITRE Corporation, Inc.
-- Copyright (c) 1992, 1993, 1994, 1995 Intermetrics, Inc.
-- SPDX-License-Identifier: BSD-3-Clause and LicenseRef-AdaReferenceManual
---------------------------------------------------------------------------
package Ada.Assertions is
pragma Pure (Assertions);
Assertion_Error : exception;
procedure Assert (Check : in Boolean);
procedure Assert (Check : in Boolean; Message : in String);
end Ada.Assertions;
|
soundness/ProofUtilities.agda
|
frelindb/agsyHOL
| 17 |
12759
|
module ProofUtilities where
-- open import Data.Nat hiding (_>_)
open import StdLibStuff
open import Syntax
open import FSC
mutual
hn-left-i : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t α) (F : Form Γ-t β) (G : Form Γ-t α) → Γ ⊢ α ∋ S (headNorm m F) ↔ G → Γ ⊢ α ∋ S F ↔ G
hn-left-i m S (app F H) G p = hn-left-i m (λ x → S (app x H)) F G (hn-left-i' m S (headNorm m F) H G p)
hn-left-i _ _ (var _ _) _ p = p
hn-left-i _ _ N _ p = p
hn-left-i _ _ A _ p = p
hn-left-i _ _ Π _ p = p
hn-left-i _ _ i _ p = p
hn-left-i _ _ (lam _ _) _ p = p
hn-left-i' : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β γ : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t α) (F : Form Γ-t (γ > β)) (H : Form Γ-t γ) (G : Form Γ-t α) → Γ ⊢ α ∋ S (headNorm' m F H) ↔ G → Γ ⊢ α ∋ S (app F H) ↔ G
hn-left-i' (suc m) S (lam _ F) H G p with hn-left-i m S (sub H F) G p
hn-left-i' (suc _) S (lam _ _) _ _ _ | p' = reduce-l {_} {_} {_} {_} {_} {_} {S} p'
hn-left-i' 0 _ (lam _ _) _ _ p = p
hn-left-i' zero _ (var _ _) _ _ p = p
hn-left-i' (suc _) _ (var _ _) _ _ p = p
hn-left-i' zero _ N _ _ p = p
hn-left-i' (suc _) _ N _ _ p = p
hn-left-i' zero _ A _ _ p = p
hn-left-i' (suc _) _ A _ _ p = p
hn-left-i' zero _ Π _ _ p = p
hn-left-i' (suc _) _ Π _ _ p = p
hn-left-i' zero _ i _ _ p = p
hn-left-i' (suc _) _ i _ _ p = p
hn-left-i' zero _ (app _ _) _ _ p = p
hn-left-i' (suc _) _ (app _ _) _ _ p = p
hn-left : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α : Type n} (m : ℕ) (F : Form Γ-t α) (G : Form Γ-t α) → Γ ⊢ α ∋ headNorm m F ↔ G → Γ ⊢ α ∋ F ↔ G
hn-left m F G p = hn-left-i m (λ x → x) F G p
mutual
hn-right-i : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t α) (F : Form Γ-t β) (G : Form Γ-t α) → Γ ⊢ α ∋ G ↔ S (headNorm m F) → Γ ⊢ α ∋ G ↔ S F
hn-right-i m S (app F H) G p = hn-right-i m (λ x → S (app x H)) F G (hn-right-i' m S (headNorm m F) H G p)
hn-right-i _ _ (var _ _) _ p = p
hn-right-i _ _ N _ p = p
hn-right-i _ _ A _ p = p
hn-right-i _ _ Π _ p = p
hn-right-i _ _ i _ p = p
hn-right-i _ _ (lam _ _) _ p = p
hn-right-i' : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β γ : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t α) (F : Form Γ-t (γ > β)) (H : Form Γ-t γ) (G : Form Γ-t α) → Γ ⊢ α ∋ G ↔ S (headNorm' m F H) → Γ ⊢ α ∋ G ↔ S (app F H)
hn-right-i' (suc m) S (lam _ F) H G p with hn-right-i m S (sub H F) G p
hn-right-i' (suc _) S (lam _ _) _ _ _ | p' = reduce-r {_} {_} {_} {_} {_} {_} {S} p'
hn-right-i' 0 _ (lam _ _) _ _ p = p
hn-right-i' zero _ (var _ _) _ _ p = p
hn-right-i' (suc _) _ (var _ _) _ _ p = p
hn-right-i' zero _ N _ _ p = p
hn-right-i' (suc _) _ N _ _ p = p
hn-right-i' zero _ A _ _ p = p
hn-right-i' (suc _) _ A _ _ p = p
hn-right-i' zero _ Π _ _ p = p
hn-right-i' (suc _) _ Π _ _ p = p
hn-right-i' zero _ i _ _ p = p
hn-right-i' (suc _) _ i _ _ p = p
hn-right-i' zero _ (app _ _) _ _ p = p
hn-right-i' (suc _) _ (app _ _) _ _ p = p
hn-right : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α : Type n} (m : ℕ) (F : Form Γ-t α) (G : Form Γ-t α) → Γ ⊢ α ∋ G ↔ headNorm m F → Γ ⊢ α ∋ G ↔ F
hn-right m F G p = hn-right-i m (λ x → x) F G p
mutual
hn-succ-i : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {β : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t β) → Γ ⊢ S (headNorm m F) → Γ ⊢ S F
hn-succ-i m S (app F H) p = hn-succ-i m (λ x → S (app x H)) F (hn-succ-i' m S (headNorm m F) H p)
hn-succ-i _ _ (var _ _) p = p
hn-succ-i _ _ N p = p
hn-succ-i _ _ A p = p
hn-succ-i _ _ Π p = p
hn-succ-i _ _ i p = p
hn-succ-i _ _ (lam _ _) p = p
hn-succ-i' : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {β γ : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t (γ > β)) (H : Form Γ-t γ) → Γ ⊢ S (headNorm' m F H) → Γ ⊢ S (app F H)
hn-succ-i' (suc m) S (lam _ F) H p with hn-succ-i m S (sub H F) p
hn-succ-i' (suc _) S (lam _ _) _ _ | p' = reduce {_} {_} {_} {_} {_} {S} p'
hn-succ-i' 0 _ (lam _ _) _ p = p
hn-succ-i' zero _ (var _ _) _ p = p
hn-succ-i' (suc _) _ (var _ _) _ p = p
hn-succ-i' zero _ N _ p = p
hn-succ-i' (suc _) _ N _ p = p
hn-succ-i' zero _ A _ p = p
hn-succ-i' (suc _) _ A _ p = p
hn-succ-i' zero _ Π _ p = p
hn-succ-i' (suc _) _ Π _ p = p
hn-succ-i' zero _ i _ p = p
hn-succ-i' (suc _) _ i _ p = p
hn-succ-i' zero _ (app _ _) _ p = p
hn-succ-i' (suc _) _ (app _ _) _ p = p
hn-succ : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} (m : ℕ) (F : Form Γ-t $o) → Γ ⊢ headNorm m F → Γ ⊢ F
hn-succ m F p = hn-succ-i m (λ x → x) F p
mutual
hn-ante-i : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {β : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t β) (G : Form Γ-t $o) → Γ , S (headNorm m F) ⊢ G → Γ , S F ⊢ G
hn-ante-i m S (app F H) G p = hn-ante-i m (λ x → S (app x H)) F G (hn-ante-i' m S (headNorm m F) H G p)
hn-ante-i _ _ (var _ _) _ p = p
hn-ante-i _ _ N _ p = p
hn-ante-i _ _ A _ p = p
hn-ante-i _ _ Π _ p = p
hn-ante-i _ _ i _ p = p
hn-ante-i _ _ (lam _ _) _ p = p
hn-ante-i' : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {β γ : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t (γ > β)) (H : Form Γ-t γ) (G : Form Γ-t $o) → Γ , S (headNorm' m F H) ⊢ G → Γ , S (app F H) ⊢ G
hn-ante-i' (suc m) S (lam _ F) H G p with hn-ante-i m S (sub H F) G p
hn-ante-i' (suc _) S (lam _ _) _ _ _ | p' = reduce {_} {_} {_} {_} {_} {S} p'
hn-ante-i' 0 _ (lam _ _) _ _ p = p
hn-ante-i' zero _ (var _ _) _ _ p = p
hn-ante-i' (suc _) _ (var _ _) _ _ p = p
hn-ante-i' zero _ N _ _ p = p
hn-ante-i' (suc _) _ N _ _ p = p
hn-ante-i' zero _ A _ _ p = p
hn-ante-i' (suc _) _ A _ _ p = p
hn-ante-i' zero _ Π _ _ p = p
hn-ante-i' (suc _) _ Π _ _ p = p
hn-ante-i' zero _ i _ _ p = p
hn-ante-i' (suc _) _ i _ _ p = p
hn-ante-i' zero _ (app _ _) _ _ p = p
hn-ante-i' (suc _) _ (app _ _) _ _ p = p
hn-ante : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} (m : ℕ) (F : Form Γ-t $o) (G : Form Γ-t $o) → Γ , headNorm m F ⊢ G → Γ , F ⊢ G
hn-ante m F G p = hn-ante-i m (λ x → x) F G p
mutual
hn-ante-eq-i : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t β) (G H : Form Γ-t α) → Γ , S (headNorm m F) ⊢ G == H → Γ , S F ⊢ G == H
hn-ante-eq-i m S (app F I) G H p = hn-ante-eq-i m (λ x → S (app x I)) F G H (hn-ante-eq-i' m S (headNorm m F) I G H p)
hn-ante-eq-i _ _ (var _ _) _ _ p = p
hn-ante-eq-i _ _ N _ _ p = p
hn-ante-eq-i _ _ A _ _ p = p
hn-ante-eq-i _ _ Π _ _ p = p
hn-ante-eq-i _ _ i _ _ p = p
hn-ante-eq-i _ _ (lam _ _) _ _ p = p
hn-ante-eq-i' : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α β γ : Type n} (m : ℕ) (S : Form Γ-t β → Form Γ-t $o) (F : Form Γ-t (γ > β)) (I : Form Γ-t γ) (G H : Form Γ-t α) → Γ , S (headNorm' m F I) ⊢ G == H → Γ , S (app F I) ⊢ G == H
hn-ante-eq-i' (suc m) S (lam _ F) I G H p with hn-ante-eq-i m S (sub I F) G H p
hn-ante-eq-i' (suc _) S (lam _ _) _ _ _ _ | p' = reduce {_} {_} {_} {_} {_} {_} {S} p'
hn-ante-eq-i' 0 _ (lam _ _) _ _ _ p = p
hn-ante-eq-i' zero _ (var _ _) _ _ _ p = p
hn-ante-eq-i' (suc _) _ (var _ _) _ _ _ p = p
hn-ante-eq-i' zero _ N _ _ _ p = p
hn-ante-eq-i' (suc _) _ N _ _ _ p = p
hn-ante-eq-i' zero _ A _ _ _ p = p
hn-ante-eq-i' (suc _) _ A _ _ _ p = p
hn-ante-eq-i' zero _ Π _ _ _ p = p
hn-ante-eq-i' (suc _) _ Π _ _ _ p = p
hn-ante-eq-i' zero _ i _ _ _ p = p
hn-ante-eq-i' (suc _) _ i _ _ _ p = p
hn-ante-eq-i' zero _ (app _ _) _ _ _ p = p
hn-ante-eq-i' (suc _) _ (app _ _) _ _ _ p = p
hn-ante-eq : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α : Type n} (m : ℕ) (F : Form Γ-t $o) (G H : Form Γ-t α) → Γ , headNorm m F ⊢ G == H → Γ , F ⊢ G == H
hn-ante-eq m F G H p = hn-ante-eq-i m (λ x → x) F G H p
-- ------------------------------------
head-& : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {F₁ F₂ G₁ G₂ : Form Γ-t $o} →
Γ ⊢ $o ∋ F₁ == F₂ → Γ ⊢ $o ∋ G₁ == G₂ →
Γ ⊢ $o ∋ (F₁ & G₁) ↔ (F₂ & G₂)
head-& p₁ p₂ = head-app _ _ _ _ _ _ (simp (head-const _ N)) (simp (head-app _ _ _ _ _ _ (simp (head-app _ _ _ _ _ _ (simp (head-const _ A)) (simp (head-app _ _ _ _ _ _ (simp (head-const _ N)) p₁)))) (simp (head-app _ _ _ _ _ _ (simp (head-const _ N)) p₂))))
head-|| : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {F₁ F₂ G₁ G₂ : Form Γ-t $o} →
Γ ⊢ $o ∋ F₁ == F₂ → Γ ⊢ $o ∋ G₁ == G₂ →
Γ ⊢ $o ∋ (F₁ || G₁) ↔ (F₂ || G₂)
head-|| p₁ p₂ = head-app _ _ _ _ _ _ (simp (head-app _ _ _ _ _ _ (simp (head-const _ A)) p₁)) p₂
head-=> : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {F₁ F₂ G₁ G₂ : Form Γ-t $o} →
Γ ⊢ $o ∋ F₁ == F₂ → Γ ⊢ $o ∋ G₁ == G₂ →
Γ ⊢ $o ∋ (F₁ => G₁) ↔ (F₂ => G₂)
head-=> p₁ p₂ = head-app _ _ _ _ _ _ (simp (head-app _ _ _ _ _ _ (simp (head-const _ A)) (simp (head-app _ _ _ _ _ _ (simp (head-const _ N)) p₁)))) p₂
head-~ : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {F₁ F₂ : Form Γ-t $o} →
Γ ⊢ $o ∋ F₁ == F₂ →
Γ ⊢ $o ∋ (~ F₁) ↔ (~ F₂)
head-~ p = head-app _ _ _ _ _ _ (simp (head-const _ N)) p
head-== : {n : ℕ} {Γ-t : Ctx n} {Γ : FSC-Ctx n Γ-t} {α : Type n} {F₁ F₂ G₁ G₂ : Form Γ-t α} →
Γ ⊢ α ∋ F₁ == F₂ → Γ ⊢ α ∋ G₁ == G₂ →
Γ ⊢ $o ∋ (F₁ == G₁) ↔ (F₂ == G₂)
head-== p₁ p₂ = head-app _ _ _ _ _ _ (simp (head-app _ _ _ _ _ _ (simp (head-const _ _)) p₁)) p₂
|
programs/oeis/267/A267582.asm
|
neoneye/loda
| 22 |
163783
|
<gh_stars>10-100
; A267582: Number of ON (black) cells in the n-th iteration of the "Rule 167" elementary cellular automaton starting with a single ON (black) cell.
; 1,2,3,5,5,9,9,11,9,17,17,19,17,23,21,23,17,33,33,35,33,39,37,39,33,47,45,47,41,51,45,47,33,65,65,67,65,71,69,71,65,79,77,79,73,83,77,79,65,95,93,95,89,99,93,95,81,107,101,103,89,107,93,95,65,129,129,131,129,135,133,135,129,143,141,143,137,147,141,143,129,159,157,159,153,163,157,159,145,171,165,167,153,171,157,159,129,191,189,191
mov $2,$0
seq $0,131136 ; Denominator of (exponential) expansion of log((x/2-1)/(x-1)).
div $0,-2
add $0,$2
add $0,$2
add $0,1
|
main.adb
|
Dioxylin/ada_shopping_tally
| 0 |
28402
|
<reponame>Dioxylin/ada_shopping_tally
with Ada.Text_IO; use Ada.Text_IO;
-- Item\tQuantity\tPrice\tTaxable[\tTax]
procedure Main is
type Money_Type is delta 0.01 range -1_000_000_000.0 .. 1_000_000_000.0;
for Money_Type'Small use 0.0001;
subtype Tax_Type is Money_Type range 0.0 .. 1.0;
subtype Quantity_Type is Integer range 0..1000;
subtype Buffer_Length is Integer range 1..256;
subtype Input_String is String(Buffer_Length'First..Buffer_Length'Last);
package Fixed_IO is new Ada.Text_IO.Fixed_IO(Money_Type);
package Integer_IO is new Ada.Text_IO.Integer_IO(Integer);
Sub_Total : Money_Type := 0.0;
Total : Money_Type;
Taxable_Total : Money_Type := 0.0;
begin
Set_Line_Length(To => Count'Val(Buffer_Length'Last));
loop
declare
Item_Name : Input_String;
Item_Name_Length : Buffer_Length;
Item_Quantity : Quantity_Type;
Item_Price : Money_Type;
Item_Taxable_Input : Character;
--Item_Taxable_Length : Buffer_Length;
Item_Taxable : Boolean;
--Item_Tax : Tax_Type;
begin
Put("Item name: ");
Get_Line(Item_Name, Item_Name_Length);
if Item_Name_Length = Buffer_Length'Last then
Put_Line("Item name is too long. Limit is " & Integer'Image(Buffer_Length'Last-1) & " characters.");
raise Data_Error;
end if;
Put_Line("Item name set to " & Item_Name(Input_String'First..Item_Name_Length));
Put_Line("");
Put("Item quantity: ");
Integer_IO.Get(Item_Quantity);
Put_Line("Item quantity set to " & Integer'Image(Item_Quantity));
Put_Line("");
Skip_Line;
Put("Item price: ");
Fixed_IO.Get(Item_Price);
Put_Line("Item price set to " & Money_Type'Image(Item_Price));
Put_Line("");
Skip_Line;
Put("Item taxable (y/n): ");
Get(Item_Taxable_Input);
Item_Taxable := Item_Taxable_Input = 'y';
Put_Line("Item taxability set to " & Boolean'Image(Item_Taxable));
Put_Line("");
Skip_Line;
if Item_Taxable then
Taxable_Total := Taxable_Total + Item_Price;
end if;
Sub_Total := Sub_Total + Item_Price;
exception
-- EOF is End_Error.
when End_Error => exit;
-- If invalid input, we'll retry.
when Data_Error =>
Put_Line("");
Put_Line("***ERROR: Please try again.");
Skip_Line;
end;
end loop;
Put_Line("Transaction:");
Total := Taxable_Total*0.07125 + Sub_Total;
Put_Line("Subtotal: " & Money_Type'Image(Sub_Total));
Put_Line("Taxable total: " & Money_Type'Image(Taxable_Total));
Put_Line("Total: " & Money_Type'Image(Total));
end Main;
|
experiments/test-suite/mutation-based/100/sll.als
|
kaiyuanw/AlloyFLCore
| 1 |
4670
|
<gh_stars>1-10
pred test9 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node1 + Node1->Node1
}}
}
run test9 for 3 expect 1
pred test6 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
}}
}
run test6 for 3 expect 1
pred test15 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0 + Node2->Node2
Acyclic[List0]
}}
}
run test15 for 3 expect 0
pred test22 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node1->Node1 + Node2->Node0
Acyclic[List0]
}}
}
run test22 for 3 expect 1
pred test2 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List1->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
}}
}
run test2 for 3 expect 1
pred test4 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node0 + List0->Node1 + List0->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node1 + Node2->Node0
}}
}
run test4 for 3 expect 0
pred test17 {
some disj List0, List1, List2: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1 + List2
header = List0->Node2 + List1->Node1 + List2->Node0
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node2->Node1
Acyclic[List2]
}}
}
run test17 for 3 expect 1
pred test18 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node1 + Node2->Node0
Acyclic[List0]
}}
}
run test18 for 3 expect 0
pred test5 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
no header
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
}}
}
run test5 for 3 expect 1
pred test14 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node1->Node0 + Node2->Node2
Acyclic[List1]
}}
}
run test14 for 3 expect 1
pred test20 {
some disj List0, List1, List2: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1 + List2
header = List0->Node2 + List1->Node2 + List2->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0
Acyclic[List2]
}}
}
run test20 for 3 expect 1
pred test3 {
some disj Node0: Node {
no List
no header
Node = Node0
no link
}
}
run test3 for 3 expect 1
pred test7 {
no List
no header
no Node
no link
}
run test7 for 3 expect 1
pred test21 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node1 + Node1->Node1 + Node2->Node0
Acyclic[List0]
}}
}
run test21 for 3 expect 0
pred test16 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List1->Node2
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0 + Node2->Node2
Acyclic[List1]
}}
}
run test16 for 3 expect 0
pred test19 {
some disj List0: List {some disj Node0, Node1, Node2: Node {
List = List0
header = List0->Node2
Node = Node0 + Node1 + Node2
link = Node1->Node1
Acyclic[List0]
}}
}
run test19 for 3 expect 1
pred test11 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List1->Node2
Node = Node0 + Node1 + Node2
link = Node2->Node2
Acyclic[List1]
}}
}
run test11 for 3 expect 0
pred test8 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node1 + List1->Node0
Node = Node0 + Node1 + Node2
link = Node2->Node0 + Node2->Node1 + Node2->Node2
}}
}
run test8 for 3 expect 0
pred test13 {
some disj List0, List1, List2: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1 + List2
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node2 + Node1->Node0 + Node2->Node2
Acyclic[List2]
}}
}
run test13 for 3 expect 1
pred test10 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List0->Node2 + List1->Node1
Node = Node0 + Node1 + Node2
link = Node0->Node1 + Node0->Node2 + Node1->Node1 + Node2->Node0
}}
}
run test10 for 3 expect 0
pred test1 {
some disj List0, List1: List {some disj Node0: Node {
List = List0 + List1
header = List1->Node0
Node = Node0
link = Node0->Node0
}}
}
run test1 for 3 expect 1
pred test12 {
some disj List0, List1: List {some disj Node0, Node1, Node2: Node {
List = List0 + List1
header = List1->Node2
Node = Node0 + Node1 + Node2
link = Node1->Node1 + Node2->Node0
Acyclic[List1]
}}
}
run test12 for 3 expect 1
|
libsrc/_DEVELOPMENT/adt/p_list/c/sccz80/p_list_back.asm
|
meesokim/z88dk
| 0 |
19959
|
<reponame>meesokim/z88dk
; void *p_list_back(p_list_t *list)
SECTION code_adt_p_list
PUBLIC p_list_back
p_list_back:
INCLUDE "adt/p_list/z80/asm_p_list_back.asm"
|
libsrc/_DEVELOPMENT/math/float/math48/z80/am48_acos.asm
|
meesokim/z88dk
| 0 |
25046
|
<reponame>meesokim/z88dk<filename>libsrc/_DEVELOPMENT/math/float/math48/z80/am48_acos.asm<gh_stars>0
; double acos(double x)
SECTION code_fp_math48
PUBLIC am48_acos
EXTERN am48_asin, am48_dconst_pi, am48_dsub, am48_dpopret
am48_acos:
; arccos
; AC' = acos(AC')
;
; enter : AC' = double x
;
; exit : success
;
; AC' = acos(x)
; carry reset
;
; fail if domain error |x| > 1
;
; AC' = 0 or pi
; carry set, errno set
;
; note : 0 < acos(x) < pi
;
; uses : af, af', bc', de', hl'
; acos(x) = pi/2 - asin(x)
call am48_asin
push bc ; save AC
push de
push hl
push af ; save error indicator
call am48_dconst_pi
dec l ; AC = pi/2
exx
call am48_dsub
pop af ; restore error indicator
jp am48_dpopret
|
src/arch/x86_64/crti.asm
|
KristianJerpetjon/IncludeOS
| 1 |
99711
|
global _init
global _fini
section .init
_init:
push rbp
mov rbp, rsp
section .fini
_fini:
push rbp
mov rbp, rsp
|
src/Categories/Object/Duality.agda
|
bblfish/agda-categories
| 5 |
15366
|
<reponame>bblfish/agda-categories
{-# OPTIONS --without-K --safe #-}
open import Categories.Category
-- Properties relating Initial and Terminal Objects,
-- and Product / Coproduct via op
module Categories.Object.Duality {o ℓ e} (C : Category o ℓ e) where
open Category C
open import Level
open import Relation.Binary.PropositionalEquality as ≡ using (_≡_)
open import Categories.Morphism C
open import Categories.Object.Terminal op
open import Categories.Object.Initial C
open import Categories.Object.Product op
open import Categories.Object.Coproduct C
IsInitial⇒coIsTerminal : ∀ {X} → IsInitial X → IsTerminal X
IsInitial⇒coIsTerminal is⊥ = record
{ ! = !
; !-unique = !-unique
}
where open IsInitial is⊥
⊥⇒op⊤ : Initial → Terminal
⊥⇒op⊤ i = record
{ ⊤ = ⊥
; ⊤-is-terminal = IsInitial⇒coIsTerminal ⊥-is-initial
}
where open Initial i
coIsTerminal⇒IsInitial : ∀ {X} → IsTerminal X → IsInitial X
coIsTerminal⇒IsInitial is⊤ = record
{ ! = !
; !-unique = !-unique
}
where open IsTerminal is⊤
op⊤⇒⊥ : Terminal → Initial
op⊤⇒⊥ t = record
{ ⊥ = ⊤
; ⊥-is-initial = coIsTerminal⇒IsInitial ⊤-is-terminal
}
where open Terminal t
Coproduct⇒coProduct : ∀ {A B} → Coproduct A B → Product A B
Coproduct⇒coProduct A+B = record
{ A×B = A+B.A+B
; π₁ = A+B.i₁
; π₂ = A+B.i₂
; ⟨_,_⟩ = A+B.[_,_]
; project₁ = A+B.inject₁
; project₂ = A+B.inject₂
; unique = A+B.unique
}
where
module A+B = Coproduct A+B
coProduct⇒Coproduct : ∀ {A B} → Product A B → Coproduct A B
coProduct⇒Coproduct A×B = record
{ A+B = A×B.A×B
; i₁ = A×B.π₁
; i₂ = A×B.π₂
; [_,_] = A×B.⟨_,_⟩
; inject₁ = A×B.project₁
; inject₂ = A×B.project₂
; unique = A×B.unique
}
where
module A×B = Product A×B
private
coIsTerminal⟺IsInitial : ∀ {X} (⊥ : IsInitial X) →
coIsTerminal⇒IsInitial (IsInitial⇒coIsTerminal ⊥) ≡ ⊥
coIsTerminal⟺IsInitial _ = ≡.refl
IsInitial⟺coIsTerminal : ∀ {X} (⊤ : IsTerminal X) →
IsInitial⇒coIsTerminal (coIsTerminal⇒IsInitial ⊤) ≡ ⊤
IsInitial⟺coIsTerminal _ = ≡.refl
⊥⟺op⊤ : (⊤ : Terminal) → ⊥⇒op⊤ (op⊤⇒⊥ ⊤) ≡ ⊤
⊥⟺op⊤ _ = ≡.refl
op⊤⟺⊥ : (⊥ : Initial) → op⊤⇒⊥ (⊥⇒op⊤ ⊥) ≡ ⊥
op⊤⟺⊥ _ = ≡.refl
Coproduct⟺coProduct : ∀ {A B} (p : Product A B) → Coproduct⇒coProduct (coProduct⇒Coproduct p) ≡ p
Coproduct⟺coProduct _ = ≡.refl
coProduct⟺Coproduct : ∀ {A B} (p : Coproduct A B) → coProduct⇒Coproduct (Coproduct⇒coProduct p) ≡ p
coProduct⟺Coproduct _ = ≡.refl
|
Transynther/x86/_processed/NONE/_un_/i9-9900K_12_0xa0.log_21829_485.asm
|
ljhsiun2/medusa
| 9 |
81693
|
.global s_prepare_buffers
s_prepare_buffers:
push %r12
push %r13
push %r14
push %r15
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x1401c, %r12
and $30714, %r14
mov $0x6162636465666768, %r13
movq %r13, %xmm6
movups %xmm6, (%r12)
nop
nop
nop
nop
nop
cmp %r15, %r15
lea addresses_UC_ht+0xadf8, %rsi
lea addresses_D_ht+0x52a0, %rdi
nop
nop
add %rbx, %rbx
mov $17, %rcx
rep movsl
sub %rdi, %rdi
lea addresses_normal_ht+0x19070, %r15
nop
nop
nop
nop
cmp %r14, %r14
mov (%r15), %rbx
nop
nop
nop
nop
nop
add %r12, %r12
lea addresses_WC_ht+0x5a70, %rdi
dec %rbx
mov $0x6162636465666768, %r14
movq %r14, %xmm6
vmovups %ymm6, (%rdi)
nop
nop
nop
nop
nop
dec %r12
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r14
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r15
push %r8
push %rax
push %rcx
// Store
lea addresses_US+0x1f155, %r13
nop
nop
nop
nop
add $30606, %r15
movb $0x51, (%r13)
nop
xor %rax, %rax
// Store
lea addresses_PSE+0x131a8, %r8
nop
add $53761, %r15
mov $0x5152535455565758, %r10
movq %r10, (%r8)
nop
nop
nop
cmp $39050, %r13
// Store
lea addresses_normal+0x2772, %rax
add %r11, %r11
movb $0x51, (%rax)
nop
nop
nop
xor %r10, %r10
// Faulty Load
lea addresses_WT+0x1870, %r10
nop
nop
nop
dec %rax
movb (%r10), %r15b
lea oracles, %r13
and $0xff, %r15
shlq $12, %r15
mov (%r13,%r15,1), %r15
pop %rcx
pop %rax
pop %r8
pop %r15
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_WT', 'AVXalign': False, 'size': 16}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': True, 'same': False, 'congruent': 0, 'type': 'addresses_US', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': True, 'same': False, 'congruent': 3, 'type': 'addresses_PSE', 'AVXalign': False, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_normal', 'AVXalign': False, 'size': 1}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_WT', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 16}}
{'src': {'same': False, 'congruent': 3, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 11, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 8}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 9, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 32}}
{'a0': 21829}
a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0 a0
*/
|
src/PJ/fileio/dossetdr.asm
|
AnimatorPro/Animator-Pro
| 119 |
88432
|
<reponame>AnimatorPro/Animator-Pro
EXTRN pj_dget_err:word
CGROUP group code
code segment dword 'CODE'
assume cs:CGROUP,ds:CGROUP
include errcodes.i
public lo_dos_set_drive
;int lo_dos_set_drive(int drive); /* 0 = A: 1 = B: .. */
; returns 0 if ok < 0 if error */
; Unfortunately (due to bug in Phar Lap??) if drive is A: or B:,
; this will return an error when it really shouldn't. Work around
; is a layer on top which checks to make sure we made it to the
; device in this case.
lo_dos_set_drive proc near
jsdp struc
jsd_edx dd ?
jsd_ret dd ?
jsd_drive dd ?
jsdp ends
push edx
mov edx,[esp].jsd_drive
mov ah,0eh
int 21h
jc jsdrbad
mov eax,success
jmp jsdrend
jsdrbad:
call near ptr pj_dget_err
jsdrend:
pop edx
ret
lo_dos_set_drive endp
code ends
end
|
programs/oeis/250/A250354.asm
|
jmorken/loda
| 1 |
15382
|
<filename>programs/oeis/250/A250354.asm
; A250354: Number of length 5 arrays x(i), i=1..5 with x(i) in i..i+n and no value appearing more than 2 times.
; 32,216,888,2724,6900,15186,30072,54888,93924,152550,237336,356172,518388,734874,1018200,1382736,1844772,2422638,3136824,4010100,5067636,6337122,7848888,9636024,11734500,14183286,17024472,20303388,24068724
mov $2,2
mov $3,$0
lpb $0
add $0,2
mul $0,2
add $2,$0
mov $0,1
lpe
mov $1,$2
add $1,30
mov $4,$3
mov $7,78
lpb $7
add $1,$4
sub $7,1
lpe
mov $6,$3
lpb $6
add $5,$4
sub $6,1
lpe
mov $4,$5
mov $7,65
lpb $7
add $1,$4
sub $7,1
lpe
mov $5,0
mov $6,$3
lpb $6
add $5,$4
sub $6,1
lpe
mov $4,$5
mov $7,30
lpb $7
add $1,$4
sub $7,1
lpe
mov $5,0
mov $6,$3
lpb $6
add $5,$4
sub $6,1
lpe
mov $4,$5
mov $7,10
lpb $7
add $1,$4
sub $7,1
lpe
mov $5,0
mov $6,$3
lpb $6
add $5,$4
sub $6,1
lpe
mov $4,$5
mov $7,1
lpb $7
add $1,$4
sub $7,1
lpe
|
Palmtree.Math.Core.Sint/vs_build/x64_Release/dllmain.asm
|
rougemeilland/Palmtree.Math.Core.Sint
| 0 |
513
|
; Listing generated by Microsoft (R) Optimizing Compiler Version 19.16.27026.1
include listing.inc
INCLUDELIB OLDNAMES
PUBLIC DllMain
; COMDAT pdata
pdata SEGMENT
$pdata$DllMain DD imagerel $LN22@DllMain
DD imagerel $LN22@DllMain+107
DD imagerel $unwind$DllMain
; COMDAT xdata
xdata SEGMENT
$unwind$DllMain DD 010401H
DD 04204H
xdata ENDS
END
|
linux64/lesson05.asm
|
mashingan/notes-asmtutor
| 1 |
20098
|
format ELF64 executable 3
entry start
segment readable writeable
msg db 'Hello the brave to the isekai!', 0Ah, 0
msgf db 'Adapt to the new environment with FASM.', 0Ah, 0
segment readable executable
start:
mov rax, msg
call sprint
mov rax, msgf
call sprint
call quitProgram
include 'procs.inc'
|
Cubical/HITs/Modulo.agda
|
limemloh/cubical
| 0 |
13350
|
<filename>Cubical/HITs/Modulo.agda
{-# OPTIONS --cubical --safe #-}
module Cubical.HITs.Modulo where
open import Cubical.HITs.Modulo.Base public
open import Cubical.HITs.Modulo.Properties public
|
programs/oeis/135/A135984.asm
|
neoneye/loda
| 22 |
13270
|
<filename>programs/oeis/135/A135984.asm<gh_stars>10-100
; A135984: a(n) = 24(prime(n))+7.
; 55,79,127,175,271,319,415,463,559,703,751,895,991,1039,1135,1279,1423,1471,1615,1711,1759,1903,1999,2143,2335,2431,2479,2575,2623,2719,3055,3151,3295,3343,3583,3631,3775,3919,4015,4159,4303,4351,4591,4639,4735
seq $0,6005 ; The odd prime numbers together with 1.
max $0,2
sub $0,2
mul $0,24
add $0,55
|
TestData/multiple_results.asm
|
robertmuth/Cwerg
| 171 |
97759
|
<reponame>robertmuth/Cwerg
# demonstrates multiple return values
# ========================================
# function with 5 return values
.fun multi NORMAL [U32 U32 U32 U32 U32] = [U32 U32]
.reg U32 [a b add sub mul div mod]
.bbl start
poparg a
poparg b
add add = a b
sub sub = a b
mul mul = a b
div div = a b
rem mod = a b
pusharg mod
pusharg div
pusharg mul
pusharg sub
pusharg add
ret
# function with heterogeneous return values
.fun hetero NORMAL [S8 S16 S32 U8 U16 U32] = []
.bbl start
pusharg 0:U32
pusharg 1:U16
pusharg 2:U8
pusharg -3:S32
pusharg -4:S16
pusharg -5:S8
ret
# ========================================
.fun main NORMAL [S32] = []
.reg U32 [a s m d M x y]
.bbl start
pusharg 6:U32
pusharg 70:U32
bsr multi
poparg a
poparg s
poparg m
poparg d
poparg M
pusharg a
bsr print_u_ln
pusharg s
bsr print_u_ln
pusharg m
bsr print_u_ln
pusharg d
bsr print_u_ln
pusharg M
bsr print_u_ln
###
bsr hetero
poparg s8:S8
poparg s16:S16
poparg s32:S32
poparg u8:U8
poparg u16:U16
poparg u32:U32
conv ss:S32 s8
pusharg ss
bsr print_d_ln
conv ss s16
pusharg ss
bsr print_d_ln
pusharg s32
bsr print_d_ln
conv uu:U32 u8
pusharg uu
bsr print_u_ln
conv uu u16
pusharg uu
bsr print_u_ln
pusharg u32
bsr print_u_ln
pusharg 0:S32
ret
|
src/asis/a4g-knd_conv.ads
|
My-Colaborations/dynamo
| 15 |
7972
|
<reponame>My-Colaborations/dynamo<gh_stars>10-100
------------------------------------------------------------------------------
-- --
-- ASIS-for-GNAT IMPLEMENTATION COMPONENTS --
-- --
-- A 4 G . K N D _ C O N V --
-- --
-- S p e c --
-- --
-- Copyright (C) 1995-2011, Free Software Foundation, Inc. --
-- --
-- ASIS-for-GNAT is free software; you can redistribute it and/or modify it --
-- under terms of the GNU General Public License as published by the Free --
-- Software Foundation; either version 2, or (at your option) any later --
-- version. ASIS-for-GNAT is distributed in the hope that it will be use- --
-- ful, but WITHOUT ANY WARRANTY; without even the implied warranty of MER- --
-- CHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General --
-- Public License for more details. You should have received a copy of the --
-- GNU General Public License distributed with ASIS-for-GNAT; see file --
-- COPYING. If not, write to the Free Software Foundation, 51 Franklin --
-- Street, Fifth Floor, Boston, MA 02110-1301, USA. --
-- --
-- --
-- --
-- --
-- --
-- --
-- --
-- --
-- ASIS-for-GNAT was originally developed by the ASIS-for-GNAT team at the --
-- Software Engineering Laboratory of the Swiss Federal Institute of --
-- Technology (LGL-EPFL) in Lausanne, Switzerland, in cooperation with the --
-- Scientific Research Computer Center of Moscow State University (SRCC --
-- MSU), Russia, with funding partially provided by grants from the Swiss --
-- National Science Foundation and the Swiss Academy of Engineering --
-- Sciences. ASIS-for-GNAT is now maintained by AdaCore --
-- (http://www.adac<EMAIL>). --
-- --
------------------------------------------------------------------------------
with Asis;
with A4G.Int_Knds; use A4G.Int_Knds;
package A4G.Knd_Conv is
--------------------------------------
-- Element Classification Functions --
--------------------------------------
-- The following functions convert the Internal Element Kind value
-- given as their argument into the corresponding value of the
-- corresponding Asis Element Classification subordinate kind.
-- Not_A_XXX is returned if the argument does not belong to the
-- corresponding internal classification subtype.
function Asis_From_Internal_Kind
(Internal_Kind : Internal_Element_Kinds)
return Asis.Element_Kinds;
function Pragma_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Pragma_Kinds;
function Defining_Name_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Defining_Name_Kinds;
function Declaration_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Declaration_Kinds;
function Definition_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Definition_Kinds;
function Type_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Type_Kinds;
function Formal_Type_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Formal_Type_Kinds;
function Access_Type_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Access_Type_Kinds;
function Root_Type_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Root_Type_Kinds;
-- --|A2005 start
function Access_Definition_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Access_Definition_Kinds;
function Interface_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Interface_Kinds;
-- --|A2005 end
function Constraint_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Constraint_Kinds;
function Discrete_Range_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Discrete_Range_Kinds;
function Expression_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Expression_Kinds;
function Operator_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Operator_Kinds;
function Attribute_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Attribute_Kinds;
function Association_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Association_Kinds;
function Statement_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Statement_Kinds;
function Path_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Path_Kinds;
function Clause_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Clause_Kinds;
function Representation_Clause_Kind_From_Internal
(Internal_Kind : Internal_Element_Kinds)
return Asis.Representation_Clause_Kinds;
-------------------------------------
-- Additional Classification items --
-------------------------------------
function Def_Operator_Kind
(Op_Kind : Internal_Element_Kinds)
return Internal_Element_Kinds;
-- this function "converts" the value of Internal_Operator_Symbol_Kinds
-- into the corresponding value of Internal_Defining_Operator_Kinds
-- It is an error to call it to an Internal_Element_Kinds value which
-- does not belong to Internal_Operator_Symbol_Kinds
end A4G.Knd_Conv;
|
ADA_RC_Car/src/sensor_behind.adb
|
Intelligente-sanntidssystemer/Ada-prosjekt
| 0 |
3606
|
<gh_stars>0
with NRF52_DK.Time;
with HAL; use HAL;
with NRF52_DK.IOs;
package body sensor_behind is
--Declaration of the PinIDs and type of the variables
TrigPin : NRF52_DK.IOs.Pin_Id := 12;
EchoPin : NRF52_DK.IOs.Pin_Id := 11;
CurrentTime : NRF52_DK.Time.Time_Ms;
Duration_Result : Duration;
Pulse : Boolean;
function HCSR04_Behind_Distance return Float is
begin
CurrentTime := NRF52_DK.Time.Clock;
--Making sure the TrigPin is clear so we set it on false for 2 microseconds.
NRF52_DK.IOs.Set(TrigPin, False);
NRF52_DK.Time.Delay_Ms(Uint64(CurrentTime / 1000) + UInt64 (2 / 1000));
CurrentTime := NRF52_DK.Time.Clock;
--To generate the ultra sound wave we have to set the TrigPin on high/true state for 10 microseconds.
NRF52_DK.IOs.Set(TrigPin, True);
NRF52_DK.Time.Delay_Ms (Uint64(CurrentTime / 1000) +UInt64 (10 / 1000));
NRF52_DK.IOs.Set(TrigPin, False);
--We need to make sure there isn't any interrupts between these parts
Pulse := NRF52_DK.IOs.Set(EchoPin);
--Returns duration when EchoPin is HIGH.
if NRF52_DK.IOs.Set(EchoPin) = True then
CurrentTime := NRF52_DK.Time.Clock;
--Supposed to return make the result into a duration but due to
--NRF52_DK packages not having a function for that and Ada.Real_time not working, we couldn't make the code function properly.
Duration_Result := Ada.Real_Time.To_Duration(NRF52_DK.Time.Clock - CurrentTime);
return (Float(Duration_Result) / 58.0) * 1000000.0;
--In order to get the distance we will divide the Duration_Result with 58
--and then multiply it with 1000000 which turns the microseconds into seconds.
end if;
return -1.0;
end HCSR04_Behind_Distance;
--Source: https://github.com/gamegine/HCSR04-ultrasonic-sensor-lib/blob/master/src/HCSR04.cpp
end sensor_behind;
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xa0_notsx.log_21829_302.asm
|
ljhsiun2/medusa
| 9 |
102765
|
<gh_stars>1-10
.global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r14
push %r8
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0xc09d, %rbx
clflush (%rbx)
nop
nop
nop
nop
nop
xor %r14, %r14
movb (%rbx), %r13b
nop
nop
nop
and $27859, %rcx
lea addresses_normal_ht+0x18d9d, %rsi
lea addresses_UC_ht+0x1981d, %rdi
nop
nop
nop
nop
sub %rbp, %rbp
mov $72, %rcx
rep movsb
add %rdi, %rdi
lea addresses_A_ht+0x18d9d, %rbp
nop
nop
nop
nop
add %r14, %r14
mov (%rbp), %di
nop
xor $43504, %r14
lea addresses_normal_ht+0x1075d, %rdi
nop
sub $18145, %rcx
mov (%rdi), %rbp
nop
nop
dec %rbx
lea addresses_WT_ht+0xd59d, %rsi
lea addresses_A_ht+0x1becd, %rdi
nop
inc %r8
mov $22, %rcx
rep movsq
nop
nop
nop
cmp %rbp, %rbp
lea addresses_A_ht+0x1dafd, %rsi
lea addresses_D_ht+0x1db9d, %rdi
nop
nop
sub $28029, %rbx
mov $1, %rcx
rep movsb
inc %rsi
lea addresses_WC_ht+0x459d, %rsi
lea addresses_WC_ht+0x1086d, %rdi
clflush (%rsi)
clflush (%rdi)
nop
nop
nop
nop
xor %r13, %r13
mov $123, %rcx
rep movsw
xor $33967, %rsi
lea addresses_UC_ht+0x639d, %rsi
clflush (%rsi)
nop
nop
nop
nop
cmp %r13, %r13
movl $0x61626364, (%rsi)
nop
xor %rcx, %rcx
lea addresses_normal_ht+0x2e1d, %rbp
add %rdi, %rdi
movl $0x61626364, (%rbp)
nop
nop
sub %rdi, %rdi
lea addresses_WC_ht+0x13d1d, %r14
nop
nop
nop
nop
nop
add %r13, %r13
mov (%r14), %ebp
nop
nop
lfence
lea addresses_WT_ht+0x2b12, %rsi
lea addresses_WC_ht+0xcd9d, %rdi
nop
nop
nop
add $11348, %r8
mov $81, %rcx
rep movsl
nop
nop
nop
nop
nop
xor %rcx, %rcx
lea addresses_UC_ht+0xb66d, %rsi
lea addresses_WC_ht+0x1085d, %rdi
inc %rbx
mov $104, %rcx
rep movsb
nop
nop
and %r8, %r8
lea addresses_WT_ht+0x5d9d, %r14
cmp $57839, %rdi
movb (%r14), %cl
nop
nop
nop
nop
xor %r14, %r14
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r8
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r8
push %rax
push %rdi
push %rdx
push %rsi
// Store
lea addresses_normal+0x5d9d, %r10
sub %r11, %r11
mov $0x5152535455565758, %rsi
movq %rsi, %xmm7
movups %xmm7, (%r10)
nop
xor %r11, %r11
// Faulty Load
lea addresses_normal+0x5d9d, %rdi
nop
nop
nop
nop
and $58454, %r8
vmovups (%rdi), %ymm7
vextracti128 $1, %ymm7, %xmm7
vpextrq $1, %xmm7, %r11
lea oracles, %rdi
and $0xff, %r11
shlq $12, %r11
mov (%rdi,%r11,1), %r11
pop %rsi
pop %rdx
pop %rdi
pop %rax
pop %r8
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 16, 'NT': True, 'same': False, 'congruent': 0}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal', 'AVXalign': False, 'size': 16, 'NT': False, 'same': True, 'congruent': 0}}
[Faulty Load]
{'src': {'type': 'addresses_normal', 'AVXalign': False, 'size': 32, 'NT': False, 'same': True, 'congruent': 0}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': False, 'congruent': 7}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}}
{'src': {'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2, 'NT': False, 'same': False, 'congruent': 11}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 8, 'NT': False, 'same': False, 'congruent': 5}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 11, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 4, 'same': True}}
{'src': {'type': 'addresses_A_ht', 'congruent': 5, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 9, 'same': False}}
{'src': {'type': 'addresses_WC_ht', 'congruent': 9, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_UC_ht', 'AVXalign': True, 'size': 4, 'NT': False, 'same': False, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 4, 'NT': False, 'same': False, 'congruent': 7}}
{'src': {'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 4, 'NT': True, 'same': False, 'congruent': 5}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': False}}
{'src': {'type': 'addresses_UC_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': False}}
{'src': {'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 1, 'NT': False, 'same': True, 'congruent': 5}, 'OP': 'LOAD'}
{'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
*/
|
boards/stm32f469_discovery/src/framebuffer_otm8009a.ads
|
morbos/Ada_Drivers_Library
| 2 |
11164
|
------------------------------------------------------------------------------
-- --
-- Copyright (C) 2015-2016, 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; use HAL;
with HAL.Framebuffer; use HAL.Framebuffer;
with HAL.Bitmap;
with Ravenscar_Time;
private with STM32.Device;
private with STM32.DMA2D_Bitmap;
private with STM32.LTDC;
private with OTM8009A;
private with HAL.DSI;
package Framebuffer_OTM8009A is
LCD_Natural_Width : constant := 800;
LCD_Natural_Height : constant := 480;
type Frame_Buffer is limited
new HAL.Framebuffer.Frame_Buffer_Display with private;
overriding function Max_Layers
(Display : Frame_Buffer) return Positive;
overriding function Supported
(Display : Frame_Buffer;
Mode : HAL.Framebuffer.FB_Color_Mode) return Boolean;
procedure Initialize
(Display : in out Frame_Buffer;
Orientation : HAL.Framebuffer.Display_Orientation := Default;
Mode : HAL.Framebuffer.Wait_Mode := Interrupt);
overriding function Initialized
(Display : Frame_Buffer) return Boolean;
overriding procedure Set_Orientation
(Display : in out Frame_Buffer;
Orientation : HAL.Framebuffer.Display_Orientation);
overriding procedure Set_Mode
(Display : in out Frame_Buffer;
Mode : HAL.Framebuffer.Wait_Mode);
overriding function Width
(Display : Frame_Buffer) return Positive;
overriding function Height
(Display : Frame_Buffer) return Positive;
overriding function Swapped
(Display : Frame_Buffer) return Boolean;
overriding procedure Set_Background
(Display : Frame_Buffer; R, G, B : UInt8);
overriding procedure Initialize_Layer
(Display : in out Frame_Buffer;
Layer : Positive;
Mode : HAL.Framebuffer.FB_Color_Mode;
X : Natural := 0;
Y : Natural := 0;
Width : Positive := Positive'Last;
Height : Positive := Positive'Last);
-- All layers are double buffered, so an explicit call to Update_Layer
-- needs to be performed to actually display the current buffer attached
-- to the layer.
-- Alloc is called to create the actual buffer.
overriding function Initialized
(Display : Frame_Buffer;
Layer : Positive) return Boolean;
overriding procedure Update_Layer
(Display : in out Frame_Buffer;
Layer : Positive;
Copy_Back : Boolean := False);
-- Updates the layer so that the hidden buffer is displayed.
-- If Copy_Back is set, then the newly displayed buffer will be copied back
-- the the hidden buffer
overriding procedure Update_Layers
(Display : in out Frame_Buffer);
-- Updates all initialized layers at once with their respective hidden
-- buffer
overriding function Color_Mode
(Display : Frame_Buffer;
Layer : Positive) return HAL.Framebuffer.FB_Color_Mode;
overriding function Hidden_Buffer
(Display : in out Frame_Buffer;
Layer : Positive) return not null HAL.Bitmap.Any_Bitmap_Buffer;
-- Retrieves the current hidden buffer for the layer.
overriding function Pixel_Size
(Display : Frame_Buffer;
Layer : Positive) return Positive;
private
type FB_Array is array (STM32.LTDC.LCD_Layer) of
aliased STM32.DMA2D_Bitmap.DMA2D_Bitmap_Buffer;
LCD_Channel : constant HAL.DSI.DSI_Virtual_Channel_ID := 0;
-- Only one display on this board, constant to 0
type Frame_Buffer is limited new HAL.Framebuffer.Frame_Buffer_Display with
record
Device : OTM8009A.OTM8009A_Device
(DSI_Host => STM32.Device.DSIHOST'Access,
Channel_Id => LCD_Channel,
Time => Ravenscar_Time.Delays);
Swapped : Boolean;
Buffers : FB_Array := (others => STM32.DMA2D_Bitmap.Null_Buffer);
end record;
type Frame_Buffer_Ref is access all Frame_Buffer;
end Framebuffer_OTM8009A;
|
programs/oeis/213/A213832.asm
|
karttu/loda
| 1 |
102553
|
<reponame>karttu/loda<gh_stars>1-10
; A213832: Principal diagonal of the convolution array A213831.
; 1,19,78,202,415,741,1204,1828,2637,3655,4906,6414,8203,10297,12720,15496,18649,22203,26182,30610,35511,40909,46828,53292,60325,67951,76194,85078,94627,104865,115816,127504,139953,153187,167230,182106,197839,214453,231972,250420,269821,290199,311578,333982,357435,381961,407584,434328,462217,491275,521526,552994,585703,619677,654940,691516,729429,768703,809362,851430,894931,939889,986328,1034272,1083745,1134771,1187374,1241578,1297407,1354885,1414036,1474884,1537453,1601767,1667850,1735726,1805419,1876953,1950352,2025640,2102841,2181979,2263078,2346162,2431255,2518381,2607564,2698828,2792197,2887695,2985346,3085174,3187203,3291457,3397960,3506736,3617809,3731203,3846942,3965050,4085551,4208469,4333828,4461652,4591965,4724791,4860154,4998078,5138587,5281705,5427456,5575864,5726953,5880747,6037270,6196546,6358599,6523453,6691132,6861660,7035061,7211359,7390578,7572742,7757875,7946001,8137144,8331328,8528577,8728915,8932366,9138954,9348703,9561637,9777780,9997156,10219789,10445703,10674922,10907470,11143371,11382649,11625328,11871432,12120985,12374011,12630534,12890578,13154167,13421325,13692076,13966444,14244453,14526127,14811490,15100566,15393379,15689953,15990312,16294480,16602481,16914339,17230078,17549722,17873295,18200821,18532324,18867828,19207357,19550935,19898586,20250334,20606203,20966217,21330400,21698776,22071369,22448203,22829302,23214690,23604391,23998429,24396828,24799612,25206805,25618431,26034514,26455078,26880147,27309745,27743896,28182624,28625953,29073907,29526510,29983786,30445759,30912453,31383892,31860100,32341101,32826919,33317578,33813102,34313515,34818841,35329104,35844328,36364537,36889755,37420006,37955314,38495703,39041197,39591820,40147596,40708549,41274703,41846082,42422710,43004611,43591809,44184328,44782192,45385425,45994051,46608094,47227578,47852527,48482965,49118916,49760404,50407453,51060087,51718330,52382206,53051739,53726953,54407872,55094520,55786921,56485099,57189078,57898882,58614535,59336061,60063484,60796828,61536117,62281375
mov $1,$0
pow $1,2
sub $1,$0
div $1,2
add $1,1
mov $3,$0
mul $3,6
add $1,$3
mov $2,$0
mul $2,$0
mov $3,$2
mul $3,8
add $1,$3
mul $2,$0
mov $3,$2
mul $3,4
add $1,$3
|
tests/data_unsized/6.asm
|
NullMember/customasm
| 414 |
84862
|
<reponame>NullMember/customasm<gh_stars>100-1000
#d (0x12 + 0x34)`16 ; = 0x0046
|
other.7z/SFC.7z/SFC/ソースデータ/ゼルダの伝説神々のトライフォース/フランス_NES/N_F_asm/zel_code.asm
|
prismotizm/gigaleak
| 0 |
81363
|
<reponame>prismotizm/gigaleak<filename>other.7z/SFC.7z/SFC/ソースデータ/ゼルダの伝説神々のトライフォース/フランス_NES/N_F_asm/zel_code.asm
Name: zel_code.asm
Type: file
Size: 18646
Last-Modified: '2016-05-13T04:22:15Z'
SHA-1: A6425ABB9DEB17C66A619E2351C0A3E56BEF5D8B
Description: null
|
programs/oeis/218/A218470.asm
|
neoneye/loda
| 22 |
89045
|
; A218470: Partial sums of floor(n/9).
; 0,0,0,0,0,0,0,0,0,1,2,3,4,5,6,7,8,9,11,13,15,17,19,21,23,25,27,30,33,36,39,42,45,48,51,54,58,62,66,70,74,78,82,86,90,95,100,105,110,115,120,125,130,135,141,147,153,159,165,171,177,183,189,196,203,210,217,224,231,238,245,252,260,268,276,284,292,300,308,316,324,333,342,351,360,369,378,387,396,405,415,425,435,445,455,465,475,485,495,506
lpb $0
sub $0,8
add $1,$0
sub $0,1
lpe
mov $0,$1
|
s1/sfx-original/SndCF - Signpost.asm
|
Cancer52/flamedriver
| 9 |
162994
|
<gh_stars>1-10
SndCF_Signpost_Header:
smpsHeaderStartSong 1
smpsHeaderVoice SndCF_Signpost_Voices
smpsHeaderTempoSFX $01
smpsHeaderChanSFX $02
smpsHeaderSFXChannel cFM4, SndCF_Signpost_FM4, $27, $03
smpsHeaderSFXChannel cFM5, SndCF_Signpost_FM5, $27, $00
; FM4 Data
SndCF_Signpost_FM4:
dc.b nRst, $04
; FM5 Data
SndCF_Signpost_FM5:
smpsSetvoice $00
SndCF_Signpost_Loop00:
dc.b nEb4, $05
smpsAlterVol $02
smpsLoop $00, $15, SndCF_Signpost_Loop00
smpsStop
SndCF_Signpost_Voices:
; Voice $00
; $F4
; $06, $04, $0F, $0E, $1F, $1F, $1F, $1F, $00, $00, $0B, $0B
; $00, $00, $05, $08, $0F, $0F, $FF, $FF, $0C, $8B, $03, $80
smpsVcAlgorithm $04
smpsVcFeedback $06
smpsVcUnusedBits $03
smpsVcDetune $00, $00, $00, $00
smpsVcCoarseFreq $0E, $0F, $04, $06
smpsVcRateScale $00, $00, $00, $00
smpsVcAttackRate $1F, $1F, $1F, $1F
smpsVcAmpMod $00, $00, $00, $00
smpsVcDecayRate1 $0B, $0B, $00, $00
smpsVcDecayRate2 $08, $05, $00, $00
smpsVcDecayLevel $0F, $0F, $00, $00
smpsVcReleaseRate $0F, $0F, $0F, $0F
smpsVcTotalLevel $00, $03, $0B, $0C
|
binaryToDecimal.asm
|
darrenyip/MipsCode
| 0 |
7099
|
li $v0, 5 #get user input
syscall
move $t0, $v0
li $t1, 2147483648 # mask 1000.....000000
li $t2, 31 # counter for all 16 digits binary numbers
li $t4, 1 #just an integer nummber 1
Loop:
and $t3, $t1, $t0 # save the number into t3
beq $t3, $zero, print #if t3 == zero print 0
addi $a0, $t4, 0 # else print number 1
li $v0, 1
syscall
srl $t1, $t1,1 #shift right 1
sub $t2, $t2, 1 #counter -1
j Loop
print:
sub $t2, $t2, 1 #counter -1
blt $t2, -1, exit # if counter is less than 01 then exit the program
srl $t1, $t1,1 #shift left 1
li $v0, 4 #print number 0
la $a0, print0
syscall
j Loop
exit:
li $v0, 10
syscall
.data
print1: .ascii "1"
print0: .ascii "0"
|
hott/equivalence/alternative.agda
|
HoTT/M-types
| 27 |
16903
|
<filename>hott/equivalence/alternative.agda
{-# OPTIONS --without-K #-}
open import function.extensionality.core
module hott.equivalence.alternative where
open import sum
open import equality.core
open import equality.calculus
open import function.core
open import function.extensionality.proof
open import function.isomorphism.core
open import function.isomorphism.coherent
open import function.isomorphism.utils
open import hott.level.core
open import hott.equivalence.core
open import hott.univalence
module _ {i j}{X : Set i}{Y : Set j} where
open ≅-Reasoning
private
we-split-iso : (f : X → Y) → _
we-split-iso f = begin
weak-equiv f
≅⟨ ΠΣ-swap-iso ⟩
( Σ ((y : Y) → f ⁻¹ y) λ gβ
→ (y : Y)(u : f ⁻¹ y) → gβ y ≡ u )
≅⟨ Σ-ap-iso₁ ΠΣ-swap-iso ⟩
( Σ (Σ (Y → X) λ g → (y : Y) → f (g y) ≡ y) λ { (g , β)
→ (y : Y)(u : f ⁻¹ y) → (g y , β y) ≡ u } )
≅⟨ Σ-assoc-iso ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (y : Y)(u : f ⁻¹ y) → (g y , β y) ≡ u )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Π-ap-iso refl≅ λ y
→ curry-iso (λ x p → (g y , β y) ≡ (x , p)) ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (y : Y)(x : X)(p : f x ≡ y)
→ (g y , β y) ≡ (x , p) )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Π-ap-iso refl≅ λ y
→ Π-ap-iso refl≅ λ x
→ Π-ap-iso refl≅ λ p
→ sym≅ Σ-split-iso ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (y : Y)(x : X)(p : f x ≡ y)
→ Σ (g y ≡ x) λ q
→ subst (λ x' → f x' ≡ y) q (β y) ≡ p )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Π-ap-iso refl≅ λ y
→ Π-ap-iso refl≅ λ x
→ Π-ap-iso refl≅ λ p
→ Σ-ap-iso₂ λ q
→ sym≅ ( trans≡-iso (
subst-naturality (λ x' → x' ≡ y) f q (β y)
· subst-eq (ap f q) (β y)) )) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (y : Y)(x : X)(p : f x ≡ y)
→ Σ (g y ≡ x) λ q
→ sym (ap f q) · β y ≡ p )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Π-comm-iso ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (x : X)(y : Y)(p : f x ≡ y)
→ Σ (g y ≡ x) λ q
→ sym (ap f q) · β y ≡ p )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Π-ap-iso refl≅ λ x
→ sym≅ J-iso ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ (x : X)
→ Σ (g (f x) ≡ x) λ q
→ sym (ap f q) · β (f x) ≡ refl )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ ΠΣ-swap-iso ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ Σ ((x : X) → g (f x) ≡ x) λ α
→ (x : X) → sym (ap f (α x)) · β (f x) ≡ refl )
≅⟨ ( Σ-ap-iso₂ λ g
→ Σ-ap-iso₂ λ β
→ Σ-ap-iso₂ λ α
→ Π-ap-iso refl≅ λ x
→ sym≅ (trans≅ (trans≡-iso (left-unit (ap f (α x))))
(move-≡-iso (ap f (α x)) refl (β (f x)))) ) ⟩
( Σ (Y → X) λ g
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ Σ ((x : X) → g (f x) ≡ x) λ α
→ (x : X) → ap f (α x) ≡ β (f x) )
≅⟨ ( Σ-ap-iso₂ λ g → Σ-comm-iso ) ⟩
( Σ (Y → X) λ g
→ Σ ((x : X) → g (f x) ≡ x) λ α
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ ((x : X) → ap f (α x) ≡ β (f x)) )
∎
≈⇔≅' : (X ≈ Y) ≅ (X ≅' Y)
≈⇔≅' = begin
(X ≈ Y)
≅⟨ Σ-ap-iso₂ we-split-iso ⟩
( Σ (X → Y) λ f
→ Σ (Y → X) λ g
→ Σ ((x : X) → g (f x) ≡ x) λ α
→ Σ ((y : Y) → f (g y) ≡ y) λ β
→ ((x : X) → ap f (α x) ≡ β (f x)) )
≅⟨ record
{ to = λ {(f , g , α , β , γ) → iso f g α β , γ }
; from = λ { (iso f g α β , γ) → f , g , α , β , γ }
; iso₁ = λ _ → refl
; iso₂ = λ _ → refl } ⟩
(X ≅' Y)
∎
open _≅_ ≈⇔≅' public using ()
renaming ( to to ≈⇒≅'
; from to ≅'⇒≈ )
≅⇒≈ : (X ≅ Y) → (X ≈ Y)
≅⇒≈ = ≅'⇒≈ ∘ ≅⇒≅'
|
libsrc/video/vdm/stdio/generic_console.asm
|
UnivEngineer/z88dk
| 1 |
24189
|
SECTION code_clib
PUBLIC generic_console_cls
PUBLIC generic_console_vpeek
PUBLIC generic_console_printc
PUBLIC generic_console_scrollup
PUBLIC generic_console_ioctl
PUBLIC generic_console_set_ink
PUBLIC generic_console_set_paper
PUBLIC generic_console_set_attribute
PUBLIC generic_console_plotc
PUBLIC generic_console_pointxy
EXTERN generic_console_flags
defc VDM_COLUMNS = 64
defc VDM_ROWS = 16
EXTERN VDM_DISPLAY
EXTERN VDM_CAPS
EXTERN VDM_CAPS_MASK
PUBLIC GRAPHICS_CHAR_SET
PUBLIC GRAPHICS_CHAR_UNSET
defc GRAPHICS_CHAR_SET = $80 + 32
defc GRAPHICS_CHAR_UNSET = 32
INCLUDE "ioctl.def"
PUBLIC CLIB_GENCON_CAPS
defc CLIB_GENCON_CAPS = VDM_CAPS
generic_console_ioctl:
scf
generic_console_set_ink:
generic_console_set_paper:
generic_console_set_attribute:
ret
generic_console_cls:
ld hl,VDM_DISPLAY
ld de,VDM_DISPLAY+1
ld bc,+(VDM_COLUMNS * VDM_ROWS) -1
ld (hl),32
ldir
ret
; c = x
; b = y
; a = d = character to print
; e = raw
generic_console_plotc:
call xypos
ld (hl),d
ret
generic_console_printc:
call xypos
ld a,(generic_console_flags)
and VDM_CAPS_MASK
jp z,add_bit
scf
add_bit:
ld a,0
rra
or d
ld (hl),a
ret
;Entry: c = x,
; b = y
; e = rawmode
;Exit: nc = success
; a = character,
; c = failure
generic_console_pointxy:
call xypos
ld a,(hl)
and a
ret
generic_console_vpeek:
call xypos
ld a,(hl)
and 127
ret
; b = row
; c = column
xypos:
ld l,b
ld h,0
add hl,hl
add hl,hl
add hl,hl
add hl,hl
add hl,hl
add hl,hl
ld b,+(VDM_DISPLAY / 256)
add hl,bc
ret
; There's actually a scroll register that we could use instead
; (similar to the vector06c one)
generic_console_scrollup:
push de
push bc
ld hl, VDM_DISPLAY + VDM_COLUMNS
ld de, VDM_DISPLAY
ld bc,+ ((VDM_COLUMNS) * (VDM_ROWS-1))
ldir
ex de,hl
ld b,VDM_COLUMNS
generic_console_scrollup_3:
ld (hl),32
inc hl
djnz generic_console_scrollup_3
pop bc
pop de
ret
SECTION code_crt_init
EXTERN __console_h
EXTERN __console_w
xor a
out (200),a ;Enable the board
ld a,VDM_ROWS
ld (__console_h),a
ld a,VDM_COLUMNS
ld (__console_w),a
|
test/Succeed/Issue1701b.agda
|
cruhland/agda
| 1,989 |
13528
|
<reponame>cruhland/agda<filename>test/Succeed/Issue1701b.agda
-- Andreas, 2015-11-10, issue reported by <NAME>
-- {-# OPTIONS -v scope.mod.inst:30 #-}
-- {-# OPTIONS -v tc.mod.check:10 -v tc.mod.apply:80 -v impossible:10 #-}
postulate
A : Set
a : A
module Id (A : Set) (a : A) where
x = a
module ModParamsToLoose (A : Set) where
private module M (a : A) where module I = Id A a
open M public
open ModParamsToLoose A
open I a
y : A
y = x
|
support/MinGW/lib/gcc/mingw32/9.2.0/adainclude/s-conca2.adb
|
orb-zhuchen/Orb
| 0 |
26042
|
<reponame>orb-zhuchen/Orb<gh_stars>0
------------------------------------------------------------------------------
-- --
-- GNAT RUN-TIME LIBRARY (GNARL) COMPONENTS --
-- --
-- S Y S T E M . C O N C A T _ 2 --
-- --
-- B o d y --
-- --
-- Copyright (C) 2008-2019, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
-- or FITNESS FOR A PARTICULAR PURPOSE. --
-- --
-- As a special exception under Section 7 of GPL version 3, you are granted --
-- additional permissions described in the GCC Runtime Library Exception, --
-- version 3.1, as published by the Free Software Foundation. --
-- --
-- You should have received a copy of the GNU General Public License and --
-- a copy of the GCC Runtime Library Exception along with this program; --
-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
pragma Compiler_Unit_Warning;
package body System.Concat_2 is
pragma Suppress (All_Checks);
------------------
-- Str_Concat_2 --
------------------
procedure Str_Concat_2 (R : out String; S1, S2 : String) is
F, L : Natural;
begin
F := R'First;
L := F + S1'Length - 1;
R (F .. L) := S1;
F := L + 1;
L := R'Last;
R (F .. L) := S2;
end Str_Concat_2;
-------------------------
-- Str_Concat_Bounds_2 --
-------------------------
procedure Str_Concat_Bounds_2
(Lo, Hi : out Natural;
S1, S2 : String)
is
begin
if S1 = "" then
Lo := S2'First;
Hi := S2'Last;
else
Lo := S1'First;
Hi := S1'Last + S2'Length;
end if;
end Str_Concat_Bounds_2;
end System.Concat_2;
|
awa/src/awa-commands-info.adb
|
My-Colaborations/ada-awa
| 81 |
955
|
<gh_stars>10-100
-----------------------------------------------------------------------
-- akt-commands-info -- Info command to describe the current configuration
-- Copyright (C) 2020 <NAME>
-- Written by <NAME> (<EMAIL>)
--
-- 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.
-----------------------------------------------------------------------
package body AWA.Commands.Info is
use type AWA.Modules.Module_Access;
-- ------------------------------
-- Print the configuration identified by the given name.
-- ------------------------------
procedure Print (Command : in out Command_Type;
Name : in String;
Value : in String;
Default : in String;
Context : in out Context_Type) is
pragma Unreferenced (Default);
Pos : Natural;
begin
Context.Console.Start_Row;
Context.Console.Print_Field (1, Name);
Pos := Value'First;
while Pos <= Value'Last loop
if Value'Last - Pos > Command.Value_Length then
Context.Console.Print_Field (2, Value (Pos .. Pos + Command.Value_Length - 1));
Pos := Pos + Command.Value_Length;
Context.Console.End_Row;
Context.Console.Start_Row;
Context.Console.Print_Field (1, "");
else
Context.Console.Print_Field (2, Value (Pos .. Value'Last));
Pos := Pos + Value'Length;
end if;
end loop;
Context.Console.End_Row;
end Print;
procedure Print (Command : in out Command_Type;
Application : in out AWA.Applications.Application'Class;
Name : in String;
Default : in String;
Context : in out Context_Type) is
Value : constant String := Application.Get_Init_Parameter (Name, Default);
begin
Command.Print (Name, Value, Default, Context);
end Print;
procedure Print (Command : in out Command_Type;
Module : in AWA.Modules.Module'Class;
Name : in String;
Default : in String;
Context : in out Context_Type) is
Value : constant String := Module.Get_Config (Name, Default);
begin
Command.Print (Module.Get_Name & "." & Name, Value, Default, Context);
end Print;
-- ------------------------------
-- Print the configuration about the application.
-- ------------------------------
overriding
procedure Execute (Command : in out Command_Type;
Application : in out AWA.Applications.Application'Class;
Args : in Argument_List'Class;
Context : in out Context_Type) is
pragma Unreferenced (Args);
Module : AWA.Modules.Module_Access;
begin
if Command.Long_List then
Command.Value_Length := Natural'Last;
end if;
Application.Load_Bundle (Name => "commands",
Locale => "en",
Bundle => Command.Bundle);
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Database configuration");
Context.Console.Notice (N_INFO, "----------------------");
Command.Print (Application, "database", "", Context);
Command.Print (Application, "ado.queries.paths", "", Context);
Command.Print (Application, "ado.queries.load", "", Context);
Command.Print (Application, "ado.drivers.load", "", Context);
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Server faces configuration");
Context.Console.Notice (N_INFO, "--------------------------");
Command.Print (Application, "view.dir",
ASF.Applications.DEF_VIEW_DIR, Context);
Command.Print (Application, "view.escape_unknown_tags",
ASF.Applications.DEF_ESCAPE_UNKNOWN_TAGS, Context);
Command.Print (Application, "view.ext",
ASF.Applications.DEF_VIEW_EXT, Context);
Command.Print (Application, "view.file_ext",
ASF.Applications.DEF_VIEW_FILE_EXT, Context);
Command.Print (Application, "view.ignore_spaces",
ASF.Applications.DEF_IGNORE_WHITE_SPACES, Context);
Command.Print (Application, "view.ignore_empty_lines",
ASF.Applications.DEF_IGNORE_EMPTY_LINES, Context);
Command.Print (Application, "view.static.dir",
ASF.Applications.DEF_STATIC_DIR, Context);
Command.Print (Application, "bundle.dir", "bundles", Context);
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "AWA Application");
Context.Console.Notice (N_INFO, "--------------------------");
Command.Print (Application, "app_name", "", Context);
Command.Print (Application, "app_search_dirs", ".", Context);
Command.Print (Application, "app.modules.dir", "", Context);
Command.Print (Application, "app_url_base", "", Context);
Command.Print (Application, "awa_url_host", "", Context);
Command.Print (Application, "awa_url_port", "", Context);
Command.Print (Application, "awa_url_scheme", "", Context);
Command.Print (Application, "app.config", "awa.xml", Context);
Command.Print (Application, "app.config.plugins", "", Context);
Command.Print (Application, "contextPath", "", Context);
Command.Print (Application, "awa_dispatcher_count", "", Context);
Command.Print (Application, "awa_dispatcher_priority", "", Context);
Module := Application.Find_Module ("users");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Users Module");
Context.Console.Notice (N_INFO, "------------");
Command.Print (Application, "openid.realm", "", Context);
Command.Print (Application, "openid.callback_url", "", Context);
Command.Print (Application, "openid.success_url", "", Context);
Command.Print (Application, "auth.url.orange", "", Context);
Command.Print (Application, "auth.provider.orange", "", Context);
Command.Print (Application, "auth.url.yahoo", "", Context);
Command.Print (Application, "auth.provider.yahoo", "", Context);
Command.Print (Application, "auth.url.google", "", Context);
Command.Print (Application, "auth.provider.google", "", Context);
Command.Print (Application, "auth.url.facebook", "", Context);
Command.Print (Application, "auth.provider.facebook", "", Context);
Command.Print (Application, "auth.url.google-plus", "", Context);
Command.Print (Application, "auth.provider.google-plus", "", Context);
Command.Print (Application, "facebook.callback_url", "", Context);
Command.Print (Application, "facebook.request_url", "", Context);
Command.Print (Application, "facebook.scope", "", Context);
Command.Print (Application, "facebook.client_id", "", Context);
Command.Print (Application, "facebook.secret", "", Context);
Command.Print (Application, "google-plus.issuer", "", Context);
Command.Print (Application, "google-plus.callback_url", "", Context);
Command.Print (Application, "google-plus.request_url", "", Context);
Command.Print (Application, "google-plus.scope", "", Context);
Command.Print (Application, "google-plus.client_id", "", Context);
Command.Print (Application, "google-plus.secret", "", Context);
Command.Print (Application, "auth-filter.redirect", "", Context);
Command.Print (Application, "verify-filter.redirect", "", Context);
Command.Print (Application, "users.auth_key", "", Context);
Command.Print (Application, "users.server_id", "", Context);
end if;
Module := Application.Find_Module ("mail");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Mail Module");
Context.Console.Notice (N_INFO, "-----------");
Command.Print (Application, "mail.smtp.host", "", Context);
Command.Print (Application, "mail.smtp.port", "", Context);
Command.Print (Application, "mail.smtp.enable", "true", Context);
Command.Print (Application, "mail.mailer", "smtp", Context);
Command.Print (Application, "mail.file.maildir", "mail", Context);
Command.Print (Application, "app_mail_name", "", Context);
Command.Print (Application, "app_mail_from", "", Context);
end if;
Module := Application.Find_Module ("workspaces");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Workspace Module");
Context.Console.Notice (N_INFO, "----------------");
Command.Print (Module.all, "permissions_list", "", Context);
Command.Print (Module.all, "allow_workspace_create", "", Context);
end if;
Module := Application.Find_Module ("storages");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Storage Module");
Context.Console.Notice (N_INFO, "--------------------------");
Command.Print (Module.all, "database_max_size", "100000", Context);
Command.Print (Module.all, "storage_root", "storage", Context);
Command.Print (Module.all, "tmp_storage_root", "tmp", Context);
Module := Application.Find_Module ("images");
if Module /= null then
Command.Print (Module.all, "thumbnail_command", "", Context);
end if;
end if;
Module := Application.Find_Module ("wikis");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Wiki Module");
Context.Console.Notice (N_INFO, "-----------");
Command.Print (Module.all, "image_prefix", "", Context);
Command.Print (Module.all, "page_prefix", "", Context);
Command.Print (Module.all, "wiki_copy_list", "", Context);
Module := Application.Find_Module ("wiki_previews");
if Module /= null then
Command.Print (Module.all, "wiki_preview_tmp", "tmp", Context);
Command.Print (Module.all, "wiki_preview_dir", "web/preview", Context);
Command.Print (Module.all, "wiki_preview_template", "", Context);
Command.Print (Module.all, "wiki_preview_html", "", Context);
Command.Print (Module.all, "wiki_preview_command", "", Context);
end if;
end if;
Module := Application.Find_Module ("counters");
if Module /= null then
Context.Console.Start_Title;
Context.Console.Print_Title (1, "", 30);
Context.Console.Print_Title (2, "", Command.Value_Length);
Context.Console.End_Title;
Context.Console.Notice (N_INFO, "Counter Module");
Context.Console.Notice (N_INFO, "--------------");
Command.Print (Module.all, "counter_age_limit", "300", Context);
Command.Print (Module.all, "counter_limit", "1000", Context);
end if;
end Execute;
-- ------------------------------
-- Setup the command before parsing the arguments and executing it.
-- ------------------------------
overriding
procedure Setup (Command : in out Command_Type;
Config : in out GNAT.Command_Line.Command_Line_Configuration;
Context : in out Context_Type) is
begin
GC.Set_Usage (Config => Config,
Usage => Command.Get_Name & " [arguments]",
Help => Command.Get_Description);
Command_Drivers.Application_Command_Type (Command).Setup (Config, Context);
GC.Define_Switch (Config => Config,
Output => Command.Long_List'Access,
Switch => "-l",
Long_Switch => "--long-lines",
Help => -("Use long lines to print configuration values"));
end Setup;
-- ------------------------------
-- Write the help associated with the command.
-- ------------------------------
overriding
procedure Help (Command : in out Command_Type;
Name : in String;
Context : in out Context_Type) is
pragma Unreferenced (Command, Context);
begin
null;
end Help;
begin
Command_Drivers.Driver.Add_Command ("info",
-("report configuration information"),
Command'Access);
end AWA.Commands.Info;
|
programs/oeis/077/A077071.asm
|
neoneye/loda
| 22 |
161054
|
<gh_stars>10-100
; A077071: Row sums of A077070.
; 0,2,8,16,30,46,66,88,118,150,186,224,268,314,364,416,478,542,610,680,756,834,916,1000,1092,1186,1284,1384,1490,1598,1710,1824,1950,2078,2210,2344,2484,2626,2772,2920,3076,3234,3396,3560,3730,3902,4078,4256
lpb $0
mov $2,$0
sub $0,1
lpb $2
add $1,$2
div $2,2
lpe
lpe
mul $1,2
mov $0,$1
|
P6/data_P6_2/cal_R_test28.asm
|
alxzzhou/BUAA_CO_2020
| 1 |
12198
|
lui $1,48726
ori $1,$1,63412
lui $2,20710
ori $2,$2,54310
lui $3,42262
ori $3,$3,46307
lui $4,6671
ori $4,$4,12379
lui $5,28632
ori $5,$5,13576
lui $6,49409
ori $6,$6,53768
mthi $1
mtlo $2
sec0:
nop
nop
nop
and $4,$6,$2
sec1:
nop
nop
xor $2,$5,$2
and $4,$6,$2
sec2:
nop
nop
xori $2,$6,48988
and $5,$6,$2
sec3:
nop
nop
mflo $2
and $4,$6,$2
sec4:
nop
nop
lhu $2,2($0)
and $3,$6,$2
sec5:
nop
or $2,$4,$3
nop
and $0,$6,$2
sec6:
nop
addu $2,$2,$5
sltu $2,$3,$4
and $0,$6,$2
sec7:
nop
subu $2,$3,$4
ori $2,$3,13862
and $3,$6,$2
sec8:
nop
xor $2,$0,$6
mfhi $2
and $0,$6,$2
sec9:
nop
xor $2,$5,$3
lh $2,0($0)
and $1,$6,$2
sec10:
nop
addiu $2,$4,3400
nop
and $4,$6,$2
sec11:
nop
xori $2,$1,2926
and $2,$2,$2
and $3,$6,$2
sec12:
nop
ori $2,$2,29419
andi $2,$3,36120
and $3,$6,$2
sec13:
nop
sltiu $2,$0,-10202
mflo $2
and $3,$6,$2
sec14:
nop
xori $2,$6,19777
lhu $2,2($0)
and $3,$6,$2
sec15:
nop
mflo $2
nop
and $5,$6,$2
sec16:
nop
mflo $2
sltu $2,$2,$1
and $3,$6,$2
sec17:
nop
mflo $2
lui $2,36943
and $2,$6,$2
sec18:
nop
mfhi $2
mflo $2
and $2,$6,$2
sec19:
nop
mflo $2
lbu $2,5($0)
and $2,$6,$2
sec20:
nop
lh $2,16($0)
nop
and $3,$6,$2
sec21:
nop
lhu $2,4($0)
slt $2,$2,$4
and $3,$6,$2
sec22:
nop
lw $2,0($0)
sltiu $2,$1,21854
and $5,$6,$2
sec23:
nop
lhu $2,6($0)
mflo $2
and $6,$6,$2
sec24:
nop
lb $2,2($0)
lh $2,8($0)
and $6,$6,$2
sec25:
slt $6,$2,$4
nop
nop
and $5,$6,$2
sec26:
nor $6,$4,$2
nop
or $2,$2,$4
and $1,$6,$2
sec27:
addu $6,$2,$3
nop
xori $2,$1,1333
and $3,$6,$2
sec28:
and $6,$3,$4
nop
mflo $2
and $1,$6,$2
sec29:
nor $6,$3,$3
nop
lb $2,15($0)
and $1,$6,$2
sec30:
and $6,$3,$2
and $2,$4,$6
nop
and $2,$6,$2
sec31:
xor $6,$3,$0
and $2,$4,$3
slt $2,$1,$3
and $4,$6,$2
sec32:
sltu $6,$5,$4
sltu $2,$5,$3
ori $2,$5,59825
and $3,$6,$2
sec33:
xor $6,$3,$4
or $2,$4,$2
mflo $2
and $5,$6,$2
sec34:
nor $6,$6,$5
or $2,$3,$3
lbu $2,3($0)
and $2,$6,$2
sec35:
xor $6,$1,$5
andi $2,$4,6287
nop
and $6,$6,$2
sec36:
sltu $6,$1,$2
ori $2,$5,54000
nor $2,$6,$2
and $4,$6,$2
sec37:
addu $6,$2,$2
sltiu $2,$5,13284
lui $2,19985
and $5,$6,$2
sec38:
sltu $6,$2,$1
andi $2,$3,40769
mfhi $2
and $2,$6,$2
sec39:
slt $6,$0,$2
slti $2,$2,3536
lb $2,1($0)
and $2,$6,$2
sec40:
subu $6,$3,$0
mfhi $2
nop
and $3,$6,$2
sec41:
addu $6,$6,$3
mfhi $2
addu $2,$2,$4
and $1,$6,$2
sec42:
subu $6,$4,$5
mfhi $2
andi $2,$5,1386
and $2,$6,$2
sec43:
subu $6,$2,$4
mfhi $2
mfhi $2
and $4,$6,$2
sec44:
subu $6,$2,$3
mflo $2
lw $2,4($0)
and $3,$6,$2
sec45:
and $6,$2,$2
lh $2,4($0)
nop
and $4,$6,$2
sec46:
or $6,$0,$2
lb $2,13($0)
and $2,$3,$1
and $5,$6,$2
sec47:
or $6,$1,$3
lb $2,3($0)
sltiu $2,$4,17317
and $1,$6,$2
sec48:
nor $6,$1,$3
lhu $2,6($0)
mfhi $2
and $3,$6,$2
sec49:
xor $6,$3,$2
lb $2,1($0)
lb $2,12($0)
and $3,$6,$2
sec50:
andi $6,$3,51265
nop
nop
and $2,$6,$2
sec51:
addiu $6,$4,-3797
nop
and $2,$5,$3
and $1,$6,$2
sec52:
lui $6,23737
nop
lui $2,37501
and $0,$6,$2
sec53:
lui $6,16639
nop
mflo $2
and $4,$6,$2
sec54:
addiu $6,$2,-31300
nop
lb $2,7($0)
and $6,$6,$2
sec55:
sltiu $6,$1,868
sltu $2,$3,$4
nop
and $3,$6,$2
sec56:
slti $6,$2,-1068
addu $2,$0,$4
subu $2,$0,$4
and $1,$6,$2
sec57:
lui $6,64883
xor $2,$2,$4
andi $2,$4,5513
and $4,$6,$2
sec58:
ori $6,$4,19650
or $2,$4,$4
mflo $2
and $3,$6,$2
sec59:
addiu $6,$6,-29471
sltu $2,$5,$3
lb $2,5($0)
and $5,$6,$2
sec60:
addiu $6,$1,21026
sltiu $2,$4,18504
nop
and $1,$6,$2
sec61:
xori $6,$0,28240
xori $2,$1,2915
xor $2,$1,$2
and $2,$6,$2
sec62:
slti $6,$4,22221
ori $2,$6,1105
ori $2,$6,30798
and $5,$6,$2
sec63:
andi $6,$3,6731
ori $2,$0,30706
mfhi $2
and $2,$6,$2
sec64:
ori $6,$3,58702
lui $2,54375
lbu $2,1($0)
and $3,$6,$2
sec65:
ori $6,$4,55652
mflo $2
nop
and $0,$6,$2
sec66:
lui $6,20919
mfhi $2
xor $2,$4,$4
and $1,$6,$2
sec67:
ori $6,$3,27287
mflo $2
addiu $2,$1,640
and $2,$6,$2
sec68:
andi $6,$3,15889
mflo $2
mfhi $2
and $4,$6,$2
sec69:
lui $6,4388
mflo $2
lbu $2,16($0)
and $5,$6,$2
sec70:
andi $6,$2,50841
lw $2,12($0)
nop
and $4,$6,$2
sec71:
slti $6,$2,15438
lb $2,12($0)
or $2,$1,$2
and $4,$6,$2
sec72:
addiu $6,$4,-9457
lhu $2,12($0)
sltiu $2,$3,-22885
and $3,$6,$2
sec73:
addiu $6,$2,-12146
lw $2,4($0)
mfhi $2
and $6,$6,$2
sec74:
addiu $6,$0,10476
lw $2,4($0)
lh $2,12($0)
and $3,$6,$2
sec75:
mfhi $6
nop
nop
and $4,$6,$2
sec76:
mfhi $6
nop
nor $2,$0,$1
and $2,$6,$2
sec77:
mflo $6
nop
andi $2,$3,59454
and $4,$6,$2
sec78:
mflo $6
nop
mflo $2
and $4,$6,$2
sec79:
mfhi $6
nop
lb $2,5($0)
and $4,$6,$2
sec80:
mflo $6
sltu $2,$4,$4
nop
and $5,$6,$2
sec81:
mfhi $6
slt $2,$1,$1
addu $2,$5,$1
and $6,$6,$2
sec82:
mflo $6
sltu $2,$3,$0
ori $2,$4,12287
and $3,$6,$2
sec83:
mflo $6
subu $2,$3,$3
mfhi $2
and $0,$6,$2
sec84:
mfhi $6
or $2,$0,$5
lhu $2,8($0)
and $4,$6,$2
sec85:
mflo $6
lui $2,27977
nop
and $0,$6,$2
sec86:
mfhi $6
ori $2,$2,12487
or $2,$5,$4
and $4,$6,$2
sec87:
mflo $6
andi $2,$4,28449
addiu $2,$3,-25098
and $5,$6,$2
sec88:
mflo $6
ori $2,$3,41740
mfhi $2
and $2,$6,$2
sec89:
mfhi $6
xori $2,$3,37484
lh $2,2($0)
and $3,$6,$2
sec90:
mfhi $6
mfhi $2
nop
and $1,$6,$2
sec91:
mflo $6
mflo $2
addu $2,$3,$3
and $6,$6,$2
sec92:
mflo $6
mfhi $2
sltiu $2,$4,30698
and $1,$6,$2
sec93:
mflo $6
mfhi $2
mfhi $2
and $3,$6,$2
sec94:
mfhi $6
mflo $2
lh $2,12($0)
and $2,$6,$2
sec95:
mflo $6
lhu $2,16($0)
nop
and $3,$6,$2
sec96:
mflo $6
lw $2,8($0)
and $2,$0,$5
and $5,$6,$2
sec97:
mflo $6
lw $2,16($0)
sltiu $2,$2,28779
and $2,$6,$2
sec98:
mfhi $6
lbu $2,14($0)
mflo $2
and $2,$6,$2
sec99:
mflo $6
lbu $2,2($0)
lw $2,8($0)
and $1,$6,$2
sec100:
lbu $6,13($0)
nop
nop
and $1,$6,$2
sec101:
lw $6,8($0)
nop
nor $2,$3,$4
and $4,$6,$2
sec102:
lb $6,12($0)
nop
ori $2,$3,65266
and $3,$6,$2
sec103:
lh $6,0($0)
nop
mfhi $2
and $0,$6,$2
sec104:
lh $6,8($0)
nop
lw $2,0($0)
and $5,$6,$2
sec105:
lbu $6,2($0)
subu $2,$4,$5
nop
and $3,$6,$2
sec106:
lw $6,8($0)
addu $2,$4,$3
nor $2,$3,$2
and $2,$6,$2
sec107:
lh $6,10($0)
addu $2,$1,$4
slti $2,$4,-5164
and $2,$6,$2
sec108:
lbu $6,3($0)
addu $2,$2,$4
mflo $2
and $1,$6,$2
sec109:
lbu $6,13($0)
nor $2,$2,$2
lw $2,0($0)
and $2,$6,$2
sec110:
lbu $6,12($0)
lui $2,64212
nop
and $5,$6,$2
sec111:
lhu $6,0($0)
andi $2,$4,12502
nor $2,$1,$3
and $5,$6,$2
sec112:
lbu $6,13($0)
lui $2,63074
ori $2,$2,28093
and $4,$6,$2
sec113:
lhu $6,10($0)
ori $2,$3,21781
mflo $2
and $1,$6,$2
sec114:
lh $6,6($0)
addiu $2,$2,4543
lw $2,0($0)
and $1,$6,$2
sec115:
lb $6,1($0)
mflo $2
nop
and $3,$6,$2
sec116:
lbu $6,16($0)
mflo $2
sltu $2,$1,$5
and $3,$6,$2
sec117:
lw $6,0($0)
mfhi $2
slti $2,$3,-16794
and $3,$6,$2
sec118:
lb $6,15($0)
mflo $2
mfhi $2
and $3,$6,$2
sec119:
lbu $6,7($0)
mflo $2
lw $2,0($0)
and $4,$6,$2
sec120:
lh $6,6($0)
lb $2,9($0)
nop
and $3,$6,$2
sec121:
lh $6,0($0)
lbu $2,9($0)
subu $2,$1,$3
and $1,$6,$2
sec122:
lbu $6,1($0)
lb $2,3($0)
ori $2,$5,17416
and $3,$6,$2
sec123:
lh $6,16($0)
lh $2,4($0)
mflo $2
and $1,$6,$2
sec124:
lh $6,16($0)
lw $2,0($0)
lbu $2,1($0)
and $1,$6,$2
|
oeis/173/A173856.asm
|
neoneye/loda-programs
| 11 |
994
|
<gh_stars>10-100
; A173856: Expansion of 10/9 in base phi.
; Submitted by <NAME>(s2)
; 1,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,1,0,1,0,0,0,1,0,0,0,0,0,0,0,0
pow $1,$0
mov $2,$0
pow $0,2
div $0,24
mul $0,$2
sub $1,$0
mov $0,$1
mod $0,2
add $0,2
mod $0,2
|
oeis/014/A014633.asm
|
neoneye/loda-programs
| 11 |
240850
|
; A014633: Even pentagonal numbers.
; Submitted by <NAME>(s1.)
; 0,12,22,70,92,176,210,330,376,532,590,782,852,1080,1162,1426,1520,1820,1926,2262,2380,2752,2882,3290,3432,3876,4030,4510,4676,5192,5370,5922,6112,6700,6902,7526,7740,8400,8626,9322,9560,10292,10542,11310,11572,12376,12650,13490,13776,14652,14950,15862,16172,17120,17442,18426,18760,19780,20126,21182,21540,22632,23002,24130,24512,25676,26070,27270,27676,28912,29330,30602,31032,32340,32782,34126,34580,35960,36426,37842,38320,39772,40262,41750,42252,43776,44290,45850,46376,47972,48510,50142,50692
mov $1,$0
mul $0,2
mod $1,2
add $0,$1
mul $0,3
bin $0,2
div $0,3
|
libsrc/_DEVELOPMENT/math/float/math48/lm/c/sdcc_iy/fmax.asm
|
jpoikela/z88dk
| 640 |
91947
|
SECTION code_clib
SECTION code_fp_math48
PUBLIC _fmax
EXTERN cm48_sdcciy_fmax
defc _fmax = cm48_sdcciy_fmax
|
test/bugs/fixed/HiddenLambda.agda
|
alhassy/agda
| 3 |
7234
|
<filename>test/bugs/fixed/HiddenLambda.agda
module HiddenLambda where
postulate
A : Set
T : A -> Set
H : Set
H = {x : A} -> T x -> T x
-- H doesn't reduce when checking the body of h
h : H
h = \tx -> tx
|
oeis/319/A319650.asm
|
neoneye/loda-programs
| 11 |
92621
|
<filename>oeis/319/A319650.asm<gh_stars>10-100
; A319650: a(n) = A073138(n) - n.
; Submitted by <NAME>
; 0,0,0,0,0,1,0,0,0,3,2,3,0,1,0,0,0,7,6,9,4,7,6,7,0,3,2,3,0,1,0,0,0,15,14,21,12,19,18,21,8,15,14,17,12,15,14,15,0,7,6,9,4,7,6,7,0,3,2,3,0,1,0,0,0,31,30,45,28,43,42,49,24,39,38,45,36,43,42,45,16,31,30,37,28,35,34,37,24,31,30,33,28,31,30,31,0,15,14,21
sub $1,$0
seq $0,73138 ; Largest number having in its binary representation the same number of 0's and 1's as n.
add $1,$0
mov $0,$1
|
alloy4fun_models/trashltl/models/11/4YuLX6hk8nSgEq4sA.als
|
Kaixi26/org.alloytools.alloy
| 0 |
4567
|
<reponame>Kaixi26/org.alloytools.alloy
open main
pred id4YuLX6hk8nSgEq4sA_prop12 {
eventually some f: File | eventually f in Trash
}
pred __repair { id4YuLX6hk8nSgEq4sA_prop12 }
check __repair { id4YuLX6hk8nSgEq4sA_prop12 <=> prop12o }
|
oeis/000/A000782.asm
|
neoneye/loda-programs
| 11 |
25492
|
; A000782: a(n) = 2*Catalan(n) - Catalan(n-1).
; 1,3,8,23,70,222,726,2431,8294,28730,100776,357238,1277788,4605980,16715250,61020495,223931910,825632610,3056887680,11360977650,42368413620,158498860260,594636663660,2236748680998,8433988655580,31872759742852,120699748759856,457962352584716,1740736481552376,6627730787533240,25274285576361514,96523493714869487,369138195947438022,1413551953887218418,5419626947664871760,20803311276813605722,79941810263383031236,307516921249391660436,1184116880672944899380,4563828712823008417250
mov $2,$0
add $0,1
seq $0,108 ; Catalan numbers: C(n) = binomial(2n,n)/(n+1) = (2n)!/(n!(n+1)!).
mul $0,2
seq $2,108 ; Catalan numbers: C(n) = binomial(2n,n)/(n+1) = (2n)!/(n!(n+1)!).
sub $0,$2
|
oeis/178/A178626.asm
|
neoneye/loda-programs
| 11 |
9695
|
<filename>oeis/178/A178626.asm
; A178626: Convolution of Pell(n) and 10^n.
; Submitted by <NAME>
; 1,12,125,1262,12649,126560,1265769,12658098,126581965,1265822028,12658226021,126582274070,1265822774161,12658227822392,126582278418945,1265822784660282,12658227847739509,126582278480139300,1265822784808018109,12658227848096175518,126582278481000369145,1265822784810096913808,12658227848101194196761,126582278481012485307330,1265822784810126164811421,12658227848101264814930172,126582278481012655794671765,1265822784810126576404273702,12658227848101265808603219169,126582278481012658193610712040
add $0,1
mov $4,1
lpb $0
sub $0,1
add $2,$4
mov $1,$2
mov $2,$3
mul $4,10
sub $4,$3
mul $3,2
add $3,$1
add $4,$2
lpe
mov $0,$3
|
oeis/031/A031167.asm
|
neoneye/loda-programs
| 11 |
175723
|
<gh_stars>10-100
; A031167: a(n) = prime(n+5) - prime(n).
; Submitted by <NAME>(w2)
; 11,14,14,16,18,18,20,22,20,18,22,22,20,24,24,20,20,22,22,26,28,24,24,20,16,26,28,30,30,36,24,26,26,28,24,28,24,28,26,24,20,30,32,34,32,34,28,18,24,28,30,30,30,26,24,20,24,36,34,32,34,38,30,36,36,36,28,30,26,30,30,30,30,28,30,36,32,34,32,30,24,28,26,28,24,24,30,30,30,36,36,30,34,32,42,44,48,42,46,30
mov $1,$0
seq $0,40 ; The prime numbers.
add $1,5
seq $1,40 ; The prime numbers.
sub $1,$0
mov $0,$1
|
oeis/184/A184012.asm
|
neoneye/loda-programs
| 11 |
18594
|
<filename>oeis/184/A184012.asm
; A184012: n + floor(sqrt(5n-4)); complement of A184013.
; 2,4,6,8,9,11,12,14,15,16,18,19,20,22,23,24,26,27,28,29,31,32,33,34,36,37,38,39,40,42,43,44,45,46,48,49,50,51,52,54,55,56,57,58,59,61,62,63,64,65,66,68,69,70,71,72,73,74,76,77,78,79,80,81,82,84,85,86,87,88,89,90,92,93,94,95,96,97,98,99,101,102,103,104,105,106,107,108,110,111,112,113,114,115,116,117,118,120,121,122
mov $2,$0
mul $2,10
add $2,3
lpb $2
add $0,1
add $2,$3
sub $3,2
add $2,$3
lpe
add $0,1
|
macros.asm
|
jeremylive/Shared_Code
| 0 |
163281
|
;;ESPACIO DE MACROS
;;;MACRO DE EXPLICITO A STRBIN
%macro IntToBin 2
push eax
push ebx
push ecx
push edx
mov eax, %1
mov ebx, [eax]
mov ecx, 31
xor edx, edx
%%while:
dec ecx
cmp ecx, 0
je %%salir
ror ebx , 1
jc %%inicio
jmp while
%%inicio:
push eax
mov eax, %2
mov [eax + edx], '0'
mov [eax + edx], '1'
pop eax
%%largo:
dec ecx
cmp ecx,0
je %%salir
push eax
mov eax, %2
ror ebx, 1
jc %%uno
jmp %%cero
%%uno:
mov byte[eax + edx], '1'
pop eax
jmp %%largo
%%cero:
mov byte[eax + edx], '0'
pop eax
jmp %%largo
%%salir:
PutCh '^'
PutStr string
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE EXPLICITO A STROCT
%macro IntToOct 1
push eax
push ebx
push ecx
push edx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE EXPLICITO A STRDEC
%macro IntToDec 1
push eax
push ebx
push ecx
push edx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE EXPLICITO A STRHEX
%macro IntToHex 1
push eax
push ebx
push ecx
push edx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE HEXADECIMAL A EXPLICITO (BINARIO)
%macro HexToInt 2
;;; IN: "H000B"
;;; OUT: 0000 0000 0000 1011 (11)
push eax
push ebx
push ecx
push edx
xor eax,eax
xor ebx, ebx
xor ecx, ecx
mov eax, %1
mov ecx, %2
%%ite:
mov ch, [eax]
sub ch, 30H
cmp ch, 9
jg %%no_number
cmp ch, 0
jl %%no_valid
add bl, ch
dec cl
cmp cl, 0
je %%salir
rol ebx, 4
inc eax
jmp %%ite
%%no_number:
sub ch, 17
cmp ch, 5
jg %%no_valid
add ch, 10
add bl, ch
dec cl
cmp cl, 0
je %%salir
rol ebx, 4
inc eax
jmp %%ite
%%no_valid:
PutStr error_variableMsg2
xor ebx, ebx
%%salir:
PutCh '('
PutLInt ebx
PutCh ')'
mov [aux], ebx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE OCTAL A EXPLICITO (BINARIO)
%macro OctToInt 2
;;; IN: "00000017"
;;; OUT: 0000 0000 0000 1111 (7)
;;; _--- ___- --__ _---
;;; (s)(0) (0)(0) (1) (7)
;PutLInt eax
PutCh '<'
PutCh '-'
push eax
push ebx
push ecx
push edx
xor eax,eax
xor ebx, ebx
xor ecx, ecx
mov eax, %1
PutStr eax
mov ecx, %2
%%ite:
mov ch, [eax]
sub ch, 30H
cmp ch, 7
jg %%no_valid
cmp ch, 0
jl %%no_valid
add bl, ch
dec cl
cmp cl, 0
je %%salir
rol ebx, 3
inc eax
jmp %%ite
%%no_valid:
PutStr error_variableMsg2
xor ebx, ebx
%%salir:
PutCh '('
PutLInt ebx
PutCh ')'
mov [aux], ebx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
;;;MACRO DE BINARIO A EXPLICITO (BINARIO)
%macro BinToInt 2
;;; IN: "000101"
;;; OUT: 0000 0000 0000 0101 (5)
push eax
push ebx
push ecx
push edx
xor eax,eax
xor ebx, ebx
xor ecx, ecx
mov eax, %1
mov ecx, %2
%%ite:
mov ch, [eax]
PutStr eax
sub ch, 30H
cmp ch, 1
jg %%no_valid
cmp ch, 0
jl %%no_valid
add bl, ch
dec cl
cmp cl, 0
je %%salir
rol ebx,1
inc eax
jmp %%ite
%%no_valid:
PutStr error_variableMsg2
xor ebx, ebx
%%salir:
PutCh '('
PutLInt ebx
PutCh ')'
mov [aux], ebx
pop edx
pop ecx
pop ebx
pop eax
%endmacro
|
source/amf/uml/amf-uml-dependencies.ads
|
svn2github/matreshka
| 24 |
9285
|
<filename>source/amf/uml/amf-uml-dependencies.ads
------------------------------------------------------------------------------
-- --
-- Matreshka Project --
-- --
-- Ada Modeling Framework --
-- --
-- Runtime Library Component --
-- --
------------------------------------------------------------------------------
-- --
-- Copyright © 2011-2012, <NAME> <<EMAIL>> --
-- All rights reserved. --
-- --
-- Redistribution and use in source and binary forms, with or without --
-- modification, are permitted provided that the following conditions --
-- are met: --
-- --
-- * Redistributions of source code must retain the above copyright --
-- notice, this list of conditions and the following disclaimer. --
-- --
-- * Redistributions in binary form must reproduce the above copyright --
-- notice, this list of conditions and the following disclaimer in the --
-- documentation and/or other materials provided with the distribution. --
-- --
-- * Neither the name of the Vadim Godunko, IE 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. --
-- --
------------------------------------------------------------------------------
-- $Revision$ $Date$
------------------------------------------------------------------------------
-- This file is generated, don't edit it.
------------------------------------------------------------------------------
-- A dependency is a relationship that signifies that a single or a set of
-- model elements requires other model elements for their specification or
-- implementation. This means that the complete semantics of the depending
-- elements is either semantically or structurally dependent on the
-- definition of the supplier element(s).
------------------------------------------------------------------------------
with AMF.UML.Directed_Relationships;
limited with AMF.UML.Named_Elements.Collections;
with AMF.UML.Packageable_Elements;
package AMF.UML.Dependencies is
pragma Preelaborate;
type UML_Dependency is limited interface
and AMF.UML.Directed_Relationships.UML_Directed_Relationship
and AMF.UML.Packageable_Elements.UML_Packageable_Element;
type UML_Dependency_Access is
access all UML_Dependency'Class;
for UML_Dependency_Access'Storage_Size use 0;
not overriding function Get_Client
(Self : not null access constant UML_Dependency)
return AMF.UML.Named_Elements.Collections.Set_Of_UML_Named_Element is abstract;
-- Getter of Dependency::client.
--
-- The element(s) dependent on the supplier element(s). In some cases
-- (such as a Trace Abstraction) the assignment of direction (that is, the
-- designation of the client element) is at the discretion of the modeler,
-- and is a stipulation.
not overriding function Get_Supplier
(Self : not null access constant UML_Dependency)
return AMF.UML.Named_Elements.Collections.Set_Of_UML_Named_Element is abstract;
-- Getter of Dependency::supplier.
--
-- The element(s) independent of the client element(s), in the same
-- respect and the same dependency relationship. In some directed
-- dependency relationships (such as Refinement Abstractions), a common
-- convention in the domain of class-based OO software is to put the more
-- abstract element in this role. Despite this convention, users of UML
-- may stipulate a sense of dependency suitable for their domain, which
-- makes a more abstract element dependent on that which is more specific.
end AMF.UML.Dependencies;
|
programs/oeis/028/A028425.asm
|
karttu/loda
| 0 |
171253
|
; A028425: Clog sequence in base 4. Right to left concatenation of n, int(log_4(n)), int(log_4(int(log_4(n)))), ... in base 4.
; 1,2,3,20,21,22,23,24,25,26,27,28,29,30,31,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183
mov $2,$0
add $2,1
mov $8,$0
lpb $2,1
mov $0,$8
sub $2,1
sub $0,$2
mov $3,2
mov $7,$0
lpb $3,1
mov $0,$7
sub $3,1
add $0,$3
add $0,8
div $0,2
mov $5,2
mov $6,11
div $6,$0
sub $5,$6
pow $5,3
mov $4,$5
mov $10,$3
lpb $10,1
mov $9,$4
sub $10,1
lpe
lpe
lpb $7,1
mov $7,0
sub $9,$4
lpe
mov $4,$9
mul $4,16
add $4,1
add $1,$4
lpe
|
src/boot.asm
|
charpointer/maikuro
| 2 |
95668
|
%define kernel_virt_offset 0xffffffff80000000
;; Multiboot shit
MBALIGN equ 1 << 0 ;; align loaded modules on page boundaries
MEMINFO equ 1 << 1 ;; provide memory map
FLAGS equ MBALIGN | MEMINFO ;; multiboot 'flag' field
MAGIC equ 0x1BADB002 ;; magic number
CHECKSUM equ -(MAGIC + FLAGS) ;; checksum of above, proves we are multiboot
section .multiboot
align 4
dd MAGIC
dd FLAGS
dd CHECKSUM
section .bss
align 16
stack_bottom:
resb 16384 ;; 16 KiB
stack_top:
section .text
global _start
bits 32
_start:
extern gdt_ptr_lowerhalf
;; The bootloader has loaded us into 32-bit protected mode on a x86
;; machine. Interrupts are disabled. Paging is disabled. The processor
;; state is as defined in the multiboot standard. The kernel has full
;; control of the CPU.
;; We set esp register to point to the top of our stack
mov esp, stack_top - kernel_virt_offset
mov edi, multiboot_header_ptr - kernel_virt_offset
mov DWORD [edi], ebx
mov eax, p4_table - kernel_virt_offset
mov cr3, eax
;; Enable PAE
mov eax, cr4
or eax, 1 << 5
mov cr4, eax
;; Long mode bit
mov ecx, 0xc0000080
rdmsr
or eax, 1 << 8
wrmsr
;; Enabling paging
mov eax, cr0
or eax, 1 << 31
mov cr0, eax
;; Load the GDT
lgdt [gdt_ptr_lowerhalf - kernel_virt_offset]
jmp 0x8:(higher_half_entry - kernel_virt_offset)
bits 64
higher_half_entry:
mov rax, higher_half
jmp rax
higher_half:
lgdt [gdt_ptr_lowerhalf]
jmp start64
start64:
mov ax, 0
mov gs, ax
mov ds, ax
mov fs, ax
mov ss, ax
mov es, ax
;;mov rdi, ebx
mov edi, DWORD [multiboot_header_ptr]
;; Enter the high-level kernel
extern kmain
call kmain
.hang:
hlt
jmp .hang
.end:
section .bss
align 16
global multiboot_header_ptr
multiboot_header_ptr:
resb 16
section .data
;; Paging shit
align 4096 ;; Align by 4096
p2_table:
dq 0 + 0x83
dq 0x200000 + 0x83
times 510 dq 0
p3_table:
dq (p2_table - kernel_virt_offset) + 0x3
times 509 dq 0
dq (p2_table - kernel_virt_offset) + 0x3
dq 0
p4_table:
dq (p3_table - kernel_virt_offset) + 0x3
times 510 dq 0
dq (p3_table - kernel_virt_offset) + 0x3
|
Cubical/Relation/Binary/Construct/StrictToNonStrict.agda
|
bijan2005/univalent-foundations
| 0 |
5440
|
<filename>Cubical/Relation/Binary/Construct/StrictToNonStrict.agda
{-# OPTIONS --cubical --no-import-sorts --safe #-}
open import Cubical.Core.Everything
open import Cubical.Relation.Binary
module Cubical.Relation.Binary.Construct.StrictToNonStrict
{a ℓ} {A : Type a}
(_<_ : Rel A ℓ)
where
open import Cubical.Foundations.Prelude
open import Cubical.Foundations.Function
open import Cubical.Foundations.Logic hiding (_⇒_) renaming (inl to inlₚ; inr to inrₚ)
open import Cubical.Data.Prod
open import Cubical.Data.Sum.Base renaming (rec to ⊎-rec)
open import Cubical.Data.Empty renaming (elim to ⊥-elim) using (isProp⊥)
open import Cubical.Relation.Binary.Properties
open import Cubical.Relation.Nullary
open import Cubical.HITs.PropositionalTruncation as PT
------------------------------------------------------------------------
-- Conversion
-- _<_ can be turned into _≤_ as follows:
_≤_ : Rel A _
x ≤ y = (x < y) ⊔ (x ≡ₚ y)
------------------------------------------------------------------------
-- The converted relations have certain properties
-- (if the original relations have certain other properties)
<⇒≤ : _<_ ⇒ _≤_
<⇒≤ = inlₚ
≤-fromEq : FromEq _≤_
≤-fromEq = inrₚ
≤-reflexive : Reflexive _≤_
≤-reflexive = fromeq→reflx _≤_ ≤-fromEq
≤-antisym : Transitive _<_ → Irreflexive _<_ → Antisymmetric _≤_
≤-antisym transitive irrefl = rec2 squash λ
{ (inl x) (inl y) → ⊥-elim (irrefl (transitive x y))
; (inl x) (inr y) → PT.map sym y
; (inr x) _ → x
}
≤-transitive : Transitive _<_ → Transitive _≤_
≤-transitive <-trans = rec2 squash λ
{ (inl x) (inl y) → inlₚ (<-trans x y)
; (inl x) (inr y) → inlₚ (substₚ (λ k → _ < k) y x)
; (inr x) (inl y) → inlₚ (substₚ (λ i → i < _) (PT.map sym x) y)
; (inr x) (inr y) → inrₚ (PT.map2 _∙_ x y)
}
<-≤-trans : Transitive _<_ → Trans _<_ _≤_ _<_
<-≤-trans transitive x<y = rec (isProp[ _<_ ] _ _) λ
{ (inl x) → transitive x<y x
; (inr x) → substₚ (λ k → _ < k) x x<y
}
≤-<-trans : Transitive _<_ → Trans _≤_ _<_ _<_
≤-<-trans transitive = rec (isPropΠ λ _ → isProp[ _<_ ] _ _) λ
{ (inl x) y → transitive x y
; (inr x) y → substₚ (λ i → i < _) (PT.map sym x) y
}
≤-total : Trichotomous _<_ → Total _≤_
≤-total <-tri x y with <-tri x y
... | tri< x<y x≢y x≯y = inlₚ (inlₚ x<y)
... | tri≡ x≮y x≡y x≯y = inlₚ (inrₚ ∣ x≡y ∣)
... | tri> x≮y x≢y x>y = inrₚ (inlₚ x>y)
≤-decidable : Discrete A → Decidable _<_ → Decidable _≤_
≤-decidable _≟_ _<?_ x y with x <? y
... | yes x<y = yes (inlₚ x<y)
... | no x≮y with x ≟ y
... | yes x≡y = yes (inrₚ ∣ x≡y ∣)
... | no x≢y = no (rec isProp⊥ λ
{ (inl x<y) → x≮y x<y
; (inr x≡y) → x≢y (rec (Discrete→isSet _≟_ _ _) id x≡y)
})
≤-decidable′ : Trichotomous _<_ → Decidable _≤_
≤-decidable′ compare x y with compare x y
... | tri< x<y x≢y x≯y = yes (inlₚ x<y)
... | tri≡ x≮y x≡y x≯y = yes (inrₚ ∣ x≡y ∣)
... | tri> x≮y x≢y x>y = no (rec isProp⊥ λ
{ (inl x<y) → x≮y x<y
; (inr x≡y) → x≢y (rec (Discrete→isSet (tri→dec≡ _<_ compare) _ _) id x≡y)
})
------------------------------------------------------------------------
-- Converting structures
isPreorder : Transitive _<_ → IsPreorder _≤_
isPreorder transitive = record
{ reflexive = ≤-reflexive
; transitive = ≤-transitive transitive
}
isPartialOrder : IsStrictPartialOrder _<_ → IsPartialOrder _≤_
isPartialOrder spo = record
{ isPreorder = isPreorder S.transitive
; antisym = ≤-antisym S.transitive S.irrefl
}
where module S = IsStrictPartialOrder spo
isTotalOrder : IsStrictTotalOrder _<_ → IsTotalOrder _≤_
isTotalOrder sto = record
{ isPartialOrder = isPartialOrder S.isStrictPartialOrder
; total = ≤-total S.compare
}
where module S = IsStrictTotalOrder sto
isDecTotalOrder : IsStrictTotalOrder _<_ → IsDecTotalOrder _≤_
isDecTotalOrder sto = record
{ isTotalOrder = isTotalOrder sto
; _≤?_ = ≤-decidable′ S.compare
}
where module S = IsStrictTotalOrder sto
|
src/Implicits/Resolution/Ambiguous/SystemFEquiv.agda
|
metaborg/ts.agda
| 4 |
10192
|
module Implicits.Resolution.Ambiguous.SystemFEquiv where
open import Prelude
open import Function.Equivalence using (_⇔_; equivalence)
open import Data.List.Properties
open import Relation.Binary.HeterogeneousEquality as H using ()
open import Data.Vec.Properties as VP using ()
open import Data.Vec hiding ([_])
open import Extensions.Vec
open import Data.List as List using ()
open import Data.Product hiding (map)
open import Implicits.Syntax
open import Implicits.Resolution.Ambiguous.Resolution
open import Implicits.Resolution.Embedding
open import Implicits.Resolution.Embedding.Lemmas
open import SystemF.Everything
as F using ()
⟦_⟧term→ : ∀ {ν} {Δ : ICtx ν} {r} → Δ ⊢ᵣ r → F.Term ν (List.length (List.map ⟦_⟧tp→ Δ))
⟦_⟧term→ {ν} {Δ} (r-tabs x) = F.Λ (subst (F.Term (suc ν)) (length-weaken-Δ Δ) ⟦ x ⟧term→)
⟦ r-tapp a x ⟧term→ = ⟦ x ⟧term→ F.[ ⟦ a ⟧tp→ ]
⟦_⟧term→ {Δ = Δ} (r-ivar x) =
F.var (subst Fin (sym $ length-map _ Δ) (proj₁ $ ∈⟶index (VP.List-∈⇒∈ x)))
⟦ r-iabs {a = a} x ⟧term→ = F.λ' ⟦ a ⟧tp→ ⟦ x ⟧term→
⟦ r-iapp f e ⟧term→ = ⟦ f ⟧term→ F.· ⟦ e ⟧term→
from-⊢ : ∀ {ν n t a} {Γ : F.Ctx ν n} → Γ F.⊢ t ∈ a → ⟦ Γ ⟧ctx← ⊢ᵣ ⟦ a ⟧tp←
from-⊢ (F.var x) = r-ivar (lookup-∈ x _)
from-⊢ {Γ = Γ} (F.Λ x) = r-tabs (subst (λ u → u ⊢ᵣ _) (⟦weaken⟧ctx← Γ) (from-⊢ x))
from-⊢ (F.λ' {b = b} a x) = r-iabs (from-⊢ x)
from-⊢ {Γ = Γ} (F._[_] {a = a} x b) = subst
(λ u → ⟦ Γ ⟧ctx← ⊢ᵣ u)
(sym (⟦a/sub⟧tp← a b))
(r-tapp ⟦ b ⟧tp← (from-⊢ x))
from-⊢ (a F.· b) = r-iapp (from-⊢ a) (from-⊢ b)
to-⊢ : ∀ {ν} {Δ : ICtx ν} {r} → (p : Δ ⊢ᵣ r) → ⟦ Δ ⟧ctx→ F.⊢ ⟦ p ⟧term→ ∈ ⟦ r ⟧tp→
to-⊢ {Δ = Δ} (r-tabs {r = r} p) with to-⊢ p
to-⊢ {Δ = Δ} (r-tabs {r = r} p) | x =
F.Λ (⊢subst-n (length-weaken-Δ Δ) (H.sym (⟦weaken⟧ctx→ Δ)) x)
to-⊢ (r-tapp a p) with to-⊢ p
to-⊢ {Δ = Δ} (r-tapp {r = a} b p) | x =
subst
(λ u → ⟦ Δ ⟧ctx→ F.⊢ ⟦ p ⟧term→ F.[ ⟦ b ⟧tp→ ] ∈ u)
(sym $ ⟦a/sub⟧tp→ a b)
(x F.[ ⟦ b ⟧tp→ ])
to-⊢ {Δ = Δ} {r = r} (r-ivar x) =
let i , eq = ∈⟶index (VP.List-∈⇒∈ x) in
let i' = (subst Fin (sym $ length-map _ Δ) i) in
subst (λ u → ⟦ Δ ⟧ctx→ F.⊢ (F.var i') ∈ u) (lookup⟦⟧ Δ i eq) (F.var i')
to-⊢ (r-iabs {a = a} p) = F.λ' ⟦ a ⟧tp→ (to-⊢ p)
to-⊢ (r-iapp p p₁) = (to-⊢ p) F.· (to-⊢ p₁)
equivalent : ∀ {ν} (Δ : ICtx ν) r → Δ ⊢ᵣ r ⇔ (∃ λ t → ⟦ Δ ⟧ctx→ F.⊢ t ∈ ⟦ r ⟧tp→)
equivalent Δ r = equivalence
(λ x → , (to-⊢ x))
(λ x → subst₂ (λ Δ' r' → Δ' ⊢ᵣ r') (ctx→← _) (tp→← r) (from-⊢ (proj₂ x)))
⊢subst : ∀ {ν n n'} {a a' : F.Type ν} {Γ : F.Ctx ν n} {Γ' : F.Ctx ν n'} →
n ≡ n' → a ≡ a' → Γ H.≅ Γ' →
(∃ λ t → Γ F.⊢ t ∈ a) →
∃ λ t → Γ' F.⊢ t ∈ a'
⊢subst refl refl H.refl p = p
equivalent' : ∀ {ν n} (Γ : F.Ctx ν n) r → ⟦ Γ ⟧ctx← ⊢ᵣ ⟦ r ⟧tp← ⇔ (∃ λ t → Γ F.⊢ t ∈ r)
equivalent' Γ r = equivalence
(λ x → ⊢subst
(length-map-toList (map ⟦_⟧tp← Γ)) (tp←→ r) (ctx←→ Γ) (, to-⊢ x))
(λ x → (from-⊢ (proj₂ x)))
|
Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_2660.asm
|
ljhsiun2/medusa
| 9 |
22473
|
<filename>Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0x48.log_21829_2660.asm
.global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r15
push %r8
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0xc39e, %rbp
cmp %rdi, %rdi
movups (%rbp), %xmm4
vpextrq $1, %xmm4, %rsi
nop
sub %rsi, %rsi
lea addresses_UC_ht+0x1993a, %rsi
lea addresses_WC_ht+0x559e, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
dec %r8
mov $69, %rcx
rep movsb
nop
nop
nop
sub $32829, %rbp
lea addresses_D_ht+0x1719e, %r15
nop
nop
nop
inc %r8
mov $0x6162636465666768, %rsi
movq %rsi, (%r15)
nop
cmp $21847, %rsi
lea addresses_WC_ht+0xd12c, %rcx
nop
nop
nop
nop
cmp %rsi, %rsi
movl $0x61626364, (%rcx)
nop
nop
nop
nop
nop
add $4065, %r15
lea addresses_WT_ht+0x57a5, %rsi
lea addresses_WC_ht+0x18c9e, %rdi
nop
nop
nop
nop
nop
xor %r10, %r10
mov $78, %rcx
rep movsq
nop
nop
nop
nop
dec %rdi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r8
pop %r15
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r8
push %rax
push %rbp
push %rdi
// Faulty Load
lea addresses_PSE+0x1059e, %rax
nop
nop
nop
nop
sub %r8, %r8
movaps (%rax), %xmm0
vpextrq $0, %xmm0, %r13
lea oracles, %rbp
and $0xff, %r13
shlq $12, %r13
mov (%rbp,%r13,1), %r13
pop %rdi
pop %rbp
pop %rax
pop %r8
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'AVXalign': False, 'congruent': 0, 'size': 32, 'same': False, 'NT': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_PSE', 'AVXalign': True, 'congruent': 0, 'size': 16, 'same': True, 'NT': False}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_normal_ht', 'AVXalign': False, 'congruent': 9, 'size': 16, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 11, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_D_ht', 'AVXalign': False, 'congruent': 10, 'size': 8, 'same': False, 'NT': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'AVXalign': False, 'congruent': 0, 'size': 4, 'same': False, 'NT': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_WT_ht', 'congruent': 0, 'same': False}, 'dst': {'type': 'addresses_WC_ht', 'congruent': 7, '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
*/
|
src/chips/QSound.asm
|
sharksym/vgmplay-sharksym
| 6 |
179116
|
<filename>src/chips/QSound.asm
;
; VGM QSound chip
;
QSound: MACRO
super: Chip QSound_name, Header.qSoundClock, System_Return
ENDM
; ix = this
; iy = header
QSound_Construct: equ Chip_Construct
; jp Chip_Construct
; ix = this
QSound_Destruct: equ Chip_Destruct
; jp Chip_Destruct
;
SECTION RAM
QSound_instance: QSound
ENDS
QSound_name:
db "QSound",0
|
src/main/fragment/mos6502-common/vdum1=vduc1_plus_vwum2.asm
|
jbrandwood/kickc
| 2 |
161980
|
lda {m2}
clc
adc #<{c1}
sta {m1}
lda {m2}+1
adc #>{c1}
sta {m1}+1
lda #0
adc #<{c1}>>$10
sta {m1}+2
lda #0
adc #>{c1}>>$10
sta {m1}+3
|
components/src/range_sensor/VL53L0X/vl53l0x.ads
|
morbos/Ada_Drivers_Library
| 2 |
1275
|
------------------------------------------------------------------------------
-- --
-- Copyright (C) 2017, 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 STMicroelectronics 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. --
-- --
-- --
-- This file is based on X-CUBE-53L0A1 STM32Cube expansion --
-- --
-- COPYRIGHT(c) 2016 STMicroelectronics --
------------------------------------------------------------------------------
with HAL.I2C;
package VL53L0X is
Fix_Point_16_16_Delta : constant := 1.0 / (2.0 ** 16);
type Fix_Point_16_16 is
delta Fix_Point_16_16_Delta
range -2.0 ** 15 .. 2.0 ** 15 - Fix_Point_16_16_Delta
with Size => 32;
type VL53L0X_Ranging_Sensor
(Port : not null HAL.I2C.Any_I2C_Port) is limited private;
type VL53L0X_GPIO_Functionality is
(No_Interrupt,
Level_Low,
Level_High,
Out_Of_Window,
New_Sample_Ready);
type VL53L0X_Interrupt_Polarity is
(Polarity_Low,
Polarity_High);
procedure Initialize
(This : in out VL53L0X_Ranging_Sensor);
function Read_Id (This : VL53L0X_Ranging_Sensor) return HAL.UInt16;
procedure Set_Device_Address
(This : in out VL53L0X_Ranging_Sensor;
Addr : HAL.I2C.I2C_Address;
Status : out Boolean);
procedure Data_Init
(This : in out VL53L0X_Ranging_Sensor;
Status : out Boolean);
procedure Static_Init
(This : in out VL53L0X_Ranging_Sensor;
GPIO_Function : VL53L0X_GPIO_Functionality;
Status : out Boolean);
procedure Perform_Ref_Calibration
(This : in out VL53L0X_Ranging_Sensor;
Status : out Boolean);
procedure Start_Range_Single_Millimeters
(This : VL53L0X_Ranging_Sensor;
Status : out Boolean);
-- Start a read operation on sensor
function Range_Value_Available
(This : VL53L0X_Ranging_Sensor) return Boolean;
-- Returns True when a new value is available
function Read_Range_Millimeters
(This : VL53L0X_Ranging_Sensor) return HAL.UInt16
with Pre => Range_Value_Available (This);
-- Read the available ranging value
function Read_Range_Single_Millimeters
(This : VL53L0X_Ranging_Sensor) return HAL.UInt16;
procedure Set_GPIO_Config
(This : in out VL53L0X_Ranging_Sensor;
Functionality : VL53L0X_GPIO_Functionality;
Polarity : VL53L0X_Interrupt_Polarity;
Status : out Boolean);
procedure Clear_Interrupt_Mask
(This : VL53L0X_Ranging_Sensor);
function Measurement_Timing_Budget
(This : VL53L0X_Ranging_Sensor) return HAL.UInt32;
procedure Set_Measurement_Timing_Budget
(This : VL53L0X_Ranging_Sensor;
Budget_Micro_Seconds : HAL.UInt32;
Status : out Boolean);
-- Sets the measurement timing budget.
-- The more time, the more precisions. By default, the budget is ~33ms
procedure Set_Signal_Rate_Limit
(This : VL53L0X_Ranging_Sensor;
Rate_Limit : Fix_Point_16_16);
-- Default signal rate: 0.25 MCPS
procedure Set_VCSEL_Pulse_Period_Pre_Range
(This : VL53L0X_Ranging_Sensor;
Period : HAL.UInt8;
Status : out Boolean);
-- Default period: 14 PCLKs
procedure Set_VCSEL_Pulse_Period_Final_Range
(This : VL53L0X_Ranging_Sensor;
Period : HAL.UInt8;
Status : out Boolean);
-- Default period: 10 PCLKs
procedure SetInterMeasurementPeriodMilliSeconds
(This : VL53L0X_Ranging_Sensor;
Period : HAL.UInt32;
Status : out Boolean);
procedure GetInterMeasurementPeriodMilliSeconds
(This : in out VL53L0X_Ranging_Sensor;
Status : out Boolean);
procedure GetDeviceParameters
(This : in out VL53L0X_Ranging_Sensor;
Status : out Boolean);
private
REG_SYSRANGE_START : constant := 16#000#;
-- mask existing bit in #REG_SYSRANGE_START
REG_SYSRANGE_MODE_MASK : constant := 16#0F#;
-- bit 0 in #REG_SYSRANGE_START write 1 toggle state in
-- continuous mode and arm next shot in single shot mode
REG_SYSRANGE_MODE_START_STOP : constant := 16#01#;
-- bit 1 write 0 in #REG_SYSRANGE_START set single shot mode
REG_SYSRANGE_MODE_SINGLESHOT : constant := 16#00#;
-- bit 1 write 1 in #REG_SYSRANGE_START set back-to-back
-- operation mode
REG_SYSRANGE_MODE_BACKTOBACK : constant := 16#02#;
-- bit 2 write 1 in #REG_SYSRANGE_START set timed operation
-- mode
REG_SYSRANGE_MODE_TIMED : constant := 16#04#;
-- bit 3 write 1 in #REG_SYSRANGE_START set histogram operation
-- mode
REG_SYSRANGE_MODE_HISTOGRAM : constant := 16#08#;
REG_SYSTEM_THRESH_HIGH : constant := 16#000C#;
REG_SYSTEM_THRESH_LOW : constant := 16#000E#;
REG_SYSTEM_SEQUENCE_CONFIG : constant := 16#0001#;
REG_SYSTEM_RANGE_CONFIG : constant := 16#0009#;
REG_SYSTEM_INTERMEASUREMENT_PERIOD : constant := 16#0004#;
REG_SYSTEM_INTERRUPT_CONFIG_GPIO : constant := 16#000A#;
REG_SYSTEM_INTERRUPT_GPIO_DISABLED : constant := 16#00#;
REG_SYSTEM_INTERRUPT_GPIO_LEVEL_LOW : constant := 16#01#;
REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH : constant := 16#02#;
REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW : constant := 16#03#;
REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY : constant := 16#04#;
REG_GPIO_HV_MUX_ACTIVE_HIGH : constant := 16#0084#;
REG_SYSTEM_INTERRUPT_CLEAR : constant := 16#000B#;
-- Result registers
REG_RESULT_INTERRUPT_STATUS : constant := 16#0013#;
REG_RESULT_RANGE_STATUS : constant := 16#0014#;
REG_RESULT_CORE_PAGE : constant := 1;
REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN : constant := 16#00BC#;
REG_RESULT_CORE_RANGING_TOTAL_EVENTS_RTN : constant := 16#00C0#;
REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF : constant := 16#00D0#;
REG_RESULT_CORE_RANGING_TOTAL_EVENTS_REF : constant := 16#00D4#;
REG_RESULT_PEAK_SIGNAL_RATE_REF : constant := 16#00B6#;
-- Algo register
REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM : constant := 16#0028#;
REG_I2C_SLAVE_DEVICE_ADDRESS : constant := 16#008A#;
-- Check Limit registers
REG_MSRC_CONFIG_CONTROL : constant := 16#0060#;
REG_PRE_RANGE_CONFIG_MIN_SNR : constant := 16#0027#;
REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW : constant := 16#0056#;
REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH : constant := 16#0057#;
REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT : constant := 16#0064#;
REG_FINAL_RANGE_CONFIG_MIN_SNR : constant := 16#0067#;
REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW : constant := 16#0047#;
REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH : constant := 16#0048#;
REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT : constant := 16#0044#;
REG_PRE_RANGE_CONFIG_SIGMA_THRESH_HI : constant := 16#0061#;
REG_PRE_RANGE_CONFIG_SIGMA_THRESH_LO : constant := 16#0062#;
-- PRE RANGE registers
REG_PRE_RANGE_CONFIG_VCSEL_PERIOD : constant := 16#0050#;
REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI : constant := 16#0051#;
REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO : constant := 16#0052#;
REG_SYSTEM_HISTOGRAM_BIN : constant := 16#0081#;
REG_HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT : constant := 16#0033#;
REG_HISTOGRAM_CONFIG_READOUT_CTRL : constant := 16#0055#;
REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD : constant := 16#0070#;
REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI : constant := 16#0071#;
REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO : constant := 16#0072#;
REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS : constant := 16#0020#;
REG_MSRC_CONFIG_TIMEOUT_MACROP : constant := 16#0046#;
REG_SOFT_RESET_GO2_SOFT_RESET_N : constant := 16#00bf#;
REG_IDENTIFICATION_MODEL_ID : constant := 16#00c0#;
REG_IDENTIFICATION_REVISION_ID : constant := 16#00c2#;
REG_OSC_CALIBRATE_VAL : constant := 16#00f8#;
SIGMA_ESTIMATE_MAX_VALUE : constant := 65535;
-- equivalent to a range sigma of 655.35mm
REG_GLOBAL_CONFIG_VCSEL_WIDTH : constant := 16#032#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0 : constant := 16#0B0#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_1 : constant := 16#0B1#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_2 : constant := 16#0B2#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_3 : constant := 16#0B3#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_4 : constant := 16#0B4#;
REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_5 : constant := 16#0B5#;
REG_GLOBAL_CONFIG_REF_EN_START_SELECT : constant := 16#B6#;
REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD : constant := 16#4E#;
REG_DYNAMIC_SPAD_REF_EN_START_OFFSET : constant := 16#4F#;
REG_POWER_MANAGEMENT_GO1_POWER_FORCE : constant := 16#80#;
-- Speed of light in um per 1E-10 Seconds
SPEED_OF_LIGHT_IN_AIR : constant := 2997;
REG_VHV_CONFIG_PAD_SCL_SDA_EXTSUP_HV : constant := 16#0089#;
REG_ALGO_PHASECAL_LIM : constant := 16#0030#;
REG_ALGO_PHASECAL_CONFIG_TIMEOUT : constant := 16#0030#;
type VL53L0X_Device_Specific_Parameters is record
Osc_Frequency : HAL.UInt32 := 0;
Last_Timeout : HAL.UInt16 := 0;
Pin0_Functionality : VL53L0X_GPIO_Functionality := No_Interrupt;
Final_Range_Timeout_Micro_Seconds : HAL.UInt32 := 0;
Final_Range_Vcsel_Pulse_Period : HAL.UInt8 := 0;
Pre_Range_Timeout_Micro_Seconds : HAL.UInt32 := 0;
Pre_Range_Vcsel_Pulse_Period : HAL.UInt8 := 0;
Sigma_Est_Ref_Array : HAL.UInt16 := 0;
Sigma_Est_Eff_Pulse_Width : HAL.UInt16 := 0;
Sigma_Est_Eff_Amb_Width : HAL.UInt16 := 0;
StopVariable : HAL.UInt8;
TargetRefRate : HAL.UInt16;
SigmaEstimate : Fix_Point_16_16;
SignalEstimate : Fix_Point_16_16;
LastSignalRefMcps : Fix_Point_16_16;
-- uint8_t *pTuningSettingsPointer;
UseInternalTuningSettings : Boolean;
Linearity_Corrective_Gain : HAL.UInt16;
Dmax_Cal_Range_MilliMeter : HAL.UInt16;
Dmax_Cal_Signal_Rate_Rtn_MegaCps : HAL.UInt32;
Read_Data_From_Device_Done : Boolean := False;
Module_Id : HAL.UInt8;
Revision : HAL.UInt8;
Reference_SPAD_Count : HAL.UInt8;
Reference_SPAD_Type : HAL.UInt8;
Reference_SPADs_Initialised : Boolean := False;
Part_UID_Upper : HAL.UInt32;
Part_UID_Lower : HAL.UInt32;
end record;
type Histogram_Modes is
(Disabled,
Reference_Only,
Return_Only,
Both);
type Device_Modes is
(Single_Ranging,
Continuous_Ranging,
Continuous_Timed_Ranging,
Single_Histogram);
CHECKENABLE_NUMBER_OF_CHECKS : constant HAL.UInt32 := 6;
type LimitChecksEnableT is array (1 .. CHECKENABLE_NUMBER_OF_CHECKS) of Boolean;
type LimitChecksStatusT is array (1 .. CHECKENABLE_NUMBER_OF_CHECKS) of HAL.UInt8;
type LimitChecksValueT is array (1 .. CHECKENABLE_NUMBER_OF_CHECKS) of Fix_Point_16_16;
type VL53L0X_Device_Parameters is record
Device_Mode : Device_Modes;
Histogram_Mode : Histogram_Modes;
X_Talk_Compensation_Enable : Boolean;
X_Talk_Compensation_Range_MilliMeter : HAL.UInt16;
X_Talk_Compensation_Rate_Mcps : Fix_Point_16_16;
MeasurementTimingBudgetMicroSeconds : HAL.UInt32;
InterMeasurementPeriodMilliSeconds : HAL.UInt32;
RangeOffsetMicroMeters : HAL.UInt32;
LimitChecksEnable : LimitChecksEnableT;
LimitChecksStatus : LimitChecksStatusT;
LimitChecksValue : LimitChecksValueT;
WrapAroundCheckEnable : Boolean;
end record;
type VL53L0X_Ranging_Sensor (Port : not null HAL.I2C.Any_I2C_Port)
is limited record
-- Default address: can be changed by software
I2C_Address : HAL.I2C.I2C_Address := 16#52#;
Stop_Variable : HAL.UInt8;
Device_Specific_Params : VL53L0X_Device_Specific_Parameters;
Device_Params : VL53L0X_Device_Parameters;
end record;
procedure I2C_Write
(This : VL53L0X_Ranging_Sensor;
Data : HAL.UInt8_Array;
Status : out Boolean);
procedure I2C_Read
(This : VL53L0X_Ranging_Sensor;
Data : out HAL.UInt8_Array;
Status : out Boolean);
procedure Write
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : HAL.UInt8_Array;
Status : out Boolean);
procedure Write
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : HAL.UInt8;
Status : out Boolean);
procedure Write
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : HAL.UInt16;
Status : out Boolean);
procedure Write
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : HAL.UInt32;
Status : out Boolean);
procedure Read
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : out HAL.UInt8_Array;
Status : out Boolean);
procedure Read
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : out HAL.UInt8;
Status : out Boolean);
procedure Read
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : out HAL.UInt16;
Status : out Boolean);
procedure Read
(This : VL53L0X_Ranging_Sensor;
Index : HAL.UInt8;
Data : out HAL.UInt32;
Status : out Boolean);
function Set_Signal_Rate_Limit
(This : VL53L0X_Ranging_Sensor;
Limit_Mcps : Fix_Point_16_16) return Boolean;
function SPAD_Info
(This : VL53L0X_Ranging_Sensor;
SPAD_Count : out HAL.UInt8;
Is_Aperture : out Boolean) return Boolean;
type VL53L0x_Sequence_Step is
(TCC, DSS, MSRC, Pre_Range, Final_Range);
type VL53L0x_Sequence_Step_Enabled is
array (VL53L0x_Sequence_Step) of Boolean;
type VL53L0x_Sequence_Step_Timeout is
array (VL53L0x_Sequence_Step) of HAL.UInt32;
function Sequence_Step_Enabled
(This : VL53L0X_Ranging_Sensor) return VL53L0x_Sequence_Step_Enabled;
function Sequence_Step_Timeout
(This : VL53L0X_Ranging_Sensor;
Step : VL53L0x_Sequence_Step;
As_Mclks : Boolean := False) return HAL.UInt32;
function VCSel_Pulse_Period
(This : VL53L0X_Ranging_Sensor;
Sequence : VL53L0x_Sequence_Step) return HAL.UInt8;
procedure Set_VCSel_Pulse_Period
(This : VL53L0X_Ranging_Sensor;
Period : HAL.UInt8;
Sequence : VL53L0x_Sequence_Step;
Status : out Boolean);
end VL53L0X;
|
src/PiCalculus/Syntax/Properties.agda
|
guilhermehas/typing-linear-pi
| 26 |
7274
|
<gh_stars>10-100
{-# OPTIONS --safe --without-K #-}
open import Relation.Binary.PropositionalEquality using (_≡_; _≢_; refl; sym; cong; cong₂; subst; trans)
open import Relation.Nullary.Decidable using (True; from-yes)
open import Relation.Nullary.Negation using (¬?; contradiction)
open Relation.Binary.PropositionalEquality.≡-Reasoning
open import Function using (_∘_)
open import Relation.Nullary using (yes; no)
open import Data.Empty using (⊥)
open import Data.Product using (_×_; _,_; Σ-syntax; proj₁; proj₂)
open import Data.Fin.Base as Fin using (Fin; zero; suc)
open import Data.Unit using (⊤; tt)
open import Data.List.Base as List using (List; []; _∷_; [_])
import Data.List.Properties as Listₚ
import Data.Char.Properties as Charₚ
import Data.Digit as Digit
import Data.List.Membership.Propositional as ∈ₗ
import Data.List.Membership.Propositional.Properties as ∈ₗₚ
open import Data.Nat.Base as ℕ using (ℕ; zero; suc)
import Data.Nat.Properties as ℕₚ
import Data.Nat.Show as ℕₛ
import Data.Nat.Show.Properties as ℕₛₚ
open import Data.String.Base as String using (String)
import Data.Product.Properties as Productₚ
open import Data.Vec.Base as Vec using ([]; _∷_; Vec)
import Data.Vec.Properties as Vecₚ
open import Data.Vec.Relation.Unary.Any as Any using (here; there)
import Data.Vec.Membership.Propositional as ∈ᵥ
import Data.Vec.Membership.Propositional.Properties as ∈ᵥₚ
open import PiCalculus.Syntax
open Raw
open Scoped
open Conversion
open import PiCalculus.Utils
module PiCalculus.Syntax.Properties where
module _ where
private
variable
n : ℕ
P Q R S : Scoped n
x y : Fin n
namex namey : Name
fromName∘toName : (i : Fin n) (ctx : Ctx n) → ∈toFin (∈ᵥₚ.∈-lookup i ctx) ≡ i
fromName∘toName zero (x ∷ ctx) = refl
fromName∘toName (suc i) (x ∷ ctx) rewrite fromName∘toName i ctx = refl
toName∘fromName : ∀ {x} {ctx : Ctx n} (x∈ctx : x ∈ᵥ.∈ ctx) → Vec.lookup ctx (∈toFin x∈ctx) ≡ x
toName∘fromName (here px) = sym px
toName∘fromName (there x∈ctx) = toName∘fromName x∈ctx
-- The circum (^) is not a decimal character
^∉DECIMALS : '^' ∈ᵥ.∉ Digit.digitChars
^∉DECIMALS = from-yes (¬? (Any.any? ('^' Charₚ.≟_) Digit.digitChars))
module _ (base : ℕ) {2≤base : True (2 ℕₚ.≤? base)} {base≤16 : True (base ℕₚ.≤? 16)} where
charsInBase∈digitChars : ∀ n c → c ∈ₗ.∈ ℕₛ.charsInBase base {2≤base} {base≤16} n → c ∈ᵥ.∈ Digit.digitChars
charsInBase∈digitChars n c i with ∈ₗₚ.∈-map⁻ Digit.showDigit i
charsInBase∈digitChars n c i | d , _ , refl = ∈ᵥₚ.∈-lookup (Fin.inject≤ d _) Digit.digitChars
-- In <name>^<natural> the <natural> does not contain ^, therefore toChars is injective
toChars-injective : (x y : Name × ℕ) → toChars x ≡ toChars y → x ≡ y
toChars-injective (nx , cx) (ny , cy) eq = cong₂ _,_ cancel-names (ℕₛₚ.charsInBase-injective 10 cx cy count-repr)
where
count-repr = ListInv.inv-++ʳ nx ny '^'
(^∉DECIMALS ∘ charsInBase∈digitChars 10 cx '^')
(^∉DECIMALS ∘ charsInBase∈digitChars 10 cy '^')
eq
cancel-names = Listₚ.++-cancelʳ nx ny
(subst (λ ● → nx List.++ ('^' ∷ ●) ≡ _)
count-repr eq)
-- A fresh variable name created from inspecting a context cannot be in that context
fresh-∉' : ∀ m name (xs : Ctx n) → toChars (name , m ℕ.+ (count name xs)) ∈ᵥ.∉ apply xs
fresh-∉' m name (x ∷ xs) (here seq) with Listₚ.≡-dec Charₚ._≟_ name x
fresh-∉' m name (x ∷ xs) (here seq) | yes refl = ℕₚ.m≢1+n+m _ (begin
count name xs
≡˘⟨ Productₚ.,-injectiveʳ (toChars-injective (name , m ℕ.+ suc (count name xs)) (name , count name xs) seq) ⟩
m ℕ.+ suc (count name xs)
≡⟨ ℕₚ.+-suc m _ ⟩
suc m ℕ.+ count name xs
∎)
fresh-∉' m name (x ∷ xs) (here seq) | no ¬q = contradiction
(Productₚ.,-injectiveˡ (toChars-injective (name , m ℕ.+ count name xs) (x , count x xs) seq)) ¬q
fresh-∉' m name (x ∷ xs) (there ∈ps) with Listₚ.≡-dec Charₚ._≟_ name x
fresh-∉' m name (x ∷ xs) (there ∈ps) | yes refl rewrite ℕₚ.+-suc m (count name xs) = fresh-∉' (suc m) name _ ∈ps
fresh-∉' m name (x ∷ xs) (there ∈ps) | no ¬q = fresh-∉' m name _ ∈ps
fresh-∉ : ∀ name (xs : Ctx n) → toChars (name , count name xs) ∈ᵥ.∉ apply xs
fresh-∉ name xs = fresh-∉' zero name xs
-- Translating from de Bruijn to names results in a well-scoped process
toRaw-WellScoped : (ctx : Ctx n) (P : Scoped n) → WellScoped (apply ctx) (toRaw ctx P)
toRaw-WellScoped ctx 𝟘 = tt
toRaw-WellScoped ctx (ν P ⦃ name ⦄) = toRaw-WellScoped (name ∷ ctx) P
toRaw-WellScoped ctx (P ∥ Q) = toRaw-WellScoped ctx P , toRaw-WellScoped ctx Q
toRaw-WellScoped ctx ((x ⦅⦆ P) ⦃ name ⦄) = ∈ᵥₚ.∈-lookup _ _ , toRaw-WellScoped (name ∷ ctx) P
toRaw-WellScoped ctx (x ⟨ y ⟩ P) = ∈ᵥₚ.∈-lookup _ _ , ∈ᵥₚ.∈-lookup _ _ , toRaw-WellScoped ctx P
-- Translating from de Bruijn to names results in no shadowed variables
toRaw-NotShadowed : (ctx : Ctx n) (P : Scoped n) → NotShadowed (apply ctx) (toRaw ctx P)
toRaw-NotShadowed ctx 𝟘 = tt
toRaw-NotShadowed ctx (ν P ⦃ name ⦄) = fresh-∉ name ctx , (toRaw-NotShadowed (_ ∷ ctx) P)
toRaw-NotShadowed ctx (P ∥ Q) = toRaw-NotShadowed ctx P , toRaw-NotShadowed ctx Q
toRaw-NotShadowed ctx ((x ⦅⦆ P) ⦃ name ⦄) = fresh-∉ name ctx , toRaw-NotShadowed (name ∷ ctx) P
toRaw-NotShadowed ctx (x ⟨ y ⟩ P) = toRaw-NotShadowed ctx P
-- Translating from de Bruijn to names and back results in the same process modulo name hints
data _α-≡_ {n} : Scoped n → Scoped n → Set where
inaction : 𝟘 α-≡ 𝟘
scope : P α-≡ Q → ν P ⦃ namex ⦄ α-≡ ν Q ⦃ namey ⦄
comp : P α-≡ Q → R α-≡ S → (P ∥ R) α-≡ (Q ∥ S)
input : P α-≡ Q → (x ⦅⦆ P) ⦃ namex ⦄ α-≡ (x ⦅⦆ Q) ⦃ namey ⦄
output : P α-≡ Q → (x ⟨ y ⟩ P) α-≡ (x ⟨ y ⟩ Q)
fromRaw∘toRaw : (ctx : Ctx n) (P : Scoped n)
→ fromRaw' (apply ctx) (toRaw ctx P) (toRaw-WellScoped ctx P) α-≡ P
fromRaw∘toRaw ctx 𝟘 = inaction
fromRaw∘toRaw ctx (ν P ⦃ name ⦄) =
scope (fromRaw∘toRaw (name ∷ ctx) P)
fromRaw∘toRaw ctx (P ∥ Q) =
comp (fromRaw∘toRaw ctx P) (fromRaw∘toRaw ctx Q)
fromRaw∘toRaw ctx ((x ⦅⦆ P) ⦃ name ⦄)
rewrite fromName∘toName x (apply ctx) =
input (fromRaw∘toRaw (name ∷ ctx) P)
fromRaw∘toRaw ctx (x ⟨ y ⟩ P)
rewrite fromName∘toName x (apply ctx) | fromName∘toName y (apply ctx) =
output (fromRaw∘toRaw ctx P)
module _ where
private
variable
n : ℕ
P Q R S : Raw
x y w z : Name
ks vs : Ctx n
_∈²_ : ∀ {n} → (Name × Name) → (Ctx n × Ctx n) → Set
(x , y ) ∈² (xs , ys) = Σ[ i ∈ Fin _ ] (Vec.lookup xs i ≡ x × Vec.lookup ys i ≡ y)
infix 5 _α[_↦_]≡_
data _α[_↦_]≡_ : Raw → ∀ {n} → Ctx n → Ctx n → Raw → Set where
inaction : 𝟘 α[ ks ↦ vs ]≡ 𝟘
scope : P α[ x ∷ ks ↦ y ∷ vs ]≡ Q
→ ⦅ν x ⦆ P α[ ks ↦ vs ]≡ ⦅ν y ⦆ Q
comp : P α[ ks ↦ vs ]≡ Q
→ R α[ ks ↦ vs ]≡ S
→ P ∥ R α[ ks ↦ vs ]≡ Q ∥ S
input : (x , y) ∈² (ks , vs)
→ P α[ w ∷ ks ↦ z ∷ vs ]≡ Q
→ x ⦅ w ⦆ P α[ ks ↦ vs ]≡ y ⦅ z ⦆ Q
output : (x , y) ∈² (ks , vs)
→ (w , z) ∈² (ks , vs)
→ P α[ ks ↦ vs ]≡ Q
→ x ⟨ w ⟩ P α[ ks ↦ vs ]≡ (y ⟨ z ⟩ Q)
-- Translating a well-scoped process to de Bruijn and back results in the same process
-- modulo alpha renaming, where the new names in `apply isf` map to the old in `ctx`
toRaw∘fromRaw : (ctx : Ctx n) (P : Raw) (wsP : WellScoped ctx P)
→ toRaw ctx (fromRaw' ctx P wsP) α[ apply ctx ↦ ctx ]≡ P
toRaw∘fromRaw ctx 𝟘 wsP = inaction
toRaw∘fromRaw ctx (⦅ν x ⦆ P) wsP
= scope (toRaw∘fromRaw (x ∷ ctx) P wsP)
toRaw∘fromRaw ctx (P ∥ Q) (wsP , wsQ)
= comp (toRaw∘fromRaw ctx P wsP)
(toRaw∘fromRaw ctx Q wsQ)
toRaw∘fromRaw ctx (x ⦅ y ⦆ P) (x∈ctx , wsP)
= input (_ , refl , toName∘fromName x∈ctx)
(toRaw∘fromRaw (y ∷ ctx) P wsP)
toRaw∘fromRaw ctx (x ⟨ y ⟩ P) (x∈ctx , y∈ctx , wsP)
= output (_ , refl , toName∘fromName x∈ctx)
(_ , refl , toName∘fromName y∈ctx)
(toRaw∘fromRaw ctx P wsP)
|
test/deligatingsample/A.asm
|
tos-kamiya/agec2
| 1 |
175473
|
Compiled from "Deligating.java"
class A {
A();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 1: 0
public void foo();
Code:
0: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
3: ldc #3 // String 4
5: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
11: ldc #5 // String 5
13: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
16: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
19: ldc #6 // String 6
21: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
24: return
LineNumberTable:
line 3: 0
line 4: 8
line 5: 16
line 6: 24
}
|
module/mpc-be/SRC/src/ExtLib/VirtualDub/Kasumi/source/a_stretchrgb_point.asm
|
1aq/PBox
| 0 |
95618
|
<reponame>1aq/PBox
segment .text
struc scaleinfo
.dst resd 1
.src resd 1
.xaccum resd 1
.xfracinc resd 1
.xintinc resd 1
.count resd 1
endstruc
global _vdasm_resize_point32
_vdasm_resize_point32:
push ebp
push edi
push esi
push ebx
mov eax, [esp+4+16]
mov ebx, [eax+scaleinfo.xaccum]
mov ecx, [eax+scaleinfo.xfracinc]
mov edx, [eax+scaleinfo.src]
mov esi, [eax+scaleinfo.xintinc]
mov edi, [eax+scaleinfo.dst]
mov ebp, [eax+scaleinfo.count]
.xloop:
mov eax,[edx*4]
add ebx,ecx
adc edx,esi
mov [edi+ebp],eax
add ebp,4
jne .xloop
pop ebx
pop esi
pop edi
pop ebp
ret
global _vdasm_resize_point32_MMX
_vdasm_resize_point32_MMX:
push ebp
push edi
push esi
push ebx
mov eax, [esp+4+16]
push 0
push dword [fs:0]
mov dword [fs:0], esp
mov ebx, [eax+scaleinfo.xaccum]
mov esp, [eax+scaleinfo.xfracinc]
mov edx, [eax+scaleinfo.src]
mov esi, [eax+scaleinfo.xintinc]
mov edi, [eax+scaleinfo.dst]
mov ebp, [eax+scaleinfo.count]
mov eax, ebx
mov ecx, edx
add ebx, esp
adc edx, esi
add esp, esp
adc esi, esi
add ebp, 4
jz .odd
.dualloop:
movd mm0, dword [ecx*4]
punpckldq mm0,[edx*4]
add eax,esp
adc ecx,esi
add ebx,esp
adc edx,esi
movq [edi+ebp-4],mm0
add ebp,8
jnc .dualloop
jnz .noodd
.odd:
mov eax, [ecx*4]
mov [edi-4], eax
.noodd:
mov esp, dword [fs:0]
pop eax
pop eax
pop ebx
pop esi
pop edi
pop ebp
ret
end
|
sw/552tests/inst_tests/jal_2.asm
|
JPShen-UWM/ThreadKraken
| 1 |
9347
|
// Original test: ./bolanows/hw4/problem6/jal_2.asm
// Author: bolanows
// Test source code follows
//Basically does no jump at all
JAL 0 // Should just increment to the next PC
Nop
Halt
|
UpTo-Properties/NaturalTransFacts.agda
|
hbasold/Sandbox
| 0 |
10487
|
<filename>UpTo-Properties/NaturalTransFacts.agda
module NaturalTransFacts where
open import Level
open import Categories.Support.Equivalence
open import Categories.Category
open import Categories.Functor
open import Categories.NaturalTransformation
renaming (id to natId; _≡_ to _≡N_; setoid to natSetoid)
hiding (_∘ˡ_; _∘ʳ_)
open import Categories.Support.EqReasoning
_⇒_ = NaturalTransformation
_∘ˡ_ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F G : Functor C D}
→ (H : Functor D E) → (η : NaturalTransformation F G)
→ (H ∘ F) ⇒ (H ∘ G)
H ∘ˡ η = (natId {F = H}) ∘₀ η
_∘ʳ_ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F G : Functor C D}
→ (η : NaturalTransformation F G) → (K : Functor E C)
→ (F ∘ K) ⇒ (G ∘ K)
η ∘ʳ K = η ∘₀ (natId {F = K})
.∘₁-resp-≡ˡ : ∀ {o ℓ e} {o′ ℓ′ e′}
{D : Category o ℓ e} {E : Category o′ ℓ′ e′}
{A B C : Functor D E}
{f h : B ⇒ C} {g : A ⇒ B}
→ f ≡N h → f ∘₁ g ≡N h ∘₁ g
∘₁-resp-≡ˡ {f = f} {h} {g} f≡h
= ∘₁-resp-≡ {f = f} {h} {g} {g} f≡h (Setoid.refl natSetoid {g})
.∘₁-resp-≡ʳ : ∀ {o ℓ e} {o′ ℓ′ e′}
{D : Category o ℓ e} {E : Category o′ ℓ′ e′}
{A B C : Functor D E}
{f : B ⇒ C} {g i : A ⇒ B}
→ g ≡N i → f ∘₁ g ≡N f ∘₁ i
∘₁-resp-≡ʳ {f = f} {g} {i} g≡i
= ∘₁-resp-≡ {f = f} {f} {g} {i} (Setoid.refl natSetoid {f}) g≡i
.∘ʳ-distr-∘₁ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F G H : Functor C D}
→ (β : G ⇒ H) → (α : F ⇒ G) → (K : Functor E C)
→ (β ∘₁ α) ∘ʳ K ≡N (β ∘ʳ K) ∘₁ (α ∘ʳ K)
∘ʳ-distr-∘₁ {F = F} {G} {H} β α K =
begin
(β ∘₁ α) ∘ʳ K
↓⟨ Setoid.refl natSetoid {(β ∘₁ α) ∘ʳ K} ⟩
(β ∘₁ α) ∘₀ idK
↑⟨ ∘₀-resp-≡
{f = (β ∘₁ α)} {(β ∘₁ α)} {idK ∘₁ idK} {idK}
(Setoid.refl natSetoid {β ∘₁ α})
(identity₁ʳ {X = idK})
⟩
(β ∘₁ α) ∘₀ (idK ∘₁ idK)
↑⟨ interchange {α = β} {idK} {α} {idK} ⟩
(β ∘₀ idK) ∘₁ (α ∘₀ idK)
↓⟨ ∘₁-resp-≡
{f = β ∘₀ idK} {β ∘ʳ K} {α ∘₀ idK} {α ∘ʳ K}
(Setoid.refl natSetoid {β ∘₀ idK})
(Setoid.refl natSetoid {α ∘₀ idK})
⟩
(β ∘ʳ K) ∘₁ (α ∘ʳ K)
∎
where
open SetoidReasoning (natSetoid {F = F ∘ K} {H ∘ K})
idK = natId {F = K}
.∘ˡ-distr-∘₁ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F G H : Functor C D}
→ (K : Functor D E)
→ (β : G ⇒ H) → (α : F ⇒ G)
→ K ∘ˡ (β ∘₁ α) ≡N (K ∘ˡ β) ∘₁ (K ∘ˡ α)
∘ˡ-distr-∘₁ {F = F} {G} {H} K β α =
begin
K ∘ˡ (β ∘₁ α)
↓⟨ Setoid.refl natSetoid {K ∘ˡ (β ∘₁ α)} ⟩
idK ∘₀ (β ∘₁ α)
↑⟨ ∘₀-resp-≡
{f = idK ∘₁ idK} {idK} {(β ∘₁ α)} {(β ∘₁ α)}
(identity₁ʳ {X = idK})
(Setoid.refl natSetoid {β ∘₁ α})
⟩
(idK ∘₁ idK) ∘₀ (β ∘₁ α)
↑⟨ interchange {α = idK} {β} {idK} {α} ⟩
(idK ∘₀ β) ∘₁ (idK ∘₀ α)
↓⟨ ∘₁-resp-≡
{f = idK ∘₀ β} {K ∘ˡ β} {idK ∘₀ α} {K ∘ˡ α}
(Setoid.refl natSetoid {idK ∘₀ β})
(Setoid.refl natSetoid {idK ∘₀ α})
⟩
(K ∘ˡ β) ∘₁ (K ∘ˡ α)
∎
where
open SetoidReasoning (natSetoid {F = K ∘ F} {K ∘ H})
idK = natId {F = K}
.identityNatˡ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F : Functor C D}
→ (H : Functor D E)
→ H ∘ˡ natId {F = F} ≡N natId
identityNatˡ H = identity₀ʳ {X = natId {F = H}}
.identityNatʳ : ∀ {o₀ ℓ₀ e₀ o₁ ℓ₁ e₁ o₂ ℓ₂ e₂}
→ {C : Category o₀ ℓ₀ e₀} {D : Category o₁ ℓ₁ e₁} {E : Category o₂ ℓ₂ e₂}
→ {F : Functor C D}
→ (K : Functor E C)
→ natId {F = F} ∘ʳ K ≡N natId
identityNatʳ {F = F} K = identity₀ʳ {X = natId {F = F}}
|
Image Processing Scripts/Crop/Crop to Letterbox Format.applescript
|
bbelyeu/applescripts
| 12 |
2245
|
<gh_stars>10-100
set this_file to choose file
try
tell application "Image Events"
-- start the Image Events application
launch
-- open the image file
set this_image to open this_file
-- get dimensions of the image
copy dimensions of this_image to {W, H}
-- determine the letterbox area
set crop_W to W
-- calcluate the 16:9 proportions
set crop_H to (W * 9) / 16
-- perform action
crop this_image to dimensions {crop_W, crop_H}
-- save the changes
save this_image with icon
-- purge the open image data
close this_image
end tell
on error error_message
display dialog error_message
end try
|
Tests/yasm-regression/arithsmall.asm
|
13xforever/x86-assembly-textmate-bundle
| 69 |
174434
|
<reponame>13xforever/x86-assembly-textmate-bundle
[bits 32]
and eax, 3584 ; out: 25 00 0e 00 00
and eax, 35 ; out: 83 e0 23
and eax, strict dword 3584 ; out: 25 00 0e 00 00
and eax, strict dword 35 ; out: 25 23 00 00 00
and eax, strict byte 3584 ; out: 83 e0 00
and eax, strict byte 35 ; out: 83 e0 23
and ebx, 3584 ; out: 81 e3 00 0e 00 00
and ebx, 35 ; out: 83 e3 23
and ebx, strict dword 3584 ; out: 81 e3 00 0e 00 00
and ebx, strict dword 35 ; out: 81 e3 23 00 00 00
and ebx, strict byte 3584 ; out: 83 e3 00
and ebx, strict byte 35 ; out: 83 e3 23
|
praks5/yl3.asm
|
Leonid-98/AVR_ASM
| 0 |
242996
|
<reponame>Leonid-98/AVR_ASM<gh_stars>0
jmp main
.org 0x22 // Timer/Counter1 Compare Match A
jmp timer_interrupt
.org 0x4C
main:
// Stack init
ldi r16, low(RAMEND)
ldi r17, high(RAMEND)
out SPL, r16
out SPH, r17
// Timer init (PWM, phase and frequency Correct), 1024 prescaler
ldi r16, (1<<WGM10) | (0<<WGM11)
ldi r17, (0<<WGM12) | (1<<WGM13) | (1<<CS12) | (0<<CS11) | (1<<CS10)
ldi r18, 1<<OCIE1A // interrupt en
sts TCCR1A, r16
sts TCCR1B, r17
sts TIMSK1, r18
//turn off JTAG
in r16, MCUCR
ldi r17, (1<<JTD) // JTAG Interface Disable
or r16, r17
out MCUCR, r16 // page 336
out MCUCR, r16
// joystick
.equ joy_mask = (1<<PF4)
ldi r16, 0
ldi r17, joy_mask
out DDRF, r16
out PORTF, r17
sei // global interrupt en
// led
ldi r16, 0xFF
out DDRA, r16
out PORTA, r16
main_loop:
in r21, PINF
andi r21, joy_mask
cpi r21, joy_mask
breq on_press
ldi r20, 0 // blink delay bytes
ldi r21, 128 // blink delay bytes
sts OCR1AH, r20
sts OCR1AL, r21
rjmp main_loop
on_press:
ldi r20, 2 // blink delay bytes
ldi r21, 0 // blink delay bytes
sts OCR1AH, r20
sts OCR1AL, r21
rjmp main_loop
timer_interrupt:
push r16
in r16, SREG
push r16
in r16, PORTA
com r16
out PORTA, r16
pop r16
out SREG, r16
pop r16
reti
|
Ada95/samples/ncurses2-menu_test.adb
|
ProtonAOSP-platina/android_external_libncurses
| 269 |
28635
|
------------------------------------------------------------------------------
-- --
-- GNAT ncurses Binding Samples --
-- --
-- ncurses --
-- --
-- B O D Y --
-- --
------------------------------------------------------------------------------
-- Copyright 2020 <NAME> --
-- Copyright 2000-2006,2011 Free Software Foundation, Inc. --
-- --
-- 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, distribute with modifications, 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 ABOVE 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. --
-- --
-- Except as contained in this notice, the name(s) of the above copyright --
-- holders shall not be used in advertising or otherwise to promote the --
-- sale, use or other dealings in this Software without prior written --
-- authorization. --
------------------------------------------------------------------------------
-- Author: <NAME> <<EMAIL>> 2000
-- Version Control
-- $Revision: 1.9 $
-- $Date: 2020/02/02 23:34:34 $
-- Binding Version 01.00
------------------------------------------------------------------------------
with ncurses2.util; use ncurses2.util;
with Terminal_Interface.Curses; use Terminal_Interface.Curses;
with Terminal_Interface.Curses.Menus; use Terminal_Interface.Curses.Menus;
with Terminal_Interface.Curses.Mouse; use Terminal_Interface.Curses.Mouse;
procedure ncurses2.menu_test is
function menu_virtualize (c : Key_Code) return Key_Code;
procedure xAdd (l : Line_Position; c : Column_Position; s : String);
function menu_virtualize (c : Key_Code) return Key_Code is
begin
case c is
when Character'Pos (newl) | Key_Exit =>
return Menu_Request_Code'Last + 1; -- MAX_COMMAND? TODO
when Character'Pos ('u') =>
return M_ScrollUp_Line;
when Character'Pos ('d') =>
return M_ScrollDown_Line;
when Character'Pos ('b') | Key_Next_Page =>
return M_ScrollUp_Page;
when Character'Pos ('f') | Key_Previous_Page =>
return M_ScrollDown_Page;
when Character'Pos ('n') | Key_Cursor_Down =>
return M_Next_Item;
when Character'Pos ('p') | Key_Cursor_Up =>
return M_Previous_Item;
when Character'Pos (' ') =>
return M_Toggle_Item;
when Key_Mouse =>
return c;
when others =>
Beep;
return c;
end case;
end menu_virtualize;
MENU_Y : constant Line_Count := 8;
MENU_X : constant Column_Count := 8;
type String_Access is access String;
animals : constant array (Positive range <>) of String_Access :=
(new String'("Lions"),
new String'("Tigers"),
new String'("Bears"),
new String'("(Oh my!)"),
new String'("Newts"),
new String'("Platypi"),
new String'("Lemurs"));
items_a : constant Item_Array_Access :=
new Item_Array (1 .. animals'Last + 1);
tmp : Event_Mask;
procedure xAdd (l : Line_Position; c : Column_Position; s : String) is
begin
Add (Line => l, Column => c, Str => s);
end xAdd;
mrows : Line_Count;
mcols : Column_Count;
menuwin : Window;
m : Menu;
c1 : Key_Code;
c : Driver_Result;
r : Key_Code;
begin
tmp := Start_Mouse;
xAdd (0, 0, "This is the menu test:");
xAdd (2, 0, " Use up and down arrow to move the select bar.");
xAdd (3, 0, " 'n' and 'p' act like arrows.");
xAdd (4, 0, " 'b' and 'f' scroll up/down (page), 'u' and 'd' (line).");
xAdd (5, 0, " Press return to exit.");
Refresh;
for i in animals'Range loop
items_a.all (i) := New_Item (animals (i).all);
end loop;
items_a.all (animals'Last + 1) := Null_Item;
m := New_Menu (items_a);
Set_Format (m, Line_Position (animals'Last + 1) / 2, 1);
Scale (m, mrows, mcols);
menuwin := Create (mrows + 2, mcols + 2, MENU_Y, MENU_X);
Set_Window (m, menuwin);
Set_KeyPad_Mode (menuwin, True);
Box (menuwin); -- 0,0?
Set_Sub_Window (m, Derived_Window (menuwin, mrows, mcols, 1, 1));
Post (m);
loop
c1 := Getchar (menuwin);
r := menu_virtualize (c1);
c := Driver (m, r);
exit when c = Unknown_Request; -- E_UNKNOWN_COMMAND?
if c = Request_Denied then
Beep;
end if;
-- continue ?
end loop;
Move_Cursor (Line => Lines - 2, Column => 0);
Add (Str => "You chose: ");
Add (Str => Name (Current (m)));
Add (Ch => newl);
Pause; -- the C version didn't use Pause, it spelled it out
Post (m, False); -- unpost, not clear :-(
declare begin
Delete (menuwin);
exception when Curses_Exception => null; end;
-- menuwin has children so will raise the exception.
Delete (m);
End_Mouse (tmp);
end ncurses2.menu_test;
|
programs/oeis/057/A057074.asm
|
neoneye/loda
| 22 |
101844
|
<gh_stars>10-100
; A057074: floor[12^12/n].
; 8916100448256,4458050224128,2972033482752,2229025112064,1783220089651,1486016741376,1273728635465,1114512556032,990677827584,891610044825,810554586205,743008370688,685853880635,636864317732,594406696550
add $0,1
mov $1,8916100448256
div $1,$0
mov $0,$1
|
alloy4fun_models/trashltl/models/13/7tqnnGZk9EJLLFYjk.als
|
Kaixi26/org.alloytools.alloy
| 0 |
3998
|
<gh_stars>0
open main
pred id7tqnnGZk9EJLLFYjk_prop14 {
always all f:File | f in Trash implies f in Protected'
}
pred __repair { id7tqnnGZk9EJLLFYjk_prop14 }
check __repair { id7tqnnGZk9EJLLFYjk_prop14 <=> prop14o }
|
src/convtest/measure_units.ads
|
shintakezou/adaplayground
| 0 |
3459
|
with Converters;
-- @summary
-- Units used in aviation, operations among them and conversion
-- factors.
--
-- @description
-- Measure_Units provides all you can need to play with
-- units used in aviation, except that this is a lie because
-- this is a test, so you won't find anything really useful
-- here.
--
package Measure_Units is
Meters_per_Nautical_Mile : constant := 1852.0;
Meters_per_Foot : constant := 0.3048;
Mps_per_Knot : constant := Meters_per_Nautical_Mile/3600.0;
type Kn is new Float;
-- Knot (NM/h)
subtype Kt is Kn;
-- kt is used in aviation in place of kn
type NM is new Float;
-- Nautical Mile (1832 m by definition; it was 1/60 of a degree of
-- latitude)
type Ft is new Float;
-- Foot (0.3048 m)
type Climb_Rate is new Float;
-- Climb rate is misured in ft/min; negative values are for sink
-- rate.
type Meter is new Float;
-- Standard meter
type Mps is new Float;
-- m/s
function To_Mps (V : Kn) return Mps;
-- Convert kn to m/s.
function To_Meters (V : NM) return Meter;
-- Convert NM to meters.
function To_Meters (V : Ft) return Meter;
-- Convert ft to meters.
function "*"
(Speed : Kn;
T : Duration) return NM;
-- Speed in kn * t gives a distance.
-- @param Speed Speed expressed in knots.
-- @param T Time in seconds.
-- @return NM done in the given time.
function "*"
(CR : Climb_Rate;
T : Duration) return Ft;
-- Climb rate (ft/min) * t gives an altitude (distance).
-- @param CR Climb rate.
-- @param T Time in seconds.
-- @return the feet climbed after that time.
function "/"
(D : Ft;
T : Duration) return Climb_Rate;
-- Distance in feet / time is a Climb rate
-- @param D Diff of altitude in feet.
-- @param T Time in seconds.
-- @return the climb rate.
function To_String is new Converters.To_String (Kn);
function To_String is new Converters.To_String (Ft);
function To_String is new Converters.To_String (NM);
function To_String is new Converters.To_String (Mps);
function To_String is new Converters.To_String (Meter);
function To_String is new Converters.To_String (Climb_Rate);
function "&" is new Converters.Concat (Kn, To_String);
function "&" is new Converters.Concat (Ft, To_String);
function "&" is new Converters.Concat (NM, To_String);
function "&" is new Converters.Concat (Mps, To_String);
function "&" is new Converters.Concat (Meter, To_String);
function "&" is new Converters.Concat (Climb_Rate, To_String);
end Measure_Units;
|
data/sprites/facings.asm
|
opiter09/ASM-Machina
| 1 |
17607
|
<gh_stars>1-10
SpriteFacingAndAnimationTable:
; This table is used for overworld sprites $1-$9.
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 0
dw .WalkingDown, .NormalOAM ; facing down, walk animation frame 1
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 2
dw .WalkingDown, .FlippedOAM ; facing down, walk animation frame 3
dw .StandingUp, .NormalOAM ; facing up, walk animation frame 0
dw .WalkingUp, .NormalOAM ; facing up, walk animation frame 1
dw .StandingUp, .NormalOAM ; facing up, walk animation frame 2
dw .WalkingUp, .FlippedOAM ; facing up, walk animation frame 3
dw .StandingLeft, .NormalOAM ; facing left, walk animation frame 0
dw .WalkingLeft, .NormalOAM ; facing left, walk animation frame 1
dw .StandingLeft, .NormalOAM ; facing left, walk animation frame 2
dw .WalkingLeft, .NormalOAM ; facing left, walk animation frame 3
dw .StandingLeft, .FlippedOAM ; facing right, walk animation frame 0
dw .WalkingLeft, .FlippedOAM ; facing right, walk animation frame 1
dw .StandingLeft, .FlippedOAM ; facing right, walk animation frame 2
dw .WalkingLeft, .FlippedOAM ; facing right, walk animation frame 3
; The rest of this table is used for sprites $a and $b.
; All orientation and animation parameters lead to the same result.
; Used for immobile sprites like items on the ground.
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 0
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 1
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 2
dw .StandingDown, .NormalOAM ; facing down, walk animation frame 3
dw .StandingDown, .NormalOAM ; facing up, walk animation frame 0
dw .StandingDown, .NormalOAM ; facing up, walk animation frame 1
dw .StandingDown, .NormalOAM ; facing up, walk animation frame 2
dw .StandingDown, .NormalOAM ; facing up, walk animation frame 3
dw .StandingDown, .NormalOAM ; facing left, walk animation frame 0
dw .StandingDown, .NormalOAM ; facing left, walk animation frame 1
dw .StandingDown, .NormalOAM ; facing left, walk animation frame 2
dw .StandingDown, .NormalOAM ; facing left, walk animation frame 3
dw .StandingDown, .NormalOAM ; facing right, walk animation frame 0
dw .StandingDown, .NormalOAM ; facing right, walk animation frame 1
dw .StandingDown, .NormalOAM ; facing right, walk animation frame 2
dw .StandingDown, .NormalOAM ; facing right, walk animation frame 3
; four tile ids compose an overworld sprite
.StandingDown: db $00, $01, $02, $03
.WalkingDown: db $80, $81, $82, $83
.StandingUp: db $04, $05, $06, $07
.WalkingUp: db $84, $85, $86, $87
.StandingLeft: db $08, $09, $0a, $0b
.WalkingLeft: db $88, $89, $8a, $8b
.NormalOAM:
; y, x, attributes
db 0, 0, $00 ; top left
db 0, 8, $00 ; top right
db 8, 0, OAMFLAG_CANBEMASKED ; bottom left
db 8, 8, OAMFLAG_CANBEMASKED | OAMFLAG_ENDOFDATA ; bottom right
.FlippedOAM:
; y, x, attributes
db 0, 8, OAM_HFLIP ; top left
db 0, 0, OAM_HFLIP ; top right
db 8, 8, OAM_HFLIP | OAMFLAG_CANBEMASKED ; bottom left
db 8, 0, OAM_HFLIP | OAMFLAG_CANBEMASKED | OAMFLAG_ENDOFDATA ; bottom right
|
LAB 2/Lab2Task_1.asm
|
smellycattt/Microprocessor-Programming
| 1 |
9288
|
<reponame>smellycattt/Microprocessor-Programming
.model tiny
.486
.data
dat1 dd 45678902h,78076788h,9008123ah,345678abh,12345678h
max1 dd ?
.code
.startup
lea si,dat1
mov cx,5
lodsd
x1: cmp eax,[si]
jae x2
mov eax,[si]
x2: add si,4
loop x1
mov max1,eax
.exit
end
|
wtfx/samples/whitenoise-v2.asm
|
bushy555/ZX-Spectrum-1-Bit-Routines
| 59 |
9422
|
db 136,136,0,204,136,204,204,204,0,136,0,204,204,0,0,0
db 204,204,204,204,204,0,0,0,0,204,0,204,204,204,0,0
db 136,136,136,204,204,136,204,0,0,0,0,0,204,204,204,204
db 204,204,204,136,0,0,136,136,0,204,136,136,204,0,204,136
db 0,136,204,0,0,204,204,204,0,0,0,0,136,0,0,204
db 0,0,204,136,204,136,0,0,204,136,136,204,136,136,204,136
db 0,136,136,204,136,204,204,136,0,0,136,136,204,136,136,0
db 136,136,204,136,204,0,136,136,204,204,136,0,0,204,136,204
db 204,0,204,0,0,136,136,204,136,0,0,204,136,0,136,0
db 136,0,136,136,204,0,0,136,0,204,136,204,204,204,204,204
db 0,136,0,204,0,0,136,136,204,0,204,0,204,136,204,136
db 0,0,0,0,136,204,0,204,204,136,204,204,136,204,204,0
db 204,0,0,0,136,136,136,136,136,136,136,0,204,0,136,136
db 204,136,136,0,0,136,136,136,0,204,136,204,204,204,0,136
db 0,204,136,136,204,0,204,136,136,136,0,136,136,136,204,0
db 0,0,136,136,204,204,204,0,204,136,0,136,136,136,0,136
|
oeis/321/A321663.asm
|
neoneye/loda-programs
| 11 |
15799
|
; A321663: a(n) = prime(n)^prime(n+2).
; Submitted by <NAME>
; 32,2187,48828125,96889010407,505447028499293771,1461920290375446110677,19967568900859523802559065713,12129821994589221844500501021364910179,1635170022196481349560959748587682926364327,1284475787728524720826927656893473276744000042113841709
mov $2,$0
add $0,2
seq $0,40 ; The prime numbers.
seq $2,40 ; The prime numbers.
pow $2,$0
mov $0,$2
|
programs/oeis/325/A325689.asm
|
karttu/loda
| 0 |
2235
|
; A325689: Number of length-3 compositions of n such that no part is the sum of the other two.
; 0,0,0,1,0,6,4,15,12,28,24,45,40,66,60,91,84,120,112,153,144,190,180,231,220,276,264,325,312,378,364,435,420,496,480,561,544,630,612,703,684,780,760,861,840,946,924,1035,1012,1128,1104,1225,1200,1326,1300,1431
mov $1,$0
mov $5,$0
gcd $5,2
sub $1,$5
mov $2,$1
trn $1,$5
mov $3,$2
mul $3,2
mul $1,$3
lpb $1,1
mov $1,$4
add $1,17
fac $1
lpe
mul $1,2
div $1,8
|
wof/lcs/base/2CC.asm
|
zengfr/arcade_game_romhacking_sourcecode_top_secret_data
| 6 |
90743
|
copyright zengfr site:http://github.com/zengfr/romhack
0029B2 move.w D1, ($6,A4)
002A24 move.w ($6,PC,D0.w), D2 [base+28C, base+2AC, base+2CC]
002A8A move.b #$c, ($d,A4) [base+28C, base+2AC, base+2CC]
002AAE move.b #$c, ($d,A4) [base+28C, base+2AC, base+2CC]
002BC2 move.b #$c, ($d,A4) [base+28C, base+2AC, base+2CC]
002C44 move.w ($82,A2), D1 [base+28C, base+2AC, base+2CC]
002C68 move.b #$c, ($d,A4) [base+28C, base+2AC, base+2CC]
002C7A move.b #$c, ($d,A4) [base+28C, base+2AC, base+2CC]
002D98 bra $2b00 [base+28C, base+2AC, base+2CC]
002DC2 addq.b #2, ($4,A4) [base+28D, base+2AD, base+2CD]
002DC6 rts [base+28C, base+2AC, base+2CC]
002E40 move.b D0, ($4,A4) [base+28D, base+2AD, base+2CD]
002E44 rts [base+28C, base+2AC, base+2CC]
01A74C dbra D7, $1a74a
copyright zengfr site:http://github.com/zengfr/romhack
|
ch02/2_power_11.asm
|
zzb610/asm-learn
| 0 |
167684
|
ASSUME cs:code
code SEGMENT
mov ax, 2
mov cx, 11
s: add ax, ax
loop s
mov ax, 4c00H
code ENDS
END
|
src/Web/URI.agda
|
agda/agda-web-uri
| 1 |
15094
|
<reponame>agda/agda-web-uri
open import Data.Bool using ( Bool ; true ; false ; _∨_ )
open import Data.List.Primitive using ( #List ; [] ; _∷_ )
open import Data.Maybe using ( Maybe ; just ; nothing )
open import Data.Maybe.Primitive using ( #Maybe ; just ; nothing )
open import Data.String using ( String )
open import Web.URI.Primitive using ( #URI ; #toString ; #fromString ; #abs ; #rel )
open import Web.URI.Scheme using ( Scheme? ; http: )
open import Web.URI.Port using ( Port? ; ε )
module Web.URI where
infixl 5 _/_ _#_ _//_∶_ _//_
-- No authority or query component for now, and no parent path segments.
-- URIRef? isAbs isRef tracks whether a URI is absolute or relative,
-- and whether it is a URI reference (allows a #fragment) or not.
data URIRef? : Bool → Bool → Set where
root : {isRef : Bool} → (URIRef? false isRef)
_//_∶_ : {isRef : Bool} → Scheme? → String → Port? → (URIRef? true isRef)
_/_ : {isAbs isRef : Bool} → (URIRef? isAbs false) → String → (URIRef? isAbs isRef)
_#_ : {isAbs : Bool} → (URIRef? isAbs false) → String → (URIRef? isAbs true)
RURI = URIRef? false false
RURIRef = URIRef? false true
RURIRef? = URIRef? false
AURI = URIRef? true false
AURIRef = URIRef? true true
AURIRef? = URIRef? true
URIRef : Bool → Set
URIRef isAbs = URIRef? isAbs true
URI : Bool → Set
URI isAbs = URIRef? isAbs false
_//_ : {isRef : Bool} → Scheme? → String → (URIRef? true isRef)
s // h = s // h ∶ ε
http://_ : {isRef : Bool} → String → (URIRef? true isRef)
http:// h = http: // h
xsd: : String → AURIRef
xsd:(local) = http://"www.w3.org"/"2001"/"XMLSchema"#(local)
rdf: : String → AURIRef
rdf:(local) = http://"www.w3.org"/"1999"/"02"/"22-rdf-syntax-ns"#(local)
rdfs: : String → AURIRef
rdfs:(local) = http://"www.w3.org"/"2000"/"01"/"rdf-schema"#(local)
owl: : String → AURIRef
owl:(local) = http://"www.w3.org"/"2002"/"07"/"owl"#(local)
-- Parsing --
fromURI : {isAbs isRef : Bool} → (URIRef? isAbs false) → (URIRef? isAbs isRef)
fromURI {isAbs} {false} u = u
fromURI root = root
fromURI (s // h ∶ n) = s // h ∶ n
fromURI (u / a) = u / a
from#Path : {isAbs : Bool} → (URIRef? isAbs false) → (#List String) → (URIRef? isAbs false)
from#Path u [] = u
from#Path u (a ∷ as) = from#Path (u / a) as
from#Fragment : {isAbs isRef : Bool} → (URIRef? isAbs false) → (#Maybe String) → (Maybe (URIRef? isAbs isRef))
from#Fragment {isAbs} {true} u (just f) = just (u # f)
from#Fragment {isAbs} {false} u (just f) = nothing
from#Fragment {isAbs} {isRef} u nothing = just (fromURI u)
from#URI : {isAbs isRef : Bool} → (#Maybe #URI) → (Maybe (URIRef? isAbs isRef))
from#URI {true} (just (#abs s h n p f)) = from#Fragment (from#Path (s // h ∶ n) p) f
from#URI {false} (just (#rel p f)) = from#Fragment (from#Path root p) f
from#URI _ = nothing
fromString : {isAbs isRef : Bool} → String → (Maybe (URIRef? isAbs isRef))
fromString s = from#URI (#fromString s)
-- Serializing to#URI'
to#URI : {isAbs isRef : Bool} → (URIRef? isAbs isRef) → (#List String) → (#Maybe String) → #URI
to#URI root as f? = #rel as f?
to#URI (s // h ∶ n) as f? = #abs s h n as f?
to#URI (u / a) as f? = to#URI u (a ∷ as) f?
to#URI (u # f) as f? = to#URI u as (just f)
toString : {isAbs isRef : Bool} → (URIRef? isAbs isRef) → String
toString u = #toString (to#URI u [] nothing)
-- Composing --
_&_ : {isAbs₁ isAbs₂ isRef : Bool} → (URIRef? isAbs₁ false) → (URIRef? isAbs₂ isRef) → (URIRef? (isAbs₂ ∨ isAbs₁) isRef)
u & root = fromURI u
u & (s // h ∶ n) = s // h ∶ n
u & (v / a) = (u & v) / a
u & (v # a) = (u & v) # a
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.