hexsha stringlengths 40 40 | size int64 6 1.05M | ext stringclasses 3 values | lang stringclasses 1 value | max_stars_repo_path stringlengths 4 232 | max_stars_repo_name stringlengths 7 106 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 7 | max_stars_count int64 1 33.5k ⌀ | max_stars_repo_stars_event_min_datetime stringlengths 24 24 ⌀ | max_stars_repo_stars_event_max_datetime stringlengths 24 24 ⌀ | max_issues_repo_path stringlengths 4 232 | max_issues_repo_name stringlengths 7 106 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 7 | max_issues_count int64 1 37.5k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 4 232 | max_forks_repo_name stringlengths 7 106 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 7 | max_forks_count int64 1 12.6k ⌀ | max_forks_repo_forks_event_min_datetime stringlengths 24 24 ⌀ | max_forks_repo_forks_event_max_datetime stringlengths 24 24 ⌀ | content stringlengths 6 1.05M | avg_line_length float64 1.16 19.7k | max_line_length int64 2 938k | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6baa5d81c388e69f29907915a3e3beb9cb4328aa | 2,728 | asm | Assembly | Source/Apps/bcd.asm | davidknoll/RomWBW | 8a7bc97fea27bf10a23c61ee508522a60e2909c6 | [
"DOC",
"MIT"
] | 194 | 2015-08-20T03:18:01.000Z | 2022-03-27T02:25:00.000Z | Source/Apps/bcd.asm | davidknoll/RomWBW | 8a7bc97fea27bf10a23c61ee508522a60e2909c6 | [
"DOC",
"MIT"
] | 234 | 2017-03-30T10:59:54.000Z | 2022-03-26T20:05:52.000Z | Source/Apps/bcd.asm | davidknoll/RomWBW | 8a7bc97fea27bf10a23c61ee508522a60e2909c6 | [
"DOC",
"MIT"
] | 68 | 2016-12-18T18:20:12.000Z | 2022-03-20T16:02:40.000Z | ;;
;; make a bcd number from a binary number
;; 32 bit binary number in hl:bc, result stored at (de)
;; de is preserved, all other regs destroyed
;;
;bin2bcd:
; push ix ; save ix
; push bc ; move bc
; pop ix ; ... to ix
; ld c,32 ; loop for 32 bits of binary dword
;;
;bin2bcd0:
; ; outer loop (once for each bit in binary number)
; ld b,5 ; loop for 5 bytes of result
; push de ; save de
; add ix,ix ; left shift next bit from hl:ix
; adc hl,hl ; ... into carry
;;
;bin2bcd1:
; ; inner loop (once for each byte of bcd number)
; ld a,(de) ; get it
; adc a,a ; double it w/ carry
; daa ; decimal adjust
; ld (de),a ; save it
; inc de ; point to next bcd byte
; djnz bin2bcd1 ; loop thru all bcd bytes
;;
; ; remainder of outer loop
; pop de ; recover de
; dec c ; dec bit counter
; jr nz,bin2bcd0 ; loop till done with all bits
; pop ix ; restore ix
;
; make a bcd number from a binary number
; 32 bit binary number in de:hl, result stored at (bc)
; on output hl = bcd buf adr
;
bin2bcd:
push ix ; save ix
; convert from de:hl -> (bc) to hl:ix -> (de)
; hl -> ix, de -> hl, bc -> de
ex de,hl
push de
pop ix
push bc
pop de
;
ld c,32 ; loop for 32 bits of binary dword
;
bin2bcd0:
; outer loop (once for each bit in binary number)
ld b,5 ; loop for 5 bytes of result
push de ; save de
add ix,ix ; left shift next bit from hl:ix
adc hl,hl ; ... into carry
;
bin2bcd1:
; inner loop (once for each byte of bcd number)
ld a,(de) ; get it
adc a,a ; double it w/ carry
daa ; decimal adjust
ld (de),a ; save it
inc de ; point to next bcd byte
djnz bin2bcd1 ; loop thru all bcd bytes
;
; remainder of outer loop
pop de ; recover de
dec c ; dec bit counter
jr nz,bin2bcd0 ; loop till done with all bits
ex de,hl ; hl -> bcd buf
pop ix ; restore ix
ret
;
; print contents of 5 byte bcd number at (hl)
; with leading zero suppression
; all regs destroyed
;
prtbcd:
inc hl ; bump hl to point to
inc hl ; ...
inc hl ; ...
inc hl ; ... last byte of bcd
ld b,5 ; loop for 5 bytes
ld c,0 ; start by suppressing leading zeroes
;
prtbcd1:
; loop to print one bcd byte (two digits)
xor a ; clear accum
rld ; rotate first nibble into a
call prtbcd2 ; print it
xor a ; clear accum
rld ; rotate second nibble into a
call prtbcd2 ; print it
dec hl ; point to prior byte
djnz prtbcd1 ; loop till done
ret ; return
;
prtbcd2:
; subroutine to print a digit in a
cp c ; compare incoming to c
ret z ; if equal, suppressing, abort
dec c ; make c negative to stop suppression
add a,'0' ; offset to printable value
jp prtchr ; exit via character out
| 25.980952 | 56 | 0.628666 |
8b3b9c73c205fa7c0eacd298a403c41bbfae07c1 | 502 | asm | Assembly | programs/oeis/130/A130259.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/130/A130259.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/130/A130259.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A130259: Maximal index k of an even Fibonacci number (A001906) such that A001906(k) = Fib(2k) <= n (the 'lower' even Fibonacci Inverse).
; 0,1,1,2,2,2,2,2,3,3,3,3,3,3,3,3,3,3,3,3,3,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5
add $0,1
seq $0,130260 ; Minimal index k of an even Fibonacci number A001906 such that A001906(k) = Fib(2k) >= n (the 'upper' even Fibonacci Inverse).
sub $0,1
| 71.714286 | 201 | 0.623506 |
6d69eab8b3baa1289452e321be17c4a3fc54f6a3 | 285 | asm | Assembly | programs/oeis/212/A212342.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/212/A212342.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/212/A212342.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A212342: Sequence of coefficients of x^0 in marked mesh pattern generating function Q_{n,132}^(0,3,0,0)(x).
; 1,1,2,5,9,14,20,27,35,44,54,65,77,90,104,119,135,152,170,189,209,230,252,275,299,324,350,377,405,434,464,495,527,560,594,629
sub $1,$0
bin $1,2
trn $1,2
add $1,1
mov $0,$1
| 31.666667 | 126 | 0.684211 |
436997ef011a239a4d657ecc92223457c234c3db | 55,856 | asm | Assembly | echo.asm | zzddhhtjzz/xv6 | dcc0d9a687ef0b9c500b5b6dd6e3facb027d01fa | [
"MIT-0"
] | null | null | null | echo.asm | zzddhhtjzz/xv6 | dcc0d9a687ef0b9c500b5b6dd6e3facb027d01fa | [
"MIT-0"
] | null | null | null | echo.asm | zzddhhtjzz/xv6 | dcc0d9a687ef0b9c500b5b6dd6e3facb027d01fa | [
"MIT-0"
] | 2 | 2017-03-29T19:43:06.000Z | 2020-10-27T15:46:18.000Z |
_echo: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
#include "stat.h"
#include "user.h"
int
main(int argc, char *argv[])
{
0: 55 push %ebp
1: 89 e5 mov %esp,%ebp
3: 83 e4 f0 and $0xfffffff0,%esp
6: 83 ec 20 sub $0x20,%esp
int i;
for(i = 1; i < argc; i++)
9: c7 44 24 1c 01 00 00 movl $0x1,0x1c(%esp)
10: 00
11: eb 4b jmp 5e <main+0x5e>
printf(1, "%s%s", argv[i], i+1 < argc ? " " : "\n");
13: 8b 44 24 1c mov 0x1c(%esp),%eax
17: 83 c0 01 add $0x1,%eax
1a: 3b 45 08 cmp 0x8(%ebp),%eax
1d: 7d 07 jge 26 <main+0x26>
1f: b8 f0 0a 00 00 mov $0xaf0,%eax
24: eb 05 jmp 2b <main+0x2b>
26: b8 f2 0a 00 00 mov $0xaf2,%eax
2b: 8b 54 24 1c mov 0x1c(%esp),%edx
2f: 8d 0c 95 00 00 00 00 lea 0x0(,%edx,4),%ecx
36: 8b 55 0c mov 0xc(%ebp),%edx
39: 01 ca add %ecx,%edx
3b: 8b 12 mov (%edx),%edx
3d: 89 44 24 0c mov %eax,0xc(%esp)
41: 89 54 24 08 mov %edx,0x8(%esp)
45: c7 44 24 04 f4 0a 00 movl $0xaf4,0x4(%esp)
4c: 00
4d: c7 04 24 01 00 00 00 movl $0x1,(%esp)
54: e8 23 04 00 00 call 47c <printf>
int
main(int argc, char *argv[])
{
int i;
for(i = 1; i < argc; i++)
59: 83 44 24 1c 01 addl $0x1,0x1c(%esp)
5e: 8b 44 24 1c mov 0x1c(%esp),%eax
62: 3b 45 08 cmp 0x8(%ebp),%eax
65: 7c ac jl 13 <main+0x13>
printf(1, "%s%s", argv[i], i+1 < argc ? " " : "\n");
exit();
67: e8 68 02 00 00 call 2d4 <exit>
0000006c <stosb>:
"cc");
}
static inline void
stosb(void *addr, int data, int cnt)
{
6c: 55 push %ebp
6d: 89 e5 mov %esp,%ebp
6f: 57 push %edi
70: 53 push %ebx
asm volatile("cld; rep stosb" :
71: 8b 4d 08 mov 0x8(%ebp),%ecx
74: 8b 55 10 mov 0x10(%ebp),%edx
77: 8b 45 0c mov 0xc(%ebp),%eax
7a: 89 cb mov %ecx,%ebx
7c: 89 df mov %ebx,%edi
7e: 89 d1 mov %edx,%ecx
80: fc cld
81: f3 aa rep stos %al,%es:(%edi)
83: 89 ca mov %ecx,%edx
85: 89 fb mov %edi,%ebx
87: 89 5d 08 mov %ebx,0x8(%ebp)
8a: 89 55 10 mov %edx,0x10(%ebp)
"=D" (addr), "=c" (cnt) :
"0" (addr), "1" (cnt), "a" (data) :
"memory", "cc");
}
8d: 5b pop %ebx
8e: 5f pop %edi
8f: 5d pop %ebp
90: c3 ret
00000091 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
91: 55 push %ebp
92: 89 e5 mov %esp,%ebp
94: 83 ec 10 sub $0x10,%esp
char *os;
os = s;
97: 8b 45 08 mov 0x8(%ebp),%eax
9a: 89 45 fc mov %eax,-0x4(%ebp)
while((*s++ = *t++) != 0)
9d: 90 nop
9e: 8b 45 08 mov 0x8(%ebp),%eax
a1: 8d 50 01 lea 0x1(%eax),%edx
a4: 89 55 08 mov %edx,0x8(%ebp)
a7: 8b 55 0c mov 0xc(%ebp),%edx
aa: 8d 4a 01 lea 0x1(%edx),%ecx
ad: 89 4d 0c mov %ecx,0xc(%ebp)
b0: 0f b6 12 movzbl (%edx),%edx
b3: 88 10 mov %dl,(%eax)
b5: 0f b6 00 movzbl (%eax),%eax
b8: 84 c0 test %al,%al
ba: 75 e2 jne 9e <strcpy+0xd>
;
return os;
bc: 8b 45 fc mov -0x4(%ebp),%eax
}
bf: c9 leave
c0: c3 ret
000000c1 <strcmp>:
int
strcmp(const char *p, const char *q)
{
c1: 55 push %ebp
c2: 89 e5 mov %esp,%ebp
while(*p && *p == *q)
c4: eb 08 jmp ce <strcmp+0xd>
p++, q++;
c6: 83 45 08 01 addl $0x1,0x8(%ebp)
ca: 83 45 0c 01 addl $0x1,0xc(%ebp)
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
ce: 8b 45 08 mov 0x8(%ebp),%eax
d1: 0f b6 00 movzbl (%eax),%eax
d4: 84 c0 test %al,%al
d6: 74 10 je e8 <strcmp+0x27>
d8: 8b 45 08 mov 0x8(%ebp),%eax
db: 0f b6 10 movzbl (%eax),%edx
de: 8b 45 0c mov 0xc(%ebp),%eax
e1: 0f b6 00 movzbl (%eax),%eax
e4: 38 c2 cmp %al,%dl
e6: 74 de je c6 <strcmp+0x5>
p++, q++;
return (uchar)*p - (uchar)*q;
e8: 8b 45 08 mov 0x8(%ebp),%eax
eb: 0f b6 00 movzbl (%eax),%eax
ee: 0f b6 d0 movzbl %al,%edx
f1: 8b 45 0c mov 0xc(%ebp),%eax
f4: 0f b6 00 movzbl (%eax),%eax
f7: 0f b6 c0 movzbl %al,%eax
fa: 29 c2 sub %eax,%edx
fc: 89 d0 mov %edx,%eax
}
fe: 5d pop %ebp
ff: c3 ret
00000100 <strlen>:
uint
strlen(char *s)
{
100: 55 push %ebp
101: 89 e5 mov %esp,%ebp
103: 83 ec 10 sub $0x10,%esp
int n;
for(n = 0; s[n]; n++)
106: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
10d: eb 04 jmp 113 <strlen+0x13>
10f: 83 45 fc 01 addl $0x1,-0x4(%ebp)
113: 8b 55 fc mov -0x4(%ebp),%edx
116: 8b 45 08 mov 0x8(%ebp),%eax
119: 01 d0 add %edx,%eax
11b: 0f b6 00 movzbl (%eax),%eax
11e: 84 c0 test %al,%al
120: 75 ed jne 10f <strlen+0xf>
;
return n;
122: 8b 45 fc mov -0x4(%ebp),%eax
}
125: c9 leave
126: c3 ret
00000127 <memset>:
void*
memset(void *dst, int c, uint n)
{
127: 55 push %ebp
128: 89 e5 mov %esp,%ebp
12a: 83 ec 0c sub $0xc,%esp
stosb(dst, c, n);
12d: 8b 45 10 mov 0x10(%ebp),%eax
130: 89 44 24 08 mov %eax,0x8(%esp)
134: 8b 45 0c mov 0xc(%ebp),%eax
137: 89 44 24 04 mov %eax,0x4(%esp)
13b: 8b 45 08 mov 0x8(%ebp),%eax
13e: 89 04 24 mov %eax,(%esp)
141: e8 26 ff ff ff call 6c <stosb>
return dst;
146: 8b 45 08 mov 0x8(%ebp),%eax
}
149: c9 leave
14a: c3 ret
0000014b <strchr>:
char*
strchr(const char *s, char c)
{
14b: 55 push %ebp
14c: 89 e5 mov %esp,%ebp
14e: 83 ec 04 sub $0x4,%esp
151: 8b 45 0c mov 0xc(%ebp),%eax
154: 88 45 fc mov %al,-0x4(%ebp)
for(; *s; s++)
157: eb 14 jmp 16d <strchr+0x22>
if(*s == c)
159: 8b 45 08 mov 0x8(%ebp),%eax
15c: 0f b6 00 movzbl (%eax),%eax
15f: 3a 45 fc cmp -0x4(%ebp),%al
162: 75 05 jne 169 <strchr+0x1e>
return (char*)s;
164: 8b 45 08 mov 0x8(%ebp),%eax
167: eb 13 jmp 17c <strchr+0x31>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
169: 83 45 08 01 addl $0x1,0x8(%ebp)
16d: 8b 45 08 mov 0x8(%ebp),%eax
170: 0f b6 00 movzbl (%eax),%eax
173: 84 c0 test %al,%al
175: 75 e2 jne 159 <strchr+0xe>
if(*s == c)
return (char*)s;
return 0;
177: b8 00 00 00 00 mov $0x0,%eax
}
17c: c9 leave
17d: c3 ret
0000017e <gets>:
char*
gets(char *buf, int max)
{
17e: 55 push %ebp
17f: 89 e5 mov %esp,%ebp
181: 83 ec 28 sub $0x28,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
184: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
18b: eb 4c jmp 1d9 <gets+0x5b>
cc = read(0, &c, 1);
18d: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
194: 00
195: 8d 45 ef lea -0x11(%ebp),%eax
198: 89 44 24 04 mov %eax,0x4(%esp)
19c: c7 04 24 00 00 00 00 movl $0x0,(%esp)
1a3: e8 44 01 00 00 call 2ec <read>
1a8: 89 45 f0 mov %eax,-0x10(%ebp)
if(cc < 1)
1ab: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
1af: 7f 02 jg 1b3 <gets+0x35>
break;
1b1: eb 31 jmp 1e4 <gets+0x66>
buf[i++] = c;
1b3: 8b 45 f4 mov -0xc(%ebp),%eax
1b6: 8d 50 01 lea 0x1(%eax),%edx
1b9: 89 55 f4 mov %edx,-0xc(%ebp)
1bc: 89 c2 mov %eax,%edx
1be: 8b 45 08 mov 0x8(%ebp),%eax
1c1: 01 c2 add %eax,%edx
1c3: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1c7: 88 02 mov %al,(%edx)
if(c == '\n' || c == '\r')
1c9: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1cd: 3c 0a cmp $0xa,%al
1cf: 74 13 je 1e4 <gets+0x66>
1d1: 0f b6 45 ef movzbl -0x11(%ebp),%eax
1d5: 3c 0d cmp $0xd,%al
1d7: 74 0b je 1e4 <gets+0x66>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
1d9: 8b 45 f4 mov -0xc(%ebp),%eax
1dc: 83 c0 01 add $0x1,%eax
1df: 3b 45 0c cmp 0xc(%ebp),%eax
1e2: 7c a9 jl 18d <gets+0xf>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
1e4: 8b 55 f4 mov -0xc(%ebp),%edx
1e7: 8b 45 08 mov 0x8(%ebp),%eax
1ea: 01 d0 add %edx,%eax
1ec: c6 00 00 movb $0x0,(%eax)
return buf;
1ef: 8b 45 08 mov 0x8(%ebp),%eax
}
1f2: c9 leave
1f3: c3 ret
000001f4 <stat>:
int
stat(char *n, struct stat *st)
{
1f4: 55 push %ebp
1f5: 89 e5 mov %esp,%ebp
1f7: 83 ec 28 sub $0x28,%esp
int fd;
int r;
fd = open(n, O_RDONLY);
1fa: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
201: 00
202: 8b 45 08 mov 0x8(%ebp),%eax
205: 89 04 24 mov %eax,(%esp)
208: e8 07 01 00 00 call 314 <open>
20d: 89 45 f4 mov %eax,-0xc(%ebp)
if(fd < 0)
210: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
214: 79 07 jns 21d <stat+0x29>
return -1;
216: b8 ff ff ff ff mov $0xffffffff,%eax
21b: eb 23 jmp 240 <stat+0x4c>
r = fstat(fd, st);
21d: 8b 45 0c mov 0xc(%ebp),%eax
220: 89 44 24 04 mov %eax,0x4(%esp)
224: 8b 45 f4 mov -0xc(%ebp),%eax
227: 89 04 24 mov %eax,(%esp)
22a: e8 fd 00 00 00 call 32c <fstat>
22f: 89 45 f0 mov %eax,-0x10(%ebp)
close(fd);
232: 8b 45 f4 mov -0xc(%ebp),%eax
235: 89 04 24 mov %eax,(%esp)
238: e8 bf 00 00 00 call 2fc <close>
return r;
23d: 8b 45 f0 mov -0x10(%ebp),%eax
}
240: c9 leave
241: c3 ret
00000242 <atoi>:
int
atoi(const char *s)
{
242: 55 push %ebp
243: 89 e5 mov %esp,%ebp
245: 83 ec 10 sub $0x10,%esp
int n;
n = 0;
248: c7 45 fc 00 00 00 00 movl $0x0,-0x4(%ebp)
while('0' <= *s && *s <= '9')
24f: eb 25 jmp 276 <atoi+0x34>
n = n*10 + *s++ - '0';
251: 8b 55 fc mov -0x4(%ebp),%edx
254: 89 d0 mov %edx,%eax
256: c1 e0 02 shl $0x2,%eax
259: 01 d0 add %edx,%eax
25b: 01 c0 add %eax,%eax
25d: 89 c1 mov %eax,%ecx
25f: 8b 45 08 mov 0x8(%ebp),%eax
262: 8d 50 01 lea 0x1(%eax),%edx
265: 89 55 08 mov %edx,0x8(%ebp)
268: 0f b6 00 movzbl (%eax),%eax
26b: 0f be c0 movsbl %al,%eax
26e: 01 c8 add %ecx,%eax
270: 83 e8 30 sub $0x30,%eax
273: 89 45 fc mov %eax,-0x4(%ebp)
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
276: 8b 45 08 mov 0x8(%ebp),%eax
279: 0f b6 00 movzbl (%eax),%eax
27c: 3c 2f cmp $0x2f,%al
27e: 7e 0a jle 28a <atoi+0x48>
280: 8b 45 08 mov 0x8(%ebp),%eax
283: 0f b6 00 movzbl (%eax),%eax
286: 3c 39 cmp $0x39,%al
288: 7e c7 jle 251 <atoi+0xf>
n = n*10 + *s++ - '0';
return n;
28a: 8b 45 fc mov -0x4(%ebp),%eax
}
28d: c9 leave
28e: c3 ret
0000028f <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
28f: 55 push %ebp
290: 89 e5 mov %esp,%ebp
292: 83 ec 10 sub $0x10,%esp
char *dst, *src;
dst = vdst;
295: 8b 45 08 mov 0x8(%ebp),%eax
298: 89 45 fc mov %eax,-0x4(%ebp)
src = vsrc;
29b: 8b 45 0c mov 0xc(%ebp),%eax
29e: 89 45 f8 mov %eax,-0x8(%ebp)
while(n-- > 0)
2a1: eb 17 jmp 2ba <memmove+0x2b>
*dst++ = *src++;
2a3: 8b 45 fc mov -0x4(%ebp),%eax
2a6: 8d 50 01 lea 0x1(%eax),%edx
2a9: 89 55 fc mov %edx,-0x4(%ebp)
2ac: 8b 55 f8 mov -0x8(%ebp),%edx
2af: 8d 4a 01 lea 0x1(%edx),%ecx
2b2: 89 4d f8 mov %ecx,-0x8(%ebp)
2b5: 0f b6 12 movzbl (%edx),%edx
2b8: 88 10 mov %dl,(%eax)
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
2ba: 8b 45 10 mov 0x10(%ebp),%eax
2bd: 8d 50 ff lea -0x1(%eax),%edx
2c0: 89 55 10 mov %edx,0x10(%ebp)
2c3: 85 c0 test %eax,%eax
2c5: 7f dc jg 2a3 <memmove+0x14>
*dst++ = *src++;
return vdst;
2c7: 8b 45 08 mov 0x8(%ebp),%eax
}
2ca: c9 leave
2cb: c3 ret
000002cc <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
2cc: b8 01 00 00 00 mov $0x1,%eax
2d1: cd 40 int $0x40
2d3: c3 ret
000002d4 <exit>:
SYSCALL(exit)
2d4: b8 02 00 00 00 mov $0x2,%eax
2d9: cd 40 int $0x40
2db: c3 ret
000002dc <wait>:
SYSCALL(wait)
2dc: b8 03 00 00 00 mov $0x3,%eax
2e1: cd 40 int $0x40
2e3: c3 ret
000002e4 <pipe>:
SYSCALL(pipe)
2e4: b8 04 00 00 00 mov $0x4,%eax
2e9: cd 40 int $0x40
2eb: c3 ret
000002ec <read>:
SYSCALL(read)
2ec: b8 05 00 00 00 mov $0x5,%eax
2f1: cd 40 int $0x40
2f3: c3 ret
000002f4 <write>:
SYSCALL(write)
2f4: b8 10 00 00 00 mov $0x10,%eax
2f9: cd 40 int $0x40
2fb: c3 ret
000002fc <close>:
SYSCALL(close)
2fc: b8 15 00 00 00 mov $0x15,%eax
301: cd 40 int $0x40
303: c3 ret
00000304 <kill>:
SYSCALL(kill)
304: b8 06 00 00 00 mov $0x6,%eax
309: cd 40 int $0x40
30b: c3 ret
0000030c <exec>:
SYSCALL(exec)
30c: b8 07 00 00 00 mov $0x7,%eax
311: cd 40 int $0x40
313: c3 ret
00000314 <open>:
SYSCALL(open)
314: b8 0f 00 00 00 mov $0xf,%eax
319: cd 40 int $0x40
31b: c3 ret
0000031c <mknod>:
SYSCALL(mknod)
31c: b8 11 00 00 00 mov $0x11,%eax
321: cd 40 int $0x40
323: c3 ret
00000324 <unlink>:
SYSCALL(unlink)
324: b8 12 00 00 00 mov $0x12,%eax
329: cd 40 int $0x40
32b: c3 ret
0000032c <fstat>:
SYSCALL(fstat)
32c: b8 08 00 00 00 mov $0x8,%eax
331: cd 40 int $0x40
333: c3 ret
00000334 <link>:
SYSCALL(link)
334: b8 13 00 00 00 mov $0x13,%eax
339: cd 40 int $0x40
33b: c3 ret
0000033c <mkdir>:
SYSCALL(mkdir)
33c: b8 14 00 00 00 mov $0x14,%eax
341: cd 40 int $0x40
343: c3 ret
00000344 <chdir>:
SYSCALL(chdir)
344: b8 09 00 00 00 mov $0x9,%eax
349: cd 40 int $0x40
34b: c3 ret
0000034c <dup>:
SYSCALL(dup)
34c: b8 0a 00 00 00 mov $0xa,%eax
351: cd 40 int $0x40
353: c3 ret
00000354 <getpid>:
SYSCALL(getpid)
354: b8 0b 00 00 00 mov $0xb,%eax
359: cd 40 int $0x40
35b: c3 ret
0000035c <sbrk>:
SYSCALL(sbrk)
35c: b8 0c 00 00 00 mov $0xc,%eax
361: cd 40 int $0x40
363: c3 ret
00000364 <sleep>:
SYSCALL(sleep)
364: b8 0d 00 00 00 mov $0xd,%eax
369: cd 40 int $0x40
36b: c3 ret
0000036c <uptime>:
SYSCALL(uptime)
36c: b8 0e 00 00 00 mov $0xe,%eax
371: cd 40 int $0x40
373: c3 ret
00000374 <date>:
SYSCALL(date)
374: b8 16 00 00 00 mov $0x16,%eax
379: cd 40 int $0x40
37b: c3 ret
0000037c <clone>:
SYSCALL(clone)
37c: b8 17 00 00 00 mov $0x17,%eax
381: cd 40 int $0x40
383: c3 ret
00000384 <join>:
SYSCALL(join)
384: b8 18 00 00 00 mov $0x18,%eax
389: cd 40 int $0x40
38b: c3 ret
0000038c <threadSleep>:
SYSCALL(threadSleep)
38c: b8 19 00 00 00 mov $0x19,%eax
391: cd 40 int $0x40
393: c3 ret
00000394 <threadWake>:
SYSCALL(threadWake)
394: b8 1a 00 00 00 mov $0x1a,%eax
399: cd 40 int $0x40
39b: c3 ret
0000039c <putc>:
#include "stat.h"
#include "user.h"
static void
putc(int fd, char c)
{
39c: 55 push %ebp
39d: 89 e5 mov %esp,%ebp
39f: 83 ec 18 sub $0x18,%esp
3a2: 8b 45 0c mov 0xc(%ebp),%eax
3a5: 88 45 f4 mov %al,-0xc(%ebp)
write(fd, &c, 1);
3a8: c7 44 24 08 01 00 00 movl $0x1,0x8(%esp)
3af: 00
3b0: 8d 45 f4 lea -0xc(%ebp),%eax
3b3: 89 44 24 04 mov %eax,0x4(%esp)
3b7: 8b 45 08 mov 0x8(%ebp),%eax
3ba: 89 04 24 mov %eax,(%esp)
3bd: e8 32 ff ff ff call 2f4 <write>
}
3c2: c9 leave
3c3: c3 ret
000003c4 <printint>:
static void
printint(int fd, int xx, int base, int sgn)
{
3c4: 55 push %ebp
3c5: 89 e5 mov %esp,%ebp
3c7: 56 push %esi
3c8: 53 push %ebx
3c9: 83 ec 30 sub $0x30,%esp
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
3cc: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
if(sgn && xx < 0){
3d3: 83 7d 14 00 cmpl $0x0,0x14(%ebp)
3d7: 74 17 je 3f0 <printint+0x2c>
3d9: 83 7d 0c 00 cmpl $0x0,0xc(%ebp)
3dd: 79 11 jns 3f0 <printint+0x2c>
neg = 1;
3df: c7 45 f0 01 00 00 00 movl $0x1,-0x10(%ebp)
x = -xx;
3e6: 8b 45 0c mov 0xc(%ebp),%eax
3e9: f7 d8 neg %eax
3eb: 89 45 ec mov %eax,-0x14(%ebp)
3ee: eb 06 jmp 3f6 <printint+0x32>
} else {
x = xx;
3f0: 8b 45 0c mov 0xc(%ebp),%eax
3f3: 89 45 ec mov %eax,-0x14(%ebp)
}
i = 0;
3f6: c7 45 f4 00 00 00 00 movl $0x0,-0xc(%ebp)
do{
buf[i++] = digits[x % base];
3fd: 8b 4d f4 mov -0xc(%ebp),%ecx
400: 8d 41 01 lea 0x1(%ecx),%eax
403: 89 45 f4 mov %eax,-0xc(%ebp)
406: 8b 5d 10 mov 0x10(%ebp),%ebx
409: 8b 45 ec mov -0x14(%ebp),%eax
40c: ba 00 00 00 00 mov $0x0,%edx
411: f7 f3 div %ebx
413: 89 d0 mov %edx,%eax
415: 0f b6 80 f4 0e 00 00 movzbl 0xef4(%eax),%eax
41c: 88 44 0d dc mov %al,-0x24(%ebp,%ecx,1)
}while((x /= base) != 0);
420: 8b 75 10 mov 0x10(%ebp),%esi
423: 8b 45 ec mov -0x14(%ebp),%eax
426: ba 00 00 00 00 mov $0x0,%edx
42b: f7 f6 div %esi
42d: 89 45 ec mov %eax,-0x14(%ebp)
430: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
434: 75 c7 jne 3fd <printint+0x39>
if(neg)
436: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
43a: 74 10 je 44c <printint+0x88>
buf[i++] = '-';
43c: 8b 45 f4 mov -0xc(%ebp),%eax
43f: 8d 50 01 lea 0x1(%eax),%edx
442: 89 55 f4 mov %edx,-0xc(%ebp)
445: c6 44 05 dc 2d movb $0x2d,-0x24(%ebp,%eax,1)
while(--i >= 0)
44a: eb 1f jmp 46b <printint+0xa7>
44c: eb 1d jmp 46b <printint+0xa7>
putc(fd, buf[i]);
44e: 8d 55 dc lea -0x24(%ebp),%edx
451: 8b 45 f4 mov -0xc(%ebp),%eax
454: 01 d0 add %edx,%eax
456: 0f b6 00 movzbl (%eax),%eax
459: 0f be c0 movsbl %al,%eax
45c: 89 44 24 04 mov %eax,0x4(%esp)
460: 8b 45 08 mov 0x8(%ebp),%eax
463: 89 04 24 mov %eax,(%esp)
466: e8 31 ff ff ff call 39c <putc>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
46b: 83 6d f4 01 subl $0x1,-0xc(%ebp)
46f: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
473: 79 d9 jns 44e <printint+0x8a>
putc(fd, buf[i]);
}
475: 83 c4 30 add $0x30,%esp
478: 5b pop %ebx
479: 5e pop %esi
47a: 5d pop %ebp
47b: c3 ret
0000047c <printf>:
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
47c: 55 push %ebp
47d: 89 e5 mov %esp,%ebp
47f: 83 ec 38 sub $0x38,%esp
char *s;
int c, i, state;
uint *ap;
state = 0;
482: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
ap = (uint*)(void*)&fmt + 1;
489: 8d 45 0c lea 0xc(%ebp),%eax
48c: 83 c0 04 add $0x4,%eax
48f: 89 45 e8 mov %eax,-0x18(%ebp)
for(i = 0; fmt[i]; i++){
492: c7 45 f0 00 00 00 00 movl $0x0,-0x10(%ebp)
499: e9 7c 01 00 00 jmp 61a <printf+0x19e>
c = fmt[i] & 0xff;
49e: 8b 55 0c mov 0xc(%ebp),%edx
4a1: 8b 45 f0 mov -0x10(%ebp),%eax
4a4: 01 d0 add %edx,%eax
4a6: 0f b6 00 movzbl (%eax),%eax
4a9: 0f be c0 movsbl %al,%eax
4ac: 25 ff 00 00 00 and $0xff,%eax
4b1: 89 45 e4 mov %eax,-0x1c(%ebp)
if(state == 0){
4b4: 83 7d ec 00 cmpl $0x0,-0x14(%ebp)
4b8: 75 2c jne 4e6 <printf+0x6a>
if(c == '%'){
4ba: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
4be: 75 0c jne 4cc <printf+0x50>
state = '%';
4c0: c7 45 ec 25 00 00 00 movl $0x25,-0x14(%ebp)
4c7: e9 4a 01 00 00 jmp 616 <printf+0x19a>
} else {
putc(fd, c);
4cc: 8b 45 e4 mov -0x1c(%ebp),%eax
4cf: 0f be c0 movsbl %al,%eax
4d2: 89 44 24 04 mov %eax,0x4(%esp)
4d6: 8b 45 08 mov 0x8(%ebp),%eax
4d9: 89 04 24 mov %eax,(%esp)
4dc: e8 bb fe ff ff call 39c <putc>
4e1: e9 30 01 00 00 jmp 616 <printf+0x19a>
}
} else if(state == '%'){
4e6: 83 7d ec 25 cmpl $0x25,-0x14(%ebp)
4ea: 0f 85 26 01 00 00 jne 616 <printf+0x19a>
if(c == 'd'){
4f0: 83 7d e4 64 cmpl $0x64,-0x1c(%ebp)
4f4: 75 2d jne 523 <printf+0xa7>
printint(fd, *ap, 10, 1);
4f6: 8b 45 e8 mov -0x18(%ebp),%eax
4f9: 8b 00 mov (%eax),%eax
4fb: c7 44 24 0c 01 00 00 movl $0x1,0xc(%esp)
502: 00
503: c7 44 24 08 0a 00 00 movl $0xa,0x8(%esp)
50a: 00
50b: 89 44 24 04 mov %eax,0x4(%esp)
50f: 8b 45 08 mov 0x8(%ebp),%eax
512: 89 04 24 mov %eax,(%esp)
515: e8 aa fe ff ff call 3c4 <printint>
ap++;
51a: 83 45 e8 04 addl $0x4,-0x18(%ebp)
51e: e9 ec 00 00 00 jmp 60f <printf+0x193>
} else if(c == 'x' || c == 'p'){
523: 83 7d e4 78 cmpl $0x78,-0x1c(%ebp)
527: 74 06 je 52f <printf+0xb3>
529: 83 7d e4 70 cmpl $0x70,-0x1c(%ebp)
52d: 75 2d jne 55c <printf+0xe0>
printint(fd, *ap, 16, 0);
52f: 8b 45 e8 mov -0x18(%ebp),%eax
532: 8b 00 mov (%eax),%eax
534: c7 44 24 0c 00 00 00 movl $0x0,0xc(%esp)
53b: 00
53c: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
543: 00
544: 89 44 24 04 mov %eax,0x4(%esp)
548: 8b 45 08 mov 0x8(%ebp),%eax
54b: 89 04 24 mov %eax,(%esp)
54e: e8 71 fe ff ff call 3c4 <printint>
ap++;
553: 83 45 e8 04 addl $0x4,-0x18(%ebp)
557: e9 b3 00 00 00 jmp 60f <printf+0x193>
} else if(c == 's'){
55c: 83 7d e4 73 cmpl $0x73,-0x1c(%ebp)
560: 75 45 jne 5a7 <printf+0x12b>
s = (char*)*ap;
562: 8b 45 e8 mov -0x18(%ebp),%eax
565: 8b 00 mov (%eax),%eax
567: 89 45 f4 mov %eax,-0xc(%ebp)
ap++;
56a: 83 45 e8 04 addl $0x4,-0x18(%ebp)
if(s == 0)
56e: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
572: 75 09 jne 57d <printf+0x101>
s = "(null)";
574: c7 45 f4 f9 0a 00 00 movl $0xaf9,-0xc(%ebp)
while(*s != 0){
57b: eb 1e jmp 59b <printf+0x11f>
57d: eb 1c jmp 59b <printf+0x11f>
putc(fd, *s);
57f: 8b 45 f4 mov -0xc(%ebp),%eax
582: 0f b6 00 movzbl (%eax),%eax
585: 0f be c0 movsbl %al,%eax
588: 89 44 24 04 mov %eax,0x4(%esp)
58c: 8b 45 08 mov 0x8(%ebp),%eax
58f: 89 04 24 mov %eax,(%esp)
592: e8 05 fe ff ff call 39c <putc>
s++;
597: 83 45 f4 01 addl $0x1,-0xc(%ebp)
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
59b: 8b 45 f4 mov -0xc(%ebp),%eax
59e: 0f b6 00 movzbl (%eax),%eax
5a1: 84 c0 test %al,%al
5a3: 75 da jne 57f <printf+0x103>
5a5: eb 68 jmp 60f <printf+0x193>
putc(fd, *s);
s++;
}
} else if(c == 'c'){
5a7: 83 7d e4 63 cmpl $0x63,-0x1c(%ebp)
5ab: 75 1d jne 5ca <printf+0x14e>
putc(fd, *ap);
5ad: 8b 45 e8 mov -0x18(%ebp),%eax
5b0: 8b 00 mov (%eax),%eax
5b2: 0f be c0 movsbl %al,%eax
5b5: 89 44 24 04 mov %eax,0x4(%esp)
5b9: 8b 45 08 mov 0x8(%ebp),%eax
5bc: 89 04 24 mov %eax,(%esp)
5bf: e8 d8 fd ff ff call 39c <putc>
ap++;
5c4: 83 45 e8 04 addl $0x4,-0x18(%ebp)
5c8: eb 45 jmp 60f <printf+0x193>
} else if(c == '%'){
5ca: 83 7d e4 25 cmpl $0x25,-0x1c(%ebp)
5ce: 75 17 jne 5e7 <printf+0x16b>
putc(fd, c);
5d0: 8b 45 e4 mov -0x1c(%ebp),%eax
5d3: 0f be c0 movsbl %al,%eax
5d6: 89 44 24 04 mov %eax,0x4(%esp)
5da: 8b 45 08 mov 0x8(%ebp),%eax
5dd: 89 04 24 mov %eax,(%esp)
5e0: e8 b7 fd ff ff call 39c <putc>
5e5: eb 28 jmp 60f <printf+0x193>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
5e7: c7 44 24 04 25 00 00 movl $0x25,0x4(%esp)
5ee: 00
5ef: 8b 45 08 mov 0x8(%ebp),%eax
5f2: 89 04 24 mov %eax,(%esp)
5f5: e8 a2 fd ff ff call 39c <putc>
putc(fd, c);
5fa: 8b 45 e4 mov -0x1c(%ebp),%eax
5fd: 0f be c0 movsbl %al,%eax
600: 89 44 24 04 mov %eax,0x4(%esp)
604: 8b 45 08 mov 0x8(%ebp),%eax
607: 89 04 24 mov %eax,(%esp)
60a: e8 8d fd ff ff call 39c <putc>
}
state = 0;
60f: c7 45 ec 00 00 00 00 movl $0x0,-0x14(%ebp)
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
616: 83 45 f0 01 addl $0x1,-0x10(%ebp)
61a: 8b 55 0c mov 0xc(%ebp),%edx
61d: 8b 45 f0 mov -0x10(%ebp),%eax
620: 01 d0 add %edx,%eax
622: 0f b6 00 movzbl (%eax),%eax
625: 84 c0 test %al,%al
627: 0f 85 71 fe ff ff jne 49e <printf+0x22>
putc(fd, c);
}
state = 0;
}
}
}
62d: c9 leave
62e: c3 ret
62f: 90 nop
00000630 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
630: 55 push %ebp
631: 89 e5 mov %esp,%ebp
633: 83 ec 10 sub $0x10,%esp
Header *bp, *p;
bp = (Header*)ap - 1;
636: 8b 45 08 mov 0x8(%ebp),%eax
639: 83 e8 08 sub $0x8,%eax
63c: 89 45 f8 mov %eax,-0x8(%ebp)
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
63f: a1 10 0f 00 00 mov 0xf10,%eax
644: 89 45 fc mov %eax,-0x4(%ebp)
647: eb 24 jmp 66d <free+0x3d>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
649: 8b 45 fc mov -0x4(%ebp),%eax
64c: 8b 00 mov (%eax),%eax
64e: 3b 45 fc cmp -0x4(%ebp),%eax
651: 77 12 ja 665 <free+0x35>
653: 8b 45 f8 mov -0x8(%ebp),%eax
656: 3b 45 fc cmp -0x4(%ebp),%eax
659: 77 24 ja 67f <free+0x4f>
65b: 8b 45 fc mov -0x4(%ebp),%eax
65e: 8b 00 mov (%eax),%eax
660: 3b 45 f8 cmp -0x8(%ebp),%eax
663: 77 1a ja 67f <free+0x4f>
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
665: 8b 45 fc mov -0x4(%ebp),%eax
668: 8b 00 mov (%eax),%eax
66a: 89 45 fc mov %eax,-0x4(%ebp)
66d: 8b 45 f8 mov -0x8(%ebp),%eax
670: 3b 45 fc cmp -0x4(%ebp),%eax
673: 76 d4 jbe 649 <free+0x19>
675: 8b 45 fc mov -0x4(%ebp),%eax
678: 8b 00 mov (%eax),%eax
67a: 3b 45 f8 cmp -0x8(%ebp),%eax
67d: 76 ca jbe 649 <free+0x19>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
break;
if(bp + bp->s.size == p->s.ptr){
67f: 8b 45 f8 mov -0x8(%ebp),%eax
682: 8b 40 04 mov 0x4(%eax),%eax
685: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
68c: 8b 45 f8 mov -0x8(%ebp),%eax
68f: 01 c2 add %eax,%edx
691: 8b 45 fc mov -0x4(%ebp),%eax
694: 8b 00 mov (%eax),%eax
696: 39 c2 cmp %eax,%edx
698: 75 24 jne 6be <free+0x8e>
bp->s.size += p->s.ptr->s.size;
69a: 8b 45 f8 mov -0x8(%ebp),%eax
69d: 8b 50 04 mov 0x4(%eax),%edx
6a0: 8b 45 fc mov -0x4(%ebp),%eax
6a3: 8b 00 mov (%eax),%eax
6a5: 8b 40 04 mov 0x4(%eax),%eax
6a8: 01 c2 add %eax,%edx
6aa: 8b 45 f8 mov -0x8(%ebp),%eax
6ad: 89 50 04 mov %edx,0x4(%eax)
bp->s.ptr = p->s.ptr->s.ptr;
6b0: 8b 45 fc mov -0x4(%ebp),%eax
6b3: 8b 00 mov (%eax),%eax
6b5: 8b 10 mov (%eax),%edx
6b7: 8b 45 f8 mov -0x8(%ebp),%eax
6ba: 89 10 mov %edx,(%eax)
6bc: eb 0a jmp 6c8 <free+0x98>
} else
bp->s.ptr = p->s.ptr;
6be: 8b 45 fc mov -0x4(%ebp),%eax
6c1: 8b 10 mov (%eax),%edx
6c3: 8b 45 f8 mov -0x8(%ebp),%eax
6c6: 89 10 mov %edx,(%eax)
if(p + p->s.size == bp){
6c8: 8b 45 fc mov -0x4(%ebp),%eax
6cb: 8b 40 04 mov 0x4(%eax),%eax
6ce: 8d 14 c5 00 00 00 00 lea 0x0(,%eax,8),%edx
6d5: 8b 45 fc mov -0x4(%ebp),%eax
6d8: 01 d0 add %edx,%eax
6da: 3b 45 f8 cmp -0x8(%ebp),%eax
6dd: 75 20 jne 6ff <free+0xcf>
p->s.size += bp->s.size;
6df: 8b 45 fc mov -0x4(%ebp),%eax
6e2: 8b 50 04 mov 0x4(%eax),%edx
6e5: 8b 45 f8 mov -0x8(%ebp),%eax
6e8: 8b 40 04 mov 0x4(%eax),%eax
6eb: 01 c2 add %eax,%edx
6ed: 8b 45 fc mov -0x4(%ebp),%eax
6f0: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
6f3: 8b 45 f8 mov -0x8(%ebp),%eax
6f6: 8b 10 mov (%eax),%edx
6f8: 8b 45 fc mov -0x4(%ebp),%eax
6fb: 89 10 mov %edx,(%eax)
6fd: eb 08 jmp 707 <free+0xd7>
} else
p->s.ptr = bp;
6ff: 8b 45 fc mov -0x4(%ebp),%eax
702: 8b 55 f8 mov -0x8(%ebp),%edx
705: 89 10 mov %edx,(%eax)
freep = p;
707: 8b 45 fc mov -0x4(%ebp),%eax
70a: a3 10 0f 00 00 mov %eax,0xf10
}
70f: c9 leave
710: c3 ret
00000711 <morecore>:
static Header*
morecore(uint nu)
{
711: 55 push %ebp
712: 89 e5 mov %esp,%ebp
714: 83 ec 28 sub $0x28,%esp
char *p;
Header *hp;
if(nu < 4096)
717: 81 7d 08 ff 0f 00 00 cmpl $0xfff,0x8(%ebp)
71e: 77 07 ja 727 <morecore+0x16>
nu = 4096;
720: c7 45 08 00 10 00 00 movl $0x1000,0x8(%ebp)
p = sbrk(nu * sizeof(Header));
727: 8b 45 08 mov 0x8(%ebp),%eax
72a: c1 e0 03 shl $0x3,%eax
72d: 89 04 24 mov %eax,(%esp)
730: e8 27 fc ff ff call 35c <sbrk>
735: 89 45 f4 mov %eax,-0xc(%ebp)
if(p == (char*)-1)
738: 83 7d f4 ff cmpl $0xffffffff,-0xc(%ebp)
73c: 75 07 jne 745 <morecore+0x34>
return 0;
73e: b8 00 00 00 00 mov $0x0,%eax
743: eb 22 jmp 767 <morecore+0x56>
hp = (Header*)p;
745: 8b 45 f4 mov -0xc(%ebp),%eax
748: 89 45 f0 mov %eax,-0x10(%ebp)
hp->s.size = nu;
74b: 8b 45 f0 mov -0x10(%ebp),%eax
74e: 8b 55 08 mov 0x8(%ebp),%edx
751: 89 50 04 mov %edx,0x4(%eax)
free((void*)(hp + 1));
754: 8b 45 f0 mov -0x10(%ebp),%eax
757: 83 c0 08 add $0x8,%eax
75a: 89 04 24 mov %eax,(%esp)
75d: e8 ce fe ff ff call 630 <free>
return freep;
762: a1 10 0f 00 00 mov 0xf10,%eax
}
767: c9 leave
768: c3 ret
00000769 <malloc>:
void*
malloc(uint nbytes)
{
769: 55 push %ebp
76a: 89 e5 mov %esp,%ebp
76c: 83 ec 28 sub $0x28,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
76f: 8b 45 08 mov 0x8(%ebp),%eax
772: 83 c0 07 add $0x7,%eax
775: c1 e8 03 shr $0x3,%eax
778: 83 c0 01 add $0x1,%eax
77b: 89 45 ec mov %eax,-0x14(%ebp)
if((prevp = freep) == 0){
77e: a1 10 0f 00 00 mov 0xf10,%eax
783: 89 45 f0 mov %eax,-0x10(%ebp)
786: 83 7d f0 00 cmpl $0x0,-0x10(%ebp)
78a: 75 23 jne 7af <malloc+0x46>
base.s.ptr = freep = prevp = &base;
78c: c7 45 f0 08 0f 00 00 movl $0xf08,-0x10(%ebp)
793: 8b 45 f0 mov -0x10(%ebp),%eax
796: a3 10 0f 00 00 mov %eax,0xf10
79b: a1 10 0f 00 00 mov 0xf10,%eax
7a0: a3 08 0f 00 00 mov %eax,0xf08
base.s.size = 0;
7a5: c7 05 0c 0f 00 00 00 movl $0x0,0xf0c
7ac: 00 00 00
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
7af: 8b 45 f0 mov -0x10(%ebp),%eax
7b2: 8b 00 mov (%eax),%eax
7b4: 89 45 f4 mov %eax,-0xc(%ebp)
if(p->s.size >= nunits){
7b7: 8b 45 f4 mov -0xc(%ebp),%eax
7ba: 8b 40 04 mov 0x4(%eax),%eax
7bd: 3b 45 ec cmp -0x14(%ebp),%eax
7c0: 72 4d jb 80f <malloc+0xa6>
if(p->s.size == nunits)
7c2: 8b 45 f4 mov -0xc(%ebp),%eax
7c5: 8b 40 04 mov 0x4(%eax),%eax
7c8: 3b 45 ec cmp -0x14(%ebp),%eax
7cb: 75 0c jne 7d9 <malloc+0x70>
prevp->s.ptr = p->s.ptr;
7cd: 8b 45 f4 mov -0xc(%ebp),%eax
7d0: 8b 10 mov (%eax),%edx
7d2: 8b 45 f0 mov -0x10(%ebp),%eax
7d5: 89 10 mov %edx,(%eax)
7d7: eb 26 jmp 7ff <malloc+0x96>
else {
p->s.size -= nunits;
7d9: 8b 45 f4 mov -0xc(%ebp),%eax
7dc: 8b 40 04 mov 0x4(%eax),%eax
7df: 2b 45 ec sub -0x14(%ebp),%eax
7e2: 89 c2 mov %eax,%edx
7e4: 8b 45 f4 mov -0xc(%ebp),%eax
7e7: 89 50 04 mov %edx,0x4(%eax)
p += p->s.size;
7ea: 8b 45 f4 mov -0xc(%ebp),%eax
7ed: 8b 40 04 mov 0x4(%eax),%eax
7f0: c1 e0 03 shl $0x3,%eax
7f3: 01 45 f4 add %eax,-0xc(%ebp)
p->s.size = nunits;
7f6: 8b 45 f4 mov -0xc(%ebp),%eax
7f9: 8b 55 ec mov -0x14(%ebp),%edx
7fc: 89 50 04 mov %edx,0x4(%eax)
}
freep = prevp;
7ff: 8b 45 f0 mov -0x10(%ebp),%eax
802: a3 10 0f 00 00 mov %eax,0xf10
return (void*)(p + 1);
807: 8b 45 f4 mov -0xc(%ebp),%eax
80a: 83 c0 08 add $0x8,%eax
80d: eb 38 jmp 847 <malloc+0xde>
}
if(p == freep)
80f: a1 10 0f 00 00 mov 0xf10,%eax
814: 39 45 f4 cmp %eax,-0xc(%ebp)
817: 75 1b jne 834 <malloc+0xcb>
if((p = morecore(nunits)) == 0)
819: 8b 45 ec mov -0x14(%ebp),%eax
81c: 89 04 24 mov %eax,(%esp)
81f: e8 ed fe ff ff call 711 <morecore>
824: 89 45 f4 mov %eax,-0xc(%ebp)
827: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
82b: 75 07 jne 834 <malloc+0xcb>
return 0;
82d: b8 00 00 00 00 mov $0x0,%eax
832: eb 13 jmp 847 <malloc+0xde>
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){
834: 8b 45 f4 mov -0xc(%ebp),%eax
837: 89 45 f0 mov %eax,-0x10(%ebp)
83a: 8b 45 f4 mov -0xc(%ebp),%eax
83d: 8b 00 mov (%eax),%eax
83f: 89 45 f4 mov %eax,-0xc(%ebp)
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
842: e9 70 ff ff ff jmp 7b7 <malloc+0x4e>
}
847: c9 leave
848: c3 ret
849: 66 90 xchg %ax,%ax
84b: 90 nop
0000084c <xchg>:
asm volatile("sti");
}
static inline uint
xchg(volatile uint *addr, uint newval)
{
84c: 55 push %ebp
84d: 89 e5 mov %esp,%ebp
84f: 83 ec 10 sub $0x10,%esp
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
852: 8b 55 08 mov 0x8(%ebp),%edx
855: 8b 45 0c mov 0xc(%ebp),%eax
858: 8b 4d 08 mov 0x8(%ebp),%ecx
85b: f0 87 02 lock xchg %eax,(%edx)
85e: 89 45 fc mov %eax,-0x4(%ebp)
"+m" (*addr), "=a" (result) :
"1" (newval) :
"cc");
return result;
861: 8b 45 fc mov -0x4(%ebp),%eax
}
864: c9 leave
865: c3 ret
00000866 <pthread_create>:
#define NULL 0
#define PGSIZE (4096)
int pthread_create(mpthread_t *thread, mpthread_attr_t *attr, void(*func)(void*), void*arg){
866: 55 push %ebp
867: 89 e5 mov %esp,%ebp
869: 83 ec 28 sub $0x28,%esp
void *stack = malloc((uint)PGSIZE*2);
86c: c7 04 24 00 20 00 00 movl $0x2000,(%esp)
873: e8 f1 fe ff ff call 769 <malloc>
878: 89 45 f4 mov %eax,-0xc(%ebp)
if((uint)stack <= 0){
87b: 8b 45 f4 mov -0xc(%ebp),%eax
87e: 85 c0 test %eax,%eax
880: 75 1b jne 89d <pthread_create+0x37>
printf(1, "Malloc new stack failed in pthread_create\n");
882: c7 44 24 04 00 0b 00 movl $0xb00,0x4(%esp)
889: 00
88a: c7 04 24 01 00 00 00 movl $0x1,(%esp)
891: e8 e6 fb ff ff call 47c <printf>
return -1;
896: b8 ff ff ff ff mov $0xffffffff,%eax
89b: eb 43 jmp 8e0 <pthread_create+0x7a>
}
if((uint)stack % PGSIZE){
89d: 8b 45 f4 mov -0xc(%ebp),%eax
8a0: 25 ff 0f 00 00 and $0xfff,%eax
8a5: 85 c0 test %eax,%eax
8a7: 74 14 je 8bd <pthread_create+0x57>
stack += 4096 - ((uint)stack % PGSIZE);
8a9: 8b 45 f4 mov -0xc(%ebp),%eax
8ac: 25 ff 0f 00 00 and $0xfff,%eax
8b1: 89 c2 mov %eax,%edx
8b3: b8 00 10 00 00 mov $0x1000,%eax
8b8: 29 d0 sub %edx,%eax
8ba: 01 45 f4 add %eax,-0xc(%ebp)
}
*thread = clone(func, arg, stack);
8bd: 8b 45 f4 mov -0xc(%ebp),%eax
8c0: 89 44 24 08 mov %eax,0x8(%esp)
8c4: 8b 45 14 mov 0x14(%ebp),%eax
8c7: 89 44 24 04 mov %eax,0x4(%esp)
8cb: 8b 45 10 mov 0x10(%ebp),%eax
8ce: 89 04 24 mov %eax,(%esp)
8d1: e8 a6 fa ff ff call 37c <clone>
8d6: 8b 55 08 mov 0x8(%ebp),%edx
8d9: 89 02 mov %eax,(%edx)
return *thread;
8db: 8b 45 08 mov 0x8(%ebp),%eax
8de: 8b 00 mov (%eax),%eax
}
8e0: c9 leave
8e1: c3 ret
000008e2 <pthread_join>:
int pthread_join(mpthread_t thread, void **retval){
8e2: 55 push %ebp
8e3: 89 e5 mov %esp,%ebp
8e5: 83 ec 28 sub $0x28,%esp
void *stack;
if(join((uint)thread, &stack)<0){
8e8: 8d 45 f4 lea -0xc(%ebp),%eax
8eb: 89 44 24 04 mov %eax,0x4(%esp)
8ef: 8b 45 08 mov 0x8(%ebp),%eax
8f2: 89 04 24 mov %eax,(%esp)
8f5: e8 8a fa ff ff call 384 <join>
8fa: 85 c0 test %eax,%eax
8fc: 79 07 jns 905 <pthread_join+0x23>
return -1;
8fe: b8 ff ff ff ff mov $0xffffffff,%eax
903: eb 10 jmp 915 <pthread_join+0x33>
}
free(stack);
905: 8b 45 f4 mov -0xc(%ebp),%eax
908: 89 04 24 mov %eax,(%esp)
90b: e8 20 fd ff ff call 630 <free>
return 0;
910: b8 00 00 00 00 mov $0x0,%eax
}
915: c9 leave
916: c3 ret
00000917 <pthread_mutex_init>:
void pthread_mutex_init(mpthread_mutex_t *mutex){
917: 55 push %ebp
918: 89 e5 mov %esp,%ebp
*mutex = 0;
91a: 8b 45 08 mov 0x8(%ebp),%eax
91d: c7 00 00 00 00 00 movl $0x0,(%eax)
return;
923: 90 nop
}
924: 5d pop %ebp
925: c3 ret
00000926 <pthread_mutex_lock>:
void pthread_mutex_lock(mpthread_mutex_t *mutex){
926: 55 push %ebp
927: 89 e5 mov %esp,%ebp
929: 83 ec 08 sub $0x8,%esp
while(xchg(mutex, 1) != 0);
92c: 90 nop
92d: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
934: 00
935: 8b 45 08 mov 0x8(%ebp),%eax
938: 89 04 24 mov %eax,(%esp)
93b: e8 0c ff ff ff call 84c <xchg>
940: 85 c0 test %eax,%eax
942: 75 e9 jne 92d <pthread_mutex_lock+0x7>
return;
944: 90 nop
}
945: c9 leave
946: c3 ret
00000947 <pthread_mutex_unlock>:
void pthread_mutex_unlock(mpthread_mutex_t *mutex){
947: 55 push %ebp
948: 89 e5 mov %esp,%ebp
94a: 83 ec 08 sub $0x8,%esp
xchg(mutex, 0);
94d: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
954: 00
955: 8b 45 08 mov 0x8(%ebp),%eax
958: 89 04 24 mov %eax,(%esp)
95b: e8 ec fe ff ff call 84c <xchg>
return;
960: 90 nop
}
961: c9 leave
962: c3 ret
00000963 <pthread_cond_init>:
void pthread_cond_init(mpthread_cond_t *cond){
963: 55 push %ebp
964: 89 e5 mov %esp,%ebp
cond->threadId = -1;
966: 8b 45 08 mov 0x8(%ebp),%eax
969: c7 00 ff ff ff ff movl $0xffffffff,(%eax)
cond->next = NULL;
96f: 8b 45 08 mov 0x8(%ebp),%eax
972: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
return;
979: 90 nop
}
97a: 5d pop %ebp
97b: c3 ret
0000097c <pthread_cond_wait>:
void pthread_cond_wait(mpthread_cond_t *cond, mpthread_mutex_t *mutex){
97c: 55 push %ebp
97d: 89 e5 mov %esp,%ebp
97f: 53 push %ebx
980: 83 ec 24 sub $0x24,%esp
mpthread_cond_t *mycond = cond;
983: 8b 45 08 mov 0x8(%ebp),%eax
986: 89 45 f4 mov %eax,-0xc(%ebp)
pthread_mutex_unlock(mutex);
989: 8b 45 0c mov 0xc(%ebp),%eax
98c: 89 04 24 mov %eax,(%esp)
98f: e8 b3 ff ff ff call 947 <pthread_mutex_unlock>
//iterate the linked-list pointer to the end;
while(mycond->next != NULL)
994: eb 09 jmp 99f <pthread_cond_wait+0x23>
mycond = mycond->next;
996: 8b 45 f4 mov -0xc(%ebp),%eax
999: 8b 40 04 mov 0x4(%eax),%eax
99c: 89 45 f4 mov %eax,-0xc(%ebp)
void pthread_cond_wait(mpthread_cond_t *cond, mpthread_mutex_t *mutex){
mpthread_cond_t *mycond = cond;
pthread_mutex_unlock(mutex);
//iterate the linked-list pointer to the end;
while(mycond->next != NULL)
99f: 8b 45 f4 mov -0xc(%ebp),%eax
9a2: 8b 40 04 mov 0x4(%eax),%eax
9a5: 85 c0 test %eax,%eax
9a7: 75 ed jne 996 <pthread_cond_wait+0x1a>
mycond = mycond->next;
mycond->next = (mpthread_cond_t *)malloc(sizeof(mpthread_cond_t));
9a9: c7 04 24 08 00 00 00 movl $0x8,(%esp)
9b0: e8 b4 fd ff ff call 769 <malloc>
9b5: 8b 55 f4 mov -0xc(%ebp),%edx
9b8: 89 42 04 mov %eax,0x4(%edx)
mycond->next->threadId = getpid();
9bb: 8b 45 f4 mov -0xc(%ebp),%eax
9be: 8b 58 04 mov 0x4(%eax),%ebx
9c1: e8 8e f9 ff ff call 354 <getpid>
9c6: 89 03 mov %eax,(%ebx)
mycond->next->next = NULL;
9c8: 8b 45 f4 mov -0xc(%ebp),%eax
9cb: 8b 40 04 mov 0x4(%eax),%eax
9ce: c7 40 04 00 00 00 00 movl $0x0,0x4(%eax)
pthread_mutex_lock(mutex);
9d5: 8b 45 0c mov 0xc(%ebp),%eax
9d8: 89 04 24 mov %eax,(%esp)
9db: e8 46 ff ff ff call 926 <pthread_mutex_lock>
pthread_mutex_unlock(mutex);
9e0: 8b 45 0c mov 0xc(%ebp),%eax
9e3: 89 04 24 mov %eax,(%esp)
9e6: e8 5c ff ff ff call 947 <pthread_mutex_unlock>
threadSleep(mutex);
9eb: 8b 45 0c mov 0xc(%ebp),%eax
9ee: 89 04 24 mov %eax,(%esp)
9f1: e8 96 f9 ff ff call 38c <threadSleep>
pthread_mutex_lock(mutex);
9f6: 8b 45 0c mov 0xc(%ebp),%eax
9f9: 89 04 24 mov %eax,(%esp)
9fc: e8 25 ff ff ff call 926 <pthread_mutex_lock>
return;
a01: 90 nop
}
a02: 83 c4 24 add $0x24,%esp
a05: 5b pop %ebx
a06: 5d pop %ebp
a07: c3 ret
00000a08 <pthread_cond_signal>:
void pthread_cond_signal(mpthread_cond_t *cond){
a08: 55 push %ebp
a09: 89 e5 mov %esp,%ebp
a0b: 83 ec 28 sub $0x28,%esp
mpthread_cond_t *mycond = cond;
a0e: 8b 45 08 mov 0x8(%ebp),%eax
a11: 89 45 f4 mov %eax,-0xc(%ebp)
while(mycond->threadId==-1)
a14: eb 09 jmp a1f <pthread_cond_signal+0x17>
mycond = mycond->next;
a16: 8b 45 f4 mov -0xc(%ebp),%eax
a19: 8b 40 04 mov 0x4(%eax),%eax
a1c: 89 45 f4 mov %eax,-0xc(%ebp)
return;
}
void pthread_cond_signal(mpthread_cond_t *cond){
mpthread_cond_t *mycond = cond;
while(mycond->threadId==-1)
a1f: 8b 45 f4 mov -0xc(%ebp),%eax
a22: 8b 00 mov (%eax),%eax
a24: 83 f8 ff cmp $0xffffffff,%eax
a27: 74 ed je a16 <pthread_cond_signal+0xe>
mycond = mycond->next;
if(mycond!=NULL){
a29: 83 7d f4 00 cmpl $0x0,-0xc(%ebp)
a2d: 74 33 je a62 <pthread_cond_signal+0x5a>
int threadId = mycond->threadId;
a2f: 8b 45 f4 mov -0xc(%ebp),%eax
a32: 8b 00 mov (%eax),%eax
a34: 89 45 f0 mov %eax,-0x10(%ebp)
mpthread_cond_t *garbage = mycond;
a37: 8b 45 f4 mov -0xc(%ebp),%eax
a3a: 89 45 ec mov %eax,-0x14(%ebp)
cond->next = cond->next->next;
a3d: 8b 45 08 mov 0x8(%ebp),%eax
a40: 8b 40 04 mov 0x4(%eax),%eax
a43: 8b 50 04 mov 0x4(%eax),%edx
a46: 8b 45 08 mov 0x8(%ebp),%eax
a49: 89 50 04 mov %edx,0x4(%eax)
free(garbage);
a4c: 8b 45 ec mov -0x14(%ebp),%eax
a4f: 89 04 24 mov %eax,(%esp)
a52: e8 d9 fb ff ff call 630 <free>
threadWake(threadId);
a57: 8b 45 f0 mov -0x10(%ebp),%eax
a5a: 89 04 24 mov %eax,(%esp)
a5d: e8 32 f9 ff ff call 394 <threadWake>
}
return;
a62: 90 nop
}
a63: c9 leave
a64: c3 ret
00000a65 <pthread_sem_init>:
void pthread_sem_init(mpthread_sem_t* sem, int flag, int value){
a65: 55 push %ebp
a66: 89 e5 mov %esp,%ebp
a68: 83 ec 04 sub $0x4,%esp
sem->value = value;
a6b: 8b 45 08 mov 0x8(%ebp),%eax
a6e: 8b 55 10 mov 0x10(%ebp),%edx
a71: 89 10 mov %edx,(%eax)
pthread_cond_init(&sem->cond);
a73: 8b 45 08 mov 0x8(%ebp),%eax
a76: 83 c0 04 add $0x4,%eax
a79: 89 04 24 mov %eax,(%esp)
a7c: e8 e2 fe ff ff call 963 <pthread_cond_init>
pthread_mutex_init(&sem->mutex);
a81: 8b 45 08 mov 0x8(%ebp),%eax
a84: 83 c0 0c add $0xc,%eax
a87: 89 04 24 mov %eax,(%esp)
a8a: e8 88 fe ff ff call 917 <pthread_mutex_init>
return;
a8f: 90 nop
}
a90: c9 leave
a91: c3 ret
00000a92 <pthread_sem_wait>:
void pthread_sem_wait(mpthread_sem_t* sem){
a92: 55 push %ebp
a93: 89 e5 mov %esp,%ebp
a95: 83 ec 18 sub $0x18,%esp
sem->value --;
a98: 8b 45 08 mov 0x8(%ebp),%eax
a9b: 8b 00 mov (%eax),%eax
a9d: 8d 50 ff lea -0x1(%eax),%edx
aa0: 8b 45 08 mov 0x8(%ebp),%eax
aa3: 89 10 mov %edx,(%eax)
if(sem->value < 0){
aa5: 8b 45 08 mov 0x8(%ebp),%eax
aa8: 8b 00 mov (%eax),%eax
aaa: 85 c0 test %eax,%eax
aac: 79 18 jns ac6 <pthread_sem_wait+0x34>
pthread_cond_wait(&sem->cond, &sem->mutex);
aae: 8b 45 08 mov 0x8(%ebp),%eax
ab1: 8d 50 0c lea 0xc(%eax),%edx
ab4: 8b 45 08 mov 0x8(%ebp),%eax
ab7: 83 c0 04 add $0x4,%eax
aba: 89 54 24 04 mov %edx,0x4(%esp)
abe: 89 04 24 mov %eax,(%esp)
ac1: e8 b6 fe ff ff call 97c <pthread_cond_wait>
}
return;
ac6: 90 nop
}
ac7: c9 leave
ac8: c3 ret
00000ac9 <pthread_sem_post>:
void pthread_sem_post(mpthread_sem_t* sem){
ac9: 55 push %ebp
aca: 89 e5 mov %esp,%ebp
acc: 83 ec 18 sub $0x18,%esp
sem->value ++;
acf: 8b 45 08 mov 0x8(%ebp),%eax
ad2: 8b 00 mov (%eax),%eax
ad4: 8d 50 01 lea 0x1(%eax),%edx
ad7: 8b 45 08 mov 0x8(%ebp),%eax
ada: 89 10 mov %edx,(%eax)
pthread_cond_signal(&sem->cond);
adc: 8b 45 08 mov 0x8(%ebp),%eax
adf: 83 c0 04 add $0x4,%eax
ae2: 89 04 24 mov %eax,(%esp)
ae5: e8 1e ff ff ff call a08 <pthread_cond_signal>
return;
aea: 90 nop
}
aeb: c9 leave
aec: c3 ret
| 34.757934 | 92 | 0.439541 |
4e1d0b9fa2ac8292cf5f10c81907c2a602c43bc4 | 8,288 | asm | Assembly | engine/scoreRoutines.asm | laoo/TimePilot | 88b2548ab23d213677047ca530b68f9523ea7140 | [
"MIT"
] | 24 | 2018-05-17T05:55:38.000Z | 2021-12-30T10:22:45.000Z | engine/scoreRoutines.asm | laoo/TimePilot | 88b2548ab23d213677047ca530b68f9523ea7140 | [
"MIT"
] | 1 | 2018-06-27T11:08:01.000Z | 2018-06-27T11:08:01.000Z | engine/scoreRoutines.asm | laoo/TimePilot | 88b2548ab23d213677047ca530b68f9523ea7140 | [
"MIT"
] | 3 | 2018-05-19T03:47:19.000Z | 2021-06-01T12:33:32.000Z | ; TIMEPILOT
; score routines
.proc SCORE
; BCD mode
; A = value to add in BCD (1-99) *100 (minimum value in game is 100)
; A = 20 => score+=2000
.proc scoreAdd
clc
sed
pha
adc playerScore
sta playerScore
bcc @+
lda playerScore+1
adc #0 ; c is set
sta playerScore+1
@
pla
adc extraLifeScore
sta extraLifeScore
bcc @+
lda extraLifeScore+1
adc #0 ; c is set
sta extraLifeScore+1
@
cld
rts
.endp
.proc scoreShow
posX equ 14 ; score position on screen
clc
lda playerScore+1
pha
and #$f0
lsr
lsr
lsr
lsr
adc #16
sta bufScreenTxt+posX
pla
and #$f
adc #16
sta bufScreenTxt+posX+1
lda playerScore
pha
and #$f0
lsr
lsr
lsr
lsr
adc #16
sta bufScreenTxt+posX+2
pla
and #$f
adc #16
sta bufScreenTxt+posX+3
; temporaly - clear first zeros
ldy #0
@ lda bufScreenTxt+posX,y
cmp #16 ; ='0'
bne cleared
lda #0
sta bufScreenTxt+posX,y
iny
cpy #4
bne @-
cleared
rts
.endp
.proc hiScoreRewrite
lda hiScoreNew ; player got higscore? we wont compare again
bne rewrite
; BCD 16BIT compare player score vs highscore
lda playerScore
cmp SCORE.highScoreTableL
lda playerScore+1
sbc SCORE.highScoreTableH
bcc noHiscore
inc hiScoreNew
rewrite
ldy #0
ldx #scoreShow.posX
@
lda bufScreenTxt,x
sta bufScreenTxt+3,y
inx
iny
cpy #6
bne @-
noHiscore
rts
.endp
.proc extraLife
lda extraLifeScore+1
cmp extraLifeValue
bcc noExtraLife
addLife
lda #5
sta extraLifeValue ; next extra life after 50.000
lda #0
sta extraLifeScore
sta extraLifeScore+1
inc playerLives
lda levelCurrent.bossKilled
bne @+ ; skip extralife song if boss is killed (teleport songs will be played instead)
lda <soundSystem.soundChannelSFX+1 ; move enemy shots sfx to channel1 until extralife subsong is done
sta SPAWN.enemyShots.shotSoundNumber+5
sta SPAWN.enemyBombs.shotSoundNumber+5
lda #$10
jsr sound.soundInit.changeSong
jsr fixBossSound
lda extraLifeDurationValue ; subsong duration (in gameloop iterations)
sta extraLifeDuration
@ jmp level.showPlayerLives
noExtraLife
rts
extraLifeDurationValue dta b(44)
.endp
; --------------------
; HIGHSCORE INIT
; IN: X = highscore position/line
; --------------------
.proc highScoreInit
copyFrom equ zeroPageLocal
copyTo equ zeroPageLocal+2
lines equ zeroPageLocal+5
cpx #4
bcs lastPosition
; copy older highscores 1 line below
lda linesToCopy,x
sta lines
lda #<titleScreenTexts.hiscoreMove
sta copyFrom
lda #>titleScreenTexts.hiscoreMove
sta copyFrom+1
lda copyFrom
sta copyTo
lda copyFrom+1
sta copyTo+1
adw copyTo #20
ldx lines
line
ldy #3 ; skip first 3 bytes of every line ('1ST', '2ND' etc)
@ lda (copyFrom),y
sta (copyTo),y
iny
cpy #20
bcc @-
sbw copyFrom #20
sbw copyTo #20
dex
bne line
; copy older highscore values 1 line below
ldy lines
ldx #4
@ lda highScoreTableL,x
sta highScoreTableL+1,x
lda highScoreTableH,x
sta highScoreTableH+1,x
dex
dey
bpl @-
lastPosition
; copy player score to highscore values table
ldx SCORE.highScoreLine
lda playerScore
sta SCORE.highScoreTableL,x
lda playerScore+1
sta SCORE.highScoreTableH,x
inc doHighScoreFlag
ldx #5
@ lda bufScreenTxt+14,x
sta newHighScore,x
dex
bpl @-
rts
linesToCopy dta b(4),b(3),b(2),b(1)
.endp
; -----------------------------
; FIND HIGHSCORE
; OUT: A>0 - we got highscore
; -----------------------------
.proc findHighScore
ldx #$ff
@ inx
cpx #5
bcs noHigh
lda playerScore
cmp SCORE.highScoreTableL,x
lda playerScore+1
sbc SCORE.highScoreTableH,x
bcc @-
stx SCORE.highScoreLine ; cache - used in doHighScore
lda #1
rts
noHigh
lda #0
rts
.endp
; ----------------------
; DO HIGHSCORE
; ----------------------
.proc doHighScore
screenLine equ zeroPageLocal ; 2 bytes
titleScreenLine equ zeroPageLocal+2 ; 2 bytes
hiscoreLine equ zeroPageLocal+4 ; 2 bytes
lda #$21 ; 'A'
sta letter
sta letterCurrent
lda #2
sta titleScreen.screenMode
jsr setTitleScreenNMI
jsr titleScreenMode2
lda #>bufScreenTxt
sta screenLine+1
lda #<bufScreenTxt
sta screenLine
ldx SCORE.highScoreLine ; line position on screen for new highscore
inx
@ adw screenLine #20
dex
bpl @-
lda #0
sta letterCounter
ldx #4 ; clear old highscore nickname
ldy #15
@ sta (screenLine),y
iny
dex
bpl @-
ldx #5 ; put new highscore on screen
ldy #11
@ lda SCORE.newHighScore,x
sta (screenLine),y
dey
dex
bpl @-
lda #configMusicHighScore
jsr sound.soundInit.changeSong
ldy #15
hiLoop
lda letter
eor letterCurrent
sta letter
sta (screenLine),y
lda changeLetterDelay
beq @+
dec changeLetterDelay
ldx #changeLetterDelayValue
jsr waitXFrames
@
jsr deleteLetter
jsr nextLetter
jsr changeLetter
ldx #10
jsr waitJoyXFrames
cpy #20
bcc hiLoop
finish
; rewrite highscore to titlescreen string
lda #>titleScreenTexts.hiscore
sta titleScreenLine+1
lda #<titleScreenTexts.hiscore
sta titleScreenLine
adw titleScreenLine #2
lda #>playfieldTexts.score2
sta hiscoreLine+1
lda #<playfieldTexts.score2
sta hiscoreLine
sbw hiscoreLine #4
ldx SCORE.highScoreLine ; line position on screen for new highscore
@ adw titleScreenLine #20
dex
bpl @-
ldy #6
scoreRewrite
lda (screenLine),y
sta (titleScreenLine),y
iny
cpy #12
bcs @+
ldx SCORE.highScoreLine
bne @+
sta (hiscoreLine),y ; 1st place highscore rewrite for playfield
@
cpy #20
bcc scoreRewrite
ldx #50
jsr waitXFrames
lda #0
sta doHighScoreFlag
sta titleScreen.screenMode
lda #0
jsr sound.soundInit.changeSong
jmp main
.proc nextLetter ; joy trigger pressed - move to next letter
lda trig0
bne @+
lda #soundNumber
sta soundSystem.soundChannelSFX+3
lda #soundNote
sta soundSystem.soundChannelNote+3
inc letterCounter
lda letterCurrent
sta (screenLine),y
ldx #18
jsr waitXFrames
iny
@ rts
.endp
.proc deleteLetter ; delete letter (joy left)
lda letterCounter
beq @+
lda porta
eor #$ff
and #$f
cmp #4
bne @+
lda #soundNumberDelete
sta soundSystem.soundChannelSFX+3
lda #soundNote
sta soundSystem.soundChannelNote+3
dec letterCounter
lda #0
sta (screenLine),y
ldx #18
jsr waitXFrames
dey
@ rts
.endp
.proc changeLetter ; empty space in highscore added by Nir Dary
lda porta
eor #$ff
and #$f
tax
cpx #1 ; joyUp
bne @+
ldx letterCurrent
cpx #$3a ; 'Z' ($3a)
bcs doNothing
cpx #00 ; Check for Space Charecter
bne notspace1
lda #$20
sta letterCurrent
notspace1
inc letterCurrent
lda #0
sta letter
inc changeLetterDelay
rts
@ cpx #2 ; joyDown
bne doNothing
ldx letterCurrent
cpx #$20 ; 'A' ($21)
beq doNothing
cpx #00 ; check for space charecter
bne notspace2
lda #$21 ; after space comes 'A'
sta letterCurrent
notspace2
dec letterCurrent
lda letterCurrent
cmp #$20 ; one below 'A'
bne space
lda #0
sta letterCurrent ; insert space
space
lda #0
sta letter
inc changeLetterDelay
rts
doNothing
rts
.endp
letter dta b($21) ; 'A'
letterCurrent dta b($21)
letterCounter dta b(0)
changeLetterDelay dta b(0)
changeLetterDelayValue equ 6
soundNumber equ 4
soundNumberDelete equ 2
soundNote equ 0
.endp
doHighScoreFlag dta b(0)
newHighScore dta ' ' ; buffer for new highscore
; BCD highscores
highScoreTableL dta b($0), b($88), b($84), b($65), b($43), b(0) ; last value is for temporary buffer
highScoreTableH dta b($1), b(0), b($0), b($0), b($0), b(0)
highScoreLine dta b(0)
.endp
| 18.879271 | 105 | 0.633205 |
93a1c1aa401a2135967beb45ca3cd5afe1e20948 | 1,313 | asm | Assembly | exercises/practice/allergies/.meta/example.asm | jonboland/x86-64-assembly | b0d586078b2f9e32ac6cd1de1d833282b2c336c0 | [
"MIT"
] | 21 | 2019-05-12T20:06:11.000Z | 2022-02-06T23:16:13.000Z | exercises/practice/allergies/.meta/example.asm | jonboland/x86-64-assembly | b0d586078b2f9e32ac6cd1de1d833282b2c336c0 | [
"MIT"
] | 49 | 2019-04-23T19:17:26.000Z | 2022-03-12T14:30:44.000Z | exercises/practice/allergies/.meta/example.asm | jonboland/x86-64-assembly | b0d586078b2f9e32ac6cd1de1d833282b2c336c0 | [
"MIT"
] | 21 | 2019-05-19T21:29:07.000Z | 2022-01-18T08:58:52.000Z | ;
; Given a person's allergy score, determine whether or not they're allergic to
; a given item.
;
; Parameters:
; rdi - item
; rsi - score
; Returns:
; rax - true if allergic, else false
;
section .text
global allergic_to
allergic_to:
xor eax, eax ; Set return value
bt esi, edi ; Select the bit in score at the bit-position represented by the item
setc al ; Return true if the bit is set, else false
ret
;
; Given a person's allergy score, determine their full list of allergies.
;
; Parameters:
; rdi - score
; rsi - list
;
global list
list:
mov rcx, rsi ; Save list
mov esi, edi ; Set score
xor edx, edx ; Set current list index
xor edi, edi ; Set current item
.loop_start:
call allergic_to
test al, al ; Check if allergic to item
je .next ; If not, process next item
mov [rcx + rdx * 4 + 4], edi ; Add item to list
inc edx ; Increment current list index
.next:
inc edi ; Advance to next item
cmp edi, 8 ; See if we reached the last item
jne .loop_start ; If items remain, loop back
mov [rcx], edx ; Set list size
ret
| 28.543478 | 86 | 0.557502 |
1258011fdccd8caae14e2ca5bfe3dd00f5ad6664 | 3,778 | asm | Assembly | XundeShenanigans/Assembler.asm | bearcott/CompArchAssembler | 081101ee004a678ac41a759e0fc91478b44bfd3a | [
"MIT"
] | 1 | 2016-04-08T08:24:53.000Z | 2016-04-08T08:24:53.000Z | XundeShenanigans/Assembler.asm | bearcott/CompArchAssembler | 081101ee004a678ac41a759e0fc91478b44bfd3a | [
"MIT"
] | 1 | 2017-10-10T20:24:08.000Z | 2017-10-10T20:26:48.000Z | XundeShenanigans/Assembler.asm | bearcott/CompArchAssembler | 081101ee004a678ac41a759e0fc91478b44bfd3a | [
"MIT"
] | null | null | null | .data
fin: .asciiz "test.asm" # filename for input
buffer: .space 1024
myString: .word 268501009
register: .space 4
prompt1: .asciiz "****************************************************\n"
string1: .space 16
string2: .space 16
string3: .space 16
string4: .space 16
s0: .asciiz "$s0"
s1: .asciiz "$s1"
s2: .asciiz "$s2"
add: .asciiz "add"
minus: .asciiz "minus"
.text
#open a file for writing
li $v0, 13 # system call for open file
la $a0, fin # board file name
li $a1, 0 # Open for reading
li $a2, 0
syscall # open a file (file descriptor returned in $v0)
move $s7, $v0 # save the file descriptor
#read from file
li $v0, 14 # system call for read from file
move $a0, $s7 # file descriptor
la $a1, buffer # address of buffer to which to read
li $a2, 1024 # hardcoded buffer length
syscall # read from file
Store: # will store the contents of the file in $t0
li $v0, 4 # system call code for print string
la $a0, prompt1 # load address of prompt1 into $a0
syscall # call operating system to perform operation
LbLoop:
li $t2, 70 # t0 is a constant THAT WE CAN CHANGE FOR THE AMOUNT OF CHARAACTERS
li $t3, 0 # t1 is our counter (i)
li $t7, ' ' # load $s0 with "space"
li $t8, ',' # load $s1 with ","
li $t9, '\n' # load $s2 with newline character
la $s4, string1
la $s5, string2
la $s6, string3
la $t6, string4
la $t0, buffer
loop1: #store first op function into string1
lb $t1, ($t0)
addi $t0, $t0, 1
beq $t1, $t7, loop2 #skip space
sb $t1, ($s4)
addi $s4, $s4, 1
j loop1 # jump back to the top
loop2: #store first oprand into string2
lb $t1, ($t0)
addi $t0, $t0, 1
beq $t1, $t8, loop3 #skip ,
sb $t1, ($s5)
addi $s5, $s5, 1
j loop2 # jump back to the top
loop3: #store second oprand into string3
lb $t1, ($t0)
addi $t0, $t0, 1
beq $t1, $t8, loop4 #skip ,
sb $t1, ($s6)
addi $s6, $s6, 1
j loop3 # jump back to the top
loop4: #store third oprand into string5
lb $t1, ($t0)
addi $t0, $t0, 1
beq $t1, $t9, Add #skip newline
sb $t1, ($t6)
addi $t6, $t6, 1
j loop4 # jump back to the top
Add:
#need a function to compare two string, byte by byte!
addi $s0, $zero, 20 # $s0 store op code
jal findReg1 # repeatedly find the reg1
jal findReg2 # repeatedly find the reg2
jal findReg3 # repeatedly find the reg3
sll $s1, $s1, 21 # shift left to get the correct position
sll $s2, $s2, 16
sll $s3, $s3, 11
or $s0, $s0, $s1 # use "or" to get the final value
or $s0, $s0, $s2
or $s0, $s0, $s3
move $a0, $s0
li $v0, 1 # system call code for print integer
syscall
jal loop1
findReg1:
#need a function to compare two string, byte by byte!
findReg2:
#need a function to compare two string, byte by byte!
findReg3:
#need a function to compare two string, byte by byte!
exit:
jr $ra
Minus:
# Close the file
end:
# for test only
li $v0, 4 # system call code for print string
la $a0, string1 # load address
syscall # call operating system to perform operation
li $v0, 4 # system call code for print string
la $a0, string2 # load address
syscall # call operating system to perform operation
li $v0, 4 # system call code for print string
la $a0, string3 # load address
syscall # call operating system to perform operation
li $v0, 4 # system call code for print string
la $a0, string4 # load address
syscall # call operating system to perform operation
li $v0, 16 # system call for close file
move $a0, $s7 # file descriptor to close
syscall # close file
| 26.236111 | 80 | 0.604288 |
d4ad8a26e29b5ab246bbf6e021602eb5502b8cb6 | 430 | asm | Assembly | oeis/020/A020958.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/020/A020958.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/020/A020958.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A020958: a(n) = Sum_{k >= 1} floor(3*tau^(n-k)).
; Submitted by Jon Maiga
; 5,9,16,28,48,81,134,221,361,589,957,1554,2519,4082,6610,10702,17322,28035,45368,73415,118795,192223,311031,503268,814313,1317596,2131924,3449536,5581476,9031029,14612522,23643569,38256109,61899697,100155825,162055542,262211387
mov $1,$0
seq $0,14739 ; Expansion of (1+x^2)/(1-2*x+x^3).
mul $0,6
sub $0,$1
sub $0,1
div $0,2
add $0,3
cmp $1,1
add $0,$1
| 30.714286 | 228 | 0.704651 |
fdcf799825ed968706db5c563ab92a6cff417679 | 560 | asm | Assembly | programs/oeis/214/A214971.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/214/A214971.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/214/A214971.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A214971: Integers k for which the base-phi representation of k includes 1.
; 1,4,8,11,15,19,22,26,29,33,37,40,44,48,51,55,58,62,66,69,73,76,80,84,87,91,95,98,102,105,109,113,116,120,124,127,131,134,138,142,145,149,152,156,160,163,167,171,174,178,181,185,189,192,196,199,203,207,210,214,218,221,225,228,232,236,239,243,247,250,254,257,261,265,268,272,275,279,283,286,290,294,297,301,304,308,312,315,319,323,326,330,333,337,341,344,348,351,355,359
mov $1,$0
seq $1,26356 ; a(n) = floor((n-1)*phi) + n + 1, n > 0, where phi = (1+sqrt(5))/2.
sub $1,1
add $0,$1
| 70 | 370 | 0.685714 |
eb306642b406d7b3ac92be917b60758740cf3e26 | 529 | asm | Assembly | appload/slrload.asm | DigitalMars/optlink | 493de158282046641ef2a3a60a88e25e26d88ec4 | [
"BSL-1.0"
] | 28 | 2015-02-03T01:38:24.000Z | 2022-03-23T05:48:24.000Z | appload/slrload.asm | DigitalMars/optlink | 493de158282046641ef2a3a60a88e25e26d88ec4 | [
"BSL-1.0"
] | 20 | 2015-01-02T14:51:20.000Z | 2021-01-09T21:37:19.000Z | appload/slrload.asm | DigitalMars/optlink | 493de158282046641ef2a3a60a88e25e26d88ec4 | [
"BSL-1.0"
] | 9 | 2015-02-11T17:43:56.000Z | 2019-09-05T11:07:02.000Z |
INCLUDE ..\COMMON\MACROS
.CODE PASS1_TEXT
PUBLIC SLRLOAD_ENTRY,SLRLOAD_BOX_ENTRY
SLRLOAD_ENTRY PROC
;
;
;
MOV EAX,OFF SLRLOAD_OBJ
MOV ECX,SLRLOAD_OBJ_LEN
RET
SLRLOAD_ENTRY ENDP
SLRLOAD_BOX_ENTRY PROC
;
;
;
MOV EAX,OFF SLRLOAD_BOX_OBJ
MOV ECX,SLRLOAD_BOX_OBJ_LEN
RET
SLRLOAD_BOX_ENTRY ENDP
.CONST
SLRLOAD_OBJ LABEL BYTE
INCLUDE SLRLOAD.DAT
SLRLOAD_OBJ_LEN EQU $-SLRLOAD_OBJ
SLRLOAD_BOX_OBJ LABEL BYTE
INCLUDE SLRLOADB.DAT
SLRLOAD_BOX_OBJ_LEN EQU $-SLRLOAD_BOX_OBJ
END
| 10.173077 | 41 | 0.744802 |
a74d2ac5c99b25b667ad2cdfe6ea8103d8be9d9c | 3,770 | asm | Assembly | Transynther/x86/_processed/NONE/_ht_/i7-7700_9_0x48_notsx.log_3_1310.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_ht_/i7-7700_9_0x48_notsx.log_3_1310.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_ht_/i7-7700_9_0x48_notsx.log_3_1310.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r8
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_normal_ht+0x1b1f, %rax
xor $62374, %rdx
vmovups (%rax), %ymm1
vextracti128 $1, %ymm1, %xmm1
vpextrq $0, %xmm1, %r8
nop
xor $64652, %r14
lea addresses_WT_ht+0xa8ff, %rsi
lea addresses_D_ht+0xc9bf, %rdi
dec %r8
mov $17, %rcx
rep movsb
cmp $18545, %rax
lea addresses_D_ht+0x1b7e1, %rcx
clflush (%rcx)
nop
nop
nop
nop
nop
xor %r14, %r14
vmovups (%rcx), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %rax
and $38480, %rax
lea addresses_WT_ht+0xbd9f, %rsi
lea addresses_WT_ht+0x1b8ff, %rdi
sub %r8, %r8
mov $46, %rcx
rep movsl
cmp $15426, %rdx
lea addresses_A_ht+0xcd9f, %rsi
lea addresses_UC_ht+0x14b1f, %rdi
clflush (%rdi)
nop
nop
xor %r10, %r10
mov $32, %rcx
rep movsq
sub %rsi, %rsi
lea addresses_WC_ht+0x691f, %rsi
lea addresses_WT_ht+0x190ff, %rdi
nop
nop
dec %r10
mov $109, %rcx
rep movsl
nop
nop
xor $8788, %rdx
lea addresses_WC_ht+0x112cf, %rcx
nop
and %rdi, %rdi
movw $0x6162, (%rcx)
add %r14, %r14
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r15
push %r8
push %r9
push %rax
push %rbx
push %rdi
push %rdx
// Store
lea addresses_D+0x1f2bf, %rdx
nop
nop
nop
and $57904, %r8
mov $0x5152535455565758, %r9
movq %r9, %xmm7
vmovaps %ymm7, (%rdx)
nop
nop
nop
dec %rax
// Store
lea addresses_A+0xbb1f, %r8
nop
and %rbx, %rbx
movl $0x51525354, (%r8)
and $33082, %rax
// Store
lea addresses_PSE+0x1d007, %rax
sub $73, %rdi
mov $0x5152535455565758, %rbx
movq %rbx, %xmm7
movups %xmm7, (%rax)
nop
nop
sub %r9, %r9
// Store
lea addresses_US+0x7bdf, %r9
nop
xor $42329, %rdi
movl $0x51525354, (%r9)
nop
nop
cmp $57622, %r9
// Faulty Load
lea addresses_A+0xbb1f, %rax
xor $35176, %r8
movups (%rax), %xmm3
vpextrq $1, %xmm3, %rbx
lea oracles, %r15
and $0xff, %rbx
shlq $12, %rbx
mov (%r15,%rbx,1), %rbx
pop %rdx
pop %rdi
pop %rbx
pop %rax
pop %r9
pop %r8
pop %r15
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_A', 'congruent': 0}}
{'dst': {'same': False, 'NT': False, 'AVXalign': True, 'size': 32, 'type': 'addresses_D', 'congruent': 4}, 'OP': 'STOR'}
{'dst': {'same': True, 'NT': True, 'AVXalign': False, 'size': 4, 'type': 'addresses_A', 'congruent': 0}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_PSE', 'congruent': 3}, 'OP': 'STOR'}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_US', 'congruent': 2}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_A', 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_normal_ht', 'congruent': 11}}
{'dst': {'same': False, 'congruent': 5, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_WT_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_D_ht', 'congruent': 1}}
{'dst': {'same': False, 'congruent': 5, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_WT_ht'}}
{'dst': {'same': True, 'congruent': 10, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 5, 'type': 'addresses_A_ht'}}
{'dst': {'same': True, 'congruent': 5, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': True, 'congruent': 9, 'type': 'addresses_WC_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': True, 'size': 2, 'type': 'addresses_WC_ht', 'congruent': 2}, 'OP': 'STOR'}
{'45': 3}
45 45 45
*/
| 22.848485 | 148 | 0.645358 |
bc984a7443c744987818b604fcadf0d467aadf3b | 3,411 | asm | Assembly | private/shell/win16/commctrl/dllentry.asm | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 11 | 2017-09-02T11:27:08.000Z | 2022-01-02T15:25:24.000Z | private/shell/win16/commctrl/dllentry.asm | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | null | null | null | private/shell/win16/commctrl/dllentry.asm | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 14 | 2019-01-16T01:01:23.000Z | 2022-02-20T15:54:27.000Z | PAGE,132
;***************************************************************************
;*
;* DLLENTRY.ASM
;*
;* VER.DLL Entry code
;*
;* This module generates a code segment called _INIT.
;* It initializes the local heap if one exists and then calls
;* the C routine LibMain() which should have the form:
;* BOOL FAR PASCAL LibMain(HANDLE hInstance,
;* WORD wDataSeg,
;* WORD cbHeap,
;* LPSTR lpszCmdLine);
;*
;* The result of the call to LibMain is returned to Windows.
;* The C routine should return TRUE if it completes initialization
;* successfully, FALSE if some error occurs.
;*
;**************************************************************************
INCLUDE CMACROS.INC
externFP <LIBMAIN> ;The C routine to be called
ifndef SEGNAME
SEGNAME equ <_INIT> ; default seg name
endif
createSeg %SEGNAME, CodeSeg, word, public, CODE
sBegin CodeSeg ; this defines what seg this goes in
assumes cs,CodeSeg
?PLM=0 ;'C'naming
externA <_acrtused> ;Ensures that Win DLL startup code is linked
?PLM=1 ;'PASCAL' naming
externFP <LOCALINIT> ;Windows heap init routine
cProc LibEntry, <PUBLIC,FAR> ;Entry point into DLL
cBegin
push di ;Handle of the module instance
push ds ;Library data segment
push cx ;Heap size
push es ;Command line segment
push si ;Command line offset
;** If we have some heap then initialize it
jcxz callc ;Jump if no heap specified
;** Call the Windows function LocalInit() to set up the heap
;** LocalInit((LPSTR)start, WORD cbHeap);
xor ax,ax
cCall LOCALINIT <ds, ax, cx>
or ax,ax ;Did it do it ok ?
jz error ;Quit if it failed
;** Invoke the C routine to do any special initialization
callc:
call LIBMAIN ;Invoke the 'C' routine (result in AX)
jmp short exit ;LibMain is responsible for stack clean up
error:
pop si ;Clean up stack on a LocalInit error
pop es
pop cx
pop ds
pop di
exit:
cEnd
sEnd
;;
;; Thunks for all the Window procedures.
;;
;; USER.EXE RegisterClass tries to verify that the WndProc is valid
;; this causes the segment that contains the WndProc to be broght in
;; we Register all our classes at startup and we dont want them to come in
;;
WNDPROC macro Name
externFP &Name
sBegin CodeSeg ; this defines what seg this goes in
assumes cs,CodeSeg
public _&Name
_&Name&:
jmp Name
sEnd
endm
ifndef WIN31
WNDPROC TV_WndProc
WNDPROC ListView_WndProc
ifdef WANT_SUCKY_HEADER
WNDPROC HeaderWndProc
endif
WNDPROC Header_WndProc
WNDPROC HotKeyWndProc
WNDPROC ProgressWndProc
WNDPROC ToolbarWndProc
WNDPROC StatusWndProc
WNDPROC TrackBarWndProc
WNDPROC ToolTipsWndProc
WNDPROC ButtonListBoxProc
else
ifdef IEWIN31_25
WNDPROC TV_WndProc
WNDPROC ListView_WndProc
ifdef WANT_SUCKY_HEADER
WNDPROC HeaderWndProc
endif
WNDPROC Header_WndProc
endif ;IEWIN31_25
endif ; !WIN31
WNDPROC UpDownWndProc
WNDPROC Tab_WndProc
END LibEntry
| 25.840909 | 78 | 0.596013 |
f92a69254fee32bba9e5033f9418a3d948d97fb6 | 6,543 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_1709.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_1709.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i3-7100_9_0xca_notsx.log_21829_1709.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x19b27, %rbx
clflush (%rbx)
nop
nop
nop
sub $40041, %r11
mov $0x6162636465666768, %rax
movq %rax, (%rbx)
nop
nop
inc %r9
lea addresses_normal_ht+0x1537, %rsi
lea addresses_D_ht+0xbb27, %rdi
nop
nop
nop
nop
xor %rdx, %rdx
mov $75, %rcx
rep movsq
nop
xor $61549, %r9
lea addresses_UC_ht+0x51fd, %rsi
lea addresses_WT_ht+0x134a7, %rdi
clflush (%rsi)
nop
xor $46335, %r9
mov $10, %rcx
rep movsw
nop
nop
and $52454, %rdx
lea addresses_D_ht+0x1c7a7, %rax
nop
nop
nop
and %rdx, %rdx
mov (%rax), %esi
add %r9, %r9
lea addresses_WT_ht+0x10927, %rsi
lea addresses_UC_ht+0xbb27, %rdi
nop
cmp $42763, %rax
mov $21, %rcx
rep movsq
nop
nop
nop
add %rsi, %rsi
lea addresses_UC_ht+0x1d527, %rdi
nop
nop
nop
nop
nop
xor $17520, %rsi
vmovups (%rdi), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rbx
and $16647, %rcx
lea addresses_WT_ht+0x17727, %rsi
inc %rdi
mov $0x6162636465666768, %rax
movq %rax, (%rsi)
nop
nop
nop
nop
nop
xor %r9, %r9
lea addresses_UC_ht+0x5927, %rcx
add $29110, %rdx
movw $0x6162, (%rcx)
cmp $39614, %rdi
lea addresses_A_ht+0x17821, %rsi
lea addresses_UC_ht+0x15e67, %rdi
nop
nop
dec %rbx
mov $106, %rcx
rep movsw
nop
nop
nop
and $3669, %rdi
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r8
push %rax
push %rbp
push %rcx
push %rsi
// Load
lea addresses_A+0x76af, %rsi
nop
nop
nop
dec %rbp
vmovups (%rsi), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $1, %xmm5, %rcx
nop
sub %rbp, %rbp
// Faulty Load
lea addresses_UC+0x18b27, %rax
nop
nop
nop
add $32584, %r12
movb (%rax), %r13b
lea oracles, %rbp
and $0xff, %r13
shlq $12, %r13
mov (%rbp,%r13,1), %r13
pop %rsi
pop %rcx
pop %rbp
pop %rax
pop %r8
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_UC', 'size': 1, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_A', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_UC', 'size': 1, 'AVXalign': True}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False}}
{'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 11, 'same': False}}
{'src': {'type': 'addresses_UC_ht', 'congruent': 0, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WT_ht', 'congruent': 7, 'same': True}}
{'src': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_D_ht', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'type': 'addresses_WT_ht', 'congruent': 9, 'same': True}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 7, 'same': False}}
{'src': {'same': True, 'congruent': 8, 'NT': False, 'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 10, 'NT': False, 'type': 'addresses_WT_ht', 'size': 8, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 8, 'NT': False, 'type': 'addresses_UC_ht', 'size': 2, 'AVXalign': False}}
{'src': {'type': 'addresses_A_ht', 'congruent': 1, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_UC_ht', 'congruent': 5, 'same': False}}
{'37': 21829}
37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37 37
*/
| 38.946429 | 2,999 | 0.658719 |
09540d5bdc32fe7cbedbd2b4f7dc88d11877f331 | 360 | asm | Assembly | programs/oeis/169/A169801.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/169/A169801.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/169/A169801.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A169801: a(n) = ((n-1)^2*n^2*(n+1)^2)/6 - 2*Sum_{l=2..n}Sum_{k=2..n}(n-k+1)*(n-l+1)*(k-1)*(l-1).
; 0,0,4,64,400,1600,4900,12544,28224,57600,108900,193600,327184,529984,828100,1254400,1849600,2663424,3755844,5198400,7075600,9486400,12545764,16386304,21160000,27040000,34222500,42928704,53406864,65934400,80820100,98406400
add $0,1
bin $0,3
pow $0,2
mul $0,4
| 45 | 223 | 0.702778 |
2d9caaa496d01d5a0056f8e05118df63a8620853 | 2,092 | asm | Assembly | arch/lib/scheme/write_sob.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | arch/lib/scheme/write_sob.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | arch/lib/scheme/write_sob.asm | Mosseridan/Compiler-Principles | 6c72a462b90ca6c6db380976c2aa60471fa65325 | [
"MIT"
] | null | null | null | /* scheme/write_sob.asm
* Take a pointer to a Scheme object, and
* prints (to stdout) the character representation
* of that object.
*
* Programmer: Mayer Goldberg, 2010
*/
WRITE_SOB:
MOV(R0, STARG(0));
MOV(R0, IND(R0));
CMP(R0, IMM(T_VOID));
JUMP_EQ(WRITE_SOB_VOID);
CMP(R0, IMM(T_NIL));
JUMP_EQ(WRITE_SOB_NIL);
CMP(R0, IMM(T_BOOL));
JUMP_EQ(WRITE_SOB_BOOL);
CMP(R0, IMM(T_CHAR));
JUMP_EQ(WRITE_SOB_CHAR);
CMP(R0, IMM(T_INTEGER));
JUMP_EQ(WRITE_SOB_INTEGER);
CMP(R0, IMM(T_FRACT));
JUMP_EQ(WRITE_SOB_FRACT);
CMP(R0, IMM(T_STRING));
JUMP_EQ(WRITE_SOB_STRING);
CMP(R0, IMM(T_SYMBOL));
JUMP_EQ(WRITE_SOB_SYMBOL);
CMP(R0, IMM(T_PAIR));
JUMP_EQ(WRITE_SOB_PAIR);
CMP(R0, IMM(T_VECTOR));
JUMP_EQ(WRITE_SOB_VECTOR);
CMP(R0, IMM(T_CLOSURE));
JUMP_EQ(WRITE_SOB_CLOSURE);
PUSH(R0);
PUSH(IMM('\n'));
CALL(PUTCHAR);
PUSH(IMM('F'));
CALL(PUTCHAR);
PUSH(IMM('a'));
CALL(PUTCHAR);
PUSH(IMM('t'));
CALL(PUTCHAR);
PUSH(IMM('a'));
CALL(PUTCHAR);
PUSH(IMM('l'));
CALL(PUTCHAR);
PUSH(IMM(' '));
CALL(PUTCHAR);
PUSH(IMM('e'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM('o'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM(':'));
CALL(PUTCHAR);
PUSH(IMM(' '));
CALL(PUTCHAR);
PUSH(IMM('C'));
CALL(PUTCHAR);
PUSH(IMM('o'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM('u'));
CALL(PUTCHAR);
PUSH(IMM('p'));
CALL(PUTCHAR);
PUSH(IMM('t'));
CALL(PUTCHAR);
PUSH(IMM(' '));
CALL(PUTCHAR);
PUSH(IMM('s'));
CALL(PUTCHAR);
PUSH(IMM('e'));
CALL(PUTCHAR);
PUSH(IMM('x'));
CALL(PUTCHAR);
PUSH(IMM('p'));
CALL(PUTCHAR);
PUSH(IMM('r'));
CALL(PUTCHAR);
PUSH(IMM(' '));
CALL(PUTCHAR);
PUSH(IMM('t'));
CALL(PUTCHAR);
PUSH(IMM('y'));
CALL(PUTCHAR);
PUSH(IMM('p'));
CALL(PUTCHAR);
PUSH(IMM('e'));
CALL(PUTCHAR);
PUSH(IMM(':'));
CALL(PUTCHAR);
PUSH(IMM(' '));
CALL(PUTCHAR);
DROP(34);
CALL(WRITE_INTEGER);
DROP(1);
CALL(NEWLINE);
HALT;
| 19.37037 | 50 | 0.599426 |
ff9e55fd60e2e83a04871bfc2281648599413514 | 527 | asm | Assembly | data/maps/objects/SeafoamIslandsB2F.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | 1 | 2022-02-15T00:19:44.000Z | 2022-02-15T00:19:44.000Z | data/maps/objects/SeafoamIslandsB2F.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null | data/maps/objects/SeafoamIslandsB2F.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null | SeafoamIslandsB2F_Object:
db $7d ; border block
def_warps
warp 5, 3, 0, SEAFOAM_ISLANDS_B1F
warp 5, 13, 0, SEAFOAM_ISLANDS_B3F
warp 13, 7, 2, SEAFOAM_ISLANDS_B1F
warp 19, 15, 3, SEAFOAM_ISLANDS_B1F
warp 25, 3, 3, SEAFOAM_ISLANDS_B3F
warp 25, 11, 5, SEAFOAM_ISLANDS_B1F
warp 25, 14, 4, SEAFOAM_ISLANDS_B3F
def_signs
def_objects
object SPRITE_BOULDER, 18, 6, STAY, BOULDER_MOVEMENT_BYTE_2, 1 ; person
object SPRITE_BOULDER, 23, 6, STAY, BOULDER_MOVEMENT_BYTE_2, 2 ; person
def_warps_to SEAFOAM_ISLANDS_B2F
| 26.35 | 72 | 0.766603 |
9aa1cc5f48bedb78b5dab8051999b1afc96f18ab | 5,636 | asm | Assembly | nasm assembly/library/matrix operations.asm | AI-Factor-y/NASM-library | 5141901352a47b73e716e27d628bb719f1891092 | [
"Apache-2.0"
] | null | null | null | nasm assembly/library/matrix operations.asm | AI-Factor-y/NASM-library | 5141901352a47b73e716e27d628bb719f1891092 | [
"Apache-2.0"
] | null | null | null | nasm assembly/library/matrix operations.asm | AI-Factor-y/NASM-library | 5141901352a47b73e716e27d628bb719f1891092 | [
"Apache-2.0"
] | null | null | null |
set_mat_to_zero:
section .bss
set_mat_i: resd 1
set_mat_j: resd 1
section .text
push rax
push rbx
push rcx
push rdx
mov dword[set_mat_i],0
mov dword[set_mat_j],0
set_zero_loop_i:
mov ax,word[set_mat_i]
cmp ax,word[col_size]
je exit_set_zero_loop_i
set_zero_loop_j:
mov ax, word[set_mat_j]
cmp ax, word[row_size]
je exit_set_zero_loop_j
mov eax,[set_mat_i]
mov ecx,[set_mat_j]
mov dx, 0
call put_elem
inc dword[set_mat_j]
jmp set_zero_loop_j
exit_set_zero_loop_j:
inc dword[set_mat_i]
exit_set_zero_loop_i:
pop rdx
pop rcx
pop rbx
pop rax
ret
put_elem:
;; i in eax, j in ecx , array address in ebx ; value in dx register
section .bss
put_elem_pos: resd 1
section .text
push rax
push rbx
push rcx
push rdx
push rbx
push rdx
mov ebx, [row_size]
mul ebx
add eax,ecx
mov [put_elem_pos],eax
; call debugger
pop rdx
pop rbx
mov eax, [put_elem_pos]
mov word[ebx+2*eax], dx
pop rdx
pop rcx
pop rbx
pop rax
ret
get_elem:
;; i in eax, j in ecx , array address in ebx ; value in cx register
section .bss
get_elem_pos: resd 1
section .text
push rax
push rbx
push rdx
push rbx
mov ebx, [row_size]
mul ebx
add eax,ecx
mov [get_elem_pos],eax
; call debugger
pop rbx
mov eax, [get_elem_pos]
mov cx , word[ebx+2*eax]
pop rdx
pop rbx
pop rax
ret
read_matrix:
section .bss
mat_rs_i: resd 1
mat_rs_j: resd 1
mat_rs_pos: resd 1
mat_rs_temp: resd 1
section .text
push rax
push rbx
push rcx
push rdx
mov dword[mat_rs_i],0
mov dword[mat_rs_j],0
rs_loop_i:
mov ax, word[col_size]
cmp word[mat_rs_i], ax
je exit_rs_loop_i
mov dword[mat_rs_j],0
rs_loop_j:
mov ax, word[row_size]
cmp word[mat_rs_j], ax ;; check if the input is ’Enter’
je exit_rs_loop_j
call read_num
mov eax, [num]
mov [mat_rs_temp], eax
push rbx
mov ax,word[mat_rs_i]
mov bx,word[row_size]
mul bx
add ax,word[mat_rs_j]
mov word[mat_rs_pos],ax
; call debugger
pop rbx
mov cx,word[mat_rs_temp]
mov eax, [mat_rs_pos]
mov word[ebx+2*eax], cx
inc dword[mat_rs_j]
jmp rs_loop_j
exit_rs_loop_j:
inc dword[mat_rs_i]
jmp rs_loop_i
exit_rs_loop_i:
pop rdx
pop rcx
pop rbx
pop rax
ret
read_num:
;usage
;------
; 1: create a variable num(word)
; 2: the input number is stored into num(word)
section .bss
temp_for_read: resb 1
section .text
push rax ; push all
push rbx
push rcx
mov word[num], 0
loop_read:
;; read a digit
mov eax, 3
mov ebx, 0
mov ecx, temp_for_read
mov edx, 1
int 80h
;;check if the read digit is the end of number, i.e, the enter-key whose ASCII cmp byte[temp], 10
cmp byte[temp_for_read], 10
je end_read
cmp byte[temp_for_read], ' '
je end_read
mov ax, word[num]
mov bx, 10
mul bx
mov bl, byte[temp_for_read]
sub bl, 30h
mov bh, 0
add ax, bx
mov word[num], ax
jmp loop_read
end_read:
;;pop all the used registers from the stack using popa
;call pop_reg
pop rcx
pop rbx
pop rax
ret
print_matrix:
section .bss
mat_ps_i: resd 1
mat_ps_j: resd 1
mat_ps_pos: resd 1
mat_ps_temp: resd 1
section .text
push rax
push rbx
push rcx
push rdx
mov dword[mat_ps_i],0
mov dword[mat_ps_j],0
ps_loop_i:
mov ax, word[mat_ps_i]
cmp ax, word[col_size]
je exit_ps_loop_i
mov dword[mat_ps_j],0
ps_loop_j:
mov ax, word[row_size]
cmp ax, word[mat_ps_j]
je exit_ps_loop_j
push rbx
mov ax, word[mat_ps_i]
mov bx, word[row_size]
mul bx
add ax,word[mat_ps_j]
mov word[mat_ps_pos],ax
pop rbx
mov eax, [mat_ps_pos]
mov ax, word[ebx+2*eax]
mov word[num], ax
call print_num
inc dword[mat_ps_j]
jmp ps_loop_j
exit_ps_loop_j:
inc dword[mat_ps_i]
call add_new_line
jmp ps_loop_i
exit_ps_loop_i:
pop rdx
pop rcx
pop rbx
pop rax
ret
add_new_line:
section .data
msg_debugger_nl : db '',10
msg_debugger_l_nl : equ $-msg_debugger_nl
section .text
push rax
push rbx
push rcx
push rdx
; debug----
mov eax, 4
mov ebx, 1
mov ecx, msg_debugger_nl
mov edx, msg_debugger_l_nl
int 80h
;debug ---
pop rdx
pop rcx
pop rbx
pop rax
; action
ret
print_num:
;usage
;------
; 1: create a variable num(word)
; 2: move number to print to num (word)
section .data
nwl_for_printnum :db ' '
nwl_l_printnum : equ $-nwl_for_printnum
section .bss
count_printnum : resb 10
temp_printnum : resb 1
section .text
push rax ; push all
push rbx
push rcx
mov byte[count_printnum],0
;call push_reg
extract_no:
cmp word[num], 0
je print_no
inc byte[count_printnum]
mov dx, 0
mov ax, word[num]
mov bx, 10
div bx
push dx ; recursion here
mov word[num], ax
jmp extract_no
print_no:
cmp byte[count_printnum], 0
je end_print
dec byte[count_printnum]
pop dx
mov byte[temp_printnum], dl ; dx is further divided into dh and dl
add byte[temp_printnum], 30h
mov eax, 4
mov ebx, 1
mov ecx, temp_printnum
mov edx, 1
int 80h
jmp print_no
end_print:
mov eax,4
mov ebx,1
mov ecx,nwl_for_printnum
mov edx,nwl_l_printnum
int 80h
;;The memory location ’newline’ should be declared with the ASCII key for new popa
;call pop_reg
pop rcx
pop rbx
pop rax ; pop all
ret
| 13.106977 | 98 | 0.638928 |
7a25e6524bf144f82afe760588a1d1eb714c8fc5 | 3,832 | asm | Assembly | eurasia/services4/srvinit/devices/sgx/tastaterestore.asm | shaqfu786/GFX_Linux_DDK | f184ac914561fa100a5c92a488df777de8785f93 | [
"FSFAP"
] | 3 | 2020-03-13T23:37:00.000Z | 2021-09-03T06:34:04.000Z | eurasia/services4/srvinit/devices/sgx/tastaterestore.asm | zzpianoman/GFX_Linux_DDK | f184ac914561fa100a5c92a488df777de8785f93 | [
"FSFAP"
] | null | null | null | eurasia/services4/srvinit/devices/sgx/tastaterestore.asm | zzpianoman/GFX_Linux_DDK | f184ac914561fa100a5c92a488df777de8785f93 | [
"FSFAP"
] | 6 | 2015-02-05T03:01:01.000Z | 2021-07-24T01:07:18.000Z | /*****************************************************************************
Name : tastaterestore.asm
Title : State restore USE program
Author : PowerVR
Created : 08/08/2006
Copyright : 2006 by Imagination Technologies Limited. All rights reserved.
No part of this software, either material or conceptual
may be copied or distributed, transmitted, transcribed,
stored in a retrieval system or translated into any
human or computer language in any form by any means,
electronic, mechanical, manual or other-wise, or
disclosed to third parties without the express written
permission of Imagination Technologies Limited, HomePark
Industrial Estate, King's Langley, Hertfordshire,
WD4 8LZ, U.K.
Description : USE program for restoring the state information after a context switch
Program Type : USE assembly language
Version : $Revision: 1.25 $
Modifications :
$Log: tastaterestore.asm $
*****************************************************************************/
#include "usedefs.h"
.skipinvon;
#if defined(SGX_FEATURE_VDM_CONTEXT_SWITCH)
/* Set macro operations to only increment src2 */
smlsi #1,#1,#1,#1,#0,#0,#0,#0,#0,#0,#0;
#if defined(SGX_FEATURE_USE_UNLIMITED_PHASES)
/* No following phase. */
phas #0, #0, pixel, end, parallel;
#endif
/* Get the location of the memory structures as passed via PAs... */
#if defined(SGX_FEATURE_MTE_STATE_FLUSH)
MK_MEM_ACCESS_BPCACHE(ldad) pa1, [pa0, #DOFFSET(SGXMK_TA3D_CTL.sTARenderContext)], drc0;
wdf drc0;
mov pa2, #OFFSET(SGXMKIF_HWRENDERCONTEXT.sMTEStateFlushDevAddr);
iaddu32 pa1, pa2.low, pa1;
#if defined(SGX_FEATURE_MASTER_VDM_CONTEXT_SWITCH) && defined(SGX_FEATURE_SLAVE_VDM_CONTEXT_SWITCH)
/* offset to the state for this core */
mov pa2, g45;
imae pa1, pa2.low, #SIZEOF(IMG_UINT32), pa1, u32;
#endif
MK_MEM_ACCESS_BPCACHE(ldad) pa1, [pa1], drc0;
wdf drc0;
#else
MK_MEM_ACCESS_BPCACHE(ldad) pa1, [pa0, #DOFFSET(SGXMK_TA3D_CTL.sTACCBCmd)], drc0;
wdf drc0;
MK_MEM_ACCESS_BPCACHE(ldad) pa1, [pa1, #DOFFSET(SGXMKIF_CMDTA.sTAStateShadowDevAddr)], drc0;
wdf drc0;
#endif
/***************************************
Send the MTE state information...
****************************************/
/* Copy the data from memory into PA regs... */
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa2, [pa1, #0++], drc1;
#if defined(SGX545)
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa18, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa34, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa50, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa66, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa82, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f16) pa98, [pa1, #0++], drc1;
MK_MEM_ACCESS_BPCACHE(ldad.f12) pa114, [pa1, #0++], drc1;
#else
#if defined(SGX543) || defined(SGX544)
MK_MEM_ACCESS_BPCACHE(ldad.f9) pa18, [pa1, #0++], drc1;
#else
MK_MEM_ACCESS_BPCACHE(ldad.f8) pa18, [pa1, #0++], drc1;
#endif
#endif
wdf drc1;
/* Copy the data to the output buffer and then emit it... */
mov.rpt16 o0, pa2;
#if defined(SGX545)
mov.rpt16 o16, pa18;
mov.rpt16 o32, pa34;
mov.rpt16 o48, pa50;
mov.rpt16 o64, pa66;
mov.rpt16 o80, pa82;
mov.rpt16 o96, pa98;
mov.rpt12 o112, pa114;
emitvcbst.threepart #0, #0;
wop #0;
emitmtest.threepart.freep.end #0, #0, #0;
#else
#if defined(SGX543) || defined(SGX544)
mov.rpt9 o16, pa18;
mov pa2, #(EURASIA_TACTL_ALL_SIZEINDWORDS+2); // +2 (header dword and pds_batch_num).
#else
mov.rpt8 o16, pa18;
mov pa2, #(EURASIA_TACTL_ALL_SIZEINDWORDS+1); // +1 for the header dword.
#endif
emitst.freep.end #0, pa2;
#endif
#else
nop.end;
#endif
/*****************************************************************************
End of file (tastaterestore.asm)
*****************************************************************************/
| 32.752137 | 101 | 0.643789 |
efb89620ca9d929a4a721c03787e9c34b9ba4f25 | 504 | asm | Assembly | programs/oeis/056/A056699.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/056/A056699.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/056/A056699.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A056699: First differences are 2,1,-2,3 (repeated).
; 1,3,4,2,5,7,8,6,9,11,12,10,13,15,16,14,17,19,20,18,21,23,24,22,25,27,28,26,29,31,32,30,33,35,36,34,37,39,40,38,41,43,44,42,45,47,48,46,49,51,52,50,53,55,56,54,57,59,60,58,61,63,64,62,65,67,68,66,69,71,72,70,73,75,76,74,77,79,80,78,81,83,84,82,85,87,88,86,89,91,92,90,93,95,96,94,97,99,100,98
mov $1,183
add $1,$0
seq $1,298364 ; Permutation of the natural numbers partitioned into quadruples [4k-2, 4k-1, 4k-3, 4k] for k > 0.
sub $1,183
mov $0,$1
| 56 | 293 | 0.664683 |
9c7b86d36693c5e63ac9e367fd8b2f2adfef0fba | 413 | asm | Assembly | ace/assembly/src/interrupt_example.asm | ale-cci/Appunti | 9aa76eb46b7a984776f50260e598c9de1fa6317a | [
"MIT"
] | null | null | null | ace/assembly/src/interrupt_example.asm | ale-cci/Appunti | 9aa76eb46b7a984776f50260e598c9de1fa6317a | [
"MIT"
] | null | null | null | ace/assembly/src/interrupt_example.asm | ale-cci/Appunti | 9aa76eb46b7a984776f50260e598c9de1fa6317a | [
"MIT"
] | null | null | null | CPU 8086 ; direttiva per il processore, indica che si
; scrive codice asm 8086 non necessaria
Start: mov ah, 00h
int 16h ; lettura da testiera
cmp al,1bh ; check if input == esc
je Exit
mov ah, 0eh
mov bx, 00h ; on page 0
int 10h ; Print to video
jmp Start
Exit: mov ax, 4C00h
int 21h ; Return 0
| 21.736842 | 64 | 0.520581 |
3a196605c7e6915e778a0b3b146b51e6935a068a | 16,523 | asm | Assembly | Source/HBIOS/ay38910.asm | b1ackmai1er/RomWBW | 711bf1c877d1d4e02add0e9a884aab4316eaf2e9 | [
"DOC",
"MIT"
] | 1 | 2021-11-10T12:31:51.000Z | 2021-11-10T12:31:51.000Z | Source/HBIOS/ay38910.asm | b1ackmai1er/RomWBW | 711bf1c877d1d4e02add0e9a884aab4316eaf2e9 | [
"DOC",
"MIT"
] | 1 | 2018-08-03T10:46:18.000Z | 2018-08-03T10:46:18.000Z | Source/HBIOS/ay38910.asm | b1ackmai1er/RomWBW | 711bf1c877d1d4e02add0e9a884aab4316eaf2e9 | [
"DOC",
"MIT"
] | null | null | null | ;======================================================================
;
; AY-3-8910 / YM2149 SOUND DRIVER
;
;======================================================================
;
; @3.579545 OCTAVE RANGE IS 2 - 7 (Bb2/A#2 .. A7)
; @4.000000 OCTAVE RANGE IS 2 - 7 (B2 .. A7)
;
AY_RCSND .EQU 0 ; 0 = EB MODULE, 1=MF MODULE
;
#IF (AYMODE == AYMODE_SCG)
AY_RSEL .EQU $9A
AY_RDAT .EQU $9B
AY_RIN .EQU AY_RSEL
AY_ACR .EQU $9C
AY_CLK .SET 3579545 ; MSX NTSC COLOUR BURST FREQ = 315/88
#ENDIF
;
#IF (AYMODE == AYMODE_N8)
AY_RSEL .EQU $9C
AY_RDAT .EQU $9D
AY_RIN .EQU AY_RSEL
AY_ACR .EQU N8_DEFACR
#ENDIF
;
#IF (AYMODE == AYMODE_RCZ80)
AY_RSEL .EQU $D8
AY_RDAT .EQU $D0
AY_RIN .EQU AY_RSEL+AY_RCSND
#ENDIF
;
#IF (AYMODE == AYMODE_RCZ180)
AY_RSEL .EQU $68
AY_RDAT .EQU $60
AY_RIN .EQU AY_RSEL+AY_RCSND
#ENDIF
;
#IF (AYMODE == AYMODE_MSX)
AY_RSEL .EQU $A0
AY_RDAT .EQU $A1
AY_RIN .EQU $A2
#ENDIF
;
#IF (AYMODE == AYMODE_LINC)
AY_RSEL .EQU $33
AY_RDAT .EQU $32
AY_RIN .EQU $32
#ENDIF
;
;======================================================================
;
; REGISTERS
;
AY_R2CHBP .EQU $02
AY_R3CHBP .EQU $03
AY_R7ENAB .EQU $07
AY_R8AVOL .EQU $08
;
;======================================================================
;
; DRIVER FUNCTION TABLE AND INSTANCE DATA
;
AY_FNTBL:
.DW AY_RESET
.DW AY_VOLUME
.DW AY_PERIOD
.DW AY_NOTE
.DW AY_PLAY
.DW AY_QUERY
.DW AY_DURATION
.DW AY_DEVICE
;
#IF (($ - AY_FNTBL) != (SND_FNCNT * 2))
.ECHO "*** INVALID SND FUNCTION TABLE ***\n"
!!!!!
#ENDIF
;
AY_IDAT .EQU 0 ; NO INSTANCE DATA ASSOCIATED WITH THIS DEVICE
;
;======================================================================
;
; DEVICE CAPABILITIES AND CONFIGURATION
;
AY_TONECNT .EQU 3 ; COUNT NUMBER OF TONE CHANNELS
AY_NOISECNT .EQU 1 ; COUNT NUMBER OF NOISE CHANNELS
;
#IF (AY_CLK > 3579545) ; DEPENDING ON THE
AY_SCALE .EQU 2 ; INPUT CLOCK FREQUENCY
#ELSE ; PRESCALE THE TONE PERIOD
AY_SCALE .EQU 3 ; DATA TO MAINTAIN MAXIMUM
#ENDIF ; RANGE AND ACCURACY
;
AY_RATIO .EQU (AY_CLK * 100) / (16 >> AY_SCALE)
;
#INCLUDE "audio.inc"
;
;======================================================================
;
; DRIVER INITIALIZATION (THERE IS NO PRE-INITIALIZATION)
;
; ANNOUNCE DEVICE ON CONSOLE. ACTIVATE DEVICE IF REQUIRED.
; SETUP FUNCTION TABLES. SETUP THE DEVICE.
; ANNOUNCE DEVICE WITH BEEP. SET VOLUME OFF.
; RETURN INITIALIZATION STATUS
;
AY38910_INIT:
CALL NEWLINE ; ANNOUNCE
PRTS("AY:$")
;
#IF (AYMODE == AYMODE_SCG)
PRTS(" MODE=SCG$")
#ENDIF
;
#IF (AYMODE == AYMODE_N8)
PRTS(" MODE=N8$")
#ENDIF
;
#IF (AYMODE == AYMODE_RCZ80)
PRTS(" MODE=RCZ80$")
#ENDIF
;
#IF (AYMODE == AYMODE_RCZ180)
PRTS(" MODE=RCZ180$")
#ENDIF
;
#IF (AYMODE == AYMODE_MSX)
PRTS(" MODE=MSX$")
#ENDIF
;
#IF (AYMODE == AYMODE_LINC)
PRTS(" MODE=LINC$")
#ENDIF
;
PRTS(" IO=0x$")
LD A,AY_RSEL
CALL PRTHEXBYTE
;
#IF ((AYMODE == AYMODE_SCG) | (AYMODE == AYMODE_N8))
LD A,$FF ; ACTIVATE DEVICE BIT 4 IS AY RESET CONTROL, BIT 3 IS ACTIVE LED
OUT (AY_ACR),A ; SET INIT AUX CONTROL REG
#ENDIF
;
LD DE,(AY_R2CHBP*256)+$55 ; SIMPLE HARDWARE PROBE
CALL AY_WRTPSG ; WRITE AND
CALL AY_RDPSG ; READ TO A
LD A,$55 ; SOUND CHANNEL
CP E ; REGISTER
JR Z,AY_FND
;
CALL PRTSTRD \ .TEXT " NOT PRESENT$"
;
LD A,$FF ; UNSUCCESSFULL INIT
RET
;
AY_FND: LD IY, AY_IDAT ; SETUP FUNCTION TABLE
LD BC, AY_FNTBL ; POINTER TO INSTANCE DATA
LD DE, AY_IDAT ; BC := FUNCTION TABLE ADDRESS
CALL SND_ADDENT ; DE := INSTANCE DATA PTR
;
CALL AY_INIT ; SET DEFAULT CHIP CONFIGURATION
;
LD E,$07 ; SET VOLUME TO 50%
CALL AY_SETV ; ON ALL CHANNELS
;
; LD DE,(AY_R2CHBP*256)+$55 ; BEEP ON CHANNEL B (CENTER)
; CALL AY_WRTPSG ; R02 = $55 = 01010101
LD DE,(AY_R3CHBP*256)+$00
CALL AY_WRTPSG ; R03 = $00 = XXXX0000
;
#IF (SYSTIM != TM_NONE)
LD A, TICKFREQ / 3 ; SCHEDULE IN 1/3 SECOND TO TURN OFF SOUND
LD (AY_TIMTIK), A
;
LD HL, (VEC_TICK + 1) ; GET CUR TICKS VECTOR
LD (AY_TIMHOOK), HL ; SAVE IT INTERNALLY
LD HL, AY_TIMER ; INSTALL TIMER HOOK HANDLER
LD (VEC_TICK + 1), HL
;
LD A, $02 ; NOT READY & IN INTERUPT HANDLER
LD (AY_READY), A
#ELSE
CALL LDELAY ; HALF SECOND DELAY
LD E,$00 ; SET VOLUME OFF
CALL AY_SETV ; ON ALL CHANNELS
LD A, $01 ; READY & NOT IN INTERUPT HANDLER
LD (AY_READY), A
#ENDIF
;
XOR A ; SUCCESSFULL INIT
RET
;
#IF (SYSTIM != TM_NONE)
AY_TIMER:
LD A, (AY_TIMTIK)
DEC A
LD (AY_TIMTIK), A
JR NZ, AY_TIMER1
;
LD E,$00 ; SET VOLUME OFF
CALL AY_SETV ; ON ALL CHANNELS
LD A, $01 ; READY & NOT IN INTERUPT HANDLER
LD (AY_READY), A
;
LD DE, AY_TIMER ; MAKE AY_TIMER A NO_OP HANDLER
LD HL, AY_TIMER1
LD BC, 3
LDIR
;
AY_TIMER1:
JP 0 ; OVERWRITTEN WITH NEXT HANDLER
AY_TIMHOOK: .EQU $ - 2
AY_TIMTIK .DB 0 ; COUNT DOWN TO FINISH BOOT BEEP
#ENDIF
;
;======================================================================
; INITIALIZE DEVICE
;======================================================================
;
AY_INIT:
LD DE,(AY_R7ENAB*256)+$F8 ; SET MIXER CONTROL / IO ENABLE. $F8 - 11 111 000
JP AY_WRTPSG ; I/O PORTS = OUTPUT, NOISE CHANNEL C, B, A DISABLE, TONE CHANNEL C, B, A ENABLE
;
AY_CHKREDY:
LD A, (AY_READY)
BIT 0, A
RET NZ
POP HL ; REMOVE LAST RETURN ADDRESS
OR $FF
RET ; RETURN NZ
;
;======================================================================
; SET VOLUME ALL CHANNELS
;======================================================================
;
AY_SETV:
PUSH BC
LD B,AY_TONECNT ; NUMBER OF CHANNELS
LD D,AY_R8AVOL ; BASE REGISTER FOR VOLUME
AY_SV: CALL AY_WRTPSG ; CYCLING THROUGH ALL CHANNELS
INC D
DJNZ AY_SV
POP BC
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - RESET
;
; INITIALIZE DEVICE. SET VOLUME OFF. RESET VOLUME AND TONE VARIABLES.
;
;======================================================================
;
AY_RESET:
AUDTRACE(AYT_INIT)
CALL AY_CHKREDY ; RETURNS TO OUR CALLER IF NOT READY
;
PUSH DE
PUSH HL
CALL AY_INIT ; SET DEFAULT CHIP CONFIGURATION
;
AUDTRACE(AYT_VOLOFF)
LD E,0 ; SET VOLUME OFF
CALL AY_SETV ; ON ALL CHANNELS
;
XOR A ; SIGNAL SUCCESS
LD (AY_PENDING_VOLUME),A ; SET VOLUME TO ZERO
LD H,A
LD L,A
LD (AY_PENDING_PERIOD),HL ; SET TONE PERIOD TO ZERO
;
POP HL
POP DE
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - VOLUME
;======================================================================
;
AY_VOLUME:
AUDTRACE(AYT_VOL)
AUDTRACE_L
AUDTRACE_CR
LD A,L ; SAVE VOLUME
LD (AY_PENDING_VOLUME), A
;
XOR A ; SIGNAL SUCCESS
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - NOTE
;======================================================================
;
AY_NOTE:
AUDTRACE(AYT_NOTE)
AUDTRACE_HL
AUDTRACE_CR
;
; CALL PRTHEXWORDHL
; CALL PC_COLON
;
LD DE, AY3NOTETBL ; ON ENTRY HL IS THE NOTE TO PLAY
PUSH DE ; AND DE IS THE START OF NOTE TABLE
LD DE, 48 ; LOAD DE WITH NOTE TABLE SIZE
CALL DIV16 ; AND CALCULATE OCTAVE COUNT IN BC
;
ADD HL, HL ; HL IS THE REMAINDER FROM ABOVE DIVISION (0-47) AND THE NOTE
POP DE ; TO PLAY IN THE OCTAVE. ADD IT TO THE START OF THE NOTE TABLE
ADD HL, DE ; TO POINT TO THE PERIOD FOR THE NOTE WE WANT TO PLAY.
;
LD A, (HL) ; HL POINT TO CURRENT PERIOD COUNT WE WANT TO PLAY
INC HL ; SO LOAD PERIOD COUNT FROM NOTE TABLE INTO HL
LD H, (HL) ; SO WE CAN UPDATE IT FOR THE REQUIRED OCTAVE
LD L, A
;
LD A,AY_SCALE-1 ; THE NOTE TABLE PERIOD DATA HAS BEEN
ADD A,C ; PRESCALED TO MAINTAIN RANGE SO ALLOW
LD B,A ; FOR THIS WHEN CHANGING OCTAVE
AY_NOTE1:
SRL H ; ADJUST THE PERIOD DATA
RR L ; FOR THE DESIRED OCTAVE
DJNZ AY_NOTE1 ; FALL THROUGH TO SET PERIOD AND RANGE CHECK
;
; CALL PRTHEXWORDHL
; CALL NEWLINE
;
;======================================================================
; SOUND DRIVER FUNCTION - PERIOD
;======================================================================
;
AY_PERIOD:
AUDTRACE(AYT_PERIOD)
AUDTRACE_HL
AUDTRACE_CR
LD A, H ; IF ZERO - ERROR
OR L
JR Z, AY_PERIOD1
;
LD A, H ; MAXIMUM TONE PERIOD IS 12-BITS
AND 11110000B ; ALLOWED RANGE IS 0001-0FFF (4095)
JR NZ, AY_PERIOD1 ; RETURN NZ IF NUMBER TOO LARGE
LD (AY_PENDING_PERIOD), HL ; SAVE AND RETURN SUCCESSFUL
RET
;
AY_PERIOD1:
LD A, $FF ; REQUESTED PERIOD IS LARGER
LD (AY_PENDING_PERIOD), A ; THAN THE DEVICE CAN SUPPORT
LD (AY_PENDING_PERIOD+1), A; SO SET PERIOD TO FFFF
RET ; AND RETURN FAILURE
;
;======================================================================
; SOUND DRIVER FUNCTION - PLAY
; B = FUNCTION
; C = AUDIO DEVICE
; D = CHANNEL
; A = EXIT STATUS
;======================================================================
;
AY_PLAY:
AUDTRACE(AYT_PLAY)
AUDTRACE_D
AUDTRACE_CR
CALL AY_CHKREDY ; RETURNS TO OUR CALLER IF NOT READY
;
LD A, (AY_PENDING_PERIOD + 1) ; CHECK THE HIGH BYTE OF THE PERIOD
INC A
JR Z, AY_PLAY1 ; PERIOD IS TOO LARGE, UNABLE TO PLAY
;
PUSH HL
PUSH DE
LD A,D ; LIMIT CHANNEL 0-2
AND $3 ; AND INDEX TO THE
ADD A,A ; CHANNEL REGISTER
LD D,A ; FOR THE TONE PERIOD
;
AUDTRACE(AYT_REGWR)
AUDTRACE_A
AUDTRACE_CR
;
LD HL,AY_PENDING_PERIOD ; WRITE THE LOWER
ld E,(HL) ; 8-BITS OF THE TONE PERIOD
CALL AY_WRTPSG
INC D ; NEXT REGISTER
INC HL ; NEXT BYTE
LD E,(HL) ; WRITE THE UPPER
CALL AY_WRTPSG ; 8-BITS OF THE TONE PERIOD
;
POP DE ; RECALL CHANNEL
PUSH DE ; SAVE CHANNEL
;
LD A,D ; LIMIT CHANNEL 0-2
AND $3 ; AND INDEX TO THE
ADD A,AY_R8AVOL ; CHANNEL VOLUME
LD D,A ; REGISTER
;
AUDTRACE(AYT_REGWR)
AUDTRACE_A
AUDTRACE_CR
;
INC HL ; NEXT BYTE
LD A,(HL) ; PENDING VOLUME
RRCA ; MAP THE VOLUME
RRCA ; FROM 00-FF
RRCA ; TO 00-0F
RRCA
AND $0F
LD E,A
CALL AY_WRTPSG ; SET VOL (E) IN CHANNEL REG (D)
;
POP DE ; RECALL CHANNEL
POP HL
;
XOR A ; SIGNAL SUCCESS
RET
;
AY_PLAY1:
PUSH DE ; TURN VOLUME OFF TO STOP PLAYING
LD A,D ; LIMIT CHANNEL 0-2
AND $3 ; AND INDEX TO THE
ADD A,AY_R8AVOL ; CHANNEL VOLUME
LD D,A ; REGISTER
LD E,0
CALL AY_WRTPSG ; SET VOL (E) IN CHANNEL REG (D)
POP DE
OR $FF ; SIGNAL FAILURE
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - QUERY AND SUBFUNCTIONS
;======================================================================
;
AY_QUERY:
LD A, E
CP BF_SNDQ_CHCNT ; SUB FUNCTION 01
JR Z, AY_QUERY_CHCNT
;
CP BF_SNDQ_VOLUME ; SUB FUNCTION 02
JR Z, AY_QUERY_VOLUME
;
CP BF_SNDQ_PERIOD ; SUB FUNCTION 03
JR Z, AY_QUERY_PERIOD
;
CP BF_SNDQ_DEV ; SUB FUNCTION 04
JR Z, AY_QUERY_DEV
;
OR $FF ; SIGNAL FAILURE
RET
;
AY_QUERY_CHCNT:
LD BC,(AY_TONECNT*256)+AY_NOISECNT ; RETURN NUMBER OF
XOR A ; TONE AND NOISE
RET ; CHANNELS IN BC
;
AY_QUERY_PERIOD:
LD HL, (AY_PENDING_PERIOD) ; RETURN 16-BIT PERIOD
XOR A ; IN HL REGISTER
RET
;
AY_QUERY_VOLUME:
LD A, (AY_PENDING_VOLUME) ; RETURN 8-BIT VOLUME
LD L, A ; IN L REGISTER
XOR A
; LD H, A
RET
;
AY_QUERY_DEV:
LD B, SNDDEV_AY38910 ; RETURN DEVICE IDENTIFIER
LD DE, (AY_RSEL*256)+AY_RDAT ; AND ADDRESS AND DATA PORT
XOR A
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - DURATION
;======================================================================
;
AY_DURATION:
LD (AY_PENDING_DURATION),HL ; SET TONE DURATION
XOR A
RET
;
;======================================================================
; SOUND DRIVER FUNCTION - DEVICE
;======================================================================
;
AY_DEVICE:
LD D,SNDDEV_AY38910 ; D := DEVICE TYPE
LD E,0 ; E := PHYSICAL UNIT
LD C,$00 ; C := DEVICE TYPE
LD H,AYMODE ; H := MODE
LD L,AY_RSEL ; L := BASE I/O ADDRESS
XOR A
RET
;
;======================================================================
; NON-BLOCKING INTERRUPT CODE
;======================================================================
;
AY_DI:
LD A, (AY_READY)
BIT 1, A
RET NZ
HB_DI
RET
;
AY_EI:
LD A, (AY_READY)
BIT 1, A
RET NZ
HB_EI
RET
;
;======================================================================
;
; WRITE DATA IN E REGISTER TO DEVICE REGISTER D
; INTERRUPTS DISABLE DURING WRITE. WRITE IN SLOW MODE IF Z180 CPU.
;
;======================================================================
;
AY_WRTPSG:
CALL AY_DI
#IFDEF SBCV2004
LD A,(RTCVAL) ; GET CURRENT RTC LATCH VALUE
OR %00001000 ; SBC-V2-004 CHANGE
OUT (RTCIO),A ; TO HALF CLOCK SPEED
#ENDIF
#IF (CPUFAM == CPU_Z180)
IN0 A,(Z180_DCNTL) ; GET WAIT STATES
PUSH AF ; SAVE VALUE
OR %00110000 ; FORCE SLOW OPERATION (I/O W/S=3)
OUT0 (Z180_DCNTL),A ; AND UPDATE DCNTL
#ENDIF
LD A,D ; SELECT THE REGISTER WE
OUT (AY_RSEL),A ; WANT TO WRITE TO
LD A,E ; WRITE THE VALUE TO
OUT (AY_RDAT),A ; THE SELECTED REGISTER
#IF (CPUFAM == CPU_Z180)
POP AF ; GET SAVED DCNTL VALUE
OUT0 (Z180_DCNTL),A ; AND RESTORE IT
#ENDIF
#IFDEF SBCV2004
LD A,(RTCVAL) ; SBC-V2-004 CHANGE TO
OUT (RTCIO),A ; NORMAL CLOCK SPEED
#ENDIF
JP AY_EI
;
;======================================================================
;
; READ FROM REGISTER D AND RETURN WITH RESULT IN E
;
AY_RDPSG:
CALL AY_DI
#IFDEF SBCV2004
LD A,(RTCVAL) ; GET CURRENT RTC LATCH VALUE
OR %00001000 ; SBC-V2-004 CHANGE
OUT (RTCIO),A ; TO HALF CLOCK SPEED
#ENDIF
#IF (CPUFAM == CPU_Z180)
IN0 A,(Z180_DCNTL) ; GET WAIT STATES
PUSH AF ; SAVE VALUE
OR %00110000 ; FORCE SLOW OPERATION (I/O W/S=3)
OUT0 (Z180_DCNTL),A ; AND UPDATE DCNTL
#ENDIF
LD A,D ; SELECT THE REGISTER WE
OUT (AY_RSEL),A ; WANT TO READ
IN A,(AY_RIN) ; READ SELECTED REGISTER
LD E,A
#IF (CPUFAM == CPU_Z180)
POP AF ; GET SAVED DCNTL VALUE
OUT0 (Z180_DCNTL),A ; AND RESTORE IT
#ENDIF
#IFDEF SBCV2004
LD A,(RTCVAL) ; SBC-V2-004 CHANGE TO
OUT (RTCIO),A ; NORMAL CLOCK SPEED
#ENDIF
JP AY_EI
;
;======================================================================
;
AY_PENDING_PERIOD .DW 0 ; PENDING PERIOD (12 BITS) ; ORDER
AY_PENDING_VOLUME .DB 0 ; PENDING VOL (8 BITS) ; SIGNIFICANT
AY_PENDING_DURATION .DW 0 ; PENDING DURATION (16 BITS)
AY_READY .DB 0 ; BIT 0 -> NZ DRIVER IS READY TO RECEIVE PLAY COMMAND
; BIT 1 -> NZ EXECUTING WITHIN TIMER HANDLER = DO NOT DIS/ENABLE INT
;
#IF AUDIOTRACE
AYT_INIT .DB "\r\nAY_INIT\r\n$"
AYT_VOLOFF .DB "\r\nAY_VOLUME OFF\r\n$"
AYT_VOL .DB "\r\nAY_VOLUME: $"
AYT_NOTE .DB "\r\nAY_NOTE: $"
AYT_PERIOD .DB "\r\nAY_PERIOD $"
AYT_PLAY .DB "\r\nAY_PLAY CH: $"
AYT_REGWR .DB "\r\nOUT AY-3-8910 $"
#ENDIF
;
;======================================================================
; QUARTER TONE FREQUENCY TABLE
;======================================================================
;
; THE FREQUENCY BY QUARTER TONE STARTING AT A0# OCTAVE 0
; USED TO MAP EACH OCTAVE (DIV BY 2 TO JUMP AN OCTAVE UP)
; FIRST PLAYABLE NOTE WILL BE 0
; ASSUMING A CLOCK OF 1843200 THIS MAPS TO A0#
;
AY3NOTETBL:
.DW AY_RATIO / 2913
.DW AY_RATIO / 2956
.DW AY_RATIO / 2999
.DW AY_RATIO / 3042
.DW AY_RATIO / 3086
.DW AY_RATIO / 3131
.DW AY_RATIO / 3177
.DW AY_RATIO / 3223
.DW AY_RATIO / 3270
.DW AY_RATIO / 3318
.DW AY_RATIO / 3366
.DW AY_RATIO / 3415
.DW AY_RATIO / 3464
.DW AY_RATIO / 3515
.DW AY_RATIO / 3566
.DW AY_RATIO / 3618
.DW AY_RATIO / 3670
.DW AY_RATIO / 3724
.DW AY_RATIO / 3778
.DW AY_RATIO / 3833
.DW AY_RATIO / 3889
.DW AY_RATIO / 3945
.DW AY_RATIO / 4003
.DW AY_RATIO / 4061
.DW AY_RATIO / 4120
.DW AY_RATIO / 4180
.DW AY_RATIO / 4241
.DW AY_RATIO / 4302
.DW AY_RATIO / 4365
.DW AY_RATIO / 4428
.DW AY_RATIO / 4493
.DW AY_RATIO / 4558
.DW AY_RATIO / 4624
.DW AY_RATIO / 4692
.DW AY_RATIO / 4760
.DW AY_RATIO / 4829
.DW AY_RATIO / 4899
.DW AY_RATIO / 4971
.DW AY_RATIO / 5043
.DW AY_RATIO / 5116
.DW AY_RATIO / 5191
.DW AY_RATIO / 5266
.DW AY_RATIO / 5343
.DW AY_RATIO / 5421
.DW AY_RATIO / 5499
.DW AY_RATIO / 5579
.DW AY_RATIO / 5661
.DW AY_RATIO / 5743
| 25.1875 | 96 | 0.55226 |
1d07c6c64af3c8d788c888e891e17ddf6c0ac980 | 546 | asm | Assembly | oeis/190/A190333.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/190/A190333.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/190/A190333.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A190333: n + [n*r/s] + [n*t/s]; r=1, s=sqrt(3), t=1/s.
; Submitted by Simon Strandgaard
; 1,3,5,7,8,11,13,14,17,18,20,22,24,26,28,30,31,34,35,37,40,41,43,45,47,49,51,53,54,57,58,60,63,64,66,68,70,71,74,76,77,80,81,83,85,87,89,91,93,94,97,99,100,103,104,106,108,110,112,114,116,117,120,121,123,126,127,129,131,133,134,137,139,140,143,144,146,149,150,152,154,156,157,160,162,163,166,167,169,171,173,175,177,179,180,183,185,186,189,190
mov $1,$0
seq $0,190057 ; a(n) = n + [n*r/s] + [n*t/s]; r=1/2, s=sin(Pi/3), t=csc(Pi/3).
sub $0,$1
sub $0,1
| 60.666667 | 344 | 0.6337 |
19e4e13a5fcea47229a049809b9084991b0f139d | 317 | asm | Assembly | Practice/Assignments assembly class/10.asm | WardunIslam/CSE331L_Section_7_Summer_2020_NSU | 4f36bf223c44afd2233a243a2f8ba92df18f5545 | [
"MIT"
] | null | null | null | Practice/Assignments assembly class/10.asm | WardunIslam/CSE331L_Section_7_Summer_2020_NSU | 4f36bf223c44afd2233a243a2f8ba92df18f5545 | [
"MIT"
] | null | null | null | Practice/Assignments assembly class/10.asm | WardunIslam/CSE331L_Section_7_Summer_2020_NSU | 4f36bf223c44afd2233a243a2f8ba92df18f5545 | [
"MIT"
] | null | null | null | org 100h
L1: NOP
L2: MOV AX, 0000H
MOV DS, AX
MOV BX, 0000H
MOV CL, BYTE PTR DS:[BX]
MOV AL, CL
L3: MOV AH, 0000H
MOV BL, 02H
DIV BL
L4: CMP AH, 00H
JZ EVEN
ODD: MOV AH, 02
MOV DL, 'O'
INT 21H
JMP L5
EVEN: MOV AH, 02
MOV DL, 'E'
INT 21H
L5: HLT
ret | 10.931034 | 29 | 0.514196 |
6eed2f17e25f9e2df108ae483d98c5676f3d1b82 | 1,673 | asm | Assembly | kernel/arch/i386/asm/boot.asm | TheKernelCorp/Fluorite | 8ef31652326dbdc0df7d6d61f0f419ce1c40b8de | [
"MIT"
] | 16 | 2017-12-19T13:17:07.000Z | 2021-12-20T19:09:38.000Z | kernel/arch/i386/asm/boot.asm | TheKernelCorp/Fluorite | 8ef31652326dbdc0df7d6d61f0f419ce1c40b8de | [
"MIT"
] | 1 | 2018-10-20T16:10:37.000Z | 2018-10-22T02:20:44.000Z | kernel/arch/i386/asm/boot.asm | TheKernelCorp/Fluorite | 8ef31652326dbdc0df7d6d61f0f419ce1c40b8de | [
"MIT"
] | 4 | 2018-01-20T07:43:32.000Z | 2019-05-24T02:46:18.000Z | ;
; Multiboot
;
section .multiboot
align 4
; Constants
MBALIGN equ 1<<0
MEMINFO equ 1<<1
VIDINFO equ 1<<2
FLAGS equ MBALIGN | MEMINFO | VIDINFO
MAGIC equ 0x1BADB002
CHECKSUM equ -(MAGIC + FLAGS)
; Header
dd MAGIC
dd FLAGS
dd CHECKSUM
dd 0x00000000
dd 0x00000000
dd 0x00000000
dd 0x00000000
dd 0x00000000
dd 0x00000000
dd 0
dd 0
dd 32
;
; Text
;
section .text
; Global
global start
; Extern
extern END_OF_KERNEL
extern kearly
extern kmain
; StartInfo structure
struc StartInfo
.multiboot_ptr: resd 1
.end_of_kernel: resd 1
.size:
endstruc
; Entry point
start:
cli ; Disable interrupts
mov esp, stack.top ; Setup kernel stack
mov [startinfo + StartInfo.multiboot_ptr], ebx
mov [startinfo + StartInfo.end_of_kernel], dword END_OF_KERNEL
push ebp ; Save old call frame
mov ebp, esp ; Init new call frame
push startinfo ; Push start info
call kearly ; Call kearly
mov esp, ebp ; Clear call frame
pop ebp ; Restore call frame
call kmain ; Call kmain
.hang:
cli ; Disable interrupts
hlt ; Halt
jmp .hang ; Repeat
;
; Glue
;
global glue_flush_gdt
glue_flush_gdt:
jmp 0x08:.flush
.flush:
ret
global glue_init_idt
glue_init_idt:
call extern idt_setup
ret
;
; Uninitialized data
;
section .bss
; Stack
stack:
resb 16384 ; 16 KiB
.top:
; StartInfo
startinfo:
resb StartInfo.size | 17.797872 | 66 | 0.580992 |
e63646739b1a744484a19975c0351482f4db26c0 | 62,595 | asm | Assembly | ls.asm | AlonYeroushalmi/Assignment_1 | 87299d2946405c5d22dac5c8397a7c639b0a7999 | [
"MIT-0"
] | null | null | null | ls.asm | AlonYeroushalmi/Assignment_1 | 87299d2946405c5d22dac5c8397a7c639b0a7999 | [
"MIT-0"
] | null | null | null | ls.asm | AlonYeroushalmi/Assignment_1 | 87299d2946405c5d22dac5c8397a7c639b0a7999 | [
"MIT-0"
] | null | null | null |
_ls: file format elf32-i386
Disassembly of section .text:
00000000 <main>:
close(fd);
}
int
main(int argc, char *argv[])
{
0: 8d 4c 24 04 lea 0x4(%esp),%ecx
4: 83 e4 f0 and $0xfffffff0,%esp
7: ff 71 fc pushl -0x4(%ecx)
a: 55 push %ebp
b: 89 e5 mov %esp,%ebp
d: 57 push %edi
e: 56 push %esi
f: 53 push %ebx
10: 51 push %ecx
11: bb 01 00 00 00 mov $0x1,%ebx
16: 83 ec 08 sub $0x8,%esp
19: 8b 31 mov (%ecx),%esi
1b: 8b 79 04 mov 0x4(%ecx),%edi
int i;
if(argc < 2){
1e: 83 fe 01 cmp $0x1,%esi
21: 7e 1f jle 42 <main+0x42>
23: 90 nop
24: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
ls(".");
exit();
}
for(i=1; i<argc; i++)
ls(argv[i]);
28: 83 ec 0c sub $0xc,%esp
2b: ff 34 9f pushl (%edi,%ebx,4)
if(argc < 2){
ls(".");
exit();
}
for(i=1; i<argc; i++)
2e: 83 c3 01 add $0x1,%ebx
ls(argv[i]);
31: e8 ca 00 00 00 call 100 <ls>
if(argc < 2){
ls(".");
exit();
}
for(i=1; i<argc; i++)
36: 83 c4 10 add $0x10,%esp
39: 39 de cmp %ebx,%esi
3b: 75 eb jne 28 <main+0x28>
ls(argv[i]);
exit();
3d: e8 e6 05 00 00 call 628 <exit>
main(int argc, char *argv[])
{
int i;
if(argc < 2){
ls(".");
42: 83 ec 0c sub $0xc,%esp
45: 68 f8 0a 00 00 push $0xaf8
4a: e8 b1 00 00 00 call 100 <ls>
exit();
4f: e8 d4 05 00 00 call 628 <exit>
54: 66 90 xchg %ax,%ax
56: 66 90 xchg %ax,%ax
58: 66 90 xchg %ax,%ax
5a: 66 90 xchg %ax,%ax
5c: 66 90 xchg %ax,%ax
5e: 66 90 xchg %ax,%ax
00000060 <fmtname>:
#include "user.h"
#include "fs.h"
char*
fmtname(char *path)
{
60: 55 push %ebp
61: 89 e5 mov %esp,%ebp
63: 56 push %esi
64: 53 push %ebx
65: 8b 5d 08 mov 0x8(%ebp),%ebx
static char buf[DIRSIZ+1];
char *p;
// Find first character after last slash.
for(p=path+strlen(path); p >= path && *p != '/'; p--)
68: 83 ec 0c sub $0xc,%esp
6b: 53 push %ebx
6c: e8 df 03 00 00 call 450 <strlen>
71: 83 c4 10 add $0x10,%esp
74: 01 d8 add %ebx,%eax
76: 73 0f jae 87 <fmtname+0x27>
78: eb 12 jmp 8c <fmtname+0x2c>
7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80: 83 e8 01 sub $0x1,%eax
83: 39 c3 cmp %eax,%ebx
85: 77 05 ja 8c <fmtname+0x2c>
87: 80 38 2f cmpb $0x2f,(%eax)
8a: 75 f4 jne 80 <fmtname+0x20>
;
p++;
8c: 8d 58 01 lea 0x1(%eax),%ebx
// Return blank-padded name.
if(strlen(p) >= DIRSIZ)
8f: 83 ec 0c sub $0xc,%esp
92: 53 push %ebx
93: e8 b8 03 00 00 call 450 <strlen>
98: 83 c4 10 add $0x10,%esp
9b: 83 f8 0d cmp $0xd,%eax
9e: 77 4a ja ea <fmtname+0x8a>
return p;
memmove(buf, p, strlen(p));
a0: 83 ec 0c sub $0xc,%esp
a3: 53 push %ebx
a4: e8 a7 03 00 00 call 450 <strlen>
a9: 83 c4 0c add $0xc,%esp
ac: 50 push %eax
ad: 53 push %ebx
ae: 68 94 0e 00 00 push $0xe94
b3: e8 28 05 00 00 call 5e0 <memmove>
memset(buf+strlen(p), ' ', DIRSIZ-strlen(p));
b8: 89 1c 24 mov %ebx,(%esp)
bb: e8 90 03 00 00 call 450 <strlen>
c0: 89 1c 24 mov %ebx,(%esp)
c3: 89 c6 mov %eax,%esi
return buf;
c5: bb 94 0e 00 00 mov $0xe94,%ebx
// Return blank-padded name.
if(strlen(p) >= DIRSIZ)
return p;
memmove(buf, p, strlen(p));
memset(buf+strlen(p), ' ', DIRSIZ-strlen(p));
ca: e8 81 03 00 00 call 450 <strlen>
cf: ba 0e 00 00 00 mov $0xe,%edx
d4: 83 c4 0c add $0xc,%esp
d7: 05 94 0e 00 00 add $0xe94,%eax
dc: 29 f2 sub %esi,%edx
de: 52 push %edx
df: 6a 20 push $0x20
e1: 50 push %eax
e2: e8 99 03 00 00 call 480 <memset>
return buf;
e7: 83 c4 10 add $0x10,%esp
}
ea: 8d 65 f8 lea -0x8(%ebp),%esp
ed: 89 d8 mov %ebx,%eax
ef: 5b pop %ebx
f0: 5e pop %esi
f1: 5d pop %ebp
f2: c3 ret
f3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000100 <ls>:
void
ls(char *path)
{
100: 55 push %ebp
101: 89 e5 mov %esp,%ebp
103: 57 push %edi
104: 56 push %esi
105: 53 push %ebx
106: 81 ec 64 02 00 00 sub $0x264,%esp
10c: 8b 7d 08 mov 0x8(%ebp),%edi
char buf[512], *p;
int fd;
struct dirent de;
struct stat st;
if((fd = open(path, 0)) < 0){
10f: 6a 00 push $0x0
111: 57 push %edi
112: e8 51 05 00 00 call 668 <open>
117: 83 c4 10 add $0x10,%esp
11a: 85 c0 test %eax,%eax
11c: 0f 88 9e 01 00 00 js 2c0 <ls+0x1c0>
printf(2, "ls: cannot open %s\n", path);
return;
}
if(fstat(fd, &st) < 0){
122: 8d b5 d4 fd ff ff lea -0x22c(%ebp),%esi
128: 83 ec 08 sub $0x8,%esp
12b: 89 c3 mov %eax,%ebx
12d: 56 push %esi
12e: 50 push %eax
12f: e8 4c 05 00 00 call 680 <fstat>
134: 83 c4 10 add $0x10,%esp
137: 85 c0 test %eax,%eax
139: 0f 88 c1 01 00 00 js 300 <ls+0x200>
printf(2, "ls: cannot stat %s\n", path);
close(fd);
return;
}
switch(st.type){
13f: 0f b7 85 d4 fd ff ff movzwl -0x22c(%ebp),%eax
146: 66 83 f8 01 cmp $0x1,%ax
14a: 74 54 je 1a0 <ls+0xa0>
14c: 66 83 f8 02 cmp $0x2,%ax
150: 75 37 jne 189 <ls+0x89>
case T_FILE:
printf(1, "%s %d %d %d\n", fmtname(path), st.type, st.ino, st.size);
152: 83 ec 0c sub $0xc,%esp
155: 8b 95 e4 fd ff ff mov -0x21c(%ebp),%edx
15b: 8b b5 dc fd ff ff mov -0x224(%ebp),%esi
161: 57 push %edi
162: 89 95 b4 fd ff ff mov %edx,-0x24c(%ebp)
168: e8 f3 fe ff ff call 60 <fmtname>
16d: 8b 95 b4 fd ff ff mov -0x24c(%ebp),%edx
173: 59 pop %ecx
174: 5f pop %edi
175: 52 push %edx
176: 56 push %esi
177: 6a 02 push $0x2
179: 50 push %eax
17a: 68 d8 0a 00 00 push $0xad8
17f: 6a 01 push $0x1
181: e8 0a 06 00 00 call 790 <printf>
break;
186: 83 c4 20 add $0x20,%esp
}
printf(1, "%s %d %d %d\n", fmtname(buf), st.type, st.ino, st.size);
}
break;
}
close(fd);
189: 83 ec 0c sub $0xc,%esp
18c: 53 push %ebx
18d: e8 be 04 00 00 call 650 <close>
192: 83 c4 10 add $0x10,%esp
}
195: 8d 65 f4 lea -0xc(%ebp),%esp
198: 5b pop %ebx
199: 5e pop %esi
19a: 5f pop %edi
19b: 5d pop %ebp
19c: c3 ret
19d: 8d 76 00 lea 0x0(%esi),%esi
case T_FILE:
printf(1, "%s %d %d %d\n", fmtname(path), st.type, st.ino, st.size);
break;
case T_DIR:
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
1a0: 83 ec 0c sub $0xc,%esp
1a3: 57 push %edi
1a4: e8 a7 02 00 00 call 450 <strlen>
1a9: 83 c0 10 add $0x10,%eax
1ac: 83 c4 10 add $0x10,%esp
1af: 3d 00 02 00 00 cmp $0x200,%eax
1b4: 0f 87 26 01 00 00 ja 2e0 <ls+0x1e0>
printf(1, "ls: path too long\n");
break;
}
strcpy(buf, path);
1ba: 8d 85 e8 fd ff ff lea -0x218(%ebp),%eax
1c0: 83 ec 08 sub $0x8,%esp
1c3: 57 push %edi
1c4: 8d bd c4 fd ff ff lea -0x23c(%ebp),%edi
1ca: 50 push %eax
1cb: e8 70 01 00 00 call 340 <strcpy>
p = buf+strlen(buf);
1d0: 8d 85 e8 fd ff ff lea -0x218(%ebp),%eax
1d6: 89 04 24 mov %eax,(%esp)
1d9: e8 72 02 00 00 call 450 <strlen>
1de: 8d 95 e8 fd ff ff lea -0x218(%ebp),%edx
*p++ = '/';
while(read(fd, &de, sizeof(de)) == sizeof(de)){
1e4: 83 c4 10 add $0x10,%esp
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
printf(1, "ls: path too long\n");
break;
}
strcpy(buf, path);
p = buf+strlen(buf);
1e7: 8d 0c 02 lea (%edx,%eax,1),%ecx
*p++ = '/';
1ea: 8d 84 05 e9 fd ff ff lea -0x217(%ebp,%eax,1),%eax
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
printf(1, "ls: path too long\n");
break;
}
strcpy(buf, path);
p = buf+strlen(buf);
1f1: 89 8d a8 fd ff ff mov %ecx,-0x258(%ebp)
*p++ = '/';
1f7: 89 85 a4 fd ff ff mov %eax,-0x25c(%ebp)
1fd: c6 01 2f movb $0x2f,(%ecx)
while(read(fd, &de, sizeof(de)) == sizeof(de)){
200: 83 ec 04 sub $0x4,%esp
203: 6a 10 push $0x10
205: 57 push %edi
206: 53 push %ebx
207: e8 34 04 00 00 call 640 <read>
20c: 83 c4 10 add $0x10,%esp
20f: 83 f8 10 cmp $0x10,%eax
212: 0f 85 71 ff ff ff jne 189 <ls+0x89>
if(de.inum == 0)
218: 66 83 bd c4 fd ff ff cmpw $0x0,-0x23c(%ebp)
21f: 00
220: 74 de je 200 <ls+0x100>
continue;
memmove(p, de.name, DIRSIZ);
222: 8d 85 c6 fd ff ff lea -0x23a(%ebp),%eax
228: 83 ec 04 sub $0x4,%esp
22b: 6a 0e push $0xe
22d: 50 push %eax
22e: ff b5 a4 fd ff ff pushl -0x25c(%ebp)
234: e8 a7 03 00 00 call 5e0 <memmove>
p[DIRSIZ] = 0;
239: 8b 85 a8 fd ff ff mov -0x258(%ebp),%eax
23f: c6 40 0f 00 movb $0x0,0xf(%eax)
if(stat(buf, &st) < 0){
243: 58 pop %eax
244: 8d 85 e8 fd ff ff lea -0x218(%ebp),%eax
24a: 5a pop %edx
24b: 56 push %esi
24c: 50 push %eax
24d: e8 fe 02 00 00 call 550 <stat>
252: 83 c4 10 add $0x10,%esp
255: 85 c0 test %eax,%eax
257: 0f 88 c3 00 00 00 js 320 <ls+0x220>
printf(1, "ls: cannot stat %s\n", buf);
continue;
}
printf(1, "%s %d %d %d\n", fmtname(buf), st.type, st.ino, st.size);
25d: 8b 8d e4 fd ff ff mov -0x21c(%ebp),%ecx
263: 0f bf 85 d4 fd ff ff movswl -0x22c(%ebp),%eax
26a: 83 ec 0c sub $0xc,%esp
26d: 8b 95 dc fd ff ff mov -0x224(%ebp),%edx
273: 89 8d ac fd ff ff mov %ecx,-0x254(%ebp)
279: 8d 8d e8 fd ff ff lea -0x218(%ebp),%ecx
27f: 89 95 b0 fd ff ff mov %edx,-0x250(%ebp)
285: 89 85 b4 fd ff ff mov %eax,-0x24c(%ebp)
28b: 51 push %ecx
28c: e8 cf fd ff ff call 60 <fmtname>
291: 5a pop %edx
292: 8b 95 b0 fd ff ff mov -0x250(%ebp),%edx
298: 59 pop %ecx
299: 8b 8d ac fd ff ff mov -0x254(%ebp),%ecx
29f: 51 push %ecx
2a0: 52 push %edx
2a1: ff b5 b4 fd ff ff pushl -0x24c(%ebp)
2a7: 50 push %eax
2a8: 68 d8 0a 00 00 push $0xad8
2ad: 6a 01 push $0x1
2af: e8 dc 04 00 00 call 790 <printf>
2b4: 83 c4 20 add $0x20,%esp
2b7: e9 44 ff ff ff jmp 200 <ls+0x100>
2bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
int fd;
struct dirent de;
struct stat st;
if((fd = open(path, 0)) < 0){
printf(2, "ls: cannot open %s\n", path);
2c0: 83 ec 04 sub $0x4,%esp
2c3: 57 push %edi
2c4: 68 b0 0a 00 00 push $0xab0
2c9: 6a 02 push $0x2
2cb: e8 c0 04 00 00 call 790 <printf>
return;
2d0: 83 c4 10 add $0x10,%esp
printf(1, "%s %d %d %d\n", fmtname(buf), st.type, st.ino, st.size);
}
break;
}
close(fd);
}
2d3: 8d 65 f4 lea -0xc(%ebp),%esp
2d6: 5b pop %ebx
2d7: 5e pop %esi
2d8: 5f pop %edi
2d9: 5d pop %ebp
2da: c3 ret
2db: 90 nop
2dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
printf(1, "%s %d %d %d\n", fmtname(path), st.type, st.ino, st.size);
break;
case T_DIR:
if(strlen(path) + 1 + DIRSIZ + 1 > sizeof buf){
printf(1, "ls: path too long\n");
2e0: 83 ec 08 sub $0x8,%esp
2e3: 68 e5 0a 00 00 push $0xae5
2e8: 6a 01 push $0x1
2ea: e8 a1 04 00 00 call 790 <printf>
break;
2ef: 83 c4 10 add $0x10,%esp
2f2: e9 92 fe ff ff jmp 189 <ls+0x89>
2f7: 89 f6 mov %esi,%esi
2f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
printf(2, "ls: cannot open %s\n", path);
return;
}
if(fstat(fd, &st) < 0){
printf(2, "ls: cannot stat %s\n", path);
300: 83 ec 04 sub $0x4,%esp
303: 57 push %edi
304: 68 c4 0a 00 00 push $0xac4
309: 6a 02 push $0x2
30b: e8 80 04 00 00 call 790 <printf>
close(fd);
310: 89 1c 24 mov %ebx,(%esp)
313: e8 38 03 00 00 call 650 <close>
return;
318: 83 c4 10 add $0x10,%esp
31b: e9 75 fe ff ff jmp 195 <ls+0x95>
if(de.inum == 0)
continue;
memmove(p, de.name, DIRSIZ);
p[DIRSIZ] = 0;
if(stat(buf, &st) < 0){
printf(1, "ls: cannot stat %s\n", buf);
320: 8d 85 e8 fd ff ff lea -0x218(%ebp),%eax
326: 83 ec 04 sub $0x4,%esp
329: 50 push %eax
32a: 68 c4 0a 00 00 push $0xac4
32f: 6a 01 push $0x1
331: e8 5a 04 00 00 call 790 <printf>
continue;
336: 83 c4 10 add $0x10,%esp
339: e9 c2 fe ff ff jmp 200 <ls+0x100>
33e: 66 90 xchg %ax,%ax
00000340 <strcpy>:
#include "user.h"
#include "x86.h"
char*
strcpy(char *s, char *t)
{
340: 55 push %ebp
341: 89 e5 mov %esp,%ebp
343: 53 push %ebx
344: 8b 45 08 mov 0x8(%ebp),%eax
347: 8b 4d 0c mov 0xc(%ebp),%ecx
char *os;
os = s;
while((*s++ = *t++) != 0)
34a: 89 c2 mov %eax,%edx
34c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
350: 83 c1 01 add $0x1,%ecx
353: 0f b6 59 ff movzbl -0x1(%ecx),%ebx
357: 83 c2 01 add $0x1,%edx
35a: 84 db test %bl,%bl
35c: 88 5a ff mov %bl,-0x1(%edx)
35f: 75 ef jne 350 <strcpy+0x10>
;
return os;
}
361: 5b pop %ebx
362: 5d pop %ebp
363: c3 ret
364: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
36a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
00000370 <strncpy>:
char* strncpy(char* s, char* t, int n) {
370: 55 push %ebp
int i = 0;
371: 31 d2 xor %edx,%edx
while((*s++ = *t++) != 0)
;
return os;
}
char* strncpy(char* s, char* t, int n) {
373: 89 e5 mov %esp,%ebp
375: 56 push %esi
376: 53 push %ebx
377: 8b 45 08 mov 0x8(%ebp),%eax
37a: 8b 5d 0c mov 0xc(%ebp),%ebx
37d: 8b 75 10 mov 0x10(%ebp),%esi
int i = 0;
char *os;
os = s;
while(((*s++ = *t++) != 0) && (++i < n));
380: eb 0d jmp 38f <strncpy+0x1f>
382: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
388: 83 c2 01 add $0x1,%edx
38b: 39 f2 cmp %esi,%edx
38d: 7d 0b jge 39a <strncpy+0x2a>
38f: 0f b6 0c 13 movzbl (%ebx,%edx,1),%ecx
393: 84 c9 test %cl,%cl
395: 88 0c 10 mov %cl,(%eax,%edx,1)
398: 75 ee jne 388 <strncpy+0x18>
return os;
}
39a: 5b pop %ebx
39b: 5e pop %esi
39c: 5d pop %ebp
39d: c3 ret
39e: 66 90 xchg %ax,%ax
000003a0 <strcmp>:
int
strcmp(const char *p, const char *q)
{
3a0: 55 push %ebp
3a1: 89 e5 mov %esp,%ebp
3a3: 56 push %esi
3a4: 53 push %ebx
3a5: 8b 55 08 mov 0x8(%ebp),%edx
3a8: 8b 4d 0c mov 0xc(%ebp),%ecx
while(*p && *p == *q)
3ab: 0f b6 02 movzbl (%edx),%eax
3ae: 0f b6 19 movzbl (%ecx),%ebx
3b1: 84 c0 test %al,%al
3b3: 75 1e jne 3d3 <strcmp+0x33>
3b5: eb 29 jmp 3e0 <strcmp+0x40>
3b7: 89 f6 mov %esi,%esi
3b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
p++, q++;
3c0: 83 c2 01 add $0x1,%edx
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3c3: 0f b6 02 movzbl (%edx),%eax
p++, q++;
3c6: 8d 71 01 lea 0x1(%ecx),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3c9: 0f b6 59 01 movzbl 0x1(%ecx),%ebx
3cd: 84 c0 test %al,%al
3cf: 74 0f je 3e0 <strcmp+0x40>
3d1: 89 f1 mov %esi,%ecx
3d3: 38 d8 cmp %bl,%al
3d5: 74 e9 je 3c0 <strcmp+0x20>
p++, q++;
return (uchar)*p - (uchar)*q;
3d7: 29 d8 sub %ebx,%eax
}
3d9: 5b pop %ebx
3da: 5e pop %esi
3db: 5d pop %ebp
3dc: c3 ret
3dd: 8d 76 00 lea 0x0(%esi),%esi
}
int
strcmp(const char *p, const char *q)
{
while(*p && *p == *q)
3e0: 31 c0 xor %eax,%eax
p++, q++;
return (uchar)*p - (uchar)*q;
3e2: 29 d8 sub %ebx,%eax
}
3e4: 5b pop %ebx
3e5: 5e pop %esi
3e6: 5d pop %ebp
3e7: c3 ret
3e8: 90 nop
3e9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000003f0 <strncmp>:
int strncmp(const char *p, const char *q, int n) {
3f0: 55 push %ebp
3f1: 89 e5 mov %esp,%ebp
3f3: 57 push %edi
3f4: 56 push %esi
3f5: 53 push %ebx
3f6: 8b 5d 10 mov 0x10(%ebp),%ebx
3f9: 8b 75 08 mov 0x8(%ebp),%esi
3fc: 8b 7d 0c mov 0xc(%ebp),%edi
int i = 0;
while(i < n && *p == *q)
3ff: 85 db test %ebx,%ebx
401: 7e 28 jle 42b <strncmp+0x3b>
403: 0f b6 16 movzbl (%esi),%edx
406: 0f b6 0f movzbl (%edi),%ecx
409: 38 d1 cmp %dl,%cl
40b: 75 2b jne 438 <strncmp+0x48>
40d: 31 c0 xor %eax,%eax
40f: eb 13 jmp 424 <strncmp+0x34>
411: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
418: 0f b6 14 06 movzbl (%esi,%eax,1),%edx
41c: 0f b6 0c 07 movzbl (%edi,%eax,1),%ecx
420: 38 ca cmp %cl,%dl
422: 75 14 jne 438 <strncmp+0x48>
p++, q++, i++;
424: 83 c0 01 add $0x1,%eax
return (uchar)*p - (uchar)*q;
}
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
427: 39 c3 cmp %eax,%ebx
429: 75 ed jne 418 <strncmp+0x28>
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
else
return 0;
}
42b: 5b pop %ebx
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
else
return 0;
42c: 31 c0 xor %eax,%eax
}
42e: 5e pop %esi
42f: 5f pop %edi
430: 5d pop %ebp
431: c3 ret
432: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
438: 0f b6 c2 movzbl %dl,%eax
else
return 0;
}
43b: 5b pop %ebx
int strncmp(const char *p, const char *q, int n) {
int i = 0;
while(i < n && *p == *q)
p++, q++, i++;
if (i < n)
return (uchar)*p - (uchar)*q;
43c: 29 c8 sub %ecx,%eax
else
return 0;
}
43e: 5e pop %esi
43f: 5f pop %edi
440: 5d pop %ebp
441: c3 ret
442: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
449: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
00000450 <strlen>:
uint
strlen(char *s)
{
450: 55 push %ebp
451: 89 e5 mov %esp,%ebp
453: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
for(n = 0; s[n]; n++)
456: 80 39 00 cmpb $0x0,(%ecx)
459: 74 12 je 46d <strlen+0x1d>
45b: 31 d2 xor %edx,%edx
45d: 8d 76 00 lea 0x0(%esi),%esi
460: 83 c2 01 add $0x1,%edx
463: 80 3c 11 00 cmpb $0x0,(%ecx,%edx,1)
467: 89 d0 mov %edx,%eax
469: 75 f5 jne 460 <strlen+0x10>
;
return n;
}
46b: 5d pop %ebp
46c: c3 ret
uint
strlen(char *s)
{
int n;
for(n = 0; s[n]; n++)
46d: 31 c0 xor %eax,%eax
;
return n;
}
46f: 5d pop %ebp
470: c3 ret
471: eb 0d jmp 480 <memset>
473: 90 nop
474: 90 nop
475: 90 nop
476: 90 nop
477: 90 nop
478: 90 nop
479: 90 nop
47a: 90 nop
47b: 90 nop
47c: 90 nop
47d: 90 nop
47e: 90 nop
47f: 90 nop
00000480 <memset>:
void*
memset(void *dst, int c, uint n)
{
480: 55 push %ebp
481: 89 e5 mov %esp,%ebp
483: 57 push %edi
484: 8b 55 08 mov 0x8(%ebp),%edx
}
static inline void
stosb(void *addr, int data, int cnt)
{
asm volatile("cld; rep stosb" :
487: 8b 4d 10 mov 0x10(%ebp),%ecx
48a: 8b 45 0c mov 0xc(%ebp),%eax
48d: 89 d7 mov %edx,%edi
48f: fc cld
490: f3 aa rep stos %al,%es:(%edi)
stosb(dst, c, n);
return dst;
}
492: 89 d0 mov %edx,%eax
494: 5f pop %edi
495: 5d pop %ebp
496: c3 ret
497: 89 f6 mov %esi,%esi
499: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000004a0 <strchr>:
char*
strchr(const char *s, char c)
{
4a0: 55 push %ebp
4a1: 89 e5 mov %esp,%ebp
4a3: 53 push %ebx
4a4: 8b 45 08 mov 0x8(%ebp),%eax
4a7: 8b 5d 0c mov 0xc(%ebp),%ebx
for(; *s; s++)
4aa: 0f b6 10 movzbl (%eax),%edx
4ad: 84 d2 test %dl,%dl
4af: 74 1d je 4ce <strchr+0x2e>
if(*s == c)
4b1: 38 d3 cmp %dl,%bl
4b3: 89 d9 mov %ebx,%ecx
4b5: 75 0d jne 4c4 <strchr+0x24>
4b7: eb 17 jmp 4d0 <strchr+0x30>
4b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
4c0: 38 ca cmp %cl,%dl
4c2: 74 0c je 4d0 <strchr+0x30>
}
char*
strchr(const char *s, char c)
{
for(; *s; s++)
4c4: 83 c0 01 add $0x1,%eax
4c7: 0f b6 10 movzbl (%eax),%edx
4ca: 84 d2 test %dl,%dl
4cc: 75 f2 jne 4c0 <strchr+0x20>
if(*s == c)
return (char*)s;
return 0;
4ce: 31 c0 xor %eax,%eax
}
4d0: 5b pop %ebx
4d1: 5d pop %ebp
4d2: c3 ret
4d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
4d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000004e0 <gets>:
char*
gets(char *buf, int max)
{
4e0: 55 push %ebp
4e1: 89 e5 mov %esp,%ebp
4e3: 57 push %edi
4e4: 56 push %esi
4e5: 53 push %ebx
int i, cc;
char c;
for(i=0; i+1 < max; ){
4e6: 31 f6 xor %esi,%esi
cc = read(0, &c, 1);
4e8: 8d 7d e7 lea -0x19(%ebp),%edi
return 0;
}
char*
gets(char *buf, int max)
{
4eb: 83 ec 1c sub $0x1c,%esp
int i, cc;
char c;
for(i=0; i+1 < max; ){
4ee: eb 29 jmp 519 <gets+0x39>
cc = read(0, &c, 1);
4f0: 83 ec 04 sub $0x4,%esp
4f3: 6a 01 push $0x1
4f5: 57 push %edi
4f6: 6a 00 push $0x0
4f8: e8 43 01 00 00 call 640 <read>
if(cc < 1)
4fd: 83 c4 10 add $0x10,%esp
500: 85 c0 test %eax,%eax
502: 7e 1d jle 521 <gets+0x41>
break;
buf[i++] = c;
504: 0f b6 45 e7 movzbl -0x19(%ebp),%eax
508: 8b 55 08 mov 0x8(%ebp),%edx
50b: 89 de mov %ebx,%esi
if(c == '\n' || c == '\r')
50d: 3c 0a cmp $0xa,%al
for(i=0; i+1 < max; ){
cc = read(0, &c, 1);
if(cc < 1)
break;
buf[i++] = c;
50f: 88 44 1a ff mov %al,-0x1(%edx,%ebx,1)
if(c == '\n' || c == '\r')
513: 74 1b je 530 <gets+0x50>
515: 3c 0d cmp $0xd,%al
517: 74 17 je 530 <gets+0x50>
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
519: 8d 5e 01 lea 0x1(%esi),%ebx
51c: 3b 5d 0c cmp 0xc(%ebp),%ebx
51f: 7c cf jl 4f0 <gets+0x10>
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
521: 8b 45 08 mov 0x8(%ebp),%eax
524: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
528: 8d 65 f4 lea -0xc(%ebp),%esp
52b: 5b pop %ebx
52c: 5e pop %esi
52d: 5f pop %edi
52e: 5d pop %ebp
52f: c3 ret
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
530: 8b 45 08 mov 0x8(%ebp),%eax
gets(char *buf, int max)
{
int i, cc;
char c;
for(i=0; i+1 < max; ){
533: 89 de mov %ebx,%esi
break;
buf[i++] = c;
if(c == '\n' || c == '\r')
break;
}
buf[i] = '\0';
535: c6 04 30 00 movb $0x0,(%eax,%esi,1)
return buf;
}
539: 8d 65 f4 lea -0xc(%ebp),%esp
53c: 5b pop %ebx
53d: 5e pop %esi
53e: 5f pop %edi
53f: 5d pop %ebp
540: c3 ret
541: eb 0d jmp 550 <stat>
543: 90 nop
544: 90 nop
545: 90 nop
546: 90 nop
547: 90 nop
548: 90 nop
549: 90 nop
54a: 90 nop
54b: 90 nop
54c: 90 nop
54d: 90 nop
54e: 90 nop
54f: 90 nop
00000550 <stat>:
int
stat(char *n, struct stat *st)
{
550: 55 push %ebp
551: 89 e5 mov %esp,%ebp
553: 56 push %esi
554: 53 push %ebx
int fd;
int r;
fd = open(n, O_RDONLY);
555: 83 ec 08 sub $0x8,%esp
558: 6a 00 push $0x0
55a: ff 75 08 pushl 0x8(%ebp)
55d: e8 06 01 00 00 call 668 <open>
if(fd < 0)
562: 83 c4 10 add $0x10,%esp
565: 85 c0 test %eax,%eax
567: 78 27 js 590 <stat+0x40>
return -1;
r = fstat(fd, st);
569: 83 ec 08 sub $0x8,%esp
56c: ff 75 0c pushl 0xc(%ebp)
56f: 89 c3 mov %eax,%ebx
571: 50 push %eax
572: e8 09 01 00 00 call 680 <fstat>
577: 89 c6 mov %eax,%esi
close(fd);
579: 89 1c 24 mov %ebx,(%esp)
57c: e8 cf 00 00 00 call 650 <close>
return r;
581: 83 c4 10 add $0x10,%esp
584: 89 f0 mov %esi,%eax
}
586: 8d 65 f8 lea -0x8(%ebp),%esp
589: 5b pop %ebx
58a: 5e pop %esi
58b: 5d pop %ebp
58c: c3 ret
58d: 8d 76 00 lea 0x0(%esi),%esi
int fd;
int r;
fd = open(n, O_RDONLY);
if(fd < 0)
return -1;
590: b8 ff ff ff ff mov $0xffffffff,%eax
595: eb ef jmp 586 <stat+0x36>
597: 89 f6 mov %esi,%esi
599: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
000005a0 <atoi>:
return r;
}
int
atoi(const char *s)
{
5a0: 55 push %ebp
5a1: 89 e5 mov %esp,%ebp
5a3: 53 push %ebx
5a4: 8b 4d 08 mov 0x8(%ebp),%ecx
int n;
n = 0;
while('0' <= *s && *s <= '9')
5a7: 0f be 11 movsbl (%ecx),%edx
5aa: 8d 42 d0 lea -0x30(%edx),%eax
5ad: 3c 09 cmp $0x9,%al
5af: b8 00 00 00 00 mov $0x0,%eax
5b4: 77 1f ja 5d5 <atoi+0x35>
5b6: 8d 76 00 lea 0x0(%esi),%esi
5b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
n = n*10 + *s++ - '0';
5c0: 8d 04 80 lea (%eax,%eax,4),%eax
5c3: 83 c1 01 add $0x1,%ecx
5c6: 8d 44 42 d0 lea -0x30(%edx,%eax,2),%eax
atoi(const char *s)
{
int n;
n = 0;
while('0' <= *s && *s <= '9')
5ca: 0f be 11 movsbl (%ecx),%edx
5cd: 8d 5a d0 lea -0x30(%edx),%ebx
5d0: 80 fb 09 cmp $0x9,%bl
5d3: 76 eb jbe 5c0 <atoi+0x20>
n = n*10 + *s++ - '0';
return n;
}
5d5: 5b pop %ebx
5d6: 5d pop %ebp
5d7: c3 ret
5d8: 90 nop
5d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
000005e0 <memmove>:
void*
memmove(void *vdst, void *vsrc, int n)
{
5e0: 55 push %ebp
5e1: 89 e5 mov %esp,%ebp
5e3: 56 push %esi
5e4: 53 push %ebx
5e5: 8b 5d 10 mov 0x10(%ebp),%ebx
5e8: 8b 45 08 mov 0x8(%ebp),%eax
5eb: 8b 75 0c mov 0xc(%ebp),%esi
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
5ee: 85 db test %ebx,%ebx
5f0: 7e 14 jle 606 <memmove+0x26>
5f2: 31 d2 xor %edx,%edx
5f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*dst++ = *src++;
5f8: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
5fc: 88 0c 10 mov %cl,(%eax,%edx,1)
5ff: 83 c2 01 add $0x1,%edx
{
char *dst, *src;
dst = vdst;
src = vsrc;
while(n-- > 0)
602: 39 da cmp %ebx,%edx
604: 75 f2 jne 5f8 <memmove+0x18>
*dst++ = *src++;
return vdst;
}
606: 5b pop %ebx
607: 5e pop %esi
608: 5d pop %ebp
609: c3 ret
60a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
00000610 <max>:
int max(int a, int b) {
610: 55 push %ebp
611: 89 e5 mov %esp,%ebp
613: 8b 55 08 mov 0x8(%ebp),%edx
616: 8b 45 0c mov 0xc(%ebp),%eax
if (b > a) return b;
else return a;
}
619: 5d pop %ebp
61a: 39 d0 cmp %edx,%eax
61c: 0f 4c c2 cmovl %edx,%eax
61f: c3 ret
00000620 <fork>:
name: \
movl $SYS_ ## name, %eax; \
int $T_SYSCALL; \
ret
SYSCALL(fork)
620: b8 01 00 00 00 mov $0x1,%eax
625: cd 40 int $0x40
627: c3 ret
00000628 <exit>:
SYSCALL(exit)
628: b8 02 00 00 00 mov $0x2,%eax
62d: cd 40 int $0x40
62f: c3 ret
00000630 <wait>:
SYSCALL(wait)
630: b8 03 00 00 00 mov $0x3,%eax
635: cd 40 int $0x40
637: c3 ret
00000638 <pipe>:
SYSCALL(pipe)
638: b8 04 00 00 00 mov $0x4,%eax
63d: cd 40 int $0x40
63f: c3 ret
00000640 <read>:
SYSCALL(read)
640: b8 05 00 00 00 mov $0x5,%eax
645: cd 40 int $0x40
647: c3 ret
00000648 <write>:
SYSCALL(write)
648: b8 10 00 00 00 mov $0x10,%eax
64d: cd 40 int $0x40
64f: c3 ret
00000650 <close>:
SYSCALL(close)
650: b8 15 00 00 00 mov $0x15,%eax
655: cd 40 int $0x40
657: c3 ret
00000658 <kill>:
SYSCALL(kill)
658: b8 06 00 00 00 mov $0x6,%eax
65d: cd 40 int $0x40
65f: c3 ret
00000660 <exec>:
SYSCALL(exec)
660: b8 07 00 00 00 mov $0x7,%eax
665: cd 40 int $0x40
667: c3 ret
00000668 <open>:
SYSCALL(open)
668: b8 0f 00 00 00 mov $0xf,%eax
66d: cd 40 int $0x40
66f: c3 ret
00000670 <mknod>:
SYSCALL(mknod)
670: b8 11 00 00 00 mov $0x11,%eax
675: cd 40 int $0x40
677: c3 ret
00000678 <unlink>:
SYSCALL(unlink)
678: b8 12 00 00 00 mov $0x12,%eax
67d: cd 40 int $0x40
67f: c3 ret
00000680 <fstat>:
SYSCALL(fstat)
680: b8 08 00 00 00 mov $0x8,%eax
685: cd 40 int $0x40
687: c3 ret
00000688 <link>:
SYSCALL(link)
688: b8 13 00 00 00 mov $0x13,%eax
68d: cd 40 int $0x40
68f: c3 ret
00000690 <mkdir>:
SYSCALL(mkdir)
690: b8 14 00 00 00 mov $0x14,%eax
695: cd 40 int $0x40
697: c3 ret
00000698 <chdir>:
SYSCALL(chdir)
698: b8 09 00 00 00 mov $0x9,%eax
69d: cd 40 int $0x40
69f: c3 ret
000006a0 <dup>:
SYSCALL(dup)
6a0: b8 0a 00 00 00 mov $0xa,%eax
6a5: cd 40 int $0x40
6a7: c3 ret
000006a8 <getpid>:
SYSCALL(getpid)
6a8: b8 0b 00 00 00 mov $0xb,%eax
6ad: cd 40 int $0x40
6af: c3 ret
000006b0 <sbrk>:
SYSCALL(sbrk)
6b0: b8 0c 00 00 00 mov $0xc,%eax
6b5: cd 40 int $0x40
6b7: c3 ret
000006b8 <sleep>:
SYSCALL(sleep)
6b8: b8 0d 00 00 00 mov $0xd,%eax
6bd: cd 40 int $0x40
6bf: c3 ret
000006c0 <uptime>:
SYSCALL(uptime)
6c0: b8 0e 00 00 00 mov $0xe,%eax
6c5: cd 40 int $0x40
6c7: c3 ret
000006c8 <setVariable>:
SYSCALL(setVariable)
6c8: b8 17 00 00 00 mov $0x17,%eax
6cd: cd 40 int $0x40
6cf: c3 ret
000006d0 <getVariable>:
SYSCALL(getVariable)
6d0: b8 18 00 00 00 mov $0x18,%eax
6d5: cd 40 int $0x40
6d7: c3 ret
000006d8 <remVariable>:
SYSCALL(remVariable)
6d8: b8 19 00 00 00 mov $0x19,%eax
6dd: cd 40 int $0x40
6df: c3 ret
000006e0 <wait2>:
SYSCALL(wait2)
6e0: b8 1a 00 00 00 mov $0x1a,%eax
6e5: cd 40 int $0x40
6e7: c3 ret
6e8: 66 90 xchg %ax,%ax
6ea: 66 90 xchg %ax,%ax
6ec: 66 90 xchg %ax,%ax
6ee: 66 90 xchg %ax,%ax
000006f0 <printint>:
write(fd, &c, 1);
}
static void
printint(int fd, int xx, int base, int sgn)
{
6f0: 55 push %ebp
6f1: 89 e5 mov %esp,%ebp
6f3: 57 push %edi
6f4: 56 push %esi
6f5: 53 push %ebx
6f6: 89 c6 mov %eax,%esi
6f8: 83 ec 3c sub $0x3c,%esp
char buf[16];
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
6fb: 8b 5d 08 mov 0x8(%ebp),%ebx
6fe: 85 db test %ebx,%ebx
700: 74 7e je 780 <printint+0x90>
702: 89 d0 mov %edx,%eax
704: c1 e8 1f shr $0x1f,%eax
707: 84 c0 test %al,%al
709: 74 75 je 780 <printint+0x90>
neg = 1;
x = -xx;
70b: 89 d0 mov %edx,%eax
int i, neg;
uint x;
neg = 0;
if(sgn && xx < 0){
neg = 1;
70d: c7 45 c4 01 00 00 00 movl $0x1,-0x3c(%ebp)
x = -xx;
714: f7 d8 neg %eax
716: 89 75 c0 mov %esi,-0x40(%ebp)
} else {
x = xx;
}
i = 0;
719: 31 ff xor %edi,%edi
71b: 8d 5d d7 lea -0x29(%ebp),%ebx
71e: 89 ce mov %ecx,%esi
720: eb 08 jmp 72a <printint+0x3a>
722: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
do{
buf[i++] = digits[x % base];
728: 89 cf mov %ecx,%edi
72a: 31 d2 xor %edx,%edx
72c: 8d 4f 01 lea 0x1(%edi),%ecx
72f: f7 f6 div %esi
731: 0f b6 92 04 0b 00 00 movzbl 0xb04(%edx),%edx
}while((x /= base) != 0);
738: 85 c0 test %eax,%eax
x = xx;
}
i = 0;
do{
buf[i++] = digits[x % base];
73a: 88 14 0b mov %dl,(%ebx,%ecx,1)
}while((x /= base) != 0);
73d: 75 e9 jne 728 <printint+0x38>
if(neg)
73f: 8b 45 c4 mov -0x3c(%ebp),%eax
742: 8b 75 c0 mov -0x40(%ebp),%esi
745: 85 c0 test %eax,%eax
747: 74 08 je 751 <printint+0x61>
buf[i++] = '-';
749: c6 44 0d d8 2d movb $0x2d,-0x28(%ebp,%ecx,1)
74e: 8d 4f 02 lea 0x2(%edi),%ecx
751: 8d 7c 0d d7 lea -0x29(%ebp,%ecx,1),%edi
755: 8d 76 00 lea 0x0(%esi),%esi
758: 0f b6 07 movzbl (%edi),%eax
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
75b: 83 ec 04 sub $0x4,%esp
75e: 83 ef 01 sub $0x1,%edi
761: 6a 01 push $0x1
763: 53 push %ebx
764: 56 push %esi
765: 88 45 d7 mov %al,-0x29(%ebp)
768: e8 db fe ff ff call 648 <write>
buf[i++] = digits[x % base];
}while((x /= base) != 0);
if(neg)
buf[i++] = '-';
while(--i >= 0)
76d: 83 c4 10 add $0x10,%esp
770: 39 df cmp %ebx,%edi
772: 75 e4 jne 758 <printint+0x68>
putc(fd, buf[i]);
}
774: 8d 65 f4 lea -0xc(%ebp),%esp
777: 5b pop %ebx
778: 5e pop %esi
779: 5f pop %edi
77a: 5d pop %ebp
77b: c3 ret
77c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
neg = 0;
if(sgn && xx < 0){
neg = 1;
x = -xx;
} else {
x = xx;
780: 89 d0 mov %edx,%eax
static char digits[] = "0123456789ABCDEF";
char buf[16];
int i, neg;
uint x;
neg = 0;
782: c7 45 c4 00 00 00 00 movl $0x0,-0x3c(%ebp)
789: eb 8b jmp 716 <printint+0x26>
78b: 90 nop
78c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
00000790 <printf>:
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
790: 55 push %ebp
791: 89 e5 mov %esp,%ebp
793: 57 push %edi
794: 56 push %esi
795: 53 push %ebx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
796: 8d 45 10 lea 0x10(%ebp),%eax
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
799: 83 ec 2c sub $0x2c,%esp
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
79c: 8b 75 0c mov 0xc(%ebp),%esi
}
// Print to the given fd. Only understands %d, %x, %p, %s.
void
printf(int fd, char *fmt, ...)
{
79f: 8b 7d 08 mov 0x8(%ebp),%edi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
7a2: 89 45 d0 mov %eax,-0x30(%ebp)
7a5: 0f b6 1e movzbl (%esi),%ebx
7a8: 83 c6 01 add $0x1,%esi
7ab: 84 db test %bl,%bl
7ad: 0f 84 b0 00 00 00 je 863 <printf+0xd3>
7b3: 31 d2 xor %edx,%edx
7b5: eb 39 jmp 7f0 <printf+0x60>
7b7: 89 f6 mov %esi,%esi
7b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
7c0: 83 f8 25 cmp $0x25,%eax
7c3: 89 55 d4 mov %edx,-0x2c(%ebp)
state = '%';
7c6: ba 25 00 00 00 mov $0x25,%edx
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
if(state == 0){
if(c == '%'){
7cb: 74 18 je 7e5 <printf+0x55>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
7cd: 8d 45 e2 lea -0x1e(%ebp),%eax
7d0: 83 ec 04 sub $0x4,%esp
7d3: 88 5d e2 mov %bl,-0x1e(%ebp)
7d6: 6a 01 push $0x1
7d8: 50 push %eax
7d9: 57 push %edi
7da: e8 69 fe ff ff call 648 <write>
7df: 8b 55 d4 mov -0x2c(%ebp),%edx
7e2: 83 c4 10 add $0x10,%esp
7e5: 83 c6 01 add $0x1,%esi
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
7e8: 0f b6 5e ff movzbl -0x1(%esi),%ebx
7ec: 84 db test %bl,%bl
7ee: 74 73 je 863 <printf+0xd3>
c = fmt[i] & 0xff;
if(state == 0){
7f0: 85 d2 test %edx,%edx
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
c = fmt[i] & 0xff;
7f2: 0f be cb movsbl %bl,%ecx
7f5: 0f b6 c3 movzbl %bl,%eax
if(state == 0){
7f8: 74 c6 je 7c0 <printf+0x30>
if(c == '%'){
state = '%';
} else {
putc(fd, c);
}
} else if(state == '%'){
7fa: 83 fa 25 cmp $0x25,%edx
7fd: 75 e6 jne 7e5 <printf+0x55>
if(c == 'd'){
7ff: 83 f8 64 cmp $0x64,%eax
802: 0f 84 f8 00 00 00 je 900 <printf+0x170>
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
808: 81 e1 f7 00 00 00 and $0xf7,%ecx
80e: 83 f9 70 cmp $0x70,%ecx
811: 74 5d je 870 <printf+0xe0>
printint(fd, *ap, 16, 0);
ap++;
} else if(c == 's'){
813: 83 f8 73 cmp $0x73,%eax
816: 0f 84 84 00 00 00 je 8a0 <printf+0x110>
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
}
} else if(c == 'c'){
81c: 83 f8 63 cmp $0x63,%eax
81f: 0f 84 ea 00 00 00 je 90f <printf+0x17f>
putc(fd, *ap);
ap++;
} else if(c == '%'){
825: 83 f8 25 cmp $0x25,%eax
828: 0f 84 c2 00 00 00 je 8f0 <printf+0x160>
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
82e: 8d 45 e7 lea -0x19(%ebp),%eax
831: 83 ec 04 sub $0x4,%esp
834: c6 45 e7 25 movb $0x25,-0x19(%ebp)
838: 6a 01 push $0x1
83a: 50 push %eax
83b: 57 push %edi
83c: e8 07 fe ff ff call 648 <write>
841: 83 c4 0c add $0xc,%esp
844: 8d 45 e6 lea -0x1a(%ebp),%eax
847: 88 5d e6 mov %bl,-0x1a(%ebp)
84a: 6a 01 push $0x1
84c: 50 push %eax
84d: 57 push %edi
84e: 83 c6 01 add $0x1,%esi
851: e8 f2 fd ff ff call 648 <write>
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
856: 0f b6 5e ff movzbl -0x1(%esi),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
85a: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
85d: 31 d2 xor %edx,%edx
int c, i, state;
uint *ap;
state = 0;
ap = (uint*)(void*)&fmt + 1;
for(i = 0; fmt[i]; i++){
85f: 84 db test %bl,%bl
861: 75 8d jne 7f0 <printf+0x60>
putc(fd, c);
}
state = 0;
}
}
}
863: 8d 65 f4 lea -0xc(%ebp),%esp
866: 5b pop %ebx
867: 5e pop %esi
868: 5f pop %edi
869: 5d pop %ebp
86a: c3 ret
86b: 90 nop
86c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
870: 83 ec 0c sub $0xc,%esp
873: b9 10 00 00 00 mov $0x10,%ecx
878: 6a 00 push $0x0
87a: 8b 5d d0 mov -0x30(%ebp),%ebx
87d: 89 f8 mov %edi,%eax
87f: 8b 13 mov (%ebx),%edx
881: e8 6a fe ff ff call 6f0 <printint>
ap++;
886: 89 d8 mov %ebx,%eax
888: 83 c4 10 add $0x10,%esp
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
88b: 31 d2 xor %edx,%edx
if(c == 'd'){
printint(fd, *ap, 10, 1);
ap++;
} else if(c == 'x' || c == 'p'){
printint(fd, *ap, 16, 0);
ap++;
88d: 83 c0 04 add $0x4,%eax
890: 89 45 d0 mov %eax,-0x30(%ebp)
893: e9 4d ff ff ff jmp 7e5 <printf+0x55>
898: 90 nop
899: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else if(c == 's'){
s = (char*)*ap;
8a0: 8b 45 d0 mov -0x30(%ebp),%eax
8a3: 8b 18 mov (%eax),%ebx
ap++;
8a5: 83 c0 04 add $0x4,%eax
8a8: 89 45 d0 mov %eax,-0x30(%ebp)
if(s == 0)
s = "(null)";
8ab: b8 fa 0a 00 00 mov $0xafa,%eax
8b0: 85 db test %ebx,%ebx
8b2: 0f 44 d8 cmove %eax,%ebx
while(*s != 0){
8b5: 0f b6 03 movzbl (%ebx),%eax
8b8: 84 c0 test %al,%al
8ba: 74 23 je 8df <printf+0x14f>
8bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
8c0: 88 45 e3 mov %al,-0x1d(%ebp)
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
8c3: 8d 45 e3 lea -0x1d(%ebp),%eax
8c6: 83 ec 04 sub $0x4,%esp
8c9: 6a 01 push $0x1
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
putc(fd, *s);
s++;
8cb: 83 c3 01 add $0x1,%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
8ce: 50 push %eax
8cf: 57 push %edi
8d0: e8 73 fd ff ff call 648 <write>
} else if(c == 's'){
s = (char*)*ap;
ap++;
if(s == 0)
s = "(null)";
while(*s != 0){
8d5: 0f b6 03 movzbl (%ebx),%eax
8d8: 83 c4 10 add $0x10,%esp
8db: 84 c0 test %al,%al
8dd: 75 e1 jne 8c0 <printf+0x130>
} else {
// Unknown % sequence. Print it to draw attention.
putc(fd, '%');
putc(fd, c);
}
state = 0;
8df: 31 d2 xor %edx,%edx
8e1: e9 ff fe ff ff jmp 7e5 <printf+0x55>
8e6: 8d 76 00 lea 0x0(%esi),%esi
8e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
8f0: 83 ec 04 sub $0x4,%esp
8f3: 88 5d e5 mov %bl,-0x1b(%ebp)
8f6: 8d 45 e5 lea -0x1b(%ebp),%eax
8f9: 6a 01 push $0x1
8fb: e9 4c ff ff ff jmp 84c <printf+0xbc>
} else {
putc(fd, c);
}
} else if(state == '%'){
if(c == 'd'){
printint(fd, *ap, 10, 1);
900: 83 ec 0c sub $0xc,%esp
903: b9 0a 00 00 00 mov $0xa,%ecx
908: 6a 01 push $0x1
90a: e9 6b ff ff ff jmp 87a <printf+0xea>
90f: 8b 5d d0 mov -0x30(%ebp),%ebx
#include "user.h"
static void
putc(int fd, char c)
{
write(fd, &c, 1);
912: 83 ec 04 sub $0x4,%esp
915: 8b 03 mov (%ebx),%eax
917: 6a 01 push $0x1
919: 88 45 e4 mov %al,-0x1c(%ebp)
91c: 8d 45 e4 lea -0x1c(%ebp),%eax
91f: 50 push %eax
920: 57 push %edi
921: e8 22 fd ff ff call 648 <write>
926: e9 5b ff ff ff jmp 886 <printf+0xf6>
92b: 66 90 xchg %ax,%ax
92d: 66 90 xchg %ax,%ax
92f: 90 nop
00000930 <free>:
static Header base;
static Header *freep;
void
free(void *ap)
{
930: 55 push %ebp
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
931: a1 a4 0e 00 00 mov 0xea4,%eax
static Header base;
static Header *freep;
void
free(void *ap)
{
936: 89 e5 mov %esp,%ebp
938: 57 push %edi
939: 56 push %esi
93a: 53 push %ebx
93b: 8b 5d 08 mov 0x8(%ebp),%ebx
Header *bp, *p;
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))
93e: 8b 10 mov (%eax),%edx
void
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
940: 8d 4b f8 lea -0x8(%ebx),%ecx
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
943: 39 c8 cmp %ecx,%eax
945: 73 19 jae 960 <free+0x30>
947: 89 f6 mov %esi,%esi
949: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
950: 39 d1 cmp %edx,%ecx
952: 72 1c jb 970 <free+0x40>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
954: 39 d0 cmp %edx,%eax
956: 73 18 jae 970 <free+0x40>
static Header base;
static Header *freep;
void
free(void *ap)
{
958: 89 d0 mov %edx,%eax
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
95a: 39 c8 cmp %ecx,%eax
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
95c: 8b 10 mov (%eax),%edx
free(void *ap)
{
Header *bp, *p;
bp = (Header*)ap - 1;
for(p = freep; !(bp > p && bp < p->s.ptr); p = p->s.ptr)
95e: 72 f0 jb 950 <free+0x20>
if(p >= p->s.ptr && (bp > p || bp < p->s.ptr))
960: 39 d0 cmp %edx,%eax
962: 72 f4 jb 958 <free+0x28>
964: 39 d1 cmp %edx,%ecx
966: 73 f0 jae 958 <free+0x28>
968: 90 nop
969: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
break;
if(bp + bp->s.size == p->s.ptr){
970: 8b 73 fc mov -0x4(%ebx),%esi
973: 8d 3c f1 lea (%ecx,%esi,8),%edi
976: 39 d7 cmp %edx,%edi
978: 74 19 je 993 <free+0x63>
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
97a: 89 53 f8 mov %edx,-0x8(%ebx)
if(p + p->s.size == bp){
97d: 8b 50 04 mov 0x4(%eax),%edx
980: 8d 34 d0 lea (%eax,%edx,8),%esi
983: 39 f1 cmp %esi,%ecx
985: 74 23 je 9aa <free+0x7a>
p->s.size += bp->s.size;
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
987: 89 08 mov %ecx,(%eax)
freep = p;
989: a3 a4 0e 00 00 mov %eax,0xea4
}
98e: 5b pop %ebx
98f: 5e pop %esi
990: 5f pop %edi
991: 5d pop %ebp
992: 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;
993: 03 72 04 add 0x4(%edx),%esi
996: 89 73 fc mov %esi,-0x4(%ebx)
bp->s.ptr = p->s.ptr->s.ptr;
999: 8b 10 mov (%eax),%edx
99b: 8b 12 mov (%edx),%edx
99d: 89 53 f8 mov %edx,-0x8(%ebx)
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
9a0: 8b 50 04 mov 0x4(%eax),%edx
9a3: 8d 34 d0 lea (%eax,%edx,8),%esi
9a6: 39 f1 cmp %esi,%ecx
9a8: 75 dd jne 987 <free+0x57>
p->s.size += bp->s.size;
9aa: 03 53 fc add -0x4(%ebx),%edx
p->s.ptr = bp->s.ptr;
} else
p->s.ptr = bp;
freep = p;
9ad: a3 a4 0e 00 00 mov %eax,0xea4
bp->s.size += p->s.ptr->s.size;
bp->s.ptr = p->s.ptr->s.ptr;
} else
bp->s.ptr = p->s.ptr;
if(p + p->s.size == bp){
p->s.size += bp->s.size;
9b2: 89 50 04 mov %edx,0x4(%eax)
p->s.ptr = bp->s.ptr;
9b5: 8b 53 f8 mov -0x8(%ebx),%edx
9b8: 89 10 mov %edx,(%eax)
} else
p->s.ptr = bp;
freep = p;
}
9ba: 5b pop %ebx
9bb: 5e pop %esi
9bc: 5f pop %edi
9bd: 5d pop %ebp
9be: c3 ret
9bf: 90 nop
000009c0 <malloc>:
return freep;
}
void*
malloc(uint nbytes)
{
9c0: 55 push %ebp
9c1: 89 e5 mov %esp,%ebp
9c3: 57 push %edi
9c4: 56 push %esi
9c5: 53 push %ebx
9c6: 83 ec 0c sub $0xc,%esp
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
9c9: 8b 45 08 mov 0x8(%ebp),%eax
if((prevp = freep) == 0){
9cc: 8b 15 a4 0e 00 00 mov 0xea4,%edx
malloc(uint nbytes)
{
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
9d2: 8d 78 07 lea 0x7(%eax),%edi
9d5: c1 ef 03 shr $0x3,%edi
9d8: 83 c7 01 add $0x1,%edi
if((prevp = freep) == 0){
9db: 85 d2 test %edx,%edx
9dd: 0f 84 a3 00 00 00 je a86 <malloc+0xc6>
9e3: 8b 02 mov (%edx),%eax
9e5: 8b 48 04 mov 0x4(%eax),%ecx
base.s.ptr = freep = prevp = &base;
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
9e8: 39 cf cmp %ecx,%edi
9ea: 76 74 jbe a60 <malloc+0xa0>
9ec: 81 ff 00 10 00 00 cmp $0x1000,%edi
9f2: be 00 10 00 00 mov $0x1000,%esi
9f7: 8d 1c fd 00 00 00 00 lea 0x0(,%edi,8),%ebx
9fe: 0f 43 f7 cmovae %edi,%esi
a01: ba 00 80 00 00 mov $0x8000,%edx
a06: 81 ff ff 0f 00 00 cmp $0xfff,%edi
a0c: 0f 46 da cmovbe %edx,%ebx
a0f: eb 10 jmp a21 <malloc+0x61>
a11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
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){
a18: 8b 02 mov (%edx),%eax
if(p->s.size >= nunits){
a1a: 8b 48 04 mov 0x4(%eax),%ecx
a1d: 39 cf cmp %ecx,%edi
a1f: 76 3f jbe a60 <malloc+0xa0>
p->s.size = nunits;
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
a21: 39 05 a4 0e 00 00 cmp %eax,0xea4
a27: 89 c2 mov %eax,%edx
a29: 75 ed jne a18 <malloc+0x58>
char *p;
Header *hp;
if(nu < 4096)
nu = 4096;
p = sbrk(nu * sizeof(Header));
a2b: 83 ec 0c sub $0xc,%esp
a2e: 53 push %ebx
a2f: e8 7c fc ff ff call 6b0 <sbrk>
if(p == (char*)-1)
a34: 83 c4 10 add $0x10,%esp
a37: 83 f8 ff cmp $0xffffffff,%eax
a3a: 74 1c je a58 <malloc+0x98>
return 0;
hp = (Header*)p;
hp->s.size = nu;
a3c: 89 70 04 mov %esi,0x4(%eax)
free((void*)(hp + 1));
a3f: 83 ec 0c sub $0xc,%esp
a42: 83 c0 08 add $0x8,%eax
a45: 50 push %eax
a46: e8 e5 fe ff ff call 930 <free>
return freep;
a4b: 8b 15 a4 0e 00 00 mov 0xea4,%edx
}
freep = prevp;
return (void*)(p + 1);
}
if(p == freep)
if((p = morecore(nunits)) == 0)
a51: 83 c4 10 add $0x10,%esp
a54: 85 d2 test %edx,%edx
a56: 75 c0 jne a18 <malloc+0x58>
return 0;
a58: 31 c0 xor %eax,%eax
a5a: eb 1c jmp a78 <malloc+0xb8>
a5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
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){
if(p->s.size == nunits)
a60: 39 cf cmp %ecx,%edi
a62: 74 1c je a80 <malloc+0xc0>
prevp->s.ptr = p->s.ptr;
else {
p->s.size -= nunits;
a64: 29 f9 sub %edi,%ecx
a66: 89 48 04 mov %ecx,0x4(%eax)
p += p->s.size;
a69: 8d 04 c8 lea (%eax,%ecx,8),%eax
p->s.size = nunits;
a6c: 89 78 04 mov %edi,0x4(%eax)
}
freep = prevp;
a6f: 89 15 a4 0e 00 00 mov %edx,0xea4
return (void*)(p + 1);
a75: 83 c0 08 add $0x8,%eax
}
if(p == freep)
if((p = morecore(nunits)) == 0)
return 0;
}
}
a78: 8d 65 f4 lea -0xc(%ebp),%esp
a7b: 5b pop %ebx
a7c: 5e pop %esi
a7d: 5f pop %edi
a7e: 5d pop %ebp
a7f: c3 ret
base.s.size = 0;
}
for(p = prevp->s.ptr; ; prevp = p, p = p->s.ptr){
if(p->s.size >= nunits){
if(p->s.size == nunits)
prevp->s.ptr = p->s.ptr;
a80: 8b 08 mov (%eax),%ecx
a82: 89 0a mov %ecx,(%edx)
a84: eb e9 jmp a6f <malloc+0xaf>
Header *p, *prevp;
uint nunits;
nunits = (nbytes + sizeof(Header) - 1)/sizeof(Header) + 1;
if((prevp = freep) == 0){
base.s.ptr = freep = prevp = &base;
a86: c7 05 a4 0e 00 00 a8 movl $0xea8,0xea4
a8d: 0e 00 00
a90: c7 05 a8 0e 00 00 a8 movl $0xea8,0xea8
a97: 0e 00 00
base.s.size = 0;
a9a: b8 a8 0e 00 00 mov $0xea8,%eax
a9f: c7 05 ac 0e 00 00 00 movl $0x0,0xeac
aa6: 00 00 00
aa9: e9 3e ff ff ff jmp 9ec <malloc+0x2c>
| 31.018335 | 73 | 0.4185 |
af15ed63e7502e0178037b4f841487257e9b1fdd | 311 | asm | Assembly | src/kernel/__gdt.asm | dacousb/HydrOS | 628cdde2f09c231c711fea7b88002f8240b52833 | [
"MIT"
] | 13 | 2021-12-06T11:59:53.000Z | 2022-03-01T13:38:57.000Z | src/kernel/__gdt.asm | dacousb/HydrOS | 628cdde2f09c231c711fea7b88002f8240b52833 | [
"MIT"
] | null | null | null | src/kernel/__gdt.asm | dacousb/HydrOS | 628cdde2f09c231c711fea7b88002f8240b52833 | [
"MIT"
] | null | null | null | [bits 64]
global gdt_load
; 0x00 : null
; 0x08 : kernel code
; 0x10 : kernel data
gdt_load:
lgdt [rdi] ; load the GDT given as a function parameter
mov ax, 0x10
mov ds, ax
mov es, ax
mov fs, ax
mov gs, ax
mov ss, ax
pop rdi
mov rax, 0x08
push rax
push rdi
retfq | 15.55 | 59 | 0.594855 |
b54c7f2df0a2e4c91a879bdf2b4f30fd6909fe7b | 1,257 | asm | Assembly | programs/oeis/187/A187560.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/187/A187560.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/187/A187560.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A187560: a(n) = 4^(n+1)-2^n-1.
; 2,13,59,247,1007,4063,16319,65407,261887,1048063,4193279,16775167,67104767,268427263,1073725439,4294934527,17179803647,68719345663,274877644799,1099511103487,4398045462527,17592183947263,70368739983359,281474968322047,1125899890065407,4503599593816063,18014398442373119,72057593903710207,288230375883276287,1152921504069976063,4611686017353646079,18446744071562067967,73786976290543239167,295147905170762891263,1180591620700231434239,4722366482835285475327,18889465931409861378047,75557863725776884465663,302231454903382415769599,1208925819614079418892287,4835703278457417187196927,19342813113831867772043263,77371252455331869134684159,309485009821336272631758847,1237940039285362682713079807,4951760157141485915224408063,19807040628566014029641809919,79228162514264196856055595007,316912650057057068899199090687,1267650600228228838546749784063,5070602400912916480086905978879,20282409603651668172147437600767,81129638414606677192189377773567,324518553658426717775956765835263,1298074214633706889118225572823039,5192296858534827592501699310256127,20769187434139310442064391278952447,83076749736557241912372753191665663,332306998946228967937721388918374399
add $0,2
mov $1,2
pow $1,$0
bin $1,2
div $1,2
sub $1,1
mov $0,$1
| 114.272727 | 1,157 | 0.91249 |
57b47816dbe06acaed626cd1baad865928dd763d | 371 | asm | Assembly | programs/oeis/242/A242849.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/242/A242849.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/242/A242849.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A242849: Triangle read by rows: T(n,k) = A060828(n)/(A060828(k) * A060828(n-k)).
; 1,1,1,1,1,1,1,3,3,1,1,1,3,1,1,1,1,1,1,1,1,1,3,3,1,3,3,1,1,1,3,1,1,3,1,1,1,1,1,1,1,1,1,1,1,1,9,9,3,9,9,3,9,9,1,1,1,9,3,3,9,3,3,9,1,1,1,1,1,3,3,3,3,3,3,1,1,1,1,3,3,1,9,9,3,9,9,1
seq $0,7318 ; Pascal's triangle read by rows: C(n,k) = binomial(n,k) = n!/(k!*(n-k)!), 0 <= k <= n.
gcd $0,9
| 61.833333 | 177 | 0.536388 |
64fa57186b3f9d2463c16cbac79186c5ccfcab15 | 7,555 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_885.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_885.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_885.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r8
push %r9
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_D_ht+0x667b, %rsi
lea addresses_normal_ht+0x12cfb, %rdi
nop
nop
nop
xor %rdx, %rdx
mov $35, %rcx
rep movsb
nop
add %rbx, %rbx
lea addresses_UC_ht+0x1defb, %rsi
lea addresses_A_ht+0x16e0b, %rdi
clflush (%rsi)
nop
nop
cmp %rbx, %rbx
mov $54, %rcx
rep movsb
cmp $19135, %rcx
lea addresses_A_ht+0x94fb, %rsi
nop
nop
nop
nop
sub $39252, %rcx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm3
and $0xffffffffffffffc0, %rsi
movntdq %xmm3, (%rsi)
xor %rbx, %rbx
lea addresses_WT_ht+0x36fb, %rsi
lea addresses_normal_ht+0x1e463, %rdi
clflush (%rsi)
nop
nop
nop
sub %r9, %r9
mov $88, %rcx
rep movsw
nop
nop
dec %rsi
lea addresses_D_ht+0x1aafb, %rsi
lea addresses_D_ht+0xf16b, %rdi
nop
nop
nop
and %r8, %r8
mov $112, %rcx
rep movsb
nop
nop
nop
nop
nop
add $32677, %rbx
lea addresses_D_ht+0x1f57, %rsi
lea addresses_WT_ht+0x207b, %rdi
nop
nop
nop
xor $65220, %rbx
mov $47, %rcx
rep movsb
and %rsi, %rsi
lea addresses_D_ht+0x62bb, %rsi
lea addresses_WC_ht+0x4bfb, %rdi
nop
nop
sub $63696, %r13
mov $14, %rcx
rep movsb
nop
nop
nop
sub %rdx, %rdx
lea addresses_UC_ht+0x9133, %rsi
lea addresses_D_ht+0x1badb, %rdi
nop
sub $12644, %r13
mov $91, %rcx
rep movsw
nop
nop
xor %rdi, %rdi
lea addresses_WT_ht+0x1b6fb, %rdi
nop
nop
nop
nop
nop
and $12497, %r9
mov $0x6162636465666768, %r13
movq %r13, (%rdi)
sub $44667, %rdx
lea addresses_D_ht+0x7afb, %rcx
and %rdx, %rdx
vmovups (%rcx), %ymm1
vextracti128 $1, %ymm1, %xmm1
vpextrq $0, %xmm1, %rbx
inc %r9
lea addresses_WC_ht+0x6fb, %rsi
lea addresses_WT_ht+0xc2bb, %rdi
nop
nop
nop
and %r9, %r9
mov $68, %rcx
rep movsb
nop
xor $57457, %rcx
lea addresses_UC_ht+0xd2d7, %rdx
nop
nop
nop
nop
inc %rdi
mov $0x6162636465666768, %r8
movq %r8, %xmm4
movups %xmm4, (%rdx)
nop
nop
inc %r8
lea addresses_normal_ht+0x1370d, %r8
nop
nop
add $42951, %r9
movups (%r8), %xmm4
vpextrq $1, %xmm4, %rcx
nop
nop
nop
nop
cmp $33804, %r13
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r9
pop %r8
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r8
push %rax
push %rdi
// Faulty Load
lea addresses_A+0x1efb, %r12
nop
nop
sub $23810, %rax
vmovups (%r12), %ymm6
vextracti128 $1, %ymm6, %xmm6
vpextrq $0, %xmm6, %r8
lea oracles, %r10
and $0xff, %r8
shlq $12, %r8
mov (%r10,%r8,1), %r8
pop %rdi
pop %rax
pop %r8
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': True, 'size': 16, 'type': 'addresses_A', 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_A', 'congruent': 0}}
<gen_prepare_buffer>
{'dst': {'same': False, 'congruent': 7, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 4, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_UC_ht'}}
{'dst': {'same': False, 'NT': True, 'AVXalign': False, 'size': 16, 'type': 'addresses_A_ht', 'congruent': 9}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 3, 'type': 'addresses_normal_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_WT_ht'}}
{'dst': {'same': False, 'congruent': 0, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 6, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 5, 'type': 'addresses_D_ht'}}
{'dst': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 3, 'type': 'addresses_UC_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 8, 'type': 'addresses_WT_ht', 'congruent': 9}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 32, 'type': 'addresses_D_ht', 'congruent': 8}}
{'dst': {'same': False, 'congruent': 6, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_WC_ht'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_UC_ht', 'congruent': 2}, 'OP': 'STOR'}
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_normal_ht', 'congruent': 0}}
{'35': 21829}
35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
| 36.853659 | 2,999 | 0.661549 |
28f6d417bb6d3b75138ad2233a60f769b8b4b48b | 656 | asm | Assembly | data/pokemon/base_stats/magnemite.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | 1 | 2022-02-15T00:19:44.000Z | 2022-02-15T00:19:44.000Z | data/pokemon/base_stats/magnemite.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null | data/pokemon/base_stats/magnemite.asm | opiter09/ASM-Machina | 75d8e457b3e82cc7a99b8e70ada643ab02863ada | [
"CC0-1.0"
] | null | null | null | db DEX_MAGNEMITE ; pokedex id
db 25, 35, 70, 45, 95
; hp atk def spd spc
db ELECTRIC, ELECTRIC ; type
db 190 ; catch rate
db 89 ; base exp
INCBIN "gfx/pokemon/front/magnemite.pic", 0, 1 ; sprite dimensions
dw MagnemitePicFront, MagnemitePicBack
db TACKLE, THUNDER_WAVE, NO_MOVE, NO_MOVE ; level 1 learnset
db GROWTH_MEDIUM_FAST ; growth rate
; tm/hm learnset
tmhm TOXIC, TAKE_DOWN, DOUBLE_EDGE, RAGE, THUNDERBOLT, \
THUNDER, TELEPORT, MIMIC, DOUBLE_TEAM, REFLECT, \
BIDE, SWIFT, REST, THUNDER_WAVE, SUBSTITUTE, \
FLASH
; end
db 0 ; padding
| 27.333333 | 77 | 0.621951 |
e4c9c91b7310a59df862364a58b29ed3b5b78c4c | 773 | asm | Assembly | oeis/238/A238803.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/238/A238803.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/238/A238803.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A238803: Number of ballot sequences of length 2n with exactly n fixed points.
; 1,1,3,9,29,99,357,1351,5343,21993,93923,414969,1892277,8887291,42912261,212676951,1080355463,5617772049,29868493827,162204146857,898874710797,5078665886931,29232738375653,171294038649639,1021117638212079,6188701520663929,38112047351927907,238358155234628121,1513158111485483813,9745873139406657003,63657218236993074693,421487675492772073399,2827892034308322333207,19218589820598336960801,132254304585077068936451,921265242916511674892361,6493974315977333179873533,46308294851200776142121539
mov $3,$0
mov $5,2
lpb $5
mov $0,$3
sub $5,1
add $0,$5
trn $0,1
seq $0,5425 ; a(n) = 2*a(n-1) + (n-1)*a(n-2).
mov $2,$5
mul $2,$0
add $4,$2
lpe
min $3,1
mul $3,$0
mov $0,$4
sub $0,$3
| 38.65 | 492 | 0.785252 |
1d08e67c8b5e6a579eab7f71a7756e7aa4174926 | 646 | asm | Assembly | oeis/157/A157664.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/157/A157664.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/157/A157664.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A157664: a(n) = 80000*n^2 + 800*n + 1.
; 80801,321601,722401,1283201,2004001,2884801,3925601,5126401,6487201,8008001,9688801,11529601,13530401,15691201,18012001,20492801,23133601,25934401,28895201,32016001,35296801,38737601,42338401,46099201,50020001,54100801,58341601,62742401,67303201,72024001,76904801,81945601,87146401,92507201,98028001,103708801,109549601,115550401,121711201,128032001,134512801,141153601,147954401,154915201,162036001,169316801,176757601,184358401,192119201,200040001,208120801,216361601,224762401,233323201,242044001
mov $2,$0
add $0,2
mov $1,1
mul $2,100
add $1,$2
mul $1,$0
sub $1,2
mul $1,800
add $1,80801
mov $0,$1
| 46.142857 | 501 | 0.811146 |
6ce9c9a0c286b7ebff6ab106519aca3d030f5b75 | 1,201 | asm | Assembly | programs/oeis/083/A083881.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/083/A083881.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/083/A083881.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A083881: a(n) = 6*a(n-1) - 6*a(n-2), with a(0)=1, a(1)=3.
; 1,3,12,54,252,1188,5616,26568,125712,594864,2814912,13320288,63032256,298271808,1411437312,6678993024,31605334272,149558047488,707716279296,3348949390848,15847398669312,74990695670784,354859782008832,1679214518028288,7946128416116736,37601483388530688,177932129834483712,841983878675718144,3984310493047406592,18853959686230130688,89217895159096344576,422183612837197283328,1997794306068605632512,9453664159388450095104,44735219119919066775552,211689329763183700082688,1001724663859587799842816,4740212004578424598560768,22430924044313020792307712,106144272238407577162481664,502280089164567338221043712,2376814901556958566351372288,11247208874354347368781971456,53222363836784332814583595008,251850929774579912674809741312,1191771395626773479161356877824,5639522795113161398919282819072,26686508396918327518547555647488,126281913610830996717769636970496,597572431283476015195332487938048,2827743106035870110865377105805312,13381024048514364574020267707203584,63319685654870966778929343608389632,299631969638139613229454455407116288
mov $1,2
mov $2,2
lpb $0
sub $0,1
mul $1,2
sub $1,$2
add $2,$1
mul $1,3
lpe
div $1,2
mov $0,$1
| 80.066667 | 1,034 | 0.880933 |
1d2e6f8f6eeb786d98cd05d119fac9ddabc17d90 | 760 | asm | Assembly | oeis/266/A266219.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/266/A266219.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/266/A266219.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A266219: Binary representation of the middle column of the "Rule 7" elementary cellular automaton starting with a single ON (black) cell.
; Submitted by Jamie Morken(s2)
; 1,11,110,1101,11010,110101,1101010,11010101,110101010,1101010101,11010101010,110101010101,1101010101010,11010101010101,110101010101010,1101010101010101,11010101010101010,110101010101010101,1101010101010101010,11010101010101010101,110101010101010101010,1101010101010101010101,11010101010101010101010,110101010101010101010101,1101010101010101010101010,11010101010101010101010101,110101010101010101010101010,1101010101010101010101010101,11010101010101010101010101010,110101010101010101010101010101
mov $1,10
pow $1,$0
add $1,12
mov $0,$1
mul $1,10
div $1,99
add $1,$0
mov $0,$1
sub $0,13
| 54.285714 | 496 | 0.855263 |
8fb1eceef3fb4664df5cd0facc8aa788bd8cca6b | 2,925 | asm | Assembly | src/PJ/flic386p/libsrc/vesa/cbralloc.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 119 | 2015-01-10T15:13:50.000Z | 2022-01-24T04:54:34.000Z | src/PJ/drivekit/vesa/cbralloc.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 6 | 2015-10-22T20:14:59.000Z | 2021-07-10T03:25:21.000Z | src/PJ/flic386p/libsrc/vesa/cbralloc.asm | AnimatorPro/Animator-Pro | 6d0b68cd94bb5cfde2cdd05e9a7c8ee1e1cb3cbb | [
"BSD-3-Clause"
] | 27 | 2015-04-24T22:55:30.000Z | 2022-01-21T13:54:00.000Z | ;*****************************************************************************
;* CBRALLOC.ASM - Allocate/Free DOS real (below 1mb line) memory (CodeBldr).
;*
;* Codebuilder allocates memory from below the 1mb line if the high bit of
;* the function code in eax is cleared. It uses the normal DOS function
;* number, but deals with flat pointers and byte counts, instead of segments
;* and paragraphs, like DOS does.
;*****************************************************************************
include stdmacro.i
include dosmem.i
Err_no_memory = -2
_TEXT segment
public pj_dosmem_alloc
public pj_dosmem_free
;*****************************************************************************
;* Errcode pj_dosmem_alloc(size_t bytes, struct dosmem_block *block);
;* This allocates a memory block of the specified size below the 1mb line.
;* If it succeeds, it return Success and the structure at *block holds
;* the selector:off32 and dos segment number of the realmode memory block.
;* If it fails, it returns Err_no_memory.
;*****************************************************************************
pj_dosmem_alloc proc near
Entry
Args #bytes,#block
Save ebx,esi,edi ; be safe; not sure DOS touches these.
mov ebx,#bytes ; load requested size, and func code for
mov eax,00004800h ; CodeBuilder alloc-dos-memory function.
int 21h ; do it. if CARRY is clear, go fill
jnc short #good ; in return value structure, else
mov eax,Err_no_memory ; return Err_no_memory.
jmp short #return
#good:
mov ebx,#block ; CB/DOS returns the flat address in
mov [ebx],eax ; in EAX, just store it. The selector
mov [ebx+4],gs ; part comes from the global below-1mb
shr eax,4 ; selector from GS. The dos segment
mov [ebx+6],ax ; number is calculated by shifting the
xor eax,eax ; flat address. Return Success.
#return:
Restore ebx,esi,edi
Exit
pj_dosmem_alloc endp
;*****************************************************************************
;* void pj_dosmem_free(struct dosmem_block *block)
;* this accepts a pointer to a dosmem_block structure which describes
;* a dos memory block allocated by pj_dosmem_alloc, and frees the block.
;*****************************************************************************
pj_dosmem_free proc near
Entry
Args #block
Save ebx,esi,edi
mov edx,#block ; load pointer to block. if pointer
test edx,edx ; is NULL just punt, else get the
jz short #punt ; 32-bit offset part of the far32
mov edx,[edx] ; pointer it points to, and check to
test edx,edx ; see if it's NULL. If so, just punt,
jz short #punt ; else pass it to the CodeBuilder
mov ax,00004900h ; free DOS memory function.
int 21h ; do it.
mov edx,#block
xor eax,eax
mov [edx],eax
mov [edx+4],eax
#punt:
Restore ebx,esi,edi
Exit
pj_dosmem_free endp
_TEXT ends
end
| 34.411765 | 79 | 0.591111 |
8a0425821b6ea3d2c7029b6da37b7e8eb7e24598 | 820 | asm | Assembly | programs/oeis/160/A160094.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/160/A160094.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/160/A160094.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A160094: 1 + the number of trailing zeros in n (A122840).
; 1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,3,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,2
mov $9,$0
mov $11,2
lpb $11,1
clr $0,9
mov $0,$9
sub $11,1
add $0,$11
lpb $0,1
div $0,10
add $8,$0
lpe
mov $1,$8
mov $12,$11
lpb $12,1
mov $10,$1
sub $12,1
lpe
lpe
lpb $9,1
mov $9,0
sub $10,$1
lpe
mov $1,$10
add $1,1
| 29.285714 | 501 | 0.507317 |
bf699f1a4a835c87758755f22fc79d4701350ddf | 593 | asm | Assembly | unittests/ASM/TwoByte/0F_7E.asm | cobalt2727/FEX | 13087f8425aeaad28dc81bed46a83e1d72ff0db8 | [
"MIT"
] | 628 | 2020-03-06T14:01:32.000Z | 2022-03-31T06:35:14.000Z | unittests/ASM/TwoByte/0F_7E.asm | cobalt2727/FEX | 13087f8425aeaad28dc81bed46a83e1d72ff0db8 | [
"MIT"
] | 576 | 2020-03-06T08:25:12.000Z | 2022-03-30T04:05:29.000Z | unittests/ASM/TwoByte/0F_7E.asm | cobalt2727/FEX | 13087f8425aeaad28dc81bed46a83e1d72ff0db8 | [
"MIT"
] | 38 | 2020-03-07T06:10:00.000Z | 2022-03-29T09:27:36.000Z | %ifdef CONFIG
{
"RegData": {
"RAX": "0x0000000045464748",
"RBX": "0x5152535455565758"
},
"MemoryRegions": {
"0x100000000": "4096"
}
}
%endif
mov rdx, 0xe0000000
mov rax, 0x4142434445464748
mov [rdx + 8 * 0], rax
mov rax, 0x5152535455565758
mov [rdx + 8 * 1], rax
mov rax, 0x6162636465666768
mov [rdx + 8 * 2], rax
mov rax, 0x7172737475767778
mov [rdx + 8 * 3], rax
mov rax, 0x0
mov [rdx + 8 * 4], rax
mov [rdx + 8 * 5], rax
mov eax, dword [rdx + 8 * 0]
mov rbx, qword [rdx + 8 * 1]
movd mm0, eax
movq mm1, rbx
mov rax, 0
mov rbx, 0
movd eax, mm0
movq rbx, mm1
hlt
| 14.119048 | 32 | 0.62226 |
2078eb54add6c7e73c54b815b5f94d79fea21fdc | 6,564 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_st_/i9-9900K_12_0xca_notsx.log_21829_210.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i9-9900K_12_0xca_notsx.log_21829_210.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_st_/i9-9900K_12_0xca_notsx.log_21829_210.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r13
push %rax
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x13ada, %rbp
add $5323, %rax
mov (%rbp), %r12d
nop
nop
add %rdi, %rdi
lea addresses_UC_ht+0x3652, %rsi
lea addresses_UC_ht+0x161ae, %rdi
nop
dec %rax
mov $116, %rcx
rep movsw
nop
nop
nop
nop
xor %rax, %rax
lea addresses_WC_ht+0x3fa, %rsi
lea addresses_normal_ht+0x1b12a, %rdi
nop
nop
nop
nop
dec %r13
mov $31, %rcx
rep movsq
nop
nop
cmp $56683, %rbp
lea addresses_normal_ht+0x15daa, %rbp
nop
nop
nop
and %rcx, %rcx
mov $0x6162636465666768, %rdi
movq %rdi, (%rbp)
nop
nop
nop
add $18967, %rcx
lea addresses_WT_ht+0x3bd2, %rax
cmp $43593, %r13
mov $0x6162636465666768, %rbp
movq %rbp, %xmm2
and $0xffffffffffffffc0, %rax
vmovaps %ymm2, (%rax)
nop
nop
nop
nop
nop
sub %rbp, %rbp
lea addresses_normal_ht+0x1c7aa, %rsi
lea addresses_D_ht+0x8faa, %rdi
nop
nop
nop
and %r11, %r11
mov $114, %rcx
rep movsq
nop
nop
nop
nop
sub %rbp, %rbp
lea addresses_WC_ht+0x946a, %r11
nop
nop
nop
nop
and %r12, %r12
movl $0x61626364, (%r11)
nop
nop
nop
xor $46370, %rax
lea addresses_UC_ht+0x12792, %rsi
lea addresses_WC_ht+0xd4da, %rdi
nop
nop
nop
nop
and %r13, %r13
mov $0, %rcx
rep movsq
nop
nop
nop
xor %rsi, %rsi
lea addresses_D_ht+0x197aa, %r13
cmp $40964, %rbp
mov (%r13), %rcx
nop
nop
nop
nop
sub %rdi, %rdi
lea addresses_D_ht+0x1faa, %rsi
lea addresses_UC_ht+0x72ea, %rdi
clflush (%rdi)
nop
nop
cmp %rbp, %rbp
mov $21, %rcx
rep movsl
sub %rsi, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r13
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r15
push %rax
push %rbp
// Faulty Load
lea addresses_PSE+0x17faa, %r13
nop
nop
xor $38126, %r15
movb (%r13), %r11b
lea oracles, %r13
and $0xff, %r11
shlq $12, %r11
mov (%r13,%r11,1), %r11
pop %rbp
pop %rax
pop %r15
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_PSE', 'NT': True, 'AVXalign': False, 'size': 1, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 2, 'type': 'addresses_UC_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 4, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_normal_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_normal_ht', 'NT': True, 'AVXalign': True, 'size': 8, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': True, 'AVXalign': True, 'size': 32, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 10, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 2, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 11}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_D_ht'}, 'dst': {'same': False, 'congruent': 3, 'type': 'addresses_UC_ht'}}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
| 38.162791 | 2,999 | 0.662096 |
e9164a3e98aa5a788dd8bec8bcd0416cfb4e9b99 | 7,639 | asm | Assembly | Transynther/x86/_processed/NC/_st_zr_un_4k_sm_/i9-9900K_12_0xca.log_21829_851.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NC/_st_zr_un_4k_sm_/i9-9900K_12_0xca.log_21829_851.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NC/_st_zr_un_4k_sm_/i9-9900K_12_0xca.log_21829_851.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r13
push %r9
push %rax
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WC_ht+0x67b2, %rdx
nop
nop
and $42281, %r13
movb $0x61, (%rdx)
nop
nop
nop
nop
nop
lfence
lea addresses_UC_ht+0xca4a, %r9
nop
nop
nop
inc %rcx
movw $0x6162, (%r9)
nop
nop
nop
dec %r11
lea addresses_WT_ht+0xe83e, %rsi
lea addresses_WT_ht+0x97ae, %rdi
clflush (%rsi)
nop
nop
add $54811, %rax
mov $6, %rcx
rep movsb
inc %rdx
lea addresses_A_ht+0x5d80, %r11
clflush (%r11)
nop
nop
nop
nop
add $12925, %rcx
movw $0x6162, (%r11)
nop
nop
nop
dec %r13
lea addresses_WC_ht+0x7715, %rsi
clflush (%rsi)
nop
nop
nop
nop
sub %r13, %r13
mov (%rsi), %ax
nop
nop
and $12191, %rax
lea addresses_WT_ht+0xcfae, %rsi
lea addresses_WT_ht+0x9a2e, %rdi
nop
nop
nop
nop
nop
inc %r13
mov $85, %rcx
rep movsl
nop
nop
nop
sub %rcx, %rcx
lea addresses_D_ht+0x1c3ae, %r9
nop
dec %rcx
movl $0x61626364, (%r9)
nop
nop
nop
and $226, %r9
lea addresses_A_ht+0x911e, %r11
nop
sub %r13, %r13
mov (%r11), %r9d
nop
nop
cmp $11187, %rax
lea addresses_WC_ht+0x71ee, %rsi
lea addresses_WC_ht+0x1a32e, %rdi
nop
nop
nop
nop
sub $15335, %rax
mov $80, %rcx
rep movsw
lfence
lea addresses_WC_ht+0xc72e, %rsi
lea addresses_WT_ht+0xe6ae, %rdi
nop
nop
nop
xor %rax, %rax
mov $71, %rcx
rep movsw
nop
nop
sub %r13, %r13
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rax
pop %r9
pop %r13
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r13
push %r14
push %r15
push %r9
push %rbx
push %rdi
push %rdx
// Store
lea addresses_UC+0xc068, %r14
clflush (%r14)
and $17887, %rdx
mov $0x5152535455565758, %r15
movq %r15, (%r14)
cmp $24735, %r14
// Load
mov $0x2b857900000003ae, %r14
nop
sub %r13, %r13
mov (%r14), %rdx
nop
nop
nop
nop
nop
cmp %r14, %r14
// Store
mov $0xcc72c00000003ae, %r9
nop
nop
nop
nop
nop
add $36897, %r14
movl $0x51525354, (%r9)
nop
nop
nop
dec %r13
// Store
lea addresses_normal+0x10bae, %rdi
nop
nop
inc %rbx
movl $0x51525354, (%rdi)
inc %r14
// Store
mov $0xcc72c00000003ae, %rdi
nop
inc %r15
mov $0x5152535455565758, %r13
movq %r13, %xmm6
vmovups %ymm6, (%rdi)
nop
nop
add $9318, %r13
// Faulty Load
mov $0xcc72c00000003ae, %r13
nop
nop
nop
add $62484, %rdx
mov (%r13), %r15
lea oracles, %rdx
and $0xff, %r15
shlq $12, %r15
mov (%rdx,%r15,1), %r15
pop %rdx
pop %rdi
pop %rbx
pop %r9
pop %r15
pop %r14
pop %r13
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_NC', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 8, 'NT': False, 'type': 'addresses_UC', 'same': False, 'AVXalign': True, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_NC', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_NC', 'same': True, 'AVXalign': True, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_normal', 'same': False, 'AVXalign': True, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'size': 32, 'NT': False, 'type': 'addresses_NC', 'same': True, 'AVXalign': False, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'size': 8, 'NT': False, 'type': 'addresses_NC', 'same': True, 'AVXalign': False, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'size': 1, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 2}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': False, 'type': 'addresses_UC_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': True, 'type': 'addresses_WT_ht', 'congruent': 2}, 'dst': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 10}}
{'OP': 'STOR', 'dst': {'size': 2, 'NT': True, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 1}}
{'OP': 'LOAD', 'src': {'size': 2, 'NT': False, 'type': 'addresses_WC_ht', 'same': False, 'AVXalign': False, 'congruent': 0}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 10}, 'dst': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 7}}
{'OP': 'STOR', 'dst': {'size': 4, 'NT': False, 'type': 'addresses_D_ht', 'same': False, 'AVXalign': True, 'congruent': 11}}
{'OP': 'LOAD', 'src': {'size': 4, 'NT': False, 'type': 'addresses_A_ht', 'same': False, 'AVXalign': False, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 7}}
{'OP': 'REPM', 'src': {'same': False, 'type': 'addresses_WC_ht', 'congruent': 6}, 'dst': {'same': False, 'type': 'addresses_WT_ht', 'congruent': 8}}
{'54': 125, '00': 305, '58': 21395, '85': 4}
00 58 58 58 58 58 54 58 58 58 58 58 58 58 58 58 54 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 54 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 54 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 00 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 54 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
| 32.926724 | 2,999 | 0.653096 |
95ea183d1b20fc390d991f58027dce95f38b229e | 398 | asm | Assembly | programs/oeis/065/A065164.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/065/A065164.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/065/A065164.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A065164: Permutation t->t+1 of Z, folded to N.
; 2,4,1,6,3,8,5,10,7,12,9,14,11,16,13,18,15,20,17,22,19,24,21,26,23,28,25,30,27,32,29,34,31,36,33,38,35,40,37,42,39,44,41,46,43,48,45,50,47,52,49,54,51,56,53,58,55,60,57,62,59,64,61,66,63,68,65,70,67,72,69,74
lpb $0
sub $0,1
add $1,2
mov $3,$0
trn $0,1
add $2,$1
trn $1,$3
mul $3,2
lpe
mov $0,$2
trn $0,2
add $1,2
sub $1,$3
add $1,$0
| 22.111111 | 208 | 0.590452 |
fe5a4a565770af28c4a7e053050d84da559b0862 | 965 | asm | Assembly | _build/dispatcher/jmp_ippsMD5Final_8d1581bf.asm | zyktrcn/ippcp | b0bbe9bbb750a7cf4af5914dd8e6776a8d544466 | [
"Apache-2.0"
] | 1 | 2021-10-04T10:21:54.000Z | 2021-10-04T10:21:54.000Z | _build/dispatcher/jmp_ippsMD5Final_8d1581bf.asm | zyktrcn/ippcp | b0bbe9bbb750a7cf4af5914dd8e6776a8d544466 | [
"Apache-2.0"
] | null | null | null | _build/dispatcher/jmp_ippsMD5Final_8d1581bf.asm | zyktrcn/ippcp | b0bbe9bbb750a7cf4af5914dd8e6776a8d544466 | [
"Apache-2.0"
] | null | null | null | extern m7_ippsMD5Final:function
extern n8_ippsMD5Final:function
extern y8_ippsMD5Final:function
extern e9_ippsMD5Final:function
extern l9_ippsMD5Final:function
extern n0_ippsMD5Final:function
extern k0_ippsMD5Final:function
extern ippcpJumpIndexForMergedLibs
extern ippcpSafeInit:function
segment .data
align 8
dq .Lin_ippsMD5Final
.Larraddr_ippsMD5Final:
dq m7_ippsMD5Final
dq n8_ippsMD5Final
dq y8_ippsMD5Final
dq e9_ippsMD5Final
dq l9_ippsMD5Final
dq n0_ippsMD5Final
dq k0_ippsMD5Final
segment .text
global ippsMD5Final:function (ippsMD5Final.LEndippsMD5Final - ippsMD5Final)
.Lin_ippsMD5Final:
db 0xf3, 0x0f, 0x1e, 0xfa
call ippcpSafeInit wrt ..plt
align 16
ippsMD5Final:
db 0xf3, 0x0f, 0x1e, 0xfa
mov rax, qword [rel ippcpJumpIndexForMergedLibs wrt ..gotpc]
movsxd rax, dword [rax]
lea r11, [rel .Larraddr_ippsMD5Final]
mov r11, qword [r11+rax*8]
jmp r11
.LEndippsMD5Final:
| 24.74359 | 75 | 0.772021 |
47c21e731eef2bf0b1b59c4d3640bbd6708b1b93 | 432 | asm | Assembly | oeis/212/A212158.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/212/A212158.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/212/A212158.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A212158: ((prime(n)- 1)/2)!, n >= 2.
; Submitted by Jamie Morken(s3)
; 1,2,6,120,720,40320,362880,39916800,87178291200,1307674368000,6402373705728000,2432902008176640000,51090942171709440000,25852016738884976640000,403291461126605635584000000,8841761993739701954543616000000
seq $0,5097 ; (Odd primes - 1)/2.
seq $0,142 ; Factorial numbers: n! = 1*2*3*4*...*n (order of symmetric group S_n, number of permutations of n letters).
| 61.714286 | 205 | 0.766204 |
f46bf1fed2c3ec2596388398633ce6b0bf1c1b1d | 4,806 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1197.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1197.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0x48_notsx.log_21829_1197.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r13
push %r14
push %r15
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Load
lea addresses_WT+0xe60c, %r14
nop
nop
nop
nop
nop
add %r10, %r10
mov (%r14), %r13d
and %r10, %r10
// Store
lea addresses_WT+0xe60c, %rdx
xor $38225, %rbx
movb $0x51, (%rdx)
nop
nop
nop
nop
nop
sub %rdx, %rdx
// REPMOV
lea addresses_PSE+0x10aa3, %rsi
lea addresses_UC+0x1670c, %rdi
nop
sub %r13, %r13
mov $41, %rcx
rep movsl
nop
add $65075, %r13
// Store
lea addresses_normal+0x3f0c, %rcx
nop
nop
nop
nop
nop
add $34547, %rdx
mov $0x5152535455565758, %rdi
movq %rdi, (%rcx)
nop
sub %r10, %r10
// Faulty Load
lea addresses_WT+0xe60c, %rcx
nop
nop
nop
nop
nop
xor $56220, %rdx
movups (%rcx), %xmm1
vpextrq $1, %xmm1, %r13
lea oracles, %r10
and $0xff, %r13
shlq $12, %r13
mov (%r10,%r13,1), %r13
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r15
pop %r14
pop %r13
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'NT': False, 'AVXalign': False, 'size': 2, 'type': 'addresses_WT', 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 4, 'type': 'addresses_WT', 'congruent': 0}}
{'dst': {'same': True, 'NT': False, 'AVXalign': False, 'size': 1, 'type': 'addresses_WT', 'congruent': 0}, 'OP': 'STOR'}
{'dst': {'same': False, 'congruent': 8, 'type': 'addresses_UC'}, 'OP': 'REPM', 'src': {'same': False, 'congruent': 0, 'type': 'addresses_PSE'}}
{'dst': {'same': False, 'NT': False, 'AVXalign': True, 'size': 8, 'type': 'addresses_normal', 'congruent': 8}, 'OP': 'STOR'}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'NT': False, 'AVXalign': False, 'size': 16, 'type': 'addresses_WT', 'congruent': 0}}
<gen_prepare_buffer>
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 47.584158 | 2,999 | 0.657511 |
b75e785c329cf94a57adb955e2c1421f20e39320 | 240 | asm | Assembly | libsrc/_DEVELOPMENT/adt/w_array/c/sccz80/w_array_init_callee.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/adt/w_array/c/sccz80/w_array_init_callee.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/adt/w_array/c/sccz80/w_array_init_callee.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null |
; w_array_t *w_array_init(void *p, void *data, size_t capacity)
SECTION code_adt_w_array
PUBLIC w_array_init_callee
w_array_init_callee:
pop hl
pop bc
pop de
ex (sp),hl
INCLUDE "adt/w_array/z80/asm_w_array_init.asm"
| 15 | 63 | 0.729167 |
b35bf50cf141b2ead06e224b0dc8ab6807cd9351 | 390 | asm | Assembly | oeis/113/A113282.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/113/A113282.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/113/A113282.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A113282: Logarithmic derivative of the g.f. of A113281.
; Submitted by Jamie Morken(s1.)
; 1,5,7,17,41,101,239,577,1393,3365,8119,19601,47321,114245,275807,665857,1607521,3880901,9369319,22619537,54608393,131836325,318281039,768398401,1855077841,4478554085,10812186007,26102926097,63018038201
seq $0,78057 ; Expansion of (1+x)/(1-2*x-x^2).
mov $1,4294967343
gcd $1,$0
add $0,$1
sub $0,1
| 39 | 203 | 0.761538 |
d55f8726a5835c77d382e8dedf36d847d2fc3951 | 280 | asm | Assembly | libsrc/_DEVELOPMENT/adt/b_vector/c/sdcc_iy/b_vector_insert_callee.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/_DEVELOPMENT/adt/b_vector/c/sdcc_iy/b_vector_insert_callee.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/_DEVELOPMENT/adt/b_vector/c/sdcc_iy/b_vector_insert_callee.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z |
; size_t b_vector_insert_callee(b_vector_t *v, size_t idx, int c)
SECTION code_clib
SECTION code_adt_b_vector
PUBLIC _b_vector_insert_callee
EXTERN asm_b_vector_insert
_b_vector_insert_callee:
pop af
pop hl
pop bc
pop de
push af
jp asm_b_vector_insert
| 14 | 65 | 0.771429 |
d0f8c82f17962f2bdb679fa18d3f0f66b7b7bbaa | 396 | asm | Assembly | src/firmware-tests/Platform/Main/PollMockToAssertTest.asm | pete-restall/Cluck2Sesame-Prototype | 99119b6748847a7b6aeadc4bee42cbed726f7fdc | [
"MIT"
] | 1 | 2019-12-12T09:07:08.000Z | 2019-12-12T09:07:08.000Z | src/firmware-tests/Platform/Main/PollMockToAssertTest.asm | pete-restall/Cluck2Sesame-Prototype | 99119b6748847a7b6aeadc4bee42cbed726f7fdc | [
"MIT"
] | null | null | null | src/firmware-tests/Platform/Main/PollMockToAssertTest.asm | pete-restall/Cluck2Sesame-Prototype | 99119b6748847a7b6aeadc4bee42cbed726f7fdc | [
"MIT"
] | null | null | null | #include "Platform.inc"
#include "TailCalls.inc"
#include "TestDoubles.inc"
radix decimal
extern testAssert
global calledPollForWork
udata
calledPollForWork res 1
PollMockToAssertTest code
global initialisePollMock
global pollForWork
initialisePollMock:
banksel calledPollForWork
clrf calledPollForWork
return
pollForWork:
mockCalled calledPollForWork
tcall testAssert
end
| 14.142857 | 29 | 0.820707 |
9dcc8524074d8fe26eb0c3e88fd683fb130077be | 434 | asm | Assembly | programs/oeis/120/A120664.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/120/A120664.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/120/A120664.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A120664: Expansion of 2*x*(1-6*x+12*x^2)/(1-8*x+19*x^2-12*x^3).
; 0,2,4,18,92,442,2004,8738,37132,155082,640004,2619058,10653372,43144922,174174004,701478978,2820264812,11324105962,45425564004,182089676498,729520967452,2921570654202,11696742970004,46818352939618
lpb $0
mov $1,$0
cal $1,162725 ; a(n) = 8*a(n-1) - 19*a(n-2) + 12*a(n-3) (n >= 3) with a(0) = a(1) = 1, a(2) = 2.
mov $0,0
mov $2,1
mul $2,$1
add $1,$2
lpe
| 36.166667 | 198 | 0.652074 |
9488b445f036f05518268635cefa649b634e9023 | 4,095 | asm | Assembly | external/mp/base/6502/cpu6502_cio.asm | polluks/effectus | 783a4715e8a86b6ecf0ce5c99da46102fa22b281 | [
"MIT"
] | 7 | 2020-05-02T15:37:57.000Z | 2021-02-17T01:59:41.000Z | external/mp/base/6502/cpu6502_cio.asm | polluks/effectus | 783a4715e8a86b6ecf0ce5c99da46102fa22b281 | [
"MIT"
] | 14 | 2020-05-03T02:02:35.000Z | 2020-08-10T08:41:19.000Z | external/mp/base/6502/cpu6502_cio.asm | polluks/effectus | 783a4715e8a86b6ecf0ce5c99da46102fa22b281 | [
"MIT"
] | 5 | 2020-06-02T18:34:14.000Z | 2020-07-09T18:13:44.000Z |
/*
Reset(f, record)
Rewrite(f, record)
C = 1 SEC IOCHECK TRUE
C = 0 CLC IOCHECK FALSE
*/
.proc @openfile (.word ya .byte x) .reg
sta bp2
sty bp2+1
stx code
lda #0
rol @
sta iocheck
ldy #s@file.status
lda (bp2),y
and #e@file.eof^$ff
sta (bp2),y
ldy #s@file.pfname
lda (bp2),y
add #1
sta lfname
iny
lda (bp2),y
adc #0
sta hfname
jsr lookup
bmi error
ldy #s@file.chanel
txa
sta (bp2),y ;CHANNEL
; -----------------------------------------
lda #$03 ;komenda: OPEN
sta iccmd,x
lda #$00 ;adres nazwy pliku
lfname equ *-1
sta icbufa,x
lda #$00
hfname equ *-1
sta icbufa+1,x
lda #$00 ;kod dostepu: $04 odczyt, $08 zapis, $09 dopisywanie, $0c odczyt/zapis, $0d odczyt/dopisywanie
code equ *-1
sta icax1,x
lda #$00 ;dodatkowy parametr, $00 jest zawsze dobre
sta icax2,x
jsr ciov
error sty MAIN.SYSTEM.IOResult
bpl ok
msg lda #true
iocheck equ *-1
beq skp
sty dx
; sty FX_CORE_RESET
@clrscr
lda <_error
ldy >_error
jsr @printSTRING
lda #$00
sta dx+1
sta dx+2
sta dx+3
jsr @printVALUE
jmp MAIN.@halt
skp ldy #s@file.status
lda (bp2),y
ora #e@file.eof
sta (bp2),y
ldy #s@file.record
lda #$00
sta (bp2),y
iny
sta (bp2),y
rts
ok ldy #s@file.status
lda (bp2),y
ora #e@file.open
sta (bp2),y
rts
_error dta 6,c'ERROR '
; -----------------------------------------
lookup ldx #$00
ldy #$01
loop lda icchid,x
cmp #$ff
beq found
txa
clc
adc #$10
tax
bpl loop
ldy #-95 ; kod bledu "TOO MANY CHANNELS OPEN"
found rts
.endp
/*
Close(f)
C = 1 SEC IOCHECK TRUE
C = 0 CLC IOCHECK FALSE
*/
.proc @closefile (.word ya) .reg
sta bp2
sty bp2+1
ldy #s@file.status
lda #0
rol @
sta @openfile.iocheck
; beq ok_open
lda (bp2),y
and #e@file.open
bne ok_open
ldy #-123 ; kod bledu "DEVICE OR FILE NOT OPEN"
jmp @openfile.error
ok_open lda (bp2),y
ora #e@file.eof
sta (bp2),y
ldy #s@file.chanel
lda (bp2),y
tax
lda #$0c ;komenda: CLOSE
sta iccmd,x
jsr ciov
; lda #0 ; iocheck off
; sta @openfile.iocheck
jmp @openfile.error
.endp
/*
BlockRead(f, buf, num_records, numread)
BlockWrite(f, buf, num_records, numwrite)
C = 1 SEC IOCHECK TRUE
C = 0 CLC IOCHECK FALSE
*/
.proc @readfile (.word ya .byte x) .reg
sta bp2
sty bp2+1
stx code
lda #$00
sta eax+2
sta eax+3
sta ecx+2
sta ecx+3
sta MAIN.SYSTEM.IOResult
rol @
sta @openfile.iocheck
ldy #s@file.status
lda (bp2),y
and #e@file.open
bne ok_open
ldy #-123 ; kod bledu "DEVICE OR FILE NOT OPEN"
jmp @openfile.error
ok_open ldy #s@file.record
mwa (bp2),y ecx
ldy #s@file.nrecord
mwa (bp2),y eax
; lda #0
jsr imulCX ; record * nrecord = file length to load
cpw eax #0
beq nothing
ldy #s@file.chanel
lda (bp2),y
tax
mwa eax icbufl,x
ldy #s@file.buffer
mwa (bp2),y icbufa,x
lda #$00
code equ *-1
and #$7f
sta iccmd,x
jsr ciov
sty MAIN.SYSTEM.IOResult
bpl ok
cpy #136
beq done
jsr eof
lda #$00
sta eax
sta eax+1
jmp @openfile.msg
done jsr eof
ok mwa icbufl,x eax
ldy #s@file.record
mwa (bp2),y ecx
lda #$00
jsr idivAX_CX.main
nothing lda code
bpl quit ; blockread(f, buf, len) short version
ldy #s@file.numread
mwa (bp2),y ztmp
ldy #0
mwa eax (ztmp),y ; length of loaded data / record = number of records
quit rts
eof ldy #s@file.status
lda (bp2),y
ora #e@file.eof
sta (bp2),y
rts
.endp
.proc @ReadDirFileName (.word ya) .reg
ldx #5
clc ; iocheck off
jsr @readfile ; (ya, x)
ldy eax
lda MAIN.SYSTEM.IOResult
smi
lda #0 ; ok
rts
.endp
.proc @DirFileName
lda #0
sta attr
cpy #$12
bne stop
lda @buf
cmp #'*'
bne skp
lda #MAIN.SYSUTILS.faReadOnly
sta attr
skp ldy #1
ldx #2
lda #10
jsr cpName
ldx #10
lda @buf,x
pha
bpl files
lda attr
ora #MAIN.SYSUTILS.faDirectory
sta attr
jmp skp2
files lda attr
ora #MAIN.SYSUTILS.faArchive
sta attr
skp2 pla
beq stp2
lda #'.'
sta (bp2),y
iny
lda #13
jsr cpName
stp2
dey
tya
stop ldy #0
sta (bp2),y
ldx #0
attr equ *-1
rts
cpName sta ln
cp lda @buf,x
cmp #' '
beq stp
sta (bp2),y
iny
inx
cpx #0
ln equ *-1
bne cp
stp rts
.endp
| 11.438547 | 105 | 0.632723 |
46b81d971d6b4a7f4aad5ebc3033390b7c1a1da0 | 144 | asm | Assembly | samples/loop.asm | sumanthreddy07/uPower_Assembler | ad382316fea8090219311aa363bdb886d2c9b391 | [
"MIT"
] | null | null | null | samples/loop.asm | sumanthreddy07/uPower_Assembler | ad382316fea8090219311aa363bdb886d2c9b391 | [
"MIT"
] | null | null | null | samples/loop.asm | sumanthreddy07/uPower_Assembler | ad382316fea8090219311aa363bdb886d2c9b391 | [
"MIT"
] | 2 | 2020-07-30T10:08:57.000Z | 2021-04-02T05:21:20.000Z | .text
addi R1, R0, 5
addi R3, R0, 7 #BF 7
addi R2, R0, 0
loop:
addi R2, R2, 1
cmp R3, R2, R1
bne loop
| 13.090909 | 24 | 0.4375 |
d3c815a3e116648dde941ad7e564f108b3fb1889 | 881 | asm | Assembly | programs/oeis/276/A276679.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/276/A276679.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/276/A276679.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A276679: Number of divisors of the n-th hexagonal number.
; 1,4,4,6,6,8,4,16,6,8,8,12,6,16,8,10,8,24,4,24,8,8,12,16,9,16,8,24,8,16,4,36,16,8,16,18,4,24,16,16,10,16,8,24,12,16,8,40,6,36,8,12,16,16,8,32,8,16,12,48,6,16,24,14,16,16,8,48,8,16,8,48,8,24,12,12,24,32,4,40,20,8,16,24,12,24,8,48,8,24,8,24,16,16,32,24,4,48,12,18,8,32,8,48,32,8,8,48,8,32,16,20,18,16,8,48,12,16,16,32,6,24,24,24,16,24,8,64,8,32,12,24,16,16,16,16,16,48,4,72,8,8,32,60,12,16,12,24,16,48,8,32,24,16,16,24,4,48,8,48,16,40,12,24,32,8,12,64,6,32,24,24,16,16,12,80,8,16,16,36,6,48,16,16,24,32,8,48,32,16,8,28,16,24,16,36,8,48,4,96,8,16,40,48,8,16,24,40,16,32,4,36,24,16,32,32,8,32,16,24,36,16,8,48,18,16,8,96,4,64,16,16,16,24,16,24,16,48,12,40,8,48,24,12,24,16,16,96,16,16
mul $0,2
mov $2,$0
add $2,1
bin $2,2
add $0,$2
cal $0,5 ; d(n) (also called tau(n) or sigma_0(n)), the number of divisors of n.
mov $1,$0
| 80.090909 | 681 | 0.634506 |
a07dd126d51fbec5dbb4009324901b2d4c4b1205 | 2,177 | asm | Assembly | non_regression/weak_x86_linux.out.asm | LRGH/plasmasm | 4cd50546c3dc895763d72dd60b7c46179c1916bc | [
"Apache-2.0"
] | 1 | 2021-02-28T21:31:18.000Z | 2021-02-28T21:31:18.000Z | non_regression/weak_x86_linux.out.asm | LRGH/plasmasm | 4cd50546c3dc895763d72dd60b7c46179c1916bc | [
"Apache-2.0"
] | null | null | null | non_regression/weak_x86_linux.out.asm | LRGH/plasmasm | 4cd50546c3dc895763d72dd60b7c46179c1916bc | [
"Apache-2.0"
] | null | null | null | .file "z02.cpp"
.text
.globl main
.type main, @function
main:
pushl %ebp
movl %esp, %ebp
movl $0, %eax
popl %ebp
ret
.size main, .-main
# ----------------------
.local _Z41__static_initialization_and_destruction_0ii
.type _Z41__static_initialization_and_destruction_0ii, @function
_Z41__static_initialization_and_destruction_0ii:
pushl %ebp
movl %esp, %ebp
subl $24, %esp
cmpl $1, 8(%ebp)
jne .L08048440
.L0804841A:
cmpl $65535, 12(%ebp)
jne .L08048440
.L08048423:
movl $_ZN4TotoIvED1Ev, %eax
movl $__dso_handle, 8(%esp)
movl $_ZL4tutu, 4(%esp)
movl %eax, (%esp)
call __cxa_atexit
.L08048440:
leave
ret
.size _Z41__static_initialization_and_destruction_0ii, .-_Z41__static_initialization_and_destruction_0ii
# ----------------------
.local _GLOBAL__sub_I_main
.type _GLOBAL__sub_I_main, @function
_GLOBAL__sub_I_main:
pushl %ebp
movl %esp, %ebp
subl $24, %esp
movl $65535, 4(%esp)
movl $1, (%esp)
call _Z41__static_initialization_and_destruction_0ii
.L0804845C:
leave
ret
.size _GLOBAL__sub_I_main, .-_GLOBAL__sub_I_main
# ----------------------
.weak _ZN4BaseD2Ev
.type _ZN4BaseD2Ev, @function
_ZN4BaseD2Ev:
pushl %ebp
movl %esp, %ebp
popl %ebp
ret
.size _ZN4BaseD2Ev, .-_ZN4BaseD2Ev
# ----------------------
.L08048463:
.p2align 2
# ----------------------
.weak _ZN4TotoIvED2Ev
.type _ZN4TotoIvED2Ev, @function
_ZN4TotoIvED2Ev:
pushl %ebp
movl %esp, %ebp
subl $24, %esp
movl 8(%ebp), %eax
movl %eax, (%esp)
call _ZN4BaseD1Ev
.L08048475:
leave
ret
.size _ZN4TotoIvED2Ev, .-_ZN4TotoIvED2Ev
# ----------------------
.section .init_array,"wa",@init_array
.LD.init_array.0:
.long _GLOBAL__sub_I_main
# ----------------------
.local _ZL4tutu
.comm _ZL4tutu,1,1
# ----------------------
.weak _ZN4TotoIvED1Ev
.set _ZN4TotoIvED1Ev,_ZN4TotoIvED2Ev
.hidden __dso_handle
.weak _ZN4BaseD1Ev
.set _ZN4BaseD1Ev,_ZN4BaseD2Ev
.ident "GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3"
.section .note.GNU-stack,"",@progbits
| 24.460674 | 105 | 0.615067 |
18855260db521b9c2e6e0acf545afe91b5f8cb65 | 1,513 | asm | Assembly | software/minol/source/commands/new_end.asm | paulscottrobson/retrochallenge-jan-2016 | 8bd340efc85969fa6f2fecc788aa21b27123a4db | [
"MIT"
] | null | null | null | software/minol/source/commands/new_end.asm | paulscottrobson/retrochallenge-jan-2016 | 8bd340efc85969fa6f2fecc788aa21b27123a4db | [
"MIT"
] | null | null | null | software/minol/source/commands/new_end.asm | paulscottrobson/retrochallenge-jan-2016 | 8bd340efc85969fa6f2fecc788aa21b27123a4db | [
"MIT"
] | null | null | null | ; ****************************************************************************************************************
; ****************************************************************************************************************
;
; NEW and END
;
; ****************************************************************************************************************
; ****************************************************************************************************************
jmp CNE_Over
; ****************************************************************************************************************
; NEW (Erase program) also executes END in case in running program
; ****************************************************************************************************************
CMD_New:
lpi p3,ProgramBase ; write $FF at program base
ldi 0xFF
st 0(p3) ; this erases the program
ldi Marker1 ; write the program-code-marker out.
st -4(p3)
ldi Marker2
st -3(p3)
ldi Marker3
st -2(p3)
ldi Marker4
st -1(p3)
; ****************************************************************************************************************
; END program
; ****************************************************************************************************************
CMD_End:
ccl ; we cause an error, but it is ERRC_End which is
ldi ERRC_End ; not an error and not reported as such.
xae
CNE_Over: | 40.891892 | 114 | 0.226702 |
162bf7b3f10fdcdcdbfc79eca88627900f337c8b | 314 | asm | Assembly | programs/oeis/029/A029739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/029/A029739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/029/A029739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A029739: Numbers that are congruent to {1, 3, 4} mod 6.
; 1,3,4,7,9,10,13,15,16,19,21,22,25,27,28,31,33,34,37,39,40,43,45,46,49,51,52,55,57,58,61,63,64,67,69,70,73,75,76,79,81,82,85,87,88,91,93,94,97,99,100,103,105,106,109,111,112,115,117,118,121,123,124
mov $1,$0
mul $0,2
mod $1,3
trn $1,1
sub $0,$1
add $0,1
| 31.4 | 198 | 0.646497 |
a06cbe8b6aa201d357e4e23549625cc84d2ebbe0 | 1,302 | asm | Assembly | coverage/IN_CTS/0242-COVERAGE-apfloat-1106-1815-1881/reduced_result/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | null | null | null | coverage/IN_CTS/0242-COVERAGE-apfloat-1106-1815-1881/reduced_result/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | 47 | 2021-03-11T07:42:51.000Z | 2022-03-14T06:30:14.000Z | coverage/IN_CTS/0242-COVERAGE-apfloat-1106-1815-1881/reduced_result/variant/1_spirv_asm/shader.frag.asm | asuonpaa/ShaderTests | 6a3672040dcfa0d164d313224446496d1775a15e | [
"Apache-2.0"
] | 4 | 2021-03-09T13:37:19.000Z | 2022-02-25T07:32:11.000Z | ; SPIR-V
; Version: 1.0
; Generator: Khronos Glslang Reference Front End; 8
; Bound: 23
; Schema: 0
OpCapability Shader
%1 = OpExtInstImport "GLSL.std.450"
OpMemoryModel Logical GLSL450
OpEntryPoint Fragment %4 "main" %9
OpExecutionMode %4 OriginUpperLeft
OpSource ESSL 310
OpName %4 "main"
OpName %9 "_GLF_color"
OpDecorate %9 Location 0
%2 = OpTypeVoid
%3 = OpTypeFunction %2
%6 = OpTypeFloat 32
%7 = OpTypeVector %6 4
%8 = OpTypePointer Output %7
%9 = OpVariable %8 Output
%10 = OpConstant %6 45.8899994
%11 = OpConstant %6 3625.05444
%12 = OpConstant %6 9.5
%13 = OpConstant %6 2.0999999
%14 = OpConstantComposite %7 %10 %11 %12 %13
%15 = OpTypeInt 32 1
%16 = OpTypeVector %15 4
%17 = OpConstant %15 54843
%18 = OpConstant %15 6405
%19 = OpConstant %15 1
%20 = OpConstantComposite %16 %17 %18 %19 %19
%4 = OpFunction %2 None %3
%5 = OpLabel
%21 = OpBitcast %7 %20
%22 = OpFMod %7 %14 %21
OpStore %9 %22
OpReturn
OpFunctionEnd
| 33.384615 | 54 | 0.508449 |
35504f943468d446e8e26b058360442790934235 | 11,251 | asm | Assembly | agent/io/icmp.asm | jephthai/EvilVM | 429fcc9df6f1168d38c21f37b377c36cf7bcc957 | [
"MIT"
] | 141 | 2019-05-18T20:46:47.000Z | 2022-02-28T05:10:43.000Z | agent/io/icmp.asm | jephthai/EvilVM | 429fcc9df6f1168d38c21f37b377c36cf7bcc957 | [
"MIT"
] | 6 | 2019-06-04T15:33:21.000Z | 2021-05-07T15:27:58.000Z | agent/io/icmp.asm | jephthai/EvilVM | 429fcc9df6f1168d38c21f37b377c36cf7bcc957 | [
"MIT"
] | 21 | 2019-05-22T02:48:30.000Z | 2021-11-03T05:34:48.000Z | %ifndef IPADDR
%define IPADDR 127,0,0,1
%endif
%ifndef DELAY
%define DELAY 5000
%endif
%ifndef WINDOW
%define WINDOW 1000
%endif
%ifndef INKEY
%define INKEY `\xf1\x77\x80\x02\xea\x2a\x5f\x72\xd2\x0b\x28\x1e\x38\xa9\xc9\x4b`
%endif
%ifndef OUTKEY
%define OUTKEY `\x1c\xab\x2b\x1d\xa7\xf8\xd7\x98\x4a\x28\x8b\x54\x58\x71\xb0\x52`
%endif
;;; Put a number on the stack identifying which IO engine this is. Each IO layer
;;; needs to have its own unique ID. This allows payloads to make decisions
;;; based on the configured IO.
start_def ASM, engine, "engine"
pushthing 5
end_def engine
start_def ASM, target, "target"
call .b
db IPADDR
.b: pop rax
mov eax, [rax]
pushthing rax
end_def target
;;; This function will be called before any IO is performed. This can be used to
;;; set up streams, initialize IO layer global variables, make network connections,
;;; etc.
start_def ASM, initio, "initio"
push rbp
mov rbp, rsp
and rsp, -16
sub rsp, 0x60
call .b
.a: db "iphlpapi.dll", 0
.1: db "IcmpCreateFile", 0
.2: db "IcmpSendEcho", 0
.b: pop rbx
lea rcx, [rbx]
call W32_LoadLibraryA
AddGlobal G_IPHLPAPI, rax
mov rsi, W32_GetProcAddress
mov rdi, rax
GetProcAddress .1 - .a, W32_IcmpCreateFile
GetProcAddress .2 - .a, W32_IcmpSendEcho
call W32_IcmpCreateFile ; get a handle for ICMP stuff
AddGlobal G_ICMPSOCK, rax ; store it in a global variable slot
call W32_GetTickCount ; keep track if last contact time
AddGlobal G_LASTTICK, rax ; ...
xor rax, rax ; get a zero
AddGlobal G_MODE, rax ; for storing more data available
AddGlobal G_OLEN, rax ; remember length of packet
AddGlobal G_SEQ, rax ; sequence number
xor ecx, ecx ; Let kernel choose address
mov edx, 16384 ; buffer space
mov r8, 0x3000 ; Reserve and commit the space
mov r9, 4 ; PAGE_READWRITE permissions
call W32_VirtualAlloc ; allocate space
AddGlobal G_ICMPBUFFER, rax ; save it here
AddGlobal G_OUTBUF, rax ; save for convenience
AddGlobal G_NEXTOUT, rax ; output buffer is bottom 2KB
AddGlobal G_LASTOUT, rax ; next available space in the output buffer
add rax, 2048 ; input buffer is top 2KB
AddGlobal G_INBUF, rax ; store for convenience
AddGlobal G_LASTIN, rax ; ...
dec rax
AddGlobal G_NEXTIN, rax ; ...
add rax, 2049 ; 4096 bytes for packet material
AddGlobal G_OPACKET, rax ; for outbound packet data
add rax, 2048 ; ...
AddGlobal G_IPACKET, rax ; for inbound packet data
add rax, 2048 ; space for crypto state
AddGlobal G_INSTATE, rax ; input stream crypto state
add rax, 512 ; ...
AddGlobal G_OUTSTATE, rax ; output stream crypto state
mov eax, DELAY ; ping interval
AddGlobal G_PINGMS, rax ; ...
xor eax, eax ; A way to keep track of bytes that don't fit
AddGlobal G_PENDING, rax ;
AddGlobal G_RESPONSE, rax ; a flag to signal when the server says there's more data to receive
AddGlobal G_CHARBUF, rax ;
InlineString INKEY, rax, rcx
pushthing rax
pushthing rcx
pushthing G_INSTATE
call code_cryptinit
InlineString OUTKEY, rax, rcx
pushthing rax
pushthing rcx
pushthing G_OUTSTATE
call code_cryptinit
mov rax, G_OUTBUF
mov QWORD [rax], 0
;; We need to get a session ID, so we'll loop until success
.loop: call code_target ; get the target IP
mov rcx, G_ICMPSOCK ; handle for ICMP comms
popthing rdx ; target IP
mov r8, G_OUTBUF ; output buffer
mov r9, 4 ; initial request is 4 zero bytes
mov QWORD [rsp+0x20], 0 ; RequestOptions
mov rax, G_INBUF ; buffer for reply packets
mov [rsp+0x28], rax ; ...
mov QWORD [rsp+0x30], 1024 ; size of reply buffer
mov QWORD [rsp+0x38], 5000 ; timeout
call W32_IcmpSendEcho ; send the ping
and rax, rax ; test result
jz .loop ; try again if failed
mov rax, G_INBUF ; start at beginning of buffer
mov rax, [rax + 0x10] ; offset to data
mov rax, [rax] ; session value
AddGlobal G_SESSID, rax ; ...
mov rsp, rbp
pop rbp
end_def initio
;;; Take a value from the stack and emit it to the output stream as a single byte.
start_def ASM, emit, "emit"
;; check available space
mov rax, G_LASTOUT ; start at the last available space
sub rax, G_ICMPBUFFER ; subtract the base address
cmp rax, 512 ; compare to buffer size
jl .avail ; as long as there's space, we can store
;; transceive
call icmp_transceive
;; store a byte for output
.avail:
mov rax, G_LASTOUT ; last byte available to store
mov [rax], dil ; store the byte
popthing rax ; pop from data stack
inc QWORD G_LASTOUT ; move last output pointer
end_def emit
;;; Read a single byte from the input stream and put its value on top of the stkack.
start_def ASM, key, "key"
;; check if bytes are currently available
mov rax, G_NEXTIN ; compare input pointers
mov rbx, G_LASTIN ; ...
inc rax ; off by one otherwise
cmp rax, rbx ; ...
jne .avail ; as long as NEXTIN < LASTIN, there's data to read
;; reset the input buffer
mov rax, G_INBUF ; find input buffer base
mov G_LASTIN, rax ; reset the pointers
dec rax ; ...
mov G_NEXTIN, rax ; ...
;; check if we have output to send, rather than wait
mov rcx, G_LASTOUT ; first unused space in output buffer
sub rcx, G_ICMPBUFFER ; count bytes to send
jnz .nodelay ; skip the delay
;; wait for send / receive
call icmp_delay
.nodelay:
;; transceive
call icmp_transceive
jmp code_key ; loop until we have input
;; grab a byte from input
.avail:
inc QWORD G_NEXTIN ; move to next byte of input
mov rax, G_NEXTIN ; get pointer to next byte
pushthing 1 ; make a spot on the stack
mov dil, [rax] ; get the byte onto the stack
cmp dil, 0x0a
jne .skip
inc QWORD G_LINENO
.skip:
end_def key
start_def ASM, keyq, "key?"
;; check if bytes are currently available
mov rax, G_NEXTIN ; compare input pointers
mov rbx, G_LASTIN ; ...
inc rax ; off by one otherwise
cmp rax, rbx ; ...
jne .avail ; as long as NEXTIN < LASTIN, there's data to read
;; check how long since last check
call W32_GetTickCount ; get our current tick count
mov rbx, G_LASTTICK ; last time we sent
add rbx, G_PINGMS ; our definition of "awhile"
sub rax, rbx ; get delta in milliseconds
js .none ; when negative, assume no bytes
;; reset the input buffer
mov rax, G_ICMPBUFFER ; find input buffer base
add rax, 2048 ; ...
mov G_LASTIN, rax ; reset the pointers
dec rax ; ...
mov G_NEXTIN, rax ; ...
.nodelay:
;; transceive
call icmp_transceive ; try one check for input
jmp code_keyq
;; grab a byte from input
.avail:
pushthing 1
ret
.none:
pushthing 0
ret
end_def keyq
;;; Given a buffer and length, send multiple bytes to the output stream. This is
;;; largely provided as a convenience for situations where IO can be optimized
;;; for block communications.
start_def ASM, type, "type"
popthing rcx
popthing rsi
.loop:
pushthing [rsi]
and rdi, 0xff
push rcx
push rsi
call code_emit
pop rsi
pop rcx
inc rsi
loop .loop
end_def type
;;; Enable and disable echoing of input to the output stream. Some IO
;;; layers may prefer to allow this to be configurable. Leave them empty
;;; if they don't make sense for your IO layer.
start_def ASM, echooff, "-echo"
end_def echooff
start_def ASM, echoon, "+echo"
end_def echoon
start_def ASM, setecho, "!echo"
end_def setecho
;;; ------------------------------------------------------------------------
;;; Stuff unique to this transport
;;; ------------------------------------------------------------------------
start_def ASM, pingms, "delay"
pushthing r15
add rdi, G_PINGMS_OFF
end_def pingms
icmp_delay:
push rbp ;
mov rbp, rsp ; save stack
sub rsp, 0x20 ; make shadow space
and rsp, -16 ; align stack just in case
mov rcx, G_MODE ; get last response code
and rcx, rcx ; if mode was non-zero, there's more data
jnz .done ; skip the delay
.loop:
call W32_GetTickCount ; get our current tick count
mov rbx, G_LASTTICK ; last time we sent
add rbx, G_PINGMS ; our definition of "awhile"
sub rax, rbx ; get delta in milliseconds
jns .done ; when the number is positive, it's been long enough
mov rcx, 500 ; sleep a bit so we don't burn CPU
call W32_Sleep ; ...
jmp .loop
.done:
mov rsp, rbp ; restore stack
pop rbp ;
ret
icmp_transceive:
push rbp
xor ebp, ebp ; get a zero
mov G_MODE, rbp ; clear the extra data flag
mov rbp, rsp ; save stack
sub rsp, 0x50 ; make space for shadow and fns with lots of args
and rsp, -16 ; align stack in case WININET cares
call icmp_prepare ; maybe load some bytes for output (puts count in rax)
mov [rsp+0x48], rax ; save the count for POSTing shortly
.loop: call code_target ; get the target IP
mov rcx, G_ICMPSOCK ; handle for ICMP comms
popthing rdx ; target IP
mov r8, G_OPACKET ; output buffer
mov r9, G_OLEN ; initial request is 4 zero bytes
mov QWORD [rsp+0x20], 0 ; RequestOptions
mov rax, G_IPACKET ; buffer for reply packets
mov [rsp+0x28], rax ; ...
mov QWORD [rsp+0x30], 1024 ; size of reply buffer
mov rax, WINDOW ; get response window (note: different from delay interval)
mov [rsp+0x38], rax ; timeout
call W32_IcmpSendEcho ; send the ping
and rax, rax ; test result
jz .loop ; ...
call W32_GetTickCount ; update last contact time
mov G_LASTTICK, rax ; ...
xor ecx, ecx ;
mov rax, G_IPACKET ; echo reply struct
mov rbx, [rax + 0x10] ; payload pointer
mov ecx, [rbx + 9] ; get length of payload
mov al, [rbx + 8] ; get MODE field
and eax, 0xff ; just one byte
mov G_MODE, rax ; save MODE value
call icmp_consume
mov rsp, rbp
pop rbp
ret
icmp_consume:
push rdi
push rsi
and rcx, rcx ; check if we have any to read at all
jz .done ; and skip if it's zero
mov rsi, rbx ; data comes from here
add rsi, 13 ; payload starts after header
mov rdi, G_LASTIN ; data goes here -- hmm, what happens if it fills up???
push rdi
push rcx
rep movsb ; move the data to the input buffer
mov G_LASTIN, rdi ; save spot
pop rcx
pop rsi
;; decrypt data
.go: push rbx
push rsi
push rcx
push rdi
mov rdi, rcx
mov rbx, G_INSTATE
call crypt_encrypt
pop rdi
pop rcx
pop rsi
pop rbx
.done:
pop rsi
pop rdi
ret
icmp_prepare:
push rdi
mov rsi, G_OUTBUF ; start encoding bytes here
mov rdi, G_OPACKET ; put encoded values here
add rdi, 12 ; fill in header later
mov rcx, G_LASTOUT ; first unused space in output buffer
sub rcx, G_OUTBUF ; count bytes to send
jz .done ; if count is 0, we're done before we start
;; encrypt the output data
.go: push rbx
push rsi
push rcx
push rdi
mov rdi, rcx
mov rbx, G_OUTSTATE
call crypt_encrypt
pop rdi
pop rcx
pop rsi
pop rbx
push rcx
rep movsb
pop rcx
.done: push rdi
;; fill in the header
mov rdi, G_OPACKET
mov rax, G_SESSID ; session ID
mov [rdi], eax ; ...
mov rax, G_SEQ ; get sequence number
mov DWORD [rdi+4], eax ; sequence #
inc QWORD G_SEQ ; increment to next
mov [rdi+8], ecx ; length
pop rdi
mov rax, rdi ; save where we ended up
sub rax, G_OPACKET ; get number of bytes to POST
mov G_OLEN, rax ; save length for later
mov rdx, G_OUTBUF ; reset output buffer since we moved it to the POST buffer
mov G_LASTOUT, rdx ; ...
pop rdi
ret
| 25.570455 | 98 | 0.69105 |
9a7602ce479a20c730e23aff2044ac6ed8a54fd4 | 148 | asm | Assembly | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/risc.lzh/risc/join/kart-enemy.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/risc.lzh/risc/join/kart-enemy.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/kart/risc.lzh/risc/join/kart-enemy.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | Name: kart-enemy.asm
Type: file
Size: 24496
Last-Modified: '1992-11-18T01:34:04Z'
SHA-1: 4BC42D62711BB032B3703D09E68AC8B714E21A4C
Description: null
| 21.142857 | 47 | 0.810811 |
15980d55cd96485dbc7205a9349a85cd02c8f184 | 457 | asm | Assembly | programs/oeis/111/A111775.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/111/A111775.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/111/A111775.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A111775: Number of ways n can be written as a sum of at least three consecutive integers.
; 0,0,0,0,0,1,0,0,1,1,0,1,0,1,2,0,0,2,0,1,2,1,0,1,1,1,2,1,0,3,0,0,2,1,2,2,0,1,2,1,0,3,0,1,4,1,0,1,1,2,2,1,0,3,2,1,2,1,0,3,0,1,4,0,2,3,0,1,2,3,0,2,0,1,4,1,2,3,0,1,3,1,0,3,2,1,2,1,0,5,2,1,2,1,2,1,0,2,4,2
max $0,4
seq $0,86374 ; Number of factors over Q in the factorization of T_n(x) + 1 where T_n(x) is the Chebyshev polynomial of the first kind.
div $0,2
sub $0,1
| 57.125 | 201 | 0.628009 |
6fe41de65211b23f259abc3600504e37f0b9c3a9 | 882 | asm | Assembly | programs/oeis/208/A208901.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/208/A208901.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/208/A208901.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A208901: Number of bitstrings of length n (with at least two runs) where the last two runs have different lengths.
; 0,0,4,8,24,48,112,224,480,960,1984,3968,8064,16128,32512,65024,130560,261120,523264,1046528,2095104,4190208,8384512,16769024,33546240,67092480,134201344,268402688,536838144,1073676288,2147418112,4294836224,8589803520,17179607040,34359476224,68718952448,137438429184,274876858368,549754765312,1099509530624,2199021158400,4398042316800,8796088827904,17592177655808,35184363700224,70368727400448,140737471578112,281474943156224,562949919866880,1125899839733760,2251799746576384,4503599493152768,9007199120523264
add $0,1
mul $0,2
mov $2,$0
mov $3,4
lpb $2
sub $0,1
trn $0,$3
sub $2,1
mov $4,3
lpb $4
mov $1,$2
mov $3,0
sub $4,3
mul $5,2
lpe
lpb $0
add $1,3
sub $1,$2
trn $0,$1
add $5,1
lpe
mov $1,$5
sub $2,1
lpe
| 31.5 | 510 | 0.746032 |
0a8625702b02eabb646fa6472f2695fedc1af4d8 | 780 | asm | Assembly | programs/oeis/072/A072491.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/072/A072491.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | programs/oeis/072/A072491.asm | jmorken/loda | 99c09d2641e858b074f6344a352d13bc55601571 | [
"Apache-2.0"
] | null | null | null | ; A072491: Define f(1) = 0. For n>=2, let f(n) = n - p where p is the largest prime <= n. a(n) = number of iterations of f to reach 0, starting from n.
; 0,1,1,1,2,1,2,1,2,2,2,1,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,3,2,1,2,1,2,2,2,3,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,3,2,1,2,2,2,3,2,1,2,1,2,2,2,3,2,1,2,2,2,1,2,1,2,2,2,3,2,1,2,2,2,1,2,2,2,3,2,1,2,2,2,3,2,3,2,1,2,2,2,1,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,3,2,3,2,3,3,3,2,3,2,1,2,2,2,1,2,2,2,3,2,1,2,1,2,2,2,3,2,3,2,3,3,1,2,1,2,2,2,3,2,1,2,2,2,3,2,1,2,2,2,1,2,2,2,3,2,1,2,2,2,3,2,1,2,1,2,2,2,3,2,3,2,3,3,1,2,1,2,2,2,1,2,1,2,2,2,3,2,3,2,3,3,3,2,1,2,2,2,3,2,3,2,3,3,3,2,1,2,2,2,1,2,1,2,2,2,1,2,2,2,3,2,1,2,1,2,2,2,3,2,3,2,3
lpb $0
mov $2,$0
cal $2,136548 ; a(n) = max {k >= 1 | sigma(k) <= n}.
sub $0,$2
mov $3,$2
min $3,1
add $1,$3
lpe
| 65 | 501 | 0.515385 |
79c4b879a6a0eee1c0f87cb5e65575c8abffe516 | 1,112 | asm | Assembly | libsrc/input/excali64/in_KeyPressed.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/input/excali64/in_KeyPressed.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/input/excali64/in_KeyPressed.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z | ; uint in_KeyPressed(uint scancode)
SECTION code_clib
PUBLIC in_KeyPressed
PUBLIC _in_KeyPressed
INCLUDE "target/cpm/def/excali64.def"
; Determines if a key is pressed using the scan code
; returned by in_LookupKey.
; enter : l = scan row
; h = key mask
; exit : carry = key is pressed & HL = 1
; no carry = key not pressed & HL = 0
; used : AF,BC,HL
.in_KeyPressed
._in_KeyPressed
ld a,@11111110 ;Shift row
out (PORT_KBD_ROW_SELECT),a
in a,(PORT_KBD_ROW_READ)
bit 7,l
jr nz,want_shift
bit 2,a
jr z,fail
jr consider_ctrl
want_shift:
bit 2,a
jr nz,fail ;Shift not pressed
.consider_ctrl
ld a,@11111101
out (PORT_KBD_ROW_SELECT),a
in a,(PORT_KBD_ROW_READ)
bit 6,l
jr nz,want_ctrl
bit 4,a
jr z,fail
jr nofunc
.want_ctrl
bit 4,a ;CTRL
jr nz,fail
.nofunc
ld a,l
ld c,@11111110
getrow_loop:
and 15
jr z,done
rlc c
dec a
jr getrow_loop
done:
ld a,c
out (PORT_KBD_ROW_SELECT),a
in a,(PORT_KBD_ROW_READ)
cpl
and h ;Check with mask
jr z,fail
ld hl,1
scf
ret
fail:
ld hl,0
and a
ret
| 15.885714 | 52 | 0.655576 |
a2063110f9acb397c3fc672d530b71174299d7ea | 132 | asm | Assembly | unit_tests/sample.asm | jarettn18/tiny_virtual_machine | dbb74966c5414fce86ed63f2f4e65e6f7616ae94 | [
"CC-BY-3.0"
] | null | null | null | unit_tests/sample.asm | jarettn18/tiny_virtual_machine | dbb74966c5414fce86ed63f2f4e65e6f7616ae94 | [
"CC-BY-3.0"
] | null | null | null | unit_tests/sample.asm | jarettn18/tiny_virtual_machine | dbb74966c5414fce86ed63f2f4e65e6f7616ae94 | [
"CC-BY-3.0"
] | null | null | null | .class Sample:Obj
.method $constructor
const 3
const 5
const 4
call Int:plus
call Int:plus
call Int:print
pop
return 0 | 11 | 20 | 0.704545 |
d9f5d7e809422e4dabca4130a9e15c1739f275d0 | 310 | asm | Assembly | programs/oeis/021/A021616.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/021/A021616.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/021/A021616.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A021616: Decimal expansion of 1/612.
; 0,0,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1,6,3,3,9,8,6,9,2,8,1,0,4,5,7,5,1
add $0,1
mov $1,10
pow $1,$0
mul $1,7
div $1,4284
mod $1,10
mov $0,$1
| 28.181818 | 199 | 0.541935 |
8706982fee211a542754bf6fec70e6c1176567d1 | 2,105 | asm | Assembly | Homeworks/Homework 3/main__.asm | GabrielEValenzuela/Digital_Electronis_II | 9cbac58c1dc81b40c3183b5a9c355955e9a02def | [
"MIT"
] | null | null | null | Homeworks/Homework 3/main__.asm | GabrielEValenzuela/Digital_Electronis_II | 9cbac58c1dc81b40c3183b5a9c355955e9a02def | [
"MIT"
] | null | null | null | Homeworks/Homework 3/main__.asm | GabrielEValenzuela/Digital_Electronis_II | 9cbac58c1dc81b40c3183b5a9c355955e9a02def | [
"MIT"
] | null | null | null | ;*******************************************************************************
; TITLE : EXERCISE 3.2
; PROFESSOR: MARTIN DEL BARCO
; AUTHOR: VALENZUELA GABRIEL EMANUEL
; SUBJET: DIGITAL ELECTRONICS II
; INSTITUTE : FEFYN - UNC
; DATE: 04-08-2019
; VERSION: 1.0.2
; CHANGE VERSION 1.0.0 TO 1.0.2: SOLVE BUG WITH THE OUPUTS.
;
; RESUME:
; THIS PROGRAM SWICHT TWO LEDS ON RB2/RB3 ACCORDING TO RA4 AND RB0
;*******************************************************************************
#include "p16f887.inc" ;HEADER THAT CONTAINS ALL ADDRESS MEMORY DEFINED BY MI-
;CROCHIP
LIST P=16F887 ;DEFINE THE MICROCONTROLLER TO BE USED.
;*******************************************************************************
; __config 0x3FF1
__CONFIG _CONFIG1, _FOSC_XT & _WDTE_OFF & _PWRTE_ON & _MCLRE_ON & _CP_OFF & _CPD_OFF & _BOREN_ON & _IESO_ON & _FCMEN_ON & _LVP_ON
; CONFIG2
; __config 0x3FFF
__CONFIG _CONFIG2, _BOR4V_BOR40V & _WRT_OFF
ORG 0x00
GOTO PROGRAM
PROGRAM: ORG 0x05
CLRW ;CLEAR THE WORK REGISTER
CALL CONFIGURE_PORTS
CLRW
CLRF PORTA
CLRF PORTB
LOOP: MOVFW PORTA ;MOVE THE CONTENT OF PORTA TO W
BTFSC PORTA,RA4 ;IF RA4 == 0 ?
GOTO ILRB2 ;FALSE --> LED RB3 ON
GOTO OLRB2 ;TRUE --> LED RB3 OFF
LOOPS: BTFSC PORTB,RB0 ;IF RB0 == 0 ?
GOTO ILRB3 ;FALSE --> LED RB4 ON
GOTO OLRB3 ;TRUE --> LED RB4 OFF
OLRB2: BCF PORTB,RB2
GOTO LOOPS
ILRB2: BSF PORTB,RB2
GOTO LOOPS
OLRB3: BCF PORTB,RB3
GOTO LOOP
ILRB3: BSF PORTB,RB3
GOTO LOOP
;INFINITY LOOP
;*******************************************************************************
; SUBRUTINE
CONFIGURE_PORTS: ORG 0X1A
;GO TO BANK 1, THAT IS, RP1 = 0 AND RP0=1
BCF STATUS,RP1
BSF STATUS,RP0
CLRF TRISA
CLRF TRISB
MOVLW B'00010000' ;RA<4> IS A INPUT
MOVWF TRISA
MOVLW B'00000001' ;RB<0> IS A INPUT
MOVWF TRISB
;GO TO ANSELH TO SET RB0 LIKE DIGITAL INPUT
BSF STATUS,RP1
CLRF ANSELH
CLRF ANSEL
BCF STATUS,RP0
BCF STATUS,RP1
RETURN
END | 30.071429 | 131 | 0.550594 |
ec7fd93d3981a31e71a87063c28ac7137b645f7d | 1,557 | asm | Assembly | src/fastblock.asm | SlyryD/Beta-Quest | 97e0ff4214bf69e7993cc7ed87231592e2cebee9 | [
"MIT"
] | null | null | null | src/fastblock.asm | SlyryD/Beta-Quest | 97e0ff4214bf69e7993cc7ed87231592e2cebee9 | [
"MIT"
] | 2 | 2021-12-29T20:52:49.000Z | 2022-01-02T22:48:44.000Z | src/fastblock.asm | SlyryD/Beta-Quest | 97e0ff4214bf69e7993cc7ed87231592e2cebee9 | [
"MIT"
] | 2 | 2021-11-22T04:59:58.000Z | 2022-03-24T06:32:41.000Z | ;rom.write_bytes(0xDD2B86, [0x40, 0x80]) #block speed
;rom.write_bytes(0xDD2D26, [0x00, 0x01]) #block delay
;rom.write_bytes(0xDD9682, [0x40, 0x80]) #milk crate speed
;rom.write_bytes(0xDD981E, [0x00, 0x01]) #milk crate delay
;rom.write_bytes(0xCE1BD0, [0x40, 0x80, 0x00, 0x00]) #amy puzzle speed
;rom.write_bytes(0xCE0F0E, [0x00, 0x01]) #amy puzzle delay
;rom.write_bytes(0xC77CA8, [0x40, 0x80, 0x00, 0x00]) #fire block speed
;rom.write_bytes(0xC770C2, [0x00, 0x01]) #fire block delay
;rom.write_bytes(0xCC5DBC, [0x29, 0xE1, 0x00, 0x01]) #forest basement puzzle delay
;rom.write_bytes(0xDBCF70, [0x2B, 0x01, 0x00, 0x00]) #spirit cobra mirror startup
;rom.write_bytes(0xDBCF70, [0x2B, 0x01, 0x00, 0x01]) #spirit cobra mirror delay
;rom.write_bytes(0xDBA230, [0x28, 0x41, 0x00, 0x19]) #truth spinner speed
;rom.write_bytes(0xDBA3A4, [0x24, 0x18, 0x00, 0x00]) #truth spinner delay
.orga 0xDD2B86
.halfword 0x4080
.orga 0xDD2D26
.halfword 0x0001
.orga 0xDD9682
.halfword 0x4080
.orga 0xDD981E
.halfword 0x0001
.orga 0xCE1BD0
.word 0x40800000
.orga 0xCE0F0E
.halfword 0x0001
.orga 0xC77CA8
.word 0x40800000
.orga 0xC770C2
.halfword 0x0001
.orga 0xCC5DBC
.word 0x29E10001
.orga 0xDBCF70
.word 0x2B010000
.orga 0xDBCF70
.word 0x2B010001
.orga 0xDBA230
.word 0x28410019
.orga 0xDBA3A4
.word 0x24180000
| 29.377358 | 87 | 0.637765 |
c4457b77380fd2597fc351111ce9becf159fe713 | 7,527 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_1923.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_1923.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i7-7700_9_0xca_notsx.log_21829_1923.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r14
push %r15
push %r8
push %r9
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0x1c474, %rdi
nop
sub $5396, %r12
mov (%rdi), %r9d
nop
nop
nop
dec %r15
lea addresses_normal_ht+0x7b4, %r14
nop
nop
nop
nop
sub $18667, %r11
movw $0x6162, (%r14)
nop
nop
nop
nop
add %r8, %r8
lea addresses_WT_ht+0x11417, %rdi
nop
sub $13302, %r9
movups (%rdi), %xmm4
vpextrq $0, %xmm4, %r14
nop
and %r9, %r9
lea addresses_UC_ht+0xaaae, %r15
nop
nop
nop
nop
and %rdi, %rdi
vmovups (%r15), %ymm4
vextracti128 $0, %ymm4, %xmm4
vpextrq $0, %xmm4, %r12
and $17672, %rdi
lea addresses_normal_ht+0x172f4, %rdi
nop
nop
nop
nop
and %r15, %r15
mov (%rdi), %r9d
nop
and $33470, %rdi
lea addresses_WT_ht+0xd034, %r12
nop
nop
nop
nop
and %r9, %r9
mov $0x6162636465666768, %r14
movq %r14, %xmm6
and $0xffffffffffffffc0, %r12
vmovaps %ymm6, (%r12)
nop
nop
nop
nop
nop
cmp $45391, %r11
lea addresses_normal_ht+0x17074, %r11
and $5326, %rdi
mov $0x6162636465666768, %r14
movq %r14, %xmm1
vmovups %ymm1, (%r11)
nop
nop
dec %rdi
lea addresses_WC_ht+0x3692, %r15
nop
nop
nop
add $3648, %rdi
vmovups (%r15), %ymm0
vextracti128 $0, %ymm0, %xmm0
vpextrq $0, %xmm0, %r12
nop
nop
nop
nop
xor %rdi, %rdi
lea addresses_normal_ht+0x18074, %r15
nop
nop
nop
nop
nop
cmp %r9, %r9
mov (%r15), %di
nop
nop
nop
nop
nop
and $16497, %r15
lea addresses_UC_ht+0x3e44, %rsi
lea addresses_normal_ht+0x1ccc5, %rdi
nop
nop
nop
nop
nop
inc %r11
mov $107, %rcx
rep movsb
nop
nop
nop
nop
nop
inc %rsi
pop %rsi
pop %rdi
pop %rcx
pop %r9
pop %r8
pop %r15
pop %r14
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r14
push %r15
push %r8
push %rdi
push %rdx
// Store
lea addresses_RW+0xea94, %r15
nop
nop
nop
nop
cmp %rdi, %rdi
movl $0x51525354, (%r15)
nop
sub %r10, %r10
// Store
lea addresses_WT+0xcef4, %rdi
nop
nop
nop
dec %r12
mov $0x5152535455565758, %r15
movq %r15, %xmm1
vmovups %ymm1, (%rdi)
nop
nop
nop
nop
xor $59042, %r14
// Load
lea addresses_RW+0xfbdc, %rdi
nop
nop
nop
dec %r8
mov (%rdi), %r10
sub $876, %r14
// Load
lea addresses_WT+0xe214, %r10
nop
nop
nop
nop
nop
cmp $435, %r15
mov (%r10), %r12
nop
and $38614, %rdx
// Faulty Load
lea addresses_PSE+0x10074, %r14
nop
nop
nop
nop
sub $63261, %r12
mov (%r14), %di
lea oracles, %r12
and $0xff, %rdi
shlq $12, %rdi
mov (%r12,%rdi,1), %rdi
pop %rdx
pop %rdi
pop %r8
pop %r15
pop %r14
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 4, 'same': False, 'type': 'addresses_RW'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 7, 'same': False, 'type': 'addresses_WT'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 2, 'same': False, 'type': 'addresses_RW'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 2, 'same': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 0, 'same': True, 'type': 'addresses_PSE'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'NT': False, 'AVXalign': True, 'size': 4, 'congruent': 9, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 3, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 1, 'same': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'src': {'NT': True, 'AVXalign': False, 'size': 4, 'congruent': 5, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'dst': {'NT': False, 'AVXalign': True, 'size': 32, 'congruent': 5, 'same': False, 'type': 'addresses_WT_ht'}, 'OP': 'STOR'}
{'dst': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'STOR'}
{'src': {'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 1, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 7, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'same': False, 'type': 'addresses_UC_ht'}, 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_normal_ht'}, 'OP': 'REPM'}
{'33': 21829}
33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33 33
*/
| 31.62605 | 2,999 | 0.655241 |
1e58fb4f0568990b3ff14ca0a873ef1b7d650084 | 2,524 | asm | Assembly | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca_notsx.log_6_67.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca_notsx.log_6_67.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_zr_/i9-9900K_12_0xca_notsx.log_6_67.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r8
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_normal_ht+0xc544, %r8
nop
nop
nop
nop
inc %rbx
vmovups (%r8), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %r11
nop
nop
nop
nop
inc %r10
lea addresses_A_ht+0x19364, %rsi
lea addresses_UC_ht+0x8384, %rdi
cmp %r8, %r8
mov $83, %rcx
rep movsw
nop
nop
and %rcx, %rcx
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %r8
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r12
push %r14
push %rax
push %rbp
push %rbx
push %rcx
// Store
lea addresses_US+0x9804, %r14
nop
nop
nop
nop
nop
dec %rbp
mov $0x5152535455565758, %r11
movq %r11, %xmm1
vmovaps %ymm1, (%r14)
nop
sub $37259, %rax
// Store
mov $0x67146b0000000144, %rbx
nop
nop
nop
nop
nop
dec %rax
mov $0x5152535455565758, %rbp
movq %rbp, %xmm0
vmovups %ymm0, (%rbx)
nop
add %r11, %r11
// Store
lea addresses_PSE+0x3c44, %rbp
add $43324, %rcx
mov $0x5152535455565758, %rax
movq %rax, %xmm6
vmovups %ymm6, (%rbp)
nop
nop
nop
nop
nop
dec %rax
// Store
lea addresses_D+0xcc4, %r14
clflush (%r14)
nop
nop
nop
dec %rbp
movb $0x51, (%r14)
nop
nop
nop
sub $46986, %rcx
// Faulty Load
lea addresses_A+0x15144, %rcx
nop
nop
dec %rbx
movups (%rcx), %xmm2
vpextrq $1, %xmm2, %r11
lea oracles, %rbx
and $0xff, %r11
shlq $12, %r11
mov (%rbx,%r11,1), %r11
pop %rcx
pop %rbx
pop %rbp
pop %rax
pop %r14
pop %r12
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A', 'NT': True, 'AVXalign': True, 'size': 32, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_US', 'NT': False, 'AVXalign': True, 'size': 32, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_NC', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_PSE', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 8}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D', 'NT': False, 'AVXalign': True, 'size': 1, 'congruent': 6}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 5}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 5, 'type': 'addresses_UC_ht'}}
{'00': 6}
00 00 00 00 00 00
*/
| 17.900709 | 147 | 0.649762 |
e4db1fa5a58c178605dccbef74fe0ab5d46ad4a9 | 41,488 | asm | Assembly | target/cos_117/disasm/iop_overlay1/DISKIO.asm | jrrk2/cray-sim | 52c9639808d6890517092637b188282c00cce4f7 | [
"BSL-1.0"
] | 49 | 2020-10-09T12:29:16.000Z | 2022-03-12T02:33:35.000Z | target/cos_117/disasm/iop_overlay1/DISKIO.asm | jrrk2/cray-sim | 52c9639808d6890517092637b188282c00cce4f7 | [
"BSL-1.0"
] | 1 | 2021-12-29T15:59:25.000Z | 2021-12-29T15:59:25.000Z | target/cos_117/disasm/iop_overlay1/DISKIO.asm | jrrk2/cray-sim | 52c9639808d6890517092637b188282c00cce4f7 | [
"BSL-1.0"
] | 6 | 2021-04-12T06:10:32.000Z | 2022-02-08T23:11:19.000Z | 0x0000 (0x000000) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0001 (0x000002) 0x2922- f:00024 d: 290 | OR[290] = A
0x0002 (0x000004) 0x2118- f:00020 d: 280 | A = OR[280]
0x0003 (0x000006) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0004 (0x000008) 0x8003- f:00100 d: 3 | P = P + 3 (0x0007), C = 0
0x0005 (0x00000A) 0x8402- f:00102 d: 2 | P = P + 2 (0x0007), A = 0
0x0006 (0x00000C) 0x71DE- f:00070 d: 478 | P = P + 478 (0x01E4)
0x0007 (0x00000E) 0x2118- f:00020 d: 280 | A = OR[280]
0x0008 (0x000010) 0x85DC- f:00102 d: 476 | P = P + 476 (0x01E4), A = 0
0x0009 (0x000012) 0x2119- f:00020 d: 281 | A = OR[281]
0x000A (0x000014) 0x85DA- f:00102 d: 474 | P = P + 474 (0x01E4), A = 0
0x000B (0x000016) 0x2119- f:00020 d: 281 | A = OR[281]
0x000C (0x000018) 0x1603- f:00013 d: 3 | A = A - 3 (0x0003)
0x000D (0x00001A) 0x8003- f:00100 d: 3 | P = P + 3 (0x0010), C = 0
0x000E (0x00001C) 0x8402- f:00102 d: 2 | P = P + 2 (0x0010), A = 0
0x000F (0x00001E) 0x71D5- f:00070 d: 469 | P = P + 469 (0x01E4)
0x0010 (0x000020) 0x211A- f:00020 d: 282 | A = OR[282]
0x0011 (0x000022) 0x1610- f:00013 d: 16 | A = A - 16 (0x0010)
0x0012 (0x000024) 0x81D2- f:00100 d: 466 | P = P + 466 (0x01E4), C = 0
0x0013 (0x000026) 0x211A- f:00020 d: 282 | A = OR[282]
0x0014 (0x000028) 0x161F- f:00013 d: 31 | A = A - 31 (0x001F)
0x0015 (0x00002A) 0x8003- f:00100 d: 3 | P = P + 3 (0x0018), C = 0
0x0016 (0x00002C) 0x8402- f:00102 d: 2 | P = P + 2 (0x0018), A = 0
0x0017 (0x00002E) 0x71CD- f:00070 d: 461 | P = P + 461 (0x01E4)
0x0018 (0x000030) 0x211F- f:00020 d: 287 | A = OR[287]
0x0019 (0x000032) 0x1E00-0x0200 f:00017 d: 0 | A = A - 512 (0x0200)
0x001B (0x000036) 0x8003- f:00100 d: 3 | P = P + 3 (0x001E), C = 0
0x001C (0x000038) 0x8402- f:00102 d: 2 | P = P + 2 (0x001E), A = 0
0x001D (0x00003A) 0x71C7- f:00070 d: 455 | P = P + 455 (0x01E4)
0x001E (0x00003C) 0x2120- f:00020 d: 288 | A = OR[288]
0x001F (0x00003E) 0x1700- f:00013 d: 256 | A = A - 256 (0x0100)
0x0020 (0x000040) 0x8003- f:00100 d: 3 | P = P + 3 (0x0023), C = 0
0x0021 (0x000042) 0x8402- f:00102 d: 2 | P = P + 2 (0x0023), A = 0
0x0022 (0x000044) 0x71C2- f:00070 d: 450 | P = P + 450 (0x01E4)
0x0023 (0x000046) 0x2121- f:00020 d: 289 | A = OR[289]
0x0024 (0x000048) 0x8603- f:00103 d: 3 | P = P + 3 (0x0027), A # 0
0x0025 (0x00004A) 0x2120- f:00020 d: 288 | A = OR[288]
0x0026 (0x00004C) 0x85BE- f:00102 d: 446 | P = P + 446 (0x01E4), A = 0
0x0027 (0x00004E) 0x1016- f:00010 d: 22 | A = 22 (0x0016)
0x0028 (0x000050) 0x2929- f:00024 d: 297 | OR[297] = A
0x0029 (0x000052) 0x1122- f:00010 d: 290 | A = 290 (0x0122)
0x002A (0x000054) 0x292A- f:00024 d: 298 | OR[298] = A
0x002B (0x000056) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x002C (0x000058) 0x5800- f:00054 d: 0 | B = A
0x002D (0x00005A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x002E (0x00005C) 0x7C09- f:00076 d: 9 | R = OR[9]
0x002F (0x00005E) 0x87B8- f:00103 d: 440 | P = P + 440 (0x01E7), A # 0
0x0030 (0x000060) 0x2122- f:00020 d: 290 | A = OR[290]
0x0031 (0x000062) 0x290E- f:00024 d: 270 | OR[270] = A
0x0032 (0x000064) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x0033 (0x000066) 0x1418- f:00012 d: 24 | A = A + 24 (0x0018)
0x0034 (0x000068) 0x290D- f:00024 d: 269 | OR[269] = A
0x0035 (0x00006A) 0x210D- f:00020 d: 269 | A = OR[269]
0x0036 (0x00006C) 0x8406- f:00102 d: 6 | P = P + 6 (0x003C), A = 0
0x0037 (0x00006E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0038 (0x000070) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0039 (0x000072) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x003A (0x000074) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x003B (0x000076) 0x7206- f:00071 d: 6 | P = P - 6 (0x0035)
0x003C (0x000078) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x003D (0x00007A) 0x2B18- f:00025 d: 280 | OR[280] = A + OR[280]
0x003E (0x00007C) 0x2118- f:00020 d: 280 | A = OR[280]
0x003F (0x00007E) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0040 (0x000080) 0x2918- f:00024 d: 280 | OR[280] = A
0x0041 (0x000082) 0x2122- f:00020 d: 290 | A = OR[290]
0x0042 (0x000084) 0x1416- f:00012 d: 22 | A = A + 22 (0x0016)
0x0043 (0x000086) 0x2908- f:00024 d: 264 | OR[264] = A
0x0044 (0x000088) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0045 (0x00008A) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0046 (0x00008C) 0x2518- f:00022 d: 280 | A = A + OR[280]
0x0047 (0x00008E) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0048 (0x000090) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0049 (0x000092) 0x2119- f:00020 d: 281 | A = OR[281]
0x004A (0x000094) 0x1203- f:00011 d: 3 | A = A & 3 (0x0003)
0x004B (0x000096) 0x2919- f:00024 d: 281 | OR[281] = A
0x004C (0x000098) 0x2122- f:00020 d: 290 | A = OR[290]
0x004D (0x00009A) 0x1417- f:00012 d: 23 | A = A + 23 (0x0017)
0x004E (0x00009C) 0x2908- f:00024 d: 264 | OR[264] = A
0x004F (0x00009E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0050 (0x0000A0) 0x0E06- f:00007 d: 6 | A = A << 6 (0x0006)
0x0051 (0x0000A2) 0x0A02- f:00005 d: 2 | A = A < 2 (0x0002)
0x0052 (0x0000A4) 0x2519- f:00022 d: 281 | A = A + OR[281]
0x0053 (0x0000A6) 0x0C08- f:00006 d: 8 | A = A >> 8 (0x0008)
0x0054 (0x0000A8) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0055 (0x0000AA) 0x211A- f:00020 d: 282 | A = OR[282]
0x0056 (0x0000AC) 0x127F- f:00011 d: 127 | A = A & 127 (0x007F)
0x0057 (0x0000AE) 0x291A- f:00024 d: 282 | OR[282] = A
0x0058 (0x0000B0) 0x2122- f:00020 d: 290 | A = OR[290]
0x0059 (0x0000B2) 0x1417- f:00012 d: 23 | A = A + 23 (0x0017)
0x005A (0x0000B4) 0x2908- f:00024 d: 264 | OR[264] = A
0x005B (0x0000B6) 0x3108- f:00030 d: 264 | A = (OR[264])
0x005C (0x0000B8) 0x1A00-0xFF80 f:00015 d: 0 | A = A & 65408 (0xFF80)
0x005E (0x0000BC) 0x251A- f:00022 d: 282 | A = A + OR[282]
0x005F (0x0000BE) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0060 (0x0000C0) 0x211B- f:00020 d: 283 | A = OR[283]
0x0061 (0x0000C2) 0x1203- f:00011 d: 3 | A = A & 3 (0x0003)
0x0062 (0x0000C4) 0x291B- f:00024 d: 283 | OR[283] = A
0x0063 (0x0000C6) 0x2122- f:00020 d: 290 | A = OR[290]
0x0064 (0x0000C8) 0x1417- f:00012 d: 23 | A = A + 23 (0x0017)
0x0065 (0x0000CA) 0x2908- f:00024 d: 264 | OR[264] = A
0x0066 (0x0000CC) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0067 (0x0000CE) 0x0E08- f:00007 d: 8 | A = A << 8 (0x0008)
0x0068 (0x0000D0) 0x0A02- f:00005 d: 2 | A = A < 2 (0x0002)
0x0069 (0x0000D2) 0x251B- f:00022 d: 283 | A = A + OR[283]
0x006A (0x0000D4) 0x0C0A- f:00006 d: 10 | A = A >> 10 (0x000A)
0x006B (0x0000D6) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x006C (0x0000D8) 0x211C- f:00020 d: 284 | A = OR[284]
0x006D (0x0000DA) 0x1A00-0x07FF f:00015 d: 0 | A = A & 2047 (0x07FF)
0x006F (0x0000DE) 0x291C- f:00024 d: 284 | OR[284] = A
0x0070 (0x0000E0) 0x2122- f:00020 d: 290 | A = OR[290]
0x0071 (0x0000E2) 0x1418- f:00012 d: 24 | A = A + 24 (0x0018)
0x0072 (0x0000E4) 0x2908- f:00024 d: 264 | OR[264] = A
0x0073 (0x0000E6) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0074 (0x0000E8) 0x0A0C- f:00005 d: 12 | A = A < 12 (0x000C)
0x0075 (0x0000EA) 0x251C- f:00022 d: 284 | A = A + OR[284]
0x0076 (0x0000EC) 0x0C0C- f:00006 d: 12 | A = A >> 12 (0x000C)
0x0077 (0x0000EE) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0078 (0x0000F0) 0x211D- f:00020 d: 285 | A = OR[285]
0x0079 (0x0000F2) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x007A (0x0000F4) 0x291D- f:00024 d: 285 | OR[285] = A
0x007B (0x0000F6) 0x2122- f:00020 d: 290 | A = OR[290]
0x007C (0x0000F8) 0x1418- f:00012 d: 24 | A = A + 24 (0x0018)
0x007D (0x0000FA) 0x2908- f:00024 d: 264 | OR[264] = A
0x007E (0x0000FC) 0x3108- f:00030 d: 264 | A = (OR[264])
0x007F (0x0000FE) 0x1A00-0xFFE0 f:00015 d: 0 | A = A & 65504 (0xFFE0)
0x0081 (0x000102) 0x251D- f:00022 d: 285 | A = A + OR[285]
0x0082 (0x000104) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0083 (0x000106) 0x211E- f:00020 d: 286 | A = OR[286]
0x0084 (0x000108) 0x127F- f:00011 d: 127 | A = A & 127 (0x007F)
0x0085 (0x00010A) 0x291E- f:00024 d: 286 | OR[286] = A
0x0086 (0x00010C) 0x2122- f:00020 d: 290 | A = OR[290]
0x0087 (0x00010E) 0x1419- f:00012 d: 25 | A = A + 25 (0x0019)
0x0088 (0x000110) 0x2908- f:00024 d: 264 | OR[264] = A
0x0089 (0x000112) 0x3108- f:00030 d: 264 | A = (OR[264])
0x008A (0x000114) 0x0A08- f:00005 d: 8 | A = A < 8 (0x0008)
0x008B (0x000116) 0x251E- f:00022 d: 286 | A = A + OR[286]
0x008C (0x000118) 0x0C08- f:00006 d: 8 | A = A >> 8 (0x0008)
0x008D (0x00011A) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x008E (0x00011C) 0x2122- f:00020 d: 290 | A = OR[290]
0x008F (0x00011E) 0x141A- f:00012 d: 26 | A = A + 26 (0x001A)
0x0090 (0x000120) 0x2908- f:00024 d: 264 | OR[264] = A
0x0091 (0x000122) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0092 (0x000124) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0093 (0x000126) 0x2122- f:00020 d: 290 | A = OR[290]
0x0094 (0x000128) 0x141B- f:00012 d: 27 | A = A + 27 (0x001B)
0x0095 (0x00012A) 0x2908- f:00024 d: 264 | OR[264] = A
0x0096 (0x00012C) 0x211F- f:00020 d: 287 | A = OR[287]
0x0097 (0x00012E) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0098 (0x000130) 0x2122- f:00020 d: 290 | A = OR[290]
0x0099 (0x000132) 0x141C- f:00012 d: 28 | A = A + 28 (0x001C)
0x009A (0x000134) 0x2908- f:00024 d: 264 | OR[264] = A
0x009B (0x000136) 0x2120- f:00020 d: 288 | A = OR[288]
0x009C (0x000138) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x009D (0x00013A) 0x2122- f:00020 d: 290 | A = OR[290]
0x009E (0x00013C) 0x141D- f:00012 d: 29 | A = A + 29 (0x001D)
0x009F (0x00013E) 0x2908- f:00024 d: 264 | OR[264] = A
0x00A0 (0x000140) 0x2121- f:00020 d: 289 | A = OR[289]
0x00A1 (0x000142) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00A2 (0x000144) 0x211F- f:00020 d: 287 | A = OR[287]
0x00A3 (0x000146) 0x0809- f:00004 d: 9 | A = A > 9 (0x0009)
0x00A4 (0x000148) 0x2913- f:00024 d: 275 | OR[275] = A
0x00A5 (0x00014A) 0x2122- f:00020 d: 290 | A = OR[290]
0x00A6 (0x00014C) 0x140C- f:00012 d: 12 | A = A + 12 (0x000C)
0x00A7 (0x00014E) 0x2908- f:00024 d: 264 | OR[264] = A
0x00A8 (0x000150) 0x2113- f:00020 d: 275 | A = OR[275]
0x00A9 (0x000152) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00AA (0x000154) 0x211F- f:00020 d: 287 | A = OR[287]
0x00AB (0x000156) 0x1A00-0x03FF f:00015 d: 0 | A = A & 1023 (0x03FF)
0x00AD (0x00015A) 0x291F- f:00024 d: 287 | OR[287] = A
0x00AE (0x00015C) 0x2122- f:00020 d: 290 | A = OR[290]
0x00AF (0x00015E) 0x140D- f:00012 d: 13 | A = A + 13 (0x000D)
0x00B0 (0x000160) 0x2908- f:00024 d: 264 | OR[264] = A
0x00B1 (0x000162) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00B2 (0x000164) 0x1A00-0xFC00 f:00015 d: 0 | A = A & 64512 (0xFC00)
0x00B4 (0x000168) 0x251F- f:00022 d: 287 | A = A + OR[287]
0x00B5 (0x00016A) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00B6 (0x00016C) 0x2047- f:00020 d: 71 | A = OR[71]
0x00B7 (0x00016E) 0x2719- f:00023 d: 281 | A = A - OR[281]
0x00B8 (0x000170) 0x8732- f:00103 d: 306 | P = P + 306 (0x01EA), A # 0
0x00B9 (0x000172) 0x1800-0x0C85 f:00014 d: 0 | A = 3205 (0x0C85)
0x00BB (0x000176) 0x1610- f:00013 d: 16 | A = A - 16 (0x0010)
0x00BC (0x000178) 0x251A- f:00022 d: 282 | A = A + OR[282]
0x00BD (0x00017A) 0x2927- f:00024 d: 295 | OR[295] = A
0x00BE (0x00017C) 0x3127- f:00030 d: 295 | A = (OR[295])
0x00BF (0x00017E) 0x2927- f:00024 d: 295 | OR[295] = A
0x00C0 (0x000180) 0x8524- f:00102 d: 292 | P = P + 292 (0x01E4), A = 0
0x00C1 (0x000182) 0x2127- f:00020 d: 295 | A = OR[295]
0x00C2 (0x000184) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x00C3 (0x000186) 0x2908- f:00024 d: 264 | OR[264] = A
0x00C4 (0x000188) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00C5 (0x00018A) 0x0809- f:00004 d: 9 | A = A > 9 (0x0009)
0x00C6 (0x00018C) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x00C7 (0x00018E) 0x2928- f:00024 d: 296 | OR[296] = A
0x00C8 (0x000190) 0x2128- f:00020 d: 296 | A = OR[296]
0x00C9 (0x000192) 0x8407- f:00102 d: 7 | P = P + 7 (0x00D0), A = 0
0x00CA (0x000194) 0x2128- f:00020 d: 296 | A = OR[296]
0x00CB (0x000196) 0x1607- f:00013 d: 7 | A = A - 7 (0x0007)
0x00CC (0x000198) 0x8003- f:00100 d: 3 | P = P + 3 (0x00CF), C = 0
0x00CD (0x00019A) 0x8402- f:00102 d: 2 | P = P + 2 (0x00CF), A = 0
0x00CE (0x00019C) 0x7002- f:00070 d: 2 | P = P + 2 (0x00D0)
0x00CF (0x00019E) 0x7003- f:00070 d: 3 | P = P + 3 (0x00D2)
0x00D0 (0x0001A0) 0x7C34- f:00076 d: 52 | R = OR[52]
0x00D1 (0x0001A2) 0x0006- f:00000 d: 6 | PASS | **** non-standard encoding with D:0x0006 ****
0x00D2 (0x0001A4) 0x2128- f:00020 d: 296 | A = OR[296]
0x00D3 (0x0001A6) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x00D4 (0x0001A8) 0x8602- f:00103 d: 2 | P = P + 2 (0x00D6), A # 0
0x00D5 (0x0001AA) 0x701E- f:00070 d: 30 | P = P + 30 (0x00F3)
0x00D6 (0x0001AC) 0x2128- f:00020 d: 296 | A = OR[296]
0x00D7 (0x0001AE) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x00D8 (0x0001B0) 0x8602- f:00103 d: 2 | P = P + 2 (0x00DA), A # 0
0x00D9 (0x0001B2) 0x701A- f:00070 d: 26 | P = P + 26 (0x00F3)
0x00DA (0x0001B4) 0x2127- f:00020 d: 295 | A = OR[295]
0x00DB (0x0001B6) 0x142F- f:00012 d: 47 | A = A + 47 (0x002F)
0x00DC (0x0001B8) 0x2908- f:00024 d: 264 | OR[264] = A
0x00DD (0x0001BA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00DE (0x0001BC) 0x2913- f:00024 d: 275 | OR[275] = A
0x00DF (0x0001BE) 0x2127- f:00020 d: 295 | A = OR[295]
0x00E0 (0x0001C0) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x00E1 (0x0001C2) 0x2908- f:00024 d: 264 | OR[264] = A
0x00E2 (0x0001C4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00E3 (0x0001C6) 0x0809- f:00004 d: 9 | A = A > 9 (0x0009)
0x00E4 (0x0001C8) 0x121F- f:00011 d: 31 | A = A & 31 (0x001F)
0x00E5 (0x0001CA) 0x2914- f:00024 d: 276 | OR[276] = A
0x00E6 (0x0001CC) 0x2127- f:00020 d: 295 | A = OR[295]
0x00E7 (0x0001CE) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x00E8 (0x0001D0) 0x2908- f:00024 d: 264 | OR[264] = A
0x00E9 (0x0001D2) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00EA (0x0001D4) 0x13FF- f:00011 d: 511 | A = A & 511 (0x01FF)
0x00EB (0x0001D6) 0x2915- f:00024 d: 277 | OR[277] = A
0x00EC (0x0001D8) 0x2127- f:00020 d: 295 | A = OR[295]
0x00ED (0x0001DA) 0x1430- f:00012 d: 48 | A = A + 48 (0x0030)
0x00EE (0x0001DC) 0x2908- f:00024 d: 264 | OR[264] = A
0x00EF (0x0001DE) 0x3108- f:00030 d: 264 | A = (OR[264])
0x00F0 (0x0001E0) 0x080E- f:00004 d: 14 | A = A > 14 (0x000E)
0x00F1 (0x0001E2) 0x2916- f:00024 d: 278 | OR[278] = A
0x00F2 (0x0001E4) 0x7015- f:00070 d: 21 | P = P + 21 (0x0107)
0x00F3 (0x0001E6) 0x2128- f:00020 d: 296 | A = OR[296]
0x00F4 (0x0001E8) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x00F5 (0x0001EA) 0x8402- f:00102 d: 2 | P = P + 2 (0x00F7), A = 0
0x00F6 (0x0001EC) 0x7004- f:00070 d: 4 | P = P + 4 (0x00FA)
0x00F7 (0x0001EE) 0x119B- f:00010 d: 411 | A = 411 (0x019B)
0x00F8 (0x0001F0) 0x2913- f:00024 d: 275 | OR[275] = A
0x00F9 (0x0001F2) 0x7008- f:00070 d: 8 | P = P + 8 (0x0101)
0x00FA (0x0001F4) 0x2128- f:00020 d: 296 | A = OR[296]
0x00FB (0x0001F6) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x00FC (0x0001F8) 0x8402- f:00102 d: 2 | P = P + 2 (0x00FE), A = 0
0x00FD (0x0001FA) 0x7004- f:00070 d: 4 | P = P + 4 (0x0101)
0x00FE (0x0001FC) 0x1800-0x0337 f:00014 d: 0 | A = 823 (0x0337)
0x0100 (0x000200) 0x2913- f:00024 d: 275 | OR[275] = A
0x0101 (0x000202) 0x100A- f:00010 d: 10 | A = 10 (0x000A)
0x0102 (0x000204) 0x2914- f:00024 d: 276 | OR[276] = A
0x0103 (0x000206) 0x1012- f:00010 d: 18 | A = 18 (0x0012)
0x0104 (0x000208) 0x2915- f:00024 d: 277 | OR[277] = A
0x0105 (0x00020A) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0106 (0x00020C) 0x2916- f:00024 d: 278 | OR[278] = A
0x0107 (0x00020E) 0x211C- f:00020 d: 284 | A = OR[284]
0x0108 (0x000210) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0109 (0x000212) 0x82DB- f:00101 d: 219 | P = P + 219 (0x01E4), C = 1
0x010A (0x000214) 0x211D- f:00020 d: 285 | A = OR[285]
0x010B (0x000216) 0x2714- f:00023 d: 276 | A = A - OR[276]
0x010C (0x000218) 0x82D8- f:00101 d: 216 | P = P + 216 (0x01E4), C = 1
0x010D (0x00021A) 0x211E- f:00020 d: 286 | A = OR[286]
0x010E (0x00021C) 0x2715- f:00023 d: 277 | A = A - OR[277]
0x010F (0x00021E) 0x82D5- f:00101 d: 213 | P = P + 213 (0x01E4), C = 1
0x0110 (0x000220) 0x211B- f:00020 d: 283 | A = OR[283]
0x0111 (0x000222) 0x2716- f:00023 d: 278 | A = A - OR[278]
0x0112 (0x000224) 0x82D2- f:00101 d: 210 | P = P + 210 (0x01E4), C = 1
0x0113 (0x000226) 0x0400- f:00002 d: 0 | I = 0
0x0114 (0x000228) 0x0000- f:00000 d: 0 | PASS
0x0115 (0x00022A) 0x2128- f:00020 d: 296 | A = OR[296]
0x0116 (0x00022C) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0117 (0x00022E) 0x8602- f:00103 d: 2 | P = P + 2 (0x0119), A # 0
0x0118 (0x000230) 0x7009- f:00070 d: 9 | P = P + 9 (0x0121)
0x0119 (0x000232) 0x2128- f:00020 d: 296 | A = OR[296]
0x011A (0x000234) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x011B (0x000236) 0x8602- f:00103 d: 2 | P = P + 2 (0x011D), A # 0
0x011C (0x000238) 0x7005- f:00070 d: 5 | P = P + 5 (0x0121)
0x011D (0x00023A) 0x20AF- f:00020 d: 175 | A = OR[175]
0x011E (0x00023C) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x011F (0x00023E) 0x2819- f:00024 d: 25 | OR[25] = A
0x0120 (0x000240) 0x7004- f:00070 d: 4 | P = P + 4 (0x0124)
0x0121 (0x000242) 0x2127- f:00020 d: 295 | A = OR[295]
0x0122 (0x000244) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x0123 (0x000246) 0x2819- f:00024 d: 25 | OR[25] = A
0x0124 (0x000248) 0x2122- f:00020 d: 290 | A = OR[290]
0x0125 (0x00024A) 0x281D- f:00024 d: 29 | OR[29] = A
0x0126 (0x00024C) 0x7E00-0x1D75 f:00077 d: 0 | R = OR[0]+7541 (0x1D75)
0x0128 (0x000250) 0x2128- f:00020 d: 296 | A = OR[296]
0x0129 (0x000252) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x012A (0x000254) 0x8602- f:00103 d: 2 | P = P + 2 (0x012C), A # 0
0x012B (0x000256) 0x700A- f:00070 d: 10 | P = P + 10 (0x0135)
0x012C (0x000258) 0x2128- f:00020 d: 296 | A = OR[296]
0x012D (0x00025A) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x012E (0x00025C) 0x8602- f:00103 d: 2 | P = P + 2 (0x0130), A # 0
0x012F (0x00025E) 0x7006- f:00070 d: 6 | P = P + 6 (0x0135)
0x0130 (0x000260) 0x2127- f:00020 d: 295 | A = OR[295]
0x0131 (0x000262) 0x2897- f:00024 d: 151 | OR[151] = A
0x0132 (0x000264) 0x7E00-0x1947 f:00077 d: 0 | R = OR[0]+6471 (0x1947)
0x0134 (0x000268) 0x703D- f:00070 d: 61 | P = P + 61 (0x0171)
0x0135 (0x00026A) 0x2127- f:00020 d: 295 | A = OR[295]
0x0136 (0x00026C) 0x288B- f:00024 d: 139 | OR[139] = A
0x0137 (0x00026E) 0x2122- f:00020 d: 290 | A = OR[290]
0x0138 (0x000270) 0x1416- f:00012 d: 22 | A = A + 22 (0x0016)
0x0139 (0x000272) 0x2908- f:00024 d: 264 | OR[264] = A
0x013A (0x000274) 0x3108- f:00030 d: 264 | A = (OR[264])
0x013B (0x000276) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x013C (0x000278) 0x1612- f:00013 d: 18 | A = A - 18 (0x0012)
0x013D (0x00027A) 0x8402- f:00102 d: 2 | P = P + 2 (0x013F), A = 0
0x013E (0x00027C) 0x7025- f:00070 d: 37 | P = P + 37 (0x0163)
0x013F (0x00027E) 0x3019- f:00030 d: 25 | A = (OR[25])
0x0140 (0x000280) 0x2722- f:00023 d: 290 | A = A - OR[290]
0x0141 (0x000282) 0x8402- f:00102 d: 2 | P = P + 2 (0x0143), A = 0
0x0142 (0x000284) 0x7020- f:00070 d: 32 | P = P + 32 (0x0162)
0x0143 (0x000286) 0x208B- f:00020 d: 139 | A = OR[139]
0x0144 (0x000288) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x0145 (0x00028A) 0x2908- f:00024 d: 264 | OR[264] = A
0x0146 (0x00028C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0147 (0x00028E) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0148 (0x000290) 0x308B- f:00030 d: 139 | A = (OR[139])
0x0149 (0x000292) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x014A (0x000294) 0x8402- f:00102 d: 2 | P = P + 2 (0x014C), A = 0
0x014B (0x000296) 0x7008- f:00070 d: 8 | P = P + 8 (0x0153)
0x014C (0x000298) 0x308B- f:00030 d: 139 | A = (OR[139])
0x014D (0x00029A) 0x1A00-0x7FFF f:00015 d: 0 | A = A & 32767 (0x7FFF)
0x014F (0x00029E) 0x1C00-0x8000 f:00016 d: 0 | A = A + 32768 (0x8000)
0x0151 (0x0002A2) 0x388B- f:00034 d: 139 | (OR[139]) = A
0x0152 (0x0002A4) 0x7010- f:00070 d: 16 | P = P + 16 (0x0162)
0x0153 (0x0002A6) 0x208B- f:00020 d: 139 | A = OR[139]
0x0154 (0x0002A8) 0x140A- f:00012 d: 10 | A = A + 10 (0x000A)
0x0155 (0x0002AA) 0x2908- f:00024 d: 264 | OR[264] = A
0x0156 (0x0002AC) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0157 (0x0002AE) 0x2913- f:00024 d: 275 | OR[275] = A
0x0158 (0x0002B0) 0x208B- f:00020 d: 139 | A = OR[139]
0x0159 (0x0002B2) 0x1424- f:00012 d: 36 | A = A + 36 (0x0024)
0x015A (0x0002B4) 0x2908- f:00024 d: 264 | OR[264] = A
0x015B (0x0002B6) 0x2113- f:00020 d: 275 | A = OR[275]
0x015C (0x0002B8) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x015D (0x0002BA) 0x208B- f:00020 d: 139 | A = OR[139]
0x015E (0x0002BC) 0x1425- f:00012 d: 37 | A = A + 37 (0x0025)
0x015F (0x0002BE) 0x2908- f:00024 d: 264 | OR[264] = A
0x0160 (0x0002C0) 0x2113- f:00020 d: 275 | A = OR[275]
0x0161 (0x0002C2) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0162 (0x0002C4) 0x700D- f:00070 d: 13 | P = P + 13 (0x016F)
0x0163 (0x0002C6) 0x3019- f:00030 d: 25 | A = (OR[25])
0x0164 (0x0002C8) 0x2722- f:00023 d: 290 | A = A - OR[290]
0x0165 (0x0002CA) 0x8402- f:00102 d: 2 | P = P + 2 (0x0167), A = 0
0x0166 (0x0002CC) 0x7009- f:00070 d: 9 | P = P + 9 (0x016F)
0x0167 (0x0002CE) 0x308B- f:00030 d: 139 | A = (OR[139])
0x0168 (0x0002D0) 0x8402- f:00102 d: 2 | P = P + 2 (0x016A), A = 0
0x0169 (0x0002D2) 0x7006- f:00070 d: 6 | P = P + 6 (0x016F)
0x016A (0x0002D4) 0x208B- f:00020 d: 139 | A = OR[139]
0x016B (0x0002D6) 0x1409- f:00012 d: 9 | A = A + 9 (0x0009)
0x016C (0x0002D8) 0x2908- f:00024 d: 264 | OR[264] = A
0x016D (0x0002DA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x016E (0x0002DC) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x016F (0x0002DE) 0x7E00-0x2BE3 f:00077 d: 0 | R = OR[0]+11235 (0x2BE3)
0x0171 (0x0002E2) 0x2122- f:00020 d: 290 | A = OR[290]
0x0172 (0x0002E4) 0x1408- f:00012 d: 8 | A = A + 8 (0x0008)
0x0173 (0x0002E6) 0x2924- f:00024 d: 292 | OR[292] = A
0x0174 (0x0002E8) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0175 (0x0002EA) 0x2929- f:00024 d: 297 | OR[297] = A
0x0176 (0x0002EC) 0x2124- f:00020 d: 292 | A = OR[292]
0x0177 (0x0002EE) 0x292A- f:00024 d: 298 | OR[298] = A
0x0178 (0x0002F0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0179 (0x0002F2) 0x292B- f:00024 d: 299 | OR[299] = A
0x017A (0x0002F4) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x017B (0x0002F6) 0x5800- f:00054 d: 0 | B = A
0x017C (0x0002F8) 0x1800-0x2318 f:00014 d: 0 | A = 8984 (0x2318)
0x017E (0x0002FC) 0x7C09- f:00076 d: 9 | R = OR[9]
0x017F (0x0002FE) 0x2006- f:00020 d: 6 | A = OR[6]
0x0180 (0x000300) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x0181 (0x000302) 0x2908- f:00024 d: 264 | OR[264] = A
0x0182 (0x000304) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0183 (0x000306) 0x2122- f:00020 d: 290 | A = OR[290]
0x0184 (0x000308) 0x1416- f:00012 d: 22 | A = A + 22 (0x0016)
0x0185 (0x00030A) 0x2908- f:00024 d: 264 | OR[264] = A
0x0186 (0x00030C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0187 (0x00030E) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0188 (0x000310) 0x2925- f:00024 d: 293 | OR[293] = A
0x0189 (0x000312) 0x2125- f:00020 d: 293 | A = OR[293]
0x018A (0x000314) 0x160C- f:00013 d: 12 | A = A - 12 (0x000C)
0x018B (0x000316) 0x8405- f:00102 d: 5 | P = P + 5 (0x0190), A = 0
0x018C (0x000318) 0x2125- f:00020 d: 293 | A = OR[293]
0x018D (0x00031A) 0x160D- f:00013 d: 13 | A = A - 13 (0x000D)
0x018E (0x00031C) 0x8402- f:00102 d: 2 | P = P + 2 (0x0190), A = 0
0x018F (0x00031E) 0x7004- f:00070 d: 4 | P = P + 4 (0x0193)
0x0190 (0x000320) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x0191 (0x000322) 0x2925- f:00024 d: 293 | OR[293] = A
0x0192 (0x000324) 0x7003- f:00070 d: 3 | P = P + 3 (0x0195)
0x0193 (0x000326) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0194 (0x000328) 0x2925- f:00024 d: 293 | OR[293] = A
0x0195 (0x00032A) 0x0400- f:00002 d: 0 | I = 0
0x0196 (0x00032C) 0x0000- f:00000 d: 0 | PASS
0x0197 (0x00032E) 0x2122- f:00020 d: 290 | A = OR[290]
0x0198 (0x000330) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x0199 (0x000332) 0x2908- f:00024 d: 264 | OR[264] = A
0x019A (0x000334) 0x3108- f:00030 d: 264 | A = (OR[264])
0x019B (0x000336) 0x2926- f:00024 d: 294 | OR[294] = A
0x019C (0x000338) 0x2126- f:00020 d: 294 | A = OR[294]
0x019D (0x00033A) 0x8425- f:00102 d: 37 | P = P + 37 (0x01C2), A = 0
0x019E (0x00033C) 0x2122- f:00020 d: 290 | A = OR[290]
0x019F (0x00033E) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x01A0 (0x000340) 0x2908- f:00024 d: 264 | OR[264] = A
0x01A1 (0x000342) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01A2 (0x000344) 0x2811- f:00024 d: 17 | OR[17] = A
0x01A3 (0x000346) 0x2122- f:00020 d: 290 | A = OR[290]
0x01A4 (0x000348) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x01A5 (0x00034A) 0x2908- f:00024 d: 264 | OR[264] = A
0x01A6 (0x00034C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01A7 (0x00034E) 0x2812- f:00024 d: 18 | OR[18] = A
0x01A8 (0x000350) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01A9 (0x000352) 0x2611- f:00023 d: 17 | A = A - OR[17]
0x01AA (0x000354) 0x8605- f:00103 d: 5 | P = P + 5 (0x01AF), A # 0
0x01AB (0x000356) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01AC (0x000358) 0x2612- f:00023 d: 18 | A = A - OR[18]
0x01AD (0x00035A) 0x8602- f:00103 d: 2 | P = P + 2 (0x01AF), A # 0
0x01AE (0x00035C) 0x7014- f:00070 d: 20 | P = P + 20 (0x01C2)
0x01AF (0x00035E) 0x2122- f:00020 d: 290 | A = OR[290]
0x01B0 (0x000360) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x01B1 (0x000362) 0x2908- f:00024 d: 264 | OR[264] = A
0x01B2 (0x000364) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01B3 (0x000366) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01B4 (0x000368) 0x2122- f:00020 d: 290 | A = OR[290]
0x01B5 (0x00036A) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x01B6 (0x00036C) 0x2908- f:00024 d: 264 | OR[264] = A
0x01B7 (0x00036E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01B8 (0x000370) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01B9 (0x000372) 0x2122- f:00020 d: 290 | A = OR[290]
0x01BA (0x000374) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x01BB (0x000376) 0x2908- f:00024 d: 264 | OR[264] = A
0x01BC (0x000378) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01BD (0x00037A) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01BE (0x00037C) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x01BF (0x00037E) 0x2810- f:00024 d: 16 | OR[16] = A
0x01C0 (0x000380) 0x7E00-0x171A f:00077 d: 0 | R = OR[0]+5914 (0x171A)
0x01C2 (0x000384) 0x2122- f:00020 d: 290 | A = OR[290]
0x01C3 (0x000386) 0x141C- f:00012 d: 28 | A = A + 28 (0x001C)
0x01C4 (0x000388) 0x2908- f:00024 d: 264 | OR[264] = A
0x01C5 (0x00038A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01C6 (0x00038C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01C7 (0x00038E) 0x2122- f:00020 d: 290 | A = OR[290]
0x01C8 (0x000390) 0x141D- f:00012 d: 29 | A = A + 29 (0x001D)
0x01C9 (0x000392) 0x2908- f:00024 d: 264 | OR[264] = A
0x01CA (0x000394) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01CB (0x000396) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01CC (0x000398) 0x2122- f:00020 d: 290 | A = OR[290]
0x01CD (0x00039A) 0x8602- f:00103 d: 2 | P = P + 2 (0x01CF), A # 0
0x01CE (0x00039C) 0x700B- f:00070 d: 11 | P = P + 11 (0x01D9)
0x01CF (0x00039E) 0x1017- f:00010 d: 23 | A = 23 (0x0017)
0x01D0 (0x0003A0) 0x2929- f:00024 d: 297 | OR[297] = A
0x01D1 (0x0003A2) 0x2122- f:00020 d: 290 | A = OR[290]
0x01D2 (0x0003A4) 0x292A- f:00024 d: 298 | OR[298] = A
0x01D3 (0x0003A6) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x01D4 (0x0003A8) 0x5800- f:00054 d: 0 | B = A
0x01D5 (0x0003AA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01D6 (0x0003AC) 0x7C09- f:00076 d: 9 | R = OR[9]
0x01D7 (0x0003AE) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01D8 (0x0003B0) 0x2922- f:00024 d: 290 | OR[290] = A
0x01D9 (0x0003B2) 0x2005- f:00020 d: 5 | A = OR[5]
0x01DA (0x0003B4) 0x1406- f:00012 d: 6 | A = A + 6 (0x0006)
0x01DB (0x0003B6) 0x2908- f:00024 d: 264 | OR[264] = A
0x01DC (0x0003B8) 0x2125- f:00020 d: 293 | A = OR[293]
0x01DD (0x0003BA) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x01DE (0x0003BC) 0x102A- f:00010 d: 42 | A = 42 (0x002A)
0x01DF (0x0003BE) 0x2929- f:00024 d: 297 | OR[297] = A
0x01E0 (0x0003C0) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x01E1 (0x0003C2) 0x5800- f:00054 d: 0 | B = A
0x01E2 (0x0003C4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01E3 (0x0003C6) 0x7C09- f:00076 d: 9 | R = OR[9]
0x01E4 (0x0003C8) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x01E5 (0x0003CA) 0x2925- f:00024 d: 293 | OR[293] = A
0x01E6 (0x0003CC) 0x721A- f:00071 d: 26 | P = P - 26 (0x01CC)
0x01E7 (0x0003CE) 0x1003- f:00010 d: 3 | A = 3 (0x0003)
0x01E8 (0x0003D0) 0x2925- f:00024 d: 293 | OR[293] = A
0x01E9 (0x0003D2) 0x721D- f:00071 d: 29 | P = P - 29 (0x01CC)
0x01EA (0x0003D4) 0x100D- f:00010 d: 13 | A = 13 (0x000D)
0x01EB (0x0003D6) 0x2929- f:00024 d: 297 | OR[297] = A
0x01EC (0x0003D8) 0x2119- f:00020 d: 281 | A = OR[281]
0x01ED (0x0003DA) 0x292A- f:00024 d: 298 | OR[298] = A
0x01EE (0x0003DC) 0x1800-0x001D f:00014 d: 0 | A = 29 (0x001D)
0x01F0 (0x0003E0) 0x292B- f:00024 d: 299 | OR[299] = A
0x01F1 (0x0003E2) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x01F2 (0x0003E4) 0x5800- f:00054 d: 0 | B = A
0x01F3 (0x0003E6) 0x1800-0x2318 f:00014 d: 0 | A = 8984 (0x2318)
0x01F5 (0x0003EA) 0x7C09- f:00076 d: 9 | R = OR[9]
0x01F6 (0x0003EC) 0x2006- f:00020 d: 6 | A = OR[6]
0x01F7 (0x0003EE) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x01F8 (0x0003F0) 0x2908- f:00024 d: 264 | OR[264] = A
0x01F9 (0x0003F2) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01FA (0x0003F4) 0x2006- f:00020 d: 6 | A = OR[6]
0x01FB (0x0003F6) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x01FC (0x0003F8) 0x2908- f:00024 d: 264 | OR[264] = A
0x01FD (0x0003FA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01FE (0x0003FC) 0x2923- f:00024 d: 291 | OR[291] = A
0x01FF (0x0003FE) 0x100E- f:00010 d: 14 | A = 14 (0x000E)
0x0200 (0x000400) 0x2929- f:00024 d: 297 | OR[297] = A
0x0201 (0x000402) 0x2119- f:00020 d: 281 | A = OR[281]
0x0202 (0x000404) 0x292A- f:00024 d: 298 | OR[298] = A
0x0203 (0x000406) 0x2123- f:00020 d: 291 | A = OR[291]
0x0204 (0x000408) 0x292B- f:00024 d: 299 | OR[299] = A
0x0205 (0x00040A) 0x2122- f:00020 d: 290 | A = OR[290]
0x0206 (0x00040C) 0x292C- f:00024 d: 300 | OR[300] = A
0x0207 (0x00040E) 0x1129- f:00010 d: 297 | A = 297 (0x0129)
0x0208 (0x000410) 0x5800- f:00054 d: 0 | B = A
0x0209 (0x000412) 0x1800-0x2318 f:00014 d: 0 | A = 8984 (0x2318)
0x020B (0x000416) 0x7C09- f:00076 d: 9 | R = OR[9]
0x020C (0x000418) 0x2006- f:00020 d: 6 | A = OR[6]
0x020D (0x00041A) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x020E (0x00041C) 0x2908- f:00024 d: 264 | OR[264] = A
0x020F (0x00041E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0210 (0x000420) 0x2006- f:00020 d: 6 | A = OR[6]
0x0211 (0x000422) 0x140B- f:00012 d: 11 | A = A + 11 (0x000B)
0x0212 (0x000424) 0x2908- f:00024 d: 264 | OR[264] = A
0x0213 (0x000426) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0214 (0x000428) 0x2925- f:00024 d: 293 | OR[293] = A
0x0215 (0x00042A) 0x7253- f:00071 d: 83 | P = P - 83 (0x01C2)
0x0216 (0x00042C) 0x0000- f:00000 d: 0 | PASS
0x0217 (0x00042E) 0x0000- f:00000 d: 0 | PASS
| 79.938343 | 127 | 0.464351 |
51d88503ea017e6e1172a85c4240948c888f30c3 | 412 | asm | Assembly | oeis/022/A022805.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/022/A022805.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/022/A022805.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A022805: a(n) = B(n) + C(n) where B(n) is Beatty sequence [ n*sqrt(3) ] and C is complement of B.
; 3,7,12,15,19,24,28,31,36,40,45,48,52,57,60,64,69,73,76,81,85,90,93,97,102,106,109,114,118,121,126,130,135,138,142,147,151,154,159,163,168,171,175,180,183,187,192,196,199,204,208,213,216,220,225,228
mul $0,2
add $0,1
seq $0,188070 ; Positions of 1 in A188068; complement of A188069.
sub $0,1
mul $0,6
div $0,4
| 41.2 | 199 | 0.674757 |
48657fd8621b13c1199d91253023ed3aa17f4785 | 1,316 | asm | Assembly | Modul 5/prog1b.asm | hyuwah/fu-praktikum-smd | a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e | [
"MIT"
] | null | null | null | Modul 5/prog1b.asm | hyuwah/fu-praktikum-smd | a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e | [
"MIT"
] | null | null | null | Modul 5/prog1b.asm | hyuwah/fu-praktikum-smd | a06fe109a42aa96e75f9a425a0905d6bfbfdfc7e | [
"MIT"
] | null | null | null | ;-------------------------------------------------------------------
; Praktikum SMD 2015
; M.Wahyudin (140310120031)
;
; Name : LATIH22.ASM (PROG1B)
; Desc : Menggunakan timer 0 di mode 0
; Input : P3.4 masukkan pencacah
; Output: 7Seg(P1)
;-------------------------------------------------------------------
setb T0 ;menyiapkan T0 sebagai masukkan
mov Tmod,#84h ;mengonfigurasi timer 0 mode 0
setb TR0 ;menyalakan timer
mov b,#0 ;nilai cacahan awal
mov a,b ;mengisi a dengan cacahan awal
lcall display ;mengambil pola tampilan
mov p1,a ;menampilkan digit
mov a,b ;mengambil nilai cacahan lagi
loop:
mov a,TL0 ;mengambil nilai cacahan
anl a,#0Fh ;modulus 0fh
xrl a,b ;membandingkan dengan cacahan skrg
jz loop ;ulang jika sama
inc b ;jika tak sama naikan cacahan
anl b,#0Fh ;modulus 0Fh
mov a,b ;isi a dengan nilai cacahan
lcall display ;mengambil pola tampilan
mov p1,a ;menampilkan digit
mov a,b ;mengambil nilai cacahan skrg
sjmp loop
display:
inc a
movc a,@a+pc
ret
db 3fh ;0
db 06h ;1
db 5bh ;2
db 4fh ;3
db 66h ;4
db 6dh ;5
db 7dh ;6
db 07h ;7
db 7fh ;8
db 67h ;9
db 77h ;a
db 7ch ;b
db 39h ;c
db 5eh ;d
db 79h ;e
db 71h ;f
end
| 23.5 | 68 | 0.559271 |
a04f386186c3683dbd7e310a96f12c0118a2a873 | 1,945 | asm | Assembly | programs/oeis/220/A220739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/220/A220739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/220/A220739.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A220739: Number of ways to reciprocally link elements of an 2 X n array either to themselves or to exactly two horizontal, diagonal and antidiagonal neighbors, without consecutive collinear links.
; 1,2,5,13,32,85,221,578,1513,3961,10368,27145,71065,186050,487085,1275205,3338528,8740381,22882613,59907458,156839761,410611825,1074995712,2814375313,7368130225,19290015362,50501915861,132215732221,346145280800,906220110181,2372515049741,6211325039042,16261460067385,42573055163113,111457705421952,291800061102745,763942477886281,2000027372556098,5236139639782013,13708391546789941,35889035000587808,93958713454973485,245987105364332645,644002602638024450,1686020702549740705,4414059505011197665,11556157812483852288,30254413932440359201,79207083984837225313,207366838022071316738,542893430081376724901,1421313452222058857965,3721046926584799848992,9741827327532340689013,25504435056012222218045,66771477840504325965122,174809998465500755677321,457658517555997941066841,1198165554202493067523200,3136838145051481261502761,8212348880951950716985081,21500208497804370889452482,56288276612461161951372365,147364621339579114964664613,385805587406276182942621472,1010052140879249433863199805,2644350835231472118646977941,6923000364815166922077734018,18124650259214028647586224113,47450950412826919020680938321,124228200979266728414456590848,325233652524973266222688834225,851472756595653070253609911825,2229184617261985944538140901250,5836081095190304763360812791925,15279058668308928345544297474525,40001094909736480273272079631648,104724226060900512474271941420421,274171583272965057149543744629613,717790523757994658974359292468418,1879199988001018919773534132775641,4919809440245062100346243105858505,12880228332734167381265195184799872,33720875557957440043449342448541113,88282398341138152749082832160823465,231126319465457018203799154033929282,605096560055232901862314629940964381
seq $0,80097 ; a(n) = Fibonacci(n+2)^2 - 1.
div $0,2
add $0,1
| 277.857143 | 1,682 | 0.920823 |
760e3036ba40c1c84435c48cd148a908fc175ee6 | 622 | asm | Assembly | oeis/298/A298101.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/298/A298101.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/298/A298101.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A298101: Expansion of x*(1 + x)/((1 - x)*(1 - 322*x + x^2)).
; 0,1,324,104329,33593616,10817040025,3483053294436,1121532343768369,361129931640120384,116282716455774995281,37442673568827908360100,12056424606446130716956921,3882131280602085262951768464,1250034215929265008539752488489,402507135397942730664537349524996,129606047563921630008972486794560225,41732744808447366920158476210498867456,13437814222272488226661020367293840760609,4326934446826932761617928399792406226048644,1393259454064050076752746283712787510946902761
mul $0,3
mov $2,1
lpb $0
sub $0,1
sub $1,$2
sub $2,$1
lpe
pow $1,2
div $1,64
mov $0,$1
| 44.428571 | 464 | 0.837621 |
f99cb4796f2b8dd47f89d6d29c776943f54d4a78 | 8,733 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xa0.log_21829_1080.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xa0.log_21829_1080.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_sm_/i9-9900K_12_0xa0.log_21829_1080.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r11
push %r9
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_A_ht+0x14f24, %rsi
lea addresses_UC_ht+0xc524, %rdi
nop
nop
nop
nop
add $60315, %rbx
mov $51, %rcx
rep movsb
nop
nop
nop
nop
nop
add $34538, %rbx
lea addresses_A_ht+0x2aa, %rsi
lea addresses_normal_ht+0x924, %rdi
xor $64347, %r9
mov $85, %rcx
rep movsb
nop
nop
dec %r9
lea addresses_A_ht+0x391c, %r10
nop
nop
nop
cmp %rsi, %rsi
movb $0x61, (%r10)
nop
nop
nop
nop
dec %rdi
lea addresses_A_ht+0xfbcc, %rcx
nop
nop
nop
nop
cmp %r11, %r11
mov (%rcx), %r9w
sub $3936, %r9
lea addresses_WC_ht+0xf524, %r11
nop
inc %r9
mov $0x6162636465666768, %rcx
movq %rcx, %xmm6
vmovups %ymm6, (%r11)
cmp %r9, %r9
lea addresses_A_ht+0xd7b2, %rsi
lea addresses_WC_ht+0x186a4, %rdi
nop
cmp %rax, %rax
mov $26, %rcx
rep movsq
nop
nop
nop
nop
and $39350, %r10
lea addresses_A_ht+0x2d24, %rsi
nop
nop
nop
add %rdi, %rdi
movw $0x6162, (%rsi)
nop
nop
dec %rbx
lea addresses_WT_ht+0x1d2e4, %rsi
lea addresses_A_ht+0x17724, %rdi
add %r9, %r9
mov $14, %rcx
rep movsb
nop
nop
nop
nop
and %r9, %r9
lea addresses_A_ht+0xc8d4, %r11
clflush (%r11)
nop
nop
sub $65329, %r9
movb (%r11), %al
nop
nop
sub %r9, %r9
lea addresses_A_ht+0x14604, %rsi
lea addresses_WT_ht+0x3324, %rdi
nop
nop
and %r10, %r10
mov $55, %rcx
rep movsq
nop
nop
nop
nop
nop
and %rbx, %rbx
lea addresses_D_ht+0x8824, %rdi
nop
nop
nop
nop
cmp %r9, %r9
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
vmovups %ymm5, (%rdi)
nop
nop
nop
nop
and %rbx, %rbx
lea addresses_UC_ht+0xb5c4, %rsi
nop
nop
xor %rbx, %rbx
vmovups (%rsi), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $1, %xmm2, %r10
nop
nop
nop
nop
nop
and $10399, %r10
lea addresses_WC_ht+0xa524, %rdi
nop
nop
nop
sub %r11, %r11
mov (%rdi), %r9d
nop
cmp %rsi, %rsi
lea addresses_WT_ht+0x1584, %rax
clflush (%rax)
nop
nop
nop
add $50688, %rcx
mov (%rax), %r9w
nop
nop
nop
nop
cmp %rdi, %rdi
lea addresses_normal_ht+0x106a4, %r11
nop
dec %rsi
mov (%r11), %r10d
sub $56701, %r9
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r9
pop %r11
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %rax
push %rbx
push %rcx
push %rdi
// Store
lea addresses_UC+0x1fef4, %rdi
nop
nop
nop
nop
xor $19782, %rbx
movb $0x51, (%rdi)
nop
nop
nop
nop
sub %rcx, %rcx
// Store
lea addresses_WC+0x11744, %r14
nop
nop
nop
nop
nop
xor %rax, %rax
mov $0x5152535455565758, %r10
movq %r10, (%r14)
nop
nop
cmp %r14, %r14
// Store
lea addresses_UC+0xe524, %r11
clflush (%r11)
nop
nop
nop
and $23888, %r14
mov $0x5152535455565758, %rcx
movq %rcx, %xmm2
vmovups %ymm2, (%r11)
inc %r14
// Store
mov $0xe0e, %rcx
nop
nop
nop
nop
inc %r14
movb $0x51, (%rcx)
nop
nop
dec %rcx
// Faulty Load
lea addresses_UC+0xe524, %rbx
and $45375, %rdi
movb (%rbx), %r11b
lea oracles, %rdi
and $0xff, %r11
shlq $12, %r11
mov (%rdi,%r11,1), %r11
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'NT': False, 'same': False, 'congruent': 0, 'type': 'addresses_UC', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 3, 'type': 'addresses_UC', 'AVXalign': False, 'size': 1}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_WC', 'AVXalign': False, 'size': 8}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_UC', 'AVXalign': False, 'size': 32}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 1, 'type': 'addresses_P', 'AVXalign': False, 'size': 1}}
[Faulty Load]
{'src': {'NT': False, 'same': True, 'congruent': 0, 'type': 'addresses_UC', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'same': False, 'congruent': 8, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_UC_ht'}}
{'src': {'same': False, 'congruent': 1, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 10, 'type': 'addresses_normal_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 2, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 1}}
{'src': {'NT': False, 'same': False, 'congruent': 3, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 32}}
{'src': {'same': False, 'congruent': 1, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_WC_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 11, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 2}}
{'src': {'same': False, 'congruent': 3, 'type': 'addresses_WT_ht'}, 'OP': 'REPM', 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_A_ht'}}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_A_ht', 'AVXalign': False, 'size': 1}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 5, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'same': True, 'congruent': 8, 'type': 'addresses_WT_ht'}}
{'OP': 'STOR', 'dst': {'NT': False, 'same': False, 'congruent': 7, 'type': 'addresses_D_ht', 'AVXalign': False, 'size': 32}}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_UC_ht', 'AVXalign': False, 'size': 32}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': True, 'congruent': 9, 'type': 'addresses_WC_ht', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 4, 'type': 'addresses_WT_ht', 'AVXalign': False, 'size': 2}, 'OP': 'LOAD'}
{'src': {'NT': False, 'same': False, 'congruent': 5, 'type': 'addresses_normal_ht', 'AVXalign': False, 'size': 4}, 'OP': 'LOAD'}
{'58': 21829}
58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58 58
*/
| 30.968085 | 2,999 | 0.652468 |
3b4168ff0142ddb3ceb5e9e8c6724e5e9606240e | 259 | asm | Assembly | src/x86_64/boot/header.asm | hyperioxx/MTK | 0432bdfc5babf80a384bd74a8dae5ed8546b7208 | [
"MIT"
] | null | null | null | src/x86_64/boot/header.asm | hyperioxx/MTK | 0432bdfc5babf80a384bd74a8dae5ed8546b7208 | [
"MIT"
] | null | null | null | src/x86_64/boot/header.asm | hyperioxx/MTK | 0432bdfc5babf80a384bd74a8dae5ed8546b7208 | [
"MIT"
] | null | null | null | section .multiboot_header
header_start:
; magic number
dd 0xe85250d6 ;multiboot2
dd 0 ; i386 protected mode
dd header_end - header_start
dd 0x100000000 - (0xe85250d6 + 0 + (header_end - header_start))
;end
dw 0
dw 0
dd 8
header_end: | 21.583333 | 66 | 0.694981 |
7a6634ab77bc0428eac17d424f08d3e6f5f0f2cf | 7,851 | asm | Assembly | v86.asm | satadriver/LiunuxOS | 693174ac2b3e503d72782fc7a14f18c8a4f2756c | [
"Apache-2.0"
] | null | null | null | v86.asm | satadriver/LiunuxOS | 693174ac2b3e503d72782fc7a14f18c8a4f2756c | [
"Apache-2.0"
] | null | null | null | v86.asm | satadriver/LiunuxOS | 693174ac2b3e503d72782fc7a14f18c8a4f2756c | [
"Apache-2.0"
] | null | null | null | .386p
Kernel Segment public para use32
assume cs:Kernel
;useless function
__initV86Tss proc
push ecx
push edx
push ebx
push esi
push edi
mov ebx,KernelData
shl ebx,4
mov ecx,SYSTEM_TSS_SIZE
mov edi,V86_TSS_BASE
mov al,0
cld
rep stosb
pushfd
pop eax
or eax,23200h
mov dword ptr ds:[V86_TSS_BASE + TASKSTATESEG.mEflags],eax
mov word ptr ds:[V86_TSS_BASE + TASKSTATESEG.mIomap],136
mov byte ptr ds:[V86_TSS_BASE + TASKSTATESEG.mIomapEnd + 8192+32],0ffh
MOV dword ptr ds:[V86_TSS_BASE + TASKSTATESEG.mEsp0],TSSV86_STACK0_TOP
MOV dword ptr ds:[V86_TSS_BASE + TASKSTATESEG.mSS0],rwData32Seg ;stackV86Seg
mov dword ptr ds:[V86_TSS_BASE + TASKSTATESEG.mCr3],PDE_ENTRY_VALUE
mov eax,Kernel16
mov ds:[V86_TSS_BASE + TASKSTATESEG.mCs],eax
mov eax,kernelData
mov ds:[V86_TSS_BASE + TASKSTATESEG.mDs],eax
mov ds:[V86_TSS_BASE + TASKSTATESEG.mEs],eax
mov ds:[V86_TSS_BASE + TASKSTATESEG.mFs],eax
mov ds:[V86_TSS_BASE + TASKSTATESEG.mGs],eax
mov ds:[V86_TSS_BASE + TASKSTATESEG.mSs],eax
mov ds:[V86_TSS_BASE + TASKSTATESEG.mEsp],BIT16_STACK_TOP - STACK_TOP_DUMMY
mov ds:[V86_TSS_BASE + TASKSTATESEG.mEbp],BIT16_STACK_TOP - STACK_TOP_DUMMY
lea eax,__v86TssProc
mov ds:[V86_TSS_BASE + TASKSTATESEG.mEip],eax
;you can modify tss in protect mode
;but you can not modify tss descriptor in gdt in protect mode ?????
mov eax,V86_TSS_BASE
mov word ptr ds:[ebx + kTssV86Descriptor + 2],ax
shr eax,16
mov byte ptr ds:[ebx + kTssV86Descriptor + 4],al
mov byte ptr ds:[ebx + kTssV86Descriptor + 7],ah
mov word ptr ds:[ebx + kTssV86Descriptor ],SYSTEM_TSS_SIZE - 1
mov ax,kTssV86Selector
mov word ptr ds:[tV86Entry + 2],ax
pop edi
pop esi
pop ebx
pop edx
pop ecx
ret
__initV86Tss endp
;useless function
__v86Entry proc
pushad
push es
push ds
push fs
push gs
;gs,fs,ds,es
mov eax,Kernel16
push eax
mov ecx,kernelData
push ecx
push eax
push eax
;ss
push eax
;esp
push dword ptr BIT16SEGMENT_SIZE - STACK_TOP_DUMMY
;eflags
pushfd
pop eax
or eax,23200h
push eax
;cs
mov eax,Kernel16
push eax
;eip
lea eax,__v86VMIntrProc
push eax
iretd
_v86EntryReturn:
pop gs
pop fs
pop ds
pop es
popad
ret
__v86Entry endp
Kernel ends
Kernel16 Segment public para use16
assume cs:Kernel16
;pushad or popfd will cause GP protection exp
align 10h
__v86VMIntrProc proc
mov eax,0
mov ds,ax
mov es,ax
;set int21h
mov eax,Kernel16
shl eax,16
mov ax,offset __v86Int21hProc
mov ecx,21h
shl ecx,2
mov dword ptr ds:[ecx],eax
;set int20h
mov eax,Kernel16
shl eax,16
mov ax,offset __v86Int20hProc
mov ecx,20h
shl ecx,2
mov dword ptr ds:[ecx],eax
mov ax,V86VMIPARAMS_SEG
mov fs,ax
mov ax,Kernel16
mov gs,ax
mov ax,kernelData
mov ds,ax
mov es,ax
mov ax,KERNEL_BASE_SEGMENT
mov ss,ax
mov esp,BIT16_STACK_TOP
mov byte ptr fs:[V86VMIPARAMS_OFFSET + V86VMIPARAMS._work],0
_v86VmIntCheckRequest:
mov ax,V86VMIPARAMS_SEG
mov fs,ax
mov ax,Kernel16
mov gs,ax
mov ax,kernelData
mov ds,ax
mov es,ax
mov ax,KERNEL_BASE_SEGMENT
mov ss,ax
mov esp,BIT16_STACK_TOP
mov ecx,8
_v86Wait:
nop
;fwait 指令会触发异常？
;fwait
;pause 指令会触发异常？
;db 0f3h,90h
;db 0f3h,90h
;db 0f3h,90h
loop _v86Wait
cmp byte ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._work],0
jz _v86VmIntCheckRequest
mov al,byte ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._intNumber]
cmp al,3
jz _v86VMInt3
mov byte ptr gs:[_v86VMIntNumber],al
mov byte ptr gs:[_v86VMIntOpcode],0cdh
jmp _v86VMIntSetRegs
_v86VMInt3:
mov byte ptr gs:[_v86VMIntOpcode],0cch
mov byte ptr gs:[_v86VMIntNumber],90h
_v86VMIntSetRegs:
push word ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._ds]
pop ds
push word ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._es]
pop es
mov eax,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._eax]
mov ecx,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._ecx]
mov edx,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._edx]
mov ebx,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._ebx]
mov esi,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._esi]
mov edi,dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._edi]
;stc
_v86VMIntOpcode:
db 0cdh
_v86VMIntNumber:
db 13h
jc _V86VMIWorkError
;cmp ah,0
;jnz _V86VMIWorkError
mov ax,V86VMIPARAMS_SEG
mov fs,ax
mov dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._result],1
jmp _V86VMIWorkOK
_V86VMIWorkError:
mov ax,V86VMIPARAMS_SEG
mov fs,ax
mov dword ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._result],0
_V86VMIWorkOK:
mov byte ptr fs:[V86VMIPARAMS_OFFSET +V86VMIPARAMS._work],0
jmp _v86VmIntCheckRequest
__v86VMIntIretdAddr:
;iretd will cause GP exception
iretd
__v86VMIntrProc endp
align 10h
__v86VMLeave proc
MOV AX,KernelData
MOV DS,AX
MOV BX,DS:[_videoMode]
OR BX,4000H
MOV AX,4F02H
INT 10H
CMP AX,4FH
mov eax,dword ptr ss:[esp + TASKDOSPARAMS.address]
mov edx,eax
shr eax,4
mov ds,ax
and edx,0fh
mov dword ptr ds:[edx + DOS_PE_CONTROL.status],DOS_THREAD_TERMINATE_CONTROL_CODE
_v86LeaveWait:
nop
jmp _v86LeaveWait
__v86VMLeave endp
__v86Int20hProc proc
pushad
push ds
push es
mov ax,V86_TASKCONTROL_SEG
mov es,ax
;bp + 36 == ip
;bp + 38 == cs
;bp + 40 == eflags
mov bp,sp
add bp,36
movzx edx,word ptr ss:[bp+2]
shl edx,4
movzx eax,word ptr ss:[bp]
add edx,eax
shr edx,4
mov si,V86_TASKCONTROL_OFFSET
mov cx,LIMIT_V86_PROC_COUNT
_v86Int20DosTaskInfo:
push cx
push edx
push si
mov eax,dword ptr es:[si+DOS_PE_CONTROL.address]
cmp edx,eax
jb ___v86Int21ProcNotFoundCs
add eax,1000h
cmp edx,eax
ja ___v86Int21ProcNotFoundCs
pop si
pop edx
pop cx
;call __restoreScreen
MOV AX,KernelData
MOV DS,AX
MOV BX,DS:[_videoMode]
OR BX,4000H
MOV AX,4F02H
INT 10H
CMP AX,4FH
JNZ _int20RestoreVideoModeError
_int20RestoreVideoModeError:
mov dword ptr es:[si + DOS_PE_CONTROL.status],DOS_THREAD_TERMINATE_CONTROL_CODE
_v86Int20WaitEnd:
wait
nop
jmp _v86Int20WaitEnd
jmp __v86Int20ProcEnd
___v86Int20ProcNotFoundCs:
pop si
add si,sizeof DOS_PE_CONTROL
pop edx
pop cx
loop _v86Int20DosTaskInfo
__v86Int20ProcEnd:
pop es
pop ds
popad
iret
__v86Int20hProc endp
__v86Int21hProc proc
pushad
push ds
push es
cmp ah,4ch
jnz __v86Int21ProcEnd
mov ax,V86_TASKCONTROL_SEG
mov es,ax
;bp + 36 == ip
;bp + 38 == cs
;bp + 40 == eflags
mov bp,sp
add bp,36
movzx edx,word ptr ss:[bp+2]
shl edx,4
movzx eax,word ptr ss:[bp]
add edx,eax
shr edx,4
mov si,V86_TASKCONTROL_OFFSET
mov ecx,LIMIT_V86_PROC_COUNT
_v86Int21DosTaskInfo:
push cx
push edx
push si
mov eax,dword ptr es:[si+DOS_PE_CONTROL.address]
cmp edx,eax
jb ___v86Int21ProcNotFoundCs
add eax,1000h
cmp edx,eax
ja ___v86Int21ProcNotFoundCs
pop si
pop edx
pop cx
;call __restoreScreen
MOV AX,KernelData
MOV DS,AX
MOV BX,DS:[_videoMode]
OR BX,4000H
MOV AX,4F02H
INT 10H
CMP AX,4FH
JNZ _int21RestoreVideoModeError
_int21RestoreVideoModeError:
mov dword ptr es:[si + DOS_PE_CONTROL.status],DOS_THREAD_TERMINATE_CONTROL_CODE
_v86Int21WaitEnd:
wait
nop
jmp _v86Int21WaitEnd
jmp __v86Int21ProcEnd
___v86Int21ProcNotFoundCs:
pop si
add si,sizeof DOS_PE_CONTROL
pop edx
pop cx
loop _v86Int21DosTaskInfo
__v86Int21ProcEnd:
pop es
pop ds
popad
iret
__v86Int21hProc endp
__v86TssProc proc
;mov ax,3
;int 10h
iret
jmp __v86TssProc
__v86TssProc endp
__restoreScreen proc
push ax
push cx
push dx
push bx
push es
mov ax,kernelData
mov es,ax
mov ax,4f02h
mov bx,4000h
or bx,word ptr es:[_videoMode]
int 10h
mov AX, 4F04h
mov DX, 2 ;子功能--恢复
mov CX, 1 ;恢复硬件控制器状态
push word ptr VESA_STATE_SEG
pop es
mov BX, VESA_STATE_OFFSET
int 10h
pop es
pop bx
pop dx
pop cx
pop ax
ret
__restoreScreen endp
Kernel16 ends | 16.993506 | 82 | 0.741179 |
fbc4512602c063dc4ea38164ad0d40158944fdf0 | 293 | asm | Assembly | Lista Assembly/questao2.asm | joaovictor42/Arquitetura-de-Computadores | 28a170113e04c0a39608fd61962aa8bd63604f03 | [
"MIT"
] | null | null | null | Lista Assembly/questao2.asm | joaovictor42/Arquitetura-de-Computadores | 28a170113e04c0a39608fd61962aa8bd63604f03 | [
"MIT"
] | null | null | null | Lista Assembly/questao2.asm | joaovictor42/Arquitetura-de-Computadores | 28a170113e04c0a39608fd61962aa8bd63604f03 | [
"MIT"
] | 1 | 2021-07-06T02:05:29.000Z | 2021-07-06T02:05:29.000Z | extern printf
global main
section .data
msg db "O valor de A eh: %d", 0AH, 0H
varA dd 0
varB dd 30
varC dd 50
section .text
main:
mov eax, [varB]
add eax, [varC]
add eax, 100
mov [varA], eax
push DWORD[varA]
push msg
call printf
add esp, 8
mov eax, 1
xor ecx, ecx
int 80h
| 12.208333 | 38 | 0.651877 |
03ffa4e8e12b821f05c3fe260e0e8ebdf891a179 | 7,153 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_114.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_114.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_114.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r13
push %r14
push %r8
push %r9
push %rbp
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0x1a4fb, %r9
sub %rbp, %rbp
mov (%r9), %r13d
nop
nop
inc %r14
lea addresses_UC_ht+0x14d5b, %rbx
nop
and $3431, %rcx
mov $0x6162636465666768, %r8
movq %r8, (%rbx)
nop
nop
sub $24645, %r14
lea addresses_A_ht+0x17b7b, %r9
nop
cmp $1052, %rbp
mov (%r9), %rcx
nop
cmp $23579, %rbx
lea addresses_A_ht+0x179bf, %rsi
lea addresses_D_ht+0x175fb, %rdi
nop
nop
xor %r9, %r9
mov $122, %rcx
rep movsw
nop
nop
nop
nop
and $58283, %r8
lea addresses_UC_ht+0x13f9b, %rsi
lea addresses_WC_ht+0x1e931, %rdi
clflush (%rsi)
nop
nop
nop
nop
sub $44890, %r8
mov $95, %rcx
rep movsw
nop
nop
nop
nop
nop
inc %rcx
lea addresses_UC_ht+0x14ecb, %r14
nop
nop
nop
cmp %rdi, %rdi
movb (%r14), %r13b
nop
nop
nop
nop
inc %rbx
lea addresses_normal_ht+0x17ffb, %rcx
nop
nop
nop
nop
dec %rbx
mov (%rcx), %r14
nop
nop
nop
nop
xor %r14, %r14
lea addresses_UC_ht+0x13ffb, %rsi
lea addresses_WT_ht+0x101fb, %rdi
nop
cmp %r8, %r8
mov $25, %rcx
rep movsb
and %rcx, %rcx
lea addresses_A_ht+0x12c3b, %rsi
lea addresses_UC_ht+0x19848, %rdi
clflush (%rsi)
nop
nop
sub %rbp, %rbp
mov $111, %rcx
rep movsl
nop
nop
xor %r8, %r8
lea addresses_A_ht+0x11ba3, %rsi
lea addresses_D_ht+0x103fb, %rdi
nop
nop
nop
nop
cmp $47691, %rbx
mov $121, %rcx
rep movsb
nop
nop
and $52353, %rcx
lea addresses_D_ht+0xa7fb, %r8
nop
nop
nop
sub %r9, %r9
movw $0x6162, (%r8)
nop
nop
xor $5656, %rbp
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r9
pop %r8
pop %r14
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r12
push %r8
push %r9
push %rbp
push %rdi
push %rsi
// Store
lea addresses_WC+0xa4fb, %r9
xor %r10, %r10
movl $0x51525354, (%r9)
mfence
// Store
lea addresses_D+0x1e7ab, %r8
and $6543, %r12
movl $0x51525354, (%r8)
nop
nop
nop
nop
nop
sub %r9, %r9
// Faulty Load
lea addresses_WT+0x74fb, %r12
nop
nop
nop
dec %rsi
movb (%r12), %r10b
lea oracles, %r12
and $0xff, %r10
shlq $12, %r10
mov (%r12,%r10,1), %r10
pop %rsi
pop %rdi
pop %rbp
pop %r9
pop %r8
pop %r12
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 2}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_WT', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 10}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 5}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': True, 'size': 8, 'congruent': 6}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_D_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 4, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 1, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 4}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 8}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 7, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_WT_ht'}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 4, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 0, 'type': 'addresses_UC_ht'}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 2, 'type': 'addresses_A_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 6}}
{'39': 21829}
39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39 39
*/
| 35.236453 | 2,999 | 0.655529 |
b24709d659e197abd1eabe45f774a003c8386c7a | 5,339 | asm | Assembly | Library/Shell/Buffer/bufferC.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 504 | 2018-11-18T03:35:53.000Z | 2022-03-29T01:02:51.000Z | Library/Shell/Buffer/bufferC.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 96 | 2018-11-19T21:06:50.000Z | 2022-03-06T10:26:48.000Z | Library/Shell/Buffer/bufferC.asm | steakknife/pcgeos | 95edd7fad36df400aba9bab1d56e154fc126044a | [
"Apache-2.0"
] | 73 | 2018-11-19T20:46:53.000Z | 2022-03-29T00:59:26.000Z | COMMENT @=====================================================================
Copyright (c) GeoWorks 1992 -- All Rights Reserved
PROJECT: PC GEOS
MODULE: Shell -- Buffer
FILE: bufferMain.asm
AUTHOR: Martin Turon, Aug 21, 1992
GLOBAL ROUTINES:
Name Description
---- -----------
ShellBufferOpen Opens a ShellBuffer
ShellBufferReadNLines Reads the next N lines from ShellBuffer
ShellBufferReadLine Reads the next line of a ShellBuffer
ShellBufferClose Closes a ShellBuffer file
ShellBufferLock Locks a ShellBuffer
ShellBufferUnlock Unlocks a ShellBuffer
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 8/21/92 Initial version
DESCRIPTION:
Routines to deal with reading huge files. (64k+)
Externally callable routines for this module.
No global routines for the buffer module of the shell library
should appear in any file other than this one.
RCS STAMP:
$Id: bufferC.asm,v 1.1 97/04/04 19:37:18 newdeal Exp $
=============================================================================@
SetGeosConvention
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFEROPEN
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION:
ShellBuffer *ShellBufferOpen(THCAR *filename, FileAccessFlags flags);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFEROPEN proc far filename:fptr,
flags:FileAccessFlags
uses es, ds
.enter
movdw dsdx, ss:[filename], ax
mov al, ss:[flags]
call ShellBufferOpen
.leave
ret
SHELLBUFFEROPEN endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFERCLOSE
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION: FileError ShellBufferClose(ShellBuffer *);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFERCLOSE proc far buffer:sptr.ShellBuffer
uses es, ds
.enter
mov es, ss:[buffer]
call ShellBufferOpen
.leave
ret
SHELLBUFFERCLOSE endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFERLOCK
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION: FileError ShellBufferClose(ShellBuffer *);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFERLOCK proc far bufhan:hptr
uses ds
.enter
mov bx, ss:[bufhan]
call ShellBufferLock
.leave
ret
SHELLBUFFERLOCK endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFERUNLOCK
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION: FileError ShellBufferClose(ShellBuffer *);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFERUNLOCK proc far buffer:sptr.ShellBuffer
uses es
.enter
mov es, ss:[buffer]
call ShellBufferUnlock
.leave
ret
SHELLBUFFERUNLOCK endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFERREADNLINES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION: FileError ShellBufferClose(ShellBuffer *);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFERREADNLINES proc far buffer:sptr.ShellBuffer,
numlines:word
uses es
.enter
mov cx, ss:[numlines]
mov es, ss:[buffer]
call ShellBufferReadNLines
.leave
ret
SHELLBUFFERREADNLINES endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SHELLBUFFERREADNLINES
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
C DECLARATION: FileError ShellBufferClose(ShellBuffer *);
SYNOPSIS: C Stubs for the shell library buffer module.
REVISION HISTORY:
Name Date Description
---- ---- -----------
martin 12/16/97 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
SHELLBUFFERREADLINE proc far buffer:sptr.ShellBuffer
uses es
.enter
mov es, ss:[buffer]
call ShellBufferReadLine
.leave
ret
SHELLBUFFERREADLINE endp
SetDefaultConvention
| 26.562189 | 79 | 0.478367 |
351d55d10f6de519d5bbf4dd73989d0b85a114c1 | 55 | asm | Assembly | debugging/pause.asm | PiJoules/brainfuck-in-the-bootsector | 81a1299b01b26d32ce9d4efe6fb7dcf8a4541905 | [
"MIT"
] | 7 | 2020-01-01T12:25:21.000Z | 2020-01-07T03:14:59.000Z | debugging/pause.asm | PiJoules/brainfuck-in-the-bootsector | 81a1299b01b26d32ce9d4efe6fb7dcf8a4541905 | [
"MIT"
] | null | null | null | debugging/pause.asm | PiJoules/brainfuck-in-the-bootsector | 81a1299b01b26d32ce9d4efe6fb7dcf8a4541905 | [
"MIT"
] | 2 | 2020-01-03T12:20:21.000Z | 2020-01-05T12:44:06.000Z | pause:
push ax
mov ah, 0
int 0x16
pop ax
ret
| 7.857143 | 11 | 0.581818 |
905a36c28bf0dce738f35ef15731adfa6aa16c83 | 144 | asm | Assembly | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/fzero.lzh/fzero/effect.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/fzero.lzh/fzero/effect.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | other.7z/NEWS.7z/NEWS/テープリストア/NEWS_05/NEWS_05.tar/home/kimura/fzero.lzh/fzero/effect.asm | prismotizm/gigaleak | d082854866186a05fec4e2fdf1def0199e7f3098 | [
"MIT"
] | null | null | null | Name: effect.asm
Type: file
Size: 61229
Last-Modified: '1993-07-20T07:13:22Z'
SHA-1: 269E3A56B08A6A3D7892BE1015827C4AE1E20564
Description: null
| 20.571429 | 47 | 0.8125 |
795dc900778e5b8799cbe7e2e14fe1671b42dba3 | 108 | asm | Assembly | pkgs/tools/yasm/src/modules/arch/x86/tests/cpubasic-err.asm | manggoguy/parsec-modified | d14edfb62795805c84a4280d67b50cca175b95af | [
"BSD-3-Clause"
] | 2,151 | 2020-04-18T07:31:17.000Z | 2022-03-31T08:39:18.000Z | pkgs/tools/yasm/src/modules/arch/x86/tests/cpubasic-err.asm | manggoguy/parsec-modified | d14edfb62795805c84a4280d67b50cca175b95af | [
"BSD-3-Clause"
] | 395 | 2020-04-18T08:22:18.000Z | 2021-12-08T13:04:49.000Z | pkgs/tools/yasm/src/modules/arch/x86/tests/cpubasic-err.asm | manggoguy/parsec-modified | d14edfb62795805c84a4280d67b50cca175b95af | [
"BSD-3-Clause"
] | 338 | 2020-04-18T08:03:10.000Z | 2022-03-29T12:33:22.000Z | [cpu 8086]
pause
shl ax, 2
cpu 386
fninit
cpu 386 fpu
fninit
cpu 8086
shl ax, 1
shl ax, 2
movsd
push 0
| 6 | 11 | 0.685185 |
87f2b605782d14d2673935f88bb61436c8ae9aa4 | 960 | asm | Assembly | data/pokemon/base_stats/baltoy.asm | AtmaBuster/pokeplat-gen2 | fa83b2e75575949b8f72cb2c48f7a1042e97f70f | [
"blessing"
] | 6 | 2021-06-19T06:41:19.000Z | 2022-02-15T17:12:33.000Z | data/pokemon/base_stats/baltoy.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | null | null | null | data/pokemon/base_stats/baltoy.asm | AtmaBuster/pokeplat-gen2-old | 01e42c55db5408d72d89133dc84a46c699d849ad | [
"blessing"
] | 2 | 2021-08-11T19:47:07.000Z | 2022-01-01T07:07:56.000Z | db 0 ; species ID placeholder
db 40, 40, 55, 55, 40, 70
; hp atk def spd sat sdf
db GROUND, PSYCHIC ; type
db 255 ; catch rate
db 58 ; base exp
db NO_ITEM, NO_ITEM ; items
db GENDER_UNKNOWN ; gender ratio
db 20 ; step cycles to hatch
INCBIN "gfx/pokemon/baltoy/front.dimensions"
db GROWTH_MEDIUM_FAST ; growth rate
dn EGG_MINERAL, EGG_MINERAL ; egg groups
db 70 ; happiness
; tm/hm learnset
tmhm CALM_MIND, TOXIC, HIDDEN_POWER, SUNNY_DAY, ICE_BEAM, LIGHT_SCREEN, PROTECT, RAIN_DANCE, SAFEGUARD, FRUSTRATION, SOLARBEAM, EARTHQUAKE, RETURN, DIG, PSYCHIC_M, SHADOW_BALL, DOUBLE_TEAM, REFLECT, SANDSTORM, ROCK_TOMB, FACADE, SECRET_POWER, REST, SKILL_SWAP, CHARGE_BEAM, ENDURE, EXPLOSION, RECYCLE, ROCK_POLISH, FLASH, GYRO_BALL, STEALTH_ROCK, PSYCH_UP, ROCK_SLIDE, SLEEP_TALK, NATURAL_GIFT, DREAM_EATER, GRASS_KNOT, SWAGGER, SUBSTITUTE, TRICK_ROOM, ANCIENTPOWER, EARTH_POWER, MUD_SLAP, SIGNAL_BEAM, SNORE, TRICK, ZEN_HEADBUTT
; end
| 48 | 531 | 0.759375 |
f46cac07350f7488d1af3eee1f2bee85498e074d | 5,800 | asm | Assembly | Transynther/x86/_processed/US/_zr_/i7-8650U_0xd2_notsx.log_33_685.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/US/_zr_/i7-8650U_0xd2_notsx.log_33_685.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/US/_zr_/i7-8650U_0xd2_notsx.log_33_685.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r13
push %r14
push %rax
push %rbx
push %rcx
push %rdi
push %rsi
lea addresses_D_ht+0xfd0b, %rdi
nop
nop
nop
nop
nop
cmp $25462, %rbx
movb (%rdi), %r13b
nop
nop
nop
dec %r14
lea addresses_WC_ht+0x19f5f, %r10
cmp $53176, %rax
movb $0x61, (%r10)
nop
nop
nop
nop
nop
cmp $64988, %r10
lea addresses_A_ht+0x4483, %rsi
lea addresses_D_ht+0x64bb, %rdi
clflush (%rsi)
clflush (%rdi)
nop
xor $29648, %rax
mov $73, %rcx
rep movsq
nop
nop
nop
nop
nop
add %rbx, %rbx
lea addresses_normal_ht+0x8c0b, %r14
nop
nop
add %rcx, %rcx
mov $0x6162636465666768, %r10
movq %r10, (%r14)
nop
sub $29368, %rsi
lea addresses_WC_ht+0xc3a3, %rcx
clflush (%rcx)
nop
cmp $21024, %rbx
movl $0x61626364, (%rcx)
nop
nop
nop
and %r10, %r10
lea addresses_WC_ht+0x1030b, %rbx
nop
cmp $54377, %rax
and $0xffffffffffffffc0, %rbx
movaps (%rbx), %xmm2
vpextrq $0, %xmm2, %rcx
nop
nop
add $857, %r13
lea addresses_UC_ht+0x230b, %rbx
and $32788, %r10
vmovups (%rbx), %ymm2
vextracti128 $0, %ymm2, %xmm2
vpextrq $0, %xmm2, %rsi
nop
nop
nop
sub %rsi, %rsi
lea addresses_normal_ht+0xf641, %rsi
lea addresses_WT_ht+0x45cb, %rdi
nop
nop
nop
sub %r14, %r14
mov $66, %rcx
rep movsq
sub $39025, %rdi
lea addresses_UC_ht+0x15a8b, %rsi
lea addresses_WT_ht+0x1e70b, %rdi
nop
nop
nop
nop
nop
xor $3339, %r10
mov $64, %rcx
rep movsw
nop
nop
sub %rax, %rax
lea addresses_WT_ht+0xeb0b, %rdi
nop
nop
xor %rbx, %rbx
movw $0x6162, (%rdi)
nop
nop
xor %r13, %r13
lea addresses_A_ht+0x1c813, %rax
nop
nop
nop
inc %rbx
vmovups (%rax), %ymm3
vextracti128 $1, %ymm3, %xmm3
vpextrq $1, %xmm3, %rcx
nop
nop
nop
nop
nop
and $7273, %r13
lea addresses_UC_ht+0x1570b, %rsi
lea addresses_A_ht+0x2507, %rdi
clflush (%rdi)
nop
nop
add %r13, %r13
mov $112, %rcx
rep movsb
nop
nop
nop
nop
nop
dec %rcx
lea addresses_WC_ht+0x360f, %r14
nop
nop
cmp %rsi, %rsi
mov $0x6162636465666768, %r13
movq %r13, (%r14)
nop
nop
xor $47694, %r10
lea addresses_normal_ht+0x153cb, %rsi
lea addresses_normal_ht+0x1210b, %rdi
clflush (%rsi)
nop
nop
nop
nop
nop
xor $55871, %r13
mov $127, %rcx
rep movsq
nop
nop
nop
nop
add $38658, %rax
pop %rsi
pop %rdi
pop %rcx
pop %rbx
pop %rax
pop %r14
pop %r13
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
// Store
lea addresses_WC+0x1da03, %r11
nop
nop
cmp %rcx, %rcx
mov $0x5152535455565758, %r13
movq %r13, (%r11)
nop
nop
nop
nop
nop
and %r11, %r11
// Store
mov $0x67b7ca00000005d3, %rsi
clflush (%rsi)
sub $57438, %rbx
movb $0x51, (%rsi)
cmp $30903, %rdx
// Store
lea addresses_A+0xdb8b, %r13
nop
xor $65143, %rbx
movw $0x5152, (%r13)
nop
nop
and %r11, %r11
// Load
mov $0x5e21070000000b8b, %rdx
nop
nop
nop
dec %rbx
vmovntdqa (%rdx), %ymm5
vextracti128 $1, %ymm5, %xmm5
vpextrq $1, %xmm5, %rcx
nop
dec %r11
// Faulty Load
lea addresses_US+0x11b0b, %rdi
nop
dec %r13
mov (%rdi), %ecx
lea oracles, %r13
and $0xff, %rcx
shlq $12, %rcx
mov (%r13,%rcx,1), %rcx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'size': 16, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_NC', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 3, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_A', 'size': 2, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_NC', 'size': 32, 'AVXalign': False, 'NT': True, 'congruent': 7, 'same': False}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'type': 'addresses_US', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 0, 'same': True}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'type': 'addresses_D_ht', 'size': 1, 'AVXalign': False, 'NT': True, 'congruent': 8, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': True, 'NT': False, 'congruent': 2, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_A_ht', 'congruent': 3, 'same': False}, 'dst': {'type': 'addresses_D_ht', 'congruent': 0, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_normal_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 7, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 4, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_WC_ht', 'size': 16, 'AVXalign': True, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_UC_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 1, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 6, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 2, 'same': False}, 'dst': {'type': 'addresses_WT_ht', 'congruent': 10, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WT_ht', 'size': 2, 'AVXalign': True, 'NT': False, 'congruent': 9, 'same': False}}
{'OP': 'LOAD', 'src': {'type': 'addresses_A_ht', 'size': 32, 'AVXalign': False, 'NT': False, 'congruent': 3, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_UC_ht', 'congruent': 10, 'same': True}, 'dst': {'type': 'addresses_A_ht', 'congruent': 2, 'same': False}}
{'OP': 'STOR', 'dst': {'type': 'addresses_WC_ht', 'size': 8, 'AVXalign': False, 'NT': False, 'congruent': 1, 'same': False}}
{'OP': 'REPM', 'src': {'type': 'addresses_normal_ht', 'congruent': 4, 'same': False}, 'dst': {'type': 'addresses_normal_ht', 'congruent': 9, 'same': False}}
{'00': 33}
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
*/
| 21.323529 | 156 | 0.650517 |
d3a355c599a92dcf2669aba1b24ce527b786ecc7 | 4,542 | asm | Assembly | win32/crc_i386.asm | OS2World/UTIL-ARCHIVER-Zip | 3cccde5524884a12eaee77f68a9040fcdf01a792 | [
"Info-ZIP"
] | null | null | null | win32/crc_i386.asm | OS2World/UTIL-ARCHIVER-Zip | 3cccde5524884a12eaee77f68a9040fcdf01a792 | [
"Info-ZIP"
] | null | null | null | win32/crc_i386.asm | OS2World/UTIL-ARCHIVER-Zip | 3cccde5524884a12eaee77f68a9040fcdf01a792 | [
"Info-ZIP"
] | 2 | 2015-07-16T08:35:34.000Z | 2021-02-07T00:28:47.000Z | ; crc_i386.asm, optimized CRC calculation function for Zip and UnZip, not
; copyrighted by Paul Kienitz and Christian Spieler. Last revised 19 Jan 96.
;
; FLAT memory model assumed.
;
; The loop unroolling can be disabled by defining the macro NO_UNROLLED_LOOPS.
; This results in shorter code at the expense of reduced performance.
;
;==============================================================================
;
; Do NOT assemble this source if external crc32 routine from zlib gets used.
;
IFNDEF USE_ZLIB
;
.386p
name crc_i386
.MODEL FLAT
extrn _get_crc_table:near ; ulg near *get_crc_table(void);
;
IFNDEF NO_STD_STACKFRAME
; Use a `standard' stack frame setup on routine entry and exit.
; Actually, this option is set as default, because it results
; in smaller code !!
STD_ENTRY MACRO
push ebp
mov ebp,esp
ENDM
Arg1 EQU 08H[ebp]
Arg2 EQU 0CH[ebp]
Arg3 EQU 10H[ebp]
STD_LEAVE MACRO
pop ebp
ENDM
ELSE ; NO_STD_STACKFRAME
STD_ENTRY MACRO
ENDM
Arg1 EQU 18H[esp]
Arg2 EQU 1CH[esp]
Arg3 EQU 20H[esp]
STD_LEAVE MACRO
ENDM
ENDIF ; ?NO_STD_STACKFRAME
; This is the loop body of the CRC32 cruncher.
; registers modified:
; ebx : crc value "c"
; esi : pointer to next data byte "text++"
; registers read:
; edi : pointer to base of crc_table array
; scratch registers:
; eax : requires upper three bytes of eax = 0, uses al
Do_CRC MACRO
lodsb ; al <-- *text++
xor al,bl ; (c ^ *text++) & 0xFF
shr ebx,8 ; c = (c >> 8)
xor ebx,[edi+eax*4] ; ^ table[(c ^ *text++) & 0xFF]
ENDM
_TEXT segment para
public _crc32
_crc32 proc near ; ulg crc32(ulg crc, uch *text, extent len)
STD_ENTRY
push edi
push esi
push ebx
push edx
push ecx
mov esi,Arg2 ; 2nd arg: uch *text
test esi,esi
jne short Crunch_it ;> if (!text)
sub eax,eax ;> return 0;
IFNDEF NO_STD_STACKFRAME
jmp short fine ;>
ELSE
jmp fine ;>
ENDIF
; align destination of commonly taken jump at longword boundary
align 4
Crunch_it: ;> else {
call _get_crc_table
mov edi,eax
mov ebx,Arg1 ; 1st arg: ulg crc
sub eax,eax ; eax=0; make al usable as a dword
mov ecx,Arg3 ; 3rd arg: extent textlen
not ebx ;> c = ~crc;
cld ; incr. idx regs on string ops
IFNDEF NO_UNROLLED_LOOPS
mov edx,ecx ; save textlen in edx
shr ecx,3 ; ecx = textlen / 8
and edx,000000007H ; edx = textlen % 8
jecxz No_Eights
; align loop head at start of 486 internal cache line !!
align 16
Next_Eight:
Do_CRC
Do_CRC
Do_CRC
Do_CRC
Do_CRC
Do_CRC
Do_CRC
Do_CRC
loop Next_Eight
No_Eights:
mov ecx,edx
ENDIF ; NO_UNROLLED_LOOPS
jecxz bail ;> if (textlen)
; align loop head at start of 486 internal cache line !!
align 16
loupe: ;> do {
Do_CRC ; c = CRC32(c, *text++);
loop loupe ;> } while (--textlen);
bail: ;> }
mov eax,ebx
not eax ;> return ~c;
fine:
pop ecx
pop edx
pop ebx
pop esi
pop edi
STD_LEAVE
ret
_crc32 endp
_TEXT ends
;
ENDIF ;!USE_ZLIB
;
end
| 31.541667 | 79 | 0.43395 |
50c8071e0cb44eef4a9b35d2d3fd2c5d06bbcf78 | 307 | asm | Assembly | NumberSum_.asm | RolEYder/x86-Assembly | a58239f89c529036fbb6dabfa2f87d09fe300923 | [
"MIT"
] | null | null | null | NumberSum_.asm | RolEYder/x86-Assembly | a58239f89c529036fbb6dabfa2f87d09fe300923 | [
"MIT"
] | null | null | null | NumberSum_.asm | RolEYder/x86-Assembly | a58239f89c529036fbb6dabfa2f87d09fe300923 | [
"MIT"
] | null | null | null | .model flat,c
.code
NumberSum_ proc
push ebp
mov ebp,esp
; Load params
mov eax,[ebp+8]
mov ecx,[ebp+12]
mov edx,[ebp+16]
; Compute the sum
add eax,ecx
add eax,edx
; Restore the stack frame pointer
pop ebp
ret
numberSum_ endp
end
| 12.28 | 34 | 0.553746 |
7f80289e5cc44c9cc0e23cbd91f7082ebfde3041 | 7,596 | asm | Assembly | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0xca.log_21829_204.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0xca.log_21829_204.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/AVXALIGN/_zr_/i7-7700_9_0xca.log_21829_204.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r10
push %r14
push %r15
push %r8
push %rbp
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x76cc, %rcx
nop
nop
nop
nop
cmp %r10, %r10
movb (%rcx), %r8b
nop
and %r15, %r15
lea addresses_WC_ht+0xf196, %rsi
lea addresses_UC_ht+0x105b6, %rdi
nop
and $24046, %r10
mov $67, %rcx
rep movsl
and $8303, %rsi
lea addresses_WC_ht+0x4896, %rsi
nop
nop
nop
nop
and %r10, %r10
mov (%rsi), %ebp
nop
nop
nop
nop
nop
xor %r15, %r15
lea addresses_A_ht+0x147ce, %rcx
nop
nop
nop
nop
nop
add $56695, %rsi
vmovups (%rcx), %ymm4
vextracti128 $1, %ymm4, %xmm4
vpextrq $0, %xmm4, %r10
cmp %r15, %r15
lea addresses_A_ht+0x3036, %rsi
lea addresses_WC_ht+0x1a66a, %rdi
nop
nop
and $13019, %r8
mov $45, %rcx
rep movsq
nop
nop
nop
nop
nop
dec %r10
lea addresses_WC_ht+0x1ef06, %r10
nop
nop
add $52620, %rsi
mov (%r10), %di
nop
nop
add $23670, %r10
lea addresses_A_ht+0xe126, %rbp
nop
xor %rcx, %rcx
movups (%rbp), %xmm3
vpextrq $1, %xmm3, %rdi
nop
nop
nop
nop
and %r10, %r10
lea addresses_D_ht+0x7e16, %rsi
lea addresses_A_ht+0x122b6, %rdi
clflush (%rsi)
nop
nop
nop
nop
cmp $19525, %r14
mov $120, %rcx
rep movsw
nop
nop
nop
xor $42205, %r15
lea addresses_UC_ht+0x7db6, %rsi
lea addresses_UC_ht+0xaae, %rdi
nop
nop
nop
nop
nop
sub %r15, %r15
mov $28, %rcx
rep movsl
nop
nop
nop
nop
nop
and $21336, %r10
pop %rsi
pop %rdi
pop %rcx
pop %rbp
pop %r8
pop %r15
pop %r14
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r13
push %r14
push %r8
push %rbx
push %rcx
// Store
lea addresses_D+0x1bee6, %r14
nop
nop
nop
add %r13, %r13
mov $0x5152535455565758, %r10
movq %r10, %xmm6
vmovups %ymm6, (%r14)
nop
nop
nop
nop
and %rcx, %rcx
// Load
lea addresses_normal+0x1827e, %rbx
dec %r8
mov (%rbx), %r13d
nop
nop
nop
nop
add $29560, %rbx
// Load
lea addresses_WT+0xfdb6, %r11
nop
nop
nop
nop
cmp %r8, %r8
movups (%r11), %xmm6
vpextrq $1, %xmm6, %rcx
nop
and %r11, %r11
// Store
lea addresses_UC+0x1992a, %r14
nop
nop
nop
nop
nop
and %r8, %r8
mov $0x5152535455565758, %rcx
movq %rcx, %xmm7
movups %xmm7, (%r14)
nop
nop
nop
nop
cmp $15166, %rcx
// Store
lea addresses_WT+0x6a06, %r14
nop
nop
nop
nop
and %r8, %r8
movw $0x5152, (%r14)
xor %rbx, %rbx
// Faulty Load
lea addresses_WT+0xfdb6, %r14
xor %rbx, %rbx
movaps (%r14), %xmm6
vpextrq $0, %xmm6, %r11
lea oracles, %r14
and $0xff, %r11
shlq $12, %r11
mov (%r14,%r11,1), %r11
pop %rcx
pop %rbx
pop %r8
pop %r14
pop %r13
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'congruent': 0, 'AVXalign': True, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 4, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_D'}}
{'src': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_normal'}, 'OP': 'LOAD'}
{'src': {'congruent': 0, 'AVXalign': False, 'same': True, 'size': 16, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'congruent': 1, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_UC'}}
{'OP': 'STOR', 'dst': {'congruent': 3, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_WT'}}
[Faulty Load]
{'src': {'congruent': 0, 'AVXalign': True, 'same': True, 'size': 16, 'NT': False, 'type': 'addresses_WT'}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'congruent': 1, 'AVXalign': False, 'same': False, 'size': 1, 'NT': False, 'type': 'addresses_UC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 5, 'same': False, 'type': 'addresses_WC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 11, 'same': False, 'type': 'addresses_UC_ht'}}
{'src': {'congruent': 5, 'AVXalign': True, 'same': False, 'size': 4, 'NT': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 2, 'AVXalign': False, 'same': False, 'size': 32, 'NT': False, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 7, 'same': False, 'type': 'addresses_A_ht'}, 'OP': 'REPM', 'dst': {'congruent': 0, 'same': False, 'type': 'addresses_WC_ht'}}
{'src': {'congruent': 0, 'AVXalign': False, 'same': False, 'size': 2, 'NT': False, 'type': 'addresses_WC_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 4, 'AVXalign': False, 'same': False, 'size': 16, 'NT': False, 'type': 'addresses_A_ht'}, 'OP': 'LOAD'}
{'src': {'congruent': 5, 'same': False, 'type': 'addresses_D_ht'}, 'OP': 'REPM', 'dst': {'congruent': 8, 'same': False, 'type': 'addresses_A_ht'}}
{'src': {'congruent': 11, 'same': True, 'type': 'addresses_UC_ht'}, 'OP': 'REPM', 'dst': {'congruent': 2, 'same': False, 'type': 'addresses_UC_ht'}}
{'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
*/
| 31.915966 | 2,999 | 0.653633 |
71776029773be2b188549e9b0e5347e811d8a793 | 250 | asm | Assembly | libsrc/_DEVELOPMENT/adt/wa_priority_queue/c/sccz80/wa_priority_queue_size.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/adt/wa_priority_queue/c/sccz80/wa_priority_queue_size.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null | libsrc/_DEVELOPMENT/adt/wa_priority_queue/c/sccz80/wa_priority_queue_size.asm | meesokim/z88dk | 5763c7778f19a71d936b3200374059d267066bb2 | [
"ClArtistic"
] | null | null | null |
; size_t wa_priority_queue_size(wa_priority_queue_t *q)
SECTION code_adt_wa_priority_queue
PUBLIC wa_priority_queue_size
defc wa_priority_queue_size = asm_wa_priority_queue_size
INCLUDE "adt/wa_priority_queue/z80/asm_wa_priority_queue_size.asm"
| 22.727273 | 66 | 0.88 |
52c49da877f70a3f42134ee4a4c36a3fe58c181c | 16 | asm | Assembly | tests/data_unsized/1.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 414 | 2016-10-14T22:39:20.000Z | 2022-03-30T07:52:44.000Z | tests/data_unsized/1.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 100 | 2018-03-22T16:12:24.000Z | 2022-03-26T09:19:23.000Z | tests/data_unsized/1.asm | NullMember/customasm | 6e34d6432583a41278e6b3596f1817ae82149531 | [
"Apache-2.0"
] | 47 | 2017-06-29T15:12:13.000Z | 2022-03-10T04:50:51.000Z | #d 0x00 ; = 0x00 | 16 | 16 | 0.5625 |
2e27aca3b60b996bfd92f16ee9cf886580ef0fb7 | 6,065 | asm | Assembly | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1044.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 9 | 2020-08-13T19:41:58.000Z | 2022-03-30T12:22:51.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1044.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 1 | 2021-04-29T06:29:35.000Z | 2021-05-13T21:02:30.000Z | Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1044.asm | ljhsiun2/medusa | 67d769b8a2fb42c538f10287abaf0e6dbb463f0c | [
"MIT"
] | 3 | 2020-07-14T17:07:07.000Z | 2022-03-21T01:12:22.000Z | .global s_prepare_buffers
s_prepare_buffers:
push %r11
push %r12
push %r8
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_A_ht+0x4f01, %rsi
lea addresses_WC_ht+0xc441, %rdi
nop
nop
nop
nop
xor $15309, %r8
mov $27, %rcx
rep movsb
xor $63100, %r11
lea addresses_UC_ht+0x11421, %r12
nop
sub $49042, %r8
movl $0x61626364, (%r12)
nop
nop
nop
nop
nop
xor $7794, %rdi
lea addresses_A_ht+0x148c1, %r8
nop
nop
nop
cmp $43858, %r11
movw $0x6162, (%r8)
nop
nop
add %rcx, %rcx
lea addresses_UC_ht+0x1a681, %r12
clflush (%r12)
nop
nop
nop
sub $48319, %rdx
movw $0x6162, (%r12)
nop
nop
nop
nop
dec %r12
lea addresses_normal_ht+0x171a9, %rcx
nop
nop
sub %rsi, %rsi
movb $0x61, (%rcx)
nop
nop
nop
nop
nop
cmp %r11, %r11
lea addresses_A_ht+0x10001, %rsi
lea addresses_D_ht+0xc4cd, %rdi
clflush (%rdi)
nop
cmp %r11, %r11
mov $77, %rcx
rep movsl
cmp $9160, %rcx
lea addresses_D_ht+0x12681, %rdx
nop
inc %r11
mov (%rdx), %r8
nop
nop
nop
nop
nop
sub $16907, %r11
lea addresses_normal_ht+0x1458b, %rcx
nop
nop
nop
inc %r12
mov (%rcx), %r8d
nop
nop
nop
nop
nop
xor $8505, %r8
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %r8
pop %r12
pop %r11
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r14
push %r8
push %r9
push %rax
push %rbp
push %rbx
// Store
lea addresses_UC+0x581, %r10
clflush (%r10)
nop
nop
inc %rbp
movb $0x51, (%r10)
nop
nop
xor %rax, %rax
// Faulty Load
lea addresses_A+0x6481, %rbx
nop
nop
nop
nop
nop
dec %r9
mov (%rbx), %r8d
lea oracles, %rbp
and $0xff, %r8
shlq $12, %r8
mov (%rbp,%r8,1), %r8
pop %rbx
pop %rbp
pop %rax
pop %r9
pop %r8
pop %r14
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_A', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 7, 'NT': False, 'type': 'addresses_UC', 'size': 1, 'AVXalign': False}}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_A', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'src': {'type': 'addresses_A_ht', 'congruent': 7, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_WC_ht', 'congruent': 6, 'same': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 4, 'NT': False, 'type': 'addresses_UC_ht', 'size': 4, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_A_ht', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 6, 'NT': False, 'type': 'addresses_UC_ht', 'size': 2, 'AVXalign': False}}
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_normal_ht', 'size': 1, 'AVXalign': True}}
{'src': {'type': 'addresses_A_ht', 'congruent': 4, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_D_ht', 'congruent': 2, 'same': False}}
{'src': {'same': False, 'congruent': 9, 'NT': False, 'type': 'addresses_D_ht', 'size': 8, 'AVXalign': False}, 'OP': 'LOAD'}
{'src': {'same': False, 'congruent': 1, 'NT': False, 'type': 'addresses_normal_ht', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
{'35': 21829}
35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35 35
*/
| 37.208589 | 2,999 | 0.656224 |
df4f760211e2b7b4326919a027ebdccc28ae95c7 | 1,672 | asm | Assembly | programs/oeis/262/A262997.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/262/A262997.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/262/A262997.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A262997: a(n+3) = a(n) + 24*n + 40, a(0)=0, a(1)=5, a(2)=19.
; 0,5,19,40,69,107,152,205,267,336,413,499,592,693,803,920,1045,1179,1320,1469,1627,1792,1965,2147,2336,2533,2739,2952,3173,3403,3640,3885,4139,4400,4669,4947,5232,5525,5827,6136,6453,6779,7112,7453,7803,8160,8525,8899,9280,9669,10067,10472,10885,11307,11736,12173,12619,13072,13533,14003,14480,14965,15459,15960,16469,16987,17512,18045,18587,19136,19693,20259,20832,21413,22003,22600,23205,23819,24440,25069,25707,26352,27005,27667,28336,29013,29699,30392,31093,31803,32520,33245,33979,34720,35469,36227,36992,37765,38547,39336,40133,40939,41752,42573,43403,44240,45085,45939,46800,47669,48547,49432,50325,51227,52136,53053,53979,54912,55853,56803,57760,58725,59699,60680,61669,62667,63672,64685,65707,66736,67773,68819,69872,70933,72003,73080,74165,75259,76360,77469,78587,79712,80845,81987,83136,84293,85459,86632,87813,89003,90200,91405,92619,93840,95069,96307,97552,98805,100067,101336,102613,103899,105192,106493,107803,109120,110445,111779,113120,114469,115827,117192,118565,119947,121336,122733,124139,125552,126973,128403,129840,131285,132739,134200,135669,137147,138632,140125,141627,143136,144653,146179,147712,149253,150803,152360,153925,155499,157080,158669,160267,161872,163485,165107,166736,168373,170019,171672,173333,175003,176680,178365,180059,181760,183469,185187,186912,188645,190387,192136,193893,195659,197432,199213,201003,202800,204605,206419,208240,210069,211907,213752,215605,217467,219336,221213,223099,224992,226893,228803,230720,232645,234579,236520,238469,240427,242392,244365,246347,248336
mov $1,$0
add $1,1
div $1,3
add $1,$0
mov $3,$0
mul $3,$0
mov $2,$3
mul $2,4
add $1,$2
| 128.615385 | 1,520 | 0.802033 |
6e7732a171f371948b5cd2e9ef60bc833126b395 | 22,224 | asm | Assembly | ioq3/build/release-js-js/baseq3/ui/ui_setup.asm | RawTechnique/quake-port | 2e7c02095f0207831a6026ec23b1c1d75c24f98d | [
"MIT"
] | 1 | 2021-12-31T10:26:58.000Z | 2021-12-31T10:26:58.000Z | ioq3/build/release-js-js/baseq3/ui/ui_setup.asm | unfriendly/quake-port | 2e7c02095f0207831a6026ec23b1c1d75c24f98d | [
"MIT"
] | 28 | 2019-03-05T20:45:07.000Z | 2019-03-05T20:45:57.000Z | ioq3/build/release-js-js/baseq3/ui/ui_setup.asm | unfriendly/quake-port | 2e7c02095f0207831a6026ec23b1c1d75c24f98d | [
"MIT"
] | null | null | null | code
proc Setup_ResetDefaults_Action 0 8
ADDRFP4 0
INDIRI4
CNSTI4 0
NEI4 $70
ADDRGP4 $69
JUMPV
LABELV $70
CNSTI4 2
ARGI4
ADDRGP4 $72
ARGP4
ADDRGP4 trap_Cmd_ExecuteText
CALLV
pop
CNSTI4 2
ARGI4
ADDRGP4 $73
ARGP4
ADDRGP4 trap_Cmd_ExecuteText
CALLV
pop
CNSTI4 2
ARGI4
ADDRGP4 $74
ARGP4
ADDRGP4 trap_Cmd_ExecuteText
CALLV
pop
LABELV $69
endproc Setup_ResetDefaults_Action 0 8
proc Setup_ResetDefaults_Draw 0 20
CNSTI4 320
ARGI4
CNSTI4 356
ARGI4
ADDRGP4 $76
ARGP4
CNSTI4 17
ARGI4
ADDRGP4 color_yellow
ARGP4
ADDRGP4 UI_DrawProportionalString
CALLV
pop
CNSTI4 320
ARGI4
CNSTI4 383
ARGI4
ADDRGP4 $77
ARGP4
CNSTI4 17
ARGI4
ADDRGP4 color_yellow
ARGP4
ADDRGP4 UI_DrawProportionalString
CALLV
pop
LABELV $75
endproc Setup_ResetDefaults_Draw 0 20
proc UI_SetupMenu_Event 8 12
ADDRFP4 4
INDIRI4
CNSTI4 3
EQI4 $79
ADDRGP4 $78
JUMPV
LABELV $79
ADDRLP4 0
ADDRFP4 0
INDIRP4
CNSTI4 8
ADDP4
INDIRI4
ASGNI4
ADDRLP4 0
INDIRI4
CNSTI4 10
LTI4 $81
ADDRLP4 0
INDIRI4
CNSTI4 18
GTI4 $81
ADDRLP4 0
INDIRI4
CNSTI4 2
LSHI4
ADDRGP4 $92-40
ADDP4
INDIRP4
JUMPV
lit
align 4
LABELV $92
address $84
address $85
address $86
address $87
address $88
address $81
address $81
address $89
address $91
code
LABELV $84
ADDRGP4 UI_PlayerSettingsMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $85
ADDRGP4 UI_ControlsMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $86
ADDRGP4 UI_GraphicsOptionsMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $87
ADDRGP4 UI_PreferencesMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $88
ADDRGP4 UI_CDKeyMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $89
ADDRGP4 $90
ARGP4
ADDRGP4 Setup_ResetDefaults_Draw
ARGP4
ADDRGP4 Setup_ResetDefaults_Action
ARGP4
ADDRGP4 UI_ConfirmMenu
CALLV
pop
ADDRGP4 $82
JUMPV
LABELV $91
ADDRGP4 UI_PopMenu
CALLV
pop
LABELV $81
LABELV $82
LABELV $78
endproc UI_SetupMenu_Event 8 12
proc UI_SetupMenu_Init 12 12
ADDRGP4 UI_SetupMenu_Cache
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
CNSTI4 0
ARGI4
CNSTU4 1056
ARGU4
ADDRGP4 qk_memset
CALLP4
pop
ADDRGP4 setupMenuInfo+276
CNSTI4 1
ASGNI4
ADDRGP4 setupMenuInfo+280
CNSTI4 1
ASGNI4
ADDRGP4 setupMenuInfo+288
CNSTI4 10
ASGNI4
ADDRGP4 setupMenuInfo+288+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+288+16
CNSTI4 16
ASGNI4
ADDRGP4 setupMenuInfo+288+60
ADDRGP4 $104
ASGNP4
ADDRGP4 setupMenuInfo+288+68
ADDRGP4 color_white
ASGNP4
ADDRGP4 setupMenuInfo+288+64
CNSTI4 1
ASGNI4
ADDRGP4 setupMenuInfo+360
CNSTI4 6
ASGNI4
ADDRGP4 setupMenuInfo+360+4
ADDRGP4 $112
ASGNP4
ADDRGP4 setupMenuInfo+360+44
CNSTU4 16384
ASGNU4
ADDRGP4 setupMenuInfo+360+12
CNSTI4 0
ASGNI4
ADDRGP4 setupMenuInfo+360+16
CNSTI4 78
ASGNI4
ADDRGP4 setupMenuInfo+360+76
CNSTI4 256
ASGNI4
ADDRGP4 setupMenuInfo+360+80
CNSTI4 329
ASGNI4
ADDRGP4 setupMenuInfo+448
CNSTI4 6
ASGNI4
ADDRGP4 setupMenuInfo+448+4
ADDRGP4 $126
ASGNP4
ADDRGP4 setupMenuInfo+448+44
CNSTU4 16384
ASGNU4
ADDRGP4 setupMenuInfo+448+12
CNSTI4 376
ASGNI4
ADDRGP4 setupMenuInfo+448+16
CNSTI4 76
ASGNI4
ADDRGP4 setupMenuInfo+448+76
CNSTI4 256
ASGNI4
ADDRGP4 setupMenuInfo+448+80
CNSTI4 334
ASGNI4
ADDRLP4 0
CNSTI4 134
ASGNI4
ADDRGP4 setupMenuInfo+536
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+536+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+536+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+536+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+536+8
CNSTI4 10
ASGNI4
ADDRGP4 setupMenuInfo+536+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+536+60
ADDRGP4 $150
ASGNP4
ADDRGP4 setupMenuInfo+536+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+536+64
CNSTI4 1
ASGNI4
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 34
ADDI4
ASGNI4
ADDRGP4 setupMenuInfo+608
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+608+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+608+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+608+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+608+8
CNSTI4 11
ASGNI4
ADDRGP4 setupMenuInfo+608+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+608+60
ADDRGP4 $168
ASGNP4
ADDRGP4 setupMenuInfo+608+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+608+64
CNSTI4 1
ASGNI4
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 34
ADDI4
ASGNI4
ADDRGP4 setupMenuInfo+680
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+680+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+680+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+680+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+680+8
CNSTI4 12
ASGNI4
ADDRGP4 setupMenuInfo+680+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+680+60
ADDRGP4 $186
ASGNP4
ADDRGP4 setupMenuInfo+680+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+680+64
CNSTI4 1
ASGNI4
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 34
ADDI4
ASGNI4
ADDRGP4 setupMenuInfo+752
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+752+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+752+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+752+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+752+8
CNSTI4 13
ASGNI4
ADDRGP4 setupMenuInfo+752+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+752+60
ADDRGP4 $204
ASGNP4
ADDRGP4 setupMenuInfo+752+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+752+64
CNSTI4 1
ASGNI4
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 34
ADDI4
ASGNI4
ADDRGP4 setupMenuInfo+824
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+824+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+824+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+824+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+824+8
CNSTI4 14
ASGNI4
ADDRGP4 setupMenuInfo+824+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+824+60
ADDRGP4 $222
ASGNP4
ADDRGP4 setupMenuInfo+824+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+824+64
CNSTI4 1
ASGNI4
ADDRGP4 $229
ARGP4
ADDRLP4 4
ADDRGP4 trap_Cvar_VariableValue
CALLF4
ASGNF4
ADDRLP4 4
INDIRF4
CNSTF4 0
NEF4 $227
ADDRLP4 0
ADDRLP4 0
INDIRI4
CNSTI4 34
ADDI4
ASGNI4
ADDRGP4 setupMenuInfo+896
CNSTI4 9
ASGNI4
ADDRGP4 setupMenuInfo+896+44
CNSTU4 264
ASGNU4
ADDRGP4 setupMenuInfo+896+12
CNSTI4 320
ASGNI4
ADDRGP4 setupMenuInfo+896+16
ADDRLP4 0
INDIRI4
ASGNI4
ADDRGP4 setupMenuInfo+896+8
CNSTI4 17
ASGNI4
ADDRGP4 setupMenuInfo+896+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+896+60
ADDRGP4 $243
ASGNP4
ADDRGP4 setupMenuInfo+896+68
ADDRGP4 color_red
ASGNP4
ADDRGP4 setupMenuInfo+896+64
CNSTI4 1
ASGNI4
LABELV $227
ADDRGP4 setupMenuInfo+968
CNSTI4 6
ASGNI4
ADDRGP4 setupMenuInfo+968+4
ADDRGP4 $251
ASGNP4
ADDRGP4 setupMenuInfo+968+44
CNSTU4 260
ASGNU4
ADDRGP4 setupMenuInfo+968+8
CNSTI4 18
ASGNI4
ADDRGP4 setupMenuInfo+968+48
ADDRGP4 UI_SetupMenu_Event
ASGNP4
ADDRGP4 setupMenuInfo+968+12
CNSTI4 0
ASGNI4
ADDRGP4 setupMenuInfo+968+16
CNSTI4 416
ASGNI4
ADDRGP4 setupMenuInfo+968+76
CNSTI4 128
ASGNI4
ADDRGP4 setupMenuInfo+968+80
CNSTI4 64
ASGNI4
ADDRGP4 setupMenuInfo+968+60
ADDRGP4 $268
ASGNP4
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+288
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+360
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+448
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+536
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+608
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+680
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+752
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+824
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
ADDRGP4 $229
ARGP4
ADDRLP4 8
ADDRGP4 trap_Cvar_VariableValue
CALLF4
ASGNF4
ADDRLP4 8
INDIRF4
CNSTF4 0
NEF4 $277
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+896
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
LABELV $277
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 setupMenuInfo+968
ARGP4
ADDRGP4 Menu_AddItem
CALLV
pop
LABELV $94
endproc UI_SetupMenu_Init 12 12
export UI_SetupMenu_Cache
proc UI_SetupMenu_Cache 0 4
ADDRGP4 $251
ARGP4
ADDRGP4 trap_R_RegisterShaderNoMip
CALLI4
pop
ADDRGP4 $268
ARGP4
ADDRGP4 trap_R_RegisterShaderNoMip
CALLI4
pop
ADDRGP4 $112
ARGP4
ADDRGP4 trap_R_RegisterShaderNoMip
CALLI4
pop
ADDRGP4 $126
ARGP4
ADDRGP4 trap_R_RegisterShaderNoMip
CALLI4
pop
LABELV $281
endproc UI_SetupMenu_Cache 0 4
export UI_SetupMenu
proc UI_SetupMenu 0 4
ADDRGP4 UI_SetupMenu_Init
CALLV
pop
ADDRGP4 setupMenuInfo
ARGP4
ADDRGP4 UI_PushMenu
CALLV
pop
LABELV $282
endproc UI_SetupMenu 0 4
bss
align 4
LABELV setupMenuInfo
skip 1056
import UI_RankStatusMenu
import RankStatus_Cache
import UI_SignupMenu
import Signup_Cache
import UI_LoginMenu
import Login_Cache
import UI_RankingsMenu
import Rankings_Cache
import Rankings_DrawPassword
import Rankings_DrawName
import Rankings_DrawText
import UI_InitGameinfo
import UI_SPUnlockMedals_f
import UI_SPUnlock_f
import UI_GetAwardLevel
import UI_LogAwardData
import UI_NewGame
import UI_GetCurrentGame
import UI_CanShowTierVideo
import UI_ShowTierVideo
import UI_TierCompleted
import UI_SetBestScore
import UI_GetBestScore
import UI_GetNumBots
import UI_GetBotInfoByName
import UI_GetBotInfoByNumber
import UI_GetNumSPTiers
import UI_GetNumSPArenas
import UI_GetNumArenas
import UI_GetSpecialArenaInfo
import UI_GetArenaInfoByMap
import UI_GetArenaInfoByNumber
import UI_NetworkOptionsMenu
import UI_NetworkOptionsMenu_Cache
import UI_SoundOptionsMenu
import UI_SoundOptionsMenu_Cache
import UI_DisplayOptionsMenu
import UI_DisplayOptionsMenu_Cache
import UI_SaveConfigMenu
import UI_SaveConfigMenu_Cache
import UI_LoadConfigMenu
import UI_LoadConfig_Cache
import UI_TeamOrdersMenu_Cache
import UI_TeamOrdersMenu_f
import UI_TeamOrdersMenu
import UI_RemoveBotsMenu
import UI_RemoveBots_Cache
import UI_AddBotsMenu
import UI_AddBots_Cache
import trap_SetPbClStatus
import trap_VerifyCDKey
import trap_SetCDKey
import trap_GetCDKey
import trap_MemoryRemaining
import trap_LAN_GetPingInfo
import trap_LAN_GetPing
import trap_LAN_ClearPing
import trap_LAN_ServerStatus
import trap_LAN_GetPingQueueCount
import trap_LAN_GetServerInfo
import trap_LAN_GetServerAddressString
import trap_LAN_GetServerCount
import trap_GetConfigString
import trap_GetGlconfig
import trap_GetClientState
import trap_GetClipboardData
import trap_Key_SetCatcher
import trap_Key_GetCatcher
import trap_Key_ClearStates
import trap_Key_SetOverstrikeMode
import trap_Key_GetOverstrikeMode
import trap_Key_IsDown
import trap_Key_SetBinding
import trap_Key_GetBindingBuf
import trap_Key_KeynumToStringBuf
import trap_S_RegisterSound
import trap_S_StartLocalSound
import trap_CM_LerpTag
import trap_UpdateScreen
import trap_R_DrawStretchPic
import trap_R_SetColor
import trap_R_RenderScene
import trap_R_AddLightToScene
import trap_R_AddPolyToScene
import trap_R_AddRefEntityToScene
import trap_R_ClearScene
import trap_R_RegisterShaderNoMip
import trap_R_RegisterSkin
import trap_R_RegisterModel
import trap_FS_Seek
import trap_FS_GetFileList
import trap_FS_FCloseFile
import trap_FS_Write
import trap_FS_Read
import trap_FS_FOpenFile
import trap_Cmd_ExecuteText
import trap_Argv
import trap_Argc
import trap_Cvar_InfoStringBuffer
import trap_Cvar_Create
import trap_Cvar_Reset
import trap_Cvar_SetValue
import trap_Cvar_VariableStringBuffer
import trap_Cvar_VariableValue
import trap_Cvar_Set
import trap_Cvar_Update
import trap_Cvar_Register
import trap_Milliseconds
import trap_Error
import trap_Print
import UI_SPSkillMenu_Cache
import UI_SPSkillMenu
import UI_SPPostgameMenu_f
import UI_SPPostgameMenu_Cache
import UI_SPArena_Start
import UI_SPLevelMenu_ReInit
import UI_SPLevelMenu_f
import UI_SPLevelMenu
import UI_SPLevelMenu_Cache
import uis
import m_entersound
import UI_StartDemoLoop
import UI_Cvar_VariableString
import UI_Argv
import UI_ForceMenuOff
import UI_PopMenu
import UI_PushMenu
import UI_SetActiveMenu
import UI_IsFullscreen
import UI_DrawTextBox
import UI_AdjustFrom640
import UI_CursorInRect
import UI_DrawChar
import UI_DrawString
import UI_ProportionalStringWidth
import UI_DrawProportionalString_AutoWrapped
import UI_DrawProportionalString
import UI_ProportionalSizeScale
import UI_DrawBannerString
import UI_LerpColor
import UI_SetColor
import UI_UpdateScreen
import UI_DrawRect
import UI_FillRect
import UI_DrawHandlePic
import UI_DrawNamedPic
import UI_ClampCvar
import UI_ConsoleCommand
import UI_Refresh
import UI_MouseEvent
import UI_KeyEvent
import UI_Shutdown
import UI_Init
import UI_RegisterClientModelname
import UI_PlayerInfo_SetInfo
import UI_PlayerInfo_SetModel
import UI_DrawPlayer
import DriverInfo_Cache
import GraphicsOptions_Cache
import UI_GraphicsOptionsMenu
import ServerInfo_Cache
import UI_ServerInfoMenu
import UI_BotSelectMenu_Cache
import UI_BotSelectMenu
import ServerOptions_Cache
import StartServer_Cache
import UI_StartServerMenu
import ArenaServers_Cache
import UI_ArenaServersMenu
import SpecifyServer_Cache
import UI_SpecifyServerMenu
import SpecifyLeague_Cache
import UI_SpecifyLeagueMenu
import Preferences_Cache
import UI_PreferencesMenu
import PlayerSettings_Cache
import UI_PlayerSettingsMenu
import PlayerModel_Cache
import UI_PlayerModelMenu
import UI_CDKeyMenu_f
import UI_CDKeyMenu_Cache
import UI_CDKeyMenu
import UI_ModsMenu_Cache
import UI_ModsMenu
import UI_CinematicsMenu_Cache
import UI_CinematicsMenu_f
import UI_CinematicsMenu
import Demos_Cache
import UI_DemosMenu
import Controls_Cache
import UI_ControlsMenu
import UI_DrawConnectScreen
import TeamMain_Cache
import UI_TeamMainMenu
import UI_Message
import UI_ConfirmMenu_Style
import UI_ConfirmMenu
import ConfirmMenu_Cache
import UI_InGameMenu
import InGame_Cache
import UI_CreditMenu
import UI_UpdateCvars
import UI_RegisterCvars
import UI_MainMenu
import MainMenu_Cache
import MenuField_Key
import MenuField_Draw
import MenuField_Init
import MField_Draw
import MField_CharEvent
import MField_KeyDownEvent
import MField_Clear
import ui_medalSounds
import ui_medalPicNames
import ui_medalNames
import text_color_highlight
import text_color_normal
import text_color_disabled
import listbar_color
import list_color
import name_color
import color_dim
import color_red
import color_orange
import color_blue
import color_yellow
import color_white
import color_black
import menu_dim_color
import menu_black_color
import menu_red_color
import menu_highlight_color
import menu_dark_color
import menu_grayed_color
import menu_text_color
import weaponChangeSound
import menu_null_sound
import menu_buzz_sound
import menu_out_sound
import menu_move_sound
import menu_in_sound
import ScrollList_Key
import ScrollList_Draw
import Bitmap_Draw
import Bitmap_Init
import Menu_DefaultKey
import Menu_SetCursorToItem
import Menu_SetCursor
import Menu_ActivateItem
import Menu_ItemAtCursor
import Menu_Draw
import Menu_AdjustCursor
import Menu_AddItem
import Menu_Focus
import Menu_Cache
import ui_ioq3
import ui_cdkeychecked
import ui_cdkey
import ui_server16
import ui_server15
import ui_server14
import ui_server13
import ui_server12
import ui_server11
import ui_server10
import ui_server9
import ui_server8
import ui_server7
import ui_server6
import ui_server5
import ui_server4
import ui_server3
import ui_server2
import ui_server1
import ui_marks
import ui_drawCrosshairNames
import ui_drawCrosshair
import ui_brassTime
import ui_browserShowEmpty
import ui_browserShowFull
import ui_browserSortKey
import ui_browserGameType
import ui_browserMaster
import ui_spSelection
import ui_spSkill
import ui_spVideos
import ui_spAwards
import ui_spScores5
import ui_spScores4
import ui_spScores3
import ui_spScores2
import ui_spScores1
import ui_botsFile
import ui_arenasFile
import ui_ctf_friendly
import ui_ctf_timelimit
import ui_ctf_capturelimit
import ui_team_friendly
import ui_team_timelimit
import ui_team_fraglimit
import ui_tourney_timelimit
import ui_tourney_fraglimit
import ui_ffa_timelimit
import ui_ffa_fraglimit
import BG_PlayerTouchesItem
import BG_PlayerStateToEntityStateExtraPolate
import BG_PlayerStateToEntityState
import BG_TouchJumpPad
import BG_AddPredictableEventToPlayerstate
import BG_EvaluateTrajectoryDelta
import BG_EvaluateTrajectory
import BG_CanItemBeGrabbed
import BG_FindItemForHoldable
import BG_FindItemForPowerup
import BG_FindItemForWeapon
import BG_FindItem
import bg_numItems
import bg_itemlist
import Pmove
import PM_UpdateViewAngles
import Com_Printf
import Com_Error
import Info_NextPair
import Info_Validate
import Info_SetValueForKey_Big
import Info_SetValueForKey
import Info_RemoveKey_Big
import Info_RemoveKey
import Info_ValueForKey
import Com_TruncateLongString
import va
import Q_CountChar
import Q_CleanStr
import Q_PrintStrlen
import Q_strcat
import Q_strncpyz
import Q_stristr
import Q_strupr
import Q_strlwr
import Q_stricmpn
import Q_strncmp
import Q_stricmp
import Q_isintegral
import Q_isanumber
import Q_isalpha
import Q_isupper
import Q_islower
import Q_isprint
import Com_RandomBytes
import Com_SkipCharset
import Com_SkipTokens
import Com_sprintf
import Com_HexStrToInt
import Parse3DMatrix
import Parse2DMatrix
import Parse1DMatrix
import SkipRestOfLine
import SkipBracedSection
import COM_MatchToken
import COM_ParseWarning
import COM_ParseError
import COM_Compress
import COM_ParseExt
import COM_Parse
import COM_GetCurrentParseLine
import COM_BeginParseSession
import COM_DefaultExtension
import COM_CompareExtension
import COM_StripExtension
import COM_GetExtension
import COM_SkipPath
import Com_Clamp
import PerpendicularVector
import AngleVectors
import MatrixMultiply
import MakeNormalVectors
import RotateAroundDirection
import RotatePointAroundVector
import ProjectPointOnPlane
import PlaneFromPoints
import AngleDelta
import AngleNormalize180
import AngleNormalize360
import AnglesSubtract
import AngleSubtract
import LerpAngle
import AngleMod
import BoundsIntersectPoint
import BoundsIntersectSphere
import BoundsIntersect
import BoxOnPlaneSide
import SetPlaneSignbits
import AxisCopy
import AxisClear
import AnglesToAxis
import vectoangles
import Q_crandom
import Q_random
import Q_rand
import Q_acos
import Q_log2
import VectorRotate
import Vector4Scale
import VectorNormalize2
import VectorNormalize
import CrossProduct
import VectorInverse
import VectorNormalizeFast
import DistanceSquared
import Distance
import VectorLengthSquared
import VectorLength
import VectorCompare
import AddPointToBounds
import ClearBounds
import RadiusFromBounds
import NormalizeColor
import ColorBytes4
import ColorBytes3
import _VectorMA
import _VectorScale
import _VectorCopy
import _VectorAdd
import _VectorSubtract
import _DotProduct
import ByteToDir
import DirToByte
import ClampShort
import ClampChar
import Q_rsqrt
import Q_fabs
import Q_isnan
import axisDefault
import vec3_origin
import g_color_table
import colorDkGrey
import colorMdGrey
import colorLtGrey
import colorWhite
import colorCyan
import colorMagenta
import colorYellow
import colorBlue
import colorGreen
import colorRed
import colorBlack
import bytedirs
import Hunk_AllocDebug
import FloatSwap
import LongSwap
import ShortSwap
import CopyLongSwap
import CopyShortSwap
import qk_acos
import qk_fabs
import qk_abs
import qk_tan
import qk_atan2
import qk_cos
import qk_sin
import qk_sqrt
import qk_floor
import qk_ceil
import qk_memcpy
import qk_memset
import qk_memmove
import qk_sscanf
import qk_vsnprintf
import qk_strtol
import qk_atoi
import qk_strtod
import qk_atof
import qk_toupper
import qk_tolower
import qk_strncpy
import qk_strstr
import qk_strrchr
import qk_strchr
import qk_strcmp
import qk_strcpy
import qk_strcat
import qk_strlen
import qk_rand
import qk_srand
import qk_qsort
lit
align 1
LABELV $268
byte 1 109
byte 1 101
byte 1 110
byte 1 117
byte 1 47
byte 1 97
byte 1 114
byte 1 116
byte 1 47
byte 1 98
byte 1 97
byte 1 99
byte 1 107
byte 1 95
byte 1 49
byte 1 0
align 1
LABELV $251
byte 1 109
byte 1 101
byte 1 110
byte 1 117
byte 1 47
byte 1 97
byte 1 114
byte 1 116
byte 1 47
byte 1 98
byte 1 97
byte 1 99
byte 1 107
byte 1 95
byte 1 48
byte 1 0
align 1
LABELV $243
byte 1 68
byte 1 69
byte 1 70
byte 1 65
byte 1 85
byte 1 76
byte 1 84
byte 1 83
byte 1 0
align 1
LABELV $229
byte 1 99
byte 1 108
byte 1 95
byte 1 112
byte 1 97
byte 1 117
byte 1 115
byte 1 101
byte 1 100
byte 1 0
align 1
LABELV $222
byte 1 67
byte 1 68
byte 1 32
byte 1 75
byte 1 101
byte 1 121
byte 1 0
align 1
LABELV $204
byte 1 71
byte 1 65
byte 1 77
byte 1 69
byte 1 32
byte 1 79
byte 1 80
byte 1 84
byte 1 73
byte 1 79
byte 1 78
byte 1 83
byte 1 0
align 1
LABELV $186
byte 1 83
byte 1 89
byte 1 83
byte 1 84
byte 1 69
byte 1 77
byte 1 0
align 1
LABELV $168
byte 1 67
byte 1 79
byte 1 78
byte 1 84
byte 1 82
byte 1 79
byte 1 76
byte 1 83
byte 1 0
align 1
LABELV $150
byte 1 80
byte 1 76
byte 1 65
byte 1 89
byte 1 69
byte 1 82
byte 1 0
align 1
LABELV $126
byte 1 109
byte 1 101
byte 1 110
byte 1 117
byte 1 47
byte 1 97
byte 1 114
byte 1 116
byte 1 47
byte 1 102
byte 1 114
byte 1 97
byte 1 109
byte 1 101
byte 1 49
byte 1 95
byte 1 114
byte 1 0
align 1
LABELV $112
byte 1 109
byte 1 101
byte 1 110
byte 1 117
byte 1 47
byte 1 97
byte 1 114
byte 1 116
byte 1 47
byte 1 102
byte 1 114
byte 1 97
byte 1 109
byte 1 101
byte 1 50
byte 1 95
byte 1 108
byte 1 0
align 1
LABELV $104
byte 1 83
byte 1 69
byte 1 84
byte 1 85
byte 1 80
byte 1 0
align 1
LABELV $90
byte 1 83
byte 1 69
byte 1 84
byte 1 32
byte 1 84
byte 1 79
byte 1 32
byte 1 68
byte 1 69
byte 1 70
byte 1 65
byte 1 85
byte 1 76
byte 1 84
byte 1 83
byte 1 63
byte 1 0
align 1
LABELV $77
byte 1 111
byte 1 112
byte 1 116
byte 1 105
byte 1 111
byte 1 110
byte 1 115
byte 1 32
byte 1 116
byte 1 111
byte 1 32
byte 1 116
byte 1 104
byte 1 101
byte 1 105
byte 1 114
byte 1 32
byte 1 100
byte 1 101
byte 1 102
byte 1 97
byte 1 117
byte 1 108
byte 1 116
byte 1 32
byte 1 118
byte 1 97
byte 1 108
byte 1 117
byte 1 101
byte 1 115
byte 1 46
byte 1 0
align 1
LABELV $76
byte 1 87
byte 1 65
byte 1 82
byte 1 78
byte 1 73
byte 1 78
byte 1 71
byte 1 58
byte 1 32
byte 1 84
byte 1 104
byte 1 105
byte 1 115
byte 1 32
byte 1 119
byte 1 105
byte 1 108
byte 1 108
byte 1 32
byte 1 114
byte 1 101
byte 1 115
byte 1 101
byte 1 116
byte 1 32
byte 1 42
byte 1 65
byte 1 76
byte 1 76
byte 1 42
byte 1 0
align 1
LABELV $74
byte 1 118
byte 1 105
byte 1 100
byte 1 95
byte 1 114
byte 1 101
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 10
byte 1 0
align 1
LABELV $73
byte 1 99
byte 1 118
byte 1 97
byte 1 114
byte 1 95
byte 1 114
byte 1 101
byte 1 115
byte 1 116
byte 1 97
byte 1 114
byte 1 116
byte 1 10
byte 1 0
align 1
LABELV $72
byte 1 101
byte 1 120
byte 1 101
byte 1 99
byte 1 32
byte 1 100
byte 1 101
byte 1 102
byte 1 97
byte 1 117
byte 1 108
byte 1 116
byte 1 46
byte 1 99
byte 1 102
byte 1 103
byte 1 10
byte 1 0
| 16.057803 | 45 | 0.862356 |
4d4ac754d0e32a2344012265ef9718f6335a7964 | 564 | asm | Assembly | SourceCode/abhisheksCodeForFPalindrome.asm | Nuthi-Sriram/Assembly-Level-Code-for-8086 | 616b651c913863d6151ae49f409762fe5d707b74 | [
"MIT"
] | null | null | null | SourceCode/abhisheksCodeForFPalindrome.asm | Nuthi-Sriram/Assembly-Level-Code-for-8086 | 616b651c913863d6151ae49f409762fe5d707b74 | [
"MIT"
] | null | null | null | SourceCode/abhisheksCodeForFPalindrome.asm | Nuthi-Sriram/Assembly-Level-Code-for-8086 | 616b651c913863d6151ae49f409762fe5d707b74 | [
"MIT"
] | null | null | null | ;program to check whether the number entered is palindrome or not
.model small
.stack
.data
pal db "palindrome$"
nopal db "not a palindrome$"
str db 10 ?
.code
.startup
lea dx,str
mov ah,0ah
int 21h
mov ax,0
mov al,str[1]
cbw
add ax,1
mov si,ax
mov bh,2h
div bh
mov cx,0
mov cl,al
mov di,2
loop1:
mov bh,str[si]
cmp bh,str[di]
jne exit1
dec si
inc di
loop loop1
lea dx,pal
mov ah,09h
int 21h
jmp end1
exit1:
lea dx,nopal
mov ah,09h
int 21h
end1:
end
| 12.818182 | 66 | 0.58156 |
c64aaa4d30a34902490fab647a878924842efca4 | 718 | asm | Assembly | oeis/214/A214997.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/214/A214997.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/214/A214997.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A214997: Power ceiling-floor sequence of 2+sqrt(2).
; Submitted by Jamie Morken(l1)
; 4,13,45,153,523,1785,6095,20809,71047,242569,828183,2827593,9654007,32960841,112535351,384219721,1311808183,4478793289,15291556791,52208640585,178251448759,608588513865,2077851157943,7094227604041,24221208100279,82696377193033,282343092571575,963979615900233,3291232278457783,11236969882030665,38365414971207095,130987720120767049,447220050540654007,1526904761921081929,5213178946603019703,17798906262569914953,60769267157073620407,207479256103154651721,708378490098471366071,2418555448187576160841
add $0,2
mov $2,1
lpb $0
sub $0,1
add $1,$4
mul $2,2
mov $3,$2
add $4,$1
add $2,$4
mov $4,$3
lpe
mov $0,$2
div $0,2
| 39.888889 | 500 | 0.814763 |
a8c3442ea117f02c932b045fb430e11e64c59dc7 | 168 | asm | Assembly | libsrc/_DEVELOPMENT/string/c/sdcc_iy/strrstrip_fastcall.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 640 | 2017-01-14T23:33:45.000Z | 2022-03-30T11:28:42.000Z | libsrc/_DEVELOPMENT/string/c/sdcc_iy/strrstrip_fastcall.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 1,600 | 2017-01-15T16:12:02.000Z | 2022-03-31T12:11:12.000Z | libsrc/_DEVELOPMENT/string/c/sdcc_iy/strrstrip_fastcall.asm | jpoikela/z88dk | 7108b2d7e3a98a77de99b30c9a7c9199da9c75cb | [
"ClArtistic"
] | 215 | 2017-01-17T10:43:03.000Z | 2022-03-23T17:25:02.000Z |
; char *strrstrip_fastcall(char *s)
SECTION code_clib
SECTION code_string
PUBLIC _strrstrip_fastcall
EXTERN asm_strrstrip
defc _strrstrip_fastcall = asm_strrstrip
| 14 | 40 | 0.839286 |
816c7429f154b7bab130d04fd76cf985ea788d02 | 2,667 | asm | Assembly | programs/oeis/017/A017283.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/017/A017283.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/017/A017283.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A017283: a(n) = (10*n + 1)^3.
; 1,1331,9261,29791,68921,132651,226981,357911,531441,753571,1030301,1367631,1771561,2248091,2803221,3442951,4173281,5000211,5929741,6967871,8120601,9393931,10793861,12326391,13997521,15813251,17779581,19902511,22188041,24642171,27270901,30080231,33076161,36264691,39651821,43243551,47045881,51064811,55306341,59776471,64481201,69426531,74618461,80062991,85766121,91733851,97972181,104487111,111284641,118370771,125751501,133432831,141420761,149721291,158340421,167284151,176558481,186169411,196122941,206425071,217081801,228099131,239483061,251239591,263374721,275894451,288804781,302111711,315821241,329939371,344472101,359425431,374805361,390617891,406869021,423564751,440711081,458314011,476379541,494913671,513922401,533411731,553387661,573856191,594823321,616295051,638277381,660776311,683797841,707347971,731432701,756058031,781229961,806954491,833237621,860085351,887503681,915498611,944076141,973242271,1003003001,1033364331,1064332261,1095912791,1128111921,1160935651,1194389981,1228480911,1263214441,1298596571,1334633301,1371330631,1408694561,1446731091,1485446221,1524845951,1564936281,1605723211,1647212741,1689410871,1732323601,1775956931,1820316861,1865409391,1911240521,1957816251,2005142581,2053225511,2102071041,2151685171,2202073901,2253243231,2305199161,2357947691,2411494821,2465846551,2521008881,2576987811,2633789341,2691419471,2749884201,2809189531,2869341461,2930345991,2992209121,3054936851,3118535181,3183010111,3248367641,3314613771,3381754501,3449795831,3518743761,3588604291,3659383421,3731087151,3803721481,3877292411,3951805941,4027268071,4103684801,4181062131,4259406061,4338722591,4419017721,4500297451,4582567781,4665834711,4750104241,4835382371,4921675101,5008988431,5097328361,5186700891,5277112021,5368567751,5461074081,5554637011,5649262541,5744956671,5841725401,5939574731,6038510661,6138539191,6239666321,6341898051,6445240381,6549699311,6655280841,6761990971,6869835701,6978821031,7088952961,7200237491,7312680621,7426288351,7541066681,7657021611,7774159141,7892485271,8012006001,8132727331,8254655261,8377795791,8502154921,8627738651,8754552981,8882603911,9011897441,9142439571,9274236301,9407293631,9541617561,9677214091,9814089221,9952248951,10091699281,10232446211,10374495741,10517853871,10662526601,10808519931,10955839861,11104492391,11254483521,11405819251,11558505581,11712548511,11867954041,12024728171,12182876901,12342406231,12503322161,12665630691,12829337821,12994449551,13160971881,13328910811,13498272341,13669062471,13841287201,14014952531,14190064461,14366628991,14544652121,14724139851,14905098181,15087533111,15271450641,15456856771
mul $0,10
add $0,1
pow $0,3
mov $1,$0
| 333.375 | 2,595 | 0.892013 |
ff2011eb1cb22f9805e54f456dc4989cc0bde451 | 595 | asm | Assembly | programs/oeis/214/A214211.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/214/A214211.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/214/A214211.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A214211: Doubled Fibonacci word: the A003842 sequence replacing 1 with 1,1 and 2 with 2,2.
; 1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,1,1,2,2,1,1,2,2,1,1,1,1,2,2,1,1,2
div $0,2
cal $0,3849 ; The infinite Fibonacci word (start with 0, apply 0->01, 1->0, take limit).
add $0,1
mov $1,$0
| 74.375 | 383 | 0.568067 |
ed7578bebf6e8d245f615f2aee28c816bb403532 | 1,035 | asm | Assembly | programs/oeis/047/A047448.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | 1 | 2021-03-15T11:38:20.000Z | 2021-03-15T11:38:20.000Z | programs/oeis/047/A047448.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | programs/oeis/047/A047448.asm | karttu/loda | 9c3b0fc57b810302220c044a9d17db733c76a598 | [
"Apache-2.0"
] | null | null | null | ; A047448: Numbers that are congruent to {0, 2, 3, 5, 6} mod 8.
; 0,2,3,5,6,8,10,11,13,14,16,18,19,21,22,24,26,27,29,30,32,34,35,37,38,40,42,43,45,46,48,50,51,53,54,56,58,59,61,62,64,66,67,69,70,72,74,75,77,78,80,82,83,85,86,88,90,91,93,94,96,98,99,101,102,104,106,107,109,110,112,114,115,117,118,120,122,123,125,126,128,130,131,133,134,136,138,139,141,142,144,146,147,149,150,152,154,155,157,158,160,162,163,165,166,168,170,171,173,174,176,178,179,181,182,184,186,187,189,190,192,194,195,197,198,200,202,203,205,206,208,210,211,213,214,216,218,219,221,222,224,226,227,229,230,232,234,235,237,238,240,242,243,245,246,248,250,251,253,254,256,258,259,261,262,264,266,267,269,270,272,274,275,277,278,280,282,283,285,286,288,290,291,293,294,296,298,299,301,302,304,306,307,309,310,312,314,315,317,318,320,322,323,325,326,328,330,331,333,334,336,338,339,341,342,344,346,347,349,350,352,354,355,357,358,360,362,363,365,366,368,370,371,373,374,376,378,379,381,382,384,386,387,389,390,392,394,395,397,398
mul $0,8
mov $1,2
add $1,$0
div $1,5
| 129.375 | 932 | 0.716908 |
cf89924f2423db1db4e26e9f8adaddbc13c38c6d | 552 | asm | Assembly | oeis/016/A016848.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 11 | 2021-08-22T19:44:55.000Z | 2022-03-20T16:47:57.000Z | oeis/016/A016848.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 9 | 2021-08-29T13:15:54.000Z | 2022-03-09T19:52:31.000Z | oeis/016/A016848.asm | neoneye/loda-programs | 84790877f8e6c2e821b183d2e334d612045d29c0 | [
"Apache-2.0"
] | 3 | 2021-08-22T20:56:47.000Z | 2021-09-29T06:26:12.000Z | ; A016848: a(n) = (4*n+3)^12.
; 531441,13841287201,3138428376721,129746337890625,2213314919066161,21914624432020321,150094635296999121,787662783788549761,3379220508056640625,12381557655576425121,39959630797262576401,116191483108948578241,309629344375621415601,766217865410400390625,1779197418239532716881,3909188328478827879681,8182718904632857144561,16409682740640811134241,31676352024078369140625,59091511031674153381441,106890007738661124410161,188031682201497672618081,322475487413604782665681,540360087662636962890625
mul $0,4
add $0,3
pow $0,12
| 78.857143 | 492 | 0.900362 |
e3e39fd951de1e2a78817fda8fb9958ea741c685 | 384 | asm | Assembly | programs/oeis/164/A164116.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/164/A164116.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/164/A164116.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A164116: Expansion of (1 - x) * (1 - x^4) / (1 - x^5) in powers of x.
; 1,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1,2,-1,0,0,-1
pow $0,2
add $0,1
mul $0,2
lpb $0
add $0,1
mod $0,5
lpe
sub $0,1
| 32 | 241 | 0.453125 |
930f3ec18338d03c0190a921d41ca362c74e0e53 | 426 | asm | Assembly | programs/oeis/119/A119674.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 22 | 2018-02-06T19:19:31.000Z | 2022-01-17T21:53:31.000Z | programs/oeis/119/A119674.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 41 | 2021-02-22T19:00:34.000Z | 2021-08-28T10:47:47.000Z | programs/oeis/119/A119674.asm | neoneye/loda | afe9559fb53ee12e3040da54bd6aa47283e0d9ec | [
"Apache-2.0"
] | 5 | 2021-02-24T21:14:16.000Z | 2021-08-09T19:48:05.000Z | ; A119674: Number of states of the minimal deterministic finite automaton that accepts binary strings that represent numbers that are divisible by n.
; 1,2,3,3,5,4,7,4,9,6,11,5,13,8,15,5,17,10,19,7,21,12,23,6,25,14,27,9,29,16,31,6,33,18,35,11,37,20,39,8,41,22,43,13,45,24,47,7,49,26,51,15,53,28,55,10,57,30,59,17,61,32,63,7,65,34,67,19,69,36,71,12,73,38,75,21,77
add $0,1
lpb $0
dif $0,2
add $1,1
lpe
add $1,$0
mov $0,$1
| 38.727273 | 212 | 0.680751 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.