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
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
6a95b1bc5fa53208417fd60979260822e9a36168
| 268
|
asm
|
Assembly
|
programs/oeis/047/A047356.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/047/A047356.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/047/A047356.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A047356: Numbers that are congruent to {1, 3} mod 7.
; 1,3,8,10,15,17,22,24,29,31,36,38,43,45,50,52,57,59,64,66,71,73,78,80,85,87,92,94,99,101,106,108,113,115,120,122,127,129,134,136,141,143,148,150,155,157,162,164,169
mul $0,3
div $0,2
mul $0,14
div $0,6
add $0,1
| 29.777778
| 165
| 0.66791
|
7ccbfe30dcaae1cf99b3bb6f949c9f4daaf49192
| 200
|
asm
|
Assembly
|
Labs/Lab7_Function-calls/1-hello-world/NASMHello.asm
|
CristianCotovanu/IOCLA
|
94bc8b092beae8ddba76d95617e7eb5b8cef52f5
|
[
"MIT"
] | null | null | null |
Labs/Lab7_Function-calls/1-hello-world/NASMHello.asm
|
CristianCotovanu/IOCLA
|
94bc8b092beae8ddba76d95617e7eb5b8cef52f5
|
[
"MIT"
] | null | null | null |
Labs/Lab7_Function-calls/1-hello-world/NASMHello.asm
|
CristianCotovanu/IOCLA
|
94bc8b092beae8ddba76d95617e7eb5b8cef52f5
|
[
"MIT"
] | null | null | null |
%include "io.inc"
section .data
msg db 'Hello, world!', 0
section .text
global CMAIN
CMAIN:
mov ebp, esp
PRINT_STRING msg
NEWLINE
xor eax, eax
ret
| 13.333333
| 30
| 0.545
|
b8b501eb5cb4fc987558e5cfacb93b1f67599a79
| 716
|
asm
|
Assembly
|
external/source/shellcode/linux/ia32/stage_udp_shell.asm
|
madhavarao-yejarla/VoIP
|
3f7d0cdc0bb1423f9e952e411d073a1424ef9f5e
|
[
"Apache-2.0",
"BSD-3-Clause"
] | 35
|
2015-08-08T07:23:38.000Z
|
2021-04-07T18:00:44.000Z
|
external/source/shellcode/linux/ia32/stage_udp_shell.asm
|
madhavarao-yejarla/VoIP
|
3f7d0cdc0bb1423f9e952e411d073a1424ef9f5e
|
[
"Apache-2.0",
"BSD-3-Clause"
] | 1
|
2019-02-12T12:13:53.000Z
|
2019-02-12T12:13:53.000Z
|
external/source/shellcode/linux/ia32/stage_udp_shell.asm
|
fozavci/metasploit-framework-with-viproy
|
3f7d0cdc0bb1423f9e952e411d073a1424ef9f5e
|
[
"Apache-2.0",
"BSD-3-Clause"
] | 23
|
2015-08-11T05:07:47.000Z
|
2020-11-06T03:55:10.000Z
|
;;
;
; Name: stage_udp_shell
; Type: Stage
; Qualities: None
; Platforms: Linux
; Authors: skape <mmiller [at] hick.org>
; Version: $Revision: 1400 $
; License:
;
; This file is part of the Metasploit Exploit Framework
; and is subject to the same licenses and copyrights as
; the rest of this package.
;
; Description:
;
; This payload redirects stdio to a file descriptor and executes
; /bin/sh with readline disabled, thus making it possible to use
; with connectionless sockets like UDP.
;
;;
BITS 32
GLOBAL _start
%include "generic.asm"
_start:
execve_binsh EXECUTE_REDIRECT_IO | EXECUTE_DISABLE_READLINE
| 24.689655
| 72
| 0.642458
|
40640ca7ef5e89a51aab528ebd0610190ab0209e
| 333
|
asm
|
Assembly
|
programs/oeis/130/A130625.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/130/A130625.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/130/A130625.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A130625: First differences of A130624.
; 1,4,7,11,20,41,85,172,343,683,1364,2729,5461,10924,21847,43691,87380,174761,349525,699052,1398103,2796203,5592404,11184809,22369621,44739244,89478487,178956971,357913940,715827881,1431655765,2863311532
mov $1,1
mov $3,4
lpb $0
sub $0,1
add $2,$1
add $1,$3
sub $1,$2
mul $3,2
lpe
| 25.615385
| 203
| 0.732733
|
797d7bf9ed2f051474038ffa0d3365080f90efe4
| 12,423
|
asm
|
Assembly
|
editPitchTable.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 11
|
2021-04-08T14:24:52.000Z
|
2022-03-25T00:45:27.000Z
|
editPitchTable.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 3
|
2021-09-17T03:10:36.000Z
|
2021-09-17T03:16:45.000Z
|
editPitchTable.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 1
|
2021-04-08T14:24:54.000Z
|
2021-04-08T14:24:54.000Z
|
editTable:
.IF SRAM_MAP=32
lda #SRAM_TABLE_BANK
jsr setMMC1r1
.ENDIF
ldx tableCursorY
lda tableRowsIndex,x
ldx editorCurrentTable
clc
adc editTableAddressLo,x
sta tableVector
lda editTableAddressHi,x
adc #$00
sta tableVector+1
lda writeScreen ;need to write screen?
beq @a
jsr writeTableScreen ;yes
dec writeScreen ;if writeScreen was 1, only write main window, else
beq @a ; write header and title too
jsr writeTableHeaderFooter
dec writeScreen ;reset screen writing flag
lda #$01
sta dmaUpdateHeader
sta dmaUpdateTitle
jmp editorLoop
@a: jsr globalKeys ;global keys
lda writeScreen ;if mode has changed, this flag will be !=0
beq @b
jmp editTableExit ;if changed, don't do any more keys
@b: jsr processKeys
.IF SRAM_MAP=32
lda #SRAM_TABLE_BANK
jsr setMMC1r1
.ENDIF
ldy tableCursorX
jsr tableHintSystem
ldy tableCursorX
jsr tableKeysTapA
jsr tableKeysTapB
jsr tableKeysHoldA_UDLR
jsr tableKeysHoldAB_TapUDLR
jsr tableKeysHoldSelect_UDLR
jsr moveAroundEditor
editTableExit:
jsr tablePlayMarkers
updateCursor tableCursorX,tableCursorY,tableCursorColumns,tableCursorRows,tableColumnCursorType
jsr tableSmartTranspose
jmp editorLoop
tableSmartTranspose:
lda PAD1_firea
beq @x
lda PAD1_sel
beq @x
lda PAD1_dlr
bne @transpose
lda PAD1_dud
eor #$FF
clc
adc #$01
bne @transpose
@x: rts
@transpose: sta tmp4
ldy editorCurrentTable
lda editTableAddressLo,y
sta tmp0
lda editTableAddressHi,y
sta tmp1
ldy tableCursorX
cpy #TABLE_COLUMN_FX1
bcc @notCommand
cpy #TABLE_COLUMN_FX2
ldy #TABLE_COLUMN_FX2_DATA
bcs @fx2
ldy #TABLE_COLUMN_FX1_DATA
@fx2: lda (tableVector),y
sta tmp3
dey
@notCommand: lda (tableVector),y
sta tmp2
lda tableCursorX
cmp #TABLE_COLUMN_PITCH
beq @tranPitch
cmp #TABLE_COLUMN_VOLUME
beq @tranVol
jmp @tranCom
@tranVol: tay
lda (tmp0),y
ldx PAD1_dud
beq @freeVol
cmp tmp2
bne @noVol
@freeVol: clc
adc tmp4
bmi @noVol
cmp #$10
bcs @noVol
sta (tmp0),y
@noVol: tya
clc
adc #BYTES_PER_TABLE_STEP
cmp #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @tranVol
ldy tableCursorX
lda (tableVector),y
sta editBuffer
lda #$01
sta writeScreen
rts
@tranPitch: tay
lda (tmp0),y
ldx PAD1_dud
beq @freePitch
cmp tmp2
bne @noPitch
@freePitch: clc
adc tmp4
sta (tmp0),y
@noPitch: tya
clc
adc #BYTES_PER_TABLE_STEP
cmp #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @tranPitch
ldy tableCursorX
lda (tableVector),y
sta editBuffer
lda #$01
sta writeScreen
rts
@tranCom: cmp #TABLE_COLUMN_FX1
beq @tranCom1
cmp #TABLE_COLUMN_FX2
bne @comData
@tranCom1: tay
lda (tmp0),y
cmp #$FF
beq @noCom
ldx PAD1_dud
beq @freeCom
cmp tmp2
bne @noCom
@freeCom: clc
adc tmp4
bmi @noCom
cmp #COMMAND_Z
bcs @noCom
sta (tmp0),y
@noCom: tya
clc
adc #BYTES_PER_TABLE_STEP
cmp #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @tranCom1
ldy tableCursorX
lda (tableVector),y
sta editBuffer
lda #$01
sta writeScreen
rts
@comData: tay
dey
tya
@comData1: tay
lda (tmp0),y
cmp #$FF
beq @noComData
ldx PAD1_dud
beq @freeComData
cmp tmp2
bne @noComData
@freeComData: iny
lda (tmp0),y
clc
adc tmp4
sta (tmp0),y
dey
@noComData: tya
clc
adc #BYTES_PER_TABLE_STEP
cmp #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @comData1
ldy tableCursorX
lda (tableVector),y
sta editBuffer
lda #$01
sta writeScreen
rts
tableHintSystem:
ldy tableCursorX
cpy #TABLE_COLUMN_FX1
;beq @yes
;cpy #TABLE_COLUMN_FX2
;bne @x
bcc @x
@yes: lda PAD1_sel
bne @x
lda PAD1_firea
bne @a
lda hintMode
beq @x
@c: lda #$00
sta hintMode
lda #$01
sta writeScreen
rts
@a: clc
adc hintMode
cmp #$20
bcc @b
lda editBuffer
;cmp #$FF
;beq @c
ldy tableCursorX
cpy #TABLE_COLUMN_FX1
beq @d
cpy #TABLE_COLUMN_FX2
beq @d
dey
lda (tableVector),y
cmp #$FF
beq @x
@d: ldy tableCursorY
jsr editorShowHint
rts
@b: sta hintMode
@x: rts
tableKeysHoldAB_TapUDLR:
lda PAD1_firea
beq @x
lda PAD1_fireb
beq @x
lda PAD1_dud
beq @noUD
bpl @down
jsr tableDeleteRow
ldy tableCursorX
lda (tableVector),y
cmp #$FF
beq @a
sta editTableLastValue,x
@a: sta editBuffer
lda #$01
sta editBufferFlag
@a1: lda #$01
sta writeScreen
rts
@down: jsr tableInsertRow
ldy tableCursorX
lda (tableVector),y
sta editBuffer
lda #$01
sta writeScreen
lda #$01
sta editBufferFlag
rts
@noUD: lda PAD1_dlr
beq @x
@x: rts
tableDeleteRow:
ldx editorCurrentTable
lda editTableAddressLo,x
sta tmp0
lda editTableAddressHi,x
sta tmp1
lda tableCursorY
cmp #STEPS_PER_TABLE-1
beq @x
tay
iny
lda tableRowsIndex,y
tay
ldx #$00
@a: lda (tmp0),y
sta copyBuffer,x
inx
iny
cpy #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @a
lda tableCursorY
tay
lda tableRowsIndex,y
tay
ldx #$00
@b: lda copyBuffer,x
sta (tmp0),y
inx
iny
cpy #((STEPS_PER_TABLE-1) * BYTES_PER_TABLE_STEP)
bcc @b
ldy #STEPS_PER_TABLE-1
lda tableRowsIndex,y
tay
lda #$0F
sta (tmp0),y ;vol
iny
lda #$00
sta (tmp0),y ;pitch
iny
lda #$FF
sta (tmp0),y ;fx
iny
lda #$00
sta (tmp0),y ;fx data
iny
lda #$FF
sta (tmp0),y ;fx
iny
lda #$00
sta (tmp0),y ;fx data
lda #$FF
sta copyBufferObjectType
jsr editorUpdateCopyInfo
@x: rts
tableInsertRow: ldx editorCurrentTable
lda editTableAddressLo,x
sta tmp0
lda editTableAddressHi,x
sta tmp1
lda tableCursorY
cmp #STEPS_PER_TABLE-1
beq @x
tay
lda tableRowsIndex,y
tay
ldx #$00
@a: lda (tmp0),y
sta copyBuffer,x
inx
iny
cpy #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @a
lda tableCursorY
tay
iny
lda tableRowsIndex,y
tay
ldx #$00
@b: lda copyBuffer,x
sta (tmp0),y
inx
iny
cpy #(STEPS_PER_TABLE * BYTES_PER_TABLE_STEP)
bcc @b
lda #$FF
sta copyBufferObjectType
jsr editorUpdateCopyInfo
@x: rts
tablePlayMarkers: ldx editorCurrentTrack
lda editorInstrumentAddressLo,x
sta tmp0
lda editorInstrumentAddressHi,x
sta tmp1
ldy #INSTRUMENT_ROW_TABLE
lda (tmp0),y
cmp editorCurrentTable
bne @x
lda plyrTableIndex,x
tay
lda tableCursorRows,y
sec
sbc #$01
sta SPR05_Y
sta SPR06_Y
lda #SPR_RIGHT_ARROW
sta SPR05_CHAR
lda #SPR_LEFT_ARROW
sta SPR06_CHAR
lda #26+48
sta SPR05_X
clc
adc #14*8
sta SPR06_X
@x: rts
tableKeysHoldSelect_UDLR:
;rts ;*new controls*
lda PAD1_sel
beq @x
lda PAD1_firea
ora PAD1_fireb
bne @x
lda PAD1_dud
ora keysRepeatUD
beq @noUD
clc
adc editorCurrentTable
bpl @a
lda #$00
beq @b
@a: cmp #NUMBER_OF_TABLES
bcs @x
@b: sta editorCurrentTable
lda #$02
sta writeScreen
rts
@noUD: lda PAD1_dlr
beq @x
bmi tableCopyData
jsr tablePasteData
@x: rts
tableCopyData: lda editorMode
sta copyBufferObjectType
ldx editorCurrentTable
stx copyBufferObject
lda editTableAddressLo,x
sta tmp0
lda editTableAddressHi,x
sta tmp1
ldx #$00
ldy tableCursorY
sty copyBufferStartIndex
lda tableRowsIndex,y
tay
@copyLoop: lda (tmp0),y
sta copyBuffer,x
inx
iny
cpy #(STEPS_PER_TABLE*BYTES_PER_TABLE_STEP)
bcc @copyLoop
stx copyBufferLength
@x: jsr editorUpdateCopyInfo
rts
tablePasteData: lda copyBufferObjectType
bmi @x ;nothing to copy
cmp editorMode
bne @x ;wrong object type
ldx editorCurrentTable
lda editTableAddressLo,x
sta tmp0
lda editTableAddressHi,x
sta tmp1
ldy tableCursorY
lda tableRowsIndex,y
tay
ldx #$00
@b: lda copyBuffer,x
sta (tmp0),y
inx
iny
cpx copyBufferLength
bcs @a
cpy #(STEPS_PER_TABLE*BYTES_PER_TABLE_STEP)
bcc @b
@a: lda #$01
sta writeScreen
rts
@x: lda #ERROR_PASTE
sta errorMessageNumber
rts
tableKeysHoldA_UDLR:
lda PAD1_fireb;keysHoldB
beq @noB
@y: rts
@noB: lda PAD1_sel
bne @y
lda PAD1_firea;keysHoldA ;hold A + U/D/L/R = modify value
bne @holdA
lda editBufferFlag
beq @x
lda editBuffer
sta (tableVector),y
@notEditing: lda #$00
sta editBufferFlag
beq @x
@holdA: lda editBufferFlag
bne @editing
inc editBufferFlag
lda (tableVector),y
cpy #TABLE_COLUMN_PITCH
beq @notEmpty
cpy #TABLE_COLUMN_FX1_DATA
beq @notEmpty
cpy #TABLE_COLUMN_FX2_DATA
beq @notEmpty
cmp #$FF
bne @notEmpty
lda editTableLastValue,y
@notEmpty: sta editBuffer
jsr editTableUpdateScreenValue
ldy tableCursorX
@editing: lda keysRepeatLR
ora PAD1_dlr
bne @addValue
lda keysRepeatUD
ora PAD1_dud
beq @x
bpl @negative
lda tablePositiveAdd,y
jmp @addValue
@negative: lda tableNegativeAdd,y
@addValue: clc
adc editBuffer
cpy #TABLE_COLUMN_PITCH
beq @noLimit1
cpy #TABLE_COLUMN_FX1_DATA
beq @noLimit1
cpy #TABLE_COLUMN_FX2_DATA
beq @noLimit1
and #$FF
bpl @notNeg0
lda #$00
beq @noLimit1
@notNeg0: cmp tableMaxValues,y
bcc @noLimit1
lda tableMaxValues,y
sec
sbc #$01
@noLimit1: sta editBuffer
sta editTableLastValue,y
jsr editTableUpdateScreenValue
@x: rts
tableKeysTapB:
lda PAD1_sel
beq @x
lda keysTapB
beq @x
ldy tableCursorX
lda tableClearValues,y
sta (tableVector),y
sta editBuffer
jmp editTableUpdateScreenValue
@x: rts
tableKeysTapA: lda keysTapA
beq @x
.IF 0=1
lda PAD1_fireb
beq @notDel
ldy tableCursorX
lda tableClearValues,y
sta (tableVector),y
sta editBuffer
jmp editTableUpdateScreenValue
.ENDIF
@notDel:
lda editTableLastValue,y
sta (tableVector),y
sta editBuffer
jsr editTableUpdateScreenValue
ldy tableCursorX
@x: rts
tableClearValues:
.BYTE $0F,$00,$FF,$00,$FF,$00
tableMaxValues:
.BYTE $10,$00,(editorCommandsEnd-editorCommands),0,(editorCommandsEnd-editorCommands),0
tablePositiveAdd:
.BYTE $01,$0C,$01,$10,$01,$10
tableNegativeAdd:
.BYTE -1, -12, -1, -16, -1, -16
printTableCommand:
cmp #$FF
bne @a
lda #CHR_EMPTY
sta windowBuffer,x
inx
rts
@a: sty tmp2
tay
lda editorCommands,y
sta windowBuffer,x
ldy tmp2
inx
rts
editTableUpdateScreenValue:
sta tmp3
ldx tableCursorY
lda rowOffsetTable,x
ldx tableCursorX
clc
adc columnOffsetTable,x
tax
lda tableCursorX
lda tmp3
cpy #TABLE_COLUMN_FX1
bcs @a
jmp phexWindow
@a: beq @command
cpy #TABLE_COLUMN_FX2
beq @command
dey
lda (tableVector),y
cmp #COMMAND_W
bne @notDuty
lda tmp3
jmp instrumentPrintDuty
@notDuty: lda tmp3
jmp phexWindow
@command: jsr printTableCommand
lda tmp3
cmp #COMMAND_W
bne @notDuty2
iny
lda (tableVector),y
jmp instrumentPrintDuty
@notDuty2: iny
lda (tableVector),y
jmp phexWindow
writeTableScreen:
ldx #$00
ldy tableFirstRow ;first write row numbers to buffer
@a: tya
jsr phexRow
iny
cpx #$20
bcc @a
ldx editorCurrentTable
lda editTableAddressLo,x
sta tmp0
lda editTableAddressHi,x
sta tmp1
ldx #$00
lda tableFirstRow
tay
lda tableRowsIndex,y
tay
@b: lda (tmp0),y ;volume
jsr phexWindow
lda #CHR_SPACE
sta windowBuffer,x
inx
iny
lda (tmp0),y ;pitch
jsr phexWindow
lda #CHR_SPACE
sta windowBuffer,x
inx
iny
lda (tmp0),y ;FX1
pha
jsr printTableCommand
iny
pla
cmp #COMMAND_W
bne @notDuty1
lda (tmp0),y
jsr instrumentPrintDuty
jmp @skipDuty1
@notDuty1: lda (tmp0),y ;FX1 data
jsr phexWindow
@skipDuty1: lda #CHR_SPACE
sta windowBuffer,x
inx
iny
lda (tmp0),y ;FX2
pha
jsr printTableCommand
iny
pla
cmp #COMMAND_W
bne @notDuty2
lda (tmp0),y
jsr instrumentPrintDuty
jmp @skipDuty2
@notDuty2: lda (tmp0),y ;FX1 data
jsr phexWindow
@skipDuty2: lda #CHR_SPACE
sta windowBuffer,x
inx
iny
cpx #(14 * 16)
bcc @b
rts
writeTableHeaderFooter:
ldx #$00 ;write header and title bars to buffer
@c: lda titleTable,x
sta titleBuffer,x
lda headerTable,x
sta headerBuffer,x
inx
cpx #$11
bne @c
ldx #$08 ;print current chain number in title bar
lda editorCurrentTable
jsr phexTitle
rts
tableCursorColumns:
.BYTE $53, $53+(3*8), $53+(6*8), $53+(7*8), $53+(10*8), $53+(11*8)
tableCursorRows:
.REPEAT 16,i
.BYTE $28 + (i * 8)
.ENDREPEAT
rowOffsetTable:
.REPEAT 16,i
.BYTE i*14
.ENDREPEAT
columnOffsetTable:
.BYTE 0,3,6,7,10,11
;
;0 = no cursor, 1=8x8, 2=8x16, 3=8x24
;
tableColumnCursorType:
.BYTE 2,2,1,2,1,2
| 16.009021
| 97
| 0.700555
|
3b1cd67d33a903533defa9788409e6fd43eba5cd
| 37,352
|
asm
|
Assembly
|
ugbc/src/hw/zx/mob.asm
|
spotlessmind1975/ugbasic
|
1df3c8fde8e80b479ece86b4ff2b97b599d57ff4
|
[
"Apache-2.0"
] | 10
|
2021-10-03T13:44:25.000Z
|
2022-03-10T23:53:32.000Z
|
ugbc/src/hw/zx/mob.asm
|
spotlessmind1975/ugbasic
|
1df3c8fde8e80b479ece86b4ff2b97b599d57ff4
|
[
"Apache-2.0"
] | 379
|
2021-08-12T09:46:09.000Z
|
2022-03-27T11:29:12.000Z
|
ugbc/src/hw/zx/mob.asm
|
spotlessmind1975/ugbasic
|
1df3c8fde8e80b479ece86b4ff2b97b599d57ff4
|
[
"Apache-2.0"
] | 2
|
2021-11-08T19:37:50.000Z
|
2021-11-20T22:27:12.000Z
|
; /*****************************************************************************
; * ugBASIC - an isomorphic BASIC language compiler for retrocomputers *
; *****************************************************************************
; * Copyright 2021-2022 Marco Spedaletti (asimov@mclink.it)
; *
; * Licensed under the Apache License, Version 2.0 (the "License");
; * you may not use this file eXcept in compliance with the License.
; * You may obtain a copy of the License at
; *
; * http://www.apache.org/licenses/LICENSE-2.0
; *
; * Unless required by applicable law or agreed to in writing, software
; * distributed under the License is distributed on an "AS IS" BASIS,
; * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either eXpress or implied.
; * See the License for the specific language governing permissions and
; * limitations under the License.
; *----------------------------------------------------------------------------
; * Concesso in licenza secondo i termini della Licenza Apache, versione 2.0
; * (la "Licenza"); è proibito usare questo file se non in conformità alla
; * Licenza. Una copia della Licenza è disponibile all'indirizzo:
; *
; * http://www.apache.org/licenses/LICENSE-2.0
; *
; * Se non richiesto dalla legislazione vigente o concordato per iscritto,
; * il software distribuito nei termini della Licenza è distribuito
; * "COSì COM'è", SENZA GARANZIE O CONDIZIONI DI ALCUN TIPO, esplicite o
; * implicite. Consultare la Licenza per il testo specifico che regola le
; * autorizzazioni e le limitazioni previste dalla medesima.
; ****************************************************************************/
;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
;* *
;* MOVABLE OBJECTS UNDER ZX (specific algorithms) *
;* *
;* by Marco Spedaletti *
;* *
;* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
MOBDRAW_TMP: DB 0
MOBDRAW_PD: DB 0
MOBDRAW_DY: DB 0
MOBDRAW_DY2: DB 0
MOBDRAW_DX: DB 0
MOBDRAW_I: DB 0
MOBDRAW_J: DB 0
MOBDRAW_K: DB 0
MOBDRAW_C: DB 0
MOBDRAW_R: DB 0
; ---------------------------------------------------------------------------
; Chipset specific initialization
; MOBINITCS(X:index,draw)
; ---------------------------------------------------------------------------
MOBDRAW2_SHIFTRIGHT:
; Load first location of draw data
LD A, (IX+11)
LD (MOBADDR), A
LD A, (IX+12)
LD (MOBADDR+1), A
; Load height (in pixels) = height (in rows) + 8
LD A, (IX+10)
LD (MOBH), A
ADD A, 8
LD (MOBDRAW_R), A
LD (MOBDRAW_I), A
; Load width (in pixels) = width (in cols) + 1
LD A, (IX+9)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_C), A
SLA A
SLA A
SLA A
LD (MOBW), A
; Load displacement = iteraction for each line
LD A, (MOBDRAW_DX)
AND A, 7
LD (MOBDRAW_K), A
LD A, MOBDRAW_K
LD E, A
; Rows loop
MOBDRAW2_SHIFTRIGHTL1:
; j = cols
LD A, (MOBDRAW_C)
LD (MOBDRAW_J), A
LD A, MOBDRAW_J
LD C, A
AND A
LD HL, (MOBADDR)
; Cols loop
MOBDRAW2_SHIFTRIGHTL2:
; Rotate the content of the cell by 1 pixel to the right
; and save the last pixel on carry. The carry will be put
; on the leftmost pixel.
LD A, (HL)
RR A
LD (HL), A
; Move to the next cell on the same line.
INC HL
; Repeat for each cell of the same row.
DEC C
JR NZ, MOBDRAW2_SHIFTRIGHTL2
; Repeat for the entire size of the displacement.
LD HL, (MOBADDR)
DEC E
JR NZ, MOBDRAW2_SHIFTRIGHTL1
; Move to the next line
LD HL, (MOBADDR)
LD A, MOBDRAW_C
LD E, A
LD A, 0
LD D, 0
ADD HL, DE
LD (MOBADDR), HL
LD A, MOBDRAW_K
LD E, A
; Repeat for each row of the entire draw.
LD A, (MOBDRAW_I)
DEC A
LD (MOBDRAW_I), A
CP #0
JR NZ, MOBDRAW2_SHIFTRIGHTL1
RET
; ---------------------------------------------------------------------------
; MODE 2 (BITMAP STANDARD)
; Shift the *current* draw area image of MOBI mob of MOBDRAW_DX pixel
; to the left. Pixels on the right are put to zero.
; ---------------------------------------------------------------------------
MOBDRAW2_SHIFTLEFT:
; Load first location of draw data
LD A, (IX+11)
LD (MOBADDR), A
LD A, (IX+12)
LD (MOBADDR+1), A
LD A, (IX+15)
LD (MOBSIZE), A
LD A, (IX+16)
LD (MOBSIZE+1), A
; Load height (in pixels) = height (in rows) + 8
LD A, (IX+10)
LD (MOBH), A
ADD 8
LD (MOBDRAW_R), A
LD (MOBDRAW_I), A
; Load width (in pixels) = width (in cols) + 1
LD A, (IX+9)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_C), A
SUB A, 1
SLA A
SLA A
SLA A
LD (MOBW), A
; Load displacement = iteraction for each line
LD A, (MOBDRAW_DX)
AND A, 7
LD (MOBDRAW_K), A
LD A, (MOBDRAW_K)
LD E, A
; Rows loop
MOBDRAW2_SHIFTLEFTL1:
; j = cols
LD A, (MOBDRAW_C)
LD (MOBDRAW_J), A
LD A, (MOBDRAW_C)
LD C, A
LD HL, (MODADDR)
AND A
; Cols loop
MOBDRAW2_SHIFTLEFTL2:
; Rotate the content of the cell by 1 pixel to the left
; and save the first pixel on carry. The carry will be put
; on the rightmost pixel.
LD A, (HL)
RL A
LD (HL), A
; Move to the previous cell on the same line.
; This is placed after 8 bytes from the current position.
DEC HL
; Repeat for each cell of the same row.
DEC C
JR NZ, MOBDRAW2_SHIFTLEFTL2
; Repeat for the entire size of the displacement.
LD A, (MOBDRAW_C)
LD C, A
LD HL, (MODADDR)
AND A
DEC E
JR NZ, MOBDRAW2_SHIFTLEFTL1
; Move to the next line
LD HL, (MODADDR)
LD A, MOBDRAW_C
LD E, A
LD A, 0
LD D, A
LD A, (MOBDRAW_DX)
AND A, 7
LD (MOBDRAW_K), A
LD A, (MOBDRAW_K)
LD E, A
; Repeat for each row of the entire draw.
LD A, (MOBDRAW_I)
DEC A
LD (MOBDRAW_I), A
CP #0
JR NZ, MOBDRAW2_SHIFTLEFTL1
RET
; ---------------------------------------------------------------------------
; MODE 2 (BITMAP STANDARD)
; Shift the *current* draw area image of MOBI mob of MOBDRAW_DY pixel
; to the top. Pixels on the bottom are put to zero.
; ---------------------------------------------------------------------------
MOBDRAW2_SHIFTUP:
LD A, (MOBDRAW_DY)
AND A, 7
LD (MOBDRAW_K), A
LD A, (IX+9)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_C), A
SLA A
SLA A
SLA A
LD (MOBW), A
LD A, 0
LD (MOBDRAW_J), A
; Load height (in pixels) = height (in rows) + 8
LD A, (IX+10)
ADD A, 8
LD (MOBH), A
LD (MOBDRAW_I), A
SRL A
SRL A
SRL A
LD (MOBDRAW_R), A
MOBDRAW2_SHIFTUPL0:
; MOBSIZE = WC x WR
LD A, (IX+15)
LD (MOBSIZE), A
LD A, (IX+16)
LD (MOBSIZE+1), A
LD A, (MOBDRAW_C)
LD (MOBDRAW_TMP), A
MOBDRAW2_SHIFTUPLCC:
LD A, (IX+11)
LD (MOBADDR), A
LD A, (IX+12)
LD (MOBADDR+1), A
LD HL, (MOBADDR)
LD (TMPPTR), HL
LD A, (MOBDRAW_C)
LD E, A
LD A, 0
LD D, A
ADD HL, DE
LD A, 0
LD (MOBDRAW_J), A
MOBDRAW2_SHIFTUPL1:
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD C, 0
MOBDRAW2_SHIFTUPLA:
LD A, (HL)
LD (DE),A
INC C
LD A, C
CP (MOBDRAW_C)
JR NZ, MOBDRAW2_SHIFTUPLA
LD HL, (MOBADDR)
LD A, MOBDRAW_C
LD E, A
LD A, 0
LD D, A
ADD HL, DE
LD (MOBADDR), HL
LD HL, (TMPPTR)
LD A, MOBDRAW_C
LD E, A
LD A, 0
LD D, A
SBC HL, DE
LD (TMPPTR), HL
; se C < 0 FINE
LD A, 0
LD C, 0
LD (MOBDRAW_J), A
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD A, (MOBDRAW_I)
DEC A
LD (MOBDRAW_I), A
CP 0
JR Z, MOBDRAW2_SHIFTUPL1X2
JMP MOBDRAW2_SHIFTUPL1
MOBDRAW2_SHIFTUPL1X2:
LD A, (MOBH)
LD (MOBDRAW_I), A
LD A, (MOBDRAW_K)
DEC A
LD (MOBDRAW_K), A
CP #0
JR Z, MOBDRAW2_SHIFTUPL1X3
JMP MOBDRAW2_SHIFTUPLCC
MOBDRAW2_SHIFTUPL1X3:
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD C, (MOBDRAW_C)
MOBDRAW2_SHIFTUPLAB:
LD A, #0
LD (DE), A
INC DE
DEC C
JR NZ, MOBDRAW2_SHIFTUPLAB
MOBDRAW2_SHIFTUPL0X:
RET
; ---------------------------------------------------------------------------
; MODE 2 (BITMAP STANDARD)
; Shift the *current* draw area image of MOBI mob of MOBDRAW_DY pixel
; to the bottom. Pixels on the top are put to zero.
; ---------------------------------------------------------------------------
MOBDRAW2_SHIFTDOWN:
LD A, (MOBDRAW_DY)
AND A, 7
LD (MOBDRAW_K), A
LD A, (IX+9)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_C), A
SLA A
SLA A
SLA A
LD (MOBW), A
LD A, 0
LD (MOBDRAW_J), A
; Load height (in pixels) = height (in rows) + 8
LD A, (IX+10)
LD (MOBH), A
ADD A, 8
LD (MOBH), A
SRL A
SRL A
SRL A
LD (MOBDRAW_R), A
LD A, (MOBH)
LD (MOBDRAW_I), A
MOBDRAW2_SHIFTDOWNL0:
; MOBSIZE = WC x WR
LD A, (IX+15)
LD (MOBSIZE), A
LD A, (IX+16)
LD (MOBSIZE+1), A
MOBDRAW2_SHIFTDOWNLCC:
LD A, (IX+11)
LD (MOBADDR), A
LD A, (IX+12)
LD (MOBADDR+1), A
LD HL, (MOBADDR)
LD DE, (MOBSIZE)
ADD HL, DE
LD (TMPPTR), HL
LD HL, (TMPPTR)
LD A, (MOBDRAW_C)
LD E, A
LD A, 0
LD D, A
SBC HL, DE
LD (MOBADDR), HL
LD A, 0
LD (MOBDRAW_J), A
MOBDRAW2_SHIFTDOWNL1:
; se C > WC121 allora
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD A, (MOBDRAW_C)
LD C, A
MOBDRAW2_SHIFTDOWNLA:
; sposta da [C+6] a [C+7]
; ...
; sposta da [C+1] a [C+2]
; sposta da [C] a [C+1]
LD A, (HL)
LD (DE), A
DEC C
JR NZ, MOBDRAW2_SHIFTDOWNLA
; C = C - 8
LD HL, (MOBADDR)
LD A, (MOBDRAW_C)
LD E, A
LD A, 0
LD D, A
SBC HL, DE
LD (MOBADDR), HL
LD HL, (TMPPTR)
LD A, (MOBDRAW_C)
LD E, A
LD A, 0
LD D, A
SBC HL, DE
LD (TMPPTR), HL
; se C < 0 FINE
LD A, 0
LD (MOBDRAW_J), 0
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD A, (MOBDRAW_C)
LD C, A
LD A, (MOBDRAW_I)
DEC A
LD (MOBDRAW_I), A
CP 0
JR Z, MOBDRAW2_SHIFTDOWNL1X2
JMP MOBDRAW2_SHIFTDOWNL1
MOBDRAW2_SHIFTDOWNL1X2:
LD A, (MOBH)
INC A
LD (MOBDRAW_I), A
LD A, (MOBDRAW_K)
DEC A
LD (MOBDRAW_K), A
CP 0
JR Z, MOBDRAW2_SHIFTDOWNL1X3
JMP MOBDRAW2_SHIFTDOWNLCC
MOBDRAW2_SHIFTDOWNL1X3:
LD HL, (MOBADDR)
LD DE, (TMPPTR)
LD A, (MOBDRAW_C)
LD C, A
MOBDRAW2_SHIFTDOWNLAB:
LD A, 0
LD (DE),A
DEC C
JR NZ, MOBDRAW2_SHIFTDOWNLAB
MOBDRAW2_SHIFTDOWNL0X:
RET
; Chipset specific initialization
; (we use the data that generic initialization put on descriptor)
MOBINITCS:
LD A, (MOBI)
LD B, A
CALL MOBDESCRIPTOR
; Save the actual data into save attribute of descriptor,
; in order to avoid to lose it during allocation.
LD A, (IX+11)
LD (IX+13), A
LD A, (IX+12)
LD (IX+14), A
; Now load the actual size of the image
; (in pixel)
LD A, (IX+9)
LD (MOBW), A
LD A, (IX+10)
LD (MOBH), A
; Calculate the needed memory space for the drawing area
; that will contain the drawing. It must be 8 pixels (+ 1 cell) wider
; and 8 pixel (+ 1 cell) higher.
LD A, (MOBW)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_C), A
LD A, (MOBH)
SRL A
SRL A
SRL A
ADD A, 1
LD (MOBDRAW_R), A
SLA A
SLA A
SLA A
LD (MOBH), A
LD A, (MOBDRAW_R)
DEC A
LD (MOBDRAW_R), A
; Now calculate the product MOBW x MOBH
; in MOBSIZE (bytes needed)
LD A, (MOBW)
LD H, A
LD A, (MOBH)
LD E, A
LD D, 0
LD L, D
LD B, 8
MOBINITCSLSIZE:
ADD HL, HL
JR NC, MOBINITCSLSIZE2
ADD HL, DE
MOBINITCSLSIZE2:
DJNZ MOBINITCSLSIZE
LD (MOBSIZE), HL
LD A, (MOBI)
LD B, A
LD HL, (MOBSIZE)
LD (IX+15), HL
LD A, (IX+10)
LD (MOBH), A
MOBINITCS22X:
; Now we can allocate the space on the MOBSEGMENT
CALL MOBALLOC
LD A, (MOBI)
LD B, A
; We now can save the address of freshly allocated
; space into the specific descriptor.
LD HL, (MOBADDR)
LD (IX+11), HL
; Now we can copy the original data to the new space,
; at position 0,0 and assuring that is aligned to the
; new space.
; Recalculate limits (w,h)
LD A, (MOBDRAW_C)
LD (MOBDRAW_J), A
SLA A
SLA A
SLA A
LD (MOBW), A
LD A, (MOBH)
LD (MOBDRAW_I), A
; Move the source data to a temporary pointer,
; (the destination area is already on MOBADDR)
LD HL, (IX+13)
LD (TMPPTR), HL
; Copy one line at a time.
MOBINITCSL1A:
DEC MOBDRAW_J
LDY #0
MOBINITCSL1:
LDA (TMPPTR),Y
STA (MOBADDR),Y
INY
DEC MOBDRAW_J
BNE MOBINITCSL1
LDA #0
STA (MOBADDR),Y
CLC
LDA TMPPTR
ADC MOBDRAW_C
STA TMPPTR
LDA TMPPTR+1
ADC #0
STA TMPPTR+1
SEC
LDA TMPPTR
SBC #1
STA TMPPTR
LDA TMPPTR+1
SBC #0
STA TMPPTR+1
CLC
LDA MOBADDR
ADC MOBDRAW_C
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
; Repeat for each row of the entire draw.
LDA MOBDRAW_C
STA MOBDRAW_J
DEC MOBDRAW_I
BEQ MOBINITCSL1AX
JMP MOBINITCSL1A
MOBINITCSL1AX:
LDA MOBDRAW_C
STA MOBDRAW_J
LDA #8
STA MOBDRAW_I
MOBINITCSL1HG:
LDY #0
MOBINITCSL1H:
LDA #0
STA (MOBADDR),Y
INY
DEC MOBDRAW_J
BNE MOBINITCSL1H
CLC
LDA MOBADDR
ADC MOBDRAW_C
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
LDA MOBDRAW_C
STA MOBDRAW_J
DEC MOBDRAW_I
BEQ MOBINITCSL1HGX
JMP MOBINITCSL1HG
MOBINITCSL1HGX:
; Now we must adjust the image inside the larger
; clip, by right and bottom shifting it, accordingly
; to the (relative) position (x,y)
LDA MOBDESCRIPTORS_XL, X
STA MOBX
LDA MOBDESCRIPTORS_YL, X
STA MOBY
; Calculate dx as x & 7: if the result is not zero,
; it means that the drawing is not aligned with the
; left border of the image.
LDA MOBX
AND #$07
STA MOBDRAW_DX
BEQ MOBINITCS2A
; If not aligned, we must shift it right by dx
JSR MOBDRAW2_SHIFTRIGHT
MOBINITCS2A:
; Calculate dy as y & 7: if the result is not zero,
; it means that the drawing is not aligned with the
; top border of the image.
LDA MOBY
AND #$07
STA MOBDRAW_DY
BEQ MOBINITCS2B
; If not aligned, we must shift it down by dy
JSR MOBDRAW2_SHIFTDOWN
MOBINITCS2B:
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; MOBSAVE(X:indeX) -> chipset
MOBSAVE:
LDA (CURRENTMODE)
CMP #8
BNE MOBSAVE8X
JMP MOBSAVE8
MOBSAVE8X:
CMP #9
BNE MOBSAVE9X
JMP MOBSAVE9
MOBSAVE9X:
CMP #10
BNE MOBSAVE10X
JMP MOBSAVE10
MOBSAVE10X:
CMP #11
BNE MOBSAVE11X
JMP MOBSAVE11
MOBSAVE11X:
CMP #13
BNE MOBSAVE13X
JMP MOBSAVE13
MOBSAVE13X:
CMP #15
BNE MOBSAVE15X
JMP MOBSAVE15
MOBSAVE15X:
CMP #12
BNE MOBSAVE12X
JMP MOBSAVE12
MOBSAVE12X:
CMP #14
BNE MOBSAVE14X
JMP MOBSAVE14
MOBSAVE14X:
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SAVE MODE 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; This routine will increment the position of the operation to the
; next byte (row) of the current cell.
MOBSAVE2_INC:
CLC
LDA MOBADDR
ADC #1
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
CLC
LDA PLOTDEST
ADC #1
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
RET
MOBSAVE8:
MOBSAVE10:
MOBSAVE13:
MOBSAVE14:
RET
; This entry point is needed do save the screen into the reserved area,
; in standard BITMAP MODE (2).
MOBSAVE9:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT4VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT4VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBSAVECOMMON
MOBSAVE11:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBSAVECOMMON
MOBSAVE15:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
ROR MOBDESCRIPTORS_XH,X ;rotate the high byte into carry flag
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT6VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT6VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBSAVECOMMON
MOBSAVE12:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
ROR MOBDESCRIPTORS_XH,X ;rotate the high byte into carry flag
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBSAVECOMMON
MOBSAVECOMMON:
LDX MOBI
LDA (IX+15)
STA MOBSIZE
LDA MOBDESCRIPTORS_SIZEH,X
STA MOBSIZE+1
JSR MOBALLOC
LDA MOBADDR
STA MOBDESCRIPTORS_SL, X
LDA MOBADDR+1
STA MOBDESCRIPTORS_SH, X
; +---+---...---+---+
; |xxx|xxxxxxxxx|xxx|
; +---+---...---+---+
; | | | |
; . . . .
; | | | |
; +---+---...---+---+
; | | | |
; +---+---...---+---+
LDX MOBI
; Calculate how many times we have to repeat
; the row copying. If the image's height is less than
; 0 pixels, we skip this part.
LDA (IX+10)
BNE MOBSAVE2L3X1
JMP MOBSAVE2L3
MOBSAVE2L3X1:
CLC
ADC #8
STA MOBDRAW_I
; Calculate how many times we have to repeat
; the cell copying. If the image's width is less than
; 9 pixels, we skip this part.
LDA (IX+9)
LSR
LSR
LSR
BNE MOBSAVE2L3X2
JMP MOBSAVE2L3
MOBSAVE2L3X2:
CLC
ADC #1
STA MOBDRAW_J
STA MOBDRAW_C
; Repeate an entire cell copy for each column
MOBSAVE2L2A:
LDY #0
MOBSAVE2L2:
LDA (PLOTDEST),Y ; D
STA (MOBADDR),Y ; S
INY
DEC MOBDRAW_J
BEQ MOBSAVE2L2X
JMP MOBSAVE2L2
MOBSAVE2L2X:
CLC
LDA PLOTDEST
ADC CURRENTSL
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
CLC
LDA MOBADDR
ADC MOBDRAW_C
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
LDA MOBDRAW_C
STA MOBDRAW_J
DEC MOBDRAW_I
BEQ MOBSAVE2L2AX
JMP MOBSAVE2L2A
MOBSAVE2L2AX:
MOBSAVE2L3:
RET
; MOBRESTORE(X:indeX) -> chipset
MOBRESTORE:
LDA (CURRENTMODE)
CMP #8
BNE MOBRESTORE8X
JMP MOBRESTORE8
MOBRESTORE8X:
CMP #9
BNE MOBRESTORE9X
JMP MOBRESTORE9
MOBRESTORE9X:
CMP #10
BNE MOBRESTORE10X
JMP MOBRESTORE10
MOBRESTORE10X:
CMP #11
BNE MOBRESTORE11X
JMP MOBRESTORE11
MOBRESTORE11X:
CMP #13
BNE MOBRESTORE13X
JMP MOBRESTORE13
MOBRESTORE13X:
CMP #15
BNE MOBRESTORE15X
JMP MOBRESTORE15
MOBRESTORE15X:
CMP #12
BNE MOBRESTORE12X
JMP MOBRESTORE12
MOBRESTORE12X:
CMP #14
BNE MOBRESTORE14X
JMP MOBRESTORE14
MOBRESTORE14X:
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; RESTORE MODE 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; This routine will do a simple copy of the screen pixels over the
; save area one, replacing them.
MOBRESTORE2_COPY:
LDY #0
LDA (MOBADDR),Y ; S
; LDA #$AA
STA (PLOTDEST),Y ; D
RET
; This routine will increment the position of the operation to the
; next byte (row) of the current cell.
MOBRESTORE2_INC:
CLC
LDA MOBADDR
ADC #1
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
CLC
LDA PLOTDEST
ADC #1
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
RET
MOBRESTORE2_INCL:
CLC
LDA PLOTDEST
ADC CURRENTSL
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
SEC
LDA PLOTDEST
SBC MOBDRAW_C
STA PLOTDEST
LDA PLOTDEST+1
SBC #0
STA PLOTDEST+1
RET
MOBRESTORE8:
MOBRESTORE10:
MOBRESTORE13:
MOBRESTORE14:
RET
; This entry point is needed do save the screen into the reserved area,
; in standard BITMAP MODE (2).
MOBRESTORE9:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_PYL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_PXL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT4VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT4VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBRESTORECOMMON
MOBRESTORE11:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_PYL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_PXL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBRESTORECOMMON
MOBRESTORE15:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_PYL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_PXL,X
ROR MOBDESCRIPTORS_PXH,X
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT6VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT6VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBRESTORECOMMON
MOBRESTORE12:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_PYL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_PXL,X
ROR MOBDESCRIPTORS_PXH,X
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBRESTORECOMMON
MOBRESTORECOMMON:
LDX MOBI
LDA MOBDESCRIPTORS_SL, X
STA MOBADDR
LDA MOBDESCRIPTORS_SH, X
STA MOBADDR+1
; +---+---...---+---+
; |xxx|xxxxxxxxx|xxx|
; +---+---...---+---+
; | | | |
; . . . .
; | | | |
; +---+---...---+---+
; | | | |
; +---+---...---+---+
LDX MOBI
; Calculate how many times we have to repeat
; the row copying. If the image's height is less than
; 8 pixels, we skip this part.
LDA (IX+10)
STA MOBH
LSR
LSR
LSR
BEQ MOBRESTORE2L3
CLC
ADC #1
STA MOBDRAW_R
; Calculate how many times we have to repeat
; the cell copying. If the image's width is less than
; 9 pixels, we skip this part.
LDA (IX+9)
LSR
LSR
LSR
BEQ MOBRESTORE2L3
CLC
ADC #1
STA MOBDRAW_J
STA MOBDRAW_C
ASL
ASL
ASL
STA MOBW
; Repeate an entire cell copy for each column
MOBRESTORE2L2A:
MOBRESTORE2L2:
JSR MOBRESTORE2_COPY
JSR MOBRESTORE2_INC
DEC MOBDRAW_J
BNE MOBRESTORE2L2A
JSR MOBRESTORE2_INCL
LDA MOBDRAW_C
STA MOBDRAW_J
DEC MOBDRAW_I
BNE MOBRESTORE2L2A
MOBRESTORE2L3:
LDX MOBI
LDA (IX+15)
STA MOBSIZE
LDA MOBDESCRIPTORS_SIZEH,X
STA MOBSIZE+1
JSR MOBFREE
LDA #0
STA MOBDESCRIPTORS_SL, X
LDA #0
STA MOBDESCRIPTORS_SH, X
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Chipset specific drawing routine
; MOBDRAW(X:indeX) -> chipset
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOBDRAW:
LDA (CURRENTMODE)
CMP #8
BNE MOBDRAW8X
JMP MOBDRAW8
MOBDRAW8X:
CMP #9
BNE MOBDRAW9X
JMP MOBDRAW9
MOBDRAW9X:
CMP #10
BNE MOBDRAW10X
JMP MOBDRAW10
MOBDRAW10X:
CMP #11
BNE MOBDRAW11X
JMP MOBDRAW11
MOBDRAW11X:
CMP #13
BNE MOBDRAW13X
JMP MOBDRAW13
MOBDRAW13X:
CMP #15
BNE MOBDRAW15X
JMP MOBDRAW15
MOBDRAW15X:
CMP #12
BNE MOBDRAW12X
JMP MOBDRAW12
MOBDRAW12X:
CMP #14
BNE MOBDRAW14X
JMP MOBDRAW14
MOBDRAW14X:
RET
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; DRAW MODE 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; This routine will do nothing, by skipping the
; number of bytes (rows in a cell) given by
; MOBDRAW_DY parameters.
MOBDRAW2_NOP:
LDA MOBDRAW_DY
STA MOBDRAW_TMP
BEQ MOBDRAW2_NOPE
MOBDRAW2_NOPL1:
CLC
LDA MOBADDR
ADC MOBDRAW_C
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
CLC
LDA PLOTDEST
ADC CURRENTSL
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
DEC MOBDRAW_TMP
BNE MOBDRAW2_NOPL1
MOBDRAW2_NOPE:
RET
; This routine will do nothing, by skipping the
; number of bytes (rows in a cell) given by
; 8-MOBDRAW_DY parameters.
MOBDRAW2_NOP2:
CLC
LDA MOBADDR
ADC #1
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
CLC
LDA PLOTDEST
ADC #1
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
RET
; This routine will do a "left mask", by taking the original pixels
; from the drawing, protecting the first MOBDRAW_DX pixels and
; replacing the others.
MOBDRAW2_LEFTMASK:
LDX MOBDRAW_DX
LDA MOBDRAW2_MASKX,X ; maskX
EOR #$FF ; ~ maskX
LDY #0
AND (PLOTDEST),Y ; B & ~ maskX
STA MOBDRAW_TMP
LDX MOBDRAW_DX
LDA MOBDRAW2_MASKX,X ; maskX
LDY #0
AND (MOBADDR),Y ; S & maskX
ORA MOBDRAW_TMP
STA (PLOTDEST),Y
RET
; This routine will do a "right mask", by taking the original pixels
; from the drawing, protecting the last MOBDRAW_DX pixels and
; replacing the others.
MOBDRAW2_RIGHTMASK:
LDX MOBDRAW_DX
LDA MOBDRAW2_MASKX,X ; maskX
LDY #0
AND (PLOTDEST),Y ; B & maskX
STA MOBDRAW_TMP
LDX MOBDRAW_DX
LDA MOBDRAW2_MASKX,X ; maskX
EOR #$FF ; ~ maskX
LDY #0
AND (MOBADDR),Y ; S & ~ maskX
ORA MOBDRAW_TMP
STA (PLOTDEST),Y
RET
; This routine will do a simple copy of the drawing pixels over the
; original one, replacing them.
MOBDRAW2_COPY:
LDY #0
LDA (MOBADDR),Y ; S
STA (PLOTDEST),Y ; D
RET
; This routine will increment the position of the operation to the
; next byte (row) of the current cell.
MOBDRAW2_INC:
CLC
LDA MOBADDR
ADC #1
STA MOBADDR
LDA MOBADDR+1
ADC #0
STA MOBADDR+1
CLC
LDA PLOTDEST
ADC #1
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
RET
MOBDRAW2_INCL:
CLC
LDA PLOTDEST
ADC CURRENTSL
STA PLOTDEST
LDA PLOTDEST+1
ADC #0
STA PLOTDEST+1
SEC
LDA PLOTDEST
SBC MOBDRAW_C
STA PLOTDEST
LDA PLOTDEST+1
SBC #$0
STA PLOTDEST+1
RET
MOBDRAW2:
MOBDRAW8:
MOBDRAW10:
MOBDRAW13:
MOBDRAW14:
RET
; This entry point is needed do draw the image over the screen,
; in standard BITMAP MODE (2).
MOBDRAW9:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT4VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT4VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBDRAWCOMMON
MOBDRAW11:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
LSR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBDRAWCOMMON
MOBDRAW15:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
ROR MOBDESCRIPTORS_XH,X ;rotate the high byte into carry flag
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT6VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT6VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBDRAWCOMMON
MOBDRAW12:
;-------------------------
;calc Y-cell
;-------------------------
LDA MOBDESCRIPTORS_YL,X
TAY ;tbl_8,y index
LDA MOBDESCRIPTORS_XL,X
ROR MOBDESCRIPTORS_XH,X ;rotate the high byte into carry flag
ROR ;lo byte / 2
LSR ;lo byte / 4
LSR ;lo byte / 8
TAX ;tbl_8,x index
;----------------------------------
;add x & y to calc cell point is in
;----------------------------------
CLC
TXA
ADC PLOT5VBASELO,Y ;table of $9C40 row base addresses
STA PLOTDEST ;= cell address
LDA #0
ADC PLOT5VBASEHI,Y ;do the high byte
STA PLOTDEST+1
JMP MOBDRAWCOMMON
MOBDRAWCOMMON:
LDX MOBI
LDA (IX+11)
STA MOBADDR
LDA (IX+12)
STA MOBADDR+1
; Calculate how many times we have to repeat
; the cell copying. If the image's width is less than
; 9 pixels, we skip this part.
LDA (IX+9)
LSR
LSR
LSR
BNE MOBDRAW2EX
JMP MOBDRAW2E
MOBDRAW2EX:
ADC #1
STA MOBDRAW_C
STA MOBDRAW_J
ASL
ASL
ASL
STA MOBW
; Calculate how many times we have to repeat
; the row copying. If the image's height is less than
; 8 pixels, we skip this part.
LDA (IX+10)
LSR
LSR
LSR
BNE MOBDRAW2L6X
JMP MOBDRAW2E
MOBDRAW2L6X:
CLC
ADC #1
STA MOBDRAW_R
ASL
ASL
ASL
STA MOBH
STA MOBDRAW_I
LDX MOBI
; Calculate the effective offset of the image,
; in order to know how many pixels we have to
; skip / mask.
LDA MOBDESCRIPTORS_YL, X
AND #$07
STA MOBDRAW_DY
STA MOBDRAW_DY2
STA MOBDRAW_I
LDA MOBDESCRIPTORS_XL, X
AND #$07
STA MOBDRAW_DX
; Skip DY rows
; JSR MOBDRAW2_NOP
LDA MOBH
SEC
SBC #8
STA MOBH
STA MOBDRAW_I
; +---+---...---+---+
; |XXX|xxxxxxxxx|XXX|
; +---+---...---+---+
; | | | |x
; . . . .x
; | | | |x
; +---+---...---+---+x
; | | | |V
; +---+---...---+---+
DEC MOBDRAW_J
MOBDRAW2L1A:
JSR MOBDRAW2_LEFTMASK
JSR MOBDRAW2_INC
DEC MOBDRAW_J
MOBDRAW2L1:
JSR MOBDRAW2_COPY
JSR MOBDRAW2_INC
DEC MOBDRAW_J
BNE MOBDRAW2L1
JSR MOBDRAW2_RIGHTMASK
JSR MOBDRAW2_INC
JSR MOBDRAW2_INCL
; Calculate how many times we have to repeat
; the cell copying. If the image's width is less than
; 9 pixels, we skip this part.
LDA MOBDRAW_C
STA MOBDRAW_J
DEC MOBDRAW_J
DEC MOBDRAW_I
BEQ MOBDRAW2L1X
JMP MOBDRAW2L1A
MOBDRAW2L1X:
MOBDRAW2L6:
MOBDRAW2E:
RET
MOBATCS:
LDX MOBI
; Now we must adjust the image inside the larger
; clip, by right and bottom shifting it, accordingly
; to the (relative) position (x,y)
;
; DX for *next* position (DXn)
LDA MOBDESCRIPTORS_XL, X
STA MOBX
AND #$07
STA MOBDRAW_DX
; DX for *previous* position (DXp)
LDA MOBDESCRIPTORS_PXL, X
AND #$07
; DX = (DXp-DXn)
; So: if DX > 0 ---> DXp > DXn ---> shift left
; if DX < 0 ---> DXp < DXn ---> shift right
SEC
SBC MOBDRAW_DX
STA MOBDRAW_DX
; DY for *next* position (DYn)
LDA MOBDESCRIPTORS_YL, X
STA MOBY
AND #$07
STA MOBDRAW_DY
; DY for *previous* position (DYp)
LDA MOBDESCRIPTORS_PYL, X
AND #$07
; DY = (DYp-DYn)
; So: if DY > 0 ---> DYp > DYn ---> shift up
; if DY < 0 ---> DYp < DYn ---> shift down
SEC
SBC MOBDRAW_DY
STA MOBDRAW_DY
LDA MOBDRAW_DX
BEQ MOBATCS_VERT
AND $80
BEQ MOBATCS_LEFT
MOBATCS_RIGHT:
LDA MOBDRAW_DX
CLC
EOR #$FF
ADC #1
STA MOBDRAW_DX
JSR MOBDRAW2_SHIFTRIGHT
JMP MOBATCS_VERT
MOBATCS_LEFT:
JSR MOBDRAW2_SHIFTLEFT
JMP MOBATCS_VERT
MOBATCS_VERT:
LDA MOBDRAW_DY
BEQ MOBATCS_DONE
AND #$80
BEQ MOBATCS_UP
MOBATCS_DOWN:
LDA MOBDRAW_DY
CLC
EOR #$FF
ADC #1
STA MOBDRAW_DY
; JSR MOBDRAW2_SHIFTDOWN
JMP MOBATCS_DONE
MOBATCS_UP:
; JSR MOBDRAW2_SHIFTUP
MOBATCS_DONE:
RET
; Mask for bit selection / unselection on a single cell
; during drawing operations.
MOBDRAW2_MASKX:
DB %11111111
DB %01111111
DB %00111111
DB %00011111
DB %00001111
DB %00000111
DB %00000011
DB %00000001
| 19.846971
| 80
| 0.514859
|
74a5eca455221ea3fad34c66089ed954a4d89052
| 331
|
asm
|
Assembly
|
programs/oeis/185/A185907.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/185/A185907.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/185/A185907.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A185907: Weight array of A185908, by antidiagonals.
; 1,0,1,0,1,1,0,0,0,1,0,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0
mul $0,2
mov $1,1
lpb $0
cmp $2,0
add $1,$2
sub $0,$1
lpe
cmp $0,$2
| 27.583333
| 201
| 0.540785
|
5f38ef3f06ed55b71b9c532ab2c662d9091e393e
| 711
|
asm
|
Assembly
|
programs/oeis/011/A011851.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/011/A011851.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/011/A011851.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A011851: a(n) = floor(binomial(n,5)/5).
; 0,0,0,0,0,0,1,4,11,25,50,92,158,257,400,600,873,1237,1713,2325,3100,4069,5266,6729,8500,10626,13156,16146,19656,23751,28501,33982,40275,47467,55651,64926,75398,87179,100388,115151,131601,149879,170133,192519,217201,244351,274150,306787,342460,381376,423752,469812,519792,573937,632502,695752,763963,837421,916423,1001277,1092302,1189829,1294200,1405769,1524902,1651977,1787385,1931529,2084825,2247702,2420602,2603981,2798308,3004066,3221752,3451878,3694968,3951563,4222218,4507503,4808003,5124319,5457067,5806879,6174403,6560303,6965260,7389971,7835150,8301528,8789853,9300891,9835425,10394256,10978203,11588103,12224812,12889204,13582172,14304628
bin $0,5
div $0,5
| 118.5
| 649
| 0.819972
|
349a1b8997571cf8bab0347a6b253a353596839b
| 251
|
asm
|
Assembly
|
programs/oeis/070/A070716.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/070/A070716.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/070/A070716.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A070716: n^7 mod 35.
; 0,1,23,17,4,5,6,28,22,9,10,11,33,27,14,15,16,3,32,19,20,21,8,2,24,25,26,13,7,29,30,31,18,12,34,0,1,23,17,4,5,6,28,22,9,10,11,33,27,14,15,16,3,32,19,20,21,8,2,24,25,26,13,7,29,30,31,18,12,34,0,1,23,17,4,5,6
pow $0,7
mod $0,35
| 41.833333
| 207
| 0.613546
|
47a57f62daff86ca72aaa7b3afb631f0bd5694bd
| 123
|
asm
|
Assembly
|
util/dummy/prcname.asm
|
olifink/smsqe
|
c546d882b26566a46d71820d1539bed9ea8af108
|
[
"BSD-2-Clause"
] | null | null | null |
util/dummy/prcname.asm
|
olifink/smsqe
|
c546d882b26566a46d71820d1539bed9ea8af108
|
[
"BSD-2-Clause"
] | null | null | null |
util/dummy/prcname.asm
|
olifink/smsqe
|
c546d882b26566a46d71820d1539bed9ea8af108
|
[
"BSD-2-Clause"
] | null | null | null |
; Dummies for Pocedures name
section dummy
xdef prc_name
prc_name dc.w 10,'Procedures'
end
| 13.666667
| 31
| 0.593496
|
a23421875b33544cd9affa716fd7ec8ec6fd4467
| 3,540
|
asm
|
Assembly
|
nasm/strings/strcpy.asm
|
codingneverends/assembly
|
dcac8cf841abd64d0a386105daf6c926ab2b124d
|
[
"MIT"
] | null | null | null |
nasm/strings/strcpy.asm
|
codingneverends/assembly
|
dcac8cf841abd64d0a386105daf6c926ab2b124d
|
[
"MIT"
] | null | null | null |
nasm/strings/strcpy.asm
|
codingneverends/assembly
|
dcac8cf841abd64d0a386105daf6c926ab2b124d
|
[
"MIT"
] | null | null | null |
;Cpying string
section .data
newline :db 10
space :db ' '
msg1 : db "Enter a String : "
size1 : equ $-msg1
msg2 : db "Copied as : "
size2 : equ $-msg2
section .bss
string1 : resb 50
string2 : resb 50
temp : resb 1
len : resb 1
count : resb 1
num : resb 1
section .text
global _start
_start :
mov eax, 4
mov ebx, 1
mov ecx, msg1
mov edx, size1
int 80h
mov ebx,string1
call readstring
;mov ebx,string1
;call toLoweCase
;call strlen
;mov cx,word[len]
;mov word[num],cx
;call print_num
mov eax,0
Loop :
mov ebx,string1
mov dl,byte[ebx+eax]
cmp dl,0
je endLoop
mov ebx,string2
mov byte[ebx+eax],dl
inc eax
jmp Loop
endLoop :
mov ebx,string2
mov byte[ebx+eax],dl
mov eax, 4
mov ebx, 1
mov ecx, msg2
mov edx, size2
int 80h
mov ebx,string2
call printstring
mov eax, 1
mov ebx, 0
int 80h
readstring :
start_readstring :
push ebx
mov eax, 3
mov ebx, 0
mov ecx, temp
mov edx, 1
int 80h
pop ebx
cmp byte[temp],10
je end_readstring
mov al,byte[temp]
mov byte[ebx],al
inc ebx
jmp start_readstring
end_readstring:
mov byte[ebx],0
ret
printstring :
start_printstring :
mov dl,byte[ebx]
mov byte[temp],dl
cmp byte[temp],0
je end_printstring
push ebx
mov eax,4
mov ebx,1
mov ecx,temp
mov edx,1
int 80h
pop ebx
inc ebx
jmp start_printstring
end_printstring :
mov eax, 4
mov ebx, 1
mov ecx, newline
mov edx, 1
int 80h
ret
;UpeerCase and LowerCase verthe ezhuthi nokkitha , ellayidatum indavum karyam akkanda , eduthu kalanjekkuu
toLoweCase :
start_convert_tolow :
mov dl,byte[ebx]
mov byte[temp],dl
cmp byte[temp],0
je end_convert_tolow
cmp dl,94
ja skip_low_convert
add dl,32
mov byte[ebx],dl
skip_low_convert :
inc ebx
jmp start_convert_tolow
end_convert_tolow :
ret
toUpperCase :
start_convert_toup :
mov dl,byte[ebx]
mov byte[temp],dl
cmp byte[temp],0
je end_convert_toup
cmp dl,94
jb skip_up_convert
sub dl,32
mov byte[ebx],dl
skip_up_convert :
inc ebx
jmp start_convert_toup
end_convert_toup :
ret
strlen :
mov byte[len],0
start_strlen :
mov dl,byte[ebx]
mov byte[temp],dl
cmp byte[temp],0
je end_strlen
inc byte[len]
inc ebx
jmp start_strlen
end_strlen :
ret
print_num:
mov byte[count],0
cmp word[num],0
jne skip___
mov word[temp],30h
mov eax, 4
mov ebx, 1
mov ecx, temp
mov edx, 1
int 80h
skip___ :
extract_no :
cmp word[num], 0
je print_no
inc byte[count]
mov dx, 0
mov ax, word[num]
mov bx, 10
div bx
push dx
mov word[num], ax
jmp extract_no
print_no :
cmp byte[count], 0
je end_print
dec byte[count]
pop dx
mov byte[temp], dl
add byte[temp], 30h
mov eax, 4
mov ebx, 1
mov ecx, temp
mov edx, 1
int 80h
jmp print_no
end_print :
mov eax,4
mov ebx,1
mov ecx,newline
mov edx,1
int 80h
ret
| 18.153846
| 106
| 0.54548
|
aed2bb5065a88d8eba2fc047b95b04228bbae1e0
| 63
|
asm
|
Assembly
|
ROM_04.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 11
|
2021-04-08T14:24:52.000Z
|
2022-03-25T00:45:27.000Z
|
ROM_04.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 3
|
2021-09-17T03:10:36.000Z
|
2021-09-17T03:16:45.000Z
|
ROM_04.asm
|
neilbaldwin/Pulsar
|
8cc11ab4cb4117dc44022b7645b02f777a672bf2
|
[
"BSD-2-Clause-FreeBSD"
] | 1
|
2021-04-08T14:24:54.000Z
|
2021-04-08T14:24:54.000Z
|
.segment "CODE_04"
.include "pulsar.h"
.include "hints.asm"
| 12.6
| 21
| 0.68254
|
174df4c389ffa5aeb98f10df82ad81fef4efe36a
| 342
|
asm
|
Assembly
|
libsrc/target/newbrain/break_status.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/target/newbrain/break_status.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/target/newbrain/break_status.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
;
; Grundy Newbrain Specific libraries
;
; Stefano Bodrato - 30/03/2007
;
;
; Check if user pressed BREAK
; 1 if BREAK, otherwise 0
;
;
;
; $Id: break_status.asm,v 1.4 2016-06-19 20:33:40 dom Exp $
;
SECTION code_clib
PUBLIC break_status
PUBLIC _break_status
.break_status
._break_status
rst 20h
defb 36h
ld hl,1
ret c
dec hl
ret
| 12.214286
| 59
| 0.707602
|
a2b6fae23a7de29c61ecf796188ff3d21c0252c6
| 1,436
|
asm
|
Assembly
|
programs/oeis/083/A083098.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/083/A083098.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/083/A083098.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A083098: a(n) = 2*a(n-1) + 6*a(n-2).
; 1,1,8,22,92,316,1184,4264,15632,56848,207488,756064,2757056,10050496,36643328,133589632,487039232,1775616256,6473467904,23600633344,86042074112,313687948288,1143628341248,4169384372224,15200538791936,55417383817216,202038000386048,736580303675392,2685388609667072,9790259041386496,35692849740775424,130127253729869824,474411605904392192,1729586734188003328,6305643103802359808,22988806612732739584,83811471848279638016,305555783372955713536,1113980397835589255168,4061295495908912791552,14806473378831361114112,53980719733116198977536,196800279739220564639744,717484877877138323144704,2615771434189600034127872,9536452135642030007123968,34767532876421660219015168,126753778566695500480774144,462112754391920962275639296,1684748180184014927435923456,6142172886719555628525682688,22392834854543200821666906112,81638707029403735414487908352,297634423186066675758977253376,1085101088548555764004881956864,3956008716213511582563627433984,14422623963718357749156546609152,52581300224717784993694857822208,191698344231745716482328995299328,698884489811798142926827137531904,2547959045014070584747628246859776,9289225028898930027056219318910976,33866204327882283562598208118980608,123467758829158147287533732151427072,450132743625609995950656713016737792
lpb $0
mov $2,$0
sub $0,1
trn $2,1
seq $2,291008 ; p-INVERT of (1,1,1,1,1,...), where p(S) = 1 - 7*S^2.
add $1,$2
lpe
add $1,1
mov $0,$1
| 110.461538
| 1,248
| 0.885097
|
c1dc9df5df3c1825bba4fc78a4c6b751e430c4eb
| 317
|
asm
|
Assembly
|
programs/oeis/271/A271216.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/271/A271216.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/271/A271216.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A271216: a(n) = 2^n floor(n/2)!
; 1,2,4,8,32,64,384,768,6144,12288,122880,245760,2949120,5898240,82575360,165150720,2642411520,5284823040,95126814720,190253629440,3805072588800
mov $3,$0
add $0,3
mov $2,$0
mul $3,2
div $3,4
fac $3
mul $3,2
mov $1,$3
lpb $2,1
mul $1,2
sub $2,1
lpe
sub $1,16
div $1,16
add $1,1
| 16.684211
| 144
| 0.675079
|
6813ccd4fecb5f81f8fe42f6ede1fe2a2b41e136
| 1,784
|
asm
|
Assembly
|
ASM/src/cutscenes.asm
|
ShadoMagi/OoT-Randomizer
|
f9abb00a299e2f50f52fee4962047f8ab7f84975
|
[
"MIT"
] | null | null | null |
ASM/src/cutscenes.asm
|
ShadoMagi/OoT-Randomizer
|
f9abb00a299e2f50f52fee4962047f8ab7f84975
|
[
"MIT"
] | null | null | null |
ASM/src/cutscenes.asm
|
ShadoMagi/OoT-Randomizer
|
f9abb00a299e2f50f52fee4962047f8ab7f84975
|
[
"MIT"
] | null | null | null |
override_great_fairy_cutscene:
; a0 = global context
; a2 = fairy actor
lw t0, 0x1D2C (a0) ; t0 = switch flags
li t1, 1
sll t1, t1, 0x18 ; t1 = ZL switch flag
and v0, t0, t1
beqz v0, @@return ; Do nothing until ZL is played
nop
lhu t2, 0x02DC (a2) ; Load fairy index
li t3, SAVE_CONTEXT
lhu t4, 0xA4 (a0) ; Load scene number
beq t4, 0x3D, @@item_fairy
nop
; Handle upgrade fairies
addu t4, a0, t2
lbu t5, 0x1D28 (t4) ; t5 = chest flag for this fairy
bnez t5, @@return ; Use default behavior if the item is already obtained
nop
li t5, 1
sb t5, 0x1D28 (t4) ; Mark item as obtained
addiu t2, t2, 3 ; t2 = index of the item in FAIRY_ITEMS
b @@give_item
nop
@@item_fairy:
li t4, 1
sllv t4, t4, t2 ; t4 = fairy item mask
lbu t5, 0x0EF2 (t3) ; t5 = fairy item flags
and t6, t5, t4
bnez t6, @@return ; Use default behavior if the item is already obtained
nop
or t6, t5, t4
sb t6, 0x0EF2 (t3) ; Mark item as obtained
@@give_item:
; Unset ZL switch
nor t1, t1, t1
and t0, t0, t1
sw t0, 0x1D2C (a0)
; Load fairy item and mark it as pending
li t0, FAIRY_ITEMS
addu t0, t0, t2
lb t0, 0x00 (t0)
li t1, PENDING_SPECIAL_ITEM
sb t0, 0x00 (t1)
li v0, 0 ; Prevent fairy animation
@@return:
jr ra
nop
;==================================================================================================
override_light_arrow_cutscene:
li t0, LIGHT_ARROW_ITEM
lb t0, 0x00 (t0)
li t1, PENDING_SPECIAL_ITEM
sb t0, 0x00 (t1)
jr ra
nop
| 26.626866
| 99
| 0.520179
|
22c01a0e7805c619c4f243a6d07debb41746e1b7
| 839
|
asm
|
Assembly
|
ASPL/factorial.asm
|
timo-cmd/ASPL
|
fe9d959f97353c048e28b1d6b5d4d4679e33cc5e
|
[
"MIT"
] | 1
|
2020-05-22T09:33:31.000Z
|
2020-05-22T09:33:31.000Z
|
ASPL/factorial.asm
|
timo-cmd/ASPL
|
fe9d959f97353c048e28b1d6b5d4d4679e33cc5e
|
[
"MIT"
] | 6
|
2020-06-03T17:02:05.000Z
|
2020-07-18T06:06:29.000Z
|
ASPL/factorial.asm
|
timo-cmd/ASPL
|
fe9d959f97353c048e28b1d6b5d4d4679e33cc5e
|
[
"MIT"
] | null | null | null |
.data
.equals string ' * 1 = '
.counter 7
.result 7
.times string ' * '
.text
.global main:
factorial:
lda A, .counter
psh A
; Print counter
mov B, A
mvi A, 0
mvi C, 0
sys
pop A
mvi B, 3
mvi D, done:
jlt A, B, D
psh a
psh b
psh c
mvi a, 0
mvi b, .times
mvi c, 4
sys
pop c
pop b
pop a
mov B, A
dec B
lda C, .result
mul C, B
ldm C, .result
ldm B, .counter
mvi A, factorial:
jmr A
done:
psh a
psh b
psh c
mvi a, 0
mvi b, .equals
mvi c, 4
sys
pop c
pop b
pop a
ret
main:
mvi A, factorial:
cal A
; Print result
mvi A, 0
mvi D, .result
ldr B, D
mvi C, 0
sys
; Print newline
mvi B, 10
mvi C, 3
sys
hlt
| 10.4875
| 26
| 0.45888
|
fc9dd1eaf8275622d14c7e518177644ed8a80512
| 197
|
asm
|
Assembly
|
test/unittest_get_module_size.asm
|
fabiankuffer/RISC-V-QR-Code-Generator
|
88f4d1db2e02841203519423a870f9fdd0c3e221
|
[
"MIT"
] | null | null | null |
test/unittest_get_module_size.asm
|
fabiankuffer/RISC-V-QR-Code-Generator
|
88f4d1db2e02841203519423a870f9fdd0c3e221
|
[
"MIT"
] | null | null | null |
test/unittest_get_module_size.asm
|
fabiankuffer/RISC-V-QR-Code-Generator
|
88f4d1db2e02841203519423a870f9fdd0c3e221
|
[
"MIT"
] | null | null | null |
.include "qr_data.asm"
.text
addi a1, zero, 1
jal ra, get_module_size
#beendet das programm
li a7, 10
ecall
#muss am ende stehen sonst wird der code dort drin ausgeführt
.include "qr_draw.asm"
| 15.153846
| 61
| 0.751269
|
ac51514bf839372b428cbefff230027030e4cff8
| 804
|
asm
|
Assembly
|
programs/oeis/208/A208086.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/208/A208086.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/208/A208086.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A208086: Number of 4 X (n+1) 0..1 arrays with every 2 X 2 subblock having the same number of equal edges as its horizontal neighbors and a different number from its vertical neighbors, and new values 0..1 introduced in row major order.
; 24,56,134,344,888,2318,6056,15848,41478,108584,284264,744206,1948344,5100824,13354118,34961528,91530456,239629838,627359048,1642447304,4299982854,11257501256,29472520904,77160061454,202007663448,528862928888,1384581123206,3624880440728,9490060198968,24845300156174,65045840269544,170292220652456,445830821687814,1167200244410984,3055769911545128,8000109490224398
add $0,3
mov $1,1
mov $3,1
lpb $0,1
sub $0,1
mov $2,$3
mov $4,$1
add $1,1
add $2,$1
mov $1,$2
sub $1,2
mov $3,2
add $3,$4
lpe
add $1,1
pow $1,2
sub $1,35
div $1,4
mul $1,2
add $1,24
| 33.5
| 364
| 0.75995
|
d396c6d690ac83b13c52d2f1eba8ef91016f4c35
| 848
|
asm
|
Assembly
|
src/firmware-tests/Platform/Arithmetic32/SignExtend/SignExtendToUpperWordATest.asm
|
pete-restall/Cluck2Sesame-Prototype
|
99119b6748847a7b6aeadc4bee42cbed726f7fdc
|
[
"MIT"
] | 1
|
2019-12-12T09:07:08.000Z
|
2019-12-12T09:07:08.000Z
|
src/firmware-tests/Platform/Arithmetic32/SignExtend/SignExtendToUpperWordATest.asm
|
pete-restall/Cluck2Sesame-Prototype
|
99119b6748847a7b6aeadc4bee42cbed726f7fdc
|
[
"MIT"
] | null | null | null |
src/firmware-tests/Platform/Arithmetic32/SignExtend/SignExtendToUpperWordATest.asm
|
pete-restall/Cluck2Sesame-Prototype
|
99119b6748847a7b6aeadc4bee42cbed726f7fdc
|
[
"MIT"
] | null | null | null |
#include "Platform.inc"
#include "FarCalls.inc"
#include "Arithmetic32.inc"
#include "TestFixture.inc"
radix decimal
udata
global expectedRAA
global expectedRAB
global expectedRAC
global expectedRAD
expectedRAA res 1
expectedRAB res 1
expectedRAC res 1
expectedRAD res 1
SignExtendToUpperWordATest code
global testArrange
testArrange:
testAct:
fcall signExtendToUpperWordA32
testAssert:
.aliasForAssert RAA, _a
.aliasForAssert expectedRAA, _b
.assert "_a == _b, 'RAA expectation failure.'"
.aliasForAssert RAB, _a
.aliasForAssert expectedRAB, _b
.assert "_a == _b, 'RAB expectation failure.'"
.aliasForAssert RAC, _a
.aliasForAssert expectedRAC, _b
.assert "_a == _b, 'RAC expectation failure.'"
.aliasForAssert RAD, _a
.aliasForAssert expectedRAD, _b
.assert "_a == _b, 'RAD expectation failure.'"
return
end
| 18.042553
| 47
| 0.760613
|
616f35e32b95df379cd7c53a41cfdb826c275bdc
| 8,564
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_15.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_15.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_15.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 %r12
push %r13
push %r8
push %rax
push %rcx
push %rdi
push %rsi
lea addresses_UC_ht+0x14d88, %rsi
lea addresses_WC_ht+0x1bb88, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
add %r10, %r10
mov $62, %rcx
rep movsq
nop
nop
add %r13, %r13
lea addresses_normal_ht+0x109c4, %rax
clflush (%rax)
nop
add $54642, %r12
mov (%rax), %r13w
nop
nop
nop
xor $40848, %rdi
lea addresses_WT_ht+0x75ec, %rsi
lea addresses_UC_ht+0x15388, %rdi
nop
nop
cmp $48855, %r8
mov $60, %rcx
rep movsb
nop
nop
nop
nop
nop
sub %r12, %r12
lea addresses_normal_ht+0x17908, %r8
nop
nop
add $32373, %r13
movb (%r8), %cl
nop
nop
nop
xor %rcx, %rcx
lea addresses_WC_ht+0x1d338, %rcx
nop
nop
nop
add %r12, %r12
mov $0x6162636465666768, %r10
movq %r10, (%rcx)
inc %r8
lea addresses_UC_ht+0x134a8, %rsi
lea addresses_WT_ht+0x308, %rdi
clflush (%rsi)
and %rax, %rax
mov $8, %rcx
rep movsl
cmp %r8, %r8
lea addresses_A_ht+0x94c8, %rdi
nop
add $58238, %r13
mov $0x6162636465666768, %rcx
movq %rcx, %xmm5
vmovups %ymm5, (%rdi)
nop
xor %rax, %rax
lea addresses_WT_ht+0x1e708, %rsi
lea addresses_WT_ht+0x1a408, %rdi
nop
nop
nop
nop
nop
cmp $13193, %r12
mov $80, %rcx
rep movsb
sub %rsi, %rsi
lea addresses_D_ht+0x11b88, %rax
nop
nop
nop
nop
cmp $57178, %rsi
movb (%rax), %r13b
sub $61909, %r12
lea addresses_UC_ht+0x4c38, %rcx
clflush (%rcx)
nop
nop
xor $12387, %r13
mov (%rcx), %eax
nop
nop
nop
inc %rdi
lea addresses_normal_ht+0x1b588, %r12
nop
nop
sub %r10, %r10
mov (%r12), %rsi
nop
nop
cmp $51878, %rsi
lea addresses_normal_ht+0xcb88, %rsi
lea addresses_A_ht+0x17d88, %rdi
clflush (%rsi)
sub %r8, %r8
mov $82, %rcx
rep movsw
nop
nop
nop
nop
nop
dec %r10
lea addresses_WC_ht+0x1518, %rax
nop
nop
nop
mfence
mov $0x6162636465666768, %rdi
movq %rdi, (%rax)
nop
nop
nop
nop
add %r12, %r12
lea addresses_normal_ht+0xf388, %rsi
lea addresses_D_ht+0xf888, %rdi
nop
nop
nop
and $53026, %r12
mov $97, %rcx
rep movsw
nop
nop
nop
nop
nop
inc %r13
lea addresses_WC_ht+0x2a88, %rsi
nop
nop
nop
sub $54150, %rcx
mov $0x6162636465666768, %r12
movq %r12, %xmm6
vmovups %ymm6, (%rsi)
nop
xor %rsi, %rsi
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r8
pop %r13
pop %r12
pop %r10
ret
.global s_faulty_load
s_faulty_load:
push %r12
push %r13
push %r15
push %r9
push %rax
push %rbp
push %rdi
// Load
mov $0x408, %r13
nop
cmp %r12, %r12
mov (%r13), %rax
nop
nop
nop
nop
sub %r13, %r13
// Store
lea addresses_WT+0x1b388, %rbp
nop
nop
nop
sub %r15, %r15
mov $0x5152535455565758, %r12
movq %r12, (%rbp)
nop
nop
and %r13, %r13
// Store
lea addresses_A+0xa388, %r15
nop
nop
nop
nop
sub %rdi, %rdi
movw $0x5152, (%r15)
sub $16303, %rax
// Faulty Load
lea addresses_RW+0x8b88, %rbp
nop
cmp %r9, %r9
mov (%rbp), %edi
lea oracles, %rax
and $0xff, %rdi
shlq $12, %rdi
mov (%rax,%rdi,1), %rdi
pop %rdi
pop %rbp
pop %rax
pop %r9
pop %r15
pop %r13
pop %r12
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 0}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_P', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 7}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 11}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A', 'NT': True, 'AVXalign': False, 'size': 2, 'congruent': 9}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_RW', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 10, 'type': 'addresses_WC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 2}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_WT_ht'}, 'dst': {'same': False, 'congruent': 11, 'type': 'addresses_UC_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': True, 'size': 1, 'congruent': 6}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 4, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_WT_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 4}}
{'OP': 'REPM', 'src': {'same': True, 'congruent': 7, 'type': 'addresses_WT_ht'}, 'dst': {'same': True, 'congruent': 6, 'type': 'addresses_WT_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 9}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_UC_ht', 'NT': False, 'AVXalign': False, 'size': 4, 'congruent': 3}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 9}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 11, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 9, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'same': True, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 3}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 7, 'type': 'addresses_D_ht'}}
{'OP': 'STOR', 'dst': {'same': True, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 8}}
{'32': 21829}
32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32 32
*/
| 32.562738
| 2,999
| 0.655535
|
074fba6bf9dbe7369809d2e34d463f89b82cc887
| 2,448
|
asm
|
Assembly
|
programs/oeis/172/A172202.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/172/A172202.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/172/A172202.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A172202: Number of ways to place 3 nonattacking kings on a 3 X n board.
; 0,0,8,34,105,248,490,858,1379,2080,2988,4130,5533,7224,9230,11578,14295,17408,20944,24930,29393,34360,39858,45914,52555,59808,67700,76258,85509,95480,106198,117690,129983,143104,157080,171938,187705,204408,222074,240730,260403,281120,302908,325794,349805,374968,401310,428858,457639,487680,519008,551650,585633,620984,657730,695898,735515,776608,819204,863330,909013,956280,1005158,1055674,1107855,1161728,1217320,1274658,1333769,1394680,1457418,1522010,1588483,1656864,1727180,1799458,1873725,1950008,2028334,2108730,2191223,2275840,2362608,2451554,2542705,2636088,2731730,2829658,2929899,3032480,3137428,3244770,3354533,3466744,3581430,3698618,3818335,3940608,4065464,4192930,4323033,4455800,4591258,4729434,4870355,5014048,5160540,5309858,5462029,5617080,5775038,5935930,6099783,6266624,6436480,6609378,6785345,6964408,7146594,7331930,7520443,7712160,7907108,8105314,8306805,8511608,8719750,8931258,9146159,9364480,9586248,9811490,10040233,10272504,10508330,10747738,10990755,11237408,11487724,11741730,11999453,12260920,12526158,12795194,13068055,13344768,13625360,13909858,14198289,14490680,14787058,15087450,15391883,15700384,16012980,16329698,16650565,16975608,17304854,17638330,17976063,18318080,18664408,19015074,19370105,19729528,20093370,20461658,20834419,21211680,21593468,21979810,22370733,22766264,23166430,23571258,23980775,24395008,24813984,25237730,25666273,26099640,26537858,26980954,27428955,27881888,28339780,28802658,29270549,29743480,30221478,30704570,31192783,31686144,32184680,32688418,33197385,33711608,34231114,34755930,35286083,35821600,36362508,36908834,37460605,38017848,38580590,39148858,39722679,40302080,40887088,41477730,42074033,42676024,43283730,43897178,44516395,45141408,45772244,46408930,47051493,47699960,48354358,49014714,49681055,50353408,51031800,51716258,52406809,53103480,53806298,54515290,55230483,55951904,56679580,57413538,58153805,58900408,59653374,60412730,61178503,61950720,62729408,63514594,64306305,65104568,65909410,66720858,67538939,68363680
mov $10,$0
mov $12,$0
lpb $12,1
clr $0,10
mov $0,$10
sub $12,1
sub $0,$12
mov $7,$0
mov $9,$0
lpb $9,1
mov $0,$7
sub $9,1
sub $0,$9
sub $0,2
mul $0,9
mov $3,8
lpb $0,1
mov $1,$0
mov $0,2
trn $1,3
mov $2,$1
mul $1,2
add $1,$2
mov $3,$1
lpe
add $8,$3
lpe
add $11,$8
lpe
mov $1,$11
| 72
| 1,997
| 0.798203
|
3a63085d3b9e6140ba2213e1c6cb28dee64d2e4b
| 3,546
|
asm
|
Assembly
|
apps/breakfast/pde_fw/toast/examples/Assembly (CCE)/msp430x24x_hfxt2_nmi.asm
|
tp-freeforall/breakfast
|
0399619cdb7a81b3c3cc4c5a1b7d69f5c32b8c65
|
[
"BSD-3-Clause"
] | 1
|
2020-05-15T18:08:48.000Z
|
2020-05-15T18:08:48.000Z
|
apps/breakfast/toast/msp430-code-examples/Assembly (CCE)/msp430x24x_hfxt2_nmi.asm
|
tp-freeforall/breakfast
|
0399619cdb7a81b3c3cc4c5a1b7d69f5c32b8c65
|
[
"BSD-3-Clause"
] | null | null | null |
apps/breakfast/toast/msp430-code-examples/Assembly (CCE)/msp430x24x_hfxt2_nmi.asm
|
tp-freeforall/breakfast
|
0399619cdb7a81b3c3cc4c5a1b7d69f5c32b8c65
|
[
"BSD-3-Clause"
] | null | null | null |
;*******************************************************************************
; MSP430x24x Demo - Basic Clock, LFXT1/MCLK Sourced from HF XTAL, NMI
;
; Description: Proper selection of an external HF XTAL for MCLK is shown with
; enabled OSC fault interrupt - if HF XTAL fails, NMI interrupt is requested.
; HF XTAL can only source MCLK when OSC fault is clear. For demonstration
; purposes P1.0 is set during OSC fault. MCLK/10 is on P1.1.
; ACLK = MCLK = LFXT1 = HFXTAL
; //* HF XTAL NOT INSTALLED ON FET *//
; //* Min Vcc required varies with MCLK frequency - refer to datasheet *//
;
; MSP430F249
; -----------------
; /|\| XIN|-
; | | | HF XTAL (3 16MHz crystal or resonator)
; --|RST XOUT|-
; | |
; | P1.1|-->MCLK/10
; | P1.0|-->LED
;
; JL Bile
; Texas Instruments Inc.
; May 2008
; Built Code Composer Essentials: v3 FET
;*******************************************************************************
.cdecls C,LIST, "msp430x24x.h"
;-------------------------------------------------------------------------------
.text ;Program Start
;-------------------------------------------------------------------------------
RESET mov.w #0500h,SP ; Initialize stackpointer
StopWDT mov.w #WDTPW+WDTHOLD,&WDTCTL ; Stop WDT
SetupBC bic.b #XT2OFF,&BCSCTL1 ; Activate XT2 high freq xtal
bis.b #XT2S_2,&BCSCTL3 ; 3 16MHz crystal or resonator
bis.b #OFIE,&IE1 ; Enable osc fault interrupt
SetupP1 bis.b #003h,&P1DIR ; P1.0,1 = output direction
bic.b #001h,&P1OUT ; P1.0 = reset
;
Mainloop bis.b #002h,&P1OUT ; P1.1 = 1
bic.b #002h,&P1OUT ; P1.1 = 0
jmp Mainloop ; Repeat
;
;-------------------------------------------------------------------------------
NMI_ISR; Only osc fault enabled, R15 used temporarly and not saved
;-------------------------------------------------------------------------------
bis.b #001h,&P1OUT ; P1.0= set
bic.b #SELM_3,&BCSCTL2 ; Ensure MCLK runs from DCO
CheckOsc bic.b #OFIFG,&IFG1 ; Clear OSC fault flag
mov.w #0FFh,R15 ; R15= Delay
CheckOsc1 dec.w R15 ; Additional delay to ensure start
jnz CheckOsc1 ;
bit.b #OFIFG,&IFG1 ; OSC fault flag set?
jnz CheckOsc ; OSC Fault, clear flag again
bic.b #001h,&P1OUT ; P1.0= reset
bis.b #SELM_2,&BCSCTL2 ; MCLK = XT2 HF XTAL (safe)
bis.b #OFIE,&IE1 ; re-enable osc fault interrupt
reti ; return from interrupt
;
;-------------------------------------------------------------------------------
; Interrupt Vectors
;-------------------------------------------------------------------------------
.sect ".int30" ; NMI vector
.short NMI_ISR
.sect ".reset" ; POR, ext. Reset
.short RESET
.end
| 53.727273
| 81
| 0.375353
|
51961f76f6974582a6851b3ba6db85b15c17e8c3
| 12,861
|
asm
|
Assembly
|
marbles.asm
|
DChristianson/atari-vcs-samples
|
3ceed98ddd242d1991abab619c321d2d58de60d3
|
[
"MIT"
] | null | null | null |
marbles.asm
|
DChristianson/atari-vcs-samples
|
3ceed98ddd242d1991abab619c321d2d58de60d3
|
[
"MIT"
] | null | null | null |
marbles.asm
|
DChristianson/atari-vcs-samples
|
3ceed98ddd242d1991abab619c321d2d58de60d3
|
[
"MIT"
] | null | null | null |
processor 6502
include "vcs.h"
include "macro.h"
NTSC = 0
PAL60 = 1
IFNCONST SYSTEM
SYSTEM = NTSC
ENDIF
; ----------------------------------
; constants
SPEED = 3
PLAYFIELD_HEIGHT_BLOCKS = 20
PLAYFIELD_HEIGHT_PIX = PLAYFIELD_HEIGHT_BLOCKS * 2
NUM_PLAYERS = 4
#if SYSTEM = NTSC
; NTSC Colors
WHITE = $0F
GREY = $08
RED = $44
YELLOW = $1A
GREEN = $B6
BLUE = $82
BLACK = 0
#else
; PAL Colors
WHITE = $0E
GREY = $08
RED = $62
YELLOW = $2A
GREEN = $36
BLUE = $B2
BLACK = 0
#endif
; ----------------------------------
; macros
MAC PLAYFIELD_BLOCKS
lda BLOCK_PF0,y ;4 14
sta PF0 ;3 17
lda BLOCK_PF1,y ;4 21
sta PF1 ;3 24
lda BLOCK_PF2,y ;4 28
sta PF2 ;3 31
lda BLOCK_PF3,y ;4 35
sta PF0 ;3 38
lda BLOCK_PF4,y ;4 42
sta PF1 ;3 45
lda BLOCK_PF5,y ;4 49
sta PF2 ;3 52
ENDM
; ----------------------------------
; variables
SEG.U variables
ORG $80
; game state
frame ds 1
blocks ds 40
player_vpos ds 4
missile_vpos ds 4
missile_hpos ds 4
missile_vvel ds 4
missile_hvel ds 4
; scratch vars
player_color ds 2
missile_hindex ds 2
missile_index ds 2
player_index ds 2
block_end_counter ds 2
block_counter ds 1
collision ds 4
SEG
; ----------------------------------
; code
SEG
ORG $F000
Reset
; do the clean start macro
CLEAN_START
initMissiles_start
ldx #10
stx player_vpos
stx player_vpos+1
stx player_vpos+2
stx player_vpos+3
ldx #$04
stx missile_vpos
stx missile_vpos+2
ldx #$07
stx missile_vpos+1
stx missile_vpos+3
ldx #$01
stx missile_vvel
stx missile_vvel + 2
ldx #$ff
stx missile_vvel + 1
stx missile_vvel + 3
ldx #$04
stx missile_hpos
stx missile_hpos + 2
ldx #$07
stx missile_hpos + 1
stx missile_hpos + 3
ldx #$10
stx missile_hvel
stx missile_hvel + 2
ldx #$f0
stx missile_hvel + 1
stx missile_hvel + 3
initMissiles_end
initBlocks_start
lda #PLAYFIELD_HEIGHT_BLOCKS
ldy #PLAYFIELD_HEIGHT_BLOCKS * 2 - 1
initBlocks_loop
sta blocks,y
dey
bpl initBlocks_loop
initblocks_end
newFrame
; Start of vertical blank processing
lda #0
sta VBLANK
sta COLUBK ; background colour to black
; 3 scanlines of vertical sync signal to follow
ldx #%00000010
stx VSYNC ; turn ON VSYNC bit 1
sta WSYNC ; wait a scanline
sta WSYNC ; another
sta WSYNC ; another = 3 lines total
sta VSYNC ; turn OFF VSYNC bit 1
; 37 scanlines of vertical blank to follow
;--------------------
; VBlank start
lda #1
sta VBLANK
lda #42 ; vblank timer will land us ~ on scanline 34
sta TIM64T
dec frame
bpl moveMissile_end
lda #SPEED
sta frame
ldx #NUM_PLAYERS - 1
moveMissile_loop
lda missile_vpos,x
clc
adc missile_vvel,x
cmp #1
bpl moveMissile_vgt0
lda #$01
sta missile_vvel,x
jmp moveMissile_savev
moveMissile_vgt0
cmp #PLAYFIELD_HEIGHT_PIX + 1
bmi moveMissile_savev
lda #$ff
sta missile_vvel,x
lda #PLAYFIELD_HEIGHT_PIX
moveMissile_savev
sta missile_vpos,x
moveMissile_horiz
lda missile_hvel,x
bmi moveMissile_right
clc
adc missile_hpos,x
bvc moveMissile_left_limit
adc #$0f
moveMissile_left_limit
tay
and #$0f
cmp #$02
bpl moveMissile_savehy
cpy #$31
bcs moveMissile_savehy
lda #$f0
sta missile_hvel,x
ldy #$21
jmp moveMissile_savehy
moveMissile_right
clc
adc missile_hpos,x
bvc moveMissile_right_limit
adc #$00 ; note carry is set
moveMissile_right_limit
tay
and #$0f
cmp #$0b
bmi moveMissile_savehy
cpy #$ab
bcc moveMissile_savehy
lda #$10
sta missile_hvel,x
ldy #$ab
moveMissile_savehy
tya
moveMissile_saveh
sta missile_hpos,x
dex
bpl moveMissile_loop
moveMissile_end
;-- collision logic
ldx #NUM_PLAYERS - 1
collideMissile_loop
lda collision,x
bpl collideMissile_next
lda #PLAYFIELD_HEIGHT_PIX - 1
sec
sbc missile_vpos,x
lsr
cpx #$02
bcc collideMissile_no_offset
adc #PLAYFIELD_HEIGHT_BLOCKS
collideMissile_no_offset
tay
txa
lsr
bcs collideMissile_right
lda blocks,y
cmp #39
bcs collideMissile_next
clc
adc #$01
sta blocks,y
lda #$03
sta missile_hpos,x
jmp collideMissile_next
collideMissile_right
lda blocks,y
beq collideMissile_next
sec
sbc #$01
sta blocks,y
lda #$09
sta missile_hpos,x
collideMissile_next
dex
bpl collideMissile_loop
; setupBlocks_start
; ldy #39
; setupBlocks_loop
; ldx blocks,y
; inx
; cpx #41
; bmi setupBlocks_save
; ldx #$00
; setupBlocks_save
; stx blocks,y
; dey
; bpl setupBlocks_loop
setupBlocks_end
ldx #0
waitOnVBlank
cpx INTIM
bmi waitOnVBlank
stx VBLANK
;--------------------
; Screen start
sta WSYNC
lda #$00
sta PF0
sta PF1
sta PF2
sta COLUBK
sta block_end_counter
lda #PLAYFIELD_HEIGHT_BLOCKS
sta block_counter
lda #WHITE
sta COLUP0
sta COLUP1
lda #BLUE
sta player_color
lda #RED
sta player_color + 1
lda player_vpos
sta player_index
lda player_vpos + 1
sta player_index + 1
lda missile_vpos
sta missile_index
lda missile_vpos + 1
sta missile_index + 1
lda missile_hpos
sta missile_hindex
lda missile_hpos + 1
sta missile_hindex + 1
sta CXCLR
jsr playfield
sta WSYNC
lda #$00
sta PF0
sta PF1
sta PF2
lda CXM0FB
eor #$80
sta collision
lda CXM1FB
sta collision + 1
sta COLUBK
lda #PLAYFIELD_HEIGHT_BLOCKS
sta block_end_counter
lda #PLAYFIELD_HEIGHT_BLOCKS * 2 - 1
sta block_counter
lda #GREEN
sta player_color
lda #YELLOW
sta player_color + 1
lda player_vpos + 2
sta player_index
lda player_vpos + 3
sta player_index + 1
lda missile_vpos + 2
sta missile_index
lda missile_vpos + 3
sta missile_index + 1
lda missile_hpos + 2
sta missile_hindex
lda missile_hpos + 3
sta missile_hindex + 1
sta CXCLR
jsr playfield
sta WSYNC
lda #$00
sta PF0
sta PF1
sta PF2
sta COLUBK
lda CXM0FB
eor #$80
sta collision + 2
lda CXM1FB
sta collision + 3
jmp overscan
playfield
; locate missile 0
sta WSYNC
lda missile_hindex
sta HMM0
and #$0F
tax
missile_0_resp
dex
bpl missile_0_resp
sta RESM0
sta WSYNC
; locate missile 1
lda missile_hindex+1
sta HMM1
and #$0F
tax
missile_1_resp
dex
bpl missile_1_resp
sta RESM1
sta WSYNC
sta HMOVE
lda player_color
sta COLUPF
lda player_color+1 ;3 3
sta COLUBK ;3 6
ldx block_counter
playfield_loop_block
ldy blocks,x ;4 --/72
sta WSYNC ;3 0
dec missile_index ;5 5
dec missile_index + 1 ;5 10
PLAYFIELD_BLOCKS ;42 52
lda missile_index ;3 55
beq missile_0_A ;2 57
lda #$ff ;2 59
missile_0_A
eor #$ff ;2 61
sta ENAM0 ;3 64
lda missile_index+1 ;3 67
beq missile_1_A ;2 69
lda #$ff ;2 71
missile_1_A
eor #$ff ;2 73
sta ENAM1 ;3 76
; sta WSYNC ;3 0
SLEEP 10 ; 10
PLAYFIELD_BLOCKS ;42 52
sta WSYNC ;3 0
dec missile_index ;5 5
dec missile_index + 1 ;5 10
PLAYFIELD_BLOCKS ;42 52
lda missile_index ;3 55
beq missile_0_B ;2 57
lda #$ff ;2 59
missile_0_B
eor #$ff ;2 61
sta ENAM0 ;3 64
lda missile_index+1 ;3 67
beq missile_1_B ;2 69
lda #$ff ;2 71
missile_1_B
eor #$ff ;2 73
sta ENAM1 ;3 76
; sta WSYNC ;3 0
SLEEP 10 ; 10
PLAYFIELD_BLOCKS ;42 52
ldx block_counter ;3 55
dex ;2 57
cpx block_end_counter ;3 60
bmi playfield_end ;2 62
stx block_counter ;3 65
jmp playfield_loop_block ;3 68
playfield_end
rts ;6 69
;--------------------
; Overscan start
overscan
ldx #30
waitOnOverscan
sta WSYNC
dex
bne waitOnOverscan
jmp newFrame
;--------------------
; Block Graphics
ORG $FF00
BLOCK_PF0 byte $00,$10,$30,$70,$F0,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
BLOCK_PF1 byte $00,$00,$00,$00,$00,$80,$C0,$E0,$F0,$F8,$FC,$FE,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
BLOCK_PF2 byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$03,$07,$0F,$1F,$3F,$7F,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
BLOCK_PF3 byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$10,$30,$70,$F0,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
BLOCK_PF4 byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$80,$C0,$E0,$F0,$F8,$FC,$FE,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF
BLOCK_PF5 byte $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$01,$03,$07,$0F,$1F,$3F,$7F,$FF
;--------------------
; Reset
ORG $FFFA
.word Reset ; NMI
.word Reset ; RESET
.word Reset ; IRQ
END
| 26.034413
| 197
| 0.447555
|
25ea58c2fd924d56d477b2d4fc62616a1221d77b
| 581
|
asm
|
Assembly
|
oeis/062/A062158.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/062/A062158.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/062/A062158.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A062158: a(n) = n^3 - n^2 + n - 1.
; -1,0,5,20,51,104,185,300,455,656,909,1220,1595,2040,2561,3164,3855,4640,5525,6516,7619,8840,10185,11660,13271,15024,16925,18980,21195,23576,26129,28860,31775,34880,38181,41684,45395,49320,53465,57836,62439,67280,72365,77700,83291,89144,95265,101660,108335,115296,122549,130100,137955,146120,154601,163404,172535,182000,191805,201956,212459,223320,234545,246140,258111,270464,283205,296340,309875,323816,338169,352940,368135,383760,399821,416324,433275,450680,468545,486876,505679,524960,544725
mov $1,$0
pow $0,2
add $0,1
sub $1,1
mul $0,$1
| 64.555556
| 495
| 0.774527
|
eefadb8c97c185720e366976780ad07555f8ded3
| 570,893
|
asm
|
Assembly
|
kernel.asm
|
neha45556/cs153_lab3
|
926ca2f81414c7f296f99aa69a6ae8f0e65b428f
|
[
"MIT-0"
] | null | null | null |
kernel.asm
|
neha45556/cs153_lab3
|
926ca2f81414c7f296f99aa69a6ae8f0e65b428f
|
[
"MIT-0"
] | null | null | null |
kernel.asm
|
neha45556/cs153_lab3
|
926ca2f81414c7f296f99aa69a6ae8f0e65b428f
|
[
"MIT-0"
] | null | null | null |
kernel: file format elf32-i386
Disassembly of section .text:
80100000 <multiboot_header>:
80100000: 02 b0 ad 1b 00 00 add 0x1bad(%eax),%dh
80100006: 00 00 add %al,(%eax)
80100008: fe 4f 52 decb 0x52(%edi)
8010000b: e4 .byte 0xe4
8010000c <entry>:
# Entering xv6 on boot processor, with paging off.
.globl entry
entry:
# Turn on page size extension for 4Mbyte pages
movl %cr4, %eax
8010000c: 0f 20 e0 mov %cr4,%eax
orl $(CR4_PSE), %eax
8010000f: 83 c8 10 or $0x10,%eax
movl %eax, %cr4
80100012: 0f 22 e0 mov %eax,%cr4
# Set page directory
movl $(V2P_WO(entrypgdir)), %eax
80100015: b8 00 90 10 00 mov $0x109000,%eax
movl %eax, %cr3
8010001a: 0f 22 d8 mov %eax,%cr3
# Turn on paging.
movl %cr0, %eax
8010001d: 0f 20 c0 mov %cr0,%eax
orl $(CR0_PG|CR0_WP), %eax
80100020: 0d 00 00 01 80 or $0x80010000,%eax
movl %eax, %cr0
80100025: 0f 22 c0 mov %eax,%cr0
# Set up the stack pointer.
movl $(stack + KSTACKSIZE), %esp
80100028: bc c0 b5 10 80 mov $0x8010b5c0,%esp
# Jump to main(), and switch to executing at
# high addresses. The indirect call is needed because
# the assembler produces a PC-relative instruction
# for a direct jump.
mov $main, %eax
8010002d: b8 f0 2d 10 80 mov $0x80102df0,%eax
jmp *%eax
80100032: ff e0 jmp *%eax
80100034: 66 90 xchg %ax,%ax
80100036: 66 90 xchg %ax,%ax
80100038: 66 90 xchg %ax,%ax
8010003a: 66 90 xchg %ax,%ax
8010003c: 66 90 xchg %ax,%ax
8010003e: 66 90 xchg %ax,%ax
80100040 <binit>:
struct buf head;
} bcache;
void
binit(void)
{
80100040: 55 push %ebp
80100041: 89 e5 mov %esp,%ebp
80100043: 53 push %ebx
//PAGEBREAK!
// Create linked list of buffers
bcache.head.prev = &bcache.head;
bcache.head.next = &bcache.head;
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100044: bb f4 b5 10 80 mov $0x8010b5f4,%ebx
{
80100049: 83 ec 14 sub $0x14,%esp
initlock(&bcache.lock, "bcache");
8010004c: c7 44 24 04 60 6e 10 movl $0x80106e60,0x4(%esp)
80100053: 80
80100054: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
8010005b: e8 f0 3f 00 00 call 80104050 <initlock>
bcache.head.next = &bcache.head;
80100060: ba bc fc 10 80 mov $0x8010fcbc,%edx
bcache.head.prev = &bcache.head;
80100065: c7 05 0c fd 10 80 bc movl $0x8010fcbc,0x8010fd0c
8010006c: fc 10 80
bcache.head.next = &bcache.head;
8010006f: c7 05 10 fd 10 80 bc movl $0x8010fcbc,0x8010fd10
80100076: fc 10 80
80100079: eb 09 jmp 80100084 <binit+0x44>
8010007b: 90 nop
8010007c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100080: 89 da mov %ebx,%edx
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
80100082: 89 c3 mov %eax,%ebx
80100084: 8d 43 0c lea 0xc(%ebx),%eax
b->next = bcache.head.next;
80100087: 89 53 54 mov %edx,0x54(%ebx)
b->prev = &bcache.head;
8010008a: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
initsleeplock(&b->lock, "buffer");
80100091: 89 04 24 mov %eax,(%esp)
80100094: c7 44 24 04 67 6e 10 movl $0x80106e67,0x4(%esp)
8010009b: 80
8010009c: e8 9f 3e 00 00 call 80103f40 <initsleeplock>
bcache.head.next->prev = b;
801000a1: a1 10 fd 10 80 mov 0x8010fd10,%eax
801000a6: 89 58 50 mov %ebx,0x50(%eax)
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000a9: 8d 83 5c 02 00 00 lea 0x25c(%ebx),%eax
801000af: 3d bc fc 10 80 cmp $0x8010fcbc,%eax
bcache.head.next = b;
801000b4: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
for(b = bcache.buf; b < bcache.buf+NBUF; b++){
801000ba: 75 c4 jne 80100080 <binit+0x40>
}
}
801000bc: 83 c4 14 add $0x14,%esp
801000bf: 5b pop %ebx
801000c0: 5d pop %ebp
801000c1: c3 ret
801000c2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801000c9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801000d0 <bread>:
}
// Return a locked buf with the contents of the indicated block.
struct buf*
bread(uint dev, uint blockno)
{
801000d0: 55 push %ebp
801000d1: 89 e5 mov %esp,%ebp
801000d3: 57 push %edi
801000d4: 56 push %esi
801000d5: 53 push %ebx
801000d6: 83 ec 1c sub $0x1c,%esp
801000d9: 8b 75 08 mov 0x8(%ebp),%esi
acquire(&bcache.lock);
801000dc: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
{
801000e3: 8b 7d 0c mov 0xc(%ebp),%edi
acquire(&bcache.lock);
801000e6: e8 55 40 00 00 call 80104140 <acquire>
for(b = bcache.head.next; b != &bcache.head; b = b->next){
801000eb: 8b 1d 10 fd 10 80 mov 0x8010fd10,%ebx
801000f1: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
801000f7: 75 12 jne 8010010b <bread+0x3b>
801000f9: eb 25 jmp 80100120 <bread+0x50>
801000fb: 90 nop
801000fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100100: 8b 5b 54 mov 0x54(%ebx),%ebx
80100103: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100109: 74 15 je 80100120 <bread+0x50>
if(b->dev == dev && b->blockno == blockno){
8010010b: 3b 73 04 cmp 0x4(%ebx),%esi
8010010e: 75 f0 jne 80100100 <bread+0x30>
80100110: 3b 7b 08 cmp 0x8(%ebx),%edi
80100113: 75 eb jne 80100100 <bread+0x30>
b->refcnt++;
80100115: 83 43 4c 01 addl $0x1,0x4c(%ebx)
80100119: eb 3f jmp 8010015a <bread+0x8a>
8010011b: 90 nop
8010011c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(b = bcache.head.prev; b != &bcache.head; b = b->prev){
80100120: 8b 1d 0c fd 10 80 mov 0x8010fd0c,%ebx
80100126: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
8010012c: 75 0d jne 8010013b <bread+0x6b>
8010012e: eb 58 jmp 80100188 <bread+0xb8>
80100130: 8b 5b 50 mov 0x50(%ebx),%ebx
80100133: 81 fb bc fc 10 80 cmp $0x8010fcbc,%ebx
80100139: 74 4d je 80100188 <bread+0xb8>
if(b->refcnt == 0 && (b->flags & B_DIRTY) == 0) {
8010013b: 8b 43 4c mov 0x4c(%ebx),%eax
8010013e: 85 c0 test %eax,%eax
80100140: 75 ee jne 80100130 <bread+0x60>
80100142: f6 03 04 testb $0x4,(%ebx)
80100145: 75 e9 jne 80100130 <bread+0x60>
b->dev = dev;
80100147: 89 73 04 mov %esi,0x4(%ebx)
b->blockno = blockno;
8010014a: 89 7b 08 mov %edi,0x8(%ebx)
b->flags = 0;
8010014d: c7 03 00 00 00 00 movl $0x0,(%ebx)
b->refcnt = 1;
80100153: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
release(&bcache.lock);
8010015a: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100161: e8 ca 40 00 00 call 80104230 <release>
acquiresleep(&b->lock);
80100166: 8d 43 0c lea 0xc(%ebx),%eax
80100169: 89 04 24 mov %eax,(%esp)
8010016c: e8 0f 3e 00 00 call 80103f80 <acquiresleep>
struct buf *b;
b = bget(dev, blockno);
if((b->flags & B_VALID) == 0) {
80100171: f6 03 02 testb $0x2,(%ebx)
80100174: 75 08 jne 8010017e <bread+0xae>
iderw(b);
80100176: 89 1c 24 mov %ebx,(%esp)
80100179: e8 a2 1f 00 00 call 80102120 <iderw>
}
return b;
}
8010017e: 83 c4 1c add $0x1c,%esp
80100181: 89 d8 mov %ebx,%eax
80100183: 5b pop %ebx
80100184: 5e pop %esi
80100185: 5f pop %edi
80100186: 5d pop %ebp
80100187: c3 ret
panic("bget: no buffers");
80100188: c7 04 24 6e 6e 10 80 movl $0x80106e6e,(%esp)
8010018f: e8 cc 01 00 00 call 80100360 <panic>
80100194: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
8010019a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801001a0 <bwrite>:
// Write b's contents to disk. Must be locked.
void
bwrite(struct buf *b)
{
801001a0: 55 push %ebp
801001a1: 89 e5 mov %esp,%ebp
801001a3: 53 push %ebx
801001a4: 83 ec 14 sub $0x14,%esp
801001a7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001aa: 8d 43 0c lea 0xc(%ebx),%eax
801001ad: 89 04 24 mov %eax,(%esp)
801001b0: e8 6b 3e 00 00 call 80104020 <holdingsleep>
801001b5: 85 c0 test %eax,%eax
801001b7: 74 10 je 801001c9 <bwrite+0x29>
panic("bwrite");
b->flags |= B_DIRTY;
801001b9: 83 0b 04 orl $0x4,(%ebx)
iderw(b);
801001bc: 89 5d 08 mov %ebx,0x8(%ebp)
}
801001bf: 83 c4 14 add $0x14,%esp
801001c2: 5b pop %ebx
801001c3: 5d pop %ebp
iderw(b);
801001c4: e9 57 1f 00 00 jmp 80102120 <iderw>
panic("bwrite");
801001c9: c7 04 24 7f 6e 10 80 movl $0x80106e7f,(%esp)
801001d0: e8 8b 01 00 00 call 80100360 <panic>
801001d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801001d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801001e0 <brelse>:
// Release a locked buffer.
// Move to the head of the MRU list.
void
brelse(struct buf *b)
{
801001e0: 55 push %ebp
801001e1: 89 e5 mov %esp,%ebp
801001e3: 56 push %esi
801001e4: 53 push %ebx
801001e5: 83 ec 10 sub $0x10,%esp
801001e8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(!holdingsleep(&b->lock))
801001eb: 8d 73 0c lea 0xc(%ebx),%esi
801001ee: 89 34 24 mov %esi,(%esp)
801001f1: e8 2a 3e 00 00 call 80104020 <holdingsleep>
801001f6: 85 c0 test %eax,%eax
801001f8: 74 5b je 80100255 <brelse+0x75>
panic("brelse");
releasesleep(&b->lock);
801001fa: 89 34 24 mov %esi,(%esp)
801001fd: e8 de 3d 00 00 call 80103fe0 <releasesleep>
acquire(&bcache.lock);
80100202: c7 04 24 c0 b5 10 80 movl $0x8010b5c0,(%esp)
80100209: e8 32 3f 00 00 call 80104140 <acquire>
b->refcnt--;
if (b->refcnt == 0) {
8010020e: 83 6b 4c 01 subl $0x1,0x4c(%ebx)
80100212: 75 2f jne 80100243 <brelse+0x63>
// no one is waiting for it.
b->next->prev = b->prev;
80100214: 8b 43 54 mov 0x54(%ebx),%eax
80100217: 8b 53 50 mov 0x50(%ebx),%edx
8010021a: 89 50 50 mov %edx,0x50(%eax)
b->prev->next = b->next;
8010021d: 8b 43 50 mov 0x50(%ebx),%eax
80100220: 8b 53 54 mov 0x54(%ebx),%edx
80100223: 89 50 54 mov %edx,0x54(%eax)
b->next = bcache.head.next;
80100226: a1 10 fd 10 80 mov 0x8010fd10,%eax
b->prev = &bcache.head;
8010022b: c7 43 50 bc fc 10 80 movl $0x8010fcbc,0x50(%ebx)
b->next = bcache.head.next;
80100232: 89 43 54 mov %eax,0x54(%ebx)
bcache.head.next->prev = b;
80100235: a1 10 fd 10 80 mov 0x8010fd10,%eax
8010023a: 89 58 50 mov %ebx,0x50(%eax)
bcache.head.next = b;
8010023d: 89 1d 10 fd 10 80 mov %ebx,0x8010fd10
}
release(&bcache.lock);
80100243: c7 45 08 c0 b5 10 80 movl $0x8010b5c0,0x8(%ebp)
}
8010024a: 83 c4 10 add $0x10,%esp
8010024d: 5b pop %ebx
8010024e: 5e pop %esi
8010024f: 5d pop %ebp
release(&bcache.lock);
80100250: e9 db 3f 00 00 jmp 80104230 <release>
panic("brelse");
80100255: c7 04 24 86 6e 10 80 movl $0x80106e86,(%esp)
8010025c: e8 ff 00 00 00 call 80100360 <panic>
80100261: 66 90 xchg %ax,%ax
80100263: 66 90 xchg %ax,%ax
80100265: 66 90 xchg %ax,%ax
80100267: 66 90 xchg %ax,%ax
80100269: 66 90 xchg %ax,%ax
8010026b: 66 90 xchg %ax,%ax
8010026d: 66 90 xchg %ax,%ax
8010026f: 90 nop
80100270 <consoleread>:
}
}
int
consoleread(struct inode *ip, char *dst, int n)
{
80100270: 55 push %ebp
80100271: 89 e5 mov %esp,%ebp
80100273: 57 push %edi
80100274: 56 push %esi
80100275: 53 push %ebx
80100276: 83 ec 1c sub $0x1c,%esp
80100279: 8b 7d 08 mov 0x8(%ebp),%edi
8010027c: 8b 75 0c mov 0xc(%ebp),%esi
uint target;
int c;
iunlock(ip);
8010027f: 89 3c 24 mov %edi,(%esp)
80100282: e8 09 15 00 00 call 80101790 <iunlock>
target = n;
acquire(&cons.lock);
80100287: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010028e: e8 ad 3e 00 00 call 80104140 <acquire>
while(n > 0){
80100293: 8b 55 10 mov 0x10(%ebp),%edx
80100296: 85 d2 test %edx,%edx
80100298: 0f 8e bc 00 00 00 jle 8010035a <consoleread+0xea>
8010029e: 8b 5d 10 mov 0x10(%ebp),%ebx
801002a1: eb 25 jmp 801002c8 <consoleread+0x58>
801002a3: 90 nop
801002a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.r == input.w){
if(myproc()->killed){
801002a8: e8 f3 33 00 00 call 801036a0 <myproc>
801002ad: 8b 40 28 mov 0x28(%eax),%eax
801002b0: 85 c0 test %eax,%eax
801002b2: 75 74 jne 80100328 <consoleread+0xb8>
release(&cons.lock);
ilock(ip);
return -1;
}
sleep(&input.r, &cons.lock);
801002b4: c7 44 24 04 20 a5 10 movl $0x8010a520,0x4(%esp)
801002bb: 80
801002bc: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
801002c3: e8 38 39 00 00 call 80103c00 <sleep>
while(input.r == input.w){
801002c8: a1 a0 ff 10 80 mov 0x8010ffa0,%eax
801002cd: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801002d3: 74 d3 je 801002a8 <consoleread+0x38>
}
c = input.buf[input.r++ % INPUT_BUF];
801002d5: 8d 50 01 lea 0x1(%eax),%edx
801002d8: 89 15 a0 ff 10 80 mov %edx,0x8010ffa0
801002de: 89 c2 mov %eax,%edx
801002e0: 83 e2 7f and $0x7f,%edx
801002e3: 0f b6 8a 20 ff 10 80 movzbl -0x7fef00e0(%edx),%ecx
801002ea: 0f be d1 movsbl %cl,%edx
if(c == C('D')){ // EOF
801002ed: 83 fa 04 cmp $0x4,%edx
801002f0: 74 57 je 80100349 <consoleread+0xd9>
// caller gets a 0-byte result.
input.r--;
}
break;
}
*dst++ = c;
801002f2: 83 c6 01 add $0x1,%esi
--n;
801002f5: 83 eb 01 sub $0x1,%ebx
if(c == '\n')
801002f8: 83 fa 0a cmp $0xa,%edx
*dst++ = c;
801002fb: 88 4e ff mov %cl,-0x1(%esi)
if(c == '\n')
801002fe: 74 53 je 80100353 <consoleread+0xe3>
while(n > 0){
80100300: 85 db test %ebx,%ebx
80100302: 75 c4 jne 801002c8 <consoleread+0x58>
80100304: 8b 45 10 mov 0x10(%ebp),%eax
break;
}
release(&cons.lock);
80100307: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010030e: 89 45 e4 mov %eax,-0x1c(%ebp)
80100311: e8 1a 3f 00 00 call 80104230 <release>
ilock(ip);
80100316: 89 3c 24 mov %edi,(%esp)
80100319: e8 92 13 00 00 call 801016b0 <ilock>
8010031e: 8b 45 e4 mov -0x1c(%ebp),%eax
return target - n;
80100321: eb 1e jmp 80100341 <consoleread+0xd1>
80100323: 90 nop
80100324: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100328: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010032f: e8 fc 3e 00 00 call 80104230 <release>
ilock(ip);
80100334: 89 3c 24 mov %edi,(%esp)
80100337: e8 74 13 00 00 call 801016b0 <ilock>
return -1;
8010033c: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100341: 83 c4 1c add $0x1c,%esp
80100344: 5b pop %ebx
80100345: 5e pop %esi
80100346: 5f pop %edi
80100347: 5d pop %ebp
80100348: c3 ret
if(n < target){
80100349: 39 5d 10 cmp %ebx,0x10(%ebp)
8010034c: 76 05 jbe 80100353 <consoleread+0xe3>
input.r--;
8010034e: a3 a0 ff 10 80 mov %eax,0x8010ffa0
80100353: 8b 45 10 mov 0x10(%ebp),%eax
80100356: 29 d8 sub %ebx,%eax
80100358: eb ad jmp 80100307 <consoleread+0x97>
while(n > 0){
8010035a: 31 c0 xor %eax,%eax
8010035c: eb a9 jmp 80100307 <consoleread+0x97>
8010035e: 66 90 xchg %ax,%ax
80100360 <panic>:
{
80100360: 55 push %ebp
80100361: 89 e5 mov %esp,%ebp
80100363: 56 push %esi
80100364: 53 push %ebx
80100365: 83 ec 40 sub $0x40,%esp
}
static inline void
cli(void)
{
asm volatile("cli");
80100368: fa cli
cons.locking = 0;
80100369: c7 05 54 a5 10 80 00 movl $0x0,0x8010a554
80100370: 00 00 00
getcallerpcs(&s, pcs);
80100373: 8d 5d d0 lea -0x30(%ebp),%ebx
cprintf("lapicid %d: panic: ", lapicid());
80100376: e8 e5 23 00 00 call 80102760 <lapicid>
8010037b: 8d 75 f8 lea -0x8(%ebp),%esi
8010037e: c7 04 24 8d 6e 10 80 movl $0x80106e8d,(%esp)
80100385: 89 44 24 04 mov %eax,0x4(%esp)
80100389: e8 c2 02 00 00 call 80100650 <cprintf>
cprintf(s);
8010038e: 8b 45 08 mov 0x8(%ebp),%eax
80100391: 89 04 24 mov %eax,(%esp)
80100394: e8 b7 02 00 00 call 80100650 <cprintf>
cprintf("\n");
80100399: c7 04 24 eb 78 10 80 movl $0x801078eb,(%esp)
801003a0: e8 ab 02 00 00 call 80100650 <cprintf>
getcallerpcs(&s, pcs);
801003a5: 8d 45 08 lea 0x8(%ebp),%eax
801003a8: 89 5c 24 04 mov %ebx,0x4(%esp)
801003ac: 89 04 24 mov %eax,(%esp)
801003af: e8 bc 3c 00 00 call 80104070 <getcallerpcs>
801003b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf(" %p", pcs[i]);
801003b8: 8b 03 mov (%ebx),%eax
801003ba: 83 c3 04 add $0x4,%ebx
801003bd: c7 04 24 a1 6e 10 80 movl $0x80106ea1,(%esp)
801003c4: 89 44 24 04 mov %eax,0x4(%esp)
801003c8: e8 83 02 00 00 call 80100650 <cprintf>
for(i=0; i<10; i++)
801003cd: 39 f3 cmp %esi,%ebx
801003cf: 75 e7 jne 801003b8 <panic+0x58>
panicked = 1; // freeze other CPU
801003d1: c7 05 58 a5 10 80 01 movl $0x1,0x8010a558
801003d8: 00 00 00
801003db: eb fe jmp 801003db <panic+0x7b>
801003dd: 8d 76 00 lea 0x0(%esi),%esi
801003e0 <consputc>:
if(panicked){
801003e0: 8b 15 58 a5 10 80 mov 0x8010a558,%edx
801003e6: 85 d2 test %edx,%edx
801003e8: 74 06 je 801003f0 <consputc+0x10>
801003ea: fa cli
801003eb: eb fe jmp 801003eb <consputc+0xb>
801003ed: 8d 76 00 lea 0x0(%esi),%esi
{
801003f0: 55 push %ebp
801003f1: 89 e5 mov %esp,%ebp
801003f3: 57 push %edi
801003f4: 56 push %esi
801003f5: 53 push %ebx
801003f6: 89 c3 mov %eax,%ebx
801003f8: 83 ec 1c sub $0x1c,%esp
if(c == BACKSPACE){
801003fb: 3d 00 01 00 00 cmp $0x100,%eax
80100400: 0f 84 ac 00 00 00 je 801004b2 <consputc+0xd2>
uartputc(c);
80100406: 89 04 24 mov %eax,(%esp)
80100409: e8 52 54 00 00 call 80105860 <uartputc>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010040e: bf d4 03 00 00 mov $0x3d4,%edi
80100413: b8 0e 00 00 00 mov $0xe,%eax
80100418: 89 fa mov %edi,%edx
8010041a: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010041b: be d5 03 00 00 mov $0x3d5,%esi
80100420: 89 f2 mov %esi,%edx
80100422: ec in (%dx),%al
pos = inb(CRTPORT+1) << 8;
80100423: 0f b6 c8 movzbl %al,%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100426: 89 fa mov %edi,%edx
80100428: c1 e1 08 shl $0x8,%ecx
8010042b: b8 0f 00 00 00 mov $0xf,%eax
80100430: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80100431: 89 f2 mov %esi,%edx
80100433: ec in (%dx),%al
pos |= inb(CRTPORT+1);
80100434: 0f b6 c0 movzbl %al,%eax
80100437: 09 c1 or %eax,%ecx
if(c == '\n')
80100439: 83 fb 0a cmp $0xa,%ebx
8010043c: 0f 84 0d 01 00 00 je 8010054f <consputc+0x16f>
else if(c == BACKSPACE){
80100442: 81 fb 00 01 00 00 cmp $0x100,%ebx
80100448: 0f 84 e8 00 00 00 je 80100536 <consputc+0x156>
crt[pos++] = (c&0xff) | 0x0700; // black on white
8010044e: 0f b6 db movzbl %bl,%ebx
80100451: 80 cf 07 or $0x7,%bh
80100454: 8d 79 01 lea 0x1(%ecx),%edi
80100457: 66 89 9c 09 00 80 0b mov %bx,-0x7ff48000(%ecx,%ecx,1)
8010045e: 80
if(pos < 0 || pos > 25*80)
8010045f: 81 ff d0 07 00 00 cmp $0x7d0,%edi
80100465: 0f 87 bf 00 00 00 ja 8010052a <consputc+0x14a>
if((pos/80) >= 24){ // Scroll up.
8010046b: 81 ff 7f 07 00 00 cmp $0x77f,%edi
80100471: 7f 68 jg 801004db <consputc+0xfb>
80100473: 89 f8 mov %edi,%eax
80100475: 89 fb mov %edi,%ebx
80100477: c1 e8 08 shr $0x8,%eax
8010047a: 89 c6 mov %eax,%esi
8010047c: 8d 8c 3f 00 80 0b 80 lea -0x7ff48000(%edi,%edi,1),%ecx
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80100483: bf d4 03 00 00 mov $0x3d4,%edi
80100488: b8 0e 00 00 00 mov $0xe,%eax
8010048d: 89 fa mov %edi,%edx
8010048f: ee out %al,(%dx)
80100490: 89 f0 mov %esi,%eax
80100492: b2 d5 mov $0xd5,%dl
80100494: ee out %al,(%dx)
80100495: b8 0f 00 00 00 mov $0xf,%eax
8010049a: 89 fa mov %edi,%edx
8010049c: ee out %al,(%dx)
8010049d: 89 d8 mov %ebx,%eax
8010049f: b2 d5 mov $0xd5,%dl
801004a1: ee out %al,(%dx)
crt[pos] = ' ' | 0x0700;
801004a2: b8 20 07 00 00 mov $0x720,%eax
801004a7: 66 89 01 mov %ax,(%ecx)
}
801004aa: 83 c4 1c add $0x1c,%esp
801004ad: 5b pop %ebx
801004ae: 5e pop %esi
801004af: 5f pop %edi
801004b0: 5d pop %ebp
801004b1: c3 ret
uartputc('\b'); uartputc(' '); uartputc('\b');
801004b2: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004b9: e8 a2 53 00 00 call 80105860 <uartputc>
801004be: c7 04 24 20 00 00 00 movl $0x20,(%esp)
801004c5: e8 96 53 00 00 call 80105860 <uartputc>
801004ca: c7 04 24 08 00 00 00 movl $0x8,(%esp)
801004d1: e8 8a 53 00 00 call 80105860 <uartputc>
801004d6: e9 33 ff ff ff jmp 8010040e <consputc+0x2e>
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004db: c7 44 24 08 60 0e 00 movl $0xe60,0x8(%esp)
801004e2: 00
pos -= 80;
801004e3: 8d 5f b0 lea -0x50(%edi),%ebx
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004e6: c7 44 24 04 a0 80 0b movl $0x800b80a0,0x4(%esp)
801004ed: 80
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
801004ee: 8d b4 1b 00 80 0b 80 lea -0x7ff48000(%ebx,%ebx,1),%esi
memmove(crt, crt+80, sizeof(crt[0])*23*80);
801004f5: c7 04 24 00 80 0b 80 movl $0x800b8000,(%esp)
801004fc: e8 1f 3e 00 00 call 80104320 <memmove>
memset(crt+pos, 0, sizeof(crt[0])*(24*80 - pos));
80100501: b8 d0 07 00 00 mov $0x7d0,%eax
80100506: 29 f8 sub %edi,%eax
80100508: 01 c0 add %eax,%eax
8010050a: 89 34 24 mov %esi,(%esp)
8010050d: 89 44 24 08 mov %eax,0x8(%esp)
80100511: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100518: 00
80100519: e8 62 3d 00 00 call 80104280 <memset>
8010051e: 89 f1 mov %esi,%ecx
80100520: be 07 00 00 00 mov $0x7,%esi
80100525: e9 59 ff ff ff jmp 80100483 <consputc+0xa3>
panic("pos under/overflow");
8010052a: c7 04 24 a5 6e 10 80 movl $0x80106ea5,(%esp)
80100531: e8 2a fe ff ff call 80100360 <panic>
if(pos > 0) --pos;
80100536: 85 c9 test %ecx,%ecx
80100538: 8d 79 ff lea -0x1(%ecx),%edi
8010053b: 0f 85 1e ff ff ff jne 8010045f <consputc+0x7f>
80100541: b9 00 80 0b 80 mov $0x800b8000,%ecx
80100546: 31 db xor %ebx,%ebx
80100548: 31 f6 xor %esi,%esi
8010054a: e9 34 ff ff ff jmp 80100483 <consputc+0xa3>
pos += 80 - pos%80;
8010054f: 89 c8 mov %ecx,%eax
80100551: ba 67 66 66 66 mov $0x66666667,%edx
80100556: f7 ea imul %edx
80100558: c1 ea 05 shr $0x5,%edx
8010055b: 8d 04 92 lea (%edx,%edx,4),%eax
8010055e: c1 e0 04 shl $0x4,%eax
80100561: 8d 78 50 lea 0x50(%eax),%edi
80100564: e9 f6 fe ff ff jmp 8010045f <consputc+0x7f>
80100569: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100570 <printint>:
{
80100570: 55 push %ebp
80100571: 89 e5 mov %esp,%ebp
80100573: 57 push %edi
80100574: 56 push %esi
80100575: 89 d6 mov %edx,%esi
80100577: 53 push %ebx
80100578: 83 ec 1c sub $0x1c,%esp
if(sign && (sign = xx < 0))
8010057b: 85 c9 test %ecx,%ecx
8010057d: 74 61 je 801005e0 <printint+0x70>
8010057f: 85 c0 test %eax,%eax
80100581: 79 5d jns 801005e0 <printint+0x70>
x = -xx;
80100583: f7 d8 neg %eax
80100585: bf 01 00 00 00 mov $0x1,%edi
i = 0;
8010058a: 31 c9 xor %ecx,%ecx
8010058c: eb 04 jmp 80100592 <printint+0x22>
8010058e: 66 90 xchg %ax,%ax
buf[i++] = digits[x % base];
80100590: 89 d9 mov %ebx,%ecx
80100592: 31 d2 xor %edx,%edx
80100594: f7 f6 div %esi
80100596: 8d 59 01 lea 0x1(%ecx),%ebx
80100599: 0f b6 92 d0 6e 10 80 movzbl -0x7fef9130(%edx),%edx
}while((x /= base) != 0);
801005a0: 85 c0 test %eax,%eax
buf[i++] = digits[x % base];
801005a2: 88 54 1d d7 mov %dl,-0x29(%ebp,%ebx,1)
}while((x /= base) != 0);
801005a6: 75 e8 jne 80100590 <printint+0x20>
if(sign)
801005a8: 85 ff test %edi,%edi
buf[i++] = digits[x % base];
801005aa: 89 d8 mov %ebx,%eax
if(sign)
801005ac: 74 08 je 801005b6 <printint+0x46>
buf[i++] = '-';
801005ae: 8d 59 02 lea 0x2(%ecx),%ebx
801005b1: c6 44 05 d8 2d movb $0x2d,-0x28(%ebp,%eax,1)
while(--i >= 0)
801005b6: 83 eb 01 sub $0x1,%ebx
801005b9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc(buf[i]);
801005c0: 0f be 44 1d d8 movsbl -0x28(%ebp,%ebx,1),%eax
while(--i >= 0)
801005c5: 83 eb 01 sub $0x1,%ebx
consputc(buf[i]);
801005c8: e8 13 fe ff ff call 801003e0 <consputc>
while(--i >= 0)
801005cd: 83 fb ff cmp $0xffffffff,%ebx
801005d0: 75 ee jne 801005c0 <printint+0x50>
}
801005d2: 83 c4 1c add $0x1c,%esp
801005d5: 5b pop %ebx
801005d6: 5e pop %esi
801005d7: 5f pop %edi
801005d8: 5d pop %ebp
801005d9: c3 ret
801005da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
x = xx;
801005e0: 31 ff xor %edi,%edi
801005e2: eb a6 jmp 8010058a <printint+0x1a>
801005e4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801005ea: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801005f0 <consolewrite>:
int
consolewrite(struct inode *ip, char *buf, int n)
{
801005f0: 55 push %ebp
801005f1: 89 e5 mov %esp,%ebp
801005f3: 57 push %edi
801005f4: 56 push %esi
801005f5: 53 push %ebx
801005f6: 83 ec 1c sub $0x1c,%esp
int i;
iunlock(ip);
801005f9: 8b 45 08 mov 0x8(%ebp),%eax
{
801005fc: 8b 75 10 mov 0x10(%ebp),%esi
iunlock(ip);
801005ff: 89 04 24 mov %eax,(%esp)
80100602: e8 89 11 00 00 call 80101790 <iunlock>
acquire(&cons.lock);
80100607: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
8010060e: e8 2d 3b 00 00 call 80104140 <acquire>
80100613: 8b 7d 0c mov 0xc(%ebp),%edi
for(i = 0; i < n; i++)
80100616: 85 f6 test %esi,%esi
80100618: 8d 1c 37 lea (%edi,%esi,1),%ebx
8010061b: 7e 12 jle 8010062f <consolewrite+0x3f>
8010061d: 8d 76 00 lea 0x0(%esi),%esi
consputc(buf[i] & 0xff);
80100620: 0f b6 07 movzbl (%edi),%eax
80100623: 83 c7 01 add $0x1,%edi
80100626: e8 b5 fd ff ff call 801003e0 <consputc>
for(i = 0; i < n; i++)
8010062b: 39 df cmp %ebx,%edi
8010062d: 75 f1 jne 80100620 <consolewrite+0x30>
release(&cons.lock);
8010062f: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100636: e8 f5 3b 00 00 call 80104230 <release>
ilock(ip);
8010063b: 8b 45 08 mov 0x8(%ebp),%eax
8010063e: 89 04 24 mov %eax,(%esp)
80100641: e8 6a 10 00 00 call 801016b0 <ilock>
return n;
}
80100646: 83 c4 1c add $0x1c,%esp
80100649: 89 f0 mov %esi,%eax
8010064b: 5b pop %ebx
8010064c: 5e pop %esi
8010064d: 5f pop %edi
8010064e: 5d pop %ebp
8010064f: c3 ret
80100650 <cprintf>:
{
80100650: 55 push %ebp
80100651: 89 e5 mov %esp,%ebp
80100653: 57 push %edi
80100654: 56 push %esi
80100655: 53 push %ebx
80100656: 83 ec 1c sub $0x1c,%esp
locking = cons.locking;
80100659: a1 54 a5 10 80 mov 0x8010a554,%eax
if(locking)
8010065e: 85 c0 test %eax,%eax
locking = cons.locking;
80100660: 89 45 e0 mov %eax,-0x20(%ebp)
if(locking)
80100663: 0f 85 27 01 00 00 jne 80100790 <cprintf+0x140>
if (fmt == 0)
80100669: 8b 45 08 mov 0x8(%ebp),%eax
8010066c: 85 c0 test %eax,%eax
8010066e: 89 c1 mov %eax,%ecx
80100670: 0f 84 2b 01 00 00 je 801007a1 <cprintf+0x151>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
80100676: 0f b6 00 movzbl (%eax),%eax
80100679: 31 db xor %ebx,%ebx
8010067b: 89 cf mov %ecx,%edi
8010067d: 8d 75 0c lea 0xc(%ebp),%esi
80100680: 85 c0 test %eax,%eax
80100682: 75 4c jne 801006d0 <cprintf+0x80>
80100684: eb 5f jmp 801006e5 <cprintf+0x95>
80100686: 66 90 xchg %ax,%ax
c = fmt[++i] & 0xff;
80100688: 83 c3 01 add $0x1,%ebx
8010068b: 0f b6 14 1f movzbl (%edi,%ebx,1),%edx
if(c == 0)
8010068f: 85 d2 test %edx,%edx
80100691: 74 52 je 801006e5 <cprintf+0x95>
switch(c){
80100693: 83 fa 70 cmp $0x70,%edx
80100696: 74 72 je 8010070a <cprintf+0xba>
80100698: 7f 66 jg 80100700 <cprintf+0xb0>
8010069a: 83 fa 25 cmp $0x25,%edx
8010069d: 8d 76 00 lea 0x0(%esi),%esi
801006a0: 0f 84 a2 00 00 00 je 80100748 <cprintf+0xf8>
801006a6: 83 fa 64 cmp $0x64,%edx
801006a9: 75 7d jne 80100728 <cprintf+0xd8>
printint(*argp++, 10, 1);
801006ab: 8d 46 04 lea 0x4(%esi),%eax
801006ae: b9 01 00 00 00 mov $0x1,%ecx
801006b3: 89 45 e4 mov %eax,-0x1c(%ebp)
801006b6: 8b 06 mov (%esi),%eax
801006b8: ba 0a 00 00 00 mov $0xa,%edx
801006bd: e8 ae fe ff ff call 80100570 <printint>
801006c2: 8b 75 e4 mov -0x1c(%ebp),%esi
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006c5: 83 c3 01 add $0x1,%ebx
801006c8: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006cc: 85 c0 test %eax,%eax
801006ce: 74 15 je 801006e5 <cprintf+0x95>
if(c != '%'){
801006d0: 83 f8 25 cmp $0x25,%eax
801006d3: 74 b3 je 80100688 <cprintf+0x38>
consputc(c);
801006d5: e8 06 fd ff ff call 801003e0 <consputc>
for(i = 0; (c = fmt[i] & 0xff) != 0; i++){
801006da: 83 c3 01 add $0x1,%ebx
801006dd: 0f b6 04 1f movzbl (%edi,%ebx,1),%eax
801006e1: 85 c0 test %eax,%eax
801006e3: 75 eb jne 801006d0 <cprintf+0x80>
if(locking)
801006e5: 8b 45 e0 mov -0x20(%ebp),%eax
801006e8: 85 c0 test %eax,%eax
801006ea: 74 0c je 801006f8 <cprintf+0xa8>
release(&cons.lock);
801006ec: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801006f3: e8 38 3b 00 00 call 80104230 <release>
}
801006f8: 83 c4 1c add $0x1c,%esp
801006fb: 5b pop %ebx
801006fc: 5e pop %esi
801006fd: 5f pop %edi
801006fe: 5d pop %ebp
801006ff: c3 ret
switch(c){
80100700: 83 fa 73 cmp $0x73,%edx
80100703: 74 53 je 80100758 <cprintf+0x108>
80100705: 83 fa 78 cmp $0x78,%edx
80100708: 75 1e jne 80100728 <cprintf+0xd8>
printint(*argp++, 16, 0);
8010070a: 8d 46 04 lea 0x4(%esi),%eax
8010070d: 31 c9 xor %ecx,%ecx
8010070f: 89 45 e4 mov %eax,-0x1c(%ebp)
80100712: 8b 06 mov (%esi),%eax
80100714: ba 10 00 00 00 mov $0x10,%edx
80100719: e8 52 fe ff ff call 80100570 <printint>
8010071e: 8b 75 e4 mov -0x1c(%ebp),%esi
break;
80100721: eb a2 jmp 801006c5 <cprintf+0x75>
80100723: 90 nop
80100724: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100728: b8 25 00 00 00 mov $0x25,%eax
8010072d: 89 55 e4 mov %edx,-0x1c(%ebp)
80100730: e8 ab fc ff ff call 801003e0 <consputc>
consputc(c);
80100735: 8b 55 e4 mov -0x1c(%ebp),%edx
80100738: 89 d0 mov %edx,%eax
8010073a: e8 a1 fc ff ff call 801003e0 <consputc>
8010073f: eb 99 jmp 801006da <cprintf+0x8a>
80100741: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
consputc('%');
80100748: b8 25 00 00 00 mov $0x25,%eax
8010074d: e8 8e fc ff ff call 801003e0 <consputc>
break;
80100752: e9 6e ff ff ff jmp 801006c5 <cprintf+0x75>
80100757: 90 nop
if((s = (char*)*argp++) == 0)
80100758: 8d 46 04 lea 0x4(%esi),%eax
8010075b: 8b 36 mov (%esi),%esi
8010075d: 89 45 e4 mov %eax,-0x1c(%ebp)
s = "(null)";
80100760: b8 b8 6e 10 80 mov $0x80106eb8,%eax
80100765: 85 f6 test %esi,%esi
80100767: 0f 44 f0 cmove %eax,%esi
for(; *s; s++)
8010076a: 0f be 06 movsbl (%esi),%eax
8010076d: 84 c0 test %al,%al
8010076f: 74 16 je 80100787 <cprintf+0x137>
80100771: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100778: 83 c6 01 add $0x1,%esi
consputc(*s);
8010077b: e8 60 fc ff ff call 801003e0 <consputc>
for(; *s; s++)
80100780: 0f be 06 movsbl (%esi),%eax
80100783: 84 c0 test %al,%al
80100785: 75 f1 jne 80100778 <cprintf+0x128>
if((s = (char*)*argp++) == 0)
80100787: 8b 75 e4 mov -0x1c(%ebp),%esi
8010078a: e9 36 ff ff ff jmp 801006c5 <cprintf+0x75>
8010078f: 90 nop
acquire(&cons.lock);
80100790: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100797: e8 a4 39 00 00 call 80104140 <acquire>
8010079c: e9 c8 fe ff ff jmp 80100669 <cprintf+0x19>
panic("null fmt");
801007a1: c7 04 24 bf 6e 10 80 movl $0x80106ebf,(%esp)
801007a8: e8 b3 fb ff ff call 80100360 <panic>
801007ad: 8d 76 00 lea 0x0(%esi),%esi
801007b0 <consoleintr>:
{
801007b0: 55 push %ebp
801007b1: 89 e5 mov %esp,%ebp
801007b3: 57 push %edi
801007b4: 56 push %esi
int c, doprocdump = 0;
801007b5: 31 f6 xor %esi,%esi
{
801007b7: 53 push %ebx
801007b8: 83 ec 1c sub $0x1c,%esp
801007bb: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&cons.lock);
801007be: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
801007c5: e8 76 39 00 00 call 80104140 <acquire>
801007ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
while((c = getc()) >= 0){
801007d0: ff d3 call *%ebx
801007d2: 85 c0 test %eax,%eax
801007d4: 89 c7 mov %eax,%edi
801007d6: 78 48 js 80100820 <consoleintr+0x70>
switch(c){
801007d8: 83 ff 10 cmp $0x10,%edi
801007db: 0f 84 2f 01 00 00 je 80100910 <consoleintr+0x160>
801007e1: 7e 5d jle 80100840 <consoleintr+0x90>
801007e3: 83 ff 15 cmp $0x15,%edi
801007e6: 0f 84 d4 00 00 00 je 801008c0 <consoleintr+0x110>
801007ec: 83 ff 7f cmp $0x7f,%edi
801007ef: 90 nop
801007f0: 75 53 jne 80100845 <consoleintr+0x95>
if(input.e != input.w){
801007f2: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801007f7: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801007fd: 74 d1 je 801007d0 <consoleintr+0x20>
input.e--;
801007ff: 83 e8 01 sub $0x1,%eax
80100802: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
80100807: b8 00 01 00 00 mov $0x100,%eax
8010080c: e8 cf fb ff ff call 801003e0 <consputc>
while((c = getc()) >= 0){
80100811: ff d3 call *%ebx
80100813: 85 c0 test %eax,%eax
80100815: 89 c7 mov %eax,%edi
80100817: 79 bf jns 801007d8 <consoleintr+0x28>
80100819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&cons.lock);
80100820: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100827: e8 04 3a 00 00 call 80104230 <release>
if(doprocdump) {
8010082c: 85 f6 test %esi,%esi
8010082e: 0f 85 ec 00 00 00 jne 80100920 <consoleintr+0x170>
}
80100834: 83 c4 1c add $0x1c,%esp
80100837: 5b pop %ebx
80100838: 5e pop %esi
80100839: 5f pop %edi
8010083a: 5d pop %ebp
8010083b: c3 ret
8010083c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
switch(c){
80100840: 83 ff 08 cmp $0x8,%edi
80100843: 74 ad je 801007f2 <consoleintr+0x42>
if(c != 0 && input.e-input.r < INPUT_BUF){
80100845: 85 ff test %edi,%edi
80100847: 74 87 je 801007d0 <consoleintr+0x20>
80100849: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010084e: 89 c2 mov %eax,%edx
80100850: 2b 15 a0 ff 10 80 sub 0x8010ffa0,%edx
80100856: 83 fa 7f cmp $0x7f,%edx
80100859: 0f 87 71 ff ff ff ja 801007d0 <consoleintr+0x20>
input.buf[input.e++ % INPUT_BUF] = c;
8010085f: 8d 50 01 lea 0x1(%eax),%edx
80100862: 83 e0 7f and $0x7f,%eax
c = (c == '\r') ? '\n' : c;
80100865: 83 ff 0d cmp $0xd,%edi
input.buf[input.e++ % INPUT_BUF] = c;
80100868: 89 15 a8 ff 10 80 mov %edx,0x8010ffa8
c = (c == '\r') ? '\n' : c;
8010086e: 0f 84 b8 00 00 00 je 8010092c <consoleintr+0x17c>
input.buf[input.e++ % INPUT_BUF] = c;
80100874: 89 f9 mov %edi,%ecx
80100876: 88 88 20 ff 10 80 mov %cl,-0x7fef00e0(%eax)
consputc(c);
8010087c: 89 f8 mov %edi,%eax
8010087e: e8 5d fb ff ff call 801003e0 <consputc>
if(c == '\n' || c == C('D') || input.e == input.r+INPUT_BUF){
80100883: 83 ff 04 cmp $0x4,%edi
80100886: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
8010088b: 74 19 je 801008a6 <consoleintr+0xf6>
8010088d: 83 ff 0a cmp $0xa,%edi
80100890: 74 14 je 801008a6 <consoleintr+0xf6>
80100892: 8b 0d a0 ff 10 80 mov 0x8010ffa0,%ecx
80100898: 8d 91 80 00 00 00 lea 0x80(%ecx),%edx
8010089e: 39 d0 cmp %edx,%eax
801008a0: 0f 85 2a ff ff ff jne 801007d0 <consoleintr+0x20>
wakeup(&input.r);
801008a6: c7 04 24 a0 ff 10 80 movl $0x8010ffa0,(%esp)
input.w = input.e;
801008ad: a3 a4 ff 10 80 mov %eax,0x8010ffa4
wakeup(&input.r);
801008b2: e8 d9 34 00 00 call 80103d90 <wakeup>
801008b7: e9 14 ff ff ff jmp 801007d0 <consoleintr+0x20>
801008bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(input.e != input.w &&
801008c0: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008c5: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008cb: 75 2b jne 801008f8 <consoleintr+0x148>
801008cd: e9 fe fe ff ff jmp 801007d0 <consoleintr+0x20>
801008d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
input.e--;
801008d8: a3 a8 ff 10 80 mov %eax,0x8010ffa8
consputc(BACKSPACE);
801008dd: b8 00 01 00 00 mov $0x100,%eax
801008e2: e8 f9 fa ff ff call 801003e0 <consputc>
while(input.e != input.w &&
801008e7: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
801008ec: 3b 05 a4 ff 10 80 cmp 0x8010ffa4,%eax
801008f2: 0f 84 d8 fe ff ff je 801007d0 <consoleintr+0x20>
input.buf[(input.e-1) % INPUT_BUF] != '\n'){
801008f8: 83 e8 01 sub $0x1,%eax
801008fb: 89 c2 mov %eax,%edx
801008fd: 83 e2 7f and $0x7f,%edx
while(input.e != input.w &&
80100900: 80 ba 20 ff 10 80 0a cmpb $0xa,-0x7fef00e0(%edx)
80100907: 75 cf jne 801008d8 <consoleintr+0x128>
80100909: e9 c2 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010090e: 66 90 xchg %ax,%ax
doprocdump = 1;
80100910: be 01 00 00 00 mov $0x1,%esi
80100915: e9 b6 fe ff ff jmp 801007d0 <consoleintr+0x20>
8010091a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
}
80100920: 83 c4 1c add $0x1c,%esp
80100923: 5b pop %ebx
80100924: 5e pop %esi
80100925: 5f pop %edi
80100926: 5d pop %ebp
procdump(); // now call procdump() wo. cons.lock held
80100927: e9 44 35 00 00 jmp 80103e70 <procdump>
input.buf[input.e++ % INPUT_BUF] = c;
8010092c: c6 80 20 ff 10 80 0a movb $0xa,-0x7fef00e0(%eax)
consputc(c);
80100933: b8 0a 00 00 00 mov $0xa,%eax
80100938: e8 a3 fa ff ff call 801003e0 <consputc>
8010093d: a1 a8 ff 10 80 mov 0x8010ffa8,%eax
80100942: e9 5f ff ff ff jmp 801008a6 <consoleintr+0xf6>
80100947: 89 f6 mov %esi,%esi
80100949: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100950 <consoleinit>:
void
consoleinit(void)
{
80100950: 55 push %ebp
80100951: 89 e5 mov %esp,%ebp
80100953: 83 ec 18 sub $0x18,%esp
initlock(&cons.lock, "console");
80100956: c7 44 24 04 c8 6e 10 movl $0x80106ec8,0x4(%esp)
8010095d: 80
8010095e: c7 04 24 20 a5 10 80 movl $0x8010a520,(%esp)
80100965: e8 e6 36 00 00 call 80104050 <initlock>
devsw[CONSOLE].write = consolewrite;
devsw[CONSOLE].read = consoleread;
cons.locking = 1;
ioapicenable(IRQ_KBD, 0);
8010096a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80100971: 00
80100972: c7 04 24 01 00 00 00 movl $0x1,(%esp)
devsw[CONSOLE].write = consolewrite;
80100979: c7 05 6c 09 11 80 f0 movl $0x801005f0,0x8011096c
80100980: 05 10 80
devsw[CONSOLE].read = consoleread;
80100983: c7 05 68 09 11 80 70 movl $0x80100270,0x80110968
8010098a: 02 10 80
cons.locking = 1;
8010098d: c7 05 54 a5 10 80 01 movl $0x1,0x8010a554
80100994: 00 00 00
ioapicenable(IRQ_KBD, 0);
80100997: e8 14 19 00 00 call 801022b0 <ioapicenable>
}
8010099c: c9 leave
8010099d: c3 ret
8010099e: 66 90 xchg %ax,%ax
801009a0 <exec>:
#include "x86.h"
#include "elf.h"
int
exec(char *path, char **argv)
{
801009a0: 55 push %ebp
801009a1: 89 e5 mov %esp,%ebp
801009a3: 57 push %edi
801009a4: 56 push %esi
801009a5: 53 push %ebx
801009a6: 81 ec 2c 01 00 00 sub $0x12c,%esp
uint argc, sz, sp, ustack[3+MAXARG+1];
struct elfhdr elf;
struct inode *ip;
struct proghdr ph;
pde_t *pgdir, *oldpgdir;
struct proc *curproc = myproc();
801009ac: e8 ef 2c 00 00 call 801036a0 <myproc>
801009b1: 89 85 f4 fe ff ff mov %eax,-0x10c(%ebp)
// curproc->szStack = 1;
begin_op();
801009b7: e8 54 21 00 00 call 80102b10 <begin_op>
if((ip = namei(path)) == 0){
801009bc: 8b 45 08 mov 0x8(%ebp),%eax
801009bf: 89 04 24 mov %eax,(%esp)
801009c2: e8 39 15 00 00 call 80101f00 <namei>
801009c7: 85 c0 test %eax,%eax
801009c9: 89 c3 mov %eax,%ebx
801009cb: 0f 84 3f 02 00 00 je 80100c10 <exec+0x270>
end_op();
cprintf("exec: fail\n");
return -1;
}
ilock(ip);
801009d1: 89 04 24 mov %eax,(%esp)
801009d4: e8 d7 0c 00 00 call 801016b0 <ilock>
pgdir = 0;
// Check ELF header
if(readi(ip, (char*)&elf, 0, sizeof(elf)) != sizeof(elf))
801009d9: 8d 85 24 ff ff ff lea -0xdc(%ebp),%eax
801009df: c7 44 24 0c 34 00 00 movl $0x34,0xc(%esp)
801009e6: 00
801009e7: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
801009ee: 00
801009ef: 89 44 24 04 mov %eax,0x4(%esp)
801009f3: 89 1c 24 mov %ebx,(%esp)
801009f6: e8 65 0f 00 00 call 80101960 <readi>
801009fb: 83 f8 34 cmp $0x34,%eax
801009fe: 74 20 je 80100a20 <exec+0x80>
bad:
if(pgdir)
freevm(pgdir);
if(ip){
iunlockput(ip);
80100a00: 89 1c 24 mov %ebx,(%esp)
80100a03: e8 08 0f 00 00 call 80101910 <iunlockput>
end_op();
80100a08: e8 73 21 00 00 call 80102b80 <end_op>
}
return -1;
80100a0d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100a12: 81 c4 2c 01 00 00 add $0x12c,%esp
80100a18: 5b pop %ebx
80100a19: 5e pop %esi
80100a1a: 5f pop %edi
80100a1b: 5d pop %ebp
80100a1c: c3 ret
80100a1d: 8d 76 00 lea 0x0(%esi),%esi
if(elf.magic != ELF_MAGIC)
80100a20: 81 bd 24 ff ff ff 7f cmpl $0x464c457f,-0xdc(%ebp)
80100a27: 45 4c 46
80100a2a: 75 d4 jne 80100a00 <exec+0x60>
if((pgdir = setupkvm()) == 0)
80100a2c: e8 3f 60 00 00 call 80106a70 <setupkvm>
80100a31: 85 c0 test %eax,%eax
80100a33: 89 85 f0 fe ff ff mov %eax,-0x110(%ebp)
80100a39: 74 c5 je 80100a00 <exec+0x60>
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a3b: 66 83 bd 50 ff ff ff cmpw $0x0,-0xb0(%ebp)
80100a42: 00
80100a43: 8b b5 40 ff ff ff mov -0xc0(%ebp),%esi
sz = 0;
80100a49: c7 85 ec fe ff ff 00 movl $0x0,-0x114(%ebp)
80100a50: 00 00 00
for(i=0, off=elf.phoff; i<elf.phnum; i++, off+=sizeof(ph)){
80100a53: 0f 84 da 00 00 00 je 80100b33 <exec+0x193>
80100a59: 31 ff xor %edi,%edi
80100a5b: eb 18 jmp 80100a75 <exec+0xd5>
80100a5d: 8d 76 00 lea 0x0(%esi),%esi
80100a60: 0f b7 85 50 ff ff ff movzwl -0xb0(%ebp),%eax
80100a67: 83 c7 01 add $0x1,%edi
80100a6a: 83 c6 20 add $0x20,%esi
80100a6d: 39 f8 cmp %edi,%eax
80100a6f: 0f 8e be 00 00 00 jle 80100b33 <exec+0x193>
if(readi(ip, (char*)&ph, off, sizeof(ph)) != sizeof(ph))
80100a75: 8d 85 04 ff ff ff lea -0xfc(%ebp),%eax
80100a7b: c7 44 24 0c 20 00 00 movl $0x20,0xc(%esp)
80100a82: 00
80100a83: 89 74 24 08 mov %esi,0x8(%esp)
80100a87: 89 44 24 04 mov %eax,0x4(%esp)
80100a8b: 89 1c 24 mov %ebx,(%esp)
80100a8e: e8 cd 0e 00 00 call 80101960 <readi>
80100a93: 83 f8 20 cmp $0x20,%eax
80100a96: 0f 85 84 00 00 00 jne 80100b20 <exec+0x180>
if(ph.type != ELF_PROG_LOAD)
80100a9c: 83 bd 04 ff ff ff 01 cmpl $0x1,-0xfc(%ebp)
80100aa3: 75 bb jne 80100a60 <exec+0xc0>
if(ph.memsz < ph.filesz)
80100aa5: 8b 85 18 ff ff ff mov -0xe8(%ebp),%eax
80100aab: 3b 85 14 ff ff ff cmp -0xec(%ebp),%eax
80100ab1: 72 6d jb 80100b20 <exec+0x180>
if(ph.vaddr + ph.memsz < ph.vaddr)
80100ab3: 03 85 0c ff ff ff add -0xf4(%ebp),%eax
80100ab9: 72 65 jb 80100b20 <exec+0x180>
if((sz = allocuvm(pgdir, sz, ph.vaddr + ph.memsz)) == 0)
80100abb: 89 44 24 08 mov %eax,0x8(%esp)
80100abf: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
80100ac5: 89 44 24 04 mov %eax,0x4(%esp)
80100ac9: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100acf: 89 04 24 mov %eax,(%esp)
80100ad2: e8 f9 5d 00 00 call 801068d0 <allocuvm>
80100ad7: 85 c0 test %eax,%eax
80100ad9: 89 85 ec fe ff ff mov %eax,-0x114(%ebp)
80100adf: 74 3f je 80100b20 <exec+0x180>
if(ph.vaddr % PGSIZE != 0)
80100ae1: 8b 85 0c ff ff ff mov -0xf4(%ebp),%eax
80100ae7: a9 ff 0f 00 00 test $0xfff,%eax
80100aec: 75 32 jne 80100b20 <exec+0x180>
if(loaduvm(pgdir, (char*)ph.vaddr, ip, ph.off, ph.filesz) < 0)
80100aee: 8b 95 14 ff ff ff mov -0xec(%ebp),%edx
80100af4: 89 44 24 04 mov %eax,0x4(%esp)
80100af8: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100afe: 89 5c 24 08 mov %ebx,0x8(%esp)
80100b02: 89 54 24 10 mov %edx,0x10(%esp)
80100b06: 8b 95 08 ff ff ff mov -0xf8(%ebp),%edx
80100b0c: 89 04 24 mov %eax,(%esp)
80100b0f: 89 54 24 0c mov %edx,0xc(%esp)
80100b13: e8 f8 5c 00 00 call 80106810 <loaduvm>
80100b18: 85 c0 test %eax,%eax
80100b1a: 0f 89 40 ff ff ff jns 80100a60 <exec+0xc0>
freevm(pgdir);
80100b20: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b26: 89 04 24 mov %eax,(%esp)
80100b29: e8 c2 5e 00 00 call 801069f0 <freevm>
80100b2e: e9 cd fe ff ff jmp 80100a00 <exec+0x60>
iunlockput(ip);
80100b33: 89 1c 24 mov %ebx,(%esp)
80100b36: e8 d5 0d 00 00 call 80101910 <iunlockput>
80100b3b: 90 nop
80100b3c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80100b40: e8 3b 20 00 00 call 80102b80 <end_op>
if((stack2 = allocuvm(pgdir, stack2, stack2 + 2) == 0))// KERNBASE2, KERNBASE2 - PGSIZE)) == 0)
80100b45: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100b4b: c7 44 24 08 02 f0 ff movl $0x7ffff002,0x8(%esp)
80100b52: 7f
80100b53: c7 44 24 04 00 f0 ff movl $0x7ffff000,0x4(%esp)
80100b5a: 7f
80100b5b: 89 04 24 mov %eax,(%esp)
80100b5e: e8 6d 5d 00 00 call 801068d0 <allocuvm>
80100b63: 85 c0 test %eax,%eax
80100b65: 0f 84 8d 00 00 00 je 80100bf8 <exec+0x258>
for(argc = 0; argv[argc]; argc++) {
80100b6b: 8b 45 0c mov 0xc(%ebp),%eax
80100b6e: 8b 00 mov (%eax),%eax
80100b70: 85 c0 test %eax,%eax
80100b72: 0f 84 af 01 00 00 je 80100d27 <exec+0x387>
80100b78: 8b 4d 0c mov 0xc(%ebp),%ecx
80100b7b: 31 d2 xor %edx,%edx
80100b7d: bb ff ff ff 7f mov $0x7fffffff,%ebx
80100b82: 8d 71 04 lea 0x4(%ecx),%esi
80100b85: 89 cf mov %ecx,%edi
80100b87: 89 f1 mov %esi,%ecx
80100b89: 89 d6 mov %edx,%esi
80100b8b: 89 ca mov %ecx,%edx
80100b8d: eb 27 jmp 80100bb6 <exec+0x216>
80100b8f: 90 nop
80100b90: 8b 95 e8 fe ff ff mov -0x118(%ebp),%edx
ustack[3+argc] = sp;
80100b96: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100b9c: 89 9c b5 64 ff ff ff mov %ebx,-0x9c(%ebp,%esi,4)
for(argc = 0; argv[argc]; argc++) {
80100ba3: 83 c6 01 add $0x1,%esi
80100ba6: 8b 02 mov (%edx),%eax
80100ba8: 89 d7 mov %edx,%edi
80100baa: 85 c0 test %eax,%eax
80100bac: 74 7d je 80100c2b <exec+0x28b>
80100bae: 83 c2 04 add $0x4,%edx
if(argc >= MAXARG)
80100bb1: 83 fe 20 cmp $0x20,%esi
80100bb4: 74 42 je 80100bf8 <exec+0x258>
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bb6: 89 04 24 mov %eax,(%esp)
80100bb9: 89 95 e8 fe ff ff mov %edx,-0x118(%ebp)
80100bbf: e8 dc 38 00 00 call 801044a0 <strlen>
80100bc4: f7 d0 not %eax
80100bc6: 01 c3 add %eax,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bc8: 8b 07 mov (%edi),%eax
sp = (sp - (strlen(argv[argc]) + 1)) & ~3;
80100bca: 83 e3 fc and $0xfffffffc,%ebx
if(copyout(pgdir, sp, argv[argc], strlen(argv[argc]) + 1) < 0)
80100bcd: 89 04 24 mov %eax,(%esp)
80100bd0: e8 cb 38 00 00 call 801044a0 <strlen>
80100bd5: 83 c0 01 add $0x1,%eax
80100bd8: 89 44 24 0c mov %eax,0xc(%esp)
80100bdc: 8b 07 mov (%edi),%eax
80100bde: 89 5c 24 04 mov %ebx,0x4(%esp)
80100be2: 89 44 24 08 mov %eax,0x8(%esp)
80100be6: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100bec: 89 04 24 mov %eax,(%esp)
80100bef: e8 4c 61 00 00 call 80106d40 <copyout>
80100bf4: 85 c0 test %eax,%eax
80100bf6: 79 98 jns 80100b90 <exec+0x1f0>
freevm(pgdir);
80100bf8: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100bfe: 89 04 24 mov %eax,(%esp)
80100c01: e8 ea 5d 00 00 call 801069f0 <freevm>
return -1;
80100c06: b8 ff ff ff ff mov $0xffffffff,%eax
80100c0b: e9 02 fe ff ff jmp 80100a12 <exec+0x72>
end_op();
80100c10: e8 6b 1f 00 00 call 80102b80 <end_op>
cprintf("exec: fail\n");
80100c15: c7 04 24 e1 6e 10 80 movl $0x80106ee1,(%esp)
80100c1c: e8 2f fa ff ff call 80100650 <cprintf>
return -1;
80100c21: b8 ff ff ff ff mov $0xffffffff,%eax
80100c26: e9 e7 fd ff ff jmp 80100a12 <exec+0x72>
80100c2b: 89 f2 mov %esi,%edx
ustack[3+argc] = 0;
80100c2d: c7 84 95 64 ff ff ff movl $0x0,-0x9c(%ebp,%edx,4)
80100c34: 00 00 00 00
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c38: 8d 04 95 04 00 00 00 lea 0x4(,%edx,4),%eax
ustack[1] = argc;
80100c3f: 89 95 5c ff ff ff mov %edx,-0xa4(%ebp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c45: 89 da mov %ebx,%edx
80100c47: 29 c2 sub %eax,%edx
sp -= (3+argc+1) * 4;
80100c49: 83 c0 0c add $0xc,%eax
80100c4c: 29 c3 sub %eax,%ebx
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c4e: 89 44 24 0c mov %eax,0xc(%esp)
80100c52: 8b 85 f0 fe ff ff mov -0x110(%ebp),%eax
80100c58: 89 4c 24 08 mov %ecx,0x8(%esp)
80100c5c: 89 5c 24 04 mov %ebx,0x4(%esp)
ustack[0] = 0xffffffff; // fake return PC
80100c60: c7 85 58 ff ff ff ff movl $0xffffffff,-0xa8(%ebp)
80100c67: ff ff ff
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c6a: 89 04 24 mov %eax,(%esp)
ustack[2] = sp - (argc+1)*4; // argv pointer
80100c6d: 89 95 60 ff ff ff mov %edx,-0xa0(%ebp)
if(copyout(pgdir, sp, ustack, (3+argc+1)*4) < 0)
80100c73: e8 c8 60 00 00 call 80106d40 <copyout>
80100c78: 85 c0 test %eax,%eax
80100c7a: 0f 88 78 ff ff ff js 80100bf8 <exec+0x258>
for(last=s=path; *s; s++)
80100c80: 8b 45 08 mov 0x8(%ebp),%eax
80100c83: 0f b6 10 movzbl (%eax),%edx
80100c86: 84 d2 test %dl,%dl
80100c88: 74 19 je 80100ca3 <exec+0x303>
80100c8a: 8b 4d 08 mov 0x8(%ebp),%ecx
80100c8d: 83 c0 01 add $0x1,%eax
last = s+1;
80100c90: 80 fa 2f cmp $0x2f,%dl
for(last=s=path; *s; s++)
80100c93: 0f b6 10 movzbl (%eax),%edx
last = s+1;
80100c96: 0f 44 c8 cmove %eax,%ecx
80100c99: 83 c0 01 add $0x1,%eax
for(last=s=path; *s; s++)
80100c9c: 84 d2 test %dl,%dl
80100c9e: 75 f0 jne 80100c90 <exec+0x2f0>
80100ca0: 89 4d 08 mov %ecx,0x8(%ebp)
safestrcpy(curproc->name, last, sizeof(curproc->name));
80100ca3: 8b bd f4 fe ff ff mov -0x10c(%ebp),%edi
80100ca9: 8b 45 08 mov 0x8(%ebp),%eax
80100cac: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80100cb3: 00
80100cb4: 89 44 24 04 mov %eax,0x4(%esp)
80100cb8: 89 f8 mov %edi,%eax
80100cba: 83 c0 70 add $0x70,%eax
80100cbd: 89 04 24 mov %eax,(%esp)
80100cc0: e8 9b 37 00 00 call 80104460 <safestrcpy>
sz = PGROUNDUP(sz);
80100cc5: 8b 85 ec fe ff ff mov -0x114(%ebp),%eax
curproc->pgdir = pgdir;
80100ccb: 8b 95 f0 fe ff ff mov -0x110(%ebp),%edx
oldpgdir = curproc->pgdir;
80100cd1: 8b 77 04 mov 0x4(%edi),%esi
curproc->szStack = 1;
80100cd4: c7 47 08 01 00 00 00 movl $0x1,0x8(%edi)
sz = PGROUNDUP(sz);
80100cdb: 05 ff 0f 00 00 add $0xfff,%eax
80100ce0: 25 00 f0 ff ff and $0xfffff000,%eax
curproc->pgdir = pgdir;
80100ce5: 89 57 04 mov %edx,0x4(%edi)
sz = PGROUNDUP(sz);
80100ce8: 89 07 mov %eax,(%edi)
cprintf("Initial number of pages by the process: %d\n", curproc->szStack);
80100cea: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80100cf1: 00
80100cf2: c7 04 24 f0 6e 10 80 movl $0x80106ef0,(%esp)
80100cf9: e8 52 f9 ff ff call 80100650 <cprintf>
curproc->tf->eip = elf.entry; // main
80100cfe: 8b 47 1c mov 0x1c(%edi),%eax
80100d01: 8b 95 3c ff ff ff mov -0xc4(%ebp),%edx
80100d07: 89 50 38 mov %edx,0x38(%eax)
curproc->tf->esp = sp;
80100d0a: 8b 47 1c mov 0x1c(%edi),%eax
80100d0d: 89 58 44 mov %ebx,0x44(%eax)
switchuvm(curproc);
80100d10: 89 3c 24 mov %edi,(%esp)
80100d13: e8 58 59 00 00 call 80106670 <switchuvm>
freevm(oldpgdir);
80100d18: 89 34 24 mov %esi,(%esp)
80100d1b: e8 d0 5c 00 00 call 801069f0 <freevm>
return 0;
80100d20: 31 c0 xor %eax,%eax
80100d22: e9 eb fc ff ff jmp 80100a12 <exec+0x72>
for(argc = 0; argv[argc]; argc++) {
80100d27: bb ff ff ff 7f mov $0x7fffffff,%ebx
80100d2c: 31 d2 xor %edx,%edx
80100d2e: 8d 8d 58 ff ff ff lea -0xa8(%ebp),%ecx
80100d34: e9 f4 fe ff ff jmp 80100c2d <exec+0x28d>
80100d39: 66 90 xchg %ax,%ax
80100d3b: 66 90 xchg %ax,%ax
80100d3d: 66 90 xchg %ax,%ax
80100d3f: 90 nop
80100d40 <fileinit>:
struct file file[NFILE];
} ftable;
void
fileinit(void)
{
80100d40: 55 push %ebp
80100d41: 89 e5 mov %esp,%ebp
80100d43: 83 ec 18 sub $0x18,%esp
initlock(&ftable.lock, "ftable");
80100d46: c7 44 24 04 1c 6f 10 movl $0x80106f1c,0x4(%esp)
80100d4d: 80
80100d4e: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d55: e8 f6 32 00 00 call 80104050 <initlock>
}
80100d5a: c9 leave
80100d5b: c3 ret
80100d5c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100d60 <filealloc>:
// Allocate a file structure.
struct file*
filealloc(void)
{
80100d60: 55 push %ebp
80100d61: 89 e5 mov %esp,%ebp
80100d63: 53 push %ebx
struct file *f;
acquire(&ftable.lock);
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d64: bb f4 ff 10 80 mov $0x8010fff4,%ebx
{
80100d69: 83 ec 14 sub $0x14,%esp
acquire(&ftable.lock);
80100d6c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100d73: e8 c8 33 00 00 call 80104140 <acquire>
80100d78: eb 11 jmp 80100d8b <filealloc+0x2b>
80100d7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(f = ftable.file; f < ftable.file + NFILE; f++){
80100d80: 83 c3 18 add $0x18,%ebx
80100d83: 81 fb 54 09 11 80 cmp $0x80110954,%ebx
80100d89: 74 25 je 80100db0 <filealloc+0x50>
if(f->ref == 0){
80100d8b: 8b 43 04 mov 0x4(%ebx),%eax
80100d8e: 85 c0 test %eax,%eax
80100d90: 75 ee jne 80100d80 <filealloc+0x20>
f->ref = 1;
release(&ftable.lock);
80100d92: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
f->ref = 1;
80100d99: c7 43 04 01 00 00 00 movl $0x1,0x4(%ebx)
release(&ftable.lock);
80100da0: e8 8b 34 00 00 call 80104230 <release>
return f;
}
}
release(&ftable.lock);
return 0;
}
80100da5: 83 c4 14 add $0x14,%esp
return f;
80100da8: 89 d8 mov %ebx,%eax
}
80100daa: 5b pop %ebx
80100dab: 5d pop %ebp
80100dac: c3 ret
80100dad: 8d 76 00 lea 0x0(%esi),%esi
release(&ftable.lock);
80100db0: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100db7: e8 74 34 00 00 call 80104230 <release>
}
80100dbc: 83 c4 14 add $0x14,%esp
return 0;
80100dbf: 31 c0 xor %eax,%eax
}
80100dc1: 5b pop %ebx
80100dc2: 5d pop %ebp
80100dc3: c3 ret
80100dc4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100dca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80100dd0 <filedup>:
// Increment ref count for file f.
struct file*
filedup(struct file *f)
{
80100dd0: 55 push %ebp
80100dd1: 89 e5 mov %esp,%ebp
80100dd3: 53 push %ebx
80100dd4: 83 ec 14 sub $0x14,%esp
80100dd7: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ftable.lock);
80100dda: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100de1: e8 5a 33 00 00 call 80104140 <acquire>
if(f->ref < 1)
80100de6: 8b 43 04 mov 0x4(%ebx),%eax
80100de9: 85 c0 test %eax,%eax
80100deb: 7e 1a jle 80100e07 <filedup+0x37>
panic("filedup");
f->ref++;
80100ded: 83 c0 01 add $0x1,%eax
80100df0: 89 43 04 mov %eax,0x4(%ebx)
release(&ftable.lock);
80100df3: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100dfa: e8 31 34 00 00 call 80104230 <release>
return f;
}
80100dff: 83 c4 14 add $0x14,%esp
80100e02: 89 d8 mov %ebx,%eax
80100e04: 5b pop %ebx
80100e05: 5d pop %ebp
80100e06: c3 ret
panic("filedup");
80100e07: c7 04 24 23 6f 10 80 movl $0x80106f23,(%esp)
80100e0e: e8 4d f5 ff ff call 80100360 <panic>
80100e13: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100e19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100e20 <fileclose>:
// Close file f. (Decrement ref count, close when reaches 0.)
void
fileclose(struct file *f)
{
80100e20: 55 push %ebp
80100e21: 89 e5 mov %esp,%ebp
80100e23: 57 push %edi
80100e24: 56 push %esi
80100e25: 53 push %ebx
80100e26: 83 ec 1c sub $0x1c,%esp
80100e29: 8b 7d 08 mov 0x8(%ebp),%edi
struct file ff;
acquire(&ftable.lock);
80100e2c: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
80100e33: e8 08 33 00 00 call 80104140 <acquire>
if(f->ref < 1)
80100e38: 8b 57 04 mov 0x4(%edi),%edx
80100e3b: 85 d2 test %edx,%edx
80100e3d: 0f 8e 89 00 00 00 jle 80100ecc <fileclose+0xac>
panic("fileclose");
if(--f->ref > 0){
80100e43: 83 ea 01 sub $0x1,%edx
80100e46: 85 d2 test %edx,%edx
80100e48: 89 57 04 mov %edx,0x4(%edi)
80100e4b: 74 13 je 80100e60 <fileclose+0x40>
release(&ftable.lock);
80100e4d: c7 45 08 c0 ff 10 80 movl $0x8010ffc0,0x8(%ebp)
else if(ff.type == FD_INODE){
begin_op();
iput(ff.ip);
end_op();
}
}
80100e54: 83 c4 1c add $0x1c,%esp
80100e57: 5b pop %ebx
80100e58: 5e pop %esi
80100e59: 5f pop %edi
80100e5a: 5d pop %ebp
release(&ftable.lock);
80100e5b: e9 d0 33 00 00 jmp 80104230 <release>
ff = *f;
80100e60: 0f b6 47 09 movzbl 0x9(%edi),%eax
80100e64: 8b 37 mov (%edi),%esi
80100e66: 8b 5f 0c mov 0xc(%edi),%ebx
f->type = FD_NONE;
80100e69: c7 07 00 00 00 00 movl $0x0,(%edi)
ff = *f;
80100e6f: 88 45 e7 mov %al,-0x19(%ebp)
80100e72: 8b 47 10 mov 0x10(%edi),%eax
release(&ftable.lock);
80100e75: c7 04 24 c0 ff 10 80 movl $0x8010ffc0,(%esp)
ff = *f;
80100e7c: 89 45 e0 mov %eax,-0x20(%ebp)
release(&ftable.lock);
80100e7f: e8 ac 33 00 00 call 80104230 <release>
if(ff.type == FD_PIPE)
80100e84: 83 fe 01 cmp $0x1,%esi
80100e87: 74 0f je 80100e98 <fileclose+0x78>
else if(ff.type == FD_INODE){
80100e89: 83 fe 02 cmp $0x2,%esi
80100e8c: 74 22 je 80100eb0 <fileclose+0x90>
}
80100e8e: 83 c4 1c add $0x1c,%esp
80100e91: 5b pop %ebx
80100e92: 5e pop %esi
80100e93: 5f pop %edi
80100e94: 5d pop %ebp
80100e95: c3 ret
80100e96: 66 90 xchg %ax,%ax
pipeclose(ff.pipe, ff.writable);
80100e98: 0f be 75 e7 movsbl -0x19(%ebp),%esi
80100e9c: 89 1c 24 mov %ebx,(%esp)
80100e9f: 89 74 24 04 mov %esi,0x4(%esp)
80100ea3: e8 b8 23 00 00 call 80103260 <pipeclose>
80100ea8: eb e4 jmp 80100e8e <fileclose+0x6e>
80100eaa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
begin_op();
80100eb0: e8 5b 1c 00 00 call 80102b10 <begin_op>
iput(ff.ip);
80100eb5: 8b 45 e0 mov -0x20(%ebp),%eax
80100eb8: 89 04 24 mov %eax,(%esp)
80100ebb: e8 10 09 00 00 call 801017d0 <iput>
}
80100ec0: 83 c4 1c add $0x1c,%esp
80100ec3: 5b pop %ebx
80100ec4: 5e pop %esi
80100ec5: 5f pop %edi
80100ec6: 5d pop %ebp
end_op();
80100ec7: e9 b4 1c 00 00 jmp 80102b80 <end_op>
panic("fileclose");
80100ecc: c7 04 24 2b 6f 10 80 movl $0x80106f2b,(%esp)
80100ed3: e8 88 f4 ff ff call 80100360 <panic>
80100ed8: 90 nop
80100ed9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80100ee0 <filestat>:
// Get metadata about file f.
int
filestat(struct file *f, struct stat *st)
{
80100ee0: 55 push %ebp
80100ee1: 89 e5 mov %esp,%ebp
80100ee3: 53 push %ebx
80100ee4: 83 ec 14 sub $0x14,%esp
80100ee7: 8b 5d 08 mov 0x8(%ebp),%ebx
if(f->type == FD_INODE){
80100eea: 83 3b 02 cmpl $0x2,(%ebx)
80100eed: 75 31 jne 80100f20 <filestat+0x40>
ilock(f->ip);
80100eef: 8b 43 10 mov 0x10(%ebx),%eax
80100ef2: 89 04 24 mov %eax,(%esp)
80100ef5: e8 b6 07 00 00 call 801016b0 <ilock>
stati(f->ip, st);
80100efa: 8b 45 0c mov 0xc(%ebp),%eax
80100efd: 89 44 24 04 mov %eax,0x4(%esp)
80100f01: 8b 43 10 mov 0x10(%ebx),%eax
80100f04: 89 04 24 mov %eax,(%esp)
80100f07: e8 24 0a 00 00 call 80101930 <stati>
iunlock(f->ip);
80100f0c: 8b 43 10 mov 0x10(%ebx),%eax
80100f0f: 89 04 24 mov %eax,(%esp)
80100f12: e8 79 08 00 00 call 80101790 <iunlock>
return 0;
}
return -1;
}
80100f17: 83 c4 14 add $0x14,%esp
return 0;
80100f1a: 31 c0 xor %eax,%eax
}
80100f1c: 5b pop %ebx
80100f1d: 5d pop %ebp
80100f1e: c3 ret
80100f1f: 90 nop
80100f20: 83 c4 14 add $0x14,%esp
return -1;
80100f23: b8 ff ff ff ff mov $0xffffffff,%eax
}
80100f28: 5b pop %ebx
80100f29: 5d pop %ebp
80100f2a: c3 ret
80100f2b: 90 nop
80100f2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80100f30 <fileread>:
// Read from file f.
int
fileread(struct file *f, char *addr, int n)
{
80100f30: 55 push %ebp
80100f31: 89 e5 mov %esp,%ebp
80100f33: 57 push %edi
80100f34: 56 push %esi
80100f35: 53 push %ebx
80100f36: 83 ec 1c sub $0x1c,%esp
80100f39: 8b 5d 08 mov 0x8(%ebp),%ebx
80100f3c: 8b 75 0c mov 0xc(%ebp),%esi
80100f3f: 8b 7d 10 mov 0x10(%ebp),%edi
int r;
if(f->readable == 0)
80100f42: 80 7b 08 00 cmpb $0x0,0x8(%ebx)
80100f46: 74 68 je 80100fb0 <fileread+0x80>
return -1;
if(f->type == FD_PIPE)
80100f48: 8b 03 mov (%ebx),%eax
80100f4a: 83 f8 01 cmp $0x1,%eax
80100f4d: 74 49 je 80100f98 <fileread+0x68>
return piperead(f->pipe, addr, n);
if(f->type == FD_INODE){
80100f4f: 83 f8 02 cmp $0x2,%eax
80100f52: 75 63 jne 80100fb7 <fileread+0x87>
ilock(f->ip);
80100f54: 8b 43 10 mov 0x10(%ebx),%eax
80100f57: 89 04 24 mov %eax,(%esp)
80100f5a: e8 51 07 00 00 call 801016b0 <ilock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f5f: 89 7c 24 0c mov %edi,0xc(%esp)
80100f63: 8b 43 14 mov 0x14(%ebx),%eax
80100f66: 89 74 24 04 mov %esi,0x4(%esp)
80100f6a: 89 44 24 08 mov %eax,0x8(%esp)
80100f6e: 8b 43 10 mov 0x10(%ebx),%eax
80100f71: 89 04 24 mov %eax,(%esp)
80100f74: e8 e7 09 00 00 call 80101960 <readi>
80100f79: 85 c0 test %eax,%eax
80100f7b: 89 c6 mov %eax,%esi
80100f7d: 7e 03 jle 80100f82 <fileread+0x52>
f->off += r;
80100f7f: 01 43 14 add %eax,0x14(%ebx)
iunlock(f->ip);
80100f82: 8b 43 10 mov 0x10(%ebx),%eax
80100f85: 89 04 24 mov %eax,(%esp)
80100f88: e8 03 08 00 00 call 80101790 <iunlock>
if((r = readi(f->ip, addr, f->off, n)) > 0)
80100f8d: 89 f0 mov %esi,%eax
return r;
}
panic("fileread");
}
80100f8f: 83 c4 1c add $0x1c,%esp
80100f92: 5b pop %ebx
80100f93: 5e pop %esi
80100f94: 5f pop %edi
80100f95: 5d pop %ebp
80100f96: c3 ret
80100f97: 90 nop
return piperead(f->pipe, addr, n);
80100f98: 8b 43 0c mov 0xc(%ebx),%eax
80100f9b: 89 45 08 mov %eax,0x8(%ebp)
}
80100f9e: 83 c4 1c add $0x1c,%esp
80100fa1: 5b pop %ebx
80100fa2: 5e pop %esi
80100fa3: 5f pop %edi
80100fa4: 5d pop %ebp
return piperead(f->pipe, addr, n);
80100fa5: e9 36 24 00 00 jmp 801033e0 <piperead>
80100faa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80100fb0: b8 ff ff ff ff mov $0xffffffff,%eax
80100fb5: eb d8 jmp 80100f8f <fileread+0x5f>
panic("fileread");
80100fb7: c7 04 24 35 6f 10 80 movl $0x80106f35,(%esp)
80100fbe: e8 9d f3 ff ff call 80100360 <panic>
80100fc3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80100fc9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80100fd0 <filewrite>:
//PAGEBREAK!
// Write to file f.
int
filewrite(struct file *f, char *addr, int n)
{
80100fd0: 55 push %ebp
80100fd1: 89 e5 mov %esp,%ebp
80100fd3: 57 push %edi
80100fd4: 56 push %esi
80100fd5: 53 push %ebx
80100fd6: 83 ec 2c sub $0x2c,%esp
80100fd9: 8b 45 0c mov 0xc(%ebp),%eax
80100fdc: 8b 7d 08 mov 0x8(%ebp),%edi
80100fdf: 89 45 dc mov %eax,-0x24(%ebp)
80100fe2: 8b 45 10 mov 0x10(%ebp),%eax
int r;
if(f->writable == 0)
80100fe5: 80 7f 09 00 cmpb $0x0,0x9(%edi)
{
80100fe9: 89 45 e4 mov %eax,-0x1c(%ebp)
if(f->writable == 0)
80100fec: 0f 84 ae 00 00 00 je 801010a0 <filewrite+0xd0>
return -1;
if(f->type == FD_PIPE)
80100ff2: 8b 07 mov (%edi),%eax
80100ff4: 83 f8 01 cmp $0x1,%eax
80100ff7: 0f 84 c2 00 00 00 je 801010bf <filewrite+0xef>
return pipewrite(f->pipe, addr, n);
if(f->type == FD_INODE){
80100ffd: 83 f8 02 cmp $0x2,%eax
80101000: 0f 85 d7 00 00 00 jne 801010dd <filewrite+0x10d>
// and 2 blocks of slop for non-aligned writes.
// this really belongs lower down, since writei()
// might be writing a device like the console.
int max = ((LOGSIZE-1-1-2) / 2) * 512;
int i = 0;
while(i < n){
80101006: 8b 45 e4 mov -0x1c(%ebp),%eax
80101009: 31 db xor %ebx,%ebx
8010100b: 85 c0 test %eax,%eax
8010100d: 7f 31 jg 80101040 <filewrite+0x70>
8010100f: e9 9c 00 00 00 jmp 801010b0 <filewrite+0xe0>
80101014: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
begin_op();
ilock(f->ip);
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
f->off += r;
iunlock(f->ip);
80101018: 8b 4f 10 mov 0x10(%edi),%ecx
f->off += r;
8010101b: 01 47 14 add %eax,0x14(%edi)
8010101e: 89 45 e0 mov %eax,-0x20(%ebp)
iunlock(f->ip);
80101021: 89 0c 24 mov %ecx,(%esp)
80101024: e8 67 07 00 00 call 80101790 <iunlock>
end_op();
80101029: e8 52 1b 00 00 call 80102b80 <end_op>
8010102e: 8b 45 e0 mov -0x20(%ebp),%eax
if(r < 0)
break;
if(r != n1)
80101031: 39 f0 cmp %esi,%eax
80101033: 0f 85 98 00 00 00 jne 801010d1 <filewrite+0x101>
panic("short filewrite");
i += r;
80101039: 01 c3 add %eax,%ebx
while(i < n){
8010103b: 39 5d e4 cmp %ebx,-0x1c(%ebp)
8010103e: 7e 70 jle 801010b0 <filewrite+0xe0>
int n1 = n - i;
80101040: 8b 75 e4 mov -0x1c(%ebp),%esi
80101043: b8 00 1a 00 00 mov $0x1a00,%eax
80101048: 29 de sub %ebx,%esi
8010104a: 81 fe 00 1a 00 00 cmp $0x1a00,%esi
80101050: 0f 4f f0 cmovg %eax,%esi
begin_op();
80101053: e8 b8 1a 00 00 call 80102b10 <begin_op>
ilock(f->ip);
80101058: 8b 47 10 mov 0x10(%edi),%eax
8010105b: 89 04 24 mov %eax,(%esp)
8010105e: e8 4d 06 00 00 call 801016b0 <ilock>
if ((r = writei(f->ip, addr + i, f->off, n1)) > 0)
80101063: 89 74 24 0c mov %esi,0xc(%esp)
80101067: 8b 47 14 mov 0x14(%edi),%eax
8010106a: 89 44 24 08 mov %eax,0x8(%esp)
8010106e: 8b 45 dc mov -0x24(%ebp),%eax
80101071: 01 d8 add %ebx,%eax
80101073: 89 44 24 04 mov %eax,0x4(%esp)
80101077: 8b 47 10 mov 0x10(%edi),%eax
8010107a: 89 04 24 mov %eax,(%esp)
8010107d: e8 de 09 00 00 call 80101a60 <writei>
80101082: 85 c0 test %eax,%eax
80101084: 7f 92 jg 80101018 <filewrite+0x48>
iunlock(f->ip);
80101086: 8b 4f 10 mov 0x10(%edi),%ecx
80101089: 89 45 e0 mov %eax,-0x20(%ebp)
8010108c: 89 0c 24 mov %ecx,(%esp)
8010108f: e8 fc 06 00 00 call 80101790 <iunlock>
end_op();
80101094: e8 e7 1a 00 00 call 80102b80 <end_op>
if(r < 0)
80101099: 8b 45 e0 mov -0x20(%ebp),%eax
8010109c: 85 c0 test %eax,%eax
8010109e: 74 91 je 80101031 <filewrite+0x61>
}
return i == n ? n : -1;
}
panic("filewrite");
}
801010a0: 83 c4 2c add $0x2c,%esp
return -1;
801010a3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801010a8: 5b pop %ebx
801010a9: 5e pop %esi
801010aa: 5f pop %edi
801010ab: 5d pop %ebp
801010ac: c3 ret
801010ad: 8d 76 00 lea 0x0(%esi),%esi
return i == n ? n : -1;
801010b0: 3b 5d e4 cmp -0x1c(%ebp),%ebx
801010b3: 89 d8 mov %ebx,%eax
801010b5: 75 e9 jne 801010a0 <filewrite+0xd0>
}
801010b7: 83 c4 2c add $0x2c,%esp
801010ba: 5b pop %ebx
801010bb: 5e pop %esi
801010bc: 5f pop %edi
801010bd: 5d pop %ebp
801010be: c3 ret
return pipewrite(f->pipe, addr, n);
801010bf: 8b 47 0c mov 0xc(%edi),%eax
801010c2: 89 45 08 mov %eax,0x8(%ebp)
}
801010c5: 83 c4 2c add $0x2c,%esp
801010c8: 5b pop %ebx
801010c9: 5e pop %esi
801010ca: 5f pop %edi
801010cb: 5d pop %ebp
return pipewrite(f->pipe, addr, n);
801010cc: e9 1f 22 00 00 jmp 801032f0 <pipewrite>
panic("short filewrite");
801010d1: c7 04 24 3e 6f 10 80 movl $0x80106f3e,(%esp)
801010d8: e8 83 f2 ff ff call 80100360 <panic>
panic("filewrite");
801010dd: c7 04 24 44 6f 10 80 movl $0x80106f44,(%esp)
801010e4: e8 77 f2 ff ff call 80100360 <panic>
801010e9: 66 90 xchg %ax,%ax
801010eb: 66 90 xchg %ax,%ax
801010ed: 66 90 xchg %ax,%ax
801010ef: 90 nop
801010f0 <balloc>:
// Blocks.
// Allocate a zeroed disk block.
static uint
balloc(uint dev)
{
801010f0: 55 push %ebp
801010f1: 89 e5 mov %esp,%ebp
801010f3: 57 push %edi
801010f4: 56 push %esi
801010f5: 53 push %ebx
801010f6: 83 ec 2c sub $0x2c,%esp
801010f9: 89 45 d8 mov %eax,-0x28(%ebp)
int b, bi, m;
struct buf *bp;
bp = 0;
for(b = 0; b < sb.size; b += BPB){
801010fc: a1 c0 09 11 80 mov 0x801109c0,%eax
80101101: 85 c0 test %eax,%eax
80101103: 0f 84 8c 00 00 00 je 80101195 <balloc+0xa5>
80101109: c7 45 dc 00 00 00 00 movl $0x0,-0x24(%ebp)
bp = bread(dev, BBLOCK(b, sb));
80101110: 8b 75 dc mov -0x24(%ebp),%esi
80101113: 89 f0 mov %esi,%eax
80101115: c1 f8 0c sar $0xc,%eax
80101118: 03 05 d8 09 11 80 add 0x801109d8,%eax
8010111e: 89 44 24 04 mov %eax,0x4(%esp)
80101122: 8b 45 d8 mov -0x28(%ebp),%eax
80101125: 89 04 24 mov %eax,(%esp)
80101128: e8 a3 ef ff ff call 801000d0 <bread>
8010112d: 89 45 e4 mov %eax,-0x1c(%ebp)
80101130: a1 c0 09 11 80 mov 0x801109c0,%eax
80101135: 89 45 e0 mov %eax,-0x20(%ebp)
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101138: 31 c0 xor %eax,%eax
8010113a: eb 33 jmp 8010116f <balloc+0x7f>
8010113c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
m = 1 << (bi % 8);
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101140: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101143: 89 c2 mov %eax,%edx
m = 1 << (bi % 8);
80101145: 89 c1 mov %eax,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101147: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
8010114a: 83 e1 07 and $0x7,%ecx
8010114d: bf 01 00 00 00 mov $0x1,%edi
80101152: d3 e7 shl %cl,%edi
if((bp->data[bi/8] & m) == 0){ // Is block free?
80101154: 0f b6 5c 13 5c movzbl 0x5c(%ebx,%edx,1),%ebx
m = 1 << (bi % 8);
80101159: 89 f9 mov %edi,%ecx
if((bp->data[bi/8] & m) == 0){ // Is block free?
8010115b: 0f b6 fb movzbl %bl,%edi
8010115e: 85 cf test %ecx,%edi
80101160: 74 46 je 801011a8 <balloc+0xb8>
for(bi = 0; bi < BPB && b + bi < sb.size; bi++){
80101162: 83 c0 01 add $0x1,%eax
80101165: 83 c6 01 add $0x1,%esi
80101168: 3d 00 10 00 00 cmp $0x1000,%eax
8010116d: 74 05 je 80101174 <balloc+0x84>
8010116f: 3b 75 e0 cmp -0x20(%ebp),%esi
80101172: 72 cc jb 80101140 <balloc+0x50>
brelse(bp);
bzero(dev, b + bi);
return b + bi;
}
}
brelse(bp);
80101174: 8b 45 e4 mov -0x1c(%ebp),%eax
80101177: 89 04 24 mov %eax,(%esp)
8010117a: e8 61 f0 ff ff call 801001e0 <brelse>
for(b = 0; b < sb.size; b += BPB){
8010117f: 81 45 dc 00 10 00 00 addl $0x1000,-0x24(%ebp)
80101186: 8b 45 dc mov -0x24(%ebp),%eax
80101189: 3b 05 c0 09 11 80 cmp 0x801109c0,%eax
8010118f: 0f 82 7b ff ff ff jb 80101110 <balloc+0x20>
}
panic("balloc: out of blocks");
80101195: c7 04 24 4e 6f 10 80 movl $0x80106f4e,(%esp)
8010119c: e8 bf f1 ff ff call 80100360 <panic>
801011a1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
bp->data[bi/8] |= m; // Mark block in use.
801011a8: 09 d9 or %ebx,%ecx
801011aa: 8b 5d e4 mov -0x1c(%ebp),%ebx
801011ad: 88 4c 13 5c mov %cl,0x5c(%ebx,%edx,1)
log_write(bp);
801011b1: 89 1c 24 mov %ebx,(%esp)
801011b4: e8 f7 1a 00 00 call 80102cb0 <log_write>
brelse(bp);
801011b9: 89 1c 24 mov %ebx,(%esp)
801011bc: e8 1f f0 ff ff call 801001e0 <brelse>
bp = bread(dev, bno);
801011c1: 8b 45 d8 mov -0x28(%ebp),%eax
801011c4: 89 74 24 04 mov %esi,0x4(%esp)
801011c8: 89 04 24 mov %eax,(%esp)
801011cb: e8 00 ef ff ff call 801000d0 <bread>
memset(bp->data, 0, BSIZE);
801011d0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801011d7: 00
801011d8: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801011df: 00
bp = bread(dev, bno);
801011e0: 89 c3 mov %eax,%ebx
memset(bp->data, 0, BSIZE);
801011e2: 8d 40 5c lea 0x5c(%eax),%eax
801011e5: 89 04 24 mov %eax,(%esp)
801011e8: e8 93 30 00 00 call 80104280 <memset>
log_write(bp);
801011ed: 89 1c 24 mov %ebx,(%esp)
801011f0: e8 bb 1a 00 00 call 80102cb0 <log_write>
brelse(bp);
801011f5: 89 1c 24 mov %ebx,(%esp)
801011f8: e8 e3 ef ff ff call 801001e0 <brelse>
}
801011fd: 83 c4 2c add $0x2c,%esp
80101200: 89 f0 mov %esi,%eax
80101202: 5b pop %ebx
80101203: 5e pop %esi
80101204: 5f pop %edi
80101205: 5d pop %ebp
80101206: c3 ret
80101207: 89 f6 mov %esi,%esi
80101209: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101210 <iget>:
// Find the inode with number inum on device dev
// and return the in-memory copy. Does not lock
// the inode and does not read it from disk.
static struct inode*
iget(uint dev, uint inum)
{
80101210: 55 push %ebp
80101211: 89 e5 mov %esp,%ebp
80101213: 57 push %edi
80101214: 89 c7 mov %eax,%edi
80101216: 56 push %esi
struct inode *ip, *empty;
acquire(&icache.lock);
// Is the inode already cached?
empty = 0;
80101217: 31 f6 xor %esi,%esi
{
80101219: 53 push %ebx
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010121a: bb 14 0a 11 80 mov $0x80110a14,%ebx
{
8010121f: 83 ec 1c sub $0x1c,%esp
acquire(&icache.lock);
80101222: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
{
80101229: 89 55 e4 mov %edx,-0x1c(%ebp)
acquire(&icache.lock);
8010122c: e8 0f 2f 00 00 call 80104140 <acquire>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
80101231: 8b 55 e4 mov -0x1c(%ebp),%edx
80101234: eb 14 jmp 8010124a <iget+0x3a>
80101236: 66 90 xchg %ax,%ax
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
ip->ref++;
release(&icache.lock);
return ip;
}
if(empty == 0 && ip->ref == 0) // Remember empty slot.
80101238: 85 f6 test %esi,%esi
8010123a: 74 3c je 80101278 <iget+0x68>
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010123c: 81 c3 90 00 00 00 add $0x90,%ebx
80101242: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101248: 74 46 je 80101290 <iget+0x80>
if(ip->ref > 0 && ip->dev == dev && ip->inum == inum){
8010124a: 8b 4b 08 mov 0x8(%ebx),%ecx
8010124d: 85 c9 test %ecx,%ecx
8010124f: 7e e7 jle 80101238 <iget+0x28>
80101251: 39 3b cmp %edi,(%ebx)
80101253: 75 e3 jne 80101238 <iget+0x28>
80101255: 39 53 04 cmp %edx,0x4(%ebx)
80101258: 75 de jne 80101238 <iget+0x28>
ip->ref++;
8010125a: 83 c1 01 add $0x1,%ecx
return ip;
8010125d: 89 de mov %ebx,%esi
release(&icache.lock);
8010125f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
ip->ref++;
80101266: 89 4b 08 mov %ecx,0x8(%ebx)
release(&icache.lock);
80101269: e8 c2 2f 00 00 call 80104230 <release>
ip->ref = 1;
ip->valid = 0;
release(&icache.lock);
return ip;
}
8010126e: 83 c4 1c add $0x1c,%esp
80101271: 89 f0 mov %esi,%eax
80101273: 5b pop %ebx
80101274: 5e pop %esi
80101275: 5f pop %edi
80101276: 5d pop %ebp
80101277: c3 ret
80101278: 85 c9 test %ecx,%ecx
8010127a: 0f 44 f3 cmove %ebx,%esi
for(ip = &icache.inode[0]; ip < &icache.inode[NINODE]; ip++){
8010127d: 81 c3 90 00 00 00 add $0x90,%ebx
80101283: 81 fb 34 26 11 80 cmp $0x80112634,%ebx
80101289: 75 bf jne 8010124a <iget+0x3a>
8010128b: 90 nop
8010128c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(empty == 0)
80101290: 85 f6 test %esi,%esi
80101292: 74 29 je 801012bd <iget+0xad>
ip->dev = dev;
80101294: 89 3e mov %edi,(%esi)
ip->inum = inum;
80101296: 89 56 04 mov %edx,0x4(%esi)
ip->ref = 1;
80101299: c7 46 08 01 00 00 00 movl $0x1,0x8(%esi)
ip->valid = 0;
801012a0: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
release(&icache.lock);
801012a7: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
801012ae: e8 7d 2f 00 00 call 80104230 <release>
}
801012b3: 83 c4 1c add $0x1c,%esp
801012b6: 89 f0 mov %esi,%eax
801012b8: 5b pop %ebx
801012b9: 5e pop %esi
801012ba: 5f pop %edi
801012bb: 5d pop %ebp
801012bc: c3 ret
panic("iget: no inodes");
801012bd: c7 04 24 64 6f 10 80 movl $0x80106f64,(%esp)
801012c4: e8 97 f0 ff ff call 80100360 <panic>
801012c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801012d0 <bmap>:
// Return the disk block address of the nth block in inode ip.
// If there is no such block, bmap allocates one.
static uint
bmap(struct inode *ip, uint bn)
{
801012d0: 55 push %ebp
801012d1: 89 e5 mov %esp,%ebp
801012d3: 57 push %edi
801012d4: 56 push %esi
801012d5: 53 push %ebx
801012d6: 89 c3 mov %eax,%ebx
801012d8: 83 ec 1c sub $0x1c,%esp
uint addr, *a;
struct buf *bp;
if(bn < NDIRECT){
801012db: 83 fa 0b cmp $0xb,%edx
801012de: 77 18 ja 801012f8 <bmap+0x28>
801012e0: 8d 34 90 lea (%eax,%edx,4),%esi
if((addr = ip->addrs[bn]) == 0)
801012e3: 8b 46 5c mov 0x5c(%esi),%eax
801012e6: 85 c0 test %eax,%eax
801012e8: 74 66 je 80101350 <bmap+0x80>
brelse(bp);
return addr;
}
panic("bmap: out of range");
}
801012ea: 83 c4 1c add $0x1c,%esp
801012ed: 5b pop %ebx
801012ee: 5e pop %esi
801012ef: 5f pop %edi
801012f0: 5d pop %ebp
801012f1: c3 ret
801012f2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
bn -= NDIRECT;
801012f8: 8d 72 f4 lea -0xc(%edx),%esi
if(bn < NINDIRECT){
801012fb: 83 fe 7f cmp $0x7f,%esi
801012fe: 77 77 ja 80101377 <bmap+0xa7>
if((addr = ip->addrs[NDIRECT]) == 0)
80101300: 8b 80 8c 00 00 00 mov 0x8c(%eax),%eax
80101306: 85 c0 test %eax,%eax
80101308: 74 5e je 80101368 <bmap+0x98>
bp = bread(ip->dev, addr);
8010130a: 89 44 24 04 mov %eax,0x4(%esp)
8010130e: 8b 03 mov (%ebx),%eax
80101310: 89 04 24 mov %eax,(%esp)
80101313: e8 b8 ed ff ff call 801000d0 <bread>
if((addr = a[bn]) == 0){
80101318: 8d 54 b0 5c lea 0x5c(%eax,%esi,4),%edx
bp = bread(ip->dev, addr);
8010131c: 89 c7 mov %eax,%edi
if((addr = a[bn]) == 0){
8010131e: 8b 32 mov (%edx),%esi
80101320: 85 f6 test %esi,%esi
80101322: 75 19 jne 8010133d <bmap+0x6d>
a[bn] = addr = balloc(ip->dev);
80101324: 8b 03 mov (%ebx),%eax
80101326: 89 55 e4 mov %edx,-0x1c(%ebp)
80101329: e8 c2 fd ff ff call 801010f0 <balloc>
8010132e: 8b 55 e4 mov -0x1c(%ebp),%edx
80101331: 89 02 mov %eax,(%edx)
80101333: 89 c6 mov %eax,%esi
log_write(bp);
80101335: 89 3c 24 mov %edi,(%esp)
80101338: e8 73 19 00 00 call 80102cb0 <log_write>
brelse(bp);
8010133d: 89 3c 24 mov %edi,(%esp)
80101340: e8 9b ee ff ff call 801001e0 <brelse>
}
80101345: 83 c4 1c add $0x1c,%esp
brelse(bp);
80101348: 89 f0 mov %esi,%eax
}
8010134a: 5b pop %ebx
8010134b: 5e pop %esi
8010134c: 5f pop %edi
8010134d: 5d pop %ebp
8010134e: c3 ret
8010134f: 90 nop
ip->addrs[bn] = addr = balloc(ip->dev);
80101350: 8b 03 mov (%ebx),%eax
80101352: e8 99 fd ff ff call 801010f0 <balloc>
80101357: 89 46 5c mov %eax,0x5c(%esi)
}
8010135a: 83 c4 1c add $0x1c,%esp
8010135d: 5b pop %ebx
8010135e: 5e pop %esi
8010135f: 5f pop %edi
80101360: 5d pop %ebp
80101361: c3 ret
80101362: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
ip->addrs[NDIRECT] = addr = balloc(ip->dev);
80101368: 8b 03 mov (%ebx),%eax
8010136a: e8 81 fd ff ff call 801010f0 <balloc>
8010136f: 89 83 8c 00 00 00 mov %eax,0x8c(%ebx)
80101375: eb 93 jmp 8010130a <bmap+0x3a>
panic("bmap: out of range");
80101377: c7 04 24 74 6f 10 80 movl $0x80106f74,(%esp)
8010137e: e8 dd ef ff ff call 80100360 <panic>
80101383: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101389: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101390 <readsb>:
{
80101390: 55 push %ebp
80101391: 89 e5 mov %esp,%ebp
80101393: 56 push %esi
80101394: 53 push %ebx
80101395: 83 ec 10 sub $0x10,%esp
bp = bread(dev, 1);
80101398: 8b 45 08 mov 0x8(%ebp),%eax
8010139b: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
801013a2: 00
{
801013a3: 8b 75 0c mov 0xc(%ebp),%esi
bp = bread(dev, 1);
801013a6: 89 04 24 mov %eax,(%esp)
801013a9: e8 22 ed ff ff call 801000d0 <bread>
memmove(sb, bp->data, sizeof(*sb));
801013ae: 89 34 24 mov %esi,(%esp)
801013b1: c7 44 24 08 1c 00 00 movl $0x1c,0x8(%esp)
801013b8: 00
bp = bread(dev, 1);
801013b9: 89 c3 mov %eax,%ebx
memmove(sb, bp->data, sizeof(*sb));
801013bb: 8d 40 5c lea 0x5c(%eax),%eax
801013be: 89 44 24 04 mov %eax,0x4(%esp)
801013c2: e8 59 2f 00 00 call 80104320 <memmove>
brelse(bp);
801013c7: 89 5d 08 mov %ebx,0x8(%ebp)
}
801013ca: 83 c4 10 add $0x10,%esp
801013cd: 5b pop %ebx
801013ce: 5e pop %esi
801013cf: 5d pop %ebp
brelse(bp);
801013d0: e9 0b ee ff ff jmp 801001e0 <brelse>
801013d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801013d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801013e0 <bfree>:
{
801013e0: 55 push %ebp
801013e1: 89 e5 mov %esp,%ebp
801013e3: 57 push %edi
801013e4: 89 d7 mov %edx,%edi
801013e6: 56 push %esi
801013e7: 53 push %ebx
801013e8: 89 c3 mov %eax,%ebx
801013ea: 83 ec 1c sub $0x1c,%esp
readsb(dev, &sb);
801013ed: 89 04 24 mov %eax,(%esp)
801013f0: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801013f7: 80
801013f8: e8 93 ff ff ff call 80101390 <readsb>
bp = bread(dev, BBLOCK(b, sb));
801013fd: 89 fa mov %edi,%edx
801013ff: c1 ea 0c shr $0xc,%edx
80101402: 03 15 d8 09 11 80 add 0x801109d8,%edx
80101408: 89 1c 24 mov %ebx,(%esp)
m = 1 << (bi % 8);
8010140b: bb 01 00 00 00 mov $0x1,%ebx
bp = bread(dev, BBLOCK(b, sb));
80101410: 89 54 24 04 mov %edx,0x4(%esp)
80101414: e8 b7 ec ff ff call 801000d0 <bread>
m = 1 << (bi % 8);
80101419: 89 f9 mov %edi,%ecx
bi = b % BPB;
8010141b: 81 e7 ff 0f 00 00 and $0xfff,%edi
80101421: 89 fa mov %edi,%edx
m = 1 << (bi % 8);
80101423: 83 e1 07 and $0x7,%ecx
if((bp->data[bi/8] & m) == 0)
80101426: c1 fa 03 sar $0x3,%edx
m = 1 << (bi % 8);
80101429: d3 e3 shl %cl,%ebx
bp = bread(dev, BBLOCK(b, sb));
8010142b: 89 c6 mov %eax,%esi
if((bp->data[bi/8] & m) == 0)
8010142d: 0f b6 44 10 5c movzbl 0x5c(%eax,%edx,1),%eax
80101432: 0f b6 c8 movzbl %al,%ecx
80101435: 85 d9 test %ebx,%ecx
80101437: 74 20 je 80101459 <bfree+0x79>
bp->data[bi/8] &= ~m;
80101439: f7 d3 not %ebx
8010143b: 21 c3 and %eax,%ebx
8010143d: 88 5c 16 5c mov %bl,0x5c(%esi,%edx,1)
log_write(bp);
80101441: 89 34 24 mov %esi,(%esp)
80101444: e8 67 18 00 00 call 80102cb0 <log_write>
brelse(bp);
80101449: 89 34 24 mov %esi,(%esp)
8010144c: e8 8f ed ff ff call 801001e0 <brelse>
}
80101451: 83 c4 1c add $0x1c,%esp
80101454: 5b pop %ebx
80101455: 5e pop %esi
80101456: 5f pop %edi
80101457: 5d pop %ebp
80101458: c3 ret
panic("freeing free block");
80101459: c7 04 24 87 6f 10 80 movl $0x80106f87,(%esp)
80101460: e8 fb ee ff ff call 80100360 <panic>
80101465: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101469: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101470 <iinit>:
{
80101470: 55 push %ebp
80101471: 89 e5 mov %esp,%ebp
80101473: 53 push %ebx
80101474: bb 20 0a 11 80 mov $0x80110a20,%ebx
80101479: 83 ec 24 sub $0x24,%esp
initlock(&icache.lock, "icache");
8010147c: c7 44 24 04 9a 6f 10 movl $0x80106f9a,0x4(%esp)
80101483: 80
80101484: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
8010148b: e8 c0 2b 00 00 call 80104050 <initlock>
initsleeplock(&icache.inode[i].lock, "inode");
80101490: 89 1c 24 mov %ebx,(%esp)
80101493: 81 c3 90 00 00 00 add $0x90,%ebx
80101499: c7 44 24 04 a1 6f 10 movl $0x80106fa1,0x4(%esp)
801014a0: 80
801014a1: e8 9a 2a 00 00 call 80103f40 <initsleeplock>
for(i = 0; i < NINODE; i++) {
801014a6: 81 fb 40 26 11 80 cmp $0x80112640,%ebx
801014ac: 75 e2 jne 80101490 <iinit+0x20>
readsb(dev, &sb);
801014ae: 8b 45 08 mov 0x8(%ebp),%eax
801014b1: c7 44 24 04 c0 09 11 movl $0x801109c0,0x4(%esp)
801014b8: 80
801014b9: 89 04 24 mov %eax,(%esp)
801014bc: e8 cf fe ff ff call 80101390 <readsb>
cprintf("sb: size %d nblocks %d ninodes %d nlog %d logstart %d\
801014c1: a1 d8 09 11 80 mov 0x801109d8,%eax
801014c6: c7 04 24 04 70 10 80 movl $0x80107004,(%esp)
801014cd: 89 44 24 1c mov %eax,0x1c(%esp)
801014d1: a1 d4 09 11 80 mov 0x801109d4,%eax
801014d6: 89 44 24 18 mov %eax,0x18(%esp)
801014da: a1 d0 09 11 80 mov 0x801109d0,%eax
801014df: 89 44 24 14 mov %eax,0x14(%esp)
801014e3: a1 cc 09 11 80 mov 0x801109cc,%eax
801014e8: 89 44 24 10 mov %eax,0x10(%esp)
801014ec: a1 c8 09 11 80 mov 0x801109c8,%eax
801014f1: 89 44 24 0c mov %eax,0xc(%esp)
801014f5: a1 c4 09 11 80 mov 0x801109c4,%eax
801014fa: 89 44 24 08 mov %eax,0x8(%esp)
801014fe: a1 c0 09 11 80 mov 0x801109c0,%eax
80101503: 89 44 24 04 mov %eax,0x4(%esp)
80101507: e8 44 f1 ff ff call 80100650 <cprintf>
}
8010150c: 83 c4 24 add $0x24,%esp
8010150f: 5b pop %ebx
80101510: 5d pop %ebp
80101511: c3 ret
80101512: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101519: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101520 <ialloc>:
{
80101520: 55 push %ebp
80101521: 89 e5 mov %esp,%ebp
80101523: 57 push %edi
80101524: 56 push %esi
80101525: 53 push %ebx
80101526: 83 ec 2c sub $0x2c,%esp
80101529: 8b 45 0c mov 0xc(%ebp),%eax
for(inum = 1; inum < sb.ninodes; inum++){
8010152c: 83 3d c8 09 11 80 01 cmpl $0x1,0x801109c8
{
80101533: 8b 7d 08 mov 0x8(%ebp),%edi
80101536: 89 45 e4 mov %eax,-0x1c(%ebp)
for(inum = 1; inum < sb.ninodes; inum++){
80101539: 0f 86 a2 00 00 00 jbe 801015e1 <ialloc+0xc1>
8010153f: be 01 00 00 00 mov $0x1,%esi
80101544: bb 01 00 00 00 mov $0x1,%ebx
80101549: eb 1a jmp 80101565 <ialloc+0x45>
8010154b: 90 nop
8010154c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
brelse(bp);
80101550: 89 14 24 mov %edx,(%esp)
for(inum = 1; inum < sb.ninodes; inum++){
80101553: 83 c3 01 add $0x1,%ebx
brelse(bp);
80101556: e8 85 ec ff ff call 801001e0 <brelse>
for(inum = 1; inum < sb.ninodes; inum++){
8010155b: 89 de mov %ebx,%esi
8010155d: 3b 1d c8 09 11 80 cmp 0x801109c8,%ebx
80101563: 73 7c jae 801015e1 <ialloc+0xc1>
bp = bread(dev, IBLOCK(inum, sb));
80101565: 89 f0 mov %esi,%eax
80101567: c1 e8 03 shr $0x3,%eax
8010156a: 03 05 d4 09 11 80 add 0x801109d4,%eax
80101570: 89 3c 24 mov %edi,(%esp)
80101573: 89 44 24 04 mov %eax,0x4(%esp)
80101577: e8 54 eb ff ff call 801000d0 <bread>
8010157c: 89 c2 mov %eax,%edx
dip = (struct dinode*)bp->data + inum%IPB;
8010157e: 89 f0 mov %esi,%eax
80101580: 83 e0 07 and $0x7,%eax
80101583: c1 e0 06 shl $0x6,%eax
80101586: 8d 4c 02 5c lea 0x5c(%edx,%eax,1),%ecx
if(dip->type == 0){ // a free inode
8010158a: 66 83 39 00 cmpw $0x0,(%ecx)
8010158e: 75 c0 jne 80101550 <ialloc+0x30>
memset(dip, 0, sizeof(*dip));
80101590: 89 0c 24 mov %ecx,(%esp)
80101593: c7 44 24 08 40 00 00 movl $0x40,0x8(%esp)
8010159a: 00
8010159b: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801015a2: 00
801015a3: 89 55 dc mov %edx,-0x24(%ebp)
801015a6: 89 4d e0 mov %ecx,-0x20(%ebp)
801015a9: e8 d2 2c 00 00 call 80104280 <memset>
dip->type = type;
801015ae: 0f b7 45 e4 movzwl -0x1c(%ebp),%eax
log_write(bp); // mark it allocated on the disk
801015b2: 8b 55 dc mov -0x24(%ebp),%edx
dip->type = type;
801015b5: 8b 4d e0 mov -0x20(%ebp),%ecx
log_write(bp); // mark it allocated on the disk
801015b8: 89 55 e4 mov %edx,-0x1c(%ebp)
dip->type = type;
801015bb: 66 89 01 mov %ax,(%ecx)
log_write(bp); // mark it allocated on the disk
801015be: 89 14 24 mov %edx,(%esp)
801015c1: e8 ea 16 00 00 call 80102cb0 <log_write>
brelse(bp);
801015c6: 8b 55 e4 mov -0x1c(%ebp),%edx
801015c9: 89 14 24 mov %edx,(%esp)
801015cc: e8 0f ec ff ff call 801001e0 <brelse>
}
801015d1: 83 c4 2c add $0x2c,%esp
return iget(dev, inum);
801015d4: 89 f2 mov %esi,%edx
}
801015d6: 5b pop %ebx
return iget(dev, inum);
801015d7: 89 f8 mov %edi,%eax
}
801015d9: 5e pop %esi
801015da: 5f pop %edi
801015db: 5d pop %ebp
return iget(dev, inum);
801015dc: e9 2f fc ff ff jmp 80101210 <iget>
panic("ialloc: no inodes");
801015e1: c7 04 24 a7 6f 10 80 movl $0x80106fa7,(%esp)
801015e8: e8 73 ed ff ff call 80100360 <panic>
801015ed: 8d 76 00 lea 0x0(%esi),%esi
801015f0 <iupdate>:
{
801015f0: 55 push %ebp
801015f1: 89 e5 mov %esp,%ebp
801015f3: 56 push %esi
801015f4: 53 push %ebx
801015f5: 83 ec 10 sub $0x10,%esp
801015f8: 8b 5d 08 mov 0x8(%ebp),%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801015fb: 8b 43 04 mov 0x4(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
801015fe: 83 c3 5c add $0x5c,%ebx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
80101601: c1 e8 03 shr $0x3,%eax
80101604: 03 05 d4 09 11 80 add 0x801109d4,%eax
8010160a: 89 44 24 04 mov %eax,0x4(%esp)
8010160e: 8b 43 a4 mov -0x5c(%ebx),%eax
80101611: 89 04 24 mov %eax,(%esp)
80101614: e8 b7 ea ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
80101619: 8b 53 a8 mov -0x58(%ebx),%edx
8010161c: 83 e2 07 and $0x7,%edx
8010161f: c1 e2 06 shl $0x6,%edx
80101622: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
80101626: 89 c6 mov %eax,%esi
dip->type = ip->type;
80101628: 0f b7 43 f4 movzwl -0xc(%ebx),%eax
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
8010162c: 83 c2 0c add $0xc,%edx
dip->type = ip->type;
8010162f: 66 89 42 f4 mov %ax,-0xc(%edx)
dip->major = ip->major;
80101633: 0f b7 43 f6 movzwl -0xa(%ebx),%eax
80101637: 66 89 42 f6 mov %ax,-0xa(%edx)
dip->minor = ip->minor;
8010163b: 0f b7 43 f8 movzwl -0x8(%ebx),%eax
8010163f: 66 89 42 f8 mov %ax,-0x8(%edx)
dip->nlink = ip->nlink;
80101643: 0f b7 43 fa movzwl -0x6(%ebx),%eax
80101647: 66 89 42 fa mov %ax,-0x6(%edx)
dip->size = ip->size;
8010164b: 8b 43 fc mov -0x4(%ebx),%eax
8010164e: 89 42 fc mov %eax,-0x4(%edx)
memmove(dip->addrs, ip->addrs, sizeof(ip->addrs));
80101651: 89 5c 24 04 mov %ebx,0x4(%esp)
80101655: 89 14 24 mov %edx,(%esp)
80101658: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
8010165f: 00
80101660: e8 bb 2c 00 00 call 80104320 <memmove>
log_write(bp);
80101665: 89 34 24 mov %esi,(%esp)
80101668: e8 43 16 00 00 call 80102cb0 <log_write>
brelse(bp);
8010166d: 89 75 08 mov %esi,0x8(%ebp)
}
80101670: 83 c4 10 add $0x10,%esp
80101673: 5b pop %ebx
80101674: 5e pop %esi
80101675: 5d pop %ebp
brelse(bp);
80101676: e9 65 eb ff ff jmp 801001e0 <brelse>
8010167b: 90 nop
8010167c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101680 <idup>:
{
80101680: 55 push %ebp
80101681: 89 e5 mov %esp,%ebp
80101683: 53 push %ebx
80101684: 83 ec 14 sub $0x14,%esp
80101687: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&icache.lock);
8010168a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101691: e8 aa 2a 00 00 call 80104140 <acquire>
ip->ref++;
80101696: 83 43 08 01 addl $0x1,0x8(%ebx)
release(&icache.lock);
8010169a: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
801016a1: e8 8a 2b 00 00 call 80104230 <release>
}
801016a6: 83 c4 14 add $0x14,%esp
801016a9: 89 d8 mov %ebx,%eax
801016ab: 5b pop %ebx
801016ac: 5d pop %ebp
801016ad: c3 ret
801016ae: 66 90 xchg %ax,%ax
801016b0 <ilock>:
{
801016b0: 55 push %ebp
801016b1: 89 e5 mov %esp,%ebp
801016b3: 56 push %esi
801016b4: 53 push %ebx
801016b5: 83 ec 10 sub $0x10,%esp
801016b8: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || ip->ref < 1)
801016bb: 85 db test %ebx,%ebx
801016bd: 0f 84 b3 00 00 00 je 80101776 <ilock+0xc6>
801016c3: 8b 53 08 mov 0x8(%ebx),%edx
801016c6: 85 d2 test %edx,%edx
801016c8: 0f 8e a8 00 00 00 jle 80101776 <ilock+0xc6>
acquiresleep(&ip->lock);
801016ce: 8d 43 0c lea 0xc(%ebx),%eax
801016d1: 89 04 24 mov %eax,(%esp)
801016d4: e8 a7 28 00 00 call 80103f80 <acquiresleep>
if(ip->valid == 0){
801016d9: 8b 43 4c mov 0x4c(%ebx),%eax
801016dc: 85 c0 test %eax,%eax
801016de: 74 08 je 801016e8 <ilock+0x38>
}
801016e0: 83 c4 10 add $0x10,%esp
801016e3: 5b pop %ebx
801016e4: 5e pop %esi
801016e5: 5d pop %ebp
801016e6: c3 ret
801016e7: 90 nop
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
801016e8: 8b 43 04 mov 0x4(%ebx),%eax
801016eb: c1 e8 03 shr $0x3,%eax
801016ee: 03 05 d4 09 11 80 add 0x801109d4,%eax
801016f4: 89 44 24 04 mov %eax,0x4(%esp)
801016f8: 8b 03 mov (%ebx),%eax
801016fa: 89 04 24 mov %eax,(%esp)
801016fd: e8 ce e9 ff ff call 801000d0 <bread>
dip = (struct dinode*)bp->data + ip->inum%IPB;
80101702: 8b 53 04 mov 0x4(%ebx),%edx
80101705: 83 e2 07 and $0x7,%edx
80101708: c1 e2 06 shl $0x6,%edx
8010170b: 8d 54 10 5c lea 0x5c(%eax,%edx,1),%edx
bp = bread(ip->dev, IBLOCK(ip->inum, sb));
8010170f: 89 c6 mov %eax,%esi
ip->type = dip->type;
80101711: 0f b7 02 movzwl (%edx),%eax
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101714: 83 c2 0c add $0xc,%edx
ip->type = dip->type;
80101717: 66 89 43 50 mov %ax,0x50(%ebx)
ip->major = dip->major;
8010171b: 0f b7 42 f6 movzwl -0xa(%edx),%eax
8010171f: 66 89 43 52 mov %ax,0x52(%ebx)
ip->minor = dip->minor;
80101723: 0f b7 42 f8 movzwl -0x8(%edx),%eax
80101727: 66 89 43 54 mov %ax,0x54(%ebx)
ip->nlink = dip->nlink;
8010172b: 0f b7 42 fa movzwl -0x6(%edx),%eax
8010172f: 66 89 43 56 mov %ax,0x56(%ebx)
ip->size = dip->size;
80101733: 8b 42 fc mov -0x4(%edx),%eax
80101736: 89 43 58 mov %eax,0x58(%ebx)
memmove(ip->addrs, dip->addrs, sizeof(ip->addrs));
80101739: 8d 43 5c lea 0x5c(%ebx),%eax
8010173c: 89 54 24 04 mov %edx,0x4(%esp)
80101740: c7 44 24 08 34 00 00 movl $0x34,0x8(%esp)
80101747: 00
80101748: 89 04 24 mov %eax,(%esp)
8010174b: e8 d0 2b 00 00 call 80104320 <memmove>
brelse(bp);
80101750: 89 34 24 mov %esi,(%esp)
80101753: e8 88 ea ff ff call 801001e0 <brelse>
if(ip->type == 0)
80101758: 66 83 7b 50 00 cmpw $0x0,0x50(%ebx)
ip->valid = 1;
8010175d: c7 43 4c 01 00 00 00 movl $0x1,0x4c(%ebx)
if(ip->type == 0)
80101764: 0f 85 76 ff ff ff jne 801016e0 <ilock+0x30>
panic("ilock: no type");
8010176a: c7 04 24 bf 6f 10 80 movl $0x80106fbf,(%esp)
80101771: e8 ea eb ff ff call 80100360 <panic>
panic("ilock");
80101776: c7 04 24 b9 6f 10 80 movl $0x80106fb9,(%esp)
8010177d: e8 de eb ff ff call 80100360 <panic>
80101782: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101789: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101790 <iunlock>:
{
80101790: 55 push %ebp
80101791: 89 e5 mov %esp,%ebp
80101793: 56 push %esi
80101794: 53 push %ebx
80101795: 83 ec 10 sub $0x10,%esp
80101798: 8b 5d 08 mov 0x8(%ebp),%ebx
if(ip == 0 || !holdingsleep(&ip->lock) || ip->ref < 1)
8010179b: 85 db test %ebx,%ebx
8010179d: 74 24 je 801017c3 <iunlock+0x33>
8010179f: 8d 73 0c lea 0xc(%ebx),%esi
801017a2: 89 34 24 mov %esi,(%esp)
801017a5: e8 76 28 00 00 call 80104020 <holdingsleep>
801017aa: 85 c0 test %eax,%eax
801017ac: 74 15 je 801017c3 <iunlock+0x33>
801017ae: 8b 43 08 mov 0x8(%ebx),%eax
801017b1: 85 c0 test %eax,%eax
801017b3: 7e 0e jle 801017c3 <iunlock+0x33>
releasesleep(&ip->lock);
801017b5: 89 75 08 mov %esi,0x8(%ebp)
}
801017b8: 83 c4 10 add $0x10,%esp
801017bb: 5b pop %ebx
801017bc: 5e pop %esi
801017bd: 5d pop %ebp
releasesleep(&ip->lock);
801017be: e9 1d 28 00 00 jmp 80103fe0 <releasesleep>
panic("iunlock");
801017c3: c7 04 24 ce 6f 10 80 movl $0x80106fce,(%esp)
801017ca: e8 91 eb ff ff call 80100360 <panic>
801017cf: 90 nop
801017d0 <iput>:
{
801017d0: 55 push %ebp
801017d1: 89 e5 mov %esp,%ebp
801017d3: 57 push %edi
801017d4: 56 push %esi
801017d5: 53 push %ebx
801017d6: 83 ec 1c sub $0x1c,%esp
801017d9: 8b 75 08 mov 0x8(%ebp),%esi
acquiresleep(&ip->lock);
801017dc: 8d 7e 0c lea 0xc(%esi),%edi
801017df: 89 3c 24 mov %edi,(%esp)
801017e2: e8 99 27 00 00 call 80103f80 <acquiresleep>
if(ip->valid && ip->nlink == 0){
801017e7: 8b 56 4c mov 0x4c(%esi),%edx
801017ea: 85 d2 test %edx,%edx
801017ec: 74 07 je 801017f5 <iput+0x25>
801017ee: 66 83 7e 56 00 cmpw $0x0,0x56(%esi)
801017f3: 74 2b je 80101820 <iput+0x50>
releasesleep(&ip->lock);
801017f5: 89 3c 24 mov %edi,(%esp)
801017f8: e8 e3 27 00 00 call 80103fe0 <releasesleep>
acquire(&icache.lock);
801017fd: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101804: e8 37 29 00 00 call 80104140 <acquire>
ip->ref--;
80101809: 83 6e 08 01 subl $0x1,0x8(%esi)
release(&icache.lock);
8010180d: c7 45 08 e0 09 11 80 movl $0x801109e0,0x8(%ebp)
}
80101814: 83 c4 1c add $0x1c,%esp
80101817: 5b pop %ebx
80101818: 5e pop %esi
80101819: 5f pop %edi
8010181a: 5d pop %ebp
release(&icache.lock);
8010181b: e9 10 2a 00 00 jmp 80104230 <release>
acquire(&icache.lock);
80101820: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101827: e8 14 29 00 00 call 80104140 <acquire>
int r = ip->ref;
8010182c: 8b 5e 08 mov 0x8(%esi),%ebx
release(&icache.lock);
8010182f: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101836: e8 f5 29 00 00 call 80104230 <release>
if(r == 1){
8010183b: 83 fb 01 cmp $0x1,%ebx
8010183e: 75 b5 jne 801017f5 <iput+0x25>
80101840: 8d 4e 30 lea 0x30(%esi),%ecx
80101843: 89 f3 mov %esi,%ebx
80101845: 89 7d e4 mov %edi,-0x1c(%ebp)
80101848: 89 cf mov %ecx,%edi
8010184a: eb 0b jmp 80101857 <iput+0x87>
8010184c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101850: 83 c3 04 add $0x4,%ebx
{
int i, j;
struct buf *bp;
uint *a;
for(i = 0; i < NDIRECT; i++){
80101853: 39 fb cmp %edi,%ebx
80101855: 74 19 je 80101870 <iput+0xa0>
if(ip->addrs[i]){
80101857: 8b 53 5c mov 0x5c(%ebx),%edx
8010185a: 85 d2 test %edx,%edx
8010185c: 74 f2 je 80101850 <iput+0x80>
bfree(ip->dev, ip->addrs[i]);
8010185e: 8b 06 mov (%esi),%eax
80101860: e8 7b fb ff ff call 801013e0 <bfree>
ip->addrs[i] = 0;
80101865: c7 43 5c 00 00 00 00 movl $0x0,0x5c(%ebx)
8010186c: eb e2 jmp 80101850 <iput+0x80>
8010186e: 66 90 xchg %ax,%ax
}
}
if(ip->addrs[NDIRECT]){
80101870: 8b 86 8c 00 00 00 mov 0x8c(%esi),%eax
80101876: 8b 7d e4 mov -0x1c(%ebp),%edi
80101879: 85 c0 test %eax,%eax
8010187b: 75 2b jne 801018a8 <iput+0xd8>
brelse(bp);
bfree(ip->dev, ip->addrs[NDIRECT]);
ip->addrs[NDIRECT] = 0;
}
ip->size = 0;
8010187d: c7 46 58 00 00 00 00 movl $0x0,0x58(%esi)
iupdate(ip);
80101884: 89 34 24 mov %esi,(%esp)
80101887: e8 64 fd ff ff call 801015f0 <iupdate>
ip->type = 0;
8010188c: 31 c0 xor %eax,%eax
8010188e: 66 89 46 50 mov %ax,0x50(%esi)
iupdate(ip);
80101892: 89 34 24 mov %esi,(%esp)
80101895: e8 56 fd ff ff call 801015f0 <iupdate>
ip->valid = 0;
8010189a: c7 46 4c 00 00 00 00 movl $0x0,0x4c(%esi)
801018a1: e9 4f ff ff ff jmp 801017f5 <iput+0x25>
801018a6: 66 90 xchg %ax,%ax
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018a8: 89 44 24 04 mov %eax,0x4(%esp)
801018ac: 8b 06 mov (%esi),%eax
for(j = 0; j < NINDIRECT; j++){
801018ae: 31 db xor %ebx,%ebx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018b0: 89 04 24 mov %eax,(%esp)
801018b3: e8 18 e8 ff ff call 801000d0 <bread>
for(j = 0; j < NINDIRECT; j++){
801018b8: 89 7d e0 mov %edi,-0x20(%ebp)
a = (uint*)bp->data;
801018bb: 8d 48 5c lea 0x5c(%eax),%ecx
bp = bread(ip->dev, ip->addrs[NDIRECT]);
801018be: 89 45 e4 mov %eax,-0x1c(%ebp)
for(j = 0; j < NINDIRECT; j++){
801018c1: 89 cf mov %ecx,%edi
801018c3: 31 c0 xor %eax,%eax
801018c5: eb 0e jmp 801018d5 <iput+0x105>
801018c7: 90 nop
801018c8: 83 c3 01 add $0x1,%ebx
801018cb: 81 fb 80 00 00 00 cmp $0x80,%ebx
801018d1: 89 d8 mov %ebx,%eax
801018d3: 74 10 je 801018e5 <iput+0x115>
if(a[j])
801018d5: 8b 14 87 mov (%edi,%eax,4),%edx
801018d8: 85 d2 test %edx,%edx
801018da: 74 ec je 801018c8 <iput+0xf8>
bfree(ip->dev, a[j]);
801018dc: 8b 06 mov (%esi),%eax
801018de: e8 fd fa ff ff call 801013e0 <bfree>
801018e3: eb e3 jmp 801018c8 <iput+0xf8>
brelse(bp);
801018e5: 8b 45 e4 mov -0x1c(%ebp),%eax
801018e8: 8b 7d e0 mov -0x20(%ebp),%edi
801018eb: 89 04 24 mov %eax,(%esp)
801018ee: e8 ed e8 ff ff call 801001e0 <brelse>
bfree(ip->dev, ip->addrs[NDIRECT]);
801018f3: 8b 96 8c 00 00 00 mov 0x8c(%esi),%edx
801018f9: 8b 06 mov (%esi),%eax
801018fb: e8 e0 fa ff ff call 801013e0 <bfree>
ip->addrs[NDIRECT] = 0;
80101900: c7 86 8c 00 00 00 00 movl $0x0,0x8c(%esi)
80101907: 00 00 00
8010190a: e9 6e ff ff ff jmp 8010187d <iput+0xad>
8010190f: 90 nop
80101910 <iunlockput>:
{
80101910: 55 push %ebp
80101911: 89 e5 mov %esp,%ebp
80101913: 53 push %ebx
80101914: 83 ec 14 sub $0x14,%esp
80101917: 8b 5d 08 mov 0x8(%ebp),%ebx
iunlock(ip);
8010191a: 89 1c 24 mov %ebx,(%esp)
8010191d: e8 6e fe ff ff call 80101790 <iunlock>
iput(ip);
80101922: 89 5d 08 mov %ebx,0x8(%ebp)
}
80101925: 83 c4 14 add $0x14,%esp
80101928: 5b pop %ebx
80101929: 5d pop %ebp
iput(ip);
8010192a: e9 a1 fe ff ff jmp 801017d0 <iput>
8010192f: 90 nop
80101930 <stati>:
// Copy stat information from inode.
// Caller must hold ip->lock.
void
stati(struct inode *ip, struct stat *st)
{
80101930: 55 push %ebp
80101931: 89 e5 mov %esp,%ebp
80101933: 8b 55 08 mov 0x8(%ebp),%edx
80101936: 8b 45 0c mov 0xc(%ebp),%eax
st->dev = ip->dev;
80101939: 8b 0a mov (%edx),%ecx
8010193b: 89 48 04 mov %ecx,0x4(%eax)
st->ino = ip->inum;
8010193e: 8b 4a 04 mov 0x4(%edx),%ecx
80101941: 89 48 08 mov %ecx,0x8(%eax)
st->type = ip->type;
80101944: 0f b7 4a 50 movzwl 0x50(%edx),%ecx
80101948: 66 89 08 mov %cx,(%eax)
st->nlink = ip->nlink;
8010194b: 0f b7 4a 56 movzwl 0x56(%edx),%ecx
8010194f: 66 89 48 0c mov %cx,0xc(%eax)
st->size = ip->size;
80101953: 8b 52 58 mov 0x58(%edx),%edx
80101956: 89 50 10 mov %edx,0x10(%eax)
}
80101959: 5d pop %ebp
8010195a: c3 ret
8010195b: 90 nop
8010195c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101960 <readi>:
//PAGEBREAK!
// Read data from inode.
// Caller must hold ip->lock.
int
readi(struct inode *ip, char *dst, uint off, uint n)
{
80101960: 55 push %ebp
80101961: 89 e5 mov %esp,%ebp
80101963: 57 push %edi
80101964: 56 push %esi
80101965: 53 push %ebx
80101966: 83 ec 2c sub $0x2c,%esp
80101969: 8b 45 0c mov 0xc(%ebp),%eax
8010196c: 8b 7d 08 mov 0x8(%ebp),%edi
8010196f: 8b 75 10 mov 0x10(%ebp),%esi
80101972: 89 45 e0 mov %eax,-0x20(%ebp)
80101975: 8b 45 14 mov 0x14(%ebp),%eax
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101978: 66 83 7f 50 03 cmpw $0x3,0x50(%edi)
{
8010197d: 89 45 e4 mov %eax,-0x1c(%ebp)
if(ip->type == T_DEV){
80101980: 0f 84 aa 00 00 00 je 80101a30 <readi+0xd0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
return -1;
return devsw[ip->major].read(ip, dst, n);
}
if(off > ip->size || off + n < off)
80101986: 8b 47 58 mov 0x58(%edi),%eax
80101989: 39 f0 cmp %esi,%eax
8010198b: 0f 82 c7 00 00 00 jb 80101a58 <readi+0xf8>
80101991: 8b 5d e4 mov -0x1c(%ebp),%ebx
80101994: 89 da mov %ebx,%edx
80101996: 01 f2 add %esi,%edx
80101998: 0f 82 ba 00 00 00 jb 80101a58 <readi+0xf8>
return -1;
if(off + n > ip->size)
n = ip->size - off;
8010199e: 89 c1 mov %eax,%ecx
801019a0: 29 f1 sub %esi,%ecx
801019a2: 39 d0 cmp %edx,%eax
801019a4: 0f 43 cb cmovae %ebx,%ecx
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
801019a7: 31 c0 xor %eax,%eax
801019a9: 85 c9 test %ecx,%ecx
n = ip->size - off;
801019ab: 89 4d e4 mov %ecx,-0x1c(%ebp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
801019ae: 74 70 je 80101a20 <readi+0xc0>
801019b0: 89 7d d8 mov %edi,-0x28(%ebp)
801019b3: 89 c7 mov %eax,%edi
801019b5: 8d 76 00 lea 0x0(%esi),%esi
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019b8: 8b 5d d8 mov -0x28(%ebp),%ebx
801019bb: 89 f2 mov %esi,%edx
801019bd: c1 ea 09 shr $0x9,%edx
801019c0: 89 d8 mov %ebx,%eax
801019c2: e8 09 f9 ff ff call 801012d0 <bmap>
801019c7: 89 44 24 04 mov %eax,0x4(%esp)
801019cb: 8b 03 mov (%ebx),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019cd: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019d2: 89 04 24 mov %eax,(%esp)
801019d5: e8 f6 e6 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
801019da: 8b 4d e4 mov -0x1c(%ebp),%ecx
801019dd: 29 f9 sub %edi,%ecx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
801019df: 89 c2 mov %eax,%edx
m = min(n - tot, BSIZE - off%BSIZE);
801019e1: 89 f0 mov %esi,%eax
801019e3: 25 ff 01 00 00 and $0x1ff,%eax
801019e8: 29 c3 sub %eax,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019ea: 8d 44 02 5c lea 0x5c(%edx,%eax,1),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019ee: 39 cb cmp %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019f0: 89 44 24 04 mov %eax,0x4(%esp)
801019f4: 8b 45 e0 mov -0x20(%ebp),%eax
m = min(n - tot, BSIZE - off%BSIZE);
801019f7: 0f 47 d9 cmova %ecx,%ebx
memmove(dst, bp->data + off%BSIZE, m);
801019fa: 89 5c 24 08 mov %ebx,0x8(%esp)
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
801019fe: 01 df add %ebx,%edi
80101a00: 01 de add %ebx,%esi
memmove(dst, bp->data + off%BSIZE, m);
80101a02: 89 55 dc mov %edx,-0x24(%ebp)
80101a05: 89 04 24 mov %eax,(%esp)
80101a08: e8 13 29 00 00 call 80104320 <memmove>
brelse(bp);
80101a0d: 8b 55 dc mov -0x24(%ebp),%edx
80101a10: 89 14 24 mov %edx,(%esp)
80101a13: e8 c8 e7 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, dst+=m){
80101a18: 01 5d e0 add %ebx,-0x20(%ebp)
80101a1b: 39 7d e4 cmp %edi,-0x1c(%ebp)
80101a1e: 77 98 ja 801019b8 <readi+0x58>
}
return n;
80101a20: 8b 45 e4 mov -0x1c(%ebp),%eax
}
80101a23: 83 c4 2c add $0x2c,%esp
80101a26: 5b pop %ebx
80101a27: 5e pop %esi
80101a28: 5f pop %edi
80101a29: 5d pop %ebp
80101a2a: c3 ret
80101a2b: 90 nop
80101a2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].read)
80101a30: 0f bf 47 52 movswl 0x52(%edi),%eax
80101a34: 66 83 f8 09 cmp $0x9,%ax
80101a38: 77 1e ja 80101a58 <readi+0xf8>
80101a3a: 8b 04 c5 60 09 11 80 mov -0x7feef6a0(,%eax,8),%eax
80101a41: 85 c0 test %eax,%eax
80101a43: 74 13 je 80101a58 <readi+0xf8>
return devsw[ip->major].read(ip, dst, n);
80101a45: 8b 75 e4 mov -0x1c(%ebp),%esi
80101a48: 89 75 10 mov %esi,0x10(%ebp)
}
80101a4b: 83 c4 2c add $0x2c,%esp
80101a4e: 5b pop %ebx
80101a4f: 5e pop %esi
80101a50: 5f pop %edi
80101a51: 5d pop %ebp
return devsw[ip->major].read(ip, dst, n);
80101a52: ff e0 jmp *%eax
80101a54: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80101a58: b8 ff ff ff ff mov $0xffffffff,%eax
80101a5d: eb c4 jmp 80101a23 <readi+0xc3>
80101a5f: 90 nop
80101a60 <writei>:
// PAGEBREAK!
// Write data to inode.
// Caller must hold ip->lock.
int
writei(struct inode *ip, char *src, uint off, uint n)
{
80101a60: 55 push %ebp
80101a61: 89 e5 mov %esp,%ebp
80101a63: 57 push %edi
80101a64: 56 push %esi
80101a65: 53 push %ebx
80101a66: 83 ec 2c sub $0x2c,%esp
80101a69: 8b 45 08 mov 0x8(%ebp),%eax
80101a6c: 8b 75 0c mov 0xc(%ebp),%esi
80101a6f: 8b 4d 14 mov 0x14(%ebp),%ecx
uint tot, m;
struct buf *bp;
if(ip->type == T_DEV){
80101a72: 66 83 78 50 03 cmpw $0x3,0x50(%eax)
{
80101a77: 89 75 dc mov %esi,-0x24(%ebp)
80101a7a: 8b 75 10 mov 0x10(%ebp),%esi
80101a7d: 89 45 d8 mov %eax,-0x28(%ebp)
80101a80: 89 4d e0 mov %ecx,-0x20(%ebp)
if(ip->type == T_DEV){
80101a83: 0f 84 b7 00 00 00 je 80101b40 <writei+0xe0>
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
return -1;
return devsw[ip->major].write(ip, src, n);
}
if(off > ip->size || off + n < off)
80101a89: 8b 45 d8 mov -0x28(%ebp),%eax
80101a8c: 39 70 58 cmp %esi,0x58(%eax)
80101a8f: 0f 82 e3 00 00 00 jb 80101b78 <writei+0x118>
80101a95: 8b 4d e0 mov -0x20(%ebp),%ecx
80101a98: 89 c8 mov %ecx,%eax
80101a9a: 01 f0 add %esi,%eax
80101a9c: 0f 82 d6 00 00 00 jb 80101b78 <writei+0x118>
return -1;
if(off + n > MAXFILE*BSIZE)
80101aa2: 3d 00 18 01 00 cmp $0x11800,%eax
80101aa7: 0f 87 cb 00 00 00 ja 80101b78 <writei+0x118>
return -1;
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101aad: 85 c9 test %ecx,%ecx
80101aaf: c7 45 e4 00 00 00 00 movl $0x0,-0x1c(%ebp)
80101ab6: 74 77 je 80101b2f <writei+0xcf>
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ab8: 8b 7d d8 mov -0x28(%ebp),%edi
80101abb: 89 f2 mov %esi,%edx
m = min(n - tot, BSIZE - off%BSIZE);
80101abd: bb 00 02 00 00 mov $0x200,%ebx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ac2: c1 ea 09 shr $0x9,%edx
80101ac5: 89 f8 mov %edi,%eax
80101ac7: e8 04 f8 ff ff call 801012d0 <bmap>
80101acc: 89 44 24 04 mov %eax,0x4(%esp)
80101ad0: 8b 07 mov (%edi),%eax
80101ad2: 89 04 24 mov %eax,(%esp)
80101ad5: e8 f6 e5 ff ff call 801000d0 <bread>
m = min(n - tot, BSIZE - off%BSIZE);
80101ada: 8b 4d e0 mov -0x20(%ebp),%ecx
80101add: 2b 4d e4 sub -0x1c(%ebp),%ecx
memmove(bp->data + off%BSIZE, src, m);
80101ae0: 8b 55 dc mov -0x24(%ebp),%edx
bp = bread(ip->dev, bmap(ip, off/BSIZE));
80101ae3: 89 c7 mov %eax,%edi
m = min(n - tot, BSIZE - off%BSIZE);
80101ae5: 89 f0 mov %esi,%eax
80101ae7: 25 ff 01 00 00 and $0x1ff,%eax
80101aec: 29 c3 sub %eax,%ebx
80101aee: 39 cb cmp %ecx,%ebx
80101af0: 0f 47 d9 cmova %ecx,%ebx
memmove(bp->data + off%BSIZE, src, m);
80101af3: 8d 44 07 5c lea 0x5c(%edi,%eax,1),%eax
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101af7: 01 de add %ebx,%esi
memmove(bp->data + off%BSIZE, src, m);
80101af9: 89 54 24 04 mov %edx,0x4(%esp)
80101afd: 89 5c 24 08 mov %ebx,0x8(%esp)
80101b01: 89 04 24 mov %eax,(%esp)
80101b04: e8 17 28 00 00 call 80104320 <memmove>
log_write(bp);
80101b09: 89 3c 24 mov %edi,(%esp)
80101b0c: e8 9f 11 00 00 call 80102cb0 <log_write>
brelse(bp);
80101b11: 89 3c 24 mov %edi,(%esp)
80101b14: e8 c7 e6 ff ff call 801001e0 <brelse>
for(tot=0; tot<n; tot+=m, off+=m, src+=m){
80101b19: 01 5d e4 add %ebx,-0x1c(%ebp)
80101b1c: 8b 45 e4 mov -0x1c(%ebp),%eax
80101b1f: 01 5d dc add %ebx,-0x24(%ebp)
80101b22: 39 45 e0 cmp %eax,-0x20(%ebp)
80101b25: 77 91 ja 80101ab8 <writei+0x58>
}
if(n > 0 && off > ip->size){
80101b27: 8b 45 d8 mov -0x28(%ebp),%eax
80101b2a: 39 70 58 cmp %esi,0x58(%eax)
80101b2d: 72 39 jb 80101b68 <writei+0x108>
ip->size = off;
iupdate(ip);
}
return n;
80101b2f: 8b 45 e0 mov -0x20(%ebp),%eax
}
80101b32: 83 c4 2c add $0x2c,%esp
80101b35: 5b pop %ebx
80101b36: 5e pop %esi
80101b37: 5f pop %edi
80101b38: 5d pop %ebp
80101b39: c3 ret
80101b3a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->major < 0 || ip->major >= NDEV || !devsw[ip->major].write)
80101b40: 0f bf 40 52 movswl 0x52(%eax),%eax
80101b44: 66 83 f8 09 cmp $0x9,%ax
80101b48: 77 2e ja 80101b78 <writei+0x118>
80101b4a: 8b 04 c5 64 09 11 80 mov -0x7feef69c(,%eax,8),%eax
80101b51: 85 c0 test %eax,%eax
80101b53: 74 23 je 80101b78 <writei+0x118>
return devsw[ip->major].write(ip, src, n);
80101b55: 89 4d 10 mov %ecx,0x10(%ebp)
}
80101b58: 83 c4 2c add $0x2c,%esp
80101b5b: 5b pop %ebx
80101b5c: 5e pop %esi
80101b5d: 5f pop %edi
80101b5e: 5d pop %ebp
return devsw[ip->major].write(ip, src, n);
80101b5f: ff e0 jmp *%eax
80101b61: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
ip->size = off;
80101b68: 8b 45 d8 mov -0x28(%ebp),%eax
80101b6b: 89 70 58 mov %esi,0x58(%eax)
iupdate(ip);
80101b6e: 89 04 24 mov %eax,(%esp)
80101b71: e8 7a fa ff ff call 801015f0 <iupdate>
80101b76: eb b7 jmp 80101b2f <writei+0xcf>
}
80101b78: 83 c4 2c add $0x2c,%esp
return -1;
80101b7b: b8 ff ff ff ff mov $0xffffffff,%eax
}
80101b80: 5b pop %ebx
80101b81: 5e pop %esi
80101b82: 5f pop %edi
80101b83: 5d pop %ebp
80101b84: c3 ret
80101b85: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101b89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101b90 <namecmp>:
//PAGEBREAK!
// Directories
int
namecmp(const char *s, const char *t)
{
80101b90: 55 push %ebp
80101b91: 89 e5 mov %esp,%ebp
80101b93: 83 ec 18 sub $0x18,%esp
return strncmp(s, t, DIRSIZ);
80101b96: 8b 45 0c mov 0xc(%ebp),%eax
80101b99: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101ba0: 00
80101ba1: 89 44 24 04 mov %eax,0x4(%esp)
80101ba5: 8b 45 08 mov 0x8(%ebp),%eax
80101ba8: 89 04 24 mov %eax,(%esp)
80101bab: e8 f0 27 00 00 call 801043a0 <strncmp>
}
80101bb0: c9 leave
80101bb1: c3 ret
80101bb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101bb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101bc0 <dirlookup>:
// Look for a directory entry in a directory.
// If found, set *poff to byte offset of entry.
struct inode*
dirlookup(struct inode *dp, char *name, uint *poff)
{
80101bc0: 55 push %ebp
80101bc1: 89 e5 mov %esp,%ebp
80101bc3: 57 push %edi
80101bc4: 56 push %esi
80101bc5: 53 push %ebx
80101bc6: 83 ec 2c sub $0x2c,%esp
80101bc9: 8b 5d 08 mov 0x8(%ebp),%ebx
uint off, inum;
struct dirent de;
if(dp->type != T_DIR)
80101bcc: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80101bd1: 0f 85 97 00 00 00 jne 80101c6e <dirlookup+0xae>
panic("dirlookup not DIR");
for(off = 0; off < dp->size; off += sizeof(de)){
80101bd7: 8b 53 58 mov 0x58(%ebx),%edx
80101bda: 31 ff xor %edi,%edi
80101bdc: 8d 75 d8 lea -0x28(%ebp),%esi
80101bdf: 85 d2 test %edx,%edx
80101be1: 75 0d jne 80101bf0 <dirlookup+0x30>
80101be3: eb 73 jmp 80101c58 <dirlookup+0x98>
80101be5: 8d 76 00 lea 0x0(%esi),%esi
80101be8: 83 c7 10 add $0x10,%edi
80101beb: 39 7b 58 cmp %edi,0x58(%ebx)
80101bee: 76 68 jbe 80101c58 <dirlookup+0x98>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101bf0: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101bf7: 00
80101bf8: 89 7c 24 08 mov %edi,0x8(%esp)
80101bfc: 89 74 24 04 mov %esi,0x4(%esp)
80101c00: 89 1c 24 mov %ebx,(%esp)
80101c03: e8 58 fd ff ff call 80101960 <readi>
80101c08: 83 f8 10 cmp $0x10,%eax
80101c0b: 75 55 jne 80101c62 <dirlookup+0xa2>
panic("dirlookup read");
if(de.inum == 0)
80101c0d: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101c12: 74 d4 je 80101be8 <dirlookup+0x28>
return strncmp(s, t, DIRSIZ);
80101c14: 8d 45 da lea -0x26(%ebp),%eax
80101c17: 89 44 24 04 mov %eax,0x4(%esp)
80101c1b: 8b 45 0c mov 0xc(%ebp),%eax
80101c1e: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101c25: 00
80101c26: 89 04 24 mov %eax,(%esp)
80101c29: e8 72 27 00 00 call 801043a0 <strncmp>
continue;
if(namecmp(name, de.name) == 0){
80101c2e: 85 c0 test %eax,%eax
80101c30: 75 b6 jne 80101be8 <dirlookup+0x28>
// entry matches path element
if(poff)
80101c32: 8b 45 10 mov 0x10(%ebp),%eax
80101c35: 85 c0 test %eax,%eax
80101c37: 74 05 je 80101c3e <dirlookup+0x7e>
*poff = off;
80101c39: 8b 45 10 mov 0x10(%ebp),%eax
80101c3c: 89 38 mov %edi,(%eax)
inum = de.inum;
80101c3e: 0f b7 55 d8 movzwl -0x28(%ebp),%edx
return iget(dp->dev, inum);
80101c42: 8b 03 mov (%ebx),%eax
80101c44: e8 c7 f5 ff ff call 80101210 <iget>
}
}
return 0;
}
80101c49: 83 c4 2c add $0x2c,%esp
80101c4c: 5b pop %ebx
80101c4d: 5e pop %esi
80101c4e: 5f pop %edi
80101c4f: 5d pop %ebp
80101c50: c3 ret
80101c51: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101c58: 83 c4 2c add $0x2c,%esp
return 0;
80101c5b: 31 c0 xor %eax,%eax
}
80101c5d: 5b pop %ebx
80101c5e: 5e pop %esi
80101c5f: 5f pop %edi
80101c60: 5d pop %ebp
80101c61: c3 ret
panic("dirlookup read");
80101c62: c7 04 24 e8 6f 10 80 movl $0x80106fe8,(%esp)
80101c69: e8 f2 e6 ff ff call 80100360 <panic>
panic("dirlookup not DIR");
80101c6e: c7 04 24 d6 6f 10 80 movl $0x80106fd6,(%esp)
80101c75: e8 e6 e6 ff ff call 80100360 <panic>
80101c7a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101c80 <namex>:
// If parent != 0, return the inode for the parent and copy the final
// path element into name, which must have room for DIRSIZ bytes.
// Must be called inside a transaction since it calls iput().
static struct inode*
namex(char *path, int nameiparent, char *name)
{
80101c80: 55 push %ebp
80101c81: 89 e5 mov %esp,%ebp
80101c83: 57 push %edi
80101c84: 89 cf mov %ecx,%edi
80101c86: 56 push %esi
80101c87: 53 push %ebx
80101c88: 89 c3 mov %eax,%ebx
80101c8a: 83 ec 2c sub $0x2c,%esp
struct inode *ip, *next;
if(*path == '/')
80101c8d: 80 38 2f cmpb $0x2f,(%eax)
{
80101c90: 89 55 e0 mov %edx,-0x20(%ebp)
if(*path == '/')
80101c93: 0f 84 51 01 00 00 je 80101dea <namex+0x16a>
ip = iget(ROOTDEV, ROOTINO);
else
ip = idup(myproc()->cwd);
80101c99: e8 02 1a 00 00 call 801036a0 <myproc>
80101c9e: 8b 70 6c mov 0x6c(%eax),%esi
acquire(&icache.lock);
80101ca1: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101ca8: e8 93 24 00 00 call 80104140 <acquire>
ip->ref++;
80101cad: 83 46 08 01 addl $0x1,0x8(%esi)
release(&icache.lock);
80101cb1: c7 04 24 e0 09 11 80 movl $0x801109e0,(%esp)
80101cb8: e8 73 25 00 00 call 80104230 <release>
80101cbd: eb 04 jmp 80101cc3 <namex+0x43>
80101cbf: 90 nop
path++;
80101cc0: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101cc3: 0f b6 03 movzbl (%ebx),%eax
80101cc6: 3c 2f cmp $0x2f,%al
80101cc8: 74 f6 je 80101cc0 <namex+0x40>
if(*path == 0)
80101cca: 84 c0 test %al,%al
80101ccc: 0f 84 ed 00 00 00 je 80101dbf <namex+0x13f>
while(*path != '/' && *path != 0)
80101cd2: 0f b6 03 movzbl (%ebx),%eax
80101cd5: 89 da mov %ebx,%edx
80101cd7: 84 c0 test %al,%al
80101cd9: 0f 84 b1 00 00 00 je 80101d90 <namex+0x110>
80101cdf: 3c 2f cmp $0x2f,%al
80101ce1: 75 0f jne 80101cf2 <namex+0x72>
80101ce3: e9 a8 00 00 00 jmp 80101d90 <namex+0x110>
80101ce8: 3c 2f cmp $0x2f,%al
80101cea: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80101cf0: 74 0a je 80101cfc <namex+0x7c>
path++;
80101cf2: 83 c2 01 add $0x1,%edx
while(*path != '/' && *path != 0)
80101cf5: 0f b6 02 movzbl (%edx),%eax
80101cf8: 84 c0 test %al,%al
80101cfa: 75 ec jne 80101ce8 <namex+0x68>
80101cfc: 89 d1 mov %edx,%ecx
80101cfe: 29 d9 sub %ebx,%ecx
if(len >= DIRSIZ)
80101d00: 83 f9 0d cmp $0xd,%ecx
80101d03: 0f 8e 8f 00 00 00 jle 80101d98 <namex+0x118>
memmove(name, s, DIRSIZ);
80101d09: 89 5c 24 04 mov %ebx,0x4(%esp)
80101d0d: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101d14: 00
80101d15: 89 3c 24 mov %edi,(%esp)
80101d18: 89 55 e4 mov %edx,-0x1c(%ebp)
80101d1b: e8 00 26 00 00 call 80104320 <memmove>
path++;
80101d20: 8b 55 e4 mov -0x1c(%ebp),%edx
80101d23: 89 d3 mov %edx,%ebx
while(*path == '/')
80101d25: 80 3a 2f cmpb $0x2f,(%edx)
80101d28: 75 0e jne 80101d38 <namex+0xb8>
80101d2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
path++;
80101d30: 83 c3 01 add $0x1,%ebx
while(*path == '/')
80101d33: 80 3b 2f cmpb $0x2f,(%ebx)
80101d36: 74 f8 je 80101d30 <namex+0xb0>
while((path = skipelem(path, name)) != 0){
ilock(ip);
80101d38: 89 34 24 mov %esi,(%esp)
80101d3b: e8 70 f9 ff ff call 801016b0 <ilock>
if(ip->type != T_DIR){
80101d40: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80101d45: 0f 85 85 00 00 00 jne 80101dd0 <namex+0x150>
iunlockput(ip);
return 0;
}
if(nameiparent && *path == '\0'){
80101d4b: 8b 55 e0 mov -0x20(%ebp),%edx
80101d4e: 85 d2 test %edx,%edx
80101d50: 74 09 je 80101d5b <namex+0xdb>
80101d52: 80 3b 00 cmpb $0x0,(%ebx)
80101d55: 0f 84 a5 00 00 00 je 80101e00 <namex+0x180>
// Stop one level early.
iunlock(ip);
return ip;
}
if((next = dirlookup(ip, name, 0)) == 0){
80101d5b: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101d62: 00
80101d63: 89 7c 24 04 mov %edi,0x4(%esp)
80101d67: 89 34 24 mov %esi,(%esp)
80101d6a: e8 51 fe ff ff call 80101bc0 <dirlookup>
80101d6f: 85 c0 test %eax,%eax
80101d71: 74 5d je 80101dd0 <namex+0x150>
iunlock(ip);
80101d73: 89 34 24 mov %esi,(%esp)
80101d76: 89 45 e4 mov %eax,-0x1c(%ebp)
80101d79: e8 12 fa ff ff call 80101790 <iunlock>
iput(ip);
80101d7e: 89 34 24 mov %esi,(%esp)
80101d81: e8 4a fa ff ff call 801017d0 <iput>
iunlockput(ip);
return 0;
}
iunlockput(ip);
ip = next;
80101d86: 8b 45 e4 mov -0x1c(%ebp),%eax
80101d89: 89 c6 mov %eax,%esi
80101d8b: e9 33 ff ff ff jmp 80101cc3 <namex+0x43>
while(*path != '/' && *path != 0)
80101d90: 31 c9 xor %ecx,%ecx
80101d92: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memmove(name, s, len);
80101d98: 89 4c 24 08 mov %ecx,0x8(%esp)
80101d9c: 89 5c 24 04 mov %ebx,0x4(%esp)
80101da0: 89 3c 24 mov %edi,(%esp)
80101da3: 89 55 dc mov %edx,-0x24(%ebp)
80101da6: 89 4d e4 mov %ecx,-0x1c(%ebp)
80101da9: e8 72 25 00 00 call 80104320 <memmove>
name[len] = 0;
80101dae: 8b 4d e4 mov -0x1c(%ebp),%ecx
80101db1: 8b 55 dc mov -0x24(%ebp),%edx
80101db4: c6 04 0f 00 movb $0x0,(%edi,%ecx,1)
80101db8: 89 d3 mov %edx,%ebx
80101dba: e9 66 ff ff ff jmp 80101d25 <namex+0xa5>
}
if(nameiparent){
80101dbf: 8b 45 e0 mov -0x20(%ebp),%eax
80101dc2: 85 c0 test %eax,%eax
80101dc4: 75 4c jne 80101e12 <namex+0x192>
80101dc6: 89 f0 mov %esi,%eax
iput(ip);
return 0;
}
return ip;
}
80101dc8: 83 c4 2c add $0x2c,%esp
80101dcb: 5b pop %ebx
80101dcc: 5e pop %esi
80101dcd: 5f pop %edi
80101dce: 5d pop %ebp
80101dcf: c3 ret
iunlock(ip);
80101dd0: 89 34 24 mov %esi,(%esp)
80101dd3: e8 b8 f9 ff ff call 80101790 <iunlock>
iput(ip);
80101dd8: 89 34 24 mov %esi,(%esp)
80101ddb: e8 f0 f9 ff ff call 801017d0 <iput>
}
80101de0: 83 c4 2c add $0x2c,%esp
return 0;
80101de3: 31 c0 xor %eax,%eax
}
80101de5: 5b pop %ebx
80101de6: 5e pop %esi
80101de7: 5f pop %edi
80101de8: 5d pop %ebp
80101de9: c3 ret
ip = iget(ROOTDEV, ROOTINO);
80101dea: ba 01 00 00 00 mov $0x1,%edx
80101def: b8 01 00 00 00 mov $0x1,%eax
80101df4: e8 17 f4 ff ff call 80101210 <iget>
80101df9: 89 c6 mov %eax,%esi
80101dfb: e9 c3 fe ff ff jmp 80101cc3 <namex+0x43>
iunlock(ip);
80101e00: 89 34 24 mov %esi,(%esp)
80101e03: e8 88 f9 ff ff call 80101790 <iunlock>
}
80101e08: 83 c4 2c add $0x2c,%esp
return ip;
80101e0b: 89 f0 mov %esi,%eax
}
80101e0d: 5b pop %ebx
80101e0e: 5e pop %esi
80101e0f: 5f pop %edi
80101e10: 5d pop %ebp
80101e11: c3 ret
iput(ip);
80101e12: 89 34 24 mov %esi,(%esp)
80101e15: e8 b6 f9 ff ff call 801017d0 <iput>
return 0;
80101e1a: 31 c0 xor %eax,%eax
80101e1c: eb aa jmp 80101dc8 <namex+0x148>
80101e1e: 66 90 xchg %ax,%ax
80101e20 <dirlink>:
{
80101e20: 55 push %ebp
80101e21: 89 e5 mov %esp,%ebp
80101e23: 57 push %edi
80101e24: 56 push %esi
80101e25: 53 push %ebx
80101e26: 83 ec 2c sub $0x2c,%esp
80101e29: 8b 5d 08 mov 0x8(%ebp),%ebx
if((ip = dirlookup(dp, name, 0)) != 0){
80101e2c: 8b 45 0c mov 0xc(%ebp),%eax
80101e2f: c7 44 24 08 00 00 00 movl $0x0,0x8(%esp)
80101e36: 00
80101e37: 89 1c 24 mov %ebx,(%esp)
80101e3a: 89 44 24 04 mov %eax,0x4(%esp)
80101e3e: e8 7d fd ff ff call 80101bc0 <dirlookup>
80101e43: 85 c0 test %eax,%eax
80101e45: 0f 85 8b 00 00 00 jne 80101ed6 <dirlink+0xb6>
for(off = 0; off < dp->size; off += sizeof(de)){
80101e4b: 8b 43 58 mov 0x58(%ebx),%eax
80101e4e: 31 ff xor %edi,%edi
80101e50: 8d 75 d8 lea -0x28(%ebp),%esi
80101e53: 85 c0 test %eax,%eax
80101e55: 75 13 jne 80101e6a <dirlink+0x4a>
80101e57: eb 35 jmp 80101e8e <dirlink+0x6e>
80101e59: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80101e60: 8d 57 10 lea 0x10(%edi),%edx
80101e63: 39 53 58 cmp %edx,0x58(%ebx)
80101e66: 89 d7 mov %edx,%edi
80101e68: 76 24 jbe 80101e8e <dirlink+0x6e>
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101e6a: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101e71: 00
80101e72: 89 7c 24 08 mov %edi,0x8(%esp)
80101e76: 89 74 24 04 mov %esi,0x4(%esp)
80101e7a: 89 1c 24 mov %ebx,(%esp)
80101e7d: e8 de fa ff ff call 80101960 <readi>
80101e82: 83 f8 10 cmp $0x10,%eax
80101e85: 75 5e jne 80101ee5 <dirlink+0xc5>
if(de.inum == 0)
80101e87: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80101e8c: 75 d2 jne 80101e60 <dirlink+0x40>
strncpy(de.name, name, DIRSIZ);
80101e8e: 8b 45 0c mov 0xc(%ebp),%eax
80101e91: c7 44 24 08 0e 00 00 movl $0xe,0x8(%esp)
80101e98: 00
80101e99: 89 44 24 04 mov %eax,0x4(%esp)
80101e9d: 8d 45 da lea -0x26(%ebp),%eax
80101ea0: 89 04 24 mov %eax,(%esp)
80101ea3: e8 68 25 00 00 call 80104410 <strncpy>
de.inum = inum;
80101ea8: 8b 45 10 mov 0x10(%ebp),%eax
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101eab: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80101eb2: 00
80101eb3: 89 7c 24 08 mov %edi,0x8(%esp)
80101eb7: 89 74 24 04 mov %esi,0x4(%esp)
80101ebb: 89 1c 24 mov %ebx,(%esp)
de.inum = inum;
80101ebe: 66 89 45 d8 mov %ax,-0x28(%ebp)
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80101ec2: e8 99 fb ff ff call 80101a60 <writei>
80101ec7: 83 f8 10 cmp $0x10,%eax
80101eca: 75 25 jne 80101ef1 <dirlink+0xd1>
return 0;
80101ecc: 31 c0 xor %eax,%eax
}
80101ece: 83 c4 2c add $0x2c,%esp
80101ed1: 5b pop %ebx
80101ed2: 5e pop %esi
80101ed3: 5f pop %edi
80101ed4: 5d pop %ebp
80101ed5: c3 ret
iput(ip);
80101ed6: 89 04 24 mov %eax,(%esp)
80101ed9: e8 f2 f8 ff ff call 801017d0 <iput>
return -1;
80101ede: b8 ff ff ff ff mov $0xffffffff,%eax
80101ee3: eb e9 jmp 80101ece <dirlink+0xae>
panic("dirlink read");
80101ee5: c7 04 24 f7 6f 10 80 movl $0x80106ff7,(%esp)
80101eec: e8 6f e4 ff ff call 80100360 <panic>
panic("dirlink");
80101ef1: c7 04 24 e6 75 10 80 movl $0x801075e6,(%esp)
80101ef8: e8 63 e4 ff ff call 80100360 <panic>
80101efd: 8d 76 00 lea 0x0(%esi),%esi
80101f00 <namei>:
struct inode*
namei(char *path)
{
80101f00: 55 push %ebp
char name[DIRSIZ];
return namex(path, 0, name);
80101f01: 31 d2 xor %edx,%edx
{
80101f03: 89 e5 mov %esp,%ebp
80101f05: 83 ec 18 sub $0x18,%esp
return namex(path, 0, name);
80101f08: 8b 45 08 mov 0x8(%ebp),%eax
80101f0b: 8d 4d ea lea -0x16(%ebp),%ecx
80101f0e: e8 6d fd ff ff call 80101c80 <namex>
}
80101f13: c9 leave
80101f14: c3 ret
80101f15: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80101f19: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80101f20 <nameiparent>:
struct inode*
nameiparent(char *path, char *name)
{
80101f20: 55 push %ebp
return namex(path, 1, name);
80101f21: ba 01 00 00 00 mov $0x1,%edx
{
80101f26: 89 e5 mov %esp,%ebp
return namex(path, 1, name);
80101f28: 8b 4d 0c mov 0xc(%ebp),%ecx
80101f2b: 8b 45 08 mov 0x8(%ebp),%eax
}
80101f2e: 5d pop %ebp
return namex(path, 1, name);
80101f2f: e9 4c fd ff ff jmp 80101c80 <namex>
80101f34: 66 90 xchg %ax,%ax
80101f36: 66 90 xchg %ax,%ax
80101f38: 66 90 xchg %ax,%ax
80101f3a: 66 90 xchg %ax,%ax
80101f3c: 66 90 xchg %ax,%ax
80101f3e: 66 90 xchg %ax,%ax
80101f40 <idestart>:
}
// Start the request for b. Caller must hold idelock.
static void
idestart(struct buf *b)
{
80101f40: 55 push %ebp
80101f41: 89 e5 mov %esp,%ebp
80101f43: 56 push %esi
80101f44: 89 c6 mov %eax,%esi
80101f46: 53 push %ebx
80101f47: 83 ec 10 sub $0x10,%esp
if(b == 0)
80101f4a: 85 c0 test %eax,%eax
80101f4c: 0f 84 99 00 00 00 je 80101feb <idestart+0xab>
panic("idestart");
if(b->blockno >= FSSIZE)
80101f52: 8b 48 08 mov 0x8(%eax),%ecx
80101f55: 81 f9 e7 03 00 00 cmp $0x3e7,%ecx
80101f5b: 0f 87 7e 00 00 00 ja 80101fdf <idestart+0x9f>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80101f61: ba f7 01 00 00 mov $0x1f7,%edx
80101f66: 66 90 xchg %ax,%ax
80101f68: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80101f69: 83 e0 c0 and $0xffffffc0,%eax
80101f6c: 3c 40 cmp $0x40,%al
80101f6e: 75 f8 jne 80101f68 <idestart+0x28>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80101f70: 31 db xor %ebx,%ebx
80101f72: ba f6 03 00 00 mov $0x3f6,%edx
80101f77: 89 d8 mov %ebx,%eax
80101f79: ee out %al,(%dx)
80101f7a: ba f2 01 00 00 mov $0x1f2,%edx
80101f7f: b8 01 00 00 00 mov $0x1,%eax
80101f84: ee out %al,(%dx)
80101f85: 0f b6 c1 movzbl %cl,%eax
80101f88: b2 f3 mov $0xf3,%dl
80101f8a: ee out %al,(%dx)
idewait(0);
outb(0x3f6, 0); // generate interrupt
outb(0x1f2, sector_per_block); // number of sectors
outb(0x1f3, sector & 0xff);
outb(0x1f4, (sector >> 8) & 0xff);
80101f8b: 89 c8 mov %ecx,%eax
80101f8d: b2 f4 mov $0xf4,%dl
80101f8f: c1 f8 08 sar $0x8,%eax
80101f92: ee out %al,(%dx)
80101f93: b2 f5 mov $0xf5,%dl
80101f95: 89 d8 mov %ebx,%eax
80101f97: ee out %al,(%dx)
outb(0x1f5, (sector >> 16) & 0xff);
outb(0x1f6, 0xe0 | ((b->dev&1)<<4) | ((sector>>24)&0x0f));
80101f98: 0f b6 46 04 movzbl 0x4(%esi),%eax
80101f9c: b2 f6 mov $0xf6,%dl
80101f9e: 83 e0 01 and $0x1,%eax
80101fa1: c1 e0 04 shl $0x4,%eax
80101fa4: 83 c8 e0 or $0xffffffe0,%eax
80101fa7: ee out %al,(%dx)
if(b->flags & B_DIRTY){
80101fa8: f6 06 04 testb $0x4,(%esi)
80101fab: 75 13 jne 80101fc0 <idestart+0x80>
80101fad: ba f7 01 00 00 mov $0x1f7,%edx
80101fb2: b8 20 00 00 00 mov $0x20,%eax
80101fb7: ee out %al,(%dx)
outb(0x1f7, write_cmd);
outsl(0x1f0, b->data, BSIZE/4);
} else {
outb(0x1f7, read_cmd);
}
}
80101fb8: 83 c4 10 add $0x10,%esp
80101fbb: 5b pop %ebx
80101fbc: 5e pop %esi
80101fbd: 5d pop %ebp
80101fbe: c3 ret
80101fbf: 90 nop
80101fc0: b2 f7 mov $0xf7,%dl
80101fc2: b8 30 00 00 00 mov $0x30,%eax
80101fc7: ee out %al,(%dx)
asm volatile("cld; rep outsl" :
80101fc8: b9 80 00 00 00 mov $0x80,%ecx
outsl(0x1f0, b->data, BSIZE/4);
80101fcd: 83 c6 5c add $0x5c,%esi
80101fd0: ba f0 01 00 00 mov $0x1f0,%edx
80101fd5: fc cld
80101fd6: f3 6f rep outsl %ds:(%esi),(%dx)
}
80101fd8: 83 c4 10 add $0x10,%esp
80101fdb: 5b pop %ebx
80101fdc: 5e pop %esi
80101fdd: 5d pop %ebp
80101fde: c3 ret
panic("incorrect blockno");
80101fdf: c7 04 24 60 70 10 80 movl $0x80107060,(%esp)
80101fe6: e8 75 e3 ff ff call 80100360 <panic>
panic("idestart");
80101feb: c7 04 24 57 70 10 80 movl $0x80107057,(%esp)
80101ff2: e8 69 e3 ff ff call 80100360 <panic>
80101ff7: 89 f6 mov %esi,%esi
80101ff9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102000 <ideinit>:
{
80102000: 55 push %ebp
80102001: 89 e5 mov %esp,%ebp
80102003: 83 ec 18 sub $0x18,%esp
initlock(&idelock, "ide");
80102006: c7 44 24 04 72 70 10 movl $0x80107072,0x4(%esp)
8010200d: 80
8010200e: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102015: e8 36 20 00 00 call 80104050 <initlock>
ioapicenable(IRQ_IDE, ncpu - 1);
8010201a: a1 00 2d 11 80 mov 0x80112d00,%eax
8010201f: c7 04 24 0e 00 00 00 movl $0xe,(%esp)
80102026: 83 e8 01 sub $0x1,%eax
80102029: 89 44 24 04 mov %eax,0x4(%esp)
8010202d: e8 7e 02 00 00 call 801022b0 <ioapicenable>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102032: ba f7 01 00 00 mov $0x1f7,%edx
80102037: 90 nop
80102038: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
80102039: 83 e0 c0 and $0xffffffc0,%eax
8010203c: 3c 40 cmp $0x40,%al
8010203e: 75 f8 jne 80102038 <ideinit+0x38>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102040: ba f6 01 00 00 mov $0x1f6,%edx
80102045: b8 f0 ff ff ff mov $0xfffffff0,%eax
8010204a: ee out %al,(%dx)
8010204b: b9 e8 03 00 00 mov $0x3e8,%ecx
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102050: b2 f7 mov $0xf7,%dl
80102052: eb 09 jmp 8010205d <ideinit+0x5d>
80102054: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<1000; i++){
80102058: 83 e9 01 sub $0x1,%ecx
8010205b: 74 0f je 8010206c <ideinit+0x6c>
8010205d: ec in (%dx),%al
if(inb(0x1f7) != 0){
8010205e: 84 c0 test %al,%al
80102060: 74 f6 je 80102058 <ideinit+0x58>
havedisk1 = 1;
80102062: c7 05 60 a5 10 80 01 movl $0x1,0x8010a560
80102069: 00 00 00
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010206c: ba f6 01 00 00 mov $0x1f6,%edx
80102071: b8 e0 ff ff ff mov $0xffffffe0,%eax
80102076: ee out %al,(%dx)
}
80102077: c9 leave
80102078: c3 ret
80102079: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102080 <ideintr>:
// Interrupt handler.
void
ideintr(void)
{
80102080: 55 push %ebp
80102081: 89 e5 mov %esp,%ebp
80102083: 57 push %edi
80102084: 56 push %esi
80102085: 53 push %ebx
80102086: 83 ec 1c sub $0x1c,%esp
struct buf *b;
// First queued buffer is the active request.
acquire(&idelock);
80102089: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102090: e8 ab 20 00 00 call 80104140 <acquire>
if((b = idequeue) == 0){
80102095: 8b 1d 64 a5 10 80 mov 0x8010a564,%ebx
8010209b: 85 db test %ebx,%ebx
8010209d: 74 30 je 801020cf <ideintr+0x4f>
release(&idelock);
return;
}
idequeue = b->qnext;
8010209f: 8b 43 58 mov 0x58(%ebx),%eax
801020a2: a3 64 a5 10 80 mov %eax,0x8010a564
// Read data if needed.
if(!(b->flags & B_DIRTY) && idewait(1) >= 0)
801020a7: 8b 33 mov (%ebx),%esi
801020a9: f7 c6 04 00 00 00 test $0x4,%esi
801020af: 74 37 je 801020e8 <ideintr+0x68>
insl(0x1f0, b->data, BSIZE/4);
// Wake process waiting for this buf.
b->flags |= B_VALID;
b->flags &= ~B_DIRTY;
801020b1: 83 e6 fb and $0xfffffffb,%esi
801020b4: 83 ce 02 or $0x2,%esi
801020b7: 89 33 mov %esi,(%ebx)
wakeup(b);
801020b9: 89 1c 24 mov %ebx,(%esp)
801020bc: e8 cf 1c 00 00 call 80103d90 <wakeup>
// Start disk on next buf in queue.
if(idequeue != 0)
801020c1: a1 64 a5 10 80 mov 0x8010a564,%eax
801020c6: 85 c0 test %eax,%eax
801020c8: 74 05 je 801020cf <ideintr+0x4f>
idestart(idequeue);
801020ca: e8 71 fe ff ff call 80101f40 <idestart>
release(&idelock);
801020cf: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
801020d6: e8 55 21 00 00 call 80104230 <release>
release(&idelock);
}
801020db: 83 c4 1c add $0x1c,%esp
801020de: 5b pop %ebx
801020df: 5e pop %esi
801020e0: 5f pop %edi
801020e1: 5d pop %ebp
801020e2: c3 ret
801020e3: 90 nop
801020e4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801020e8: ba f7 01 00 00 mov $0x1f7,%edx
801020ed: 8d 76 00 lea 0x0(%esi),%esi
801020f0: ec in (%dx),%al
while(((r = inb(0x1f7)) & (IDE_BSY|IDE_DRDY)) != IDE_DRDY)
801020f1: 89 c1 mov %eax,%ecx
801020f3: 83 e1 c0 and $0xffffffc0,%ecx
801020f6: 80 f9 40 cmp $0x40,%cl
801020f9: 75 f5 jne 801020f0 <ideintr+0x70>
if(checkerr && (r & (IDE_DF|IDE_ERR)) != 0)
801020fb: a8 21 test $0x21,%al
801020fd: 75 b2 jne 801020b1 <ideintr+0x31>
insl(0x1f0, b->data, BSIZE/4);
801020ff: 8d 7b 5c lea 0x5c(%ebx),%edi
asm volatile("cld; rep insl" :
80102102: b9 80 00 00 00 mov $0x80,%ecx
80102107: ba f0 01 00 00 mov $0x1f0,%edx
8010210c: fc cld
8010210d: f3 6d rep insl (%dx),%es:(%edi)
8010210f: 8b 33 mov (%ebx),%esi
80102111: eb 9e jmp 801020b1 <ideintr+0x31>
80102113: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102119: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102120 <iderw>:
// Sync buf with disk.
// If B_DIRTY is set, write buf to disk, clear B_DIRTY, set B_VALID.
// Else if B_VALID is not set, read buf from disk, set B_VALID.
void
iderw(struct buf *b)
{
80102120: 55 push %ebp
80102121: 89 e5 mov %esp,%ebp
80102123: 53 push %ebx
80102124: 83 ec 14 sub $0x14,%esp
80102127: 8b 5d 08 mov 0x8(%ebp),%ebx
struct buf **pp;
if(!holdingsleep(&b->lock))
8010212a: 8d 43 0c lea 0xc(%ebx),%eax
8010212d: 89 04 24 mov %eax,(%esp)
80102130: e8 eb 1e 00 00 call 80104020 <holdingsleep>
80102135: 85 c0 test %eax,%eax
80102137: 0f 84 9e 00 00 00 je 801021db <iderw+0xbb>
panic("iderw: buf not locked");
if((b->flags & (B_VALID|B_DIRTY)) == B_VALID)
8010213d: 8b 03 mov (%ebx),%eax
8010213f: 83 e0 06 and $0x6,%eax
80102142: 83 f8 02 cmp $0x2,%eax
80102145: 0f 84 a8 00 00 00 je 801021f3 <iderw+0xd3>
panic("iderw: nothing to do");
if(b->dev != 0 && !havedisk1)
8010214b: 8b 53 04 mov 0x4(%ebx),%edx
8010214e: 85 d2 test %edx,%edx
80102150: 74 0d je 8010215f <iderw+0x3f>
80102152: a1 60 a5 10 80 mov 0x8010a560,%eax
80102157: 85 c0 test %eax,%eax
80102159: 0f 84 88 00 00 00 je 801021e7 <iderw+0xc7>
panic("iderw: ide disk 1 not present");
acquire(&idelock); //DOC:acquire-lock
8010215f: c7 04 24 80 a5 10 80 movl $0x8010a580,(%esp)
80102166: e8 d5 1f 00 00 call 80104140 <acquire>
// Append b to idequeue.
b->qnext = 0;
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
8010216b: a1 64 a5 10 80 mov 0x8010a564,%eax
b->qnext = 0;
80102170: c7 43 58 00 00 00 00 movl $0x0,0x58(%ebx)
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
80102177: 85 c0 test %eax,%eax
80102179: 75 07 jne 80102182 <iderw+0x62>
8010217b: eb 4e jmp 801021cb <iderw+0xab>
8010217d: 8d 76 00 lea 0x0(%esi),%esi
80102180: 89 d0 mov %edx,%eax
80102182: 8b 50 58 mov 0x58(%eax),%edx
80102185: 85 d2 test %edx,%edx
80102187: 75 f7 jne 80102180 <iderw+0x60>
80102189: 83 c0 58 add $0x58,%eax
;
*pp = b;
8010218c: 89 18 mov %ebx,(%eax)
// Start disk if necessary.
if(idequeue == b)
8010218e: 39 1d 64 a5 10 80 cmp %ebx,0x8010a564
80102194: 74 3c je 801021d2 <iderw+0xb2>
idestart(b);
// Wait for request to finish.
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
80102196: 8b 03 mov (%ebx),%eax
80102198: 83 e0 06 and $0x6,%eax
8010219b: 83 f8 02 cmp $0x2,%eax
8010219e: 74 1a je 801021ba <iderw+0x9a>
sleep(b, &idelock);
801021a0: c7 44 24 04 80 a5 10 movl $0x8010a580,0x4(%esp)
801021a7: 80
801021a8: 89 1c 24 mov %ebx,(%esp)
801021ab: e8 50 1a 00 00 call 80103c00 <sleep>
while((b->flags & (B_VALID|B_DIRTY)) != B_VALID){
801021b0: 8b 13 mov (%ebx),%edx
801021b2: 83 e2 06 and $0x6,%edx
801021b5: 83 fa 02 cmp $0x2,%edx
801021b8: 75 e6 jne 801021a0 <iderw+0x80>
}
release(&idelock);
801021ba: c7 45 08 80 a5 10 80 movl $0x8010a580,0x8(%ebp)
}
801021c1: 83 c4 14 add $0x14,%esp
801021c4: 5b pop %ebx
801021c5: 5d pop %ebp
release(&idelock);
801021c6: e9 65 20 00 00 jmp 80104230 <release>
for(pp=&idequeue; *pp; pp=&(*pp)->qnext) //DOC:insert-queue
801021cb: b8 64 a5 10 80 mov $0x8010a564,%eax
801021d0: eb ba jmp 8010218c <iderw+0x6c>
idestart(b);
801021d2: 89 d8 mov %ebx,%eax
801021d4: e8 67 fd ff ff call 80101f40 <idestart>
801021d9: eb bb jmp 80102196 <iderw+0x76>
panic("iderw: buf not locked");
801021db: c7 04 24 76 70 10 80 movl $0x80107076,(%esp)
801021e2: e8 79 e1 ff ff call 80100360 <panic>
panic("iderw: ide disk 1 not present");
801021e7: c7 04 24 a1 70 10 80 movl $0x801070a1,(%esp)
801021ee: e8 6d e1 ff ff call 80100360 <panic>
panic("iderw: nothing to do");
801021f3: c7 04 24 8c 70 10 80 movl $0x8010708c,(%esp)
801021fa: e8 61 e1 ff ff call 80100360 <panic>
801021ff: 90 nop
80102200 <ioapicinit>:
ioapic->data = data;
}
void
ioapicinit(void)
{
80102200: 55 push %ebp
80102201: 89 e5 mov %esp,%ebp
80102203: 56 push %esi
80102204: 53 push %ebx
80102205: 83 ec 10 sub $0x10,%esp
int i, id, maxintr;
ioapic = (volatile struct ioapic*)IOAPIC;
80102208: c7 05 34 26 11 80 00 movl $0xfec00000,0x80112634
8010220f: 00 c0 fe
ioapic->reg = reg;
80102212: c7 05 00 00 c0 fe 01 movl $0x1,0xfec00000
80102219: 00 00 00
return ioapic->data;
8010221c: 8b 15 34 26 11 80 mov 0x80112634,%edx
80102222: 8b 42 10 mov 0x10(%edx),%eax
ioapic->reg = reg;
80102225: c7 02 00 00 00 00 movl $0x0,(%edx)
return ioapic->data;
8010222b: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
id = ioapicread(REG_ID) >> 24;
if(id != ioapicid)
80102231: 0f b6 15 60 27 11 80 movzbl 0x80112760,%edx
maxintr = (ioapicread(REG_VER) >> 16) & 0xFF;
80102238: c1 e8 10 shr $0x10,%eax
8010223b: 0f b6 f0 movzbl %al,%esi
return ioapic->data;
8010223e: 8b 43 10 mov 0x10(%ebx),%eax
id = ioapicread(REG_ID) >> 24;
80102241: c1 e8 18 shr $0x18,%eax
if(id != ioapicid)
80102244: 39 c2 cmp %eax,%edx
80102246: 74 12 je 8010225a <ioapicinit+0x5a>
cprintf("ioapicinit: id isn't equal to ioapicid; not a MP\n");
80102248: c7 04 24 c0 70 10 80 movl $0x801070c0,(%esp)
8010224f: e8 fc e3 ff ff call 80100650 <cprintf>
80102254: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
8010225a: ba 10 00 00 00 mov $0x10,%edx
8010225f: 31 c0 xor %eax,%eax
80102261: eb 07 jmp 8010226a <ioapicinit+0x6a>
80102263: 90 nop
80102264: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102268: 89 cb mov %ecx,%ebx
ioapic->reg = reg;
8010226a: 89 13 mov %edx,(%ebx)
ioapic->data = data;
8010226c: 8b 1d 34 26 11 80 mov 0x80112634,%ebx
80102272: 8d 48 20 lea 0x20(%eax),%ecx
// Mark all interrupts edge-triggered, active high, disabled,
// and not routed to any CPUs.
for(i = 0; i <= maxintr; i++){
ioapicwrite(REG_TABLE+2*i, INT_DISABLED | (T_IRQ0 + i));
80102275: 81 c9 00 00 01 00 or $0x10000,%ecx
for(i = 0; i <= maxintr; i++){
8010227b: 83 c0 01 add $0x1,%eax
ioapic->data = data;
8010227e: 89 4b 10 mov %ecx,0x10(%ebx)
80102281: 8d 4a 01 lea 0x1(%edx),%ecx
80102284: 83 c2 02 add $0x2,%edx
ioapic->reg = reg;
80102287: 89 0b mov %ecx,(%ebx)
ioapic->data = data;
80102289: 8b 0d 34 26 11 80 mov 0x80112634,%ecx
for(i = 0; i <= maxintr; i++){
8010228f: 39 c6 cmp %eax,%esi
ioapic->data = data;
80102291: c7 41 10 00 00 00 00 movl $0x0,0x10(%ecx)
for(i = 0; i <= maxintr; i++){
80102298: 7d ce jge 80102268 <ioapicinit+0x68>
ioapicwrite(REG_TABLE+2*i+1, 0);
}
}
8010229a: 83 c4 10 add $0x10,%esp
8010229d: 5b pop %ebx
8010229e: 5e pop %esi
8010229f: 5d pop %ebp
801022a0: c3 ret
801022a1: eb 0d jmp 801022b0 <ioapicenable>
801022a3: 90 nop
801022a4: 90 nop
801022a5: 90 nop
801022a6: 90 nop
801022a7: 90 nop
801022a8: 90 nop
801022a9: 90 nop
801022aa: 90 nop
801022ab: 90 nop
801022ac: 90 nop
801022ad: 90 nop
801022ae: 90 nop
801022af: 90 nop
801022b0 <ioapicenable>:
void
ioapicenable(int irq, int cpunum)
{
801022b0: 55 push %ebp
801022b1: 89 e5 mov %esp,%ebp
801022b3: 8b 55 08 mov 0x8(%ebp),%edx
801022b6: 53 push %ebx
801022b7: 8b 45 0c mov 0xc(%ebp),%eax
// Mark interrupt edge-triggered, active high,
// enabled, and routed to the given cpunum,
// which happens to be that cpu's APIC ID.
ioapicwrite(REG_TABLE+2*irq, T_IRQ0 + irq);
801022ba: 8d 5a 20 lea 0x20(%edx),%ebx
801022bd: 8d 4c 12 10 lea 0x10(%edx,%edx,1),%ecx
ioapic->reg = reg;
801022c1: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022c7: c1 e0 18 shl $0x18,%eax
ioapic->reg = reg;
801022ca: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022cc: 8b 15 34 26 11 80 mov 0x80112634,%edx
ioapicwrite(REG_TABLE+2*irq+1, cpunum << 24);
801022d2: 83 c1 01 add $0x1,%ecx
ioapic->data = data;
801022d5: 89 5a 10 mov %ebx,0x10(%edx)
ioapic->reg = reg;
801022d8: 89 0a mov %ecx,(%edx)
ioapic->data = data;
801022da: 8b 15 34 26 11 80 mov 0x80112634,%edx
801022e0: 89 42 10 mov %eax,0x10(%edx)
}
801022e3: 5b pop %ebx
801022e4: 5d pop %ebp
801022e5: c3 ret
801022e6: 66 90 xchg %ax,%ax
801022e8: 66 90 xchg %ax,%ax
801022ea: 66 90 xchg %ax,%ax
801022ec: 66 90 xchg %ax,%ax
801022ee: 66 90 xchg %ax,%ax
801022f0 <kfree>:
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
void
kfree(char *v)
{
801022f0: 55 push %ebp
801022f1: 89 e5 mov %esp,%ebp
801022f3: 53 push %ebx
801022f4: 83 ec 14 sub $0x14,%esp
801022f7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct run *r;
if((uint)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
801022fa: f7 c3 ff 0f 00 00 test $0xfff,%ebx
80102300: 75 7c jne 8010237e <kfree+0x8e>
80102302: 81 fb f4 58 11 80 cmp $0x801158f4,%ebx
80102308: 72 74 jb 8010237e <kfree+0x8e>
8010230a: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
80102310: 3d ff ff ff 0d cmp $0xdffffff,%eax
80102315: 77 67 ja 8010237e <kfree+0x8e>
panic("kfree");
// Fill with junk to catch dangling refs.
memset(v, 1, PGSIZE);
80102317: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
8010231e: 00
8010231f: c7 44 24 04 01 00 00 movl $0x1,0x4(%esp)
80102326: 00
80102327: 89 1c 24 mov %ebx,(%esp)
8010232a: e8 51 1f 00 00 call 80104280 <memset>
if(kmem.use_lock)
8010232f: 8b 15 74 26 11 80 mov 0x80112674,%edx
80102335: 85 d2 test %edx,%edx
80102337: 75 37 jne 80102370 <kfree+0x80>
acquire(&kmem.lock);
r = (struct run*)v;
r->next = kmem.freelist;
80102339: a1 78 26 11 80 mov 0x80112678,%eax
8010233e: 89 03 mov %eax,(%ebx)
kmem.freelist = r;
if(kmem.use_lock)
80102340: a1 74 26 11 80 mov 0x80112674,%eax
kmem.freelist = r;
80102345: 89 1d 78 26 11 80 mov %ebx,0x80112678
if(kmem.use_lock)
8010234b: 85 c0 test %eax,%eax
8010234d: 75 09 jne 80102358 <kfree+0x68>
release(&kmem.lock);
}
8010234f: 83 c4 14 add $0x14,%esp
80102352: 5b pop %ebx
80102353: 5d pop %ebp
80102354: c3 ret
80102355: 8d 76 00 lea 0x0(%esi),%esi
release(&kmem.lock);
80102358: c7 45 08 40 26 11 80 movl $0x80112640,0x8(%ebp)
}
8010235f: 83 c4 14 add $0x14,%esp
80102362: 5b pop %ebx
80102363: 5d pop %ebp
release(&kmem.lock);
80102364: e9 c7 1e 00 00 jmp 80104230 <release>
80102369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
acquire(&kmem.lock);
80102370: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
80102377: e8 c4 1d 00 00 call 80104140 <acquire>
8010237c: eb bb jmp 80102339 <kfree+0x49>
panic("kfree");
8010237e: c7 04 24 f2 70 10 80 movl $0x801070f2,(%esp)
80102385: e8 d6 df ff ff call 80100360 <panic>
8010238a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102390 <freerange>:
{
80102390: 55 push %ebp
80102391: 89 e5 mov %esp,%ebp
80102393: 56 push %esi
80102394: 53 push %ebx
80102395: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102398: 8b 45 08 mov 0x8(%ebp),%eax
{
8010239b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010239e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
801023a4: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
801023aa: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
801023b0: 39 de cmp %ebx,%esi
801023b2: 73 08 jae 801023bc <freerange+0x2c>
801023b4: eb 18 jmp 801023ce <freerange+0x3e>
801023b6: 66 90 xchg %ax,%ax
801023b8: 89 da mov %ebx,%edx
801023ba: 89 c3 mov %eax,%ebx
kfree(p);
801023bc: 89 14 24 mov %edx,(%esp)
801023bf: e8 2c ff ff ff call 801022f0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
801023c4: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
801023ca: 39 f0 cmp %esi,%eax
801023cc: 76 ea jbe 801023b8 <freerange+0x28>
}
801023ce: 83 c4 10 add $0x10,%esp
801023d1: 5b pop %ebx
801023d2: 5e pop %esi
801023d3: 5d pop %ebp
801023d4: c3 ret
801023d5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801023d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801023e0 <kinit1>:
{
801023e0: 55 push %ebp
801023e1: 89 e5 mov %esp,%ebp
801023e3: 56 push %esi
801023e4: 53 push %ebx
801023e5: 83 ec 10 sub $0x10,%esp
801023e8: 8b 75 0c mov 0xc(%ebp),%esi
initlock(&kmem.lock, "kmem");
801023eb: c7 44 24 04 f8 70 10 movl $0x801070f8,0x4(%esp)
801023f2: 80
801023f3: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801023fa: e8 51 1c 00 00 call 80104050 <initlock>
p = (char*)PGROUNDUP((uint)vstart);
801023ff: 8b 45 08 mov 0x8(%ebp),%eax
kmem.use_lock = 0;
80102402: c7 05 74 26 11 80 00 movl $0x0,0x80112674
80102409: 00 00 00
p = (char*)PGROUNDUP((uint)vstart);
8010240c: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102412: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102418: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
8010241e: 39 de cmp %ebx,%esi
80102420: 73 0a jae 8010242c <kinit1+0x4c>
80102422: eb 1a jmp 8010243e <kinit1+0x5e>
80102424: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102428: 89 da mov %ebx,%edx
8010242a: 89 c3 mov %eax,%ebx
kfree(p);
8010242c: 89 14 24 mov %edx,(%esp)
8010242f: e8 bc fe ff ff call 801022f0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102434: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010243a: 39 c6 cmp %eax,%esi
8010243c: 73 ea jae 80102428 <kinit1+0x48>
}
8010243e: 83 c4 10 add $0x10,%esp
80102441: 5b pop %ebx
80102442: 5e pop %esi
80102443: 5d pop %ebp
80102444: c3 ret
80102445: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102449: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102450 <kinit2>:
{
80102450: 55 push %ebp
80102451: 89 e5 mov %esp,%ebp
80102453: 56 push %esi
80102454: 53 push %ebx
80102455: 83 ec 10 sub $0x10,%esp
p = (char*)PGROUNDUP((uint)vstart);
80102458: 8b 45 08 mov 0x8(%ebp),%eax
{
8010245b: 8b 75 0c mov 0xc(%ebp),%esi
p = (char*)PGROUNDUP((uint)vstart);
8010245e: 8d 90 ff 0f 00 00 lea 0xfff(%eax),%edx
80102464: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
8010246a: 8d 9a 00 10 00 00 lea 0x1000(%edx),%ebx
80102470: 39 de cmp %ebx,%esi
80102472: 73 08 jae 8010247c <kinit2+0x2c>
80102474: eb 18 jmp 8010248e <kinit2+0x3e>
80102476: 66 90 xchg %ax,%ax
80102478: 89 da mov %ebx,%edx
8010247a: 89 c3 mov %eax,%ebx
kfree(p);
8010247c: 89 14 24 mov %edx,(%esp)
8010247f: e8 6c fe ff ff call 801022f0 <kfree>
for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
80102484: 8d 83 00 10 00 00 lea 0x1000(%ebx),%eax
8010248a: 39 c6 cmp %eax,%esi
8010248c: 73 ea jae 80102478 <kinit2+0x28>
kmem.use_lock = 1;
8010248e: c7 05 74 26 11 80 01 movl $0x1,0x80112674
80102495: 00 00 00
}
80102498: 83 c4 10 add $0x10,%esp
8010249b: 5b pop %ebx
8010249c: 5e pop %esi
8010249d: 5d pop %ebp
8010249e: c3 ret
8010249f: 90 nop
801024a0 <kalloc>:
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns 0 if the memory cannot be allocated.
char*
kalloc(void)
{
801024a0: 55 push %ebp
801024a1: 89 e5 mov %esp,%ebp
801024a3: 53 push %ebx
801024a4: 83 ec 14 sub $0x14,%esp
struct run *r;
if(kmem.use_lock)
801024a7: a1 74 26 11 80 mov 0x80112674,%eax
801024ac: 85 c0 test %eax,%eax
801024ae: 75 30 jne 801024e0 <kalloc+0x40>
acquire(&kmem.lock);
r = kmem.freelist;
801024b0: 8b 1d 78 26 11 80 mov 0x80112678,%ebx
if(r)
801024b6: 85 db test %ebx,%ebx
801024b8: 74 08 je 801024c2 <kalloc+0x22>
kmem.freelist = r->next;
801024ba: 8b 13 mov (%ebx),%edx
801024bc: 89 15 78 26 11 80 mov %edx,0x80112678
if(kmem.use_lock)
801024c2: 85 c0 test %eax,%eax
801024c4: 74 0c je 801024d2 <kalloc+0x32>
release(&kmem.lock);
801024c6: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024cd: e8 5e 1d 00 00 call 80104230 <release>
return (char*)r;
}
801024d2: 83 c4 14 add $0x14,%esp
801024d5: 89 d8 mov %ebx,%eax
801024d7: 5b pop %ebx
801024d8: 5d pop %ebp
801024d9: c3 ret
801024da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
acquire(&kmem.lock);
801024e0: c7 04 24 40 26 11 80 movl $0x80112640,(%esp)
801024e7: e8 54 1c 00 00 call 80104140 <acquire>
801024ec: a1 74 26 11 80 mov 0x80112674,%eax
801024f1: eb bd jmp 801024b0 <kalloc+0x10>
801024f3: 66 90 xchg %ax,%ax
801024f5: 66 90 xchg %ax,%ax
801024f7: 66 90 xchg %ax,%ax
801024f9: 66 90 xchg %ax,%ax
801024fb: 66 90 xchg %ax,%ax
801024fd: 66 90 xchg %ax,%ax
801024ff: 90 nop
80102500 <kbdgetc>:
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102500: ba 64 00 00 00 mov $0x64,%edx
80102505: ec in (%dx),%al
normalmap, shiftmap, ctlmap, ctlmap
};
uint st, data, c;
st = inb(KBSTATP);
if((st & KBS_DIB) == 0)
80102506: a8 01 test $0x1,%al
80102508: 0f 84 ba 00 00 00 je 801025c8 <kbdgetc+0xc8>
8010250e: b2 60 mov $0x60,%dl
80102510: ec in (%dx),%al
return -1;
data = inb(KBDATAP);
80102511: 0f b6 c8 movzbl %al,%ecx
if(data == 0xE0){
80102514: 81 f9 e0 00 00 00 cmp $0xe0,%ecx
8010251a: 0f 84 88 00 00 00 je 801025a8 <kbdgetc+0xa8>
shift |= E0ESC;
return 0;
} else if(data & 0x80){
80102520: 84 c0 test %al,%al
80102522: 79 2c jns 80102550 <kbdgetc+0x50>
// Key released
data = (shift & E0ESC ? data : data & 0x7F);
80102524: 8b 15 b4 a5 10 80 mov 0x8010a5b4,%edx
8010252a: f6 c2 40 test $0x40,%dl
8010252d: 75 05 jne 80102534 <kbdgetc+0x34>
8010252f: 89 c1 mov %eax,%ecx
80102531: 83 e1 7f and $0x7f,%ecx
shift &= ~(shiftcode[data] | E0ESC);
80102534: 0f b6 81 20 72 10 80 movzbl -0x7fef8de0(%ecx),%eax
8010253b: 83 c8 40 or $0x40,%eax
8010253e: 0f b6 c0 movzbl %al,%eax
80102541: f7 d0 not %eax
80102543: 21 d0 and %edx,%eax
80102545: a3 b4 a5 10 80 mov %eax,0x8010a5b4
return 0;
8010254a: 31 c0 xor %eax,%eax
8010254c: c3 ret
8010254d: 8d 76 00 lea 0x0(%esi),%esi
{
80102550: 55 push %ebp
80102551: 89 e5 mov %esp,%ebp
80102553: 53 push %ebx
80102554: 8b 1d b4 a5 10 80 mov 0x8010a5b4,%ebx
} else if(shift & E0ESC){
8010255a: f6 c3 40 test $0x40,%bl
8010255d: 74 09 je 80102568 <kbdgetc+0x68>
// Last character was an E0 escape; or with 0x80
data |= 0x80;
8010255f: 83 c8 80 or $0xffffff80,%eax
shift &= ~E0ESC;
80102562: 83 e3 bf and $0xffffffbf,%ebx
data |= 0x80;
80102565: 0f b6 c8 movzbl %al,%ecx
}
shift |= shiftcode[data];
80102568: 0f b6 91 20 72 10 80 movzbl -0x7fef8de0(%ecx),%edx
shift ^= togglecode[data];
8010256f: 0f b6 81 20 71 10 80 movzbl -0x7fef8ee0(%ecx),%eax
shift |= shiftcode[data];
80102576: 09 da or %ebx,%edx
shift ^= togglecode[data];
80102578: 31 c2 xor %eax,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010257a: 89 d0 mov %edx,%eax
8010257c: 83 e0 03 and $0x3,%eax
8010257f: 8b 04 85 00 71 10 80 mov -0x7fef8f00(,%eax,4),%eax
shift ^= togglecode[data];
80102586: 89 15 b4 a5 10 80 mov %edx,0x8010a5b4
if(shift & CAPSLOCK){
8010258c: 83 e2 08 and $0x8,%edx
c = charcode[shift & (CTL | SHIFT)][data];
8010258f: 0f b6 04 08 movzbl (%eax,%ecx,1),%eax
if(shift & CAPSLOCK){
80102593: 74 0b je 801025a0 <kbdgetc+0xa0>
if('a' <= c && c <= 'z')
80102595: 8d 50 9f lea -0x61(%eax),%edx
80102598: 83 fa 19 cmp $0x19,%edx
8010259b: 77 1b ja 801025b8 <kbdgetc+0xb8>
c += 'A' - 'a';
8010259d: 83 e8 20 sub $0x20,%eax
else if('A' <= c && c <= 'Z')
c += 'a' - 'A';
}
return c;
}
801025a0: 5b pop %ebx
801025a1: 5d pop %ebp
801025a2: c3 ret
801025a3: 90 nop
801025a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
shift |= E0ESC;
801025a8: 83 0d b4 a5 10 80 40 orl $0x40,0x8010a5b4
return 0;
801025af: 31 c0 xor %eax,%eax
801025b1: c3 ret
801025b2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
else if('A' <= c && c <= 'Z')
801025b8: 8d 48 bf lea -0x41(%eax),%ecx
c += 'a' - 'A';
801025bb: 8d 50 20 lea 0x20(%eax),%edx
801025be: 83 f9 19 cmp $0x19,%ecx
801025c1: 0f 46 c2 cmovbe %edx,%eax
return c;
801025c4: eb da jmp 801025a0 <kbdgetc+0xa0>
801025c6: 66 90 xchg %ax,%ax
return -1;
801025c8: b8 ff ff ff ff mov $0xffffffff,%eax
801025cd: c3 ret
801025ce: 66 90 xchg %ax,%ax
801025d0 <kbdintr>:
void
kbdintr(void)
{
801025d0: 55 push %ebp
801025d1: 89 e5 mov %esp,%ebp
801025d3: 83 ec 18 sub $0x18,%esp
consoleintr(kbdgetc);
801025d6: c7 04 24 00 25 10 80 movl $0x80102500,(%esp)
801025dd: e8 ce e1 ff ff call 801007b0 <consoleintr>
}
801025e2: c9 leave
801025e3: c3 ret
801025e4: 66 90 xchg %ax,%ax
801025e6: 66 90 xchg %ax,%ax
801025e8: 66 90 xchg %ax,%ax
801025ea: 66 90 xchg %ax,%ax
801025ec: 66 90 xchg %ax,%ax
801025ee: 66 90 xchg %ax,%ax
801025f0 <fill_rtcdate>:
return inb(CMOS_RETURN);
}
static void fill_rtcdate(struct rtcdate *r)
{
801025f0: 55 push %ebp
801025f1: 89 c1 mov %eax,%ecx
801025f3: 89 e5 mov %esp,%ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801025f5: ba 70 00 00 00 mov $0x70,%edx
801025fa: 53 push %ebx
801025fb: 31 c0 xor %eax,%eax
801025fd: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801025fe: bb 71 00 00 00 mov $0x71,%ebx
80102603: 89 da mov %ebx,%edx
80102605: ec in (%dx),%al
return inb(CMOS_RETURN);
80102606: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102609: b2 70 mov $0x70,%dl
8010260b: 89 01 mov %eax,(%ecx)
8010260d: b8 02 00 00 00 mov $0x2,%eax
80102612: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102613: 89 da mov %ebx,%edx
80102615: ec in (%dx),%al
80102616: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102619: b2 70 mov $0x70,%dl
8010261b: 89 41 04 mov %eax,0x4(%ecx)
8010261e: b8 04 00 00 00 mov $0x4,%eax
80102623: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102624: 89 da mov %ebx,%edx
80102626: ec in (%dx),%al
80102627: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010262a: b2 70 mov $0x70,%dl
8010262c: 89 41 08 mov %eax,0x8(%ecx)
8010262f: b8 07 00 00 00 mov $0x7,%eax
80102634: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102635: 89 da mov %ebx,%edx
80102637: ec in (%dx),%al
80102638: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010263b: b2 70 mov $0x70,%dl
8010263d: 89 41 0c mov %eax,0xc(%ecx)
80102640: b8 08 00 00 00 mov $0x8,%eax
80102645: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102646: 89 da mov %ebx,%edx
80102648: ec in (%dx),%al
80102649: 0f b6 c0 movzbl %al,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010264c: b2 70 mov $0x70,%dl
8010264e: 89 41 10 mov %eax,0x10(%ecx)
80102651: b8 09 00 00 00 mov $0x9,%eax
80102656: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102657: 89 da mov %ebx,%edx
80102659: ec in (%dx),%al
8010265a: 0f b6 d8 movzbl %al,%ebx
8010265d: 89 59 14 mov %ebx,0x14(%ecx)
r->minute = cmos_read(MINS);
r->hour = cmos_read(HOURS);
r->day = cmos_read(DAY);
r->month = cmos_read(MONTH);
r->year = cmos_read(YEAR);
}
80102660: 5b pop %ebx
80102661: 5d pop %ebp
80102662: c3 ret
80102663: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102669: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102670 <lapicinit>:
if(!lapic)
80102670: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102675: 55 push %ebp
80102676: 89 e5 mov %esp,%ebp
if(!lapic)
80102678: 85 c0 test %eax,%eax
8010267a: 0f 84 c0 00 00 00 je 80102740 <lapicinit+0xd0>
lapic[index] = value;
80102680: c7 80 f0 00 00 00 3f movl $0x13f,0xf0(%eax)
80102687: 01 00 00
lapic[ID]; // wait for write to finish, by reading
8010268a: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010268d: c7 80 e0 03 00 00 0b movl $0xb,0x3e0(%eax)
80102694: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102697: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010269a: c7 80 20 03 00 00 20 movl $0x20020,0x320(%eax)
801026a1: 00 02 00
lapic[ID]; // wait for write to finish, by reading
801026a4: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026a7: c7 80 80 03 00 00 80 movl $0x989680,0x380(%eax)
801026ae: 96 98 00
lapic[ID]; // wait for write to finish, by reading
801026b1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026b4: c7 80 50 03 00 00 00 movl $0x10000,0x350(%eax)
801026bb: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026be: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026c1: c7 80 60 03 00 00 00 movl $0x10000,0x360(%eax)
801026c8: 00 01 00
lapic[ID]; // wait for write to finish, by reading
801026cb: 8b 50 20 mov 0x20(%eax),%edx
if(((lapic[VER]>>16) & 0xFF) >= 4)
801026ce: 8b 50 30 mov 0x30(%eax),%edx
801026d1: c1 ea 10 shr $0x10,%edx
801026d4: 80 fa 03 cmp $0x3,%dl
801026d7: 77 6f ja 80102748 <lapicinit+0xd8>
lapic[index] = value;
801026d9: c7 80 70 03 00 00 33 movl $0x33,0x370(%eax)
801026e0: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026e3: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026e6: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026ed: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026f0: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801026f3: c7 80 80 02 00 00 00 movl $0x0,0x280(%eax)
801026fa: 00 00 00
lapic[ID]; // wait for write to finish, by reading
801026fd: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
80102700: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
80102707: 00 00 00
lapic[ID]; // wait for write to finish, by reading
8010270a: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010270d: c7 80 10 03 00 00 00 movl $0x0,0x310(%eax)
80102714: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102717: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010271a: c7 80 00 03 00 00 00 movl $0x88500,0x300(%eax)
80102721: 85 08 00
lapic[ID]; // wait for write to finish, by reading
80102724: 8b 50 20 mov 0x20(%eax),%edx
80102727: 90 nop
while(lapic[ICRLO] & DELIVS)
80102728: 8b 90 00 03 00 00 mov 0x300(%eax),%edx
8010272e: 80 e6 10 and $0x10,%dh
80102731: 75 f5 jne 80102728 <lapicinit+0xb8>
lapic[index] = value;
80102733: c7 80 80 00 00 00 00 movl $0x0,0x80(%eax)
8010273a: 00 00 00
lapic[ID]; // wait for write to finish, by reading
8010273d: 8b 40 20 mov 0x20(%eax),%eax
}
80102740: 5d pop %ebp
80102741: c3 ret
80102742: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
lapic[index] = value;
80102748: c7 80 40 03 00 00 00 movl $0x10000,0x340(%eax)
8010274f: 00 01 00
lapic[ID]; // wait for write to finish, by reading
80102752: 8b 50 20 mov 0x20(%eax),%edx
80102755: eb 82 jmp 801026d9 <lapicinit+0x69>
80102757: 89 f6 mov %esi,%esi
80102759: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102760 <lapicid>:
if (!lapic)
80102760: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102765: 55 push %ebp
80102766: 89 e5 mov %esp,%ebp
if (!lapic)
80102768: 85 c0 test %eax,%eax
8010276a: 74 0c je 80102778 <lapicid+0x18>
return lapic[ID] >> 24;
8010276c: 8b 40 20 mov 0x20(%eax),%eax
}
8010276f: 5d pop %ebp
return lapic[ID] >> 24;
80102770: c1 e8 18 shr $0x18,%eax
}
80102773: c3 ret
80102774: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80102778: 31 c0 xor %eax,%eax
}
8010277a: 5d pop %ebp
8010277b: c3 ret
8010277c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102780 <lapiceoi>:
if(lapic)
80102780: a1 7c 26 11 80 mov 0x8011267c,%eax
{
80102785: 55 push %ebp
80102786: 89 e5 mov %esp,%ebp
if(lapic)
80102788: 85 c0 test %eax,%eax
8010278a: 74 0d je 80102799 <lapiceoi+0x19>
lapic[index] = value;
8010278c: c7 80 b0 00 00 00 00 movl $0x0,0xb0(%eax)
80102793: 00 00 00
lapic[ID]; // wait for write to finish, by reading
80102796: 8b 40 20 mov 0x20(%eax),%eax
}
80102799: 5d pop %ebp
8010279a: c3 ret
8010279b: 90 nop
8010279c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801027a0 <microdelay>:
{
801027a0: 55 push %ebp
801027a1: 89 e5 mov %esp,%ebp
}
801027a3: 5d pop %ebp
801027a4: c3 ret
801027a5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801027a9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801027b0 <lapicstartap>:
{
801027b0: 55 push %ebp
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801027b1: ba 70 00 00 00 mov $0x70,%edx
801027b6: 89 e5 mov %esp,%ebp
801027b8: b8 0f 00 00 00 mov $0xf,%eax
801027bd: 53 push %ebx
801027be: 8b 4d 08 mov 0x8(%ebp),%ecx
801027c1: 8b 5d 0c mov 0xc(%ebp),%ebx
801027c4: ee out %al,(%dx)
801027c5: b8 0a 00 00 00 mov $0xa,%eax
801027ca: b2 71 mov $0x71,%dl
801027cc: ee out %al,(%dx)
wrv[0] = 0;
801027cd: 31 c0 xor %eax,%eax
801027cf: 66 a3 67 04 00 80 mov %ax,0x80000467
wrv[1] = addr >> 4;
801027d5: 89 d8 mov %ebx,%eax
801027d7: c1 e8 04 shr $0x4,%eax
801027da: 66 a3 69 04 00 80 mov %ax,0x80000469
lapic[index] = value;
801027e0: a1 7c 26 11 80 mov 0x8011267c,%eax
lapicw(ICRHI, apicid<<24);
801027e5: c1 e1 18 shl $0x18,%ecx
lapicw(ICRLO, STARTUP | (addr>>12));
801027e8: c1 eb 0c shr $0xc,%ebx
lapic[index] = value;
801027eb: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
801027f1: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
801027f4: c7 80 00 03 00 00 00 movl $0xc500,0x300(%eax)
801027fb: c5 00 00
lapic[ID]; // wait for write to finish, by reading
801027fe: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
80102801: c7 80 00 03 00 00 00 movl $0x8500,0x300(%eax)
80102808: 85 00 00
lapic[ID]; // wait for write to finish, by reading
8010280b: 8b 50 20 mov 0x20(%eax),%edx
lapic[index] = value;
8010280e: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
80102814: 8b 50 20 mov 0x20(%eax),%edx
lapicw(ICRLO, STARTUP | (addr>>12));
80102817: 89 da mov %ebx,%edx
80102819: 80 ce 06 or $0x6,%dh
lapic[index] = value;
8010281c: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102822: 8b 58 20 mov 0x20(%eax),%ebx
lapic[index] = value;
80102825: 89 88 10 03 00 00 mov %ecx,0x310(%eax)
lapic[ID]; // wait for write to finish, by reading
8010282b: 8b 48 20 mov 0x20(%eax),%ecx
lapic[index] = value;
8010282e: 89 90 00 03 00 00 mov %edx,0x300(%eax)
lapic[ID]; // wait for write to finish, by reading
80102834: 8b 40 20 mov 0x20(%eax),%eax
}
80102837: 5b pop %ebx
80102838: 5d pop %ebp
80102839: c3 ret
8010283a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102840 <cmostime>:
// qemu seems to use 24-hour GWT and the values are BCD encoded
void cmostime(struct rtcdate *r)
{
80102840: 55 push %ebp
80102841: ba 70 00 00 00 mov $0x70,%edx
80102846: 89 e5 mov %esp,%ebp
80102848: b8 0b 00 00 00 mov $0xb,%eax
8010284d: 57 push %edi
8010284e: 56 push %esi
8010284f: 53 push %ebx
80102850: 83 ec 4c sub $0x4c,%esp
80102853: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
80102854: b2 71 mov $0x71,%dl
80102856: ec in (%dx),%al
80102857: 88 45 b7 mov %al,-0x49(%ebp)
8010285a: 8d 5d b8 lea -0x48(%ebp),%ebx
struct rtcdate t1, t2;
int sb, bcd;
sb = cmos_read(CMOS_STATB);
bcd = (sb & (1 << 2)) == 0;
8010285d: 80 65 b7 04 andb $0x4,-0x49(%ebp)
80102861: 8d 7d d0 lea -0x30(%ebp),%edi
80102864: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
asm volatile("out %0,%1" : : "a" (data), "d" (port));
80102868: be 70 00 00 00 mov $0x70,%esi
// make sure CMOS doesn't modify time while we read it
for(;;) {
fill_rtcdate(&t1);
8010286d: 89 d8 mov %ebx,%eax
8010286f: e8 7c fd ff ff call 801025f0 <fill_rtcdate>
80102874: b8 0a 00 00 00 mov $0xa,%eax
80102879: 89 f2 mov %esi,%edx
8010287b: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010287c: ba 71 00 00 00 mov $0x71,%edx
80102881: ec in (%dx),%al
if(cmos_read(CMOS_STATA) & CMOS_UIP)
80102882: 84 c0 test %al,%al
80102884: 78 e7 js 8010286d <cmostime+0x2d>
continue;
fill_rtcdate(&t2);
80102886: 89 f8 mov %edi,%eax
80102888: e8 63 fd ff ff call 801025f0 <fill_rtcdate>
if(memcmp(&t1, &t2, sizeof(t1)) == 0)
8010288d: c7 44 24 08 18 00 00 movl $0x18,0x8(%esp)
80102894: 00
80102895: 89 7c 24 04 mov %edi,0x4(%esp)
80102899: 89 1c 24 mov %ebx,(%esp)
8010289c: e8 2f 1a 00 00 call 801042d0 <memcmp>
801028a1: 85 c0 test %eax,%eax
801028a3: 75 c3 jne 80102868 <cmostime+0x28>
break;
}
// convert
if(bcd) {
801028a5: 80 7d b7 00 cmpb $0x0,-0x49(%ebp)
801028a9: 75 78 jne 80102923 <cmostime+0xe3>
#define CONV(x) (t1.x = ((t1.x >> 4) * 10) + (t1.x & 0xf))
CONV(second);
801028ab: 8b 45 b8 mov -0x48(%ebp),%eax
801028ae: 89 c2 mov %eax,%edx
801028b0: 83 e0 0f and $0xf,%eax
801028b3: c1 ea 04 shr $0x4,%edx
801028b6: 8d 14 92 lea (%edx,%edx,4),%edx
801028b9: 8d 04 50 lea (%eax,%edx,2),%eax
801028bc: 89 45 b8 mov %eax,-0x48(%ebp)
CONV(minute);
801028bf: 8b 45 bc mov -0x44(%ebp),%eax
801028c2: 89 c2 mov %eax,%edx
801028c4: 83 e0 0f and $0xf,%eax
801028c7: c1 ea 04 shr $0x4,%edx
801028ca: 8d 14 92 lea (%edx,%edx,4),%edx
801028cd: 8d 04 50 lea (%eax,%edx,2),%eax
801028d0: 89 45 bc mov %eax,-0x44(%ebp)
CONV(hour );
801028d3: 8b 45 c0 mov -0x40(%ebp),%eax
801028d6: 89 c2 mov %eax,%edx
801028d8: 83 e0 0f and $0xf,%eax
801028db: c1 ea 04 shr $0x4,%edx
801028de: 8d 14 92 lea (%edx,%edx,4),%edx
801028e1: 8d 04 50 lea (%eax,%edx,2),%eax
801028e4: 89 45 c0 mov %eax,-0x40(%ebp)
CONV(day );
801028e7: 8b 45 c4 mov -0x3c(%ebp),%eax
801028ea: 89 c2 mov %eax,%edx
801028ec: 83 e0 0f and $0xf,%eax
801028ef: c1 ea 04 shr $0x4,%edx
801028f2: 8d 14 92 lea (%edx,%edx,4),%edx
801028f5: 8d 04 50 lea (%eax,%edx,2),%eax
801028f8: 89 45 c4 mov %eax,-0x3c(%ebp)
CONV(month );
801028fb: 8b 45 c8 mov -0x38(%ebp),%eax
801028fe: 89 c2 mov %eax,%edx
80102900: 83 e0 0f and $0xf,%eax
80102903: c1 ea 04 shr $0x4,%edx
80102906: 8d 14 92 lea (%edx,%edx,4),%edx
80102909: 8d 04 50 lea (%eax,%edx,2),%eax
8010290c: 89 45 c8 mov %eax,-0x38(%ebp)
CONV(year );
8010290f: 8b 45 cc mov -0x34(%ebp),%eax
80102912: 89 c2 mov %eax,%edx
80102914: 83 e0 0f and $0xf,%eax
80102917: c1 ea 04 shr $0x4,%edx
8010291a: 8d 14 92 lea (%edx,%edx,4),%edx
8010291d: 8d 04 50 lea (%eax,%edx,2),%eax
80102920: 89 45 cc mov %eax,-0x34(%ebp)
#undef CONV
}
*r = t1;
80102923: 8b 4d 08 mov 0x8(%ebp),%ecx
80102926: 8b 45 b8 mov -0x48(%ebp),%eax
80102929: 89 01 mov %eax,(%ecx)
8010292b: 8b 45 bc mov -0x44(%ebp),%eax
8010292e: 89 41 04 mov %eax,0x4(%ecx)
80102931: 8b 45 c0 mov -0x40(%ebp),%eax
80102934: 89 41 08 mov %eax,0x8(%ecx)
80102937: 8b 45 c4 mov -0x3c(%ebp),%eax
8010293a: 89 41 0c mov %eax,0xc(%ecx)
8010293d: 8b 45 c8 mov -0x38(%ebp),%eax
80102940: 89 41 10 mov %eax,0x10(%ecx)
80102943: 8b 45 cc mov -0x34(%ebp),%eax
80102946: 89 41 14 mov %eax,0x14(%ecx)
r->year += 2000;
80102949: 81 41 14 d0 07 00 00 addl $0x7d0,0x14(%ecx)
}
80102950: 83 c4 4c add $0x4c,%esp
80102953: 5b pop %ebx
80102954: 5e pop %esi
80102955: 5f pop %edi
80102956: 5d pop %ebp
80102957: c3 ret
80102958: 66 90 xchg %ax,%ax
8010295a: 66 90 xchg %ax,%ax
8010295c: 66 90 xchg %ax,%ax
8010295e: 66 90 xchg %ax,%ax
80102960 <install_trans>:
}
// Copy committed blocks from log to their home location
static void
install_trans(void)
{
80102960: 55 push %ebp
80102961: 89 e5 mov %esp,%ebp
80102963: 57 push %edi
80102964: 56 push %esi
80102965: 53 push %ebx
int tail;
for (tail = 0; tail < log.lh.n; tail++) {
80102966: 31 db xor %ebx,%ebx
{
80102968: 83 ec 1c sub $0x1c,%esp
for (tail = 0; tail < log.lh.n; tail++) {
8010296b: a1 c8 26 11 80 mov 0x801126c8,%eax
80102970: 85 c0 test %eax,%eax
80102972: 7e 78 jle 801029ec <install_trans+0x8c>
80102974: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
struct buf *lbuf = bread(log.dev, log.start+tail+1); // read log block
80102978: a1 b4 26 11 80 mov 0x801126b4,%eax
8010297d: 01 d8 add %ebx,%eax
8010297f: 83 c0 01 add $0x1,%eax
80102982: 89 44 24 04 mov %eax,0x4(%esp)
80102986: a1 c4 26 11 80 mov 0x801126c4,%eax
8010298b: 89 04 24 mov %eax,(%esp)
8010298e: e8 3d d7 ff ff call 801000d0 <bread>
80102993: 89 c7 mov %eax,%edi
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
80102995: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
8010299c: 83 c3 01 add $0x1,%ebx
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
8010299f: 89 44 24 04 mov %eax,0x4(%esp)
801029a3: a1 c4 26 11 80 mov 0x801126c4,%eax
801029a8: 89 04 24 mov %eax,(%esp)
801029ab: e8 20 d7 ff ff call 801000d0 <bread>
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029b0: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
801029b7: 00
struct buf *dbuf = bread(log.dev, log.lh.block[tail]); // read dst
801029b8: 89 c6 mov %eax,%esi
memmove(dbuf->data, lbuf->data, BSIZE); // copy block to dst
801029ba: 8d 47 5c lea 0x5c(%edi),%eax
801029bd: 89 44 24 04 mov %eax,0x4(%esp)
801029c1: 8d 46 5c lea 0x5c(%esi),%eax
801029c4: 89 04 24 mov %eax,(%esp)
801029c7: e8 54 19 00 00 call 80104320 <memmove>
bwrite(dbuf); // write dst to disk
801029cc: 89 34 24 mov %esi,(%esp)
801029cf: e8 cc d7 ff ff call 801001a0 <bwrite>
brelse(lbuf);
801029d4: 89 3c 24 mov %edi,(%esp)
801029d7: e8 04 d8 ff ff call 801001e0 <brelse>
brelse(dbuf);
801029dc: 89 34 24 mov %esi,(%esp)
801029df: e8 fc d7 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
801029e4: 39 1d c8 26 11 80 cmp %ebx,0x801126c8
801029ea: 7f 8c jg 80102978 <install_trans+0x18>
}
}
801029ec: 83 c4 1c add $0x1c,%esp
801029ef: 5b pop %ebx
801029f0: 5e pop %esi
801029f1: 5f pop %edi
801029f2: 5d pop %ebp
801029f3: c3 ret
801029f4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801029fa: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80102a00 <write_head>:
// Write in-memory log header to disk.
// This is the true point at which the
// current transaction commits.
static void
write_head(void)
{
80102a00: 55 push %ebp
80102a01: 89 e5 mov %esp,%ebp
80102a03: 57 push %edi
80102a04: 56 push %esi
80102a05: 53 push %ebx
80102a06: 83 ec 1c sub $0x1c,%esp
struct buf *buf = bread(log.dev, log.start);
80102a09: a1 b4 26 11 80 mov 0x801126b4,%eax
80102a0e: 89 44 24 04 mov %eax,0x4(%esp)
80102a12: a1 c4 26 11 80 mov 0x801126c4,%eax
80102a17: 89 04 24 mov %eax,(%esp)
80102a1a: e8 b1 d6 ff ff call 801000d0 <bread>
struct logheader *hb = (struct logheader *) (buf->data);
int i;
hb->n = log.lh.n;
80102a1f: 8b 1d c8 26 11 80 mov 0x801126c8,%ebx
for (i = 0; i < log.lh.n; i++) {
80102a25: 31 d2 xor %edx,%edx
80102a27: 85 db test %ebx,%ebx
struct buf *buf = bread(log.dev, log.start);
80102a29: 89 c7 mov %eax,%edi
hb->n = log.lh.n;
80102a2b: 89 58 5c mov %ebx,0x5c(%eax)
80102a2e: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102a31: 7e 17 jle 80102a4a <write_head+0x4a>
80102a33: 90 nop
80102a34: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
hb->block[i] = log.lh.block[i];
80102a38: 8b 0c 95 cc 26 11 80 mov -0x7feed934(,%edx,4),%ecx
80102a3f: 89 4c 96 04 mov %ecx,0x4(%esi,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102a43: 83 c2 01 add $0x1,%edx
80102a46: 39 da cmp %ebx,%edx
80102a48: 75 ee jne 80102a38 <write_head+0x38>
}
bwrite(buf);
80102a4a: 89 3c 24 mov %edi,(%esp)
80102a4d: e8 4e d7 ff ff call 801001a0 <bwrite>
brelse(buf);
80102a52: 89 3c 24 mov %edi,(%esp)
80102a55: e8 86 d7 ff ff call 801001e0 <brelse>
}
80102a5a: 83 c4 1c add $0x1c,%esp
80102a5d: 5b pop %ebx
80102a5e: 5e pop %esi
80102a5f: 5f pop %edi
80102a60: 5d pop %ebp
80102a61: c3 ret
80102a62: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80102a69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102a70 <initlog>:
{
80102a70: 55 push %ebp
80102a71: 89 e5 mov %esp,%ebp
80102a73: 56 push %esi
80102a74: 53 push %ebx
80102a75: 83 ec 30 sub $0x30,%esp
80102a78: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&log.lock, "log");
80102a7b: c7 44 24 04 20 73 10 movl $0x80107320,0x4(%esp)
80102a82: 80
80102a83: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102a8a: e8 c1 15 00 00 call 80104050 <initlock>
readsb(dev, &sb);
80102a8f: 8d 45 dc lea -0x24(%ebp),%eax
80102a92: 89 44 24 04 mov %eax,0x4(%esp)
80102a96: 89 1c 24 mov %ebx,(%esp)
80102a99: e8 f2 e8 ff ff call 80101390 <readsb>
log.start = sb.logstart;
80102a9e: 8b 45 ec mov -0x14(%ebp),%eax
log.size = sb.nlog;
80102aa1: 8b 55 e8 mov -0x18(%ebp),%edx
struct buf *buf = bread(log.dev, log.start);
80102aa4: 89 1c 24 mov %ebx,(%esp)
log.dev = dev;
80102aa7: 89 1d c4 26 11 80 mov %ebx,0x801126c4
struct buf *buf = bread(log.dev, log.start);
80102aad: 89 44 24 04 mov %eax,0x4(%esp)
log.size = sb.nlog;
80102ab1: 89 15 b8 26 11 80 mov %edx,0x801126b8
log.start = sb.logstart;
80102ab7: a3 b4 26 11 80 mov %eax,0x801126b4
struct buf *buf = bread(log.dev, log.start);
80102abc: e8 0f d6 ff ff call 801000d0 <bread>
for (i = 0; i < log.lh.n; i++) {
80102ac1: 31 d2 xor %edx,%edx
log.lh.n = lh->n;
80102ac3: 8b 58 5c mov 0x5c(%eax),%ebx
80102ac6: 8d 70 5c lea 0x5c(%eax),%esi
for (i = 0; i < log.lh.n; i++) {
80102ac9: 85 db test %ebx,%ebx
log.lh.n = lh->n;
80102acb: 89 1d c8 26 11 80 mov %ebx,0x801126c8
for (i = 0; i < log.lh.n; i++) {
80102ad1: 7e 17 jle 80102aea <initlog+0x7a>
80102ad3: 90 nop
80102ad4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = lh->block[i];
80102ad8: 8b 4c 96 04 mov 0x4(%esi,%edx,4),%ecx
80102adc: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
for (i = 0; i < log.lh.n; i++) {
80102ae3: 83 c2 01 add $0x1,%edx
80102ae6: 39 da cmp %ebx,%edx
80102ae8: 75 ee jne 80102ad8 <initlog+0x68>
brelse(buf);
80102aea: 89 04 24 mov %eax,(%esp)
80102aed: e8 ee d6 ff ff call 801001e0 <brelse>
static void
recover_from_log(void)
{
read_head();
install_trans(); // if committed, copy from log to disk
80102af2: e8 69 fe ff ff call 80102960 <install_trans>
log.lh.n = 0;
80102af7: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102afe: 00 00 00
write_head(); // clear the log
80102b01: e8 fa fe ff ff call 80102a00 <write_head>
}
80102b06: 83 c4 30 add $0x30,%esp
80102b09: 5b pop %ebx
80102b0a: 5e pop %esi
80102b0b: 5d pop %ebp
80102b0c: c3 ret
80102b0d: 8d 76 00 lea 0x0(%esi),%esi
80102b10 <begin_op>:
}
// called at the start of each FS system call.
void
begin_op(void)
{
80102b10: 55 push %ebp
80102b11: 89 e5 mov %esp,%ebp
80102b13: 83 ec 18 sub $0x18,%esp
acquire(&log.lock);
80102b16: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b1d: e8 1e 16 00 00 call 80104140 <acquire>
80102b22: eb 18 jmp 80102b3c <begin_op+0x2c>
80102b24: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(1){
if(log.committing){
sleep(&log, &log.lock);
80102b28: c7 44 24 04 80 26 11 movl $0x80112680,0x4(%esp)
80102b2f: 80
80102b30: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b37: e8 c4 10 00 00 call 80103c00 <sleep>
if(log.committing){
80102b3c: a1 c0 26 11 80 mov 0x801126c0,%eax
80102b41: 85 c0 test %eax,%eax
80102b43: 75 e3 jne 80102b28 <begin_op+0x18>
} else if(log.lh.n + (log.outstanding+1)*MAXOPBLOCKS > LOGSIZE){
80102b45: a1 bc 26 11 80 mov 0x801126bc,%eax
80102b4a: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102b50: 83 c0 01 add $0x1,%eax
80102b53: 8d 0c 80 lea (%eax,%eax,4),%ecx
80102b56: 8d 14 4a lea (%edx,%ecx,2),%edx
80102b59: 83 fa 1e cmp $0x1e,%edx
80102b5c: 7f ca jg 80102b28 <begin_op+0x18>
// this op might exhaust log space; wait for commit.
sleep(&log, &log.lock);
} else {
log.outstanding += 1;
release(&log.lock);
80102b5e: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
log.outstanding += 1;
80102b65: a3 bc 26 11 80 mov %eax,0x801126bc
release(&log.lock);
80102b6a: e8 c1 16 00 00 call 80104230 <release>
break;
}
}
}
80102b6f: c9 leave
80102b70: c3 ret
80102b71: eb 0d jmp 80102b80 <end_op>
80102b73: 90 nop
80102b74: 90 nop
80102b75: 90 nop
80102b76: 90 nop
80102b77: 90 nop
80102b78: 90 nop
80102b79: 90 nop
80102b7a: 90 nop
80102b7b: 90 nop
80102b7c: 90 nop
80102b7d: 90 nop
80102b7e: 90 nop
80102b7f: 90 nop
80102b80 <end_op>:
// called at the end of each FS system call.
// commits if this was the last outstanding operation.
void
end_op(void)
{
80102b80: 55 push %ebp
80102b81: 89 e5 mov %esp,%ebp
80102b83: 57 push %edi
80102b84: 56 push %esi
80102b85: 53 push %ebx
80102b86: 83 ec 1c sub $0x1c,%esp
int do_commit = 0;
acquire(&log.lock);
80102b89: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102b90: e8 ab 15 00 00 call 80104140 <acquire>
log.outstanding -= 1;
80102b95: a1 bc 26 11 80 mov 0x801126bc,%eax
if(log.committing)
80102b9a: 8b 15 c0 26 11 80 mov 0x801126c0,%edx
log.outstanding -= 1;
80102ba0: 83 e8 01 sub $0x1,%eax
if(log.committing)
80102ba3: 85 d2 test %edx,%edx
log.outstanding -= 1;
80102ba5: a3 bc 26 11 80 mov %eax,0x801126bc
if(log.committing)
80102baa: 0f 85 f3 00 00 00 jne 80102ca3 <end_op+0x123>
panic("log.committing");
if(log.outstanding == 0){
80102bb0: 85 c0 test %eax,%eax
80102bb2: 0f 85 cb 00 00 00 jne 80102c83 <end_op+0x103>
// begin_op() may be waiting for log space,
// and decrementing log.outstanding has decreased
// the amount of reserved space.
wakeup(&log);
}
release(&log.lock);
80102bb8: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
}
static void
commit()
{
if (log.lh.n > 0) {
80102bbf: 31 db xor %ebx,%ebx
log.committing = 1;
80102bc1: c7 05 c0 26 11 80 01 movl $0x1,0x801126c0
80102bc8: 00 00 00
release(&log.lock);
80102bcb: e8 60 16 00 00 call 80104230 <release>
if (log.lh.n > 0) {
80102bd0: a1 c8 26 11 80 mov 0x801126c8,%eax
80102bd5: 85 c0 test %eax,%eax
80102bd7: 0f 8e 90 00 00 00 jle 80102c6d <end_op+0xed>
80102bdd: 8d 76 00 lea 0x0(%esi),%esi
struct buf *to = bread(log.dev, log.start+tail+1); // log block
80102be0: a1 b4 26 11 80 mov 0x801126b4,%eax
80102be5: 01 d8 add %ebx,%eax
80102be7: 83 c0 01 add $0x1,%eax
80102bea: 89 44 24 04 mov %eax,0x4(%esp)
80102bee: a1 c4 26 11 80 mov 0x801126c4,%eax
80102bf3: 89 04 24 mov %eax,(%esp)
80102bf6: e8 d5 d4 ff ff call 801000d0 <bread>
80102bfb: 89 c6 mov %eax,%esi
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102bfd: 8b 04 9d cc 26 11 80 mov -0x7feed934(,%ebx,4),%eax
for (tail = 0; tail < log.lh.n; tail++) {
80102c04: 83 c3 01 add $0x1,%ebx
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102c07: 89 44 24 04 mov %eax,0x4(%esp)
80102c0b: a1 c4 26 11 80 mov 0x801126c4,%eax
80102c10: 89 04 24 mov %eax,(%esp)
80102c13: e8 b8 d4 ff ff call 801000d0 <bread>
memmove(to->data, from->data, BSIZE);
80102c18: c7 44 24 08 00 02 00 movl $0x200,0x8(%esp)
80102c1f: 00
struct buf *from = bread(log.dev, log.lh.block[tail]); // cache block
80102c20: 89 c7 mov %eax,%edi
memmove(to->data, from->data, BSIZE);
80102c22: 8d 40 5c lea 0x5c(%eax),%eax
80102c25: 89 44 24 04 mov %eax,0x4(%esp)
80102c29: 8d 46 5c lea 0x5c(%esi),%eax
80102c2c: 89 04 24 mov %eax,(%esp)
80102c2f: e8 ec 16 00 00 call 80104320 <memmove>
bwrite(to); // write the log
80102c34: 89 34 24 mov %esi,(%esp)
80102c37: e8 64 d5 ff ff call 801001a0 <bwrite>
brelse(from);
80102c3c: 89 3c 24 mov %edi,(%esp)
80102c3f: e8 9c d5 ff ff call 801001e0 <brelse>
brelse(to);
80102c44: 89 34 24 mov %esi,(%esp)
80102c47: e8 94 d5 ff ff call 801001e0 <brelse>
for (tail = 0; tail < log.lh.n; tail++) {
80102c4c: 3b 1d c8 26 11 80 cmp 0x801126c8,%ebx
80102c52: 7c 8c jl 80102be0 <end_op+0x60>
write_log(); // Write modified blocks from cache to log
write_head(); // Write header to disk -- the real commit
80102c54: e8 a7 fd ff ff call 80102a00 <write_head>
install_trans(); // Now install writes to home locations
80102c59: e8 02 fd ff ff call 80102960 <install_trans>
log.lh.n = 0;
80102c5e: c7 05 c8 26 11 80 00 movl $0x0,0x801126c8
80102c65: 00 00 00
write_head(); // Erase the transaction from the log
80102c68: e8 93 fd ff ff call 80102a00 <write_head>
acquire(&log.lock);
80102c6d: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c74: e8 c7 14 00 00 call 80104140 <acquire>
log.committing = 0;
80102c79: c7 05 c0 26 11 80 00 movl $0x0,0x801126c0
80102c80: 00 00 00
wakeup(&log);
80102c83: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c8a: e8 01 11 00 00 call 80103d90 <wakeup>
release(&log.lock);
80102c8f: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102c96: e8 95 15 00 00 call 80104230 <release>
}
80102c9b: 83 c4 1c add $0x1c,%esp
80102c9e: 5b pop %ebx
80102c9f: 5e pop %esi
80102ca0: 5f pop %edi
80102ca1: 5d pop %ebp
80102ca2: c3 ret
panic("log.committing");
80102ca3: c7 04 24 24 73 10 80 movl $0x80107324,(%esp)
80102caa: e8 b1 d6 ff ff call 80100360 <panic>
80102caf: 90 nop
80102cb0 <log_write>:
// modify bp->data[]
// log_write(bp)
// brelse(bp)
void
log_write(struct buf *b)
{
80102cb0: 55 push %ebp
80102cb1: 89 e5 mov %esp,%ebp
80102cb3: 53 push %ebx
80102cb4: 83 ec 14 sub $0x14,%esp
int i;
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102cb7: a1 c8 26 11 80 mov 0x801126c8,%eax
{
80102cbc: 8b 5d 08 mov 0x8(%ebp),%ebx
if (log.lh.n >= LOGSIZE || log.lh.n >= log.size - 1)
80102cbf: 83 f8 1d cmp $0x1d,%eax
80102cc2: 0f 8f 98 00 00 00 jg 80102d60 <log_write+0xb0>
80102cc8: 8b 0d b8 26 11 80 mov 0x801126b8,%ecx
80102cce: 8d 51 ff lea -0x1(%ecx),%edx
80102cd1: 39 d0 cmp %edx,%eax
80102cd3: 0f 8d 87 00 00 00 jge 80102d60 <log_write+0xb0>
panic("too big a transaction");
if (log.outstanding < 1)
80102cd9: a1 bc 26 11 80 mov 0x801126bc,%eax
80102cde: 85 c0 test %eax,%eax
80102ce0: 0f 8e 86 00 00 00 jle 80102d6c <log_write+0xbc>
panic("log_write outside of trans");
acquire(&log.lock);
80102ce6: c7 04 24 80 26 11 80 movl $0x80112680,(%esp)
80102ced: e8 4e 14 00 00 call 80104140 <acquire>
for (i = 0; i < log.lh.n; i++) {
80102cf2: 8b 15 c8 26 11 80 mov 0x801126c8,%edx
80102cf8: 83 fa 00 cmp $0x0,%edx
80102cfb: 7e 54 jle 80102d51 <log_write+0xa1>
if (log.lh.block[i] == b->blockno) // log absorbtion
80102cfd: 8b 4b 08 mov 0x8(%ebx),%ecx
for (i = 0; i < log.lh.n; i++) {
80102d00: 31 c0 xor %eax,%eax
if (log.lh.block[i] == b->blockno) // log absorbtion
80102d02: 39 0d cc 26 11 80 cmp %ecx,0x801126cc
80102d08: 75 0f jne 80102d19 <log_write+0x69>
80102d0a: eb 3c jmp 80102d48 <log_write+0x98>
80102d0c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80102d10: 39 0c 85 cc 26 11 80 cmp %ecx,-0x7feed934(,%eax,4)
80102d17: 74 2f je 80102d48 <log_write+0x98>
for (i = 0; i < log.lh.n; i++) {
80102d19: 83 c0 01 add $0x1,%eax
80102d1c: 39 d0 cmp %edx,%eax
80102d1e: 75 f0 jne 80102d10 <log_write+0x60>
break;
}
log.lh.block[i] = b->blockno;
80102d20: 89 0c 95 cc 26 11 80 mov %ecx,-0x7feed934(,%edx,4)
if (i == log.lh.n)
log.lh.n++;
80102d27: 83 c2 01 add $0x1,%edx
80102d2a: 89 15 c8 26 11 80 mov %edx,0x801126c8
b->flags |= B_DIRTY; // prevent eviction
80102d30: 83 0b 04 orl $0x4,(%ebx)
release(&log.lock);
80102d33: c7 45 08 80 26 11 80 movl $0x80112680,0x8(%ebp)
}
80102d3a: 83 c4 14 add $0x14,%esp
80102d3d: 5b pop %ebx
80102d3e: 5d pop %ebp
release(&log.lock);
80102d3f: e9 ec 14 00 00 jmp 80104230 <release>
80102d44: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
log.lh.block[i] = b->blockno;
80102d48: 89 0c 85 cc 26 11 80 mov %ecx,-0x7feed934(,%eax,4)
80102d4f: eb df jmp 80102d30 <log_write+0x80>
80102d51: 8b 43 08 mov 0x8(%ebx),%eax
80102d54: a3 cc 26 11 80 mov %eax,0x801126cc
if (i == log.lh.n)
80102d59: 75 d5 jne 80102d30 <log_write+0x80>
80102d5b: eb ca jmp 80102d27 <log_write+0x77>
80102d5d: 8d 76 00 lea 0x0(%esi),%esi
panic("too big a transaction");
80102d60: c7 04 24 33 73 10 80 movl $0x80107333,(%esp)
80102d67: e8 f4 d5 ff ff call 80100360 <panic>
panic("log_write outside of trans");
80102d6c: c7 04 24 49 73 10 80 movl $0x80107349,(%esp)
80102d73: e8 e8 d5 ff ff call 80100360 <panic>
80102d78: 66 90 xchg %ax,%ax
80102d7a: 66 90 xchg %ax,%ax
80102d7c: 66 90 xchg %ax,%ax
80102d7e: 66 90 xchg %ax,%ax
80102d80 <mpmain>:
}
// Common CPU setup code.
static void
mpmain(void)
{
80102d80: 55 push %ebp
80102d81: 89 e5 mov %esp,%ebp
80102d83: 53 push %ebx
80102d84: 83 ec 14 sub $0x14,%esp
cprintf("cpu%d: starting %d\n", cpuid(), cpuid());
80102d87: e8 f4 08 00 00 call 80103680 <cpuid>
80102d8c: 89 c3 mov %eax,%ebx
80102d8e: e8 ed 08 00 00 call 80103680 <cpuid>
80102d93: 89 5c 24 08 mov %ebx,0x8(%esp)
80102d97: c7 04 24 64 73 10 80 movl $0x80107364,(%esp)
80102d9e: 89 44 24 04 mov %eax,0x4(%esp)
80102da2: e8 a9 d8 ff ff call 80100650 <cprintf>
idtinit(); // load idt register
80102da7: e8 34 27 00 00 call 801054e0 <idtinit>
xchg(&(mycpu()->started), 1); // tell startothers() we're up
80102dac: e8 4f 08 00 00 call 80103600 <mycpu>
80102db1: 89 c2 mov %eax,%edx
xchg(volatile uint *addr, uint newval)
{
uint result;
// The + in "+m" denotes a read-modify-write operand.
asm volatile("lock; xchgl %0, %1" :
80102db3: b8 01 00 00 00 mov $0x1,%eax
80102db8: f0 87 82 a0 00 00 00 lock xchg %eax,0xa0(%edx)
scheduler(); // start running processes
80102dbf: e8 9c 0b 00 00 call 80103960 <scheduler>
80102dc4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102dca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80102dd0 <mpenter>:
{
80102dd0: 55 push %ebp
80102dd1: 89 e5 mov %esp,%ebp
80102dd3: 83 ec 08 sub $0x8,%esp
switchkvm();
80102dd6: e8 75 38 00 00 call 80106650 <switchkvm>
seginit();
80102ddb: e8 30 37 00 00 call 80106510 <seginit>
lapicinit();
80102de0: e8 8b f8 ff ff call 80102670 <lapicinit>
mpmain();
80102de5: e8 96 ff ff ff call 80102d80 <mpmain>
80102dea: 66 90 xchg %ax,%ax
80102dec: 66 90 xchg %ax,%ax
80102dee: 66 90 xchg %ax,%ax
80102df0 <main>:
{
80102df0: 55 push %ebp
80102df1: 89 e5 mov %esp,%ebp
80102df3: 53 push %ebx
// The linker has placed the image of entryother.S in
// _binary_entryother_start.
code = P2V(0x7000);
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
for(c = cpus; c < cpus+ncpu; c++){
80102df4: bb 80 27 11 80 mov $0x80112780,%ebx
{
80102df9: 83 e4 f0 and $0xfffffff0,%esp
80102dfc: 83 ec 10 sub $0x10,%esp
kinit1(end, P2V(4*1024*1024)); // phys page allocator
80102dff: c7 44 24 04 00 00 40 movl $0x80400000,0x4(%esp)
80102e06: 80
80102e07: c7 04 24 f4 58 11 80 movl $0x801158f4,(%esp)
80102e0e: e8 cd f5 ff ff call 801023e0 <kinit1>
kvmalloc(); // kernel page table
80102e13: e8 e8 3c 00 00 call 80106b00 <kvmalloc>
mpinit(); // detect other processors
80102e18: e8 73 01 00 00 call 80102f90 <mpinit>
80102e1d: 8d 76 00 lea 0x0(%esi),%esi
lapicinit(); // interrupt controller
80102e20: e8 4b f8 ff ff call 80102670 <lapicinit>
seginit(); // segment descriptors
80102e25: e8 e6 36 00 00 call 80106510 <seginit>
picinit(); // disable pic
80102e2a: e8 21 03 00 00 call 80103150 <picinit>
80102e2f: 90 nop
ioapicinit(); // another interrupt controller
80102e30: e8 cb f3 ff ff call 80102200 <ioapicinit>
consoleinit(); // console hardware
80102e35: e8 16 db ff ff call 80100950 <consoleinit>
uartinit(); // serial port
80102e3a: e8 71 2a 00 00 call 801058b0 <uartinit>
80102e3f: 90 nop
pinit(); // process table
80102e40: e8 9b 07 00 00 call 801035e0 <pinit>
shminit(); // shared memory
80102e45: e8 86 3f 00 00 call 80106dd0 <shminit>
tvinit(); // trap vectors
80102e4a: e8 f1 25 00 00 call 80105440 <tvinit>
80102e4f: 90 nop
binit(); // buffer cache
80102e50: e8 eb d1 ff ff call 80100040 <binit>
fileinit(); // file table
80102e55: e8 e6 de ff ff call 80100d40 <fileinit>
ideinit(); // disk
80102e5a: e8 a1 f1 ff ff call 80102000 <ideinit>
memmove(code, _binary_entryother_start, (uint)_binary_entryother_size);
80102e5f: c7 44 24 08 8a 00 00 movl $0x8a,0x8(%esp)
80102e66: 00
80102e67: c7 44 24 04 8c a4 10 movl $0x8010a48c,0x4(%esp)
80102e6e: 80
80102e6f: c7 04 24 00 70 00 80 movl $0x80007000,(%esp)
80102e76: e8 a5 14 00 00 call 80104320 <memmove>
for(c = cpus; c < cpus+ncpu; c++){
80102e7b: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102e82: 00 00 00
80102e85: 05 80 27 11 80 add $0x80112780,%eax
80102e8a: 39 d8 cmp %ebx,%eax
80102e8c: 76 65 jbe 80102ef3 <main+0x103>
80102e8e: 66 90 xchg %ax,%ax
if(c == mycpu()) // We've started already.
80102e90: e8 6b 07 00 00 call 80103600 <mycpu>
80102e95: 39 d8 cmp %ebx,%eax
80102e97: 74 41 je 80102eda <main+0xea>
continue;
// Tell entryother.S what stack to use, where to enter, and what
// pgdir to use. We cannot use kpgdir yet, because the AP processor
// is running in low memory, so we use entrypgdir for the APs too.
stack = kalloc();
80102e99: e8 02 f6 ff ff call 801024a0 <kalloc>
*(void**)(code-4) = stack + KSTACKSIZE;
*(void**)(code-8) = mpenter;
80102e9e: c7 05 f8 6f 00 80 d0 movl $0x80102dd0,0x80006ff8
80102ea5: 2d 10 80
*(int**)(code-12) = (void *) V2P(entrypgdir);
80102ea8: c7 05 f4 6f 00 80 00 movl $0x109000,0x80006ff4
80102eaf: 90 10 00
*(void**)(code-4) = stack + KSTACKSIZE;
80102eb2: 05 00 10 00 00 add $0x1000,%eax
80102eb7: a3 fc 6f 00 80 mov %eax,0x80006ffc
lapicstartap(c->apicid, V2P(code));
80102ebc: 0f b6 03 movzbl (%ebx),%eax
80102ebf: c7 44 24 04 00 70 00 movl $0x7000,0x4(%esp)
80102ec6: 00
80102ec7: 89 04 24 mov %eax,(%esp)
80102eca: e8 e1 f8 ff ff call 801027b0 <lapicstartap>
80102ecf: 90 nop
// wait for cpu to finish mpmain()
while(c->started == 0)
80102ed0: 8b 83 a0 00 00 00 mov 0xa0(%ebx),%eax
80102ed6: 85 c0 test %eax,%eax
80102ed8: 74 f6 je 80102ed0 <main+0xe0>
for(c = cpus; c < cpus+ncpu; c++){
80102eda: 69 05 00 2d 11 80 b0 imul $0xb0,0x80112d00,%eax
80102ee1: 00 00 00
80102ee4: 81 c3 b0 00 00 00 add $0xb0,%ebx
80102eea: 05 80 27 11 80 add $0x80112780,%eax
80102eef: 39 c3 cmp %eax,%ebx
80102ef1: 72 9d jb 80102e90 <main+0xa0>
kinit2(P2V(4*1024*1024), P2V(PHYSTOP)); // must come after startothers()
80102ef3: c7 44 24 04 00 00 00 movl $0x8e000000,0x4(%esp)
80102efa: 8e
80102efb: c7 04 24 00 00 40 80 movl $0x80400000,(%esp)
80102f02: e8 49 f5 ff ff call 80102450 <kinit2>
userinit(); // first user process
80102f07: e8 c4 07 00 00 call 801036d0 <userinit>
mpmain(); // finish this processor's setup
80102f0c: e8 6f fe ff ff call 80102d80 <mpmain>
80102f11: 66 90 xchg %ax,%ax
80102f13: 66 90 xchg %ax,%ax
80102f15: 66 90 xchg %ax,%ax
80102f17: 66 90 xchg %ax,%ax
80102f19: 66 90 xchg %ax,%ax
80102f1b: 66 90 xchg %ax,%ax
80102f1d: 66 90 xchg %ax,%ax
80102f1f: 90 nop
80102f20 <mpsearch1>:
}
// Look for an MP structure in the len bytes at addr.
static struct mp*
mpsearch1(uint a, int len)
{
80102f20: 55 push %ebp
80102f21: 89 e5 mov %esp,%ebp
80102f23: 56 push %esi
uchar *e, *p, *addr;
addr = P2V(a);
80102f24: 8d b0 00 00 00 80 lea -0x80000000(%eax),%esi
{
80102f2a: 53 push %ebx
e = addr+len;
80102f2b: 8d 1c 16 lea (%esi,%edx,1),%ebx
{
80102f2e: 83 ec 10 sub $0x10,%esp
for(p = addr; p < e; p += sizeof(struct mp))
80102f31: 39 de cmp %ebx,%esi
80102f33: 73 3c jae 80102f71 <mpsearch1+0x51>
80102f35: 8d 76 00 lea 0x0(%esi),%esi
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f38: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102f3f: 00
80102f40: c7 44 24 04 78 73 10 movl $0x80107378,0x4(%esp)
80102f47: 80
80102f48: 89 34 24 mov %esi,(%esp)
80102f4b: e8 80 13 00 00 call 801042d0 <memcmp>
80102f50: 85 c0 test %eax,%eax
80102f52: 75 16 jne 80102f6a <mpsearch1+0x4a>
80102f54: 31 c9 xor %ecx,%ecx
80102f56: 31 d2 xor %edx,%edx
sum += addr[i];
80102f58: 0f b6 04 16 movzbl (%esi,%edx,1),%eax
for(i=0; i<len; i++)
80102f5c: 83 c2 01 add $0x1,%edx
sum += addr[i];
80102f5f: 01 c1 add %eax,%ecx
for(i=0; i<len; i++)
80102f61: 83 fa 10 cmp $0x10,%edx
80102f64: 75 f2 jne 80102f58 <mpsearch1+0x38>
if(memcmp(p, "_MP_", 4) == 0 && sum(p, sizeof(struct mp)) == 0)
80102f66: 84 c9 test %cl,%cl
80102f68: 74 10 je 80102f7a <mpsearch1+0x5a>
for(p = addr; p < e; p += sizeof(struct mp))
80102f6a: 83 c6 10 add $0x10,%esi
80102f6d: 39 f3 cmp %esi,%ebx
80102f6f: 77 c7 ja 80102f38 <mpsearch1+0x18>
return (struct mp*)p;
return 0;
}
80102f71: 83 c4 10 add $0x10,%esp
return 0;
80102f74: 31 c0 xor %eax,%eax
}
80102f76: 5b pop %ebx
80102f77: 5e pop %esi
80102f78: 5d pop %ebp
80102f79: c3 ret
80102f7a: 83 c4 10 add $0x10,%esp
80102f7d: 89 f0 mov %esi,%eax
80102f7f: 5b pop %ebx
80102f80: 5e pop %esi
80102f81: 5d pop %ebp
80102f82: c3 ret
80102f83: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80102f89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80102f90 <mpinit>:
return conf;
}
void
mpinit(void)
{
80102f90: 55 push %ebp
80102f91: 89 e5 mov %esp,%ebp
80102f93: 57 push %edi
80102f94: 56 push %esi
80102f95: 53 push %ebx
80102f96: 83 ec 1c sub $0x1c,%esp
if((p = ((bda[0x0F]<<8)| bda[0x0E]) << 4)){
80102f99: 0f b6 05 0f 04 00 80 movzbl 0x8000040f,%eax
80102fa0: 0f b6 15 0e 04 00 80 movzbl 0x8000040e,%edx
80102fa7: c1 e0 08 shl $0x8,%eax
80102faa: 09 d0 or %edx,%eax
80102fac: c1 e0 04 shl $0x4,%eax
80102faf: 85 c0 test %eax,%eax
80102fb1: 75 1b jne 80102fce <mpinit+0x3e>
p = ((bda[0x14]<<8)|bda[0x13])*1024;
80102fb3: 0f b6 05 14 04 00 80 movzbl 0x80000414,%eax
80102fba: 0f b6 15 13 04 00 80 movzbl 0x80000413,%edx
80102fc1: c1 e0 08 shl $0x8,%eax
80102fc4: 09 d0 or %edx,%eax
80102fc6: c1 e0 0a shl $0xa,%eax
if((mp = mpsearch1(p-1024, 1024)))
80102fc9: 2d 00 04 00 00 sub $0x400,%eax
if((mp = mpsearch1(p, 1024)))
80102fce: ba 00 04 00 00 mov $0x400,%edx
80102fd3: e8 48 ff ff ff call 80102f20 <mpsearch1>
80102fd8: 85 c0 test %eax,%eax
80102fda: 89 c7 mov %eax,%edi
80102fdc: 0f 84 22 01 00 00 je 80103104 <mpinit+0x174>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80102fe2: 8b 77 04 mov 0x4(%edi),%esi
80102fe5: 85 f6 test %esi,%esi
80102fe7: 0f 84 30 01 00 00 je 8010311d <mpinit+0x18d>
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80102fed: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
if(memcmp(conf, "PCMP", 4) != 0)
80102ff3: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
80102ffa: 00
80102ffb: c7 44 24 04 7d 73 10 movl $0x8010737d,0x4(%esp)
80103002: 80
80103003: 89 04 24 mov %eax,(%esp)
conf = (struct mpconf*) P2V((uint) mp->physaddr);
80103006: 89 45 e4 mov %eax,-0x1c(%ebp)
if(memcmp(conf, "PCMP", 4) != 0)
80103009: e8 c2 12 00 00 call 801042d0 <memcmp>
8010300e: 85 c0 test %eax,%eax
80103010: 0f 85 07 01 00 00 jne 8010311d <mpinit+0x18d>
if(conf->version != 1 && conf->version != 4)
80103016: 0f b6 86 06 00 00 80 movzbl -0x7ffffffa(%esi),%eax
8010301d: 3c 04 cmp $0x4,%al
8010301f: 0f 85 0b 01 00 00 jne 80103130 <mpinit+0x1a0>
if(sum((uchar*)conf, conf->length) != 0)
80103025: 0f b7 86 04 00 00 80 movzwl -0x7ffffffc(%esi),%eax
for(i=0; i<len; i++)
8010302c: 85 c0 test %eax,%eax
8010302e: 74 21 je 80103051 <mpinit+0xc1>
sum = 0;
80103030: 31 c9 xor %ecx,%ecx
for(i=0; i<len; i++)
80103032: 31 d2 xor %edx,%edx
80103034: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sum += addr[i];
80103038: 0f b6 9c 16 00 00 00 movzbl -0x80000000(%esi,%edx,1),%ebx
8010303f: 80
for(i=0; i<len; i++)
80103040: 83 c2 01 add $0x1,%edx
sum += addr[i];
80103043: 01 d9 add %ebx,%ecx
for(i=0; i<len; i++)
80103045: 39 d0 cmp %edx,%eax
80103047: 7f ef jg 80103038 <mpinit+0xa8>
if(sum((uchar*)conf, conf->length) != 0)
80103049: 84 c9 test %cl,%cl
8010304b: 0f 85 cc 00 00 00 jne 8010311d <mpinit+0x18d>
struct mp *mp;
struct mpconf *conf;
struct mpproc *proc;
struct mpioapic *ioapic;
if((conf = mpconfig(&mp)) == 0)
80103051: 8b 45 e4 mov -0x1c(%ebp),%eax
80103054: 85 c0 test %eax,%eax
80103056: 0f 84 c1 00 00 00 je 8010311d <mpinit+0x18d>
panic("Expect to run on an SMP");
ismp = 1;
lapic = (uint*)conf->lapicaddr;
8010305c: 8b 86 24 00 00 80 mov -0x7fffffdc(%esi),%eax
ismp = 1;
80103062: bb 01 00 00 00 mov $0x1,%ebx
lapic = (uint*)conf->lapicaddr;
80103067: a3 7c 26 11 80 mov %eax,0x8011267c
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010306c: 0f b7 96 04 00 00 80 movzwl -0x7ffffffc(%esi),%edx
80103073: 8d 86 2c 00 00 80 lea -0x7fffffd4(%esi),%eax
80103079: 03 55 e4 add -0x1c(%ebp),%edx
8010307c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103080: 39 c2 cmp %eax,%edx
80103082: 76 1b jbe 8010309f <mpinit+0x10f>
80103084: 0f b6 08 movzbl (%eax),%ecx
switch(*p){
80103087: 80 f9 04 cmp $0x4,%cl
8010308a: 77 74 ja 80103100 <mpinit+0x170>
8010308c: ff 24 8d bc 73 10 80 jmp *-0x7fef8c44(,%ecx,4)
80103093: 90 nop
80103094: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
p += sizeof(struct mpioapic);
continue;
case MPBUS:
case MPIOINTR:
case MPLINTR:
p += 8;
80103098: 83 c0 08 add $0x8,%eax
for(p=(uchar*)(conf+1), e=(uchar*)conf+conf->length; p<e; ){
8010309b: 39 c2 cmp %eax,%edx
8010309d: 77 e5 ja 80103084 <mpinit+0xf4>
default:
ismp = 0;
break;
}
}
if(!ismp)
8010309f: 85 db test %ebx,%ebx
801030a1: 0f 84 93 00 00 00 je 8010313a <mpinit+0x1aa>
panic("Didn't find a suitable machine");
if(mp->imcrp){
801030a7: 80 7f 0c 00 cmpb $0x0,0xc(%edi)
801030ab: 74 12 je 801030bf <mpinit+0x12f>
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801030ad: ba 22 00 00 00 mov $0x22,%edx
801030b2: b8 70 00 00 00 mov $0x70,%eax
801030b7: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801030b8: b2 23 mov $0x23,%dl
801030ba: ec in (%dx),%al
// Bochs doesn't support IMCR, so this doesn't run on Bochs.
// But it would on real hardware.
outb(0x22, 0x70); // Select IMCR
outb(0x23, inb(0x23) | 1); // Mask external interrupts.
801030bb: 83 c8 01 or $0x1,%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
801030be: ee out %al,(%dx)
}
}
801030bf: 83 c4 1c add $0x1c,%esp
801030c2: 5b pop %ebx
801030c3: 5e pop %esi
801030c4: 5f pop %edi
801030c5: 5d pop %ebp
801030c6: c3 ret
801030c7: 90 nop
if(ncpu < NCPU) {
801030c8: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
801030ce: 83 fe 07 cmp $0x7,%esi
801030d1: 7f 17 jg 801030ea <mpinit+0x15a>
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030d3: 0f b6 48 01 movzbl 0x1(%eax),%ecx
801030d7: 69 f6 b0 00 00 00 imul $0xb0,%esi,%esi
ncpu++;
801030dd: 83 05 00 2d 11 80 01 addl $0x1,0x80112d00
cpus[ncpu].apicid = proc->apicid; // apicid may differ from ncpu
801030e4: 88 8e 80 27 11 80 mov %cl,-0x7feed880(%esi)
p += sizeof(struct mpproc);
801030ea: 83 c0 14 add $0x14,%eax
continue;
801030ed: eb 91 jmp 80103080 <mpinit+0xf0>
801030ef: 90 nop
ioapicid = ioapic->apicno;
801030f0: 0f b6 48 01 movzbl 0x1(%eax),%ecx
p += sizeof(struct mpioapic);
801030f4: 83 c0 08 add $0x8,%eax
ioapicid = ioapic->apicno;
801030f7: 88 0d 60 27 11 80 mov %cl,0x80112760
continue;
801030fd: eb 81 jmp 80103080 <mpinit+0xf0>
801030ff: 90 nop
ismp = 0;
80103100: 31 db xor %ebx,%ebx
80103102: eb 83 jmp 80103087 <mpinit+0xf7>
return mpsearch1(0xF0000, 0x10000);
80103104: ba 00 00 01 00 mov $0x10000,%edx
80103109: b8 00 00 0f 00 mov $0xf0000,%eax
8010310e: e8 0d fe ff ff call 80102f20 <mpsearch1>
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103113: 85 c0 test %eax,%eax
return mpsearch1(0xF0000, 0x10000);
80103115: 89 c7 mov %eax,%edi
if((mp = mpsearch()) == 0 || mp->physaddr == 0)
80103117: 0f 85 c5 fe ff ff jne 80102fe2 <mpinit+0x52>
panic("Expect to run on an SMP");
8010311d: c7 04 24 82 73 10 80 movl $0x80107382,(%esp)
80103124: e8 37 d2 ff ff call 80100360 <panic>
80103129: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(conf->version != 1 && conf->version != 4)
80103130: 3c 01 cmp $0x1,%al
80103132: 0f 84 ed fe ff ff je 80103025 <mpinit+0x95>
80103138: eb e3 jmp 8010311d <mpinit+0x18d>
panic("Didn't find a suitable machine");
8010313a: c7 04 24 9c 73 10 80 movl $0x8010739c,(%esp)
80103141: e8 1a d2 ff ff call 80100360 <panic>
80103146: 66 90 xchg %ax,%ax
80103148: 66 90 xchg %ax,%ax
8010314a: 66 90 xchg %ax,%ax
8010314c: 66 90 xchg %ax,%ax
8010314e: 66 90 xchg %ax,%ax
80103150 <picinit>:
#define IO_PIC2 0xA0 // Slave (IRQs 8-15)
// Don't use the 8259A interrupt controllers. Xv6 assumes SMP hardware.
void
picinit(void)
{
80103150: 55 push %ebp
80103151: ba 21 00 00 00 mov $0x21,%edx
80103156: 89 e5 mov %esp,%ebp
80103158: b8 ff ff ff ff mov $0xffffffff,%eax
8010315d: ee out %al,(%dx)
8010315e: b2 a1 mov $0xa1,%dl
80103160: ee out %al,(%dx)
// mask all interrupts
outb(IO_PIC1+1, 0xFF);
outb(IO_PIC2+1, 0xFF);
}
80103161: 5d pop %ebp
80103162: c3 ret
80103163: 66 90 xchg %ax,%ax
80103165: 66 90 xchg %ax,%ax
80103167: 66 90 xchg %ax,%ax
80103169: 66 90 xchg %ax,%ax
8010316b: 66 90 xchg %ax,%ax
8010316d: 66 90 xchg %ax,%ax
8010316f: 90 nop
80103170 <pipealloc>:
int writeopen; // write fd is still open
};
int
pipealloc(struct file **f0, struct file **f1)
{
80103170: 55 push %ebp
80103171: 89 e5 mov %esp,%ebp
80103173: 57 push %edi
80103174: 56 push %esi
80103175: 53 push %ebx
80103176: 83 ec 1c sub $0x1c,%esp
80103179: 8b 75 08 mov 0x8(%ebp),%esi
8010317c: 8b 5d 0c mov 0xc(%ebp),%ebx
struct pipe *p;
p = 0;
*f0 = *f1 = 0;
8010317f: c7 03 00 00 00 00 movl $0x0,(%ebx)
80103185: c7 06 00 00 00 00 movl $0x0,(%esi)
if((*f0 = filealloc()) == 0 || (*f1 = filealloc()) == 0)
8010318b: e8 d0 db ff ff call 80100d60 <filealloc>
80103190: 85 c0 test %eax,%eax
80103192: 89 06 mov %eax,(%esi)
80103194: 0f 84 a4 00 00 00 je 8010323e <pipealloc+0xce>
8010319a: e8 c1 db ff ff call 80100d60 <filealloc>
8010319f: 85 c0 test %eax,%eax
801031a1: 89 03 mov %eax,(%ebx)
801031a3: 0f 84 87 00 00 00 je 80103230 <pipealloc+0xc0>
goto bad;
if((p = (struct pipe*)kalloc()) == 0)
801031a9: e8 f2 f2 ff ff call 801024a0 <kalloc>
801031ae: 85 c0 test %eax,%eax
801031b0: 89 c7 mov %eax,%edi
801031b2: 74 7c je 80103230 <pipealloc+0xc0>
goto bad;
p->readopen = 1;
801031b4: c7 80 3c 02 00 00 01 movl $0x1,0x23c(%eax)
801031bb: 00 00 00
p->writeopen = 1;
801031be: c7 80 40 02 00 00 01 movl $0x1,0x240(%eax)
801031c5: 00 00 00
p->nwrite = 0;
801031c8: c7 80 38 02 00 00 00 movl $0x0,0x238(%eax)
801031cf: 00 00 00
p->nread = 0;
801031d2: c7 80 34 02 00 00 00 movl $0x0,0x234(%eax)
801031d9: 00 00 00
initlock(&p->lock, "pipe");
801031dc: 89 04 24 mov %eax,(%esp)
801031df: c7 44 24 04 d0 73 10 movl $0x801073d0,0x4(%esp)
801031e6: 80
801031e7: e8 64 0e 00 00 call 80104050 <initlock>
(*f0)->type = FD_PIPE;
801031ec: 8b 06 mov (%esi),%eax
801031ee: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f0)->readable = 1;
801031f4: 8b 06 mov (%esi),%eax
801031f6: c6 40 08 01 movb $0x1,0x8(%eax)
(*f0)->writable = 0;
801031fa: 8b 06 mov (%esi),%eax
801031fc: c6 40 09 00 movb $0x0,0x9(%eax)
(*f0)->pipe = p;
80103200: 8b 06 mov (%esi),%eax
80103202: 89 78 0c mov %edi,0xc(%eax)
(*f1)->type = FD_PIPE;
80103205: 8b 03 mov (%ebx),%eax
80103207: c7 00 01 00 00 00 movl $0x1,(%eax)
(*f1)->readable = 0;
8010320d: 8b 03 mov (%ebx),%eax
8010320f: c6 40 08 00 movb $0x0,0x8(%eax)
(*f1)->writable = 1;
80103213: 8b 03 mov (%ebx),%eax
80103215: c6 40 09 01 movb $0x1,0x9(%eax)
(*f1)->pipe = p;
80103219: 8b 03 mov (%ebx),%eax
return 0;
8010321b: 31 db xor %ebx,%ebx
(*f1)->pipe = p;
8010321d: 89 78 0c mov %edi,0xc(%eax)
if(*f0)
fileclose(*f0);
if(*f1)
fileclose(*f1);
return -1;
}
80103220: 83 c4 1c add $0x1c,%esp
80103223: 89 d8 mov %ebx,%eax
80103225: 5b pop %ebx
80103226: 5e pop %esi
80103227: 5f pop %edi
80103228: 5d pop %ebp
80103229: c3 ret
8010322a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(*f0)
80103230: 8b 06 mov (%esi),%eax
80103232: 85 c0 test %eax,%eax
80103234: 74 08 je 8010323e <pipealloc+0xce>
fileclose(*f0);
80103236: 89 04 24 mov %eax,(%esp)
80103239: e8 e2 db ff ff call 80100e20 <fileclose>
if(*f1)
8010323e: 8b 03 mov (%ebx),%eax
return -1;
80103240: bb ff ff ff ff mov $0xffffffff,%ebx
if(*f1)
80103245: 85 c0 test %eax,%eax
80103247: 74 d7 je 80103220 <pipealloc+0xb0>
fileclose(*f1);
80103249: 89 04 24 mov %eax,(%esp)
8010324c: e8 cf db ff ff call 80100e20 <fileclose>
}
80103251: 83 c4 1c add $0x1c,%esp
80103254: 89 d8 mov %ebx,%eax
80103256: 5b pop %ebx
80103257: 5e pop %esi
80103258: 5f pop %edi
80103259: 5d pop %ebp
8010325a: c3 ret
8010325b: 90 nop
8010325c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103260 <pipeclose>:
void
pipeclose(struct pipe *p, int writable)
{
80103260: 55 push %ebp
80103261: 89 e5 mov %esp,%ebp
80103263: 56 push %esi
80103264: 53 push %ebx
80103265: 83 ec 10 sub $0x10,%esp
80103268: 8b 5d 08 mov 0x8(%ebp),%ebx
8010326b: 8b 75 0c mov 0xc(%ebp),%esi
acquire(&p->lock);
8010326e: 89 1c 24 mov %ebx,(%esp)
80103271: e8 ca 0e 00 00 call 80104140 <acquire>
if(writable){
80103276: 85 f6 test %esi,%esi
80103278: 74 3e je 801032b8 <pipeclose+0x58>
p->writeopen = 0;
wakeup(&p->nread);
8010327a: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
p->writeopen = 0;
80103280: c7 83 40 02 00 00 00 movl $0x0,0x240(%ebx)
80103287: 00 00 00
wakeup(&p->nread);
8010328a: 89 04 24 mov %eax,(%esp)
8010328d: e8 fe 0a 00 00 call 80103d90 <wakeup>
} else {
p->readopen = 0;
wakeup(&p->nwrite);
}
if(p->readopen == 0 && p->writeopen == 0){
80103292: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
80103298: 85 d2 test %edx,%edx
8010329a: 75 0a jne 801032a6 <pipeclose+0x46>
8010329c: 8b 83 40 02 00 00 mov 0x240(%ebx),%eax
801032a2: 85 c0 test %eax,%eax
801032a4: 74 32 je 801032d8 <pipeclose+0x78>
release(&p->lock);
kfree((char*)p);
} else
release(&p->lock);
801032a6: 89 5d 08 mov %ebx,0x8(%ebp)
}
801032a9: 83 c4 10 add $0x10,%esp
801032ac: 5b pop %ebx
801032ad: 5e pop %esi
801032ae: 5d pop %ebp
release(&p->lock);
801032af: e9 7c 0f 00 00 jmp 80104230 <release>
801032b4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
wakeup(&p->nwrite);
801032b8: 8d 83 38 02 00 00 lea 0x238(%ebx),%eax
p->readopen = 0;
801032be: c7 83 3c 02 00 00 00 movl $0x0,0x23c(%ebx)
801032c5: 00 00 00
wakeup(&p->nwrite);
801032c8: 89 04 24 mov %eax,(%esp)
801032cb: e8 c0 0a 00 00 call 80103d90 <wakeup>
801032d0: eb c0 jmp 80103292 <pipeclose+0x32>
801032d2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
release(&p->lock);
801032d8: 89 1c 24 mov %ebx,(%esp)
801032db: e8 50 0f 00 00 call 80104230 <release>
kfree((char*)p);
801032e0: 89 5d 08 mov %ebx,0x8(%ebp)
}
801032e3: 83 c4 10 add $0x10,%esp
801032e6: 5b pop %ebx
801032e7: 5e pop %esi
801032e8: 5d pop %ebp
kfree((char*)p);
801032e9: e9 02 f0 ff ff jmp 801022f0 <kfree>
801032ee: 66 90 xchg %ax,%ax
801032f0 <pipewrite>:
//PAGEBREAK: 40
int
pipewrite(struct pipe *p, char *addr, int n)
{
801032f0: 55 push %ebp
801032f1: 89 e5 mov %esp,%ebp
801032f3: 57 push %edi
801032f4: 56 push %esi
801032f5: 53 push %ebx
801032f6: 83 ec 1c sub $0x1c,%esp
801032f9: 8b 5d 08 mov 0x8(%ebp),%ebx
int i;
acquire(&p->lock);
801032fc: 89 1c 24 mov %ebx,(%esp)
801032ff: e8 3c 0e 00 00 call 80104140 <acquire>
for(i = 0; i < n; i++){
80103304: 8b 4d 10 mov 0x10(%ebp),%ecx
80103307: 85 c9 test %ecx,%ecx
80103309: 0f 8e b2 00 00 00 jle 801033c1 <pipewrite+0xd1>
8010330f: 8b 4d 0c mov 0xc(%ebp),%ecx
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
if(p->readopen == 0 || myproc()->killed){
release(&p->lock);
return -1;
}
wakeup(&p->nread);
80103312: 8d bb 34 02 00 00 lea 0x234(%ebx),%edi
80103318: 8b 83 38 02 00 00 mov 0x238(%ebx),%eax
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
8010331e: 8d b3 38 02 00 00 lea 0x238(%ebx),%esi
80103324: 89 4d e4 mov %ecx,-0x1c(%ebp)
80103327: 03 4d 10 add 0x10(%ebp),%ecx
8010332a: 89 4d e0 mov %ecx,-0x20(%ebp)
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
8010332d: 8b 8b 34 02 00 00 mov 0x234(%ebx),%ecx
80103333: 81 c1 00 02 00 00 add $0x200,%ecx
80103339: 39 c8 cmp %ecx,%eax
8010333b: 74 38 je 80103375 <pipewrite+0x85>
8010333d: eb 55 jmp 80103394 <pipewrite+0xa4>
8010333f: 90 nop
if(p->readopen == 0 || myproc()->killed){
80103340: e8 5b 03 00 00 call 801036a0 <myproc>
80103345: 8b 40 28 mov 0x28(%eax),%eax
80103348: 85 c0 test %eax,%eax
8010334a: 75 33 jne 8010337f <pipewrite+0x8f>
wakeup(&p->nread);
8010334c: 89 3c 24 mov %edi,(%esp)
8010334f: e8 3c 0a 00 00 call 80103d90 <wakeup>
sleep(&p->nwrite, &p->lock); //DOC: pipewrite-sleep
80103354: 89 5c 24 04 mov %ebx,0x4(%esp)
80103358: 89 34 24 mov %esi,(%esp)
8010335b: e8 a0 08 00 00 call 80103c00 <sleep>
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103360: 8b 83 34 02 00 00 mov 0x234(%ebx),%eax
80103366: 8b 93 38 02 00 00 mov 0x238(%ebx),%edx
8010336c: 05 00 02 00 00 add $0x200,%eax
80103371: 39 c2 cmp %eax,%edx
80103373: 75 23 jne 80103398 <pipewrite+0xa8>
if(p->readopen == 0 || myproc()->killed){
80103375: 8b 93 3c 02 00 00 mov 0x23c(%ebx),%edx
8010337b: 85 d2 test %edx,%edx
8010337d: 75 c1 jne 80103340 <pipewrite+0x50>
release(&p->lock);
8010337f: 89 1c 24 mov %ebx,(%esp)
80103382: e8 a9 0e 00 00 call 80104230 <release>
return -1;
80103387: b8 ff ff ff ff mov $0xffffffff,%eax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
}
wakeup(&p->nread); //DOC: pipewrite-wakeup1
release(&p->lock);
return n;
}
8010338c: 83 c4 1c add $0x1c,%esp
8010338f: 5b pop %ebx
80103390: 5e pop %esi
80103391: 5f pop %edi
80103392: 5d pop %ebp
80103393: c3 ret
while(p->nwrite == p->nread + PIPESIZE){ //DOC: pipewrite-full
80103394: 89 c2 mov %eax,%edx
80103396: 66 90 xchg %ax,%ax
p->data[p->nwrite++ % PIPESIZE] = addr[i];
80103398: 8b 4d e4 mov -0x1c(%ebp),%ecx
8010339b: 8d 42 01 lea 0x1(%edx),%eax
8010339e: 81 e2 ff 01 00 00 and $0x1ff,%edx
801033a4: 89 83 38 02 00 00 mov %eax,0x238(%ebx)
801033aa: 83 45 e4 01 addl $0x1,-0x1c(%ebp)
801033ae: 0f b6 09 movzbl (%ecx),%ecx
801033b1: 88 4c 13 34 mov %cl,0x34(%ebx,%edx,1)
for(i = 0; i < n; i++){
801033b5: 8b 4d e4 mov -0x1c(%ebp),%ecx
801033b8: 3b 4d e0 cmp -0x20(%ebp),%ecx
801033bb: 0f 85 6c ff ff ff jne 8010332d <pipewrite+0x3d>
wakeup(&p->nread); //DOC: pipewrite-wakeup1
801033c1: 8d 83 34 02 00 00 lea 0x234(%ebx),%eax
801033c7: 89 04 24 mov %eax,(%esp)
801033ca: e8 c1 09 00 00 call 80103d90 <wakeup>
release(&p->lock);
801033cf: 89 1c 24 mov %ebx,(%esp)
801033d2: e8 59 0e 00 00 call 80104230 <release>
return n;
801033d7: 8b 45 10 mov 0x10(%ebp),%eax
801033da: eb b0 jmp 8010338c <pipewrite+0x9c>
801033dc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801033e0 <piperead>:
int
piperead(struct pipe *p, char *addr, int n)
{
801033e0: 55 push %ebp
801033e1: 89 e5 mov %esp,%ebp
801033e3: 57 push %edi
801033e4: 56 push %esi
801033e5: 53 push %ebx
801033e6: 83 ec 1c sub $0x1c,%esp
801033e9: 8b 75 08 mov 0x8(%ebp),%esi
801033ec: 8b 7d 0c mov 0xc(%ebp),%edi
int i;
acquire(&p->lock);
801033ef: 89 34 24 mov %esi,(%esp)
801033f2: e8 49 0d 00 00 call 80104140 <acquire>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
801033f7: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
801033fd: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
80103403: 75 5b jne 80103460 <piperead+0x80>
80103405: 8b 9e 40 02 00 00 mov 0x240(%esi),%ebx
8010340b: 85 db test %ebx,%ebx
8010340d: 74 51 je 80103460 <piperead+0x80>
if(myproc()->killed){
release(&p->lock);
return -1;
}
sleep(&p->nread, &p->lock); //DOC: piperead-sleep
8010340f: 8d 9e 34 02 00 00 lea 0x234(%esi),%ebx
80103415: eb 25 jmp 8010343c <piperead+0x5c>
80103417: 90 nop
80103418: 89 74 24 04 mov %esi,0x4(%esp)
8010341c: 89 1c 24 mov %ebx,(%esp)
8010341f: e8 dc 07 00 00 call 80103c00 <sleep>
while(p->nread == p->nwrite && p->writeopen){ //DOC: pipe-empty
80103424: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
8010342a: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
80103430: 75 2e jne 80103460 <piperead+0x80>
80103432: 8b 96 40 02 00 00 mov 0x240(%esi),%edx
80103438: 85 d2 test %edx,%edx
8010343a: 74 24 je 80103460 <piperead+0x80>
if(myproc()->killed){
8010343c: e8 5f 02 00 00 call 801036a0 <myproc>
80103441: 8b 48 28 mov 0x28(%eax),%ecx
80103444: 85 c9 test %ecx,%ecx
80103446: 74 d0 je 80103418 <piperead+0x38>
release(&p->lock);
80103448: 89 34 24 mov %esi,(%esp)
8010344b: e8 e0 0d 00 00 call 80104230 <release>
addr[i] = p->data[p->nread++ % PIPESIZE];
}
wakeup(&p->nwrite); //DOC: piperead-wakeup
release(&p->lock);
return i;
}
80103450: 83 c4 1c add $0x1c,%esp
return -1;
80103453: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103458: 5b pop %ebx
80103459: 5e pop %esi
8010345a: 5f pop %edi
8010345b: 5d pop %ebp
8010345c: c3 ret
8010345d: 8d 76 00 lea 0x0(%esi),%esi
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103460: 8b 55 10 mov 0x10(%ebp),%edx
if(p->nread == p->nwrite)
80103463: 31 db xor %ebx,%ebx
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103465: 85 d2 test %edx,%edx
80103467: 7f 2b jg 80103494 <piperead+0xb4>
80103469: eb 31 jmp 8010349c <piperead+0xbc>
8010346b: 90 nop
8010346c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
addr[i] = p->data[p->nread++ % PIPESIZE];
80103470: 8d 48 01 lea 0x1(%eax),%ecx
80103473: 25 ff 01 00 00 and $0x1ff,%eax
80103478: 89 8e 34 02 00 00 mov %ecx,0x234(%esi)
8010347e: 0f b6 44 06 34 movzbl 0x34(%esi,%eax,1),%eax
80103483: 88 04 1f mov %al,(%edi,%ebx,1)
for(i = 0; i < n; i++){ //DOC: piperead-copy
80103486: 83 c3 01 add $0x1,%ebx
80103489: 3b 5d 10 cmp 0x10(%ebp),%ebx
8010348c: 74 0e je 8010349c <piperead+0xbc>
if(p->nread == p->nwrite)
8010348e: 8b 86 34 02 00 00 mov 0x234(%esi),%eax
80103494: 3b 86 38 02 00 00 cmp 0x238(%esi),%eax
8010349a: 75 d4 jne 80103470 <piperead+0x90>
wakeup(&p->nwrite); //DOC: piperead-wakeup
8010349c: 8d 86 38 02 00 00 lea 0x238(%esi),%eax
801034a2: 89 04 24 mov %eax,(%esp)
801034a5: e8 e6 08 00 00 call 80103d90 <wakeup>
release(&p->lock);
801034aa: 89 34 24 mov %esi,(%esp)
801034ad: e8 7e 0d 00 00 call 80104230 <release>
}
801034b2: 83 c4 1c add $0x1c,%esp
return i;
801034b5: 89 d8 mov %ebx,%eax
}
801034b7: 5b pop %ebx
801034b8: 5e pop %esi
801034b9: 5f pop %edi
801034ba: 5d pop %ebp
801034bb: c3 ret
801034bc: 66 90 xchg %ax,%ax
801034be: 66 90 xchg %ax,%ax
801034c0 <allocproc>:
// If found, change state to EMBRYO and initialize
// state required to run in the kernel.
// Otherwise return 0.
static struct proc*
allocproc(void)
{
801034c0: 55 push %ebp
801034c1: 89 e5 mov %esp,%ebp
801034c3: 53 push %ebx
struct proc *p;
char *sp;
acquire(&ptable.lock);
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034c4: bb 54 2d 11 80 mov $0x80112d54,%ebx
{
801034c9: 83 ec 14 sub $0x14,%esp
acquire(&ptable.lock);
801034cc: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801034d3: e8 68 0c 00 00 call 80104140 <acquire>
801034d8: eb 11 jmp 801034eb <allocproc+0x2b>
801034da: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
801034e0: 83 eb 80 sub $0xffffff80,%ebx
801034e3: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
801034e9: 74 7d je 80103568 <allocproc+0xa8>
if(p->state == UNUSED)
801034eb: 8b 43 10 mov 0x10(%ebx),%eax
801034ee: 85 c0 test %eax,%eax
801034f0: 75 ee jne 801034e0 <allocproc+0x20>
release(&ptable.lock);
return 0;
found:
p->state = EMBRYO;
p->pid = nextpid++;
801034f2: a1 04 a0 10 80 mov 0x8010a004,%eax
release(&ptable.lock);
801034f7: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->state = EMBRYO;
801034fe: c7 43 10 01 00 00 00 movl $0x1,0x10(%ebx)
p->pid = nextpid++;
80103505: 8d 50 01 lea 0x1(%eax),%edx
80103508: 89 15 04 a0 10 80 mov %edx,0x8010a004
8010350e: 89 43 14 mov %eax,0x14(%ebx)
release(&ptable.lock);
80103511: e8 1a 0d 00 00 call 80104230 <release>
// Allocate kernel stack.
if((p->kstack = kalloc()) == 0){
80103516: e8 85 ef ff ff call 801024a0 <kalloc>
8010351b: 85 c0 test %eax,%eax
8010351d: 89 43 0c mov %eax,0xc(%ebx)
80103520: 74 5a je 8010357c <allocproc+0xbc>
return 0;
}
sp = p->kstack + KSTACKSIZE;
// Leave room for trap frame.
sp -= sizeof *p->tf;
80103522: 8d 90 b4 0f 00 00 lea 0xfb4(%eax),%edx
// Set up new context to start executing at forkret,
// which returns to trapret.
sp -= 4;
*(uint*)sp = (uint)trapret;
sp -= sizeof *p->context;
80103528: 05 9c 0f 00 00 add $0xf9c,%eax
sp -= sizeof *p->tf;
8010352d: 89 53 1c mov %edx,0x1c(%ebx)
*(uint*)sp = (uint)trapret;
80103530: c7 40 14 35 54 10 80 movl $0x80105435,0x14(%eax)
p->context = (struct context*)sp;
memset(p->context, 0, sizeof *p->context);
80103537: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
8010353e: 00
8010353f: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103546: 00
80103547: 89 04 24 mov %eax,(%esp)
p->context = (struct context*)sp;
8010354a: 89 43 20 mov %eax,0x20(%ebx)
memset(p->context, 0, sizeof *p->context);
8010354d: e8 2e 0d 00 00 call 80104280 <memset>
p->context->eip = (uint)forkret;
80103552: 8b 43 20 mov 0x20(%ebx),%eax
80103555: c7 40 10 90 35 10 80 movl $0x80103590,0x10(%eax)
return p;
8010355c: 89 d8 mov %ebx,%eax
}
8010355e: 83 c4 14 add $0x14,%esp
80103561: 5b pop %ebx
80103562: 5d pop %ebp
80103563: c3 ret
80103564: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103568: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010356f: e8 bc 0c 00 00 call 80104230 <release>
}
80103574: 83 c4 14 add $0x14,%esp
return 0;
80103577: 31 c0 xor %eax,%eax
}
80103579: 5b pop %ebx
8010357a: 5d pop %ebp
8010357b: c3 ret
p->state = UNUSED;
8010357c: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
return 0;
80103583: eb d9 jmp 8010355e <allocproc+0x9e>
80103585: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103589: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103590 <forkret>:
// A fork child's very first scheduling by scheduler()
// will swtch here. "Return" to user space.
void
forkret(void)
{
80103590: 55 push %ebp
80103591: 89 e5 mov %esp,%ebp
80103593: 83 ec 18 sub $0x18,%esp
static int first = 1;
// Still holding ptable.lock from scheduler.
release(&ptable.lock);
80103596: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
8010359d: e8 8e 0c 00 00 call 80104230 <release>
if (first) {
801035a2: a1 00 a0 10 80 mov 0x8010a000,%eax
801035a7: 85 c0 test %eax,%eax
801035a9: 75 05 jne 801035b0 <forkret+0x20>
iinit(ROOTDEV);
initlog(ROOTDEV);
}
// Return to "caller", actually trapret (see allocproc).
}
801035ab: c9 leave
801035ac: c3 ret
801035ad: 8d 76 00 lea 0x0(%esi),%esi
iinit(ROOTDEV);
801035b0: c7 04 24 01 00 00 00 movl $0x1,(%esp)
first = 0;
801035b7: c7 05 00 a0 10 80 00 movl $0x0,0x8010a000
801035be: 00 00 00
iinit(ROOTDEV);
801035c1: e8 aa de ff ff call 80101470 <iinit>
initlog(ROOTDEV);
801035c6: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801035cd: e8 9e f4 ff ff call 80102a70 <initlog>
}
801035d2: c9 leave
801035d3: c3 ret
801035d4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801035da: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801035e0 <pinit>:
{
801035e0: 55 push %ebp
801035e1: 89 e5 mov %esp,%ebp
801035e3: 83 ec 18 sub $0x18,%esp
initlock(&ptable.lock, "ptable");
801035e6: c7 44 24 04 d5 73 10 movl $0x801073d5,0x4(%esp)
801035ed: 80
801035ee: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801035f5: e8 56 0a 00 00 call 80104050 <initlock>
}
801035fa: c9 leave
801035fb: c3 ret
801035fc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103600 <mycpu>:
{
80103600: 55 push %ebp
80103601: 89 e5 mov %esp,%ebp
80103603: 56 push %esi
80103604: 53 push %ebx
80103605: 83 ec 10 sub $0x10,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
80103608: 9c pushf
80103609: 58 pop %eax
if(readeflags()&FL_IF)
8010360a: f6 c4 02 test $0x2,%ah
8010360d: 75 57 jne 80103666 <mycpu+0x66>
apicid = lapicid();
8010360f: e8 4c f1 ff ff call 80102760 <lapicid>
for (i = 0; i < ncpu; ++i) {
80103614: 8b 35 00 2d 11 80 mov 0x80112d00,%esi
8010361a: 85 f6 test %esi,%esi
8010361c: 7e 3c jle 8010365a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
8010361e: 0f b6 15 80 27 11 80 movzbl 0x80112780,%edx
80103625: 39 c2 cmp %eax,%edx
80103627: 74 2d je 80103656 <mycpu+0x56>
80103629: b9 30 28 11 80 mov $0x80112830,%ecx
for (i = 0; i < ncpu; ++i) {
8010362e: 31 d2 xor %edx,%edx
80103630: 83 c2 01 add $0x1,%edx
80103633: 39 f2 cmp %esi,%edx
80103635: 74 23 je 8010365a <mycpu+0x5a>
if (cpus[i].apicid == apicid)
80103637: 0f b6 19 movzbl (%ecx),%ebx
8010363a: 81 c1 b0 00 00 00 add $0xb0,%ecx
80103640: 39 c3 cmp %eax,%ebx
80103642: 75 ec jne 80103630 <mycpu+0x30>
return &cpus[i];
80103644: 69 c2 b0 00 00 00 imul $0xb0,%edx,%eax
}
8010364a: 83 c4 10 add $0x10,%esp
8010364d: 5b pop %ebx
8010364e: 5e pop %esi
8010364f: 5d pop %ebp
return &cpus[i];
80103650: 05 80 27 11 80 add $0x80112780,%eax
}
80103655: c3 ret
for (i = 0; i < ncpu; ++i) {
80103656: 31 d2 xor %edx,%edx
80103658: eb ea jmp 80103644 <mycpu+0x44>
panic("unknown apicid\n");
8010365a: c7 04 24 dc 73 10 80 movl $0x801073dc,(%esp)
80103661: e8 fa cc ff ff call 80100360 <panic>
panic("mycpu called with interrupts enabled\n");
80103666: c7 04 24 b8 74 10 80 movl $0x801074b8,(%esp)
8010366d: e8 ee cc ff ff call 80100360 <panic>
80103672: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103679: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103680 <cpuid>:
cpuid() {
80103680: 55 push %ebp
80103681: 89 e5 mov %esp,%ebp
80103683: 83 ec 08 sub $0x8,%esp
return mycpu()-cpus;
80103686: e8 75 ff ff ff call 80103600 <mycpu>
}
8010368b: c9 leave
return mycpu()-cpus;
8010368c: 2d 80 27 11 80 sub $0x80112780,%eax
80103691: c1 f8 04 sar $0x4,%eax
80103694: 69 c0 a3 8b 2e ba imul $0xba2e8ba3,%eax,%eax
}
8010369a: c3 ret
8010369b: 90 nop
8010369c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801036a0 <myproc>:
myproc(void) {
801036a0: 55 push %ebp
801036a1: 89 e5 mov %esp,%ebp
801036a3: 53 push %ebx
801036a4: 83 ec 04 sub $0x4,%esp
pushcli();
801036a7: e8 54 0a 00 00 call 80104100 <pushcli>
c = mycpu();
801036ac: e8 4f ff ff ff call 80103600 <mycpu>
p = c->proc;
801036b1: 8b 98 ac 00 00 00 mov 0xac(%eax),%ebx
popcli();
801036b7: e8 04 0b 00 00 call 801041c0 <popcli>
}
801036bc: 83 c4 04 add $0x4,%esp
801036bf: 89 d8 mov %ebx,%eax
801036c1: 5b pop %ebx
801036c2: 5d pop %ebp
801036c3: c3 ret
801036c4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801036ca: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801036d0 <userinit>:
{
801036d0: 55 push %ebp
801036d1: 89 e5 mov %esp,%ebp
801036d3: 53 push %ebx
801036d4: 83 ec 14 sub $0x14,%esp
p = allocproc();
801036d7: e8 e4 fd ff ff call 801034c0 <allocproc>
801036dc: 89 c3 mov %eax,%ebx
initproc = p;
801036de: a3 b8 a5 10 80 mov %eax,0x8010a5b8
if((p->pgdir = setupkvm()) == 0)
801036e3: e8 88 33 00 00 call 80106a70 <setupkvm>
801036e8: 85 c0 test %eax,%eax
801036ea: 89 43 04 mov %eax,0x4(%ebx)
801036ed: 0f 84 d4 00 00 00 je 801037c7 <userinit+0xf7>
inituvm(p->pgdir, _binary_initcode_start, (int)_binary_initcode_size);
801036f3: 89 04 24 mov %eax,(%esp)
801036f6: c7 44 24 08 2c 00 00 movl $0x2c,0x8(%esp)
801036fd: 00
801036fe: c7 44 24 04 60 a4 10 movl $0x8010a460,0x4(%esp)
80103705: 80
80103706: e8 75 30 00 00 call 80106780 <inituvm>
p->sz = PGSIZE;
8010370b: c7 03 00 10 00 00 movl $0x1000,(%ebx)
memset(p->tf, 0, sizeof(*p->tf));
80103711: c7 44 24 08 4c 00 00 movl $0x4c,0x8(%esp)
80103718: 00
80103719: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80103720: 00
80103721: 8b 43 1c mov 0x1c(%ebx),%eax
80103724: 89 04 24 mov %eax,(%esp)
80103727: e8 54 0b 00 00 call 80104280 <memset>
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
8010372c: 8b 43 1c mov 0x1c(%ebx),%eax
8010372f: ba 1b 00 00 00 mov $0x1b,%edx
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
80103734: b9 23 00 00 00 mov $0x23,%ecx
p->tf->cs = (SEG_UCODE << 3) | DPL_USER;
80103739: 66 89 50 3c mov %dx,0x3c(%eax)
p->tf->ds = (SEG_UDATA << 3) | DPL_USER;
8010373d: 8b 43 1c mov 0x1c(%ebx),%eax
80103740: 66 89 48 2c mov %cx,0x2c(%eax)
p->tf->es = p->tf->ds;
80103744: 8b 43 1c mov 0x1c(%ebx),%eax
80103747: 0f b7 50 2c movzwl 0x2c(%eax),%edx
8010374b: 66 89 50 28 mov %dx,0x28(%eax)
p->tf->ss = p->tf->ds;
8010374f: 8b 43 1c mov 0x1c(%ebx),%eax
80103752: 0f b7 50 2c movzwl 0x2c(%eax),%edx
80103756: 66 89 50 48 mov %dx,0x48(%eax)
p->tf->eflags = FL_IF;
8010375a: 8b 43 1c mov 0x1c(%ebx),%eax
8010375d: c7 40 40 00 02 00 00 movl $0x200,0x40(%eax)
p->tf->esp = PGSIZE;
80103764: 8b 43 1c mov 0x1c(%ebx),%eax
80103767: c7 40 44 00 10 00 00 movl $0x1000,0x44(%eax)
p->tf->eip = 0; // beginning of initcode.S
8010376e: 8b 43 1c mov 0x1c(%ebx),%eax
80103771: c7 40 38 00 00 00 00 movl $0x0,0x38(%eax)
safestrcpy(p->name, "initcode", sizeof(p->name));
80103778: 8d 43 70 lea 0x70(%ebx),%eax
8010377b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80103782: 00
80103783: c7 44 24 04 05 74 10 movl $0x80107405,0x4(%esp)
8010378a: 80
8010378b: 89 04 24 mov %eax,(%esp)
8010378e: e8 cd 0c 00 00 call 80104460 <safestrcpy>
p->cwd = namei("/");
80103793: c7 04 24 0e 74 10 80 movl $0x8010740e,(%esp)
8010379a: e8 61 e7 ff ff call 80101f00 <namei>
8010379f: 89 43 6c mov %eax,0x6c(%ebx)
acquire(&ptable.lock);
801037a2: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801037a9: e8 92 09 00 00 call 80104140 <acquire>
p->state = RUNNABLE;
801037ae: c7 43 10 03 00 00 00 movl $0x3,0x10(%ebx)
release(&ptable.lock);
801037b5: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801037bc: e8 6f 0a 00 00 call 80104230 <release>
}
801037c1: 83 c4 14 add $0x14,%esp
801037c4: 5b pop %ebx
801037c5: 5d pop %ebp
801037c6: c3 ret
panic("userinit: out of memory?");
801037c7: c7 04 24 ec 73 10 80 movl $0x801073ec,(%esp)
801037ce: e8 8d cb ff ff call 80100360 <panic>
801037d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801037d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801037e0 <growproc>:
{
801037e0: 55 push %ebp
801037e1: 89 e5 mov %esp,%ebp
801037e3: 56 push %esi
801037e4: 53 push %ebx
801037e5: 83 ec 10 sub $0x10,%esp
801037e8: 8b 75 08 mov 0x8(%ebp),%esi
struct proc *curproc = myproc();
801037eb: e8 b0 fe ff ff call 801036a0 <myproc>
if(n > 0){
801037f0: 83 fe 00 cmp $0x0,%esi
struct proc *curproc = myproc();
801037f3: 89 c3 mov %eax,%ebx
sz = curproc->sz;
801037f5: 8b 00 mov (%eax),%eax
if(n > 0){
801037f7: 7e 2f jle 80103828 <growproc+0x48>
if((sz = allocuvm(curproc->pgdir, sz, sz + n)) == 0)
801037f9: 01 c6 add %eax,%esi
801037fb: 89 74 24 08 mov %esi,0x8(%esp)
801037ff: 89 44 24 04 mov %eax,0x4(%esp)
80103803: 8b 43 04 mov 0x4(%ebx),%eax
80103806: 89 04 24 mov %eax,(%esp)
80103809: e8 c2 30 00 00 call 801068d0 <allocuvm>
8010380e: 85 c0 test %eax,%eax
80103810: 74 36 je 80103848 <growproc+0x68>
curproc->sz = sz;
80103812: 89 03 mov %eax,(%ebx)
switchuvm(curproc);
80103814: 89 1c 24 mov %ebx,(%esp)
80103817: e8 54 2e 00 00 call 80106670 <switchuvm>
return 0;
8010381c: 31 c0 xor %eax,%eax
}
8010381e: 83 c4 10 add $0x10,%esp
80103821: 5b pop %ebx
80103822: 5e pop %esi
80103823: 5d pop %ebp
80103824: c3 ret
80103825: 8d 76 00 lea 0x0(%esi),%esi
} else if(n < 0){
80103828: 74 e8 je 80103812 <growproc+0x32>
if((sz = deallocuvm(curproc->pgdir, sz, sz + n)) == 0)
8010382a: 01 c6 add %eax,%esi
8010382c: 89 74 24 08 mov %esi,0x8(%esp)
80103830: 89 44 24 04 mov %eax,0x4(%esp)
80103834: 8b 43 04 mov 0x4(%ebx),%eax
80103837: 89 04 24 mov %eax,(%esp)
8010383a: e8 91 31 00 00 call 801069d0 <deallocuvm>
8010383f: 85 c0 test %eax,%eax
80103841: 75 cf jne 80103812 <growproc+0x32>
80103843: 90 nop
80103844: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80103848: b8 ff ff ff ff mov $0xffffffff,%eax
8010384d: eb cf jmp 8010381e <growproc+0x3e>
8010384f: 90 nop
80103850 <fork>:
{
80103850: 55 push %ebp
80103851: 89 e5 mov %esp,%ebp
80103853: 57 push %edi
80103854: 56 push %esi
80103855: 53 push %ebx
80103856: 83 ec 1c sub $0x1c,%esp
struct proc *curproc = myproc();
80103859: e8 42 fe ff ff call 801036a0 <myproc>
8010385e: 89 c3 mov %eax,%ebx
if((np = allocproc()) == 0){
80103860: e8 5b fc ff ff call 801034c0 <allocproc>
80103865: 85 c0 test %eax,%eax
80103867: 89 c7 mov %eax,%edi
80103869: 89 45 e4 mov %eax,-0x1c(%ebp)
8010386c: 0f 84 c4 00 00 00 je 80103936 <fork+0xe6>
if((np->pgdir = copyuvm(curproc->pgdir, curproc->sz,curproc->szStack)) == 0){
80103872: 8b 43 08 mov 0x8(%ebx),%eax
80103875: 89 44 24 08 mov %eax,0x8(%esp)
80103879: 8b 03 mov (%ebx),%eax
8010387b: 89 44 24 04 mov %eax,0x4(%esp)
8010387f: 8b 43 04 mov 0x4(%ebx),%eax
80103882: 89 04 24 mov %eax,(%esp)
80103885: e8 c6 32 00 00 call 80106b50 <copyuvm>
8010388a: 85 c0 test %eax,%eax
8010388c: 89 47 04 mov %eax,0x4(%edi)
8010388f: 0f 84 a8 00 00 00 je 8010393d <fork+0xed>
np->sz = curproc->sz;
80103895: 8b 03 mov (%ebx),%eax
80103897: 8b 4d e4 mov -0x1c(%ebp),%ecx
8010389a: 89 01 mov %eax,(%ecx)
*np->tf = *curproc->tf;
8010389c: 8b 79 1c mov 0x1c(%ecx),%edi
8010389f: 89 c8 mov %ecx,%eax
np->parent = curproc;
801038a1: 89 59 18 mov %ebx,0x18(%ecx)
*np->tf = *curproc->tf;
801038a4: 8b 73 1c mov 0x1c(%ebx),%esi
801038a7: b9 13 00 00 00 mov $0x13,%ecx
801038ac: f3 a5 rep movsl %ds:(%esi),%es:(%edi)
for(i = 0; i < NOFILE; i++)
801038ae: 31 f6 xor %esi,%esi
np->tf->eax = 0;
801038b0: 8b 40 1c mov 0x1c(%eax),%eax
801038b3: c7 40 1c 00 00 00 00 movl $0x0,0x1c(%eax)
801038ba: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(curproc->ofile[i])
801038c0: 8b 44 b3 2c mov 0x2c(%ebx,%esi,4),%eax
801038c4: 85 c0 test %eax,%eax
801038c6: 74 0f je 801038d7 <fork+0x87>
np->ofile[i] = filedup(curproc->ofile[i]);
801038c8: 89 04 24 mov %eax,(%esp)
801038cb: e8 00 d5 ff ff call 80100dd0 <filedup>
801038d0: 8b 55 e4 mov -0x1c(%ebp),%edx
801038d3: 89 44 b2 2c mov %eax,0x2c(%edx,%esi,4)
for(i = 0; i < NOFILE; i++)
801038d7: 83 c6 01 add $0x1,%esi
801038da: 83 fe 10 cmp $0x10,%esi
801038dd: 75 e1 jne 801038c0 <fork+0x70>
np->cwd = idup(curproc->cwd);
801038df: 8b 43 6c mov 0x6c(%ebx),%eax
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038e2: 83 c3 70 add $0x70,%ebx
np->cwd = idup(curproc->cwd);
801038e5: 89 04 24 mov %eax,(%esp)
801038e8: e8 93 dd ff ff call 80101680 <idup>
801038ed: 8b 7d e4 mov -0x1c(%ebp),%edi
801038f0: 89 47 6c mov %eax,0x6c(%edi)
safestrcpy(np->name, curproc->name, sizeof(curproc->name));
801038f3: 8d 47 70 lea 0x70(%edi),%eax
801038f6: 89 5c 24 04 mov %ebx,0x4(%esp)
801038fa: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80103901: 00
80103902: 89 04 24 mov %eax,(%esp)
80103905: e8 56 0b 00 00 call 80104460 <safestrcpy>
pid = np->pid;
8010390a: 8b 5f 14 mov 0x14(%edi),%ebx
acquire(&ptable.lock);
8010390d: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103914: e8 27 08 00 00 call 80104140 <acquire>
np->state = RUNNABLE;
80103919: c7 47 10 03 00 00 00 movl $0x3,0x10(%edi)
release(&ptable.lock);
80103920: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103927: e8 04 09 00 00 call 80104230 <release>
return pid;
8010392c: 89 d8 mov %ebx,%eax
}
8010392e: 83 c4 1c add $0x1c,%esp
80103931: 5b pop %ebx
80103932: 5e pop %esi
80103933: 5f pop %edi
80103934: 5d pop %ebp
80103935: c3 ret
return -1;
80103936: b8 ff ff ff ff mov $0xffffffff,%eax
8010393b: eb f1 jmp 8010392e <fork+0xde>
kfree(np->kstack);
8010393d: 8b 7d e4 mov -0x1c(%ebp),%edi
80103940: 8b 47 0c mov 0xc(%edi),%eax
80103943: 89 04 24 mov %eax,(%esp)
80103946: e8 a5 e9 ff ff call 801022f0 <kfree>
return -1;
8010394b: b8 ff ff ff ff mov $0xffffffff,%eax
np->kstack = 0;
80103950: c7 47 0c 00 00 00 00 movl $0x0,0xc(%edi)
np->state = UNUSED;
80103957: c7 47 10 00 00 00 00 movl $0x0,0x10(%edi)
return -1;
8010395e: eb ce jmp 8010392e <fork+0xde>
80103960 <scheduler>:
{
80103960: 55 push %ebp
80103961: 89 e5 mov %esp,%ebp
80103963: 57 push %edi
80103964: 56 push %esi
80103965: 53 push %ebx
80103966: 83 ec 1c sub $0x1c,%esp
struct cpu *c = mycpu();
80103969: e8 92 fc ff ff call 80103600 <mycpu>
8010396e: 89 c6 mov %eax,%esi
c->proc = 0;
80103970: c7 80 ac 00 00 00 00 movl $0x0,0xac(%eax)
80103977: 00 00 00
8010397a: 8d 78 04 lea 0x4(%eax),%edi
8010397d: 8d 76 00 lea 0x0(%esi),%esi
asm volatile("sti");
80103980: fb sti
acquire(&ptable.lock);
80103981: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103988: bb 54 2d 11 80 mov $0x80112d54,%ebx
acquire(&ptable.lock);
8010398d: e8 ae 07 00 00 call 80104140 <acquire>
80103992: eb 0f jmp 801039a3 <scheduler+0x43>
80103994: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103998: 83 eb 80 sub $0xffffff80,%ebx
8010399b: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
801039a1: 74 45 je 801039e8 <scheduler+0x88>
if(p->state != RUNNABLE)
801039a3: 83 7b 10 03 cmpl $0x3,0x10(%ebx)
801039a7: 75 ef jne 80103998 <scheduler+0x38>
c->proc = p;
801039a9: 89 9e ac 00 00 00 mov %ebx,0xac(%esi)
switchuvm(p);
801039af: 89 1c 24 mov %ebx,(%esp)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039b2: 83 eb 80 sub $0xffffff80,%ebx
switchuvm(p);
801039b5: e8 b6 2c 00 00 call 80106670 <switchuvm>
swtch(&(c->scheduler), p->context);
801039ba: 8b 43 a0 mov -0x60(%ebx),%eax
p->state = RUNNING;
801039bd: c7 43 90 04 00 00 00 movl $0x4,-0x70(%ebx)
swtch(&(c->scheduler), p->context);
801039c4: 89 3c 24 mov %edi,(%esp)
801039c7: 89 44 24 04 mov %eax,0x4(%esp)
801039cb: e8 eb 0a 00 00 call 801044bb <swtch>
switchkvm();
801039d0: e8 7b 2c 00 00 call 80106650 <switchkvm>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039d5: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
c->proc = 0;
801039db: c7 86 ac 00 00 00 00 movl $0x0,0xac(%esi)
801039e2: 00 00 00
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
801039e5: 75 bc jne 801039a3 <scheduler+0x43>
801039e7: 90 nop
release(&ptable.lock);
801039e8: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
801039ef: e8 3c 08 00 00 call 80104230 <release>
}
801039f4: eb 8a jmp 80103980 <scheduler+0x20>
801039f6: 8d 76 00 lea 0x0(%esi),%esi
801039f9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103a00 <sched>:
{
80103a00: 55 push %ebp
80103a01: 89 e5 mov %esp,%ebp
80103a03: 56 push %esi
80103a04: 53 push %ebx
80103a05: 83 ec 10 sub $0x10,%esp
struct proc *p = myproc();
80103a08: e8 93 fc ff ff call 801036a0 <myproc>
if(!holding(&ptable.lock))
80103a0d: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *p = myproc();
80103a14: 89 c3 mov %eax,%ebx
if(!holding(&ptable.lock))
80103a16: e8 b5 06 00 00 call 801040d0 <holding>
80103a1b: 85 c0 test %eax,%eax
80103a1d: 74 4f je 80103a6e <sched+0x6e>
if(mycpu()->ncli != 1)
80103a1f: e8 dc fb ff ff call 80103600 <mycpu>
80103a24: 83 b8 a4 00 00 00 01 cmpl $0x1,0xa4(%eax)
80103a2b: 75 65 jne 80103a92 <sched+0x92>
if(p->state == RUNNING)
80103a2d: 83 7b 10 04 cmpl $0x4,0x10(%ebx)
80103a31: 74 53 je 80103a86 <sched+0x86>
asm volatile("pushfl; popl %0" : "=r" (eflags));
80103a33: 9c pushf
80103a34: 58 pop %eax
if(readeflags()&FL_IF)
80103a35: f6 c4 02 test $0x2,%ah
80103a38: 75 40 jne 80103a7a <sched+0x7a>
intena = mycpu()->intena;
80103a3a: e8 c1 fb ff ff call 80103600 <mycpu>
swtch(&p->context, mycpu()->scheduler);
80103a3f: 83 c3 20 add $0x20,%ebx
intena = mycpu()->intena;
80103a42: 8b b0 a8 00 00 00 mov 0xa8(%eax),%esi
swtch(&p->context, mycpu()->scheduler);
80103a48: e8 b3 fb ff ff call 80103600 <mycpu>
80103a4d: 8b 40 04 mov 0x4(%eax),%eax
80103a50: 89 1c 24 mov %ebx,(%esp)
80103a53: 89 44 24 04 mov %eax,0x4(%esp)
80103a57: e8 5f 0a 00 00 call 801044bb <swtch>
mycpu()->intena = intena;
80103a5c: e8 9f fb ff ff call 80103600 <mycpu>
80103a61: 89 b0 a8 00 00 00 mov %esi,0xa8(%eax)
}
80103a67: 83 c4 10 add $0x10,%esp
80103a6a: 5b pop %ebx
80103a6b: 5e pop %esi
80103a6c: 5d pop %ebp
80103a6d: c3 ret
panic("sched ptable.lock");
80103a6e: c7 04 24 10 74 10 80 movl $0x80107410,(%esp)
80103a75: e8 e6 c8 ff ff call 80100360 <panic>
panic("sched interruptible");
80103a7a: c7 04 24 3c 74 10 80 movl $0x8010743c,(%esp)
80103a81: e8 da c8 ff ff call 80100360 <panic>
panic("sched running");
80103a86: c7 04 24 2e 74 10 80 movl $0x8010742e,(%esp)
80103a8d: e8 ce c8 ff ff call 80100360 <panic>
panic("sched locks");
80103a92: c7 04 24 22 74 10 80 movl $0x80107422,(%esp)
80103a99: e8 c2 c8 ff ff call 80100360 <panic>
80103a9e: 66 90 xchg %ax,%ax
80103aa0 <exit>:
{
80103aa0: 55 push %ebp
80103aa1: 89 e5 mov %esp,%ebp
80103aa3: 56 push %esi
if(curproc == initproc)
80103aa4: 31 f6 xor %esi,%esi
{
80103aa6: 53 push %ebx
80103aa7: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103aaa: e8 f1 fb ff ff call 801036a0 <myproc>
if(curproc == initproc)
80103aaf: 3b 05 b8 a5 10 80 cmp 0x8010a5b8,%eax
struct proc *curproc = myproc();
80103ab5: 89 c3 mov %eax,%ebx
if(curproc == initproc)
80103ab7: 0f 84 ea 00 00 00 je 80103ba7 <exit+0x107>
80103abd: 8d 76 00 lea 0x0(%esi),%esi
if(curproc->ofile[fd]){
80103ac0: 8b 44 b3 2c mov 0x2c(%ebx,%esi,4),%eax
80103ac4: 85 c0 test %eax,%eax
80103ac6: 74 10 je 80103ad8 <exit+0x38>
fileclose(curproc->ofile[fd]);
80103ac8: 89 04 24 mov %eax,(%esp)
80103acb: e8 50 d3 ff ff call 80100e20 <fileclose>
curproc->ofile[fd] = 0;
80103ad0: c7 44 b3 2c 00 00 00 movl $0x0,0x2c(%ebx,%esi,4)
80103ad7: 00
for(fd = 0; fd < NOFILE; fd++){
80103ad8: 83 c6 01 add $0x1,%esi
80103adb: 83 fe 10 cmp $0x10,%esi
80103ade: 75 e0 jne 80103ac0 <exit+0x20>
begin_op();
80103ae0: e8 2b f0 ff ff call 80102b10 <begin_op>
iput(curproc->cwd);
80103ae5: 8b 43 6c mov 0x6c(%ebx),%eax
80103ae8: 89 04 24 mov %eax,(%esp)
80103aeb: e8 e0 dc ff ff call 801017d0 <iput>
end_op();
80103af0: e8 8b f0 ff ff call 80102b80 <end_op>
curproc->cwd = 0;
80103af5: c7 43 6c 00 00 00 00 movl $0x0,0x6c(%ebx)
acquire(&ptable.lock);
80103afc: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103b03: e8 38 06 00 00 call 80104140 <acquire>
wakeup1(curproc->parent);
80103b08: 8b 43 18 mov 0x18(%ebx),%eax
static void
wakeup1(void *chan)
{
struct proc *p;
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b0b: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b10: eb 11 jmp 80103b23 <exit+0x83>
80103b12: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103b18: 83 ea 80 sub $0xffffff80,%edx
80103b1b: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b21: 74 1d je 80103b40 <exit+0xa0>
if(p->state == SLEEPING && p->chan == chan)
80103b23: 83 7a 10 02 cmpl $0x2,0x10(%edx)
80103b27: 75 ef jne 80103b18 <exit+0x78>
80103b29: 3b 42 24 cmp 0x24(%edx),%eax
80103b2c: 75 ea jne 80103b18 <exit+0x78>
p->state = RUNNABLE;
80103b2e: c7 42 10 03 00 00 00 movl $0x3,0x10(%edx)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b35: 83 ea 80 sub $0xffffff80,%edx
80103b38: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b3e: 75 e3 jne 80103b23 <exit+0x83>
p->parent = initproc;
80103b40: a1 b8 a5 10 80 mov 0x8010a5b8,%eax
80103b45: b9 54 2d 11 80 mov $0x80112d54,%ecx
80103b4a: eb 0f jmp 80103b5b <exit+0xbb>
80103b4c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103b50: 83 e9 80 sub $0xffffff80,%ecx
80103b53: 81 f9 54 4d 11 80 cmp $0x80114d54,%ecx
80103b59: 74 34 je 80103b8f <exit+0xef>
if(p->parent == curproc){
80103b5b: 39 59 18 cmp %ebx,0x18(%ecx)
80103b5e: 75 f0 jne 80103b50 <exit+0xb0>
if(p->state == ZOMBIE)
80103b60: 83 79 10 05 cmpl $0x5,0x10(%ecx)
p->parent = initproc;
80103b64: 89 41 18 mov %eax,0x18(%ecx)
if(p->state == ZOMBIE)
80103b67: 75 e7 jne 80103b50 <exit+0xb0>
80103b69: ba 54 2d 11 80 mov $0x80112d54,%edx
80103b6e: eb 0b jmp 80103b7b <exit+0xdb>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103b70: 83 ea 80 sub $0xffffff80,%edx
80103b73: 81 fa 54 4d 11 80 cmp $0x80114d54,%edx
80103b79: 74 d5 je 80103b50 <exit+0xb0>
if(p->state == SLEEPING && p->chan == chan)
80103b7b: 83 7a 10 02 cmpl $0x2,0x10(%edx)
80103b7f: 75 ef jne 80103b70 <exit+0xd0>
80103b81: 3b 42 24 cmp 0x24(%edx),%eax
80103b84: 75 ea jne 80103b70 <exit+0xd0>
p->state = RUNNABLE;
80103b86: c7 42 10 03 00 00 00 movl $0x3,0x10(%edx)
80103b8d: eb e1 jmp 80103b70 <exit+0xd0>
curproc->state = ZOMBIE;
80103b8f: c7 43 10 05 00 00 00 movl $0x5,0x10(%ebx)
sched();
80103b96: e8 65 fe ff ff call 80103a00 <sched>
panic("zombie exit");
80103b9b: c7 04 24 5d 74 10 80 movl $0x8010745d,(%esp)
80103ba2: e8 b9 c7 ff ff call 80100360 <panic>
panic("init exiting");
80103ba7: c7 04 24 50 74 10 80 movl $0x80107450,(%esp)
80103bae: e8 ad c7 ff ff call 80100360 <panic>
80103bb3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103bb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103bc0 <yield>:
{
80103bc0: 55 push %ebp
80103bc1: 89 e5 mov %esp,%ebp
80103bc3: 83 ec 18 sub $0x18,%esp
acquire(&ptable.lock); //DOC: yieldlock
80103bc6: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bcd: e8 6e 05 00 00 call 80104140 <acquire>
myproc()->state = RUNNABLE;
80103bd2: e8 c9 fa ff ff call 801036a0 <myproc>
80103bd7: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
sched();
80103bde: e8 1d fe ff ff call 80103a00 <sched>
release(&ptable.lock);
80103be3: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103bea: e8 41 06 00 00 call 80104230 <release>
}
80103bef: c9 leave
80103bf0: c3 ret
80103bf1: eb 0d jmp 80103c00 <sleep>
80103bf3: 90 nop
80103bf4: 90 nop
80103bf5: 90 nop
80103bf6: 90 nop
80103bf7: 90 nop
80103bf8: 90 nop
80103bf9: 90 nop
80103bfa: 90 nop
80103bfb: 90 nop
80103bfc: 90 nop
80103bfd: 90 nop
80103bfe: 90 nop
80103bff: 90 nop
80103c00 <sleep>:
{
80103c00: 55 push %ebp
80103c01: 89 e5 mov %esp,%ebp
80103c03: 57 push %edi
80103c04: 56 push %esi
80103c05: 53 push %ebx
80103c06: 83 ec 1c sub $0x1c,%esp
80103c09: 8b 7d 08 mov 0x8(%ebp),%edi
80103c0c: 8b 75 0c mov 0xc(%ebp),%esi
struct proc *p = myproc();
80103c0f: e8 8c fa ff ff call 801036a0 <myproc>
if(p == 0)
80103c14: 85 c0 test %eax,%eax
struct proc *p = myproc();
80103c16: 89 c3 mov %eax,%ebx
if(p == 0)
80103c18: 0f 84 7c 00 00 00 je 80103c9a <sleep+0x9a>
if(lk == 0)
80103c1e: 85 f6 test %esi,%esi
80103c20: 74 6c je 80103c8e <sleep+0x8e>
if(lk != &ptable.lock){ //DOC: sleeplock0
80103c22: 81 fe 20 2d 11 80 cmp $0x80112d20,%esi
80103c28: 74 46 je 80103c70 <sleep+0x70>
acquire(&ptable.lock); //DOC: sleeplock1
80103c2a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c31: e8 0a 05 00 00 call 80104140 <acquire>
release(lk);
80103c36: 89 34 24 mov %esi,(%esp)
80103c39: e8 f2 05 00 00 call 80104230 <release>
p->chan = chan;
80103c3e: 89 7b 24 mov %edi,0x24(%ebx)
p->state = SLEEPING;
80103c41: c7 43 10 02 00 00 00 movl $0x2,0x10(%ebx)
sched();
80103c48: e8 b3 fd ff ff call 80103a00 <sched>
p->chan = 0;
80103c4d: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
release(&ptable.lock);
80103c54: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103c5b: e8 d0 05 00 00 call 80104230 <release>
acquire(lk);
80103c60: 89 75 08 mov %esi,0x8(%ebp)
}
80103c63: 83 c4 1c add $0x1c,%esp
80103c66: 5b pop %ebx
80103c67: 5e pop %esi
80103c68: 5f pop %edi
80103c69: 5d pop %ebp
acquire(lk);
80103c6a: e9 d1 04 00 00 jmp 80104140 <acquire>
80103c6f: 90 nop
p->chan = chan;
80103c70: 89 78 24 mov %edi,0x24(%eax)
p->state = SLEEPING;
80103c73: c7 40 10 02 00 00 00 movl $0x2,0x10(%eax)
sched();
80103c7a: e8 81 fd ff ff call 80103a00 <sched>
p->chan = 0;
80103c7f: c7 43 24 00 00 00 00 movl $0x0,0x24(%ebx)
}
80103c86: 83 c4 1c add $0x1c,%esp
80103c89: 5b pop %ebx
80103c8a: 5e pop %esi
80103c8b: 5f pop %edi
80103c8c: 5d pop %ebp
80103c8d: c3 ret
panic("sleep without lk");
80103c8e: c7 04 24 6f 74 10 80 movl $0x8010746f,(%esp)
80103c95: e8 c6 c6 ff ff call 80100360 <panic>
panic("sleep");
80103c9a: c7 04 24 69 74 10 80 movl $0x80107469,(%esp)
80103ca1: e8 ba c6 ff ff call 80100360 <panic>
80103ca6: 8d 76 00 lea 0x0(%esi),%esi
80103ca9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103cb0 <wait>:
{
80103cb0: 55 push %ebp
80103cb1: 89 e5 mov %esp,%ebp
80103cb3: 56 push %esi
80103cb4: 53 push %ebx
80103cb5: 83 ec 10 sub $0x10,%esp
struct proc *curproc = myproc();
80103cb8: e8 e3 f9 ff ff call 801036a0 <myproc>
acquire(&ptable.lock);
80103cbd: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
struct proc *curproc = myproc();
80103cc4: 89 c6 mov %eax,%esi
acquire(&ptable.lock);
80103cc6: e8 75 04 00 00 call 80104140 <acquire>
havekids = 0;
80103ccb: 31 c0 xor %eax,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103ccd: bb 54 2d 11 80 mov $0x80112d54,%ebx
80103cd2: eb 0f jmp 80103ce3 <wait+0x33>
80103cd4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80103cd8: 83 eb 80 sub $0xffffff80,%ebx
80103cdb: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103ce1: 74 1d je 80103d00 <wait+0x50>
if(p->parent != curproc)
80103ce3: 39 73 18 cmp %esi,0x18(%ebx)
80103ce6: 75 f0 jne 80103cd8 <wait+0x28>
if(p->state == ZOMBIE){
80103ce8: 83 7b 10 05 cmpl $0x5,0x10(%ebx)
80103cec: 74 2f je 80103d1d <wait+0x6d>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cee: 83 eb 80 sub $0xffffff80,%ebx
havekids = 1;
80103cf1: b8 01 00 00 00 mov $0x1,%eax
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103cf6: 81 fb 54 4d 11 80 cmp $0x80114d54,%ebx
80103cfc: 75 e5 jne 80103ce3 <wait+0x33>
80103cfe: 66 90 xchg %ax,%ax
if(!havekids || curproc->killed){
80103d00: 85 c0 test %eax,%eax
80103d02: 74 6e je 80103d72 <wait+0xc2>
80103d04: 8b 46 28 mov 0x28(%esi),%eax
80103d07: 85 c0 test %eax,%eax
80103d09: 75 67 jne 80103d72 <wait+0xc2>
sleep(curproc, &ptable.lock); //DOC: wait-sleep
80103d0b: c7 44 24 04 20 2d 11 movl $0x80112d20,0x4(%esp)
80103d12: 80
80103d13: 89 34 24 mov %esi,(%esp)
80103d16: e8 e5 fe ff ff call 80103c00 <sleep>
}
80103d1b: eb ae jmp 80103ccb <wait+0x1b>
kfree(p->kstack);
80103d1d: 8b 43 0c mov 0xc(%ebx),%eax
pid = p->pid;
80103d20: 8b 73 14 mov 0x14(%ebx),%esi
kfree(p->kstack);
80103d23: 89 04 24 mov %eax,(%esp)
80103d26: e8 c5 e5 ff ff call 801022f0 <kfree>
freevm(p->pgdir);
80103d2b: 8b 43 04 mov 0x4(%ebx),%eax
p->kstack = 0;
80103d2e: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
freevm(p->pgdir);
80103d35: 89 04 24 mov %eax,(%esp)
80103d38: e8 b3 2c 00 00 call 801069f0 <freevm>
release(&ptable.lock);
80103d3d: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
p->pid = 0;
80103d44: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
p->parent = 0;
80103d4b: c7 43 18 00 00 00 00 movl $0x0,0x18(%ebx)
p->name[0] = 0;
80103d52: c6 43 70 00 movb $0x0,0x70(%ebx)
p->killed = 0;
80103d56: c7 43 28 00 00 00 00 movl $0x0,0x28(%ebx)
p->state = UNUSED;
80103d5d: c7 43 10 00 00 00 00 movl $0x0,0x10(%ebx)
release(&ptable.lock);
80103d64: e8 c7 04 00 00 call 80104230 <release>
}
80103d69: 83 c4 10 add $0x10,%esp
return pid;
80103d6c: 89 f0 mov %esi,%eax
}
80103d6e: 5b pop %ebx
80103d6f: 5e pop %esi
80103d70: 5d pop %ebp
80103d71: c3 ret
release(&ptable.lock);
80103d72: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103d79: e8 b2 04 00 00 call 80104230 <release>
}
80103d7e: 83 c4 10 add $0x10,%esp
return -1;
80103d81: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103d86: 5b pop %ebx
80103d87: 5e pop %esi
80103d88: 5d pop %ebp
80103d89: c3 ret
80103d8a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80103d90 <wakeup>:
}
// Wake up all processes sleeping on chan.
void
wakeup(void *chan)
{
80103d90: 55 push %ebp
80103d91: 89 e5 mov %esp,%ebp
80103d93: 53 push %ebx
80103d94: 83 ec 14 sub $0x14,%esp
80103d97: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&ptable.lock);
80103d9a: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103da1: e8 9a 03 00 00 call 80104140 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103da6: b8 54 2d 11 80 mov $0x80112d54,%eax
80103dab: eb 0d jmp 80103dba <wakeup+0x2a>
80103dad: 8d 76 00 lea 0x0(%esi),%esi
80103db0: 83 e8 80 sub $0xffffff80,%eax
80103db3: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103db8: 74 1e je 80103dd8 <wakeup+0x48>
if(p->state == SLEEPING && p->chan == chan)
80103dba: 83 78 10 02 cmpl $0x2,0x10(%eax)
80103dbe: 75 f0 jne 80103db0 <wakeup+0x20>
80103dc0: 3b 58 24 cmp 0x24(%eax),%ebx
80103dc3: 75 eb jne 80103db0 <wakeup+0x20>
p->state = RUNNABLE;
80103dc5: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++)
80103dcc: 83 e8 80 sub $0xffffff80,%eax
80103dcf: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103dd4: 75 e4 jne 80103dba <wakeup+0x2a>
80103dd6: 66 90 xchg %ax,%ax
wakeup1(chan);
release(&ptable.lock);
80103dd8: c7 45 08 20 2d 11 80 movl $0x80112d20,0x8(%ebp)
}
80103ddf: 83 c4 14 add $0x14,%esp
80103de2: 5b pop %ebx
80103de3: 5d pop %ebp
release(&ptable.lock);
80103de4: e9 47 04 00 00 jmp 80104230 <release>
80103de9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80103df0 <kill>:
// Kill the process with the given pid.
// Process won't exit until it returns
// to user space (see trap in trap.c).
int
kill(int pid)
{
80103df0: 55 push %ebp
80103df1: 89 e5 mov %esp,%ebp
80103df3: 53 push %ebx
80103df4: 83 ec 14 sub $0x14,%esp
80103df7: 8b 5d 08 mov 0x8(%ebp),%ebx
struct proc *p;
acquire(&ptable.lock);
80103dfa: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e01: e8 3a 03 00 00 call 80104140 <acquire>
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103e06: b8 54 2d 11 80 mov $0x80112d54,%eax
80103e0b: eb 0d jmp 80103e1a <kill+0x2a>
80103e0d: 8d 76 00 lea 0x0(%esi),%esi
80103e10: 83 e8 80 sub $0xffffff80,%eax
80103e13: 3d 54 4d 11 80 cmp $0x80114d54,%eax
80103e18: 74 36 je 80103e50 <kill+0x60>
if(p->pid == pid){
80103e1a: 39 58 14 cmp %ebx,0x14(%eax)
80103e1d: 75 f1 jne 80103e10 <kill+0x20>
p->killed = 1;
// Wake process from sleep if necessary.
if(p->state == SLEEPING)
80103e1f: 83 78 10 02 cmpl $0x2,0x10(%eax)
p->killed = 1;
80103e23: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax)
if(p->state == SLEEPING)
80103e2a: 74 14 je 80103e40 <kill+0x50>
p->state = RUNNABLE;
release(&ptable.lock);
80103e2c: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e33: e8 f8 03 00 00 call 80104230 <release>
return 0;
}
}
release(&ptable.lock);
return -1;
}
80103e38: 83 c4 14 add $0x14,%esp
return 0;
80103e3b: 31 c0 xor %eax,%eax
}
80103e3d: 5b pop %ebx
80103e3e: 5d pop %ebp
80103e3f: c3 ret
p->state = RUNNABLE;
80103e40: c7 40 10 03 00 00 00 movl $0x3,0x10(%eax)
80103e47: eb e3 jmp 80103e2c <kill+0x3c>
80103e49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
release(&ptable.lock);
80103e50: c7 04 24 20 2d 11 80 movl $0x80112d20,(%esp)
80103e57: e8 d4 03 00 00 call 80104230 <release>
}
80103e5c: 83 c4 14 add $0x14,%esp
return -1;
80103e5f: b8 ff ff ff ff mov $0xffffffff,%eax
}
80103e64: 5b pop %ebx
80103e65: 5d pop %ebp
80103e66: c3 ret
80103e67: 89 f6 mov %esi,%esi
80103e69: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103e70 <procdump>:
// Print a process listing to console. For debugging.
// Runs when user types ^P on console.
// No lock to avoid wedging a stuck machine further.
void
procdump(void)
{
80103e70: 55 push %ebp
80103e71: 89 e5 mov %esp,%ebp
80103e73: 57 push %edi
80103e74: 56 push %esi
80103e75: 53 push %ebx
80103e76: bb c4 2d 11 80 mov $0x80112dc4,%ebx
80103e7b: 83 ec 4c sub $0x4c,%esp
80103e7e: 8d 75 e8 lea -0x18(%ebp),%esi
80103e81: eb 20 jmp 80103ea3 <procdump+0x33>
80103e83: 90 nop
80103e84: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(p->state == SLEEPING){
getcallerpcs((uint*)p->context->ebp+2, pc);
for(i=0; i<10 && pc[i] != 0; i++)
cprintf(" %p", pc[i]);
}
cprintf("\n");
80103e88: c7 04 24 eb 78 10 80 movl $0x801078eb,(%esp)
80103e8f: e8 bc c7 ff ff call 80100650 <cprintf>
80103e94: 83 eb 80 sub $0xffffff80,%ebx
for(p = ptable.proc; p < &ptable.proc[NPROC]; p++){
80103e97: 81 fb c4 4d 11 80 cmp $0x80114dc4,%ebx
80103e9d: 0f 84 8d 00 00 00 je 80103f30 <procdump+0xc0>
if(p->state == UNUSED)
80103ea3: 8b 43 a0 mov -0x60(%ebx),%eax
80103ea6: 85 c0 test %eax,%eax
80103ea8: 74 ea je 80103e94 <procdump+0x24>
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103eaa: 83 f8 05 cmp $0x5,%eax
state = "???";
80103ead: ba 80 74 10 80 mov $0x80107480,%edx
if(p->state >= 0 && p->state < NELEM(states) && states[p->state])
80103eb2: 77 11 ja 80103ec5 <procdump+0x55>
80103eb4: 8b 14 85 e0 74 10 80 mov -0x7fef8b20(,%eax,4),%edx
state = "???";
80103ebb: b8 80 74 10 80 mov $0x80107480,%eax
80103ec0: 85 d2 test %edx,%edx
80103ec2: 0f 44 d0 cmove %eax,%edx
cprintf("%d %s %s", p->pid, state, p->name);
80103ec5: 8b 43 a4 mov -0x5c(%ebx),%eax
80103ec8: 89 5c 24 0c mov %ebx,0xc(%esp)
80103ecc: 89 54 24 08 mov %edx,0x8(%esp)
80103ed0: c7 04 24 84 74 10 80 movl $0x80107484,(%esp)
80103ed7: 89 44 24 04 mov %eax,0x4(%esp)
80103edb: e8 70 c7 ff ff call 80100650 <cprintf>
if(p->state == SLEEPING){
80103ee0: 83 7b a0 02 cmpl $0x2,-0x60(%ebx)
80103ee4: 75 a2 jne 80103e88 <procdump+0x18>
getcallerpcs((uint*)p->context->ebp+2, pc);
80103ee6: 8d 45 c0 lea -0x40(%ebp),%eax
80103ee9: 89 44 24 04 mov %eax,0x4(%esp)
80103eed: 8b 43 b0 mov -0x50(%ebx),%eax
80103ef0: 8d 7d c0 lea -0x40(%ebp),%edi
80103ef3: 8b 40 0c mov 0xc(%eax),%eax
80103ef6: 83 c0 08 add $0x8,%eax
80103ef9: 89 04 24 mov %eax,(%esp)
80103efc: e8 6f 01 00 00 call 80104070 <getcallerpcs>
80103f01: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
for(i=0; i<10 && pc[i] != 0; i++)
80103f08: 8b 17 mov (%edi),%edx
80103f0a: 85 d2 test %edx,%edx
80103f0c: 0f 84 76 ff ff ff je 80103e88 <procdump+0x18>
cprintf(" %p", pc[i]);
80103f12: 89 54 24 04 mov %edx,0x4(%esp)
80103f16: 83 c7 04 add $0x4,%edi
80103f19: c7 04 24 a1 6e 10 80 movl $0x80106ea1,(%esp)
80103f20: e8 2b c7 ff ff call 80100650 <cprintf>
for(i=0; i<10 && pc[i] != 0; i++)
80103f25: 39 f7 cmp %esi,%edi
80103f27: 75 df jne 80103f08 <procdump+0x98>
80103f29: e9 5a ff ff ff jmp 80103e88 <procdump+0x18>
80103f2e: 66 90 xchg %ax,%ax
}
}
80103f30: 83 c4 4c add $0x4c,%esp
80103f33: 5b pop %ebx
80103f34: 5e pop %esi
80103f35: 5f pop %edi
80103f36: 5d pop %ebp
80103f37: c3 ret
80103f38: 66 90 xchg %ax,%ax
80103f3a: 66 90 xchg %ax,%ax
80103f3c: 66 90 xchg %ax,%ax
80103f3e: 66 90 xchg %ax,%ax
80103f40 <initsleeplock>:
#include "spinlock.h"
#include "sleeplock.h"
void
initsleeplock(struct sleeplock *lk, char *name)
{
80103f40: 55 push %ebp
80103f41: 89 e5 mov %esp,%ebp
80103f43: 53 push %ebx
80103f44: 83 ec 14 sub $0x14,%esp
80103f47: 8b 5d 08 mov 0x8(%ebp),%ebx
initlock(&lk->lk, "sleep lock");
80103f4a: c7 44 24 04 f8 74 10 movl $0x801074f8,0x4(%esp)
80103f51: 80
80103f52: 8d 43 04 lea 0x4(%ebx),%eax
80103f55: 89 04 24 mov %eax,(%esp)
80103f58: e8 f3 00 00 00 call 80104050 <initlock>
lk->name = name;
80103f5d: 8b 45 0c mov 0xc(%ebp),%eax
lk->locked = 0;
80103f60: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103f66: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
lk->name = name;
80103f6d: 89 43 38 mov %eax,0x38(%ebx)
}
80103f70: 83 c4 14 add $0x14,%esp
80103f73: 5b pop %ebx
80103f74: 5d pop %ebp
80103f75: c3 ret
80103f76: 8d 76 00 lea 0x0(%esi),%esi
80103f79: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80103f80 <acquiresleep>:
void
acquiresleep(struct sleeplock *lk)
{
80103f80: 55 push %ebp
80103f81: 89 e5 mov %esp,%ebp
80103f83: 56 push %esi
80103f84: 53 push %ebx
80103f85: 83 ec 10 sub $0x10,%esp
80103f88: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103f8b: 8d 73 04 lea 0x4(%ebx),%esi
80103f8e: 89 34 24 mov %esi,(%esp)
80103f91: e8 aa 01 00 00 call 80104140 <acquire>
while (lk->locked) {
80103f96: 8b 13 mov (%ebx),%edx
80103f98: 85 d2 test %edx,%edx
80103f9a: 74 16 je 80103fb2 <acquiresleep+0x32>
80103f9c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
sleep(lk, &lk->lk);
80103fa0: 89 74 24 04 mov %esi,0x4(%esp)
80103fa4: 89 1c 24 mov %ebx,(%esp)
80103fa7: e8 54 fc ff ff call 80103c00 <sleep>
while (lk->locked) {
80103fac: 8b 03 mov (%ebx),%eax
80103fae: 85 c0 test %eax,%eax
80103fb0: 75 ee jne 80103fa0 <acquiresleep+0x20>
}
lk->locked = 1;
80103fb2: c7 03 01 00 00 00 movl $0x1,(%ebx)
lk->pid = myproc()->pid;
80103fb8: e8 e3 f6 ff ff call 801036a0 <myproc>
80103fbd: 8b 40 14 mov 0x14(%eax),%eax
80103fc0: 89 43 3c mov %eax,0x3c(%ebx)
release(&lk->lk);
80103fc3: 89 75 08 mov %esi,0x8(%ebp)
}
80103fc6: 83 c4 10 add $0x10,%esp
80103fc9: 5b pop %ebx
80103fca: 5e pop %esi
80103fcb: 5d pop %ebp
release(&lk->lk);
80103fcc: e9 5f 02 00 00 jmp 80104230 <release>
80103fd1: eb 0d jmp 80103fe0 <releasesleep>
80103fd3: 90 nop
80103fd4: 90 nop
80103fd5: 90 nop
80103fd6: 90 nop
80103fd7: 90 nop
80103fd8: 90 nop
80103fd9: 90 nop
80103fda: 90 nop
80103fdb: 90 nop
80103fdc: 90 nop
80103fdd: 90 nop
80103fde: 90 nop
80103fdf: 90 nop
80103fe0 <releasesleep>:
void
releasesleep(struct sleeplock *lk)
{
80103fe0: 55 push %ebp
80103fe1: 89 e5 mov %esp,%ebp
80103fe3: 56 push %esi
80103fe4: 53 push %ebx
80103fe5: 83 ec 10 sub $0x10,%esp
80103fe8: 8b 5d 08 mov 0x8(%ebp),%ebx
acquire(&lk->lk);
80103feb: 8d 73 04 lea 0x4(%ebx),%esi
80103fee: 89 34 24 mov %esi,(%esp)
80103ff1: e8 4a 01 00 00 call 80104140 <acquire>
lk->locked = 0;
80103ff6: c7 03 00 00 00 00 movl $0x0,(%ebx)
lk->pid = 0;
80103ffc: c7 43 3c 00 00 00 00 movl $0x0,0x3c(%ebx)
wakeup(lk);
80104003: 89 1c 24 mov %ebx,(%esp)
80104006: e8 85 fd ff ff call 80103d90 <wakeup>
release(&lk->lk);
8010400b: 89 75 08 mov %esi,0x8(%ebp)
}
8010400e: 83 c4 10 add $0x10,%esp
80104011: 5b pop %ebx
80104012: 5e pop %esi
80104013: 5d pop %ebp
release(&lk->lk);
80104014: e9 17 02 00 00 jmp 80104230 <release>
80104019: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104020 <holdingsleep>:
int
holdingsleep(struct sleeplock *lk)
{
80104020: 55 push %ebp
80104021: 89 e5 mov %esp,%ebp
80104023: 56 push %esi
80104024: 53 push %ebx
80104025: 83 ec 10 sub $0x10,%esp
80104028: 8b 5d 08 mov 0x8(%ebp),%ebx
int r;
acquire(&lk->lk);
8010402b: 8d 73 04 lea 0x4(%ebx),%esi
8010402e: 89 34 24 mov %esi,(%esp)
80104031: e8 0a 01 00 00 call 80104140 <acquire>
r = lk->locked;
80104036: 8b 1b mov (%ebx),%ebx
release(&lk->lk);
80104038: 89 34 24 mov %esi,(%esp)
8010403b: e8 f0 01 00 00 call 80104230 <release>
return r;
}
80104040: 83 c4 10 add $0x10,%esp
80104043: 89 d8 mov %ebx,%eax
80104045: 5b pop %ebx
80104046: 5e pop %esi
80104047: 5d pop %ebp
80104048: c3 ret
80104049: 66 90 xchg %ax,%ax
8010404b: 66 90 xchg %ax,%ax
8010404d: 66 90 xchg %ax,%ax
8010404f: 90 nop
80104050 <initlock>:
#include "proc.h"
#include "spinlock.h"
void
initlock(struct spinlock *lk, char *name)
{
80104050: 55 push %ebp
80104051: 89 e5 mov %esp,%ebp
80104053: 8b 45 08 mov 0x8(%ebp),%eax
lk->name = name;
80104056: 8b 55 0c mov 0xc(%ebp),%edx
lk->locked = 0;
80104059: c7 00 00 00 00 00 movl $0x0,(%eax)
lk->name = name;
8010405f: 89 50 04 mov %edx,0x4(%eax)
lk->cpu = 0;
80104062: c7 40 08 00 00 00 00 movl $0x0,0x8(%eax)
}
80104069: 5d pop %ebp
8010406a: c3 ret
8010406b: 90 nop
8010406c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104070 <getcallerpcs>:
}
// Record the current call stack in pcs[] by following the %ebp chain.
void
getcallerpcs(void *v, uint pcs[])
{
80104070: 55 push %ebp
80104071: 89 e5 mov %esp,%ebp
uint *ebp;
int i;
ebp = (uint*)v - 2;
80104073: 8b 45 08 mov 0x8(%ebp),%eax
{
80104076: 8b 4d 0c mov 0xc(%ebp),%ecx
80104079: 53 push %ebx
ebp = (uint*)v - 2;
8010407a: 8d 50 f8 lea -0x8(%eax),%edx
for(i = 0; i < 10; i++){
8010407d: 31 c0 xor %eax,%eax
8010407f: 90 nop
if(ebp == 0 || ebp < (uint*)KERNBASE || ebp == (uint*)0xffffffff)
80104080: 8d 9a 00 00 00 80 lea -0x80000000(%edx),%ebx
80104086: 81 fb fe ff ff 7f cmp $0x7ffffffe,%ebx
8010408c: 77 1a ja 801040a8 <getcallerpcs+0x38>
break;
pcs[i] = ebp[1]; // saved %eip
8010408e: 8b 5a 04 mov 0x4(%edx),%ebx
80104091: 89 1c 81 mov %ebx,(%ecx,%eax,4)
for(i = 0; i < 10; i++){
80104094: 83 c0 01 add $0x1,%eax
ebp = (uint*)ebp[0]; // saved %ebp
80104097: 8b 12 mov (%edx),%edx
for(i = 0; i < 10; i++){
80104099: 83 f8 0a cmp $0xa,%eax
8010409c: 75 e2 jne 80104080 <getcallerpcs+0x10>
}
for(; i < 10; i++)
pcs[i] = 0;
}
8010409e: 5b pop %ebx
8010409f: 5d pop %ebp
801040a0: c3 ret
801040a1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
pcs[i] = 0;
801040a8: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
801040af: 83 c0 01 add $0x1,%eax
801040b2: 83 f8 0a cmp $0xa,%eax
801040b5: 74 e7 je 8010409e <getcallerpcs+0x2e>
pcs[i] = 0;
801040b7: c7 04 81 00 00 00 00 movl $0x0,(%ecx,%eax,4)
for(; i < 10; i++)
801040be: 83 c0 01 add $0x1,%eax
801040c1: 83 f8 0a cmp $0xa,%eax
801040c4: 75 e2 jne 801040a8 <getcallerpcs+0x38>
801040c6: eb d6 jmp 8010409e <getcallerpcs+0x2e>
801040c8: 90 nop
801040c9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801040d0 <holding>:
// Check whether this cpu is holding the lock.
int
holding(struct spinlock *lock)
{
801040d0: 55 push %ebp
return lock->locked && lock->cpu == mycpu();
801040d1: 31 c0 xor %eax,%eax
{
801040d3: 89 e5 mov %esp,%ebp
801040d5: 53 push %ebx
801040d6: 83 ec 04 sub $0x4,%esp
801040d9: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
801040dc: 8b 0a mov (%edx),%ecx
801040de: 85 c9 test %ecx,%ecx
801040e0: 74 10 je 801040f2 <holding+0x22>
801040e2: 8b 5a 08 mov 0x8(%edx),%ebx
801040e5: e8 16 f5 ff ff call 80103600 <mycpu>
801040ea: 39 c3 cmp %eax,%ebx
801040ec: 0f 94 c0 sete %al
801040ef: 0f b6 c0 movzbl %al,%eax
}
801040f2: 83 c4 04 add $0x4,%esp
801040f5: 5b pop %ebx
801040f6: 5d pop %ebp
801040f7: c3 ret
801040f8: 90 nop
801040f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104100 <pushcli>:
// it takes two popcli to undo two pushcli. Also, if interrupts
// are off, then pushcli, popcli leaves them off.
void
pushcli(void)
{
80104100: 55 push %ebp
80104101: 89 e5 mov %esp,%ebp
80104103: 53 push %ebx
80104104: 83 ec 04 sub $0x4,%esp
80104107: 9c pushf
80104108: 5b pop %ebx
asm volatile("cli");
80104109: fa cli
int eflags;
eflags = readeflags();
cli();
if(mycpu()->ncli == 0)
8010410a: e8 f1 f4 ff ff call 80103600 <mycpu>
8010410f: 8b 80 a4 00 00 00 mov 0xa4(%eax),%eax
80104115: 85 c0 test %eax,%eax
80104117: 75 11 jne 8010412a <pushcli+0x2a>
mycpu()->intena = eflags & FL_IF;
80104119: e8 e2 f4 ff ff call 80103600 <mycpu>
8010411e: 81 e3 00 02 00 00 and $0x200,%ebx
80104124: 89 98 a8 00 00 00 mov %ebx,0xa8(%eax)
mycpu()->ncli += 1;
8010412a: e8 d1 f4 ff ff call 80103600 <mycpu>
8010412f: 83 80 a4 00 00 00 01 addl $0x1,0xa4(%eax)
}
80104136: 83 c4 04 add $0x4,%esp
80104139: 5b pop %ebx
8010413a: 5d pop %ebp
8010413b: c3 ret
8010413c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104140 <acquire>:
{
80104140: 55 push %ebp
80104141: 89 e5 mov %esp,%ebp
80104143: 53 push %ebx
80104144: 83 ec 14 sub $0x14,%esp
pushcli(); // disable interrupts to avoid deadlock.
80104147: e8 b4 ff ff ff call 80104100 <pushcli>
if(holding(lk))
8010414c: 8b 55 08 mov 0x8(%ebp),%edx
return lock->locked && lock->cpu == mycpu();
8010414f: 8b 02 mov (%edx),%eax
80104151: 85 c0 test %eax,%eax
80104153: 75 43 jne 80104198 <acquire+0x58>
asm volatile("lock; xchgl %0, %1" :
80104155: b9 01 00 00 00 mov $0x1,%ecx
8010415a: eb 07 jmp 80104163 <acquire+0x23>
8010415c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104160: 8b 55 08 mov 0x8(%ebp),%edx
80104163: 89 c8 mov %ecx,%eax
80104165: f0 87 02 lock xchg %eax,(%edx)
while(xchg(&lk->locked, 1) != 0)
80104168: 85 c0 test %eax,%eax
8010416a: 75 f4 jne 80104160 <acquire+0x20>
__sync_synchronize();
8010416c: 0f ae f0 mfence
lk->cpu = mycpu();
8010416f: 8b 5d 08 mov 0x8(%ebp),%ebx
80104172: e8 89 f4 ff ff call 80103600 <mycpu>
80104177: 89 43 08 mov %eax,0x8(%ebx)
getcallerpcs(&lk, lk->pcs);
8010417a: 8b 45 08 mov 0x8(%ebp),%eax
8010417d: 83 c0 0c add $0xc,%eax
80104180: 89 44 24 04 mov %eax,0x4(%esp)
80104184: 8d 45 08 lea 0x8(%ebp),%eax
80104187: 89 04 24 mov %eax,(%esp)
8010418a: e8 e1 fe ff ff call 80104070 <getcallerpcs>
}
8010418f: 83 c4 14 add $0x14,%esp
80104192: 5b pop %ebx
80104193: 5d pop %ebp
80104194: c3 ret
80104195: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104198: 8b 5a 08 mov 0x8(%edx),%ebx
8010419b: e8 60 f4 ff ff call 80103600 <mycpu>
if(holding(lk))
801041a0: 39 c3 cmp %eax,%ebx
801041a2: 74 05 je 801041a9 <acquire+0x69>
801041a4: 8b 55 08 mov 0x8(%ebp),%edx
801041a7: eb ac jmp 80104155 <acquire+0x15>
panic("acquire");
801041a9: c7 04 24 03 75 10 80 movl $0x80107503,(%esp)
801041b0: e8 ab c1 ff ff call 80100360 <panic>
801041b5: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801041b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801041c0 <popcli>:
void
popcli(void)
{
801041c0: 55 push %ebp
801041c1: 89 e5 mov %esp,%ebp
801041c3: 83 ec 18 sub $0x18,%esp
asm volatile("pushfl; popl %0" : "=r" (eflags));
801041c6: 9c pushf
801041c7: 58 pop %eax
if(readeflags()&FL_IF)
801041c8: f6 c4 02 test $0x2,%ah
801041cb: 75 49 jne 80104216 <popcli+0x56>
panic("popcli - interruptible");
if(--mycpu()->ncli < 0)
801041cd: e8 2e f4 ff ff call 80103600 <mycpu>
801041d2: 8b 88 a4 00 00 00 mov 0xa4(%eax),%ecx
801041d8: 8d 51 ff lea -0x1(%ecx),%edx
801041db: 85 d2 test %edx,%edx
801041dd: 89 90 a4 00 00 00 mov %edx,0xa4(%eax)
801041e3: 78 25 js 8010420a <popcli+0x4a>
panic("popcli");
if(mycpu()->ncli == 0 && mycpu()->intena)
801041e5: e8 16 f4 ff ff call 80103600 <mycpu>
801041ea: 8b 90 a4 00 00 00 mov 0xa4(%eax),%edx
801041f0: 85 d2 test %edx,%edx
801041f2: 74 04 je 801041f8 <popcli+0x38>
sti();
}
801041f4: c9 leave
801041f5: c3 ret
801041f6: 66 90 xchg %ax,%ax
if(mycpu()->ncli == 0 && mycpu()->intena)
801041f8: e8 03 f4 ff ff call 80103600 <mycpu>
801041fd: 8b 80 a8 00 00 00 mov 0xa8(%eax),%eax
80104203: 85 c0 test %eax,%eax
80104205: 74 ed je 801041f4 <popcli+0x34>
asm volatile("sti");
80104207: fb sti
}
80104208: c9 leave
80104209: c3 ret
panic("popcli");
8010420a: c7 04 24 22 75 10 80 movl $0x80107522,(%esp)
80104211: e8 4a c1 ff ff call 80100360 <panic>
panic("popcli - interruptible");
80104216: c7 04 24 0b 75 10 80 movl $0x8010750b,(%esp)
8010421d: e8 3e c1 ff ff call 80100360 <panic>
80104222: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104229: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104230 <release>:
{
80104230: 55 push %ebp
80104231: 89 e5 mov %esp,%ebp
80104233: 56 push %esi
80104234: 53 push %ebx
80104235: 83 ec 10 sub $0x10,%esp
80104238: 8b 5d 08 mov 0x8(%ebp),%ebx
return lock->locked && lock->cpu == mycpu();
8010423b: 8b 03 mov (%ebx),%eax
8010423d: 85 c0 test %eax,%eax
8010423f: 75 0f jne 80104250 <release+0x20>
panic("release");
80104241: c7 04 24 29 75 10 80 movl $0x80107529,(%esp)
80104248: e8 13 c1 ff ff call 80100360 <panic>
8010424d: 8d 76 00 lea 0x0(%esi),%esi
return lock->locked && lock->cpu == mycpu();
80104250: 8b 73 08 mov 0x8(%ebx),%esi
80104253: e8 a8 f3 ff ff call 80103600 <mycpu>
if(!holding(lk))
80104258: 39 c6 cmp %eax,%esi
8010425a: 75 e5 jne 80104241 <release+0x11>
lk->pcs[0] = 0;
8010425c: c7 43 0c 00 00 00 00 movl $0x0,0xc(%ebx)
lk->cpu = 0;
80104263: c7 43 08 00 00 00 00 movl $0x0,0x8(%ebx)
__sync_synchronize();
8010426a: 0f ae f0 mfence
asm volatile("movl $0, %0" : "+m" (lk->locked) : );
8010426d: c7 03 00 00 00 00 movl $0x0,(%ebx)
}
80104273: 83 c4 10 add $0x10,%esp
80104276: 5b pop %ebx
80104277: 5e pop %esi
80104278: 5d pop %ebp
popcli();
80104279: e9 42 ff ff ff jmp 801041c0 <popcli>
8010427e: 66 90 xchg %ax,%ax
80104280 <memset>:
#include "types.h"
#include "x86.h"
void*
memset(void *dst, int c, uint n)
{
80104280: 55 push %ebp
80104281: 89 e5 mov %esp,%ebp
80104283: 8b 55 08 mov 0x8(%ebp),%edx
80104286: 57 push %edi
80104287: 8b 4d 10 mov 0x10(%ebp),%ecx
8010428a: 53 push %ebx
if ((int)dst%4 == 0 && n%4 == 0){
8010428b: f6 c2 03 test $0x3,%dl
8010428e: 75 05 jne 80104295 <memset+0x15>
80104290: f6 c1 03 test $0x3,%cl
80104293: 74 13 je 801042a8 <memset+0x28>
asm volatile("cld; rep stosb" :
80104295: 89 d7 mov %edx,%edi
80104297: 8b 45 0c mov 0xc(%ebp),%eax
8010429a: fc cld
8010429b: f3 aa rep stos %al,%es:(%edi)
c &= 0xFF;
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
} else
stosb(dst, c, n);
return dst;
}
8010429d: 5b pop %ebx
8010429e: 89 d0 mov %edx,%eax
801042a0: 5f pop %edi
801042a1: 5d pop %ebp
801042a2: c3 ret
801042a3: 90 nop
801042a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
c &= 0xFF;
801042a8: 0f b6 7d 0c movzbl 0xc(%ebp),%edi
stosl(dst, (c<<24)|(c<<16)|(c<<8)|c, n/4);
801042ac: c1 e9 02 shr $0x2,%ecx
801042af: 89 f8 mov %edi,%eax
801042b1: 89 fb mov %edi,%ebx
801042b3: c1 e0 18 shl $0x18,%eax
801042b6: c1 e3 10 shl $0x10,%ebx
801042b9: 09 d8 or %ebx,%eax
801042bb: 09 f8 or %edi,%eax
801042bd: c1 e7 08 shl $0x8,%edi
801042c0: 09 f8 or %edi,%eax
asm volatile("cld; rep stosl" :
801042c2: 89 d7 mov %edx,%edi
801042c4: fc cld
801042c5: f3 ab rep stos %eax,%es:(%edi)
}
801042c7: 5b pop %ebx
801042c8: 89 d0 mov %edx,%eax
801042ca: 5f pop %edi
801042cb: 5d pop %ebp
801042cc: c3 ret
801042cd: 8d 76 00 lea 0x0(%esi),%esi
801042d0 <memcmp>:
int
memcmp(const void *v1, const void *v2, uint n)
{
801042d0: 55 push %ebp
801042d1: 89 e5 mov %esp,%ebp
801042d3: 8b 45 10 mov 0x10(%ebp),%eax
801042d6: 57 push %edi
801042d7: 56 push %esi
801042d8: 8b 75 0c mov 0xc(%ebp),%esi
801042db: 53 push %ebx
801042dc: 8b 5d 08 mov 0x8(%ebp),%ebx
const uchar *s1, *s2;
s1 = v1;
s2 = v2;
while(n-- > 0){
801042df: 85 c0 test %eax,%eax
801042e1: 8d 78 ff lea -0x1(%eax),%edi
801042e4: 74 26 je 8010430c <memcmp+0x3c>
if(*s1 != *s2)
801042e6: 0f b6 03 movzbl (%ebx),%eax
801042e9: 31 d2 xor %edx,%edx
801042eb: 0f b6 0e movzbl (%esi),%ecx
801042ee: 38 c8 cmp %cl,%al
801042f0: 74 16 je 80104308 <memcmp+0x38>
801042f2: eb 24 jmp 80104318 <memcmp+0x48>
801042f4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801042f8: 0f b6 44 13 01 movzbl 0x1(%ebx,%edx,1),%eax
801042fd: 83 c2 01 add $0x1,%edx
80104300: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104304: 38 c8 cmp %cl,%al
80104306: 75 10 jne 80104318 <memcmp+0x48>
while(n-- > 0){
80104308: 39 fa cmp %edi,%edx
8010430a: 75 ec jne 801042f8 <memcmp+0x28>
return *s1 - *s2;
s1++, s2++;
}
return 0;
}
8010430c: 5b pop %ebx
return 0;
8010430d: 31 c0 xor %eax,%eax
}
8010430f: 5e pop %esi
80104310: 5f pop %edi
80104311: 5d pop %ebp
80104312: c3 ret
80104313: 90 nop
80104314: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104318: 5b pop %ebx
return *s1 - *s2;
80104319: 29 c8 sub %ecx,%eax
}
8010431b: 5e pop %esi
8010431c: 5f pop %edi
8010431d: 5d pop %ebp
8010431e: c3 ret
8010431f: 90 nop
80104320 <memmove>:
void*
memmove(void *dst, const void *src, uint n)
{
80104320: 55 push %ebp
80104321: 89 e5 mov %esp,%ebp
80104323: 57 push %edi
80104324: 8b 45 08 mov 0x8(%ebp),%eax
80104327: 56 push %esi
80104328: 8b 75 0c mov 0xc(%ebp),%esi
8010432b: 53 push %ebx
8010432c: 8b 5d 10 mov 0x10(%ebp),%ebx
const char *s;
char *d;
s = src;
d = dst;
if(s < d && s + n > d){
8010432f: 39 c6 cmp %eax,%esi
80104331: 73 35 jae 80104368 <memmove+0x48>
80104333: 8d 0c 1e lea (%esi,%ebx,1),%ecx
80104336: 39 c8 cmp %ecx,%eax
80104338: 73 2e jae 80104368 <memmove+0x48>
s += n;
d += n;
while(n-- > 0)
8010433a: 85 db test %ebx,%ebx
d += n;
8010433c: 8d 3c 18 lea (%eax,%ebx,1),%edi
while(n-- > 0)
8010433f: 8d 53 ff lea -0x1(%ebx),%edx
80104342: 74 1b je 8010435f <memmove+0x3f>
80104344: f7 db neg %ebx
80104346: 8d 34 19 lea (%ecx,%ebx,1),%esi
80104349: 01 fb add %edi,%ebx
8010434b: 90 nop
8010434c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
*--d = *--s;
80104350: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104354: 88 0c 13 mov %cl,(%ebx,%edx,1)
while(n-- > 0)
80104357: 83 ea 01 sub $0x1,%edx
8010435a: 83 fa ff cmp $0xffffffff,%edx
8010435d: 75 f1 jne 80104350 <memmove+0x30>
} else
while(n-- > 0)
*d++ = *s++;
return dst;
}
8010435f: 5b pop %ebx
80104360: 5e pop %esi
80104361: 5f pop %edi
80104362: 5d pop %ebp
80104363: c3 ret
80104364: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
while(n-- > 0)
80104368: 31 d2 xor %edx,%edx
8010436a: 85 db test %ebx,%ebx
8010436c: 74 f1 je 8010435f <memmove+0x3f>
8010436e: 66 90 xchg %ax,%ax
*d++ = *s++;
80104370: 0f b6 0c 16 movzbl (%esi,%edx,1),%ecx
80104374: 88 0c 10 mov %cl,(%eax,%edx,1)
80104377: 83 c2 01 add $0x1,%edx
while(n-- > 0)
8010437a: 39 da cmp %ebx,%edx
8010437c: 75 f2 jne 80104370 <memmove+0x50>
}
8010437e: 5b pop %ebx
8010437f: 5e pop %esi
80104380: 5f pop %edi
80104381: 5d pop %ebp
80104382: c3 ret
80104383: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104389: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104390 <memcpy>:
// memcpy exists to placate GCC. Use memmove.
void*
memcpy(void *dst, const void *src, uint n)
{
80104390: 55 push %ebp
80104391: 89 e5 mov %esp,%ebp
return memmove(dst, src, n);
}
80104393: 5d pop %ebp
return memmove(dst, src, n);
80104394: eb 8a jmp 80104320 <memmove>
80104396: 8d 76 00 lea 0x0(%esi),%esi
80104399: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801043a0 <strncmp>:
int
strncmp(const char *p, const char *q, uint n)
{
801043a0: 55 push %ebp
801043a1: 89 e5 mov %esp,%ebp
801043a3: 56 push %esi
801043a4: 8b 75 10 mov 0x10(%ebp),%esi
801043a7: 53 push %ebx
801043a8: 8b 4d 08 mov 0x8(%ebp),%ecx
801043ab: 8b 5d 0c mov 0xc(%ebp),%ebx
while(n > 0 && *p && *p == *q)
801043ae: 85 f6 test %esi,%esi
801043b0: 74 30 je 801043e2 <strncmp+0x42>
801043b2: 0f b6 01 movzbl (%ecx),%eax
801043b5: 84 c0 test %al,%al
801043b7: 74 2f je 801043e8 <strncmp+0x48>
801043b9: 0f b6 13 movzbl (%ebx),%edx
801043bc: 38 d0 cmp %dl,%al
801043be: 75 46 jne 80104406 <strncmp+0x66>
801043c0: 8d 51 01 lea 0x1(%ecx),%edx
801043c3: 01 ce add %ecx,%esi
801043c5: eb 14 jmp 801043db <strncmp+0x3b>
801043c7: 90 nop
801043c8: 0f b6 02 movzbl (%edx),%eax
801043cb: 84 c0 test %al,%al
801043cd: 74 31 je 80104400 <strncmp+0x60>
801043cf: 0f b6 19 movzbl (%ecx),%ebx
801043d2: 83 c2 01 add $0x1,%edx
801043d5: 38 d8 cmp %bl,%al
801043d7: 75 17 jne 801043f0 <strncmp+0x50>
n--, p++, q++;
801043d9: 89 cb mov %ecx,%ebx
while(n > 0 && *p && *p == *q)
801043db: 39 f2 cmp %esi,%edx
n--, p++, q++;
801043dd: 8d 4b 01 lea 0x1(%ebx),%ecx
while(n > 0 && *p && *p == *q)
801043e0: 75 e6 jne 801043c8 <strncmp+0x28>
if(n == 0)
return 0;
return (uchar)*p - (uchar)*q;
}
801043e2: 5b pop %ebx
return 0;
801043e3: 31 c0 xor %eax,%eax
}
801043e5: 5e pop %esi
801043e6: 5d pop %ebp
801043e7: c3 ret
801043e8: 0f b6 1b movzbl (%ebx),%ebx
while(n > 0 && *p && *p == *q)
801043eb: 31 c0 xor %eax,%eax
801043ed: 8d 76 00 lea 0x0(%esi),%esi
return (uchar)*p - (uchar)*q;
801043f0: 0f b6 d3 movzbl %bl,%edx
801043f3: 29 d0 sub %edx,%eax
}
801043f5: 5b pop %ebx
801043f6: 5e pop %esi
801043f7: 5d pop %ebp
801043f8: c3 ret
801043f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104400: 0f b6 5b 01 movzbl 0x1(%ebx),%ebx
80104404: eb ea jmp 801043f0 <strncmp+0x50>
while(n > 0 && *p && *p == *q)
80104406: 89 d3 mov %edx,%ebx
80104408: eb e6 jmp 801043f0 <strncmp+0x50>
8010440a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104410 <strncpy>:
char*
strncpy(char *s, const char *t, int n)
{
80104410: 55 push %ebp
80104411: 89 e5 mov %esp,%ebp
80104413: 8b 45 08 mov 0x8(%ebp),%eax
80104416: 56 push %esi
80104417: 8b 4d 10 mov 0x10(%ebp),%ecx
8010441a: 53 push %ebx
8010441b: 8b 5d 0c mov 0xc(%ebp),%ebx
char *os;
os = s;
while(n-- > 0 && (*s++ = *t++) != 0)
8010441e: 89 c2 mov %eax,%edx
80104420: eb 19 jmp 8010443b <strncpy+0x2b>
80104422: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80104428: 83 c3 01 add $0x1,%ebx
8010442b: 0f b6 4b ff movzbl -0x1(%ebx),%ecx
8010442f: 83 c2 01 add $0x1,%edx
80104432: 84 c9 test %cl,%cl
80104434: 88 4a ff mov %cl,-0x1(%edx)
80104437: 74 09 je 80104442 <strncpy+0x32>
80104439: 89 f1 mov %esi,%ecx
8010443b: 85 c9 test %ecx,%ecx
8010443d: 8d 71 ff lea -0x1(%ecx),%esi
80104440: 7f e6 jg 80104428 <strncpy+0x18>
;
while(n-- > 0)
80104442: 31 c9 xor %ecx,%ecx
80104444: 85 f6 test %esi,%esi
80104446: 7e 0f jle 80104457 <strncpy+0x47>
*s++ = 0;
80104448: c6 04 0a 00 movb $0x0,(%edx,%ecx,1)
8010444c: 89 f3 mov %esi,%ebx
8010444e: 83 c1 01 add $0x1,%ecx
80104451: 29 cb sub %ecx,%ebx
while(n-- > 0)
80104453: 85 db test %ebx,%ebx
80104455: 7f f1 jg 80104448 <strncpy+0x38>
return os;
}
80104457: 5b pop %ebx
80104458: 5e pop %esi
80104459: 5d pop %ebp
8010445a: c3 ret
8010445b: 90 nop
8010445c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104460 <safestrcpy>:
// Like strncpy but guaranteed to NUL-terminate.
char*
safestrcpy(char *s, const char *t, int n)
{
80104460: 55 push %ebp
80104461: 89 e5 mov %esp,%ebp
80104463: 8b 4d 10 mov 0x10(%ebp),%ecx
80104466: 56 push %esi
80104467: 8b 45 08 mov 0x8(%ebp),%eax
8010446a: 53 push %ebx
8010446b: 8b 55 0c mov 0xc(%ebp),%edx
char *os;
os = s;
if(n <= 0)
8010446e: 85 c9 test %ecx,%ecx
80104470: 7e 26 jle 80104498 <safestrcpy+0x38>
80104472: 8d 74 0a ff lea -0x1(%edx,%ecx,1),%esi
80104476: 89 c1 mov %eax,%ecx
80104478: eb 17 jmp 80104491 <safestrcpy+0x31>
8010447a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return os;
while(--n > 0 && (*s++ = *t++) != 0)
80104480: 83 c2 01 add $0x1,%edx
80104483: 0f b6 5a ff movzbl -0x1(%edx),%ebx
80104487: 83 c1 01 add $0x1,%ecx
8010448a: 84 db test %bl,%bl
8010448c: 88 59 ff mov %bl,-0x1(%ecx)
8010448f: 74 04 je 80104495 <safestrcpy+0x35>
80104491: 39 f2 cmp %esi,%edx
80104493: 75 eb jne 80104480 <safestrcpy+0x20>
;
*s = 0;
80104495: c6 01 00 movb $0x0,(%ecx)
return os;
}
80104498: 5b pop %ebx
80104499: 5e pop %esi
8010449a: 5d pop %ebp
8010449b: c3 ret
8010449c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801044a0 <strlen>:
int
strlen(const char *s)
{
801044a0: 55 push %ebp
int n;
for(n = 0; s[n]; n++)
801044a1: 31 c0 xor %eax,%eax
{
801044a3: 89 e5 mov %esp,%ebp
801044a5: 8b 55 08 mov 0x8(%ebp),%edx
for(n = 0; s[n]; n++)
801044a8: 80 3a 00 cmpb $0x0,(%edx)
801044ab: 74 0c je 801044b9 <strlen+0x19>
801044ad: 8d 76 00 lea 0x0(%esi),%esi
801044b0: 83 c0 01 add $0x1,%eax
801044b3: 80 3c 02 00 cmpb $0x0,(%edx,%eax,1)
801044b7: 75 f7 jne 801044b0 <strlen+0x10>
;
return n;
}
801044b9: 5d pop %ebp
801044ba: c3 ret
801044bb <swtch>:
# Save current register context in old
# and then load register context from new.
.globl swtch
swtch:
movl 4(%esp), %eax
801044bb: 8b 44 24 04 mov 0x4(%esp),%eax
movl 8(%esp), %edx
801044bf: 8b 54 24 08 mov 0x8(%esp),%edx
# Save old callee-save registers
pushl %ebp
801044c3: 55 push %ebp
pushl %ebx
801044c4: 53 push %ebx
pushl %esi
801044c5: 56 push %esi
pushl %edi
801044c6: 57 push %edi
# Switch stacks
movl %esp, (%eax)
801044c7: 89 20 mov %esp,(%eax)
movl %edx, %esp
801044c9: 89 d4 mov %edx,%esp
# Load new callee-save registers
popl %edi
801044cb: 5f pop %edi
popl %esi
801044cc: 5e pop %esi
popl %ebx
801044cd: 5b pop %ebx
popl %ebp
801044ce: 5d pop %ebp
ret
801044cf: c3 ret
801044d0 <fetchint>:
// to a saved program counter, and then the first argument.
// Fetch the int at addr from the current process.
int
fetchint(uint addr, int *ip)
{
801044d0: 55 push %ebp
801044d1: 89 e5 mov %esp,%ebp
801044d3: 8b 45 08 mov 0x8(%ebp),%eax
// struct proc *curproc = myproc();
if(addr >= KERNBASE2 || addr+4 > KERNBASE2)
801044d6: 3d fb ff ff 7f cmp $0x7ffffffb,%eax
801044db: 77 0b ja 801044e8 <fetchint+0x18>
return -1;
*ip = *(int*)(addr);
801044dd: 8b 10 mov (%eax),%edx
801044df: 8b 45 0c mov 0xc(%ebp),%eax
801044e2: 89 10 mov %edx,(%eax)
return 0;
801044e4: 31 c0 xor %eax,%eax
}
801044e6: 5d pop %ebp
801044e7: c3 ret
return -1;
801044e8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801044ed: 5d pop %ebp
801044ee: c3 ret
801044ef: 90 nop
801044f0 <fetchstr>:
// Fetch the nul-terminated string at addr from the current process.
// Doesn't actually copy the string - just sets *pp to point at it.
// Returns length of string, not including nul.
int
fetchstr(uint addr, char **pp)
{
801044f0: 55 push %ebp
801044f1: 89 e5 mov %esp,%ebp
801044f3: 8b 55 08 mov 0x8(%ebp),%edx
char *s, *ep;
// struct proc *curproc = myproc();
if(addr >= KERNBASE2)
801044f6: 81 fa fe ff ff 7f cmp $0x7ffffffe,%edx
801044fc: 77 21 ja 8010451f <fetchstr+0x2f>
return -1;
*pp = (char*)addr;
801044fe: 8b 4d 0c mov 0xc(%ebp),%ecx
80104501: 89 d0 mov %edx,%eax
80104503: 89 11 mov %edx,(%ecx)
ep = (char*)KERNBASE2; // changedit?????
for(s = *pp; s < ep; s++){
if(*s == 0)
80104505: 80 3a 00 cmpb $0x0,(%edx)
80104508: 75 0b jne 80104515 <fetchstr+0x25>
8010450a: eb 1c jmp 80104528 <fetchstr+0x38>
8010450c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104510: 80 38 00 cmpb $0x0,(%eax)
80104513: 74 13 je 80104528 <fetchstr+0x38>
for(s = *pp; s < ep; s++){
80104515: 83 c0 01 add $0x1,%eax
80104518: 3d ff ff ff 7f cmp $0x7fffffff,%eax
8010451d: 75 f1 jne 80104510 <fetchstr+0x20>
return -1;
8010451f: b8 ff ff ff ff mov $0xffffffff,%eax
return s - *pp;
}
return -1;
}
80104524: 5d pop %ebp
80104525: c3 ret
80104526: 66 90 xchg %ax,%ax
return s - *pp;
80104528: 29 d0 sub %edx,%eax
}
8010452a: 5d pop %ebp
8010452b: c3 ret
8010452c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104530 <argint>:
// Fetch the nth 32-bit system call argument.
int
argint(int n, int *ip)
{
80104530: 55 push %ebp
80104531: 89 e5 mov %esp,%ebp
80104533: 83 ec 08 sub $0x8,%esp
return fetchint((myproc()->tf->esp) + 4 + 4*n, ip);
80104536: e8 65 f1 ff ff call 801036a0 <myproc>
8010453b: 8b 55 08 mov 0x8(%ebp),%edx
8010453e: 8b 40 1c mov 0x1c(%eax),%eax
80104541: 8b 40 44 mov 0x44(%eax),%eax
80104544: 8d 44 90 04 lea 0x4(%eax,%edx,4),%eax
if(addr >= KERNBASE2 || addr+4 > KERNBASE2)
80104548: 3d fb ff ff 7f cmp $0x7ffffffb,%eax
8010454d: 77 11 ja 80104560 <argint+0x30>
*ip = *(int*)(addr);
8010454f: 8b 10 mov (%eax),%edx
80104551: 8b 45 0c mov 0xc(%ebp),%eax
80104554: 89 10 mov %edx,(%eax)
return 0;
80104556: 31 c0 xor %eax,%eax
}
80104558: c9 leave
80104559: c3 ret
8010455a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80104560: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104565: c9 leave
80104566: c3 ret
80104567: 89 f6 mov %esi,%esi
80104569: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104570 <argptr>:
// Fetch the nth word-sized system call argument as a pointer
// to a block of memory of size bytes. Check that the pointer
// lies within the process address space.
int
argptr(int n, char **pp, int size)
{
80104570: 55 push %ebp
80104571: 89 e5 mov %esp,%ebp
80104573: 53 push %ebx
80104574: 83 ec 24 sub $0x24,%esp
80104577: 8b 5d 10 mov 0x10(%ebp),%ebx
int i;
// struct proc *curproc = myproc();
if(argint(n, &i) < 0)
8010457a: 8d 45 f4 lea -0xc(%ebp),%eax
8010457d: 89 44 24 04 mov %eax,0x4(%esp)
80104581: 8b 45 08 mov 0x8(%ebp),%eax
80104584: 89 04 24 mov %eax,(%esp)
80104587: e8 a4 ff ff ff call 80104530 <argint>
8010458c: 85 c0 test %eax,%eax
8010458e: 78 20 js 801045b0 <argptr+0x40>
return -1;
if(size < 0 || (uint)i >= KERNBASE2 || (uint)i+size > KERNBASE2)
80104590: 85 db test %ebx,%ebx
80104592: 78 1c js 801045b0 <argptr+0x40>
80104594: 8b 45 f4 mov -0xc(%ebp),%eax
80104597: 3d fe ff ff 7f cmp $0x7ffffffe,%eax
8010459c: 77 12 ja 801045b0 <argptr+0x40>
8010459e: 01 c3 add %eax,%ebx
801045a0: 78 0e js 801045b0 <argptr+0x40>
return -1;
*pp = (char*)i;
801045a2: 8b 55 0c mov 0xc(%ebp),%edx
801045a5: 89 02 mov %eax,(%edx)
return 0;
801045a7: 31 c0 xor %eax,%eax
}
801045a9: 83 c4 24 add $0x24,%esp
801045ac: 5b pop %ebx
801045ad: 5d pop %ebp
801045ae: c3 ret
801045af: 90 nop
return -1;
801045b0: b8 ff ff ff ff mov $0xffffffff,%eax
801045b5: eb f2 jmp 801045a9 <argptr+0x39>
801045b7: 89 f6 mov %esi,%esi
801045b9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801045c0 <argstr>:
// Check that the pointer is valid and the string is nul-terminated.
// (There is no shared writable memory, so the string can't change
// between this check and being used by the kernel.)
int
argstr(int n, char **pp)
{
801045c0: 55 push %ebp
801045c1: 89 e5 mov %esp,%ebp
801045c3: 83 ec 28 sub $0x28,%esp
int addr;
if(argint(n, &addr) < 0)
801045c6: 8d 45 f4 lea -0xc(%ebp),%eax
801045c9: 89 44 24 04 mov %eax,0x4(%esp)
801045cd: 8b 45 08 mov 0x8(%ebp),%eax
801045d0: 89 04 24 mov %eax,(%esp)
801045d3: e8 58 ff ff ff call 80104530 <argint>
801045d8: 85 c0 test %eax,%eax
801045da: 78 2b js 80104607 <argstr+0x47>
return -1;
return fetchstr(addr, pp);
801045dc: 8b 55 f4 mov -0xc(%ebp),%edx
if(addr >= KERNBASE2)
801045df: 81 fa fe ff ff 7f cmp $0x7ffffffe,%edx
801045e5: 77 20 ja 80104607 <argstr+0x47>
*pp = (char*)addr;
801045e7: 8b 4d 0c mov 0xc(%ebp),%ecx
801045ea: 89 d0 mov %edx,%eax
801045ec: 89 11 mov %edx,(%ecx)
if(*s == 0)
801045ee: 80 3a 00 cmpb $0x0,(%edx)
801045f1: 75 0a jne 801045fd <argstr+0x3d>
801045f3: eb 1b jmp 80104610 <argstr+0x50>
801045f5: 8d 76 00 lea 0x0(%esi),%esi
801045f8: 80 38 00 cmpb $0x0,(%eax)
801045fb: 74 13 je 80104610 <argstr+0x50>
for(s = *pp; s < ep; s++){
801045fd: 83 c0 01 add $0x1,%eax
80104600: 3d fe ff ff 7f cmp $0x7ffffffe,%eax
80104605: 76 f1 jbe 801045f8 <argstr+0x38>
return -1;
80104607: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010460c: c9 leave
8010460d: c3 ret
8010460e: 66 90 xchg %ax,%ax
return s - *pp;
80104610: 29 d0 sub %edx,%eax
}
80104612: c9 leave
80104613: c3 ret
80104614: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
8010461a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80104620 <syscall>:
[SYS_shm_close] sys_shm_close
};
void
syscall(void)
{
80104620: 55 push %ebp
80104621: 89 e5 mov %esp,%ebp
80104623: 56 push %esi
80104624: 53 push %ebx
80104625: 83 ec 10 sub $0x10,%esp
int num;
struct proc *curproc = myproc();
80104628: e8 73 f0 ff ff call 801036a0 <myproc>
num = curproc->tf->eax;
8010462d: 8b 70 1c mov 0x1c(%eax),%esi
struct proc *curproc = myproc();
80104630: 89 c3 mov %eax,%ebx
num = curproc->tf->eax;
80104632: 8b 46 1c mov 0x1c(%esi),%eax
if(num > 0 && num < NELEM(syscalls) && syscalls[num]) {
80104635: 8d 50 ff lea -0x1(%eax),%edx
80104638: 83 fa 16 cmp $0x16,%edx
8010463b: 77 1b ja 80104658 <syscall+0x38>
8010463d: 8b 14 85 60 75 10 80 mov -0x7fef8aa0(,%eax,4),%edx
80104644: 85 d2 test %edx,%edx
80104646: 74 10 je 80104658 <syscall+0x38>
curproc->tf->eax = syscalls[num]();
80104648: ff d2 call *%edx
8010464a: 89 46 1c mov %eax,0x1c(%esi)
} else {
cprintf("%d %s: unknown sys call %d\n",
curproc->pid, curproc->name, num);
curproc->tf->eax = -1;
}
}
8010464d: 83 c4 10 add $0x10,%esp
80104650: 5b pop %ebx
80104651: 5e pop %esi
80104652: 5d pop %ebp
80104653: c3 ret
80104654: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
cprintf("%d %s: unknown sys call %d\n",
80104658: 89 44 24 0c mov %eax,0xc(%esp)
curproc->pid, curproc->name, num);
8010465c: 8d 43 70 lea 0x70(%ebx),%eax
8010465f: 89 44 24 08 mov %eax,0x8(%esp)
cprintf("%d %s: unknown sys call %d\n",
80104663: 8b 43 14 mov 0x14(%ebx),%eax
80104666: c7 04 24 31 75 10 80 movl $0x80107531,(%esp)
8010466d: 89 44 24 04 mov %eax,0x4(%esp)
80104671: e8 da bf ff ff call 80100650 <cprintf>
curproc->tf->eax = -1;
80104676: 8b 43 1c mov 0x1c(%ebx),%eax
80104679: c7 40 1c ff ff ff ff movl $0xffffffff,0x1c(%eax)
}
80104680: 83 c4 10 add $0x10,%esp
80104683: 5b pop %ebx
80104684: 5e pop %esi
80104685: 5d pop %ebp
80104686: c3 ret
80104687: 66 90 xchg %ax,%ax
80104689: 66 90 xchg %ax,%ax
8010468b: 66 90 xchg %ax,%ax
8010468d: 66 90 xchg %ax,%ax
8010468f: 90 nop
80104690 <fdalloc>:
// Allocate a file descriptor for the given file.
// Takes over file reference from caller on success.
static int
fdalloc(struct file *f)
{
80104690: 55 push %ebp
80104691: 89 e5 mov %esp,%ebp
80104693: 53 push %ebx
80104694: 89 c3 mov %eax,%ebx
80104696: 83 ec 04 sub $0x4,%esp
int fd;
struct proc *curproc = myproc();
80104699: e8 02 f0 ff ff call 801036a0 <myproc>
for(fd = 0; fd < NOFILE; fd++){
8010469e: 31 d2 xor %edx,%edx
if(curproc->ofile[fd] == 0){
801046a0: 8b 4c 90 2c mov 0x2c(%eax,%edx,4),%ecx
801046a4: 85 c9 test %ecx,%ecx
801046a6: 74 18 je 801046c0 <fdalloc+0x30>
for(fd = 0; fd < NOFILE; fd++){
801046a8: 83 c2 01 add $0x1,%edx
801046ab: 83 fa 10 cmp $0x10,%edx
801046ae: 75 f0 jne 801046a0 <fdalloc+0x10>
curproc->ofile[fd] = f;
return fd;
}
}
return -1;
}
801046b0: 83 c4 04 add $0x4,%esp
return -1;
801046b3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801046b8: 5b pop %ebx
801046b9: 5d pop %ebp
801046ba: c3 ret
801046bb: 90 nop
801046bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
curproc->ofile[fd] = f;
801046c0: 89 5c 90 2c mov %ebx,0x2c(%eax,%edx,4)
}
801046c4: 83 c4 04 add $0x4,%esp
return fd;
801046c7: 89 d0 mov %edx,%eax
}
801046c9: 5b pop %ebx
801046ca: 5d pop %ebp
801046cb: c3 ret
801046cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801046d0 <create>:
return -1;
}
static struct inode*
create(char *path, short type, short major, short minor)
{
801046d0: 55 push %ebp
801046d1: 89 e5 mov %esp,%ebp
801046d3: 57 push %edi
801046d4: 56 push %esi
801046d5: 53 push %ebx
801046d6: 83 ec 4c sub $0x4c,%esp
801046d9: 89 4d c0 mov %ecx,-0x40(%ebp)
801046dc: 8b 4d 08 mov 0x8(%ebp),%ecx
uint off;
struct inode *ip, *dp;
char name[DIRSIZ];
if((dp = nameiparent(path, name)) == 0)
801046df: 8d 5d da lea -0x26(%ebp),%ebx
801046e2: 89 5c 24 04 mov %ebx,0x4(%esp)
801046e6: 89 04 24 mov %eax,(%esp)
{
801046e9: 89 55 c4 mov %edx,-0x3c(%ebp)
801046ec: 89 4d bc mov %ecx,-0x44(%ebp)
if((dp = nameiparent(path, name)) == 0)
801046ef: e8 2c d8 ff ff call 80101f20 <nameiparent>
801046f4: 85 c0 test %eax,%eax
801046f6: 89 c7 mov %eax,%edi
801046f8: 0f 84 da 00 00 00 je 801047d8 <create+0x108>
return 0;
ilock(dp);
801046fe: 89 04 24 mov %eax,(%esp)
80104701: e8 aa cf ff ff call 801016b0 <ilock>
if((ip = dirlookup(dp, name, &off)) != 0){
80104706: 8d 45 d4 lea -0x2c(%ebp),%eax
80104709: 89 44 24 08 mov %eax,0x8(%esp)
8010470d: 89 5c 24 04 mov %ebx,0x4(%esp)
80104711: 89 3c 24 mov %edi,(%esp)
80104714: e8 a7 d4 ff ff call 80101bc0 <dirlookup>
80104719: 85 c0 test %eax,%eax
8010471b: 89 c6 mov %eax,%esi
8010471d: 74 41 je 80104760 <create+0x90>
iunlockput(dp);
8010471f: 89 3c 24 mov %edi,(%esp)
80104722: e8 e9 d1 ff ff call 80101910 <iunlockput>
ilock(ip);
80104727: 89 34 24 mov %esi,(%esp)
8010472a: e8 81 cf ff ff call 801016b0 <ilock>
if(type == T_FILE && ip->type == T_FILE)
8010472f: 66 83 7d c4 02 cmpw $0x2,-0x3c(%ebp)
80104734: 75 12 jne 80104748 <create+0x78>
80104736: 66 83 7e 50 02 cmpw $0x2,0x50(%esi)
8010473b: 89 f0 mov %esi,%eax
8010473d: 75 09 jne 80104748 <create+0x78>
panic("create: dirlink");
iunlockput(dp);
return ip;
}
8010473f: 83 c4 4c add $0x4c,%esp
80104742: 5b pop %ebx
80104743: 5e pop %esi
80104744: 5f pop %edi
80104745: 5d pop %ebp
80104746: c3 ret
80104747: 90 nop
iunlockput(ip);
80104748: 89 34 24 mov %esi,(%esp)
8010474b: e8 c0 d1 ff ff call 80101910 <iunlockput>
}
80104750: 83 c4 4c add $0x4c,%esp
return 0;
80104753: 31 c0 xor %eax,%eax
}
80104755: 5b pop %ebx
80104756: 5e pop %esi
80104757: 5f pop %edi
80104758: 5d pop %ebp
80104759: c3 ret
8010475a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if((ip = ialloc(dp->dev, type)) == 0)
80104760: 0f bf 45 c4 movswl -0x3c(%ebp),%eax
80104764: 89 44 24 04 mov %eax,0x4(%esp)
80104768: 8b 07 mov (%edi),%eax
8010476a: 89 04 24 mov %eax,(%esp)
8010476d: e8 ae cd ff ff call 80101520 <ialloc>
80104772: 85 c0 test %eax,%eax
80104774: 89 c6 mov %eax,%esi
80104776: 0f 84 bf 00 00 00 je 8010483b <create+0x16b>
ilock(ip);
8010477c: 89 04 24 mov %eax,(%esp)
8010477f: e8 2c cf ff ff call 801016b0 <ilock>
ip->major = major;
80104784: 0f b7 45 c0 movzwl -0x40(%ebp),%eax
80104788: 66 89 46 52 mov %ax,0x52(%esi)
ip->minor = minor;
8010478c: 0f b7 45 bc movzwl -0x44(%ebp),%eax
80104790: 66 89 46 54 mov %ax,0x54(%esi)
ip->nlink = 1;
80104794: b8 01 00 00 00 mov $0x1,%eax
80104799: 66 89 46 56 mov %ax,0x56(%esi)
iupdate(ip);
8010479d: 89 34 24 mov %esi,(%esp)
801047a0: e8 4b ce ff ff call 801015f0 <iupdate>
if(type == T_DIR){ // Create . and .. entries.
801047a5: 66 83 7d c4 01 cmpw $0x1,-0x3c(%ebp)
801047aa: 74 34 je 801047e0 <create+0x110>
if(dirlink(dp, name, ip->inum) < 0)
801047ac: 8b 46 04 mov 0x4(%esi),%eax
801047af: 89 5c 24 04 mov %ebx,0x4(%esp)
801047b3: 89 3c 24 mov %edi,(%esp)
801047b6: 89 44 24 08 mov %eax,0x8(%esp)
801047ba: e8 61 d6 ff ff call 80101e20 <dirlink>
801047bf: 85 c0 test %eax,%eax
801047c1: 78 6c js 8010482f <create+0x15f>
iunlockput(dp);
801047c3: 89 3c 24 mov %edi,(%esp)
801047c6: e8 45 d1 ff ff call 80101910 <iunlockput>
}
801047cb: 83 c4 4c add $0x4c,%esp
return ip;
801047ce: 89 f0 mov %esi,%eax
}
801047d0: 5b pop %ebx
801047d1: 5e pop %esi
801047d2: 5f pop %edi
801047d3: 5d pop %ebp
801047d4: c3 ret
801047d5: 8d 76 00 lea 0x0(%esi),%esi
return 0;
801047d8: 31 c0 xor %eax,%eax
801047da: e9 60 ff ff ff jmp 8010473f <create+0x6f>
801047df: 90 nop
dp->nlink++; // for ".."
801047e0: 66 83 47 56 01 addw $0x1,0x56(%edi)
iupdate(dp);
801047e5: 89 3c 24 mov %edi,(%esp)
801047e8: e8 03 ce ff ff call 801015f0 <iupdate>
if(dirlink(ip, ".", ip->inum) < 0 || dirlink(ip, "..", dp->inum) < 0)
801047ed: 8b 46 04 mov 0x4(%esi),%eax
801047f0: c7 44 24 04 dc 75 10 movl $0x801075dc,0x4(%esp)
801047f7: 80
801047f8: 89 34 24 mov %esi,(%esp)
801047fb: 89 44 24 08 mov %eax,0x8(%esp)
801047ff: e8 1c d6 ff ff call 80101e20 <dirlink>
80104804: 85 c0 test %eax,%eax
80104806: 78 1b js 80104823 <create+0x153>
80104808: 8b 47 04 mov 0x4(%edi),%eax
8010480b: c7 44 24 04 db 75 10 movl $0x801075db,0x4(%esp)
80104812: 80
80104813: 89 34 24 mov %esi,(%esp)
80104816: 89 44 24 08 mov %eax,0x8(%esp)
8010481a: e8 01 d6 ff ff call 80101e20 <dirlink>
8010481f: 85 c0 test %eax,%eax
80104821: 79 89 jns 801047ac <create+0xdc>
panic("create dots");
80104823: c7 04 24 cf 75 10 80 movl $0x801075cf,(%esp)
8010482a: e8 31 bb ff ff call 80100360 <panic>
panic("create: dirlink");
8010482f: c7 04 24 de 75 10 80 movl $0x801075de,(%esp)
80104836: e8 25 bb ff ff call 80100360 <panic>
panic("create: ialloc");
8010483b: c7 04 24 c0 75 10 80 movl $0x801075c0,(%esp)
80104842: e8 19 bb ff ff call 80100360 <panic>
80104847: 89 f6 mov %esi,%esi
80104849: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104850 <argfd.constprop.0>:
argfd(int n, int *pfd, struct file **pf)
80104850: 55 push %ebp
80104851: 89 e5 mov %esp,%ebp
80104853: 56 push %esi
80104854: 89 c6 mov %eax,%esi
80104856: 53 push %ebx
80104857: 89 d3 mov %edx,%ebx
80104859: 83 ec 20 sub $0x20,%esp
if(argint(n, &fd) < 0)
8010485c: 8d 45 f4 lea -0xc(%ebp),%eax
8010485f: 89 44 24 04 mov %eax,0x4(%esp)
80104863: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010486a: e8 c1 fc ff ff call 80104530 <argint>
8010486f: 85 c0 test %eax,%eax
80104871: 78 2d js 801048a0 <argfd.constprop.0+0x50>
if(fd < 0 || fd >= NOFILE || (f=myproc()->ofile[fd]) == 0)
80104873: 83 7d f4 0f cmpl $0xf,-0xc(%ebp)
80104877: 77 27 ja 801048a0 <argfd.constprop.0+0x50>
80104879: e8 22 ee ff ff call 801036a0 <myproc>
8010487e: 8b 55 f4 mov -0xc(%ebp),%edx
80104881: 8b 44 90 2c mov 0x2c(%eax,%edx,4),%eax
80104885: 85 c0 test %eax,%eax
80104887: 74 17 je 801048a0 <argfd.constprop.0+0x50>
if(pfd)
80104889: 85 f6 test %esi,%esi
8010488b: 74 02 je 8010488f <argfd.constprop.0+0x3f>
*pfd = fd;
8010488d: 89 16 mov %edx,(%esi)
if(pf)
8010488f: 85 db test %ebx,%ebx
80104891: 74 1d je 801048b0 <argfd.constprop.0+0x60>
*pf = f;
80104893: 89 03 mov %eax,(%ebx)
return 0;
80104895: 31 c0 xor %eax,%eax
}
80104897: 83 c4 20 add $0x20,%esp
8010489a: 5b pop %ebx
8010489b: 5e pop %esi
8010489c: 5d pop %ebp
8010489d: c3 ret
8010489e: 66 90 xchg %ax,%ax
801048a0: 83 c4 20 add $0x20,%esp
return -1;
801048a3: b8 ff ff ff ff mov $0xffffffff,%eax
}
801048a8: 5b pop %ebx
801048a9: 5e pop %esi
801048aa: 5d pop %ebp
801048ab: c3 ret
801048ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
801048b0: 31 c0 xor %eax,%eax
801048b2: eb e3 jmp 80104897 <argfd.constprop.0+0x47>
801048b4: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801048ba: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
801048c0 <sys_dup>:
{
801048c0: 55 push %ebp
if(argfd(0, 0, &f) < 0)
801048c1: 31 c0 xor %eax,%eax
{
801048c3: 89 e5 mov %esp,%ebp
801048c5: 53 push %ebx
801048c6: 83 ec 24 sub $0x24,%esp
if(argfd(0, 0, &f) < 0)
801048c9: 8d 55 f4 lea -0xc(%ebp),%edx
801048cc: e8 7f ff ff ff call 80104850 <argfd.constprop.0>
801048d1: 85 c0 test %eax,%eax
801048d3: 78 23 js 801048f8 <sys_dup+0x38>
if((fd=fdalloc(f)) < 0)
801048d5: 8b 45 f4 mov -0xc(%ebp),%eax
801048d8: e8 b3 fd ff ff call 80104690 <fdalloc>
801048dd: 85 c0 test %eax,%eax
801048df: 89 c3 mov %eax,%ebx
801048e1: 78 15 js 801048f8 <sys_dup+0x38>
filedup(f);
801048e3: 8b 45 f4 mov -0xc(%ebp),%eax
801048e6: 89 04 24 mov %eax,(%esp)
801048e9: e8 e2 c4 ff ff call 80100dd0 <filedup>
return fd;
801048ee: 89 d8 mov %ebx,%eax
}
801048f0: 83 c4 24 add $0x24,%esp
801048f3: 5b pop %ebx
801048f4: 5d pop %ebp
801048f5: c3 ret
801048f6: 66 90 xchg %ax,%ax
return -1;
801048f8: b8 ff ff ff ff mov $0xffffffff,%eax
801048fd: eb f1 jmp 801048f0 <sys_dup+0x30>
801048ff: 90 nop
80104900 <sys_read>:
{
80104900: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104901: 31 c0 xor %eax,%eax
{
80104903: 89 e5 mov %esp,%ebp
80104905: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104908: 8d 55 ec lea -0x14(%ebp),%edx
8010490b: e8 40 ff ff ff call 80104850 <argfd.constprop.0>
80104910: 85 c0 test %eax,%eax
80104912: 78 54 js 80104968 <sys_read+0x68>
80104914: 8d 45 f0 lea -0x10(%ebp),%eax
80104917: 89 44 24 04 mov %eax,0x4(%esp)
8010491b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104922: e8 09 fc ff ff call 80104530 <argint>
80104927: 85 c0 test %eax,%eax
80104929: 78 3d js 80104968 <sys_read+0x68>
8010492b: 8b 45 f0 mov -0x10(%ebp),%eax
8010492e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104935: 89 44 24 08 mov %eax,0x8(%esp)
80104939: 8d 45 f4 lea -0xc(%ebp),%eax
8010493c: 89 44 24 04 mov %eax,0x4(%esp)
80104940: e8 2b fc ff ff call 80104570 <argptr>
80104945: 85 c0 test %eax,%eax
80104947: 78 1f js 80104968 <sys_read+0x68>
return fileread(f, p, n);
80104949: 8b 45 f0 mov -0x10(%ebp),%eax
8010494c: 89 44 24 08 mov %eax,0x8(%esp)
80104950: 8b 45 f4 mov -0xc(%ebp),%eax
80104953: 89 44 24 04 mov %eax,0x4(%esp)
80104957: 8b 45 ec mov -0x14(%ebp),%eax
8010495a: 89 04 24 mov %eax,(%esp)
8010495d: e8 ce c5 ff ff call 80100f30 <fileread>
}
80104962: c9 leave
80104963: c3 ret
80104964: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104968: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010496d: c9 leave
8010496e: c3 ret
8010496f: 90 nop
80104970 <sys_write>:
{
80104970: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104971: 31 c0 xor %eax,%eax
{
80104973: 89 e5 mov %esp,%ebp
80104975: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argint(2, &n) < 0 || argptr(1, &p, n) < 0)
80104978: 8d 55 ec lea -0x14(%ebp),%edx
8010497b: e8 d0 fe ff ff call 80104850 <argfd.constprop.0>
80104980: 85 c0 test %eax,%eax
80104982: 78 54 js 801049d8 <sys_write+0x68>
80104984: 8d 45 f0 lea -0x10(%ebp),%eax
80104987: 89 44 24 04 mov %eax,0x4(%esp)
8010498b: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104992: e8 99 fb ff ff call 80104530 <argint>
80104997: 85 c0 test %eax,%eax
80104999: 78 3d js 801049d8 <sys_write+0x68>
8010499b: 8b 45 f0 mov -0x10(%ebp),%eax
8010499e: c7 04 24 01 00 00 00 movl $0x1,(%esp)
801049a5: 89 44 24 08 mov %eax,0x8(%esp)
801049a9: 8d 45 f4 lea -0xc(%ebp),%eax
801049ac: 89 44 24 04 mov %eax,0x4(%esp)
801049b0: e8 bb fb ff ff call 80104570 <argptr>
801049b5: 85 c0 test %eax,%eax
801049b7: 78 1f js 801049d8 <sys_write+0x68>
return filewrite(f, p, n);
801049b9: 8b 45 f0 mov -0x10(%ebp),%eax
801049bc: 89 44 24 08 mov %eax,0x8(%esp)
801049c0: 8b 45 f4 mov -0xc(%ebp),%eax
801049c3: 89 44 24 04 mov %eax,0x4(%esp)
801049c7: 8b 45 ec mov -0x14(%ebp),%eax
801049ca: 89 04 24 mov %eax,(%esp)
801049cd: e8 fe c5 ff ff call 80100fd0 <filewrite>
}
801049d2: c9 leave
801049d3: c3 ret
801049d4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
801049d8: b8 ff ff ff ff mov $0xffffffff,%eax
}
801049dd: c9 leave
801049de: c3 ret
801049df: 90 nop
801049e0 <sys_close>:
{
801049e0: 55 push %ebp
801049e1: 89 e5 mov %esp,%ebp
801049e3: 83 ec 28 sub $0x28,%esp
if(argfd(0, &fd, &f) < 0)
801049e6: 8d 55 f4 lea -0xc(%ebp),%edx
801049e9: 8d 45 f0 lea -0x10(%ebp),%eax
801049ec: e8 5f fe ff ff call 80104850 <argfd.constprop.0>
801049f1: 85 c0 test %eax,%eax
801049f3: 78 23 js 80104a18 <sys_close+0x38>
myproc()->ofile[fd] = 0;
801049f5: e8 a6 ec ff ff call 801036a0 <myproc>
801049fa: 8b 55 f0 mov -0x10(%ebp),%edx
801049fd: c7 44 90 2c 00 00 00 movl $0x0,0x2c(%eax,%edx,4)
80104a04: 00
fileclose(f);
80104a05: 8b 45 f4 mov -0xc(%ebp),%eax
80104a08: 89 04 24 mov %eax,(%esp)
80104a0b: e8 10 c4 ff ff call 80100e20 <fileclose>
return 0;
80104a10: 31 c0 xor %eax,%eax
}
80104a12: c9 leave
80104a13: c3 ret
80104a14: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80104a18: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a1d: c9 leave
80104a1e: c3 ret
80104a1f: 90 nop
80104a20 <sys_fstat>:
{
80104a20: 55 push %ebp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a21: 31 c0 xor %eax,%eax
{
80104a23: 89 e5 mov %esp,%ebp
80104a25: 83 ec 28 sub $0x28,%esp
if(argfd(0, 0, &f) < 0 || argptr(1, (void*)&st, sizeof(*st)) < 0)
80104a28: 8d 55 f0 lea -0x10(%ebp),%edx
80104a2b: e8 20 fe ff ff call 80104850 <argfd.constprop.0>
80104a30: 85 c0 test %eax,%eax
80104a32: 78 34 js 80104a68 <sys_fstat+0x48>
80104a34: 8d 45 f4 lea -0xc(%ebp),%eax
80104a37: c7 44 24 08 14 00 00 movl $0x14,0x8(%esp)
80104a3e: 00
80104a3f: 89 44 24 04 mov %eax,0x4(%esp)
80104a43: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104a4a: e8 21 fb ff ff call 80104570 <argptr>
80104a4f: 85 c0 test %eax,%eax
80104a51: 78 15 js 80104a68 <sys_fstat+0x48>
return filestat(f, st);
80104a53: 8b 45 f4 mov -0xc(%ebp),%eax
80104a56: 89 44 24 04 mov %eax,0x4(%esp)
80104a5a: 8b 45 f0 mov -0x10(%ebp),%eax
80104a5d: 89 04 24 mov %eax,(%esp)
80104a60: e8 7b c4 ff ff call 80100ee0 <filestat>
}
80104a65: c9 leave
80104a66: c3 ret
80104a67: 90 nop
return -1;
80104a68: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104a6d: c9 leave
80104a6e: c3 ret
80104a6f: 90 nop
80104a70 <sys_link>:
{
80104a70: 55 push %ebp
80104a71: 89 e5 mov %esp,%ebp
80104a73: 57 push %edi
80104a74: 56 push %esi
80104a75: 53 push %ebx
80104a76: 83 ec 3c sub $0x3c,%esp
if(argstr(0, &old) < 0 || argstr(1, &new) < 0)
80104a79: 8d 45 d4 lea -0x2c(%ebp),%eax
80104a7c: 89 44 24 04 mov %eax,0x4(%esp)
80104a80: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104a87: e8 34 fb ff ff call 801045c0 <argstr>
80104a8c: 85 c0 test %eax,%eax
80104a8e: 0f 88 e6 00 00 00 js 80104b7a <sys_link+0x10a>
80104a94: 8d 45 d0 lea -0x30(%ebp),%eax
80104a97: 89 44 24 04 mov %eax,0x4(%esp)
80104a9b: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104aa2: e8 19 fb ff ff call 801045c0 <argstr>
80104aa7: 85 c0 test %eax,%eax
80104aa9: 0f 88 cb 00 00 00 js 80104b7a <sys_link+0x10a>
begin_op();
80104aaf: e8 5c e0 ff ff call 80102b10 <begin_op>
if((ip = namei(old)) == 0){
80104ab4: 8b 45 d4 mov -0x2c(%ebp),%eax
80104ab7: 89 04 24 mov %eax,(%esp)
80104aba: e8 41 d4 ff ff call 80101f00 <namei>
80104abf: 85 c0 test %eax,%eax
80104ac1: 89 c3 mov %eax,%ebx
80104ac3: 0f 84 ac 00 00 00 je 80104b75 <sys_link+0x105>
ilock(ip);
80104ac9: 89 04 24 mov %eax,(%esp)
80104acc: e8 df cb ff ff call 801016b0 <ilock>
if(ip->type == T_DIR){
80104ad1: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104ad6: 0f 84 91 00 00 00 je 80104b6d <sys_link+0xfd>
ip->nlink++;
80104adc: 66 83 43 56 01 addw $0x1,0x56(%ebx)
if((dp = nameiparent(new, name)) == 0)
80104ae1: 8d 7d da lea -0x26(%ebp),%edi
iupdate(ip);
80104ae4: 89 1c 24 mov %ebx,(%esp)
80104ae7: e8 04 cb ff ff call 801015f0 <iupdate>
iunlock(ip);
80104aec: 89 1c 24 mov %ebx,(%esp)
80104aef: e8 9c cc ff ff call 80101790 <iunlock>
if((dp = nameiparent(new, name)) == 0)
80104af4: 8b 45 d0 mov -0x30(%ebp),%eax
80104af7: 89 7c 24 04 mov %edi,0x4(%esp)
80104afb: 89 04 24 mov %eax,(%esp)
80104afe: e8 1d d4 ff ff call 80101f20 <nameiparent>
80104b03: 85 c0 test %eax,%eax
80104b05: 89 c6 mov %eax,%esi
80104b07: 74 4f je 80104b58 <sys_link+0xe8>
ilock(dp);
80104b09: 89 04 24 mov %eax,(%esp)
80104b0c: e8 9f cb ff ff call 801016b0 <ilock>
if(dp->dev != ip->dev || dirlink(dp, name, ip->inum) < 0){
80104b11: 8b 03 mov (%ebx),%eax
80104b13: 39 06 cmp %eax,(%esi)
80104b15: 75 39 jne 80104b50 <sys_link+0xe0>
80104b17: 8b 43 04 mov 0x4(%ebx),%eax
80104b1a: 89 7c 24 04 mov %edi,0x4(%esp)
80104b1e: 89 34 24 mov %esi,(%esp)
80104b21: 89 44 24 08 mov %eax,0x8(%esp)
80104b25: e8 f6 d2 ff ff call 80101e20 <dirlink>
80104b2a: 85 c0 test %eax,%eax
80104b2c: 78 22 js 80104b50 <sys_link+0xe0>
iunlockput(dp);
80104b2e: 89 34 24 mov %esi,(%esp)
80104b31: e8 da cd ff ff call 80101910 <iunlockput>
iput(ip);
80104b36: 89 1c 24 mov %ebx,(%esp)
80104b39: e8 92 cc ff ff call 801017d0 <iput>
end_op();
80104b3e: e8 3d e0 ff ff call 80102b80 <end_op>
}
80104b43: 83 c4 3c add $0x3c,%esp
return 0;
80104b46: 31 c0 xor %eax,%eax
}
80104b48: 5b pop %ebx
80104b49: 5e pop %esi
80104b4a: 5f pop %edi
80104b4b: 5d pop %ebp
80104b4c: c3 ret
80104b4d: 8d 76 00 lea 0x0(%esi),%esi
iunlockput(dp);
80104b50: 89 34 24 mov %esi,(%esp)
80104b53: e8 b8 cd ff ff call 80101910 <iunlockput>
ilock(ip);
80104b58: 89 1c 24 mov %ebx,(%esp)
80104b5b: e8 50 cb ff ff call 801016b0 <ilock>
ip->nlink--;
80104b60: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104b65: 89 1c 24 mov %ebx,(%esp)
80104b68: e8 83 ca ff ff call 801015f0 <iupdate>
iunlockput(ip);
80104b6d: 89 1c 24 mov %ebx,(%esp)
80104b70: e8 9b cd ff ff call 80101910 <iunlockput>
end_op();
80104b75: e8 06 e0 ff ff call 80102b80 <end_op>
}
80104b7a: 83 c4 3c add $0x3c,%esp
return -1;
80104b7d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104b82: 5b pop %ebx
80104b83: 5e pop %esi
80104b84: 5f pop %edi
80104b85: 5d pop %ebp
80104b86: c3 ret
80104b87: 89 f6 mov %esi,%esi
80104b89: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104b90 <sys_unlink>:
{
80104b90: 55 push %ebp
80104b91: 89 e5 mov %esp,%ebp
80104b93: 57 push %edi
80104b94: 56 push %esi
80104b95: 53 push %ebx
80104b96: 83 ec 5c sub $0x5c,%esp
if(argstr(0, &path) < 0)
80104b99: 8d 45 c0 lea -0x40(%ebp),%eax
80104b9c: 89 44 24 04 mov %eax,0x4(%esp)
80104ba0: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ba7: e8 14 fa ff ff call 801045c0 <argstr>
80104bac: 85 c0 test %eax,%eax
80104bae: 0f 88 76 01 00 00 js 80104d2a <sys_unlink+0x19a>
begin_op();
80104bb4: e8 57 df ff ff call 80102b10 <begin_op>
if((dp = nameiparent(path, name)) == 0){
80104bb9: 8b 45 c0 mov -0x40(%ebp),%eax
80104bbc: 8d 5d ca lea -0x36(%ebp),%ebx
80104bbf: 89 5c 24 04 mov %ebx,0x4(%esp)
80104bc3: 89 04 24 mov %eax,(%esp)
80104bc6: e8 55 d3 ff ff call 80101f20 <nameiparent>
80104bcb: 85 c0 test %eax,%eax
80104bcd: 89 45 b4 mov %eax,-0x4c(%ebp)
80104bd0: 0f 84 4f 01 00 00 je 80104d25 <sys_unlink+0x195>
ilock(dp);
80104bd6: 8b 75 b4 mov -0x4c(%ebp),%esi
80104bd9: 89 34 24 mov %esi,(%esp)
80104bdc: e8 cf ca ff ff call 801016b0 <ilock>
if(namecmp(name, ".") == 0 || namecmp(name, "..") == 0)
80104be1: c7 44 24 04 dc 75 10 movl $0x801075dc,0x4(%esp)
80104be8: 80
80104be9: 89 1c 24 mov %ebx,(%esp)
80104bec: e8 9f cf ff ff call 80101b90 <namecmp>
80104bf1: 85 c0 test %eax,%eax
80104bf3: 0f 84 21 01 00 00 je 80104d1a <sys_unlink+0x18a>
80104bf9: c7 44 24 04 db 75 10 movl $0x801075db,0x4(%esp)
80104c00: 80
80104c01: 89 1c 24 mov %ebx,(%esp)
80104c04: e8 87 cf ff ff call 80101b90 <namecmp>
80104c09: 85 c0 test %eax,%eax
80104c0b: 0f 84 09 01 00 00 je 80104d1a <sys_unlink+0x18a>
if((ip = dirlookup(dp, name, &off)) == 0)
80104c11: 8d 45 c4 lea -0x3c(%ebp),%eax
80104c14: 89 5c 24 04 mov %ebx,0x4(%esp)
80104c18: 89 44 24 08 mov %eax,0x8(%esp)
80104c1c: 89 34 24 mov %esi,(%esp)
80104c1f: e8 9c cf ff ff call 80101bc0 <dirlookup>
80104c24: 85 c0 test %eax,%eax
80104c26: 89 c3 mov %eax,%ebx
80104c28: 0f 84 ec 00 00 00 je 80104d1a <sys_unlink+0x18a>
ilock(ip);
80104c2e: 89 04 24 mov %eax,(%esp)
80104c31: e8 7a ca ff ff call 801016b0 <ilock>
if(ip->nlink < 1)
80104c36: 66 83 7b 56 00 cmpw $0x0,0x56(%ebx)
80104c3b: 0f 8e 24 01 00 00 jle 80104d65 <sys_unlink+0x1d5>
if(ip->type == T_DIR && !isdirempty(ip)){
80104c41: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c46: 8d 75 d8 lea -0x28(%ebp),%esi
80104c49: 74 7d je 80104cc8 <sys_unlink+0x138>
memset(&de, 0, sizeof(de));
80104c4b: c7 44 24 08 10 00 00 movl $0x10,0x8(%esp)
80104c52: 00
80104c53: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80104c5a: 00
80104c5b: 89 34 24 mov %esi,(%esp)
80104c5e: e8 1d f6 ff ff call 80104280 <memset>
if(writei(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104c63: 8b 45 c4 mov -0x3c(%ebp),%eax
80104c66: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104c6d: 00
80104c6e: 89 74 24 04 mov %esi,0x4(%esp)
80104c72: 89 44 24 08 mov %eax,0x8(%esp)
80104c76: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c79: 89 04 24 mov %eax,(%esp)
80104c7c: e8 df cd ff ff call 80101a60 <writei>
80104c81: 83 f8 10 cmp $0x10,%eax
80104c84: 0f 85 cf 00 00 00 jne 80104d59 <sys_unlink+0x1c9>
if(ip->type == T_DIR){
80104c8a: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
80104c8f: 0f 84 a3 00 00 00 je 80104d38 <sys_unlink+0x1a8>
iunlockput(dp);
80104c95: 8b 45 b4 mov -0x4c(%ebp),%eax
80104c98: 89 04 24 mov %eax,(%esp)
80104c9b: e8 70 cc ff ff call 80101910 <iunlockput>
ip->nlink--;
80104ca0: 66 83 6b 56 01 subw $0x1,0x56(%ebx)
iupdate(ip);
80104ca5: 89 1c 24 mov %ebx,(%esp)
80104ca8: e8 43 c9 ff ff call 801015f0 <iupdate>
iunlockput(ip);
80104cad: 89 1c 24 mov %ebx,(%esp)
80104cb0: e8 5b cc ff ff call 80101910 <iunlockput>
end_op();
80104cb5: e8 c6 de ff ff call 80102b80 <end_op>
}
80104cba: 83 c4 5c add $0x5c,%esp
return 0;
80104cbd: 31 c0 xor %eax,%eax
}
80104cbf: 5b pop %ebx
80104cc0: 5e pop %esi
80104cc1: 5f pop %edi
80104cc2: 5d pop %ebp
80104cc3: c3 ret
80104cc4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for(off=2*sizeof(de); off<dp->size; off+=sizeof(de)){
80104cc8: 83 7b 58 20 cmpl $0x20,0x58(%ebx)
80104ccc: 0f 86 79 ff ff ff jbe 80104c4b <sys_unlink+0xbb>
80104cd2: bf 20 00 00 00 mov $0x20,%edi
80104cd7: eb 15 jmp 80104cee <sys_unlink+0x15e>
80104cd9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104ce0: 8d 57 10 lea 0x10(%edi),%edx
80104ce3: 3b 53 58 cmp 0x58(%ebx),%edx
80104ce6: 0f 83 5f ff ff ff jae 80104c4b <sys_unlink+0xbb>
80104cec: 89 d7 mov %edx,%edi
if(readi(dp, (char*)&de, off, sizeof(de)) != sizeof(de))
80104cee: c7 44 24 0c 10 00 00 movl $0x10,0xc(%esp)
80104cf5: 00
80104cf6: 89 7c 24 08 mov %edi,0x8(%esp)
80104cfa: 89 74 24 04 mov %esi,0x4(%esp)
80104cfe: 89 1c 24 mov %ebx,(%esp)
80104d01: e8 5a cc ff ff call 80101960 <readi>
80104d06: 83 f8 10 cmp $0x10,%eax
80104d09: 75 42 jne 80104d4d <sys_unlink+0x1bd>
if(de.inum != 0)
80104d0b: 66 83 7d d8 00 cmpw $0x0,-0x28(%ebp)
80104d10: 74 ce je 80104ce0 <sys_unlink+0x150>
iunlockput(ip);
80104d12: 89 1c 24 mov %ebx,(%esp)
80104d15: e8 f6 cb ff ff call 80101910 <iunlockput>
iunlockput(dp);
80104d1a: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d1d: 89 04 24 mov %eax,(%esp)
80104d20: e8 eb cb ff ff call 80101910 <iunlockput>
end_op();
80104d25: e8 56 de ff ff call 80102b80 <end_op>
}
80104d2a: 83 c4 5c add $0x5c,%esp
return -1;
80104d2d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104d32: 5b pop %ebx
80104d33: 5e pop %esi
80104d34: 5f pop %edi
80104d35: 5d pop %ebp
80104d36: c3 ret
80104d37: 90 nop
dp->nlink--;
80104d38: 8b 45 b4 mov -0x4c(%ebp),%eax
80104d3b: 66 83 68 56 01 subw $0x1,0x56(%eax)
iupdate(dp);
80104d40: 89 04 24 mov %eax,(%esp)
80104d43: e8 a8 c8 ff ff call 801015f0 <iupdate>
80104d48: e9 48 ff ff ff jmp 80104c95 <sys_unlink+0x105>
panic("isdirempty: readi");
80104d4d: c7 04 24 00 76 10 80 movl $0x80107600,(%esp)
80104d54: e8 07 b6 ff ff call 80100360 <panic>
panic("unlink: writei");
80104d59: c7 04 24 12 76 10 80 movl $0x80107612,(%esp)
80104d60: e8 fb b5 ff ff call 80100360 <panic>
panic("unlink: nlink < 1");
80104d65: c7 04 24 ee 75 10 80 movl $0x801075ee,(%esp)
80104d6c: e8 ef b5 ff ff call 80100360 <panic>
80104d71: eb 0d jmp 80104d80 <sys_open>
80104d73: 90 nop
80104d74: 90 nop
80104d75: 90 nop
80104d76: 90 nop
80104d77: 90 nop
80104d78: 90 nop
80104d79: 90 nop
80104d7a: 90 nop
80104d7b: 90 nop
80104d7c: 90 nop
80104d7d: 90 nop
80104d7e: 90 nop
80104d7f: 90 nop
80104d80 <sys_open>:
int
sys_open(void)
{
80104d80: 55 push %ebp
80104d81: 89 e5 mov %esp,%ebp
80104d83: 57 push %edi
80104d84: 56 push %esi
80104d85: 53 push %ebx
80104d86: 83 ec 2c sub $0x2c,%esp
char *path;
int fd, omode;
struct file *f;
struct inode *ip;
if(argstr(0, &path) < 0 || argint(1, &omode) < 0)
80104d89: 8d 45 e0 lea -0x20(%ebp),%eax
80104d8c: 89 44 24 04 mov %eax,0x4(%esp)
80104d90: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104d97: e8 24 f8 ff ff call 801045c0 <argstr>
80104d9c: 85 c0 test %eax,%eax
80104d9e: 0f 88 d1 00 00 00 js 80104e75 <sys_open+0xf5>
80104da4: 8d 45 e4 lea -0x1c(%ebp),%eax
80104da7: 89 44 24 04 mov %eax,0x4(%esp)
80104dab: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104db2: e8 79 f7 ff ff call 80104530 <argint>
80104db7: 85 c0 test %eax,%eax
80104db9: 0f 88 b6 00 00 00 js 80104e75 <sys_open+0xf5>
return -1;
begin_op();
80104dbf: e8 4c dd ff ff call 80102b10 <begin_op>
if(omode & O_CREATE){
80104dc4: f6 45 e5 02 testb $0x2,-0x1b(%ebp)
80104dc8: 0f 85 82 00 00 00 jne 80104e50 <sys_open+0xd0>
if(ip == 0){
end_op();
return -1;
}
} else {
if((ip = namei(path)) == 0){
80104dce: 8b 45 e0 mov -0x20(%ebp),%eax
80104dd1: 89 04 24 mov %eax,(%esp)
80104dd4: e8 27 d1 ff ff call 80101f00 <namei>
80104dd9: 85 c0 test %eax,%eax
80104ddb: 89 c6 mov %eax,%esi
80104ddd: 0f 84 8d 00 00 00 je 80104e70 <sys_open+0xf0>
end_op();
return -1;
}
ilock(ip);
80104de3: 89 04 24 mov %eax,(%esp)
80104de6: e8 c5 c8 ff ff call 801016b0 <ilock>
if(ip->type == T_DIR && omode != O_RDONLY){
80104deb: 66 83 7e 50 01 cmpw $0x1,0x50(%esi)
80104df0: 0f 84 92 00 00 00 je 80104e88 <sys_open+0x108>
end_op();
return -1;
}
}
if((f = filealloc()) == 0 || (fd = fdalloc(f)) < 0){
80104df6: e8 65 bf ff ff call 80100d60 <filealloc>
80104dfb: 85 c0 test %eax,%eax
80104dfd: 89 c3 mov %eax,%ebx
80104dff: 0f 84 93 00 00 00 je 80104e98 <sys_open+0x118>
80104e05: e8 86 f8 ff ff call 80104690 <fdalloc>
80104e0a: 85 c0 test %eax,%eax
80104e0c: 89 c7 mov %eax,%edi
80104e0e: 0f 88 94 00 00 00 js 80104ea8 <sys_open+0x128>
fileclose(f);
iunlockput(ip);
end_op();
return -1;
}
iunlock(ip);
80104e14: 89 34 24 mov %esi,(%esp)
80104e17: e8 74 c9 ff ff call 80101790 <iunlock>
end_op();
80104e1c: e8 5f dd ff ff call 80102b80 <end_op>
f->type = FD_INODE;
80104e21: c7 03 02 00 00 00 movl $0x2,(%ebx)
f->ip = ip;
f->off = 0;
f->readable = !(omode & O_WRONLY);
80104e27: 8b 45 e4 mov -0x1c(%ebp),%eax
f->ip = ip;
80104e2a: 89 73 10 mov %esi,0x10(%ebx)
f->off = 0;
80104e2d: c7 43 14 00 00 00 00 movl $0x0,0x14(%ebx)
f->readable = !(omode & O_WRONLY);
80104e34: 89 c2 mov %eax,%edx
80104e36: 83 e2 01 and $0x1,%edx
80104e39: 83 f2 01 xor $0x1,%edx
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e3c: a8 03 test $0x3,%al
f->readable = !(omode & O_WRONLY);
80104e3e: 88 53 08 mov %dl,0x8(%ebx)
return fd;
80104e41: 89 f8 mov %edi,%eax
f->writable = (omode & O_WRONLY) || (omode & O_RDWR);
80104e43: 0f 95 43 09 setne 0x9(%ebx)
}
80104e47: 83 c4 2c add $0x2c,%esp
80104e4a: 5b pop %ebx
80104e4b: 5e pop %esi
80104e4c: 5f pop %edi
80104e4d: 5d pop %ebp
80104e4e: c3 ret
80104e4f: 90 nop
ip = create(path, T_FILE, 0, 0);
80104e50: 8b 45 e0 mov -0x20(%ebp),%eax
80104e53: 31 c9 xor %ecx,%ecx
80104e55: ba 02 00 00 00 mov $0x2,%edx
80104e5a: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104e61: e8 6a f8 ff ff call 801046d0 <create>
if(ip == 0){
80104e66: 85 c0 test %eax,%eax
ip = create(path, T_FILE, 0, 0);
80104e68: 89 c6 mov %eax,%esi
if(ip == 0){
80104e6a: 75 8a jne 80104df6 <sys_open+0x76>
80104e6c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
end_op();
80104e70: e8 0b dd ff ff call 80102b80 <end_op>
}
80104e75: 83 c4 2c add $0x2c,%esp
return -1;
80104e78: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104e7d: 5b pop %ebx
80104e7e: 5e pop %esi
80104e7f: 5f pop %edi
80104e80: 5d pop %ebp
80104e81: c3 ret
80104e82: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(ip->type == T_DIR && omode != O_RDONLY){
80104e88: 8b 45 e4 mov -0x1c(%ebp),%eax
80104e8b: 85 c0 test %eax,%eax
80104e8d: 0f 84 63 ff ff ff je 80104df6 <sys_open+0x76>
80104e93: 90 nop
80104e94: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
iunlockput(ip);
80104e98: 89 34 24 mov %esi,(%esp)
80104e9b: e8 70 ca ff ff call 80101910 <iunlockput>
80104ea0: eb ce jmp 80104e70 <sys_open+0xf0>
80104ea2: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
fileclose(f);
80104ea8: 89 1c 24 mov %ebx,(%esp)
80104eab: e8 70 bf ff ff call 80100e20 <fileclose>
80104eb0: eb e6 jmp 80104e98 <sys_open+0x118>
80104eb2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80104eb9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80104ec0 <sys_mkdir>:
int
sys_mkdir(void)
{
80104ec0: 55 push %ebp
80104ec1: 89 e5 mov %esp,%ebp
80104ec3: 83 ec 28 sub $0x28,%esp
char *path;
struct inode *ip;
begin_op();
80104ec6: e8 45 dc ff ff call 80102b10 <begin_op>
if(argstr(0, &path) < 0 || (ip = create(path, T_DIR, 0, 0)) == 0){
80104ecb: 8d 45 f4 lea -0xc(%ebp),%eax
80104ece: 89 44 24 04 mov %eax,0x4(%esp)
80104ed2: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ed9: e8 e2 f6 ff ff call 801045c0 <argstr>
80104ede: 85 c0 test %eax,%eax
80104ee0: 78 2e js 80104f10 <sys_mkdir+0x50>
80104ee2: 8b 45 f4 mov -0xc(%ebp),%eax
80104ee5: 31 c9 xor %ecx,%ecx
80104ee7: ba 01 00 00 00 mov $0x1,%edx
80104eec: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104ef3: e8 d8 f7 ff ff call 801046d0 <create>
80104ef8: 85 c0 test %eax,%eax
80104efa: 74 14 je 80104f10 <sys_mkdir+0x50>
end_op();
return -1;
}
iunlockput(ip);
80104efc: 89 04 24 mov %eax,(%esp)
80104eff: e8 0c ca ff ff call 80101910 <iunlockput>
end_op();
80104f04: e8 77 dc ff ff call 80102b80 <end_op>
return 0;
80104f09: 31 c0 xor %eax,%eax
}
80104f0b: c9 leave
80104f0c: c3 ret
80104f0d: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104f10: e8 6b dc ff ff call 80102b80 <end_op>
return -1;
80104f15: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104f1a: c9 leave
80104f1b: c3 ret
80104f1c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104f20 <sys_mknod>:
int
sys_mknod(void)
{
80104f20: 55 push %ebp
80104f21: 89 e5 mov %esp,%ebp
80104f23: 83 ec 28 sub $0x28,%esp
struct inode *ip;
char *path;
int major, minor;
begin_op();
80104f26: e8 e5 db ff ff call 80102b10 <begin_op>
if((argstr(0, &path)) < 0 ||
80104f2b: 8d 45 ec lea -0x14(%ebp),%eax
80104f2e: 89 44 24 04 mov %eax,0x4(%esp)
80104f32: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104f39: e8 82 f6 ff ff call 801045c0 <argstr>
80104f3e: 85 c0 test %eax,%eax
80104f40: 78 5e js 80104fa0 <sys_mknod+0x80>
argint(1, &major) < 0 ||
80104f42: 8d 45 f0 lea -0x10(%ebp),%eax
80104f45: 89 44 24 04 mov %eax,0x4(%esp)
80104f49: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80104f50: e8 db f5 ff ff call 80104530 <argint>
if((argstr(0, &path)) < 0 ||
80104f55: 85 c0 test %eax,%eax
80104f57: 78 47 js 80104fa0 <sys_mknod+0x80>
argint(2, &minor) < 0 ||
80104f59: 8d 45 f4 lea -0xc(%ebp),%eax
80104f5c: 89 44 24 04 mov %eax,0x4(%esp)
80104f60: c7 04 24 02 00 00 00 movl $0x2,(%esp)
80104f67: e8 c4 f5 ff ff call 80104530 <argint>
argint(1, &major) < 0 ||
80104f6c: 85 c0 test %eax,%eax
80104f6e: 78 30 js 80104fa0 <sys_mknod+0x80>
(ip = create(path, T_DEV, major, minor)) == 0){
80104f70: 0f bf 45 f4 movswl -0xc(%ebp),%eax
argint(2, &minor) < 0 ||
80104f74: ba 03 00 00 00 mov $0x3,%edx
(ip = create(path, T_DEV, major, minor)) == 0){
80104f79: 0f bf 4d f0 movswl -0x10(%ebp),%ecx
80104f7d: 89 04 24 mov %eax,(%esp)
argint(2, &minor) < 0 ||
80104f80: 8b 45 ec mov -0x14(%ebp),%eax
80104f83: e8 48 f7 ff ff call 801046d0 <create>
80104f88: 85 c0 test %eax,%eax
80104f8a: 74 14 je 80104fa0 <sys_mknod+0x80>
end_op();
return -1;
}
iunlockput(ip);
80104f8c: 89 04 24 mov %eax,(%esp)
80104f8f: e8 7c c9 ff ff call 80101910 <iunlockput>
end_op();
80104f94: e8 e7 db ff ff call 80102b80 <end_op>
return 0;
80104f99: 31 c0 xor %eax,%eax
}
80104f9b: c9 leave
80104f9c: c3 ret
80104f9d: 8d 76 00 lea 0x0(%esi),%esi
end_op();
80104fa0: e8 db db ff ff call 80102b80 <end_op>
return -1;
80104fa5: b8 ff ff ff ff mov $0xffffffff,%eax
}
80104faa: c9 leave
80104fab: c3 ret
80104fac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80104fb0 <sys_chdir>:
int
sys_chdir(void)
{
80104fb0: 55 push %ebp
80104fb1: 89 e5 mov %esp,%ebp
80104fb3: 56 push %esi
80104fb4: 53 push %ebx
80104fb5: 83 ec 20 sub $0x20,%esp
char *path;
struct inode *ip;
struct proc *curproc = myproc();
80104fb8: e8 e3 e6 ff ff call 801036a0 <myproc>
80104fbd: 89 c6 mov %eax,%esi
begin_op();
80104fbf: e8 4c db ff ff call 80102b10 <begin_op>
if(argstr(0, &path) < 0 || (ip = namei(path)) == 0){
80104fc4: 8d 45 f4 lea -0xc(%ebp),%eax
80104fc7: 89 44 24 04 mov %eax,0x4(%esp)
80104fcb: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80104fd2: e8 e9 f5 ff ff call 801045c0 <argstr>
80104fd7: 85 c0 test %eax,%eax
80104fd9: 78 4a js 80105025 <sys_chdir+0x75>
80104fdb: 8b 45 f4 mov -0xc(%ebp),%eax
80104fde: 89 04 24 mov %eax,(%esp)
80104fe1: e8 1a cf ff ff call 80101f00 <namei>
80104fe6: 85 c0 test %eax,%eax
80104fe8: 89 c3 mov %eax,%ebx
80104fea: 74 39 je 80105025 <sys_chdir+0x75>
end_op();
return -1;
}
ilock(ip);
80104fec: 89 04 24 mov %eax,(%esp)
80104fef: e8 bc c6 ff ff call 801016b0 <ilock>
if(ip->type != T_DIR){
80104ff4: 66 83 7b 50 01 cmpw $0x1,0x50(%ebx)
iunlockput(ip);
80104ff9: 89 1c 24 mov %ebx,(%esp)
if(ip->type != T_DIR){
80104ffc: 75 22 jne 80105020 <sys_chdir+0x70>
end_op();
return -1;
}
iunlock(ip);
80104ffe: e8 8d c7 ff ff call 80101790 <iunlock>
iput(curproc->cwd);
80105003: 8b 46 6c mov 0x6c(%esi),%eax
80105006: 89 04 24 mov %eax,(%esp)
80105009: e8 c2 c7 ff ff call 801017d0 <iput>
end_op();
8010500e: e8 6d db ff ff call 80102b80 <end_op>
curproc->cwd = ip;
return 0;
80105013: 31 c0 xor %eax,%eax
curproc->cwd = ip;
80105015: 89 5e 6c mov %ebx,0x6c(%esi)
}
80105018: 83 c4 20 add $0x20,%esp
8010501b: 5b pop %ebx
8010501c: 5e pop %esi
8010501d: 5d pop %ebp
8010501e: c3 ret
8010501f: 90 nop
iunlockput(ip);
80105020: e8 eb c8 ff ff call 80101910 <iunlockput>
end_op();
80105025: e8 56 db ff ff call 80102b80 <end_op>
}
8010502a: 83 c4 20 add $0x20,%esp
return -1;
8010502d: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105032: 5b pop %ebx
80105033: 5e pop %esi
80105034: 5d pop %ebp
80105035: c3 ret
80105036: 8d 76 00 lea 0x0(%esi),%esi
80105039: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105040 <sys_exec>:
int
sys_exec(void)
{
80105040: 55 push %ebp
80105041: 89 e5 mov %esp,%ebp
80105043: 57 push %edi
80105044: 56 push %esi
80105045: 53 push %ebx
80105046: 81 ec ac 00 00 00 sub $0xac,%esp
char *path, *argv[MAXARG];
int i;
uint uargv, uarg;
if(argstr(0, &path) < 0 || argint(1, (int*)&uargv) < 0){
8010504c: 8d 85 5c ff ff ff lea -0xa4(%ebp),%eax
80105052: 89 44 24 04 mov %eax,0x4(%esp)
80105056: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010505d: e8 5e f5 ff ff call 801045c0 <argstr>
80105062: 85 c0 test %eax,%eax
80105064: 0f 88 84 00 00 00 js 801050ee <sys_exec+0xae>
8010506a: 8d 85 60 ff ff ff lea -0xa0(%ebp),%eax
80105070: 89 44 24 04 mov %eax,0x4(%esp)
80105074: c7 04 24 01 00 00 00 movl $0x1,(%esp)
8010507b: e8 b0 f4 ff ff call 80104530 <argint>
80105080: 85 c0 test %eax,%eax
80105082: 78 6a js 801050ee <sys_exec+0xae>
return -1;
}
memset(argv, 0, sizeof(argv));
80105084: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
for(i=0;; i++){
8010508a: 31 db xor %ebx,%ebx
memset(argv, 0, sizeof(argv));
8010508c: c7 44 24 08 80 00 00 movl $0x80,0x8(%esp)
80105093: 00
80105094: 8d b5 68 ff ff ff lea -0x98(%ebp),%esi
8010509a: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801050a1: 00
801050a2: 8d bd 64 ff ff ff lea -0x9c(%ebp),%edi
801050a8: 89 04 24 mov %eax,(%esp)
801050ab: e8 d0 f1 ff ff call 80104280 <memset>
if(i >= NELEM(argv))
return -1;
if(fetchint(uargv+4*i, (int*)&uarg) < 0)
801050b0: 8b 85 60 ff ff ff mov -0xa0(%ebp),%eax
801050b6: 89 7c 24 04 mov %edi,0x4(%esp)
801050ba: 8d 04 98 lea (%eax,%ebx,4),%eax
801050bd: 89 04 24 mov %eax,(%esp)
801050c0: e8 0b f4 ff ff call 801044d0 <fetchint>
801050c5: 85 c0 test %eax,%eax
801050c7: 78 25 js 801050ee <sys_exec+0xae>
return -1;
if(uarg == 0){
801050c9: 8b 85 64 ff ff ff mov -0x9c(%ebp),%eax
801050cf: 85 c0 test %eax,%eax
801050d1: 74 2d je 80105100 <sys_exec+0xc0>
argv[i] = 0;
break;
}
if(fetchstr(uarg, &argv[i]) < 0)
801050d3: 89 74 24 04 mov %esi,0x4(%esp)
801050d7: 89 04 24 mov %eax,(%esp)
801050da: e8 11 f4 ff ff call 801044f0 <fetchstr>
801050df: 85 c0 test %eax,%eax
801050e1: 78 0b js 801050ee <sys_exec+0xae>
for(i=0;; i++){
801050e3: 83 c3 01 add $0x1,%ebx
801050e6: 83 c6 04 add $0x4,%esi
if(i >= NELEM(argv))
801050e9: 83 fb 20 cmp $0x20,%ebx
801050ec: 75 c2 jne 801050b0 <sys_exec+0x70>
return -1;
}
return exec(path, argv);
}
801050ee: 81 c4 ac 00 00 00 add $0xac,%esp
return -1;
801050f4: b8 ff ff ff ff mov $0xffffffff,%eax
}
801050f9: 5b pop %ebx
801050fa: 5e pop %esi
801050fb: 5f pop %edi
801050fc: 5d pop %ebp
801050fd: c3 ret
801050fe: 66 90 xchg %ax,%ax
return exec(path, argv);
80105100: 8d 85 68 ff ff ff lea -0x98(%ebp),%eax
80105106: 89 44 24 04 mov %eax,0x4(%esp)
8010510a: 8b 85 5c ff ff ff mov -0xa4(%ebp),%eax
argv[i] = 0;
80105110: c7 84 9d 68 ff ff ff movl $0x0,-0x98(%ebp,%ebx,4)
80105117: 00 00 00 00
return exec(path, argv);
8010511b: 89 04 24 mov %eax,(%esp)
8010511e: e8 7d b8 ff ff call 801009a0 <exec>
}
80105123: 81 c4 ac 00 00 00 add $0xac,%esp
80105129: 5b pop %ebx
8010512a: 5e pop %esi
8010512b: 5f pop %edi
8010512c: 5d pop %ebp
8010512d: c3 ret
8010512e: 66 90 xchg %ax,%ax
80105130 <sys_pipe>:
int
sys_pipe(void)
{
80105130: 55 push %ebp
80105131: 89 e5 mov %esp,%ebp
80105133: 53 push %ebx
80105134: 83 ec 24 sub $0x24,%esp
int *fd;
struct file *rf, *wf;
int fd0, fd1;
if(argptr(0, (void*)&fd, 2*sizeof(fd[0])) < 0)
80105137: 8d 45 ec lea -0x14(%ebp),%eax
8010513a: c7 44 24 08 08 00 00 movl $0x8,0x8(%esp)
80105141: 00
80105142: 89 44 24 04 mov %eax,0x4(%esp)
80105146: c7 04 24 00 00 00 00 movl $0x0,(%esp)
8010514d: e8 1e f4 ff ff call 80104570 <argptr>
80105152: 85 c0 test %eax,%eax
80105154: 78 6d js 801051c3 <sys_pipe+0x93>
return -1;
if(pipealloc(&rf, &wf) < 0)
80105156: 8d 45 f4 lea -0xc(%ebp),%eax
80105159: 89 44 24 04 mov %eax,0x4(%esp)
8010515d: 8d 45 f0 lea -0x10(%ebp),%eax
80105160: 89 04 24 mov %eax,(%esp)
80105163: e8 08 e0 ff ff call 80103170 <pipealloc>
80105168: 85 c0 test %eax,%eax
8010516a: 78 57 js 801051c3 <sys_pipe+0x93>
return -1;
fd0 = -1;
if((fd0 = fdalloc(rf)) < 0 || (fd1 = fdalloc(wf)) < 0){
8010516c: 8b 45 f0 mov -0x10(%ebp),%eax
8010516f: e8 1c f5 ff ff call 80104690 <fdalloc>
80105174: 85 c0 test %eax,%eax
80105176: 89 c3 mov %eax,%ebx
80105178: 78 33 js 801051ad <sys_pipe+0x7d>
8010517a: 8b 45 f4 mov -0xc(%ebp),%eax
8010517d: e8 0e f5 ff ff call 80104690 <fdalloc>
80105182: 85 c0 test %eax,%eax
80105184: 78 1a js 801051a0 <sys_pipe+0x70>
myproc()->ofile[fd0] = 0;
fileclose(rf);
fileclose(wf);
return -1;
}
fd[0] = fd0;
80105186: 8b 55 ec mov -0x14(%ebp),%edx
80105189: 89 1a mov %ebx,(%edx)
fd[1] = fd1;
8010518b: 8b 55 ec mov -0x14(%ebp),%edx
8010518e: 89 42 04 mov %eax,0x4(%edx)
return 0;
}
80105191: 83 c4 24 add $0x24,%esp
return 0;
80105194: 31 c0 xor %eax,%eax
}
80105196: 5b pop %ebx
80105197: 5d pop %ebp
80105198: c3 ret
80105199: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
myproc()->ofile[fd0] = 0;
801051a0: e8 fb e4 ff ff call 801036a0 <myproc>
801051a5: c7 44 98 2c 00 00 00 movl $0x0,0x2c(%eax,%ebx,4)
801051ac: 00
fileclose(rf);
801051ad: 8b 45 f0 mov -0x10(%ebp),%eax
801051b0: 89 04 24 mov %eax,(%esp)
801051b3: e8 68 bc ff ff call 80100e20 <fileclose>
fileclose(wf);
801051b8: 8b 45 f4 mov -0xc(%ebp),%eax
801051bb: 89 04 24 mov %eax,(%esp)
801051be: e8 5d bc ff ff call 80100e20 <fileclose>
}
801051c3: 83 c4 24 add $0x24,%esp
return -1;
801051c6: b8 ff ff ff ff mov $0xffffffff,%eax
}
801051cb: 5b pop %ebx
801051cc: 5d pop %ebp
801051cd: c3 ret
801051ce: 66 90 xchg %ax,%ax
801051d0 <sys_shm_open>:
#include "param.h"
#include "memlayout.h"
#include "mmu.h"
#include "proc.h"
int sys_shm_open(void) {
801051d0: 55 push %ebp
801051d1: 89 e5 mov %esp,%ebp
801051d3: 83 ec 28 sub $0x28,%esp
int id;
char **pointer;
if(argint(0, &id) < 0)
801051d6: 8d 45 f0 lea -0x10(%ebp),%eax
801051d9: 89 44 24 04 mov %eax,0x4(%esp)
801051dd: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801051e4: e8 47 f3 ff ff call 80104530 <argint>
801051e9: 85 c0 test %eax,%eax
801051eb: 78 33 js 80105220 <sys_shm_open+0x50>
return -1;
if(argptr(1, (char **) (&pointer),4)<0)
801051ed: 8d 45 f4 lea -0xc(%ebp),%eax
801051f0: c7 44 24 08 04 00 00 movl $0x4,0x8(%esp)
801051f7: 00
801051f8: 89 44 24 04 mov %eax,0x4(%esp)
801051fc: c7 04 24 01 00 00 00 movl $0x1,(%esp)
80105203: e8 68 f3 ff ff call 80104570 <argptr>
80105208: 85 c0 test %eax,%eax
8010520a: 78 14 js 80105220 <sys_shm_open+0x50>
return -1;
return shm_open(id, pointer);
8010520c: 8b 45 f4 mov -0xc(%ebp),%eax
8010520f: 89 44 24 04 mov %eax,0x4(%esp)
80105213: 8b 45 f0 mov -0x10(%ebp),%eax
80105216: 89 04 24 mov %eax,(%esp)
80105219: e8 12 1c 00 00 call 80106e30 <shm_open>
}
8010521e: c9 leave
8010521f: c3 ret
return -1;
80105220: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105225: c9 leave
80105226: c3 ret
80105227: 89 f6 mov %esi,%esi
80105229: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105230 <sys_shm_close>:
int sys_shm_close(void) {
80105230: 55 push %ebp
80105231: 89 e5 mov %esp,%ebp
80105233: 83 ec 28 sub $0x28,%esp
int id;
if(argint(0, &id) < 0)
80105236: 8d 45 f4 lea -0xc(%ebp),%eax
80105239: 89 44 24 04 mov %eax,0x4(%esp)
8010523d: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105244: e8 e7 f2 ff ff call 80104530 <argint>
80105249: 85 c0 test %eax,%eax
8010524b: 78 13 js 80105260 <sys_shm_close+0x30>
return -1;
return shm_close(id);
8010524d: 8b 45 f4 mov -0xc(%ebp),%eax
80105250: 89 04 24 mov %eax,(%esp)
80105253: e8 e8 1b 00 00 call 80106e40 <shm_close>
}
80105258: c9 leave
80105259: c3 ret
8010525a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
80105260: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105265: c9 leave
80105266: c3 ret
80105267: 89 f6 mov %esi,%esi
80105269: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105270 <sys_fork>:
int
sys_fork(void)
{
80105270: 55 push %ebp
80105271: 89 e5 mov %esp,%ebp
return fork();
}
80105273: 5d pop %ebp
return fork();
80105274: e9 d7 e5 ff ff jmp 80103850 <fork>
80105279: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80105280 <sys_exit>:
int
sys_exit(void)
{
80105280: 55 push %ebp
80105281: 89 e5 mov %esp,%ebp
80105283: 83 ec 08 sub $0x8,%esp
exit();
80105286: e8 15 e8 ff ff call 80103aa0 <exit>
return 0; // not reached
}
8010528b: 31 c0 xor %eax,%eax
8010528d: c9 leave
8010528e: c3 ret
8010528f: 90 nop
80105290 <sys_wait>:
int
sys_wait(void)
{
80105290: 55 push %ebp
80105291: 89 e5 mov %esp,%ebp
return wait();
}
80105293: 5d pop %ebp
return wait();
80105294: e9 17 ea ff ff jmp 80103cb0 <wait>
80105299: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
801052a0 <sys_kill>:
int
sys_kill(void)
{
801052a0: 55 push %ebp
801052a1: 89 e5 mov %esp,%ebp
801052a3: 83 ec 28 sub $0x28,%esp
int pid;
if(argint(0, &pid) < 0)
801052a6: 8d 45 f4 lea -0xc(%ebp),%eax
801052a9: 89 44 24 04 mov %eax,0x4(%esp)
801052ad: c7 04 24 00 00 00 00 movl $0x0,(%esp)
801052b4: e8 77 f2 ff ff call 80104530 <argint>
801052b9: 85 c0 test %eax,%eax
801052bb: 78 13 js 801052d0 <sys_kill+0x30>
return -1;
return kill(pid);
801052bd: 8b 45 f4 mov -0xc(%ebp),%eax
801052c0: 89 04 24 mov %eax,(%esp)
801052c3: e8 28 eb ff ff call 80103df0 <kill>
}
801052c8: c9 leave
801052c9: c3 ret
801052ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
return -1;
801052d0: b8 ff ff ff ff mov $0xffffffff,%eax
}
801052d5: c9 leave
801052d6: c3 ret
801052d7: 89 f6 mov %esi,%esi
801052d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801052e0 <sys_getpid>:
int
sys_getpid(void)
{
801052e0: 55 push %ebp
801052e1: 89 e5 mov %esp,%ebp
801052e3: 83 ec 08 sub $0x8,%esp
return myproc()->pid;
801052e6: e8 b5 e3 ff ff call 801036a0 <myproc>
801052eb: 8b 40 14 mov 0x14(%eax),%eax
}
801052ee: c9 leave
801052ef: c3 ret
801052f0 <sys_sbrk>:
int
sys_sbrk(void)
{
801052f0: 55 push %ebp
801052f1: 89 e5 mov %esp,%ebp
801052f3: 53 push %ebx
801052f4: 83 ec 24 sub $0x24,%esp
int addr;
int n;
if(argint(0, &n) < 0)
801052f7: 8d 45 f4 lea -0xc(%ebp),%eax
801052fa: 89 44 24 04 mov %eax,0x4(%esp)
801052fe: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105305: e8 26 f2 ff ff call 80104530 <argint>
8010530a: 85 c0 test %eax,%eax
8010530c: 78 22 js 80105330 <sys_sbrk+0x40>
return -1;
addr = myproc()->sz;
8010530e: e8 8d e3 ff ff call 801036a0 <myproc>
if(growproc(n) < 0)
80105313: 8b 55 f4 mov -0xc(%ebp),%edx
addr = myproc()->sz;
80105316: 8b 18 mov (%eax),%ebx
if(growproc(n) < 0)
80105318: 89 14 24 mov %edx,(%esp)
8010531b: e8 c0 e4 ff ff call 801037e0 <growproc>
80105320: 85 c0 test %eax,%eax
80105322: 78 0c js 80105330 <sys_sbrk+0x40>
return -1;
return addr;
80105324: 89 d8 mov %ebx,%eax
}
80105326: 83 c4 24 add $0x24,%esp
80105329: 5b pop %ebx
8010532a: 5d pop %ebp
8010532b: c3 ret
8010532c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return -1;
80105330: b8 ff ff ff ff mov $0xffffffff,%eax
80105335: eb ef jmp 80105326 <sys_sbrk+0x36>
80105337: 89 f6 mov %esi,%esi
80105339: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105340 <sys_sleep>:
int
sys_sleep(void)
{
80105340: 55 push %ebp
80105341: 89 e5 mov %esp,%ebp
80105343: 53 push %ebx
80105344: 83 ec 24 sub $0x24,%esp
int n;
uint ticks0;
if(argint(0, &n) < 0)
80105347: 8d 45 f4 lea -0xc(%ebp),%eax
8010534a: 89 44 24 04 mov %eax,0x4(%esp)
8010534e: c7 04 24 00 00 00 00 movl $0x0,(%esp)
80105355: e8 d6 f1 ff ff call 80104530 <argint>
8010535a: 85 c0 test %eax,%eax
8010535c: 78 7e js 801053dc <sys_sleep+0x9c>
return -1;
acquire(&tickslock);
8010535e: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105365: e8 d6 ed ff ff call 80104140 <acquire>
ticks0 = ticks;
while(ticks - ticks0 < n){
8010536a: 8b 55 f4 mov -0xc(%ebp),%edx
ticks0 = ticks;
8010536d: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
while(ticks - ticks0 < n){
80105373: 85 d2 test %edx,%edx
80105375: 75 29 jne 801053a0 <sys_sleep+0x60>
80105377: eb 4f jmp 801053c8 <sys_sleep+0x88>
80105379: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc()->killed){
release(&tickslock);
return -1;
}
sleep(&ticks, &tickslock);
80105380: c7 44 24 04 60 4d 11 movl $0x80114d60,0x4(%esp)
80105387: 80
80105388: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
8010538f: e8 6c e8 ff ff call 80103c00 <sleep>
while(ticks - ticks0 < n){
80105394: a1 a0 55 11 80 mov 0x801155a0,%eax
80105399: 29 d8 sub %ebx,%eax
8010539b: 3b 45 f4 cmp -0xc(%ebp),%eax
8010539e: 73 28 jae 801053c8 <sys_sleep+0x88>
if(myproc()->killed){
801053a0: e8 fb e2 ff ff call 801036a0 <myproc>
801053a5: 8b 40 28 mov 0x28(%eax),%eax
801053a8: 85 c0 test %eax,%eax
801053aa: 74 d4 je 80105380 <sys_sleep+0x40>
release(&tickslock);
801053ac: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053b3: e8 78 ee ff ff call 80104230 <release>
return -1;
801053b8: b8 ff ff ff ff mov $0xffffffff,%eax
}
release(&tickslock);
return 0;
}
801053bd: 83 c4 24 add $0x24,%esp
801053c0: 5b pop %ebx
801053c1: 5d pop %ebp
801053c2: c3 ret
801053c3: 90 nop
801053c4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
release(&tickslock);
801053c8: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053cf: e8 5c ee ff ff call 80104230 <release>
}
801053d4: 83 c4 24 add $0x24,%esp
return 0;
801053d7: 31 c0 xor %eax,%eax
}
801053d9: 5b pop %ebx
801053da: 5d pop %ebp
801053db: c3 ret
return -1;
801053dc: b8 ff ff ff ff mov $0xffffffff,%eax
801053e1: eb da jmp 801053bd <sys_sleep+0x7d>
801053e3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801053e9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801053f0 <sys_uptime>:
// return how many clock tick interrupts have occurred
// since start.
int
sys_uptime(void)
{
801053f0: 55 push %ebp
801053f1: 89 e5 mov %esp,%ebp
801053f3: 53 push %ebx
801053f4: 83 ec 14 sub $0x14,%esp
uint xticks;
acquire(&tickslock);
801053f7: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801053fe: e8 3d ed ff ff call 80104140 <acquire>
xticks = ticks;
80105403: 8b 1d a0 55 11 80 mov 0x801155a0,%ebx
release(&tickslock);
80105409: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
80105410: e8 1b ee ff ff call 80104230 <release>
return xticks;
}
80105415: 83 c4 14 add $0x14,%esp
80105418: 89 d8 mov %ebx,%eax
8010541a: 5b pop %ebx
8010541b: 5d pop %ebp
8010541c: c3 ret
8010541d <alltraps>:
# vectors.S sends all traps here.
.globl alltraps
alltraps:
# Build trap frame.
pushl %ds
8010541d: 1e push %ds
pushl %es
8010541e: 06 push %es
pushl %fs
8010541f: 0f a0 push %fs
pushl %gs
80105421: 0f a8 push %gs
pushal
80105423: 60 pusha
# Set up data segments.
movw $(SEG_KDATA<<3), %ax
80105424: 66 b8 10 00 mov $0x10,%ax
movw %ax, %ds
80105428: 8e d8 mov %eax,%ds
movw %ax, %es
8010542a: 8e c0 mov %eax,%es
# Call trap(tf), where tf=%esp
pushl %esp
8010542c: 54 push %esp
call trap
8010542d: e8 de 00 00 00 call 80105510 <trap>
addl $4, %esp
80105432: 83 c4 04 add $0x4,%esp
80105435 <trapret>:
# Return falls through to trapret...
.globl trapret
trapret:
popal
80105435: 61 popa
popl %gs
80105436: 0f a9 pop %gs
popl %fs
80105438: 0f a1 pop %fs
popl %es
8010543a: 07 pop %es
popl %ds
8010543b: 1f pop %ds
addl $0x8, %esp # trapno and errcode
8010543c: 83 c4 08 add $0x8,%esp
iret
8010543f: cf iret
80105440 <tvinit>:
void
tvinit(void)
{
int i;
for(i = 0; i < 256; i++)
80105440: 31 c0 xor %eax,%eax
80105442: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
SETGATE(idt[i], 0, SEG_KCODE<<3, vectors[i], 0);
80105448: 8b 14 85 08 a0 10 80 mov -0x7fef5ff8(,%eax,4),%edx
8010544f: b9 08 00 00 00 mov $0x8,%ecx
80105454: 66 89 0c c5 a2 4d 11 mov %cx,-0x7feeb25e(,%eax,8)
8010545b: 80
8010545c: c6 04 c5 a4 4d 11 80 movb $0x0,-0x7feeb25c(,%eax,8)
80105463: 00
80105464: c6 04 c5 a5 4d 11 80 movb $0x8e,-0x7feeb25b(,%eax,8)
8010546b: 8e
8010546c: 66 89 14 c5 a0 4d 11 mov %dx,-0x7feeb260(,%eax,8)
80105473: 80
80105474: c1 ea 10 shr $0x10,%edx
80105477: 66 89 14 c5 a6 4d 11 mov %dx,-0x7feeb25a(,%eax,8)
8010547e: 80
for(i = 0; i < 256; i++)
8010547f: 83 c0 01 add $0x1,%eax
80105482: 3d 00 01 00 00 cmp $0x100,%eax
80105487: 75 bf jne 80105448 <tvinit+0x8>
{
80105489: 55 push %ebp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
8010548a: ba 08 00 00 00 mov $0x8,%edx
{
8010548f: 89 e5 mov %esp,%ebp
80105491: 83 ec 18 sub $0x18,%esp
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
80105494: a1 08 a1 10 80 mov 0x8010a108,%eax
initlock(&tickslock, "time");
80105499: c7 44 24 04 21 76 10 movl $0x80107621,0x4(%esp)
801054a0: 80
801054a1: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
SETGATE(idt[T_SYSCALL], 1, SEG_KCODE<<3, vectors[T_SYSCALL], DPL_USER);
801054a8: 66 89 15 a2 4f 11 80 mov %dx,0x80114fa2
801054af: 66 a3 a0 4f 11 80 mov %ax,0x80114fa0
801054b5: c1 e8 10 shr $0x10,%eax
801054b8: c6 05 a4 4f 11 80 00 movb $0x0,0x80114fa4
801054bf: c6 05 a5 4f 11 80 ef movb $0xef,0x80114fa5
801054c6: 66 a3 a6 4f 11 80 mov %ax,0x80114fa6
initlock(&tickslock, "time");
801054cc: e8 7f eb ff ff call 80104050 <initlock>
}
801054d1: c9 leave
801054d2: c3 ret
801054d3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801054d9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
801054e0 <idtinit>:
void
idtinit(void)
{
801054e0: 55 push %ebp
pd[0] = size-1;
801054e1: b8 ff 07 00 00 mov $0x7ff,%eax
801054e6: 89 e5 mov %esp,%ebp
801054e8: 83 ec 10 sub $0x10,%esp
801054eb: 66 89 45 fa mov %ax,-0x6(%ebp)
pd[1] = (uint)p;
801054ef: b8 a0 4d 11 80 mov $0x80114da0,%eax
801054f4: 66 89 45 fc mov %ax,-0x4(%ebp)
pd[2] = (uint)p >> 16;
801054f8: c1 e8 10 shr $0x10,%eax
801054fb: 66 89 45 fe mov %ax,-0x2(%ebp)
asm volatile("lidt (%0)" : : "r" (pd));
801054ff: 8d 45 fa lea -0x6(%ebp),%eax
80105502: 0f 01 18 lidtl (%eax)
lidt(idt, sizeof(idt));
}
80105505: c9 leave
80105506: c3 ret
80105507: 89 f6 mov %esi,%esi
80105509: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105510 <trap>:
//PAGEBREAK: 41
void
trap(struct trapframe *tf)
{
80105510: 55 push %ebp
80105511: 89 e5 mov %esp,%ebp
80105513: 57 push %edi
80105514: 56 push %esi
80105515: 53 push %ebx
80105516: 83 ec 3c sub $0x3c,%esp
80105519: 8b 5d 08 mov 0x8(%ebp),%ebx
if(tf->trapno == T_SYSCALL){
8010551c: 8b 43 30 mov 0x30(%ebx),%eax
8010551f: 83 f8 40 cmp $0x40,%eax
80105522: 0f 84 30 02 00 00 je 80105758 <trap+0x248>
if(myproc()->killed)
exit();
return;
}
switch(tf->trapno){
80105528: 83 e8 0e sub $0xe,%eax
8010552b: 83 f8 31 cmp $0x31,%eax
8010552e: 77 08 ja 80105538 <trap+0x28>
80105530: ff 24 85 6c 77 10 80 jmp *-0x7fef8894(,%eax,4)
80105537: 90 nop
cprintf("case T_PGFLT from trap.c: allocuvm succeeded. Number of pages allocated: %d\n", myproc()->szStack);
}
break;
//PAGEBREAK: 13
default:
if(myproc() == 0 || (tf->cs&3) == 0){
80105538: e8 63 e1 ff ff call 801036a0 <myproc>
8010553d: 85 c0 test %eax,%eax
8010553f: 90 nop
80105540: 0f 84 ac 02 00 00 je 801057f2 <trap+0x2e2>
80105546: f6 43 3c 03 testb $0x3,0x3c(%ebx)
8010554a: 0f 84 a2 02 00 00 je 801057f2 <trap+0x2e2>
static inline uint
rcr2(void)
{
uint val;
asm volatile("movl %%cr2,%0" : "=r" (val));
80105550: 0f 20 d1 mov %cr2,%ecx
cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
tf->trapno, cpuid(), tf->eip, rcr2());
panic("trap");
}
// In user space, assume process misbehaved.
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105553: 8b 53 38 mov 0x38(%ebx),%edx
80105556: 89 4d d8 mov %ecx,-0x28(%ebp)
80105559: 89 55 dc mov %edx,-0x24(%ebp)
8010555c: e8 1f e1 ff ff call 80103680 <cpuid>
80105561: 8b 73 30 mov 0x30(%ebx),%esi
80105564: 89 c7 mov %eax,%edi
80105566: 8b 43 34 mov 0x34(%ebx),%eax
80105569: 89 45 e4 mov %eax,-0x1c(%ebp)
"eip 0x%x addr 0x%x--kill proc\n",
myproc()->pid, myproc()->name, tf->trapno,
8010556c: e8 2f e1 ff ff call 801036a0 <myproc>
80105571: 89 45 e0 mov %eax,-0x20(%ebp)
80105574: e8 27 e1 ff ff call 801036a0 <myproc>
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105579: 8b 55 dc mov -0x24(%ebp),%edx
8010557c: 89 74 24 0c mov %esi,0xc(%esp)
myproc()->pid, myproc()->name, tf->trapno,
80105580: 8b 75 e0 mov -0x20(%ebp),%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105583: 8b 4d d8 mov -0x28(%ebp),%ecx
80105586: 89 7c 24 14 mov %edi,0x14(%esp)
8010558a: 89 54 24 18 mov %edx,0x18(%esp)
8010558e: 8b 55 e4 mov -0x1c(%ebp),%edx
myproc()->pid, myproc()->name, tf->trapno,
80105591: 83 c6 70 add $0x70,%esi
cprintf("pid %d %s: trap %d err %d on cpu %d "
80105594: 89 4c 24 1c mov %ecx,0x1c(%esp)
myproc()->pid, myproc()->name, tf->trapno,
80105598: 89 74 24 08 mov %esi,0x8(%esp)
cprintf("pid %d %s: trap %d err %d on cpu %d "
8010559c: 89 54 24 10 mov %edx,0x10(%esp)
801055a0: 8b 40 14 mov 0x14(%eax),%eax
801055a3: c7 04 24 28 77 10 80 movl $0x80107728,(%esp)
801055aa: 89 44 24 04 mov %eax,0x4(%esp)
801055ae: e8 9d b0 ff ff call 80100650 <cprintf>
tf->err, cpuid(), tf->eip, rcr2());
myproc()->killed = 1;
801055b3: e8 e8 e0 ff ff call 801036a0 <myproc>
801055b8: c7 40 28 01 00 00 00 movl $0x1,0x28(%eax)
801055bf: 90 nop
}
// Force process exit if it has been killed and is in user space.
// (If it is still executing in the kernel, let it keep running
// until it gets to the regular system call return.)
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055c0: e8 db e0 ff ff call 801036a0 <myproc>
801055c5: 85 c0 test %eax,%eax
801055c7: 74 0c je 801055d5 <trap+0xc5>
801055c9: e8 d2 e0 ff ff call 801036a0 <myproc>
801055ce: 8b 50 28 mov 0x28(%eax),%edx
801055d1: 85 d2 test %edx,%edx
801055d3: 75 4b jne 80105620 <trap+0x110>
exit();
// Force process to give up CPU on clock tick.
// If interrupts were on while locks held, would need to check nlock.
if(myproc() && myproc()->state == RUNNING &&
801055d5: e8 c6 e0 ff ff call 801036a0 <myproc>
801055da: 85 c0 test %eax,%eax
801055dc: 74 0d je 801055eb <trap+0xdb>
801055de: 66 90 xchg %ax,%ax
801055e0: e8 bb e0 ff ff call 801036a0 <myproc>
801055e5: 83 78 10 04 cmpl $0x4,0x10(%eax)
801055e9: 74 4d je 80105638 <trap+0x128>
tf->trapno == T_IRQ0+IRQ_TIMER)
yield();
// Check if the process has been killed since we yielded
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
801055eb: e8 b0 e0 ff ff call 801036a0 <myproc>
801055f0: 85 c0 test %eax,%eax
801055f2: 74 1d je 80105611 <trap+0x101>
801055f4: e8 a7 e0 ff ff call 801036a0 <myproc>
801055f9: 8b 40 28 mov 0x28(%eax),%eax
801055fc: 85 c0 test %eax,%eax
801055fe: 74 11 je 80105611 <trap+0x101>
80105600: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
80105604: 83 e0 03 and $0x3,%eax
80105607: 66 83 f8 03 cmp $0x3,%ax
8010560b: 0f 84 78 01 00 00 je 80105789 <trap+0x279>
exit();
}
80105611: 83 c4 3c add $0x3c,%esp
80105614: 5b pop %ebx
80105615: 5e pop %esi
80105616: 5f pop %edi
80105617: 5d pop %ebp
80105618: c3 ret
80105619: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->killed && (tf->cs&3) == DPL_USER)
80105620: 0f b7 43 3c movzwl 0x3c(%ebx),%eax
80105624: 83 e0 03 and $0x3,%eax
80105627: 66 83 f8 03 cmp $0x3,%ax
8010562b: 75 a8 jne 801055d5 <trap+0xc5>
exit();
8010562d: e8 6e e4 ff ff call 80103aa0 <exit>
80105632: eb a1 jmp 801055d5 <trap+0xc5>
80105634: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc() && myproc()->state == RUNNING &&
80105638: 83 7b 30 20 cmpl $0x20,0x30(%ebx)
8010563c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80105640: 75 a9 jne 801055eb <trap+0xdb>
yield();
80105642: e8 79 e5 ff ff call 80103bc0 <yield>
80105647: eb a2 jmp 801055eb <trap+0xdb>
80105649: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80105650: 0f 20 d6 mov %cr2,%esi
if(rcr2() > KERNBASE - ((myproc()->szStack + 1) * PGSIZE)){
80105653: e8 48 e0 ff ff call 801036a0 <myproc>
80105658: 8b 40 08 mov 0x8(%eax),%eax
8010565b: f7 d8 neg %eax
8010565d: c1 e0 0c shl $0xc,%eax
80105660: 05 00 f0 ff 7f add $0x7ffff000,%eax
80105665: 39 f0 cmp %esi,%eax
80105667: 0f 83 53 ff ff ff jae 801055c0 <trap+0xb0>
if(allocuvm(myproc()->pgdir, KERNBASE - ((myproc()->szStack + 1) * PGSIZE) , KERNBASE - ((myproc()->szStack + 1) * PGSIZE)+ 2) == 0){
8010566d: e8 2e e0 ff ff call 801036a0 <myproc>
80105672: 8b 40 08 mov 0x8(%eax),%eax
80105675: f7 d8 neg %eax
80105677: c1 e0 0c shl $0xc,%eax
8010567a: 8d b0 02 f0 ff 7f lea 0x7ffff002(%eax),%esi
80105680: e8 1b e0 ff ff call 801036a0 <myproc>
80105685: 8b 40 08 mov 0x8(%eax),%eax
80105688: f7 d8 neg %eax
8010568a: c1 e0 0c shl $0xc,%eax
8010568d: 8d b8 00 f0 ff 7f lea 0x7ffff000(%eax),%edi
80105693: e8 08 e0 ff ff call 801036a0 <myproc>
80105698: 89 74 24 08 mov %esi,0x8(%esp)
8010569c: 89 7c 24 04 mov %edi,0x4(%esp)
801056a0: 8b 40 04 mov 0x4(%eax),%eax
801056a3: 89 04 24 mov %eax,(%esp)
801056a6: e8 25 12 00 00 call 801068d0 <allocuvm>
801056ab: 85 c0 test %eax,%eax
801056ad: 0f 84 1d 01 00 00 je 801057d0 <trap+0x2c0>
myproc()->szStack++;
801056b3: e8 e8 df ff ff call 801036a0 <myproc>
801056b8: 83 40 08 01 addl $0x1,0x8(%eax)
cprintf("case T_PGFLT from trap.c: allocuvm succeeded. Number of pages allocated: %d\n", myproc()->szStack);
801056bc: e8 df df ff ff call 801036a0 <myproc>
801056c1: 8b 40 08 mov 0x8(%eax),%eax
801056c4: c7 04 24 a4 76 10 80 movl $0x801076a4,(%esp)
801056cb: 89 44 24 04 mov %eax,0x4(%esp)
801056cf: e8 7c af ff ff call 80100650 <cprintf>
801056d4: e9 e7 fe ff ff jmp 801055c0 <trap+0xb0>
801056d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(cpuid() == 0){
801056e0: e8 9b df ff ff call 80103680 <cpuid>
801056e5: 85 c0 test %eax,%eax
801056e7: 0f 84 b3 00 00 00 je 801057a0 <trap+0x290>
801056ed: 8d 76 00 lea 0x0(%esi),%esi
lapiceoi();
801056f0: e8 8b d0 ff ff call 80102780 <lapiceoi>
break;
801056f5: e9 c6 fe ff ff jmp 801055c0 <trap+0xb0>
801056fa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
kbdintr();
80105700: e8 cb ce ff ff call 801025d0 <kbdintr>
lapiceoi();
80105705: e8 76 d0 ff ff call 80102780 <lapiceoi>
break;
8010570a: e9 b1 fe ff ff jmp 801055c0 <trap+0xb0>
8010570f: 90 nop
uartintr();
80105710: e8 3b 02 00 00 call 80105950 <uartintr>
lapiceoi();
80105715: e8 66 d0 ff ff call 80102780 <lapiceoi>
break;
8010571a: e9 a1 fe ff ff jmp 801055c0 <trap+0xb0>
8010571f: 90 nop
cprintf("cpu%d: spurious interrupt at %x:%x\n",
80105720: 8b 7b 38 mov 0x38(%ebx),%edi
80105723: 0f b7 73 3c movzwl 0x3c(%ebx),%esi
80105727: e8 54 df ff ff call 80103680 <cpuid>
8010572c: c7 04 24 2c 76 10 80 movl $0x8010762c,(%esp)
80105733: 89 7c 24 0c mov %edi,0xc(%esp)
80105737: 89 74 24 08 mov %esi,0x8(%esp)
8010573b: 89 44 24 04 mov %eax,0x4(%esp)
8010573f: e8 0c af ff ff call 80100650 <cprintf>
lapiceoi();
80105744: e8 37 d0 ff ff call 80102780 <lapiceoi>
break;
80105749: e9 72 fe ff ff jmp 801055c0 <trap+0xb0>
8010574e: 66 90 xchg %ax,%ax
ideintr();
80105750: e8 2b c9 ff ff call 80102080 <ideintr>
80105755: eb 96 jmp 801056ed <trap+0x1dd>
80105757: 90 nop
80105758: 90 nop
80105759: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
if(myproc()->killed)
80105760: e8 3b df ff ff call 801036a0 <myproc>
80105765: 8b 70 28 mov 0x28(%eax),%esi
80105768: 85 f6 test %esi,%esi
8010576a: 75 2c jne 80105798 <trap+0x288>
myproc()->tf = tf;
8010576c: e8 2f df ff ff call 801036a0 <myproc>
80105771: 89 58 1c mov %ebx,0x1c(%eax)
syscall();
80105774: e8 a7 ee ff ff call 80104620 <syscall>
if(myproc()->killed)
80105779: e8 22 df ff ff call 801036a0 <myproc>
8010577e: 8b 48 28 mov 0x28(%eax),%ecx
80105781: 85 c9 test %ecx,%ecx
80105783: 0f 84 88 fe ff ff je 80105611 <trap+0x101>
}
80105789: 83 c4 3c add $0x3c,%esp
8010578c: 5b pop %ebx
8010578d: 5e pop %esi
8010578e: 5f pop %edi
8010578f: 5d pop %ebp
exit();
80105790: e9 0b e3 ff ff jmp 80103aa0 <exit>
80105795: 8d 76 00 lea 0x0(%esi),%esi
exit();
80105798: e8 03 e3 ff ff call 80103aa0 <exit>
8010579d: eb cd jmp 8010576c <trap+0x25c>
8010579f: 90 nop
acquire(&tickslock);
801057a0: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801057a7: e8 94 e9 ff ff call 80104140 <acquire>
wakeup(&ticks);
801057ac: c7 04 24 a0 55 11 80 movl $0x801155a0,(%esp)
ticks++;
801057b3: 83 05 a0 55 11 80 01 addl $0x1,0x801155a0
wakeup(&ticks);
801057ba: e8 d1 e5 ff ff call 80103d90 <wakeup>
release(&tickslock);
801057bf: c7 04 24 60 4d 11 80 movl $0x80114d60,(%esp)
801057c6: e8 65 ea ff ff call 80104230 <release>
801057cb: e9 1d ff ff ff jmp 801056ed <trap+0x1dd>
cprintf("case T_PGFLT from trap.c: allocuvm failed. Number of current allocated pages: %d \n", myproc()->szStack);
801057d0: e8 cb de ff ff call 801036a0 <myproc>
801057d5: 8b 40 08 mov 0x8(%eax),%eax
801057d8: c7 04 24 50 76 10 80 movl $0x80107650,(%esp)
801057df: 89 44 24 04 mov %eax,0x4(%esp)
801057e3: e8 68 ae ff ff call 80100650 <cprintf>
exit();
801057e8: e8 b3 e2 ff ff call 80103aa0 <exit>
801057ed: e9 c1 fe ff ff jmp 801056b3 <trap+0x1a3>
801057f2: 0f 20 d7 mov %cr2,%edi
cprintf("unexpected trap %d from cpu %d eip %x (cr2=0x%x)\n",
801057f5: 8b 73 38 mov 0x38(%ebx),%esi
801057f8: e8 83 de ff ff call 80103680 <cpuid>
801057fd: 89 7c 24 10 mov %edi,0x10(%esp)
80105801: 89 74 24 0c mov %esi,0xc(%esp)
80105805: 89 44 24 08 mov %eax,0x8(%esp)
80105809: 8b 43 30 mov 0x30(%ebx),%eax
8010580c: c7 04 24 f4 76 10 80 movl $0x801076f4,(%esp)
80105813: 89 44 24 04 mov %eax,0x4(%esp)
80105817: e8 34 ae ff ff call 80100650 <cprintf>
panic("trap");
8010581c: c7 04 24 26 76 10 80 movl $0x80107626,(%esp)
80105823: e8 38 ab ff ff call 80100360 <panic>
80105828: 66 90 xchg %ax,%ax
8010582a: 66 90 xchg %ax,%ax
8010582c: 66 90 xchg %ax,%ax
8010582e: 66 90 xchg %ax,%ax
80105830 <uartgetc>:
}
static int
uartgetc(void)
{
if(!uart)
80105830: a1 bc a5 10 80 mov 0x8010a5bc,%eax
{
80105835: 55 push %ebp
80105836: 89 e5 mov %esp,%ebp
if(!uart)
80105838: 85 c0 test %eax,%eax
8010583a: 74 14 je 80105850 <uartgetc+0x20>
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
8010583c: ba fd 03 00 00 mov $0x3fd,%edx
80105841: ec in (%dx),%al
return -1;
if(!(inb(COM1+5) & 0x01))
80105842: a8 01 test $0x1,%al
80105844: 74 0a je 80105850 <uartgetc+0x20>
80105846: b2 f8 mov $0xf8,%dl
80105848: ec in (%dx),%al
return -1;
return inb(COM1+0);
80105849: 0f b6 c0 movzbl %al,%eax
}
8010584c: 5d pop %ebp
8010584d: c3 ret
8010584e: 66 90 xchg %ax,%ax
return -1;
80105850: b8 ff ff ff ff mov $0xffffffff,%eax
}
80105855: 5d pop %ebp
80105856: c3 ret
80105857: 89 f6 mov %esi,%esi
80105859: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80105860 <uartputc>:
if(!uart)
80105860: a1 bc a5 10 80 mov 0x8010a5bc,%eax
80105865: 85 c0 test %eax,%eax
80105867: 74 3f je 801058a8 <uartputc+0x48>
{
80105869: 55 push %ebp
8010586a: 89 e5 mov %esp,%ebp
8010586c: 56 push %esi
8010586d: be fd 03 00 00 mov $0x3fd,%esi
80105872: 53 push %ebx
if(!uart)
80105873: bb 80 00 00 00 mov $0x80,%ebx
{
80105878: 83 ec 10 sub $0x10,%esp
8010587b: eb 14 jmp 80105891 <uartputc+0x31>
8010587d: 8d 76 00 lea 0x0(%esi),%esi
microdelay(10);
80105880: c7 04 24 0a 00 00 00 movl $0xa,(%esp)
80105887: e8 14 cf ff ff call 801027a0 <microdelay>
for(i = 0; i < 128 && !(inb(COM1+5) & 0x20); i++)
8010588c: 83 eb 01 sub $0x1,%ebx
8010588f: 74 07 je 80105898 <uartputc+0x38>
80105891: 89 f2 mov %esi,%edx
80105893: ec in (%dx),%al
80105894: a8 20 test $0x20,%al
80105896: 74 e8 je 80105880 <uartputc+0x20>
outb(COM1+0, c);
80105898: 0f b6 45 08 movzbl 0x8(%ebp),%eax
asm volatile("out %0,%1" : : "a" (data), "d" (port));
8010589c: ba f8 03 00 00 mov $0x3f8,%edx
801058a1: ee out %al,(%dx)
}
801058a2: 83 c4 10 add $0x10,%esp
801058a5: 5b pop %ebx
801058a6: 5e pop %esi
801058a7: 5d pop %ebp
801058a8: f3 c3 repz ret
801058aa: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801058b0 <uartinit>:
{
801058b0: 55 push %ebp
801058b1: 31 c9 xor %ecx,%ecx
801058b3: 89 e5 mov %esp,%ebp
801058b5: 89 c8 mov %ecx,%eax
801058b7: 57 push %edi
801058b8: bf fa 03 00 00 mov $0x3fa,%edi
801058bd: 56 push %esi
801058be: 89 fa mov %edi,%edx
801058c0: 53 push %ebx
801058c1: 83 ec 1c sub $0x1c,%esp
801058c4: ee out %al,(%dx)
801058c5: be fb 03 00 00 mov $0x3fb,%esi
801058ca: b8 80 ff ff ff mov $0xffffff80,%eax
801058cf: 89 f2 mov %esi,%edx
801058d1: ee out %al,(%dx)
801058d2: b8 0c 00 00 00 mov $0xc,%eax
801058d7: b2 f8 mov $0xf8,%dl
801058d9: ee out %al,(%dx)
801058da: bb f9 03 00 00 mov $0x3f9,%ebx
801058df: 89 c8 mov %ecx,%eax
801058e1: 89 da mov %ebx,%edx
801058e3: ee out %al,(%dx)
801058e4: b8 03 00 00 00 mov $0x3,%eax
801058e9: 89 f2 mov %esi,%edx
801058eb: ee out %al,(%dx)
801058ec: b2 fc mov $0xfc,%dl
801058ee: 89 c8 mov %ecx,%eax
801058f0: ee out %al,(%dx)
801058f1: b8 01 00 00 00 mov $0x1,%eax
801058f6: 89 da mov %ebx,%edx
801058f8: ee out %al,(%dx)
asm volatile("in %1,%0" : "=a" (data) : "d" (port));
801058f9: b2 fd mov $0xfd,%dl
801058fb: ec in (%dx),%al
if(inb(COM1+5) == 0xFF)
801058fc: 3c ff cmp $0xff,%al
801058fe: 74 42 je 80105942 <uartinit+0x92>
uart = 1;
80105900: c7 05 bc a5 10 80 01 movl $0x1,0x8010a5bc
80105907: 00 00 00
8010590a: 89 fa mov %edi,%edx
8010590c: ec in (%dx),%al
8010590d: b2 f8 mov $0xf8,%dl
8010590f: ec in (%dx),%al
ioapicenable(IRQ_COM1, 0);
80105910: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80105917: 00
for(p="xv6...\n"; *p; p++)
80105918: bb 34 78 10 80 mov $0x80107834,%ebx
ioapicenable(IRQ_COM1, 0);
8010591d: c7 04 24 04 00 00 00 movl $0x4,(%esp)
80105924: e8 87 c9 ff ff call 801022b0 <ioapicenable>
for(p="xv6...\n"; *p; p++)
80105929: b8 78 00 00 00 mov $0x78,%eax
8010592e: 66 90 xchg %ax,%ax
uartputc(*p);
80105930: 89 04 24 mov %eax,(%esp)
for(p="xv6...\n"; *p; p++)
80105933: 83 c3 01 add $0x1,%ebx
uartputc(*p);
80105936: e8 25 ff ff ff call 80105860 <uartputc>
for(p="xv6...\n"; *p; p++)
8010593b: 0f be 03 movsbl (%ebx),%eax
8010593e: 84 c0 test %al,%al
80105940: 75 ee jne 80105930 <uartinit+0x80>
}
80105942: 83 c4 1c add $0x1c,%esp
80105945: 5b pop %ebx
80105946: 5e pop %esi
80105947: 5f pop %edi
80105948: 5d pop %ebp
80105949: c3 ret
8010594a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80105950 <uartintr>:
void
uartintr(void)
{
80105950: 55 push %ebp
80105951: 89 e5 mov %esp,%ebp
80105953: 83 ec 18 sub $0x18,%esp
consoleintr(uartgetc);
80105956: c7 04 24 30 58 10 80 movl $0x80105830,(%esp)
8010595d: e8 4e ae ff ff call 801007b0 <consoleintr>
}
80105962: c9 leave
80105963: c3 ret
80105964 <vector0>:
# generated by vectors.pl - do not edit
# handlers
.globl alltraps
.globl vector0
vector0:
pushl $0
80105964: 6a 00 push $0x0
pushl $0
80105966: 6a 00 push $0x0
jmp alltraps
80105968: e9 b0 fa ff ff jmp 8010541d <alltraps>
8010596d <vector1>:
.globl vector1
vector1:
pushl $0
8010596d: 6a 00 push $0x0
pushl $1
8010596f: 6a 01 push $0x1
jmp alltraps
80105971: e9 a7 fa ff ff jmp 8010541d <alltraps>
80105976 <vector2>:
.globl vector2
vector2:
pushl $0
80105976: 6a 00 push $0x0
pushl $2
80105978: 6a 02 push $0x2
jmp alltraps
8010597a: e9 9e fa ff ff jmp 8010541d <alltraps>
8010597f <vector3>:
.globl vector3
vector3:
pushl $0
8010597f: 6a 00 push $0x0
pushl $3
80105981: 6a 03 push $0x3
jmp alltraps
80105983: e9 95 fa ff ff jmp 8010541d <alltraps>
80105988 <vector4>:
.globl vector4
vector4:
pushl $0
80105988: 6a 00 push $0x0
pushl $4
8010598a: 6a 04 push $0x4
jmp alltraps
8010598c: e9 8c fa ff ff jmp 8010541d <alltraps>
80105991 <vector5>:
.globl vector5
vector5:
pushl $0
80105991: 6a 00 push $0x0
pushl $5
80105993: 6a 05 push $0x5
jmp alltraps
80105995: e9 83 fa ff ff jmp 8010541d <alltraps>
8010599a <vector6>:
.globl vector6
vector6:
pushl $0
8010599a: 6a 00 push $0x0
pushl $6
8010599c: 6a 06 push $0x6
jmp alltraps
8010599e: e9 7a fa ff ff jmp 8010541d <alltraps>
801059a3 <vector7>:
.globl vector7
vector7:
pushl $0
801059a3: 6a 00 push $0x0
pushl $7
801059a5: 6a 07 push $0x7
jmp alltraps
801059a7: e9 71 fa ff ff jmp 8010541d <alltraps>
801059ac <vector8>:
.globl vector8
vector8:
pushl $8
801059ac: 6a 08 push $0x8
jmp alltraps
801059ae: e9 6a fa ff ff jmp 8010541d <alltraps>
801059b3 <vector9>:
.globl vector9
vector9:
pushl $0
801059b3: 6a 00 push $0x0
pushl $9
801059b5: 6a 09 push $0x9
jmp alltraps
801059b7: e9 61 fa ff ff jmp 8010541d <alltraps>
801059bc <vector10>:
.globl vector10
vector10:
pushl $10
801059bc: 6a 0a push $0xa
jmp alltraps
801059be: e9 5a fa ff ff jmp 8010541d <alltraps>
801059c3 <vector11>:
.globl vector11
vector11:
pushl $11
801059c3: 6a 0b push $0xb
jmp alltraps
801059c5: e9 53 fa ff ff jmp 8010541d <alltraps>
801059ca <vector12>:
.globl vector12
vector12:
pushl $12
801059ca: 6a 0c push $0xc
jmp alltraps
801059cc: e9 4c fa ff ff jmp 8010541d <alltraps>
801059d1 <vector13>:
.globl vector13
vector13:
pushl $13
801059d1: 6a 0d push $0xd
jmp alltraps
801059d3: e9 45 fa ff ff jmp 8010541d <alltraps>
801059d8 <vector14>:
.globl vector14
vector14:
pushl $14
801059d8: 6a 0e push $0xe
jmp alltraps
801059da: e9 3e fa ff ff jmp 8010541d <alltraps>
801059df <vector15>:
.globl vector15
vector15:
pushl $0
801059df: 6a 00 push $0x0
pushl $15
801059e1: 6a 0f push $0xf
jmp alltraps
801059e3: e9 35 fa ff ff jmp 8010541d <alltraps>
801059e8 <vector16>:
.globl vector16
vector16:
pushl $0
801059e8: 6a 00 push $0x0
pushl $16
801059ea: 6a 10 push $0x10
jmp alltraps
801059ec: e9 2c fa ff ff jmp 8010541d <alltraps>
801059f1 <vector17>:
.globl vector17
vector17:
pushl $17
801059f1: 6a 11 push $0x11
jmp alltraps
801059f3: e9 25 fa ff ff jmp 8010541d <alltraps>
801059f8 <vector18>:
.globl vector18
vector18:
pushl $0
801059f8: 6a 00 push $0x0
pushl $18
801059fa: 6a 12 push $0x12
jmp alltraps
801059fc: e9 1c fa ff ff jmp 8010541d <alltraps>
80105a01 <vector19>:
.globl vector19
vector19:
pushl $0
80105a01: 6a 00 push $0x0
pushl $19
80105a03: 6a 13 push $0x13
jmp alltraps
80105a05: e9 13 fa ff ff jmp 8010541d <alltraps>
80105a0a <vector20>:
.globl vector20
vector20:
pushl $0
80105a0a: 6a 00 push $0x0
pushl $20
80105a0c: 6a 14 push $0x14
jmp alltraps
80105a0e: e9 0a fa ff ff jmp 8010541d <alltraps>
80105a13 <vector21>:
.globl vector21
vector21:
pushl $0
80105a13: 6a 00 push $0x0
pushl $21
80105a15: 6a 15 push $0x15
jmp alltraps
80105a17: e9 01 fa ff ff jmp 8010541d <alltraps>
80105a1c <vector22>:
.globl vector22
vector22:
pushl $0
80105a1c: 6a 00 push $0x0
pushl $22
80105a1e: 6a 16 push $0x16
jmp alltraps
80105a20: e9 f8 f9 ff ff jmp 8010541d <alltraps>
80105a25 <vector23>:
.globl vector23
vector23:
pushl $0
80105a25: 6a 00 push $0x0
pushl $23
80105a27: 6a 17 push $0x17
jmp alltraps
80105a29: e9 ef f9 ff ff jmp 8010541d <alltraps>
80105a2e <vector24>:
.globl vector24
vector24:
pushl $0
80105a2e: 6a 00 push $0x0
pushl $24
80105a30: 6a 18 push $0x18
jmp alltraps
80105a32: e9 e6 f9 ff ff jmp 8010541d <alltraps>
80105a37 <vector25>:
.globl vector25
vector25:
pushl $0
80105a37: 6a 00 push $0x0
pushl $25
80105a39: 6a 19 push $0x19
jmp alltraps
80105a3b: e9 dd f9 ff ff jmp 8010541d <alltraps>
80105a40 <vector26>:
.globl vector26
vector26:
pushl $0
80105a40: 6a 00 push $0x0
pushl $26
80105a42: 6a 1a push $0x1a
jmp alltraps
80105a44: e9 d4 f9 ff ff jmp 8010541d <alltraps>
80105a49 <vector27>:
.globl vector27
vector27:
pushl $0
80105a49: 6a 00 push $0x0
pushl $27
80105a4b: 6a 1b push $0x1b
jmp alltraps
80105a4d: e9 cb f9 ff ff jmp 8010541d <alltraps>
80105a52 <vector28>:
.globl vector28
vector28:
pushl $0
80105a52: 6a 00 push $0x0
pushl $28
80105a54: 6a 1c push $0x1c
jmp alltraps
80105a56: e9 c2 f9 ff ff jmp 8010541d <alltraps>
80105a5b <vector29>:
.globl vector29
vector29:
pushl $0
80105a5b: 6a 00 push $0x0
pushl $29
80105a5d: 6a 1d push $0x1d
jmp alltraps
80105a5f: e9 b9 f9 ff ff jmp 8010541d <alltraps>
80105a64 <vector30>:
.globl vector30
vector30:
pushl $0
80105a64: 6a 00 push $0x0
pushl $30
80105a66: 6a 1e push $0x1e
jmp alltraps
80105a68: e9 b0 f9 ff ff jmp 8010541d <alltraps>
80105a6d <vector31>:
.globl vector31
vector31:
pushl $0
80105a6d: 6a 00 push $0x0
pushl $31
80105a6f: 6a 1f push $0x1f
jmp alltraps
80105a71: e9 a7 f9 ff ff jmp 8010541d <alltraps>
80105a76 <vector32>:
.globl vector32
vector32:
pushl $0
80105a76: 6a 00 push $0x0
pushl $32
80105a78: 6a 20 push $0x20
jmp alltraps
80105a7a: e9 9e f9 ff ff jmp 8010541d <alltraps>
80105a7f <vector33>:
.globl vector33
vector33:
pushl $0
80105a7f: 6a 00 push $0x0
pushl $33
80105a81: 6a 21 push $0x21
jmp alltraps
80105a83: e9 95 f9 ff ff jmp 8010541d <alltraps>
80105a88 <vector34>:
.globl vector34
vector34:
pushl $0
80105a88: 6a 00 push $0x0
pushl $34
80105a8a: 6a 22 push $0x22
jmp alltraps
80105a8c: e9 8c f9 ff ff jmp 8010541d <alltraps>
80105a91 <vector35>:
.globl vector35
vector35:
pushl $0
80105a91: 6a 00 push $0x0
pushl $35
80105a93: 6a 23 push $0x23
jmp alltraps
80105a95: e9 83 f9 ff ff jmp 8010541d <alltraps>
80105a9a <vector36>:
.globl vector36
vector36:
pushl $0
80105a9a: 6a 00 push $0x0
pushl $36
80105a9c: 6a 24 push $0x24
jmp alltraps
80105a9e: e9 7a f9 ff ff jmp 8010541d <alltraps>
80105aa3 <vector37>:
.globl vector37
vector37:
pushl $0
80105aa3: 6a 00 push $0x0
pushl $37
80105aa5: 6a 25 push $0x25
jmp alltraps
80105aa7: e9 71 f9 ff ff jmp 8010541d <alltraps>
80105aac <vector38>:
.globl vector38
vector38:
pushl $0
80105aac: 6a 00 push $0x0
pushl $38
80105aae: 6a 26 push $0x26
jmp alltraps
80105ab0: e9 68 f9 ff ff jmp 8010541d <alltraps>
80105ab5 <vector39>:
.globl vector39
vector39:
pushl $0
80105ab5: 6a 00 push $0x0
pushl $39
80105ab7: 6a 27 push $0x27
jmp alltraps
80105ab9: e9 5f f9 ff ff jmp 8010541d <alltraps>
80105abe <vector40>:
.globl vector40
vector40:
pushl $0
80105abe: 6a 00 push $0x0
pushl $40
80105ac0: 6a 28 push $0x28
jmp alltraps
80105ac2: e9 56 f9 ff ff jmp 8010541d <alltraps>
80105ac7 <vector41>:
.globl vector41
vector41:
pushl $0
80105ac7: 6a 00 push $0x0
pushl $41
80105ac9: 6a 29 push $0x29
jmp alltraps
80105acb: e9 4d f9 ff ff jmp 8010541d <alltraps>
80105ad0 <vector42>:
.globl vector42
vector42:
pushl $0
80105ad0: 6a 00 push $0x0
pushl $42
80105ad2: 6a 2a push $0x2a
jmp alltraps
80105ad4: e9 44 f9 ff ff jmp 8010541d <alltraps>
80105ad9 <vector43>:
.globl vector43
vector43:
pushl $0
80105ad9: 6a 00 push $0x0
pushl $43
80105adb: 6a 2b push $0x2b
jmp alltraps
80105add: e9 3b f9 ff ff jmp 8010541d <alltraps>
80105ae2 <vector44>:
.globl vector44
vector44:
pushl $0
80105ae2: 6a 00 push $0x0
pushl $44
80105ae4: 6a 2c push $0x2c
jmp alltraps
80105ae6: e9 32 f9 ff ff jmp 8010541d <alltraps>
80105aeb <vector45>:
.globl vector45
vector45:
pushl $0
80105aeb: 6a 00 push $0x0
pushl $45
80105aed: 6a 2d push $0x2d
jmp alltraps
80105aef: e9 29 f9 ff ff jmp 8010541d <alltraps>
80105af4 <vector46>:
.globl vector46
vector46:
pushl $0
80105af4: 6a 00 push $0x0
pushl $46
80105af6: 6a 2e push $0x2e
jmp alltraps
80105af8: e9 20 f9 ff ff jmp 8010541d <alltraps>
80105afd <vector47>:
.globl vector47
vector47:
pushl $0
80105afd: 6a 00 push $0x0
pushl $47
80105aff: 6a 2f push $0x2f
jmp alltraps
80105b01: e9 17 f9 ff ff jmp 8010541d <alltraps>
80105b06 <vector48>:
.globl vector48
vector48:
pushl $0
80105b06: 6a 00 push $0x0
pushl $48
80105b08: 6a 30 push $0x30
jmp alltraps
80105b0a: e9 0e f9 ff ff jmp 8010541d <alltraps>
80105b0f <vector49>:
.globl vector49
vector49:
pushl $0
80105b0f: 6a 00 push $0x0
pushl $49
80105b11: 6a 31 push $0x31
jmp alltraps
80105b13: e9 05 f9 ff ff jmp 8010541d <alltraps>
80105b18 <vector50>:
.globl vector50
vector50:
pushl $0
80105b18: 6a 00 push $0x0
pushl $50
80105b1a: 6a 32 push $0x32
jmp alltraps
80105b1c: e9 fc f8 ff ff jmp 8010541d <alltraps>
80105b21 <vector51>:
.globl vector51
vector51:
pushl $0
80105b21: 6a 00 push $0x0
pushl $51
80105b23: 6a 33 push $0x33
jmp alltraps
80105b25: e9 f3 f8 ff ff jmp 8010541d <alltraps>
80105b2a <vector52>:
.globl vector52
vector52:
pushl $0
80105b2a: 6a 00 push $0x0
pushl $52
80105b2c: 6a 34 push $0x34
jmp alltraps
80105b2e: e9 ea f8 ff ff jmp 8010541d <alltraps>
80105b33 <vector53>:
.globl vector53
vector53:
pushl $0
80105b33: 6a 00 push $0x0
pushl $53
80105b35: 6a 35 push $0x35
jmp alltraps
80105b37: e9 e1 f8 ff ff jmp 8010541d <alltraps>
80105b3c <vector54>:
.globl vector54
vector54:
pushl $0
80105b3c: 6a 00 push $0x0
pushl $54
80105b3e: 6a 36 push $0x36
jmp alltraps
80105b40: e9 d8 f8 ff ff jmp 8010541d <alltraps>
80105b45 <vector55>:
.globl vector55
vector55:
pushl $0
80105b45: 6a 00 push $0x0
pushl $55
80105b47: 6a 37 push $0x37
jmp alltraps
80105b49: e9 cf f8 ff ff jmp 8010541d <alltraps>
80105b4e <vector56>:
.globl vector56
vector56:
pushl $0
80105b4e: 6a 00 push $0x0
pushl $56
80105b50: 6a 38 push $0x38
jmp alltraps
80105b52: e9 c6 f8 ff ff jmp 8010541d <alltraps>
80105b57 <vector57>:
.globl vector57
vector57:
pushl $0
80105b57: 6a 00 push $0x0
pushl $57
80105b59: 6a 39 push $0x39
jmp alltraps
80105b5b: e9 bd f8 ff ff jmp 8010541d <alltraps>
80105b60 <vector58>:
.globl vector58
vector58:
pushl $0
80105b60: 6a 00 push $0x0
pushl $58
80105b62: 6a 3a push $0x3a
jmp alltraps
80105b64: e9 b4 f8 ff ff jmp 8010541d <alltraps>
80105b69 <vector59>:
.globl vector59
vector59:
pushl $0
80105b69: 6a 00 push $0x0
pushl $59
80105b6b: 6a 3b push $0x3b
jmp alltraps
80105b6d: e9 ab f8 ff ff jmp 8010541d <alltraps>
80105b72 <vector60>:
.globl vector60
vector60:
pushl $0
80105b72: 6a 00 push $0x0
pushl $60
80105b74: 6a 3c push $0x3c
jmp alltraps
80105b76: e9 a2 f8 ff ff jmp 8010541d <alltraps>
80105b7b <vector61>:
.globl vector61
vector61:
pushl $0
80105b7b: 6a 00 push $0x0
pushl $61
80105b7d: 6a 3d push $0x3d
jmp alltraps
80105b7f: e9 99 f8 ff ff jmp 8010541d <alltraps>
80105b84 <vector62>:
.globl vector62
vector62:
pushl $0
80105b84: 6a 00 push $0x0
pushl $62
80105b86: 6a 3e push $0x3e
jmp alltraps
80105b88: e9 90 f8 ff ff jmp 8010541d <alltraps>
80105b8d <vector63>:
.globl vector63
vector63:
pushl $0
80105b8d: 6a 00 push $0x0
pushl $63
80105b8f: 6a 3f push $0x3f
jmp alltraps
80105b91: e9 87 f8 ff ff jmp 8010541d <alltraps>
80105b96 <vector64>:
.globl vector64
vector64:
pushl $0
80105b96: 6a 00 push $0x0
pushl $64
80105b98: 6a 40 push $0x40
jmp alltraps
80105b9a: e9 7e f8 ff ff jmp 8010541d <alltraps>
80105b9f <vector65>:
.globl vector65
vector65:
pushl $0
80105b9f: 6a 00 push $0x0
pushl $65
80105ba1: 6a 41 push $0x41
jmp alltraps
80105ba3: e9 75 f8 ff ff jmp 8010541d <alltraps>
80105ba8 <vector66>:
.globl vector66
vector66:
pushl $0
80105ba8: 6a 00 push $0x0
pushl $66
80105baa: 6a 42 push $0x42
jmp alltraps
80105bac: e9 6c f8 ff ff jmp 8010541d <alltraps>
80105bb1 <vector67>:
.globl vector67
vector67:
pushl $0
80105bb1: 6a 00 push $0x0
pushl $67
80105bb3: 6a 43 push $0x43
jmp alltraps
80105bb5: e9 63 f8 ff ff jmp 8010541d <alltraps>
80105bba <vector68>:
.globl vector68
vector68:
pushl $0
80105bba: 6a 00 push $0x0
pushl $68
80105bbc: 6a 44 push $0x44
jmp alltraps
80105bbe: e9 5a f8 ff ff jmp 8010541d <alltraps>
80105bc3 <vector69>:
.globl vector69
vector69:
pushl $0
80105bc3: 6a 00 push $0x0
pushl $69
80105bc5: 6a 45 push $0x45
jmp alltraps
80105bc7: e9 51 f8 ff ff jmp 8010541d <alltraps>
80105bcc <vector70>:
.globl vector70
vector70:
pushl $0
80105bcc: 6a 00 push $0x0
pushl $70
80105bce: 6a 46 push $0x46
jmp alltraps
80105bd0: e9 48 f8 ff ff jmp 8010541d <alltraps>
80105bd5 <vector71>:
.globl vector71
vector71:
pushl $0
80105bd5: 6a 00 push $0x0
pushl $71
80105bd7: 6a 47 push $0x47
jmp alltraps
80105bd9: e9 3f f8 ff ff jmp 8010541d <alltraps>
80105bde <vector72>:
.globl vector72
vector72:
pushl $0
80105bde: 6a 00 push $0x0
pushl $72
80105be0: 6a 48 push $0x48
jmp alltraps
80105be2: e9 36 f8 ff ff jmp 8010541d <alltraps>
80105be7 <vector73>:
.globl vector73
vector73:
pushl $0
80105be7: 6a 00 push $0x0
pushl $73
80105be9: 6a 49 push $0x49
jmp alltraps
80105beb: e9 2d f8 ff ff jmp 8010541d <alltraps>
80105bf0 <vector74>:
.globl vector74
vector74:
pushl $0
80105bf0: 6a 00 push $0x0
pushl $74
80105bf2: 6a 4a push $0x4a
jmp alltraps
80105bf4: e9 24 f8 ff ff jmp 8010541d <alltraps>
80105bf9 <vector75>:
.globl vector75
vector75:
pushl $0
80105bf9: 6a 00 push $0x0
pushl $75
80105bfb: 6a 4b push $0x4b
jmp alltraps
80105bfd: e9 1b f8 ff ff jmp 8010541d <alltraps>
80105c02 <vector76>:
.globl vector76
vector76:
pushl $0
80105c02: 6a 00 push $0x0
pushl $76
80105c04: 6a 4c push $0x4c
jmp alltraps
80105c06: e9 12 f8 ff ff jmp 8010541d <alltraps>
80105c0b <vector77>:
.globl vector77
vector77:
pushl $0
80105c0b: 6a 00 push $0x0
pushl $77
80105c0d: 6a 4d push $0x4d
jmp alltraps
80105c0f: e9 09 f8 ff ff jmp 8010541d <alltraps>
80105c14 <vector78>:
.globl vector78
vector78:
pushl $0
80105c14: 6a 00 push $0x0
pushl $78
80105c16: 6a 4e push $0x4e
jmp alltraps
80105c18: e9 00 f8 ff ff jmp 8010541d <alltraps>
80105c1d <vector79>:
.globl vector79
vector79:
pushl $0
80105c1d: 6a 00 push $0x0
pushl $79
80105c1f: 6a 4f push $0x4f
jmp alltraps
80105c21: e9 f7 f7 ff ff jmp 8010541d <alltraps>
80105c26 <vector80>:
.globl vector80
vector80:
pushl $0
80105c26: 6a 00 push $0x0
pushl $80
80105c28: 6a 50 push $0x50
jmp alltraps
80105c2a: e9 ee f7 ff ff jmp 8010541d <alltraps>
80105c2f <vector81>:
.globl vector81
vector81:
pushl $0
80105c2f: 6a 00 push $0x0
pushl $81
80105c31: 6a 51 push $0x51
jmp alltraps
80105c33: e9 e5 f7 ff ff jmp 8010541d <alltraps>
80105c38 <vector82>:
.globl vector82
vector82:
pushl $0
80105c38: 6a 00 push $0x0
pushl $82
80105c3a: 6a 52 push $0x52
jmp alltraps
80105c3c: e9 dc f7 ff ff jmp 8010541d <alltraps>
80105c41 <vector83>:
.globl vector83
vector83:
pushl $0
80105c41: 6a 00 push $0x0
pushl $83
80105c43: 6a 53 push $0x53
jmp alltraps
80105c45: e9 d3 f7 ff ff jmp 8010541d <alltraps>
80105c4a <vector84>:
.globl vector84
vector84:
pushl $0
80105c4a: 6a 00 push $0x0
pushl $84
80105c4c: 6a 54 push $0x54
jmp alltraps
80105c4e: e9 ca f7 ff ff jmp 8010541d <alltraps>
80105c53 <vector85>:
.globl vector85
vector85:
pushl $0
80105c53: 6a 00 push $0x0
pushl $85
80105c55: 6a 55 push $0x55
jmp alltraps
80105c57: e9 c1 f7 ff ff jmp 8010541d <alltraps>
80105c5c <vector86>:
.globl vector86
vector86:
pushl $0
80105c5c: 6a 00 push $0x0
pushl $86
80105c5e: 6a 56 push $0x56
jmp alltraps
80105c60: e9 b8 f7 ff ff jmp 8010541d <alltraps>
80105c65 <vector87>:
.globl vector87
vector87:
pushl $0
80105c65: 6a 00 push $0x0
pushl $87
80105c67: 6a 57 push $0x57
jmp alltraps
80105c69: e9 af f7 ff ff jmp 8010541d <alltraps>
80105c6e <vector88>:
.globl vector88
vector88:
pushl $0
80105c6e: 6a 00 push $0x0
pushl $88
80105c70: 6a 58 push $0x58
jmp alltraps
80105c72: e9 a6 f7 ff ff jmp 8010541d <alltraps>
80105c77 <vector89>:
.globl vector89
vector89:
pushl $0
80105c77: 6a 00 push $0x0
pushl $89
80105c79: 6a 59 push $0x59
jmp alltraps
80105c7b: e9 9d f7 ff ff jmp 8010541d <alltraps>
80105c80 <vector90>:
.globl vector90
vector90:
pushl $0
80105c80: 6a 00 push $0x0
pushl $90
80105c82: 6a 5a push $0x5a
jmp alltraps
80105c84: e9 94 f7 ff ff jmp 8010541d <alltraps>
80105c89 <vector91>:
.globl vector91
vector91:
pushl $0
80105c89: 6a 00 push $0x0
pushl $91
80105c8b: 6a 5b push $0x5b
jmp alltraps
80105c8d: e9 8b f7 ff ff jmp 8010541d <alltraps>
80105c92 <vector92>:
.globl vector92
vector92:
pushl $0
80105c92: 6a 00 push $0x0
pushl $92
80105c94: 6a 5c push $0x5c
jmp alltraps
80105c96: e9 82 f7 ff ff jmp 8010541d <alltraps>
80105c9b <vector93>:
.globl vector93
vector93:
pushl $0
80105c9b: 6a 00 push $0x0
pushl $93
80105c9d: 6a 5d push $0x5d
jmp alltraps
80105c9f: e9 79 f7 ff ff jmp 8010541d <alltraps>
80105ca4 <vector94>:
.globl vector94
vector94:
pushl $0
80105ca4: 6a 00 push $0x0
pushl $94
80105ca6: 6a 5e push $0x5e
jmp alltraps
80105ca8: e9 70 f7 ff ff jmp 8010541d <alltraps>
80105cad <vector95>:
.globl vector95
vector95:
pushl $0
80105cad: 6a 00 push $0x0
pushl $95
80105caf: 6a 5f push $0x5f
jmp alltraps
80105cb1: e9 67 f7 ff ff jmp 8010541d <alltraps>
80105cb6 <vector96>:
.globl vector96
vector96:
pushl $0
80105cb6: 6a 00 push $0x0
pushl $96
80105cb8: 6a 60 push $0x60
jmp alltraps
80105cba: e9 5e f7 ff ff jmp 8010541d <alltraps>
80105cbf <vector97>:
.globl vector97
vector97:
pushl $0
80105cbf: 6a 00 push $0x0
pushl $97
80105cc1: 6a 61 push $0x61
jmp alltraps
80105cc3: e9 55 f7 ff ff jmp 8010541d <alltraps>
80105cc8 <vector98>:
.globl vector98
vector98:
pushl $0
80105cc8: 6a 00 push $0x0
pushl $98
80105cca: 6a 62 push $0x62
jmp alltraps
80105ccc: e9 4c f7 ff ff jmp 8010541d <alltraps>
80105cd1 <vector99>:
.globl vector99
vector99:
pushl $0
80105cd1: 6a 00 push $0x0
pushl $99
80105cd3: 6a 63 push $0x63
jmp alltraps
80105cd5: e9 43 f7 ff ff jmp 8010541d <alltraps>
80105cda <vector100>:
.globl vector100
vector100:
pushl $0
80105cda: 6a 00 push $0x0
pushl $100
80105cdc: 6a 64 push $0x64
jmp alltraps
80105cde: e9 3a f7 ff ff jmp 8010541d <alltraps>
80105ce3 <vector101>:
.globl vector101
vector101:
pushl $0
80105ce3: 6a 00 push $0x0
pushl $101
80105ce5: 6a 65 push $0x65
jmp alltraps
80105ce7: e9 31 f7 ff ff jmp 8010541d <alltraps>
80105cec <vector102>:
.globl vector102
vector102:
pushl $0
80105cec: 6a 00 push $0x0
pushl $102
80105cee: 6a 66 push $0x66
jmp alltraps
80105cf0: e9 28 f7 ff ff jmp 8010541d <alltraps>
80105cf5 <vector103>:
.globl vector103
vector103:
pushl $0
80105cf5: 6a 00 push $0x0
pushl $103
80105cf7: 6a 67 push $0x67
jmp alltraps
80105cf9: e9 1f f7 ff ff jmp 8010541d <alltraps>
80105cfe <vector104>:
.globl vector104
vector104:
pushl $0
80105cfe: 6a 00 push $0x0
pushl $104
80105d00: 6a 68 push $0x68
jmp alltraps
80105d02: e9 16 f7 ff ff jmp 8010541d <alltraps>
80105d07 <vector105>:
.globl vector105
vector105:
pushl $0
80105d07: 6a 00 push $0x0
pushl $105
80105d09: 6a 69 push $0x69
jmp alltraps
80105d0b: e9 0d f7 ff ff jmp 8010541d <alltraps>
80105d10 <vector106>:
.globl vector106
vector106:
pushl $0
80105d10: 6a 00 push $0x0
pushl $106
80105d12: 6a 6a push $0x6a
jmp alltraps
80105d14: e9 04 f7 ff ff jmp 8010541d <alltraps>
80105d19 <vector107>:
.globl vector107
vector107:
pushl $0
80105d19: 6a 00 push $0x0
pushl $107
80105d1b: 6a 6b push $0x6b
jmp alltraps
80105d1d: e9 fb f6 ff ff jmp 8010541d <alltraps>
80105d22 <vector108>:
.globl vector108
vector108:
pushl $0
80105d22: 6a 00 push $0x0
pushl $108
80105d24: 6a 6c push $0x6c
jmp alltraps
80105d26: e9 f2 f6 ff ff jmp 8010541d <alltraps>
80105d2b <vector109>:
.globl vector109
vector109:
pushl $0
80105d2b: 6a 00 push $0x0
pushl $109
80105d2d: 6a 6d push $0x6d
jmp alltraps
80105d2f: e9 e9 f6 ff ff jmp 8010541d <alltraps>
80105d34 <vector110>:
.globl vector110
vector110:
pushl $0
80105d34: 6a 00 push $0x0
pushl $110
80105d36: 6a 6e push $0x6e
jmp alltraps
80105d38: e9 e0 f6 ff ff jmp 8010541d <alltraps>
80105d3d <vector111>:
.globl vector111
vector111:
pushl $0
80105d3d: 6a 00 push $0x0
pushl $111
80105d3f: 6a 6f push $0x6f
jmp alltraps
80105d41: e9 d7 f6 ff ff jmp 8010541d <alltraps>
80105d46 <vector112>:
.globl vector112
vector112:
pushl $0
80105d46: 6a 00 push $0x0
pushl $112
80105d48: 6a 70 push $0x70
jmp alltraps
80105d4a: e9 ce f6 ff ff jmp 8010541d <alltraps>
80105d4f <vector113>:
.globl vector113
vector113:
pushl $0
80105d4f: 6a 00 push $0x0
pushl $113
80105d51: 6a 71 push $0x71
jmp alltraps
80105d53: e9 c5 f6 ff ff jmp 8010541d <alltraps>
80105d58 <vector114>:
.globl vector114
vector114:
pushl $0
80105d58: 6a 00 push $0x0
pushl $114
80105d5a: 6a 72 push $0x72
jmp alltraps
80105d5c: e9 bc f6 ff ff jmp 8010541d <alltraps>
80105d61 <vector115>:
.globl vector115
vector115:
pushl $0
80105d61: 6a 00 push $0x0
pushl $115
80105d63: 6a 73 push $0x73
jmp alltraps
80105d65: e9 b3 f6 ff ff jmp 8010541d <alltraps>
80105d6a <vector116>:
.globl vector116
vector116:
pushl $0
80105d6a: 6a 00 push $0x0
pushl $116
80105d6c: 6a 74 push $0x74
jmp alltraps
80105d6e: e9 aa f6 ff ff jmp 8010541d <alltraps>
80105d73 <vector117>:
.globl vector117
vector117:
pushl $0
80105d73: 6a 00 push $0x0
pushl $117
80105d75: 6a 75 push $0x75
jmp alltraps
80105d77: e9 a1 f6 ff ff jmp 8010541d <alltraps>
80105d7c <vector118>:
.globl vector118
vector118:
pushl $0
80105d7c: 6a 00 push $0x0
pushl $118
80105d7e: 6a 76 push $0x76
jmp alltraps
80105d80: e9 98 f6 ff ff jmp 8010541d <alltraps>
80105d85 <vector119>:
.globl vector119
vector119:
pushl $0
80105d85: 6a 00 push $0x0
pushl $119
80105d87: 6a 77 push $0x77
jmp alltraps
80105d89: e9 8f f6 ff ff jmp 8010541d <alltraps>
80105d8e <vector120>:
.globl vector120
vector120:
pushl $0
80105d8e: 6a 00 push $0x0
pushl $120
80105d90: 6a 78 push $0x78
jmp alltraps
80105d92: e9 86 f6 ff ff jmp 8010541d <alltraps>
80105d97 <vector121>:
.globl vector121
vector121:
pushl $0
80105d97: 6a 00 push $0x0
pushl $121
80105d99: 6a 79 push $0x79
jmp alltraps
80105d9b: e9 7d f6 ff ff jmp 8010541d <alltraps>
80105da0 <vector122>:
.globl vector122
vector122:
pushl $0
80105da0: 6a 00 push $0x0
pushl $122
80105da2: 6a 7a push $0x7a
jmp alltraps
80105da4: e9 74 f6 ff ff jmp 8010541d <alltraps>
80105da9 <vector123>:
.globl vector123
vector123:
pushl $0
80105da9: 6a 00 push $0x0
pushl $123
80105dab: 6a 7b push $0x7b
jmp alltraps
80105dad: e9 6b f6 ff ff jmp 8010541d <alltraps>
80105db2 <vector124>:
.globl vector124
vector124:
pushl $0
80105db2: 6a 00 push $0x0
pushl $124
80105db4: 6a 7c push $0x7c
jmp alltraps
80105db6: e9 62 f6 ff ff jmp 8010541d <alltraps>
80105dbb <vector125>:
.globl vector125
vector125:
pushl $0
80105dbb: 6a 00 push $0x0
pushl $125
80105dbd: 6a 7d push $0x7d
jmp alltraps
80105dbf: e9 59 f6 ff ff jmp 8010541d <alltraps>
80105dc4 <vector126>:
.globl vector126
vector126:
pushl $0
80105dc4: 6a 00 push $0x0
pushl $126
80105dc6: 6a 7e push $0x7e
jmp alltraps
80105dc8: e9 50 f6 ff ff jmp 8010541d <alltraps>
80105dcd <vector127>:
.globl vector127
vector127:
pushl $0
80105dcd: 6a 00 push $0x0
pushl $127
80105dcf: 6a 7f push $0x7f
jmp alltraps
80105dd1: e9 47 f6 ff ff jmp 8010541d <alltraps>
80105dd6 <vector128>:
.globl vector128
vector128:
pushl $0
80105dd6: 6a 00 push $0x0
pushl $128
80105dd8: 68 80 00 00 00 push $0x80
jmp alltraps
80105ddd: e9 3b f6 ff ff jmp 8010541d <alltraps>
80105de2 <vector129>:
.globl vector129
vector129:
pushl $0
80105de2: 6a 00 push $0x0
pushl $129
80105de4: 68 81 00 00 00 push $0x81
jmp alltraps
80105de9: e9 2f f6 ff ff jmp 8010541d <alltraps>
80105dee <vector130>:
.globl vector130
vector130:
pushl $0
80105dee: 6a 00 push $0x0
pushl $130
80105df0: 68 82 00 00 00 push $0x82
jmp alltraps
80105df5: e9 23 f6 ff ff jmp 8010541d <alltraps>
80105dfa <vector131>:
.globl vector131
vector131:
pushl $0
80105dfa: 6a 00 push $0x0
pushl $131
80105dfc: 68 83 00 00 00 push $0x83
jmp alltraps
80105e01: e9 17 f6 ff ff jmp 8010541d <alltraps>
80105e06 <vector132>:
.globl vector132
vector132:
pushl $0
80105e06: 6a 00 push $0x0
pushl $132
80105e08: 68 84 00 00 00 push $0x84
jmp alltraps
80105e0d: e9 0b f6 ff ff jmp 8010541d <alltraps>
80105e12 <vector133>:
.globl vector133
vector133:
pushl $0
80105e12: 6a 00 push $0x0
pushl $133
80105e14: 68 85 00 00 00 push $0x85
jmp alltraps
80105e19: e9 ff f5 ff ff jmp 8010541d <alltraps>
80105e1e <vector134>:
.globl vector134
vector134:
pushl $0
80105e1e: 6a 00 push $0x0
pushl $134
80105e20: 68 86 00 00 00 push $0x86
jmp alltraps
80105e25: e9 f3 f5 ff ff jmp 8010541d <alltraps>
80105e2a <vector135>:
.globl vector135
vector135:
pushl $0
80105e2a: 6a 00 push $0x0
pushl $135
80105e2c: 68 87 00 00 00 push $0x87
jmp alltraps
80105e31: e9 e7 f5 ff ff jmp 8010541d <alltraps>
80105e36 <vector136>:
.globl vector136
vector136:
pushl $0
80105e36: 6a 00 push $0x0
pushl $136
80105e38: 68 88 00 00 00 push $0x88
jmp alltraps
80105e3d: e9 db f5 ff ff jmp 8010541d <alltraps>
80105e42 <vector137>:
.globl vector137
vector137:
pushl $0
80105e42: 6a 00 push $0x0
pushl $137
80105e44: 68 89 00 00 00 push $0x89
jmp alltraps
80105e49: e9 cf f5 ff ff jmp 8010541d <alltraps>
80105e4e <vector138>:
.globl vector138
vector138:
pushl $0
80105e4e: 6a 00 push $0x0
pushl $138
80105e50: 68 8a 00 00 00 push $0x8a
jmp alltraps
80105e55: e9 c3 f5 ff ff jmp 8010541d <alltraps>
80105e5a <vector139>:
.globl vector139
vector139:
pushl $0
80105e5a: 6a 00 push $0x0
pushl $139
80105e5c: 68 8b 00 00 00 push $0x8b
jmp alltraps
80105e61: e9 b7 f5 ff ff jmp 8010541d <alltraps>
80105e66 <vector140>:
.globl vector140
vector140:
pushl $0
80105e66: 6a 00 push $0x0
pushl $140
80105e68: 68 8c 00 00 00 push $0x8c
jmp alltraps
80105e6d: e9 ab f5 ff ff jmp 8010541d <alltraps>
80105e72 <vector141>:
.globl vector141
vector141:
pushl $0
80105e72: 6a 00 push $0x0
pushl $141
80105e74: 68 8d 00 00 00 push $0x8d
jmp alltraps
80105e79: e9 9f f5 ff ff jmp 8010541d <alltraps>
80105e7e <vector142>:
.globl vector142
vector142:
pushl $0
80105e7e: 6a 00 push $0x0
pushl $142
80105e80: 68 8e 00 00 00 push $0x8e
jmp alltraps
80105e85: e9 93 f5 ff ff jmp 8010541d <alltraps>
80105e8a <vector143>:
.globl vector143
vector143:
pushl $0
80105e8a: 6a 00 push $0x0
pushl $143
80105e8c: 68 8f 00 00 00 push $0x8f
jmp alltraps
80105e91: e9 87 f5 ff ff jmp 8010541d <alltraps>
80105e96 <vector144>:
.globl vector144
vector144:
pushl $0
80105e96: 6a 00 push $0x0
pushl $144
80105e98: 68 90 00 00 00 push $0x90
jmp alltraps
80105e9d: e9 7b f5 ff ff jmp 8010541d <alltraps>
80105ea2 <vector145>:
.globl vector145
vector145:
pushl $0
80105ea2: 6a 00 push $0x0
pushl $145
80105ea4: 68 91 00 00 00 push $0x91
jmp alltraps
80105ea9: e9 6f f5 ff ff jmp 8010541d <alltraps>
80105eae <vector146>:
.globl vector146
vector146:
pushl $0
80105eae: 6a 00 push $0x0
pushl $146
80105eb0: 68 92 00 00 00 push $0x92
jmp alltraps
80105eb5: e9 63 f5 ff ff jmp 8010541d <alltraps>
80105eba <vector147>:
.globl vector147
vector147:
pushl $0
80105eba: 6a 00 push $0x0
pushl $147
80105ebc: 68 93 00 00 00 push $0x93
jmp alltraps
80105ec1: e9 57 f5 ff ff jmp 8010541d <alltraps>
80105ec6 <vector148>:
.globl vector148
vector148:
pushl $0
80105ec6: 6a 00 push $0x0
pushl $148
80105ec8: 68 94 00 00 00 push $0x94
jmp alltraps
80105ecd: e9 4b f5 ff ff jmp 8010541d <alltraps>
80105ed2 <vector149>:
.globl vector149
vector149:
pushl $0
80105ed2: 6a 00 push $0x0
pushl $149
80105ed4: 68 95 00 00 00 push $0x95
jmp alltraps
80105ed9: e9 3f f5 ff ff jmp 8010541d <alltraps>
80105ede <vector150>:
.globl vector150
vector150:
pushl $0
80105ede: 6a 00 push $0x0
pushl $150
80105ee0: 68 96 00 00 00 push $0x96
jmp alltraps
80105ee5: e9 33 f5 ff ff jmp 8010541d <alltraps>
80105eea <vector151>:
.globl vector151
vector151:
pushl $0
80105eea: 6a 00 push $0x0
pushl $151
80105eec: 68 97 00 00 00 push $0x97
jmp alltraps
80105ef1: e9 27 f5 ff ff jmp 8010541d <alltraps>
80105ef6 <vector152>:
.globl vector152
vector152:
pushl $0
80105ef6: 6a 00 push $0x0
pushl $152
80105ef8: 68 98 00 00 00 push $0x98
jmp alltraps
80105efd: e9 1b f5 ff ff jmp 8010541d <alltraps>
80105f02 <vector153>:
.globl vector153
vector153:
pushl $0
80105f02: 6a 00 push $0x0
pushl $153
80105f04: 68 99 00 00 00 push $0x99
jmp alltraps
80105f09: e9 0f f5 ff ff jmp 8010541d <alltraps>
80105f0e <vector154>:
.globl vector154
vector154:
pushl $0
80105f0e: 6a 00 push $0x0
pushl $154
80105f10: 68 9a 00 00 00 push $0x9a
jmp alltraps
80105f15: e9 03 f5 ff ff jmp 8010541d <alltraps>
80105f1a <vector155>:
.globl vector155
vector155:
pushl $0
80105f1a: 6a 00 push $0x0
pushl $155
80105f1c: 68 9b 00 00 00 push $0x9b
jmp alltraps
80105f21: e9 f7 f4 ff ff jmp 8010541d <alltraps>
80105f26 <vector156>:
.globl vector156
vector156:
pushl $0
80105f26: 6a 00 push $0x0
pushl $156
80105f28: 68 9c 00 00 00 push $0x9c
jmp alltraps
80105f2d: e9 eb f4 ff ff jmp 8010541d <alltraps>
80105f32 <vector157>:
.globl vector157
vector157:
pushl $0
80105f32: 6a 00 push $0x0
pushl $157
80105f34: 68 9d 00 00 00 push $0x9d
jmp alltraps
80105f39: e9 df f4 ff ff jmp 8010541d <alltraps>
80105f3e <vector158>:
.globl vector158
vector158:
pushl $0
80105f3e: 6a 00 push $0x0
pushl $158
80105f40: 68 9e 00 00 00 push $0x9e
jmp alltraps
80105f45: e9 d3 f4 ff ff jmp 8010541d <alltraps>
80105f4a <vector159>:
.globl vector159
vector159:
pushl $0
80105f4a: 6a 00 push $0x0
pushl $159
80105f4c: 68 9f 00 00 00 push $0x9f
jmp alltraps
80105f51: e9 c7 f4 ff ff jmp 8010541d <alltraps>
80105f56 <vector160>:
.globl vector160
vector160:
pushl $0
80105f56: 6a 00 push $0x0
pushl $160
80105f58: 68 a0 00 00 00 push $0xa0
jmp alltraps
80105f5d: e9 bb f4 ff ff jmp 8010541d <alltraps>
80105f62 <vector161>:
.globl vector161
vector161:
pushl $0
80105f62: 6a 00 push $0x0
pushl $161
80105f64: 68 a1 00 00 00 push $0xa1
jmp alltraps
80105f69: e9 af f4 ff ff jmp 8010541d <alltraps>
80105f6e <vector162>:
.globl vector162
vector162:
pushl $0
80105f6e: 6a 00 push $0x0
pushl $162
80105f70: 68 a2 00 00 00 push $0xa2
jmp alltraps
80105f75: e9 a3 f4 ff ff jmp 8010541d <alltraps>
80105f7a <vector163>:
.globl vector163
vector163:
pushl $0
80105f7a: 6a 00 push $0x0
pushl $163
80105f7c: 68 a3 00 00 00 push $0xa3
jmp alltraps
80105f81: e9 97 f4 ff ff jmp 8010541d <alltraps>
80105f86 <vector164>:
.globl vector164
vector164:
pushl $0
80105f86: 6a 00 push $0x0
pushl $164
80105f88: 68 a4 00 00 00 push $0xa4
jmp alltraps
80105f8d: e9 8b f4 ff ff jmp 8010541d <alltraps>
80105f92 <vector165>:
.globl vector165
vector165:
pushl $0
80105f92: 6a 00 push $0x0
pushl $165
80105f94: 68 a5 00 00 00 push $0xa5
jmp alltraps
80105f99: e9 7f f4 ff ff jmp 8010541d <alltraps>
80105f9e <vector166>:
.globl vector166
vector166:
pushl $0
80105f9e: 6a 00 push $0x0
pushl $166
80105fa0: 68 a6 00 00 00 push $0xa6
jmp alltraps
80105fa5: e9 73 f4 ff ff jmp 8010541d <alltraps>
80105faa <vector167>:
.globl vector167
vector167:
pushl $0
80105faa: 6a 00 push $0x0
pushl $167
80105fac: 68 a7 00 00 00 push $0xa7
jmp alltraps
80105fb1: e9 67 f4 ff ff jmp 8010541d <alltraps>
80105fb6 <vector168>:
.globl vector168
vector168:
pushl $0
80105fb6: 6a 00 push $0x0
pushl $168
80105fb8: 68 a8 00 00 00 push $0xa8
jmp alltraps
80105fbd: e9 5b f4 ff ff jmp 8010541d <alltraps>
80105fc2 <vector169>:
.globl vector169
vector169:
pushl $0
80105fc2: 6a 00 push $0x0
pushl $169
80105fc4: 68 a9 00 00 00 push $0xa9
jmp alltraps
80105fc9: e9 4f f4 ff ff jmp 8010541d <alltraps>
80105fce <vector170>:
.globl vector170
vector170:
pushl $0
80105fce: 6a 00 push $0x0
pushl $170
80105fd0: 68 aa 00 00 00 push $0xaa
jmp alltraps
80105fd5: e9 43 f4 ff ff jmp 8010541d <alltraps>
80105fda <vector171>:
.globl vector171
vector171:
pushl $0
80105fda: 6a 00 push $0x0
pushl $171
80105fdc: 68 ab 00 00 00 push $0xab
jmp alltraps
80105fe1: e9 37 f4 ff ff jmp 8010541d <alltraps>
80105fe6 <vector172>:
.globl vector172
vector172:
pushl $0
80105fe6: 6a 00 push $0x0
pushl $172
80105fe8: 68 ac 00 00 00 push $0xac
jmp alltraps
80105fed: e9 2b f4 ff ff jmp 8010541d <alltraps>
80105ff2 <vector173>:
.globl vector173
vector173:
pushl $0
80105ff2: 6a 00 push $0x0
pushl $173
80105ff4: 68 ad 00 00 00 push $0xad
jmp alltraps
80105ff9: e9 1f f4 ff ff jmp 8010541d <alltraps>
80105ffe <vector174>:
.globl vector174
vector174:
pushl $0
80105ffe: 6a 00 push $0x0
pushl $174
80106000: 68 ae 00 00 00 push $0xae
jmp alltraps
80106005: e9 13 f4 ff ff jmp 8010541d <alltraps>
8010600a <vector175>:
.globl vector175
vector175:
pushl $0
8010600a: 6a 00 push $0x0
pushl $175
8010600c: 68 af 00 00 00 push $0xaf
jmp alltraps
80106011: e9 07 f4 ff ff jmp 8010541d <alltraps>
80106016 <vector176>:
.globl vector176
vector176:
pushl $0
80106016: 6a 00 push $0x0
pushl $176
80106018: 68 b0 00 00 00 push $0xb0
jmp alltraps
8010601d: e9 fb f3 ff ff jmp 8010541d <alltraps>
80106022 <vector177>:
.globl vector177
vector177:
pushl $0
80106022: 6a 00 push $0x0
pushl $177
80106024: 68 b1 00 00 00 push $0xb1
jmp alltraps
80106029: e9 ef f3 ff ff jmp 8010541d <alltraps>
8010602e <vector178>:
.globl vector178
vector178:
pushl $0
8010602e: 6a 00 push $0x0
pushl $178
80106030: 68 b2 00 00 00 push $0xb2
jmp alltraps
80106035: e9 e3 f3 ff ff jmp 8010541d <alltraps>
8010603a <vector179>:
.globl vector179
vector179:
pushl $0
8010603a: 6a 00 push $0x0
pushl $179
8010603c: 68 b3 00 00 00 push $0xb3
jmp alltraps
80106041: e9 d7 f3 ff ff jmp 8010541d <alltraps>
80106046 <vector180>:
.globl vector180
vector180:
pushl $0
80106046: 6a 00 push $0x0
pushl $180
80106048: 68 b4 00 00 00 push $0xb4
jmp alltraps
8010604d: e9 cb f3 ff ff jmp 8010541d <alltraps>
80106052 <vector181>:
.globl vector181
vector181:
pushl $0
80106052: 6a 00 push $0x0
pushl $181
80106054: 68 b5 00 00 00 push $0xb5
jmp alltraps
80106059: e9 bf f3 ff ff jmp 8010541d <alltraps>
8010605e <vector182>:
.globl vector182
vector182:
pushl $0
8010605e: 6a 00 push $0x0
pushl $182
80106060: 68 b6 00 00 00 push $0xb6
jmp alltraps
80106065: e9 b3 f3 ff ff jmp 8010541d <alltraps>
8010606a <vector183>:
.globl vector183
vector183:
pushl $0
8010606a: 6a 00 push $0x0
pushl $183
8010606c: 68 b7 00 00 00 push $0xb7
jmp alltraps
80106071: e9 a7 f3 ff ff jmp 8010541d <alltraps>
80106076 <vector184>:
.globl vector184
vector184:
pushl $0
80106076: 6a 00 push $0x0
pushl $184
80106078: 68 b8 00 00 00 push $0xb8
jmp alltraps
8010607d: e9 9b f3 ff ff jmp 8010541d <alltraps>
80106082 <vector185>:
.globl vector185
vector185:
pushl $0
80106082: 6a 00 push $0x0
pushl $185
80106084: 68 b9 00 00 00 push $0xb9
jmp alltraps
80106089: e9 8f f3 ff ff jmp 8010541d <alltraps>
8010608e <vector186>:
.globl vector186
vector186:
pushl $0
8010608e: 6a 00 push $0x0
pushl $186
80106090: 68 ba 00 00 00 push $0xba
jmp alltraps
80106095: e9 83 f3 ff ff jmp 8010541d <alltraps>
8010609a <vector187>:
.globl vector187
vector187:
pushl $0
8010609a: 6a 00 push $0x0
pushl $187
8010609c: 68 bb 00 00 00 push $0xbb
jmp alltraps
801060a1: e9 77 f3 ff ff jmp 8010541d <alltraps>
801060a6 <vector188>:
.globl vector188
vector188:
pushl $0
801060a6: 6a 00 push $0x0
pushl $188
801060a8: 68 bc 00 00 00 push $0xbc
jmp alltraps
801060ad: e9 6b f3 ff ff jmp 8010541d <alltraps>
801060b2 <vector189>:
.globl vector189
vector189:
pushl $0
801060b2: 6a 00 push $0x0
pushl $189
801060b4: 68 bd 00 00 00 push $0xbd
jmp alltraps
801060b9: e9 5f f3 ff ff jmp 8010541d <alltraps>
801060be <vector190>:
.globl vector190
vector190:
pushl $0
801060be: 6a 00 push $0x0
pushl $190
801060c0: 68 be 00 00 00 push $0xbe
jmp alltraps
801060c5: e9 53 f3 ff ff jmp 8010541d <alltraps>
801060ca <vector191>:
.globl vector191
vector191:
pushl $0
801060ca: 6a 00 push $0x0
pushl $191
801060cc: 68 bf 00 00 00 push $0xbf
jmp alltraps
801060d1: e9 47 f3 ff ff jmp 8010541d <alltraps>
801060d6 <vector192>:
.globl vector192
vector192:
pushl $0
801060d6: 6a 00 push $0x0
pushl $192
801060d8: 68 c0 00 00 00 push $0xc0
jmp alltraps
801060dd: e9 3b f3 ff ff jmp 8010541d <alltraps>
801060e2 <vector193>:
.globl vector193
vector193:
pushl $0
801060e2: 6a 00 push $0x0
pushl $193
801060e4: 68 c1 00 00 00 push $0xc1
jmp alltraps
801060e9: e9 2f f3 ff ff jmp 8010541d <alltraps>
801060ee <vector194>:
.globl vector194
vector194:
pushl $0
801060ee: 6a 00 push $0x0
pushl $194
801060f0: 68 c2 00 00 00 push $0xc2
jmp alltraps
801060f5: e9 23 f3 ff ff jmp 8010541d <alltraps>
801060fa <vector195>:
.globl vector195
vector195:
pushl $0
801060fa: 6a 00 push $0x0
pushl $195
801060fc: 68 c3 00 00 00 push $0xc3
jmp alltraps
80106101: e9 17 f3 ff ff jmp 8010541d <alltraps>
80106106 <vector196>:
.globl vector196
vector196:
pushl $0
80106106: 6a 00 push $0x0
pushl $196
80106108: 68 c4 00 00 00 push $0xc4
jmp alltraps
8010610d: e9 0b f3 ff ff jmp 8010541d <alltraps>
80106112 <vector197>:
.globl vector197
vector197:
pushl $0
80106112: 6a 00 push $0x0
pushl $197
80106114: 68 c5 00 00 00 push $0xc5
jmp alltraps
80106119: e9 ff f2 ff ff jmp 8010541d <alltraps>
8010611e <vector198>:
.globl vector198
vector198:
pushl $0
8010611e: 6a 00 push $0x0
pushl $198
80106120: 68 c6 00 00 00 push $0xc6
jmp alltraps
80106125: e9 f3 f2 ff ff jmp 8010541d <alltraps>
8010612a <vector199>:
.globl vector199
vector199:
pushl $0
8010612a: 6a 00 push $0x0
pushl $199
8010612c: 68 c7 00 00 00 push $0xc7
jmp alltraps
80106131: e9 e7 f2 ff ff jmp 8010541d <alltraps>
80106136 <vector200>:
.globl vector200
vector200:
pushl $0
80106136: 6a 00 push $0x0
pushl $200
80106138: 68 c8 00 00 00 push $0xc8
jmp alltraps
8010613d: e9 db f2 ff ff jmp 8010541d <alltraps>
80106142 <vector201>:
.globl vector201
vector201:
pushl $0
80106142: 6a 00 push $0x0
pushl $201
80106144: 68 c9 00 00 00 push $0xc9
jmp alltraps
80106149: e9 cf f2 ff ff jmp 8010541d <alltraps>
8010614e <vector202>:
.globl vector202
vector202:
pushl $0
8010614e: 6a 00 push $0x0
pushl $202
80106150: 68 ca 00 00 00 push $0xca
jmp alltraps
80106155: e9 c3 f2 ff ff jmp 8010541d <alltraps>
8010615a <vector203>:
.globl vector203
vector203:
pushl $0
8010615a: 6a 00 push $0x0
pushl $203
8010615c: 68 cb 00 00 00 push $0xcb
jmp alltraps
80106161: e9 b7 f2 ff ff jmp 8010541d <alltraps>
80106166 <vector204>:
.globl vector204
vector204:
pushl $0
80106166: 6a 00 push $0x0
pushl $204
80106168: 68 cc 00 00 00 push $0xcc
jmp alltraps
8010616d: e9 ab f2 ff ff jmp 8010541d <alltraps>
80106172 <vector205>:
.globl vector205
vector205:
pushl $0
80106172: 6a 00 push $0x0
pushl $205
80106174: 68 cd 00 00 00 push $0xcd
jmp alltraps
80106179: e9 9f f2 ff ff jmp 8010541d <alltraps>
8010617e <vector206>:
.globl vector206
vector206:
pushl $0
8010617e: 6a 00 push $0x0
pushl $206
80106180: 68 ce 00 00 00 push $0xce
jmp alltraps
80106185: e9 93 f2 ff ff jmp 8010541d <alltraps>
8010618a <vector207>:
.globl vector207
vector207:
pushl $0
8010618a: 6a 00 push $0x0
pushl $207
8010618c: 68 cf 00 00 00 push $0xcf
jmp alltraps
80106191: e9 87 f2 ff ff jmp 8010541d <alltraps>
80106196 <vector208>:
.globl vector208
vector208:
pushl $0
80106196: 6a 00 push $0x0
pushl $208
80106198: 68 d0 00 00 00 push $0xd0
jmp alltraps
8010619d: e9 7b f2 ff ff jmp 8010541d <alltraps>
801061a2 <vector209>:
.globl vector209
vector209:
pushl $0
801061a2: 6a 00 push $0x0
pushl $209
801061a4: 68 d1 00 00 00 push $0xd1
jmp alltraps
801061a9: e9 6f f2 ff ff jmp 8010541d <alltraps>
801061ae <vector210>:
.globl vector210
vector210:
pushl $0
801061ae: 6a 00 push $0x0
pushl $210
801061b0: 68 d2 00 00 00 push $0xd2
jmp alltraps
801061b5: e9 63 f2 ff ff jmp 8010541d <alltraps>
801061ba <vector211>:
.globl vector211
vector211:
pushl $0
801061ba: 6a 00 push $0x0
pushl $211
801061bc: 68 d3 00 00 00 push $0xd3
jmp alltraps
801061c1: e9 57 f2 ff ff jmp 8010541d <alltraps>
801061c6 <vector212>:
.globl vector212
vector212:
pushl $0
801061c6: 6a 00 push $0x0
pushl $212
801061c8: 68 d4 00 00 00 push $0xd4
jmp alltraps
801061cd: e9 4b f2 ff ff jmp 8010541d <alltraps>
801061d2 <vector213>:
.globl vector213
vector213:
pushl $0
801061d2: 6a 00 push $0x0
pushl $213
801061d4: 68 d5 00 00 00 push $0xd5
jmp alltraps
801061d9: e9 3f f2 ff ff jmp 8010541d <alltraps>
801061de <vector214>:
.globl vector214
vector214:
pushl $0
801061de: 6a 00 push $0x0
pushl $214
801061e0: 68 d6 00 00 00 push $0xd6
jmp alltraps
801061e5: e9 33 f2 ff ff jmp 8010541d <alltraps>
801061ea <vector215>:
.globl vector215
vector215:
pushl $0
801061ea: 6a 00 push $0x0
pushl $215
801061ec: 68 d7 00 00 00 push $0xd7
jmp alltraps
801061f1: e9 27 f2 ff ff jmp 8010541d <alltraps>
801061f6 <vector216>:
.globl vector216
vector216:
pushl $0
801061f6: 6a 00 push $0x0
pushl $216
801061f8: 68 d8 00 00 00 push $0xd8
jmp alltraps
801061fd: e9 1b f2 ff ff jmp 8010541d <alltraps>
80106202 <vector217>:
.globl vector217
vector217:
pushl $0
80106202: 6a 00 push $0x0
pushl $217
80106204: 68 d9 00 00 00 push $0xd9
jmp alltraps
80106209: e9 0f f2 ff ff jmp 8010541d <alltraps>
8010620e <vector218>:
.globl vector218
vector218:
pushl $0
8010620e: 6a 00 push $0x0
pushl $218
80106210: 68 da 00 00 00 push $0xda
jmp alltraps
80106215: e9 03 f2 ff ff jmp 8010541d <alltraps>
8010621a <vector219>:
.globl vector219
vector219:
pushl $0
8010621a: 6a 00 push $0x0
pushl $219
8010621c: 68 db 00 00 00 push $0xdb
jmp alltraps
80106221: e9 f7 f1 ff ff jmp 8010541d <alltraps>
80106226 <vector220>:
.globl vector220
vector220:
pushl $0
80106226: 6a 00 push $0x0
pushl $220
80106228: 68 dc 00 00 00 push $0xdc
jmp alltraps
8010622d: e9 eb f1 ff ff jmp 8010541d <alltraps>
80106232 <vector221>:
.globl vector221
vector221:
pushl $0
80106232: 6a 00 push $0x0
pushl $221
80106234: 68 dd 00 00 00 push $0xdd
jmp alltraps
80106239: e9 df f1 ff ff jmp 8010541d <alltraps>
8010623e <vector222>:
.globl vector222
vector222:
pushl $0
8010623e: 6a 00 push $0x0
pushl $222
80106240: 68 de 00 00 00 push $0xde
jmp alltraps
80106245: e9 d3 f1 ff ff jmp 8010541d <alltraps>
8010624a <vector223>:
.globl vector223
vector223:
pushl $0
8010624a: 6a 00 push $0x0
pushl $223
8010624c: 68 df 00 00 00 push $0xdf
jmp alltraps
80106251: e9 c7 f1 ff ff jmp 8010541d <alltraps>
80106256 <vector224>:
.globl vector224
vector224:
pushl $0
80106256: 6a 00 push $0x0
pushl $224
80106258: 68 e0 00 00 00 push $0xe0
jmp alltraps
8010625d: e9 bb f1 ff ff jmp 8010541d <alltraps>
80106262 <vector225>:
.globl vector225
vector225:
pushl $0
80106262: 6a 00 push $0x0
pushl $225
80106264: 68 e1 00 00 00 push $0xe1
jmp alltraps
80106269: e9 af f1 ff ff jmp 8010541d <alltraps>
8010626e <vector226>:
.globl vector226
vector226:
pushl $0
8010626e: 6a 00 push $0x0
pushl $226
80106270: 68 e2 00 00 00 push $0xe2
jmp alltraps
80106275: e9 a3 f1 ff ff jmp 8010541d <alltraps>
8010627a <vector227>:
.globl vector227
vector227:
pushl $0
8010627a: 6a 00 push $0x0
pushl $227
8010627c: 68 e3 00 00 00 push $0xe3
jmp alltraps
80106281: e9 97 f1 ff ff jmp 8010541d <alltraps>
80106286 <vector228>:
.globl vector228
vector228:
pushl $0
80106286: 6a 00 push $0x0
pushl $228
80106288: 68 e4 00 00 00 push $0xe4
jmp alltraps
8010628d: e9 8b f1 ff ff jmp 8010541d <alltraps>
80106292 <vector229>:
.globl vector229
vector229:
pushl $0
80106292: 6a 00 push $0x0
pushl $229
80106294: 68 e5 00 00 00 push $0xe5
jmp alltraps
80106299: e9 7f f1 ff ff jmp 8010541d <alltraps>
8010629e <vector230>:
.globl vector230
vector230:
pushl $0
8010629e: 6a 00 push $0x0
pushl $230
801062a0: 68 e6 00 00 00 push $0xe6
jmp alltraps
801062a5: e9 73 f1 ff ff jmp 8010541d <alltraps>
801062aa <vector231>:
.globl vector231
vector231:
pushl $0
801062aa: 6a 00 push $0x0
pushl $231
801062ac: 68 e7 00 00 00 push $0xe7
jmp alltraps
801062b1: e9 67 f1 ff ff jmp 8010541d <alltraps>
801062b6 <vector232>:
.globl vector232
vector232:
pushl $0
801062b6: 6a 00 push $0x0
pushl $232
801062b8: 68 e8 00 00 00 push $0xe8
jmp alltraps
801062bd: e9 5b f1 ff ff jmp 8010541d <alltraps>
801062c2 <vector233>:
.globl vector233
vector233:
pushl $0
801062c2: 6a 00 push $0x0
pushl $233
801062c4: 68 e9 00 00 00 push $0xe9
jmp alltraps
801062c9: e9 4f f1 ff ff jmp 8010541d <alltraps>
801062ce <vector234>:
.globl vector234
vector234:
pushl $0
801062ce: 6a 00 push $0x0
pushl $234
801062d0: 68 ea 00 00 00 push $0xea
jmp alltraps
801062d5: e9 43 f1 ff ff jmp 8010541d <alltraps>
801062da <vector235>:
.globl vector235
vector235:
pushl $0
801062da: 6a 00 push $0x0
pushl $235
801062dc: 68 eb 00 00 00 push $0xeb
jmp alltraps
801062e1: e9 37 f1 ff ff jmp 8010541d <alltraps>
801062e6 <vector236>:
.globl vector236
vector236:
pushl $0
801062e6: 6a 00 push $0x0
pushl $236
801062e8: 68 ec 00 00 00 push $0xec
jmp alltraps
801062ed: e9 2b f1 ff ff jmp 8010541d <alltraps>
801062f2 <vector237>:
.globl vector237
vector237:
pushl $0
801062f2: 6a 00 push $0x0
pushl $237
801062f4: 68 ed 00 00 00 push $0xed
jmp alltraps
801062f9: e9 1f f1 ff ff jmp 8010541d <alltraps>
801062fe <vector238>:
.globl vector238
vector238:
pushl $0
801062fe: 6a 00 push $0x0
pushl $238
80106300: 68 ee 00 00 00 push $0xee
jmp alltraps
80106305: e9 13 f1 ff ff jmp 8010541d <alltraps>
8010630a <vector239>:
.globl vector239
vector239:
pushl $0
8010630a: 6a 00 push $0x0
pushl $239
8010630c: 68 ef 00 00 00 push $0xef
jmp alltraps
80106311: e9 07 f1 ff ff jmp 8010541d <alltraps>
80106316 <vector240>:
.globl vector240
vector240:
pushl $0
80106316: 6a 00 push $0x0
pushl $240
80106318: 68 f0 00 00 00 push $0xf0
jmp alltraps
8010631d: e9 fb f0 ff ff jmp 8010541d <alltraps>
80106322 <vector241>:
.globl vector241
vector241:
pushl $0
80106322: 6a 00 push $0x0
pushl $241
80106324: 68 f1 00 00 00 push $0xf1
jmp alltraps
80106329: e9 ef f0 ff ff jmp 8010541d <alltraps>
8010632e <vector242>:
.globl vector242
vector242:
pushl $0
8010632e: 6a 00 push $0x0
pushl $242
80106330: 68 f2 00 00 00 push $0xf2
jmp alltraps
80106335: e9 e3 f0 ff ff jmp 8010541d <alltraps>
8010633a <vector243>:
.globl vector243
vector243:
pushl $0
8010633a: 6a 00 push $0x0
pushl $243
8010633c: 68 f3 00 00 00 push $0xf3
jmp alltraps
80106341: e9 d7 f0 ff ff jmp 8010541d <alltraps>
80106346 <vector244>:
.globl vector244
vector244:
pushl $0
80106346: 6a 00 push $0x0
pushl $244
80106348: 68 f4 00 00 00 push $0xf4
jmp alltraps
8010634d: e9 cb f0 ff ff jmp 8010541d <alltraps>
80106352 <vector245>:
.globl vector245
vector245:
pushl $0
80106352: 6a 00 push $0x0
pushl $245
80106354: 68 f5 00 00 00 push $0xf5
jmp alltraps
80106359: e9 bf f0 ff ff jmp 8010541d <alltraps>
8010635e <vector246>:
.globl vector246
vector246:
pushl $0
8010635e: 6a 00 push $0x0
pushl $246
80106360: 68 f6 00 00 00 push $0xf6
jmp alltraps
80106365: e9 b3 f0 ff ff jmp 8010541d <alltraps>
8010636a <vector247>:
.globl vector247
vector247:
pushl $0
8010636a: 6a 00 push $0x0
pushl $247
8010636c: 68 f7 00 00 00 push $0xf7
jmp alltraps
80106371: e9 a7 f0 ff ff jmp 8010541d <alltraps>
80106376 <vector248>:
.globl vector248
vector248:
pushl $0
80106376: 6a 00 push $0x0
pushl $248
80106378: 68 f8 00 00 00 push $0xf8
jmp alltraps
8010637d: e9 9b f0 ff ff jmp 8010541d <alltraps>
80106382 <vector249>:
.globl vector249
vector249:
pushl $0
80106382: 6a 00 push $0x0
pushl $249
80106384: 68 f9 00 00 00 push $0xf9
jmp alltraps
80106389: e9 8f f0 ff ff jmp 8010541d <alltraps>
8010638e <vector250>:
.globl vector250
vector250:
pushl $0
8010638e: 6a 00 push $0x0
pushl $250
80106390: 68 fa 00 00 00 push $0xfa
jmp alltraps
80106395: e9 83 f0 ff ff jmp 8010541d <alltraps>
8010639a <vector251>:
.globl vector251
vector251:
pushl $0
8010639a: 6a 00 push $0x0
pushl $251
8010639c: 68 fb 00 00 00 push $0xfb
jmp alltraps
801063a1: e9 77 f0 ff ff jmp 8010541d <alltraps>
801063a6 <vector252>:
.globl vector252
vector252:
pushl $0
801063a6: 6a 00 push $0x0
pushl $252
801063a8: 68 fc 00 00 00 push $0xfc
jmp alltraps
801063ad: e9 6b f0 ff ff jmp 8010541d <alltraps>
801063b2 <vector253>:
.globl vector253
vector253:
pushl $0
801063b2: 6a 00 push $0x0
pushl $253
801063b4: 68 fd 00 00 00 push $0xfd
jmp alltraps
801063b9: e9 5f f0 ff ff jmp 8010541d <alltraps>
801063be <vector254>:
.globl vector254
vector254:
pushl $0
801063be: 6a 00 push $0x0
pushl $254
801063c0: 68 fe 00 00 00 push $0xfe
jmp alltraps
801063c5: e9 53 f0 ff ff jmp 8010541d <alltraps>
801063ca <vector255>:
.globl vector255
vector255:
pushl $0
801063ca: 6a 00 push $0x0
pushl $255
801063cc: 68 ff 00 00 00 push $0xff
jmp alltraps
801063d1: e9 47 f0 ff ff jmp 8010541d <alltraps>
801063d6: 66 90 xchg %ax,%ax
801063d8: 66 90 xchg %ax,%ax
801063da: 66 90 xchg %ax,%ax
801063dc: 66 90 xchg %ax,%ax
801063de: 66 90 xchg %ax,%ax
801063e0 <walkpgdir>:
// Return the address of the PTE in page table pgdir
// that corresponds to virtual address va. If alloc!=0,
// create any required page table pages.
static pte_t *
walkpgdir(pde_t *pgdir, const void *va, int alloc)
{
801063e0: 55 push %ebp
801063e1: 89 e5 mov %esp,%ebp
801063e3: 57 push %edi
801063e4: 56 push %esi
801063e5: 89 d6 mov %edx,%esi
pde_t *pde;
pte_t *pgtab;
pde = &pgdir[PDX(va)];
801063e7: c1 ea 16 shr $0x16,%edx
{
801063ea: 53 push %ebx
pde = &pgdir[PDX(va)];
801063eb: 8d 3c 90 lea (%eax,%edx,4),%edi
{
801063ee: 83 ec 1c sub $0x1c,%esp
if(*pde & PTE_P){
801063f1: 8b 1f mov (%edi),%ebx
801063f3: f6 c3 01 test $0x1,%bl
801063f6: 74 28 je 80106420 <walkpgdir+0x40>
pgtab = (pte_t*)P2V(PTE_ADDR(*pde));
801063f8: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
801063fe: 81 c3 00 00 00 80 add $0x80000000,%ebx
// The permissions here are overly generous, but they can
// be further restricted by the permissions in the page table
// entries, if necessary.
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
}
return &pgtab[PTX(va)];
80106404: c1 ee 0a shr $0xa,%esi
}
80106407: 83 c4 1c add $0x1c,%esp
return &pgtab[PTX(va)];
8010640a: 89 f2 mov %esi,%edx
8010640c: 81 e2 fc 0f 00 00 and $0xffc,%edx
80106412: 8d 04 13 lea (%ebx,%edx,1),%eax
}
80106415: 5b pop %ebx
80106416: 5e pop %esi
80106417: 5f pop %edi
80106418: 5d pop %ebp
80106419: c3 ret
8010641a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
if(!alloc || (pgtab = (pte_t*)kalloc()) == 0)
80106420: 85 c9 test %ecx,%ecx
80106422: 74 34 je 80106458 <walkpgdir+0x78>
80106424: e8 77 c0 ff ff call 801024a0 <kalloc>
80106429: 85 c0 test %eax,%eax
8010642b: 89 c3 mov %eax,%ebx
8010642d: 74 29 je 80106458 <walkpgdir+0x78>
memset(pgtab, 0, PGSIZE);
8010642f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106436: 00
80106437: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
8010643e: 00
8010643f: 89 04 24 mov %eax,(%esp)
80106442: e8 39 de ff ff call 80104280 <memset>
*pde = V2P(pgtab) | PTE_P | PTE_W | PTE_U;
80106447: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
8010644d: 83 c8 07 or $0x7,%eax
80106450: 89 07 mov %eax,(%edi)
80106452: eb b0 jmp 80106404 <walkpgdir+0x24>
80106454: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
}
80106458: 83 c4 1c add $0x1c,%esp
return 0;
8010645b: 31 c0 xor %eax,%eax
}
8010645d: 5b pop %ebx
8010645e: 5e pop %esi
8010645f: 5f pop %edi
80106460: 5d pop %ebp
80106461: c3 ret
80106462: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106469: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106470 <deallocuvm.part.0>:
// Deallocate user pages to bring the process size from oldsz to
// newsz. oldsz and newsz need not be page-aligned, nor does newsz
// need to be less than oldsz. oldsz can be larger than the actual
// process size. Returns the new process size.
int
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106470: 55 push %ebp
80106471: 89 e5 mov %esp,%ebp
80106473: 57 push %edi
80106474: 89 c7 mov %eax,%edi
80106476: 56 push %esi
80106477: 89 d6 mov %edx,%esi
80106479: 53 push %ebx
uint a, pa;
if(newsz >= oldsz)
return oldsz;
a = PGROUNDUP(newsz);
8010647a: 8d 99 ff 0f 00 00 lea 0xfff(%ecx),%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
80106480: 83 ec 1c sub $0x1c,%esp
a = PGROUNDUP(newsz);
80106483: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < oldsz; a += PGSIZE){
80106489: 39 d3 cmp %edx,%ebx
deallocuvm(pde_t *pgdir, uint oldsz, uint newsz)
8010648b: 89 4d e0 mov %ecx,-0x20(%ebp)
for(; a < oldsz; a += PGSIZE){
8010648e: 72 3b jb 801064cb <deallocuvm.part.0+0x5b>
80106490: eb 5e jmp 801064f0 <deallocuvm.part.0+0x80>
80106492: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
pte = walkpgdir(pgdir, (char*)a, 0);
if(!pte)
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
else if((*pte & PTE_P) != 0){
80106498: 8b 10 mov (%eax),%edx
8010649a: f6 c2 01 test $0x1,%dl
8010649d: 74 22 je 801064c1 <deallocuvm.part.0+0x51>
pa = PTE_ADDR(*pte);
if(pa == 0)
8010649f: 81 e2 00 f0 ff ff and $0xfffff000,%edx
801064a5: 74 54 je 801064fb <deallocuvm.part.0+0x8b>
panic("kfree");
char *v = P2V(pa);
801064a7: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
801064ad: 89 14 24 mov %edx,(%esp)
801064b0: 89 45 e4 mov %eax,-0x1c(%ebp)
801064b3: e8 38 be ff ff call 801022f0 <kfree>
*pte = 0;
801064b8: 8b 45 e4 mov -0x1c(%ebp),%eax
801064bb: c7 00 00 00 00 00 movl $0x0,(%eax)
for(; a < oldsz; a += PGSIZE){
801064c1: 81 c3 00 10 00 00 add $0x1000,%ebx
801064c7: 39 f3 cmp %esi,%ebx
801064c9: 73 25 jae 801064f0 <deallocuvm.part.0+0x80>
pte = walkpgdir(pgdir, (char*)a, 0);
801064cb: 31 c9 xor %ecx,%ecx
801064cd: 89 da mov %ebx,%edx
801064cf: 89 f8 mov %edi,%eax
801064d1: e8 0a ff ff ff call 801063e0 <walkpgdir>
if(!pte)
801064d6: 85 c0 test %eax,%eax
801064d8: 75 be jne 80106498 <deallocuvm.part.0+0x28>
a = PGADDR(PDX(a) + 1, 0, 0) - PGSIZE;
801064da: 81 e3 00 00 c0 ff and $0xffc00000,%ebx
801064e0: 81 c3 00 f0 3f 00 add $0x3ff000,%ebx
for(; a < oldsz; a += PGSIZE){
801064e6: 81 c3 00 10 00 00 add $0x1000,%ebx
801064ec: 39 f3 cmp %esi,%ebx
801064ee: 72 db jb 801064cb <deallocuvm.part.0+0x5b>
}
}
return newsz;
}
801064f0: 8b 45 e0 mov -0x20(%ebp),%eax
801064f3: 83 c4 1c add $0x1c,%esp
801064f6: 5b pop %ebx
801064f7: 5e pop %esi
801064f8: 5f pop %edi
801064f9: 5d pop %ebp
801064fa: c3 ret
panic("kfree");
801064fb: c7 04 24 f2 70 10 80 movl $0x801070f2,(%esp)
80106502: e8 59 9e ff ff call 80100360 <panic>
80106507: 89 f6 mov %esi,%esi
80106509: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106510 <seginit>:
{
80106510: 55 push %ebp
80106511: 89 e5 mov %esp,%ebp
80106513: 83 ec 18 sub $0x18,%esp
c = &cpus[cpuid()];
80106516: e8 65 d1 ff ff call 80103680 <cpuid>
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
8010651b: 31 c9 xor %ecx,%ecx
8010651d: ba ff ff ff ff mov $0xffffffff,%edx
c = &cpus[cpuid()];
80106522: 69 c0 b0 00 00 00 imul $0xb0,%eax,%eax
80106528: 05 80 27 11 80 add $0x80112780,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
8010652d: 66 89 50 78 mov %dx,0x78(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106531: ba ff ff ff ff mov $0xffffffff,%edx
lgdt(c->gdt, sizeof(c->gdt));
80106536: 83 c0 70 add $0x70,%eax
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
80106539: 66 89 48 0a mov %cx,0xa(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
8010653d: 31 c9 xor %ecx,%ecx
8010653f: 66 89 50 10 mov %dx,0x10(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106543: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106548: 66 89 48 12 mov %cx,0x12(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
8010654c: 31 c9 xor %ecx,%ecx
8010654e: 66 89 50 18 mov %dx,0x18(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
80106552: ba ff ff ff ff mov $0xffffffff,%edx
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106557: 66 89 48 1a mov %cx,0x1a(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
8010655b: 31 c9 xor %ecx,%ecx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
8010655d: c6 40 0d 9a movb $0x9a,0xd(%eax)
80106561: c6 40 0e cf movb $0xcf,0xe(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
80106565: c6 40 15 92 movb $0x92,0x15(%eax)
80106569: c6 40 16 cf movb $0xcf,0x16(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
8010656d: c6 40 1d fa movb $0xfa,0x1d(%eax)
80106571: c6 40 1e cf movb $0xcf,0x1e(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
80106575: c6 40 25 f2 movb $0xf2,0x25(%eax)
80106579: c6 40 26 cf movb $0xcf,0x26(%eax)
8010657d: 66 89 50 20 mov %dx,0x20(%eax)
pd[0] = size-1;
80106581: ba 2f 00 00 00 mov $0x2f,%edx
c->gdt[SEG_KCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, 0);
80106586: c6 40 0c 00 movb $0x0,0xc(%eax)
8010658a: c6 40 0f 00 movb $0x0,0xf(%eax)
c->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0);
8010658e: c6 40 14 00 movb $0x0,0x14(%eax)
80106592: c6 40 17 00 movb $0x0,0x17(%eax)
c->gdt[SEG_UCODE] = SEG(STA_X|STA_R, 0, 0xffffffff, DPL_USER);
80106596: c6 40 1c 00 movb $0x0,0x1c(%eax)
8010659a: c6 40 1f 00 movb $0x0,0x1f(%eax)
c->gdt[SEG_UDATA] = SEG(STA_W, 0, 0xffffffff, DPL_USER);
8010659e: 66 89 48 22 mov %cx,0x22(%eax)
801065a2: c6 40 24 00 movb $0x0,0x24(%eax)
801065a6: c6 40 27 00 movb $0x0,0x27(%eax)
801065aa: 66 89 55 f2 mov %dx,-0xe(%ebp)
pd[1] = (uint)p;
801065ae: 66 89 45 f4 mov %ax,-0xc(%ebp)
pd[2] = (uint)p >> 16;
801065b2: c1 e8 10 shr $0x10,%eax
801065b5: 66 89 45 f6 mov %ax,-0xa(%ebp)
asm volatile("lgdt (%0)" : : "r" (pd));
801065b9: 8d 45 f2 lea -0xe(%ebp),%eax
801065bc: 0f 01 10 lgdtl (%eax)
}
801065bf: c9 leave
801065c0: c3 ret
801065c1: eb 0d jmp 801065d0 <mappages>
801065c3: 90 nop
801065c4: 90 nop
801065c5: 90 nop
801065c6: 90 nop
801065c7: 90 nop
801065c8: 90 nop
801065c9: 90 nop
801065ca: 90 nop
801065cb: 90 nop
801065cc: 90 nop
801065cd: 90 nop
801065ce: 90 nop
801065cf: 90 nop
801065d0 <mappages>:
{
801065d0: 55 push %ebp
801065d1: 89 e5 mov %esp,%ebp
801065d3: 57 push %edi
801065d4: 56 push %esi
801065d5: 53 push %ebx
801065d6: 83 ec 1c sub $0x1c,%esp
801065d9: 8b 45 0c mov 0xc(%ebp),%eax
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
801065dc: 8b 55 10 mov 0x10(%ebp),%edx
{
801065df: 8b 7d 14 mov 0x14(%ebp),%edi
*pte = pa | perm | PTE_P;
801065e2: 83 4d 18 01 orl $0x1,0x18(%ebp)
a = (char*)PGROUNDDOWN((uint)va);
801065e6: 89 c3 mov %eax,%ebx
801065e8: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
last = (char*)PGROUNDDOWN(((uint)va) + size - 1);
801065ee: 8d 44 10 ff lea -0x1(%eax,%edx,1),%eax
801065f2: 29 df sub %ebx,%edi
801065f4: 89 45 e4 mov %eax,-0x1c(%ebp)
801065f7: 81 65 e4 00 f0 ff ff andl $0xfffff000,-0x1c(%ebp)
801065fe: eb 15 jmp 80106615 <mappages+0x45>
if(*pte & PTE_P)
80106600: f6 00 01 testb $0x1,(%eax)
80106603: 75 3d jne 80106642 <mappages+0x72>
*pte = pa | perm | PTE_P;
80106605: 0b 75 18 or 0x18(%ebp),%esi
if(a == last)
80106608: 3b 5d e4 cmp -0x1c(%ebp),%ebx
*pte = pa | perm | PTE_P;
8010660b: 89 30 mov %esi,(%eax)
if(a == last)
8010660d: 74 29 je 80106638 <mappages+0x68>
a += PGSIZE;
8010660f: 81 c3 00 10 00 00 add $0x1000,%ebx
if((pte = walkpgdir(pgdir, a, 1)) == 0)
80106615: 8b 45 08 mov 0x8(%ebp),%eax
80106618: b9 01 00 00 00 mov $0x1,%ecx
8010661d: 89 da mov %ebx,%edx
8010661f: 8d 34 3b lea (%ebx,%edi,1),%esi
80106622: e8 b9 fd ff ff call 801063e0 <walkpgdir>
80106627: 85 c0 test %eax,%eax
80106629: 75 d5 jne 80106600 <mappages+0x30>
}
8010662b: 83 c4 1c add $0x1c,%esp
return -1;
8010662e: b8 ff ff ff ff mov $0xffffffff,%eax
}
80106633: 5b pop %ebx
80106634: 5e pop %esi
80106635: 5f pop %edi
80106636: 5d pop %ebp
80106637: c3 ret
80106638: 83 c4 1c add $0x1c,%esp
return 0;
8010663b: 31 c0 xor %eax,%eax
}
8010663d: 5b pop %ebx
8010663e: 5e pop %esi
8010663f: 5f pop %edi
80106640: 5d pop %ebp
80106641: c3 ret
panic("remap");
80106642: c7 04 24 3c 78 10 80 movl $0x8010783c,(%esp)
80106649: e8 12 9d ff ff call 80100360 <panic>
8010664e: 66 90 xchg %ax,%ax
80106650 <switchkvm>:
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106650: a1 a4 55 11 80 mov 0x801155a4,%eax
{
80106655: 55 push %ebp
80106656: 89 e5 mov %esp,%ebp
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106658: 05 00 00 00 80 add $0x80000000,%eax
}
static inline void
lcr3(uint val)
{
asm volatile("movl %0,%%cr3" : : "r" (val));
8010665d: 0f 22 d8 mov %eax,%cr3
}
80106660: 5d pop %ebp
80106661: c3 ret
80106662: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106669: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106670 <switchuvm>:
{
80106670: 55 push %ebp
80106671: 89 e5 mov %esp,%ebp
80106673: 57 push %edi
80106674: 56 push %esi
80106675: 53 push %ebx
80106676: 83 ec 1c sub $0x1c,%esp
80106679: 8b 75 08 mov 0x8(%ebp),%esi
if(p == 0)
8010667c: 85 f6 test %esi,%esi
8010667e: 0f 84 cd 00 00 00 je 80106751 <switchuvm+0xe1>
if(p->kstack == 0)
80106684: 8b 46 0c mov 0xc(%esi),%eax
80106687: 85 c0 test %eax,%eax
80106689: 0f 84 da 00 00 00 je 80106769 <switchuvm+0xf9>
if(p->pgdir == 0)
8010668f: 8b 7e 04 mov 0x4(%esi),%edi
80106692: 85 ff test %edi,%edi
80106694: 0f 84 c3 00 00 00 je 8010675d <switchuvm+0xed>
pushcli();
8010669a: e8 61 da ff ff call 80104100 <pushcli>
mycpu()->gdt[SEG_TSS] = SEG16(STS_T32A, &mycpu()->ts,
8010669f: e8 5c cf ff ff call 80103600 <mycpu>
801066a4: 89 c3 mov %eax,%ebx
801066a6: e8 55 cf ff ff call 80103600 <mycpu>
801066ab: 89 c7 mov %eax,%edi
801066ad: e8 4e cf ff ff call 80103600 <mycpu>
801066b2: 83 c7 08 add $0x8,%edi
801066b5: 89 45 e4 mov %eax,-0x1c(%ebp)
801066b8: e8 43 cf ff ff call 80103600 <mycpu>
801066bd: 8b 4d e4 mov -0x1c(%ebp),%ecx
801066c0: ba 67 00 00 00 mov $0x67,%edx
801066c5: 66 89 93 98 00 00 00 mov %dx,0x98(%ebx)
801066cc: 66 89 bb 9a 00 00 00 mov %di,0x9a(%ebx)
801066d3: c6 83 9d 00 00 00 99 movb $0x99,0x9d(%ebx)
801066da: 83 c1 08 add $0x8,%ecx
801066dd: c1 e9 10 shr $0x10,%ecx
801066e0: 83 c0 08 add $0x8,%eax
801066e3: c1 e8 18 shr $0x18,%eax
801066e6: 88 8b 9c 00 00 00 mov %cl,0x9c(%ebx)
801066ec: c6 83 9e 00 00 00 40 movb $0x40,0x9e(%ebx)
801066f3: 88 83 9f 00 00 00 mov %al,0x9f(%ebx)
mycpu()->ts.iomb = (ushort) 0xFFFF;
801066f9: bb ff ff ff ff mov $0xffffffff,%ebx
mycpu()->gdt[SEG_TSS].s = 0;
801066fe: e8 fd ce ff ff call 80103600 <mycpu>
80106703: 80 a0 9d 00 00 00 ef andb $0xef,0x9d(%eax)
mycpu()->ts.ss0 = SEG_KDATA << 3;
8010670a: e8 f1 ce ff ff call 80103600 <mycpu>
8010670f: b9 10 00 00 00 mov $0x10,%ecx
80106714: 66 89 48 10 mov %cx,0x10(%eax)
mycpu()->ts.esp0 = (uint)p->kstack + KSTACKSIZE;
80106718: e8 e3 ce ff ff call 80103600 <mycpu>
8010671d: 8b 56 0c mov 0xc(%esi),%edx
80106720: 8d 8a 00 10 00 00 lea 0x1000(%edx),%ecx
80106726: 89 48 0c mov %ecx,0xc(%eax)
mycpu()->ts.iomb = (ushort) 0xFFFF;
80106729: e8 d2 ce ff ff call 80103600 <mycpu>
8010672e: 66 89 58 6e mov %bx,0x6e(%eax)
asm volatile("ltr %0" : : "r" (sel));
80106732: b8 28 00 00 00 mov $0x28,%eax
80106737: 0f 00 d8 ltr %ax
lcr3(V2P(p->pgdir)); // switch to process's address space
8010673a: 8b 46 04 mov 0x4(%esi),%eax
8010673d: 05 00 00 00 80 add $0x80000000,%eax
asm volatile("movl %0,%%cr3" : : "r" (val));
80106742: 0f 22 d8 mov %eax,%cr3
}
80106745: 83 c4 1c add $0x1c,%esp
80106748: 5b pop %ebx
80106749: 5e pop %esi
8010674a: 5f pop %edi
8010674b: 5d pop %ebp
popcli();
8010674c: e9 6f da ff ff jmp 801041c0 <popcli>
panic("switchuvm: no process");
80106751: c7 04 24 42 78 10 80 movl $0x80107842,(%esp)
80106758: e8 03 9c ff ff call 80100360 <panic>
panic("switchuvm: no pgdir");
8010675d: c7 04 24 6d 78 10 80 movl $0x8010786d,(%esp)
80106764: e8 f7 9b ff ff call 80100360 <panic>
panic("switchuvm: no kstack");
80106769: c7 04 24 58 78 10 80 movl $0x80107858,(%esp)
80106770: e8 eb 9b ff ff call 80100360 <panic>
80106775: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106779: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106780 <inituvm>:
{
80106780: 55 push %ebp
80106781: 89 e5 mov %esp,%ebp
80106783: 57 push %edi
80106784: 56 push %esi
80106785: 53 push %ebx
80106786: 83 ec 2c sub $0x2c,%esp
80106789: 8b 75 10 mov 0x10(%ebp),%esi
8010678c: 8b 55 08 mov 0x8(%ebp),%edx
8010678f: 8b 7d 0c mov 0xc(%ebp),%edi
if(sz >= PGSIZE)
80106792: 81 fe ff 0f 00 00 cmp $0xfff,%esi
80106798: 77 64 ja 801067fe <inituvm+0x7e>
8010679a: 89 55 e4 mov %edx,-0x1c(%ebp)
mem = kalloc();
8010679d: e8 fe bc ff ff call 801024a0 <kalloc>
memset(mem, 0, PGSIZE);
801067a2: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801067a9: 00
801067aa: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801067b1: 00
801067b2: 89 04 24 mov %eax,(%esp)
mem = kalloc();
801067b5: 89 c3 mov %eax,%ebx
memset(mem, 0, PGSIZE);
801067b7: e8 c4 da ff ff call 80104280 <memset>
mappages(pgdir, 0, PGSIZE, V2P(mem), PTE_W|PTE_U);
801067bc: 8b 55 e4 mov -0x1c(%ebp),%edx
801067bf: 8d 83 00 00 00 80 lea -0x80000000(%ebx),%eax
801067c5: c7 44 24 10 06 00 00 movl $0x6,0x10(%esp)
801067cc: 00
801067cd: 89 44 24 0c mov %eax,0xc(%esp)
801067d1: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
801067d8: 00
801067d9: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
801067e0: 00
801067e1: 89 14 24 mov %edx,(%esp)
801067e4: e8 e7 fd ff ff call 801065d0 <mappages>
memmove(mem, init, sz);
801067e9: 89 75 10 mov %esi,0x10(%ebp)
801067ec: 89 7d 0c mov %edi,0xc(%ebp)
801067ef: 89 5d 08 mov %ebx,0x8(%ebp)
}
801067f2: 83 c4 2c add $0x2c,%esp
801067f5: 5b pop %ebx
801067f6: 5e pop %esi
801067f7: 5f pop %edi
801067f8: 5d pop %ebp
memmove(mem, init, sz);
801067f9: e9 22 db ff ff jmp 80104320 <memmove>
panic("inituvm: more than a page");
801067fe: c7 04 24 81 78 10 80 movl $0x80107881,(%esp)
80106805: e8 56 9b ff ff call 80100360 <panic>
8010680a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106810 <loaduvm>:
{
80106810: 55 push %ebp
80106811: 89 e5 mov %esp,%ebp
80106813: 57 push %edi
80106814: 56 push %esi
80106815: 53 push %ebx
80106816: 83 ec 1c sub $0x1c,%esp
if((uint) addr % PGSIZE != 0)
80106819: f7 45 0c ff 0f 00 00 testl $0xfff,0xc(%ebp)
80106820: 0f 85 98 00 00 00 jne 801068be <loaduvm+0xae>
for(i = 0; i < sz; i += PGSIZE){
80106826: 8b 75 18 mov 0x18(%ebp),%esi
80106829: 31 db xor %ebx,%ebx
8010682b: 85 f6 test %esi,%esi
8010682d: 75 1a jne 80106849 <loaduvm+0x39>
8010682f: eb 77 jmp 801068a8 <loaduvm+0x98>
80106831: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106838: 81 c3 00 10 00 00 add $0x1000,%ebx
8010683e: 81 ee 00 10 00 00 sub $0x1000,%esi
80106844: 39 5d 18 cmp %ebx,0x18(%ebp)
80106847: 76 5f jbe 801068a8 <loaduvm+0x98>
80106849: 8b 55 0c mov 0xc(%ebp),%edx
if((pte = walkpgdir(pgdir, addr+i, 0)) == 0)
8010684c: 31 c9 xor %ecx,%ecx
8010684e: 8b 45 08 mov 0x8(%ebp),%eax
80106851: 01 da add %ebx,%edx
80106853: e8 88 fb ff ff call 801063e0 <walkpgdir>
80106858: 85 c0 test %eax,%eax
8010685a: 74 56 je 801068b2 <loaduvm+0xa2>
pa = PTE_ADDR(*pte);
8010685c: 8b 00 mov (%eax),%eax
n = PGSIZE;
8010685e: bf 00 10 00 00 mov $0x1000,%edi
80106863: 8b 4d 14 mov 0x14(%ebp),%ecx
pa = PTE_ADDR(*pte);
80106866: 25 00 f0 ff ff and $0xfffff000,%eax
n = PGSIZE;
8010686b: 81 fe 00 10 00 00 cmp $0x1000,%esi
80106871: 0f 42 fe cmovb %esi,%edi
if(readi(ip, P2V(pa), offset+i, n) != n)
80106874: 05 00 00 00 80 add $0x80000000,%eax
80106879: 89 44 24 04 mov %eax,0x4(%esp)
8010687d: 8b 45 10 mov 0x10(%ebp),%eax
80106880: 01 d9 add %ebx,%ecx
80106882: 89 7c 24 0c mov %edi,0xc(%esp)
80106886: 89 4c 24 08 mov %ecx,0x8(%esp)
8010688a: 89 04 24 mov %eax,(%esp)
8010688d: e8 ce b0 ff ff call 80101960 <readi>
80106892: 39 f8 cmp %edi,%eax
80106894: 74 a2 je 80106838 <loaduvm+0x28>
}
80106896: 83 c4 1c add $0x1c,%esp
return -1;
80106899: b8 ff ff ff ff mov $0xffffffff,%eax
}
8010689e: 5b pop %ebx
8010689f: 5e pop %esi
801068a0: 5f pop %edi
801068a1: 5d pop %ebp
801068a2: c3 ret
801068a3: 90 nop
801068a4: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801068a8: 83 c4 1c add $0x1c,%esp
return 0;
801068ab: 31 c0 xor %eax,%eax
}
801068ad: 5b pop %ebx
801068ae: 5e pop %esi
801068af: 5f pop %edi
801068b0: 5d pop %ebp
801068b1: c3 ret
panic("loaduvm: address should exist");
801068b2: c7 04 24 9b 78 10 80 movl $0x8010789b,(%esp)
801068b9: e8 a2 9a ff ff call 80100360 <panic>
panic("loaduvm: addr must be page aligned");
801068be: c7 04 24 3c 79 10 80 movl $0x8010793c,(%esp)
801068c5: e8 96 9a ff ff call 80100360 <panic>
801068ca: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
801068d0 <allocuvm>:
{
801068d0: 55 push %ebp
801068d1: 89 e5 mov %esp,%ebp
801068d3: 57 push %edi
801068d4: 56 push %esi
801068d5: 53 push %ebx
801068d6: 83 ec 2c sub $0x2c,%esp
801068d9: 8b 7d 10 mov 0x10(%ebp),%edi
if(newsz >= KERNBASE)
801068dc: 85 ff test %edi,%edi
801068de: 0f 88 8f 00 00 00 js 80106973 <allocuvm+0xa3>
if(newsz < oldsz)
801068e4: 3b 7d 0c cmp 0xc(%ebp),%edi
return oldsz;
801068e7: 8b 45 0c mov 0xc(%ebp),%eax
if(newsz < oldsz)
801068ea: 0f 82 85 00 00 00 jb 80106975 <allocuvm+0xa5>
a = PGROUNDUP(oldsz);
801068f0: 8d 98 ff 0f 00 00 lea 0xfff(%eax),%ebx
801068f6: 81 e3 00 f0 ff ff and $0xfffff000,%ebx
for(; a < newsz; a += PGSIZE){
801068fc: 39 df cmp %ebx,%edi
801068fe: 77 57 ja 80106957 <allocuvm+0x87>
80106900: eb 7e jmp 80106980 <allocuvm+0xb0>
80106902: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memset(mem, 0, PGSIZE);
80106908: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
8010690f: 00
80106910: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80106917: 00
80106918: 89 04 24 mov %eax,(%esp)
8010691b: e8 60 d9 ff ff call 80104280 <memset>
if(mappages(pgdir, (char*)a, PGSIZE, V2P(mem), PTE_W|PTE_U) < 0){
80106920: 8d 86 00 00 00 80 lea -0x80000000(%esi),%eax
80106926: 89 44 24 0c mov %eax,0xc(%esp)
8010692a: 8b 45 08 mov 0x8(%ebp),%eax
8010692d: c7 44 24 10 06 00 00 movl $0x6,0x10(%esp)
80106934: 00
80106935: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
8010693c: 00
8010693d: 89 5c 24 04 mov %ebx,0x4(%esp)
80106941: 89 04 24 mov %eax,(%esp)
80106944: e8 87 fc ff ff call 801065d0 <mappages>
80106949: 85 c0 test %eax,%eax
8010694b: 78 43 js 80106990 <allocuvm+0xc0>
for(; a < newsz; a += PGSIZE){
8010694d: 81 c3 00 10 00 00 add $0x1000,%ebx
80106953: 39 df cmp %ebx,%edi
80106955: 76 29 jbe 80106980 <allocuvm+0xb0>
mem = kalloc();
80106957: e8 44 bb ff ff call 801024a0 <kalloc>
if(mem == 0){
8010695c: 85 c0 test %eax,%eax
mem = kalloc();
8010695e: 89 c6 mov %eax,%esi
if(mem == 0){
80106960: 75 a6 jne 80106908 <allocuvm+0x38>
cprintf("allocuvm out of memory\n");
80106962: c7 04 24 b9 78 10 80 movl $0x801078b9,(%esp)
80106969: e8 e2 9c ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010696e: 3b 7d 0c cmp 0xc(%ebp),%edi
80106971: 77 47 ja 801069ba <allocuvm+0xea>
return 0;
80106973: 31 c0 xor %eax,%eax
}
80106975: 83 c4 2c add $0x2c,%esp
80106978: 5b pop %ebx
80106979: 5e pop %esi
8010697a: 5f pop %edi
8010697b: 5d pop %ebp
8010697c: c3 ret
8010697d: 8d 76 00 lea 0x0(%esi),%esi
80106980: 83 c4 2c add $0x2c,%esp
80106983: 89 f8 mov %edi,%eax
80106985: 5b pop %ebx
80106986: 5e pop %esi
80106987: 5f pop %edi
80106988: 5d pop %ebp
80106989: c3 ret
8010698a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
cprintf("allocuvm out of memory (2)\n");
80106990: c7 04 24 d1 78 10 80 movl $0x801078d1,(%esp)
80106997: e8 b4 9c ff ff call 80100650 <cprintf>
if(newsz >= oldsz)
8010699c: 3b 7d 0c cmp 0xc(%ebp),%edi
8010699f: 76 0d jbe 801069ae <allocuvm+0xde>
801069a1: 8b 4d 0c mov 0xc(%ebp),%ecx
801069a4: 89 fa mov %edi,%edx
801069a6: 8b 45 08 mov 0x8(%ebp),%eax
801069a9: e8 c2 fa ff ff call 80106470 <deallocuvm.part.0>
kfree(mem);
801069ae: 89 34 24 mov %esi,(%esp)
801069b1: e8 3a b9 ff ff call 801022f0 <kfree>
return 0;
801069b6: 31 c0 xor %eax,%eax
801069b8: eb bb jmp 80106975 <allocuvm+0xa5>
801069ba: 8b 4d 0c mov 0xc(%ebp),%ecx
801069bd: 89 fa mov %edi,%edx
801069bf: 8b 45 08 mov 0x8(%ebp),%eax
801069c2: e8 a9 fa ff ff call 80106470 <deallocuvm.part.0>
return 0;
801069c7: 31 c0 xor %eax,%eax
801069c9: eb aa jmp 80106975 <allocuvm+0xa5>
801069cb: 90 nop
801069cc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801069d0 <deallocuvm>:
{
801069d0: 55 push %ebp
801069d1: 89 e5 mov %esp,%ebp
801069d3: 8b 55 0c mov 0xc(%ebp),%edx
801069d6: 8b 4d 10 mov 0x10(%ebp),%ecx
801069d9: 8b 45 08 mov 0x8(%ebp),%eax
if(newsz >= oldsz)
801069dc: 39 d1 cmp %edx,%ecx
801069de: 73 08 jae 801069e8 <deallocuvm+0x18>
}
801069e0: 5d pop %ebp
801069e1: e9 8a fa ff ff jmp 80106470 <deallocuvm.part.0>
801069e6: 66 90 xchg %ax,%ax
801069e8: 89 d0 mov %edx,%eax
801069ea: 5d pop %ebp
801069eb: c3 ret
801069ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
801069f0 <freevm>:
// Free a page table and all the physical memory pages
// in the user part.
void
freevm(pde_t *pgdir)
{
801069f0: 55 push %ebp
801069f1: 89 e5 mov %esp,%ebp
801069f3: 56 push %esi
801069f4: 53 push %ebx
801069f5: 83 ec 10 sub $0x10,%esp
801069f8: 8b 75 08 mov 0x8(%ebp),%esi
uint i;
if(pgdir == 0)
801069fb: 85 f6 test %esi,%esi
801069fd: 74 59 je 80106a58 <freevm+0x68>
801069ff: 31 c9 xor %ecx,%ecx
80106a01: ba 00 00 00 80 mov $0x80000000,%edx
80106a06: 89 f0 mov %esi,%eax
panic("freevm: no pgdir");
deallocuvm(pgdir, KERNBASE, 0);
for(i = 0; i < NPDENTRIES; i++){
80106a08: 31 db xor %ebx,%ebx
80106a0a: e8 61 fa ff ff call 80106470 <deallocuvm.part.0>
80106a0f: eb 12 jmp 80106a23 <freevm+0x33>
80106a11: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106a18: 83 c3 01 add $0x1,%ebx
80106a1b: 81 fb 00 04 00 00 cmp $0x400,%ebx
80106a21: 74 27 je 80106a4a <freevm+0x5a>
if(pgdir[i] & PTE_P){
80106a23: 8b 14 9e mov (%esi,%ebx,4),%edx
80106a26: f6 c2 01 test $0x1,%dl
80106a29: 74 ed je 80106a18 <freevm+0x28>
char * v = P2V(PTE_ADDR(pgdir[i]));
80106a2b: 81 e2 00 f0 ff ff and $0xfffff000,%edx
for(i = 0; i < NPDENTRIES; i++){
80106a31: 83 c3 01 add $0x1,%ebx
char * v = P2V(PTE_ADDR(pgdir[i]));
80106a34: 81 c2 00 00 00 80 add $0x80000000,%edx
kfree(v);
80106a3a: 89 14 24 mov %edx,(%esp)
80106a3d: e8 ae b8 ff ff call 801022f0 <kfree>
for(i = 0; i < NPDENTRIES; i++){
80106a42: 81 fb 00 04 00 00 cmp $0x400,%ebx
80106a48: 75 d9 jne 80106a23 <freevm+0x33>
}
}
kfree((char*)pgdir);
80106a4a: 89 75 08 mov %esi,0x8(%ebp)
}
80106a4d: 83 c4 10 add $0x10,%esp
80106a50: 5b pop %ebx
80106a51: 5e pop %esi
80106a52: 5d pop %ebp
kfree((char*)pgdir);
80106a53: e9 98 b8 ff ff jmp 801022f0 <kfree>
panic("freevm: no pgdir");
80106a58: c7 04 24 ed 78 10 80 movl $0x801078ed,(%esp)
80106a5f: e8 fc 98 ff ff call 80100360 <panic>
80106a64: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106a6a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106a70 <setupkvm>:
{
80106a70: 55 push %ebp
80106a71: 89 e5 mov %esp,%ebp
80106a73: 56 push %esi
80106a74: 53 push %ebx
80106a75: 83 ec 20 sub $0x20,%esp
if((pgdir = (pde_t*)kalloc()) == 0)
80106a78: e8 23 ba ff ff call 801024a0 <kalloc>
80106a7d: 85 c0 test %eax,%eax
80106a7f: 89 c6 mov %eax,%esi
80106a81: 74 75 je 80106af8 <setupkvm+0x88>
memset(pgdir, 0, PGSIZE);
80106a83: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106a8a: 00
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106a8b: bb 20 a4 10 80 mov $0x8010a420,%ebx
memset(pgdir, 0, PGSIZE);
80106a90: c7 44 24 04 00 00 00 movl $0x0,0x4(%esp)
80106a97: 00
80106a98: 89 04 24 mov %eax,(%esp)
80106a9b: e8 e0 d7 ff ff call 80104280 <memset>
if(mappages(pgdir, k->virt, k->phys_end - k->phys_start,
80106aa0: 8b 53 0c mov 0xc(%ebx),%edx
80106aa3: 8b 43 04 mov 0x4(%ebx),%eax
80106aa6: 89 34 24 mov %esi,(%esp)
80106aa9: 89 54 24 10 mov %edx,0x10(%esp)
80106aad: 8b 53 08 mov 0x8(%ebx),%edx
80106ab0: 89 44 24 0c mov %eax,0xc(%esp)
80106ab4: 29 c2 sub %eax,%edx
80106ab6: 8b 03 mov (%ebx),%eax
80106ab8: 89 54 24 08 mov %edx,0x8(%esp)
80106abc: 89 44 24 04 mov %eax,0x4(%esp)
80106ac0: e8 0b fb ff ff call 801065d0 <mappages>
80106ac5: 85 c0 test %eax,%eax
80106ac7: 78 17 js 80106ae0 <setupkvm+0x70>
for(k = kmap; k < &kmap[NELEM(kmap)]; k++)
80106ac9: 83 c3 10 add $0x10,%ebx
80106acc: 81 fb 60 a4 10 80 cmp $0x8010a460,%ebx
80106ad2: 72 cc jb 80106aa0 <setupkvm+0x30>
80106ad4: 89 f0 mov %esi,%eax
}
80106ad6: 83 c4 20 add $0x20,%esp
80106ad9: 5b pop %ebx
80106ada: 5e pop %esi
80106adb: 5d pop %ebp
80106adc: c3 ret
80106add: 8d 76 00 lea 0x0(%esi),%esi
freevm(pgdir);
80106ae0: 89 34 24 mov %esi,(%esp)
80106ae3: e8 08 ff ff ff call 801069f0 <freevm>
}
80106ae8: 83 c4 20 add $0x20,%esp
return 0;
80106aeb: 31 c0 xor %eax,%eax
}
80106aed: 5b pop %ebx
80106aee: 5e pop %esi
80106aef: 5d pop %ebp
80106af0: c3 ret
80106af1: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106af8: 31 c0 xor %eax,%eax
80106afa: eb da jmp 80106ad6 <setupkvm+0x66>
80106afc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106b00 <kvmalloc>:
{
80106b00: 55 push %ebp
80106b01: 89 e5 mov %esp,%ebp
80106b03: 83 ec 08 sub $0x8,%esp
kpgdir = setupkvm();
80106b06: e8 65 ff ff ff call 80106a70 <setupkvm>
80106b0b: a3 a4 55 11 80 mov %eax,0x801155a4
lcr3(V2P(kpgdir)); // switch to the kernel page table
80106b10: 05 00 00 00 80 add $0x80000000,%eax
80106b15: 0f 22 d8 mov %eax,%cr3
}
80106b18: c9 leave
80106b19: c3 ret
80106b1a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106b20 <clearpteu>:
// Clear PTE_U on a page. Used to create an inaccessible
// page beneath the user stack.
void
clearpteu(pde_t *pgdir, char *uva)
{
80106b20: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106b21: 31 c9 xor %ecx,%ecx
{
80106b23: 89 e5 mov %esp,%ebp
80106b25: 83 ec 18 sub $0x18,%esp
pte = walkpgdir(pgdir, uva, 0);
80106b28: 8b 55 0c mov 0xc(%ebp),%edx
80106b2b: 8b 45 08 mov 0x8(%ebp),%eax
80106b2e: e8 ad f8 ff ff call 801063e0 <walkpgdir>
if(pte == 0)
80106b33: 85 c0 test %eax,%eax
80106b35: 74 05 je 80106b3c <clearpteu+0x1c>
panic("clearpteu");
*pte &= ~PTE_U;
80106b37: 83 20 fb andl $0xfffffffb,(%eax)
}
80106b3a: c9 leave
80106b3b: c3 ret
panic("clearpteu");
80106b3c: c7 04 24 fe 78 10 80 movl $0x801078fe,(%esp)
80106b43: e8 18 98 ff ff call 80100360 <panic>
80106b48: 90 nop
80106b49: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
80106b50 <copyuvm>:
// Given a parent process's page table, create a copy
// of it for a child.
pde_t*
copyuvm(pde_t *pgdir, uint sz, uint szStack)
{
80106b50: 55 push %ebp
80106b51: 89 e5 mov %esp,%ebp
80106b53: 57 push %edi
80106b54: 56 push %esi
80106b55: 53 push %ebx
80106b56: 83 ec 2c sub $0x2c,%esp
pte_t *pte;
uint pa, i,j, flags;
//struct proc *currproc = myproc();
char *mem;
if((d = setupkvm()) == 0)
80106b59: e8 12 ff ff ff call 80106a70 <setupkvm>
80106b5e: 85 c0 test %eax,%eax
80106b60: 89 45 e0 mov %eax,-0x20(%ebp)
80106b63: 0f 84 6b 01 00 00 je 80106cd4 <copyuvm+0x184>
return 0;
for(i = 0; i < sz; i += PGSIZE){
80106b69: 8b 55 0c mov 0xc(%ebp),%edx
80106b6c: 85 d2 test %edx,%edx
80106b6e: 0f 84 ac 00 00 00 je 80106c20 <copyuvm+0xd0>
80106b74: 31 db xor %ebx,%ebx
80106b76: eb 51 jmp 80106bc9 <copyuvm+0x79>
panic("copyuvm: page not present");
pa = PTE_ADDR(*pte);
flags = PTE_FLAGS(*pte);
if((mem = kalloc()) == 0)
goto bad;
memmove(mem, (char*)P2V(pa), PGSIZE);
80106b78: 81 c7 00 00 00 80 add $0x80000000,%edi
80106b7e: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106b85: 00
80106b86: 89 7c 24 04 mov %edi,0x4(%esp)
80106b8a: 89 04 24 mov %eax,(%esp)
80106b8d: e8 8e d7 ff ff call 80104320 <memmove>
if(mappages(d, (void*)i, PGSIZE, V2P(mem), flags) < 0)
80106b92: 8b 45 e4 mov -0x1c(%ebp),%eax
80106b95: 8d 96 00 00 00 80 lea -0x80000000(%esi),%edx
80106b9b: 89 54 24 0c mov %edx,0xc(%esp)
80106b9f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106ba6: 00
80106ba7: 89 5c 24 04 mov %ebx,0x4(%esp)
80106bab: 89 44 24 10 mov %eax,0x10(%esp)
80106baf: 8b 45 e0 mov -0x20(%ebp),%eax
80106bb2: 89 04 24 mov %eax,(%esp)
80106bb5: e8 16 fa ff ff call 801065d0 <mappages>
80106bba: 85 c0 test %eax,%eax
80106bbc: 78 4d js 80106c0b <copyuvm+0xbb>
for(i = 0; i < sz; i += PGSIZE){
80106bbe: 81 c3 00 10 00 00 add $0x1000,%ebx
80106bc4: 39 5d 0c cmp %ebx,0xc(%ebp)
80106bc7: 76 57 jbe 80106c20 <copyuvm+0xd0>
if((pte = walkpgdir(pgdir, (void *) i, 0)) == 0)
80106bc9: 8b 45 08 mov 0x8(%ebp),%eax
80106bcc: 31 c9 xor %ecx,%ecx
80106bce: 89 da mov %ebx,%edx
80106bd0: e8 0b f8 ff ff call 801063e0 <walkpgdir>
80106bd5: 85 c0 test %eax,%eax
80106bd7: 0f 84 0a 01 00 00 je 80106ce7 <copyuvm+0x197>
if(!(*pte & PTE_P))
80106bdd: 8b 30 mov (%eax),%esi
80106bdf: f7 c6 01 00 00 00 test $0x1,%esi
80106be5: 0f 84 f0 00 00 00 je 80106cdb <copyuvm+0x18b>
pa = PTE_ADDR(*pte);
80106beb: 89 f7 mov %esi,%edi
flags = PTE_FLAGS(*pte);
80106bed: 81 e6 ff 0f 00 00 and $0xfff,%esi
80106bf3: 89 75 e4 mov %esi,-0x1c(%ebp)
pa = PTE_ADDR(*pte);
80106bf6: 81 e7 00 f0 ff ff and $0xfffff000,%edi
if((mem = kalloc()) == 0)
80106bfc: e8 9f b8 ff ff call 801024a0 <kalloc>
80106c01: 85 c0 test %eax,%eax
80106c03: 89 c6 mov %eax,%esi
80106c05: 0f 85 6d ff ff ff jne 80106b78 <copyuvm+0x28>
return d;
bad:
freevm(d);
80106c0b: 8b 45 e0 mov -0x20(%ebp),%eax
80106c0e: 89 04 24 mov %eax,(%esp)
80106c11: e8 da fd ff ff call 801069f0 <freevm>
return 0;
80106c16: 31 c0 xor %eax,%eax
}
80106c18: 83 c4 2c add $0x2c,%esp
80106c1b: 5b pop %ebx
80106c1c: 5e pop %esi
80106c1d: 5f pop %edi
80106c1e: 5d pop %ebp
80106c1f: c3 ret
for(j = KERNBASE2 - PGSIZE +1 ; szStack > 0; j-= PGSIZE,szStack--){ //do we increment or decrement pgsize
80106c20: 8b 45 10 mov 0x10(%ebp),%eax
80106c23: 85 c0 test %eax,%eax
80106c25: 0f 84 9e 00 00 00 je 80106cc9 <copyuvm+0x179>
80106c2b: bb 00 f0 ff 7f mov $0x7ffff000,%ebx
80106c30: eb 58 jmp 80106c8a <copyuvm+0x13a>
80106c32: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memmove(mem, (char*)P2V(pa), PGSIZE);
80106c38: 81 c7 00 00 00 80 add $0x80000000,%edi
80106c3e: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106c45: 00
80106c46: 89 7c 24 04 mov %edi,0x4(%esp)
80106c4a: 89 04 24 mov %eax,(%esp)
80106c4d: e8 ce d6 ff ff call 80104320 <memmove>
if(mappages(d, (void*)j, PGSIZE, V2P(mem), flags) < 0)
80106c52: 8b 45 e4 mov -0x1c(%ebp),%eax
80106c55: 8d 96 00 00 00 80 lea -0x80000000(%esi),%edx
80106c5b: 89 54 24 0c mov %edx,0xc(%esp)
80106c5f: c7 44 24 08 00 10 00 movl $0x1000,0x8(%esp)
80106c66: 00
80106c67: 89 5c 24 04 mov %ebx,0x4(%esp)
80106c6b: 89 44 24 10 mov %eax,0x10(%esp)
80106c6f: 8b 45 e0 mov -0x20(%ebp),%eax
80106c72: 89 04 24 mov %eax,(%esp)
80106c75: e8 56 f9 ff ff call 801065d0 <mappages>
80106c7a: 85 c0 test %eax,%eax
80106c7c: 78 8d js 80106c0b <copyuvm+0xbb>
for(j = KERNBASE2 - PGSIZE +1 ; szStack > 0; j-= PGSIZE,szStack--){ //do we increment or decrement pgsize
80106c7e: 81 eb 00 10 00 00 sub $0x1000,%ebx
80106c84: 83 6d 10 01 subl $0x1,0x10(%ebp)
80106c88: 74 3f je 80106cc9 <copyuvm+0x179>
if((pte = walkpgdir(pgdir, (void *) j, 0)) == 0)
80106c8a: 8b 45 08 mov 0x8(%ebp),%eax
80106c8d: 31 c9 xor %ecx,%ecx
80106c8f: 89 da mov %ebx,%edx
80106c91: e8 4a f7 ff ff call 801063e0 <walkpgdir>
80106c96: 85 c0 test %eax,%eax
80106c98: 74 4d je 80106ce7 <copyuvm+0x197>
if(!(*pte & PTE_P))
80106c9a: 8b 30 mov (%eax),%esi
80106c9c: f7 c6 01 00 00 00 test $0x1,%esi
80106ca2: 74 37 je 80106cdb <copyuvm+0x18b>
pa = PTE_ADDR(*pte);
80106ca4: 89 f7 mov %esi,%edi
flags = PTE_FLAGS(*pte);
80106ca6: 81 e6 ff 0f 00 00 and $0xfff,%esi
80106cac: 89 75 e4 mov %esi,-0x1c(%ebp)
pa = PTE_ADDR(*pte);
80106caf: 81 e7 00 f0 ff ff and $0xfffff000,%edi
if((mem = kalloc()) == 0)
80106cb5: e8 e6 b7 ff ff call 801024a0 <kalloc>
80106cba: 85 c0 test %eax,%eax
80106cbc: 89 c6 mov %eax,%esi
80106cbe: 0f 85 74 ff ff ff jne 80106c38 <copyuvm+0xe8>
80106cc4: e9 42 ff ff ff jmp 80106c0b <copyuvm+0xbb>
80106cc9: 8b 45 e0 mov -0x20(%ebp),%eax
}
80106ccc: 83 c4 2c add $0x2c,%esp
80106ccf: 5b pop %ebx
80106cd0: 5e pop %esi
80106cd1: 5f pop %edi
80106cd2: 5d pop %ebp
80106cd3: c3 ret
return 0;
80106cd4: 31 c0 xor %eax,%eax
80106cd6: e9 3d ff ff ff jmp 80106c18 <copyuvm+0xc8>
panic("copyuvm: page not present");
80106cdb: c7 04 24 22 79 10 80 movl $0x80107922,(%esp)
80106ce2: e8 79 96 ff ff call 80100360 <panic>
panic("copyuvm: pte should exist");
80106ce7: c7 04 24 08 79 10 80 movl $0x80107908,(%esp)
80106cee: e8 6d 96 ff ff call 80100360 <panic>
80106cf3: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106cf9: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106d00 <uva2ka>:
//PAGEBREAK!
// Map user virtual address to kernel address.
char*
uva2ka(pde_t *pgdir, char *uva)
{
80106d00: 55 push %ebp
pte_t *pte;
pte = walkpgdir(pgdir, uva, 0);
80106d01: 31 c9 xor %ecx,%ecx
{
80106d03: 89 e5 mov %esp,%ebp
80106d05: 83 ec 08 sub $0x8,%esp
pte = walkpgdir(pgdir, uva, 0);
80106d08: 8b 55 0c mov 0xc(%ebp),%edx
80106d0b: 8b 45 08 mov 0x8(%ebp),%eax
80106d0e: e8 cd f6 ff ff call 801063e0 <walkpgdir>
if((*pte & PTE_P) == 0)
80106d13: 8b 00 mov (%eax),%eax
80106d15: 89 c2 mov %eax,%edx
80106d17: 83 e2 05 and $0x5,%edx
return 0;
if((*pte & PTE_U) == 0)
80106d1a: 83 fa 05 cmp $0x5,%edx
80106d1d: 75 11 jne 80106d30 <uva2ka+0x30>
return 0;
return (char*)P2V(PTE_ADDR(*pte));
80106d1f: 25 00 f0 ff ff and $0xfffff000,%eax
80106d24: 05 00 00 00 80 add $0x80000000,%eax
}
80106d29: c9 leave
80106d2a: c3 ret
80106d2b: 90 nop
80106d2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return 0;
80106d30: 31 c0 xor %eax,%eax
}
80106d32: c9 leave
80106d33: c3 ret
80106d34: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
80106d3a: 8d bf 00 00 00 00 lea 0x0(%edi),%edi
80106d40 <copyout>:
// Copy len bytes from p to user address va in page table pgdir.
// Most useful when pgdir is not the current page table.
// uva2ka ensures this only works for PTE_U pages.
int
copyout(pde_t *pgdir, uint va, void *p, uint len)
{
80106d40: 55 push %ebp
80106d41: 89 e5 mov %esp,%ebp
80106d43: 57 push %edi
80106d44: 56 push %esi
80106d45: 53 push %ebx
80106d46: 83 ec 1c sub $0x1c,%esp
80106d49: 8b 5d 14 mov 0x14(%ebp),%ebx
80106d4c: 8b 4d 0c mov 0xc(%ebp),%ecx
80106d4f: 8b 7d 10 mov 0x10(%ebp),%edi
char *buf, *pa0;
uint n, va0;
buf = (char*)p;
while(len > 0){
80106d52: 85 db test %ebx,%ebx
80106d54: 75 3a jne 80106d90 <copyout+0x50>
80106d56: eb 68 jmp 80106dc0 <copyout+0x80>
va0 = (uint)PGROUNDDOWN(va);
pa0 = uva2ka(pgdir, (char*)va0);
if(pa0 == 0)
return -1;
n = PGSIZE - (va - va0);
80106d58: 8b 4d e4 mov -0x1c(%ebp),%ecx
80106d5b: 89 f2 mov %esi,%edx
if(n > len)
n = len;
memmove(pa0 + (va - va0), buf, n);
80106d5d: 89 7c 24 04 mov %edi,0x4(%esp)
n = PGSIZE - (va - va0);
80106d61: 29 ca sub %ecx,%edx
80106d63: 81 c2 00 10 00 00 add $0x1000,%edx
80106d69: 39 da cmp %ebx,%edx
80106d6b: 0f 47 d3 cmova %ebx,%edx
memmove(pa0 + (va - va0), buf, n);
80106d6e: 29 f1 sub %esi,%ecx
80106d70: 01 c8 add %ecx,%eax
80106d72: 89 54 24 08 mov %edx,0x8(%esp)
80106d76: 89 04 24 mov %eax,(%esp)
80106d79: 89 55 e4 mov %edx,-0x1c(%ebp)
80106d7c: e8 9f d5 ff ff call 80104320 <memmove>
len -= n;
buf += n;
80106d81: 8b 55 e4 mov -0x1c(%ebp),%edx
va = va0 + PGSIZE;
80106d84: 8d 8e 00 10 00 00 lea 0x1000(%esi),%ecx
buf += n;
80106d8a: 01 d7 add %edx,%edi
while(len > 0){
80106d8c: 29 d3 sub %edx,%ebx
80106d8e: 74 30 je 80106dc0 <copyout+0x80>
pa0 = uva2ka(pgdir, (char*)va0);
80106d90: 8b 45 08 mov 0x8(%ebp),%eax
va0 = (uint)PGROUNDDOWN(va);
80106d93: 89 ce mov %ecx,%esi
80106d95: 81 e6 00 f0 ff ff and $0xfffff000,%esi
pa0 = uva2ka(pgdir, (char*)va0);
80106d9b: 89 74 24 04 mov %esi,0x4(%esp)
va0 = (uint)PGROUNDDOWN(va);
80106d9f: 89 4d e4 mov %ecx,-0x1c(%ebp)
pa0 = uva2ka(pgdir, (char*)va0);
80106da2: 89 04 24 mov %eax,(%esp)
80106da5: e8 56 ff ff ff call 80106d00 <uva2ka>
if(pa0 == 0)
80106daa: 85 c0 test %eax,%eax
80106dac: 75 aa jne 80106d58 <copyout+0x18>
}
return 0;
}
80106dae: 83 c4 1c add $0x1c,%esp
return -1;
80106db1: b8 ff ff ff ff mov $0xffffffff,%eax
}
80106db6: 5b pop %ebx
80106db7: 5e pop %esi
80106db8: 5f pop %edi
80106db9: 5d pop %ebp
80106dba: c3 ret
80106dbb: 90 nop
80106dbc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106dc0: 83 c4 1c add $0x1c,%esp
return 0;
80106dc3: 31 c0 xor %eax,%eax
}
80106dc5: 5b pop %ebx
80106dc6: 5e pop %esi
80106dc7: 5f pop %edi
80106dc8: 5d pop %ebp
80106dc9: c3 ret
80106dca: 66 90 xchg %ax,%ax
80106dcc: 66 90 xchg %ax,%ax
80106dce: 66 90 xchg %ax,%ax
80106dd0 <shminit>:
char *frame;
int refcnt;
} shm_pages[64];
} shm_table;
void shminit() {
80106dd0: 55 push %ebp
80106dd1: 89 e5 mov %esp,%ebp
80106dd3: 83 ec 18 sub $0x18,%esp
int i;
initlock(&(shm_table.lock), "SHM lock");
80106dd6: c7 44 24 04 60 79 10 movl $0x80107960,0x4(%esp)
80106ddd: 80
80106dde: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106de5: e8 66 d2 ff ff call 80104050 <initlock>
acquire(&(shm_table.lock));
80106dea: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106df1: e8 4a d3 ff ff call 80104140 <acquire>
80106df6: b8 f4 55 11 80 mov $0x801155f4,%eax
80106dfb: 90 nop
80106dfc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
for (i = 0; i< 64; i++) {
shm_table.shm_pages[i].id =0;
80106e00: c7 00 00 00 00 00 movl $0x0,(%eax)
80106e06: 83 c0 0c add $0xc,%eax
shm_table.shm_pages[i].frame =0;
80106e09: c7 40 f8 00 00 00 00 movl $0x0,-0x8(%eax)
shm_table.shm_pages[i].refcnt =0;
80106e10: c7 40 fc 00 00 00 00 movl $0x0,-0x4(%eax)
for (i = 0; i< 64; i++) {
80106e17: 3d f4 58 11 80 cmp $0x801158f4,%eax
80106e1c: 75 e2 jne 80106e00 <shminit+0x30>
}
release(&(shm_table.lock));
80106e1e: c7 04 24 c0 55 11 80 movl $0x801155c0,(%esp)
80106e25: e8 06 d4 ff ff call 80104230 <release>
}
80106e2a: c9 leave
80106e2b: c3 ret
80106e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
80106e30 <shm_open>:
int shm_open(int id, char **pointer) {
80106e30: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106e31: 31 c0 xor %eax,%eax
int shm_open(int id, char **pointer) {
80106e33: 89 e5 mov %esp,%ebp
}
80106e35: 5d pop %ebp
80106e36: c3 ret
80106e37: 89 f6 mov %esi,%esi
80106e39: 8d bc 27 00 00 00 00 lea 0x0(%edi,%eiz,1),%edi
80106e40 <shm_close>:
int shm_close(int id) {
80106e40: 55 push %ebp
return 0; //added to remove compiler warning -- you should decide what to return
}
80106e41: 31 c0 xor %eax,%eax
int shm_close(int id) {
80106e43: 89 e5 mov %esp,%ebp
}
80106e45: 5d pop %ebp
80106e46: c3 ret
| 38.069685
| 141
| 0.529378
|
512cb794778c0165f8ef4b5ffb735c90bad36117
| 1,385
|
asm
|
Assembly
|
programs/oeis/020/A020712.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/020/A020712.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/020/A020712.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A020712: Pisot sequences E(5,8), P(5,8).
; 5,8,13,21,34,55,89,144,233,377,610,987,1597,2584,4181,6765,10946,17711,28657,46368,75025,121393,196418,317811,514229,832040,1346269,2178309,3524578,5702887,9227465,14930352,24157817,39088169,63245986,102334155,165580141,267914296,433494437,701408733,1134903170,1836311903,2971215073,4807526976,7778742049,12586269025,20365011074,32951280099,53316291173,86267571272,139583862445,225851433717,365435296162,591286729879,956722026041,1548008755920,2504730781961,4052739537881,6557470319842,10610209857723,17167680177565,27777890035288,44945570212853,72723460248141,117669030460994,190392490709135,308061521170129,498454011879264,806515533049393,1304969544928657,2111485077978050,3416454622906707,5527939700884757,8944394323791464,14472334024676221,23416728348467685,37889062373143906,61305790721611591,99194853094755497,160500643816367088,259695496911122585,420196140727489673,679891637638612258,1100087778366101931,1779979416004714189,2880067194370816120,4660046610375530309,7540113804746346429,12200160415121876738,19740274219868223167,31940434634990099905,51680708854858323072,83621143489848422977,135301852344706746049,218922995834555169026,354224848179261915075,573147844013817084101,927372692193078999176,1500520536206896083277,2427893228399975082453
mov $1,5
mov $2,3
lpb $0
sub $0,1
mov $3,$2
mov $2,$1
add $1,$3
lpe
mov $0,$1
| 106.538462
| 1,254
| 0.88231
|
87b4e5ab8d3a98e4fa6a70539905e79bfef4aae4
| 263
|
asm
|
Assembly
|
programs/oeis/238/A238377.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/238/A238377.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/238/A238377.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A238377: Row sums of triangle in A204028.
; 1,2,6,10,17,24,34,44,57,70,86,102,121,140,162,184,209,234,262,290,321,352,386,420,457,494,534,574,617,660,706,752,801,850,902,954,1009,1064,1122,1180
mov $1,6
mul $1,$0
add $1,8
mul $1,$0
div $1,8
add $1,1
mov $0,$1
| 23.909091
| 151
| 0.676806
|
149c01ad64a46a0aa38289968df955bbf5311fd0
| 7
|
asm
|
Assembly
|
shellcode/amd64/nop.asm
|
r0ck3rt/gopwn
|
71f1d0881e0032f8b08353f0bf7d6d8551be0780
|
[
"MIT"
] | 9
|
2021-08-23T08:05:15.000Z
|
2022-03-09T21:03:30.000Z
|
shellcode/amd64/nop.asm
|
r0ck3rt/gopwn
|
71f1d0881e0032f8b08353f0bf7d6d8551be0780
|
[
"MIT"
] | null | null | null |
shellcode/amd64/nop.asm
|
r0ck3rt/gopwn
|
71f1d0881e0032f8b08353f0bf7d6d8551be0780
|
[
"MIT"
] | 2
|
2021-08-23T08:12:27.000Z
|
2021-09-19T14:47:15.000Z
|
nop
| 7
| 7
| 0.428571
|
dfad05a6798f76406055f874134d616fe298ddc0
| 205
|
asm
|
Assembly
|
programs/oeis/005/A005096.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/005/A005096.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/005/A005096.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A005096: a(n) = n! - n.
; 1,0,0,3,20,115,714,5033,40312,362871,3628790,39916789,479001588,6227020787,87178291186,1307674367985,20922789887984,355687428095983,6402373705727982
mov $1,$0
fac $1
sub $1,$0
| 29.285714
| 150
| 0.756098
|
b028e616e811d081eef8a97c4a53b1394a361f22
| 785
|
asm
|
Assembly
|
audio/sfx/cry1e_1.asm
|
AmateurPanda92/pokemon-rby-dx
|
f7ba1cc50b22d93ed176571e074a52d73360da93
|
[
"MIT"
] | 9
|
2020-07-12T19:44:21.000Z
|
2022-03-03T23:32:40.000Z
|
audio/sfx/cry1e_1.asm
|
JStar-debug2020/pokemon-rby-dx
|
c2fdd8145d96683addbd8d9075f946a68d1527a1
|
[
"MIT"
] | 7
|
2020-07-16T10:48:52.000Z
|
2021-01-28T18:32:02.000Z
|
audio/sfx/cry1e_1.asm
|
JStar-debug2020/pokemon-rby-dx
|
c2fdd8145d96683addbd8d9075f946a68d1527a1
|
[
"MIT"
] | 2
|
2021-03-28T18:33:43.000Z
|
2021-05-06T13:12:09.000Z
|
SFX_Cry1E_1_Ch4:
dutycycle 240
squarenote 6, 15, 2, 1536
squarenote 6, 14, 2, 1600
squarenote 6, 13, 2, 1664
squarenote 6, 14, 2, 1728
squarenote 6, 13, 2, 1792
squarenote 6, 12, 2, 1856
squarenote 6, 11, 2, 1920
squarenote 8, 10, 1, 1984
endchannel
SFX_Cry1E_1_Ch5:
dutycycle 17
squarenote 3, 0, 8, 1
squarenote 6, 12, 2, 1473
squarenote 6, 11, 2, 1538
squarenote 6, 10, 2, 1601
squarenote 6, 11, 2, 1666
squarenote 6, 10, 2, 1730
squarenote 6, 9, 2, 1793
squarenote 6, 10, 2, 1858
squarenote 8, 8, 1, 1921
endchannel
SFX_Cry1E_1_Ch7:
noisenote 6, 0, 8, 1
noisenote 5, 14, 2, 92
noisenote 5, 12, 2, 76
noisenote 5, 13, 2, 60
noisenote 5, 11, 2, 44
noisenote 5, 12, 2, 28
noisenote 5, 10, 2, 27
noisenote 5, 9, 2, 26
noisenote 8, 8, 1, 24
endchannel
| 20.128205
| 26
| 0.673885
|
fe449b2ba60bb8962773645e1dd1e8384afaac00
| 4,268
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i3-7100_9_0xca_notsx.log_21829_1770.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_1770.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_1770.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 %rax
push %rcx
push %rdi
push %rsi
lea addresses_WC_ht+0x234f, %rsi
add %rdi, %rdi
movb $0x61, (%rsi)
nop
inc %rax
lea addresses_WT_ht+0xb24f, %rsi
lea addresses_A_ht+0x15d3d, %rdi
clflush (%rdi)
sub $23998, %r13
mov $65, %rcx
rep movsb
and $38347, %rax
pop %rsi
pop %rdi
pop %rcx
pop %rax
pop %r13
ret
.global s_faulty_load
s_faulty_load:
push %r11
push %r13
push %r15
push %r8
push %rbp
// Faulty Load
lea addresses_WT+0xdb4f, %rbp
nop
nop
nop
nop
nop
xor %r15, %r15
mov (%rbp), %r11d
lea oracles, %r8
and $0xff, %r11
shlq $12, %r11
mov (%r8,%r11,1), %r11
pop %rbp
pop %r8
pop %r15
pop %r13
pop %r11
ret
/*
<gen_faulty_load>
[REF]
{'src': {'same': False, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
[Faulty Load]
{'src': {'same': True, 'congruent': 0, 'NT': False, 'type': 'addresses_WT', 'size': 4, 'AVXalign': False}, 'OP': 'LOAD'}
<gen_prepare_buffer>
{'OP': 'STOR', 'dst': {'same': False, 'congruent': 8, 'NT': False, 'type': 'addresses_WC_ht', 'size': 1, 'AVXalign': False}}
{'src': {'type': 'addresses_WT_ht', 'congruent': 3, 'same': False}, 'OP': 'REPM', 'dst': {'type': 'addresses_A_ht', 'congruent': 0, 'same': False}}
{'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
*/
| 63.701493
| 2,999
| 0.661668
|
51119122a16b8d88e8f63e3bf36a5897350a2551
| 198
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/adt/p_queue/c/sdcc_iy/p_queue_front_fastcall.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/_DEVELOPMENT/adt/p_queue/c/sdcc_iy/p_queue_front_fastcall.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/_DEVELOPMENT/adt/p_queue/c/sdcc_iy/p_queue_front_fastcall.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
; void *p_queue_front_fastcall(p_queue_t *q)
SECTION code_clib
SECTION code_adt_p_queue
PUBLIC _p_queue_front_fastcall
EXTERN asm_p_queue_front
defc _p_queue_front_fastcall = asm_p_queue_front
| 16.5
| 48
| 0.863636
|
b10ae02c92bcae8ae683e68ddb9411cdf56a073a
| 478
|
asm
|
Assembly
|
oeis/319/A319880.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/319/A319880.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/319/A319880.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A319880: Difference between 2^n and the product of primes less than or equal to n.
; Submitted by Christian Krause
; 0,1,2,2,10,2,34,-82,46,302,814,-262,1786,-21838,-13646,2738,35506,-379438,-248366,-9175402,-8651114,-7602538,-5505386,-214704262,-206315654,-189538438,-155984006,-88875142,45342586,-5932822318,-5395951406,-198413006482
mov $1,2
pow $1,$0
mul $0,2
seq $0,300951 ; a(n) = Product_{j=1..floor(n/2)} p(j) where p(j) = j if j is prime else 1.
sub $1,$0
mov $0,$1
| 43.454545
| 220
| 0.709205
|
d68a907f80792f84cadb3316d75e9b20ace839f1
| 4,839
|
asm
|
Assembly
|
pwnlib/shellcraft/templates/aarch64/linux/loader.asm
|
IMULMUL/python3-pwntools
|
61210a68cd88e9084c72292d3119c38c44f07966
|
[
"MIT"
] | 325
|
2016-01-25T08:38:06.000Z
|
2022-03-30T14:31:50.000Z
|
pwnlib/shellcraft/templates/aarch64/linux/loader.asm
|
IMULMUL/python3-pwntools
|
61210a68cd88e9084c72292d3119c38c44f07966
|
[
"MIT"
] | 8
|
2016-08-23T10:15:27.000Z
|
2019-01-16T02:49:34.000Z
|
pwnlib/shellcraft/templates/aarch64/linux/loader.asm
|
IMULMUL/python3-pwntools
|
61210a68cd88e9084c72292d3119c38c44f07966
|
[
"MIT"
] | 71
|
2016-07-13T10:03:52.000Z
|
2022-01-10T11:57:34.000Z
|
<%
from pwnlib.shellcraft.aarch64.linux import exit as exit
from pwnlib.shellcraft.aarch64.linux import mmap
from pwnlib.shellcraft.aarch64 import setregs, mov, memcpy
from pwnlib.shellcraft import common
from pwnlib.util.packing import unpack
%>
<%page args="address"/>
<%docstring>
Loads a statically-linked ELF into memory and transfers control.
Arguments:
address(int): Address of the ELF as a register or integer.
</%docstring>
<%
elf_magic = unpack(b'\x7fELF', 32)
die = common.label('die')
load_one = common.label('load_one')
next_phdr = common.label('next_phdr')
"""
Elf64_Ehdr
+0x0000 e_ident : unsigned char [16]
+0x0010 e_type : Elf64_Half
+0x0012 e_machine : Elf64_Half
+0x0014 e_version : Elf64_Word
+0x0018 e_entry : Elf64_Addr
+0x0020 e_phoff : Elf64_Off
+0x0028 e_shoff : Elf64_Off
+0x0030 e_flags : Elf64_Word
+0x0034 e_ehsize : Elf64_Half
+0x0036 e_phentsize : Elf64_Half
+0x0038 e_phnum : Elf64_Half
+0x003a e_shentsize : Elf64_Half
+0x003c e_shnum : Elf64_Half
+0x003e e_shstrndx : Elf64_Half
Elf64_Phdr
+0x0000 p_type : Elf64_Word
+0x0004 p_flags : Elf64_Word
+0x0008 p_offset : Elf64_Off
+0x0010 p_vaddr : Elf64_Addr
+0x0018 p_paddr : Elf64_Addr
+0x0020 p_filesz : Elf64_Xword
+0x0028 p_memsz : Elf64_Xword
+0x0030 p_align : Elf64_Xword
"""
e_entry = 0x0018
e_phoff = 0x0020
e_phnum = 0x0038
e_phentsize = 0x0036
p_type = 0x0000
p_offset = 0x0008
p_vaddr = 0x0010
p_filesz = 0x0020
p_memsz = 0x0028
PT_LOAD = 1
%>
${setregs({'x0': address})}
/* Check the ELF header */
ldr x1, [x0]
${mov('x2', elf_magic)}
cmp w1, w2
bne ${die}
/* Discover program headers */
add x1, x0, #${e_phoff}
ldr x1, [x1]
add x1, x1, x0 /* x1 = &program headers */
add x2, x0, #${e_phentsize}
ldrh w2, [x2] /* x2 = program header size */
add x3, x0, #${e_phnum}
ldrh w3, [x3] /* x3 = number of program headers */
1:
/* For each section header, mmap it to the desired address */
stp x0, x1, [sp, #-16]!
stp x2, x3, [sp, #-16]!
bl ${load_one}
ldp x2, x3, [sp], #16
ldp x0, x1, [sp], #16
add x1, x1, x2
subs x3, x3, #1
bne 1b
/* Everything is loaded and RWX. Find the entry point and call it */
add x1, x0, #${e_entry}
ldr x1, [x1]
mov x8, x1
/* Set up the fake stack.
For whatever reason, aarch64 binaries really want AT_RANDOM
to be available. */
/* AT_NULL */
eor x0, x0, x0
eor x1, x1, x1
stp x0, x1, [sp, #-16]!
/* AT_RANDOM */
mov x2, #25
mov x3, sp
stp x2, x3, [sp, #-16]!
/* argc, argv[0], argv[1], envp */
/* ideally these could all be empty, but unfortunately
we have to keep the stack aligned. it's easier to
just push an extra argument than care... */
stp x0, x1, [sp, #-16]! /* argv[1] = NULL, envp = NULL */
mov x0, 1
mov x1, sp
stp x0, x1, [sp, #-16]! /* argc = 1, argv[0] = "" */
br x8
${load_one}:
/* x1 = &program headers */
stp x29, x30, [sp, #-16]!
mov x29, sp
/* If it's not a PT_LOAD header, don't care */
add x2, x1, #${p_type}
ldr x2, [x2]
uxth w2, w2 /* zero-extend halfword */
cmp x2, #${PT_LOAD}
bne ${next_phdr}
/* Get the destination address into x2 */
add x2, x1, ${p_vaddr}
ldr x2, [x2]
/* Get the size to mmap into x3 */
add x3, x1, #${p_memsz}
ldr x3, [x3]
lsr w3, w3, #12
add x3, x3, #1
/* We can't move the program break with brk(),
so we basically have to fake it. Allocate
more space than we ever expect the heap to
need, by over-allocating space by 8x */
lsl w3, w3, #12 + 4
/* Map the page in */
stp x0, x1, [sp, #-16]!
stp x2, x3, [sp, #-16]!
lsr w2, w2, #12
lsl w2, w2, #12
${mmap('x2', 'x3', 'PROT_READ|PROT_WRITE|PROT_EXEC', 'MAP_ANONYMOUS|MAP_PRIVATE|MAP_FIXED', 0, 0)}
/* Ignore failure */
ldp x2, x3, [sp], #16
ldp x0, x1, [sp], #16
/* Get the source address into x4 */
add x4, x1, #${p_offset}
ldr x4, [x4]
add x4, x4, x0
/* Get the number of bytes into x5 */
add x5, x1, #${p_filesz}
ldr x5, [x5]
/* Copy the data */
stp x0, x1, [sp, #-16]!
stp x2, x3, [sp, #-16]!
stp x4, x5, [sp, #-16]!
${memcpy('x2', 'x4', 'x5')}
ldp x4, x5, [sp], #16
ldp x2, x3, [sp], #16
ldp x0, x1, [sp], #16
${next_phdr}:
mov sp, x29
ldp x29, x30, [sp], #16
ret x30
${die}:
${exit(1)}
| 26.298913
| 102
| 0.553833
|
2640446f58226d8fed26d77f6a4c7595c9ed7d92
| 29,113
|
asm
|
Assembly
|
dos/file.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
dos/file.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
dos/file.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
TITLE FILE - Pathname related system calls
NAME FILE
;
; Microsoft Confidential
; Copyright (C) Microsoft Corporation 1991
; All Rights Reserved.
;
;** FILE.ASM - Pathname Related System Calls
;
; These will be passed direct text of the
; pathname from the user. They will need to be passed through the macro
; expander prior to being sent through the low-level stuff. I/O specs are
; defined in DISPATCH. The system calls are:
;
; $Open written
; $Creat written
; $ChMod written
; $Unlink written
; $Rename written
; $CreateTempFile written
; $CreateNewFile written
; $Extended_Open written DOS 4.00
; GetIOParms written DOS 4.00
;
; Revision history:
;
; Created: MZ 4 April 1983
; A000 version 4.00 Jan. 1988
; A001 DOS 4.0, PTM #6069, BL, ROMDOS fix
; M022 conditional removed
; M049 If access_denied is obtained whle trying to create a temp
; file, check to see if this was due to the network drive
; being read only.
;
; M069 Bug #5913. CreateTempFile now checks for error_net_access_
; denied instead of error_cannot_make because ExtErr is set
; to the first errorcode when we try to create a file on a
; read-only share.
;
; M070 Bug #5943. CreateTempFile now has a check for
; error_failed_I24 which is set if the user fails on an I24
; that is got on a write-protected disk. Previously, the
; code would go ahead and try another name and then hang
; because DOS is in an inconsistent state.
;
.xlist
.xcref
include version.inc
include dosseg.inc
include dossym.inc
include devsym.inc
include sf.inc
include filemode.inc
include bugtyp.inc
.cref
.list
I_need WFP_Start,WORD ; pointer to beginning of expansion
I_Need ThisCDS,DWORD ; pointer to curdir in use
I_need ThisSft,DWORD ; SFT pointer for DOS_Open
I_need pJFN,DWORD ; temporary spot for pointer to JFN
I_need JFN,WORD ; word JFN for process
I_need SFN,WORD ; word SFN for process
I_Need OpenBuf,128 ; buffer for filename
I_Need RenBuf,128 ; buffer for filename in rename
I_need Sattrib,BYTE ; byte attribute to search for
I_need Ren_WFP,WORD ; pointer to real path
I_need cMeta,BYTE
I_need EXTERR,WORD ; extended error code
I_need EXTERR_LOCUS,BYTE ; Extended Error Locus
i_need JShare,DWORD ; share jump table
I_need fSharing,BYTE ; TRUE => via ServerDOSCall
I_need FastOpenTable,BYTE
I_need CPSWFLAG,BYTE ;AN000;FT. cpsw falg
I_need EXTOPEN_FLAG,WORD ;AN000;FT. extended file open flag
I_need EXTOPEN_ON,BYTE ;AN000;FT. extended open flag
I_need EXTOPEN_IO_MODE,WORD ;AN000;FT. IO mode
I_need SAVE_ES,WORD ;AN000;;FT. for get/set XA
I_need SAVE_DI,WORD ;AN000;;FT. for get/set XA
I_need SAVE_DS,WORD ;AN000;;FT. for get/set XA
I_need SAVE_SI,WORD ;AN000;;FT. for get/set XA
I_need SAVE_DX,WORD ;AN000;;FT. for get/set XA
I_need SAVE_BX,WORD ;AN000;;FT. for get/set XA
I_need SAVE_CX,WORD ;AN000;;FT. for get/set XA
I_need Temp_Var,WORD ;AN000;;
I_need DOS34_FLAG,WORD ;AN000;;
I_need Temp_Var2,WORD ;AN000;;
DOSCODE SEGMENT
ASSUME SS:DOSDATA,CS:DOSCODE
EXTRN DOS_OPEN:NEAR,DOS_CREATE:NEAR,DOS_Create_New:NEAR
EXTRN SFNFree:near
extrn Set_EXT_mode:near ;M022 conditional removed
BREAK <$Open - open a file from a path string>
;** $OPen - Open a File
;
; given a path name in DS:DX and an open mode in AL, $Open opens the
; file and and returns a handle
;
; ENTRY (DS:DX) = pointer to asciz name
; (AL) = open mode
; EXIT 'C' clear if OK
; (ax) = file handle
; 'C' set iff error
; (ax) = error code
; USES all
Procedure $Open,NEAR
DOSAssume <SS>,"Open"
fmt TypSysCall,LevArgs,<" Mode = $x file = '$S'\n">,<AX,DS,DX>
XOR AH,AH
Entry $Open2 ;AN000;
mov ch,attr_hidden+attr_system+attr_directory
call SetAttrib
MOV CX,OFFSET DOSCODE:DOS_Open ; address of routine to call
SAVE <AX> ; Save mode on stack
IFDEF DBCS ;AN000;
MOV Temp_Var,0 ;AN000;KK. set variable with 0;smr;SS Override
ENDIF ;AN000;
;* General file open/create code. The $CREATE call and the various
; $OPEN calls all come here.
;
; We'll share a lot of the standard stuff of allocating SFTs, cracking
; path names, etc., and then dispatch to our individual handlers.
; WARNING - this info and list is just a guess, not definitive - jgl
;
; (TOS) = create mode
; (CX) = address of routine to call to do actual function
; (DS:DX) = ASCIZ name
; SAttrib = Attribute mask
; Get a free SFT and mark it "being allocated"
AccessFile:
IFDEF DBCS ;AN000;
TEST Temp_Var,ATTR_VOLUME_ID ; volume id bit set?
JZ novol
OR [DOS34_FLAG],DBCS_VOLID ; warn transpath about VOLID
novol:
ENDIF
EnterCrit critSFT
call SFNFree ; get a free sfn
LeaveCrit critSFT
JC OpenFailJ ; oops, no free sft's
MOV SFN,BX ; save the SFN for later;smr;SS Override
fmt TypAccess,LevSFN,<"AccessFile setting SFN to $x\n">,<BX>
MOV WORD PTR ThisSFT,DI ; save the SF offset ;smr;SS Override
MOV WORD PTR ThisSFT+2,ES ; save the SF segment ;smr;SS Override
; Find a free area in the user's JFN table.
invoke JFNFree ; get a free jfn
JNC SaveJFN
OpenFailJ:
JMP OpenFail ; there were free JFNs... try SFN
SaveJFN:MOV WORD PTR pJFN,DI ; save the jfn offset ;smr;SS Override
MOV WORD PTR pJFN+2,ES ; save the jfn segment ;smr;SS Override
MOV JFN,BX ; save the jfn itself ;smr;SS Override
; We have been given an JFN. We lock it down to prevent other tasks from
; reusing the same JFN.
MOV BX,SFN ;smr;SS Override
MOV ES:[DI],BL ; assign the JFN
MOV SI,DX ; get name in appropriate place
MOV DI,OFFSET DOSDATA:OpenBuf ; appropriate buffer
SAVE <CX> ; save routine to call
invoke TransPath ; convert the path
RESTORE <BX> ; (bx) = routine to call
LDS SI,ThisSFT ;smr;SS Override
ASSUME DS:NOTHING
JC OpenCleanJ ; no error, go and open file
CMP cMeta,-1 ;smr;SS Override
JZ SetSearch
MOV AL,error_file_not_found ; no meta chars allowed
OpenCleanJ:
JMP short OpenClean
SetSearch:
RESTORE <AX> ; Mode (Open), Attributes (Create)
; We need to get the new inheritance bits.
xor cx,cx
MOV [SI].sf_mode,cx ; initialize mode field to 0
MOV [SI].SF_mft,cx ; clean out sharing info
CMP BX,OFFSET DOSCODE:DOS_OPEN
JNZ DoOper
TEST AL,sharing_no_inherit ; look for no inher
JZ DoOper
AND AL,07Fh ; mask off inherit bit
MOV CX,sf_no_inherit
DoOper:
;** Check if this is an extended open. If so you must set the
; modes in sf_mode. Call Set_EXT_mode to do all this. See
; Set_EXT_mode in creat.asm
SAVE <di, es> ;M022 conditional removed here
push ds
pop es
push si
pop di ; (es:di) = SFT address
call Set_EXT_mode
RESTORE <es, di>
Context DS
SAVE <CX>
CALL BX ; blam!
RESTORE <CX>
LDS SI,ThisSFT
ASSUME DS:NOTHING
JC OpenE2 ;AN000;FT. chek extended open hooks first
; The SFT was successfully opened. Remove busy mark.
OpenOK:
ASSUME DS:NOTHING
MOV [SI].sf_ref_count,1
OR [SI].sf_flags,CX ; set no inherit bit if necessary
; If the open mode is 70, we scan the system for other SFT's with the same
; contents. If we find one, then we can 'collapse' thissft onto the already
; opened one. Otherwise we use this new one. We compare uid/pid/mode/mft
;
; Since this is only relevant on sharer systems, we stick this code into the
; sharer.
MOV AX,JFN ;smr;SS Override
if installed
Call JShare + 12 * 4 ;smr;SS Override
else
Call ShCol ;PBUGBUG
endif
fmt TypAccess,LevSFN,<"AccessFile setting SFN to -1\n">
MOV SFN,-1 ; clear out sfn pointer ;smr;SS Override
transfer Sys_Ret_OK ; bye with no errors
;Extended Open hooks check
OpenE2: ;AN000;;EO.
CMP AX,error_invalid_parameter ;AN000;;EO. IFS extended open ?
JNZ OpenE ;AN000;;EO. no.
JMP short OpenCritLeave ;AN000;;EO. keep handle
; Extended Open hooks check
;
; AL has error code. Stack has argument to dos_open/dos_create.
OpenClean:
fmt TypSysCall,LevErr,<"Return value from transpath $x\n">,<AX>
RESTORE <bx> ; clean off stack
OpenE:
MOV [SI.SF_Ref_Count],0 ; release SFT
LDS SI,pJFN ;smr;SS Override
MOV BYTE PTR [SI],0FFh ; free the SFN...
JMP SHORT OpenCritLeave
OpenFail:
STI
RESTORE <CX> ; Clean stack
OpenCritLeave:
MOV SFN,-1 ; remove mark.
fmt TypSysCall,LevErr,<"Open/CreateXX: error $x\n">,<AX>
;; File Tagging DOS 4.00
CMP [EXTERR],error_Code_Page_Mismatched ;AN000;;FT. code page mismatch;smr;SS Override
JNZ NORERR ;AN000;;FT. no
transfer From_GetSet ;AN000;;FT. yes
NORERR: ;AN000;
;; File Tagging DOS 4.00
transfer Sys_Ret_Err ; no free, return error
EndProc $Open, NoCheck
BREAK <$Creat - create a brand-new file>
;** $Creat - Create a File
;
; $Creat creates the directory entry specified in DS:DX and gives it the
; initial attributes contained in CX
;
; ENTRY (DS:DX) = ASCIZ path name
; (CX) = initial attributes
; EXIT 'C' set if error
; (ax) = error code
; 'C' clear if OK
; (ax) = file handle
; USES all
Procedure $Creat,NEAR
DOSAssume <SS>,"Creat"
fmt TypSysCall,LevArgs,<"file = '$S'\n">,<DS,DX>
IFDEF DBCS ;AN000;
MOV Temp_Var,CX ;AN000;KK. set variable with attribute ;AN000;smr;SS Override
ENDIF ;AN000;
SAVE <CX> ; Save attributes on stack
MOV CX,OFFSET DOSCODE:DOS_Create; routine to call
AccessSet:
mov SAttrib,attr_hidden+attr_system ;smr;SS Override
JMP AccessFile ; use good ol' open
EndProc $Creat, NoCheck
BREAK <$CHMOD - change file attributes>
;** $CHMOD - Change File Attributes
;
; Assembler usage:
; LDS DX, name
; MOV CX, attributes
; MOV AL,func (0=get, 1=set)
; INT 21h
; Error returns:
; AX = error_path_not_found
; AX = error_access_denied
;
procedure $CHMOD,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
MOV DI,OFFSET DOSDATA:OpenBuf ; appropriate buffer
SAVE <AX,CX> ; save function and attributes
MOV SI,DX ; get things in appropriate places
invoke TransPathSet ; get correct path
RESTORE <CX,AX> ; and get function and attrs back
JC ChModErr ; errors get mapped to path not found
Context DS ; set up for later possible calls
CMP cMeta,-1
JNZ ChModErr
MOV [SAttrib],attr_hidden+attr_system+attr_directory
SUB AL,1 ; fast way to discriminate
JB ChModGet ; 0 -> go get value
JZ ChModSet ; 1 -> go set value
MOV EXTERR_LOCUS,errLoc_Unk ; Extended Error Locus
error error_invalid_function ; bad value
ChModGet:
invoke Get_File_Info ; suck out the ol' info
JC ChModE ; error codes are already set for ret
invoke Get_User_stack ; point to user saved vaiables
assume DS:NOTHING ;smr;PBUGBUG
MOV [SI.User_CX],AX ; return the attributes
transfer Sys_Ret_OK ; say sayonara
ChModSet:
MOV AX,CX ; get attrs in position
invoke Set_File_Attribute ; go set
JC ChModE ; errors are set
transfer Sys_Ret_OK
ChModErr:
mov al,error_path_not_found
ChmodE:
Transfer SYS_RET_ERR
EndProc $ChMod
BREAK <$UNLINK - delete a file entry>
;** $UNLINK - Delete a File
;
;
; Assembler usage:
; LDS DX, name
; IF VIA SERVER DOS CALL
; MOV CX,SEARCH_ATTRIB
; MOV AH, Unlink
; INT 21h
;
; ENTRY (ds:dx) = path name
; (cx) = search_attribute, if via server_dos
; EXIT 'C' clear if no error
; 'C' set if error
; (ax) = error code
; = error_file_not_found
; = error_access_denied
procedure $UNLINK,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <CX> ; Save possible CX input parm
MOV SI,DX ; Point at input string
MOV DI,OFFSET DOSDATA:OpenBuf ; temp spot for path
invoke TransPathSet ; go get normalized path
RESTORE <CX>
JC ChModErr ; badly formed path
CMP cMeta,-1 ; meta chars? ;smr;SS Override
JNZ NotFound
Context DS
mov ch,attr_hidden+attr_system ; unlink appropriate files
call SetAttrib
invoke DOS_Delete ; remove that file
JC UnlinkE ; error is there
transfer Sys_Ret_OK ; okey doksy
NotFound:
MOV AL,error_path_not_found
UnlinkE:
transfer Sys_Ret_Err ; bye
EndProc $UnLink
BREAK <$RENAME - move directory entries around>
;
; Assembler usage:
; LDS DX, source
; LES DI, dest
; IF VIA SERVER DOS CALL
; MOV CX,SEARCH_ATTRIB
; MOV AH, Rename
; INT 21h
;
; Error returns:
; AX = error_file_not_found
; = error_not_same_device
; = error_access_denied
procedure $RENAME,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
SAVE <CX,DS,DX> ; save source and possible CX arg
PUSH ES
POP DS ; move dest to source
MOV SI,DI ; save for offsets
MOV DI,OFFSET DOSDATA:RenBuf
invoke TransPathSet ; munge the paths
PUSH WFP_Start ; get pointer ;smr;SS Override
POP Ren_WFP ; stash it ;smr;SS Override
RESTORE <SI,DS,CX> ; get back source and possible CX arg
epjc2: JC ChModErr ; get old error
CMP cMeta,-1 ;smr;SS Override
JNZ NotFound
SAVE <CX> ; Save possible CX arg
MOV DI,OFFSET DOSDATA:OpenBuf ; appropriate buffer
invoke TransPathSet ; wham
RESTORE <CX>
JC EPJC2
Context DS
CMP cMeta,-1
JB NotFound
PUSH WORD PTR [THISCDS] ;AN000;;MS.save thiscds
PUSH WORD PTR [THISCDS+2] ;AN000;;MS.
MOV DI,OFFSET DOSDATA:OpenBuf ;AN000;;MS.
PUSH SS ;AN000;;MS.
POP ES ;AN000;;MS.es:di-> source
XOR AL,AL ;AN000;;MS.scan all CDS
rnloop: ;AN000;
invoke GetCDSFromDrv ;AN000;;MS.
JC dorn ;AN000;;MS. end of CDS
invoke StrCmp ;AN000;;MS. current dir ?
JZ rnerr ;AN000;;MS. yes
INC AL ;AN000;;MS. next
JMP rnloop ;AN000;;MS.
rnerr: ;AN000;
ADD SP,4 ;AN000;;MS. pop thiscds
error error_current_directory ;AN000;;MS.
dorn: ;AN000;
POP WORD PTR SS:[THISCDS+2] ;AN000;;MS.;PBUGBUG;SS REQD??
POP WORD PTR SS:[THISCDS] ;AN000;;MS.;PBUGBUG;SS REQD??
Context DS
mov ch,attr_directory+attr_hidden+attr_system; rename appropriate files
call SetAttrib
invoke DOS_Rename ; do the deed
JC UnlinkE ; errors
transfer Sys_Ret_OK
EndProc $Rename
Break <$CreateNewFile - Create a new directory entry>
;
; CreateNew - Create a new directory entry. Return a file handle if there
; was no previous directory entry, and fail if a directory entry with
; the same name existed previously.
;
; Inputs: DS:DX point to an ASCIZ file name
; CX contains default file attributes
; Outputs: Carry Clear:
; AX has file handle opened for read/write
; Carry Set:
; AX has error code
; Registers modified: All
Procedure $CreateNewFile,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
fmt TypSysCall,LevArgs,<" Att = $x file = '$S'\n">,<CX,DS,DX>
IFDEF DBCS ;AN000;
MOV Temp_Var,CX ;AN000;KK. set variable with attribute;smr;SS Override
ENDIF ;AN000;
SAVE <CX> ; Save attributes on stack
MOV CX,OFFSET DOSCODE:DOS_Create_New ; routine to call
JMP AccessSet ; use good ol' open
EndProc $CreateNewFile, NoCheck
Break <BinToAscii - convert a number to a string>
;** BinToAscii - conver a number to a string.
;
; BinToAscii converts a 16 bit number into a 4 ascii characters.
; This routine is used to generate temp file names so we don't spend
; the time and code needed for a true hex number, we just use
; A thorugh O.
;
; ENTRY (ax) = value
; (es:di) = destination
; EXIT (es:di) updated by 4
; USES cx, di, flags
Procedure BinToAscii,NEAR
mov cx,404h ; (ch) = digit counter, (cl) = shift cnt
bta5: ROL AX,CL ; move leftmost nibble into rightmost
SAVE <AX> ; preserve remainder of digits
AND AL,0Fh ; grab low nibble
ADD AL,'A' ; turn into ascii
STOSB ; drop in the character
RESTORE <AX> ; (ax) = shifted number
dec ch
jnz bta5 ; process 4 digits
return
EndProc BinToAscii
Break <$CreateTempFile - create a unique name>
;
; $CreateTemp - given a directory, create a unique name in that directory.
; Method used is to get the current time, convert to a name and attempt
; a create new. Repeat until create new succeeds.
;
; Inputs: DS:DX point to a null terminated directory name.
; CX contains default attributes
; Outputs: Unique name is appended to DS:DX directory.
; AX has handle
; Registers modified: all
Procedure $CreateTempFile,NEAR
ASSUME CS:DOSCODE,SS:DOSDATA
fmt TypSysCall,LevArgs,<" Att = $x dir = '$S'\n">,<CX,DS,DX>
PUBLIC FILE001S,FILE001E
FILE001S:
LocalVar EndPtr,DWORD
LocalVar FilPtr,DWORD
LocalVar Attr,WORD
FILE001E:
Enter
TEST CX,NOT attr_changeable
JZ OKatts ; Ok if no non-changeable bits set
;
; We need this "hook" here to detect these cases (like user sets one both of
; vol_id and dir bits) because of the structure of the or $CreateNewFile loop
; below. The code loops on error_access_denied, but if one of the non
; changeable attributes is specified, the loop COULD be infinite or WILL be
; infinite because CreateNewFile will fail with access_denied always. Thus we
; need to detect these cases before getting to the loop.
;
MOV AX,error_access_denied
JMP SHORT SETTMPERR
OKatts:
MOV attr,CX ; save attribute
MOV FilPtrL,DX ; pointer to file
MOV FilPtrH,DS
MOV EndPtrH,DS ; seg pointer to end of dir
PUSH DS
POP ES ; destination for nul search
MOV DI,DX
MOV CX,DI
NEG CX ; number of bytes remaining in segment
IFDEF DBCS ;AN000;
Kloop: ;AN000;; 2/13/KK
MOV AL, BYTE PTR ES:[DI] ;AN000;; 2/13/KK
INC DI ;AN000;; 2/13/KK
OR AL,AL ;AN000;; 2/13/KK
JZ GOTEND ;AN000;; 2/13/KK
invoke testkanj ;AN000;; 2/13/KK
jz Kloop ;AN000;; 2/13/KK
inc di ;AN000;; Skip over second kanji byte 2/13/KK
CMP BYTE PTR ES:[DI],0 ;AN000;; 2/13/KK
JZ STOREPTH ;AN000; When char before NUL is sec Kanji byte
;AN000; do not look for path char. 2/13/KK
jmp Kloop ;AN000; 2/13/KK
GOTEND: ;AN000; 2/13/KK
ELSE ;AN000;
OR CX,CX ;AN000;MS. cx=0 ? ds:dx on segment boundary
JNZ okok ;AN000;MS. no
MOV CX,-1 ;AN000;MS.
okok: ;AN000;
XOR AX,AX ;AN000;
REPNZ SCASB ;AN000;
ENDIF ;AN000;
DEC DI ; point back to the null
MOV AL,ES:[DI-1] ; Get char before the NUL
invoke PathChrCmp ; Is it a path separator?
JZ SETENDPTR ; Yes
STOREPTH:
MOV AL,'\'
STOSB ; Add a path separator (and INC DI)
SETENDPTR:
MOV EndPtrL,DI ; pointer to the tail
CreateLoop:
Context DS ; let ReadTime see variables
SAVE <BP>
invoke ReadTime ; go get time
RESTORE <BP>
;
; Time is in CX:DX. Go drop it into the string.
;
les di,EndPtr ; point to the string
mov ax,cx
call BinToAscii ; store upper word
mov ax,dx
call BinToAscii ; store lower word
xor al,al
STOSB ; nul terminate
LDS DX,FilPtr ; get name
ASSUME DS:NOTHING
MOV CX,Attr ; get attr
SAVE <BP>
CALL $CreateNewFile ; try to create a new file
RESTORE <BP>
JNC CreateDone ; failed, go try again
;
; The operation failed and the error has been mapped in AX. Grab the extended
; error and figure out what to do.
;
; M049 - start
;; mov ax,ExtErr ;smr;SS Override
;; cmp al,error_file_exists
;; jz CreateLoop ; file existed => try with new name
;; cmp al,error_access_denied
;; jz CreateLoop ; access denied (attr mismatch)
CMP AL,error_file_exists ; Q: did file already exist
JZ CreateLoop ; Y: try again
CMP AL,error_access_denied ; Q: was it access denied
JNZ SETTMPERR ; N: Error out
; Y: Check to see if we got this due
; to the network drive. Note that
; the redir will set the exterr
; to error_cannot_make if this is
; so.
CMP [EXTERR],error_net_access_denied ; M069
; See if it's REALLY an att mismatch
je SetTmpErr ; no, network error, stop
;M070
; If the user failed on an I24, we do not want to try again
;
cmp ExtErr,error_FAIL_I24 ;User failed on I24? ;M070
je SetTmpErr ;yes, do not try again ;M070
jmp short CreateLoop ;attr mismatch, try again ;M070
;; MOV AL,error_access_denied ; Return this "extended" error
; M049 - end
SETTMPERR:
STC
CreateDone:
Leave
JC CreateFail
transfer Sys_Ret_OK ; success!
CreateFail:
transfer Sys_Ret_Err
EndProc $CreateTempFile
Break <SetAttrib - set the search attrib>
;
; SetAttrib will set the search attribute (SAttrib) either to the normal
; (CH) or to the value in CL if the current system call is through
; serverdoscall.
;
; Inputs: fSharing == FALSE => set sattrib to CH
; fSharing == TRUE => set sattrib to CL
; Outputs: none
; Registers changed: CX
procedure SetAttrib,NEAR
assume SS:DOSDATA ;smr;
test fSharing,-1 ;smr;SS Override
jnz Set
mov cl,ch
Set:
mov SAttrib,cl ;smr;SS Override
return
EndProc SetAttrib
Break <Extended_Open- Extended open the file>
; Input: AL= 0 reserved AH=6CH
; BX= mode
; CL= create attribute CH=search attribute (from server)
; DX= flag
; DS:SI = file name
; ES:DI = parm list
; DD SET EA list (-1) null
; DW n parameters
; DB type (TTTTTTLL)
; DW IOMODE
; Function: Extended Open
; Output: carry clear
; AX= handle
; CX=1 file opened
; 2 file created/opened
; 3 file replaced/opened
; carry set: AX has error code
;
procedure $Extended_Open,NEAR ;AN000;
ASSUME CS:DOSCODE,SS:DOSDATA ;AN000;
MOV [EXTOPEN_FLAG],DX ;AN000;EO. save ext. open flag;smr;SS Override
MOV [EXTOPEN_IO_MODE],0 ;AN000;EO. initialize IO mode;smr;SS Override
TEST DX,reserved_bits_mask ;AN000;EO. reserved bits 0 ?
JNZ ext_inval2 ;AN000;EO. no
MOV AH,DL ;AN000;EO. make sure flag is right
CMP DL,0 ;AN000;EO. all fail ?
JZ ext_inval2 ;AN000;EO. yes, error
AND DL,exists_mask ;AN000;EO. get exists action byte
CMP DL,2 ;AN000;EO, > 02
JA ext_inval2 ;AN000;EO. yes ,error
AND AH,not_exists_mask ;AN000;EO. get no exists action byte
CMP AH,10H ;AN000;EO. > 10
JA ext_inval2 ;AN000;EO. yes error
; CMP DI,-1 ;AN000;EO. null parm list
; JZ no_parm ;AN000;EO. yes
; ;AN000;EO
; PUSH CX ;AN000;EO.
; ;AN000;EO.
; MOV CX,ES:[DI.EXT_NUM_OF_PARM];AN000;EO. get number of parms
; OR CX,CX ;AN000;EO. 0 pamrs ?
; JZ parmend ;AN000;EO. yes
; PUSH SI ;AN000;EO.
; PUSH DS ;AN000;EO.
; MOV SI,DI ;AN000;EO.
; ADD SI,size EXT_OPEN_PARM ;AN000;EO. position to 1st parm
; PUSH ES ;AN000;EO.
; POP DS ;AN000;EO. ds:si -> parm list
; CALL GetIOParms ;AN000;EO.
; POP DS ;AN000;EO.
; POP SI ;AN000;EO.
;parmend: ;AN000;EO
; POP CX ;AN000;EO. restore CX
;no_parm: ;AN000;EO.
MOV [SAVE_ES],ES ;AN000;EO. save API parms;smr;SS Override
MOV [SAVE_DI],DI ;AN000;EO.;smr;SS Override
PUSH [EXTOPEN_FLAG] ;AN000;EO.;smr;SS Override
POP [SAVE_DX] ;AN000;EO.;smr;SS Override
MOV [SAVE_CX],CX ;AN000;EO.;smr;SS Override
MOV [SAVE_BX],BX ;AN000;EO.;smr;SS Override
MOV [SAVE_DS],DS ;AN000;EO.;smr;SS Override
MOV [SAVE_SI],SI ;AN000;EO.;smr;SS Override
MOV DX,SI ;AN000;EO. ds:dx points to file name
MOV AX,BX ;AN000;EO. ax= mode
; TEST [EXTOPEN_FLAG],no_code_page_check ;AN000;EO. check no code page
; JNZ no_cdpg_chk ;AN000;;EO. no
JMP SHORT goopen2 ;AN000;;EO. do nromal
ext_inval2: ;AN000;;EO.
error error_Invalid_Function ;AN000;EO.. invalid function
ext_inval_parm: ;AN000;EO..
POP CX ;AN000;EO.. pop up satck
POP SI ;AN000;EO..
error error_Invalid_data ;AN000;EO.. invalid parms
error_return: ;AN000;EO.
ret ;AN000;EO.. return with error
;no_cdpg_chk: EO.
; MOV [CPSWFLAG],0 ;AN000;EO.. set CPSW flag off
goopen2: ;AN000;
TEST BX,int_24_error ;AN000;EO.. disable INT 24 error ?
JZ goopen ;AN000;EO.. no
OR [EXTOPEN_ON],EXT_OPEN_I24_OFF ;AN000;EO.. set bit to disable;smr;SS Override
goopen: ;AN000;
OR [EXTOPEN_ON],EXT_OPEN_ON ;AN000;EO.. set Extended Open active;smr;SS Override
AND [EXTOPEN_FLAG],0FFH ;AN000;EO.create new ?;smr;SS Override
CMP [EXTOPEN_FLAG],ext_exists_fail + ext_nexists_create ;AN000;FT.;smr;SS Override
JNZ chknext ;AN000;;EO. no
invoke $CreateNewFile ;AN000;;EO. yes
JC error_return ;AN000;;EO. error
CMP [EXTOPEN_ON],0 ;AN000;;EO. IFS does it;smr;SS Override
JZ ok_return2 ;AN000;;EO. yes
MOV [EXTOPEN_FLAG],action_created_opened ;AN000;EO. creted/opened;smr;SS Override
JMP setXAttr ;AN000;;EO. set XAs
ok_return2:
transfer SYS_RET_OK ;AN000;;EO.
chknext:
TEST [EXTOPEN_FLAG],ext_exists_open ;AN000;;EO. exists open;smr;SS Override
JNZ exist_open ;AN000;;EO. yes
invoke $Creat ;AN000;;EO. must be replace open
JC error_return ;AN000;;EO. return with error
CMP [EXTOPEN_ON],0 ;AN000;;EO. IFS does it;smr;SS Override
JZ ok_return2 ;AN000;;EO. yes
MOV [EXTOPEN_FLAG],action_created_opened ;AN000;EO. prsume create/open;smr;SS Override
TEST [EXTOPEN_ON],ext_file_not_exists ;AN000;;EO. file not exists ?;smr;SS Override
JNZ setXAttr ;AN000;;EO. no
MOV [EXTOPEN_FLAG],action_replaced_opened ;AN000;;EO. replaced/opened;smr;SS Override
JMP SHORT setXAttr ;AN000;;EO. set XAs
error_return2:
STC ; Set Carry again to flag error ;AN001;
ret ;AN000;;EO. return with error
;AN000;
exist_open: ;AN000;
test fSharing,-1 ;AN000;;EO. server doscall?;smr;SS Override
jz noserver ;AN000;;EO. no
MOV CL,CH ;AN000;;EO. cl=search attribute
noserver:
call $Open2 ;AN000;;EO. do open
JNC ext_ok ;AN000;;EO.
CMP [EXTOPEN_ON],0 ;AN000;;EO. error and IFS call;smr;SS Override
JZ error_return2 ;AN000;;EO. return with error
local_extopen:
CMP AX,error_file_not_found ;AN000;;EO. file not found error
JNZ error_return2 ;AN000;;EO. no,
TEST [EXTOPEN_FLAG],ext_nexists_create;AN000;;EO. want to fail;smr;SS Override
JNZ do_creat ;AN000;;EO. yes
JMP short extexit ;AN000;;EO. yes
do_creat:
MOV CX,[SAVE_CX] ;AN000;;EO. get ds:dx for file name;smr;SS Override
LDS SI,DWORD PTR [SAVE_SI] ;AN000;;EO. cx = attribute;smr;SS Override
MOV DX,SI ;AN000;;EO.
invoke $Creat ;AN000;;EO. do create
JC extexit ;AN000;;EO. error
MOV [EXTOPEN_FLAG],action_created_opened ;AN000;;EO. is created/opened;smr;SS Override
JMP SHORT setXAttr ;AN000;;EO. set XAs
ext_ok:
CMP [EXTOPEN_ON],0 ;AN000;;EO. IFS call ?;smr;SS Override
JZ ok_return ;AN000;;EO. yes
MOV [EXTOPEN_FLAG],action_opened ;AN000;;EO. opened;smr;SS Override
setXAttr:
; LES DI,DWORD PTR [SAVE_DI] ;AN000;EO.
PUSH AX ;AN000;;EO. save handle for final
; MOV BX,AX ;AN000;;EO. bx= handle
; MOV AX,04H ;AN000;;EO. set extended attr by handle
; PUSH DS ;AN000;;EO. save file name addr
; PUSH DX ;AN000;;EO.
; CMP DI,-1 ;AN000;;EO. null parm list
; JZ nosetea ;AN000;;EO. yes
; CMP WORD PTR ES:[DI],-1 ;AN000;;EO. null set list
; JZ nosetea ;AN000;;EO. yes
; LES DI,DWORD PTR ES:[DI] ;AN000;;EO. es:di -> set list
; invoke $File_times ;AN000;;EO.
;nosetea: ;AN000; EO
; POP DX ;AN000;;EO. restore file name addr
; POP DS ;AN000;;EO.
; JC extexit2 ;AN000;;EO.
invoke get_user_stack ;AN000;;EO.
MOV AX,[EXTOPEN_FLAG] ;AN000;;EO.;smr;SS Override
MOV [SI.USER_CX],AX ;AN000;;EO. set action code for cx
POP AX ;AN000;;EO.
MOV [SI.USER_AX],AX ;AN000;;EO. set handle for ax
ok_return: ;AN000;
transfer SYS_RET_OK ;AN000;;EO.
extexit2: ;AN000; ERROR RECOVERY
POP BX ;AN000;EO. close the handle
PUSH AX ;AN000;EO. save error code from set XA
CMP [EXTOPEN_FLAG],action_created_opened ;AN000;EO. from create;smr;SS Override
JNZ justopen ;AN000;EO.
LDS SI,DWORD PTR [SAVE_SI] ;AN000;EO. cx = attribute;smr;SS Override
LDS DX,DWORD PTR [SI] ;AN000;EO.
invoke $UNLINK ;AN000;EO. delete the file
JMP SHORT reserror ;AN000;EO.
justopen: ;AN000;
invoke $close ;AN000;EO. pretend never happend
reserror: ;AN000;
POP AX ;AN000;EO. retore error code from set XA
JMP SHORT extexit ;AN000;EO.
ext_file_unfound: ;AN000;
MOV AX,error_file_not_found ;AN000;EO.
JMP SHORT extexit ;AN000;EO.
ext_inval: ;AN000;
MOV AX,error_invalid_function;AN000;EO.
extexit:
transfer SYS_RET_ERR ;AN000;EO.
EndProc $Extended_Open ;AN000;
Break <GetIOParms - get IO parms form extended open parm list>
;
;
; Inputs: DS:SI -> IO parm list
; CX= number of parms
; Function: get IO parms from parm list
; Outputs: [EXT_IOMODE]= IO mode parm
;procedure GetIOParms,NEAR
;
; LODSB ; get parm type ;AN000;
; CMP AL,0*100B+10B ; have IOMODE ;AN000;
; JE SET_IOMODE ;AN000;
; AND AL,00000011B ; decode it ;AN000;
; JZ SKIP_ASCIIZ ;AN000;
; DEC AL ;AN000;
; JZ SKIP_LEN ;AN000;
;; DEC AL ;AN000;
; JZ SKIP_WORD ;AN000;
;SKIP_DWORD: ; copy DWORD parm ;AN000;
; LODSW ;AN000;
;SKIP_WORD: ; copy WORD parm ;AN000;
; LODSW ;AN000;
; JMP SHORT NEXT_PARM ;AN000;
;SET_IOMODE: ; copy IOMODE ;AN000;
; LODSW ;AN000;
; MOV [EXTOPEN_IO_MODE],AX ;AN000;
; JMP SHORT NEXT_PARM ;AN000;
;SKIP_LEN: ; copy LENGTH parm ;AN000;
; LODSW ;AN000;
; ADD SI,AX ;AN000;
; JMP SHORT NEXT_PARM ;AN000;
;SKIP_ASCIIZ: ; copy ASCIIZ parm ;AN000;
; LODSB ;AN000;
; OR AL,AL ;AN000;
; JNE SKIP_ASCIIZ ;AN000;
;NEXT_PARM: ;AN000;
; LOOP GetIOParms ;AN000;
; return ;AN000;
;EndProc GetIOParms ;AN000;
DOSCODE ENDS
END
| 30.580882
| 89
| 0.688352
|
f65763a1b157dd0f75f0df1653e4b94c1a4322e5
| 58,864
|
asm
|
Assembly
|
target/cos_117/disasm/iop_overlay1/COMM05.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/COMM05.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/COMM05.asm
|
jrrk2/cray-sim
|
52c9639808d6890517092637b188282c00cce4f7
|
[
"BSL-1.0"
] | 6
|
2021-04-12T06:10:32.000Z
|
2022-02-08T23:11:19.000Z
|
0x0000 (0x000000) 0x211C- f:00020 d: 284 | A = OR[284]
0x0001 (0x000002) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x0002 (0x000004) 0x2922- f:00024 d: 290 | OR[290] = A
0x0003 (0x000006) 0x102C- f:00010 d: 44 | A = 44 (0x002C)
0x0004 (0x000008) 0x2913- f:00024 d: 275 | OR[275] = A
0x0005 (0x00000A) 0x2113- f:00020 d: 275 | A = OR[275]
0x0006 (0x00000C) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0007 (0x00000E) 0x290D- f:00024 d: 269 | OR[269] = A
0x0008 (0x000010) 0x2122- f:00020 d: 290 | A = OR[290]
0x0009 (0x000012) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x000A (0x000014) 0x2519- f:00022 d: 281 | A = A + OR[281]
0x000B (0x000016) 0x290E- f:00024 d: 270 | OR[270] = A
0x000C (0x000018) 0x2122- f:00020 d: 290 | A = OR[290]
0x000D (0x00001A) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x000E (0x00001C) 0x2908- f:00024 d: 264 | OR[264] = A
0x000F (0x00001E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0010 (0x000020) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0011 (0x000022) 0x8607- f:00103 d: 7 | P = P + 7 (0x0018), A # 0
0x0012 (0x000024) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0013 (0x000026) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0014 (0x000028) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0015 (0x00002A) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0016 (0x00002C) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0017 (0x00002E) 0x7006- f:00070 d: 6 | P = P + 6 (0x001D)
0x0018 (0x000030) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0019 (0x000032) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x001B (0x000036) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x001C (0x000038) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x001D (0x00003A) 0x2104- f:00020 d: 260 | A = OR[260]
0x001E (0x00003C) 0x290D- f:00024 d: 269 | OR[269] = A
0x001F (0x00003E) 0x2104- f:00020 d: 260 | A = OR[260]
0x0020 (0x000040) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0021 (0x000042) 0x1A00-0xFFFC f:00015 d: 0 | A = A & 65532 (0xFFFC)
0x0023 (0x000046) 0x2904- f:00024 d: 260 | OR[260] = A
0x0024 (0x000048) 0x2104- f:00020 d: 260 | A = OR[260]
0x0025 (0x00004A) 0x291E- f:00024 d: 286 | OR[286] = A
0x0026 (0x00004C) 0x1014- f:00010 d: 20 | A = 20 (0x0014)
0x0027 (0x00004E) 0x2B04- f:00025 d: 260 | OR[260] = A + OR[260]
0x0028 (0x000050) 0x2104- f:00020 d: 260 | A = OR[260]
0x0029 (0x000052) 0x2705- f:00023 d: 261 | A = A - OR[261]
0x002A (0x000054) 0xB234- f:00131 d: 52 | R = OR[52], C = 1
0x002B (0x000056) 0x000B- f:00000 d: 11 | PASS | **** non-standard encoding with D:0x000B ****
0x002C (0x000058) 0x210D- f:00020 d: 269 | A = OR[269]
0x002D (0x00005A) 0x3904- f:00034 d: 260 | (OR[260]) = A
0x002E (0x00005C) 0x2D04- f:00026 d: 260 | OR[260] = OR[260] + 1
0x002F (0x00005E) 0x211E- f:00020 d: 286 | A = OR[286]
0x0030 (0x000060) 0x2925- f:00024 d: 293 | OR[293] = A
0x0031 (0x000062) 0x211D- f:00020 d: 285 | A = OR[285]
0x0032 (0x000064) 0x251C- f:00022 d: 284 | A = A + OR[284]
0x0033 (0x000066) 0x2913- f:00024 d: 275 | OR[275] = A
0x0034 (0x000068) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x0035 (0x00006A) 0x2926- f:00024 d: 294 | OR[294] = A
0x0036 (0x00006C) 0x1800-0x012A f:00014 d: 0 | A = 298 (0x012A)
0x0038 (0x000070) 0x2927- f:00024 d: 295 | OR[295] = A
0x0039 (0x000072) 0x2119- f:00020 d: 281 | A = OR[281]
0x003A (0x000074) 0x2928- f:00024 d: 296 | OR[296] = A
0x003B (0x000076) 0x211A- f:00020 d: 282 | A = OR[282]
0x003C (0x000078) 0x2929- f:00024 d: 297 | OR[297] = A
0x003D (0x00007A) 0x2113- f:00020 d: 275 | A = OR[275]
0x003E (0x00007C) 0x292A- f:00024 d: 298 | OR[298] = A
0x003F (0x00007E) 0x1800-0x0264 f:00014 d: 0 | A = 612 (0x0264)
0x0041 (0x000082) 0x292B- f:00024 d: 299 | OR[299] = A
0x0042 (0x000084) 0x211E- f:00020 d: 286 | A = OR[286]
0x0043 (0x000086) 0x292C- f:00024 d: 300 | OR[300] = A
0x0044 (0x000088) 0x1015- f:00010 d: 21 | A = 21 (0x0015)
0x0045 (0x00008A) 0x292D- f:00024 d: 301 | OR[301] = A
0x0046 (0x00008C) 0x1015- f:00010 d: 21 | A = 21 (0x0015)
0x0047 (0x00008E) 0x292E- f:00024 d: 302 | OR[302] = A
0x0048 (0x000090) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x0049 (0x000092) 0x5800- f:00054 d: 0 | B = A
0x004A (0x000094) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x004C (0x000098) 0x7C09- f:00076 d: 9 | R = OR[9]
0x004D (0x00009A) 0x2921- f:00024 d: 289 | OR[289] = A
0x004E (0x00009C) 0x103D- f:00010 d: 61 | A = 61 (0x003D)
0x004F (0x00009E) 0x2913- f:00024 d: 275 | OR[275] = A
0x0050 (0x0000A0) 0x2113- f:00020 d: 275 | A = OR[275]
0x0051 (0x0000A2) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0052 (0x0000A4) 0x290D- f:00024 d: 269 | OR[269] = A
0x0053 (0x0000A6) 0x2122- f:00020 d: 290 | A = OR[290]
0x0054 (0x0000A8) 0x0801- f:00004 d: 1 | A = A > 1 (0x0001)
0x0055 (0x0000AA) 0x2519- f:00022 d: 281 | A = A + OR[281]
0x0056 (0x0000AC) 0x290E- f:00024 d: 270 | OR[270] = A
0x0057 (0x0000AE) 0x2122- f:00020 d: 290 | A = OR[290]
0x0058 (0x0000B0) 0x1201- f:00011 d: 1 | A = A & 1 (0x0001)
0x0059 (0x0000B2) 0x2908- f:00024 d: 264 | OR[264] = A
0x005A (0x0000B4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x005B (0x0000B6) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x005C (0x0000B8) 0x8607- f:00103 d: 7 | P = P + 7 (0x0063), A # 0
0x005D (0x0000BA) 0x310E- f:00030 d: 270 | A = (OR[270])
0x005E (0x0000BC) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x005F (0x0000BE) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0060 (0x0000C0) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0061 (0x0000C2) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0062 (0x0000C4) 0x7006- f:00070 d: 6 | P = P + 6 (0x0068)
0x0063 (0x0000C6) 0x310E- f:00030 d: 270 | A = (OR[270])
0x0064 (0x0000C8) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x0066 (0x0000CC) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0067 (0x0000CE) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0068 (0x0000D0) 0x2121- f:00020 d: 289 | A = OR[289]
0x0069 (0x0000D2) 0xAE03-0x0309 f:00127 d: 3 | P = OR[3]+777 (0x0309), A # 0
0x006B (0x0000D6) 0x2104- f:00020 d: 260 | A = OR[260]
0x006C (0x0000D8) 0x290D- f:00024 d: 269 | OR[269] = A
0x006D (0x0000DA) 0x2104- f:00020 d: 260 | A = OR[260]
0x006E (0x0000DC) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x006F (0x0000DE) 0x1A00-0xFFFC f:00015 d: 0 | A = A & 65532 (0xFFFC)
0x0071 (0x0000E2) 0x2904- f:00024 d: 260 | OR[260] = A
0x0072 (0x0000E4) 0x2104- f:00020 d: 260 | A = OR[260]
0x0073 (0x0000E6) 0x291F- f:00024 d: 287 | OR[287] = A
0x0074 (0x0000E8) 0x102C- f:00010 d: 44 | A = 44 (0x002C)
0x0075 (0x0000EA) 0x2B04- f:00025 d: 260 | OR[260] = A + OR[260]
0x0076 (0x0000EC) 0x2104- f:00020 d: 260 | A = OR[260]
0x0077 (0x0000EE) 0x2705- f:00023 d: 261 | A = A - OR[261]
0x0078 (0x0000F0) 0xB234- f:00131 d: 52 | R = OR[52], C = 1
0x0079 (0x0000F2) 0x000B- f:00000 d: 11 | PASS | **** non-standard encoding with D:0x000B ****
0x007A (0x0000F4) 0x210D- f:00020 d: 269 | A = OR[269]
0x007B (0x0000F6) 0x3904- f:00034 d: 260 | (OR[260]) = A
0x007C (0x0000F8) 0x2D04- f:00026 d: 260 | OR[260] = OR[260] + 1
0x007D (0x0000FA) 0x211F- f:00020 d: 287 | A = OR[287]
0x007E (0x0000FC) 0x290E- f:00024 d: 270 | OR[270] = A
0x007F (0x0000FE) 0x102C- f:00010 d: 44 | A = 44 (0x002C)
0x0080 (0x000100) 0x290D- f:00024 d: 269 | OR[269] = A
0x0081 (0x000102) 0x210D- f:00020 d: 269 | A = OR[269]
0x0082 (0x000104) 0x8406- f:00102 d: 6 | P = P + 6 (0x0088), A = 0
0x0083 (0x000106) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0084 (0x000108) 0x390E- f:00034 d: 270 | (OR[270]) = A
0x0085 (0x00010A) 0x2F0D- f:00027 d: 269 | OR[269] = OR[269] - 1
0x0086 (0x00010C) 0x2D0E- f:00026 d: 270 | OR[270] = OR[270] + 1
0x0087 (0x00010E) 0x7206- f:00071 d: 6 | P = P - 6 (0x0081)
0x0088 (0x000110) 0x311E- f:00030 d: 286 | A = (OR[286])
0x0089 (0x000112) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x008A (0x000114) 0x2913- f:00024 d: 275 | OR[275] = A
0x008B (0x000116) 0x211E- f:00020 d: 286 | A = OR[286]
0x008C (0x000118) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x008D (0x00011A) 0x2908- f:00024 d: 264 | OR[264] = A
0x008E (0x00011C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x008F (0x00011E) 0x2914- f:00024 d: 276 | OR[276] = A
0x0090 (0x000120) 0x211E- f:00020 d: 286 | A = OR[286]
0x0091 (0x000122) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x0092 (0x000124) 0x2908- f:00024 d: 264 | OR[264] = A
0x0093 (0x000126) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0094 (0x000128) 0x2915- f:00024 d: 277 | OR[277] = A
0x0095 (0x00012A) 0x211E- f:00020 d: 286 | A = OR[286]
0x0096 (0x00012C) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x0097 (0x00012E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0098 (0x000130) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0099 (0x000132) 0x2916- f:00024 d: 278 | OR[278] = A
0x009A (0x000134) 0x211E- f:00020 d: 286 | A = OR[286]
0x009B (0x000136) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x009C (0x000138) 0x2908- f:00024 d: 264 | OR[264] = A
0x009D (0x00013A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x009E (0x00013C) 0x2917- f:00024 d: 279 | OR[279] = A
0x009F (0x00013E) 0x2113- f:00020 d: 275 | A = OR[275]
0x00A0 (0x000140) 0x1605- f:00013 d: 5 | A = A - 5 (0x0005)
0x00A1 (0x000142) 0x8402- f:00102 d: 2 | P = P + 2 (0x00A3), A = 0
0x00A2 (0x000144) 0x7039- f:00070 d: 57 | P = P + 57 (0x00DB)
0x00A3 (0x000146) 0x211F- f:00020 d: 287 | A = OR[287]
0x00A4 (0x000148) 0x140E- f:00012 d: 14 | A = A + 14 (0x000E)
0x00A5 (0x00014A) 0x2908- f:00024 d: 264 | OR[264] = A
0x00A6 (0x00014C) 0x2114- f:00020 d: 276 | A = OR[276]
0x00A7 (0x00014E) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00A8 (0x000150) 0x211F- f:00020 d: 287 | A = OR[287]
0x00A9 (0x000152) 0x140F- f:00012 d: 15 | A = A + 15 (0x000F)
0x00AA (0x000154) 0x2908- f:00024 d: 264 | OR[264] = A
0x00AB (0x000156) 0x2115- f:00020 d: 277 | A = OR[277]
0x00AC (0x000158) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x00AD (0x00015A) 0x2114- f:00020 d: 276 | A = OR[276]
0x00AE (0x00015C) 0x1E00-0x4141 f:00017 d: 0 | A = A - 16705 (0x4141)
0x00B0 (0x000160) 0x8406- f:00102 d: 6 | P = P + 6 (0x00B6), A = 0
0x00B1 (0x000162) 0x2114- f:00020 d: 276 | A = OR[276]
0x00B2 (0x000164) 0x1E00-0x4242 f:00017 d: 0 | A = A - 16962 (0x4242)
0x00B4 (0x000168) 0x8402- f:00102 d: 2 | P = P + 2 (0x00B6), A = 0
0x00B5 (0x00016A) 0x700E- f:00070 d: 14 | P = P + 14 (0x00C3)
0x00B6 (0x00016C) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x00B7 (0x00016E) 0x1603- f:00013 d: 3 | A = A - 3 (0x0003)
0x00B8 (0x000170) 0x8405- f:00102 d: 5 | P = P + 5 (0x00BD), A = 0
0x00B9 (0x000172) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x00BA (0x000174) 0x1604- f:00013 d: 4 | A = A - 4 (0x0004)
0x00BB (0x000176) 0x8402- f:00102 d: 2 | P = P + 2 (0x00BD), A = 0
0x00BC (0x000178) 0x7004- f:00070 d: 4 | P = P + 4 (0x00C0)
0x00BD (0x00017A) 0x1020- f:00010 d: 32 | A = 32 (0x0020)
0x00BE (0x00017C) 0x2920- f:00024 d: 288 | OR[288] = A
0x00BF (0x00017E) 0x7003- f:00070 d: 3 | P = P + 3 (0x00C2)
0x00C0 (0x000180) 0x1018- f:00010 d: 24 | A = 24 (0x0018)
0x00C1 (0x000182) 0x2920- f:00024 d: 288 | OR[288] = A
0x00C2 (0x000184) 0x7013- f:00070 d: 19 | P = P + 19 (0x00D5)
0x00C3 (0x000186) 0x2114- f:00020 d: 276 | A = OR[276]
0x00C4 (0x000188) 0x1E00-0x5050 f:00017 d: 0 | A = A - 20560 (0x5050)
0x00C6 (0x00018C) 0x8402- f:00102 d: 2 | P = P + 2 (0x00C8), A = 0
0x00C7 (0x00018E) 0x7004- f:00070 d: 4 | P = P + 4 (0x00CB)
0x00C8 (0x000190) 0x1018- f:00010 d: 24 | A = 24 (0x0018)
0x00C9 (0x000192) 0x2920- f:00024 d: 288 | OR[288] = A
0x00CA (0x000194) 0x700B- f:00070 d: 11 | P = P + 11 (0x00D5)
0x00CB (0x000196) 0x2114- f:00020 d: 276 | A = OR[276]
0x00CC (0x000198) 0x1E00-0x564C f:00017 d: 0 | A = A - 22092 (0x564C)
0x00CE (0x00019C) 0x8402- f:00102 d: 2 | P = P + 2 (0x00D0), A = 0
0x00CF (0x00019E) 0x7004- f:00070 d: 4 | P = P + 4 (0x00D3)
0x00D0 (0x0001A0) 0x1007- f:00010 d: 7 | A = 7 (0x0007)
0x00D1 (0x0001A2) 0x2920- f:00024 d: 288 | OR[288] = A
0x00D2 (0x0001A4) 0x7003- f:00070 d: 3 | P = P + 3 (0x00D5)
0x00D3 (0x0001A6) 0x1040- f:00010 d: 64 | A = 64 (0x0040)
0x00D4 (0x0001A8) 0x2920- f:00024 d: 288 | OR[288] = A
0x00D5 (0x0001AA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00D6 (0x0001AC) 0x2916- f:00024 d: 278 | OR[278] = A
0x00D7 (0x0001AE) 0x1800-0x4352 f:00014 d: 0 | A = 17234 (0x4352)
0x00D9 (0x0001B2) 0x2917- f:00024 d: 279 | OR[279] = A
0x00DA (0x0001B4) 0x703A- f:00070 d: 58 | P = P + 58 (0x0114)
0x00DB (0x0001B6) 0x2113- f:00020 d: 275 | A = OR[275]
0x00DC (0x0001B8) 0x1609- f:00013 d: 9 | A = A - 9 (0x0009)
0x00DD (0x0001BA) 0x8402- f:00102 d: 2 | P = P + 2 (0x00DF), A = 0
0x00DE (0x0001BC) 0x700A- f:00070 d: 10 | P = P + 10 (0x00E8)
0x00DF (0x0001BE) 0x2116- f:00020 d: 278 | A = OR[278]
0x00E0 (0x0001C0) 0x2914- f:00024 d: 276 | OR[276] = A
0x00E1 (0x0001C2) 0x2117- f:00020 d: 279 | A = OR[279]
0x00E2 (0x0001C4) 0x2915- f:00024 d: 277 | OR[277] = A
0x00E3 (0x0001C6) 0x1040- f:00010 d: 64 | A = 64 (0x0040)
0x00E4 (0x0001C8) 0x2920- f:00024 d: 288 | OR[288] = A
0x00E5 (0x0001CA) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x00E6 (0x0001CC) 0x2916- f:00024 d: 278 | OR[278] = A
0x00E7 (0x0001CE) 0x701A- f:00070 d: 26 | P = P + 26 (0x0101)
0x00E8 (0x0001D0) 0x2113- f:00020 d: 275 | A = OR[275]
0x00E9 (0x0001D2) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x00EA (0x0001D4) 0x8402- f:00102 d: 2 | P = P + 2 (0x00EC), A = 0
0x00EB (0x0001D6) 0x7016- f:00070 d: 22 | P = P + 22 (0x0101)
0x00EC (0x0001D8) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x00ED (0x0001DA) 0x2920- f:00024 d: 288 | OR[288] = A
0x00EE (0x0001DC) 0x2115- f:00020 d: 277 | A = OR[277]
0x00EF (0x0001DE) 0x1203- f:00011 d: 3 | A = A & 3 (0x0003)
0x00F0 (0x0001E0) 0x0A04- f:00005 d: 4 | A = A < 4 (0x0004)
0x00F1 (0x0001E2) 0x2916- f:00024 d: 278 | OR[278] = A
0x00F2 (0x0001E4) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x00F3 (0x0001E6) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x00F4 (0x0001E8) 0x5800- f:00054 d: 0 | B = A
0x00F5 (0x0001EA) 0x2114- f:00020 d: 276 | A = OR[276]
0x00F6 (0x0001EC) 0x4A00- f:00045 d: 0 | A = A < B
0x00F7 (0x0001EE) 0x290D- f:00024 d: 269 | OR[269] = A
0x00F8 (0x0001F0) 0x1002- f:00010 d: 2 | A = 2 (0x0002)
0x00F9 (0x0001F2) 0x5800- f:00054 d: 0 | B = A
0x00FA (0x0001F4) 0x2114- f:00020 d: 276 | A = OR[276]
0x00FB (0x0001F6) 0x4800- f:00044 d: 0 | A = A > B
0x00FC (0x0001F8) 0x2914- f:00024 d: 276 | OR[276] = A
0x00FD (0x0001FA) 0x2115- f:00020 d: 277 | A = OR[277]
0x00FE (0x0001FC) 0x4800- f:00044 d: 0 | A = A > B
0x00FF (0x0001FE) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0100 (0x000200) 0x2915- f:00024 d: 277 | OR[277] = A
0x0101 (0x000202) 0x2114- f:00020 d: 276 | A = OR[276]
0x0102 (0x000204) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0103 (0x000206) 0x2914- f:00024 d: 276 | OR[276] = A
0x0104 (0x000208) 0x211F- f:00020 d: 287 | A = OR[287]
0x0105 (0x00020A) 0x1412- f:00012 d: 18 | A = A + 18 (0x0012)
0x0106 (0x00020C) 0x2908- f:00024 d: 264 | OR[264] = A
0x0107 (0x00020E) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0108 (0x000210) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x010A (0x000214) 0x2514- f:00022 d: 276 | A = A + OR[276]
0x010B (0x000216) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x010C (0x000218) 0x211F- f:00020 d: 287 | A = OR[287]
0x010D (0x00021A) 0x1413- f:00012 d: 19 | A = A + 19 (0x0013)
0x010E (0x00021C) 0x2908- f:00024 d: 264 | OR[264] = A
0x010F (0x00021E) 0x2115- f:00020 d: 277 | A = OR[277]
0x0110 (0x000220) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0111 (0x000222) 0x1800-0x434D f:00014 d: 0 | A = 17229 (0x434D)
0x0113 (0x000226) 0x2917- f:00024 d: 279 | OR[279] = A
0x0114 (0x000228) 0x2120- f:00020 d: 288 | A = OR[288]
0x0115 (0x00022A) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0116 (0x00022C) 0x2920- f:00024 d: 288 | OR[288] = A
0x0117 (0x00022E) 0x211F- f:00020 d: 287 | A = OR[287]
0x0118 (0x000230) 0x141B- f:00012 d: 27 | A = A + 27 (0x001B)
0x0119 (0x000232) 0x2908- f:00024 d: 264 | OR[264] = A
0x011A (0x000234) 0x3108- f:00030 d: 264 | A = (OR[264])
0x011B (0x000236) 0x1A00-0xFF00 f:00015 d: 0 | A = A & 65280 (0xFF00)
0x011D (0x00023A) 0x2520- f:00022 d: 288 | A = A + OR[288]
0x011E (0x00023C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x011F (0x00023E) 0x2116- f:00020 d: 278 | A = OR[278]
0x0120 (0x000240) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x0121 (0x000242) 0x2916- f:00024 d: 278 | OR[278] = A
0x0122 (0x000244) 0x211F- f:00020 d: 287 | A = OR[287]
0x0123 (0x000246) 0x1412- f:00012 d: 18 | A = A + 18 (0x0012)
0x0124 (0x000248) 0x2908- f:00024 d: 264 | OR[264] = A
0x0125 (0x00024A) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0126 (0x00024C) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0127 (0x00024E) 0x2516- f:00022 d: 278 | A = A + OR[278]
0x0128 (0x000250) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0129 (0x000252) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x012A (0x000254) 0x211F- f:00020 d: 287 | A = OR[287]
0x012B (0x000256) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x012C (0x000258) 0x2908- f:00024 d: 264 | OR[264] = A
0x012D (0x00025A) 0x2117- f:00020 d: 279 | A = OR[279]
0x012E (0x00025C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x012F (0x00025E) 0x7E03-0x02FF f:00077 d: 3 | R = OR[3]+767 (0x02FF)
0x0131 (0x000262) 0x211E- f:00020 d: 286 | A = OR[286]
0x0132 (0x000264) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x0133 (0x000266) 0x2908- f:00024 d: 264 | OR[264] = A
0x0134 (0x000268) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0135 (0x00026A) 0x2914- f:00024 d: 276 | OR[276] = A
0x0136 (0x00026C) 0x211E- f:00020 d: 286 | A = OR[286]
0x0137 (0x00026E) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x0138 (0x000270) 0x2908- f:00024 d: 264 | OR[264] = A
0x0139 (0x000272) 0x3108- f:00030 d: 264 | A = (OR[264])
0x013A (0x000274) 0x2915- f:00024 d: 277 | OR[277] = A
0x013B (0x000276) 0x211E- f:00020 d: 286 | A = OR[286]
0x013C (0x000278) 0x1403- f:00012 d: 3 | A = A + 3 (0x0003)
0x013D (0x00027A) 0x2908- f:00024 d: 264 | OR[264] = A
0x013E (0x00027C) 0x3108- f:00030 d: 264 | A = (OR[264])
0x013F (0x00027E) 0x2916- f:00024 d: 278 | OR[278] = A
0x0140 (0x000280) 0x211E- f:00020 d: 286 | A = OR[286]
0x0141 (0x000282) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x0142 (0x000284) 0x2908- f:00024 d: 264 | OR[264] = A
0x0143 (0x000286) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0144 (0x000288) 0x2917- f:00024 d: 279 | OR[279] = A
0x0145 (0x00028A) 0x2113- f:00020 d: 275 | A = OR[275]
0x0146 (0x00028C) 0x1608- f:00013 d: 8 | A = A - 8 (0x0008)
0x0147 (0x00028E) 0x8402- f:00102 d: 2 | P = P + 2 (0x0149), A = 0
0x0148 (0x000290) 0x704F- f:00070 d: 79 | P = P + 79 (0x0197)
0x0149 (0x000292) 0x2120- f:00020 d: 288 | A = OR[288]
0x014A (0x000294) 0x1618- f:00013 d: 24 | A = A - 24 (0x0018)
0x014B (0x000296) 0x8402- f:00102 d: 2 | P = P + 2 (0x014D), A = 0
0x014C (0x000298) 0x701F- f:00070 d: 31 | P = P + 31 (0x016B)
0x014D (0x00029A) 0x2115- f:00020 d: 277 | A = OR[277]
0x014E (0x00029C) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x014F (0x00029E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0150 (0x0002A0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0151 (0x0002A2) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x0152 (0x0002A4) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x0154 (0x0002A8) 0x2114- f:00020 d: 276 | A = OR[276]
0x0155 (0x0002AA) 0x2916- f:00024 d: 278 | OR[278] = A
0x0156 (0x0002AC) 0x2115- f:00020 d: 277 | A = OR[277]
0x0157 (0x0002AE) 0x2917- f:00024 d: 279 | OR[279] = A
0x0158 (0x0002B0) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0159 (0x0002B2) 0x2914- f:00024 d: 276 | OR[276] = A
0x015A (0x0002B4) 0x2915- f:00024 d: 277 | OR[277] = A
0x015B (0x0002B6) 0x1010- f:00010 d: 16 | A = 16 (0x0010)
0x015C (0x0002B8) 0x1608- f:00013 d: 8 | A = A - 8 (0x0008)
0x015D (0x0002BA) 0x5800- f:00054 d: 0 | B = A
0x015E (0x0002BC) 0x2116- f:00020 d: 278 | A = OR[278]
0x015F (0x0002BE) 0x4A00- f:00045 d: 0 | A = A < B
0x0160 (0x0002C0) 0x290D- f:00024 d: 269 | OR[269] = A
0x0161 (0x0002C2) 0x1008- f:00010 d: 8 | A = 8 (0x0008)
0x0162 (0x0002C4) 0x5800- f:00054 d: 0 | B = A
0x0163 (0x0002C6) 0x2116- f:00020 d: 278 | A = OR[278]
0x0164 (0x0002C8) 0x4800- f:00044 d: 0 | A = A > B
0x0165 (0x0002CA) 0x2916- f:00024 d: 278 | OR[278] = A
0x0166 (0x0002CC) 0x2117- f:00020 d: 279 | A = OR[279]
0x0167 (0x0002CE) 0x4800- f:00044 d: 0 | A = A > B
0x0168 (0x0002D0) 0x250D- f:00022 d: 269 | A = A + OR[269]
0x0169 (0x0002D2) 0x2917- f:00024 d: 279 | OR[279] = A
0x016A (0x0002D4) 0x702C- f:00070 d: 44 | P = P + 44 (0x0196)
0x016B (0x0002D6) 0x2120- f:00020 d: 288 | A = OR[288]
0x016C (0x0002D8) 0x1620- f:00013 d: 32 | A = A - 32 (0x0020)
0x016D (0x0002DA) 0x8402- f:00102 d: 2 | P = P + 2 (0x016F), A = 0
0x016E (0x0002DC) 0x700C- f:00070 d: 12 | P = P + 12 (0x017A)
0x016F (0x0002DE) 0x2116- f:00020 d: 278 | A = OR[278]
0x0170 (0x0002E0) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x0172 (0x0002E4) 0x2114- f:00020 d: 276 | A = OR[276]
0x0173 (0x0002E6) 0x2916- f:00024 d: 278 | OR[278] = A
0x0174 (0x0002E8) 0x2115- f:00020 d: 277 | A = OR[277]
0x0175 (0x0002EA) 0x2917- f:00024 d: 279 | OR[279] = A
0x0176 (0x0002EC) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0177 (0x0002EE) 0x2914- f:00024 d: 276 | OR[276] = A
0x0178 (0x0002F0) 0x2915- f:00024 d: 277 | OR[277] = A
0x0179 (0x0002F2) 0x701D- f:00070 d: 29 | P = P + 29 (0x0196)
0x017A (0x0002F4) 0x2120- f:00020 d: 288 | A = OR[288]
0x017B (0x0002F6) 0x1610- f:00013 d: 16 | A = A - 16 (0x0010)
0x017C (0x0002F8) 0x8402- f:00102 d: 2 | P = P + 2 (0x017E), A = 0
0x017D (0x0002FA) 0x7009- f:00070 d: 9 | P = P + 9 (0x0186)
0x017E (0x0002FC) 0x2115- f:00020 d: 277 | A = OR[277]
0x017F (0x0002FE) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x0181 (0x000302) 0x2114- f:00020 d: 276 | A = OR[276]
0x0182 (0x000304) 0x2917- f:00024 d: 279 | OR[279] = A
0x0183 (0x000306) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0184 (0x000308) 0x2914- f:00024 d: 276 | OR[276] = A
0x0185 (0x00030A) 0x7011- f:00070 d: 17 | P = P + 17 (0x0196)
0x0186 (0x00030C) 0x2120- f:00020 d: 288 | A = OR[288]
0x0187 (0x00030E) 0x1610- f:00013 d: 16 | A = A - 16 (0x0010)
0x0188 (0x000310) 0x8002- f:00100 d: 2 | P = P + 2 (0x018A), C = 0
0x0189 (0x000312) 0x700D- f:00070 d: 13 | P = P + 13 (0x0196)
0x018A (0x000314) 0x2114- f:00020 d: 276 | A = OR[276]
0x018B (0x000316) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x018C (0x000318) 0x2908- f:00024 d: 264 | OR[264] = A
0x018D (0x00031A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x018E (0x00031C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x018F (0x00031E) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x0191 (0x000322) 0x2114- f:00020 d: 276 | A = OR[276]
0x0192 (0x000324) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0193 (0x000326) 0x2917- f:00024 d: 279 | OR[279] = A
0x0194 (0x000328) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0195 (0x00032A) 0x2914- f:00024 d: 276 | OR[276] = A
0x0196 (0x00032C) 0x7033- f:00070 d: 51 | P = P + 51 (0x01C9)
0x0197 (0x00032E) 0x2113- f:00020 d: 275 | A = OR[275]
0x0198 (0x000330) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x0199 (0x000332) 0x8402- f:00102 d: 2 | P = P + 2 (0x019B), A = 0
0x019A (0x000334) 0x7008- f:00070 d: 8 | P = P + 8 (0x01A2)
0x019B (0x000336) 0x2114- f:00020 d: 276 | A = OR[276]
0x019C (0x000338) 0x2916- f:00024 d: 278 | OR[278] = A
0x019D (0x00033A) 0x2115- f:00020 d: 277 | A = OR[277]
0x019E (0x00033C) 0x2917- f:00024 d: 279 | OR[279] = A
0x019F (0x00033E) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01A0 (0x000340) 0x2914- f:00024 d: 276 | OR[276] = A
0x01A1 (0x000342) 0x2915- f:00024 d: 277 | OR[277] = A
0x01A2 (0x000344) 0x2120- f:00020 d: 288 | A = OR[288]
0x01A3 (0x000346) 0x1640- f:00013 d: 64 | A = A - 64 (0x0040)
0x01A4 (0x000348) 0x8602- f:00103 d: 2 | P = P + 2 (0x01A6), A # 0
0x01A5 (0x00034A) 0x7014- f:00070 d: 20 | P = P + 20 (0x01B9)
0x01A6 (0x00034C) 0x2114- f:00020 d: 276 | A = OR[276]
0x01A7 (0x00034E) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x01A9 (0x000352) 0x2115- f:00020 d: 277 | A = OR[277]
0x01AA (0x000354) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x01AC (0x000358) 0x2120- f:00020 d: 288 | A = OR[288]
0x01AD (0x00035A) 0x1618- f:00013 d: 24 | A = A - 24 (0x0018)
0x01AE (0x00035C) 0x8002- f:00100 d: 2 | P = P + 2 (0x01B0), C = 0
0x01AF (0x00035E) 0x8602- f:00103 d: 2 | P = P + 2 (0x01B1), A # 0
0x01B0 (0x000360) 0x7002- f:00070 d: 2 | P = P + 2 (0x01B2)
0x01B1 (0x000362) 0x7008- f:00070 d: 8 | P = P + 8 (0x01B9)
0x01B2 (0x000364) 0x2116- f:00020 d: 278 | A = OR[278]
0x01B3 (0x000366) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x01B4 (0x000368) 0x2908- f:00024 d: 264 | OR[264] = A
0x01B5 (0x00036A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01B6 (0x00036C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x01B7 (0x00036E) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x01B9 (0x000372) 0x2120- f:00020 d: 288 | A = OR[288]
0x01BA (0x000374) 0x1611- f:00013 d: 17 | A = A - 17 (0x0011)
0x01BB (0x000376) 0x8002- f:00100 d: 2 | P = P + 2 (0x01BD), C = 0
0x01BC (0x000378) 0x700D- f:00070 d: 13 | P = P + 13 (0x01C9)
0x01BD (0x00037A) 0x2116- f:00020 d: 278 | A = OR[278]
0x01BE (0x00037C) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x01C0 (0x000380) 0x2120- f:00020 d: 288 | A = OR[288]
0x01C1 (0x000382) 0x5800- f:00054 d: 0 | B = A
0x01C2 (0x000384) 0x2117- f:00020 d: 279 | A = OR[279]
0x01C3 (0x000386) 0x4800- f:00044 d: 0 | A = A > B
0x01C4 (0x000388) 0x2908- f:00024 d: 264 | OR[264] = A
0x01C5 (0x00038A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x01C6 (0x00038C) 0x2708- f:00023 d: 264 | A = A - OR[264]
0x01C7 (0x00038E) 0xAE03-0x02DB f:00127 d: 3 | P = OR[3]+731 (0x02DB), A # 0
0x01C9 (0x000392) 0x211F- f:00020 d: 287 | A = OR[287]
0x01CA (0x000394) 0x141C- f:00012 d: 28 | A = A + 28 (0x001C)
0x01CB (0x000396) 0x2913- f:00024 d: 275 | OR[275] = A
0x01CC (0x000398) 0x2114- f:00020 d: 276 | A = OR[276]
0x01CD (0x00039A) 0x3913- f:00034 d: 275 | (OR[275]) = A
0x01CE (0x00039C) 0x2D13- f:00026 d: 275 | OR[275] = OR[275] + 1
0x01CF (0x00039E) 0x2115- f:00020 d: 277 | A = OR[277]
0x01D0 (0x0003A0) 0x3913- f:00034 d: 275 | (OR[275]) = A
0x01D1 (0x0003A2) 0x2D13- f:00026 d: 275 | OR[275] = OR[275] + 1
0x01D2 (0x0003A4) 0x2116- f:00020 d: 278 | A = OR[278]
0x01D3 (0x0003A6) 0x3913- f:00034 d: 275 | (OR[275]) = A
0x01D4 (0x0003A8) 0x2D13- f:00026 d: 275 | OR[275] = OR[275] + 1
0x01D5 (0x0003AA) 0x2117- f:00020 d: 279 | A = OR[279]
0x01D6 (0x0003AC) 0x3913- f:00034 d: 275 | (OR[275]) = A
0x01D7 (0x0003AE) 0x7E03-0x02FF f:00077 d: 3 | R = OR[3]+767 (0x02FF)
0x01D9 (0x0003B2) 0x2113- f:00020 d: 275 | A = OR[275]
0x01DA (0x0003B4) 0x160C- f:00013 d: 12 | A = A - 12 (0x000C)
0x01DB (0x0003B6) 0x8402- f:00102 d: 2 | P = P + 2 (0x01DD), A = 0
0x01DC (0x0003B8) 0x7008- f:00070 d: 8 | P = P + 8 (0x01E4)
0x01DD (0x0003BA) 0x2102- f:00020 d: 258 | A = OR[258]
0x01DE (0x0003BC) 0x140D- f:00012 d: 13 | A = A + 13 (0x000D)
0x01DF (0x0003BE) 0x2908- f:00024 d: 264 | OR[264] = A
0x01E0 (0x0003C0) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01E1 (0x0003C2) 0x2914- f:00024 d: 276 | OR[276] = A
0x01E2 (0x0003C4) 0x7A03-0x020D f:00075 d: 3 | P = OR[3]+525 (0x020D)
0x01E4 (0x0003C8) 0x211E- f:00020 d: 286 | A = OR[286]
0x01E5 (0x0003CA) 0x1401- f:00012 d: 1 | A = A + 1 (0x0001)
0x01E6 (0x0003CC) 0x2908- f:00024 d: 264 | OR[264] = A
0x01E7 (0x0003CE) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01E8 (0x0003D0) 0x2914- f:00024 d: 276 | OR[276] = A
0x01E9 (0x0003D2) 0x2114- f:00020 d: 276 | A = OR[276]
0x01EA (0x0003D4) 0x1601- f:00013 d: 1 | A = A - 1 (0x0001)
0x01EB (0x0003D6) 0x8603- f:00103 d: 3 | P = P + 3 (0x01EE), A # 0
0x01EC (0x0003D8) 0x7A03-0x020D f:00075 d: 3 | P = OR[3]+525 (0x020D)
0x01EE (0x0003DC) 0x2114- f:00020 d: 276 | A = OR[276]
0x01EF (0x0003DE) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x01F0 (0x0003E0) 0x8603- f:00103 d: 3 | P = P + 3 (0x01F3), A # 0
0x01F1 (0x0003E2) 0x7A03-0x020D f:00075 d: 3 | P = OR[3]+525 (0x020D)
0x01F3 (0x0003E6) 0x7E03-0x02FF f:00077 d: 3 | R = OR[3]+767 (0x02FF)
0x01F5 (0x0003EA) 0x2113- f:00020 d: 275 | A = OR[275]
0x01F6 (0x0003EC) 0x160C- f:00013 d: 12 | A = A - 12 (0x000C)
0x01F7 (0x0003EE) 0x8603- f:00103 d: 3 | P = P + 3 (0x01FA), A # 0
0x01F8 (0x0003F0) 0x7A03-0x020D f:00075 d: 3 | P = OR[3]+525 (0x020D)
0x01FA (0x0003F4) 0x211E- f:00020 d: 286 | A = OR[286]
0x01FB (0x0003F6) 0x1402- f:00012 d: 2 | A = A + 2 (0x0002)
0x01FC (0x0003F8) 0x2908- f:00024 d: 264 | OR[264] = A
0x01FD (0x0003FA) 0x3108- f:00030 d: 264 | A = (OR[264])
0x01FE (0x0003FC) 0x2916- f:00024 d: 278 | OR[278] = A
0x01FF (0x0003FE) 0x104A- f:00010 d: 74 | A = 74 (0x004A)
0x0200 (0x000400) 0x2915- f:00024 d: 277 | OR[277] = A
0x0201 (0x000402) 0x2114- f:00020 d: 276 | A = OR[276]
0x0202 (0x000404) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0203 (0x000406) 0x8603- f:00103 d: 3 | P = P + 3 (0x0206), A # 0
0x0204 (0x000408) 0x1053- f:00010 d: 83 | A = 83 (0x0053)
0x0205 (0x00040A) 0x2915- f:00024 d: 277 | OR[277] = A
0x0206 (0x00040C) 0x7026- f:00070 d: 38 | P = P + 38 (0x022C)
0x0207 (0x00040E) 0x2114- f:00020 d: 276 | A = OR[276]
0x0208 (0x000410) 0x1603- f:00013 d: 3 | A = A - 3 (0x0003)
0x0209 (0x000412) 0x8402- f:00102 d: 2 | P = P + 2 (0x020B), A = 0
0x020A (0x000414) 0x7009- f:00070 d: 9 | P = P + 9 (0x0213)
0x020B (0x000416) 0x104A- f:00010 d: 74 | A = 74 (0x004A)
0x020C (0x000418) 0x2915- f:00024 d: 277 | OR[277] = A
0x020D (0x00041A) 0x2102- f:00020 d: 258 | A = OR[258]
0x020E (0x00041C) 0x140F- f:00012 d: 15 | A = A + 15 (0x000F)
0x020F (0x00041E) 0x2908- f:00024 d: 264 | OR[264] = A
0x0210 (0x000420) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0211 (0x000422) 0x2916- f:00024 d: 278 | OR[278] = A
0x0212 (0x000424) 0x701A- f:00070 d: 26 | P = P + 26 (0x022C)
0x0213 (0x000426) 0x2114- f:00020 d: 276 | A = OR[276]
0x0214 (0x000428) 0x1602- f:00013 d: 2 | A = A - 2 (0x0002)
0x0215 (0x00042A) 0x8402- f:00102 d: 2 | P = P + 2 (0x0217), A = 0
0x0216 (0x00042C) 0x7009- f:00070 d: 9 | P = P + 9 (0x021F)
0x0217 (0x00042E) 0x1053- f:00010 d: 83 | A = 83 (0x0053)
0x0218 (0x000430) 0x2915- f:00024 d: 277 | OR[277] = A
0x0219 (0x000432) 0x2102- f:00020 d: 258 | A = OR[258]
0x021A (0x000434) 0x140E- f:00012 d: 14 | A = A + 14 (0x000E)
0x021B (0x000436) 0x2908- f:00024 d: 264 | OR[264] = A
0x021C (0x000438) 0x3108- f:00030 d: 264 | A = (OR[264])
0x021D (0x00043A) 0x2916- f:00024 d: 278 | OR[278] = A
0x021E (0x00043C) 0x700E- f:00070 d: 14 | P = P + 14 (0x022C)
0x021F (0x00043E) 0x2114- f:00020 d: 276 | A = OR[276]
0x0220 (0x000440) 0x1606- f:00013 d: 6 | A = A - 6 (0x0006)
0x0221 (0x000442) 0x8402- f:00102 d: 2 | P = P + 2 (0x0223), A = 0
0x0222 (0x000444) 0x7006- f:00070 d: 6 | P = P + 6 (0x0228)
0x0223 (0x000446) 0x1041- f:00010 d: 65 | A = 65 (0x0041)
0x0224 (0x000448) 0x2915- f:00024 d: 277 | OR[277] = A
0x0225 (0x00044A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0226 (0x00044C) 0x2916- f:00024 d: 278 | OR[278] = A
0x0227 (0x00044E) 0x7005- f:00070 d: 5 | P = P + 5 (0x022C)
0x0228 (0x000450) 0x1045- f:00010 d: 69 | A = 69 (0x0045)
0x0229 (0x000452) 0x2915- f:00024 d: 277 | OR[277] = A
0x022A (0x000454) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x022B (0x000456) 0x2916- f:00024 d: 278 | OR[278] = A
0x022C (0x000458) 0x2115- f:00020 d: 277 | A = OR[277]
0x022D (0x00045A) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x022E (0x00045C) 0x2915- f:00024 d: 277 | OR[277] = A
0x022F (0x00045E) 0x211F- f:00020 d: 287 | A = OR[287]
0x0230 (0x000460) 0x1405- f:00012 d: 5 | A = A + 5 (0x0005)
0x0231 (0x000462) 0x2908- f:00024 d: 264 | OR[264] = A
0x0232 (0x000464) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0233 (0x000466) 0x0A09- f:00005 d: 9 | A = A < 9 (0x0009)
0x0234 (0x000468) 0x2515- f:00022 d: 277 | A = A + OR[277]
0x0235 (0x00046A) 0x0C09- f:00006 d: 9 | A = A >> 9 (0x0009)
0x0236 (0x00046C) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x0237 (0x00046E) 0x211F- f:00020 d: 287 | A = OR[287]
0x0238 (0x000470) 0x1407- f:00012 d: 7 | A = A + 7 (0x0007)
0x0239 (0x000472) 0x2908- f:00024 d: 264 | OR[264] = A
0x023A (0x000474) 0x2116- f:00020 d: 278 | A = OR[278]
0x023B (0x000476) 0x3908- f:00034 d: 264 | (OR[264]) = A
0x023C (0x000478) 0x2115- f:00020 d: 277 | A = OR[277]
0x023D (0x00047A) 0x1641- f:00013 d: 65 | A = A - 65 (0x0041)
0x023E (0x00047C) 0x8402- f:00102 d: 2 | P = P + 2 (0x0240), A = 0
0x023F (0x00047E) 0x7060- f:00070 d: 96 | P = P + 96 (0x029F)
0x0240 (0x000480) 0x211F- f:00020 d: 287 | A = OR[287]
0x0241 (0x000482) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x0242 (0x000484) 0x2908- f:00024 d: 264 | OR[264] = A
0x0243 (0x000486) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0244 (0x000488) 0x2913- f:00024 d: 275 | OR[275] = A
0x0245 (0x00048A) 0x2113- f:00020 d: 275 | A = OR[275]
0x0246 (0x00048C) 0x1E00-0x434D f:00017 d: 0 | A = A - 17229 (0x434D)
0x0248 (0x000490) 0x868D- f:00103 d: 141 | P = P + 141 (0x02D5), A # 0
0x0249 (0x000492) 0x211F- f:00020 d: 287 | A = OR[287]
0x024A (0x000494) 0x1412- f:00012 d: 18 | A = A + 18 (0x0012)
0x024B (0x000496) 0x2908- f:00024 d: 264 | OR[264] = A
0x024C (0x000498) 0x3108- f:00030 d: 264 | A = (OR[264])
0x024D (0x00049A) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x024E (0x00049C) 0x2923- f:00024 d: 291 | OR[291] = A
0x024F (0x00049E) 0x211F- f:00020 d: 287 | A = OR[287]
0x0250 (0x0004A0) 0x1413- f:00012 d: 19 | A = A + 19 (0x0013)
0x0251 (0x0004A2) 0x2908- f:00024 d: 264 | OR[264] = A
0x0252 (0x0004A4) 0x3108- f:00030 d: 264 | A = (OR[264])
0x0253 (0x0004A6) 0x2924- f:00024 d: 292 | OR[292] = A
0x0254 (0x0004A8) 0x2120- f:00020 d: 288 | A = OR[288]
0x0255 (0x0004AA) 0x1640- f:00013 d: 64 | A = A - 64 (0x0040)
0x0256 (0x0004AC) 0x8602- f:00103 d: 2 | P = P + 2 (0x0258), A # 0
0x0257 (0x0004AE) 0x7014- f:00070 d: 20 | P = P + 20 (0x026B)
0x0258 (0x0004B0) 0x1022- f:00010 d: 34 | A = 34 (0x0022)
0x0259 (0x0004B2) 0x2926- f:00024 d: 294 | OR[294] = A
0x025A (0x0004B4) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x025B (0x0004B6) 0x2927- f:00024 d: 295 | OR[295] = A
0x025C (0x0004B8) 0x2123- f:00020 d: 291 | A = OR[291]
0x025D (0x0004BA) 0x2928- f:00024 d: 296 | OR[296] = A
0x025E (0x0004BC) 0x2124- f:00020 d: 292 | A = OR[292]
0x025F (0x0004BE) 0x2929- f:00024 d: 297 | OR[297] = A
0x0260 (0x0004C0) 0x2125- f:00020 d: 293 | A = OR[293]
0x0261 (0x0004C2) 0x292A- f:00024 d: 298 | OR[298] = A
0x0262 (0x0004C4) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0263 (0x0004C6) 0x292B- f:00024 d: 299 | OR[299] = A
0x0264 (0x0004C8) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0265 (0x0004CA) 0x292C- f:00024 d: 300 | OR[300] = A
0x0266 (0x0004CC) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x0267 (0x0004CE) 0x5800- f:00054 d: 0 | B = A
0x0268 (0x0004D0) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x026A (0x0004D4) 0x7C09- f:00076 d: 9 | R = OR[9]
0x026B (0x0004D6) 0x211F- f:00020 d: 287 | A = OR[287]
0x026C (0x0004D8) 0x1412- f:00012 d: 18 | A = A + 18 (0x0012)
0x026D (0x0004DA) 0x2908- f:00024 d: 264 | OR[264] = A
0x026E (0x0004DC) 0x3108- f:00030 d: 264 | A = (OR[264])
0x026F (0x0004DE) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0270 (0x0004E0) 0x2914- f:00024 d: 276 | OR[276] = A
0x0271 (0x0004E2) 0x2114- f:00020 d: 276 | A = OR[276]
0x0272 (0x0004E4) 0x0804- f:00004 d: 4 | A = A > 4 (0x0004)
0x0273 (0x0004E6) 0x2914- f:00024 d: 276 | OR[276] = A
0x0274 (0x0004E8) 0x2114- f:00020 d: 276 | A = OR[276]
0x0275 (0x0004EA) 0x2525- f:00022 d: 293 | A = A + OR[293]
0x0276 (0x0004EC) 0x2914- f:00024 d: 276 | OR[276] = A
0x0277 (0x0004EE) 0x211F- f:00020 d: 287 | A = OR[287]
0x0278 (0x0004F0) 0x141C- f:00012 d: 28 | A = A + 28 (0x001C)
0x0279 (0x0004F2) 0x2915- f:00024 d: 277 | OR[277] = A
0x027A (0x0004F4) 0x2120- f:00020 d: 288 | A = OR[288]
0x027B (0x0004F6) 0x0804- f:00004 d: 4 | A = A > 4 (0x0004)
0x027C (0x0004F8) 0x2913- f:00024 d: 275 | OR[275] = A
0x027D (0x0004FA) 0x2115- f:00020 d: 277 | A = OR[277]
0x027E (0x0004FC) 0x1404- f:00012 d: 4 | A = A + 4 (0x0004)
0x027F (0x0004FE) 0x2713- f:00023 d: 275 | A = A - OR[275]
0x0280 (0x000500) 0x2915- f:00024 d: 277 | OR[277] = A
0x0281 (0x000502) 0x2113- f:00020 d: 275 | A = OR[275]
0x0282 (0x000504) 0x8407- f:00102 d: 7 | P = P + 7 (0x0289), A = 0
0x0283 (0x000506) 0x3115- f:00030 d: 277 | A = (OR[277])
0x0284 (0x000508) 0x3914- f:00034 d: 276 | (OR[276]) = A
0x0285 (0x00050A) 0x2D14- f:00026 d: 276 | OR[276] = OR[276] + 1
0x0286 (0x00050C) 0x2D15- f:00026 d: 277 | OR[277] = OR[277] + 1
0x0287 (0x00050E) 0x2F13- f:00027 d: 275 | OR[275] = OR[275] - 1
0x0288 (0x000510) 0x7207- f:00071 d: 7 | P = P - 7 (0x0281)
0x0289 (0x000512) 0x1023- f:00010 d: 35 | A = 35 (0x0023)
0x028A (0x000514) 0x2926- f:00024 d: 294 | OR[294] = A
0x028B (0x000516) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x028C (0x000518) 0x2927- f:00024 d: 295 | OR[295] = A
0x028D (0x00051A) 0x2123- f:00020 d: 291 | A = OR[291]
0x028E (0x00051C) 0x2928- f:00024 d: 296 | OR[296] = A
0x028F (0x00051E) 0x2124- f:00020 d: 292 | A = OR[292]
0x0290 (0x000520) 0x2929- f:00024 d: 297 | OR[297] = A
0x0291 (0x000522) 0x2125- f:00020 d: 293 | A = OR[293]
0x0292 (0x000524) 0x292A- f:00024 d: 298 | OR[298] = A
0x0293 (0x000526) 0x1001- f:00010 d: 1 | A = 1 (0x0001)
0x0294 (0x000528) 0x292B- f:00024 d: 299 | OR[299] = A
0x0295 (0x00052A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0296 (0x00052C) 0x292C- f:00024 d: 300 | OR[300] = A
0x0297 (0x00052E) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x0298 (0x000530) 0x5800- f:00054 d: 0 | B = A
0x0299 (0x000532) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x029B (0x000536) 0x7C09- f:00076 d: 9 | R = OR[9]
0x029C (0x000538) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x029D (0x00053A) 0x2921- f:00024 d: 289 | OR[289] = A
0x029E (0x00053C) 0x7020- f:00070 d: 32 | P = P + 32 (0x02BE)
0x029F (0x00053E) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x02A0 (0x000540) 0x2926- f:00024 d: 294 | OR[294] = A
0x02A1 (0x000542) 0x1800-0x015A f:00014 d: 0 | A = 346 (0x015A)
0x02A3 (0x000546) 0x2927- f:00024 d: 295 | OR[295] = A
0x02A4 (0x000548) 0x1800-0x01CA f:00014 d: 0 | A = 458 (0x01CA)
0x02A6 (0x00054C) 0x2928- f:00024 d: 296 | OR[296] = A
0x02A7 (0x00054E) 0x211F- f:00020 d: 287 | A = OR[287]
0x02A8 (0x000550) 0x2929- f:00024 d: 297 | OR[297] = A
0x02A9 (0x000552) 0x1800-0x02C0 f:00014 d: 0 | A = 704 (0x02C0)
0x02AB (0x000556) 0x292A- f:00024 d: 298 | OR[298] = A
0x02AC (0x000558) 0x1800-0x0247 f:00014 d: 0 | A = 583 (0x0247)
0x02AE (0x00055C) 0x292B- f:00024 d: 299 | OR[299] = A
0x02AF (0x00055E) 0x1800-0x0001 f:00014 d: 0 | A = 1 (0x0001)
0x02B1 (0x000562) 0x292C- f:00024 d: 300 | OR[300] = A
0x02B2 (0x000564) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02B3 (0x000566) 0x292D- f:00024 d: 301 | OR[301] = A
0x02B4 (0x000568) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02B5 (0x00056A) 0x292E- f:00024 d: 302 | OR[302] = A
0x02B6 (0x00056C) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02B7 (0x00056E) 0x292F- f:00024 d: 303 | OR[303] = A
0x02B8 (0x000570) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x02B9 (0x000572) 0x5800- f:00054 d: 0 | B = A
0x02BA (0x000574) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x02BC (0x000578) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02BD (0x00057A) 0x2921- f:00024 d: 289 | OR[289] = A
0x02BE (0x00057C) 0x742C- f:00072 d: 44 | R = P + 44 (0x02EA)
0x02BF (0x00057E) 0x2121- f:00020 d: 289 | A = OR[289]
0x02C0 (0x000580) 0x8602- f:00103 d: 2 | P = P + 2 (0x02C2), A # 0
0x02C1 (0x000582) 0x7013- f:00070 d: 19 | P = P + 19 (0x02D4)
0x02C2 (0x000584) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x02C3 (0x000586) 0x2926- f:00024 d: 294 | OR[294] = A
0x02C4 (0x000588) 0x1800-0x0137 f:00014 d: 0 | A = 311 (0x0137)
0x02C6 (0x00058C) 0x2927- f:00024 d: 295 | OR[295] = A
0x02C7 (0x00058E) 0x2121- f:00020 d: 289 | A = OR[289]
0x02C8 (0x000590) 0x2928- f:00024 d: 296 | OR[296] = A
0x02C9 (0x000592) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02CA (0x000594) 0x2929- f:00024 d: 297 | OR[297] = A
0x02CB (0x000596) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02CC (0x000598) 0x292A- f:00024 d: 298 | OR[298] = A
0x02CD (0x00059A) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x02CE (0x00059C) 0x292B- f:00024 d: 299 | OR[299] = A
0x02CF (0x00059E) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x02D0 (0x0005A0) 0x5800- f:00054 d: 0 | B = A
0x02D1 (0x0005A2) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x02D3 (0x0005A6) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02D4 (0x0005A8) 0x702F- f:00070 d: 47 | P = P + 47 (0x0303)
0x02D5 (0x0005AA) 0x7415- f:00072 d: 21 | R = P + 21 (0x02EA)
0x02D6 (0x0005AC) 0x1028- f:00010 d: 40 | A = 40 (0x0028)
0x02D7 (0x0005AE) 0x2926- f:00024 d: 294 | OR[294] = A
0x02D8 (0x0005B0) 0x1800-0x0137 f:00014 d: 0 | A = 311 (0x0137)
0x02DA (0x0005B4) 0x2927- f:00024 d: 295 | OR[295] = A
0x02DB (0x0005B6) 0x1800-0x0004 f:00014 d: 0 | A = 4 (0x0004)
0x02DD (0x0005BA) 0x2928- f:00024 d: 296 | OR[296] = A
0x02DE (0x0005BC) 0x2119- f:00020 d: 281 | A = OR[281]
0x02DF (0x0005BE) 0x2929- f:00024 d: 297 | OR[297] = A
0x02E0 (0x0005C0) 0x211C- f:00020 d: 284 | A = OR[284]
0x02E1 (0x0005C2) 0x292A- f:00024 d: 298 | OR[298] = A
0x02E2 (0x0005C4) 0x211D- f:00020 d: 285 | A = OR[285]
0x02E3 (0x0005C6) 0x292B- f:00024 d: 299 | OR[299] = A
0x02E4 (0x0005C8) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x02E5 (0x0005CA) 0x5800- f:00054 d: 0 | B = A
0x02E6 (0x0005CC) 0x1800-0x1D18 f:00014 d: 0 | A = 7448 (0x1D18)
0x02E8 (0x0005D0) 0x7C09- f:00076 d: 9 | R = OR[9]
0x02E9 (0x0005D2) 0x701A- f:00070 d: 26 | P = P + 26 (0x0303)
0x02EA (0x0005D4) 0x2F04- f:00027 d: 260 | OR[260] = OR[260] - 1
0x02EB (0x0005D6) 0x3104- f:00030 d: 260 | A = (OR[260])
0x02EC (0x0005D8) 0x2904- f:00024 d: 260 | OR[260] = A
0x02ED (0x0005DA) 0x2104- f:00020 d: 260 | A = OR[260]
0x02EE (0x0005DC) 0x2706- f:00023 d: 262 | A = A - OR[262]
0x02EF (0x0005DE) 0x8007- f:00100 d: 7 | P = P + 7 (0x02F6), C = 0
0x02F0 (0x0005E0) 0x2104- f:00020 d: 260 | A = OR[260]
0x02F1 (0x0005E2) 0x2705- f:00023 d: 261 | A = A - OR[261]
0x02F2 (0x0005E4) 0x8003- f:00100 d: 3 | P = P + 3 (0x02F5), C = 0
0x02F3 (0x0005E6) 0x8402- f:00102 d: 2 | P = P + 2 (0x02F5), A = 0
0x02F4 (0x0005E8) 0x7002- f:00070 d: 2 | P = P + 2 (0x02F6)
0x02F5 (0x0005EA) 0x7003- f:00070 d: 3 | P = P + 3 (0x02F8)
0x02F6 (0x0005EC) 0x7C34- f:00076 d: 52 | R = OR[52]
0x02F7 (0x0005EE) 0x000B- f:00000 d: 11 | PASS | **** non-standard encoding with D:0x000B ****
0x02F8 (0x0005F0) 0x0200- f:00001 d: 0 | EXIT
0x02F9 (0x0005F2) 0x311E- f:00030 d: 286 | A = (OR[286])
0x02FA (0x0005F4) 0x12FF- f:00011 d: 255 | A = A & 255 (0x00FF)
0x02FB (0x0005F6) 0x2913- f:00024 d: 275 | OR[275] = A
0x02FC (0x0005F8) 0x211E- f:00020 d: 286 | A = OR[286]
0x02FD (0x0005FA) 0x2513- f:00022 d: 275 | A = A + OR[275]
0x02FE (0x0005FC) 0x291E- f:00024 d: 286 | OR[286] = A
0x02FF (0x0005FE) 0x311E- f:00030 d: 286 | A = (OR[286])
0x0300 (0x000600) 0x0808- f:00004 d: 8 | A = A > 8 (0x0008)
0x0301 (0x000602) 0x2913- f:00024 d: 275 | OR[275] = A
0x0302 (0x000604) 0x0200- f:00001 d: 0 | EXIT
0x0303 (0x000606) 0x7619- f:00073 d: 25 | R = P - 25 (0x02EA)
0x0304 (0x000608) 0x102A- f:00010 d: 42 | A = 42 (0x002A)
0x0305 (0x00060A) 0x2926- f:00024 d: 294 | OR[294] = A
0x0306 (0x00060C) 0x1126- f:00010 d: 294 | A = 294 (0x0126)
0x0307 (0x00060E) 0x5800- f:00054 d: 0 | B = A
0x0308 (0x000610) 0x1000- f:00010 d: 0 | A = 0 (0x0000)
0x0309 (0x000612) 0x7C09- f:00076 d: 9 | R = OR[9]
0x030A (0x000614) 0x0000- f:00000 d: 0 | PASS
0x030B (0x000616) 0x0000- f:00000 d: 0 | PASS
| 80.087075
| 127
| 0.465684
|
dcfb380ee5b25c7698bc99dfd570845654d73641
| 2,751
|
asm
|
Assembly
|
dev/emm386/dbg.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
dev/emm386/dbg.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
dev/emm386/dbg.asm
|
minblock/msdos
|
479ffd237d9bb7cc83cb06361db2c4ef42dfbac0
|
[
"Apache-2.0"
] | null | null | null |
.386p
include emm386.inc
include emmdata.inc
include vdmseg.inc
include vdmsel.inc
ifdef DEBUG
_TEXT segment
assume cs:_TEXT, ds:NOTHING, es:NOTHING, fs:NOTHING, gs:NOTHING
public pDebugPrintf
pDebugPrintf proc far
Pcall VDMC_GSEL,pTestDbgIns
jnc pDP_skip_it
push bp
mov bp, sp
push es
push ds
push si
push di
push ax
mov ax, 074h
push VDMD_GSEL
pop ds
mov si, [bp+6]
push ss
pop es
lea di, [bp+8]
int 41h
pop ax
pop di
pop si
pop ds
pop es
pop bp
pDP_skip_it:
ret
pDebugPrintf endp
public pTestDbgIns
pTestDbgIns proc far
push ds
push RCODEA_GSEL
pop ds
bt ds:[GenFlags], fDebugActiveBit
pop ds
ret
pTestDbgIns endp
_TEXT ends
R_CODE segment
assume cs:R_CODE, ds:NOTHING, es:NOTHING, fs:NOTHING, gs:NOTHING
public rDebugPrintf
rDebugPrintf proc far
call far ptr rTestDbgIns
jnc rDP_skip_it
push bp
mov bp, sp
push es
push ds
push si
push di
push ax
mov ah, 057h
push cs
pop ds
mov si, [bp+6]
push ss
pop es
lea di, [bp+8]
int 68h
pop ax
pop di
pop si
pop ds
pop es
pop bp
rDP_skip_it:
ret
rDebugPrintf endp
public rTestDbgIns
rTestDbgIns proc far
bt cs:[GenFlags], fDebugActiveBit
ret
rTestDbgIns endp
R_CODE ends
endif ;DEBUG
if 0 ;----------------------------------------------------------------
public dbgr
public pdbgr
R_CODE SEGMENT
assume cs:R_CODE,ds:R_CODE,es:R_CODE
dbgr proc near
push bx
push cx
push dx
push bp
mov dx, 02f8h ; com2
; mov dx, 03f8h ; com1
push ax
add dx, 4
mov al, 3
out dx, al
inc dx
inc dx
mov bh, 30h
call wait_status
je a9
a7: pop cx
mov al, cl
a8: or ah, 80
jmp a3
a9: dec dx
a10: mov bh, 20h
call wait_status
jne a7
a11: sub dx,5
pop cx
mov al, cl
out dx, al
a3: pop bp
pop dx
pop cx
pop bx
ret
dbgr endp
wait_status:
push bp
push bx
pop bp
and bp, 0ffh
rcl bp, 1
rcl bp, 1
wfs0: sub cx,cx
wfs1: in al, dx
mov ah,al
and al, bh
cmp al, bh
je wfsend
loop wfs1
dec bp
jne wfs0
or bh,bh
wfsend: pop bp
ret
R_CODE ENDS
_TEXT SEGMENT
assume cs:_TEXT
pdbgr proc near
push bx
push cx
push dx
push bp
mov dx, 02f8h ; com2
; mov dx, 03f8h ; com1
push ax
add dx, 4
mov al, 3
out dx, al
inc dx
inc dx
mov bh, 30h
call pwait_status
je pa9
pa7: pop cx
mov al, cl
pa8: or ah, 80
jmp pa3
pa9: dec dx
pa10: mov bh, 20h
call pwait_status
jne pa7
pa11: sub dx,5
pop cx
mov al, cl
out dx, al
pa3: pop bp
pop dx
pop cx
pop bx
ret
pdbgr endp
pwait_status:
push bp
push bx
pop bp
and bp, 0ffh
rcl bp, 1
rcl bp, 1
pwfs0: sub cx,cx
pwfs1:
in al, dx
mov ah,al
and al, bh
cmp al, bh
je pwfsend
loop pwfs1
dec bp
jne pwfs0
or bh,bh
pwfsend: pop bp
ret
_TEXT ENDS
endif ;----------------------------------------------------------------
END
| 10.916667
| 71
| 0.658306
|
986fa8ece379dd422aa8d486c8f72f735931d1ae
| 856
|
asm
|
Assembly
|
programs/oeis/103/A103459.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/103/A103459.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/103/A103459.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A103459: a(n) = 8^n + 1 - 0^n.
; 1,9,65,513,4097,32769,262145,2097153,16777217,134217729,1073741825,8589934593,68719476737,549755813889,4398046511105,35184372088833,281474976710657,2251799813685249,18014398509481985,144115188075855873,1152921504606846977,9223372036854775809,73786976294838206465,590295810358705651713,4722366482869645213697,37778931862957161709569,302231454903657293676545,2417851639229258349412353,19342813113834066795298817,154742504910672534362390529,1237940039285380274899124225,9903520314283042199192993793,79228162514264337593543950337,633825300114114700748351602689,5070602400912917605986812821505,40564819207303340847894502572033,324518553658426726783156020576257,2596148429267413814265248164610049,20769187434139310514121985316880385,166153499473114484112975882535043073
mov $1,8
pow $1,$0
div $1,8
mul $1,8
add $1,1
mov $0,$1
| 85.6
| 765
| 0.897196
|
6cf857a3104b0a455f2d8f2af55d76a6aefff4e8
| 2,884
|
asm
|
Assembly
|
Driver/Printer/DotMatrix/CanonBJC/canonBJCcmyInfo.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 504
|
2018-11-18T03:35:53.000Z
|
2022-03-29T01:02:51.000Z
|
Driver/Printer/DotMatrix/CanonBJC/canonBJCcmyInfo.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 96
|
2018-11-19T21:06:50.000Z
|
2022-03-06T10:26:48.000Z
|
Driver/Printer/DotMatrix/CanonBJC/canonBJCcmyInfo.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 73
|
2018-11-19T20:46:53.000Z
|
2022-03-29T00:59:26.000Z
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) GlobalPC 1999. All rights reserved.
GLOBALPC CONFIDENTIAL
PROJECT: GlobalPC
MODULE: Canon BJC Printer Driver
FILE: canonBJCcmyInfo.asm
AUTHOR: Joon Song, Jan 25, 1999
ROUTINES:
Name Description
---- -----------
REVISION HISTORY:
Name Date Description
---- ---- -----------
joon 1/25/99 Initial revision
DESCRIPTION:
$Id$
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
;----------------------------------------------------------------------------
; Canon BJC CMY Info
;----------------------------------------------------------------------------
cmyInfo segment resource
; info blocks
PrinterInfo < ; ---- PrinterType -------------
< PT_RASTER, BMF_3CMY >,
; ---- PrinterConnections ------
< IC_NO_IEEE488,
CC_NO_CUSTOM,
SC_NO_SCSI,
RC_NO_RS232C,
CC_CENTRONICS,
FC_FILE,
AC_NO_APPLETALK >,
; ---- PrinterSmarts -----------
PS_DUMB_RASTER,
;-------Custom Entry Routine-------
NULL,
;-------Custom Exit Routine-------
NULL,
; ---- Mode Info Offsets -------
offset cmylowRes,
NULL,
offset cmyhiRes,
NULL,
NULL,
; ---- Font Geometry -----------
NULL,
; ---- Symbol Set list -----------
NULL,
; ---- PaperMargins ------------
< PR_MARGIN_LEFT, ; Tractor Margins
PR_MARGIN_TOP,
PR_MARGIN_RIGHT,
PR_MARGIN_BOTTOM >,
< PR_MARGIN_LEFT, ; ASF Margins
PR_MARGIN_TOP,
PR_MARGIN_RIGHT,
PR_MARGIN_BOTTOM >,
; ---- PaperInputOptions -------
< MF_NO_MANUAL,
ASF_TRAY1,
TF_NO_TRACTOR >,
; ---- PaperOutputOptions ------
< OC_NO_COPIES,
PS_REVERSE,
OD_SIMPLEX,
SO_NO_STAPLER,
OS_NO_SORTER,
OB_NO_OUTPUTBIN >,
612, ; paper width (points)
NULL, ; Main UI
ASF1BinOptionsDialogBox,; Options UI
PrintEvalDummyASF ; eval routine address
>
;----------------------------------------------------------------------------
; Graphics modes info
;----------------------------------------------------------------------------
cmylowRes GraphicsProperties < LOW_RES_X_RES, ; xres
LOW_RES_Y_RES, ; yres
BAND_HEIGHT, ; band height
BUFF_HEIGHT, ; buffer height
INTERLEAVE_FACTOR, ; #interleaves
BMF_3CMY, ; color format
NULL > ; color correct
cmyhiRes GraphicsProperties < HI_RES_X_RES, ; xres
HI_RES_Y_RES, ; yres
BAND_HEIGHT, ; band height
BUFF_HEIGHT, ; buffer height
INTERLEAVE_FACTOR, ; #interleaves
BMF_3CMY, ; color format
NULL > ; color correct
cmyInfo ends
| 26.218182
| 79
| 0.465326
|
0dcf063fb7b77390a87d1e8060aa9d345bb46562
| 543
|
asm
|
Assembly
|
oeis/244/A244725.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/244/A244725.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/244/A244725.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A244725: a(n) = 5*n^3.
; 0,5,40,135,320,625,1080,1715,2560,3645,5000,6655,8640,10985,13720,16875,20480,24565,29160,34295,40000,46305,53240,60835,69120,78125,87880,98415,109760,121945,135000,148955,163840,179685,196520,214375,233280,253265,274360,296595,320000,344605,370440,397535,425920,455625,486680,519115,552960,588245,625000,663255,703040,744385,787320,831875,878080,925965,975560,1026895,1080000,1134905,1191640,1250235,1310720,1373125,1437480,1503815,1572160,1642545,1715000,1789555,1866240,1945085,2026120,2109375
pow $0,3
mul $0,5
| 90.5
| 498
| 0.815838
|
ec7186ee10334c9c7dc85c8e31ce8997f440f921
| 4,765
|
asm
|
Assembly
|
Graphics/TextHandler.asm
|
jaredwhitney/os3
|
05e0cda4670da093cc720d0dccbfeb29e788fa0f
|
[
"MIT"
] | 5
|
2015-02-25T01:28:09.000Z
|
2021-05-22T09:03:04.000Z
|
Graphics/TextHandler.asm
|
jaredwhitney/os3
|
05e0cda4670da093cc720d0dccbfeb29e788fa0f
|
[
"MIT"
] | 38
|
2015-02-10T18:37:11.000Z
|
2017-10-03T03:08:50.000Z
|
Graphics/TextHandler.asm
|
jaredwhitney/os3
|
05e0cda4670da093cc720d0dccbfeb29e788fa0f
|
[
"MIT"
] | 2
|
2016-05-06T22:48:46.000Z
|
2017-01-12T19:28:49.000Z
|
[bits 32]
newline equ 0x0A
endstring equ 0x0
;clearScreenG :
;pusha
;mov dx, 0x0
;mov ebx, [Dolphin.SCREEN_BUFFER]
;mov edx, ebx
;add edx, [Graphics.SCREEN_SIZE]
;csgloop :
;mov [ebx], dx
;add ebx, 0x2
;cmp ebx, edx
;jl csgloop
;mov ecx, [TextHandler.charpos]
;mov ecx, [Dolphin.SCREEN_BUFFER]
;mov [TextHandler.charpos], ecx
;popa
;ret
TextHandler.drawCharFromBitmap : ; ebx contains char to draw
methodTraceEnter
pusha
;mov [TextHandler.selectedColor], ah
mov dx, 0x0
TextHandler.drawCharloop :
; ah contains the current row of the char
mov ah, [ebx]
push ecx
mov ecx, [TextHandler.textSizeMultiplier]
TextHandler.drawCharLoop.FinishHeight :
call TextHandler.drawRow
sub ecx, 1
cmp ecx, 0x0
jg TextHandler.drawCharLoop.FinishHeight
pop ecx
add ebx, 0x1
add dx, 0x1
cmp dx, 0x7
jl TextHandler.drawCharloop
call TextHandler.drawSolidBacking
mov ecx, [TextHandler.charpos]
push eax
xor eax, eax
mov ax, [TextHandler.textWidth]
push ebx
mov ebx, 7
imul ebx, [TextHandler.textSizeMultiplier]
add ebx, 2
imul eax, ebx ; 1=9, 2=16, 3=23
pop ebx
;imul eax, [TextHandler.textSizeMultiplier]
sub ecx, eax
pop eax
push edx
push ecx
push eax
mov edx, [Graphics.bytesPerPixel]
imul edx, 6
imul edx, [TextHandler.textSizeMultiplier]
pop eax
pop ecx
add ecx, edx
pop edx
mov eax, [TextHandler.textWidth]
imul eax, 2
add ecx, eax
mov [TextHandler.charpos], ecx
popa
methodTraceLeave
ret
TextHandler.drawSolidBacking :
methodTraceEnter
pusha
mov dl, [TextHandler.solidChar]
cmp dl, 0x0
je TextHandler.drawSolidBacking.ret
mov ah, 0x0
call TextHandler.drawRow
call TextHandler.drawRow
push ecx
mov ecx, [TextHandler.charpos]
sub ecx, [TextHandler.textWidth]
sub ecx, [TextHandler.textWidth]
mov [TextHandler.charpos], ecx
pop ecx
TextHandler.drawSolidBacking.ret :
popa
methodTraceLeave
ret
TextHandler.drawRow : ; ah contains row
methodTraceEnter
pusha
mov ebx, [TextHandler.charpos]
;sub ebx, [bstor]
;add ebx, [Dolphin.cbuffer]
mov cl, 6
TextHandler.drawRowloop :
mov ch, ah
sub cl, 0x1
shr ch, cl
and ch, 0b1
cmp ch, 0b0
je TextHandler.drawRownd
mov dl, [Graphics.VESA_MODE]
cmp dl, 0x0
jne TextHandler.drawRowVESA ; should be jne
mov dl, [TextHandler.selectedColor]
push ecx
mov ecx, [TextHandler.textSizeMultiplier]
TextHandler.drawRowloop.FinishWidth :
mov [ebx], dl
add ebx, 1
sub ecx, 1
cmp ecx, 0x0
jg TextHandler.drawRowloop.FinishWidth
pop ecx
jmp TextHandler.drawRownddone
TextHandler.drawRowVESA :
mov edx, [TextHandler.selectedColor]
or edx, CHANGE_MASK
push ecx
mov ecx, [TextHandler.textSizeMultiplier]
TextHandler.drawRowloop.FinishWidthVESA :
mov [ebx], edx
add ebx, 4
sub ecx, 1
cmp ecx, 0x0
jg TextHandler.drawRowloop.FinishWidthVESA
pop ecx
jmp TextHandler.drawRownddone
TextHandler.drawRownd :
push dx
mov dl, [TextHandler.solidChar]
cmp dl, 0x0
je TextHandler.drawRownd.nodrawnodr
mov dl, 0x0
mov [ebx], dl
TextHandler.drawRownd.nodrawnodr :
push ecx ; advance to next char slot
mov ecx, [TextHandler.textSizeMultiplier]
imul ecx, [Graphics.bytesPerPixel]
add ebx, ecx
pop ecx
TextHandler.drawRownd.nodr :
pop dx
TextHandler.drawRownddone :
cmp cl, 0x0
jg TextHandler.drawRowloop
mov ecx, [TextHandler.charpos]
push eax
xor eax, eax
mov ax, [TextHandler.textWidth]
;push edx
;push ecx
;mov dl, [Graphics.VESA_MODE]
;cmp dl, 0x0
;je TextHandler.drawRownnddoneNOVESA
;imul eax, 0x2
;TextHandler.drawRownnddoneNOVESA :
;pop ecx
;pop edx
add ecx, eax
pop eax
mov [TextHandler.charpos], ecx
popa
methodTraceLeave
ret
TextHandler.newline :
methodTraceEnter
;mov eax, [TextHandler.charpos]
;mov bx, 0x0
;mov [eax], bx
mov eax, [TextHandler.charpos]
mov ecx, 0x0
add eax, 0x2
gnldloop :
sub eax, 0xA00
add ecx, 0x1
cmp eax, [Dolphin.SCREEN_BUFFER]
jg gnldloop
mov eax, ecx
mov ebx, 0xA00
mul ebx
add eax, [Dolphin.SCREEN_BUFFER]
mov [TextHandler.charpos], eax
methodTraceLeave
ret
TextHandler.drawChar : ; char in ax
methodTraceEnter
pusha
call TextHandler.getCharBitmap
call TextHandler.drawCharFromBitmap
popa
methodTraceLeave
ret
TextHandler.getCharBitmap :
methodTraceEnter
mov ebx, Font.bitmaps
mov edx, Font.order
graphicsgetposloop :
mov cl, [edx]
cmp al, cl
je graphicsgetposret
add ebx, 7
add edx, 1
mov cl, [edx]
cmp cl, 0xFF
je graphicsgetposret
jmp graphicsgetposloop
graphicsgetposret :
methodTraceLeave
ret
TextHandler.charpos :
dd 0x0
Graphics.bytesPerPixel :
dd 0x1
TextHandler.selectedColor :
dd 0xFFFFFF
TextHandler.solidChar :
db 0xFF, 0x0 ; (pad)
TextHandler.textWidth :
dd 0x0
TextHandler.charposStor :
dd 0x0
TextHandler.textSizeMultiplier :
dd 0x1
| 19.136546
| 60
| 0.740609
|
c6b19a5d4813a86d09f82a7c5a890dcd8744c10f
| 691
|
asm
|
Assembly
|
oeis/073/A073028.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/073/A073028.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/073/A073028.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A073028: a(n) = max{ C(n,0), C(n-1,1), C(n-2,2), ..., C(n-n,n) }.
; Submitted by Christian Krause
; 1,1,1,2,3,4,6,10,15,21,35,56,84,126,210,330,495,792,1287,2002,3003,5005,8008,12376,19448,31824,50388,77520,125970,203490,319770,497420,817190,1307504,2042975,3268760,5311735,8436285,13123110,21474180,34597290,54627300,86493225,141120525,225792840,354817320,573166440,927983760,1476337800,2319959400,3796297200,6107086800,9669554100,15471286560,25140840660,40225345056,63432274896,103077446706,166509721602,265182149218,421171648758,686353797976,1103068603890,1749695026860,2818953098830
pow $1,$0
lpb $0
sub $0,1
add $3,1
mov $2,$3
bin $2,$0
trn $2,$1
add $1,$2
lpe
mov $0,$1
| 46.066667
| 488
| 0.755427
|
288d857414a656c5ae566ce10e58536f409abdcf
| 450
|
asm
|
Assembly
|
libsrc/graphics/g800/drawr.asm
|
bahmanrafatjoo/z88dk
|
001b7eab7fa2e94ee7210ff483c789e15e8d6a40
|
[
"ClArtistic"
] | null | null | null |
libsrc/graphics/g800/drawr.asm
|
bahmanrafatjoo/z88dk
|
001b7eab7fa2e94ee7210ff483c789e15e8d6a40
|
[
"ClArtistic"
] | null | null | null |
libsrc/graphics/g800/drawr.asm
|
bahmanrafatjoo/z88dk
|
001b7eab7fa2e94ee7210ff483c789e15e8d6a40
|
[
"ClArtistic"
] | 1
|
2019-12-03T23:28:20.000Z
|
2019-12-03T23:28:20.000Z
|
SECTION code_clib
PUBLIC drawr
PUBLIC _drawr
EXTERN plotpixel
EXTERN draw_main
EXTERN last_pos
drawr:
_drawr:
push ix
ld ix,2
add ix,sp
ld de,(last_pos); x0/y0
ld h,(ix+4); xr
ld l,(ix+2); yr
ld a,h
add d
ld h,a
ld a,l
add e
ld l,a
push hl
push iy
ld iy,plotpixel
call draw_main
pop iy
pop hl
ld (last_pos),hl
pop ix
ret
| 10.97561
| 29
| 0.524444
|
4bd931d9b1d1776f15a3f0f475c6bfc0b224b317
| 211
|
asm
|
Assembly
|
WEEK-1/9.asm
|
ShruKin/Microprocessor-and-Microcontroller-Lab
|
279c1432f0dee01fae37dc8fcb1dcb798e5725d8
|
[
"MIT"
] | null | null | null |
WEEK-1/9.asm
|
ShruKin/Microprocessor-and-Microcontroller-Lab
|
279c1432f0dee01fae37dc8fcb1dcb798e5725d8
|
[
"MIT"
] | null | null | null |
WEEK-1/9.asm
|
ShruKin/Microprocessor-and-Microcontroller-Lab
|
279c1432f0dee01fae37dc8fcb1dcb798e5725d8
|
[
"MIT"
] | null | null | null |
// Write an 8085 assembly language program to add two 8-bit numbers in an 8085 microprocessor
LDA 9100
MOV B,A
LDA 9101
ADD B
MOV L,A
MVI A,00
ADC A
MOV H,A
SHLD 9200
HLT
| 17.583333
| 93
| 0.611374
|
14d8c3c6099695febccb757623e2ee1077cba573
| 670
|
asm
|
Assembly
|
oeis/124/A124644.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/124/A124644.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/124/A124644.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A124644: Mirror image of A098474 formatted as a triangular array.
; Submitted by Jon Maiga
; 1,1,1,2,2,1,5,6,3,1,14,20,12,4,1,42,70,50,20,5,1,132,252,210,100,30,6,1,429,924,882,490,175,42,7,1,1430,3432,3696,2352,980,280,56,8,1,4862,12870,15444,11088,5292,1764,420,72,9,1,16796,48620,64350,51480,27720,10584,2940,600,90,10,1,58786,184756,267410,235950,141570,60984,19404,4620,825,110,11,1,208012,705432,1108536,1069640,707850,339768,121968,33264,6930,1100,132,12,1,742900,2704156,4585308,4803656,3476330,1840410,736164,226512,54054
lpb $0
add $1,1
sub $0,$1
mov $2,$1
sub $2,$0
lpe
bin $1,$0
mov $0,2
mul $0,$2
bin $0,$2
add $2,1
div $0,$2
mul $1,$0
mov $0,$1
| 35.263158
| 439
| 0.713433
|
278fd27bf657d8a682b76343f1168a345488bcdc
| 807
|
asm
|
Assembly
|
programs/oeis/133/A133628.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/133/A133628.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/133/A133628.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A133628: a(1)=1, a(n) = a(n-1) + (p-1)*p^(n/2-1) if n is even, else a(n) = a(n-1) + p^((n-1)/2), where p=4.
; 1,4,8,20,36,84,148,340,596,1364,2388,5460,9556,21844,38228,87380,152916,349524,611668,1398100,2446676,5592404,9786708,22369620,39146836,89478484,156587348,357913940,626349396,1431655764,2505397588,5726623060,10021590356,22906492244,40086361428,91625968980,160345445716,366503875924,641381782868,1466015503700,2565527131476,5864062014804,10262108525908,23456248059220,41048434103636,93824992236884,164193736414548,375299968947540,656774945658196,1501199875790164,2627099782632788,6004799503160660
mov $1,1
mov $2,1
mov $3,1
lpb $0
sub $0,1
sub $1,$2
mul $3,2
mov $2,$3
add $2,$1
sub $3,1
mov $1,$3
add $3,1
add $1,$3
mul $1,2
sub $2,1
sub $1,$2
sub $1,1
add $2,1
lpe
| 35.086957
| 497
| 0.726146
|
d214554e8fc9143afd79808f752e75e6d3ac6f20
| 364
|
asm
|
Assembly
|
programs/oeis/278/A278312.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/278/A278312.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/278/A278312.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A278312: a(n) = denominator of n/(2^(2*n+1)).
; 1,8,16,128,128,2048,4096,32768,16384,524288,1048576,8388608,8388608,134217728,268435456,2147483648,536870912,34359738368,68719476736,549755813888,549755813888,8796093022208,17592186044416,140737488355328,70368744177664,2251799813685248
mul $0,2
mov $1,2
mov $2,2
add $2,$0
pow $1,$2
gcd $0,$1
div $1,$0
mov $0,$1
| 30.333333
| 237
| 0.760989
|
446ac1dff92b032cfd8f8c73fd98ef4d3a9e054c
| 656
|
asm
|
Assembly
|
MULTIPLEINPUTOUTPUT.asm
|
TashinAhmed/ASSEMBLY-LANGUAGE
|
fbda7c30f46f55eb3c1ce0907d22f99c2e8adf86
|
[
"MIT"
] | null | null | null |
MULTIPLEINPUTOUTPUT.asm
|
TashinAhmed/ASSEMBLY-LANGUAGE
|
fbda7c30f46f55eb3c1ce0907d22f99c2e8adf86
|
[
"MIT"
] | null | null | null |
MULTIPLEINPUTOUTPUT.asm
|
TashinAhmed/ASSEMBLY-LANGUAGE
|
fbda7c30f46f55eb3c1ce0907d22f99c2e8adf86
|
[
"MIT"
] | null | null | null |
; AUTHOR : TASHIN AHMED
.MODEL SMALL
.STACK 100h
.CODE
MAIN PROC
MOV AH , 1
INT 21h
MOV BL , AL
INT 21h
MOV BH , AL
INT 21h
MOV CL , AL
INT 21h
MOV CH , AL
INT 21h
MOV AH , 2
MOV DL , 10
INT 21h
MOV DL , 13
INT 21h
MOV AH , 2
INT 21h
MOV DL , BL
INT 21h
MOV DL , BH
INT 21h
MOV DL , CL
INT 21h
MOV DL , CH
INT 21h
MOV AH ,4CH
INT 21h
MAIN ENDP
END MAIN
| 16.820513
| 24
| 0.36128
|
6e43b764892cb5f62c149b60d5ea2b341f977c84
| 4,202
|
nasm
|
Assembly
|
napoca/kernel/cpu_state_defs.nasm
|
fengjixuchui/napoca
|
ed26609ab9a3ea12d12882b311dcb332dc759d32
|
[
"Apache-2.0"
] | 170
|
2020-07-30T15:04:59.000Z
|
2022-03-24T10:59:29.000Z
|
napoca/kernel/cpu_state_defs.nasm
|
a-cristi/napoca
|
ed6691125bf703366581e47a1fe789167009c24a
|
[
"Apache-2.0"
] | 3
|
2020-08-10T09:16:56.000Z
|
2022-02-18T21:40:43.000Z
|
napoca/kernel/cpu_state_defs.nasm
|
a-cristi/napoca
|
ed6691125bf703366581e47a1fe789167009c24a
|
[
"Apache-2.0"
] | 44
|
2020-07-30T15:06:55.000Z
|
2022-02-25T08:55:55.000Z
|
;
; Copyright (c) 2020 Bitdefender
; SPDX-License-Identifier: Apache-2.0
;
section .text
struc CPUSTATE_UNPACKED_DESCRIPTOR_DATA
.Limit resd 1
.Base resq 1
.AccessAndFlags resd 1
.Type resb 1
.System resb 1
.PrivilegeLevel resb 1
.Present resb 1
.Available resb 1
.Code64 resb 1
.BigOperands resb 1
.Granularity resb 1
endstruc
CPUSTATE_BAD_SELECTOR_ACCESS_RIGHTS equ (0xc093 | 0x10000)
struc CPUSTATE_FULL_SELECTOR_DATA
.Length resw 1
.Base resq 1
endstruc
struc CPUSTATE_GUEST_STATE_INFO ; 361 kbytes in size
.IsStructureInitialized resb 1
.Rax resq 1
.Rbx resq 1
.Rcx resq 1
.Rdx resq 1
.Rbp resq 1
.Rsi resq 1
.Rdi resq 1
.R8 resq 1
.R9 resq 1
.R10 resq 1
.R11 resq 1
.R12 resq 1
.R13 resq 1
.R14 resq 1
.R15 resq 1
.UsingFakedTr resb 1
.Es resw 1
.Cs resw 1
.Ss resw 1
.Ds resw 1
.Fs resw 1
.Gs resw 1
.Ldtr resw 1
.Tr resw 1
.LinkPointer resq 1
.Ia32Debugctl resq 1
.Ia32Pat resq 1
.Ia32Efer resq 1
.Ia32PerfGlobalCtrl resq 1
.Pdpte0 resq 1
.Pdpte1 resq 1
.Pdpte2 resq 1
.Pdpte3 resq 1
.EsLimit resd 1
.CsLimit resd 1
.SsLimit resd 1
.DsLimit resd 1
.FsLimit resd 1
.GsLimit resd 1
.LdtrLimit resd 1
.TrLimit resd 1
.GdtrLimit resd 1
.IdtrLimit resd 1
.EsAccessRights resd 1
.CsAccessRights resd 1
.SsAccessRights resd 1
.DsAccessRights resd 1
.FsAccessRights resd 1
.GsAccessRights resd 1
.LdtrAccessRights resd 1
.TrAccessRights resd 1
.InterruptibilityState resd 1
.ActivityState resd 1
.SmBase resd 1
.Ia32SysenterCs resd 1
.VmxPreemptionTimerValue resd 1
.Cr0 resq 1
.Cr2 resq 1
.Cr3 resq 1
.Cr4 resq 1
.Cr8 resq 1
.EsBase resq 1
.CsBase resq 1
.SsBase resq 1
.DsBase resq 1
.FsBase resq 1
.GsBase resq 1
.LdtrBase resq 1
.TrBase resq 1
.GdtrBase resq 1
.IdtrBase resq 1
.Dr7 resq 1
.Rsp resq 1
.Rip resq 1
.Rflags resq 1
.PendingDebugExceptions resq 1
.Ia32SysenterEsp resq 1
.Ia32SysenterEip resq 1
.Ia32KernelGsBase resq 1
.Star resq 1
.LStar resq 1
.CStar resq 1
;;;.Extensions resb (512+15) ; +15 so we can always get a 16-byte aligned 512 buffer
.Extensions resb (4096 + 63)
.LapicId resd 1
endstruc
| 35.310924
| 104
| 0.368396
|
37f7d3e888f6a047f5cc6661d8b37bbe99ccb010
| 419
|
asm
|
Assembly
|
oeis/107/A107409.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/107/A107409.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/107/A107409.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A107409: Each term is sum of three previous terms mod 10.
; Submitted by Jon Maiga
; 0,1,2,3,6,1,0,7,8,5,0,3,8,1,2,1,4,7,2,3,2,7,2,1,0,3,4,7,4,5,6,5,6,7,8,1,6,5,2,3,0,5,8,3,6,7,6,9,2,7,8,7,2,7,6,5,8,9,2,9,0,1,0,1,2,3,6,1,0,7,8,5,0,3,8,1,2,1,4,7,2,3,2,7,2,1,0,3,4,7,4,5,6,5,6,7,8,1,6,5
mov $1,2
mov $2,1
lpb $0
sub $0,1
sub $2,2
add $2,$1
add $1,$3
sub $1,$2
add $3,$2
add $2,$1
lpe
mov $0,$3
mod $0,10
| 23.277778
| 201
| 0.541766
|
81446df998ede4ccb2569831cd41d3cc0f55bca6
| 144
|
asm
|
Assembly
|
other.7z/SFC.7z/SFC/ソースデータ/ヨッシーアイランド/日本_Ver2/sfc/ys_w33.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
other.7z/SFC.7z/SFC/ソースデータ/ヨッシーアイランド/日本_Ver2/sfc/ys_w33.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
other.7z/SFC.7z/SFC/ソースデータ/ヨッシーアイランド/日本_Ver2/sfc/ys_w33.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
Name: ys_w33.asm
Type: file
Size: 18108
Last-Modified: '2016-05-13T04:51:43Z'
SHA-1: 67A1A6B12DFA0593D3AD658D65F498AB86AC5576
Description: null
| 20.571429
| 47
| 0.8125
|
cae150afcf056a0993dbbd0cf0409c9df341b385
| 5,914
|
asm
|
Assembly
|
Transynther/x86/_processed/NONE/_xt_/i9-9900K_12_0xca_notsx.log_21829_1234.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_1234.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_1234.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 %r9
push %rax
push %rbp
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_WT_ht+0x57d6, %rdx
nop
nop
add $13180, %rsi
vmovups (%rdx), %ymm0
vextracti128 $1, %ymm0, %xmm0
vpextrq $0, %xmm0, %rbp
and $65024, %rax
lea addresses_normal_ht+0xd9e, %rsi
lea addresses_A_ht+0x7786, %rdi
add $11727, %r9
mov $16, %rcx
rep movsb
nop
nop
nop
nop
xor $28928, %rax
lea addresses_D_ht+0xa51a, %r9
nop
dec %rcx
movw $0x6162, (%r9)
nop
sub $4545, %r9
lea addresses_normal_ht+0x146e6, %rdi
clflush (%rdi)
xor %rdx, %rdx
mov (%rdi), %rsi
nop
sub $26646, %rsi
lea addresses_WT_ht+0x15e76, %r9
nop
nop
nop
nop
add %rsi, %rsi
movb $0x61, (%r9)
nop
nop
cmp %rax, %rax
lea addresses_WT_ht+0x1bed6, %rbp
nop
nop
nop
nop
nop
add $18849, %rdx
mov $0x6162636465666768, %rdi
movq %rdi, %xmm5
movups %xmm5, (%rbp)
nop
nop
nop
nop
nop
add %rbp, %rbp
lea addresses_WT_ht+0x19cc6, %rsi
lea addresses_A_ht+0x8bd6, %rdi
clflush (%rdi)
nop
nop
nop
nop
nop
add $26784, %rax
mov $79, %rcx
rep movsq
nop
dec %rbp
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbp
pop %rax
pop %r9
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r14
push %r8
push %rax
push %rbx
// Store
lea addresses_WC+0x17bd6, %r14
nop
dec %r8
mov $0x5152535455565758, %r11
movq %r11, (%r14)
nop
nop
nop
cmp %r10, %r10
// Faulty Load
lea addresses_WC+0x153d6, %r14
nop
nop
nop
dec %r10
mov (%r14), %rbx
lea oracles, %r11
and $0xff, %rbx
shlq $12, %rbx
mov (%r11,%rbx,1), %rbx
pop %rbx
pop %rax
pop %r8
pop %r14
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WC', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 11}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_WC', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 7}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 1, 'type': 'addresses_normal_ht'}, 'dst': {'same': False, 'congruent': 4, 'type': 'addresses_A_ht'}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_D_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 2}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_normal_ht', 'NT': False, 'AVXalign': False, 'size': 8, 'congruent': 3}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 1, 'congruent': 5}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WT_ht', 'NT': False, 'AVXalign': False, 'size': 16, 'congruent': 8}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 4, 'type': 'addresses_WT_ht'}, 'dst': {'same': True, 'congruent': 10, 'type': 'addresses_A_ht'}}
{'38': 21829}
38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38 38
*/
| 40.786207
| 2,999
| 0.658607
|
0789918430fa1066d58c5dc47e2e8a31236657d5
| 465
|
asm
|
Assembly
|
programs/oeis/293/A293668.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/293/A293668.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/293/A293668.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A293668: First differences of A292046.
; 1,2,3,1,4,1,1,1,2,1,1,1,1,1,1,1,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1
mov $3,$0
mov $4,2
lpb $4
mov $0,$3
sub $4,1
add $0,$4
trn $0,1
seq $0,292046 ; The list of distinct values of A072464.
mov $2,$4
mul $2,$0
add $1,$2
mov $5,$0
lpe
min $3,1
mul $3,$5
sub $1,$3
mov $0,$1
| 22.142857
| 201
| 0.539785
|
93704a54d036eff9af3c14e75908d3b1dc636be0
| 24,696
|
asm
|
Assembly
|
main.asm
|
vipoo/bbcbasic-z80
|
793c16b76059edc6917e60c12281fb009d529ead
|
[
"Zlib"
] | 2
|
2020-06-30T15:43:19.000Z
|
2021-01-05T17:07:27.000Z
|
main.asm
|
vipoo/bbcbasic-z80
|
793c16b76059edc6917e60c12281fb009d529ead
|
[
"Zlib"
] | 6
|
2020-05-30T04:26:34.000Z
|
2020-07-21T02:43:24.000Z
|
main.asm
|
vipoo/bbcbasic-z80
|
793c16b76059edc6917e60c12281fb009d529ead
|
[
"Zlib"
] | null | null | null |
; TITLE BBC BASIC (C) R.T.RUSSELL 1987
;
;BBC BASIC INTERPRETER - Z80 VERSION
;COMMAND, ERROR AND LEXICAL ANALYSIS MODULE - "MAIN"
;(C) COPYRIGHT R.T.RUSSELL 1984
;VERSION 2.3, 07-05-1984
;VERSION 3.0, 01-03-1987
;
include "hbios.inc"
include "constants.inc"
include "version._inc"
EXTERN XEQ
EXTERN RUN0
EXTERN CHAIN0
EXTERN TERMQ
EXTERN MUL16
EXTERN X4OR5
EXTERN FILL
EXTERN ESCAPE
EXTERN CHECK
EXTERN SEARCH
;
EXTERN OSWRCH
EXTERN OSLINE
EXTERN OSINIT
EXTERN OSLOAD
EXTERN OSSAVE
EXTERN OSBGET
EXTERN OSBPUT
EXTERN OSSHUT
EXTERN OSSTAT
EXTERN PROMPT
EXTERN LTRAP
EXTERN OSCLI
EXTERN RESET
;
EXTERN COMMA
EXTERN BRAKET
EXTERN NXT
EXTERN ZERO
EXTERN ITEMI
EXTERN EXPRI
EXTERN EXPRS
EXTERN DECODE
EXTERN LOADN
EXTERN SFIX
;
PUBLIC OUTCHR
PUBLIC TKOUT
PUBLIC ERROR
PUBLIC EXTERR
PUBLIC REPORT
PUBLIC CLOOP
PUBLIC WARM
PUBLIC NEW
PUBLIC OLD
PUBLIC LOAD
PUBLIC SAVE
PUBLIC RENUMBER
PUBLIC AUTO
PUBLIC CLEAR
PUBLIC CRLF
PUBLIC SAYLN
PUBLIC LOAD0
PUBLIC TELL
PUBLIC FINDL
PUBLIC SETLIN
PUBLIC LIST
PUBLIC DELETE
PUBLIC GETVAR
PUBLIC PUTVAR
PUBLIC GETDEF
PUBLIC CREATE
PUBLIC PBCDL
PUBLIC LEXAN2
PUBLIC RANGE
PUBLIC TEXT
;
EXTERN PAGE
EXTERN ACCS
EXTERN BUFFER
EXTERN LINENO
EXTERN LOMEM
EXTERN HIMEM
EXTERN COUNT
EXTERN WIDTH
EXTERN TOP
EXTERN FREE
EXTERN STAVAR
EXTERN DYNVAR
EXTERN ERRTXT
EXTERN ERR
EXTERN ERL
EXTERN ERRLIN
EXTERN ERRTRP
EXTERN FNPTR
EXTERN PROPTR
EXTERN AUTONO
EXTERN INCREM
EXTERN LISTON
EXTERN TRACEN
EXTERN NUMTOSTR
EXTERN HBIOS_INIT
EXTERN KEYWDS, KEYWDL, ERRWDS
EXTERN TKR_LINE, TK_TOKLO, TK_TOKHI, TK_OFFSET, TKR_THEN, TKR_ELSE, TKR_ERROR
EXTERN TKE_DECODE, TKN_DATA, TKE_FN, TKN_RENUMBER, TKN_FOR, TKN_GOSUB, TKN_GOTO, TKN_IF, TKN_NEXT, TKN_PROC, TKN_REM, TKN_REPEAT, TKN_RESTOR, TKN_TRACE, TKN_UNTIL
EXTERN TK_EXTENDED
EXTERN PRTHL
ORG 100H
APPSTART:
COLD: LD HL,STAVAR ;COLD START
LD SP,HL
LD (HL),10
INC L
LD (HL),9
INC L
XOR A
PURGE: LD (HL),A ;CLEAR SCRATCHPAD
INC L
JR NZ,PURGE
LD A,37H ;V3.0
LD (LISTON),A
LD HL,NOTICE
LD (ERRTXT),HL
CALL OSINIT
LD DE, APPSTART ; HIMEM IS OUT START ADDRESS
LD HL, $100 ; START PROG AT ZERO PAGE
LD (HIMEM), DE
LD (PAGE), HL
CALL NEWIT
JP NZ,CHAIN0 ;AUTO-RUN
CALL HBIOS_INIT
CALL TELL
DEFM "DINO BASIC Version "
DEFM VERSIONSTAMP
DEFB CR
DEFB LF
DEFM "Assembled Date: "
DEFM BUILDTIME
DEFB CR
DEFB LF
DEFM "(C) Copyright Dean Netherton 2020"
DEFB CR
DEFB LF
DEFB 0
LD SP, (HIMEM)
LD HL, (HIMEM)
LD DE, (PAGE)
OR A
SBC HL, DE
CALL PRTHL
CALL TELL
DEFM " Free bytes"
DEFB CR
DEFB LF
DEFB CR
DEFB LF
DEFM "Based on BBC BASIC (Z80) Version 3.00 "
DEFB CR
DEFB LF
NOTICE: DEFM "(C) Copyright R.T.Russell 1987"
DEFB CR
DEFB LF
DEFB 0
WARM:
CLOOP: SCF
LD SP,(HIMEM)
CALL PROMPT ;PROMPT USER
LD HL,LISTON
LD A,(HL)
AND 0FH ;LISTO
OR 30H ;OPT 3
LD (HL),A
SBC HL,HL ;HL <- 0 (V3.0)
LD (ERRTRP),HL
LD (ERRLIN),HL
LD HL,(AUTONO)
LD (LINENO),HL
LD A,H
OR L
JR Z,NOAUTO
PUSH HL
CALL PBCD ;AUTO NUMBER
POP HL
LD BC,(INCREM)
LD B,0
ADD HL,BC
JP C,TOOBIG
LD (AUTONO),HL
LD A,' '
CALL OUTCHR
NOAUTO: LD HL,ACCS
CALL OSLINE ;GET CONSOLE INPUT
XOR A
LD (COUNT),A
LD IY,ACCS
CALL LINNUM
CALL NXT
LD A,H
OR L
JR Z,LNZERO ;FOR AUTO (NON-MAPPED)
LD (LINENO),HL
LNZERO: LD DE,BUFFER
LD C,1 ;LEFT MODE
CALL LEXAN2 ;LEXICAL ANALYSIS
LD (DE),A ;TERMINATOR
XOR A
LD B,A
LD C,E ;BC=LINE LENGTH
INC DE
LD (DE),A ;ZERO NEXT
LD HL,(LINENO)
LD A,H
OR L
LD IY,BUFFER ;FOR XEQ
JP Z,XEQ ;DIRECT MODE
PUSH BC
PUSH HL
CALL SETTOP ;SET TOP
POP HL
CALL FINDL
CALL Z,DEL
POP BC
LD A,C
OR A
JP Z,CLOOP ;DELETE LINE ONLY
ADD A,4
LD C,A ;LENGTH INCLUSIVE
PUSH DE ;LINE NUMBER
PUSH BC ;SAVE LINE LENGTH
EX DE,HL
LD HL,(TOP)
PUSH HL
ADD HL,BC
PUSH HL
INC H
XOR A
SBC HL,SP
POP HL
JP NC,ERROR ;"No room"
LD (TOP),HL
EX (SP),HL
PUSH HL
INC HL
OR A
SBC HL,DE
LD B,H ;BC=AMOUNT TO MOVE
LD C,L
POP HL
POP DE
JR Z,ATEND
LDDR ;MAKE SPACE
ATEND: POP BC ;LINE LENGTH
POP DE ;LINE NUMBER
INC HL
LD (HL),C ;STORE LENGTH
INC HL
LD (HL),E ;STORE LINE NUMBER
INC HL
LD (HL),D
INC HL
LD DE,BUFFER
EX DE,HL
DEC C
DEC C
DEC C
LDIR ;ADD LINE
CALL CLEAN
JP CLOOP
;
;COMMANDS:
;
;DELETE line,line
;
DELETE: CALL SETTOP ;SET TOP
CALL DLPAIR
DELET1: LD A,(HL)
OR A
JR Z,WARMNC
INC HL
LD E,(HL)
INC HL
LD D,(HL)
LD A,D
OR E
JR Z,CLOOP1 ;LINE NUMBER ZERO
DEC HL
DEC HL
EX DE,HL
SCF
SBC HL,BC
EX DE,HL
JR NC,WARMNC
PUSH BC
CALL DEL
POP BC
JR DELET1
;
;LISTO expr
;
LISTO: INC IY ;SKIP "O"
CALL EXPRI
EXX
LD A,L
LD (LISTON),A
CLOOP1: JP CLOOP
;
;LIST
;LIST line
;LIST line,line [IF string]
;LIST ,line
;LIST line,
;
LIST: CP 'O'
JR Z,LISTO
CALL DLPAIR
CALL NXT
CP TKN_IF ;IF CLAUSE ?
LD A,0 ;INIT IF-CLAUSE LENGTH
JR NZ,LISTB
INC IY ;SKIP IF
CALL NXT ;SKIP SPACES (IF ANY)
EX DE,HL
PUSH IY
POP HL ;HL ADDRESSES IF CLAUSE
LD A,CR
PUSH BC
LD BC,256
CPIR ;LOCATE CR
LD A,C
CPL ;A = SUBSTRING LENGTH
POP BC
EX DE,HL
LISTB: LD E,A ;IF-CLAUSE LENGTH
LD A,B
OR C
JR NZ,LISTA
DEC BC
LISTA: EXX
LD IX,LISTON
LD BC,0 ;INDENTATION COUNT
EXX
LD A,20
;
LISTC: PUSH BC ;SAVE HIGH LINE NUMBER
PUSH DE ;SAVE IF-CLAUSE LENGTH
PUSH HL ;SAVE PROGRAM POINTER
EX AF,AF'
LD A,(HL)
OR A
JR Z,WARMNC
;
;CHECK IF PAST TERMINATING LINE NUMBER:
;
LD A,E ;A = IF-CLAUSE LENGTH
INC HL
LD E,(HL)
INC HL
LD D,(HL) ;DE = LINE NUMBER
DEC HL
DEC HL
PUSH DE ;SAVE LINE NUMBER
EX DE,HL
SCF
SBC HL,BC
EX DE,HL
POP DE ;RESTORE LINE NUMBER
WARMNC: JP NC,WARM
LD C,(HL) ;C = LINE LENGTH + 4
LD B,A ;B = IF-CLAUSE LENGTH
;
;CHECK IF "UNLISTABLE":
;
LD A,D
OR E
JP Z,CLOOP
;
;CHECK FOR IF CLAUSE:
;
INC HL
INC HL
INC HL ;HL ADDRESSES LINE TEXT
DEC C
DEC C
DEC C
DEC C ;C = LINE LENGTH
PUSH DE ;SAVE LINE NUMBER
PUSH HL ;SAVE LINE ADDRESS
XOR A ;A <- 0
CP B ;WAS THERE AN IF-CLAUSE
PUSH IY
POP DE ;DE ADDRESSES IF-CLAUSE
CALL NZ,SEARCH ;SEARCH FOR IF CLAUSE
POP HL ;RESTORE LINE ADDRESS
POP DE ;RESTORE LINE NUMBER
PUSH IY
CALL Z,LISTIT ;LIST IF MATCH
POP IY
;
EX AF,AF'
DEC A
CALL LTRAP
POP HL ;RESTORE POINTER
LD E,(HL)
LD D,0
ADD HL,DE ;ADDRESS NEXT LINE
POP DE ;RESTORE IF-CLAUSE LEN
POP BC ;RESTORE HI LINE NUMBER
JR LISTC
;
;RENUMBER
;RENUMBER start
;RENUMBER start,increment
;RENUMBER ,increment
;
RENUMBER: CALL CLEAR ;USES DYNAMIC AREA
CALL PAIR ;LOAD HL,BC
EXX
LD HL,(PAGE)
LD DE,(LOMEM)
RENUM1: LD A,(HL) ;BUILD TABLE
OR A
JR Z,RENUM2
INC HL
LD C,(HL) ;OLD LINE NUMBER
INC HL
LD B,(HL)
LD A,B
OR C
JP Z,CLOOP ;LINE NUMBER ZERO
EX DE,HL
LD (HL),C
INC HL
LD (HL),B
INC HL
EXX
PUSH HL
ADD HL,BC ;ADD INCREMENT
JP C,TOOBIG ;"Too big"
EXX
POP BC
LD (HL),C
INC HL
LD (HL),B
INC HL
EX DE,HL
DEC HL
DEC HL
XOR A
LD B,A
LD C,(HL)
ADD HL,BC ;NEXT LINE
EX DE,HL
PUSH HL
INC H
SBC HL,SP
POP HL
EX DE,HL
JR C,RENUM1 ;CONTINUE
CALL EXTERR ;"RENUMBER space"
DEFB TKN_RENUMBER
DEFB 8
DEFB 0
;
RENUM2: EX DE,HL
LD (HL),-1
INC HL
LD (HL),-1
LD DE,(LOMEM)
EXX
LD HL,(PAGE)
RENUM3: LD C,(HL)
LD A,C
OR A
JP Z,WARM
EXX
EX DE,HL
INC HL
INC HL
LD E,(HL)
INC HL
LD D,(HL)
INC HL
PUSH DE
EX DE,HL
LD (LINENO),HL
EXX
POP DE
INC HL
LD (HL),E ;NEW LINE NUMBER
INC HL
LD (HL),D
INC HL
DEC C
DEC C
DEC C
LD B,0
RENUM7: LD A,TKE_DECODE
CPIR ;SEARCH FOR LINE NUMBER
JR NZ,RENUM3
PUSH BC
PUSH HL
PUSH HL
POP IY
EXX
CALL DECODE ;DECODE LINE NUMBER
EXX
LD B,H
LD C,L
LD HL,(LOMEM)
RENUM4: LD E,(HL) ;CROSS-REFERENCE TABLE
INC HL
LD D,(HL)
INC HL
EX DE,HL
OR A ;CLEAR CARRY
SBC HL,BC
EX DE,HL
LD E,(HL) ;NEW NUMBER
INC HL
LD D,(HL)
INC HL
JR C,RENUM4
EX DE,HL
JR Z,RENUM5 ;FOUND
CALL TELL
DEFM "Failed at "
DEFB 0
LD HL,(LINENO)
CALL PBCDL
CALL CRLF
JR RENUM6
RENUM5: POP DE
PUSH DE
DEC DE
CALL ENCODE ;RE-WRITE NUMBER
RENUM6: POP HL
POP BC
JR RENUM7
;
;AUTO
;AUTO start,increment
;AUTO start
;AUTO ,increment
;
AUTO: CALL PAIR
LD (AUTONO),HL
LD A,C
LD (INCREM),A
JR CLOOP0
;
;BAD
;NEW
;
BAD: CALL TELL ;"Bad program"
DEFB 3
DEFM "program"
DEFB CR
DEFB LF
DEFB 0
NEW: CALL NEWIT
JR CLOOP0
;
;OLD
;
OLD: LD HL,(PAGE)
PUSH HL
INC HL
INC HL
INC HL
LD BC,252
LD A,CR
CPIR
JR NZ,BAD
LD A,L
POP HL
LD (HL),A
CALL CLEAN
CLOOP0: JP CLOOP
;
;LOAD filename
;
LOAD: CALL EXPRS ;GET FILENAME
LD A,CR
LD (DE),A
CALL LOAD0
CALL CLEAR
JR WARM0
;
;SAVE filename
;
SAVE: CALL SETTOP ;SET TOP
CALL EXPRS ;FILENAME
LD A,CR
LD (DE),A
LD DE,(PAGE)
LD HL,(TOP)
OR A
SBC HL,DE
LD B,H ;LENGTH OF PROGRAM
LD C,L
LD HL,ACCS
CALL OSSAVE
WARM0: JP WARM
;
;ERROR
;
ERROR: LD SP,(HIMEM)
LD HL,ERRWDS
OR A
JR Z,ERROR1
LD B,A ;ERROR NUMBER
EX AF,AF'
XOR A
ERROR0: CP (HL)
INC HL
JR NZ,ERROR0
DJNZ ERROR0
EX AF,AF'
ERROR1: PUSH HL
EXTERR: POP HL
LD (ERRTXT),HL
LD SP,(HIMEM)
LD (ERR),A
CALL SETLIN
LD (ERL),HL
OR A
JR Z,ERROR2
LD HL,(ERRTRP)
LD A,H
OR L
PUSH HL
POP IY
JP NZ,XEQ ;ERROR TRAPPED
ERROR2: LD HL,0
LD (AUTONO),HL
LD (TRACEN),HL ;CANCEL TRACE
CALL RESET ;RESET OPSYS
CALL CRLF
CALL REPORT ;MESSAGE
CALL SAYLN
LD E,0
CALL C,OSSHUT ;CLOSE ALL FILES
CALL CRLF
JP CLOOP
;
;SUBROUTINES:
;
;
;LEX - SEARCH FOR KEYWORDS
; Inputs: HL = start of keyword table
; IY = start of match text
; Outputs: If found, Z-flag set, A=token.
; If not found, Z-flag reset, A=(IY).
; IY updated (if NZ, IY unchanged).
; Destroys: A,B,H,L,IY,F
;
LEX: LD HL, KEYWDS
LEX0: LD A,(IY)
LD B,(HL)
EX AF, AF
LD A, B
CP TK_EXTENDED
JR NZ, LEX_NOT_EXTENDED
INC HL
LD A, (HL) ; PLACE EXTENDED TOKEN IN A'
LEX_NOT_EXTENDED:
EX AF, AF
INC HL
CP (HL)
JR Z,LEX2
RET C ;FAIL EXIT
LEX1: INC HL
BIT 7,(HL)
JR Z,LEX1
JR LEX0
LEX2: PUSH IY ;SAVE POINTER
LEX3: INC HL
BIT 7,(HL)
JR NZ,LEX6 ;FOUND
INC IY
LD A,(IY)
CP '.'
JR Z,LEX6 ;FOUND (ABBREV.)
CP (HL)
JR Z,LEX3
CALL RANGE1
JR C,LEX5
LEX4: POP IY ;RESTORE POINTER
JR LEX1
LEX5: LD A,(HL)
OR A
JR NZ,LEX4
DEC IY
LEX6: POP AF
XOR A
LD A,B
RET
;
;DEL - DELETE A PROGRAM LINE.
; Inputs: HL addresses program line.
; Destroys: B,C,F
;
DEL: PUSH DE
PUSH HL
PUSH HL
LD B,0
LD C,(HL)
ADD HL,BC
PUSH HL
EX DE,HL
LD HL,(TOP)
SBC HL,DE
LD B,H
LD C,L
POP HL
POP DE
LDIR ;DELETE LINE
LD (TOP),DE
POP HL
POP DE
RET
;
;LOAD0 - LOAD A DISK FILE THEN CLEAN.
; Inputs: Filename in ACC$ (term CR)
; Destroys: A,B,C,D,E,H,L,F
;
;CLEAN - CHECK FOR BAD PROGRAM, FIND END OF TEXT
; AND WRITE FF FF, THEN LOAD (TOP).
; Destroys: A,B,C,H,L,F
;
LOAD0: LD DE,(PAGE)
LD HL,-256
ADD HL,SP
SBC HL,DE ;FIND AVAILABLE SPACE
LD B,H
LD C,L
LD HL,ACCS
CALL OSLOAD ;LOAD
CALL NC,NEWIT
LD A,0
JP NC,ERROR ;"No room"
CLEAN: CALL SETTOP
DEC HL
LD (HL),-1 ;WRITE &FFFF
DEC HL
LD (HL),-1
JR CLEAR
;
SETTOP: LD HL,(PAGE)
LD B,0
LD A,CR
SETOP1: LD C,(HL)
INC C
DEC C
JR Z,SETOP2
ADD HL,BC
DEC HL
CP (HL)
INC HL
JR Z,SETOP1
JP BAD
SETOP2: INC HL ;N.B. CALLED FROM NEWIT
INC HL
INC HL
LD (TOP),HL
RET
;
;NEWIT - NEW PROGRAM THEN CLEAR
; Destroys: H,L
;
;CLEAR - CLEAR ALL DYNAMIC VARIABLES INCLUDING
; FUNCTION AND PROCEDURE POINTERS.
; Destroys: Nothing
;
NEWIT: LD HL,(PAGE)
LD (HL),0
CALL SETOP2
CLEAR: PUSH HL
LD HL,(TOP)
LD (LOMEM),HL
LD (FREE),HL
LD HL,DYNVAR
PUSH BC
LD B,2*(54+2)
CLEAR1: LD (HL),0
INC HL
DJNZ CLEAR1
POP BC
POP HL
RET
;
;LISTIT - LIST A PROGRAM LINE.
; Inputs: HL addresses line
; DE = line number (binary)
; IX addresses LISTON
; Destroys: A,D,E,B',C',D',E',H',L',IY,F
;
LISTIT: PUSH HL
EX DE,HL
PUSH BC
CALL PBCD
POP BC
POP HL
LD A,(HL)
CP TKN_NEXT
CALL Z,INDENT
CP TKN_UNTIL
CALL Z,INDENT
EXX
LD A,' '
BIT 0,(IX)
CALL NZ,OUTCHR
LD A,B
ADD A,A
BIT 1,(IX)
CALL NZ,FILL
LD A,C
ADD A,A
BIT 2,(IX)
CALL NZ,FILL
EXX
LD A,(HL)
CP TKN_FOR
CALL Z,INDENT
CP TKN_REPEAT
CALL Z,INDENT
LD E,0
LIST8: LD A,(HL)
INC HL
CP CR
JR Z,CRLF
CP DOUBLE_QUOTE
JR NZ,LIST7
INC E
LIST7: CALL LOUT
JR LIST8
;
PRLINO: PUSH HL
POP IY
PUSH BC
CALL DECODE
POP BC
EXX
PUSH BC
CALL PBCDL
POP BC
EXX
PUSH IY
POP HL
RET
;
LOUT: BIT 0,E
JR NZ,OUTCHR
CP TKE_DECODE
JR Z,PRLINO
CP TK_EXTENDED
JR NZ, LOUT1
EX AF, AF ; IF EXTENDED, RETREIEVE EXTENDED TOKEN INTO A'
LD A, (HL)
INC HL
EX AF, AF
LOUT1: CALL TKOUT
LD A,(HL)
INDENT: EXX
CP TKN_FOR
JR Z,IND1
CP TKN_NEXT
JR NZ,IND2
DEC B
JP P,IND2
IND1: INC B
IND2: CP TKN_REPEAT
JR Z,IND3
CP TKN_UNTIL
JR NZ,IND4
DEC C
JP P,IND4
IND3: INC C
IND4: EXX
RET
;
;CRLF - SEND CARRIAGE RETURN, LINE FEED.
; Destroys: A,F
;OUTCHR - OUTPUT A CHARACTER TO CONSOLE.
; Inputs: A = character
; Destroys: A,F
;
CRLF: LD A,CR
CALL OUTCHR
LD A,LF
OUTCHR: CALL OSWRCH
SUB CR
JR Z,CARRET
RET C ;NON-PRINTING
LD A,(COUNT)
INC A
CARRET: LD (COUNT),A
RET Z
PUSH HL
LD HL,(WIDTH)
CP L
POP HL
RET NZ
JR CRLF
;
;TKOUT - SEND CHARACTER OR KEYWORD
; Inputs: A = character (>=10, <128)
; A = Token (<10, >=128)
; IF A == TK_EXTENDED (FF), THEN A' IS THE EXTENDED TOKEN VALUE
; Destroys: A,F
;
TKOUT: CP 138
JP PE,OUTCHR
PUSH BC
PUSH HL
LD HL,KEYWDS
LD BC,KEYWDL
TOKEN1:
CPIR
CP TK_EXTENDED
JR NZ, TOKEN2
EX AF, AF
CP (HL) ; CHECK EXTENDED TOKEN
INC HL
JR Z, TOKEN2 ; IF NO SAME, CONTINUE SEARCH
EX AF, AF
JR TOKEN1
TOKEN2: LD A,(HL)
INC HL
CP 138
PUSH AF
CALL PE,OUTCHR
POP AF
JP PE,TOKEN2
POP HL
POP BC
RET
;
;FINDL - FIND PROGRAM LINE.
; Inputs: HL = line number (binary)
; Outputs: HL addresses line (if found)
; DE = line number
; Z-flag set if found.
; Destroys: A,B,C,D,E,H,L,F
;
FINDL: EX DE,HL
LD HL,(PAGE)
XOR A ;A=0
CP (HL)
INC A
RET NC
XOR A ;CLEAR CARRY
LD B,A
FINDL1: LD C,(HL)
PUSH HL
INC HL
LD A,(HL)
INC HL
LD H,(HL)
LD L,A
SBC HL,DE
POP HL
RET NC ;FOUND OR PAST
ADD HL,BC
JP FINDL1
;
;SETLIN - Search program for line containing address.
; Update (LINENO).
; Inputs: Address in (ERRLIN)
; Outputs: Line number in HL and (LINENO)
; Destroys: B,C,D,E,H,L,F
;
SETLIN: LD B,0
LD DE,(ERRLIN)
LD HL,(PAGE)
OR A
SBC HL,DE
ADD HL,DE
JR NC,SET3
SET1: LD C,(HL)
INC C
DEC C
JR Z,SET3
ADD HL,BC
SBC HL,DE
ADD HL,DE
JR C,SET1
SBC HL,BC
INC HL
LD E,(HL) ;LINE NUMBER
INC HL
LD D,(HL)
EX DE,HL
SET2: LD (LINENO),HL
RET
SET3: LD HL,0
JR SET2
;
;SAYLN - PRINT " at line nnnn" MESSAGE.
; Outputs: Carry=0 if line number is zero.
; Carry=1 if line number is non-zero.
; Destroys: A,B,C,D,E,H,L,F
;
SAYLN: LD HL,(LINENO)
LD A,H
OR L
RET Z
CALL TELL
DEFM " at line "
DEFB 0
PBCDL: LD C,0
JR PBCD0
;
;PBCD - PRINT NUMBER AS DECIMAL INTEGER.
; Inputs: HL = number (binary).
; Outputs: Carry = 1
; Destroys: A,B,C,D,E,H,L,F
;
PBCD: LD C,' '
PBCD0: LD B,5
LD DE,10000
PBCD1: XOR A
PBCD2: SBC HL,DE
INC A
JR NC,PBCD2
ADD HL,DE
DEC A
JR Z,PBCD3
SET 4,C
SET 5,C
PBCD3: OR C
CALL NZ,OUTCHR
LD A,B
CP 5
JR Z,PBCD4
ADD HL,HL
LD D,H
LD E,L
ADD HL,HL
ADD HL,HL
ADD HL,DE
PBCD4: LD DE,1000
DJNZ PBCD1
SCF
RET
;
;PUTVAR - CREATE VARIABLE AND INITIALISE TO ZERO.
; Inputs: HL, IY as returned from GETVAR (NZ).
; Outputs: As GETVAR.
; Destroys: everything
;
PUTVAR: CALL CREATE
LD A,(IY)
CP '('
JR NZ,GETVZ ;SET EXIT CONDITIONS
ARRAY: LD A,14 ;'Array'
ERROR3: JP ERROR
;
;GETVAR - GET LOCATION OF VARIABLE, RETURN IN HL & IX
; Inputs: IY addresses first character.
; Outputs: Carry set and NZ if illegal character.
; Z-flag set if variable found, then:
; A = variable type (0,4,5,128 or 129)
; HL = IX = variable pointer.
; IY updated
; If Z-flag & carry reset, then:
; HL, IY set for subsequent PUTVAR call.
; Destroys: everything
;
GETVAR: LD A,(IY)
CP '$'
JR Z,GETV4
CP '!!'
JR Z,GETV5
CP '?'
JR Z,GETV6
CALL LOCATE
RET NZ
LD A,(IY)
CP '(' ;ARRAY?
JR NZ,GETVX ;EXIT
PUSH DE ;SAVE TYPE
LD A,(HL) ;NO. OF DIMENSIONS
OR A
JR Z,ARRAY
INC HL
LD DE,0 ;ACCUMULATOR
PUSH AF
INC IY ;SKIP (
JR GETV3
GETV2: PUSH AF
CALL COMMA
GETV3: PUSH HL
PUSH DE
CALL EXPRI ;SUBSCRIPT
EXX
POP DE
EX (SP),HL
LD C,(HL)
INC HL
LD B,(HL)
INC HL
EX (SP),HL
EX DE,HL
PUSH DE
CALL MUL16 ;HL=HL*BC
POP DE
ADD HL,DE
EX DE,HL
OR A
SBC HL,BC
LD A,15
JR NC,ERROR3 ;"Subscript"
POP HL
POP AF
DEC A ;DIMENSION COUNTER
JR NZ,GETV2
CALL BRAKET ;CLOSING BRACKET
POP AF ;RESTORE TYPE
PUSH HL
CALL X4OR5 ;DE=DE*n
POP HL
ADD HL,DE
LD D,A ;TYPE
LD A,(IY)
GETVX: CP '?'
JR Z,GETV9
CP '!!'
JR Z,GETV8
GETVZ: PUSH HL ;SET EXIT CONDITIONS
POP IX
LD A,D
CP A
RET
;
;PROCESS UNARY & BINARY INDIRECTION:
;
GETV4: LD A,128 ;STATIC STRING
JR GETV7
GETV5: LD A,4 ;UNARY 32-BIT INDIRN.
JR GETV7
GETV6: XOR A ;UNARY 8-BIT INDIRECTION
GETV7: LD HL,0
PUSH AF
JR GETV0
;
GETV8: LD B,4 ;32-BIT BINARY INDIRN.
JR GETVA
GETV9: LD B,0 ;8-BIT BINARY INDIRN.
GETVA: PUSH HL
POP IX
LD A,D ;TYPE
CP 129
RET Z ;STRING!
PUSH BC
CALL LOADN ;LEFT OPERAND
CALL SFIX
EXX
GETV0: PUSH HL
INC IY
CALL ITEMI
EXX
POP DE
POP AF
ADD HL,DE
PUSH HL
POP IX
CP A
RET
;
;GETDEF - Find entry for FN or PROC in dynamic area.
; Inputs: IY addresses byte following "DEF" token.
; Outputs: Z flag set if found
; Carry set if neither FN or PROC first.
; If Z: HL points to entry
; IY addresses delimiter
; Destroys: A,D,E,H,L,IY,F
;
GETDEF: LD A,(IY+1)
CALL RANGE1
RET C
LD A,(IY)
LD HL,FNPTR
CP TKE_FN
JR Z,LOC2
LD HL,PROPTR
CP TKN_PROC
JR Z,LOC2
SCF
RET
;
;LOCATE - Try to locate variable name in static or
;dynamic variables. If illegal first character return
;carry, non-zero. If found, return no-carry, zero.
;If not found, return no-carry, non-zero.
; Inputs: IY addresses first character of name.
; A=(IY)
; Outputs: Z-flag set if found, then:
; IY addresses terminator
; HL addresses location of variable
; D=type of variable: 4 = integer
; 5 = floating point
; 129 = string
; Destroys: A,D,E,H,L,IY,F
;
LOCATE: SUB '@'
RET C
LD H,0
CP 'Z'-'@'+1
JR NC,LOC0 ;NOT STATIC
ADD A,A
LD L,A
LD A,(IY+1) ;2nd CHARACTER
CP '%'
JR NZ,LOC1 ;NOT STATIC
LD A,(IY+2)
CP '('
JR Z,LOC1 ;NOT STATIC
ADD HL,HL
LD DE,STAVAR ;STATIC VARIABLES
ADD HL,DE
INC IY
INC IY
LD D,4 ;INTEGER TYPE
XOR A
RET
;
LOC0: CP '_'-'@'
RET C
CP 'z'-'@'+1
CCF
DEC A ;SET NZ
RET C
SUB 3
ADD A,A
LD L,A
LOC1: LD DE,DYNVAR ;DYNAMIC VARIABLES
DEC L
DEC L
SCF
RET M
ADD HL,DE
LOC2: LD E,(HL)
INC HL
LD D,(HL)
LD A,D
OR E
JR Z,LOC6 ;UNDEFINED VARIABLE
LD H,D
LD L,E
INC HL ;SKIP LINK
INC HL
PUSH IY
LOC3: LD A,(HL) ;COMPARE
INC HL
INC IY
CP (IY)
JR Z,LOC3
OR A ;0=TERMINATOR
JR Z,LOC5 ;FOUND (MAYBE)
LOC4: POP IY
EX DE,HL
JP LOC2 ;TRY NEXT ENTRY
;
LOC5: DEC IY
LD A,(IY)
CP '('
JR Z,LOC5A ;FOUND
INC IY
CALL RANGE
JR C,LOC5A ;FOUND
CP '('
JR Z,LOC4 ;KEEP LOOKING
LD A,(IY-1)
CALL RANGE1
JR NC,LOC4 ;KEEP LOOKING
LOC5A: POP DE
TYPE: LD A,(IY-1)
CP '$'
LD D,129
RET Z ;STRING
CP '%'
LD D,4
RET Z ;INTEGER
INC D
CP A
RET
;
LOC6: INC A ;SET NZ
RET
;
;CREATE - CREATE NEW ENTRY, INITIALISE TO ZERO.
; Inputs: HL, IY as returned from LOCATE (NZ).
; Outputs: As LOCATE, GETDEF.
; Destroys: As LOCATE, GETDEF.
;
CREATE: XOR A
LD DE,(FREE)
LD (HL),D
DEC HL
LD (HL),E
EX DE,HL
LD (HL),A
INC HL
LD (HL),A
INC HL
LOC7: INC IY
CALL RANGE ;END OF VARIABLE?
JR C,LOC8
LD (HL),A
INC HL
CALL RANGE1
JR NC,LOC7
CP '('
JR Z,LOC8
LD A,(IY+1)
CP '('
JR Z,LOC7
INC IY
LOC8: LD (HL),0 ;TERMINATOR
INC HL
PUSH HL
CALL TYPE
LD A,5
CP D
JR Z,LOC9
DEC A
LOC9: LD (HL),0 ;INITIALISE TO ZERO
INC HL
DEC A
JR NZ,LOC9
LD (FREE),HL
CALL CHECK
POP HL
XOR A
RET
;
;LINNUM - GET LINE NUMBER FROM TEXT STRING
; Inputs: IY = Text Pointer
; Outputs: HL = Line number (zero if none)
; IY updated
; Destroys: A,D,E,H,L,IY,F
;
LINNUM: CALL NXT
LD HL,0
LINNM1: LD A,(IY)
SUB '0'
RET C
CP 10
RET NC
INC IY
LD D,H
LD E,L
ADD HL,HL ;*2
JR C,TOOBIG
ADD HL,HL ;*4
JR C,TOOBIG
ADD HL,DE ;*5
JR C,TOOBIG
ADD HL,HL ;*10
JR C,TOOBIG
LD E,A
LD D,0
ADD HL,DE ;ADD IN DIGIT
JR NC,LINNM1
TOOBIG: LD A,20
JP ERROR ;"Too big"
;
;PAIR - GET PAIR OF LINE NUMBERS FOR RENUMBER/AUTO.
; Inputs: IY = text pointer
; Outputs: HL = first number (10 by default)
; BC = second number (10 by default)
; Destroys: A,B,C,D,E,H,L,B',C',D',E',H',L',IY,F
;
PAIR: CALL LINNUM ;FIRST
LD A,H
OR L
JR NZ,PAIR1
LD L,10
PAIR1: CALL TERMQ
INC IY
PUSH HL
LD HL,10
CALL NZ,LINNUM ;SECOND
EX (SP),HL
POP BC
LD A,B
OR C
RET NZ
CALL EXTERR
DEFM "Silly"
DEFB 0
;
;DLPAIR - GET PAIR OF LINE NUMBERS FOR DELETE/LIST.
; Inputs: IY = text pointer
; Outputs: HL = points to program text
; BC = second number (0 by default)
; Destroys: A,B,C,D,E,H,L,IY,F
;
DLPAIR: CALL LINNUM
PUSH HL
CALL TERMQ
JR Z,DLP1
CP TKN_IF
JR Z,DLP1
INC IY
CALL LINNUM
DLP1: EX (SP),HL
CALL FINDL
POP BC
RET
;
;TEST FOR VALID CHARACTER IN VARIABLE NAME:
; Inputs: IY addresses character
; Outputs: Carry set if out-of-range.
; Destroys: A,F
;
RANGE: LD A,(IY)
CP '$'
RET Z
CP '%'
RET Z
CP '('
RET Z
RANGE1: CP '0'
RET C
CP '9'+1
CCF
RET NC
CP '@' ;V2.4
RET Z
RANGE2: CP 'A'
RET C
CP 'Z'+1
CCF
RET NC
CP '_'
RET C
CP 'z'+1
CCF
RET
;
SPACE: XOR A
CALL EXTERR ;"LINE space"
DEFB TKR_LINE
DEFB 8
DEFB 0
;
;LEXAN - LEXICAL ANALYSIS.
; Bit 0,C: 1=left, 0=right
; Bit 3,C: 1=in HEX
; Bit 4,C: 1=accept line number
; Bit 5,C: 1=in variable, FN, PROC
; Bit 6,C: 1=in REM, DATA, *
; Bit 7,C: 1=in quotes
; Inputs: IY addresses source string
; DE addresses destination string
; (must be page boundary)
; C sets initial mode
; Outputs: DE, IY updated
; A holds carriage return
;
LEXAN1: LD (DE),A ;TRANSFER TO BUFFER
CP TK_EXTENDED
JR NZ, LEXAN_NOT_EXTENDED
EX AF, AF ; STORE THE EXTENDED TOKEN VALUE
INC DE
LD (DE), A
EX AF, AF
LEXAN_NOT_EXTENDED:
INC DE ;INCREMENT POINTERS
INC IY
LEXAN2: LD A,E ;MAIN ENTRY
CP 252 ;TEST LENGTH
JR NC,SPACE ;LINE TOO LONG
LD A,(IY)
CP CR
RET Z ;END OF LINE
CALL RANGE1
JR NC,LEXAN3
RES 5,C ;NOT IN VARIABLE
RES 3,C ;NOT IN HEX
LEXAN3: CP ' '
JR Z,LEXAN1 ;PASS SPACES
CP ','
JR Z,LEXAN1 ;PASS COMMAS
CP 'G'
JR C,LEXAN4
RES 3,C ;NOT IN HEX
LEXAN4: CP DOUBLE_QUOTE
JR NZ,LEXAN5
RL C
CCF ;TOGGLE C7
RR C
LEXAN5: BIT 4,C
JR Z,LEXAN6
RES 4,C
PUSH BC
PUSH DE
CALL LINNUM ;GET LINE NUMBER
POP DE
POP BC
LD A,H
OR L
CALL NZ,ENCODE ;ENCODE LINE NUMBER
JR LEXAN2 ;CONTINUE
;
LEXAN6: DEC C
JR Z,LEXAN7 ;C=1 (LEFT)
INC C
JR NZ,LEXAN1
OR A
CALL P,LEX ;TOKENISE IF POSS.
JR LEXAN8
;
LEXAN7: CP '*'
JR Z,LEXAN9
OR A
CALL P,LEX ;TOKENISE IF POSS.
CP TK_TOKLO
JR C,LEXAN8
CP TK_TOKHI+1
JR NC,LEXAN8
ADD A,TK_OFFSET ;LEFT VERSION
LEXAN8: CP TKN_REM
JR Z,LEXAN9
CP TKN_DATA
JR NZ,LEXANA
LEXAN9: SET 6,C ;QUIT TOKENISING
LEXANA: CP TKE_FN
JR Z,LEXANB
CP TKN_PROC
JR Z,LEXANB
CALL RANGE2
JR C,LEXANC
LEXANB: SET 5,C ;IN VARIABLE/FN/PROC
LEXANC: CP '&'
JR NZ,LEXAND
SET 3,C ;IN HEX
LEXAND: LD HL,LIST1
PUSH BC
LD BC,LIST1L
CPIR
POP BC
JR NZ,LEXANE
SET 4,C ;ACCEPT LINE NUMBER
LEXANE: LD HL,LIST2
PUSH BC
LD BC,LIST2L
CPIR
POP BC
JR NZ,LEXANF
SET 0,C ;ENTER LEFT MODE
LEXANF: JP LEXAN1
;
LIST1: DEFB TKN_GOTO
DEFB TKN_GOSUB
DEFB TKN_RESTOR
DEFB TKN_TRACE
LIST2: DEFB TKR_THEN
DEFB TKR_ELSE
LIST1END:
LIST1L EQU LIST1END - LIST1 ; $-LIST1
DEFB TKN_REPEAT
DEFB TKR_ERROR
DEFB ':'
LIST2END:
LIST2L EQU LIST2END - LIST2 ;$-LIST2
;
;ENCODE - ENCODE LINE NUMBER INTO PSEUDO-BINARY FORM.
; Inputs: HL=line number, DE=string pointer
; Outputs: DE updated, BIT 4,C set.
; Destroys: A,B,C,D,E,H,L,F
;
ENCODE: SET 4,C
EX DE,HL
LD (HL),TKE_DECODE
INC HL
LD A,D
AND 0C0H
RRCA
RRCA
LD B,A
LD A,E
AND 0C0H
OR B
RRCA
RRCA
XOR 01010100B
LD (HL),A
INC HL
LD A,E
AND 3FH
OR '@'
LD (HL),A
INC HL
LD A,D
AND 3FH
OR '@'
LD (HL),A
INC HL
EX DE,HL
RET
;
;TEXT - OUTPUT MESSAGE.
; Inputs: HL addresses text (terminated by nul)
; Outputs: HL addresses character following nul.
; Destroys: A,H,L,F
;
REPORT: LD HL,(ERRTXT)
TEXT: LD A,(HL)
INC HL
OR A
RET Z
CALL TKOUT
JR TEXT
;
;TELL - OUTPUT MESSAGE.
; Inputs: Text follows subroutine call (term=nul)
; Destroys: A,F
;
TELL: EX (SP),HL ;GET RETURN ADDRESS
CALL TEXT
EX (SP),HL
RET
PRTHL: ; PRINT in DECIMAL, the 16bit number in HL
EXX
LD HL, 0
LD C, 0
LD DE, ACCS
LD IX, NO_FORMAT
CALL NUMTOSTR
EX DE, HL
LD (HL), 0
LD HL, ACCS
JP TEXT
NO_FORMAT:
DEFB 0
DEFB 0
DEFB 0
DEFB 0
| 14.743881
| 163
| 0.650186
|
0da94b1225ae42f30fc05f1ee3dce1dad9817254
| 420
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/math/float/math48/c/sdcc_iy/cm48_sdcciyp_ds2slong_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/_DEVELOPMENT/math/float/math48/c/sdcc_iy/cm48_sdcciyp_ds2slong_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/_DEVELOPMENT/math/float/math48/c/sdcc_iy/cm48_sdcciyp_ds2slong_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
; signed long __fs2slong_callee(float f)
SECTION code_clib
SECTION code_fp_math48
PUBLIC cm48_sdcciyp_ds2slong_callee
EXTERN cm48_sdcciyp_dcallee1, am48_dfix32
cm48_sdcciyp_ds2slong_callee:
; double to signed long
;
; enter : stack = sdcc_float x, ret
;
; exit : dehl = (long)(x)
;
; uses : af, bc, de, hl, bc', de', hl'
call cm48_sdcciyp_dcallee1 ; AC'= math48(x)
jp am48_dfix32
| 17.5
| 49
| 0.690476
|
a10fac458341c71bc63932c57d6dcc79d9d70f30
| 171,470
|
asm
|
Assembly
|
src/atari8.vm/xeroms.asm
|
softmac/xformer10
|
75598e6e32a06e647931c24fa762540d68892fc3
|
[
"MIT"
] | 6
|
2021-06-29T01:44:59.000Z
|
2021-10-30T19:25:16.000Z
|
src/atari8.vm/xeroms.asm
|
softmac/xformer10
|
75598e6e32a06e647931c24fa762540d68892fc3
|
[
"MIT"
] | 1
|
2021-07-29T06:35:07.000Z
|
2021-07-29T06:35:07.000Z
|
src/atari8.vm/xeroms.asm
|
softmac/xformer10
|
75598e6e32a06e647931c24fa762540d68892fc3
|
[
"MIT"
] | 1
|
2021-12-24T05:56:13.000Z
|
2021-12-24T05:56:13.000Z
|
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
;; XEROMS.ASM
;;
;; Hex dump of Atari XL/XE BASIC revision C and OS revision D
;;
;; Atari OS and BASIC used with permission. Copyright (C) 1979-1984 Atari Corp.
;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IFDEF HWIN32
.486
.MODEL FLAT,C
OPTION NOSCOPED
OPTION NOOLDMACROS
ENDIF
IFDEF HDOS32
.486
DOSSEG
.MODEL FLAT
OPTION NOSCOPED
OPTION NOOLDMACROS
ENDIF
IFDEF HDOS16
DOSSEG
.MODEL large,c
.286
ENDIF
IFDEF HDOS16
.FARDATA xeroms
ELSE
.CONST
ENDIF
PUBLIC rgbXLXEBAS, rgbXLXE5000, rgbXLXEC000, rgbXLXED800
rgbXLXEBAS LABEL BYTE
DB 0A5h, 0CAh, 0D0h, 004h, 0A5h, 008h, 0D0h, 045h, 0A2h, 0FFh, 09Ah, 0D8h, 0AEh, 0E7h, 002h, 0ACh ; A000 Atari BASIC $A000-$BFFF
DB 0E8h, 002h, 086h, 080h, 084h, 081h, 0A9h, 000h, 085h, 092h, 085h, 0CAh, 0C8h, 08Ah, 0A2h, 082h ; A010
DB 095h, 000h, 0E8h, 094h, 000h, 0E8h, 0E0h, 092h, 090h, 0F6h, 0A2h, 086h, 0A0h, 001h, 020h, 07Ah ; A020
DB 0A8h, 0A2h, 08Ch, 0A0h, 003h, 020h, 07Ah, 0A8h, 0A9h, 000h, 0A8h, 091h, 084h, 091h, 08Ah, 0C8h ; A030
DB 0A9h, 080h, 091h, 08Ah, 0C8h, 0A9h, 003h, 091h, 08Ah, 0A9h, 00Ah, 085h, 0C9h, 020h, 0F1h, 0B8h ; A040
DB 020h, 045h, 0BDh, 020h, 05Bh, 0BDh, 0A5h, 092h, 0F0h, 003h, 020h, 09Dh, 0BDh, 020h, 062h, 0BDh ; A050
DB 0A5h, 0CAh, 0D0h, 09Ch, 0A2h, 0FFh, 09Ah, 020h, 051h, 0DAh, 0A9h, 05Dh, 085h, 0C2h, 020h, 0EDh ; A060
DB 0BDh, 020h, 0F2h, 0A9h, 0F0h, 0EAh, 0A9h, 000h, 085h, 0F2h, 085h, 09Fh, 085h, 094h, 085h, 0A6h ; A070
DB 085h, 0B3h, 085h, 0B0h, 085h, 0B1h, 0A5h, 084h, 085h, 0ADh, 0A5h, 085h, 085h, 0AEh, 020h, 0A1h ; A080
DB 0DBh, 020h, 09Ah, 0A1h, 020h, 0C4h, 0A2h, 0A5h, 0D5h, 010h, 002h, 085h, 0A6h, 020h, 0A1h, 0DBh ; A090
DB 0A4h, 0F2h, 084h, 0A8h, 0B1h, 0F3h, 0C9h, 09Bh, 0D0h, 007h, 024h, 0A6h, 030h, 0B2h, 04Ch, 086h ; A0A0
DB 0A1h, 0A5h, 094h, 085h, 0A7h, 020h, 0C4h, 0A2h, 020h, 0A1h, 0DBh, 0A9h, 0A4h, 0A0h, 09Fh, 0A2h ; A0B0
DB 002h, 020h, 054h, 0A4h, 086h, 0F2h, 0A5h, 0AFh, 020h, 0C4h, 0A2h, 020h, 0A1h, 0DBh, 020h, 0BEh ; A0C0
DB 0A1h, 090h, 035h, 0A4h, 09Fh, 0B1h, 0F3h, 0C9h, 09Bh, 0D0h, 006h, 0C8h, 091h, 0F3h, 088h, 0A9h ; A0D0
DB 020h, 009h, 080h, 091h, 0F3h, 0A9h, 040h, 005h, 0A6h, 085h, 0A6h, 0A4h, 0A8h, 084h, 0F2h, 0A2h ; A0E0
DB 003h, 086h, 0A7h, 0E8h, 086h, 094h, 0A9h, 037h, 020h, 0C4h, 0A2h, 0A4h, 0F2h, 0B1h, 0F3h, 0E6h ; A0F0
DB 0F2h, 0C9h, 09Bh, 0D0h, 0F3h, 020h, 0C4h, 0A2h, 0A5h, 094h, 0A4h, 0A7h, 091h, 080h, 0A4h, 0F2h ; A100
DB 088h, 0B1h, 0F3h, 0C9h, 09Bh, 0D0h, 09Ah, 0A0h, 002h, 0A5h, 094h, 091h, 080h, 020h, 0A2h, 0A9h ; A110
DB 0A9h, 000h, 0B0h, 003h, 020h, 0DCh, 0A9h, 038h, 0E5h, 094h, 0F0h, 01Eh, 0B0h, 013h, 049h, 0FFh ; A120
DB 0A8h, 0C8h, 0A2h, 08Ah, 020h, 07Ah, 0A8h, 0A5h, 097h, 085h, 08Ah, 0A5h, 098h, 085h, 08Bh, 0D0h ; A130
DB 009h, 0A8h, 020h, 0D0h, 0A9h, 0A2h, 08Ah, 020h, 0F8h, 0A8h, 0A4h, 094h, 088h, 0B1h, 080h, 091h ; A140
DB 08Ah, 098h, 0D0h, 0F8h, 024h, 0A6h, 050h, 029h, 0A5h, 0B1h, 00Ah, 00Ah, 00Ah, 0A2h, 088h, 020h ; A150
DB 0F7h, 0A8h, 038h, 0A5h, 084h, 0E5h, 0ADh, 0A8h, 0A5h, 085h, 0E5h, 0AEh, 0A2h, 084h, 020h, 0FAh ; A160
DB 0A8h, 024h, 0A6h, 010h, 006h, 020h, 0AAh, 0B5h, 04Ch, 060h, 0A0h, 020h, 08Eh, 0B5h, 04Ch, 060h ; A170
DB 0A0h, 010h, 0FBh, 04Ch, 05Eh, 0A9h, 020h, 0A2h, 0A9h, 0B0h, 0F3h, 020h, 0DCh, 0A9h, 0A8h, 020h ; A180
DB 0D0h, 0A9h, 0A2h, 08Ah, 020h, 0F8h, 0A8h, 04Ch, 060h, 0A0h, 020h, 000h, 0D8h, 090h, 008h, 0A9h ; A190
DB 000h, 085h, 0F2h, 0A0h, 080h, 030h, 009h, 020h, 041h, 0ADh, 0A4h, 0D5h, 030h, 0F1h, 0A5h, 0D4h ; A1A0
DB 084h, 0A1h, 085h, 0A0h, 020h, 0C4h, 0A2h, 0A5h, 0A1h, 085h, 0D5h, 04Ch, 0C4h, 0A2h, 0A0h, 001h ; A1B0
DB 0B1h, 095h, 085h, 09Eh, 08Dh, 083h, 004h, 088h, 0B1h, 095h, 085h, 09Dh, 08Dh, 082h, 004h, 084h ; A1C0
DB 0A9h, 0A5h, 094h, 08Dh, 081h, 004h, 0A5h, 0F2h, 08Dh, 080h, 004h, 020h, 093h, 0A2h, 030h, 016h ; A1D0
DB 0C9h, 001h, 090h, 024h, 0D0h, 006h, 020h, 008h, 0A2h, 04Ch, 059h, 0A2h, 0C9h, 005h, 090h, 055h ; A1E0
DB 020h, 09Bh, 0A2h, 04Ch, 059h, 0A2h, 038h, 0E9h, 0C1h, 0B0h, 002h, 0A2h, 0FFh, 018h, 065h, 09Dh ; A1F0
DB 048h, 08Ah, 065h, 09Eh, 048h, 04Ch, 01Bh, 0A2h, 020h, 093h, 0A2h, 048h, 020h, 093h, 0A2h, 048h ; A200
DB 090h, 009h, 068h, 0A8h, 068h, 0AAh, 098h, 048h, 08Ah, 048h, 060h, 0A6h, 0A9h, 0E8h, 0E8h, 0E8h ; A210
DB 0E8h, 0F0h, 01Fh, 086h, 0A9h, 0A5h, 0F2h, 09Dh, 080h, 004h, 0A5h, 094h, 09Dh, 081h, 004h, 0A5h ; A220
DB 09Dh, 09Dh, 082h, 004h, 0A5h, 09Eh, 09Dh, 083h, 004h, 068h, 085h, 09Eh, 068h, 085h, 09Dh, 04Ch ; A230
DB 0DBh, 0A1h, 04Ch, 018h, 0B9h, 0A6h, 0A9h, 0F0h, 0D1h, 0BDh, 082h, 004h, 085h, 09Dh, 0BDh, 083h ; A240
DB 004h, 085h, 09Eh, 0CAh, 0CAh, 0CAh, 0CAh, 086h, 0A9h, 0B0h, 003h, 04Ch, 0DBh, 0A1h, 020h, 093h ; A250
DB 0A2h, 030h, 0FBh, 0C9h, 002h, 0B0h, 008h, 020h, 08Ch, 0A2h, 020h, 08Ch, 0A2h, 0D0h, 0EFh, 0C9h ; A260
DB 003h, 0F0h, 0D2h, 0B0h, 0E9h, 0A5h, 0F2h, 0C5h, 09Fh, 090h, 002h, 085h, 09Fh, 0A6h, 0A9h, 0BDh ; A270
DB 080h, 004h, 085h, 0F2h, 0BDh, 081h, 004h, 085h, 094h, 04Ch, 0DBh, 0A1h, 0E6h, 09Dh, 0D0h, 002h ; A280
DB 0E6h, 09Eh, 060h, 020h, 08Ch, 0A2h, 0A2h, 000h, 0A1h, 09Dh, 060h, 0C9h, 00Fh, 0F0h, 017h, 0B0h ; A290
DB 040h, 0C9h, 00Dh, 0D0h, 006h, 020h, 08Ch, 0A2h, 04Ch, 0E4h, 0A2h, 068h, 068h, 0A9h, 004h, 048h ; A2A0
DB 0A9h, 0A6h, 048h, 04Ch, 01Bh, 0A2h, 020h, 08Ch, 0A2h, 0A0h, 000h, 0B1h, 09Dh, 0A4h, 094h, 088h ; A2B0
DB 091h, 080h, 018h, 060h, 0A4h, 094h, 091h, 080h, 0E6h, 094h, 0D0h, 0F7h, 04Ch, 018h, 0B9h, 0A2h ; A2C0
DB 0FFh, 09Ah, 0A5h, 094h, 0A4h, 0A7h, 091h, 080h, 04Ch, 0B1h, 0A0h, 0A2h, 0FFh, 09Ah, 04Ch, 0FBh ; A2D0
DB 0A0h, 020h, 0A1h, 0DBh, 0A5h, 0F2h, 0C5h, 0B3h, 0F0h, 015h, 085h, 0B3h, 0A9h, 0A7h, 0A0h, 0DEh ; A2E0
DB 0A2h, 000h, 020h, 054h, 0A4h, 0B0h, 023h, 086h, 0B2h, 0A5h, 0AFh, 069h, 010h, 085h, 0B0h, 0A0h ; A2F0
DB 000h, 0B1h, 09Dh, 0C5h, 0B0h, 0F0h, 00Ah, 0C9h, 044h, 0D0h, 013h, 0A5h, 0B0h, 0C9h, 044h, 090h ; A300
DB 00Dh, 020h, 0C4h, 0A2h, 0A6h, 0B2h, 086h, 0F2h, 018h, 060h, 0A9h, 000h, 085h, 0B0h, 038h, 060h ; A310
DB 0A9h, 000h, 0F0h, 002h, 0A9h, 080h, 085h, 0D2h, 020h, 0A1h, 0DBh, 0A5h, 0F2h, 085h, 0ACh, 020h ; A320
DB 0E8h, 0A3h, 0B0h, 025h, 020h, 0E1h, 0A2h, 0A5h, 0B0h, 0F0h, 008h, 0A4h, 0B2h, 0B1h, 0F3h, 0C9h ; A330
DB 030h, 090h, 016h, 0E6h, 0F2h, 020h, 0E8h, 0A3h, 090h, 0F9h, 020h, 0AFh, 0DBh, 090h, 0F4h, 0B1h ; A340
DB 0F3h, 0C9h, 024h, 0F0h, 006h, 024h, 0D2h, 010h, 009h, 038h, 060h, 024h, 0D2h, 010h, 0FAh, 0C8h ; A350
DB 0D0h, 00Dh, 0B1h, 0F3h, 0C9h, 028h, 0D0h, 007h, 0C8h, 0A9h, 040h, 005h, 0D2h, 085h, 0D2h, 0A5h ; A360
DB 0ACh, 085h, 0F2h, 084h, 0ACh, 0A5h, 083h, 0A4h, 082h, 0A2h, 000h, 020h, 054h, 0A4h, 0B0h, 00Ah ; A370
DB 0E4h, 0ACh, 0F0h, 04Dh, 020h, 082h, 0A4h, 04Ch, 07Eh, 0A3h, 038h, 0A5h, 0ACh, 0E5h, 0F2h, 085h ; A380
DB 0F2h, 0A8h, 0A2h, 084h, 020h, 07Ah, 0A8h, 0A5h, 0AFh, 085h, 0D3h, 0A4h, 0F2h, 088h, 0A6h, 0ACh ; A390
DB 0CAh, 0BDh, 080h, 005h, 091h, 097h, 0CAh, 088h, 010h, 0F7h, 0A4h, 0F2h, 088h, 0B1h, 097h, 009h ; A3A0
DB 080h, 091h, 097h, 0A0h, 008h, 0A2h, 088h, 020h, 07Ah, 0A8h, 0E6h, 0B1h, 0A0h, 002h, 0A9h, 000h ; A3B0
DB 099h, 0D2h, 000h, 0C8h, 0C0h, 008h, 090h, 0F8h, 088h, 0B9h, 0D2h, 000h, 091h, 097h, 088h, 010h ; A3C0
DB 0F8h, 024h, 0D2h, 050h, 002h, 0C6h, 0ACh, 0A5h, 0ACh, 085h, 0F2h, 0A5h, 0AFh, 030h, 006h, 009h ; A3D0
DB 080h, 018h, 04Ch, 0C4h, 0A2h, 04Ch, 02Ch, 0B9h, 0A4h, 0F2h, 0B1h, 0F3h, 0C9h, 041h, 090h, 003h ; A3E0
DB 0C9h, 05Bh, 060h, 038h, 060h, 020h, 0A1h, 0DBh, 0A5h, 0F2h, 085h, 0ACh, 020h, 000h, 0D8h, 090h ; A3F0
DB 005h, 0A5h, 0ACh, 085h, 0F2h, 060h, 0A9h, 00Eh, 020h, 0C4h, 0A2h, 0C8h, 0A2h, 000h, 0B5h, 0D4h ; A400
DB 091h, 080h, 0C8h, 0E8h, 0E0h, 006h, 090h, 0F6h, 084h, 094h, 018h, 060h, 020h, 0A1h, 0DBh, 0A4h ; A410
DB 0F2h, 0B1h, 0F3h, 0C9h, 022h, 0D0h, 0CCh, 0A9h, 00Fh, 020h, 0C4h, 0A2h, 0A5h, 094h, 085h, 0ABh ; A420
DB 020h, 0C4h, 0A2h, 0E6h, 0F2h, 0A4h, 0F2h, 0B1h, 0F3h, 0C9h, 09Bh, 0F0h, 00Ch, 0C9h, 022h, 0F0h ; A430
DB 006h, 020h, 0C4h, 0A2h, 04Ch, 033h, 0A4h, 0E6h, 0F2h, 018h, 0A5h, 094h, 0E5h, 0ABh, 0A4h, 0ABh ; A440
DB 091h, 080h, 018h, 060h, 086h, 0AAh, 0A2h, 0FFh, 086h, 0AFh, 085h, 096h, 084h, 095h, 0E6h, 0AFh ; A450
DB 0A6h, 0F2h, 0A4h, 0AAh, 0B1h, 095h, 0F0h, 025h, 0A9h, 000h, 008h, 0BDh, 080h, 005h, 029h, 07Fh ; A460
DB 0C9h, 02Eh, 0F0h, 01Bh, 051h, 095h, 00Ah, 0F0h, 002h, 068h, 008h, 0C8h, 0E8h, 090h, 0ECh, 028h ; A470
DB 0F0h, 0D0h, 018h, 098h, 065h, 095h, 0A8h, 0A5h, 096h, 069h, 000h, 0D0h, 0CDh, 038h, 060h, 0A9h ; A480
DB 002h, 0C5h, 0AAh, 0D0h, 0DFh, 0B1h, 095h, 030h, 003h, 0C8h, 0D0h, 0F9h, 038h, 0B0h, 0DCh, 0C2h ; A490
DB 0A7h, 052h, 045h, 0CDh, 0C5h, 0A7h, 044h, 041h, 054h, 0C1h, 0EEh, 0A6h, 049h, 04Eh, 050h, 055h ; A4A0
DB 0D4h, 0B7h, 0A6h, 043h, 04Fh, 04Ch, 04Fh, 0D2h, 02Ch, 0A7h, 04Ch, 049h, 053h, 0D4h, 01Dh, 0A7h ; A4B0
DB 045h, 04Eh, 054h, 045h, 0D2h, 0BAh, 0A6h, 04Ch, 045h, 0D4h, 08Eh, 0A7h, 049h, 0C6h, 0CCh, 0A6h ; A4C0
DB 046h, 04Fh, 0D2h, 0E4h, 0A6h, 04Eh, 045h, 058h, 0D4h, 0B7h, 0A6h, 047h, 04Fh, 054h, 0CFh, 0B7h ; A4D0
DB 0A6h, 047h, 04Fh, 020h, 054h, 0CFh, 0B7h, 0A6h, 047h, 04Fh, 053h, 055h, 0C2h, 0B7h, 0A6h, 054h ; A4E0
DB 052h, 041h, 0D0h, 0B8h, 0A6h, 042h, 059h, 0C5h, 0B8h, 0A6h, 043h, 04Fh, 04Eh, 0D4h, 059h, 0A7h ; A4F0
DB 043h, 04Fh, 0CDh, 01Ah, 0A7h, 043h, 04Ch, 04Fh, 053h, 0C5h, 0B8h, 0A6h, 043h, 04Ch, 0D2h, 0B8h ; A500
DB 0A6h, 044h, 045h, 0C7h, 059h, 0A7h, 044h, 049h, 0CDh, 0B8h, 0A6h, 045h, 04Eh, 0C4h, 0B8h, 0A6h ; A510
DB 04Eh, 045h, 0D7h, 013h, 0A7h, 04Fh, 050h, 045h, 0CEh, 01Dh, 0A7h, 04Ch, 04Fh, 041h, 0C4h, 01Dh ; A520
DB 0A7h, 053h, 041h, 056h, 0C5h, 03Ah, 0A7h, 053h, 054h, 041h, 054h, 055h, 0D3h, 043h, 0A7h, 04Eh ; A530
DB 04Fh, 054h, 0C5h, 043h, 0A7h, 050h, 04Fh, 049h, 04Eh, 0D4h, 011h, 0A7h, 058h, 049h, 0CFh, 05Ch ; A540
DB 0A7h, 04Fh, 0CEh, 056h, 0A7h, 050h, 04Fh, 04Bh, 0C5h, 0F6h, 0A6h, 050h, 052h, 049h, 04Eh, 0D4h ; A550
DB 0B8h, 0A6h, 052h, 041h, 0C4h, 0EFh, 0A6h, 052h, 045h, 041h, 0C4h, 0E9h, 0A6h, 052h, 045h, 053h ; A560
DB 054h, 04Fh, 052h, 0C5h, 0B8h, 0A6h, 052h, 045h, 054h, 055h, 052h, 0CEh, 020h, 0A7h, 052h, 055h ; A570
DB 0CEh, 0B8h, 0A6h, 053h, 054h, 04Fh, 0D0h, 0B8h, 0A6h, 050h, 04Fh, 0D0h, 0F6h, 0A6h, 0BFh, 0E2h ; A580
DB 0A6h, 047h, 045h, 0D4h, 0B4h, 0A6h, 050h, 055h, 0D4h, 0B7h, 0A6h, 047h, 052h, 041h, 050h, 048h ; A590
DB 049h, 043h, 0D3h, 056h, 0A7h, 050h, 04Ch, 04Fh, 0D4h, 056h, 0A7h, 050h, 04Fh, 053h, 049h, 054h ; A5A0
DB 049h, 04Fh, 0CEh, 0B8h, 0A6h, 044h, 04Fh, 0D3h, 056h, 0A7h, 044h, 052h, 041h, 057h, 054h, 0CFh ; A5B0
DB 054h, 0A7h, 053h, 045h, 054h, 043h, 04Fh, 04Ch, 04Fh, 0D2h, 0DCh, 0A6h, 04Ch, 04Fh, 043h, 041h ; A5C0
DB 054h, 0C5h, 052h, 0A7h, 053h, 04Fh, 055h, 04Eh, 0C4h, 0FAh, 0A6h, 04Ch, 050h, 052h, 049h, 04Eh ; A5D0
DB 0D4h, 0B8h, 0A6h, 043h, 053h, 041h, 056h, 0C5h, 0B8h, 0A6h, 043h, 04Ch, 04Fh, 041h, 0C4h, 0BAh ; A5E0
DB 0A6h, 000h, 080h, 000h, 02Ah, 045h, 052h, 052h, 04Fh, 052h, 02Dh, 020h, 0A0h, 053h, 054h, 04Fh ; A5F0
DB 050h, 050h, 045h, 044h, 0A0h, 0CDh, 0C4h, 002h, 0C2h, 003h, 02Bh, 0BAh, 02Ch, 0DBh, 002h, 0CDh ; A600
DB 0D8h, 003h, 025h, 00Fh, 035h, 002h, 026h, 00Fh, 036h, 002h, 028h, 003h, 0FEh, 002h, 0E8h, 002h ; A610
DB 001h, 0F4h, 0A3h, 002h, 000h, 078h, 0A6h, 003h, 0C4h, 09Ch, 002h, 003h, 023h, 002h, 025h, 002h ; A620
DB 026h, 002h, 024h, 002h, 027h, 002h, 01Dh, 002h, 01Fh, 002h, 01Eh, 002h, 020h, 002h, 021h, 002h ; A630
DB 022h, 002h, 02Ah, 002h, 029h, 003h, 001h, 01Fh, 0A3h, 0C2h, 003h, 00Dh, 02Bh, 00Fh, 038h, 00Eh ; A640
DB 0C4h, 02Ch, 002h, 003h, 012h, 00Fh, 03Ch, 00Eh, 002h, 003h, 044h, 0D2h, 002h, 000h, 0C8h, 0A7h ; A650
DB 0D3h, 002h, 0C2h, 003h, 03Fh, 02Bh, 00Fh, 03Ah, 000h, 0D4h, 0A7h, 02Ch, 003h, 02Bh, 00Fh, 03Ah ; A660
DB 00Eh, 02Ch, 003h, 02Bh, 00Fh, 03Ah, 0C7h, 02Ch, 003h, 0C4h, 0E3h, 0C2h, 003h, 0C8h, 002h, 0CBh ; A670
DB 002h, 001h, 01Bh, 0A4h, 003h, 000h, 0D0h, 0A7h, 0A5h, 003h, 001h, 023h, 0A3h, 0C2h, 003h, 02Bh ; A680
DB 00Fh, 037h, 00Eh, 0C4h, 02Ch, 002h, 003h, 012h, 00Fh, 03Ch, 00Eh, 002h, 003h, 01Dh, 00Fh, 02Fh ; A690
DB 002h, 01Eh, 00Fh, 030h, 002h, 01Fh, 00Fh, 031h, 002h, 020h, 00Fh, 032h, 002h, 021h, 00Fh, 033h ; A6A0
DB 002h, 022h, 00Fh, 034h, 003h, 01Ch, 00Eh, 012h, 00Eh, 0FAh, 003h, 000h, 045h, 0A6h, 022h, 00Fh ; A6B0
DB 02Dh, 00Eh, 0F1h, 002h, 086h, 022h, 00Fh, 02Eh, 000h, 07Ch, 0A6h, 0E8h, 003h, 001h, 01Fh, 0A3h ; A6C0
DB 022h, 00Fh, 02Dh, 00Eh, 019h, 00Eh, 0C3h, 0DCh, 003h, 01Ah, 00Eh, 002h, 003h, 00Eh, 012h, 00Eh ; A6D0
DB 012h, 0C4h, 003h, 0DDh, 012h, 001h, 01Fh, 0A3h, 0CBh, 003h, 00Eh, 0C8h, 002h, 0C6h, 003h, 0F7h ; A6E0
DB 0DBh, 0C2h, 003h, 014h, 002h, 016h, 003h, 0C9h, 0BBh, 002h, 0ECh, 000h, 09Ah, 0A7h, 0B5h, 003h ; A6F0
DB 01Ch, 00Eh, 003h, 001h, 01Fh, 0A3h, 002h, 001h, 023h, 0A3h, 003h, 0B8h, 0C2h, 003h, 012h, 0BCh ; A700
DB 002h, 003h, 00Eh, 012h, 0ACh, 012h, 0F9h, 012h, 0F3h, 09Ah, 003h, 0A5h, 097h, 003h, 0EDh, 094h ; A710
DB 003h, 0EAh, 091h, 002h, 08Fh, 003h, 09Ah, 012h, 002h, 097h, 015h, 002h, 003h, 0DEh, 085h, 002h ; A720
DB 0DBh, 012h, 0C4h, 002h, 0C2h, 003h, 000h, 0BAh, 0A7h, 0F4h, 003h, 0C3h, 0F1h, 003h, 082h, 012h ; A730
DB 000h, 045h, 0A6h, 003h, 0BAh, 012h, 000h, 045h, 0A6h, 0E4h, 003h, 000h, 07Ch, 0A6h, 003h, 00Eh ; A740
DB 012h, 00Eh, 003h, 00Eh, 012h, 00Eh, 012h, 0B8h, 0D5h, 003h, 0EDh, 0D2h, 003h, 00Eh, 0C4h, 0C7h ; A750
DB 0CDh, 003h, 017h, 002h, 018h, 003h, 00Eh, 0C2h, 003h, 012h, 0BCh, 002h, 003h, 014h, 002h, 016h ; A760
DB 003h, 001h, 01Fh, 0A3h, 00Dh, 02Bh, 00Fh, 039h, 00Eh, 000h, 053h, 0A6h, 02Ch, 002h, 001h, 023h ; A770
DB 0A3h, 02Bh, 00Fh, 03Bh, 00Eh, 02Ch, 003h, 0AAh, 0C3h, 002h, 003h, 012h, 0BBh, 002h, 003h, 00Eh ; A780
DB 01Bh, 0C3h, 09Bh, 003h, 001h, 0F4h, 0A3h, 002h, 001h, 0CEh, 0A2h, 0C9h, 002h, 0D4h, 0C3h, 002h ; A790
DB 003h, 0C3h, 002h, 003h, 0C3h, 0C8h, 003h, 00Eh, 002h, 000h, 07Ch, 0A6h, 003h, 0C4h, 0B3h, 002h ; A7A0
DB 003h, 0C6h, 0C2h, 003h, 0BDh, 002h, 003h, 012h, 002h, 015h, 003h, 00Eh, 0C3h, 002h, 003h, 012h ; A7B0
DB 00Eh, 002h, 003h, 001h, 0DAh, 0A2h, 001h, 0DAh, 0A2h, 040h, 002h, 041h, 002h, 043h, 002h, 042h ; A7C0
DB 003h, 03Dh, 002h, 03Eh, 003h, 00Eh, 0C2h, 003h, 012h, 00Fh, 03Ch, 0BAh, 002h, 003h, 082h, 080h ; A7D0
DB 0ACh, 0A4h, 0BAh, 0BBh, 09Bh, 047h, 04Fh, 054h, 0CFh, 047h, 04Fh, 053h, 055h, 0C2h, 054h, 0CFh ; A7E0
DB 053h, 054h, 045h, 0D0h, 054h, 048h, 045h, 0CEh, 0A3h, 03Ch, 0BDh, 03Ch, 0BEh, 03Eh, 0BDh, 0BCh ; A7F0
DB 0BEh, 0BDh, 0DEh, 0AAh, 0ABh, 0ADh, 0AFh, 04Eh, 04Fh, 0D4h, 04Fh, 0D2h, 041h, 04Eh, 0C4h, 0A8h ; A800
DB 0A9h, 0BDh, 0BDh, 03Ch, 0BDh, 03Ch, 0BEh, 03Eh, 0BDh, 0BCh, 0BEh, 0BDh, 0ABh, 0ADh, 0A8h, 080h ; A810
DB 080h, 0A8h, 0A8h, 0ACh, 053h, 054h, 052h, 0A4h, 043h, 048h, 052h, 0A4h, 055h, 053h, 0D2h, 041h ; A820
DB 053h, 0C3h, 056h, 041h, 0CCh, 04Ch, 045h, 0CEh, 041h, 044h, 0D2h, 041h, 054h, 0CEh, 043h, 04Fh ; A830
DB 0D3h, 050h, 045h, 045h, 0CBh, 053h, 049h, 0CEh, 052h, 04Eh, 0C4h, 046h, 052h, 0C5h, 045h, 058h ; A840
DB 0D0h, 04Ch, 04Fh, 0C7h, 043h, 04Ch, 04Fh, 0C7h, 053h, 051h, 0D2h, 053h, 047h, 0CEh, 041h, 042h ; A850
DB 0D3h, 049h, 04Eh, 0D4h, 050h, 041h, 044h, 044h, 04Ch, 0C5h, 053h, 054h, 049h, 043h, 0CBh, 050h ; A860
DB 054h, 052h, 049h, 0C7h, 053h, 054h, 052h, 049h, 0C7h, 000h, 0A9h, 000h, 084h, 0A4h, 085h, 0A5h ; A870
DB 098h, 038h, 065h, 090h, 0A8h, 0A5h, 091h, 065h, 0A5h, 0CDh, 0E6h, 002h, 090h, 00Ch, 0D0h, 007h ; A880
DB 0CCh, 0E5h, 002h, 090h, 005h, 0F0h, 003h, 04Ch, 030h, 0B9h, 038h, 0A5h, 090h, 0F5h, 000h, 085h ; A890
DB 0A2h, 0A5h, 091h, 0F5h, 001h, 085h, 0A3h, 018h, 075h, 001h, 085h, 09Ah, 0B5h, 000h, 085h, 099h ; A8A0
DB 085h, 097h, 065h, 0A4h, 085h, 09Bh, 0B5h, 001h, 085h, 098h, 065h, 0A5h, 065h, 0A3h, 085h, 09Ch ; A8B0
DB 0B5h, 000h, 065h, 0A4h, 095h, 000h, 0B5h, 001h, 065h, 0A5h, 095h, 001h, 0E8h, 0E8h, 0E0h, 092h ; A8C0
DB 090h, 0EEh, 085h, 00Fh, 0A5h, 090h, 085h, 00Eh, 0A6h, 0A3h, 0E8h, 0A4h, 0A2h, 0D0h, 00Dh, 0EAh ; A8D0
DB 0F0h, 011h, 0EAh, 088h, 0C6h, 09Ah, 0C6h, 09Ch, 0B1h, 099h, 091h, 09Bh, 088h, 0D0h, 0F9h, 0B1h ; A8E0
DB 099h, 091h, 09Bh, 0CAh, 0D0h, 0EDh, 060h, 0A8h, 0A9h, 000h, 084h, 0A4h, 085h, 0A5h, 038h, 0A5h ; A8F0
DB 090h, 0F5h, 000h, 049h, 0FFh, 0A8h, 0C8h, 084h, 0A2h, 0A5h, 091h, 0F5h, 001h, 085h, 0A3h, 0B5h ; A900
DB 000h, 0E5h, 0A2h, 085h, 099h, 0B5h, 001h, 0E9h, 000h, 085h, 09Ah, 086h, 09Bh, 038h, 0B5h, 000h ; A910
DB 0E5h, 0A4h, 095h, 000h, 0B5h, 001h, 0E5h, 0A5h, 095h, 001h, 0E8h, 0E8h, 0E0h, 092h, 090h, 0EDh ; A920
DB 085h, 00Fh, 0A5h, 090h, 085h, 00Eh, 0A6h, 09Bh, 0B5h, 000h, 0E5h, 0A2h, 085h, 09Bh, 0B5h, 001h ; A930
DB 0E9h, 000h, 085h, 09Ch, 0A6h, 0A3h, 0E8h, 0A4h, 0A2h, 0D0h, 008h, 0CAh, 0D0h, 005h, 060h, 0E6h ; A940
DB 09Ah, 0E6h, 09Ch, 0B1h, 099h, 091h, 09Bh, 0C8h, 0D0h, 0F9h, 0CAh, 0D0h, 0F2h, 060h, 020h, 019h ; A950
DB 0B8h, 020h, 0F2h, 0A9h, 0F0h, 036h, 0A4h, 0A7h, 0C4h, 09Fh, 0B0h, 01Dh, 0B1h, 08Ah, 085h, 0A7h ; A960
DB 098h, 0C8h, 0B1h, 08Ah, 0C8h, 084h, 0A8h, 020h, 07Eh, 0A9h, 0EAh, 04Ch, 061h, 0A9h, 00Ah, 0AAh ; A970
DB 0BDh, 0FAh, 0A9h, 048h, 0BDh, 0FBh, 0A9h, 048h, 060h, 0A0h, 001h, 0B1h, 08Ah, 030h, 010h, 0A5h ; A980
DB 09Fh, 020h, 0D0h, 0A9h, 020h, 0E1h, 0A9h, 010h, 0C5h, 04Ch, 08Ch, 0B7h, 04Ch, 092h, 0B7h, 04Ch ; A990
DB 05Dh, 0A0h, 0A5h, 08Ah, 085h, 0BEh, 0A5h, 08Bh, 085h, 0BFh, 0A5h, 089h, 0A4h, 088h, 085h, 08Bh ; A9A0
DB 084h, 08Ah, 0A0h, 001h, 0B1h, 08Ah, 0C5h, 0A1h, 090h, 00Dh, 0D0h, 00Ah, 088h, 0B1h, 08Ah, 0C5h ; A9B0
DB 0A0h, 090h, 004h, 0D0h, 001h, 018h, 060h, 020h, 0DCh, 0A9h, 020h, 0D0h, 0A9h, 04Ch, 0B2h, 0A9h ; A9C0
DB 018h, 065h, 08Ah, 085h, 08Ah, 0A5h, 08Bh, 069h, 000h, 085h, 08Bh, 060h, 0A0h, 002h, 0B1h, 08Ah ; A9D0
DB 060h, 0A0h, 001h, 0B1h, 08Ah, 060h, 020h, 045h, 0BDh, 04Ch, 071h, 0E4h, 020h, 045h, 0BDh, 06Ch ; A9E0
DB 00Ah, 000h, 0A4h, 011h, 0D0h, 003h, 0C6h, 011h, 098h, 060h, 0A9h, 0E4h, 0A9h, 0E4h, 0B3h, 03Dh ; A9F0
DB 0BAh, 01Eh, 0B4h, 0B4h, 0BAh, 0C4h, 0AAh, 0D9h, 0B7h, 077h, 0B6h, 07Ch, 0B6h, 0FFh, 0B6h, 0D4h ; AA00
DB 0B6h, 0D4h, 0B6h, 0D1h, 0B7h, 0D7h, 0A9h, 0E5h, 0B7h, 0B4h, 0B2h, 005h, 0BCh, 021h, 0B7h, 065h ; AA10
DB 0B2h, 08Ch, 0B2h, 005h, 0B7h, 08Bh, 0A0h, 00Bh, 0BBh, 0F1h, 0BAh, 0FAh, 0BBh, 06Ch, 0BCh, 02Eh ; AA20
DB 0BCh, 03Ch, 0BCh, 053h, 0BBh, 0EBh, 0B7h, 0E3h, 0B2h, 077h, 0B3h, 0D9h, 0B2h, 090h, 0B2h, 0ADh ; AA30
DB 0B2h, 095h, 0BDh, 0A7h, 0B7h, 04Bh, 0B7h, 091h, 0B8h, 03Dh, 0B3h, 0D9h, 0BCh, 084h, 0BCh, 077h ; AA40
DB 0BAh, 045h, 0BAh, 06Bh, 0BAh, 00Bh, 0A9h, 0EBh, 0BAh, 026h, 0B9h, 0ACh, 0BCh, 09Dh, 0B9h, 0D2h ; AA50
DB 0B4h, 095h, 0BBh, 0D0h, 0BBh, 063h, 0AAh, 0D9h, 0B9h, 011h, 0ACh, 0A2h, 0ACh, 0ABh, 0ACh, 0C1h ; AA60
DB 0ACh, 0B1h, 0ACh, 0B8h, 0ACh, 0C8h, 0B1h, 05Dh, 0ACh, 082h, 0BDh, 0F9h, 0ACh, 079h, 0ACh, 08Bh ; AA70
DB 0ACh, 0E3h, 0ACh, 0D8h, 0ACh, 0CEh, 0ABh, 034h, 0ADh, 065h, 0ADh, 049h, 0AEh, 08Dh, 0ACh, 0A2h ; AA80
DB 0ACh, 0ABh, 0ACh, 0C1h, 0ACh, 0B1h, 0ACh, 0B8h, 0ACh, 0C8h, 0ABh, 034h, 0ACh, 094h, 0AEh, 010h ; AA90
DB 0ADh, 070h, 0ADh, 06Ch, 0ADh, 065h, 0ADh, 06Ch, 0ADh, 063h, 0B0h, 033h, 0B0h, 051h, 0B0h, 0A4h ; AAA0
DB 0AFh, 0FCh, 0AFh, 0EAh, 0AFh, 0B4h, 0B0h, 006h, 0B1h, 017h, 0B1h, 00Eh, 0AFh, 0CBh, 0B1h, 005h ; AAB0
DB 0B0h, 075h, 0AFh, 0D5h, 0B1h, 049h, 0B1h, 020h, 0B1h, 03Ch, 0B1h, 052h, 0ADh, 003h, 0B0h, 098h ; AAC0
DB 0B0h, 0C7h, 0B0h, 00Ch, 0B0h, 010h, 0B0h, 014h, 0B0h, 018h, 020h, 026h, 0ABh, 020h, 036h, 0ABh ; AAD0
DB 0B0h, 005h, 020h, 0B2h, 0ABh, 030h, 0F6h, 085h, 0ABh, 0AAh, 0BDh, 025h, 0ACh, 04Ah, 04Ah, 04Ah ; AAE0
DB 04Ah, 085h, 0ACh, 0A4h, 0A9h, 0B1h, 080h, 0AAh, 0BDh, 025h, 0ACh, 029h, 00Fh, 0C5h, 0ACh, 090h ; AAF0
DB 00Dh, 0AAh, 0F0h, 031h, 0B1h, 080h, 0E6h, 0A9h, 020h, 018h, 0ABh, 04Ch, 0F3h, 0AAh, 0A5h, 0ABh ; AB00
DB 088h, 091h, 080h, 084h, 0A9h, 04Ch, 0DDh, 0AAh, 038h, 0E9h, 01Dh, 00Ah, 0AAh, 0BDh, 06Ah, 0AAh ; AB10
DB 048h, 0BDh, 06Bh, 0AAh, 048h, 060h, 0A0h, 0FFh, 0A9h, 011h, 091h, 080h, 084h, 0A9h, 0C8h, 084h ; AB20
DB 0B0h, 084h, 0AAh, 084h, 0B1h, 060h, 0A4h, 0A8h, 0E6h, 0A8h, 0B1h, 08Ah, 030h, 043h, 0C9h, 00Fh ; AB30
DB 090h, 003h, 0F0h, 013h, 060h, 0A2h, 000h, 0C8h, 0B1h, 08Ah, 095h, 0D4h, 0E8h, 0E0h, 006h, 090h ; AB40
DB 0F6h, 0C8h, 0A9h, 000h, 0AAh, 0F0h, 022h, 0C8h, 0B1h, 08Ah, 0A2h, 08Ah, 085h, 0D6h, 085h, 0D8h ; AB50
DB 0C8h, 098h, 018h, 075h, 000h, 085h, 0D4h, 0A9h, 000h, 085h, 0D7h, 085h, 0D9h, 075h, 001h, 085h ; AB60
DB 0D5h, 098h, 065h, 0D6h, 0A8h, 0A2h, 000h, 0A9h, 083h, 085h, 0D2h, 086h, 0D3h, 084h, 0A8h, 018h ; AB70
DB 060h, 020h, 01Eh, 0ACh, 0B1h, 09Dh, 099h, 0D2h, 000h, 0C8h, 0C0h, 008h, 090h, 0F6h, 018h, 060h ; AB80
DB 020h, 0E9h, 0ABh, 0A9h, 002h, 024h, 0D2h, 0D0h, 015h, 005h, 0D2h, 085h, 0D2h, 06Ah, 090h, 00Fh ; AB90
DB 018h, 0A5h, 0D4h, 065h, 08Ch, 085h, 0D4h, 0A8h, 0A5h, 0D5h, 065h, 08Dh, 085h, 0D5h, 060h, 020h ; ABA0
DB 022h, 0B9h, 0E6h, 0AAh, 0A5h, 0AAh, 00Ah, 00Ah, 00Ah, 0C5h, 0A9h, 0B0h, 00Dh, 0A8h, 088h, 0A2h ; ABB0
DB 007h, 0B5h, 0D2h, 091h, 080h, 088h, 0CAh, 010h, 0F8h, 060h, 04Ch, 020h, 0B9h, 020h, 0D7h, 0ABh ; ABC0
DB 0A5h, 0D5h, 010h, 0F5h, 04Ch, 026h, 0B9h, 020h, 0DAh, 0AAh, 020h, 0E9h, 0ABh, 04Ch, 041h, 0ADh ; ABD0
DB 020h, 0CDh, 0ABh, 0D0h, 001h, 060h, 020h, 02Eh, 0B9h, 0A5h, 0AAh, 0C6h, 0AAh, 00Ah, 00Ah, 00Ah ; ABE0
DB 0A8h, 088h, 0A2h, 007h, 0B1h, 080h, 095h, 0D2h, 088h, 0CAh, 010h, 0F8h, 060h, 020h, 0E9h, 0ABh ; ABF0
DB 020h, 0B6h, 0DDh, 04Ch, 0E9h, 0ABh, 020h, 0DAh, 0AAh, 04Ch, 0E9h, 0ABh, 0A5h, 0D3h, 020h, 01Eh ; AC00
DB 0ACh, 0A2h, 000h, 0B5h, 0D2h, 091h, 09Dh, 0C8h, 0E8h, 0E0h, 008h, 090h, 0F6h, 060h, 0A0h, 000h ; AC10
DB 084h, 09Eh, 00Ah, 00Ah, 026h, 09Eh, 00Ah, 026h, 09Eh, 018h, 065h, 086h, 085h, 09Dh, 0A5h, 087h ; AC20
DB 065h, 09Eh, 085h, 09Eh, 060h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; AC30
DB 000h, 000h, 088h, 088h, 088h, 088h, 088h, 088h, 0CCh, 0AAh, 099h, 099h, 0AAh, 0DDh, 055h, 066h ; AC40
DB 0F2h, 04Eh, 0F1h, 0F1h, 0EEh, 0EEh, 0EEh, 0EEh, 0EEh, 0EEh, 0DDh, 0DDh, 0F2h, 0F2h, 0F2h, 0F2h ; AC50
DB 0F2h, 043h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h ; AC60
DB 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 0F2h, 020h, 0FDh, 0ABh, 020h, 02Ch, 0ADh ; AC70
DB 04Ch, 0B2h, 0ABh, 020h, 0FDh, 0ABh, 020h, 032h, 0ADh, 04Ch, 0B2h, 0ABh, 020h, 0FDh, 0ABh, 020h ; AC80
DB 038h, 0ADh, 04Ch, 0B2h, 0ABh, 020h, 0E9h, 0ABh, 0A5h, 0D4h, 0F0h, 004h, 049h, 080h, 085h, 0D4h ; AC90
DB 04Ch, 0B2h, 0ABh, 020h, 011h, 0ADh, 030h, 048h, 0F0h, 046h, 010h, 03Fh, 020h, 011h, 0ADh, 04Ch ; ACA0
DB 0E0h, 0ACh, 020h, 011h, 0ADh, 030h, 039h, 010h, 032h, 020h, 011h, 0ADh, 030h, 02Dh, 0F0h, 02Bh ; ACB0
DB 010h, 02Eh, 020h, 011h, 0ADh, 030h, 024h, 010h, 027h, 020h, 011h, 0ADh, 04Ch, 0E9h, 0ACh, 020h ; ACC0
DB 0FDh, 0ABh, 0A5h, 0D4h, 025h, 0E0h, 04Ch, 0E0h, 0ACh, 020h, 0FDh, 0ABh, 0A5h, 0D4h, 005h, 0E0h ; ACD0
DB 0F0h, 009h, 0D0h, 00Ch, 020h, 0E9h, 0ABh, 0A5h, 0D4h, 0F0h, 005h, 0A9h, 000h, 0A8h, 0F0h, 004h ; ACE0
DB 0A9h, 040h, 0A0h, 001h, 085h, 0D4h, 084h, 0D5h, 0A2h, 0D6h, 0A0h, 004h, 020h, 048h, 0DAh, 085h ; ACF0
DB 0D2h, 04Ch, 0B2h, 0ABh, 020h, 0E9h, 0ABh, 0A5h, 0D4h, 0F0h, 0F6h, 010h, 0E3h, 0A9h, 0C0h, 030h ; AD00
DB 0E1h, 0A4h, 0A9h, 088h, 0B1h, 080h, 0C9h, 02Fh, 090h, 003h, 04Ch, 06Ch, 0AFh, 020h, 0FDh, 0ABh ; AD10
DB 020h, 02Ch, 0ADh, 0A5h, 0D4h, 060h, 020h, 066h, 0DAh, 0B0h, 013h, 060h, 020h, 060h, 0DAh, 0B0h ; AD20
DB 00Dh, 060h, 020h, 0DBh, 0DAh, 0B0h, 007h, 060h, 020h, 028h, 0DBh, 0B0h, 001h, 060h, 020h, 01Eh ; AD30
DB 0B9h, 020h, 0D2h, 0D9h, 0B0h, 001h, 060h, 020h, 02Eh, 0B9h, 0A5h, 0A9h, 0C9h, 0FFh, 0D0h, 00Fh ; AD40
DB 020h, 0FDh, 0ABh, 0A2h, 005h, 0B5h, 0E0h, 095h, 0D4h, 0CAh, 010h, 0F9h, 04Ch, 00Ch, 0ACh, 0A9h ; AD50
DB 080h, 085h, 0B1h, 060h, 0E6h, 0B0h, 0A4h, 0A9h, 068h, 068h, 04Ch, 004h, 0ABh, 0A9h, 040h, 085h ; AD60
DB 0B1h, 024h, 0B1h, 010h, 006h, 0A5h, 0AAh, 085h, 0AFh, 0C6h, 0AAh, 0A9h, 000h, 0A8h, 0C5h, 0B0h ; AD70
DB 0F0h, 00Bh, 0C6h, 0B0h, 020h, 0DAh, 0ABh, 0A5h, 0D5h, 030h, 023h, 0A4h, 0D4h, 085h, 098h, 084h ; AD80
DB 097h, 020h, 0DAh, 0ABh, 0A5h, 0D4h, 085h, 0F5h, 0A5h, 0D5h, 030h, 012h, 085h, 0F6h, 020h, 0E9h ; AD90
DB 0ABh, 024h, 0B1h, 050h, 005h, 0A9h, 000h, 085h, 0B1h, 060h, 066h, 0D2h, 0B0h, 003h, 020h, 022h ; ADA0
DB 0B9h, 0A5h, 0F6h, 0C5h, 0D7h, 090h, 008h, 0D0h, 0F5h, 0A5h, 0F5h, 0C5h, 0D6h, 0B0h, 0EFh, 0A5h ; ADB0
DB 098h, 0C5h, 0D9h, 090h, 008h, 0D0h, 0E7h, 0A5h, 097h, 0C5h, 0D8h, 0B0h, 0E1h, 020h, 048h, 0AFh ; ADC0
DB 0A5h, 097h, 0A4h, 098h, 020h, 03Dh, 0AFh, 020h, 031h, 0AFh, 0A5h, 0D4h, 0A4h, 0D5h, 020h, 03Dh ; ADD0
DB 0AFh, 0A5h, 08Ch, 0A4h, 08Dh, 020h, 03Dh, 0AFh, 024h, 0B1h, 010h, 015h, 0A5h, 0AFh, 085h, 0AAh ; ADE0
DB 020h, 0E9h, 0ABh, 0A0h, 005h, 0B9h, 0D4h, 000h, 091h, 0F5h, 088h, 010h, 0F8h, 0C8h, 084h, 0B1h ; ADF0
DB 060h, 0A0h, 005h, 0B1h, 0F5h, 099h, 0D4h, 000h, 088h, 010h, 0F8h, 0C8h, 084h, 0D2h, 04Ch, 0B2h ; AE00
DB 0ABh, 0A5h, 0B0h, 0F0h, 007h, 020h, 081h, 0AEh, 084h, 098h, 085h, 097h, 020h, 081h, 0AEh, 038h ; AE10
DB 0E9h, 001h, 085h, 0F5h, 098h, 0E9h, 000h, 085h, 0F6h, 020h, 0E9h, 0ABh, 0A5h, 0B1h, 010h, 00Bh ; AE20
DB 005h, 0B0h, 085h, 0B1h, 0A4h, 0D9h, 0A5h, 0D8h, 04Ch, 03Fh, 0AEh, 0A5h, 0D6h, 0A4h, 0D7h, 0A6h ; AE30
DB 0B0h, 0F0h, 010h, 0C6h, 0B0h, 0C4h, 098h, 090h, 035h, 0D0h, 004h, 0C5h, 097h, 090h, 02Fh, 0A4h ; AE40
DB 098h, 0A5h, 097h, 038h, 0E5h, 0F5h, 085h, 0D6h, 0AAh, 098h, 0E5h, 0F6h, 085h, 0D7h, 090h, 01Eh ; AE50
DB 0A8h, 0D0h, 003h, 08Ah, 0F0h, 018h, 020h, 093h, 0ABh, 018h, 0A5h, 0D4h, 065h, 0F5h, 085h, 0D4h ; AE60
DB 0A5h, 0D5h, 065h, 0F6h, 085h, 0D5h, 024h, 0B1h, 010h, 001h, 060h, 04Ch, 0B2h, 0ABh, 020h, 02Ah ; AE70
DB 0B9h, 020h, 0DAh, 0ABh, 0A5h, 0D4h, 0A4h, 0D5h, 0D0h, 003h, 0AAh, 0F0h, 0F1h, 060h, 020h, 090h ; AE80
DB 0ABh, 0A5h, 0D4h, 085h, 099h, 0A5h, 0D5h, 085h, 09Ah, 0A5h, 0D6h, 085h, 0A2h, 0A4h, 0D7h, 084h ; AE90
DB 0A3h, 0A4h, 0A9h, 0C0h, 0FFh, 0F0h, 00Fh, 0A9h, 080h, 085h, 0B1h, 020h, 004h, 0ABh, 0A5h, 0D7h ; AEA0
DB 0A4h, 0D6h, 026h, 0B1h, 0B0h, 007h, 020h, 090h, 0ABh, 0A5h, 0D9h, 0A4h, 0D8h, 0C5h, 0A3h, 090h ; AEB0
DB 006h, 0D0h, 008h, 0C4h, 0A2h, 0B0h, 004h, 085h, 0A3h, 084h, 0A2h, 018h, 0A5h, 0D4h, 065h, 0A2h ; AEC0
DB 0A8h, 0A5h, 0D5h, 065h, 0A3h, 0AAh, 038h, 098h, 0E5h, 08Ch, 085h, 0F9h, 08Ah, 0E5h, 08Dh, 085h ; AED0
DB 0FAh, 038h, 0A9h, 000h, 0E5h, 0A2h, 085h, 0A2h, 038h, 0A5h, 099h, 0E5h, 0A2h, 085h, 099h, 0A5h ; AEE0
DB 09Ah, 0E9h, 000h, 085h, 09Ah, 038h, 0A5h, 0D4h, 0E5h, 0A2h, 085h, 09Bh, 0A5h, 0D5h, 0E9h, 000h ; AEF0
DB 085h, 09Ch, 020h, 044h, 0A9h, 0A5h, 0D3h, 020h, 081h, 0ABh, 038h, 0A5h, 0F9h, 0E5h, 0D4h, 0A8h ; AF00
DB 0A5h, 0FAh, 0E5h, 0D5h, 0AAh, 0A9h, 002h, 025h, 0B1h, 0F0h, 00Fh, 0A9h, 000h, 085h, 0B1h, 0E4h ; AF10
DB 0D7h, 090h, 006h, 0D0h, 005h, 0C4h, 0D6h, 0B0h, 001h, 060h, 084h, 0D6h, 086h, 0D7h, 04Ch, 00Ch ; AF20
DB 0ACh, 006h, 0F5h, 026h, 0F6h, 0A4h, 0F6h, 0A5h, 0F5h, 006h, 0F5h, 026h, 0F6h, 018h, 065h, 0F5h ; AF30
DB 085h, 0F5h, 098h, 065h, 0F6h, 085h, 0F6h, 060h, 0A9h, 000h, 085h, 0F7h, 085h, 0F8h, 0A0h, 010h ; AF40
DB 0A5h, 0F5h, 04Ah, 090h, 00Ch, 018h, 0A2h, 0FEh, 0B5h, 0F9h, 075h, 0DAh, 095h, 0F9h, 0E8h, 0D0h ; AF50
DB 0F7h, 0A2h, 003h, 076h, 0F5h, 0CAh, 010h, 0FBh, 088h, 0D0h, 0E5h, 060h, 020h, 090h, 0ABh, 020h ; AF60
DB 0B6h, 0DDh, 020h, 090h, 0ABh, 0A2h, 0D6h, 020h, 0A7h, 0AFh, 008h, 0A2h, 0E2h, 020h, 0A7h, 0AFh ; AF70
DB 0F0h, 013h, 028h, 0F0h, 00Dh, 0A0h, 000h, 0B1h, 0D4h, 0D1h, 0E0h, 0F0h, 00Ch, 090h, 003h, 0A9h ; AF80
DB 001h, 060h, 0A9h, 080h, 060h, 028h, 0D0h, 0F7h, 060h, 0E6h, 0D4h, 0D0h, 002h, 0E6h, 0D5h, 0E6h ; AF90
DB 0E0h, 0D0h, 0D2h, 0E6h, 0E1h, 0D0h, 0CEh, 0B5h, 000h, 0D0h, 006h, 0B5h, 001h, 0F0h, 005h, 0D6h ; AFA0
DB 001h, 0D6h, 000h, 0A8h, 060h, 020h, 090h, 0ABh, 0A5h, 0D6h, 0A4h, 0D7h, 085h, 0D4h, 084h, 0D5h ; AFB0
DB 020h, 0AAh, 0D9h, 0A9h, 000h, 085h, 0D2h, 085h, 0D3h, 04Ch, 0B2h, 0ABh, 020h, 0DAh, 0ABh, 0A0h ; AFC0
DB 000h, 0B1h, 0D4h, 04Ch, 0BCh, 0AFh, 020h, 0E9h, 0ABh, 038h, 0ADh, 0E5h, 002h, 0E5h, 090h, 085h ; AFD0
DB 0D4h, 0ADh, 0E6h, 002h, 0E5h, 091h, 085h, 0D5h, 04Ch, 0C0h, 0AFh, 020h, 07Dh, 0BDh, 0A9h, 000h ; AFE0
DB 085h, 0F2h, 020h, 000h, 0D8h, 020h, 09Dh, 0BDh, 090h, 0C9h, 020h, 010h, 0B9h, 020h, 090h, 0ABh ; AFF0
DB 0A0h, 000h, 0B1h, 0D4h, 04Ch, 0BCh, 0AFh, 020h, 090h, 0ABh, 04Ch, 0C0h, 0AFh, 0A9h, 000h, 0F0h ; B000
DB 00Ah, 0A9h, 008h, 0D0h, 006h, 0A9h, 00Ch, 0D0h, 002h, 0A9h, 014h, 048h, 020h, 0DAh, 0ABh, 0A5h ; B010
DB 0D5h, 0D0h, 00Eh, 0A5h, 0D4h, 068h, 018h, 065h, 0D4h, 0AAh, 0BDh, 070h, 002h, 0A0h, 000h, 0F0h ; B020
DB 08Bh, 020h, 02Eh, 0B9h, 020h, 0E9h, 0ABh, 020h, 0E6h, 0D8h, 0A5h, 0F3h, 085h, 0D4h, 0A5h, 0F4h ; B030
DB 085h, 0D5h, 0A0h, 0FFh, 0C8h, 0B1h, 0F3h, 010h, 0FBh, 029h, 07Fh, 091h, 0F3h, 0C8h, 084h, 0D6h ; B040
DB 0D0h, 017h, 020h, 0E9h, 0ABh, 020h, 041h, 0ADh, 0A5h, 0D4h, 08Dh, 0C0h, 005h, 0A9h, 005h, 085h ; B050
DB 0D5h, 0A9h, 0C0h, 085h, 0D4h, 0A9h, 001h, 085h, 0D6h, 0A9h, 000h, 085h, 0D7h, 085h, 0D3h, 0A9h ; B060
DB 083h, 085h, 0D2h, 04Ch, 0B2h, 0ABh, 0A2h, 093h, 0A0h, 0B0h, 020h, 098h, 0DDh, 020h, 0E9h, 0ABh ; B070
DB 0ACh, 00Ah, 0D2h, 084h, 0D4h, 0ACh, 00Ah, 0D2h, 084h, 0D5h, 020h, 0AAh, 0D9h, 020h, 038h, 0ADh ; B080
DB 04Ch, 0B2h, 0ABh, 042h, 006h, 055h, 036h, 000h, 000h, 020h, 0E9h, 0ABh, 0A5h, 0D4h, 029h, 07Fh ; B090
DB 085h, 0D4h, 04Ch, 0B2h, 0ABh, 020h, 0AEh, 0B0h, 020h, 0AAh, 0D9h, 04Ch, 0B2h, 0ABh, 0A5h, 0B0h ; B0A0
DB 085h, 0C6h, 020h, 0DAh, 0ABh, 0C6h, 0C6h, 030h, 009h, 0A5h, 0D4h, 048h, 0A5h, 0D5h, 048h, 04Ch ; B0B0
DB 0B2h, 0B0h, 0A5h, 0B0h, 048h, 06Ch, 0D4h, 000h, 020h, 0E9h, 0ABh, 020h, 0D1h, 0B0h, 04Ch, 0B2h ; B0C0
DB 0ABh, 0A5h, 0D4h, 029h, 07Fh, 038h, 0E9h, 03Fh, 010h, 002h, 0A9h, 000h, 0AAh, 0A9h, 000h, 0A8h ; B0D0
DB 0E0h, 005h, 0B0h, 007h, 015h, 0D5h, 094h, 0D5h, 0E8h, 0D0h, 0F5h, 0A6h, 0D4h, 010h, 014h, 0AAh ; B0E0
DB 0F0h, 011h, 0A2h, 0E0h, 020h, 046h, 0DAh, 0A9h, 0C0h, 085h, 0E0h, 0A9h, 001h, 085h, 0E1h, 020h ; B0F0
DB 026h, 0ADh, 060h, 04Ch, 000h, 0DCh, 020h, 0E9h, 0ABh, 020h, 005h, 0BEh, 04Ch, 059h, 0B1h, 020h ; B100
DB 0E9h, 0ABh, 020h, 00Fh, 0BEh, 04Ch, 059h, 0B1h, 020h, 0E9h, 0ABh, 020h, 0D5h, 0BEh, 04Ch, 059h ; B110
DB 0B1h, 020h, 0E9h, 0ABh, 0A5h, 0D4h, 0F0h, 033h, 020h, 0CDh, 0DEh, 0B0h, 02Eh, 0A5h, 0D4h, 049h ; B120
DB 03Bh, 0D0h, 039h, 0A5h, 0D5h, 029h, 0F8h, 0D0h, 033h, 085h, 0D4h, 0F0h, 02Fh, 020h, 0E9h, 0ABh ; B130
DB 0A5h, 0D4h, 0F0h, 017h, 020h, 0D1h, 0DEh, 04Ch, 02Bh, 0B1h, 020h, 0E9h, 0ABh, 020h, 0C0h, 0DDh ; B140
DB 04Ch, 059h, 0B1h, 020h, 0E9h, 0ABh, 020h, 043h, 0BFh, 090h, 011h, 020h, 02Eh, 0B9h, 020h, 0FDh ; B150
DB 0ABh, 0A5h, 0E0h, 0F0h, 00Ah, 02Ah, 0A4h, 0D4h, 0D0h, 008h, 0B0h, 0EFh, 04Ch, 0B2h, 0ABh, 04Ch ; B160
DB 0F0h, 0ACh, 0A2h, 0D4h, 020h, 076h, 0BAh, 06Ah, 048h, 0A2h, 0E0h, 020h, 076h, 0BAh, 098h, 010h ; B170
DB 01Eh, 029h, 07Fh, 085h, 0D4h, 0B0h, 003h, 068h, 090h, 0D1h, 0A5h, 0E0h, 010h, 001h, 018h, 008h ; B180
DB 0A6h, 0F7h, 0E0h, 005h, 0B0h, 00Fh, 0B5h, 0E1h, 06Ah, 090h, 00Ah, 0A9h, 080h, 0D0h, 008h, 0A5h ; B190
DB 0E0h, 010h, 001h, 018h, 008h, 0A9h, 000h, 048h, 0A2h, 005h, 0B5h, 0E0h, 048h, 0CAh, 010h, 0FAh ; B1A0
DB 020h, 0D1h, 0DEh, 0A2h, 000h, 0A0h, 005h, 068h, 095h, 0E0h, 0E8h, 088h, 010h, 0F9h, 020h, 032h ; B1B0
DB 0ADh, 020h, 0CCh, 0DDh, 0B0h, 03Dh, 068h, 005h, 0D4h, 085h, 0D4h, 028h, 068h, 010h, 09Dh, 090h ; B1C0
DB 09Bh, 0A2h, 0D4h, 020h, 076h, 0BAh, 0B0h, 094h, 0A5h, 0D4h, 038h, 029h, 07Fh, 0E9h, 03Fh, 0C9h ; B1D0
DB 006h, 0B0h, 01Dh, 0AAh, 0A8h, 0F8h, 038h, 0B5h, 0D4h, 069h, 000h, 095h, 0D4h, 0CAh, 0D0h, 0F7h ; B1E0
DB 0D8h, 090h, 004h, 0E6h, 0D4h, 0E6h, 0D5h, 0C8h, 0C0h, 006h, 0B0h, 004h, 096h, 0D4h, 090h, 0F7h ; B1F0
DB 04Ch, 0B2h, 0ABh, 020h, 01Eh, 0B9h, 0A4h, 0A8h, 0C4h, 0A7h, 090h, 001h, 060h, 020h, 0DAh, 0AAh ; B200
DB 0A5h, 0D2h, 06Ah, 090h, 003h, 020h, 022h, 0B9h, 038h, 02Ah, 085h, 0D2h, 030h, 02Eh, 0A4h, 0F5h ; B210
DB 0A6h, 0F6h, 0C8h, 0D0h, 003h, 0E8h, 030h, 0EDh, 084h, 0D6h, 086h, 0D7h, 084h, 0F5h, 086h, 0F6h ; B220
DB 0A4h, 097h, 0A6h, 098h, 0C8h, 0D0h, 003h, 0E8h, 030h, 0DBh, 084h, 0D8h, 086h, 0D9h, 020h, 048h ; B230
DB 0AFh, 020h, 031h, 0AFh, 0A4h, 0F5h, 0A5h, 0F6h, 030h, 0CBh, 010h, 014h, 0A9h, 000h, 085h, 0D6h ; B240
DB 085h, 0D7h, 0A4h, 0F5h, 084h, 0D8h, 0A5h, 0F6h, 085h, 0D9h, 0D0h, 004h, 0C0h, 000h, 0F0h, 0B5h ; B250
DB 0A2h, 08Eh, 020h, 07Ch, 0A8h, 038h, 0A5h, 097h, 0E5h, 08Ch, 085h, 0D4h, 0A5h, 098h, 0E5h, 08Dh ; B260
DB 085h, 0D5h, 020h, 00Ch, 0ACh, 04Ch, 006h, 0B2h, 020h, 0D7h, 0ABh, 0A5h, 0D4h, 085h, 095h, 0A5h ; B270
DB 0D5h, 085h, 096h, 020h, 0E0h, 0ABh, 0A5h, 0D4h, 0A0h, 000h, 091h, 095h, 060h, 0A9h, 006h, 0D0h ; B280
DB 002h, 0A9h, 000h, 085h, 0FBh, 060h, 0A9h, 000h, 085h, 0B6h, 020h, 004h, 0B9h, 090h, 003h, 0A8h ; B290
DB 0F0h, 007h, 020h, 0CDh, 0ABh, 0A5h, 0D5h, 0A4h, 0D4h, 085h, 0B8h, 084h, 0B7h, 060h, 0A5h, 0A8h ; B2A0
DB 048h, 020h, 0F9h, 0B6h, 0A5h, 0B7h, 085h, 0A0h, 0A5h, 0B8h, 085h, 0A1h, 020h, 0A2h, 0A9h, 0A5h ; B2B0
DB 08Ah, 085h, 0F3h, 0A5h, 08Bh, 085h, 0F4h, 020h, 0A8h, 0BDh, 068h, 085h, 0A8h, 0A0h, 000h, 084h ; B2C0
DB 0F2h, 020h, 02Fh, 0B3h, 085h, 0B7h, 020h, 02Dh, 0B3h, 085h, 0B8h, 020h, 02Dh, 0B3h, 085h, 0F5h ; B2D0
DB 020h, 02Dh, 0B3h, 085h, 0F6h, 020h, 02Dh, 0B3h, 049h, 001h, 0F0h, 026h, 0A4h, 0F6h, 0C4h, 0F5h ; B2E0
DB 0B0h, 005h, 088h, 084h, 0F2h, 090h, 0E9h, 084h, 0F2h, 0C6h, 0F2h, 0A0h, 001h, 0B1h, 0F3h, 030h ; B2F0
DB 03Ah, 038h, 0A5h, 0F2h, 065h, 0F3h, 085h, 0F3h, 0A9h, 000h, 085h, 0B6h, 065h, 0F4h, 085h, 0F4h ; B300
DB 090h, 0BBh, 085h, 0F5h, 0A5h, 0F5h, 0C5h, 0B6h, 0B0h, 00Bh, 020h, 02Dh, 0B3h, 0D0h, 0FBh, 0B0h ; B310
DB 0DAh, 0E6h, 0F5h, 0D0h, 0EFh, 0A9h, 040h, 085h, 0A6h, 0E6h, 0F2h, 0B0h, 032h, 0E6h, 0F2h, 0A4h ; B320
DB 0F2h, 0B1h, 0F3h, 0C9h, 02Ch, 018h, 0F0h, 002h, 0C9h, 09Bh, 060h, 020h, 028h, 0B9h, 0A9h, 03Fh ; B330
DB 085h, 0C2h, 020h, 036h, 0ABh, 0C6h, 0A8h, 090h, 005h, 020h, 007h, 0BDh, 085h, 0B4h, 020h, 051h ; B340
DB 0DAh, 020h, 0E4h, 0BDh, 020h, 0F2h, 0A9h, 0F0h, 01Fh, 0A0h, 000h, 084h, 0A6h, 084h, 0F2h, 020h ; B350
DB 036h, 0ABh, 0E6h, 0A8h, 0A5h, 0D2h, 030h, 01Ah, 020h, 000h, 0D8h, 0B0h, 00Eh, 020h, 02Fh, 0B3h ; B360
DB 0D0h, 009h, 020h, 00Ch, 0ACh, 04Ch, 0ADh, 0B3h, 04Ch, 092h, 0B7h, 0A9h, 000h, 085h, 0B4h, 020h ; B370
DB 024h, 0B9h, 020h, 026h, 0ABh, 020h, 0B2h, 0ABh, 0C6h, 0F2h, 0A5h, 0F2h, 085h, 0F5h, 0A2h, 0FFh ; B380
DB 0E8h, 020h, 02Dh, 0B3h, 0D0h, 0FAh, 0B0h, 004h, 024h, 0A6h, 050h, 0F4h, 0A4h, 0F5h, 0A5h, 0A8h ; B390
DB 048h, 08Ah, 0A2h, 0F3h, 020h, 05Ch, 0ABh, 068h, 085h, 0A8h, 020h, 091h, 0AEh, 024h, 0A6h, 050h ; B3A0
DB 00Fh, 0E6h, 0B6h, 020h, 004h, 0B9h, 0B0h, 00Dh, 020h, 02Fh, 0B3h, 090h, 018h, 04Ch, 0FBh, 0B2h ; B3B0
DB 020h, 004h, 0B9h, 090h, 008h, 020h, 051h, 0DAh, 0A9h, 000h, 085h, 0B4h, 060h, 020h, 02Fh, 0B3h ; B3C0
DB 090h, 003h, 04Ch, 04Eh, 0B3h, 0E6h, 0F2h, 04Ch, 05Fh, 0B3h, 0A5h, 0C9h, 085h, 0AFh, 0A9h, 000h ; B3D0
DB 085h, 094h, 0A4h, 0A8h, 0B1h, 08Ah, 0C9h, 012h, 0F0h, 05Fh, 0C9h, 016h, 0F0h, 079h, 0C9h, 014h ; B3E0
DB 0F0h, 075h, 0C9h, 015h, 0F0h, 07Eh, 0C9h, 01Ch, 0F0h, 070h, 020h, 0DAh, 0AAh, 020h, 0E9h, 0ABh ; B3F0
DB 0C6h, 0A8h, 024h, 0D2h, 030h, 022h, 0A5h, 0D5h, 0C9h, 010h, 090h, 006h, 0A5h, 0D9h, 029h, 0F0h ; B400
DB 085h, 0D9h, 020h, 0E6h, 0D8h, 0A9h, 000h, 085h, 0F2h, 0A4h, 0F2h, 0B1h, 0F3h, 048h, 0E6h, 0F2h ; B410
DB 020h, 08Fh, 0B4h, 068h, 010h, 0F3h, 030h, 0BAh, 020h, 093h, 0ABh, 0A9h, 000h, 085h, 0F2h, 0A5h ; B420
DB 0D6h, 0D0h, 004h, 0C6h, 0D7h, 030h, 0ABh, 0C6h, 0D6h, 0A4h, 0F2h, 0B1h, 0D4h, 0E6h, 0F2h, 0D0h ; B430
DB 002h, 0E6h, 0D5h, 020h, 091h, 0B4h, 04Ch, 02Fh, 0B4h, 0A4h, 094h, 0C8h, 0C4h, 0AFh, 090h, 009h ; B440
DB 018h, 0A5h, 0C9h, 065h, 0AFh, 085h, 0AFh, 090h, 0F0h, 0A4h, 094h, 0C4h, 0AFh, 0B0h, 015h, 0A9h ; B450
DB 020h, 020h, 08Fh, 0B4h, 04Ch, 059h, 0B4h, 04Ch, 085h, 0B4h, 020h, 007h, 0BDh, 085h, 0B5h, 0C6h ; B460
DB 0A8h, 04Ch, 0E2h, 0B3h, 0E6h, 0A8h, 0A4h, 0A8h, 0B1h, 08Ah, 0C9h, 016h, 0F0h, 00Ch, 0C9h, 014h ; B470
DB 0F0h, 008h, 04Ch, 0E2h, 0B3h, 0A9h, 09Bh, 020h, 091h, 0B4h, 0A9h, 000h, 085h, 0B5h, 060h, 029h ; B480
DB 07Fh, 0E6h, 094h, 04Ch, 099h, 0BAh, 0A9h, 0B2h, 085h, 0F3h, 0A9h, 0B4h, 085h, 0F4h, 0A2h, 007h ; B490
DB 086h, 0B5h, 0A9h, 000h, 0A0h, 008h, 020h, 0D8h, 0BBh, 020h, 0BBh, 0BCh, 020h, 0DAh, 0B3h, 04Ch ; B4A0
DB 0F7h, 0BCh, 050h, 03Ah, 09Bh, 0A0h, 000h, 084h, 0A0h, 084h, 0A1h, 088h, 084h, 0ADh, 0A9h, 07Fh ; B4B0
DB 085h, 0AEh, 08Dh, 0FEh, 002h, 0A9h, 09Bh, 020h, 099h, 0BAh, 020h, 0F9h, 0B6h, 0A4h, 0A8h, 0C8h ; B4C0
DB 0C4h, 0A7h, 0B0h, 02Dh, 0A5h, 0A8h, 048h, 020h, 006h, 0ACh, 068h, 085h, 0A8h, 0A5h, 0D2h, 010h ; B4D0
DB 006h, 020h, 0CFh, 0BAh, 04Ch, 0CDh, 0B4h, 020h, 0CDh, 0ABh, 085h, 0A1h, 0A5h, 0D4h, 085h, 0A0h ; B4E0
DB 0A4h, 0A8h, 0C4h, 0A7h, 0F0h, 003h, 020h, 0CDh, 0ABh, 0A5h, 0D4h, 085h, 0ADh, 0A5h, 0D5h, 085h ; B4F0
DB 0AEh, 020h, 0A2h, 0A9h, 020h, 0E1h, 0A9h, 030h, 024h, 0A0h, 001h, 0B1h, 08Ah, 0C5h, 0AEh, 090h ; B500
DB 00Bh, 0D0h, 01Ah, 088h, 0B1h, 08Ah, 0C5h, 0ADh, 090h, 002h, 0D0h, 011h, 020h, 08Eh, 0B5h, 020h ; B510
DB 0F2h, 0A9h, 0F0h, 009h, 020h, 0DCh, 0A9h, 020h, 0D0h, 0A9h, 04Ch, 004h, 0B5h, 0A5h, 0B5h, 0F0h ; B520
DB 007h, 020h, 0F7h, 0BCh, 0A9h, 000h, 085h, 0B5h, 08Dh, 0FEh, 002h, 04Ch, 0A8h, 0BDh, 086h, 0AAh ; B530
DB 020h, 062h, 0B5h, 0A4h, 0AAh, 0C6h, 0AFh, 030h, 00Eh, 0B1h, 095h, 030h, 003h, 0C8h, 0D0h, 0F9h ; B540
DB 0C8h, 020h, 057h, 0B5h, 04Ch, 043h, 0B5h, 018h, 098h, 065h, 095h, 085h, 095h, 0A8h, 0A5h, 096h ; B550
DB 069h, 000h, 085h, 096h, 084h, 095h, 060h, 0A0h, 0FFh, 084h, 0AFh, 0E6h, 0AFh, 0A4h, 0AFh, 0B1h ; B560
DB 095h, 048h, 0C9h, 09Bh, 0F0h, 004h, 029h, 07Fh, 0F0h, 003h, 020h, 099h, 0BAh, 068h, 010h, 0EBh ; B570
DB 060h, 0A9h, 020h, 020h, 099h, 0BAh, 020h, 067h, 0B5h, 0A9h, 020h, 04Ch, 099h, 0BAh, 0A0h, 000h ; B580
DB 0B1h, 08Ah, 085h, 0D4h, 0C8h, 0B1h, 08Ah, 085h, 0D5h, 020h, 0AAh, 0D9h, 020h, 0E6h, 0D8h, 0A5h ; B590
DB 0F3h, 085h, 095h, 0A5h, 0F4h, 085h, 096h, 020h, 086h, 0B5h, 0A0h, 002h, 0B1h, 08Ah, 085h, 09Fh ; B5A0
DB 0C8h, 0B1h, 08Ah, 085h, 0A7h, 0C8h, 084h, 0A8h, 020h, 0C2h, 0B5h, 0A4h, 0A7h, 0C4h, 09Fh, 090h ; B5B0
DB 0F0h, 060h, 020h, 063h, 0B6h, 0C9h, 036h, 0F0h, 017h, 020h, 06Fh, 0B6h, 020h, 063h, 0B6h, 0C9h ; B5C0
DB 037h, 0F0h, 004h, 0C9h, 002h, 0B0h, 009h, 020h, 061h, 0B6h, 020h, 099h, 0BAh, 04Ch, 0D7h, 0B5h ; B5D0
DB 020h, 061h, 0B6h, 010h, 01Ah, 029h, 07Fh, 085h, 0AFh, 0A2h, 000h, 0A5h, 083h, 0A4h, 082h, 020h ; B5E0
DB 03Eh, 0B5h, 020h, 067h, 0B5h, 0C9h, 0A8h, 0D0h, 0E7h, 020h, 061h, 0B6h, 04Ch, 0E0h, 0B5h, 0C9h ; B5F0
DB 00Fh, 0F0h, 018h, 0B0h, 036h, 020h, 045h, 0ABh, 0C6h, 0A8h, 020h, 0E6h, 0D8h, 0A5h, 0F3h, 085h ; B600
DB 095h, 0A5h, 0F4h, 085h, 096h, 020h, 067h, 0B5h, 04Ch, 0E0h, 0B5h, 020h, 061h, 0B6h, 085h, 0AFh ; B610
DB 0A9h, 022h, 020h, 099h, 0BAh, 0A5h, 0AFh, 0F0h, 00Ah, 020h, 061h, 0B6h, 020h, 099h, 0BAh, 0C6h ; B620
DB 0AFh, 0D0h, 0F6h, 0A9h, 022h, 020h, 099h, 0BAh, 04Ch, 0E0h, 0B5h, 038h, 0E9h, 010h, 085h, 0AFh ; B630
DB 0A2h, 000h, 0A9h, 0A7h, 0A0h, 0DEh, 020h, 03Eh, 0B5h, 020h, 063h, 0B6h, 0C9h, 03Dh, 0B0h, 0C5h ; B640
DB 0A0h, 000h, 0B1h, 095h, 029h, 07Fh, 020h, 0ECh, 0A3h, 0B0h, 0BAh, 020h, 081h, 0B5h, 04Ch, 0E0h ; B650
DB 0B5h, 0E6h, 0A8h, 0A4h, 0A8h, 0C4h, 0A7h, 0B0h, 003h, 0B1h, 08Ah, 060h, 068h, 068h, 060h, 085h ; B660
DB 0AFh, 0A2h, 002h, 0A9h, 0A4h, 0A0h, 09Fh, 020h, 03Eh, 0B5h, 04Ch, 086h, 0B5h, 020h, 083h, 0B8h ; B670
DB 020h, 0DAh, 0AAh, 0A5h, 0D3h, 009h, 080h, 048h, 020h, 023h, 0B8h, 0A9h, 00Ch, 020h, 071h, 0B8h ; B680
DB 020h, 006h, 0ACh, 0A2h, 0D4h, 0A0h, 000h, 020h, 088h, 0B8h, 020h, 044h, 0DAh, 0A9h, 001h, 085h ; B690
DB 0D5h, 0A9h, 040h, 085h, 0D4h, 020h, 004h, 0B9h, 0B0h, 003h, 020h, 006h, 0ACh, 0A2h, 0D4h, 0A0h ; B6A0
DB 006h, 020h, 088h, 0B8h, 068h, 048h, 0A9h, 004h, 020h, 071h, 0B8h, 068h, 0A0h, 000h, 091h, 0C4h ; B6B0
DB 0B1h, 08Ah, 0C8h, 091h, 0C4h, 0B1h, 08Ah, 0C8h, 091h, 0C4h, 0A6h, 0B3h, 0CAh, 08Ah, 0C8h, 091h ; B6C0
DB 0C4h, 060h, 020h, 0F9h, 0B6h, 020h, 0CDh, 0ABh, 0A5h, 0D5h, 085h, 0A1h, 0A5h, 0D4h, 085h, 0A0h ; B6D0
DB 020h, 0A2h, 0A9h, 0B0h, 005h, 068h, 068h, 04Ch, 05Eh, 0A9h, 020h, 0F0h, 0B6h, 020h, 01Ch, 0B9h ; B6E0
DB 0A5h, 0BEh, 085h, 08Ah, 0A5h, 0BFh, 085h, 08Bh, 060h, 020h, 083h, 0B8h, 0A9h, 000h, 0F0h, 0B5h ; B6F0
DB 0A4h, 0A8h, 0B1h, 08Ah, 085h, 0C7h, 020h, 03Eh, 0B8h, 0B0h, 03Eh, 0F0h, 03Ch, 0C5h, 0C7h, 0D0h ; B700
DB 0F5h, 0A0h, 006h, 020h, 097h, 0B8h, 0A5h, 0E0h, 048h, 0A5h, 0C7h, 020h, 081h, 0ABh, 020h, 026h ; B710
DB 0ADh, 020h, 00Ch, 0ACh, 0A0h, 000h, 020h, 097h, 0B8h, 068h, 010h, 006h, 020h, 020h, 0ADh, 010h ; B720
DB 009h, 060h, 020h, 020h, 0ADh, 0F0h, 003h, 030h, 001h, 060h, 0A9h, 010h, 020h, 071h, 0B8h, 020h ; B730
DB 0CBh, 0BDh, 0C9h, 008h, 0F0h, 0F3h, 04Ch, 0C2h, 0BDh, 020h, 01Ah, 0B9h, 020h, 004h, 0B9h, 0B0h ; B740
DB 003h, 020h, 0F7h, 0BAh, 0EAh, 0A9h, 000h, 085h, 0A0h, 085h, 0A1h, 020h, 016h, 0B8h, 020h, 0E1h ; B750
DB 0A9h, 030h, 012h, 020h, 0F1h, 0B8h, 020h, 0B9h, 0B8h, 020h, 0A8h, 0B8h, 0A9h, 000h, 085h, 0B7h ; B760
DB 085h, 0B8h, 085h, 0B6h, 060h, 04Ch, 050h, 0A0h, 020h, 006h, 0ACh, 0A5h, 0D5h, 0F0h, 008h, 020h ; B770
DB 004h, 0B9h, 0B0h, 007h, 04Ch, 0D5h, 0B6h, 0A5h, 09Fh, 085h, 0A7h, 060h, 020h, 0A6h, 0B7h, 04Ch ; B780
DB 050h, 0A0h, 020h, 0A6h, 0B7h, 020h, 079h, 0BDh, 0A9h, 0FDh, 085h, 095h, 0A9h, 0A5h, 085h, 096h ; B790
DB 020h, 067h, 0B5h, 04Ch, 068h, 0B9h, 020h, 0E1h, 0A9h, 030h, 007h, 085h, 0BBh, 088h, 0B1h, 08Ah ; B7A0
DB 085h, 0BAh, 04Ch, 05Bh, 0BDh, 020h, 0E1h, 0A9h, 010h, 0F8h, 0A5h, 0BAh, 085h, 0A0h, 0A5h, 0BBh ; B7B0
DB 085h, 0A1h, 020h, 0A2h, 0A9h, 020h, 0E1h, 0A9h, 030h, 0ABh, 020h, 0DCh, 0A9h, 020h, 0D0h, 0A9h ; B7C0
DB 020h, 0E1h, 0A9h, 030h, 0A0h, 04Ch, 019h, 0B8h, 020h, 0D7h, 0ABh, 0A5h, 0D4h, 085h, 0BCh, 0A5h ; B7D0
DB 0D5h, 085h, 0BDh, 060h, 020h, 083h, 0B8h, 020h, 0E0h, 0ABh, 0A5h, 0D4h, 0F0h, 023h, 0A4h, 0A8h ; B7E0
DB 088h, 0B1h, 08Ah, 0C9h, 017h, 008h, 0F0h, 003h, 020h, 0FCh, 0B6h, 0A5h, 0D4h, 085h, 0B3h, 020h ; B7F0
DB 0CDh, 0ABh, 0C6h, 0B3h, 0F0h, 00Ch, 020h, 004h, 0B9h, 090h, 0F4h, 028h, 0F0h, 003h, 020h, 03Eh ; B800
DB 0B8h, 060h, 028h, 04Ch, 0D8h, 0B6h, 020h, 0A2h, 0A9h, 0A0h, 002h, 0B1h, 08Ah, 085h, 09Fh, 0C8h ; B810
DB 084h, 0A7h, 060h, 085h, 0C7h, 020h, 07Ah, 0B8h, 020h, 03Eh, 0B8h, 0B0h, 008h, 0F0h, 006h, 0C5h ; B820
DB 0C7h, 0F0h, 00Ah, 0D0h, 0F3h, 0A5h, 0C4h, 085h, 090h, 0A5h, 0C5h, 085h, 091h, 060h, 0A5h, 08Fh ; B830
DB 0C5h, 091h, 090h, 006h, 0A5h, 08Eh, 0C5h, 090h, 0B0h, 0F3h, 0A9h, 004h, 0A2h, 090h, 020h, 0F7h ; B840
DB 0A8h, 0A0h, 003h, 0B1h, 090h, 085h, 0B2h, 088h, 0B1h, 090h, 085h, 0A1h, 088h, 0B1h, 090h, 085h ; B850
DB 0A0h, 088h, 0B1h, 090h, 0F0h, 009h, 048h, 0A9h, 00Ch, 0A2h, 090h, 020h, 0F7h, 0A8h, 068h, 018h ; B860
DB 060h, 020h, 07Ah, 0B8h, 0A8h, 0A2h, 090h, 04Ch, 07Ah, 0A8h, 0A6h, 090h, 086h, 0C4h, 0A6h, 091h ; B870
DB 086h, 0C5h, 060h, 0A4h, 0A8h, 084h, 0B3h, 060h, 0A9h, 006h, 085h, 0C6h, 0B5h, 000h, 091h, 0C4h ; B880
DB 0E8h, 0C8h, 0C6h, 0C6h, 0D0h, 0F6h, 060h, 0A9h, 006h, 085h, 0C6h, 0A2h, 0E0h, 0B1h, 090h, 095h ; B890
DB 000h, 0E8h, 0C8h, 0C6h, 0C6h, 0D0h, 0F6h, 060h, 0A5h, 08Ch, 085h, 08Eh, 085h, 090h, 085h, 00Eh ; B8A0
DB 0A5h, 08Dh, 085h, 08Fh, 085h, 091h, 085h, 00Fh, 060h, 0A6h, 086h, 086h, 0F5h, 0A4h, 087h, 084h ; B8B0
DB 0F6h, 0A6h, 0F6h, 0E4h, 089h, 090h, 007h, 0A6h, 0F5h, 0E4h, 088h, 090h, 001h, 060h, 0A0h, 000h ; B8C0
DB 0B1h, 0F5h, 029h, 0FEh, 091h, 0F5h, 0A0h, 002h, 0A2h, 006h, 0A9h, 000h, 091h, 0F5h, 0C8h, 0CAh ; B8D0
DB 0D0h, 0FAh, 0A5h, 0F5h, 018h, 069h, 008h, 085h, 0F5h, 0A5h, 0F6h, 069h, 000h, 085h, 0F6h, 0D0h ; B8E0
DB 0D0h, 0A2h, 005h, 0A0h, 000h, 094h, 0B6h, 0CAh, 010h, 0FBh, 084h, 0FBh, 088h, 084h, 0BDh, 084h ; B8F0
DB 011h, 04Ch, 045h, 0BDh, 0A6h, 0A8h, 0E8h, 0E4h, 0A7h, 060h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h ; B900
DB 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h ; B910
DB 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h, 0E6h, 0B9h ; B920
DB 0E6h, 0B9h, 0E6h, 0B9h, 0A9h, 000h, 08Dh, 0FEh, 002h, 020h, 0A6h, 0B7h, 0A5h, 0BDh, 030h, 015h ; B930
DB 085h, 0A1h, 0A5h, 0BCh, 085h, 0A0h, 0A9h, 080h, 085h, 0BDh, 0A5h, 0B9h, 085h, 0C3h, 0A9h, 000h ; B940
DB 085h, 0B9h, 04Ch, 0E0h, 0B6h, 020h, 079h, 0BDh, 0A9h, 037h, 020h, 06Fh, 0B6h, 0A5h, 0B9h, 085h ; B950
DB 0D4h, 0A9h, 000h, 085h, 0D5h, 020h, 093h, 0B9h, 020h, 0E1h, 0A9h, 030h, 019h, 0A9h, 0A4h, 085h ; B960
DB 095h, 0A9h, 0B9h, 085h, 096h, 020h, 067h, 0B5h, 0A0h, 001h, 0B1h, 08Ah, 085h, 0D5h, 088h, 0B1h ; B970
DB 08Ah, 085h, 0D4h, 020h, 093h, 0B9h, 020h, 079h, 0BDh, 0A9h, 000h, 085h, 0B9h, 020h, 05Bh, 0BDh ; B980
DB 04Ch, 060h, 0A0h, 020h, 0AAh, 0D9h, 020h, 0E6h, 0D8h, 0A5h, 0F3h, 085h, 095h, 0A5h, 0F4h, 085h ; B990
DB 096h, 04Ch, 067h, 0B5h, 020h, 041h, 054h, 020h, 04Ch, 049h, 04Eh, 045h, 0A0h, 020h, 0E0h, 0ABh ; B9A0
DB 0A5h, 0D4h, 0C9h, 005h, 0B0h, 01Ah, 048h, 020h, 0D7h, 0ABh, 0A5h, 0D4h, 00Ah, 00Ah, 00Ah, 00Ah ; B9B0
DB 048h, 020h, 0D7h, 0ABh, 068h, 018h, 065h, 0D4h, 0A8h, 068h, 0AAh, 098h, 09Dh, 0C4h, 002h, 060h ; B9C0
DB 020h, 02Eh, 0B9h, 020h, 0E0h, 0ABh, 0A5h, 0D4h, 0C9h, 004h, 0B0h, 0F4h, 00Ah, 048h, 0A9h, 000h ; B9D0
DB 08Dh, 008h, 0D2h, 0A9h, 003h, 08Dh, 00Fh, 0D2h, 020h, 0D7h, 0ABh, 068h, 048h, 0AAh, 0A5h, 0D4h ; B9E0
DB 09Dh, 000h, 0D2h, 020h, 0D7h, 0ABh, 0A5h, 0D4h, 00Ah, 00Ah, 00Ah, 00Ah, 048h, 020h, 0D7h, 0ABh ; B9F0
DB 068h, 0A8h, 068h, 0AAh, 098h, 018h, 065h, 0D4h, 09Dh, 001h, 0D2h, 060h, 020h, 0D7h, 0ABh, 0A5h ; BA00
DB 0D4h, 085h, 055h, 0A5h, 0D5h, 085h, 056h, 020h, 0E0h, 0ABh, 0A5h, 0D4h, 085h, 054h, 060h, 020h ; BA10
DB 0D7h, 0ABh, 0A5h, 0D4h, 085h, 0C8h, 060h, 020h, 00Ch, 0BAh, 0A5h, 0C8h, 08Dh, 0FBh, 002h, 0A9h ; BA20
DB 011h, 0A2h, 006h, 020h, 0BEh, 0BAh, 0A9h, 00Ch, 09Dh, 04Ah, 003h, 0A9h, 000h, 09Dh, 04Bh, 003h ; BA30
DB 020h, 029h, 0BDh, 04Ch, 0BBh, 0BCh, 0A2h, 006h, 086h, 0C1h, 020h, 0F7h, 0BCh, 020h, 0D7h, 0ABh ; BA40
DB 0A2h, 069h, 0A0h, 0BAh, 086h, 0F3h, 084h, 0F4h, 0A2h, 006h, 0A5h, 0D4h, 029h, 0F0h, 049h, 01Ch ; BA50
DB 0A8h, 0A5h, 0D4h, 020h, 0D8h, 0BBh, 04Ch, 0BBh, 0BCh, 053h, 03Ah, 09Bh, 020h, 00Ch, 0BAh, 0A5h ; BA60
DB 0C8h, 0A2h, 006h, 04Ch, 09Bh, 0BAh, 038h, 0B5h, 000h, 029h, 07Fh, 0E9h, 040h, 090h, 019h, 085h ; BA70
DB 0F5h, 085h, 0F7h, 08Ah, 065h, 0F5h, 0E8h, 0E8h, 0E8h, 0E8h, 0E8h, 0E8h, 086h, 0F5h, 0AAh, 0E8h ; BA80
DB 0E4h, 0F5h, 0B0h, 004h, 0B5h, 000h, 0F0h, 0F7h, 060h, 0A6h, 0B5h, 048h, 020h, 0C0h, 0BAh, 0BDh ; BA90
DB 04Ah, 003h, 085h, 02Ah, 0BDh, 04Bh, 003h, 085h, 02Bh, 068h, 0A8h, 020h, 0B2h, 0BAh, 098h, 04Ch ; BAA0
DB 0BEh, 0BCh, 0BDh, 047h, 003h, 048h, 0BDh, 046h, 003h, 048h, 098h, 0A0h, 092h, 060h, 085h, 0C0h ; BAB0
DB 086h, 0C1h, 04Ch, 0AFh, 0BCh, 0A9h, 004h, 020h, 0D7h, 0BAh, 085h, 0B4h, 04Ch, 060h, 0A0h, 0A9h ; BAC0
DB 008h, 020h, 0D7h, 0BAh, 085h, 0B5h, 060h, 048h, 0A0h, 007h, 084h, 0C1h, 020h, 0AFh, 0BCh, 0A9h ; BAD0
DB 00Ch, 020h, 02Bh, 0BDh, 0A0h, 003h, 084h, 0C0h, 068h, 0A0h, 000h, 020h, 002h, 0BCh, 0A9h, 007h ; BAE0
DB 060h, 040h, 002h, 000h, 000h, 000h, 000h, 0A9h, 0FFh, 0D0h, 002h, 0A9h, 000h, 048h, 0A9h, 004h ; BAF0
DB 020h, 0D7h, 0BAh, 068h, 048h, 0A9h, 007h, 085h, 0C0h, 085h, 0CAh, 020h, 0AFh, 0BCh, 0A0h, 00Eh ; BB00
DB 020h, 015h, 0BDh, 020h, 0BBh, 0BCh, 0ADh, 080h, 005h, 00Dh, 081h, 005h, 0D0h, 03Fh, 0A2h, 08Ch ; BB10
DB 018h, 0A5h, 080h, 07Dh, 000h, 005h, 008h, 018h, 069h, 000h, 0A8h, 0A5h, 081h, 07Dh, 001h, 005h ; BB20
DB 028h, 069h, 000h, 0CDh, 0E6h, 002h, 090h, 00Ah, 0D0h, 005h, 0CCh, 0E5h, 002h, 090h, 003h, 04Ch ; BB30
DB 00Eh, 0B9h, 095h, 001h, 094h, 000h, 0CAh, 0CAh, 0E0h, 082h, 0B0h, 0D4h, 020h, 098h, 0BBh, 020h ; BB40
DB 066h, 0B7h, 0A9h, 000h, 085h, 0CAh, 068h, 0F0h, 001h, 060h, 04Ch, 050h, 0A0h, 0A9h, 000h, 085h ; BB50
DB 0CAh, 020h, 00Ah, 0B9h, 0A9h, 004h, 020h, 0B4h, 0BBh, 0A9h, 000h, 0F0h, 097h, 0A9h, 008h, 020h ; BB60
DB 0D7h, 0BAh, 0A9h, 00Bh, 085h, 0C0h, 0A2h, 080h, 038h, 0B5h, 000h, 0E5h, 080h, 09Dh, 000h, 005h ; BB70
DB 0E8h, 0B5h, 000h, 0E5h, 081h, 09Dh, 000h, 005h, 0E8h, 0E0h, 08Eh, 090h, 0EBh, 020h, 0AFh, 0BCh ; BB80
DB 0A0h, 00Eh, 020h, 015h, 0BDh, 020h, 0BBh, 0BCh, 020h, 0AFh, 0BCh, 0A5h, 082h, 085h, 0F3h, 0A5h ; BB90
DB 083h, 085h, 0F4h, 0ACh, 08Dh, 005h, 088h, 098h, 0ACh, 08Ch, 005h, 020h, 017h, 0BDh, 020h, 0BBh ; BBA0
DB 0BCh, 04Ch, 0F7h, 0BCh, 0EAh, 0EAh, 048h, 0A2h, 0CEh, 086h, 0F3h, 0A2h, 0BBh, 086h, 0F4h, 0A2h ; BBB0
DB 007h, 068h, 0A8h, 0A9h, 080h, 020h, 0D8h, 0BBh, 020h, 0BBh, 0BCh, 0A9h, 007h, 060h, 043h, 03Ah ; BBC0
DB 09Bh, 0A9h, 008h, 020h, 0B4h, 0BBh, 0D0h, 09Ah, 048h, 0A9h, 003h, 020h, 0BEh, 0BAh, 068h, 09Dh ; BBD0
DB 04Bh, 003h, 098h, 09Dh, 04Ah, 003h, 020h, 01Eh, 0BDh, 04Ch, 051h, 0DAh, 020h, 009h, 0BDh, 04Ch ; BBE0
DB 0F4h, 0BBh, 0A9h, 003h, 085h, 0C0h, 020h, 0A8h, 0BCh, 020h, 009h, 0BDh, 048h, 020h, 009h, 0BDh ; BBF0
DB 0A8h, 068h, 048h, 098h, 048h, 020h, 0DAh, 0AAh, 020h, 07Dh, 0BDh, 020h, 0AFh, 0BCh, 068h, 09Dh ; BC00
DB 04Bh, 003h, 068h, 09Dh, 04Ah, 003h, 020h, 00Fh, 0BDh, 020h, 09Dh, 0BDh, 020h, 051h, 0DAh, 04Ch ; BC10
DB 0BBh, 0BCh, 0A9h, 00Ch, 085h, 0C0h, 020h, 0A8h, 0BCh, 020h, 029h, 0BDh, 04Ch, 0BBh, 0BCh, 020h ; BC20
DB 0A8h, 0BCh, 0A9h, 00Dh, 020h, 02Bh, 0BDh, 020h, 000h, 0BDh, 04Ch, 031h, 0BDh, 0A9h, 026h, 020h ; BC30
DB 024h, 0BCh, 0BDh, 04Ch, 003h, 0BCh, 04Dh, 003h, 020h, 033h, 0BDh, 020h, 0AFh, 0BCh, 0BDh, 04Eh ; BC40
DB 003h, 04Ch, 031h, 0BDh, 020h, 0A8h, 0BCh, 020h, 0CDh, 0ABh, 020h, 0AFh, 0BCh, 0A5h, 0D4h, 09Dh ; BC50
DB 04Ch, 003h, 0A5h, 0D5h, 09Dh, 04Dh, 003h, 020h, 0CDh, 0ABh, 020h, 0AFh, 0BCh, 0A5h, 0D4h, 09Dh ; BC60
DB 04Eh, 003h, 0A9h, 025h, 085h, 0C0h, 0D0h, 0B1h, 020h, 0A8h, 0BCh, 020h, 0D7h, 0ABh, 0A5h, 0D4h ; BC70
DB 0A6h, 0C1h, 04Ch, 09Bh, 0BAh, 020h, 051h, 0DAh, 020h, 0A8h, 0BCh, 0A9h, 007h, 085h, 0C0h, 0A0h ; BC80
DB 001h, 020h, 015h, 0BDh, 020h, 0BBh, 0BCh, 0A0h, 000h, 0B1h, 0F3h, 04Ch, 031h, 0BDh, 020h, 00Ch ; BC90
DB 0BAh, 0A2h, 006h, 020h, 0C0h, 0BAh, 0D0h, 0E3h, 020h, 007h, 0BDh, 085h, 0C1h, 0F0h, 009h, 0A5h ; BCA0
DB 0C1h, 00Ah, 00Ah, 00Ah, 00Ah, 0AAh, 010h, 04Eh, 020h, 00Ch, 0B9h, 020h, 000h, 0BDh, 010h, 046h ; BCB0
DB 0A0h, 000h, 08Ch, 0FEh, 002h, 0C9h, 080h, 0D0h, 009h, 084h, 011h, 0A5h, 0CAh, 0F0h, 037h, 04Ch ; BCC0
DB 000h, 0A0h, 0A4h, 0C1h, 0C9h, 088h, 0F0h, 00Fh, 085h, 0B9h, 0C0h, 007h, 0D0h, 003h, 020h, 0F7h ; BCD0
DB 0BCh, 020h, 05Bh, 0BDh, 04Ch, 034h, 0B9h, 0C0h, 007h, 0D0h, 0EDh, 0A2h, 05Dh, 0E4h, 0C2h, 0D0h ; BCE0
DB 0E7h, 020h, 0F7h, 0BCh, 04Ch, 053h, 0A0h, 020h, 0AFh, 0BCh, 0F0h, 00Ah, 0A9h, 00Ch, 0D0h, 02Bh ; BCF0
DB 020h, 0AFh, 0BCh, 0BDh, 043h, 003h, 060h, 0E6h, 0A8h, 020h, 0CDh, 0ABh, 0A5h, 0D4h, 060h, 0A0h ; BD00
DB 0FFh, 0D0h, 002h, 0A0h, 000h, 0A9h, 000h, 09Dh, 049h, 003h, 098h, 09Dh, 048h, 003h, 0A5h, 0F4h ; BD10
DB 0A4h, 0F3h, 09Dh, 045h, 003h, 098h, 09Dh, 044h, 003h, 0A5h, 0C0h, 09Dh, 042h, 003h, 04Ch, 056h ; BD20
DB 0E4h, 0A0h, 000h, 048h, 098h, 048h, 020h, 006h, 0ACh, 068h, 085h, 0D5h, 068h, 085h, 0D4h, 020h ; BD30
DB 0AAh, 0D9h, 04Ch, 00Ch, 0ACh, 0A9h, 000h, 0A2h, 007h, 09Dh, 000h, 0D2h, 0CAh, 0D0h, 0FAh, 0A0h ; BD40
DB 007h, 084h, 0C1h, 020h, 0F7h, 0BCh, 0C6h, 0C1h, 0D0h, 0F9h, 060h, 0A9h, 000h, 085h, 0B4h, 085h ; BD50
DB 0B5h, 060h, 0A2h, 006h, 086h, 0F2h, 0BDh, 072h, 0BDh, 020h, 099h, 0BAh, 0A6h, 0F2h, 0CAh, 010h ; BD60
DB 0F3h, 060h, 09Bh, 059h, 044h, 041h, 045h, 052h, 09Bh, 0A2h, 000h, 0F0h, 0E7h, 020h, 090h, 0ABh ; BD70
DB 0A5h, 0D4h, 085h, 0F3h, 0A5h, 0D5h, 085h, 0F4h, 0A4h, 0D6h, 0A6h, 0D7h, 0F0h, 002h, 0A0h, 0FFh ; BD80
DB 0B1h, 0F3h, 085h, 097h, 084h, 098h, 0A9h, 09Bh, 091h, 0F3h, 085h, 092h, 060h, 0A4h, 098h, 0A5h ; BD90
DB 097h, 091h, 0F3h, 0A9h, 000h, 085h, 092h, 060h, 020h, 03Eh, 0B8h, 0B0h, 01Bh, 0D0h, 0F9h, 020h ; BDA0
DB 0CBh, 0BDh, 0C9h, 00Ch, 0F0h, 024h, 0C9h, 01Eh, 0F0h, 020h, 0C9h, 004h, 0F0h, 01Ch, 0C9h, 022h ; BDB0
DB 0F0h, 018h, 020h, 0F0h, 0B6h, 020h, 016h, 0B9h, 020h, 014h, 0B9h, 020h, 016h, 0B8h, 0B0h, 0F2h ; BDC0
DB 0A4h, 0B2h, 088h, 0B1h, 08Ah, 085h, 0A7h, 0C8h, 0B1h, 08Ah, 060h, 0A6h, 0B4h, 0D0h, 00Eh, 0A9h ; BDD0
DB 09Bh, 020h, 099h, 0BAh, 0A6h, 0B4h, 0D0h, 005h, 0A5h, 0C2h, 020h, 099h, 0BAh, 0A6h, 0B4h, 0A9h ; BDE0
DB 005h, 020h, 0BEh, 0BAh, 020h, 00Fh, 0BDh, 04Ch, 0BBh, 0BCh, 020h, 0FDh, 0ABh, 020h, 026h, 0ADh ; BDF0
DB 04Ch, 0B2h, 0ABh, 038h, 060h, 0A9h, 004h, 024h, 0D4h, 010h, 006h, 0A9h, 002h, 0D0h, 002h, 0A9h ; BE00
DB 001h, 085h, 0F0h, 0A5h, 0D4h, 029h, 07Fh, 085h, 0D4h, 0A9h, 0BDh, 018h, 065h, 0FBh, 0AAh, 0A0h ; BE10
DB 0BEh, 020h, 098h, 0DDh, 020h, 028h, 0DBh, 090h, 001h, 060h, 0A5h, 0D4h, 029h, 07Fh, 038h, 0E9h ; BE20
DB 040h, 030h, 02Bh, 0C9h, 004h, 010h, 0CCh, 0AAh, 0B5h, 0D5h, 085h, 0F1h, 029h, 010h, 0F0h, 002h ; BE30
DB 0A9h, 002h, 018h, 065h, 0F1h, 029h, 003h, 065h, 0F0h, 085h, 0F0h, 086h, 0F1h, 020h, 0B6h, 0DDh ; BE40
DB 0A6h, 0F1h, 0A9h, 000h, 095h, 0E2h, 0E8h, 0E0h, 003h, 090h, 0F9h, 020h, 060h, 0DAh, 046h, 0F0h ; BE50
DB 090h, 00Dh, 020h, 0B6h, 0DDh, 0A2h, 0CFh, 0A0h, 0BEh, 020h, 089h, 0DDh, 020h, 060h, 0DAh, 0A2h ; BE60
DB 0E6h, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h, 0B6h, 0DDh, 020h, 0DBh, 0DAh, 0B0h, 085h, 0A9h, 006h ; BE70
DB 0A2h, 09Fh, 0A0h, 0BEh, 020h, 040h, 0DDh, 0A2h, 0E6h, 0A0h, 005h, 020h, 098h, 0DDh, 020h, 0DBh ; BE80
DB 0DAh, 046h, 0F0h, 090h, 009h, 018h, 0A5h, 0D4h, 0F0h, 004h, 049h, 080h, 085h, 0D4h, 060h, 0BDh ; BE90
DB 003h, 055h, 014h, 099h, 039h, 03Eh, 001h, 060h, 044h, 027h, 052h, 0BEh, 046h, 081h, 075h, 043h ; BEA0
DB 055h, 03Fh, 007h, 096h, 092h, 062h, 039h, 0BFh, 064h, 059h, 064h, 008h, 067h, 040h, 001h, 057h ; BEB0
DB 007h, 096h, 032h, 040h, 090h, 000h, 000h, 000h, 000h, 03Fh, 001h, 074h, 053h, 029h, 025h, 040h ; BEC0
DB 001h, 000h, 000h, 000h, 000h, 0A9h, 000h, 085h, 0F0h, 085h, 0F1h, 0A5h, 0D4h, 029h, 07Fh, 0C9h ; BED0
DB 040h, 030h, 015h, 0A5h, 0D4h, 029h, 080h, 085h, 0F0h, 0E6h, 0F1h, 0A9h, 07Fh, 025h, 0D4h, 085h ; BEE0
DB 0D4h, 0A2h, 0EAh, 0A0h, 0DFh, 020h, 095h, 0DEh, 0A2h, 0E6h, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h ; BEF0
DB 0B6h, 0DDh, 020h, 0DBh, 0DAh, 0B0h, 039h, 0A9h, 00Bh, 0A2h, 0AEh, 0A0h, 0DFh, 020h, 040h, 0DDh ; BF00
DB 0B0h, 02Eh, 0A2h, 0E6h, 0A0h, 005h, 020h, 098h, 0DDh, 020h, 0DBh, 0DAh, 0B0h, 022h, 0A5h, 0F1h ; BF10
DB 0F0h, 010h, 0A2h, 0F0h, 0A0h, 0DFh, 020h, 098h, 0DDh, 020h, 066h, 0DAh, 0A5h, 0F0h, 005h, 0D4h ; BF20
DB 085h, 0D4h, 0A5h, 0FBh, 0F0h, 00Ah, 0A2h, 0C9h, 0A0h, 0BEh, 020h, 098h, 0DDh, 020h, 028h, 0DBh ; BF30
DB 060h, 038h, 060h, 0A9h, 000h, 085h, 0F1h, 0A5h, 0D4h, 030h, 0F6h, 0C9h, 03Fh, 0F0h, 017h, 018h ; BF40
DB 069h, 001h, 085h, 0F1h, 085h, 0E0h, 0A9h, 001h, 085h, 0E1h, 0A2h, 004h, 0A9h, 000h, 095h, 0E2h ; BF50
DB 0CAh, 010h, 0FBh, 020h, 028h, 0DBh, 0A9h, 006h, 085h, 0EFh, 0A2h, 0E6h, 0A0h, 005h, 020h, 0A7h ; BF60
DB 0DDh, 020h, 0B6h, 0DDh, 0A2h, 0F1h, 0A0h, 0BAh, 020h, 089h, 0DDh, 020h, 060h, 0DAh, 0A2h, 0E6h ; BF70
DB 0A0h, 005h, 020h, 098h, 0DDh, 020h, 0DBh, 0DAh, 0A2h, 0ECh, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h ; BF80
DB 0B6h, 0DDh, 0A2h, 0E6h, 0A0h, 005h, 020h, 089h, 0DDh, 020h, 028h, 0DBh, 0A2h, 0ECh, 0A0h, 005h ; BF90
DB 020h, 098h, 0DDh, 020h, 060h, 0DAh, 0A2h, 06Ch, 0A0h, 0DFh, 020h, 098h, 0DDh, 020h, 0DBh, 0DAh ; BFA0
DB 0A5h, 0D4h, 0F0h, 00Eh, 0A2h, 0ECh, 0A0h, 005h, 020h, 098h, 0DDh, 020h, 066h, 0DAh, 0C6h, 0EFh ; BFB0
DB 010h, 0C6h, 0A2h, 0ECh, 0A0h, 005h, 020h, 089h, 0DDh, 0A5h, 0F1h, 0F0h, 023h, 038h, 0E9h, 040h ; BFC0
DB 018h, 06Ah, 018h, 069h, 040h, 029h, 07Fh, 085h, 0E0h, 0A5h, 0F1h, 06Ah, 0A9h, 001h, 090h, 002h ; BFD0
DB 0A9h, 010h, 085h, 0E1h, 0A2h, 004h, 0A9h, 000h, 095h, 0E2h, 0CAh, 010h, 0FBh, 020h, 0DBh, 0DAh ; BFE0
DB 060h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 0A0h, 000h, 005h, 0F0h, 0BFh ; BFF0
rgbXLXEC000 LABEL BYTE
DB 011h, 092h, 010h, 005h, 083h, 000h, 042h, 042h, 000h, 000h, 001h, 002h, 0A9h, 040h, 08Dh, 00Eh ; C000 XL/XE OS $C000-$CFFF
DB 0D4h, 0ADh, 013h, 0D0h, 08Dh, 0FAh, 003h, 060h, 02Ch, 00Fh, 0D4h, 010h, 003h, 06Ch, 000h, 002h ; C010
DB 0D8h, 048h, 08Ah, 048h, 098h, 048h, 08Dh, 00Fh, 0D4h, 06Ch, 022h, 002h, 0D8h, 06Ch, 016h, 002h ; C020
DB 048h, 0ADh, 00Eh, 0D2h, 029h, 020h, 0D0h, 00Dh, 0A9h, 0DFh, 08Dh, 00Eh, 0D2h, 0A5h, 010h, 08Dh ; C030
DB 00Eh, 0D2h, 06Ch, 00Ah, 002h, 08Ah, 048h, 0ADh, 0FFh, 0D1h, 02Dh, 049h, 002h, 0F0h, 003h, 06Ch ; C040
DB 038h, 002h, 0A2h, 006h, 0BDh, 0CFh, 0C0h, 0E0h, 005h, 0D0h, 004h, 025h, 010h, 0F0h, 005h, 02Ch ; C050
DB 00Eh, 0D2h, 0F0h, 006h, 0CAh, 010h, 0EDh, 04Ch, 0A0h, 0C0h, 049h, 0FFh, 08Dh, 00Eh, 0D2h, 0A5h ; C060
DB 010h, 08Dh, 00Eh, 0D2h, 0E0h, 000h, 0D0h, 005h, 0ADh, 06Dh, 002h, 0D0h, 023h, 0BDh, 0D7h, 0C0h ; C070
DB 0AAh, 0BDh, 000h, 002h, 08Dh, 08Ch, 002h, 0BDh, 001h, 002h, 08Dh, 08Dh, 002h, 068h, 0AAh, 06Ch ; C080
DB 08Ch, 002h, 0A9h, 000h, 085h, 011h, 08Dh, 0FFh, 002h, 08Dh, 0F0h, 002h, 085h, 04Dh, 068h, 040h ; C090
DB 068h, 0AAh, 02Ch, 002h, 0D3h, 010h, 006h, 0ADh, 000h, 0D3h, 06Ch, 002h, 002h, 02Ch, 003h, 0D3h ; C0A0
DB 010h, 006h, 0ADh, 001h, 0D3h, 06Ch, 004h, 002h, 068h, 08Dh, 08Ch, 002h, 068h, 048h, 029h, 010h ; C0B0
DB 0F0h, 007h, 0ADh, 08Ch, 002h, 048h, 06Ch, 006h, 002h, 0ADh, 08Ch, 002h, 048h, 068h, 040h, 080h ; C0C0
DB 040h, 004h, 002h, 001h, 008h, 010h, 020h, 036h, 008h, 014h, 012h, 010h, 00Eh, 00Ch, 00Ah, 04Ch ; C0D0
DB 0DFh, 0C0h, 0E6h, 014h, 0D0h, 008h, 0E6h, 04Dh, 0E6h, 013h, 0D0h, 002h, 0E6h, 012h, 0A9h, 0FEh ; C0E0
DB 0A2h, 000h, 0A4h, 04Dh, 010h, 006h, 085h, 04Dh, 0A6h, 013h, 0A9h, 0F6h, 085h, 04Eh, 086h, 04Fh ; C0F0
DB 0ADh, 0C5h, 002h, 045h, 04Fh, 025h, 04Eh, 08Dh, 017h, 0D0h, 0A2h, 000h, 020h, 055h, 0C2h, 0D0h ; C100
DB 003h, 020h, 04Fh, 0C2h, 0A5h, 042h, 0D0h, 008h, 0BAh, 0BDh, 004h, 001h, 029h, 004h, 0F0h, 003h ; C110
DB 04Ch, 08Ah, 0C2h, 0ADh, 013h, 0D0h, 0CDh, 0FAh, 003h, 0D0h, 0B4h, 0ADh, 00Dh, 0D4h, 08Dh, 035h ; C120
DB 002h, 0ADh, 00Ch, 0D4h, 08Dh, 034h, 002h, 0ADh, 031h, 002h, 08Dh, 003h, 0D4h, 0ADh, 030h, 002h ; C130
DB 08Dh, 002h, 0D4h, 0ADh, 02Fh, 002h, 08Dh, 000h, 0D4h, 0ADh, 06Fh, 002h, 08Dh, 01Bh, 0D0h, 0ADh ; C140
DB 06Ch, 002h, 0F0h, 00Eh, 0CEh, 06Ch, 002h, 0A9h, 008h, 038h, 0EDh, 06Ch, 002h, 029h, 007h, 08Dh ; C150
DB 005h, 0D4h, 0A2h, 008h, 08Eh, 01Fh, 0D0h, 058h, 0BDh, 0C0h, 002h, 045h, 04Fh, 025h, 04Eh, 09Dh ; C160
DB 012h, 0D0h, 0CAh, 010h, 0F2h, 0ADh, 0F4h, 002h, 08Dh, 009h, 0D4h, 0ADh, 0F3h, 002h, 08Dh, 001h ; C170
DB 0D4h, 0A2h, 002h, 020h, 055h, 0C2h, 0D0h, 003h, 020h, 052h, 0C2h, 0A2h, 002h, 0E8h, 0E8h, 0BDh ; C180
DB 018h, 002h, 01Dh, 019h, 002h, 0F0h, 006h, 020h, 055h, 0C2h, 09Dh, 026h, 002h, 0E0h, 008h, 0D0h ; C190
DB 0ECh, 0ADh, 00Fh, 0D2h, 029h, 004h, 0F0h, 008h, 0ADh, 0F1h, 002h, 0F0h, 003h, 0CEh, 0F1h, 002h ; C1A0
DB 0ADh, 02Bh, 002h, 0F0h, 03Eh, 0ADh, 00Fh, 0D2h, 029h, 004h, 0D0h, 032h, 0CEh, 02Bh, 002h, 0D0h ; C1B0
DB 032h, 0ADh, 06Dh, 002h, 0D0h, 02Dh, 0ADh, 0DAh, 002h, 08Dh, 02Bh, 002h, 0ADh, 009h, 0D2h, 0C9h ; C1C0
DB 09Fh, 0F0h, 020h, 0C9h, 083h, 0F0h, 01Ch, 0C9h, 084h, 0F0h, 018h, 0C9h, 094h, 0F0h, 014h, 029h ; C1D0
DB 03Fh, 0C9h, 011h, 0F0h, 00Eh, 0ADh, 009h, 0D2h, 08Dh, 0FCh, 002h, 04Ch, 0F3h, 0C1h, 0A9h, 000h ; C1E0
DB 08Dh, 02Bh, 002h, 0ADh, 000h, 0D3h, 04Ah, 04Ah, 04Ah, 04Ah, 08Dh, 079h, 002h, 08Dh, 07Bh, 002h ; C1F0
DB 0ADh, 000h, 0D3h, 029h, 00Fh, 08Dh, 078h, 002h, 08Dh, 07Ah, 002h, 0ADh, 010h, 0D0h, 08Dh, 084h ; C200
DB 002h, 08Dh, 086h, 002h, 0ADh, 011h, 0D0h, 08Dh, 085h, 002h, 08Dh, 087h, 002h, 0A2h, 003h, 0BDh ; C210
DB 000h, 0D2h, 09Dh, 070h, 002h, 09Dh, 074h, 002h, 0CAh, 010h, 0F4h, 08Dh, 00Bh, 0D2h, 0A2h, 002h ; C220
DB 0A0h, 001h, 0B9h, 078h, 002h, 04Ah, 04Ah, 04Ah, 09Dh, 07Dh, 002h, 09Dh, 081h, 002h, 0A9h, 000h ; C230
DB 02Ah, 09Dh, 07Ch, 002h, 09Dh, 080h, 002h, 0CAh, 0CAh, 088h, 010h, 0E6h, 06Ch, 024h, 002h, 06Ch ; C240
DB 026h, 002h, 06Ch, 028h, 002h, 0BCh, 018h, 002h, 0D0h, 008h, 0BCh, 019h, 002h, 0F0h, 010h, 0DEh ; C250
DB 019h, 002h, 0DEh, 018h, 002h, 0D0h, 008h, 0BCh, 019h, 002h, 0D0h, 003h, 0A9h, 000h, 060h, 0A9h ; C260
DB 0FFh, 060h, 00Ah, 08Dh, 02Dh, 002h, 08Ah, 0A2h, 005h, 08Dh, 00Ah, 0D4h, 0CAh, 0D0h, 0FDh, 0AEh ; C270
DB 02Dh, 002h, 09Dh, 017h, 002h, 098h, 09Dh, 016h, 002h, 060h, 068h, 0A8h, 068h, 0AAh, 068h, 040h ; C280
DB 078h, 0ADh, 013h, 0D0h, 0CDh, 0FAh, 003h, 0D0h, 02Fh, 06Ah, 090h, 005h, 020h, 0C9h, 0C4h, 0D0h ; C290
DB 027h, 0ADh, 044h, 002h, 0D0h, 022h, 0A9h, 0FFh, 0D0h, 020h, 078h, 0A2h, 08Ch, 088h, 0D0h, 0FDh ; C2A0
DB 0CAh, 0D0h, 0FAh, 0ADh, 03Dh, 003h, 0C9h, 05Ch, 0D0h, 00Eh, 0ADh, 03Eh, 003h, 0C9h, 093h, 0D0h ; C2B0
DB 007h, 0ADh, 03Fh, 003h, 0C9h, 025h, 0F0h, 0C8h, 0A9h, 000h, 085h, 008h, 078h, 0D8h, 0A2h, 0FFh ; C2C0
DB 09Ah, 020h, 071h, 0C4h, 0A9h, 001h, 085h, 001h, 0A5h, 008h, 0D0h, 052h, 0A9h, 000h, 0A0h, 008h ; C2D0
DB 085h, 004h, 085h, 005h, 0A9h, 0FFh, 091h, 004h, 0D1h, 004h, 0F0h, 002h, 046h, 001h, 0A9h, 000h ; C2E0
DB 091h, 004h, 0D1h, 004h, 0F0h, 002h, 046h, 001h, 0C8h, 0D0h, 0E9h, 0E6h, 005h, 0A6h, 005h, 0E4h ; C2F0
DB 006h, 0D0h, 0E1h, 0A9h, 023h, 085h, 00Ah, 0A9h, 0F2h, 085h, 00Bh, 0ADh, 001h, 0D3h, 029h, 07Fh ; C300
DB 08Dh, 001h, 0D3h, 020h, 073h, 0FFh, 0B0h, 005h, 020h, 092h, 0FFh, 090h, 002h, 046h, 001h, 0ADh ; C310
DB 001h, 0D3h, 009h, 080h, 08Dh, 001h, 0D3h, 0A9h, 0FFh, 08Dh, 044h, 002h, 0D0h, 022h, 0A2h, 000h ; C320
DB 0ADh, 0ECh, 003h, 0F0h, 007h, 08Eh, 00Eh, 000h, 08Eh, 00Fh, 000h, 08Ah, 09Dh, 000h, 002h, 0E0h ; C330
DB 0EDh, 0B0h, 003h, 09Dh, 000h, 003h, 0CAh, 0D0h, 0F3h, 0A2h, 010h, 095h, 000h, 0E8h, 010h, 0FBh ; C340
DB 0A2h, 000h, 0ADh, 001h, 0D3h, 029h, 002h, 0F0h, 001h, 0E8h, 08Eh, 0F8h, 003h, 0A9h, 05Ch, 08Dh ; C350
DB 03Dh, 003h, 0A9h, 093h, 08Dh, 03Eh, 003h, 0A9h, 025h, 08Dh, 03Fh, 003h, 0A9h, 002h, 085h, 052h ; C360
DB 0A9h, 027h, 085h, 053h, 0ADh, 014h, 0D0h, 029h, 00Eh, 0D0h, 008h, 0A9h, 005h, 0A2h, 001h, 0A0h ; C370
DB 028h, 0D0h, 006h, 0A9h, 006h, 0A2h, 000h, 0A0h, 030h, 08Dh, 0DAh, 002h, 086h, 062h, 08Ch, 0D9h ; C380
DB 002h, 0A2h, 025h, 0BDh, 04Bh, 0C4h, 09Dh, 000h, 002h, 0CAh, 010h, 0F7h, 0A2h, 00Eh, 0BDh, 02Eh ; C390
DB 0C4h, 09Dh, 01Ah, 003h, 0CAh, 010h, 0F7h, 020h, 035h, 0C5h, 058h, 0A5h, 001h, 0D0h, 015h, 0ADh ; C3A0
DB 001h, 0D3h, 029h, 07Fh, 08Dh, 001h, 0D3h, 0A9h, 002h, 08Dh, 0F3h, 002h, 0A9h, 0E0h, 08Dh, 0F4h ; C3B0
DB 002h, 04Ch, 003h, 050h, 0A2h, 000h, 086h, 006h, 0AEh, 0E4h, 002h, 0E0h, 0B0h, 0B0h, 00Dh, 0AEh ; C3C0
DB 0FCh, 0BFh, 0D0h, 008h, 0E6h, 006h, 020h, 0C9h, 0C4h, 020h, 029h, 0C4h, 0A9h, 003h, 0A2h, 000h ; C3D0
DB 09Dh, 042h, 003h, 0A9h, 048h, 09Dh, 044h, 003h, 0A9h, 0C4h, 09Dh, 045h, 003h, 0A9h, 00Ch, 09Dh ; C3E0
DB 04Ah, 003h, 020h, 056h, 0E4h, 010h, 003h, 04Ch, 0AAh, 0C2h, 0E8h, 0D0h, 0FDh, 0C8h, 010h, 0FAh ; C3F0
DB 020h, 06Eh, 0C6h, 0A5h, 006h, 0F0h, 006h, 0ADh, 0FDh, 0BFh, 06Ah, 090h, 006h, 020h, 08Bh, 0C5h ; C400
DB 020h, 039h, 0E7h, 0A9h, 000h, 08Dh, 044h, 002h, 0A5h, 006h, 0F0h, 00Ah, 0ADh, 0FDh, 0BFh, 029h ; C410
DB 004h, 0F0h, 003h, 06Ch, 0FAh, 0BFh, 06Ch, 00Ah, 000h, 06Ch, 0FEh, 0BFh, 018h, 060h, 050h, 030h ; C420
DB 0E4h, 043h, 040h, 0E4h, 045h, 000h, 0E4h, 053h, 010h, 0E4h, 04Bh, 020h, 0E4h, 042h, 04Fh, 04Fh ; C430
DB 054h, 020h, 045h, 052h, 052h, 04Fh, 052h, 09Bh, 045h, 03Ah, 09Bh, 0CEh, 0C0h, 0CDh, 0C0h, 0CDh ; C440
DB 0C0h, 0CDh, 0C0h, 019h, 0FCh, 02Ch, 0EBh, 0ADh, 0EAh, 0ECh, 0EAh, 0CDh, 0C0h, 0CDh, 0C0h, 0CDh ; C450
DB 0C0h, 030h, 0C0h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 0E2h, 0C0h, 08Ah ; C460
DB 0C2h, 0ADh, 013h, 0D0h, 06Ah, 090h, 00Dh, 0ADh, 0FCh, 0BFh, 0D0h, 008h, 0ADh, 0FDh, 0BFh, 010h ; C470
DB 003h, 06Ch, 0FEh, 0BFh, 020h, 0DAh, 0C4h, 0ADh, 001h, 0D3h, 009h, 002h, 08Dh, 001h, 0D3h, 0A5h ; C480
DB 008h, 0F0h, 007h, 0ADh, 0F8h, 003h, 0D0h, 011h, 0F0h, 007h, 0ADh, 01Fh, 0D0h, 029h, 004h, 0F0h ; C490
DB 008h, 0ADh, 001h, 0D3h, 029h, 0FDh, 08Dh, 001h, 0D3h, 0A9h, 000h, 0A8h, 085h, 005h, 0A9h, 028h ; C4A0
DB 085h, 006h, 0B1h, 005h, 049h, 0FFh, 091h, 005h, 0D1h, 005h, 0D0h, 00Ch, 049h, 0FFh, 091h, 005h ; C4B0
DB 0D1h, 005h, 0D0h, 004h, 0E6h, 006h, 0D0h, 0EAh, 060h, 0A9h, 000h, 0AAh, 018h, 07Dh, 0F0h, 0BFh ; C4C0
DB 0E8h, 0D0h, 0FAh, 0CDh, 0EBh, 003h, 08Dh, 0EBh, 003h, 060h, 0A9h, 000h, 0AAh, 08Dh, 003h, 0D3h ; C4D0
DB 09Dh, 000h, 0D0h, 09Dh, 000h, 0D4h, 09Dh, 000h, 0D2h, 0E0h, 001h, 0F0h, 003h, 09Dh, 000h, 0D3h ; C4E0
DB 0E8h, 0D0h, 0EDh, 0A9h, 03Ch, 08Dh, 003h, 0D3h, 0A9h, 0FFh, 08Dh, 001h, 0D3h, 0A9h, 038h, 08Dh ; C4F0
DB 002h, 0D3h, 08Dh, 003h, 0D3h, 0A9h, 000h, 08Dh, 000h, 0D3h, 0A9h, 0FFh, 08Dh, 001h, 0D3h, 0A9h ; C500
DB 03Ch, 08Dh, 002h, 0D3h, 08Dh, 003h, 0D3h, 0ADh, 001h, 0D3h, 0ADh, 000h, 0D3h, 0A9h, 022h, 08Dh ; C510
DB 00Fh, 0D2h, 0A9h, 0A0h, 08Dh, 005h, 0D2h, 08Dh, 007h, 0D2h, 0A9h, 028h, 08Dh, 008h, 0D2h, 0A9h ; C520
DB 0FFh, 08Dh, 00Dh, 0D2h, 060h, 0C6h, 011h, 0A9h, 092h, 08Dh, 036h, 002h, 0A9h, 0C0h, 08Dh, 037h ; C530
DB 002h, 0A5h, 006h, 08Dh, 0E4h, 002h, 08Dh, 0E6h, 002h, 0A9h, 000h, 08Dh, 0E5h, 002h, 0A9h, 000h ; C540
DB 08Dh, 0E7h, 002h, 0A9h, 007h, 08Dh, 0E8h, 002h, 020h, 00Ch, 0E4h, 020h, 01Ch, 0E4h, 020h, 02Ch ; C550
DB 0E4h, 020h, 03Ch, 0E4h, 020h, 04Ch, 0E4h, 020h, 06Eh, 0E4h, 020h, 065h, 0E4h, 020h, 06Bh, 0E4h ; C560
DB 020h, 050h, 0E4h, 0A9h, 06Eh, 08Dh, 038h, 002h, 0A9h, 0C9h, 08Dh, 039h, 002h, 020h, 09Bh, 0E4h ; C570
DB 0ADh, 01Fh, 0D0h, 029h, 001h, 049h, 001h, 08Dh, 0E9h, 003h, 060h, 0A5h, 008h, 0F0h, 009h, 0A5h ; C580
DB 009h, 029h, 001h, 0F0h, 033h, 04Ch, 03Bh, 0C6h, 0A9h, 001h, 08Dh, 001h, 003h, 0A9h, 053h, 08Dh ; C590
DB 002h, 003h, 020h, 053h, 0E4h, 030h, 021h, 0A9h, 000h, 08Dh, 00Bh, 003h, 0A9h, 001h, 08Dh, 00Ah ; C5A0
DB 003h, 0A9h, 000h, 08Dh, 004h, 003h, 0A9h, 004h, 08Dh, 005h, 003h, 020h, 059h, 0C6h, 010h, 009h ; C5B0
DB 020h, 03Eh, 0C6h, 0ADh, 0EAh, 003h, 0F0h, 0DFh, 060h, 0A2h, 003h, 0BDh, 000h, 004h, 09Dh, 040h ; C5C0
DB 002h, 0CAh, 010h, 0F7h, 0ADh, 042h, 002h, 085h, 004h, 0ADh, 043h, 002h, 085h, 005h, 0ADh, 004h ; C5D0
DB 004h, 085h, 00Ch, 0ADh, 005h, 004h, 085h, 00Dh, 0A0h, 07Fh, 0B9h, 000h, 004h, 091h, 004h, 088h ; C5E0
DB 010h, 0F8h, 018h, 0A5h, 004h, 069h, 080h, 085h, 004h, 0A5h, 005h, 069h, 000h, 085h, 005h, 0CEh ; C5F0
DB 041h, 002h, 0F0h, 012h, 0EEh, 00Ah, 003h, 020h, 059h, 0C6h, 010h, 0DCh, 020h, 03Eh, 0C6h, 0ADh ; C600
DB 0EAh, 003h, 0D0h, 0ACh, 0F0h, 0F1h, 0ADh, 0EAh, 003h, 0F0h, 003h, 020h, 059h, 0C6h, 020h, 029h ; C610
DB 0C6h, 0B0h, 09Dh, 020h, 03Bh, 0C6h, 0E6h, 009h, 060h, 018h, 0ADh, 042h, 002h, 069h, 006h, 085h ; C620
DB 004h, 0ADh, 043h, 002h, 069h, 000h, 085h, 005h, 06Ch, 004h, 000h, 06Ch, 00Ch, 000h, 0A2h, 03Dh ; C630
DB 0A0h, 0C4h, 08Ah, 0A2h, 000h, 09Dh, 044h, 003h, 098h, 09Dh, 045h, 003h, 0A9h, 009h, 09Dh, 042h ; C640
DB 003h, 0A9h, 0FFh, 09Dh, 048h, 003h, 04Ch, 056h, 0E4h, 0ADh, 0EAh, 003h, 0F0h, 003h, 04Ch, 07Ah ; C650
DB 0E4h, 0A9h, 052h, 08Dh, 002h, 003h, 0A9h, 001h, 08Dh, 001h, 003h, 04Ch, 053h, 0E4h, 0A5h, 008h ; C660
DB 0F0h, 009h, 0A5h, 009h, 029h, 002h, 0F0h, 027h, 04Ch, 0A0h, 0C6h, 0ADh, 0E9h, 003h, 0F0h, 01Fh ; C670
DB 0A9h, 080h, 085h, 03Eh, 0EEh, 0EAh, 003h, 020h, 07Dh, 0E4h, 020h, 0BBh, 0C5h, 0A9h, 000h, 08Dh ; C680
DB 0EAh, 003h, 08Dh, 0E9h, 003h, 006h, 009h, 0A5h, 00Ch, 085h, 002h, 0A5h, 00Dh, 085h, 003h, 060h ; C690
DB 06Ch, 002h, 000h, 0A9h, 0A0h, 08Dh, 046h, 002h, 0A9h, 080h, 08Dh, 0D5h, 002h, 0A9h, 000h, 08Dh ; C6A0
DB 0D6h, 002h, 060h, 0A9h, 031h, 08Dh, 000h, 003h, 0ADh, 046h, 002h, 0AEh, 002h, 003h, 0E0h, 021h ; C6B0
DB 0F0h, 002h, 0A9h, 007h, 08Dh, 006h, 003h, 0A2h, 040h, 0ADh, 002h, 003h, 0C9h, 050h, 0F0h, 004h ; C6C0
DB 0C9h, 057h, 0D0h, 002h, 0A2h, 080h, 0C9h, 053h, 0D0h, 010h, 0A9h, 0EAh, 08Dh, 004h, 003h, 0A9h ; C6D0
DB 002h, 08Dh, 005h, 003h, 0A0h, 004h, 0A9h, 000h, 0F0h, 006h, 0ACh, 0D5h, 002h, 0ADh, 0D6h, 002h ; C6E0
DB 08Eh, 003h, 003h, 08Ch, 008h, 003h, 08Dh, 009h, 003h, 020h, 059h, 0E4h, 010h, 001h, 060h, 0ADh ; C6F0
DB 002h, 003h, 0C9h, 053h, 0D0h, 00Ah, 020h, 03Ah, 0C7h, 0A0h, 002h, 0B1h, 015h, 08Dh, 046h, 002h ; C700
DB 0ADh, 002h, 003h, 0C9h, 021h, 0D0h, 01Fh, 020h, 03Ah, 0C7h, 0A0h, 0FEh, 0C8h, 0C8h, 0B1h, 015h ; C710
DB 0C9h, 0FFh, 0D0h, 0F8h, 0C8h, 0B1h, 015h, 0C8h, 0C9h, 0FFh, 0D0h, 0F2h, 088h, 088h, 08Ch, 008h ; C720
DB 003h, 0A9h, 000h, 08Dh, 009h, 003h, 0ACh, 003h, 003h, 060h, 0ADh, 004h, 003h, 085h, 015h, 0ADh ; C730
DB 005h, 003h, 085h, 016h, 060h, 0A2h, 005h, 0A9h, 000h, 09Dh, 0C9h, 002h, 0CAh, 010h, 0F8h, 0A9h ; C740
DB 000h, 08Dh, 033h, 002h, 020h, 0CFh, 0C7h, 0A0h, 09Ch, 0B0h, 039h, 08Dh, 088h, 002h, 020h, 0CFh ; C750
DB 0C7h, 0A0h, 09Ch, 0B0h, 02Fh, 08Dh, 045h, 002h, 0ADh, 088h, 002h, 0C9h, 00Bh, 0F0h, 026h, 02Ah ; C760
DB 0AAh, 0BDh, 0E4h, 0C8h, 08Dh, 0C9h, 002h, 0BDh, 0E5h, 0C8h, 08Dh, 0CAh, 002h, 0ADh, 045h, 002h ; C770
DB 0CDh, 033h, 002h, 0F0h, 0CAh, 020h, 0CFh, 0C7h, 0A0h, 09Ch, 0B0h, 008h, 020h, 0D2h, 0C7h, 0EEh ; C780
DB 033h, 002h, 0D0h, 0E9h, 060h, 020h, 0CFh, 0C7h, 0A0h, 09Ch, 0B0h, 02Ch, 08Dh, 0C9h, 002h, 020h ; C790
DB 0CFh, 0C7h, 0A0h, 09Ch, 0B0h, 022h, 08Dh, 0CAh, 002h, 0ADh, 045h, 002h, 0C9h, 001h, 0F0h, 016h ; C7A0
DB 090h, 017h, 018h, 0ADh, 0C9h, 002h, 06Dh, 0D1h, 002h, 0A8h, 0ADh, 0CAh, 002h, 06Dh, 0D2h, 002h ; C7B0
DB 08Ch, 0C9h, 002h, 08Dh, 0CAh, 002h, 0A0h, 001h, 060h, 0A0h, 000h, 0A9h, 000h, 0F0h, 0F1h, 06Ch ; C7C0
DB 0CFh, 002h, 06Ch, 0C9h, 002h, 0ACh, 033h, 002h, 0C0h, 001h, 0F0h, 00Ah, 0B0h, 073h, 08Dh, 04Ah ; C7D0
DB 002h, 08Dh, 08Eh, 002h, 090h, 06Ah, 08Dh, 04Bh, 002h, 08Dh, 08Fh, 002h, 0A2h, 000h, 0ADh, 088h ; C7E0
DB 002h, 0F0h, 006h, 0C9h, 00Ah, 0F0h, 015h, 0A2h, 002h, 018h, 0ADh, 04Ah, 002h, 07Dh, 0D1h, 002h ; C7F0
DB 08Dh, 08Eh, 002h, 0ADh, 04Bh, 002h, 07Dh, 0D2h, 002h, 08Dh, 08Fh, 002h, 018h, 0ADh, 08Eh, 002h ; C800
DB 06Dh, 045h, 002h, 048h, 0A9h, 000h, 06Dh, 08Fh, 002h, 0A8h, 068h, 038h, 0E9h, 002h, 0B0h, 001h ; C810
DB 088h, 048h, 098h, 0DDh, 0CCh, 002h, 068h, 090h, 010h, 0D0h, 005h, 0DDh, 0CBh, 002h, 090h, 009h ; C820
DB 09Dh, 0CBh, 002h, 048h, 098h, 09Dh, 0CCh, 002h, 068h, 0AEh, 088h, 002h, 0E0h, 001h, 0F0h, 010h ; C830
DB 0CCh, 0E6h, 002h, 090h, 00Bh, 0D0h, 005h, 0CDh, 0E5h, 002h, 090h, 004h, 068h, 068h, 0A0h, 09Dh ; C840
DB 060h, 038h, 048h, 0ADh, 033h, 002h, 0E9h, 002h, 018h, 06Dh, 08Eh, 002h, 085h, 036h, 0A9h, 000h ; C850
DB 06Dh, 08Fh, 002h, 085h, 037h, 068h, 0A0h, 000h, 091h, 036h, 04Ch, 050h, 0C8h, 018h, 06Dh, 08Eh ; C860
DB 002h, 085h, 036h, 0A9h, 000h, 06Dh, 08Fh, 002h, 085h, 037h, 0A0h, 000h, 0B1h, 036h, 018h, 06Dh ; C870
DB 0D1h, 002h, 091h, 036h, 0E6h, 036h, 0D0h, 002h, 0E6h, 037h, 0B1h, 036h, 06Dh, 0D2h, 002h, 091h ; C880
DB 036h, 060h, 0A2h, 000h, 0ACh, 088h, 002h, 0C0h, 004h, 090h, 002h, 0A2h, 002h, 018h, 06Dh, 08Eh ; C890
DB 002h, 085h, 036h, 0A9h, 000h, 06Dh, 08Fh, 002h, 085h, 037h, 0A0h, 000h, 0B1h, 036h, 018h, 07Dh ; C8A0
DB 0D1h, 002h, 091h, 036h, 060h, 048h, 0ADh, 033h, 002h, 06Ah, 068h, 0B0h, 015h, 018h, 06Dh, 08Eh ; C8B0
DB 002h, 085h, 036h, 0A9h, 000h, 06Dh, 08Fh, 002h, 085h, 037h, 0A0h, 000h, 0B1h, 036h, 08Dh, 088h ; C8C0
DB 002h, 060h, 018h, 06Dh, 0D1h, 002h, 0A9h, 000h, 06Dh, 0D2h, 002h, 06Dh, 088h, 002h, 0A0h, 000h ; C8D0
DB 091h, 036h, 0F0h, 0EDh, 0D5h, 0C7h, 0D5h, 0C7h, 092h, 0C8h, 092h, 0C8h, 092h, 0C8h, 092h, 0C8h ; C8E0
DB 06Dh, 0C8h, 06Dh, 0C8h, 0B5h, 0C8h, 0B5h, 0C8h, 0D5h, 0C7h, 095h, 0C7h, 0A9h, 0FFh, 08Dh, 044h ; C8F0
DB 002h, 0ADh, 001h, 0D3h, 029h, 07Fh, 08Dh, 001h, 0D3h, 04Ch, 083h, 0E4h, 0A9h, 001h, 08Dh, 048h ; C900
DB 002h, 0ADh, 048h, 002h, 08Dh, 0FFh, 0D1h, 0ADh, 003h, 0D8h, 0C9h, 080h, 0D0h, 00Ah, 0ADh, 00Bh ; C910
DB 0D8h, 0C9h, 091h, 0D0h, 003h, 020h, 019h, 0D8h, 00Eh, 048h, 002h, 0D0h, 0E4h, 0A9h, 000h, 08Dh ; C920
DB 0FFh, 0D1h, 060h, 0A9h, 001h, 08Dh, 042h, 000h, 0ADh, 001h, 003h, 048h, 0ADh, 047h, 002h, 0F0h ; C930
DB 01Ah, 0A2h, 008h, 020h, 0AFh, 0C9h, 0F0h, 013h, 08Ah, 048h, 020h, 005h, 0D8h, 068h, 0AAh, 090h ; C940
DB 0F2h, 0A9h, 000h, 08Dh, 048h, 002h, 08Dh, 0FFh, 0D1h, 0F0h, 003h, 020h, 071h, 0E9h, 068h, 08Dh ; C950
DB 001h, 003h, 0A9h, 000h, 08Dh, 042h, 000h, 08Ch, 003h, 003h, 0ACh, 003h, 003h, 060h, 0A2h, 008h ; C960
DB 06Ah, 0B0h, 003h, 0CAh, 0D0h, 0FAh, 0ADh, 048h, 002h, 048h, 0BDh, 020h, 0CAh, 08Dh, 048h, 002h ; C970
DB 08Dh, 0FFh, 0D1h, 020h, 008h, 0D8h, 068h, 08Dh, 048h, 002h, 08Dh, 0FFh, 0D1h, 068h, 0AAh, 068h ; C980
DB 040h, 0A0h, 001h, 04Ch, 0DCh, 0C9h, 0A0h, 003h, 04Ch, 0DCh, 0C9h, 0A0h, 005h, 04Ch, 0DCh, 0C9h ; C990
DB 0A0h, 007h, 04Ch, 0DCh, 0C9h, 0A0h, 009h, 04Ch, 0DCh, 0C9h, 0A0h, 00Bh, 04Ch, 0DCh, 0C9h, 0CAh ; C9A0
DB 010h, 009h, 0A9h, 000h, 08Dh, 048h, 002h, 08Dh, 0FFh, 0D1h, 060h, 0ADh, 047h, 002h, 03Dh, 021h ; C9B0
DB 0CAh, 0F0h, 0ECh, 08Dh, 048h, 002h, 08Dh, 0FFh, 0D1h, 060h, 0B9h, 00Dh, 0D8h, 048h, 088h, 0B9h ; C9C0
DB 00Dh, 0D8h, 048h, 0ADh, 04Ch, 002h, 0AEh, 04Dh, 002h, 0A0h, 092h, 060h, 08Dh, 04Ch, 002h, 08Eh ; C9D0
DB 04Dh, 002h, 0ADh, 042h, 000h, 048h, 0A9h, 001h, 08Dh, 042h, 000h, 0A2h, 008h, 020h, 0AFh, 0C9h ; C9E0
DB 0F0h, 011h, 08Ah, 048h, 098h, 048h, 020h, 0CAh, 0C9h, 090h, 020h, 08Dh, 04Ch, 002h, 068h, 068h ; C9F0
DB 04Ch, 005h, 0CAh, 0A0h, 082h, 0A9h, 000h, 08Dh, 048h, 002h, 08Dh, 0FFh, 0D1h, 068h, 08Dh, 042h ; CA00
DB 000h, 0ADh, 04Ch, 002h, 08Ch, 04Dh, 002h, 0ACh, 04Dh, 002h, 060h, 068h, 0A8h, 068h, 0AAh, 090h ; CA10
DB 0CCh, 080h, 040h, 020h, 010h, 008h, 004h, 002h, 001h, 0AEh, 02Eh, 000h, 0BDh, 04Dh, 003h, 020h ; CA20
DB 0DEh, 0E7h, 0B0h, 020h, 018h, 020h, 09Eh, 0E8h, 0B0h, 01Ah, 0AEh, 02Eh, 000h, 0BDh, 04Ch, 003h ; CA30
DB 020h, 016h, 0E7h, 0B0h, 00Fh, 0AEh, 02Eh, 000h, 09Dh, 040h, 003h, 085h, 020h, 0A9h, 003h, 085h ; CA40
DB 017h, 04Ch, 05Ch, 0E5h, 04Ch, 010h, 0E5h, 000h, 013h, 016h, 0D1h, 0E4h, 0E4h, 0E8h, 029h, 0EBh ; CA50
DB 0EEh, 000h, 000h, 02Dh, 025h, 02Dh, 02Fh, 032h, 039h, 000h, 034h, 025h, 033h, 034h, 000h, 000h ; CA60
DB 000h, 032h, 02Fh, 02Dh, 032h, 021h, 02Dh, 000h, 000h, 02Bh, 025h, 039h, 022h, 02Fh, 021h, 032h ; CA70
DB 024h, 000h, 034h, 025h, 033h, 034h, 000h, 000h, 000h, 0B2h, 091h, 000h, 092h, 000h, 093h, 000h ; CA80
DB 094h, 000h, 0A8h, 000h, 0A1h, 000h, 0A2h, 000h, 000h, 000h, 05Bh, 000h, 011h, 000h, 012h, 000h ; CA90
DB 013h, 000h, 014h, 000h, 015h, 000h, 016h, 000h, 017h, 000h, 018h, 000h, 019h, 000h, 010h, 000h ; CAA0
DB 01Ch, 000h, 01Eh, 000h, 0A2h, 080h, 0B3h, 000h, 000h, 000h, 0FFh, 0FFh, 000h, 031h, 000h, 037h ; CAB0
DB 000h, 025h, 000h, 032h, 000h, 034h, 000h, 039h, 000h, 035h, 000h, 029h, 000h, 02Fh, 000h, 030h ; CAC0
DB 000h, 00Dh, 000h, 01Dh, 000h, 0B2h, 0B4h, 000h, 000h, 000h, 080h, 0DCh, 080h, 000h, 021h, 000h ; CAD0
DB 033h, 000h, 024h, 000h, 026h, 000h, 027h, 000h, 028h, 000h, 02Ah, 000h, 02Bh, 000h, 02Ch, 000h ; CAE0
DB 01Bh, 000h, 00Bh, 000h, 00Ah, 000h, 0A3h, 000h, 000h, 000h, 080h, 0B3h, 0A8h, 080h, 000h, 03Ah ; CAF0
DB 000h, 038h, 000h, 023h, 000h, 036h, 000h, 022h, 000h, 02Eh, 000h, 02Dh, 000h, 00Ch, 000h, 00Eh ; CB00
DB 000h, 00Fh, 000h, 080h, 0B3h, 0A8h, 080h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 080h ; CB10
DB 0B3h, 080h, 0B0h, 080h, 0A1h, 080h, 0A3h, 080h, 0A5h, 080h, 080h, 080h, 0A2h, 080h, 0A1h, 080h ; CB20
DB 0B2h, 080h, 000h, 033h, 000h, 030h, 000h, 021h, 000h, 023h, 000h, 025h, 000h, 000h, 000h, 022h ; CB30
DB 000h, 021h, 000h, 032h, 000h, 000h, 033h, 028h, 000h, 022h, 000h, 033h, 000h, 05Ch, 000h, 036h ; CB40
DB 02Fh, 029h, 023h, 025h, 000h, 003h, 0A0h, 011h, 0A9h, 000h, 018h, 071h, 04Ah, 088h, 010h, 0FBh ; CB50
DB 069h, 000h, 049h, 0FFh, 060h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CB60
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CB70
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CB80
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CB90
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBA0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBB0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBC0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBD0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBE0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; CBF0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 018h, 018h, 018h, 018h, 000h, 018h, 000h ; CC00
DB 000h, 066h, 066h, 066h, 000h, 000h, 000h, 000h, 000h, 066h, 0FFh, 066h, 066h, 0FFh, 066h, 000h ; CC10
DB 018h, 03Eh, 060h, 03Ch, 006h, 07Ch, 018h, 000h, 000h, 066h, 06Ch, 018h, 030h, 066h, 046h, 000h ; CC20
DB 01Ch, 036h, 01Ch, 038h, 06Fh, 066h, 03Bh, 000h, 000h, 018h, 018h, 018h, 000h, 000h, 000h, 000h ; CC30
DB 000h, 00Eh, 01Ch, 018h, 018h, 01Ch, 00Eh, 000h, 000h, 070h, 038h, 018h, 018h, 038h, 070h, 000h ; CC40
DB 000h, 066h, 03Ch, 0FFh, 03Ch, 066h, 000h, 000h, 000h, 018h, 018h, 07Eh, 018h, 018h, 000h, 000h ; CC50
DB 000h, 000h, 000h, 000h, 000h, 018h, 018h, 030h, 000h, 000h, 000h, 07Eh, 000h, 000h, 000h, 000h ; CC60
DB 000h, 000h, 000h, 000h, 000h, 018h, 018h, 000h, 000h, 006h, 00Ch, 018h, 030h, 060h, 040h, 000h ; CC70
DB 000h, 03Ch, 066h, 06Eh, 076h, 066h, 03Ch, 000h, 000h, 018h, 038h, 018h, 018h, 018h, 07Eh, 000h ; CC80
DB 000h, 03Ch, 066h, 00Ch, 018h, 030h, 07Eh, 000h, 000h, 07Eh, 00Ch, 018h, 00Ch, 066h, 03Ch, 000h ; CC90
DB 000h, 00Ch, 01Ch, 03Ch, 06Ch, 07Eh, 00Ch, 000h, 000h, 07Eh, 060h, 07Ch, 006h, 066h, 03Ch, 000h ; CCA0
DB 000h, 03Ch, 060h, 07Ch, 066h, 066h, 03Ch, 000h, 000h, 07Eh, 006h, 00Ch, 018h, 030h, 030h, 000h ; CCB0
DB 000h, 03Ch, 066h, 03Ch, 066h, 066h, 03Ch, 000h, 000h, 03Ch, 066h, 03Eh, 006h, 00Ch, 038h, 000h ; CCC0
DB 000h, 000h, 018h, 018h, 000h, 018h, 018h, 000h, 000h, 000h, 018h, 018h, 000h, 018h, 018h, 030h ; CCD0
DB 006h, 00Ch, 018h, 030h, 018h, 00Ch, 006h, 000h, 000h, 000h, 07Eh, 000h, 000h, 07Eh, 000h, 000h ; CCE0
DB 060h, 030h, 018h, 00Ch, 018h, 030h, 060h, 000h, 000h, 03Ch, 066h, 00Ch, 018h, 000h, 018h, 000h ; CCF0
DB 000h, 03Ch, 066h, 06Eh, 06Eh, 060h, 03Eh, 000h, 000h, 018h, 03Ch, 066h, 066h, 07Eh, 066h, 000h ; CD00
DB 000h, 07Ch, 066h, 07Ch, 066h, 066h, 07Ch, 000h, 000h, 03Ch, 066h, 060h, 060h, 066h, 03Ch, 000h ; CD10
DB 000h, 078h, 06Ch, 066h, 066h, 06Ch, 078h, 000h, 000h, 07Eh, 060h, 07Ch, 060h, 060h, 07Eh, 000h ; CD20
DB 000h, 07Eh, 060h, 07Ch, 060h, 060h, 060h, 000h, 000h, 03Eh, 060h, 060h, 06Eh, 066h, 03Eh, 000h ; CD30
DB 000h, 066h, 066h, 07Eh, 066h, 066h, 066h, 000h, 000h, 07Eh, 018h, 018h, 018h, 018h, 07Eh, 000h ; CD40
DB 000h, 006h, 006h, 006h, 006h, 066h, 03Ch, 000h, 000h, 066h, 06Ch, 078h, 078h, 06Ch, 066h, 000h ; CD50
DB 000h, 060h, 060h, 060h, 060h, 060h, 07Eh, 000h, 000h, 063h, 077h, 07Fh, 06Bh, 063h, 063h, 000h ; CD60
DB 000h, 066h, 076h, 07Eh, 07Eh, 06Eh, 066h, 000h, 000h, 03Ch, 066h, 066h, 066h, 066h, 03Ch, 000h ; CD70
DB 000h, 07Ch, 066h, 066h, 07Ch, 060h, 060h, 000h, 000h, 03Ch, 066h, 066h, 066h, 06Ch, 036h, 000h ; CD80
DB 000h, 07Ch, 066h, 066h, 07Ch, 06Ch, 066h, 000h, 000h, 03Ch, 060h, 03Ch, 006h, 006h, 03Ch, 000h ; CD90
DB 000h, 07Eh, 018h, 018h, 018h, 018h, 018h, 000h, 000h, 066h, 066h, 066h, 066h, 066h, 07Eh, 000h ; CDA0
DB 000h, 066h, 066h, 066h, 066h, 03Ch, 018h, 000h, 000h, 063h, 063h, 06Bh, 07Fh, 077h, 063h, 000h ; CDB0
DB 000h, 066h, 066h, 03Ch, 03Ch, 066h, 066h, 000h, 000h, 066h, 066h, 03Ch, 018h, 018h, 018h, 000h ; CDC0
DB 000h, 07Eh, 00Ch, 018h, 030h, 060h, 07Eh, 000h, 000h, 01Eh, 018h, 018h, 018h, 018h, 01Eh, 000h ; CDD0
DB 000h, 040h, 060h, 030h, 018h, 00Ch, 006h, 000h, 000h, 078h, 018h, 018h, 018h, 018h, 078h, 000h ; CDE0
DB 000h, 008h, 01Ch, 036h, 063h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 0FFh, 000h ; CDF0
DB 00Ch, 018h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h, 030h, 018h, 000h, 066h, 066h, 066h, 03Eh, 000h ; CE00
DB 036h, 06Ch, 000h, 076h, 076h, 07Eh, 06Eh, 000h, 00Ch, 018h, 07Eh, 060h, 07Ch, 060h, 07Eh, 000h ; CE10
DB 000h, 000h, 03Ch, 060h, 060h, 03Ch, 018h, 030h, 03Ch, 066h, 000h, 03Ch, 066h, 066h, 03Ch, 000h ; CE20
DB 030h, 018h, 000h, 03Ch, 066h, 066h, 03Ch, 000h, 030h, 018h, 000h, 038h, 018h, 018h, 03Ch, 000h ; CE30
DB 01Ch, 030h, 030h, 078h, 030h, 030h, 07Eh, 000h, 000h, 066h, 000h, 038h, 018h, 018h, 03Ch, 000h ; CE40
DB 000h, 066h, 000h, 066h, 066h, 066h, 03Eh, 000h, 036h, 000h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h ; CE50
DB 066h, 000h, 03Ch, 066h, 066h, 066h, 03Ch, 000h, 00Ch, 018h, 000h, 066h, 066h, 066h, 03Eh, 000h ; CE60
DB 00Ch, 018h, 000h, 03Ch, 066h, 066h, 03Ch, 000h, 000h, 066h, 000h, 03Ch, 066h, 066h, 03Ch, 000h ; CE70
DB 066h, 000h, 066h, 066h, 066h, 066h, 07Eh, 000h, 03Ch, 066h, 01Ch, 006h, 03Eh, 066h, 03Eh, 000h ; CE80
DB 03Ch, 066h, 000h, 066h, 066h, 066h, 03Eh, 000h, 03Ch, 066h, 000h, 038h, 018h, 018h, 03Ch, 000h ; CE90
DB 00Ch, 018h, 03Ch, 066h, 07Eh, 060h, 03Ch, 000h, 030h, 018h, 03Ch, 066h, 07Eh, 060h, 03Ch, 000h ; CEA0
DB 036h, 06Ch, 000h, 07Ch, 066h, 066h, 066h, 000h, 03Ch, 0C3h, 03Ch, 066h, 07Eh, 060h, 03Ch, 000h ; CEB0
DB 018h, 000h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h, 030h, 018h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h ; CEC0
DB 018h, 000h, 018h, 03Ch, 066h, 07Eh, 066h, 000h, 078h, 060h, 078h, 060h, 07Eh, 018h, 01Eh, 000h ; CED0
DB 000h, 018h, 03Ch, 07Eh, 018h, 018h, 018h, 000h, 000h, 018h, 018h, 018h, 07Eh, 03Ch, 018h, 000h ; CEE0
DB 000h, 018h, 030h, 07Eh, 030h, 018h, 000h, 000h, 000h, 018h, 00Ch, 07Eh, 00Ch, 018h, 000h, 000h ; CEF0
DB 018h, 000h, 018h, 018h, 018h, 018h, 018h, 000h, 000h, 000h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h ; CF00
DB 000h, 060h, 060h, 07Ch, 066h, 066h, 07Ch, 000h, 000h, 000h, 03Ch, 060h, 060h, 060h, 03Ch, 000h ; CF10
DB 000h, 006h, 006h, 03Eh, 066h, 066h, 03Eh, 000h, 000h, 000h, 03Ch, 066h, 07Eh, 060h, 03Ch, 000h ; CF20
DB 000h, 00Eh, 018h, 03Eh, 018h, 018h, 018h, 000h, 000h, 000h, 03Eh, 066h, 066h, 03Eh, 006h, 07Ch ; CF30
DB 000h, 060h, 060h, 07Ch, 066h, 066h, 066h, 000h, 000h, 018h, 000h, 038h, 018h, 018h, 03Ch, 000h ; CF40
DB 000h, 006h, 000h, 006h, 006h, 006h, 006h, 03Ch, 000h, 060h, 060h, 06Ch, 078h, 06Ch, 066h, 000h ; CF50
DB 000h, 038h, 018h, 018h, 018h, 018h, 03Ch, 000h, 000h, 000h, 066h, 07Fh, 07Fh, 06Bh, 063h, 000h ; CF60
DB 000h, 000h, 07Ch, 066h, 066h, 066h, 066h, 000h, 000h, 000h, 03Ch, 066h, 066h, 066h, 03Ch, 000h ; CF70
DB 000h, 000h, 07Ch, 066h, 066h, 07Ch, 060h, 060h, 000h, 000h, 03Eh, 066h, 066h, 03Eh, 006h, 006h ; CF80
DB 000h, 000h, 07Ch, 066h, 060h, 060h, 060h, 000h, 000h, 000h, 03Eh, 060h, 03Ch, 006h, 07Ch, 000h ; CF90
DB 000h, 018h, 07Eh, 018h, 018h, 018h, 00Eh, 000h, 000h, 000h, 066h, 066h, 066h, 066h, 03Eh, 000h ; CFA0
DB 000h, 000h, 066h, 066h, 066h, 03Ch, 018h, 000h, 000h, 000h, 063h, 06Bh, 07Fh, 03Eh, 036h, 000h ; CFB0
DB 000h, 000h, 066h, 03Ch, 018h, 03Ch, 066h, 000h, 000h, 000h, 066h, 066h, 066h, 03Eh, 00Ch, 078h ; CFC0
DB 000h, 000h, 07Eh, 00Ch, 018h, 030h, 07Eh, 000h, 066h, 066h, 018h, 03Ch, 066h, 07Eh, 066h, 000h ; CFD0
DB 018h, 018h, 018h, 018h, 018h, 018h, 018h, 018h, 000h, 07Eh, 078h, 07Ch, 06Eh, 066h, 006h, 000h ; CFE0
DB 008h, 018h, 038h, 078h, 038h, 018h, 008h, 000h, 010h, 018h, 01Ch, 01Eh, 01Ch, 018h, 010h, 000h ; CFF0
rgbXLXE5000 LABEL BYTE
DB 04Ch, 009h, 050h, 020h, 086h, 050h, 04Ch, 091h, 052h, 020h, 086h, 050h, 0A9h, 000h, 085h, 080h ; 5000 Self test ROM $5000-$5FFF
DB 085h, 081h, 085h, 082h, 08Dh, 008h, 0D2h, 0A9h, 003h, 08Dh, 00Fh, 0D2h, 020h, 010h, 055h, 0A9h ; 5010
DB 040h, 08Dh, 00Eh, 0D4h, 0A2h, 000h, 020h, 073h, 057h, 0A2h, 03Ah, 0A0h, 051h, 020h, 09Eh, 050h ; 5020
DB 0A9h, 0D0h, 08Dh, 000h, 002h, 0A9h, 050h, 08Dh, 001h, 002h, 0A2h, 00Ch, 0A9h, 0AAh, 020h, 02Ah ; 5030
DB 057h, 0A2h, 000h, 08Eh, 00Ah, 0D4h, 0E8h, 0D0h, 0FAh, 0ADh, 00Bh, 0D4h, 0C9h, 018h, 0B0h, 0F9h ; 5040
DB 0A9h, 010h, 085h, 087h, 0A9h, 0C0h, 08Dh, 00Eh, 0D4h, 0ADh, 01Fh, 0D0h, 029h, 001h, 0D0h, 0F9h ; 5050
DB 0A9h, 0FFh, 08Dh, 0FCh, 002h, 0A5h, 086h, 029h, 00Fh, 0C9h, 001h, 0F0h, 010h, 0C9h, 002h, 0F0h ; 5060
DB 00Fh, 0C9h, 004h, 0F0h, 00Eh, 0A9h, 088h, 085h, 086h, 0A9h, 0FFh, 085h, 082h, 04Ch, 091h, 052h ; 5070
DB 04Ch, 057h, 055h, 04Ch, 050h, 054h, 0A9h, 011h, 085h, 086h, 0A9h, 021h, 08Dh, 02Fh, 002h, 0A9h ; 5080
DB 0C0h, 08Dh, 00Eh, 0D4h, 0A9h, 041h, 085h, 083h, 0A9h, 0FFh, 08Dh, 0FCh, 002h, 060h, 085h, 08Ah ; 5090
DB 098h, 048h, 08Ah, 048h, 0A9h, 000h, 08Dh, 02Fh, 002h, 08Dh, 0DCh, 002h, 0A9h, 0DAh, 08Dh, 000h ; 50A0
DB 002h, 0A9h, 053h, 08Dh, 001h, 002h, 0A2h, 000h, 08Ah, 020h, 02Ah, 057h, 068h, 0AAh, 068h, 0A8h ; 50B0
DB 08Eh, 030h, 002h, 086h, 084h, 08Ch, 031h, 002h, 084h, 085h, 0A9h, 021h, 08Dh, 02Fh, 002h, 060h ; 50C0
DB 048h, 08Ah, 048h, 0A2h, 07Ah, 0A5h, 087h, 0C9h, 001h, 0F0h, 01Fh, 029h, 001h, 0F0h, 00Ah, 0E6h ; 50D0
DB 0A2h, 0A5h, 0A2h, 029h, 020h, 0F0h, 002h, 0A2h, 02Ch, 08Eh, 00Ah, 0D4h, 08Eh, 016h, 0D0h, 018h ; 50E0
DB 066h, 087h, 0A9h, 000h, 085h, 04Dh, 068h, 0AAh, 068h, 040h, 0A5h, 088h, 0D0h, 016h, 0ADh, 01Fh ; 50F0
DB 0D0h, 029h, 002h, 0D0h, 01Ah, 0A5h, 086h, 02Ah, 026h, 086h, 0A9h, 020h, 085h, 0A2h, 0A9h, 0FFh ; 5100
DB 085h, 088h, 0D0h, 00Bh, 0ADh, 01Fh, 0D0h, 029h, 002h, 0F0h, 004h, 0A9h, 000h, 085h, 088h, 0A5h ; 5110
DB 086h, 029h, 00Fh, 009h, 010h, 085h, 087h, 0E6h, 080h, 0D0h, 002h, 0E6h, 081h, 0A5h, 081h, 0C9h ; 5120
DB 0FAh, 0D0h, 004h, 058h, 04Ch, 075h, 050h, 04Ch, 0D3h, 050h, 070h, 070h, 070h, 070h, 070h, 047h ; 5130
DB 061h, 051h, 070h, 070h, 070h, 04Eh, 000h, 030h, 070h, 0F0h, 0C6h, 071h, 051h, 070h, 086h, 070h ; 5140
DB 086h, 070h, 006h, 070h, 070h, 04Eh, 000h, 030h, 070h, 070h, 070h, 042h, 0B1h, 051h, 041h, 03Ah ; 5150
DB 051h, 000h, 000h, 000h, 000h, 033h, 025h, 02Ch, 026h, 000h, 034h, 025h, 033h, 034h, 000h, 000h ; 5160
DB 000h, 000h, 000h, 02Dh, 025h, 02Dh, 02Fh, 032h, 039h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; 5170
DB 000h, 000h, 000h, 021h, 035h, 024h, 029h, 02Fh, 00Dh, 036h, 029h, 033h, 035h, 021h, 02Ch, 000h ; 5180
DB 000h, 000h, 000h, 02Bh, 025h, 039h, 022h, 02Fh, 021h, 032h, 024h, 000h, 000h, 000h, 000h, 000h ; 5190
DB 000h, 000h, 000h, 021h, 02Ch, 02Ch, 000h, 034h, 025h, 033h, 034h, 033h, 000h, 000h, 000h, 000h ; 51A0
DB 000h, 000h, 000h, 000h, 000h, 042h, 0B3h, 0A5h, 0ACh, 0A5h, 0A3h, 0B4h, 056h, 00Ch, 042h, 0B3h ; 51B0
DB 0B4h, 0A1h, 0B2h, 0B4h, 056h, 02Fh, 032h, 042h, 0B2h, 0A5h, 0B3h, 0A5h, 0B4h, 056h, 000h, 000h ; 51C0
DB 000h, 070h, 070h, 070h, 046h, 000h, 030h, 070h, 070h, 006h, 070h, 008h, 070h, 070h, 006h, 070h ; 51D0
DB 008h, 070h, 008h, 070h, 008h, 070h, 008h, 070h, 070h, 070h, 001h, 0EDh, 051h, 0A0h, 040h, 042h ; 51E0
DB 0F5h, 051h, 001h, 083h, 000h, 000h, 000h, 000h, 000h, 000h, 042h, 0B2h, 0A5h, 0B3h, 0A5h, 0B4h ; 51F0
DB 056h, 02Fh, 032h, 042h, 0A8h, 0A5h, 0ACh, 0B0h, 056h, 034h, 02Fh, 000h, 025h, 038h, 029h, 034h ; 5200
DB 000h, 000h, 000h, 000h, 000h, 070h, 070h, 070h, 070h, 046h, 000h, 030h, 070h, 070h, 070h, 070h ; 5210
DB 002h, 070h, 070h, 002h, 070h, 002h, 070h, 002h, 070h, 002h, 070h, 002h, 070h, 070h, 001h, 0EDh ; 5220
DB 051h, 070h, 070h, 070h, 070h, 046h, 071h, 052h, 070h, 006h, 070h, 070h, 04Bh, 000h, 031h, 00Bh ; 5230
DB 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh ; 5240
DB 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh ; 5250
DB 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 00Bh, 070h, 046h, 000h, 030h, 070h, 001h, 0EDh ; 5260
DB 051h, 000h, 000h, 021h, 035h, 024h, 029h, 02Fh, 00Dh, 036h, 029h, 033h, 035h, 021h, 02Ch, 000h ; 5270
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 034h, 025h, 033h, 034h, 000h, 000h, 000h, 000h, 000h ; 5280
DB 000h, 0A2h, 0D1h, 0A0h, 051h, 0A9h, 000h, 020h, 09Eh, 050h, 0A2h, 001h, 020h, 073h, 057h, 0A2h ; 5290
DB 000h, 020h, 059h, 057h, 0A2h, 001h, 020h, 059h, 057h, 0ADh, 020h, 030h, 0C9h, 0AAh, 0F0h, 017h ; 52A0
DB 0A9h, 055h, 020h, 08Eh, 053h, 020h, 0B1h, 053h, 020h, 073h, 0FFh, 0B0h, 005h, 0A9h, 0FFh, 04Ch ; 52B0
DB 0C4h, 052h, 0A9h, 0AAh, 020h, 08Eh, 053h, 0ADh, 024h, 030h, 0C9h, 0AAh, 0F0h, 017h, 0A9h, 055h ; 52C0
DB 020h, 099h, 053h, 020h, 0B1h, 053h, 020h, 092h, 0FFh, 0B0h, 005h, 0A9h, 0FFh, 04Ch, 0E2h, 052h ; 52D0
DB 0A9h, 0AAh, 020h, 099h, 053h, 0A9h, 0C0h, 085h, 08Dh, 0A9h, 004h, 085h, 0A4h, 0A9h, 000h, 085h ; 52E0
DB 08Eh, 085h, 090h, 085h, 091h, 085h, 08Fh, 0A6h, 08Eh, 0BDh, 038h, 030h, 025h, 08Dh, 0C9h, 080h ; 52F0
DB 0F0h, 05Ch, 0C9h, 008h, 0F0h, 058h, 0A9h, 044h, 020h, 0C3h, 053h, 0A5h, 0A4h, 020h, 0A4h, 053h ; 5300
DB 0A5h, 0A4h, 049h, 00Ch, 085h, 0A4h, 0A2h, 007h, 0BDh, 04Ah, 054h, 0C5h, 091h, 0F0h, 037h, 0CAh ; 5310
DB 010h, 0F6h, 0A9h, 004h, 085h, 092h, 0A2h, 000h, 0A0h, 000h, 08Ah, 091h, 090h, 0E8h, 0C8h, 0D0h ; 5320
DB 0F9h, 086h, 093h, 0A0h, 000h, 0B1h, 090h, 0C5h, 093h, 0D0h, 010h, 0E6h, 093h, 0C8h, 0D0h, 0F5h ; 5330
DB 0E8h, 0D0h, 0E5h, 0E6h, 091h, 0C6h, 092h, 0D0h, 0DDh, 0F0h, 00Eh, 020h, 0B1h, 053h, 0A9h, 088h ; 5340
DB 020h, 0C3h, 053h, 04Ch, 05Eh, 053h, 020h, 0B5h, 053h, 0A9h, 0CCh, 020h, 0C3h, 053h, 0A5h, 08Dh ; 5350
DB 030h, 026h, 0A9h, 0C0h, 085h, 08Dh, 0E6h, 08Eh, 018h, 0A5h, 08Fh, 069h, 004h, 085h, 091h, 085h ; 5360
DB 08Fh, 0CDh, 0E4h, 002h, 0D0h, 081h, 0A5h, 082h, 0D0h, 003h, 04Ch, 0A9h, 052h, 0A9h, 00Ch, 020h ; 5370
DB 0A4h, 053h, 020h, 0B5h, 053h, 04Ch, 057h, 055h, 0A9h, 00Ch, 085h, 08Dh, 0D0h, 0DAh, 0A2h, 004h ; 5380
DB 020h, 02Ah, 057h, 029h, 0FCh, 08Dh, 023h, 030h, 060h, 0A2h, 008h, 020h, 02Ah, 057h, 029h, 0FCh ; 5390
DB 08Dh, 027h, 030h, 060h, 085h, 0A5h, 0ADh, 001h, 0D3h, 029h, 0F3h, 005h, 0A5h, 08Dh, 001h, 0D3h ; 53A0
DB 060h, 0A2h, 03Ch, 0D0h, 002h, 0A2h, 096h, 0A0h, 0FFh, 08Ch, 00Ah, 0D4h, 088h, 0D0h, 0FAh, 0CAh ; 53B0
DB 0D0h, 0F5h, 060h, 048h, 0A6h, 08Eh, 0A5h, 08Dh, 049h, 0FFh, 03Dh, 038h, 030h, 09Dh, 038h, 030h ; 53C0
DB 068h, 025h, 08Dh, 01Dh, 038h, 030h, 09Dh, 038h, 030h, 060h, 048h, 0A9h, 00Ch, 08Dh, 017h, 0D0h ; 53D0
DB 0ADh, 0C8h, 002h, 08Dh, 018h, 0D0h, 0A9h, 000h, 085h, 04Dh, 0ADh, 0DCh, 002h, 0F0h, 00Eh, 0A9h ; 53E0
DB 000h, 08Dh, 0DCh, 002h, 0A9h, 00Ch, 020h, 0A4h, 053h, 058h, 04Ch, 00Ch, 050h, 0A5h, 08Ah, 0F0h ; 53F0
DB 047h, 0ADh, 01Fh, 0D0h, 029h, 001h, 0F0h, 004h, 0A9h, 0B3h, 0D0h, 002h, 0A9h, 033h, 08Dh, 01Ch ; 5400
DB 030h, 0ADh, 01Fh, 0D0h, 029h, 002h, 0F0h, 004h, 0A9h, 0F3h, 0D0h, 002h, 0A9h, 073h, 08Dh, 01Eh ; 5410
DB 030h, 0ADh, 01Fh, 0D0h, 029h, 004h, 0F0h, 004h, 0A9h, 0AFh, 0D0h, 002h, 0A9h, 02Fh, 08Dh, 020h ; 5420
DB 030h, 0ADh, 01Fh, 0D0h, 029h, 007h, 0C9h, 007h, 0F0h, 009h, 0A9h, 064h, 08Dh, 002h, 0D2h, 0A9h ; 5430
DB 0A8h, 0D0h, 002h, 0A9h, 000h, 08Dh, 003h, 0D2h, 068h, 040h, 000h, 050h, 054h, 030h, 030h, 030h ; 5440
DB 0A2h, 000h, 086h, 094h, 0A2h, 003h, 020h, 073h, 057h, 0A2h, 015h, 0A0h, 052h, 0A9h, 0FFh, 020h ; 5450
DB 09Eh, 050h, 0A2h, 002h, 020h, 059h, 057h, 0A2h, 007h, 020h, 059h, 057h, 0A5h, 082h, 0F0h, 013h ; 5460
DB 0A6h, 094h, 0BDh, 045h, 055h, 0E6h, 094h, 0A6h, 094h, 0E0h, 013h, 0D0h, 014h, 020h, 0B5h, 053h ; 5470
DB 04Ch, 091h, 052h, 0ADh, 0FCh, 002h, 0C9h, 0FFh, 0F0h, 0F9h, 0C9h, 0C0h, 0B0h, 0F5h, 0ADh, 0FCh ; 5480
DB 002h, 0A2h, 0FFh, 08Eh, 0FCh, 002h, 048h, 029h, 080h, 0F0h, 005h, 0A2h, 008h, 020h, 059h, 057h ; 5490
DB 068h, 048h, 029h, 040h, 0F0h, 00Ah, 0A2h, 005h, 020h, 059h, 057h, 0A2h, 004h, 020h, 059h, 057h ; 54A0
DB 068h, 029h, 03Fh, 0C9h, 021h, 0F0h, 068h, 0C9h, 02Ch, 0F0h, 074h, 0C9h, 034h, 0F0h, 068h, 0C9h ; 54B0
DB 00Ch, 0F0h, 076h, 0AAh, 0BDh, 09Ch, 057h, 048h, 0A9h, 021h, 085h, 095h, 0A9h, 030h, 085h, 096h ; 54C0
DB 068h, 0A0h, 0FFh, 0C8h, 0D1h, 095h, 0D0h, 0FBh, 0B1h, 095h, 049h, 080h, 091h, 095h, 0A5h, 082h ; 54D0
DB 0F0h, 013h, 020h, 005h, 055h, 0A2h, 014h, 020h, 0B7h, 053h, 020h, 010h, 055h, 0A2h, 00Ah, 020h ; 54E0
DB 0B7h, 053h, 04Ch, 062h, 054h, 020h, 005h, 055h, 0ADh, 00Fh, 0D2h, 029h, 004h, 0F0h, 0F9h, 020h ; 54F0
DB 010h, 055h, 04Ch, 062h, 054h, 0A9h, 064h, 08Dh, 000h, 0D2h, 0A9h, 0A8h, 08Dh, 001h, 0D2h, 060h ; 5500
DB 0A9h, 000h, 08Dh, 001h, 0D2h, 08Dh, 003h, 0D2h, 08Dh, 005h, 0D2h, 08Dh, 007h, 0D2h, 060h, 0A2h ; 5510
DB 003h, 020h, 059h, 057h, 04Ch, 0DEh, 054h, 0A2h, 006h, 020h, 059h, 057h, 04Ch, 0DEh, 054h, 0A9h ; 5520
DB 07Fh, 08Dh, 052h, 030h, 08Dh, 053h, 030h, 0D0h, 0A5h, 0A9h, 032h, 08Dh, 06Dh, 030h, 0A9h, 034h ; 5530
DB 08Dh, 06Eh, 030h, 0D0h, 099h, 052h, 008h, 00Ah, 02Bh, 028h, 00Dh, 03Dh, 039h, 02Dh, 01Fh, 030h ; 5540
DB 035h, 01Ah, 07Fh, 02Dh, 03Fh, 028h, 00Dh, 0A2h, 002h, 020h, 073h, 057h, 0A9h, 000h, 085h, 097h ; 5550
DB 0A9h, 000h, 085h, 098h, 0A2h, 031h, 0A0h, 052h, 0A9h, 000h, 020h, 09Eh, 050h, 0A2h, 009h, 020h ; 5560
DB 059h, 057h, 0A5h, 097h, 04Ah, 018h, 069h, 011h, 08Dh, 00Bh, 030h, 0A2h, 00Fh, 0A9h, 0FFh, 09Dh ; 5570
DB 050h, 031h, 09Dh, 0B0h, 031h, 09Dh, 010h, 032h, 09Dh, 070h, 032h, 09Dh, 0D0h, 032h, 0CAh, 010h ; 5580
DB 0ECh, 0A9h, 000h, 085h, 099h, 0A9h, 00Ch, 085h, 09Ah, 0A6h, 099h, 0BDh, 017h, 057h, 0A8h, 0BDh ; 5590
DB 016h, 057h, 0AAh, 0A5h, 09Ah, 020h, 085h, 056h, 018h, 0A5h, 09Ah, 069h, 006h, 085h, 09Ah, 0E6h ; 55A0
DB 099h, 0E6h, 099h, 0A5h, 099h, 0C9h, 014h, 0D0h, 0E0h, 020h, 0B1h, 053h, 0A2h, 054h, 0A0h, 031h ; 55B0
DB 0A9h, 000h, 020h, 085h, 056h, 0A9h, 051h, 020h, 06Ch, 056h, 0A2h, 086h, 0A0h, 031h, 0A9h, 000h ; 55C0
DB 020h, 085h, 056h, 0A9h, 05Bh, 020h, 06Ch, 056h, 0A2h, 0F8h, 0A0h, 030h, 0A9h, 048h, 020h, 085h ; 55D0
DB 056h, 0A2h, 0C7h, 0A0h, 030h, 0A9h, 054h, 020h, 085h, 056h, 0A2h, 048h, 0A0h, 032h, 0A9h, 04Eh ; 55E0
DB 020h, 085h, 056h, 0A9h, 044h, 020h, 06Ch, 056h, 0A2h, 0CAh, 0A0h, 030h, 0A9h, 048h, 020h, 085h ; 55F0
DB 056h, 0A2h, 01Ah, 0A0h, 032h, 0A9h, 04Eh, 020h, 085h, 056h, 0A2h, 0CAh, 0A0h, 031h, 0A9h, 006h ; 5600
DB 020h, 085h, 056h, 0A9h, 03Ch, 020h, 06Ch, 056h, 0A2h, 03Ch, 0A0h, 030h, 0A9h, 048h, 020h, 085h ; 5610
DB 056h, 0A2h, 08Ch, 0A0h, 031h, 0A9h, 04Eh, 020h, 085h, 056h, 0A2h, 03Ch, 0A0h, 031h, 0A9h, 006h ; 5620
DB 020h, 085h, 056h, 0A9h, 02Dh, 020h, 06Ch, 056h, 0A2h, 09Eh, 0A0h, 030h, 0A9h, 048h, 020h, 085h ; 5630
DB 056h, 0A2h, 0EEh, 0A0h, 031h, 0A9h, 04Eh, 020h, 085h, 056h, 0A9h, 035h, 020h, 06Ch, 056h, 020h ; 5640
DB 0B5h, 053h, 0E6h, 097h, 0E6h, 097h, 0A5h, 097h, 0C9h, 008h, 0D0h, 007h, 0A5h, 082h, 0D0h, 006h ; 5650
DB 04Ch, 05Ch, 055h, 04Ch, 060h, 055h, 020h, 0B5h, 053h, 04Ch, 050h, 054h, 0A4h, 097h, 099h, 000h ; 5660
DB 0D2h, 0A9h, 0A8h, 099h, 001h, 0D2h, 0A6h, 098h, 0BDh, 0B6h, 056h, 0AAh, 020h, 0B7h, 053h, 0E6h ; 5670
DB 098h, 020h, 010h, 055h, 060h, 086h, 09Bh, 084h, 09Ch, 0AAh, 0A0h, 000h, 0A9h, 010h, 085h, 09Dh ; 5680
DB 0A9h, 006h, 085h, 0A3h, 0BDh, 0BCh, 056h, 011h, 09Bh, 091h, 09Bh, 020h, 0AAh, 056h, 0C6h, 09Dh ; 5690
DB 0D0h, 0F2h, 0E6h, 09Dh, 0E8h, 0C6h, 0A3h, 0D0h, 0EBh, 060h, 018h, 0A5h, 09Bh, 069h, 010h, 085h ; 56A0
DB 09Bh, 090h, 002h, 0E6h, 09Ch, 060h, 020h, 020h, 020h, 010h, 010h, 020h, 001h, 01Fh, 03Fh, 07Fh ; 56B0
DB 03Eh, 01Ch, 000h, 041h, 042h, 04Ch, 070h, 040h, 000h, 001h, 002h, 004h, 008h, 010h, 000h, 043h ; 56C0
DB 044h, 048h, 048h, 048h, 000h, 044h, 022h, 010h, 008h, 007h, 000h, 004h, 008h, 005h, 002h, 000h ; 56D0
DB 000h, 030h, 048h, 088h, 084h, 084h, 000h, 088h, 088h, 090h, 0A0h, 0C0h, 000h, 0F0h, 088h, 084h ; 56E0
DB 082h, 082h, 000h, 082h, 082h, 084h, 088h, 0F0h, 000h, 000h, 000h, 000h, 000h, 080h, 080h, 080h ; 56F0
DB 080h, 080h, 080h, 080h, 000h, 01Ch, 03Eh, 07Fh, 07Eh, 07Ch, 040h, 000h, 000h, 000h, 000h, 000h ; 5700
DB 000h, 004h, 004h, 006h, 005h, 006h, 0C1h, 030h, 021h, 031h, 081h, 031h, 0F1h, 031h, 002h, 030h ; 5710
DB 062h, 030h, 022h, 031h, 082h, 031h, 0C2h, 030h, 0C2h, 031h, 048h, 0BDh, 0DCh, 057h, 085h, 09Eh ; 5720
DB 0BDh, 0DDh, 057h, 085h, 09Fh, 0BDh, 0DEh, 057h, 085h, 0A0h, 0BDh, 0DFh, 057h, 085h, 0A1h, 0A0h ; 5730
DB 000h, 068h, 091h, 09Eh, 0E6h, 09Eh, 0D0h, 002h, 0E6h, 09Fh, 048h, 0A5h, 09Eh, 0C5h, 0A0h, 0D0h ; 5740
DB 0F0h, 0A5h, 09Fh, 0C5h, 0A1h, 0D0h, 0EAh, 068h, 060h, 0BDh, 057h, 0CAh, 0A8h, 0BDh, 0ECh, 057h ; 5750
DB 085h, 09Eh, 0BDh, 0F6h, 057h, 0AAh, 0B9h, 061h, 0CAh, 09Dh, 000h, 030h, 0C8h, 0E8h, 0C6h, 09Eh ; 5760
DB 0D0h, 0F4h, 060h, 0BDh, 08Ch, 057h, 08Dh, 0C4h, 002h, 0BDh, 090h, 057h, 08Dh, 0C5h, 002h, 0BDh ; 5770
DB 094h, 057h, 08Dh, 0C6h, 002h, 0BDh, 098h, 057h, 08Dh, 0C8h, 002h, 060h, 02Ch, 00Ch, 02Ah, 018h ; 5780
DB 00Fh, 032h, 00Ch, 00Eh, 0D2h, 0D6h, 000h, 0B4h, 0D2h, 0A0h, 030h, 0B4h, 02Ch, 02Ah, 01Bh, 091h ; 5790
DB 092h, 02Bh, 00Bh, 00Ah, 02Fh, 000h, 030h, 035h, 0B2h, 029h, 00Dh, 01Dh, 036h, 0A8h, 023h, 093h ; 57A0
DB 094h, 022h, 038h, 03Ah, 014h, 000h, 013h, 016h, 05Bh, 015h, 012h, 011h, 00Ch, 000h, 00Eh, 02Eh ; 57B0
DB 000h, 02Dh, 00Fh, 0A1h, 032h, 000h, 025h, 039h, 0FFh, 034h, 037h, 031h, 019h, 000h, 010h, 017h ; 57C0
DB 0A2h, 018h, 01Ch, 01Eh, 026h, 028h, 024h, 000h, 0A3h, 027h, 033h, 021h, 000h, 030h, 0FFh, 03Eh ; 57D0
DB 020h, 030h, 024h, 030h, 024h, 030h, 028h, 030h, 000h, 030h, 020h, 030h, 013h, 003h, 013h, 013h ; 57E0
DB 004h, 004h, 003h, 0A8h, 003h, 007h, 000h, 028h, 000h, 0B7h, 092h, 0ABh, 04Ch, 022h, 072h, 004h ; 57F0
rgbXLXED800 LABEL BYTE
DB 020h, 0A1h, 0DBh, 020h, 0BBh, 0DBh, 0B0h, 039h, 0A2h, 0EDh, 0A0h, 004h, 020h, 048h, 0DAh, 0A2h ; D800 XL/XE FP $D800-$DFFF
DB 0FFh, 086h, 0F1h, 020h, 044h, 0DAh, 0F0h, 004h, 0A9h, 0FFh, 085h, 0F0h, 020h, 094h, 0DBh, 0B0h ; D810
DB 021h, 048h, 0A6h, 0D5h, 0D0h, 011h, 020h, 0EBh, 0DBh, 068h, 005h, 0D9h, 085h, 0D9h, 0A6h, 0F1h ; D820
DB 030h, 0E6h, 0E8h, 086h, 0F1h, 0D0h, 0E1h, 068h, 0A6h, 0F1h, 010h, 002h, 0E6h, 0EDh, 04Ch, 018h ; D830
DB 0D8h, 060h, 0C9h, 02Eh, 0F0h, 014h, 0C9h, 045h, 0F0h, 019h, 0A6h, 0F0h, 0D0h, 068h, 0C9h, 02Bh ; D840
DB 0F0h, 0C6h, 0C9h, 02Dh, 0F0h, 000h, 085h, 0EEh, 0F0h, 0BEh, 0A6h, 0F1h, 010h, 058h, 0E8h, 086h ; D850
DB 0F1h, 0F0h, 0B5h, 0A5h, 0F2h, 085h, 0ECh, 020h, 094h, 0DBh, 0B0h, 037h, 0AAh, 0A5h, 0EDh, 048h ; D860
DB 086h, 0EDh, 020h, 094h, 0DBh, 0B0h, 017h, 048h, 0A5h, 0EDh, 00Ah, 085h, 0EDh, 00Ah, 00Ah, 065h ; D870
DB 0EDh, 085h, 0EDh, 068h, 018h, 065h, 0EDh, 085h, 0EDh, 0A4h, 0F2h, 020h, 09Dh, 0DBh, 0A5h, 0EFh ; D880
DB 0F0h, 009h, 0A5h, 0EDh, 049h, 0FFh, 018h, 069h, 001h, 085h, 0EDh, 068h, 018h, 065h, 0EDh, 085h ; D890
DB 0EDh, 0D0h, 013h, 0C9h, 02Bh, 0F0h, 006h, 0C9h, 02Dh, 0D0h, 007h, 085h, 0EFh, 020h, 094h, 0DBh ; D8A0
DB 090h, 0BAh, 0A5h, 0ECh, 085h, 0F2h, 0C6h, 0F2h, 0A5h, 0EDh, 0A6h, 0F1h, 030h, 005h, 0F0h, 003h ; D8B0
DB 038h, 0E5h, 0F1h, 048h, 02Ah, 068h, 06Ah, 085h, 0EDh, 090h, 003h, 020h, 0EBh, 0DBh, 0A5h, 0EDh ; D8C0
DB 018h, 069h, 044h, 085h, 0D4h, 020h, 000h, 0DCh, 0B0h, 00Bh, 0A6h, 0EEh, 0F0h, 006h, 0A5h, 0D4h ; D8D0
DB 009h, 080h, 085h, 0D4h, 018h, 060h, 020h, 051h, 0DAh, 0A9h, 030h, 08Dh, 07Fh, 005h, 0A5h, 0D4h ; D8E0
DB 0F0h, 028h, 029h, 07Fh, 0C9h, 03Fh, 090h, 028h, 0C9h, 045h, 0B0h, 024h, 038h, 0E9h, 03Fh, 020h ; D8F0
DB 070h, 0DCh, 020h, 0A4h, 0DCh, 009h, 080h, 09Dh, 080h, 005h, 0ADh, 080h, 005h, 0C9h, 02Eh, 0F0h ; D900
DB 003h, 04Ch, 088h, 0D9h, 020h, 0C1h, 0DCh, 04Ch, 09Ch, 0D9h, 0A9h, 0B0h, 08Dh, 080h, 005h, 060h ; D910
DB 0A9h, 001h, 020h, 070h, 0DCh, 020h, 0A4h, 0DCh, 0E8h, 086h, 0F2h, 0A5h, 0D4h, 00Ah, 038h, 0E9h ; D920
DB 080h, 0AEh, 080h, 005h, 0E0h, 030h, 0F0h, 017h, 0AEh, 081h, 005h, 0ACh, 082h, 005h, 08Eh, 082h ; D930
DB 005h, 08Ch, 081h, 005h, 0A6h, 0F2h, 0E0h, 002h, 0D0h, 002h, 0E6h, 0F2h, 018h, 069h, 001h, 085h ; D940
DB 0EDh, 0A9h, 045h, 0A4h, 0F2h, 020h, 09Fh, 0DCh, 084h, 0F2h, 0A5h, 0EDh, 010h, 00Bh, 0A9h, 000h ; D950
DB 038h, 0E5h, 0EDh, 085h, 0EDh, 0A9h, 02Dh, 0D0h, 002h, 0A9h, 02Bh, 020h, 09Fh, 0DCh, 0A2h, 000h ; D960
DB 0A5h, 0EDh, 038h, 0E9h, 00Ah, 090h, 003h, 0E8h, 0D0h, 0F8h, 018h, 069h, 00Ah, 048h, 08Ah, 020h ; D970
DB 09Dh, 0DCh, 068h, 009h, 080h, 020h, 09Dh, 0DCh, 0ADh, 080h, 005h, 0C9h, 030h, 0D0h, 00Dh, 018h ; D980
DB 0A5h, 0F3h, 069h, 001h, 085h, 0F3h, 0A5h, 0F4h, 069h, 000h, 085h, 0F4h, 0A5h, 0D4h, 010h, 009h ; D990
DB 020h, 0C1h, 0DCh, 0A0h, 000h, 0A9h, 02Dh, 091h, 0F3h, 060h, 0A5h, 0D4h, 085h, 0F8h, 0A5h, 0D5h ; D9A0
DB 085h, 0F7h, 020h, 044h, 0DAh, 0F8h, 0A0h, 010h, 006h, 0F8h, 026h, 0F7h, 0A2h, 003h, 0B5h, 0D4h ; D9B0
DB 075h, 0D4h, 095h, 0D4h, 0CAh, 0D0h, 0F7h, 088h, 0D0h, 0EEh, 0D8h, 0A9h, 042h, 085h, 0D4h, 04Ch ; D9C0
DB 000h, 0DCh, 0A9h, 000h, 085h, 0F7h, 085h, 0F8h, 0A5h, 0D4h, 030h, 066h, 0C9h, 043h, 0B0h, 062h ; D9D0
DB 038h, 0E9h, 040h, 090h, 03Fh, 069h, 000h, 00Ah, 085h, 0F5h, 020h, 05Ah, 0DAh, 0B0h, 053h, 0A5h ; D9E0
DB 0F7h, 085h, 0F9h, 0A5h, 0F8h, 085h, 0FAh, 020h, 05Ah, 0DAh, 0B0h, 046h, 020h, 05Ah, 0DAh, 0B0h ; D9F0
DB 041h, 018h, 0A5h, 0F8h, 065h, 0FAh, 085h, 0F8h, 0A5h, 0F7h, 065h, 0F9h, 085h, 0F7h, 0B0h, 032h ; DA00
DB 020h, 0B9h, 0DCh, 018h, 065h, 0F8h, 085h, 0F8h, 0A5h, 0F7h, 069h, 000h, 0B0h, 024h, 085h, 0F7h ; DA10
DB 0C6h, 0F5h, 0D0h, 0C6h, 020h, 0B9h, 0DCh, 0C9h, 005h, 090h, 00Dh, 018h, 0A5h, 0F8h, 069h, 001h ; DA20
DB 085h, 0F8h, 0A5h, 0F7h, 069h, 000h, 085h, 0F7h, 0A5h, 0F8h, 085h, 0D4h, 0A5h, 0F7h, 085h, 0D5h ; DA30
DB 018h, 060h, 038h, 060h, 0A2h, 0D4h, 0A0h, 006h, 0A9h, 000h, 095h, 000h, 0E8h, 088h, 0D0h, 0FAh ; DA40
DB 060h, 0A9h, 005h, 085h, 0F4h, 0A9h, 080h, 085h, 0F3h, 060h, 018h, 026h, 0F8h, 026h, 0F7h, 060h ; DA50
DB 0A5h, 0E0h, 049h, 080h, 085h, 0E0h, 0A5h, 0E0h, 029h, 07Fh, 085h, 0F7h, 0A5h, 0D4h, 029h, 07Fh ; DA60
DB 038h, 0E5h, 0F7h, 010h, 010h, 0A2h, 005h, 0B5h, 0D4h, 0B4h, 0E0h, 095h, 0E0h, 098h, 095h, 0D4h ; DA70
DB 0CAh, 010h, 0F4h, 030h, 0E1h, 0F0h, 007h, 0C9h, 005h, 0B0h, 019h, 020h, 03Eh, 0DCh, 0F8h, 0A5h ; DA80
DB 0D4h, 045h, 0E0h, 030h, 01Eh, 0A2h, 004h, 018h, 0B5h, 0D5h, 075h, 0E1h, 095h, 0D5h, 0CAh, 010h ; DA90
DB 0F7h, 0D8h, 0B0h, 003h, 04Ch, 000h, 0DCh, 0A9h, 001h, 020h, 03Ah, 0DCh, 0A9h, 001h, 085h, 0D5h ; DAA0
DB 04Ch, 000h, 0DCh, 0A2h, 004h, 038h, 0B5h, 0D5h, 0F5h, 0E1h, 095h, 0D5h, 0CAh, 010h, 0F7h, 090h ; DAB0
DB 004h, 0D8h, 04Ch, 000h, 0DCh, 0A5h, 0D4h, 049h, 080h, 085h, 0D4h, 038h, 0A2h, 004h, 0A9h, 000h ; DAC0
DB 0F5h, 0D5h, 095h, 0D5h, 0CAh, 010h, 0F7h, 0D8h, 04Ch, 000h, 0DCh, 0A5h, 0D4h, 0F0h, 045h, 0A5h ; DAD0
DB 0E0h, 0F0h, 03Eh, 020h, 0CFh, 0DCh, 038h, 0E9h, 040h, 038h, 065h, 0E0h, 030h, 038h, 020h, 0E0h ; DAE0
DB 0DCh, 0A5h, 0DFh, 029h, 00Fh, 085h, 0F6h, 0C6h, 0F6h, 030h, 006h, 020h, 001h, 0DDh, 04Ch, 0F7h ; DAF0
DB 0DAh, 0A5h, 0DFh, 04Ah, 04Ah, 04Ah, 04Ah, 085h, 0F6h, 0C6h, 0F6h, 030h, 006h, 020h, 005h, 0DDh ; DB00
DB 04Ch, 009h, 0DBh, 020h, 062h, 0DCh, 0C6h, 0F5h, 0D0h, 0D7h, 0A5h, 0EDh, 085h, 0D4h, 04Ch, 004h ; DB10
DB 0DCh, 020h, 044h, 0DAh, 018h, 060h, 038h, 060h, 0A5h, 0E0h, 0F0h, 0FAh, 0A5h, 0D4h, 0F0h, 0F4h ; DB20
DB 020h, 0CFh, 0DCh, 038h, 0E5h, 0E0h, 018h, 069h, 040h, 030h, 0EBh, 020h, 0E0h, 0DCh, 0E6h, 0F5h ; DB30
DB 04Ch, 04Eh, 0DBh, 0A2h, 000h, 0B5h, 0D5h, 095h, 0D4h, 0E8h, 0E0h, 00Ch, 0D0h, 0F7h, 0A0h, 005h ; DB40
DB 038h, 0F8h, 0B9h, 0DAh, 000h, 0F9h, 0E6h, 000h, 099h, 0DAh, 000h, 088h, 010h, 0F4h, 0D8h, 090h ; DB50
DB 004h, 0E6h, 0D9h, 0D0h, 0E9h, 020h, 00Fh, 0DDh, 006h, 0D9h, 006h, 0D9h, 006h, 0D9h, 006h, 0D9h ; DB60
DB 0A0h, 005h, 038h, 0F8h, 0B9h, 0DAh, 000h, 0F9h, 0E0h, 000h, 099h, 0DAh, 000h, 088h, 010h, 0F4h ; DB70
DB 0D8h, 090h, 004h, 0E6h, 0D9h, 0D0h, 0E9h, 020h, 009h, 0DDh, 0C6h, 0F5h, 0D0h, 0B5h, 020h, 062h ; DB80
DB 0DCh, 04Ch, 01Ah, 0DBh, 020h, 0AFh, 0DBh, 0A4h, 0F2h, 090h, 002h, 0B1h, 0F3h, 0C8h, 084h, 0F2h ; DB90
DB 060h, 0A4h, 0F2h, 0A9h, 020h, 0D1h, 0F3h, 0D0h, 003h, 0C8h, 0D0h, 0F9h, 084h, 0F2h, 060h, 0A4h ; DBA0
DB 0F2h, 0B1h, 0F3h, 038h, 0E9h, 030h, 090h, 018h, 0C9h, 00Ah, 060h, 0A5h, 0F2h, 048h, 020h, 094h ; DBB0
DB 0DBh, 090h, 01Fh, 0C9h, 02Eh, 0F0h, 014h, 0C9h, 02Bh, 0F0h, 007h, 0C9h, 02Dh, 0F0h, 003h, 068h ; DBC0
DB 038h, 060h, 020h, 094h, 0DBh, 090h, 00Bh, 0C9h, 02Eh, 0D0h, 0F4h, 020h, 094h, 0DBh, 090h, 002h ; DBD0
DB 0B0h, 0EDh, 068h, 085h, 0F2h, 018h, 060h, 0A2h, 0E7h, 0D0h, 002h, 0A2h, 0D5h, 0A0h, 004h, 018h ; DBE0
DB 036h, 004h, 036h, 003h, 036h, 002h, 036h, 001h, 036h, 000h, 026h, 0ECh, 088h, 0D0h, 0F0h, 060h ; DBF0
DB 0A2h, 000h, 086h, 0DAh, 0A2h, 004h, 0A5h, 0D4h, 0F0h, 02Eh, 0A5h, 0D5h, 0D0h, 01Ah, 0A0h, 000h ; DC00
DB 0B9h, 0D6h, 000h, 099h, 0D5h, 000h, 0C8h, 0C0h, 005h, 090h, 0F5h, 0C6h, 0D4h, 0CAh, 0D0h, 0EAh ; DC10
DB 0A5h, 0D5h, 0D0h, 004h, 085h, 0D4h, 018h, 060h, 0A5h, 0D4h, 029h, 07Fh, 0C9h, 071h, 090h, 001h ; DC20
DB 060h, 0C9h, 00Fh, 0B0h, 003h, 020h, 044h, 0DAh, 018h, 060h, 0A2h, 0D4h, 0D0h, 002h, 0A2h, 0E0h ; DC30
DB 086h, 0F9h, 085h, 0F7h, 085h, 0F8h, 0A0h, 004h, 0B5h, 004h, 095h, 005h, 0CAh, 088h, 0D0h, 0F8h ; DC40
DB 0A9h, 000h, 095h, 005h, 0A6h, 0F9h, 0C6h, 0F7h, 0D0h, 0ECh, 0B5h, 000h, 018h, 065h, 0F8h, 095h ; DC50
DB 000h, 060h, 0A2h, 00Ah, 0B5h, 0D4h, 095h, 0D5h, 0CAh, 010h, 0F9h, 0A9h, 000h, 085h, 0D4h, 060h ; DC60
DB 085h, 0F7h, 0A2h, 000h, 0A0h, 000h, 020h, 093h, 0DCh, 038h, 0E9h, 001h, 085h, 0F7h, 0B5h, 0D5h ; DC70
DB 04Ah, 04Ah, 04Ah, 04Ah, 020h, 09Dh, 0DCh, 0B5h, 0D5h, 029h, 00Fh, 020h, 09Dh, 0DCh, 0E8h, 0E0h ; DC80
DB 005h, 090h, 0E3h, 0A5h, 0F7h, 0D0h, 005h, 0A9h, 02Eh, 020h, 09Fh, 0DCh, 060h, 009h, 030h, 099h ; DC90
DB 080h, 005h, 0C8h, 060h, 0A2h, 00Ah, 0BDh, 080h, 005h, 0C9h, 02Eh, 0F0h, 007h, 0C9h, 030h, 0D0h ; DCA0
DB 007h, 0CAh, 0D0h, 0F2h, 0CAh, 0BDh, 080h, 005h, 060h, 020h, 0EBh, 0DBh, 0A5h, 0ECh, 029h, 00Fh ; DCB0
DB 060h, 038h, 0A5h, 0F3h, 0E9h, 001h, 085h, 0F3h, 0A5h, 0F4h, 0E9h, 000h, 085h, 0F4h, 060h, 0A5h ; DCC0
DB 0D4h, 045h, 0E0h, 029h, 080h, 085h, 0EEh, 006h, 0E0h, 046h, 0E0h, 0A5h, 0D4h, 029h, 07Fh, 060h ; DCD0
DB 005h, 0EEh, 085h, 0EDh, 0A9h, 000h, 085h, 0D4h, 085h, 0E0h, 020h, 028h, 0DDh, 020h, 0E7h, 0DBh ; DCE0
DB 0A5h, 0ECh, 029h, 00Fh, 085h, 0E6h, 0A9h, 005h, 085h, 0F5h, 020h, 034h, 0DDh, 020h, 044h, 0DAh ; DCF0
DB 060h, 0A2h, 0D9h, 0D0h, 006h, 0A2h, 0D9h, 0D0h, 008h, 0A2h, 0DFh, 0A0h, 0E5h, 0D0h, 004h, 0A2h ; DD00
DB 0DFh, 0A0h, 0EBh, 0A9h, 005h, 085h, 0F7h, 018h, 0F8h, 0B5h, 000h, 079h, 000h, 000h, 095h, 000h ; DD10
DB 0CAh, 088h, 0C6h, 0F7h, 010h, 0F3h, 0D8h, 060h, 0A0h, 005h, 0B9h, 0E0h, 000h, 099h, 0E6h, 000h ; DD20
DB 088h, 010h, 0F7h, 060h, 0A0h, 005h, 0B9h, 0D4h, 000h, 099h, 0DAh, 000h, 088h, 010h, 0F7h, 060h ; DD30
DB 086h, 0FEh, 084h, 0FFh, 085h, 0EFh, 0A2h, 0E0h, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h, 0B6h, 0DDh ; DD40
DB 0A6h, 0FEh, 0A4h, 0FFh, 020h, 089h, 0DDh, 0C6h, 0EFh, 0F0h, 02Dh, 020h, 0DBh, 0DAh, 0B0h, 028h ; DD50
DB 018h, 0A5h, 0FEh, 069h, 006h, 085h, 0FEh, 090h, 006h, 0A5h, 0FFh, 069h, 000h, 085h, 0FFh, 0A6h ; DD60
DB 0FEh, 0A4h, 0FFh, 020h, 098h, 0DDh, 020h, 066h, 0DAh, 0B0h, 00Dh, 0C6h, 0EFh, 0F0h, 009h, 0A2h ; DD70
DB 0E0h, 0A0h, 005h, 020h, 098h, 0DDh, 030h, 0D3h, 060h, 086h, 0FCh, 084h, 0FDh, 0A0h, 005h, 0B1h ; DD80
DB 0FCh, 099h, 0D4h, 000h, 088h, 010h, 0F8h, 060h, 086h, 0FCh, 084h, 0FDh, 0A0h, 005h, 0B1h, 0FCh ; DD90
DB 099h, 0E0h, 000h, 088h, 010h, 0F8h, 060h, 086h, 0FCh, 084h, 0FDh, 0A0h, 005h, 0B9h, 0D4h, 000h ; DDA0
DB 091h, 0FCh, 088h, 010h, 0F8h, 060h, 0A2h, 005h, 0B5h, 0D4h, 095h, 0E0h, 0CAh, 010h, 0F9h, 060h ; DDB0
DB 0A2h, 089h, 0A0h, 0DEh, 020h, 098h, 0DDh, 020h, 0DBh, 0DAh, 0B0h, 07Fh, 0A9h, 000h, 085h, 0F1h ; DDC0
DB 0A5h, 0D4h, 085h, 0F0h, 029h, 07Fh, 085h, 0D4h, 038h, 0E9h, 040h, 030h, 026h, 0C9h, 004h, 010h ; DDD0
DB 06Ah, 0A2h, 0E6h, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h, 0D2h, 0D9h, 0A5h, 0D4h, 085h, 0F1h, 0A5h ; DDE0
DB 0D5h, 0D0h, 058h, 020h, 0AAh, 0D9h, 020h, 0B6h, 0DDh, 0A2h, 0E6h, 0A0h, 005h, 020h, 089h, 0DDh ; DDF0
DB 020h, 060h, 0DAh, 0A9h, 00Ah, 0A2h, 04Dh, 0A0h, 0DEh, 020h, 040h, 0DDh, 020h, 0B6h, 0DDh, 020h ; DE00
DB 0DBh, 0DAh, 0A5h, 0F1h, 0F0h, 023h, 018h, 06Ah, 085h, 0E0h, 0A9h, 001h, 090h, 002h, 0A9h, 010h ; DE10
DB 085h, 0E1h, 0A2h, 004h, 0A9h, 000h, 095h, 0E2h, 0CAh, 010h, 0FBh, 0A5h, 0E0h, 018h, 069h, 040h ; DE20
DB 0B0h, 019h, 030h, 017h, 085h, 0E0h, 020h, 0DBh, 0DAh, 0A5h, 0F0h, 010h, 00Dh, 020h, 0B6h, 0DDh ; DE30
DB 0A2h, 08Fh, 0A0h, 0DEh, 020h, 089h, 0DDh, 020h, 028h, 0DBh, 060h, 038h, 060h, 03Dh, 017h, 094h ; DE40
DB 019h, 000h, 000h, 03Dh, 057h, 033h, 005h, 000h, 000h, 03Eh, 005h, 054h, 076h, 062h, 000h, 03Eh ; DE50
DB 032h, 019h, 062h, 027h, 000h, 03Fh, 001h, 068h, 060h, 030h, 036h, 03Fh, 007h, 032h, 003h, 027h ; DE60
DB 041h, 03Fh, 025h, 043h, 034h, 056h, 075h, 03Fh, 066h, 027h, 037h, 030h, 050h, 040h, 001h, 015h ; DE70
DB 012h, 092h, 055h, 03Fh, 099h, 099h, 099h, 099h, 099h, 03Fh, 043h, 042h, 094h, 048h, 019h, 040h ; DE80
DB 001h, 000h, 000h, 000h, 000h, 086h, 0FEh, 084h, 0FFh, 0A2h, 0E0h, 0A0h, 005h, 020h, 0A7h, 0DDh ; DE90
DB 0A6h, 0FEh, 0A4h, 0FFh, 020h, 098h, 0DDh, 020h, 066h, 0DAh, 0A2h, 0E6h, 0A0h, 005h, 020h, 0A7h ; DEA0
DB 0DDh, 0A2h, 0E0h, 0A0h, 005h, 020h, 089h, 0DDh, 0A6h, 0FEh, 0A4h, 0FFh, 020h, 098h, 0DDh, 020h ; DEB0
DB 060h, 0DAh, 0A2h, 0E6h, 0A0h, 005h, 020h, 098h, 0DDh, 020h, 028h, 0DBh, 060h, 0A9h, 001h, 0D0h ; DEC0
DB 002h, 0A9h, 000h, 085h, 0F0h, 0A5h, 0D4h, 0F0h, 005h, 030h, 003h, 04Ch, 0F6h, 0DFh, 038h, 060h ; DED0
DB 0E9h, 040h, 00Ah, 085h, 0F1h, 0A5h, 0D5h, 029h, 0F0h, 0D0h, 004h, 0A9h, 001h, 0D0h, 004h, 0E6h ; DEE0
DB 0F1h, 0A9h, 010h, 085h, 0E1h, 0A2h, 004h, 0A9h, 000h, 095h, 0E2h, 0CAh, 010h, 0FBh, 020h, 028h ; DEF0
DB 0DBh, 0A2h, 066h, 0A0h, 0DFh, 020h, 095h, 0DEh, 0A2h, 0E6h, 0A0h, 005h, 020h, 0A7h, 0DDh, 020h ; DF00
DB 0B6h, 0DDh, 020h, 0DBh, 0DAh, 0A9h, 00Ah, 0A2h, 072h, 0A0h, 0DFh, 020h, 040h, 0DDh, 0A2h, 0E6h ; DF10
DB 0A0h, 005h, 020h, 098h, 0DDh, 020h, 0DBh, 0DAh, 0A2h, 06Ch, 0A0h, 0DFh, 020h, 098h, 0DDh, 020h ; DF20
DB 066h, 0DAh, 020h, 0B6h, 0DDh, 0A9h, 000h, 085h, 0D5h, 0A5h, 0F1h, 085h, 0D4h, 010h, 007h, 049h ; DF30
DB 0FFh, 018h, 069h, 001h, 085h, 0D4h, 020h, 0AAh, 0D9h, 024h, 0F1h, 010h, 006h, 0A9h, 080h, 005h ; DF40
DB 0D4h, 085h, 0D4h, 020h, 066h, 0DAh, 0A5h, 0F0h, 0F0h, 00Ah, 0A2h, 089h, 0A0h, 0DEh, 020h, 098h ; DF50
DB 0DDh, 020h, 028h, 0DBh, 018h, 060h, 040h, 003h, 016h, 022h, 077h, 066h, 03Fh, 050h, 000h, 000h ; DF60
DB 000h, 000h, 03Fh, 049h, 015h, 057h, 011h, 008h, 0BFh, 051h, 070h, 049h, 047h, 008h, 03Fh, 039h ; DF70
DB 020h, 057h, 061h, 095h, 0BFh, 004h, 039h, 063h, 003h, 055h, 03Fh, 010h, 009h, 030h, 012h, 064h ; DF80
DB 03Fh, 009h, 039h, 008h, 004h, 060h, 03Fh, 012h, 042h, 058h, 047h, 042h, 03Fh, 017h, 037h, 012h ; DF90
DB 006h, 008h, 03Fh, 028h, 095h, 029h, 071h, 017h, 03Fh, 086h, 085h, 088h, 096h, 044h, 03Eh, 016h ; DFA0
DB 005h, 044h, 049h, 000h, 0BEh, 095h, 068h, 038h, 045h, 000h, 03Fh, 002h, 068h, 079h, 094h, 016h ; DFB0
DB 0BFh, 004h, 092h, 078h, 090h, 080h, 03Fh, 007h, 003h, 015h, 020h, 000h, 0BFh, 008h, 092h, 029h ; DFC0
DB 012h, 044h, 03Fh, 011h, 008h, 040h, 009h, 011h, 0BFh, 014h, 028h, 031h, 056h, 004h, 03Fh, 019h ; DFD0
DB 099h, 098h, 077h, 044h, 0BFh, 033h, 033h, 033h, 031h, 013h, 03Fh, 099h, 099h, 099h, 099h, 099h ; DFE0
DB 03Fh, 078h, 053h, 098h, 016h, 034h, 0A5h, 0D4h, 085h, 0E0h, 038h, 04Ch, 0E0h, 0DEh, 000h, 000h ; DFF0
;rgbXLXEE000 LABEL BYTE
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 018h, 018h, 018h, 018h, 000h, 018h, 000h ; E000 XL/XE OS $E000-$FFFF
DB 000h, 066h, 066h, 066h, 000h, 000h, 000h, 000h, 000h, 066h, 0FFh, 066h, 066h, 0FFh, 066h, 000h ; E010
DB 018h, 03Eh, 060h, 03Ch, 006h, 07Ch, 018h, 000h, 000h, 066h, 06Ch, 018h, 030h, 066h, 046h, 000h ; E020
DB 01Ch, 036h, 01Ch, 038h, 06Fh, 066h, 03Bh, 000h, 000h, 018h, 018h, 018h, 000h, 000h, 000h, 000h ; E030
DB 000h, 00Eh, 01Ch, 018h, 018h, 01Ch, 00Eh, 000h, 000h, 070h, 038h, 018h, 018h, 038h, 070h, 000h ; E040
DB 000h, 066h, 03Ch, 0FFh, 03Ch, 066h, 000h, 000h, 000h, 018h, 018h, 07Eh, 018h, 018h, 000h, 000h ; E050
DB 000h, 000h, 000h, 000h, 000h, 018h, 018h, 030h, 000h, 000h, 000h, 07Eh, 000h, 000h, 000h, 000h ; E060
DB 000h, 000h, 000h, 000h, 000h, 018h, 018h, 000h, 000h, 006h, 00Ch, 018h, 030h, 060h, 040h, 000h ; E070
DB 000h, 03Ch, 066h, 06Eh, 076h, 066h, 03Ch, 000h, 000h, 018h, 038h, 018h, 018h, 018h, 07Eh, 000h ; E080
DB 000h, 03Ch, 066h, 00Ch, 018h, 030h, 07Eh, 000h, 000h, 07Eh, 00Ch, 018h, 00Ch, 066h, 03Ch, 000h ; E090
DB 000h, 00Ch, 01Ch, 03Ch, 06Ch, 07Eh, 00Ch, 000h, 000h, 07Eh, 060h, 07Ch, 006h, 066h, 03Ch, 000h ; E0A0
DB 000h, 03Ch, 060h, 07Ch, 066h, 066h, 03Ch, 000h, 000h, 07Eh, 006h, 00Ch, 018h, 030h, 030h, 000h ; E0B0
DB 000h, 03Ch, 066h, 03Ch, 066h, 066h, 03Ch, 000h, 000h, 03Ch, 066h, 03Eh, 006h, 00Ch, 038h, 000h ; E0C0
DB 000h, 000h, 018h, 018h, 000h, 018h, 018h, 000h, 000h, 000h, 018h, 018h, 000h, 018h, 018h, 030h ; E0D0
DB 006h, 00Ch, 018h, 030h, 018h, 00Ch, 006h, 000h, 000h, 000h, 07Eh, 000h, 000h, 07Eh, 000h, 000h ; E0E0
DB 060h, 030h, 018h, 00Ch, 018h, 030h, 060h, 000h, 000h, 03Ch, 066h, 00Ch, 018h, 000h, 018h, 000h ; E0F0
DB 000h, 03Ch, 066h, 06Eh, 06Eh, 060h, 03Eh, 000h, 000h, 018h, 03Ch, 066h, 066h, 07Eh, 066h, 000h ; E100
DB 000h, 07Ch, 066h, 07Ch, 066h, 066h, 07Ch, 000h, 000h, 03Ch, 066h, 060h, 060h, 066h, 03Ch, 000h ; E110
DB 000h, 078h, 06Ch, 066h, 066h, 06Ch, 078h, 000h, 000h, 07Eh, 060h, 07Ch, 060h, 060h, 07Eh, 000h ; E120
DB 000h, 07Eh, 060h, 07Ch, 060h, 060h, 060h, 000h, 000h, 03Eh, 060h, 060h, 06Eh, 066h, 03Eh, 000h ; E130
DB 000h, 066h, 066h, 07Eh, 066h, 066h, 066h, 000h, 000h, 07Eh, 018h, 018h, 018h, 018h, 07Eh, 000h ; E140
DB 000h, 006h, 006h, 006h, 006h, 066h, 03Ch, 000h, 000h, 066h, 06Ch, 078h, 078h, 06Ch, 066h, 000h ; E150
DB 000h, 060h, 060h, 060h, 060h, 060h, 07Eh, 000h, 000h, 063h, 077h, 07Fh, 06Bh, 063h, 063h, 000h ; E160
DB 000h, 066h, 076h, 07Eh, 07Eh, 06Eh, 066h, 000h, 000h, 03Ch, 066h, 066h, 066h, 066h, 03Ch, 000h ; E170
DB 000h, 07Ch, 066h, 066h, 07Ch, 060h, 060h, 000h, 000h, 03Ch, 066h, 066h, 066h, 06Ch, 036h, 000h ; E180
DB 000h, 07Ch, 066h, 066h, 07Ch, 06Ch, 066h, 000h, 000h, 03Ch, 060h, 03Ch, 006h, 006h, 03Ch, 000h ; E190
DB 000h, 07Eh, 018h, 018h, 018h, 018h, 018h, 000h, 000h, 066h, 066h, 066h, 066h, 066h, 07Eh, 000h ; E1A0
DB 000h, 066h, 066h, 066h, 066h, 03Ch, 018h, 000h, 000h, 063h, 063h, 06Bh, 07Fh, 077h, 063h, 000h ; E1B0
DB 000h, 066h, 066h, 03Ch, 03Ch, 066h, 066h, 000h, 000h, 066h, 066h, 03Ch, 018h, 018h, 018h, 000h ; E1C0
DB 000h, 07Eh, 00Ch, 018h, 030h, 060h, 07Eh, 000h, 000h, 01Eh, 018h, 018h, 018h, 018h, 01Eh, 000h ; E1D0
DB 000h, 040h, 060h, 030h, 018h, 00Ch, 006h, 000h, 000h, 078h, 018h, 018h, 018h, 018h, 078h, 000h ; E1E0
DB 000h, 008h, 01Ch, 036h, 063h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 0FFh, 000h ; E1F0
DB 000h, 036h, 07Fh, 07Fh, 03Eh, 01Ch, 008h, 000h, 018h, 018h, 018h, 01Fh, 01Fh, 018h, 018h, 018h ; E200
DB 003h, 003h, 003h, 003h, 003h, 003h, 003h, 003h, 018h, 018h, 018h, 0F8h, 0F8h, 000h, 000h, 000h ; E210
DB 018h, 018h, 018h, 0F8h, 0F8h, 018h, 018h, 018h, 000h, 000h, 000h, 0F8h, 0F8h, 018h, 018h, 018h ; E220
DB 003h, 007h, 00Eh, 01Ch, 038h, 070h, 0E0h, 0C0h, 0C0h, 0E0h, 070h, 038h, 01Ch, 00Eh, 007h, 003h ; E230
DB 001h, 003h, 007h, 00Fh, 01Fh, 03Fh, 07Fh, 0FFh, 000h, 000h, 000h, 000h, 00Fh, 00Fh, 00Fh, 00Fh ; E240
DB 080h, 0C0h, 0E0h, 0F0h, 0F8h, 0FCh, 0FEh, 0FFh, 00Fh, 00Fh, 00Fh, 00Fh, 000h, 000h, 000h, 000h ; E250
DB 0F0h, 0F0h, 0F0h, 0F0h, 000h, 000h, 000h, 000h, 0FFh, 0FFh, 000h, 000h, 000h, 000h, 000h, 000h ; E260
DB 000h, 000h, 000h, 000h, 000h, 000h, 0FFh, 0FFh, 000h, 000h, 000h, 000h, 0F0h, 0F0h, 0F0h, 0F0h ; E270
DB 000h, 01Ch, 01Ch, 077h, 077h, 008h, 01Ch, 000h, 000h, 000h, 000h, 01Fh, 01Fh, 018h, 018h, 018h ; E280
DB 000h, 000h, 000h, 0FFh, 0FFh, 000h, 000h, 000h, 018h, 018h, 018h, 0FFh, 0FFh, 018h, 018h, 018h ; E290
DB 000h, 000h, 03Ch, 07Eh, 07Eh, 07Eh, 03Ch, 000h, 000h, 000h, 000h, 000h, 0FFh, 0FFh, 0FFh, 0FFh ; E2A0
DB 0C0h, 0C0h, 0C0h, 0C0h, 0C0h, 0C0h, 0C0h, 0C0h, 000h, 000h, 000h, 0FFh, 0FFh, 018h, 018h, 018h ; E2B0
DB 018h, 018h, 018h, 0FFh, 0FFh, 000h, 000h, 000h, 0F0h, 0F0h, 0F0h, 0F0h, 0F0h, 0F0h, 0F0h, 0F0h ; E2C0
DB 018h, 018h, 018h, 01Fh, 01Fh, 000h, 000h, 000h, 078h, 060h, 078h, 060h, 07Eh, 018h, 01Eh, 000h ; E2D0
DB 000h, 018h, 03Ch, 07Eh, 018h, 018h, 018h, 000h, 000h, 018h, 018h, 018h, 07Eh, 03Ch, 018h, 000h ; E2E0
DB 000h, 018h, 030h, 07Eh, 030h, 018h, 000h, 000h, 000h, 018h, 00Ch, 07Eh, 00Ch, 018h, 000h, 000h ; E2F0
DB 000h, 018h, 03Ch, 07Eh, 07Eh, 03Ch, 018h, 000h, 000h, 000h, 03Ch, 006h, 03Eh, 066h, 03Eh, 000h ; E300
DB 000h, 060h, 060h, 07Ch, 066h, 066h, 07Ch, 000h, 000h, 000h, 03Ch, 060h, 060h, 060h, 03Ch, 000h ; E310
DB 000h, 006h, 006h, 03Eh, 066h, 066h, 03Eh, 000h, 000h, 000h, 03Ch, 066h, 07Eh, 060h, 03Ch, 000h ; E320
DB 000h, 00Eh, 018h, 03Eh, 018h, 018h, 018h, 000h, 000h, 000h, 03Eh, 066h, 066h, 03Eh, 006h, 07Ch ; E330
DB 000h, 060h, 060h, 07Ch, 066h, 066h, 066h, 000h, 000h, 018h, 000h, 038h, 018h, 018h, 03Ch, 000h ; E340
DB 000h, 006h, 000h, 006h, 006h, 006h, 006h, 03Ch, 000h, 060h, 060h, 06Ch, 078h, 06Ch, 066h, 000h ; E350
DB 000h, 038h, 018h, 018h, 018h, 018h, 03Ch, 000h, 000h, 000h, 066h, 07Fh, 07Fh, 06Bh, 063h, 000h ; E360
DB 000h, 000h, 07Ch, 066h, 066h, 066h, 066h, 000h, 000h, 000h, 03Ch, 066h, 066h, 066h, 03Ch, 000h ; E370
DB 000h, 000h, 07Ch, 066h, 066h, 07Ch, 060h, 060h, 000h, 000h, 03Eh, 066h, 066h, 03Eh, 006h, 006h ; E380
DB 000h, 000h, 07Ch, 066h, 060h, 060h, 060h, 000h, 000h, 000h, 03Eh, 060h, 03Ch, 006h, 07Ch, 000h ; E390
DB 000h, 018h, 07Eh, 018h, 018h, 018h, 00Eh, 000h, 000h, 000h, 066h, 066h, 066h, 066h, 03Eh, 000h ; E3A0
DB 000h, 000h, 066h, 066h, 066h, 03Ch, 018h, 000h, 000h, 000h, 063h, 06Bh, 07Fh, 03Eh, 036h, 000h ; E3B0
DB 000h, 000h, 066h, 03Ch, 018h, 03Ch, 066h, 000h, 000h, 000h, 066h, 066h, 066h, 03Eh, 00Ch, 078h ; E3C0
DB 000h, 000h, 07Eh, 00Ch, 018h, 030h, 07Eh, 000h, 000h, 018h, 03Ch, 07Eh, 07Eh, 018h, 03Ch, 000h ; E3D0
DB 018h, 018h, 018h, 018h, 018h, 018h, 018h, 018h, 000h, 07Eh, 078h, 07Ch, 06Eh, 066h, 006h, 000h ; E3E0
DB 008h, 018h, 038h, 078h, 038h, 018h, 008h, 000h, 010h, 018h, 01Ch, 01Eh, 01Ch, 018h, 010h, 000h ; E3F0
DB 093h, 0EFh, 02Dh, 0F2h, 049h, 0F2h, 0AFh, 0F2h, 01Dh, 0F2h, 02Ch, 0F2h, 04Ch, 06Eh, 0EFh, 000h ; E400
DB 08Dh, 0EFh, 02Dh, 0F2h, 07Fh, 0F1h, 0A3h, 0F1h, 01Dh, 0F2h, 0AEh, 0F9h, 04Ch, 06Eh, 0EFh, 000h ; E410
DB 01Dh, 0F2h, 01Dh, 0F2h, 0FCh, 0F2h, 02Ch, 0F2h, 01Dh, 0F2h, 02Ch, 0F2h, 04Ch, 06Eh, 0EFh, 000h ; E420
DB 0C1h, 0FEh, 006h, 0FFh, 0C0h, 0FEh, 0CAh, 0FEh, 0A2h, 0FEh, 0C0h, 0FEh, 04Ch, 099h, 0FEh, 000h ; E430
DB 0E5h, 0FCh, 0CEh, 0FDh, 079h, 0FDh, 0B3h, 0FDh, 0CBh, 0FDh, 0E4h, 0FCh, 04Ch, 0DBh, 0FCh, 000h ; E440
DB 04Ch, 0A3h, 0C6h, 04Ch, 0B3h, 0C6h, 04Ch, 0DFh, 0E4h, 04Ch, 033h, 0C9h, 04Ch, 072h, 0C2h, 04Ch ; E450
DB 0E2h, 0C0h, 04Ch, 08Ah, 0C2h, 04Ch, 05Ch, 0E9h, 04Ch, 017h, 0ECh, 04Ch, 00Ch, 0C0h, 04Ch, 0C1h ; E460
DB 0E4h, 04Ch, 023h, 0F2h, 04Ch, 090h, 0C2h, 04Ch, 0C8h, 0C2h, 04Ch, 08Dh, 0FDh, 04Ch, 0F7h, 0FCh ; E470
DB 04Ch, 023h, 0F2h, 04Ch, 000h, 050h, 04Ch, 0BCh, 0EEh, 04Ch, 015h, 0E9h, 04Ch, 098h, 0E8h, 090h ; E480
DB 0C9h, 095h, 0C9h, 09Ah, 0C9h, 09Fh, 0C9h, 0A4h, 0C9h, 0A9h, 0C9h, 04Ch, 00Ch, 0C9h, 000h, 000h ; E490
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; E4A0
DB 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h, 000h ; E4B0
DB 060h, 0A2h, 000h, 0A9h, 0FFh, 09Dh, 040h, 003h, 0A9h, 0DBh, 09Dh, 046h, 003h, 0A9h, 0E4h, 09Dh ; E4C0
DB 047h, 003h, 08Ah, 018h, 069h, 010h, 0AAh, 0C9h, 080h, 090h, 0E8h, 060h, 0A0h, 085h, 060h, 085h ; E4D0
DB 02Fh, 086h, 02Eh, 08Ah, 029h, 00Fh, 0D0h, 004h, 0E0h, 080h, 090h, 005h, 0A0h, 086h, 04Ch, 070h ; E4E0
DB 0E6h, 0A0h, 000h, 0BDh, 040h, 003h, 099h, 020h, 000h, 0E8h, 0C8h, 0C0h, 00Ch, 090h, 0F4h, 0A5h ; E4F0
DB 020h, 0C9h, 07Fh, 0D0h, 015h, 0A5h, 022h, 0C9h, 00Ch, 0F0h, 071h, 0ADh, 0E9h, 002h, 0D0h, 005h ; E500
DB 0A0h, 082h, 04Ch, 070h, 0E6h, 020h, 029h, 0CAh, 030h, 0F8h, 0A0h, 084h, 0A5h, 022h, 0C9h, 003h ; E510
DB 090h, 025h, 0A8h, 0C0h, 00Eh, 090h, 002h, 0A0h, 00Eh, 084h, 017h, 0B9h, 02Ah, 0E7h, 0F0h, 00Fh ; E520
DB 0C9h, 002h, 0F0h, 048h, 0C9h, 008h, 0B0h, 05Fh, 0C9h, 004h, 0F0h, 076h, 04Ch, 01Eh, 0E6h, 0A5h ; E530
DB 020h, 0C9h, 0FFh, 0F0h, 005h, 0A0h, 081h, 04Ch, 070h, 0E6h, 0ADh, 0E9h, 002h, 0D0h, 027h, 020h ; E540
DB 0FFh, 0E6h, 0B0h, 022h, 0A9h, 000h, 08Dh, 0EAh, 002h, 08Dh, 0EBh, 002h, 020h, 095h, 0E6h, 0B0h ; E550
DB 0E6h, 020h, 0EAh, 0E6h, 0A9h, 00Bh, 085h, 017h, 020h, 095h, 0E6h, 0A5h, 02Ch, 085h, 026h, 0A5h ; E560
DB 02Dh, 085h, 027h, 04Ch, 072h, 0E6h, 020h, 0F9h, 0EEh, 04Ch, 070h, 0E6h, 0A0h, 001h, 084h, 023h ; E570
DB 020h, 095h, 0E6h, 0B0h, 003h, 020h, 0EAh, 0E6h, 0A9h, 0FFh, 085h, 020h, 0A9h, 0E4h, 085h, 027h ; E580
DB 0A9h, 0DBh, 085h, 026h, 04Ch, 072h, 0E6h, 0A5h, 020h, 0C9h, 0FFh, 0D0h, 005h, 020h, 0FFh, 0E6h ; E590
DB 0B0h, 0A5h, 020h, 095h, 0E6h, 020h, 0EAh, 0E6h, 0A6h, 02Eh, 0BDh, 040h, 003h, 085h, 020h, 04Ch ; E5A0
DB 072h, 0E6h, 0A5h, 022h, 025h, 02Ah, 0D0h, 005h, 0A0h, 083h, 04Ch, 070h, 0E6h, 020h, 095h, 0E6h ; E5B0
DB 0B0h, 0F8h, 0A5h, 028h, 005h, 029h, 0D0h, 008h, 020h, 0EAh, 0E6h, 085h, 02Fh, 04Ch, 072h, 0E6h ; E5C0
DB 020h, 0EAh, 0E6h, 085h, 02Fh, 030h, 041h, 0A0h, 000h, 091h, 024h, 020h, 0D1h, 0E6h, 0A5h, 022h ; E5D0
DB 029h, 002h, 0D0h, 00Ch, 0A5h, 02Fh, 0C9h, 09Bh, 0D0h, 006h, 020h, 0BBh, 0E6h, 04Ch, 018h, 0E6h ; E5E0
DB 020h, 0BBh, 0E6h, 0D0h, 0DBh, 0A5h, 022h, 029h, 002h, 0D0h, 01Dh, 020h, 0EAh, 0E6h, 085h, 02Fh ; E5F0
DB 030h, 00Ah, 0A5h, 02Fh, 0C9h, 09Bh, 0D0h, 0F3h, 0A9h, 089h, 085h, 023h, 020h, 0C8h, 0E6h, 0A0h ; E600
DB 000h, 0A9h, 09Bh, 091h, 024h, 020h, 0D1h, 0E6h, 020h, 0D8h, 0E6h, 04Ch, 072h, 0E6h, 0A5h, 022h ; E610
DB 025h, 02Ah, 0D0h, 005h, 0A0h, 087h, 04Ch, 070h, 0E6h, 020h, 095h, 0E6h, 0B0h, 0F8h, 0A5h, 028h ; E620
DB 005h, 029h, 0D0h, 006h, 0A5h, 02Fh, 0E6h, 028h, 0D0h, 006h, 0A0h, 000h, 0B1h, 024h, 085h, 02Fh ; E630
DB 020h, 0EAh, 0E6h, 008h, 020h, 0D1h, 0E6h, 020h, 0BBh, 0E6h, 028h, 030h, 01Dh, 0A5h, 022h, 029h ; E640
DB 002h, 0D0h, 006h, 0A5h, 02Fh, 0C9h, 09Bh, 0F0h, 011h, 0A5h, 028h, 005h, 029h, 0D0h, 0DBh, 0A5h ; E650
DB 022h, 029h, 002h, 0D0h, 005h, 0A9h, 09Bh, 020h, 0EAh, 0E6h, 020h, 0D8h, 0E6h, 04Ch, 072h, 0E6h ; E660
DB 084h, 023h, 0A4h, 02Eh, 0B9h, 044h, 003h, 085h, 024h, 0B9h, 045h, 003h, 085h, 025h, 0A2h, 000h ; E670
DB 08Eh, 0E9h, 002h, 0B5h, 020h, 099h, 040h, 003h, 0E8h, 0C8h, 0E0h, 00Ch, 090h, 0F5h, 0A5h, 02Fh ; E680
DB 0A6h, 02Eh, 0A4h, 023h, 060h, 0A4h, 020h, 0C0h, 022h, 090h, 004h, 0A0h, 085h, 0B0h, 01Bh, 0B9h ; E690
DB 01Bh, 003h, 085h, 02Ch, 0B9h, 01Ch, 003h, 085h, 02Dh, 0A4h, 017h, 0B9h, 02Ah, 0E7h, 0A8h, 0B1h ; E6A0
DB 02Ch, 0AAh, 0C8h, 0B1h, 02Ch, 085h, 02Dh, 086h, 02Ch, 018h, 060h, 0A5h, 028h, 0D0h, 002h, 0C6h ; E6B0
DB 029h, 0C6h, 028h, 0A5h, 028h, 005h, 029h, 060h, 0A5h, 024h, 0D0h, 002h, 0C6h, 025h, 0C6h, 024h ; E6C0
DB 060h, 0E6h, 024h, 0D0h, 002h, 0E6h, 025h, 060h, 0A6h, 02Eh, 038h, 0BDh, 048h, 003h, 0E5h, 028h ; E6D0
DB 085h, 028h, 0BDh, 049h, 003h, 0E5h, 029h, 085h, 029h, 060h, 0A0h, 092h, 020h, 0F4h, 0E6h, 084h ; E6E0
DB 023h, 0C0h, 000h, 060h, 0AAh, 0A5h, 02Dh, 048h, 0A5h, 02Ch, 048h, 08Ah, 0A6h, 02Eh, 060h, 038h ; E6F0
DB 0A0h, 001h, 0B1h, 024h, 0E9h, 031h, 030h, 004h, 0C9h, 009h, 090h, 002h, 0A9h, 000h, 085h, 021h ; E700
DB 0E6h, 021h, 0A0h, 000h, 0B1h, 024h, 0F0h, 00Ch, 0A0h, 021h, 0D9h, 01Ah, 003h, 0F0h, 009h, 088h ; E710
DB 088h, 088h, 010h, 0F6h, 0A0h, 082h, 038h, 060h, 098h, 085h, 020h, 018h, 060h, 000h, 004h, 004h ; E720
DB 004h, 004h, 006h, 006h, 006h, 006h, 002h, 008h, 00Ah, 0A5h, 008h, 0F0h, 025h, 0A9h, 0E9h, 085h ; E730
DB 04Ah, 0A9h, 003h, 085h, 04Bh, 0A0h, 012h, 018h, 0B1h, 04Ah, 0AAh, 0C8h, 071h, 04Ah, 0F0h, 026h ; E740
DB 0B1h, 04Ah, 085h, 04Bh, 086h, 04Ah, 020h, 056h, 0CBh, 0D0h, 01Bh, 020h, 094h, 0E8h, 0B0h, 016h ; E750
DB 090h, 0E3h, 0A9h, 000h, 08Dh, 0FBh, 003h, 08Dh, 0FCh, 003h, 0A9h, 04Fh, 0D0h, 02Dh, 0A9h, 000h ; E760
DB 0A8h, 020h, 0BEh, 0E7h, 010h, 001h, 060h, 018h, 0ADh, 0E7h, 002h, 06Dh, 0EAh, 002h, 08Dh, 012h ; E770
DB 003h, 0ADh, 0E8h, 002h, 06Dh, 0EBh, 002h, 08Dh, 013h, 003h, 038h, 0ADh, 0E5h, 002h, 0EDh, 012h ; E780
DB 003h, 0ADh, 0E6h, 002h, 0EDh, 013h, 003h, 0B0h, 009h, 0A9h, 04Eh, 0A8h, 020h, 0BEh, 0E7h, 04Ch ; E790
DB 06Eh, 0E7h, 0ADh, 0ECh, 002h, 0AEh, 0E7h, 002h, 08Eh, 0ECh, 002h, 0AEh, 0E8h, 002h, 08Eh, 0EDh ; E7A0
DB 002h, 020h, 0DEh, 0E7h, 030h, 0E3h, 038h, 020h, 09Eh, 0E8h, 0B0h, 0DDh, 090h, 0B0h, 048h, 0A2h ; E7B0
DB 009h, 0BDh, 0D4h, 0E7h, 09Dh, 000h, 003h, 0CAh, 010h, 0F7h, 08Ch, 00Bh, 003h, 068h, 08Dh, 00Ah ; E7C0
DB 003h, 04Ch, 059h, 0E4h, 04Fh, 001h, 040h, 040h, 0EAh, 002h, 01Eh, 000h, 004h, 000h, 08Dh, 013h ; E7D0
DB 003h, 0A2h, 000h, 08Eh, 012h, 003h, 0CAh, 08Eh, 015h, 003h, 0ADh, 0ECh, 002h, 06Ah, 090h, 008h ; E7E0
DB 0EEh, 0ECh, 002h, 0D0h, 003h, 0EEh, 0EDh, 002h, 0ADh, 0ECh, 002h, 08Dh, 0D1h, 002h, 0ADh, 0EDh ; E7F0
DB 002h, 08Dh, 0D2h, 002h, 0A9h, 016h, 08Dh, 0CFh, 002h, 0A9h, 0E8h, 08Dh, 0D0h, 002h, 0A9h, 080h ; E800
DB 08Dh, 0D3h, 002h, 04Ch, 045h, 0C7h, 0AEh, 015h, 003h, 0E8h, 08Eh, 015h, 003h, 0F0h, 008h, 0AEh ; E810
DB 015h, 003h, 0BDh, 07Dh, 003h, 018h, 060h, 0A9h, 080h, 08Dh, 015h, 003h, 020h, 033h, 0E8h, 010h ; E820
DB 0EEh, 038h, 060h, 0A2h, 00Bh, 0BDh, 051h, 0E8h, 09Dh, 000h, 003h, 0CAh, 010h, 0F7h, 0AEh, 012h ; E830
DB 003h, 08Eh, 00Ah, 003h, 0E8h, 08Eh, 012h, 003h, 0ADh, 013h, 003h, 08Dh, 000h, 003h, 04Ch, 059h ; E840
DB 0E4h, 000h, 001h, 026h, 040h, 0FDh, 003h, 01Eh, 000h, 080h, 000h, 000h, 000h, 08Ch, 012h, 003h ; E850
DB 08Dh, 013h, 003h, 0A9h, 0E9h, 085h, 04Ah, 0A9h, 003h, 085h, 04Bh, 0A0h, 012h, 0B1h, 04Ah, 0AAh ; E860
DB 0C8h, 0B1h, 04Ah, 0CDh, 013h, 003h, 0D0h, 007h, 0ECh, 012h, 003h, 0D0h, 002h, 018h, 060h, 0C9h ; E870
DB 000h, 0D0h, 006h, 0E0h, 000h, 0D0h, 002h, 038h, 060h, 086h, 04Ah, 085h, 04Bh, 020h, 056h, 0CBh ; E880
DB 0D0h, 0F5h, 0F0h, 0D7h, 038h, 008h, 0B0h, 028h, 08Dh, 0EDh, 002h, 08Ch, 0ECh, 002h, 008h, 0A9h ; E890
DB 000h, 0A8h, 020h, 05Dh, 0E8h, 0B0h, 027h, 0A0h, 012h, 0ADh, 0ECh, 002h, 091h, 04Ah, 0AAh, 0C8h ; E8A0
DB 0ADh, 0EDh, 002h, 091h, 04Ah, 086h, 04Ah, 085h, 04Bh, 0A9h, 000h, 091h, 04Ah, 088h, 091h, 04Ah ; E8B0
DB 020h, 000h, 0E9h, 090h, 00Ch, 0ADh, 0EDh, 002h, 0ACh, 0ECh, 002h, 020h, 015h, 0E9h, 028h, 038h ; E8C0
DB 060h, 028h, 0B0h, 009h, 0A9h, 000h, 0A0h, 010h, 091h, 04Ah, 0C8h, 091h, 04Ah, 018h, 0A0h, 010h ; E8D0
DB 0ADh, 0E7h, 002h, 071h, 04Ah, 08Dh, 0E7h, 002h, 0C8h, 0ADh, 0E8h, 002h, 071h, 04Ah, 08Dh, 0E8h ; E8E0
DB 002h, 0A0h, 00Fh, 0A9h, 000h, 091h, 04Ah, 020h, 056h, 0CBh, 0A0h, 00Fh, 091h, 04Ah, 018h, 060h ; E8F0
DB 018h, 0A5h, 04Ah, 069h, 00Ch, 08Dh, 012h, 003h, 0A5h, 04Bh, 069h, 000h, 08Dh, 013h, 003h, 06Ch ; E900
DB 012h, 003h, 04Ch, 072h, 0C2h, 020h, 05Dh, 0E8h, 0B0h, 03Bh, 0A8h, 0A5h, 04Ah, 048h, 0A5h, 04Bh ; E910
DB 048h, 086h, 04Ah, 084h, 04Bh, 0ADh, 044h, 002h, 0D0h, 00Fh, 0A0h, 010h, 018h, 0B1h, 04Ah, 0C8h ; E920
DB 071h, 04Ah, 0D0h, 01Fh, 020h, 056h, 0CBh, 0D0h, 01Ah, 0A0h, 012h, 0B1h, 04Ah, 0AAh, 0C8h, 0B1h ; E930
DB 04Ah, 0A8h, 068h, 085h, 04Bh, 068h, 085h, 04Ah, 098h, 0A0h, 013h, 091h, 04Ah, 088h, 08Ah, 091h ; E940
DB 04Ah, 018h, 060h, 068h, 068h, 038h, 060h, 000h, 000h, 04Ch, 033h, 0C9h, 0A9h, 03Ch, 08Dh, 002h ; E950
DB 0D3h, 0A9h, 03Ch, 08Dh, 003h, 0D3h, 0A9h, 003h, 08Dh, 032h, 002h, 085h, 041h, 08Dh, 00Fh, 0D2h ; E960
DB 060h, 0BAh, 08Eh, 018h, 003h, 0A9h, 001h, 085h, 042h, 0ADh, 000h, 003h, 0C9h, 060h, 0D0h, 003h ; E970
DB 04Ch, 09Dh, 0EBh, 0A9h, 000h, 08Dh, 00Fh, 003h, 0A9h, 001h, 08Dh, 0BDh, 002h, 0A9h, 00Dh, 08Dh ; E980
DB 09Ch, 002h, 0A9h, 028h, 08Dh, 004h, 0D2h, 0A9h, 000h, 08Dh, 006h, 0D2h, 018h, 0ADh, 000h, 003h ; E990
DB 06Dh, 001h, 003h, 069h, 0FFh, 08Dh, 03Ah, 002h, 0ADh, 002h, 003h, 08Dh, 03Bh, 002h, 0ADh, 00Ah ; E9A0
DB 003h, 08Dh, 03Ch, 002h, 0ADh, 00Bh, 003h, 08Dh, 03Dh, 002h, 018h, 0A9h, 03Ah, 085h, 032h, 069h ; E9B0
DB 004h, 085h, 034h, 0A9h, 002h, 085h, 033h, 085h, 035h, 0A9h, 034h, 08Dh, 003h, 0D3h, 020h, 0AFh ; E9C0
DB 0ECh, 0ADh, 03Fh, 002h, 0D0h, 003h, 098h, 0D0h, 008h, 0CEh, 09Ch, 002h, 010h, 0B4h, 04Ch, 022h ; E9D0
DB 0EAh, 0ADh, 003h, 003h, 010h, 00Dh, 0A9h, 00Dh, 08Dh, 09Ch, 002h, 020h, 087h, 0EBh, 020h, 0AFh ; E9E0
DB 0ECh, 0F0h, 02Fh, 020h, 09Ah, 0ECh, 0A9h, 000h, 08Dh, 03Fh, 002h, 020h, 0C0h, 0ECh, 0F0h, 012h ; E9F0
DB 02Ch, 003h, 003h, 070h, 007h, 0ADh, 03Fh, 002h, 0D0h, 018h, 0F0h, 01Eh, 020h, 087h, 0EBh, 020h ; EA00
DB 0FDh, 0EAh, 0ADh, 03Fh, 002h, 0F0h, 005h, 0ADh, 019h, 003h, 085h, 030h, 0A5h, 030h, 0C9h, 001h ; EA10
DB 0F0h, 008h, 0CEh, 0BDh, 002h, 030h, 003h, 04Ch, 08Dh, 0E9h, 020h, 084h, 0ECh, 0A9h, 000h, 085h ; EA20
DB 042h, 0A4h, 030h, 08Ch, 003h, 003h, 060h, 0A9h, 000h, 08Dh, 03Fh, 002h, 018h, 0A9h, 03Eh, 085h ; EA30
DB 032h, 069h, 001h, 085h, 034h, 0A9h, 002h, 085h, 033h, 085h, 035h, 0A9h, 0FFh, 085h, 03Ch, 020h ; EA40
DB 0FDh, 0EAh, 0A0h, 0FFh, 0A5h, 030h, 0C9h, 001h, 0D0h, 019h, 0ADh, 03Eh, 002h, 0C9h, 041h, 0F0h ; EA50
DB 021h, 0C9h, 043h, 0F0h, 01Dh, 0C9h, 045h, 0D0h, 006h, 0A9h, 090h, 085h, 030h, 0D0h, 004h, 0A9h ; EA60
DB 08Bh, 085h, 030h, 0A5h, 030h, 0C9h, 08Ah, 0F0h, 007h, 0A9h, 0FFh, 08Dh, 03Fh, 002h, 0D0h, 002h ; EA70
DB 0A0h, 000h, 0A5h, 030h, 08Dh, 019h, 003h, 060h, 0A9h, 001h, 085h, 030h, 020h, 017h, 0ECh, 0A0h ; EA80
DB 000h, 084h, 031h, 084h, 03Bh, 084h, 03Ah, 0B1h, 032h, 08Dh, 00Dh, 0D2h, 085h, 031h, 0A5h, 011h ; EA90
DB 0D0h, 003h, 04Ch, 0C7h, 0EDh, 0A5h, 03Ah, 0F0h, 0F5h, 020h, 084h, 0ECh, 060h, 098h, 048h, 0E6h ; EAA0
DB 032h, 0D0h, 002h, 0E6h, 033h, 0A5h, 032h, 0C5h, 034h, 0A5h, 033h, 0E5h, 035h, 090h, 01Ch, 0A5h ; EAB0
DB 03Bh, 0D0h, 00Bh, 0A5h, 031h, 08Dh, 00Dh, 0D2h, 0A9h, 0FFh, 085h, 03Bh, 0D0h, 009h, 0A5h, 010h ; EAC0
DB 009h, 008h, 085h, 010h, 08Dh, 00Eh, 0D2h, 068h, 0A8h, 068h, 040h, 0A0h, 000h, 0B1h, 032h, 08Dh ; EAD0
DB 00Dh, 0D2h, 018h, 065h, 031h, 069h, 000h, 085h, 031h, 04Ch, 0D7h, 0EAh, 0A5h, 03Bh, 0F0h, 00Bh ; EAE0
DB 085h, 03Ah, 0A5h, 010h, 029h, 0F7h, 085h, 010h, 08Dh, 00Eh, 0D2h, 068h, 040h, 0A9h, 000h, 0ACh ; EAF0
DB 00Fh, 003h, 0D0h, 002h, 085h, 031h, 085h, 038h, 085h, 039h, 0A9h, 001h, 085h, 030h, 020h, 040h ; EB00
DB 0ECh, 0A9h, 03Ch, 08Dh, 003h, 0D3h, 0A5h, 011h, 0D0h, 003h, 04Ch, 0C7h, 0EDh, 0ADh, 017h, 003h ; EB10
DB 0F0h, 005h, 0A5h, 039h, 0F0h, 0F0h, 060h, 0A9h, 08Ah, 085h, 030h, 060h, 098h, 048h, 0ADh, 00Fh ; EB20
DB 0D2h, 08Dh, 00Ah, 0D2h, 030h, 004h, 0A0h, 08Ch, 084h, 030h, 029h, 020h, 0D0h, 004h, 0A0h, 08Eh ; EB30
DB 084h, 030h, 0A5h, 038h, 0F0h, 013h, 0ADh, 00Dh, 0D2h, 0C5h, 031h, 0F0h, 004h, 0A0h, 08Fh, 084h ; EB40
DB 030h, 0A9h, 0FFh, 085h, 039h, 068h, 0A8h, 068h, 040h, 0ADh, 00Dh, 0D2h, 0A0h, 000h, 091h, 032h ; EB50
DB 018h, 065h, 031h, 069h, 000h, 085h, 031h, 0E6h, 032h, 0D0h, 002h, 0E6h, 033h, 0A5h, 032h, 0C5h ; EB60
DB 034h, 0A5h, 033h, 0E5h, 035h, 090h, 0DEh, 0A5h, 03Ch, 0F0h, 006h, 0A9h, 000h, 085h, 03Ch, 0F0h ; EB70
DB 0D0h, 0A9h, 0FFh, 085h, 038h, 0D0h, 0CEh, 018h, 0ADh, 004h, 003h, 085h, 032h, 06Dh, 008h, 003h ; EB80
DB 085h, 034h, 0ADh, 005h, 003h, 085h, 033h, 06Dh, 009h, 003h, 085h, 035h, 060h, 0ADh, 003h, 003h ; EB90
DB 010h, 032h, 0A9h, 0CCh, 08Dh, 004h, 0D2h, 0A9h, 005h, 08Dh, 006h, 0D2h, 020h, 017h, 0ECh, 0A6h ; EBA0
DB 062h, 0BCh, 015h, 0EEh, 0ADh, 00Bh, 003h, 030h, 003h, 0BCh, 011h, 0EEh, 0A2h, 000h, 020h, 0E2h ; EBB0
DB 0EDh, 0A9h, 034h, 08Dh, 002h, 0D3h, 0ADh, 017h, 003h, 0D0h, 0FBh, 020h, 087h, 0EBh, 020h, 088h ; EBC0
DB 0EAh, 04Ch, 004h, 0ECh, 0A9h, 0FFh, 08Dh, 00Fh, 003h, 0A6h, 062h, 0BCh, 017h, 0EEh, 0ADh, 00Bh ; EBD0
DB 003h, 030h, 003h, 0BCh, 013h, 0EEh, 0A2h, 000h, 020h, 0E2h, 0EDh, 0A9h, 034h, 08Dh, 002h, 0D3h ; EBE0
DB 0ADh, 017h, 003h, 0D0h, 0FBh, 020h, 087h, 0EBh, 020h, 09Ah, 0ECh, 020h, 0E2h, 0EDh, 020h, 03Dh ; EBF0
DB 0EDh, 020h, 0FDh, 0EAh, 0ADh, 00Bh, 003h, 030h, 005h, 0A9h, 03Ch, 08Dh, 002h, 0D3h, 04Ch, 02Ah ; EC00
DB 0EAh, 0A9h, 000h, 08Dh, 017h, 003h, 060h, 0A9h, 007h, 02Dh, 032h, 002h, 009h, 020h, 0ACh, 000h ; EC10
DB 003h, 0C0h, 060h, 0D0h, 00Ch, 009h, 008h, 0A0h, 007h, 08Ch, 002h, 0D2h, 0A0h, 005h, 08Ch, 000h ; EC20
DB 0D2h, 08Dh, 032h, 002h, 08Dh, 00Fh, 0D2h, 0A9h, 0C7h, 025h, 010h, 009h, 010h, 04Ch, 056h, 0ECh ; EC30
DB 0A9h, 007h, 02Dh, 032h, 002h, 009h, 010h, 08Dh, 032h, 002h, 08Dh, 00Fh, 0D2h, 08Dh, 00Ah, 0D2h ; EC40
DB 0A9h, 0C7h, 025h, 010h, 009h, 020h, 085h, 010h, 08Dh, 00Eh, 0D2h, 0A9h, 028h, 08Dh, 008h, 0D2h ; EC50
DB 0A2h, 006h, 0A9h, 0A8h, 0A4h, 041h, 0D0h, 002h, 0A9h, 0A0h, 09Dh, 001h, 0D2h, 0CAh, 0CAh, 010h ; EC60
DB 0F9h, 0A9h, 0A0h, 08Dh, 005h, 0D2h, 0ACh, 000h, 003h, 0C0h, 060h, 0F0h, 006h, 08Dh, 001h, 0D2h ; EC70
DB 08Dh, 003h, 0D2h, 060h, 0EAh, 0A9h, 0C7h, 025h, 010h, 085h, 010h, 08Dh, 00Eh, 0D2h, 0A2h, 006h ; EC80
DB 0A9h, 000h, 09Dh, 001h, 0D2h, 0CAh, 0CAh, 010h, 0F9h, 060h, 0ADh, 006h, 003h, 06Ah, 06Ah, 0A8h ; EC90
DB 029h, 03Fh, 0AAh, 098h, 06Ah, 029h, 0C0h, 0A8h, 060h, 02Ch, 0EBh, 0ADh, 0EAh, 0ECh, 0EAh, 0A2h ; ECA0
DB 001h, 0A0h, 0FFh, 088h, 0D0h, 0FDh, 0CAh, 0D0h, 0F8h, 020h, 088h, 0EAh, 0A0h, 002h, 0A2h, 000h ; ECB0
DB 020h, 0E2h, 0EDh, 020h, 037h, 0EAh, 098h, 060h, 08Dh, 010h, 003h, 08Ch, 011h, 003h, 020h, 02Eh ; ECC0
DB 0EDh, 08Dh, 010h, 003h, 0ADh, 00Ch, 003h, 020h, 02Eh, 0EDh, 08Dh, 00Ch, 003h, 0ADh, 010h, 003h ; ECD0
DB 038h, 0EDh, 00Ch, 003h, 08Dh, 012h, 003h, 0ADh, 011h, 003h, 038h, 0EDh, 00Dh, 003h, 0A8h, 0A6h ; ECE0
DB 062h, 0A9h, 000h, 038h, 0FDh, 019h, 0EEh, 018h, 07Dh, 019h, 0EEh, 088h, 010h, 0F9h, 018h, 06Dh ; ECF0
DB 012h, 003h, 0A8h, 04Ah, 04Ah, 04Ah, 00Ah, 038h, 0E9h, 016h, 0AAh, 098h, 029h, 007h, 0A8h, 0A9h ; ED00
DB 0F5h, 018h, 069h, 00Bh, 088h, 010h, 0FAh, 0A0h, 000h, 038h, 0E9h, 007h, 010h, 001h, 088h, 018h ; ED10
DB 07Dh, 0F9h, 0EDh, 08Dh, 0EEh, 002h, 098h, 07Dh, 0FAh, 0EDh, 08Dh, 0EFh, 002h, 060h, 0C9h, 07Ch ; ED20
DB 030h, 004h, 038h, 0E9h, 07Ch, 060h, 018h, 0A6h, 062h, 07Dh, 01Bh, 0EEh, 060h, 0A5h, 011h, 0D0h ; ED30
DB 003h, 04Ch, 0C7h, 0EDh, 078h, 0ADh, 017h, 003h, 0D0h, 002h, 0F0h, 025h, 0ADh, 00Fh, 0D2h, 029h ; ED40
DB 010h, 0D0h, 0EAh, 08Dh, 016h, 003h, 0AEh, 00Bh, 0D4h, 0A4h, 014h, 08Eh, 00Ch, 003h, 08Ch, 00Dh ; ED50
DB 003h, 0A2h, 001h, 08Eh, 015h, 003h, 0A0h, 00Ah, 0A5h, 011h, 0F0h, 05Bh, 0ADh, 017h, 003h, 0D0h ; ED60
DB 004h, 058h, 04Ch, 027h, 0EBh, 0ADh, 00Fh, 0D2h, 029h, 010h, 0CDh, 016h, 003h, 0F0h, 0E9h, 08Dh ; ED70
DB 016h, 003h, 088h, 0D0h, 0E3h, 0CEh, 015h, 003h, 030h, 00Ch, 0ADh, 00Bh, 0D4h, 0A4h, 014h, 020h ; ED80
DB 0C8h, 0ECh, 0A0h, 009h, 0D0h, 0D2h, 0ADh, 0EEh, 002h, 08Dh, 004h, 0D2h, 0ADh, 0EFh, 002h, 08Dh ; ED90
DB 006h, 0D2h, 0A9h, 000h, 08Dh, 00Fh, 0D2h, 0ADh, 032h, 002h, 08Dh, 00Fh, 0D2h, 0A9h, 055h, 091h ; EDA0
DB 032h, 0C8h, 091h, 032h, 0A9h, 0AAh, 085h, 031h, 018h, 0A5h, 032h, 069h, 002h, 085h, 032h, 0A5h ; EDB0
DB 033h, 069h, 000h, 085h, 033h, 058h, 060h, 020h, 084h, 0ECh, 0A9h, 03Ch, 08Dh, 002h, 0D3h, 0A9h ; EDC0
DB 03Ch, 08Dh, 003h, 0D3h, 0A9h, 080h, 085h, 030h, 0AEh, 018h, 003h, 09Ah, 0C6h, 011h, 058h, 04Ch ; EDD0
DB 02Ah, 0EAh, 0A9h, 011h, 08Dh, 026h, 002h, 0A9h, 0ECh, 08Dh, 027h, 002h, 0A9h, 001h, 078h, 020h ; EDE0
DB 05Ch, 0E4h, 0A9h, 001h, 08Dh, 017h, 003h, 058h, 060h, 0E8h, 003h, 043h, 004h, 09Eh, 004h, 0F9h ; EDF0
DB 004h, 054h, 005h, 0AFh, 005h, 00Ah, 006h, 065h, 006h, 0C0h, 006h, 01Ah, 007h, 075h, 007h, 0D0h ; EE00
DB 007h, 0B4h, 096h, 078h, 064h, 00Fh, 00Dh, 00Ah, 008h, 083h, 09Ch, 007h, 020h, 018h, 010h, 00Ah ; EE10
DB 00Ah, 010h, 01Ch, 034h, 064h, 0C4h, 0C4h, 0C4h, 0C4h, 01Ch, 010h, 064h, 0C4h, 017h, 017h, 00Bh ; EE20
DB 017h, 02Fh, 02Fh, 05Fh, 05Fh, 061h, 061h, 061h, 061h, 017h, 00Bh, 0BFh, 061h, 013h, 013h, 009h ; EE30
DB 013h, 027h, 027h, 04Fh, 04Fh, 041h, 041h, 041h, 041h, 013h, 009h, 09Fh, 041h, 002h, 006h, 007h ; EE40
DB 008h, 009h, 00Ah, 00Bh, 00Dh, 00Fh, 00Fh, 00Fh, 00Fh, 004h, 005h, 00Ch, 00Eh, 000h, 000h, 000h ; EE50
DB 000h, 000h, 000h, 000h, 001h, 001h, 001h, 001h, 001h, 000h, 000h, 001h, 001h, 003h, 002h, 002h ; EE60
DB 001h, 001h, 002h, 002h, 003h, 003h, 003h, 003h, 003h, 003h, 003h, 002h, 003h, 028h, 014h, 014h ; EE70
DB 028h, 050h, 050h, 0A0h, 0A0h, 040h, 050h, 050h, 050h, 028h, 028h, 0A0h, 0A0h, 018h, 018h, 00Ch ; EE80
DB 018h, 030h, 030h, 060h, 060h, 0C0h, 0C0h, 0C0h, 0C0h, 018h, 00Ch, 0C0h, 0C0h, 000h, 000h, 000h ; EE90
DB 002h, 003h, 002h, 003h, 002h, 003h, 001h, 001h, 001h, 000h, 000h, 003h, 002h, 0FFh, 0F0h, 00Fh ; EEA0
DB 0C0h, 030h, 00Ch, 003h, 080h, 040h, 020h, 010h, 008h, 004h, 002h, 001h, 048h, 098h, 048h, 08Ah ; EEB0
DB 0A2h, 000h, 0DDh, 01Ah, 003h, 0F0h, 01Eh, 0E8h, 0E8h, 0E8h, 0E0h, 022h, 030h, 0F4h, 0A2h, 000h ; EEC0
DB 0A8h, 0A9h, 000h, 0DDh, 01Ah, 003h, 0F0h, 013h, 0E8h, 0E8h, 0E8h, 0E0h, 022h, 030h, 0F4h, 068h ; EED0
DB 068h, 0A0h, 0FFh, 038h, 060h, 068h, 0A8h, 068h, 0E8h, 038h, 060h, 098h, 09Dh, 01Ah, 003h, 068h ; EEE0
DB 09Dh, 01Bh, 003h, 068h, 09Dh, 01Ch, 003h, 018h, 060h, 0A0h, 000h, 0B1h, 024h, 0A4h, 021h, 020h ; EEF0
DB 0BEh, 0E7h, 010h, 003h, 0A0h, 082h, 060h, 0A9h, 07Fh, 085h, 020h, 0A9h, 025h, 085h, 026h, 0A9h ; EF00
DB 0EFh, 085h, 027h, 0ADh, 0ECh, 002h, 0AEh, 02Eh, 000h, 09Dh, 04Dh, 003h, 0A0h, 000h, 0B1h, 024h ; EF10
DB 09Dh, 04Ch, 003h, 0A0h, 001h, 060h, 048h, 08Ah, 048h, 029h, 00Fh, 0D0h, 010h, 0E0h, 080h, 010h ; EF20
DB 00Ch, 0ADh, 0E9h, 002h, 0D0h, 00Bh, 0A0h, 082h, 068h, 068h, 0C0h, 000h, 060h, 0A0h, 086h, 030h ; EF30
DB 0F7h, 08Eh, 02Eh, 000h, 0A0h, 000h, 0BDh, 040h, 003h, 099h, 020h, 000h, 0E8h, 0C8h, 0C0h, 00Ch ; EF40
DB 030h, 0F4h, 020h, 029h, 0CAh, 030h, 0E1h, 068h, 0AAh, 068h, 0A8h, 0A5h, 027h, 048h, 0A5h, 026h ; EF50
DB 048h, 098h, 0A0h, 092h, 060h, 000h, 000h, 000h, 000h, 000h, 000h, 04Ch, 005h, 0FDh, 0A9h, 0FFh ; EF60
DB 08Dh, 0FCh, 002h, 0ADh, 0E4h, 002h, 085h, 06Ah, 0A9h, 040h, 08Dh, 0BEh, 002h, 0A9h, 051h, 085h ; EF70
DB 079h, 0A9h, 0FBh, 085h, 07Ah, 0A9h, 011h, 085h, 060h, 0A9h, 0FCh, 085h, 061h, 060h, 0A5h, 02Bh ; EF80
DB 029h, 00Fh, 0D0h, 008h, 0A5h, 02Ah, 029h, 00Fh, 085h, 02Ah, 0A9h, 000h, 085h, 057h, 0C9h, 010h ; EF90
DB 090h, 005h, 0A9h, 091h, 04Ch, 054h, 0F1h, 0A9h, 0E0h, 08Dh, 0F4h, 002h, 0A9h, 0CCh, 08Dh, 06Bh ; EFA0
DB 002h, 0A9h, 002h, 08Dh, 0F3h, 002h, 08Dh, 02Fh, 002h, 0A9h, 001h, 085h, 04Ch, 0A9h, 0C0h, 005h ; EFB0
DB 010h, 085h, 010h, 08Dh, 00Eh, 0D2h, 0A9h, 040h, 08Dh, 00Eh, 0D4h, 02Ch, 06Eh, 002h, 010h, 00Ch ; EFC0
DB 0A9h, 0C4h, 08Dh, 000h, 002h, 0A9h, 0FCh, 08Dh, 001h, 002h, 0A9h, 0C0h, 08Dh, 00Eh, 0D4h, 0A9h ; EFD0
DB 000h, 08Dh, 093h, 002h, 085h, 064h, 085h, 07Bh, 08Dh, 0F0h, 002h, 0A0h, 00Eh, 0A9h, 001h, 099h ; EFE0
DB 0A3h, 002h, 088h, 010h, 0FAh, 0A2h, 004h, 0BDh, 008h, 0FBh, 09Dh, 0C4h, 002h, 0CAh, 010h, 0F7h ; EFF0
DB 0A4h, 06Ah, 088h, 08Ch, 095h, 002h, 0A9h, 060h, 08Dh, 094h, 002h, 0A6h, 057h, 0BDh, 04Dh, 0EEh ; F000
DB 085h, 051h, 0A5h, 06Ah, 085h, 065h, 0BCh, 01Dh, 0EEh, 0A9h, 028h, 020h, 07Ah, 0F5h, 088h, 0D0h ; F010
DB 0F8h, 0ADh, 06Fh, 002h, 029h, 03Fh, 085h, 067h, 0A8h, 0E0h, 008h, 090h, 01Fh, 0E0h, 00Fh, 0F0h ; F020
DB 00Dh, 0E0h, 00Ch, 0B0h, 017h, 08Ah, 06Ah, 06Ah, 06Ah, 029h, 0C0h, 005h, 067h, 0A8h, 0A9h, 010h ; F030
DB 020h, 07Ah, 0F5h, 0E0h, 00Bh, 0D0h, 005h, 0A9h, 006h, 08Dh, 0C8h, 002h, 08Ch, 06Fh, 002h, 0A5h ; F040
DB 064h, 085h, 058h, 0A5h, 065h, 085h, 059h, 0ADh, 00Bh, 0D4h, 0C9h, 07Ah, 0D0h, 0F9h, 020h, 078h ; F050
DB 0F5h, 0BDh, 05Dh, 0EEh, 0F0h, 006h, 0A9h, 0FFh, 085h, 064h, 0C6h, 065h, 020h, 065h, 0F5h, 0A5h ; F060
DB 064h, 085h, 068h, 0A5h, 065h, 085h, 069h, 0A9h, 041h, 020h, 070h, 0F5h, 086h, 066h, 0A9h, 018h ; F070
DB 08Dh, 0BFh, 002h, 0A5h, 057h, 0C9h, 00Ch, 0B0h, 004h, 0C9h, 009h, 0B0h, 039h, 0A5h, 02Ah, 029h ; F080
DB 010h, 0F0h, 033h, 0A9h, 004h, 08Dh, 0BFh, 002h, 0A2h, 002h, 0ADh, 06Eh, 002h, 0F0h, 003h, 020h ; F090
DB 0A0h, 0F5h, 0A9h, 002h, 020h, 069h, 0F5h, 0CAh, 010h, 0F8h, 0A4h, 06Ah, 088h, 098h, 020h, 070h ; F0A0
DB 0F5h, 0A9h, 060h, 020h, 070h, 0F5h, 0A9h, 042h, 020h, 069h, 0F5h, 018h, 0A9h, 010h, 065h, 066h ; F0B0
DB 0A8h, 0BEh, 02Dh, 0EEh, 0D0h, 015h, 0A4h, 066h, 0BEh, 02Dh, 0EEh, 0A5h, 057h, 0D0h, 00Ch, 0ADh ; F0C0
DB 06Eh, 002h, 0F0h, 007h, 020h, 0A0h, 0F5h, 0A9h, 022h, 085h, 051h, 0A5h, 051h, 020h, 070h, 0F5h ; F0D0
DB 0CAh, 0D0h, 0F8h, 0A5h, 057h, 0C9h, 008h, 090h, 026h, 0C9h, 00Fh, 0F0h, 004h, 0C9h, 00Ch, 0B0h ; F0E0
DB 01Eh, 0A2h, 05Dh, 0A5h, 06Ah, 038h, 0E9h, 010h, 020h, 070h, 0F5h, 0A9h, 000h, 020h, 070h, 0F5h ; F0F0
DB 0A5h, 051h, 009h, 040h, 020h, 070h, 0F5h, 0A5h, 051h, 020h, 070h, 0F5h, 0CAh, 0D0h, 0F8h, 0A5h ; F100
DB 059h, 020h, 070h, 0F5h, 0A5h, 058h, 020h, 070h, 0F5h, 0A5h, 051h, 009h, 040h, 020h, 070h, 0F5h ; F110
DB 0A9h, 070h, 020h, 070h, 0F5h, 0A9h, 070h, 020h, 070h, 0F5h, 0A5h, 064h, 08Dh, 030h, 002h, 0A5h ; F120
DB 065h, 08Dh, 031h, 002h, 0A9h, 070h, 020h, 070h, 0F5h, 0A5h, 064h, 08Dh, 0E5h, 002h, 0A5h, 065h ; F130
DB 08Dh, 0E6h, 002h, 0A0h, 001h, 0ADh, 030h, 002h, 091h, 068h, 0C8h, 0ADh, 031h, 002h, 091h, 068h ; F140
DB 0A5h, 04Ch, 010h, 010h, 08Dh, 0ECh, 003h, 020h, 094h, 0EFh, 0ADh, 0ECh, 003h, 0A0h, 000h, 08Ch ; F150
DB 0ECh, 003h, 0A8h, 060h, 0A5h, 02Ah, 029h, 020h, 0D0h, 00Bh, 020h, 020h, 0F4h, 08Dh, 090h, 002h ; F160
DB 0A5h, 052h, 08Dh, 091h, 002h, 0A9h, 022h, 00Dh, 02Fh, 002h, 08Dh, 02Fh, 002h, 04Ch, 00Bh, 0F2h ; F170
DB 020h, 0CAh, 0F6h, 020h, 08Fh, 0F1h, 020h, 06Ah, 0F7h, 020h, 00Ah, 0F6h, 04Ch, 01Eh, 0F2h, 020h ; F180
DB 0ACh, 0F5h, 0B1h, 064h, 02Dh, 0A0h, 002h, 046h, 06Fh, 0B0h, 003h, 04Ah, 010h, 0F9h, 08Dh, 0FAh ; F190
DB 002h, 0C9h, 000h, 060h, 08Dh, 0FBh, 002h, 0C9h, 07Dh, 0D0h, 006h, 020h, 020h, 0F4h, 04Ch, 00Bh ; F1A0
DB 0F2h, 020h, 0CAh, 0F6h, 0ADh, 0FBh, 002h, 0C9h, 09Bh, 0D0h, 006h, 020h, 061h, 0F6h, 04Ch, 00Bh ; F1B0
DB 0F2h, 020h, 0CAh, 0F1h, 020h, 00Eh, 0F6h, 04Ch, 00Bh, 0F2h, 0ADh, 0FFh, 002h, 0D0h, 0FBh, 0A2h ; F1C0
DB 002h, 0B5h, 054h, 095h, 05Ah, 0CAh, 010h, 0F9h, 0ADh, 0FBh, 002h, 0A8h, 02Ah, 02Ah, 02Ah, 02Ah ; F1D0
DB 029h, 003h, 0AAh, 098h, 029h, 09Fh, 01Dh, 049h, 0FBh, 08Dh, 0FAh, 002h, 020h, 0ACh, 0F5h, 0ADh ; F1E0
DB 0FAh, 002h, 046h, 06Fh, 0B0h, 004h, 00Ah, 04Ch, 0F2h, 0F1h, 02Dh, 0A0h, 002h, 085h, 050h, 0ADh ; F1F0
DB 0A0h, 002h, 049h, 0FFh, 031h, 064h, 005h, 050h, 091h, 064h, 060h, 020h, 08Fh, 0F1h, 085h, 05Dh ; F200
DB 0A6h, 057h, 0D0h, 00Ah, 0AEh, 0F0h, 002h, 0D0h, 005h, 049h, 080h, 020h, 0E9h, 0F1h, 0A4h, 04Ch ; F210
DB 04Ch, 026h, 0F2h, 04Ch, 0FCh, 0C8h, 0A9h, 001h, 085h, 04Ch, 0ADh, 0FBh, 002h, 060h, 02Ch, 06Eh ; F220
DB 002h, 010h, 0EBh, 0A9h, 040h, 08Dh, 00Eh, 0D4h, 0A9h, 000h, 08Dh, 06Eh, 002h, 0A9h, 0CEh, 08Dh ; F230
DB 000h, 002h, 0A9h, 0C0h, 08Dh, 001h, 002h, 04Ch, 094h, 0EFh, 020h, 062h, 0F9h, 020h, 0BCh, 0F6h ; F240
DB 0A5h, 06Bh, 0D0h, 034h, 0A5h, 054h, 085h, 06Ch, 0A5h, 055h, 085h, 06Dh, 020h, 0FDh, 0F2h, 084h ; F250
DB 04Ch, 0ADh, 0FBh, 002h, 0C9h, 09Bh, 0F0h, 012h, 020h, 0BEh, 0F2h, 020h, 062h, 0F9h, 0A5h, 063h ; F260
DB 0C9h, 071h, 0D0h, 003h, 020h, 056h, 0F5h, 04Ch, 05Ch, 0F2h, 020h, 018h, 0F7h, 020h, 0B1h, 0F8h ; F270
DB 0A5h, 06Ch, 085h, 054h, 0A5h, 06Dh, 085h, 055h, 0A5h, 06Bh, 0F0h, 011h, 0C6h, 06Bh, 0F0h, 00Dh ; F280
DB 0A5h, 04Ch, 030h, 0F8h, 020h, 080h, 0F1h, 08Dh, 0FBh, 002h, 04Ch, 062h, 0F9h, 020h, 061h, 0F6h ; F290
DB 0A9h, 09Bh, 08Dh, 0FBh, 002h, 020h, 00Bh, 0F2h, 084h, 04Ch, 04Ch, 062h, 0F9h, 06Ch, 064h, 000h ; F2A0
DB 08Dh, 0FBh, 002h, 020h, 062h, 0F9h, 020h, 0BCh, 0F6h, 0A9h, 000h, 08Dh, 0E8h, 003h, 020h, 018h ; F2B0
DB 0F7h, 020h, 03Ch, 0F9h, 0F0h, 009h, 00Eh, 0A2h, 002h, 020h, 0B4h, 0F1h, 04Ch, 062h, 0F9h, 0ADh ; F2C0
DB 0FEh, 002h, 00Dh, 0A2h, 002h, 0D0h, 0EFh, 00Eh, 0A2h, 002h, 0E8h, 0ADh, 0E8h, 003h, 0F0h, 005h ; F2D0
DB 08Ah, 018h, 069h, 02Dh, 0AAh, 0BDh, 00Dh, 0FBh, 085h, 064h, 0BDh, 00Eh, 0FBh, 085h, 065h, 020h ; F2E0
DB 0ADh, 0F2h, 020h, 00Bh, 0F2h, 04Ch, 062h, 0F9h, 0A9h, 0FFh, 08Dh, 0FCh, 002h, 0A9h, 000h, 08Dh ; F2F0
DB 0E8h, 003h, 0A5h, 02Ah, 04Ah, 0B0h, 06Fh, 0A9h, 080h, 0A6h, 011h, 0F0h, 065h, 0ADh, 0FCh, 002h ; F300
DB 0C9h, 0FFh, 0F0h, 0E9h, 085h, 07Ch, 0A2h, 0FFh, 08Eh, 0FCh, 002h, 0AEh, 0DBh, 002h, 0D0h, 003h ; F310
DB 020h, 083h, 0F9h, 0A8h, 0C0h, 0C0h, 0B0h, 0D0h, 0B1h, 079h, 08Dh, 0FBh, 002h, 0AAh, 030h, 003h ; F320
DB 04Ch, 0B4h, 0F3h, 0C9h, 080h, 0F0h, 0C1h, 0C9h, 081h, 0D0h, 00Ah, 0ADh, 0B6h, 002h, 049h, 080h ; F330
DB 08Dh, 0B6h, 002h, 0B0h, 0B3h, 0C9h, 082h, 0D0h, 00Ch, 0ADh, 0BEh, 002h, 0F0h, 00Bh, 0A9h, 000h ; F340
DB 08Dh, 0BEh, 002h, 0F0h, 0A3h, 0C9h, 083h, 0D0h, 007h, 0A9h, 040h, 08Dh, 0BEh, 002h, 0D0h, 098h ; F350
DB 0C9h, 084h, 0D0h, 008h, 0A9h, 080h, 08Dh, 0BEh, 002h, 04Ch, 0F8h, 0F2h, 0C9h, 085h, 0D0h, 00Bh ; F360
DB 0A9h, 088h, 085h, 04Ch, 085h, 011h, 0A9h, 09Bh, 04Ch, 0DAh, 0F3h, 0C9h, 089h, 0D0h, 010h, 0ADh ; F370
DB 0DBh, 002h, 049h, 0FFh, 08Dh, 0DBh, 002h, 0D0h, 003h, 020h, 083h, 0F9h, 04Ch, 0F8h, 0F2h, 0C9h ; F380
DB 08Eh, 0B0h, 012h, 0C9h, 08Ah, 090h, 0F5h, 0E9h, 08Ah, 006h, 07Ch, 010h, 002h, 009h, 004h, 0A8h ; F390
DB 0B1h, 060h, 04Ch, 02Ah, 0F3h, 0C9h, 092h, 0B0h, 00Bh, 0C9h, 08Eh, 090h, 0DFh, 0E9h, 072h, 0EEh ; F3A0
DB 0E8h, 003h, 0D0h, 026h, 0A5h, 07Ch, 0C9h, 040h, 0B0h, 015h, 0ADh, 0FBh, 002h, 0C9h, 061h, 090h ; F3B0
DB 00Eh, 0C9h, 07Bh, 0B0h, 00Ah, 0ADh, 0BEh, 002h, 0F0h, 005h, 005h, 07Ch, 04Ch, 023h, 0F3h, 020h ; F3C0
DB 03Ch, 0F9h, 0F0h, 009h, 0ADh, 0FBh, 002h, 04Dh, 0B6h, 002h, 08Dh, 0FBh, 002h, 04Ch, 01Eh, 0F2h ; F3D0
DB 0A9h, 080h, 08Dh, 0A2h, 002h, 060h, 0C6h, 054h, 010h, 006h, 0AEh, 0BFh, 002h, 0CAh, 086h, 054h ; F3E0
DB 04Ch, 00Ch, 0F9h, 0E6h, 054h, 0A5h, 054h, 0CDh, 0BFh, 002h, 090h, 0F4h, 0A2h, 000h, 0F0h, 0EEh ; F3F0
DB 0C6h, 055h, 0A5h, 055h, 030h, 004h, 0C5h, 052h, 0B0h, 004h, 0A5h, 053h, 085h, 055h, 04Ch, 08Eh ; F400
DB 0F8h, 0E6h, 055h, 0A5h, 055h, 0C5h, 053h, 090h, 0F5h, 0F0h, 0F3h, 0A5h, 052h, 04Ch, 00Ch, 0F4h ; F410
DB 020h, 0A6h, 0F9h, 0A4h, 064h, 0A9h, 000h, 085h, 064h, 091h, 064h, 0C8h, 0D0h, 0FBh, 0E6h, 065h ; F420
DB 0A6h, 065h, 0E4h, 06Ah, 090h, 0F3h, 0A9h, 0FFh, 099h, 0B2h, 002h, 0C8h, 0C0h, 004h, 090h, 0F8h ; F430
DB 020h, 097h, 0F9h, 085h, 063h, 085h, 06Dh, 0A9h, 000h, 085h, 054h, 085h, 056h, 085h, 06Ch, 060h ; F440
DB 0A5h, 063h, 0C5h, 052h, 0F0h, 021h, 0A5h, 055h, 0C5h, 052h, 0D0h, 003h, 020h, 023h, 0F9h, 020h ; F450
DB 000h, 0F4h, 0A5h, 055h, 0C5h, 053h, 0D0h, 007h, 0A5h, 054h, 0F0h, 003h, 020h, 0E6h, 0F3h, 0A9h ; F460
DB 020h, 08Dh, 0FBh, 002h, 020h, 0CAh, 0F1h, 04Ch, 08Eh, 0F8h, 020h, 011h, 0F4h, 0A5h, 055h, 0C5h ; F470
DB 052h, 0D0h, 008h, 020h, 065h, 0F6h, 020h, 058h, 0F7h, 0B0h, 007h, 0A5h, 063h, 020h, 05Dh, 0F7h ; F480
DB 090h, 0E8h, 04Ch, 08Eh, 0F8h, 0A5h, 063h, 04Ch, 03Eh, 0F7h, 0A5h, 063h, 04Ch, 04Ah, 0F7h, 020h ; F490
DB 04Ch, 0F9h, 020h, 08Fh, 0F1h, 085h, 07Dh, 0A9h, 000h, 08Dh, 0BBh, 002h, 020h, 0E9h, 0F1h, 0A5h ; F4A0
DB 063h, 048h, 020h, 012h, 0F6h, 068h, 0C5h, 063h, 0B0h, 00Ch, 0A5h, 07Dh, 048h, 020h, 08Fh, 0F1h ; F4B0
DB 085h, 07Dh, 068h, 04Ch, 0ACh, 0F4h, 020h, 057h, 0F9h, 0CEh, 0BBh, 002h, 030h, 004h, 0C6h, 054h ; F4C0
DB 0D0h, 0F7h, 04Ch, 08Eh, 0F8h, 020h, 04Ch, 0F9h, 020h, 0ACh, 0F5h, 0A5h, 064h, 085h, 068h, 0A5h ; F4D0
DB 065h, 085h, 069h, 0A5h, 063h, 048h, 020h, 00Ah, 0F6h, 068h, 0C5h, 063h, 0B0h, 010h, 0A5h, 054h ; F4E0
DB 0CDh, 0BFh, 002h, 0B0h, 009h, 020h, 08Fh, 0F1h, 0A0h, 000h, 091h, 068h, 0F0h, 0DAh, 0A0h, 000h ; F4F0
DB 098h, 091h, 068h, 020h, 018h, 0F9h, 020h, 057h, 0F9h, 04Ch, 08Eh, 0F8h, 038h, 020h, 0C2h, 0F7h ; F500
DB 0A5h, 052h, 085h, 055h, 020h, 0ACh, 0F5h, 020h, 08Eh, 0F7h, 020h, 0E2h, 0F7h, 04Ch, 08Eh, 0F8h ; F510
DB 020h, 08Eh, 0F8h, 0A4h, 051h, 084h, 054h, 0A4h, 054h, 098h, 038h, 020h, 05Bh, 0F7h, 008h, 098h ; F520
DB 018h, 069h, 078h, 028h, 020h, 03Ch, 0F7h, 0C8h, 0C0h, 018h, 0D0h, 0EDh, 0ADh, 0B4h, 002h, 009h ; F530
DB 001h, 08Dh, 0B4h, 002h, 0A9h, 000h, 085h, 055h, 020h, 0ACh, 0F5h, 020h, 02Ah, 0F8h, 020h, 058h ; F540
DB 0F7h, 090h, 0D4h, 04Ch, 01Bh, 0F4h, 0A0h, 020h, 020h, 083h, 0F9h, 088h, 010h, 0FAh, 060h, 020h ; F550
DB 040h, 0F4h, 04Ch, 0E6h, 0F3h, 0A9h, 002h, 0D0h, 011h, 0ACh, 06Eh, 002h, 0F0h, 002h, 009h, 020h ; F560
DB 0A4h, 04Ch, 030h, 02Bh, 0A0h, 000h, 091h, 064h, 0A9h, 001h, 08Dh, 09Eh, 002h, 0A5h, 04Ch, 030h ; F570
DB 01Eh, 0A5h, 064h, 038h, 0EDh, 09Eh, 002h, 085h, 064h, 0B0h, 002h, 0C6h, 065h, 0A5h, 00Fh, 0C5h ; F580
DB 065h, 090h, 00Ch, 0D0h, 006h, 0A5h, 00Eh, 0C5h, 064h, 090h, 004h, 0A9h, 093h, 085h, 04Ch, 060h ; F590
DB 0A9h, 002h, 020h, 070h, 0F5h, 0A9h, 0A2h, 020h, 070h, 0F5h, 0CAh, 060h, 0A2h, 001h, 086h, 066h ; F5A0
DB 0CAh, 086h, 065h, 0A5h, 054h, 00Ah, 026h, 065h, 00Ah, 026h, 065h, 065h, 054h, 085h, 064h, 090h ; F5B0
DB 002h, 0E6h, 065h, 0A4h, 057h, 0BEh, 06Dh, 0EEh, 006h, 064h, 026h, 065h, 0CAh, 0D0h, 0F9h, 0A5h ; F5C0
DB 056h, 04Ah, 0A5h, 055h, 0BEh, 09Dh, 0EEh, 0F0h, 006h, 06Ah, 006h, 066h, 0CAh, 0D0h, 0FAh, 065h ; F5D0
DB 064h, 090h, 002h, 0E6h, 065h, 018h, 065h, 058h, 085h, 064h, 085h, 05Eh, 0A5h, 065h, 065h, 059h ; F5E0
DB 085h, 065h, 085h, 05Fh, 0BEh, 09Dh, 0EEh, 0BDh, 004h, 0FBh, 025h, 055h, 065h, 066h, 0A8h, 0B9h ; F5F0
DB 0ACh, 0EEh, 08Dh, 0A0h, 002h, 085h, 06Fh, 0A0h, 000h, 060h, 0A9h, 000h, 0F0h, 002h, 0A9h, 09Bh ; F600
DB 085h, 07Dh, 0E6h, 063h, 0E6h, 055h, 0D0h, 002h, 0E6h, 056h, 0A5h, 055h, 0A6h, 057h, 0DDh, 07Dh ; F610
DB 0EEh, 0F0h, 00Ah, 0E0h, 000h, 0D0h, 0E2h, 0C5h, 053h, 0F0h, 0DEh, 090h, 0DCh, 0E0h, 008h, 0D0h ; F620
DB 004h, 0A5h, 056h, 0F0h, 0D4h, 0A5h, 057h, 0D0h, 02Ch, 0A5h, 063h, 0C9h, 051h, 090h, 00Ah, 0A5h ; F630
DB 07Dh, 0F0h, 022h, 020h, 061h, 0F6h, 04Ch, 0ABh, 0F6h, 020h, 065h, 0F6h, 0A5h, 054h, 018h, 069h ; F640
DB 078h, 020h, 05Dh, 0F7h, 090h, 008h, 0A5h, 07Dh, 0F0h, 004h, 018h, 020h, 00Dh, 0F5h, 04Ch, 08Eh ; F650
DB 0F8h, 0A9h, 09Bh, 085h, 07Dh, 020h, 097h, 0F9h, 0A9h, 000h, 085h, 056h, 0E6h, 054h, 0A6h, 057h ; F660
DB 0A0h, 018h, 024h, 07Bh, 010h, 005h, 0A0h, 004h, 098h, 0D0h, 003h, 0BDh, 08Dh, 0EEh, 0C5h, 054h ; F670
DB 0D0h, 029h, 08Ch, 09Dh, 002h, 08Ah, 0D0h, 023h, 0A5h, 07Dh, 0F0h, 01Fh, 0C9h, 09Bh, 0F0h, 001h ; F680
DB 018h, 020h, 0F7h, 0F7h, 0EEh, 0BBh, 002h, 0C6h, 06Ch, 010h, 002h, 0E6h, 06Ch, 0CEh, 09Dh, 002h ; F690
DB 0ADh, 0B2h, 002h, 038h, 010h, 0EBh, 0ADh, 09Dh, 002h, 085h, 054h, 04Ch, 08Eh, 0F8h, 038h, 0B5h ; F6A0
DB 070h, 0E5h, 074h, 095h, 070h, 0B5h, 071h, 0E5h, 075h, 095h, 071h, 060h, 0ADh, 0BFh, 002h, 0C9h ; F6B0
DB 004h, 0F0h, 007h, 0A5h, 057h, 0F0h, 003h, 020h, 094h, 0EFh, 0A9h, 027h, 0C5h, 053h, 0B0h, 002h ; F6C0
DB 085h, 053h, 0A6h, 057h, 0BDh, 08Dh, 0EEh, 0C5h, 054h, 090h, 02Ah, 0F0h, 028h, 0E0h, 008h, 0D0h ; F6D0
DB 00Ah, 0A5h, 056h, 0F0h, 013h, 0C9h, 001h, 0D0h, 01Ch, 0F0h, 004h, 0A5h, 056h, 0D0h, 016h, 0BDh ; F6E0
DB 07Dh, 0EEh, 0C5h, 055h, 090h, 00Fh, 0F0h, 00Dh, 0A9h, 001h, 085h, 04Ch, 0A9h, 080h, 0A6h, 011h ; F6F0
DB 085h, 011h, 0F0h, 006h, 060h, 020h, 040h, 0F4h, 0A9h, 08Dh, 085h, 04Ch, 068h, 068h, 0A5h, 07Bh ; F700
DB 010h, 003h, 04Ch, 062h, 0F9h, 04Ch, 01Eh, 0F2h, 0A0h, 000h, 0A5h, 05Fh, 0F0h, 004h, 0A5h, 05Dh ; F710
DB 091h, 05Eh, 060h, 048h, 029h, 007h, 0AAh, 0BDh, 0B4h, 0EEh, 085h, 06Eh, 068h, 04Ah, 04Ah, 04Ah ; F720
DB 0AAh, 060h, 02Eh, 0B4h, 002h, 02Eh, 0B3h, 002h, 02Eh, 0B2h, 002h, 060h, 090h, 00Ch, 020h, 023h ; F730
DB 0F7h, 0BDh, 0A3h, 002h, 005h, 06Eh, 09Dh, 0A3h, 002h, 060h, 020h, 023h, 0F7h, 0A5h, 06Eh, 049h ; F740
DB 0FFh, 03Dh, 0A3h, 002h, 09Dh, 0A3h, 002h, 060h, 0A5h, 054h, 018h, 069h, 078h, 020h, 023h, 0F7h ; F750
DB 018h, 0BDh, 0A3h, 002h, 025h, 06Eh, 0F0h, 001h, 038h, 060h, 0ADh, 0FAh, 002h, 0A4h, 057h, 0C0h ; F760
DB 00Eh, 0B0h, 017h, 0C0h, 00Ch, 0B0h, 004h, 0C0h, 003h, 0B0h, 00Fh, 02Ah, 02Ah, 02Ah, 02Ah, 029h ; F770
DB 003h, 0AAh, 0ADh, 0FAh, 002h, 029h, 09Fh, 01Dh, 04Dh, 0FBh, 08Dh, 0FBh, 002h, 060h, 0A6h, 06Ah ; F780
DB 0CAh, 086h, 069h, 086h, 067h, 0A9h, 0B0h, 085h, 068h, 0A9h, 0D8h, 085h, 066h, 0A6h, 054h, 0E8h ; F790
DB 0ECh, 0BFh, 002h, 0F0h, 0E8h, 0A0h, 027h, 0B1h, 068h, 091h, 066h, 088h, 010h, 0F9h, 038h, 0A5h ; F7A0
DB 068h, 085h, 066h, 0E9h, 028h, 085h, 068h, 0A5h, 069h, 085h, 067h, 0E9h, 000h, 085h, 069h, 04Ch ; F7B0
DB 09Fh, 0F7h, 008h, 0A0h, 016h, 098h, 020h, 05Ah, 0F7h, 008h, 098h, 018h, 069h, 079h, 028h, 020h ; F7C0
DB 03Ch, 0F7h, 088h, 030h, 004h, 0C4h, 054h, 0B0h, 0ECh, 0A5h, 054h, 018h, 069h, 078h, 028h, 04Ch ; F7D0
DB 03Ch, 0F7h, 0A5h, 052h, 085h, 055h, 020h, 0ACh, 0F5h, 038h, 0A5h, 053h, 0E5h, 052h, 0A8h, 0A9h ; F7E0
DB 000h, 091h, 064h, 088h, 010h, 0FBh, 060h, 020h, 032h, 0F7h, 0ADh, 06Eh, 002h, 0F0h, 028h, 0ADh ; F7F0
DB 06Ch, 002h, 0D0h, 0FBh, 0A9h, 008h, 08Dh, 06Ch, 002h, 0ADh, 06Ch, 002h, 0C9h, 001h, 0D0h, 0F9h ; F800
DB 0ADh, 00Bh, 0D4h, 0C9h, 040h, 0B0h, 0F9h, 0A2h, 00Dh, 0ADh, 0BFh, 002h, 0C9h, 004h, 0D0h, 002h ; F810
DB 0A2h, 070h, 0ECh, 00Bh, 0D4h, 0B0h, 0FBh, 020h, 0A6h, 0F9h, 0A5h, 064h, 0A6h, 065h, 0E8h, 0E4h ; F820
DB 06Ah, 0F0h, 006h, 038h, 0E9h, 010h, 04Ch, 02Eh, 0F8h, 069h, 027h, 0D0h, 00Ah, 0A6h, 065h, 0E8h ; F830
DB 0E4h, 06Ah, 0F0h, 038h, 018h, 069h, 010h, 0A8h, 085h, 07Eh, 038h, 0A5h, 064h, 0E5h, 07Eh, 085h ; F840
DB 064h, 0B0h, 002h, 0C6h, 065h, 0A5h, 064h, 018h, 069h, 028h, 085h, 07Eh, 0A5h, 065h, 069h, 000h ; F850
DB 085h, 07Fh, 0B1h, 07Eh, 091h, 064h, 0C8h, 0D0h, 0F9h, 0A0h, 010h, 0A5h, 064h, 0C9h, 0D8h, 0F0h ; F860
DB 00Bh, 018h, 069h, 0F0h, 085h, 064h, 090h, 0DDh, 0E6h, 065h, 0D0h, 0D9h, 0A6h, 06Ah, 0CAh, 086h ; F870
DB 07Fh, 0A2h, 0D8h, 086h, 07Eh, 0A9h, 000h, 0A0h, 027h, 091h, 07Eh, 088h, 010h, 0FBh, 0A9h, 000h ; F880
DB 085h, 063h, 0A5h, 054h, 085h, 051h, 0A5h, 051h, 020h, 05Ah, 0F7h, 0B0h, 00Ch, 0A5h, 063h, 018h ; F890
DB 069h, 028h, 085h, 063h, 0C6h, 051h, 04Ch, 096h, 0F8h, 018h, 0A5h, 063h, 065h, 055h, 085h, 063h ; F8A0
DB 060h, 020h, 04Ch, 0F9h, 0A5h, 063h, 048h, 0A5h, 06Ch, 085h, 054h, 0A5h, 06Dh, 085h, 055h, 0A9h ; F8B0
DB 001h, 085h, 06Bh, 0A2h, 017h, 0A5h, 07Bh, 010h, 002h, 0A2h, 003h, 0E4h, 054h, 0D0h, 00Bh, 0A5h ; F8C0
DB 055h, 0C5h, 053h, 0D0h, 005h, 0E6h, 06Bh, 04Ch, 0EAh, 0F8h, 020h, 00Ah, 0F6h, 0E6h, 06Bh, 0A5h ; F8D0
DB 063h, 0C5h, 052h, 0D0h, 0DEh, 0C6h, 054h, 020h, 000h, 0F4h, 020h, 08Fh, 0F1h, 0D0h, 017h, 0C6h ; F8E0
DB 06Bh, 0A5h, 063h, 0C5h, 052h, 0F0h, 00Fh, 020h, 000h, 0F4h, 0A5h, 055h, 0C5h, 053h, 0D0h, 002h ; F8F0
DB 0C6h, 054h, 0A5h, 06Bh, 0D0h, 0E4h, 068h, 085h, 063h, 04Ch, 057h, 0F9h, 020h, 08Eh, 0F8h, 0A5h ; F900
DB 051h, 085h, 06Ch, 0A5h, 052h, 085h, 06Dh, 060h, 0A5h, 063h, 0C5h, 052h, 0D0h, 002h, 0C6h, 054h ; F910
DB 020h, 08Eh, 0F8h, 0A5h, 063h, 0C5h, 052h, 0F0h, 0EEh, 020h, 0ACh, 0F5h, 0A5h, 053h, 038h, 0E5h ; F920
DB 052h, 0A8h, 0B1h, 064h, 0D0h, 0E1h, 088h, 010h, 0F9h, 04Ch, 027h, 0F5h, 0A2h, 02Dh, 0BDh, 00Dh ; F930
DB 0FBh, 0CDh, 0FBh, 002h, 0F0h, 005h, 0CAh, 0CAh, 0CAh, 010h, 0F3h, 060h, 0A2h, 002h, 0B5h, 054h ; F940
DB 09Dh, 0B8h, 002h, 0CAh, 010h, 0F8h, 060h, 0A2h, 002h, 0BDh, 0B8h, 002h, 095h, 054h, 0CAh, 010h ; F950
DB 0F8h, 060h, 0ADh, 0BFh, 002h, 0C9h, 018h, 0F0h, 017h, 0A2h, 00Bh, 0B5h, 054h, 048h, 0BDh, 090h ; F960
DB 002h, 095h, 054h, 068h, 09Dh, 090h, 002h, 0CAh, 010h, 0F1h, 0A5h, 07Bh, 049h, 0FFh, 085h, 07Bh ; F970
DB 04Ch, 01Eh, 0F2h, 0A2h, 07Eh, 048h, 08Eh, 01Fh, 0D0h, 0ADh, 00Bh, 0D4h, 0CDh, 00Bh, 0D4h, 0F0h ; F980
DB 0FBh, 0CAh, 0CAh, 010h, 0F1h, 068h, 060h, 0A9h, 000h, 0A6h, 07Bh, 0D0h, 004h, 0A6h, 057h, 0D0h ; F990
DB 002h, 0A5h, 052h, 085h, 055h, 060h, 0A5h, 058h, 085h, 064h, 0A5h, 059h, 085h, 065h, 060h, 0A2h ; F9A0
DB 000h, 0A5h, 022h, 0C9h, 011h, 0F0h, 008h, 0C9h, 012h, 0F0h, 003h, 0A0h, 084h, 060h, 0E8h, 08Eh ; F9B0
DB 0B7h, 002h, 0A5h, 054h, 08Dh, 0F5h, 002h, 0A5h, 055h, 08Dh, 0F6h, 002h, 0A5h, 056h, 08Dh, 0F7h ; F9C0
DB 002h, 0A9h, 001h, 08Dh, 0F8h, 002h, 08Dh, 0F9h, 002h, 038h, 0ADh, 0F5h, 002h, 0E5h, 05Ah, 085h ; F9D0
DB 076h, 0B0h, 00Eh, 0A9h, 0FFh, 08Dh, 0F8h, 002h, 0A5h, 076h, 049h, 0FFh, 018h, 069h, 001h, 085h ; F9E0
DB 076h, 038h, 0ADh, 0F6h, 002h, 0E5h, 05Bh, 085h, 077h, 0ADh, 0F7h, 002h, 0E5h, 05Ch, 085h, 078h ; F9F0
DB 0B0h, 017h, 0A9h, 0FFh, 08Dh, 0F9h, 002h, 0A5h, 077h, 049h, 0FFh, 085h, 077h, 0A5h, 078h, 049h ; FA00
DB 0FFh, 085h, 078h, 0E6h, 077h, 0D0h, 002h, 0E6h, 078h, 0A2h, 002h, 0A0h, 000h, 084h, 073h, 098h ; FA10
DB 095h, 070h, 0B5h, 05Ah, 095h, 054h, 0CAh, 010h, 0F6h, 0A5h, 077h, 0E8h, 0A8h, 0A5h, 078h, 085h ; FA20
DB 07Fh, 085h, 075h, 0D0h, 00Bh, 0A5h, 077h, 0C5h, 076h, 0B0h, 005h, 0A5h, 076h, 0A2h, 002h, 0A8h ; FA30
DB 098h, 085h, 07Eh, 085h, 074h, 048h, 0A5h, 075h, 04Ah, 068h, 06Ah, 095h, 070h, 0A5h, 07Eh, 005h ; FA40
DB 07Fh, 0D0h, 003h, 04Ch, 001h, 0FBh, 018h, 0A5h, 070h, 065h, 076h, 085h, 070h, 090h, 002h, 0E6h ; FA50
DB 071h, 0A5h, 071h, 0C5h, 075h, 090h, 015h, 0D0h, 006h, 0A5h, 070h, 0C5h, 074h, 090h, 00Dh, 018h ; FA60
DB 0A5h, 054h, 06Dh, 0F8h, 002h, 085h, 054h, 0A2h, 000h, 020h, 0AEh, 0F6h, 018h, 0A5h, 072h, 065h ; FA70
DB 077h, 085h, 072h, 0A5h, 073h, 065h, 078h, 085h, 073h, 0C5h, 075h, 090h, 028h, 0D0h, 006h, 0A5h ; FA80
DB 072h, 0C5h, 074h, 090h, 020h, 02Ch, 0F9h, 002h, 010h, 010h, 0C6h, 055h, 0A5h, 055h, 0C9h, 0FFh ; FA90
DB 0D0h, 00Eh, 0A5h, 056h, 0F0h, 00Ah, 0C6h, 056h, 010h, 006h, 0E6h, 055h, 0D0h, 002h, 0E6h, 056h ; FAA0
DB 0A2h, 002h, 020h, 0AEh, 0F6h, 020h, 0CAh, 0F6h, 020h, 0CAh, 0F1h, 0ADh, 0B7h, 002h, 0F0h, 02Fh ; FAB0
DB 020h, 04Ch, 0F9h, 0ADh, 0FBh, 002h, 08Dh, 0BCh, 002h, 0A5h, 054h, 048h, 020h, 012h, 0F6h, 068h ; FAC0
DB 085h, 054h, 020h, 0CAh, 0F6h, 020h, 08Fh, 0F1h, 0D0h, 00Ch, 0ADh, 0FDh, 002h, 08Dh, 0FBh, 002h ; FAD0
DB 020h, 0CAh, 0F1h, 04Ch, 0C9h, 0FAh, 0ADh, 0BCh, 002h, 08Dh, 0FBh, 002h, 020h, 057h, 0F9h, 038h ; FAE0
DB 0A5h, 07Eh, 0E9h, 001h, 085h, 07Eh, 0A5h, 07Fh, 0E9h, 000h, 085h, 07Fh, 030h, 003h, 04Ch, 04Dh ; FAF0
DB 0FAh, 04Ch, 01Eh, 0F2h, 000h, 001h, 003h, 007h, 028h, 0CAh, 094h, 046h, 000h, 01Bh, 0E0h, 0F3h ; FB00
DB 01Ch, 0E6h, 0F3h, 01Dh, 0F3h, 0F3h, 01Eh, 000h, 0F4h, 01Fh, 011h, 0F4h, 07Dh, 020h, 0F4h, 07Eh ; FB10
DB 050h, 0F4h, 07Fh, 07Ah, 0F4h, 09Bh, 061h, 0F6h, 09Ch, 020h, 0F5h, 09Dh, 00Ch, 0F5h, 09Eh, 09Ah ; FB20
DB 0F4h, 09Fh, 095h, 0F4h, 0FDh, 056h, 0F5h, 0FEh, 0D5h, 0F4h, 0FFh, 09Fh, 0F4h, 01Ch, 040h, 0F4h ; FB30
DB 01Dh, 05Fh, 0F5h, 01Eh, 01Bh, 0F4h, 01Fh, 00Ah, 0F4h, 040h, 000h, 020h, 060h, 020h, 040h, 000h ; FB40
DB 060h, 06Ch, 06Ah, 03Bh, 08Ah, 08Bh, 06Bh, 02Bh, 02Ah, 06Fh, 080h, 070h, 075h, 09Bh, 069h, 02Dh ; FB50
DB 03Dh, 076h, 080h, 063h, 08Ch, 08Dh, 062h, 078h, 07Ah, 034h, 080h, 033h, 036h, 01Bh, 035h, 032h ; FB60
DB 031h, 02Ch, 020h, 02Eh, 06Eh, 080h, 06Dh, 02Fh, 081h, 072h, 080h, 065h, 079h, 07Fh, 074h, 077h ; FB70
DB 071h, 039h, 080h, 030h, 037h, 07Eh, 038h, 03Ch, 03Eh, 066h, 068h, 064h, 080h, 082h, 067h, 073h ; FB80
DB 061h, 04Ch, 04Ah, 03Ah, 08Ah, 08Bh, 04Bh, 05Ch, 05Eh, 04Fh, 080h, 050h, 055h, 09Bh, 049h, 05Fh ; FB90
DB 07Ch, 056h, 080h, 043h, 08Ch, 08Dh, 042h, 058h, 05Ah, 024h, 080h, 023h, 026h, 01Bh, 025h, 022h ; FBA0
DB 021h, 05Bh, 020h, 05Dh, 04Eh, 080h, 04Dh, 03Fh, 081h, 052h, 080h, 045h, 059h, 09Fh, 054h, 057h ; FBB0
DB 051h, 028h, 080h, 029h, 027h, 09Ch, 040h, 07Dh, 09Dh, 046h, 048h, 044h, 080h, 083h, 047h, 053h ; FBC0
DB 041h, 00Ch, 00Ah, 07Bh, 080h, 080h, 00Bh, 01Eh, 01Fh, 00Fh, 080h, 010h, 015h, 09Bh, 009h, 01Ch ; FBD0
DB 01Dh, 016h, 080h, 003h, 089h, 080h, 002h, 018h, 01Ah, 080h, 080h, 085h, 080h, 01Bh, 080h, 0FDh ; FBE0
DB 080h, 000h, 020h, 060h, 00Eh, 080h, 00Dh, 080h, 081h, 012h, 080h, 005h, 019h, 09Eh, 014h, 017h ; FBF0
DB 011h, 080h, 080h, 080h, 080h, 0FEh, 080h, 07Dh, 0FFh, 006h, 008h, 004h, 080h, 084h, 007h, 013h ; FC00
DB 001h, 01Ch, 01Dh, 01Eh, 01Fh, 08Eh, 08Fh, 090h, 091h, 08Ah, 048h, 098h, 048h, 0ACh, 001h, 0D3h ; FC10
DB 0ADh, 009h, 0D2h, 0CDh, 0F2h, 002h, 0D0h, 005h, 0AEh, 0F1h, 002h, 0D0h, 049h, 0AEh, 06Dh, 002h ; FC20
DB 0C9h, 083h, 0D0h, 013h, 08Ah, 049h, 0FFh, 08Dh, 06Dh, 002h, 0D0h, 005h, 098h, 009h, 004h, 0D0h ; FC30
DB 003h, 098h, 029h, 0FBh, 0A8h, 0B0h, 026h, 08Ah, 0D0h, 03Dh, 0ADh, 009h, 0D2h, 0AAh, 0C9h, 09Fh ; FC40
DB 0D0h, 00Ah, 0ADh, 0FFh, 002h, 049h, 0FFh, 08Dh, 0FFh, 002h, 0B0h, 011h, 029h, 03Fh, 0C9h, 011h ; FC50
DB 0D0h, 02Eh, 08Eh, 0DCh, 002h, 0F0h, 006h, 08Eh, 0FCh, 002h, 08Eh, 0F2h, 002h, 0A9h, 003h, 08Dh ; FC60
DB 0F1h, 002h, 0A9h, 000h, 085h, 04Dh, 0ADh, 0D9h, 002h, 08Dh, 02Bh, 002h, 0ADh, 02Fh, 002h, 0D0h ; FC70
DB 006h, 0ADh, 0DDh, 002h, 08Dh, 02Fh, 002h, 08Ch, 001h, 0D3h, 068h, 0A8h, 068h, 0AAh, 068h, 040h ; FC80
DB 0E0h, 084h, 0F0h, 021h, 0E0h, 094h, 0D0h, 0CFh, 0ADh, 0F4h, 002h, 0AEh, 06Bh, 002h, 08Dh, 06Bh ; FC90
DB 002h, 08Eh, 0F4h, 002h, 0E0h, 0CCh, 0F0h, 006h, 098h, 009h, 008h, 0A8h, 0D0h, 0BFh, 098h, 029h ; FCA0
DB 0F7h, 0A8h, 04Ch, 06Dh, 0FCh, 0ADh, 02Fh, 002h, 0F0h, 0CDh, 08Dh, 0DDh, 002h, 0A9h, 000h, 08Dh ; FCB0
DB 02Fh, 002h, 0F0h, 0C3h, 048h, 0ADh, 0C6h, 002h, 04Dh, 04Fh, 000h, 02Dh, 04Eh, 000h, 08Dh, 00Ah ; FCC0
DB 0D4h, 08Dh, 017h, 0D0h, 068h, 040h, 000h, 000h, 04Ch, 083h, 0F9h, 0A9h, 0CCh, 08Dh, 0EEh, 002h ; FCD0
DB 0A9h, 005h, 08Dh, 0EFh, 002h, 060h, 0A5h, 02Bh, 085h, 03Eh, 0A5h, 02Ah, 029h, 00Ch, 0C9h, 004h ; FCE0
DB 0F0h, 005h, 0C9h, 008h, 0F0h, 03Eh, 060h, 0A9h, 000h, 08Dh, 089h, 002h, 085h, 03Fh, 0A9h, 001h ; FCF0
DB 020h, 0FCh, 0FDh, 030h, 029h, 0A9h, 034h, 08Dh, 002h, 0D3h, 0A6h, 062h, 0BCh, 093h, 0FEh, 0BDh ; FD00
DB 091h, 0FEh, 0AAh, 0A9h, 003h, 08Dh, 02Ah, 002h, 020h, 05Ch, 0E4h, 0ADh, 02Ah, 002h, 0D0h, 0FBh ; FD10
DB 0A9h, 080h, 085h, 03Dh, 08Dh, 08Ah, 002h, 04Ch, 077h, 0FDh, 0A0h, 080h, 0C6h, 011h, 0A9h, 000h ; FD20
DB 08Dh, 089h, 002h, 060h, 0A9h, 080h, 08Dh, 089h, 002h, 0A9h, 002h, 020h, 0FCh, 0FDh, 030h, 0EEh ; FD30
DB 0A9h, 0CCh, 08Dh, 004h, 0D2h, 0A9h, 005h, 08Dh, 006h, 0D2h, 0A9h, 060h, 08Dh, 000h, 003h, 020h ; FD40
DB 068h, 0E4h, 0A9h, 034h, 08Dh, 002h, 0D3h, 0A6h, 062h, 0BCh, 08Fh, 0FEh, 0BDh, 08Dh, 0FEh, 0AAh ; FD50
DB 0A9h, 003h, 020h, 05Ch, 0E4h, 0A9h, 0FFh, 08Dh, 02Ah, 002h, 0A5h, 011h, 0F0h, 0BCh, 0ADh, 02Ah ; FD60
DB 002h, 0D0h, 0F7h, 0A9h, 000h, 085h, 03Dh, 0A0h, 001h, 060h, 0A5h, 03Fh, 030h, 033h, 0A6h, 03Dh ; FD70
DB 0ECh, 08Ah, 002h, 0F0h, 008h, 0BDh, 000h, 004h, 0E6h, 03Dh, 0A0h, 001h, 060h, 0A9h, 052h, 020h ; FD80
DB 03Fh, 0FEh, 098h, 030h, 0F7h, 0A9h, 000h, 085h, 03Dh, 0A2h, 080h, 0ADh, 0FFh, 003h, 0C9h, 0FEh ; FD90
DB 0F0h, 00Dh, 0C9h, 0FAh, 0D0h, 003h, 0AEh, 07Fh, 004h, 08Eh, 08Ah, 002h, 04Ch, 07Ah, 0FDh, 0C6h ; FDA0
DB 03Fh, 0A0h, 088h, 060h, 0A6h, 03Dh, 09Dh, 000h, 004h, 0E6h, 03Dh, 0A0h, 001h, 0E0h, 07Fh, 0F0h ; FDB0
DB 001h, 060h, 0A9h, 0FCh, 020h, 07Ch, 0FEh, 0A9h, 000h, 085h, 03Dh, 060h, 0A0h, 001h, 060h, 0ADh ; FDC0
DB 089h, 002h, 030h, 008h, 0A0h, 001h, 0A9h, 03Ch, 08Dh, 002h, 0D3h, 060h, 0A6h, 03Dh, 0F0h, 00Ah ; FDD0
DB 08Eh, 07Fh, 004h, 0A9h, 0FAh, 020h, 07Ch, 0FEh, 030h, 0ECh, 0A2h, 07Fh, 0A9h, 000h, 09Dh, 000h ; FDE0
DB 004h, 0CAh, 010h, 0FAh, 0A9h, 0FEh, 020h, 07Ch, 0FEh, 04Ch, 0D6h, 0FDh, 085h, 040h, 0A5h, 014h ; FDF0
DB 018h, 0A6h, 062h, 07Dh, 095h, 0FEh, 0AAh, 0A9h, 0FFh, 08Dh, 01Fh, 0D0h, 0A9h, 000h, 0A0h, 0F0h ; FE00
DB 088h, 0D0h, 0FDh, 08Dh, 01Fh, 0D0h, 0A0h, 0F0h, 088h, 0D0h, 0FDh, 0E4h, 014h, 0D0h, 0E8h, 0C6h ; FE10
DB 040h, 0F0h, 00Eh, 08Ah, 018h, 0A6h, 062h, 07Dh, 097h, 0FEh, 0AAh, 0E4h, 014h, 0D0h, 0FCh, 0F0h ; FE20
DB 0CDh, 020h, 036h, 0FEh, 098h, 060h, 0ADh, 025h, 0E4h, 048h, 0ADh, 024h, 0E4h, 048h, 060h, 08Dh ; FE30
DB 002h, 003h, 0A9h, 000h, 08Dh, 009h, 003h, 0A9h, 083h, 08Dh, 008h, 003h, 0A9h, 003h, 08Dh, 005h ; FE40
DB 003h, 0A9h, 0FDh, 08Dh, 004h, 003h, 0A9h, 060h, 08Dh, 000h, 003h, 0A9h, 000h, 08Dh, 001h, 003h ; FE50
DB 0A9h, 023h, 08Dh, 006h, 003h, 0ADh, 002h, 003h, 0A0h, 040h, 0C9h, 052h, 0F0h, 002h, 0A0h, 080h ; FE60
DB 08Ch, 003h, 003h, 0A5h, 03Eh, 08Dh, 00Bh, 003h, 020h, 059h, 0E4h, 060h, 08Dh, 0FFh, 003h, 0A9h ; FE70
DB 055h, 08Dh, 0FDh, 003h, 08Dh, 0FEh, 003h, 0A9h, 057h, 020h, 03Fh, 0FEh, 060h, 004h, 003h, 080h ; FE80
DB 0C0h, 002h, 001h, 040h, 0E0h, 01Eh, 019h, 00Ah, 008h, 0A9h, 01Eh, 08Dh, 014h, 003h, 060h, 0EAh ; FE90
DB 002h, 0C0h, 003h, 0A9h, 004h, 08Dh, 0DFh, 002h, 0AEh, 09Fh, 0FEh, 0ACh, 0A0h, 0FEh, 0A9h, 053h ; FEA0
DB 08Dh, 002h, 003h, 08Dh, 00Ah, 003h, 020h, 014h, 0FFh, 020h, 059h, 0E4h, 030h, 003h, 020h, 044h ; FEB0
DB 0FFh, 060h, 020h, 0A3h, 0FEh, 0A9h, 000h, 08Dh, 0DEh, 002h, 060h, 048h, 0BDh, 041h, 003h, 085h ; FEC0
DB 021h, 020h, 04Bh, 0FFh, 0AEh, 0DEh, 002h, 068h, 09Dh, 0C0h, 003h, 0E8h, 0ECh, 0DFh, 002h, 0F0h ; FED0
DB 015h, 08Eh, 0DEh, 002h, 0C9h, 09Bh, 0F0h, 003h, 0A0h, 001h, 060h, 0A9h, 020h, 09Dh, 0C0h, 003h ; FEE0
DB 0E8h, 0ECh, 0DFh, 002h, 0D0h, 0F7h, 0A9h, 000h, 08Dh, 0DEh, 002h, 0AEh, 0A1h, 0FEh, 0ACh, 0A2h ; FEF0
DB 0FEh, 020h, 014h, 0FFh, 04Ch, 059h, 0E4h, 020h, 04Bh, 0FFh, 0A9h, 09Bh, 0AEh, 0DEh, 002h, 0D0h ; FF00
DB 0DCh, 0A0h, 001h, 060h, 08Eh, 004h, 003h, 08Ch, 005h, 003h, 0A9h, 040h, 08Dh, 000h, 003h, 0A5h ; FF10
DB 021h, 08Dh, 001h, 003h, 0A9h, 080h, 0AEh, 002h, 003h, 0E0h, 053h, 0D0h, 002h, 0A9h, 040h, 08Dh ; FF20
DB 003h, 003h, 0ADh, 0DFh, 002h, 08Dh, 008h, 003h, 0A9h, 000h, 08Dh, 009h, 003h, 0ADh, 014h, 003h ; FF30
DB 08Dh, 006h, 003h, 060h, 0ADh, 0ECh, 002h, 08Dh, 014h, 003h, 060h, 0A0h, 057h, 0A5h, 02Bh, 0C9h ; FF40
DB 04Eh, 0D0h, 004h, 0A2h, 028h, 0D0h, 00Eh, 0C9h, 044h, 0D0h, 004h, 0A2h, 014h, 0D0h, 006h, 0C9h ; FF50
DB 053h, 0D0h, 00Ch, 0A2h, 01Dh, 08Eh, 0DFh, 002h, 08Ch, 002h, 003h, 08Dh, 00Ah, 003h, 060h, 0A9h ; FF60
DB 04Eh, 0D0h, 0DCh, 0A2h, 000h, 086h, 08Bh, 086h, 08Ch, 020h, 0A9h, 0FFh, 0E0h, 00Ch, 0D0h, 0F9h ; FF70
DB 0ADh, 000h, 0C0h, 0AEh, 001h, 0C0h, 0C5h, 08Bh, 0D0h, 006h, 0E4h, 08Ch, 0D0h, 002h, 018h, 060h ; FF80
DB 038h, 060h, 0A2h, 000h, 086h, 08Bh, 086h, 08Ch, 0A2h, 00Ch, 020h, 0A9h, 0FFh, 020h, 0A9h, 0FFh ; FF90
DB 0ADh, 0F8h, 0FFh, 0AEh, 0F9h, 0FFh, 04Ch, 086h, 0FFh, 0A0h, 000h, 0BDh, 0D7h, 0FFh, 099h, 09Eh ; FFA0
DB 000h, 0E8h, 0C8h, 0C0h, 004h, 0D0h, 0F4h, 0A0h, 000h, 018h, 0B1h, 09Eh, 065h, 08Bh, 085h, 08Bh ; FFB0
DB 090h, 002h, 0E6h, 08Ch, 0E6h, 09Eh, 0D0h, 002h, 0E6h, 09Fh, 0A5h, 09Eh, 0C5h, 0A0h, 0D0h, 0E9h ; FFC0
DB 0A5h, 09Fh, 0C5h, 0A1h, 0D0h, 0E3h, 060h, 002h, 0C0h, 000h, 0D0h, 000h, 050h, 000h, 058h, 000h ; FFD0
DB 0D8h, 000h, 0E0h, 000h, 0E0h, 0F8h, 0FFh, 0FAh, 0FFh, 000h, 000h, 000h, 000h, 000h, 010h, 005h ; FFE0
DB 083h, 002h, 042h, 042h, 000h, 000h, 001h, 002h, 08Ch, 06Ch, 018h, 0C0h, 0AAh, 0C2h, 02Ch, 0C0h ; FFF0
END
| 107.910636
| 136
| 0.630221
|
10391ecc5420c241b3ee6a3596a990c8962ecf54
| 489
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/stdio/c/sccz80/fscanf.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/_DEVELOPMENT/stdio/c/sccz80/fscanf.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/_DEVELOPMENT/stdio/c/sccz80/fscanf.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
; int fscanf(FILE *stream, const char *format, ...)
INCLUDE "config_private.inc"
SECTION code_clib
SECTION code_stdio
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF __CLIB_OPT_MULTITHREAD & $02
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PUBLIC fscanf
EXTERN asm_fscanf
defc fscanf = asm_fscanf
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ELSE
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PUBLIC fscanf
EXTERN fscanf_unlocked
defc fscanf = fscanf_unlocked
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ENDIF
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
| 15.28125
| 51
| 0.474438
|
6bf77ddd39a88612f3cb72df35b8f97040dc5c64
| 4,453
|
asm
|
Assembly
|
src/state-story.asm
|
santiontanon/triton
|
b3f7374852e8bf3077f647a8abaf71bb4bcb9874
|
[
"Apache-2.0"
] | 41
|
2020-07-13T01:47:20.000Z
|
2022-03-31T07:04:54.000Z
|
src/state-story.asm
|
santiontanon/triton
|
b3f7374852e8bf3077f647a8abaf71bb4bcb9874
|
[
"Apache-2.0"
] | null | null | null |
src/state-story.asm
|
santiontanon/triton
|
b3f7374852e8bf3077f647a8abaf71bb4bcb9874
|
[
"Apache-2.0"
] | 3
|
2020-10-28T18:46:35.000Z
|
2022-01-09T21:20:15.000Z
|
story_cutscene_1_text:
db TEXT_CUTSCENE_1_1_BANK, #f0, TEXT_CUTSCENE_1_1_IDX
db #fe ; new line
db TEXT_CUTSCENE_1_2_BANK, #f0, TEXT_CUTSCENE_1_2_IDX
db TEXT_CUTSCENE_1_3_BANK, #f0, TEXT_CUTSCENE_1_3_IDX
db TEXT_CUTSCENE_1_4_BANK, #f0, TEXT_CUTSCENE_1_4_IDX
db #fe ; new line
db TEXT_CUTSCENE_1_5_BANK, #f0, TEXT_CUTSCENE_1_5_IDX
db #ff ; end of text
story_cutscene_2_text:
db TEXT_CUTSCENE_2_1_BANK, #f0, TEXT_CUTSCENE_2_1_IDX
db TEXT_CUTSCENE_2_2_BANK, #f0, TEXT_CUTSCENE_2_2_IDX
db #fe ; new line
db TEXT_CUTSCENE_2_3_BANK, #70, TEXT_CUTSCENE_2_3_IDX
db TEXT_CUTSCENE_2_4_BANK, #70, TEXT_CUTSCENE_2_4_IDX
db #fe ; new line
db TEXT_CUTSCENE_2_5_BANK, #70, TEXT_CUTSCENE_2_5_IDX
db #ff ; end of text
story_cutscene_2_sprite:
db 39,137,16,COLOR_BLUE
story_cutscene_3_text:
db TEXT_CUTSCENE_3_1_BANK, #70, TEXT_CUTSCENE_3_1_IDX
db #fe ; new line
db TEXT_CUTSCENE_3_2_BANK, #70, TEXT_CUTSCENE_3_2_IDX
db #fe ; new line
db TEXT_CUTSCENE_3_3_BANK, #70, TEXT_CUTSCENE_3_3_IDX
db #ff ; end of text
story_cutscene_4_text:
db TEXT_CUTSCENE_4_1_BANK, #f0, TEXT_CUTSCENE_4_1_IDX
db TEXT_CUTSCENE_4_2_BANK, #f0, TEXT_CUTSCENE_4_2_IDX
db #ff ; end of text
story_cutscene_5_text:
db TEXT_CUTSCENE_5_1_BANK, #90, TEXT_CUTSCENE_5_1_IDX
db #fe ; new line
db TEXT_CUTSCENE_5_2_BANK, #90, TEXT_CUTSCENE_5_2_IDX
db TEXT_CUTSCENE_5_3_BANK, #90, TEXT_CUTSCENE_5_3_IDX
db TEXT_CUTSCENE_5_4_BANK, #90, TEXT_CUTSCENE_5_4_IDX
db TEXT_CUTSCENE_5_5_BANK, #90, TEXT_CUTSCENE_5_5_IDX
db #fe ; new line
db TEXT_CUTSCENE_5_6_BANK, #90, TEXT_CUTSCENE_5_6_IDX
db #ff ; end of text
;-----------------------------------------------
state_story:
call disable_VDP_output
call setup_ui_gfx
ld hl,cutscene_gfx_plt
ld de,cutscene_gfx_buffer
call unpack_compressed
call enable_VDP_output
ld ix,decompress_story_song_from_page1
call call_from_page1
ld a,(isComputer50HzOr60Hz)
add a,a
add a,10 ; 10 if 50Hz, 12 if 60Hz
call PlayMusic
; scene 1:
ld iyh,24*8
ld hl,story_cutscene_1_text
ld de,CHRTBL2+(4*32+4)*8
call state_story_cutscene
call set_bitmap_mode
; scene 2:
ld hl,cutscene_gfx_buffer
call draw_cutscene_image
ld hl,story_cutscene_2_sprite
ld de,SPRATR2
ld bc,4
call fast_LDIRVM
ld hl,story_cutscene_2_text
ld de,CHRTBL2+(12*32+4)*8
call state_story_cutscene
ld hl,CHRTBL2+(12*32)*8
ld bc,32*7*8
xor a
call fast_FILVRM
; scene 3:
ld hl,story_cutscene_3_text
ld de,CHRTBL2+(12*32+4)*8
call state_story_cutscene
ld hl,CHRTBL2+(12*32)*8
ld bc,32*7*8
xor a
call fast_FILVRM
ld hl,SPRATR2
ld bc,4
xor a
call fast_FILVRM
ld hl,cutscene_gfx_buffer+6*12
call draw_cutscene_image
; scene 4:
ld hl,story_cutscene_4_text
ld de,CHRTBL2+(12*32+4)*8
call state_story_cutscene
ld hl,CHRTBL2+(12*32)*8
ld bc,32*7*8
xor a
call fast_FILVRM
ld hl,cutscene_gfx_buffer+6*12*2
call draw_cutscene_image
; scene 5:
ld hl,story_cutscene_5_text
ld de,CHRTBL2+(12*32+4)*8
call state_story_cutscene
call clearScreenLeftToRight
jp state_braingames_screen
;-----------------------------------------------
; de: pointer to draw
; hl: text lines
; iyh: line width
state_story_cutscene:
xor a
ld (text_skip),a
state_story_cutscene_loop:
ld a,(hl)
inc hl
cp #fe ; new line
jr z,state_story_cutscene_new_line
cp #ff
jr z,state_story_cutscene_done_with_text
ld c,a
ld a,(hl) ; color
ld iyl,a
inc hl
ld a,(hl)
inc hl
push hl
push de
push iy
ld b,iyh
call draw_text_from_bank_slow
pop iy
pop de
pop hl
state_story_cutscene_new_line:
ex de,hl
ld bc,32*8
add hl,bc
ex de,hl
jr state_story_cutscene_loop
state_story_cutscene_done_with_text:
ld c,0 ; time counter
state_story_loop:
halt
ld a,(interrupt_cycle)
and #01
jr nz,state_story_loop_continue
inc c
ret z
state_story_loop_continue:
push bc
call update_keyboard_buffers
pop bc
; wait a few seconds and skip to the menu:
ld a,(keyboard_line_clicks)
; bit 0,a
; jr z,state_story_loop
rra
jr nc,state_story_loop
ret
;-----------------------------------------------
draw_cutscene_image:
ld de,CHRTBL2+(4*32+10)*8
ld c,6
draw_cutscene_image_y_loop:
ld b,12
draw_cutscene_image_x_loop:
ld a,(hl)
inc hl
push bc
push hl
push de
call draw_tile_bitmap_mode_by_index
pop hl
ld bc,8
add hl,bc
ex de,hl
pop hl
pop bc
djnz draw_cutscene_image_x_loop
push bc
ex de,hl
ld bc,20*8
add hl,bc
ex de,hl
pop bc
dec c
jr nz,draw_cutscene_image_y_loop
ret
| 21.408654
| 54
| 0.744217
|
618b1812fa533178f60f3121466af6be93e99984
| 876
|
nasm
|
Assembly
|
MdePkg/Library/BaseLib/X64/WriteMsr64.nasm
|
kokweich/slimbootloader
|
6fd1141c75a33894e3a7937dbc55859e4a6dacae
|
[
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | 9
|
2021-07-26T17:02:51.000Z
|
2021-12-30T10:49:46.000Z
|
MdePkg/Library/BaseLib/X64/WriteMsr64.nasm
|
kokweich/slimbootloader
|
6fd1141c75a33894e3a7937dbc55859e4a6dacae
|
[
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | null | null | null |
MdePkg/Library/BaseLib/X64/WriteMsr64.nasm
|
kokweich/slimbootloader
|
6fd1141c75a33894e3a7937dbc55859e4a6dacae
|
[
"BSD-2-Clause-NetBSD",
"PSF-2.0",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"BSD-2-Clause-Patent"
] | null | null | null |
;------------------------------------------------------------------------------
;
; Copyright (c) 2006, Intel Corporation. All rights reserved.<BR>
; SPDX-License-Identifier: BSD-2-Clause-Patent
;
; Module Name:
;
; WriteMsr64.Asm
;
; Abstract:
;
; AsmWriteMsr64 function
;
; Notes:
;
;------------------------------------------------------------------------------
DEFAULT REL
SECTION .text
;------------------------------------------------------------------------------
; UINT64
; EFIAPI
; AsmWriteMsr64 (
; IN UINT32 Index,
; IN UINT64 Value
; );
;------------------------------------------------------------------------------
global ASM_PFX(AsmWriteMsr64)
ASM_PFX(AsmWriteMsr64):
mov rax, rdx ; meanwhile, rax <- return value
shr rdx, 0x20 ; edx:eax contains the value to write
wrmsr
ret
| 24.333333
| 79
| 0.388128
|
eb22f1d2a48c43e14f328175d9b273a8f4f3f043
| 8,704
|
asm
|
Assembly
|
arm/data_processing.asm
|
jsmolka/gba-suite
|
a6447c5404c8fc2898ddc51f438271f832083b7e
|
[
"MIT"
] | 31
|
2020-01-18T21:48:54.000Z
|
2021-01-08T11:17:56.000Z
|
arm/data_processing.asm
|
jsmolka/gba-suite
|
a6447c5404c8fc2898ddc51f438271f832083b7e
|
[
"MIT"
] | 8
|
2020-01-19T07:37:23.000Z
|
2020-11-10T17:09:24.000Z
|
arm/data_processing.asm
|
jsmolka/gba-tests
|
a6447c5404c8fc2898ddc51f438271f832083b7e
|
[
"MIT"
] | 6
|
2021-05-28T09:35:20.000Z
|
2021-12-22T18:09:32.000Z
|
data_processing:
; Tests for the data processing instruction
t200:
; ARM 3: Move
mov r0, 32
cmp r0, 32
bne f200
b t201
f200:
m_exit 200
t201:
; ARM 3: Move negative
mvn r0, 0
adds r0, 1
bne f201
b t202
f201:
m_exit 201
t202:
; ARM 3: And
mov r0, 0xFF
and r0, 0x0F
cmp r0, 0x0F
bne f202
b t203
f202:
m_exit 202
t203:
; ARM 3: Exclusive or
mov r0, 0xFF
eor r0, 0xF0
cmp r0, 0x0F
bne f203
b t204
f203:
m_exit 203
t204:
; ARM 3: Or
mov r0, 0xF0
orr r0, 0x0F
cmp r0, 0xFF
bne f204
b t205
f204:
m_exit 204
t205:
; ARM 3: Bit clear
mov r0, 0xFF
bic r0, 0x0F
cmp r0, 0xF0
bne f205
b t206
f205:
m_exit 205
t206:
; ARM 3: Add
mov r0, 32
add r0, 32
cmp r0, 64
bne f206
b t207
f206:
m_exit 206
t207:
; ARM 3: Add with carry
msr cpsr_f, 0
movs r0, 32
adc r0, 32
cmp r0, 64
bne f207
msr cpsr_f, FLAG_C
mov r0, 32
adc r0, 32
cmp r0, 65
bne f207
b t208
f207:
m_exit 207
t208:
; ARM 3: Subtract
mov r0, 64
sub r0, 32
cmp r0, 32
bne f208
b t209
f208:
m_exit 208
t209:
; ARM 3: Reverse subtract
mov r0, 32
rsb r0, 64
cmp r0, 32
bne f209
b t210
f209:
m_exit 209
t210:
; ARM 3: Subtract with carry
msr cpsr_f, 0
mov r0, 64
sbc r0, 32
cmp r0, 31
bne f210
msr cpsr_f, FLAG_C
mov r0, 64
sbc r0, 32
cmp r0, 32
bne f210
b t211
f210:
m_exit 210
t211:
; ARM 3: Reverse subtract with carry
msr cpsr_f, 0
mov r0, 32
rsc r0, 64
cmp r0, 31
bne f211
msr cpsr_f, FLAG_C
mov r0, 32
rsc r0, 64
cmp r0, 32
bne f211
b t212
f211:
m_exit 211
t212:
; ARM 3: Compare
mov r0, 32
cmp r0, r0
bne f212
b t213
f212:
m_exit 212
t213:
; ARM 3: Compare negative
mov r0, 1 shl 31
cmn r0, r0
bne f213
b t214
f213:
m_exit 213
t214:
; ARM 3: Test
mov r0, 0xF0
tst r0, 0x0F
bne f214
b t215
f214:
m_exit 214
t215:
; ARM 3: Test equal
mov r0, 0xFF
teq r0, 0xFF
bne f215
b t216
f215:
m_exit 215
t216:
; ARM 3: Operand types
mov r0, 0xFF00
mov r1, 0x00FF
mov r1, r1, lsl 8
cmp r1, r0
bne f216
b t217
f216:
m_exit 216
t217:
; ARM 3: Update carry for rotated immediate
movs r0, 0xF000000F
bcc f217
movs r0, 0x0FF00000
bcs f217
b t218
f217:
m_exit 217
t218:
; ARM 3: Update carry for rotated register
mov r0, 0xFF
mov r1, 4
movs r2, r0, ror r1
bcc f218
mov r0, 0xF0
mov r1, 4
movs r2, r0, ror r1
bcs f218
b t219
f218:
m_exit 218
t219:
; ARM 3: Update carry for rotated register
mov r0, 0xFF
movs r1, r0, ror 4
bcc f219
mov r0, 0xF0
movs r1, r0, ror 4
bcs f219
b t220
f219:
m_exit 219
t220:
; ARM 3: Register shift special
mov r0, 0
msr cpsr_f, FLAG_C
movs r0, r0, rrx
bcs f220
cmp r0, 1 shl 31
bne f220
b t221
f220:
m_exit 220
t221:
; ARM 3: PC as operand
add r0, pc, 4
cmp r0, pc
bne f221
b t222
f221:
m_exit 221
t222:
; ARM 3: PC as destination
adr r0, t223
mov pc, r0
f222:
m_exit 222
t223:
; ARM 3: PC as destination with S bit
mov r8, 32
msr cpsr, MODE_FIQ
mov r8, 64
msr spsr, MODE_SYS
subs pc, 4
cmp r8, 32
bne f223
b t224
f223:
m_exit 223
t224:
; ARM 3: PC as shifted register
mov r0, 0
dw 0xE1A0001F ; mov r0, pc, lsl r0
cmp r0, pc
bne f224
b t225
f224:
m_exit 224
t225:
; ARM 3: PC as operand 1 with shifted register
mov r0, 0
dw 0xE08F0010 ; add r0, pc, r0, lsl r0
cmp r0, pc
bne f225
b t226
f225:
m_exit 225
t226:
; ARM 3: PC as operand 1 with shifted register with immediate shift amount
mov r0, 0
mov r2, lr
bl .get_pc
.get_pc:
mov r1, lr
mov lr, r2
add r0, pc, r0
add r1, 16
cmp r1, r0
bne f226
b t227
f226:
m_exit 226
t227:
; ARM 3: Rotated immediate logical operation
msr cpsr_f, 0
movs r0, 0x80000000
bcc f227
bpl f227
b t228
f227:
m_exit 227
t228:
; ARM 3: Rotated immediate arithmetic operation
msr cpsr_f, FLAG_C
mov r0, 0
adcs r0, 0x80000000
cmp r0, 0x80000001
bne f228
msr cpsr_f, FLAG_C
mov r0, 0
adcs r0, 0x70000000
cmp r0, 0x70000001
bne f228
b t229
f228:
m_exit 228
t229:
; ARM 3: Immediate shift logical operation
msr cpsr_f, 0
mov r0, 0x80
movs r0, r0, ror 8
bcc f229
bpl f229
b t230
f229:
m_exit 229
t230:
; ARM 3: Immediate shift arithmetic operation
msr cpsr_f, FLAG_C
mov r0, 0
mov r1, 0x80
adcs r0, r1, ror 8
cmp r0, 0x80000001
bne f230
msr cpsr_f, FLAG_C
mov r0, 0
mov r1, 0x70
adcs r0, r1, ror 8
cmp r0, 0x70000001
bne f230
b t231
f230:
m_exit 230
t231:
; ARM 3: Register shift logical operation
msr cpsr_f, 0
mov r0, 0x80
mov r1, 8
movs r0, r0, ror r1
bcc f231
bpl f231
b t232
f231:
m_exit 231
t232:
; ARM 3: Register shift arithmetic operation
msr cpsr_f, FLAG_C
mov r0, 0
mov r1, 0x80
mov r2, 8
adcs r0, r1, ror r2
cmp r0, 0x80000001
bne f232
msr cpsr_f, FLAG_C
mov r0, 0
mov r1, 0x70
mov r2, 8
adcs r0, r1, ror r2
cmp r0, 0x70000001
bne f232
b t233
f232:
m_exit 232
t233:
; ARM 3: TST / TEQ setting flags during shifts
msr cpsr_f, 0
tst r0, 0x80000000
bcc f233
msr cpsr_f, 0
teq r0, 0x80000000
bcc f233
b t234
f233:
m_exit 233
t234:
; ARM 3: Bad CMP / CMN / TST / TEQ change the mode
mov r8, 32
msr cpsr, MODE_FIQ
mov r8, 64
msr spsr, MODE_SYS
dw 0xE15FF000 ; cmp pc, pc
nop
nop
beq f234
cmp r8, 32
bne f234
b t235
f234:
m_exit 234
t235:
; ARM 3: Bad CMP / CMN / TST / TEQ do not flush the pipeline
mov r8, 0
dw 0xE15FF000 ; cmp pc, pc
mov r8, 1
nop
cmp r8, 0
beq f235
b data_processing_passed
f235:
m_exit 235
data_processing_passed:
| 17.066667
| 82
| 0.413833
|
a3997912c63c64e0ce536d744118b2da08dd577e
| 128
|
asm
|
Assembly
|
test/br3392442.asm
|
bitwiseworks/nasm-os2
|
ef78e4ee1ca3220ac3b60a61b084a693b8032ab6
|
[
"BSD-2-Clause"
] | 1
|
2020-06-20T07:35:25.000Z
|
2020-06-20T07:35:25.000Z
|
3rdParties/src/nasm/nasm-2.15.02/test/br3392442.asm
|
blue3k/StormForge
|
1557e699a673ae9adcc8f987868139f601ec0887
|
[
"Apache-2.0"
] | 1
|
2020-03-26T19:58:54.000Z
|
2020-04-24T08:58:04.000Z
|
test/br3392442.asm
|
bitwiseworks/nasm-os2
|
ef78e4ee1ca3220ac3b60a61b084a693b8032ab6
|
[
"BSD-2-Clause"
] | null | null | null |
;; Bug report 3392442: invalid warning
and byte [0], ~80h
and byte [0], 0xfff
and byte [0], -256
and byte [0], -257
| 18.285714
| 40
| 0.59375
|
379b9f6b6aa9b44201696bb90bc8e408e9349767
| 1,208
|
asm
|
Assembly
|
programs/oeis/122/A122709.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/122/A122709.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/122/A122709.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A122709: a(0)=1; thereafter a(n) = 9*n-3.
; 1,6,15,24,33,42,51,60,69,78,87,96,105,114,123,132,141,150,159,168,177,186,195,204,213,222,231,240,249,258,267,276,285,294,303,312,321,330,339,348,357,366,375,384,393,402,411,420,429,438,447,456,465,474,483,492,501,510,519,528,537,546,555,564,573,582,591,600,609,618,627,636,645,654,663,672,681,690,699,708,717,726,735,744,753,762,771,780,789,798,807,816,825,834,843,852,861,870,879,888,897,906,915,924,933,942,951,960,969,978,987,996,1005,1014,1023,1032,1041,1050,1059,1068,1077,1086,1095,1104,1113,1122,1131,1140,1149,1158,1167,1176,1185,1194,1203,1212,1221,1230,1239,1248,1257,1266,1275,1284,1293,1302,1311,1320,1329,1338,1347,1356,1365,1374,1383,1392,1401,1410,1419,1428,1437,1446,1455,1464,1473,1482,1491,1500,1509,1518,1527,1536,1545,1554,1563,1572,1581,1590,1599,1608,1617,1626,1635,1644,1653,1662,1671,1680,1689,1698,1707,1716,1725,1734,1743,1752,1761,1770,1779,1788,1797,1806,1815,1824,1833,1842,1851,1860,1869,1878,1887,1896,1905,1914,1923,1932,1941,1950,1959,1968,1977,1986,1995,2004,2013,2022,2031,2040,2049,2058,2067,2076,2085,2094,2103,2112,2121,2130,2139,2148,2157,2166,2175,2184,2193,2202,2211,2220,2229,2238
mul $0,9
mov $1,$0
trn $1,4
add $1,1
| 151
| 1,125
| 0.760762
|
be09ccdda75f5aa1a89ec8bd8eed792c3cf1720d
| 303
|
asm
|
Assembly
|
programs/oeis/139/A139782.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/139/A139782.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/139/A139782.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A139782: Binomial transform of A077947.
; 1,2,5,15,46,139,417,1250,3749,11247,33742,101227,303681,911042,2733125,8199375,24598126,73794379,221383137,664149410,1992448229,5977344687,17932034062,53796102187,161388306561,484164919682,1452494759045
mov $1,3
pow $1,$0
sub $1,1
mul $1,4
div $1,7
add $1,1
| 30.3
| 204
| 0.788779
|
5f8173ceeeb57ae3a0a784a8abd001f63879bbd1
| 216
|
asm
|
Assembly
|
lab09/1-hello-world/hello-world.asm
|
adinasm/iocla-demos
|
a4109ed9fd3a34b097299f941617a6380267c003
|
[
"MIT"
] | null | null | null |
lab09/1-hello-world/hello-world.asm
|
adinasm/iocla-demos
|
a4109ed9fd3a34b097299f941617a6380267c003
|
[
"MIT"
] | null | null | null |
lab09/1-hello-world/hello-world.asm
|
adinasm/iocla-demos
|
a4109ed9fd3a34b097299f941617a6380267c003
|
[
"MIT"
] | null | null | null |
%include "../utils/printf32.asm"
section .data
msg db 'Hello, world!', 0
section .text
extern puts
global main
main:
push ebp
mov ebp, esp
push msg
call puts
add esp, 4
leave
ret
| 10.8
| 32
| 0.606481
|
36c3fecd0bbacef654e54211cef57a87b7e1c359
| 1,125
|
asm
|
Assembly
|
programs/oeis/255/A255527.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/255/A255527.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/255/A255527.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A255527: Where records occur in A255437.
; 1,2,3,6,7,8,9,13,14,15,16,17,18,23,24,25,26,27,28,29,30,36,37,38,39,40,41,42,43,44,45,52,53,54,55,56,57,58,59,60,61,62,63,71,72,73,74,75,76,77,78,79,80,81,82,83,84,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,377,378,379,380,381,382,383,384,385
mov $1,1
mov $3,$0
lpb $0
add $2,1
sub $0,$2
add $0,1
sub $0,$2
trn $0,1
add $1,$2
lpe
trn $1,2
lpb $3
add $1,1
sub $3,1
lpe
add $1,1
| 56.25
| 930
| 0.698667
|
f39536b0e650fd2ae3cdaa12b49ea7a6bfc5ca63
| 148
|
asm
|
Assembly
|
other.7z/SFC.7z/SFC/ソースデータ/MarioKart/c-select-j.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
other.7z/SFC.7z/SFC/ソースデータ/MarioKart/c-select-j.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
other.7z/SFC.7z/SFC/ソースデータ/MarioKart/c-select-j.asm
|
prismotizm/gigaleak
|
d082854866186a05fec4e2fdf1def0199e7f3098
|
[
"MIT"
] | null | null | null |
Name: c-select-j.asm
Type: file
Size: 46127
Last-Modified: '1992-07-14T15:00:00Z'
SHA-1: 0CA16B7F3743209D4B70D98F6BD379E3FA26F779
Description: null
| 21.142857
| 47
| 0.804054
|
df93e161ac0f4a1c9227a4dc1d428350bc752d70
| 779
|
asm
|
Assembly
|
programs/oeis/103/A103325.asm
|
ckrause/cm
|
0021b6ca0be0fbe79164e647ddfd0e65869304fe
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/103/A103325.asm
|
ckrause/cm
|
0021b6ca0be0fbe79164e647ddfd0e65869304fe
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/103/A103325.asm
|
ckrause/cm
|
0021b6ca0be0fbe79164e647ddfd0e65869304fe
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A103325: Fifth powers of Lucas numbers.
; 32,1,243,1024,16807,161051,1889568,20511149,229345007,2535525376,28153056843,312079600999,3461619737632,38387392786601,425733547012443,4721411479245824,52361450147627807,580696556856146851,6440026990881070368,71420978989035821749,792070857155636444407,8784200148092074597376,97418273585889659238243,1080385204934384542976399,11981655547597815947366432,132878596144917080887174801,1473646213495792518277165443,16342986943098614252491777024,181246502593934738225898738007,2010054515449463958486865974251,22291846172652059575513328839968,247220362414139117337154778826749,2741715832730228379386061687619007,30406094522437984172224469966334976,337208755579584768776394528178768443
seq $0,258160 ; a(n) = 8*Lucas(n).
pow $0,5
div $0,32768
| 111.285714
| 678
| 0.907574
|
5311ec1630acee80abddb9eee9246ecc8a0a3132
| 706
|
asm
|
Assembly
|
oeis/345/A345368.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/345/A345368.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/345/A345368.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A345368: a(n) = Sum_{k=0..n} binomial(5*k,k) / (4*k + 1).
; 1,2,7,42,327,2857,26608,258488,2588933,26539288,277082658,2936050788,31494394563,341325970323,3731742758203,41108999917483,455850863463768,5084213586320193,56997201842602368,641906808539396253,7258985455500009623,82393287049581399283,938361765591288616333,10719680133897784047733,122804240480765419931908,1410475938881559404643913,16238697480787429704015193,187366605058972690401871593,2166304097345429870708093393,25094058702998072091966038193,291199722674027551690860554593
mov $3,$0
mov $5,$0
lpb $5
mov $0,$3
sub $5,1
sub $0,$5
mov $2,4
mul $2,$0
add $0,$2
bin $0,$2
add $2,1
div $0,$2
add $4,$0
lpe
mov $0,$4
add $0,1
| 35.3
| 477
| 0.78187
|
54b352e8237ded2a265c794f4486b834ef49f56b
| 517
|
asm
|
Assembly
|
data/baseStats/eevee.asm
|
etdv-thevoid/pokemon-rgb-enhanced
|
5b244c1cf46aab98b9c820d1b7888814eb7fa53f
|
[
"MIT"
] | 1
|
2022-01-09T05:28:52.000Z
|
2022-01-09T05:28:52.000Z
|
data/baseStats/eevee.asm
|
ETDV-TheVoid/pokemon-rgb-enhanced
|
5b244c1cf46aab98b9c820d1b7888814eb7fa53f
|
[
"MIT"
] | null | null | null |
data/baseStats/eevee.asm
|
ETDV-TheVoid/pokemon-rgb-enhanced
|
5b244c1cf46aab98b9c820d1b7888814eb7fa53f
|
[
"MIT"
] | null | null | null |
db EEVEE ; pokedex id
db 55 ; base hp
db 55 ; base attack
db 55 ; base defense
db 55 ; base speed
db 55 ; base special
db NORMAL ; species type 1
db NORMAL ; species type 2
db 45 ; catch rate
db 92 ; base exp yield
INCBIN "pic/gsmon/eevee.pic",0,1 ; 55, sprite dimensions
dw EeveePicFront
dw EeveePicBack
; attacks known at lvl 0
db TACKLE
db TAIL_WHIP
db 0
db 0
db 0 ; growth rate
; learnset
tmlearn 3,6,8
tmlearn 9,10
tmlearn 20
tmlearn 28,31,32
tmlearn 33,34,39
tmlearn 44
tmlearn 50
db BANK(EeveePicFront)
| 17.827586
| 56
| 0.733075
|
d45e8b18ba7ca178806395a4b3690b2af82012cf
| 1,649
|
asm
|
Assembly
|
bddisasm_test/basic/aes_64.asm
|
andreaswimmer/bddisasm
|
960e9eaeee4f87d8269095031cd6cfb8aabb998b
|
[
"Apache-2.0"
] | 675
|
2020-07-09T12:57:49.000Z
|
2022-03-26T15:03:53.000Z
|
bddisasm_test/basic/aes_64.asm
|
andreaswimmer/bddisasm
|
960e9eaeee4f87d8269095031cd6cfb8aabb998b
|
[
"Apache-2.0"
] | 41
|
2020-07-22T07:15:07.000Z
|
2022-03-23T08:34:28.000Z
|
bddisasm_test/basic/aes_64.asm
|
andreaswimmer/bddisasm
|
960e9eaeee4f87d8269095031cd6cfb8aabb998b
|
[
"Apache-2.0"
] | 94
|
2020-07-09T14:39:02.000Z
|
2022-03-27T10:37:03.000Z
|
bits 64
; legacy, reg - reg
aesimc xmm7, xmm13
aesenc xmm7, xmm13
aesenclast xmm7, xmm13
aesdec xmm7, xmm13
aesdeclast xmm7, xmm13
aeskeygenassist xmm7, xmm13, 10
; legacy, reg - mem
aesimc xmm7, [rbx]
aesenc xmm7, [rbx]
aesenclast xmm7, [rbx]
aesdec xmm7, [rbx]
aesdeclast xmm7, [rbx]
aeskeygenassist xmm7, [rbx], 10
; VEX, reg - reg - reg, 128 bit
vaesimc xmm7, xmm13
vaesenc xmm7, xmm15, xmm13
vaesenclast xmm7, xmm15, xmm13
vaesdec xmm7, xmm15, xmm13
vaesdeclast xmm7, xmm15, xmm13
vaeskeygenassist xmm7, xmm13, 10
; VEX, reg - reg - mem, 128 bit
vaesimc xmm7, [rbx]
vaesenc xmm7, xmm15, [rbx]
vaesenclast xmm7, xmm15, [rbx]
vaesdec xmm7, xmm15, [rbx]
vaesdeclast xmm7, xmm15, [rbx]
vaeskeygenassist xmm7, [rbx], 10
; VEX, reg - reg - reg, 256 bit
vaesenc ymm7, ymm15, ymm13
vaesenclast ymm7, ymm15, ymm13
vaesdec ymm7, ymm15, ymm13
vaesdeclast ymm7, ymm15, ymm13
; VEX reg - reg - mem, 256 bit
vaesenc ymm7, ymm15, [rbx]
vaesenclast ymm7, ymm15, [rbx]
vaesdec ymm7, ymm15, [rbx]
vaesdeclast ymm7, ymm15, [rbx]
; EVEX, reg - reg - reg, 512 bit
vaesenc zmm7, zmm31, zmm13
vaesenclast zmm7, zmm31, zmm13
vaesdec zmm7, zmm31, zmm13
vaesdeclast zmm7, zmm31, zmm13
; EVEX reg - reg - mem, 512 bit
vaesenc zmm7, zmm31, [rbx]
vaesenclast zmm7, zmm31, [rbx]
vaesdec zmm7, zmm31, [rbx]
vaesdeclast zmm7, zmm31, [rbx]
| 28.929825
| 38
| 0.579745
|
cbf4b4693bb748f8ea76ebdb9b42cd97075ec9e4
| 3,105
|
asm
|
Assembly
|
deps/gmp.js/mpn/x86_64/aorsmul_1.asm
|
6un9-h0-Dan/cobaul
|
11115a7a77924d6e1642f847c613efb25f217e56
|
[
"MIT"
] | 184
|
2020-04-15T14:28:37.000Z
|
2020-09-22T15:57:55.000Z
|
deps/gmp.js/mpn/x86_64/aorsmul_1.asm
|
6un9-h0-Dan/cobaul
|
11115a7a77924d6e1642f847c613efb25f217e56
|
[
"MIT"
] | 3
|
2020-09-22T18:09:12.000Z
|
2021-11-27T22:37:52.000Z
|
deps/gmp.js/mpn/x86_64/aorsmul_1.asm
|
6un9-h0-Dan/cobaul
|
11115a7a77924d6e1642f847c613efb25f217e56
|
[
"MIT"
] | 5
|
2020-04-21T19:50:23.000Z
|
2020-09-22T10:58:02.000Z
|
dnl AMD64 mpn_addmul_1 and mpn_submul_1.
dnl Copyright 2003, 2004, 2005, 2007, 2008 Free Software Foundation, Inc.
dnl This file is part of the GNU MP Library.
dnl The GNU MP Library is free software; you can redistribute it and/or modify
dnl it under the terms of the GNU Lesser General Public License as published
dnl by the Free Software Foundation; either version 3 of the License, or (at
dnl your option) any later version.
dnl The GNU MP Library is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
dnl or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
dnl License for more details.
dnl You should have received a copy of the GNU Lesser General Public License
dnl along with the GNU MP Library. If not, see http://www.gnu.org/licenses/.
include(`../config.m4')
C cycles/limb
C K8,K9: 2.5
C K10: 2.5
C P4: 14.9
C P6 core2: 5.09
C P6 corei7:
C P6 atom: 21.3
C The inner loop of this code is the result of running a code generation and
C optimization tool suite written by David Harvey and Torbjorn Granlund.
C TODO:
C * The inner loop is great, but the prologue and epilogue code was
C quickly written. Tune it!
C INPUT PARAMETERS
define(`rp', `%rdi')
define(`up', `%rsi')
define(`n_param',`%rdx')
define(`vl', `%rcx')
define(`n', `%r11')
ifdef(`OPERATION_addmul_1',`
define(`ADDSUB', `add')
define(`func', `mpn_addmul_1')
')
ifdef(`OPERATION_submul_1',`
define(`ADDSUB', `sub')
define(`func', `mpn_submul_1')
')
MULFUNC_PROLOGUE(mpn_addmul_1 mpn_submul_1)
ASM_START()
TEXT
ALIGN(16)
PROLOGUE(func)
mov (up), %rax C read first u limb early
push %rbx
mov n_param, %rbx C move away n from rdx, mul uses it
mul vl
mov %rbx, %r11
and $3, R32(%rbx)
jz L(b0)
cmp $2, R32(%rbx)
jz L(b2)
jg L(b3)
L(b1): dec n
jne L(gt1)
ADDSUB %rax, (rp)
jmp L(ret)
L(gt1): lea 8(up,n,8), up
lea -8(rp,n,8), rp
neg n
xor %r10, %r10
xor R32(%rbx), R32(%rbx)
mov %rax, %r9
mov (up,n,8), %rax
mov %rdx, %r8
jmp L(L1)
L(b0): lea (up,n,8), up
lea -16(rp,n,8), rp
neg n
xor %r10, %r10
mov %rax, %r8
mov %rdx, %rbx
jmp L(L0)
L(b3): lea -8(up,n,8), up
lea -24(rp,n,8), rp
neg n
mov %rax, %rbx
mov %rdx, %r10
jmp L(L3)
L(b2): lea -16(up,n,8), up
lea -32(rp,n,8), rp
neg n
xor %r8, %r8
xor R32(%rbx), R32(%rbx)
mov %rax, %r10
mov 24(up,n,8), %rax
mov %rdx, %r9
jmp L(L2)
ALIGN(16)
L(top): ADDSUB %r10, (rp,n,8)
adc %rax, %r9
mov (up,n,8), %rax
adc %rdx, %r8
mov $0, %r10d
L(L1): mul vl
ADDSUB %r9, 8(rp,n,8)
adc %rax, %r8
adc %rdx, %rbx
L(L0): mov 8(up,n,8), %rax
mul vl
ADDSUB %r8, 16(rp,n,8)
adc %rax, %rbx
adc %rdx, %r10
L(L3): mov 16(up,n,8), %rax
mul vl
ADDSUB %rbx, 24(rp,n,8)
mov $0, %r8d # zero
mov %r8, %rbx # zero
adc %rax, %r10
mov 24(up,n,8), %rax
mov %r8, %r9 # zero
adc %rdx, %r9
L(L2): mul vl
add $4, n
js L(top)
ADDSUB %r10, (rp,n,8)
adc %rax, %r9
adc %r8, %rdx
ADDSUB %r9, 8(rp,n,8)
L(ret): adc $0, %rdx
mov %rdx, %rax
pop %rbx
ret
EPILOGUE()
| 20.838926
| 79
| 0.641868
|
2e9bb6662f97e68562e3504e62b6924aa3cb03ea
| 6,365
|
asm
|
Assembly
|
Driver/Socket/EtherLink/etherUtil.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 504
|
2018-11-18T03:35:53.000Z
|
2022-03-29T01:02:51.000Z
|
Driver/Socket/EtherLink/etherUtil.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 96
|
2018-11-19T21:06:50.000Z
|
2022-03-06T10:26:48.000Z
|
Driver/Socket/EtherLink/etherUtil.asm
|
steakknife/pcgeos
|
95edd7fad36df400aba9bab1d56e154fc126044a
|
[
"Apache-2.0"
] | 73
|
2018-11-19T20:46:53.000Z
|
2022-03-29T00:59:26.000Z
|
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
Copyright (c) Tedious Endeavors 1998 -- All Rights Reserved
PROJECT: Native ethernet support
MODULE: Ethernet driver
FILE: etherUtil.asm
AUTHOR: Todd Stumpf, July 8th, 1998
ROUTINES:
Name Description
---- -----------
AddConnection adds a connection entry to InfoResource
RemoveConnection removes a conncetion entry from InfoResource
FindConnection find a connection entry in InfoResource
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 07/08/98 Initial revision
DESCRIPTION:
Utilities for handling connections.
$Id:$
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
EtherCode segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
AddConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Adds a connection entry to EtherInfoResource
CALLED BY: INTERNAL
PASS: ds -> EtherInfoResource segment
bx -> local IP port #
dx -> remote IP port #
RETURN: ax <- connection chunk handle
ds:si <- connection entry fptr
DESTROYED: nothing
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 6/24/98 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
AddConnection proc near
uses bx, cx
.enter
;
; Allocate a connection entry
;
mov cx, size EtherConnection
clr al
call LMemAlloc ; ax <- new chunk handle
mov bx, ax ; bx = new chunk handle
mov si, ds:[bx]
clr ds:[si].EC_connectionSem
clr ds:[si].EC_status
mov ds:[si].EC_localPort, bx
mov ds:[si].EC_remotePort, dx
clr ds:[si].EC_remoteConnection
;
; Add the entry to connection list atomically
;
pushf
INT_OFF
xchg bx, ds:[EIH_connection]
mov ds:[si].EC_next, bx
popf
.leave
ret
AddConnection endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
RemoveConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Removes a connection entry from EtherInfoResource
CALLED BY: INTERNAL
PASS: bx -> connection handle
RETURN: carry set if connection entry was not found
DESTROYED: bx
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 6/24/98 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
RemoveConnection proc near
uses ax, di, si, ds
.enter
;
; Find the connection, given its handle
;
push bx ; save connection handle
mov bx, handle EtherInfoResource
call MemLockShared ; ax <- segment of EIR
mov ds, ax
pop bx ; restore connection handle
call FindConnection ; ds:si <- connection entry
; ds:di <- field to remove conn. handle
jc done ; => Which connection?
;
; Unlink the connection entry from list...
;
mov ax, ds:[si].EC_next
xchg ax, ds:[di] ; ax = connection handle to remove
;
; ... then remove it from the block
;
call LMemFree
mov bx, handle EtherInfoResource
call MemUnlockShared
clc
done:
.leave
ret
RemoveConnection endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
FindConnection
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Finds a connection entry
CALLED BY: INTERNAL
PASS: bx -> connection handle
ds -> EtherInfoResource segment
RETURN: carry set if not found
otherwise
ds:si <- connection entry
ds:di <- memory location that contains the connection
handle( for removal )
DESTROYED: nothing
SIDE EFFECTS:
PSEUDO CODE/STRATEGY:
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 6/28/98 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
FindConnection proc near
.enter
mov di, offset EIH_connection
mov si, ds:[di]
findLoop:
;
; di = mem location that contains a connection handle
; si = connection handle in ds:[di]
; bx = connection handle to find
;
tst si
jz notFound
cmp si, bx
mov si, ds:[si] ; deref connection handle
je found
mov di, si
add di, offset EC_next
mov si, ds:[si].EC_next ; next connection handle
jmp findLoop
notFound:
stc
found:
.leave
ret
FindConnection endp
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
DestroyAllConnections
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Destroy all existing connections
CALLED BY: EtherUnregister
PASS: es = dgroup
ds = EtherInfoResource segment
RETURN: nothing
DESTROYED: nothing
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 6/28/98 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
DestroyAllConnections proc near
uses ax,si
.enter
removeLoop:
;
; Make sure there's something left...
mov si, ds:[EIH_connection]
tst si
jz done ; => No more...
call RemoveConnection
jmp removeLoop
done:
clr ds:[EIH_connection]
.leave
ret
DestroyAllConnections endp
EtherCode ends
ResidentCode segment resource
COMMENT @%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
EtherNewThread
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
SYNOPSIS: Call client entry routine with a new thread
CALLED BY: SCOIndication_newThread macro
PASS: cx = RegisterSetStruct mem handle
RETURN: never
DESTROYED: nothing
REVISION HISTORY:
Name Date Description
---- ---- -----------
TDS 7/8/98 Initial version
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%@
EtherNewThread proc far
mov bx, cx
push bx
call MemLock
mov ds, ax
push ds:RSS_ds, ds:RSS_bx, ds:RSS_es
mov ax, ds:RSS_ax
mov cx, ds:RSS_cx
mov dx, ds:RSS_dx
mov bp, ds:RSS_bp
mov di, ds:RSS_di
mov si, ds:RSS_si
call MemUnlock
pop ds, bx, es
SCOIndication
pop bx
call MemFree
clr cx, dx, bp, si
jmp ThreadDestroy
EtherNewThread endp
ResidentCode ends
| 23.574074
| 79
| 0.531186
|
2445d4a547c1779858b8a3f4d6b103bdbb63593e
| 793
|
asm
|
Assembly
|
programs/oeis/214/A214848.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/214/A214848.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/214/A214848.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A214848: First difference of A022846.
; 1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,1,2,1,2,1,2
mov $4,2
mov $5,$0
lpb $4,1
mov $0,$5
sub $4,1
add $0,$4
pow $0,2
mov $3,0
lpb $0,1
sub $0,$3
trn $0,1
add $3,1
lpe
mov $2,$4
mov $6,$3
lpb $2,1
mov $1,$6
sub $2,1
lpe
lpe
lpb $5,1
sub $1,$6
mov $5,0
lpe
| 28.321429
| 501
| 0.495586
|
4ed116f0c2d66a418a62e4c778c6992d2218b9fc
| 680
|
asm
|
Assembly
|
src/modules/engines/gl_common/shader/font_frag_s3c6410.asm
|
tizenorg/framework.uifw.evas
|
be359fde3762e4ea90a1d11ac5840302c20e1b12
|
[
"BSD-2-Clause"
] | 1
|
2016-10-20T06:19:11.000Z
|
2016-10-20T06:19:11.000Z
|
src/modules/engines/gl_common/shader/font_frag_s3c6410.asm
|
tizenorg/framework.uifw.evas
|
be359fde3762e4ea90a1d11ac5840302c20e1b12
|
[
"BSD-2-Clause"
] | null | null | null |
src/modules/engines/gl_common/shader/font_frag_s3c6410.asm
|
tizenorg/framework.uifw.evas
|
be359fde3762e4ea90a1d11ac5840302c20e1b12
|
[
"BSD-2-Clause"
] | null | null | null |
#-------------------------------------------------
# ORION - OpenGL ES 2.0 Shading Language Compiler
# SAMSUNG INDIA SOFTWARE OPERATIONS PVT. LTD.
# Compiler Version : v04.00.09
# Release Date : 19.01.2009
# FIMG VERSION : FIMGv1.5
# Optimizer Options : -O --nolodcalc
#-------------------------------------------------
# hand optimised - removed useless ops
ps_3_0
fimg_version 0x01020000
dcl_s2_tex s0
dcl_f4_col v1.x
dcl_f2_tex_c v0.x
label start
label main_
texld r0.xyzw, v0.xyzw, s0 # tex=s0
mul_sat oColor.xyzw, r0.wwww, v1.xyzw # gl_FragColor=oColor.xyzw, col=v1.xyzw
label main_end
ret
# 4 instructions, 4 C regs, 1 R regs
| 25.185185
| 79
| 0.591176
|
9f98dc9f3b3081c89e7a362dbbcd6c6e23c644d1
| 380
|
asm
|
Assembly
|
oeis/118/A118538.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/118/A118538.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/118/A118538.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A118538: a(n) = A000040(n+1) - 6.
; Submitted by Jon Maiga
; -3,-1,1,5,7,11,13,17,23,25,31,35,37,41,47,53,55,61,65,67,73,77,83,91,95,97,101,103,107,121,125,131,133,143,145,151,157,161,167,173,175,185,187,191,193,205,217,221,223,227,233,235,245,251,257,263,265,271,275,277,287,301,305,307,311,325,331,341,343,347
seq $0,298252 ; Even integers n such that n-3 is prime.
sub $0,9
| 54.285714
| 252
| 0.689474
|
f390fa8b5fd6ab7b143be696cce9a9642d92722f
| 714
|
asm
|
Assembly
|
programs/oeis/111/A111406.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/111/A111406.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/111/A111406.asm
|
jmorken/loda
|
99c09d2641e858b074f6344a352d13bc55601571
|
[
"Apache-2.0"
] | null | null | null |
; A111406: a(n) = f(f(n+1)) - f(f(n)), where f(m) = pi(m) = A000720(m), with f(0) = 0.
; 0,0,1,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0
cal $0,78442 ; a(p) = a(n) + 1 if p is the n-th prime, prime(n); a(n)=0 if n is not prime.
lpb $0
sub $0,3
mov $1,1
lpe
| 79.333333
| 501
| 0.504202
|
000741cb53d2ce08b68fb09221aad7b60cdc584c
| 1,374
|
asm
|
Assembly
|
kernel/kernel.asm
|
paulscottrobson/MZ-Compiler
|
6f992844f6f447fbaf65569e3c70fb7dfc086b7e
|
[
"MIT"
] | null | null | null |
kernel/kernel.asm
|
paulscottrobson/MZ-Compiler
|
6f992844f6f447fbaf65569e3c70fb7dfc086b7e
|
[
"MIT"
] | null | null | null |
kernel/kernel.asm
|
paulscottrobson/MZ-Compiler
|
6f992844f6f447fbaf65569e3c70fb7dfc086b7e
|
[
"MIT"
] | null | null | null |
; ***************************************************************************************
; ***************************************************************************************
;
; Name : kernel.asm
; Author : Paul Robson (paul@robsons.org.uk)
; Date : 8th November 2018
; Purpose : MZ Kernel
;
; ***************************************************************************************
; ***************************************************************************************
StackTop = $7EF0 ; Top of stack
DictionaryPage = $20 ; dictionary page
FirstCodePage = $22
opt zxnextreg
org $8000
jr Boot
org $8004
dw SystemInformation
Boot: ld sp,(SIStack) ; reset Z80 Stack
di ; enable interrupts
nextreg 7,2 ; set turbo port (7) to 2 (14Mhz)
call SetMode48k ; initialise and clear screen.
ld a,(SIBootCodePage) ; get the page to start
nextreg $56,a
inc a
nextreg $57,a
dec a
ex af,af' ; set the current code page in A'
ld hl,(SIBootCodeAddress)
jp (hl)
include "support/multiply.asm" ; support functions
include "support/divide.asm"
include "support/keyboard.asm"
AlternateFont:
include "font.inc"
include "__words.asm"
include "data.asm"
org $C000
db 0 ; start of dictionary, which is empty.
| 27.48
| 89
| 0.44687
|
5fade819e8e9c2ad3be76b459c84dbbb4216cee0
| 364
|
asm
|
Assembly
|
programs/oeis/172/A172022.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/172/A172022.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/172/A172022.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A172022: a(n) = prime(n) + (-1)^n.
; 1,4,4,8,10,14,16,20,22,30,30,38,40,44,46,54,58,62,66,72,72,80,82,90,96,102,102,108,108,114,126,132,136,140,148,152,156,164,166,174,178,182,190,194,196,200,210,224,226,230,232,240,240,252,256,264,268,272,276
mov $1,$0
mul $0,2
mod $0,4
seq $1,40 ; The prime numbers.
sub $1,$0
mov $2,$1
add $2,1
add $2,$0
add $0,$2
sub $0,2
| 26
| 208
| 0.634615
|
116773d5c4af6a93eec90c7b69799815c09fb836
| 1,032
|
asm
|
Assembly
|
libsrc/cpc/sprites/cpc_PutMaskSp_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 640
|
2017-01-14T23:33:45.000Z
|
2022-03-30T11:28:42.000Z
|
libsrc/cpc/sprites/cpc_PutMaskSp_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 1,600
|
2017-01-15T16:12:02.000Z
|
2022-03-31T12:11:12.000Z
|
libsrc/cpc/sprites/cpc_PutMaskSp_callee.asm
|
jpoikela/z88dk
|
7108b2d7e3a98a77de99b30c9a7c9199da9c75cb
|
[
"ClArtistic"
] | 215
|
2017-01-17T10:43:03.000Z
|
2022-03-23T17:25:02.000Z
|
;
; Amstrad CPC library
;
; ******************************************************
; ** Librería de rutinas para Amstrad CPC **
; ** Raúl Simarro, Artaburu 2009 **
; ******************************************************
;
; void cpc_PutMaskSp(int *sprite, char *alto, char *ancho, int *posicion);
;
; $Id: cpc_PutMaskSp_callee.asm $
;
SECTION code_clib
PUBLIC cpc_PutMaskSp_callee
PUBLIC _cpc_PutMaskSp_callee
EXTERN cpc_PutMaskSp0
EXTERN ancho_m0
EXTERN suma_siguiente_linea_m0
.cpc_PutMaskSp_callee
._cpc_PutMaskSp_callee
; dibujar en pantalla el sprite
; Entradas bc-> Alto Ancho
; de-> origen
; hl-> destino
; Se alteran hl, bc, de, af
pop hl ; ret addr
pop de
pop bc ; ancho
ld a,c
ld (ancho_m0+1),a ;actualizo rutina de captura
dec a
cpl
ld (suma_siguiente_linea_m0+1),a ;comparten los 2 los mismos valores.
pop bc ; alto
ld a,c
ex (sp),hl
ex de,hl
jp cpc_PutMaskSp0
| 19.471698
| 81
| 0.554264
|
589c460eefe584c5a3e47e433778bb1845f3df17
| 2,300
|
asm
|
Assembly
|
libvpx/build/asm_enc_offsets.asm
|
ooyanglinoo/Plugin_Videoplayer
|
a4c00a9a4e7291364316ef22e8f3aaf0851d593a
|
[
"BSD-2-Clause"
] | 4
|
2017-02-25T15:50:39.000Z
|
2021-04-13T21:10:42.000Z
|
libvpx/build/asm_enc_offsets.asm
|
Aboutdept/Plugin_Videoplayer
|
b2f823f4b3b58a8fb63f31015e98bc65c7d8365d
|
[
"BSD-2-Clause"
] | null | null | null |
libvpx/build/asm_enc_offsets.asm
|
Aboutdept/Plugin_Videoplayer
|
b2f823f4b3b58a8fb63f31015e98bc65c7d8365d
|
[
"BSD-2-Clause"
] | 6
|
2017-05-10T15:22:20.000Z
|
2021-04-13T21:11:01.000Z
|
vp8_block_coeff EQU 8
vp8_block_zbin EQU 40
vp8_block_round EQU 56
vp8_block_quant EQU 16
vp8_block_quant_fast EQU 24
vp8_block_zbin_extra EQU 64
vp8_block_zrun_zbin_boost EQU 48
vp8_block_quant_shift EQU 32
vp8_blockd_qcoeff EQU 0
vp8_blockd_dequant EQU 24
vp8_blockd_dqcoeff EQU 8
vp8_blockd_eob EQU 40
vp8_block_base_src EQU 72
vp8_block_src EQU 80
vp8_block_src_diff EQU 0
vp8_block_src_stride EQU 84
vp8_blockd_predictor EQU 16
vp8_writer_lowvalue EQU 0
vp8_writer_range EQU 4
vp8_writer_count EQU 8
vp8_writer_pos EQU 12
vp8_writer_buffer EQU 16
vp8_writer_buffer_end EQU 24
vp8_writer_error EQU 32
tokenextra_token EQU 10
tokenextra_extra EQU 8
tokenextra_context_tree EQU 0
tokenextra_skip_eob_node EQU 11
TOKENEXTRA_SZ EQU 16
vp8_extra_bit_struct_sz EQU 24
vp8_token_value EQU 0
vp8_token_len EQU 4
vp8_extra_bit_struct_tree EQU 0
vp8_extra_bit_struct_prob EQU 8
vp8_extra_bit_struct_len EQU 16
vp8_extra_bit_struct_base_val EQU 20
vp8_comp_tplist EQU 173104
vp8_comp_common EQU 105920
vp8_comp_bc EQU 118400
vp8_writer_sz EQU 48
tokenlist_start EQU 0
tokenlist_stop EQU 8
TOKENLIST_SZ EQU 16
vp8_common_mb_rows EQU 2536
END
| 50
| 52
| 0.435217
|
5ccc9508316bb1b1f9304e8dcaf329af6371bf5c
| 501
|
asm
|
Assembly
|
oeis/346/A346618.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/346/A346618.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/346/A346618.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A346618: Triangle read by rows: T(n,k) = 1 iff 2 divides binomial(n,k) but 4 does not (0 <= k <= n).
; Submitted by Christian Krause
; 0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,0,0,0,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,1,0,0,0,0,0,1,0,0,1,0,1,0,0,1,0,0,0,0,0,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0
seq $0,34931 ; Triangle, read by rows, formed by reading Pascal's triangle (A007318) mod 4.
seq $0,124758 ; Product of the parts of the compositions in standard order.
sub $0,1
| 62.625
| 187
| 0.628743
|
cf3a6c515d0fc84110608b12d2b25b581292bc68
| 712
|
asm
|
Assembly
|
oeis/212/A212509.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/212/A212509.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/212/A212509.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A212509: Number of (w,x,y,z) with all terms in {1,...,n} and w<2x and y<=3z.
; Submitted by Christian Krause
; 0,1,12,63,180,437,891,1628,2736,4392,6600,9646,13608,18669,24990,32955,42432,54033,67797,84010,102900,125118,150282,179444,212544,249977,292032,339687,392196,451165,516375,588336,667392,754908,849660,953922,1067256,1190293,1323426,1468467,1623600,1791881,1972593,2166494,2374020,2597490,2834382,3088648,3359232,3647025,3952500,4278543,4621812,4987269,5373459,5781412,6211632,6667632,7145136,7650230,8181000,8738621,9323622,9940203,10583040,11259457,11967021,12707058,13480116,14291142,15133650
sub $1,$0
pow $0,2
mov $2,$0
add $0,1
div $0,2
add $0,$2
bin $1,2
div $2,3
add $1,$2
mul $0,$1
div $0,2
| 44.5
| 495
| 0.773876
|
7376d0f43598c68f606813003920e09937da13fc
| 243
|
asm
|
Assembly
|
programs/oeis/017/A017431.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/017/A017431.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/017/A017431.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A017431: (11n+3)^7.
; 2187,105413504,6103515625,78364164096,506623120463,2207984167552,7446353252589,20971520000000,51676101935731,114868566764928,235260548044817,450766669594624,817215093984375,1414067010444416
mul $0,11
add $0,3
pow $0,7
| 34.714286
| 191
| 0.839506
|
cb82806b52c8f046feb94582f800dfdd63af2492
| 10,227
|
asm
|
Assembly
|
vbox/src/VBox/ValidationKit/bootsectors/bootsector2-cpu-a20-1.asm
|
Nurzamal/rest_api_docker
|
a9cc01dfc235467d490d9663755b33ef6990bdd8
|
[
"MIT"
] | null | null | null |
vbox/src/VBox/ValidationKit/bootsectors/bootsector2-cpu-a20-1.asm
|
Nurzamal/rest_api_docker
|
a9cc01dfc235467d490d9663755b33ef6990bdd8
|
[
"MIT"
] | null | null | null |
vbox/src/VBox/ValidationKit/bootsectors/bootsector2-cpu-a20-1.asm
|
Nurzamal/rest_api_docker
|
a9cc01dfc235467d490d9663755b33ef6990bdd8
|
[
"MIT"
] | null | null | null |
; $Id: bootsector2-cpu-a20-1.asm 69111 2017-10-17 14:26:02Z vboxsync $
;; @file
; Bootsector that checks the A20 emulation.
;
;
; Copyright (C) 2007-2017 Oracle Corporation
;
; This file is part of VirtualBox Open Source Edition (OSE), as
; available from http://www.virtualbox.org. This file is free software;
; you can redistribute it and/or modify it under the terms of the GNU
; General Public License (GPL) as published by the Free Software
; Foundation, in version 2 as it comes in the "COPYING" file of the
; VirtualBox OSE distribution. VirtualBox OSE is distributed in the
; hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
;
; The contents of this file may alternatively be used under the terms
; of the Common Development and Distribution License Version 1.0
; (CDDL) only, as it comes in the "COPYING.CDDL" file of the
; VirtualBox OSE distribution, in which case the provisions of the
; CDDL are applicable instead of those of the GPL.
;
; You may elect to license modified versions of this file under the
; terms and conditions of either the GPL or the CDDL or both.
;
%include "iprt/asmdefs.mac"
%include "iprt/x86.mac"
%include "VBox/VMMDevTesting.mac"
;
; Include and execute the init code.
;
%define BS2_WITH_TRAPS
%define BS2_INIT_RM
%define BS2_INC_PE16
%define BS2_INC_PE32
%define BS2_INC_PP32
%define BS2_INC_PAE32
%define BS2_INC_LM64
%include "bootsector2-common-init-code.mac"
;
; The benchmark driver
;
BEGINPROC main
;
; Test prologue.
;
mov ax, .s_szTstName
call TestInit_r86
;
; The actual tests.
;
call TestA20_1 ; must come first
call TestA20_rm_rm
;call TestA20_rm_pe16
call TestA20_rm_pe32
call TestA20_rm_pp32
;call TestA20_rm_pp16
call TestA20_rm_pae32
call TestA20_rm_lm64
;
; We're done.
;
call TestTerm_r86
call Bs2Panic
.s_szTstName:
db 'tstA20-1', 0
.s_szInitialA20Status:
db 'Initial A20 state', 0
ENDPROC main
;
; Do some initial tests.
;
BEGINPROC TestA20_1
push eax
push edx
push ecx
push ebx
push edi
;
; Check that the A20 gate is disabled when we come from the BIOS.
;
mov ax, .s_szInitialA20Status
call TestSub_r86
call IsA20GateEnabled_rm
mov di, ax ; save A20 state in AX for bios test.
cmp al, 0
je .initial_state_done
mov ax, .s_szBadInitialA20Status
call TestFailed_r86
jmp .initial_state_done
.s_szInitialA20Status:
db 'Initial A20 state', 0
.s_szBadInitialA20Status:
db 'Initial A20 state is enabled, expected disabled', 10, 13, 0
.initial_state_done:
call TestSubDone_r86
;
; Disable it via the BIOS interface and check.
;
mov ax, .s_szBios
call TestSub_r86
; query support
mov ax, 2403h
int 15h
jnc .bios_2403_ok
movzx edx, ax
mov ax, .s_szBios2403Error
mov cl, VMMDEV_TESTING_UNIT_NONE
call TestValueU32_r86
jmp .bios_2403_done
.bios_2403_ok:
movzx edx, al
mov ax, .s_szBios2403Mask
mov cl, VMMDEV_TESTING_UNIT_NONE
call TestValueU32_r86
.bios_2403_done:
; Check what the bios thinks the state is.
call BiosIsA20GateEnabled_rm
cmp ax, di
je .bios_2402_done
push di
push ax
push word ds
push word .s_szBios2402Error
call TestFailedF_r86
add sp, 8
.bios_2402_done:
; Loop to make sure we get all transitions and ends up with A20 disabled.
mov cx, 10h
.bios_loop:
; enable it
mov ax, 2401h
push cx ; paranoia that seems necessary for at least one AMI bios.
int 15h
pop cx
jnc .bios_continue1
mov ax, .s_szBiosFailed2401
jmp .bios_failed
.bios_continue1:
call IsA20GateEnabled_rm
cmp al, 1
je .bios_continue2
mov ax, .s_szBiosEnableFailed
jmp .bios_failed
.bios_continue2:
; disable
mov ax, 2400h
push cx ; paranoia that seems necessary for at least one AMI bios.
int 15h
pop cx
jnc .bios_continue3
mov ax, .s_szBiosFailed2400
jmp .bios_failed
.bios_continue3:
call IsA20GateEnabled_rm
cmp al, 0
je .bios_continue4
mov ax, .s_szBiosDisableFailed
jmp .bios_failed
.bios_continue4:
loop .bios_loop
jmp .bios_done
.s_szBios:
db 'INT 15h AH=24 A20 Gate interface', 0
.s_szBios2403Mask:
db 'AX=2403 return (AL)', 0
.s_szBios2403Error:
db 'AX=2403 error (AX)', 10, 13, 0
.s_szBios2402Error:
db '2402h -> AX=%RX16 expected %RX16', 10, 13, 0
.s_szBiosFailed2400:
db '2400h interface failed', 10, 13, 0
.s_szBiosFailed2401:
db '2401h interface failed', 10, 13, 0
.s_szBiosDisableFailed:
db 'BIOS failed to disable A20 (or bad CPU)', 10, 13, 0
.s_szBiosEnableFailed:
db 'BIOS failed to enable A20', 10, 13, 0
.bios_failed:
call TestFailed_r86
.bios_done:
call TestSubDone_r86
call Bs2DisableA20ViaPortA_r86
call Bs2DisableA20ViaKbd_r86
;
; Test the fast A20 gate interface.
;
mov ax, .s_szFastA20
call TestSub_r86
mov cx, 10h
.fast_loop:
call Bs2EnableA20ViaPortA_r86
call IsA20GateEnabled_rm
cmp al, 1
mov ax, .s_szFastEnableFailed
jne .fast_failed
call Bs2DisableA20ViaPortA_r86
call IsA20GateEnabled_rm
cmp al, 0
mov ax, .s_szFastDisableFailed
jne .fast_failed
loop .fast_loop
jmp .fast_done
.s_szFastA20:
db 'Fast A20 Gate Interface', 0
.s_szFastDisableFailed:
db 'Fast A20 gate disabling failed', 10, 13, 0
.s_szFastEnableFailed:
db 'Fast A20 gate enabling failed', 10, 13, 0
.fast_failed:
call TestFailed_r86
.fast_done:
call TestSubDone_r86
call Bs2DisableA20ViaPortA_r86
call Bs2DisableA20ViaKbd_r86
;
; Test the keyboard interface.
;
mov ax, .s_szKeyboardA20
call TestSub_r86
mov cx, 10h
.kbd_loop:
call Bs2EnableA20ViaKbd_r86
call IsA20GateEnabled_rm
cmp al, 1
mov ax, .s_szKbdEnableFailed
jne .kbd_failed
call Bs2DisableA20ViaKbd_r86
call IsA20GateEnabled_rm
cmp al, 0
mov ax, .s_szKbdDisableFailed
jne .kbd_failed
loop .kbd_loop
jmp .kbd_done
.s_szKeyboardA20:
db 'Keyboard A20 Gate Interface', 0
.s_szKbdDisableFailed:
db 'Disabling the A20 gate via the keyboard controller failed', 10, 13, 0
.s_szKbdEnableFailed:
db 'Enabling the A20 gate via the keyboard controller failed', 10, 13, 0
.kbd_failed:
call TestFailed_r86
.kbd_done:
call TestSubDone_r86
call Bs2DisableA20ViaPortA_r86
call Bs2DisableA20ViaKbd_r86
pop edi
pop ebx
pop ecx
pop edx
pop eax
ret
ENDPROC TestA20_1
;;
; Checks if the A20 gate is enabled.
;
; This is do by temporarily changing a word at address 0000000h and see if this
; is reflected at address 0100000h (1 MB). The word written is
; ~*(word *)0x100000h to make sure it won't accidentally match.
;
; @returns ax 1 if enabled, 0 if disabled.
;
BEGINPROC IsA20GateEnabled_rm
push ds
push es
push dx
pushf
cli
.once_again:
xor ax, ax
mov ds, ax
dec ax
mov es, ax
mov ax, [es:0010h] ; 0ffff:0010 => 0100000h (1 MB)
mov dx, [ds:0000h] ; 00000:0000 => 0000000h - save it
not ax
mov [ds:0000h], ax ; 0000000h - write ~[0100000h]
cmp [es:0010h], ax ; 0100000h - same as 0000000h if A20 is disabled.
mov [ds:0000h], dx ; 0000000h - restore original value
setne al
movzx ax, al
popf
pop dx
pop es
pop ds
ret
ENDPROC IsA20GateEnabled_rm
;;
; Checks if the BIOS thinks the A20 gate is enabled.
;
; @returns ax 1 if enabled, 0 if disabled.
;
BEGINPROC BiosIsA20GateEnabled_rm
push ecx
push eax
mov ax, 2402h
int 15h
jnc .ok
mov al, 080h
.ok:
mov cx, ax
pop eax
mov ax, cx
pop ecx
ret
ENDPROC BiosIsA20GateEnabled_rm
;
; Instantiate the template code.
;
%include "bootsector2-template-footer.mac" ; reset the initial environemnt.
%define TMPL_RM
%include "bootsector2-cpu-a20-1-template.mac"
;%define TMPL_CMN_V86
;%include "bootsector2-cpu-a20-1-template.mac"
%define TMPL_PE16
%include "bootsector2-cpu-a20-1-template.mac"
%define TMPL_PE32
%include "bootsector2-cpu-a20-1-template.mac"
;%define TMPL_PP16
;%include "bootsector2-cpu-a20-1-template.mac"
%define TMPL_PP32
%include "bootsector2-cpu-a20-1-template.mac"
;%define TMPL_PAE16
;%include "bootsector2-cpu-a20-1-template.mac"
%define TMPL_PAE32
%include "bootsector2-cpu-a20-1-template.mac"
;%define TMPL_LM16
;%include "bootsector2-cpu-a20-1-template.mac"
;%define TMPL_LM32
;%include "bootsector2-cpu-a20-1-template.mac"
%define TMPL_LM64
%include "bootsector2-cpu-a20-1-template.mac"
;
; End sections and image.
;
%include "bootsector2-common-end.mac"
| 27.127321
| 98
| 0.595189
|
7f46e44c96710962a9e520a30b44e18d7e74a8d6
| 35,115
|
asm
|
Assembly
|
private/ntos/ke/i386/newsysbg.asm
|
King0987654/windows2000
|
01f9c2e62c4289194e33244aade34b7d19e7c9b8
|
[
"MIT"
] | 11
|
2017-09-02T11:27:08.000Z
|
2022-01-02T15:25:24.000Z
|
private/ntos/ke/i386/newsysbg.asm
|
King0987654/windows2000
|
01f9c2e62c4289194e33244aade34b7d19e7c9b8
|
[
"MIT"
] | null | null | null |
private/ntos/ke/i386/newsysbg.asm
|
King0987654/windows2000
|
01f9c2e62c4289194e33244aade34b7d19e7c9b8
|
[
"MIT"
] | 14
|
2019-01-16T01:01:23.000Z
|
2022-02-20T15:54:27.000Z
|
title "System Startup"
;++
;
; Copyright (c) 1989 Microsoft Corporation
;
; Module Name:
;
; systembg.asm
;
; Abstract:
;
; This module implements the code necessary to initially startup the
; NT system.
;
; Author:
;
; Shie-Lin Tzong (shielint) 07-Mar-1990
;
; Environment:
;
; Kernel mode only.
;
; Revision History:
;
; John Vert (jvert) 25-Jun-1991
; Major overhaul in order to move into new osloader architecture
; Removed old debugger hacks
;
;--
.386p
.xlist
include i386\cpu.inc
include ks386.inc
include i386\kimacro.inc
include mac386.inc
include callconv.inc
include fastsys.inc
FPOFRAME macro a, b
.FPO ( a, b, 0, 0, 0, 0 )
endm
.list
option segment:flat
extrn @ExfInterlockedPopEntrySList@8:DWORD
extrn @ExfInterlockedPushEntrySList@12:DWORD
extrn @ExfInterlockedFlushSList@4:DWORD
extrn @ExInterlockedCompareExchange64@16:DWORD
extrn @ExInterlockedPopEntrySList@8:DWORD
extrn @ExInterlockedPushEntrySList@12:DWORD
extrn @ExInterlockedFlushSList@4:DWORD
extrn @ExpInterlockedCompareExchange64@16:DWORD
extrn _ExInterlockedAddLargeInteger@16:DWORD
extrn _ExInterlockedExchangeAddLargeInteger@16:DWORD
extrn _KiBootFeatureBits:DWORD
EXTRNP _KdInitSystem,2
EXTRNP KfRaiseIrql,1,IMPORT,FASTCALL
EXTRNP KfLowerIrql,1,IMPORT,FASTCALL
EXTRNP _KiInitializeKernel,6
extrn SwapContext:PROC
EXTRNP GetMachineBootPointers
EXTRNP _KiInitializePcr,7
EXTRNP _KiSwapIDT
EXTRNP _KiInitializeTSS,1
EXTRNP _KiInitializeTSS2,2
EXTRNP _KiInitializeGdtEntry,6
extrn _KiTrap08:PROC
extrn _KiTrap02:PROC
EXTRNP _HalDisplayString,1,IMPORT
EXTRNP _KiInitializeAbios,1
EXTRNP _KiInitializeMachineType
EXTRNP _KeGetCurrentIrql,0,IMPORT
EXTRNP _KeBugCheck, 1
EXTRNP _KeBugCheckEx, 5
EXTRNP _HalInitializeProcessor,2,IMPORT
EXTRNP HalClearSoftwareInterrupt,1,IMPORT,FASTCALL
if NT_INST
EXTRNP _KiAcquireSpinLock, 1
EXTRNP _KiReleaseSpinLock, 1
endif
EXTRNP KiTryToAcquireQueuedSpinLock,1,,FASTCALL
extrn _KiFreezeExecutionLock:DWORD
extrn _KiDispatcherLock:DWORD
extrn _IDT:BYTE
extrn _IDTLEN:BYTE ; NOTE - really an ABS, linker problems
extrn _KeNumberProcessors:BYTE
extrn _KeActiveProcessors:DWORD
extrn _KiIdleSummary:DWORD
extrn _KiProcessorBlock:DWORD
extrn _KiFindFirstSetRight:BYTE
EXTRNP _KdPollBreakIn,0
extrn _KeLoaderBlock:DWORD
extrn _KeI386NpxPresent:DWORD
extrn _KeI386CpuType:DWORD
extrn _KeI386CpuStep:DWORD
extrn _KeTickCount:DWORD
extrn _KeFeatureBits:DWORD
ifndef NT_UP
extrn _KiBarrierWait:DWORD
endif
if DBG
extrn _KdDebuggerEnabled:BYTE
EXTRNP _DbgBreakPoint,0
extrn _DbgPrint:near
extrn _MsgDpcTrashedEsp:BYTE
endif
;
; Constants for various variables
;
_DATA SEGMENT PARA PUBLIC 'DATA'
;
; Idle thread process object
;
align 4
public _KiIdleProcess
_KiIdleProcess label byte
db ExtendedProcessObjectLength dup(?) ; sizeof (EPROCESS)
;
; Statically allocated structures for Bootstrap processor
; idle thread object for P0
; idle thread stack for P0
;
align 4
public P0BootThread
P0BootThread label byte
db ExtendedThreadObjectLength dup(?) ; sizeof (ETHREAD)
align 16
public _KiDoubleFaultStack
db DOUBLE_FAULT_STACK_SIZE dup (?)
_KiDoubleFaultStack label byte
public P0BootStack
db KERNEL_STACK_SIZE dup (?)
P0BootStack label byte
;
; Double fault task stack
;
MINIMUM_TSS_SIZE EQU TssIoMaps
align 16
public _KiDoubleFaultTSS
_KiDoubleFaultTSS label byte
db MINIMUM_TSS_SIZE dup(0)
public _KiNMITSS
_KiNMITSS label byte
db MINIMUM_TSS_SIZE dup(0)
;
; Abios specific definitions
;
public _KiCommonDataArea, _KiAbiosPresent
_KiCommonDataArea dd 0
_KiAbiosPresent dd 0
_DATA ends
page ,132
subttl "System Startup"
INIT SEGMENT DWORD PUBLIC 'CODE'
ASSUME DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
;++
;
; For processor 0, Routine Description:
;
; This routine is called when the NT system begins execution.
; Its function is to initialize system hardware state, call the
; kernel initialization routine, and then fall into code that
; represents the idle thread for all processors.
;
; Entry state created by the boot loader:
; A short-form IDT (0-1f) exists and is active.
; A complete GDT is set up and loaded.
; A complete TSS is set up and loaded.
; Page map is set up with minimal start pages loaded
; The lower 4Mb of virtual memory are directly mapped into
; physical memory.
;
; The system code (ntoskrnl.exe) is mapped into virtual memory
; as described by its memory descriptor.
; DS=ES=SS = flat
; ESP->a usable boot stack
; Interrupts OFF
;
; For processor > 0, Routine Description:
;
; This routine is called when each additional processor begins execution.
; The entry state for the processor is:
; IDT, GDT, TSS, stack, selectors, PCR = all valid
; Page directory is set to the current running directory
; LoaderBlock - parameters for this processor
;
; Arguments:
;
; PLOADER_PARAMETER_BLOCK LoaderBlock
;
; Return Value:
;
; None.
;
;--
;
; Arguments for KiSystemStartupPx
;
KissLoaderBlock equ [ebp+8]
;
; Local variables
;
KissGdt equ [ebp-4]
KissPcr equ [ebp-8]
KissTss equ [ebp-12]
KissIdt equ [ebp-16]
KissIrql equ [ebp-20]
KissPbNumber equ [ebp-24]
KissIdleStack equ [ebp-28]
KissIdleThread equ [ebp-32]
cPublicProc _KiSystemStartup ,1
push ebp
mov ebp, esp
sub esp, 32 ; Reserve space for local variables
mov ebx, dword ptr KissLoaderBlock
mov _KeLoaderBlock, ebx ; Get loader block param
movzx ecx, _KeNumberProcessors ; get number of processors
mov KissPbNumber, ecx
or ecx, ecx ; Is the the boot processor?
jnz @f ; no
; P0 uses static memory for these
mov dword ptr [ebx].LpbThread, offset P0BootThread
mov dword ptr [ebx].LpbKernelStack, offset P0BootStack
push KGDT_R0_PCR ; P0 needs FS set
pop fs
; Save processornumber in Prcb
mov byte ptr fs:PcPrcbData+PbNumber, cl
@@:
mov eax, dword ptr [ebx].LpbThread
mov dword ptr KissIdleThread, eax
mov eax, dword ptr [ebx].LpbKernelStack
mov dword ptr KissIdleStack, eax
stdCall _KiInitializeMachineType
cmp byte ptr KissPbNumber, 0 ; if not p0, then
jne kiss_notp0 ; skip a bunch
;
;+++++++++++++++++++++++
;
; Initialize the PCR
;
stdCall GetMachineBootPointers
;
; Upon return:
; (edi) -> gdt
; (esi) -> pcr
; (edx) -> tss
; (eax) -> idt
; Now, save them in our local variables
;
mov KissGdt, edi
mov KissPcr, esi
mov KissTss, edx
mov KissIdt, eax
;
; edit TSS to be 32bits. loader gives us a tss, but it's 16bits!
;
lea ecx,[edi]+KGDT_TSS ; (ecx) -> TSS descriptor
mov byte ptr [ecx+5],089h ; 32bit, dpl=0, present, TSS32, not busy
; KiInitializeTSS2(
; Linear address of TSS
; Linear address of TSS descriptor
; );
stdCall _KiInitializeTSS2, <KissTss, ecx>
stdCall _KiInitializeTSS, <KissTss>
mov cx,KGDT_TSS
ltr cx
;
; set up 32bit double fault task gate to catch double faults.
;
mov eax,KissIdt
lea ecx,[eax]+40h ; Descriptor 8
mov byte ptr [ecx+5],085h ; dpl=0, present, taskgate
mov word ptr [ecx+2],KGDT_DF_TSS
lea ecx,[edi]+KGDT_DF_TSS
mov byte ptr [ecx+5],089h ; 32bit, dpl=0, present, TSS32, not busy
mov edx,offset FLAT:_KiDoubleFaultTSS
mov eax,edx
mov [ecx+KgdtBaseLow],ax
shr eax,16
mov [ecx+KgdtBaseHi],ah
mov [ecx+KgdtBaseMid],al
mov eax, MINIMUM_TSS_SIZE
mov [ecx+KgdtLimitLow],ax
; KiInitializeTSS(
; address of double fault TSS
; );
stdCall _KiInitializeTSS, <edx>
mov eax,cr3
mov [edx+TssCr3],eax
mov eax, offset FLAT:_KiDoubleFaultStack
mov dword ptr [edx+038h],eax
mov dword ptr [edx+TssEsp0],eax
mov dword ptr [edx+020h],offset FLAT:_KiTrap08
mov dword ptr [edx+024h],0 ; eflags
mov word ptr [edx+04ch],KGDT_R0_CODE ; set value for CS
mov word ptr [edx+058h],KGDT_R0_PCR ; set value for FS
mov [edx+050h],ss
mov word ptr [edx+048h],KGDT_R3_DATA OR RPL_MASK ; Es
mov word ptr [edx+054h],KGDT_R3_DATA OR RPL_MASK ; Ds
;
; set up 32bit NMI task gate to catch NMI faults.
;
mov eax,KissIdt
lea ecx,[eax]+10h ; Descriptor 2
mov byte ptr [ecx+5],085h ; dpl=0, present, taskgate
mov word ptr [ecx+2],KGDT_NMI_TSS
lea ecx,[edi]+KGDT_NMI_TSS
mov byte ptr [ecx+5],089h ; 32bit, dpl=0, present, TSS32, not busy
mov edx,offset FLAT:_KiNMITSS
mov eax,edx
mov [ecx+KgdtBaseLow],ax
shr eax,16
mov [ecx+KgdtBaseHi],ah
mov [ecx+KgdtBaseMid],al
mov eax, MINIMUM_TSS_SIZE
mov [ecx+KgdtLimitLow],ax
push edx
stdCall _KiInitializeTSS,<edx> ; KiInitializeTSS(
; address TSS
; );
;
; We are using the DoubleFault stack as the DoubleFault stack and the
; NMI Task Gate stack and briefly, it is the DPC stack for the first
; processor.
;
mov eax,cr3
mov [edx+TssCr3],eax
mov eax, offset FLAT:_KiDoubleFaultTSS
mov eax, dword ptr [eax+038h] ; get DF stack
mov dword ptr [edx+TssEsp0],eax ; use it for NMI stack
mov dword ptr [edx+038h],eax
mov dword ptr [edx+020h],offset FLAT:_KiTrap02
mov dword ptr [edx+024h],0 ; eflags
mov word ptr [edx+04ch],KGDT_R0_CODE ; set value for CS
mov word ptr [edx+058h],KGDT_R0_PCR ; set value for FS
mov [edx+050h],ss
mov word ptr [edx+048h],KGDT_R3_DATA OR RPL_MASK ; Es
mov word ptr [edx+054h],KGDT_R3_DATA OR RPL_MASK ; Ds
stdCall _KiInitializePcr, <KissPbNumber,KissPcr,KissIdt,KissGdt,KissTss,KissIdleThread,offset FLAT:_KiDoubleFaultStack>
;
; set current process pointer in current thread object
;
mov edx, KissIdleThread
mov ecx, offset FLAT:_KiIdleProcess ; (ecx)-> idle process obj
mov [edx]+ThApcState+AsProcess, ecx ; set addr of thread's process
;
; set up PCR: Teb, Prcb pointers. The PCR:InitialStack, and various fields
; of Prcb will be set up in _KiInitializeKernel
;
mov dword ptr fs:PcTeb, 0 ; PCR->Teb = 0
;
; Initialize KernelDr7 and KernelDr6 to 0. This must be done before
; the debugger is called.
;
mov dword ptr fs:PcPrcbData+PbProcessorState+PsSpecialRegisters+SrKernelDr6,0
mov dword ptr fs:PcPrcbData+PbProcessorState+PsSpecialRegisters+SrKernelDr7,0
;
; Since the entries of Kernel IDT have their Selector and Extended Offset
; fields set up in the wrong order, we need to swap them back to the order
; which i386 recognizes.
; This is only done by the bootup processor.
;
stdCall _KiSwapIDT ; otherwise, do the work
;
; Switch to R3 flat selectors that we want loaded so lazy segment
; loading will work.
;
mov eax,KGDT_R3_DATA OR RPL_MASK ; Set RPL = ring 3
mov ds,ax
mov es,ax
;
; Now copy our trap handlers to replace kernel debugger's handlers.
;
mov eax, KissIdt ; (eax)-> Idt
push dword ptr [eax+40h] ; save double fault's descriptor
push dword ptr [eax+44h]
push dword ptr [eax+10h] ; save nmi fault's descriptor
push dword ptr [eax+14h]
mov edi,KissIdt
mov esi,offset FLAT:_IDT
mov ecx,offset FLAT:_IDTLEN ; _IDTLEN is really an abs, we use
shr ecx,2
rep movsd
pop dword ptr [eax+14h] ; restore nmi fault's descriptor
pop dword ptr [eax+10h]
pop dword ptr [eax+44h] ; restore double fault's descriptor
pop dword ptr [eax+40h]
kiss_notp0:
;
; A new processor can't come online while execution is frozen
; Take freezelock while adding a processor to the system
; NOTE: don't use SPINLOCK macro - it has debugger stuff in it
;
if NT_INST
lea eax, _KiFreezeExecutionLock
stdCall _KiAcquireSpinLock, <eax>
else
@@: test _KiFreezeExecutionLock, 1
jnz short @b
lock bts _KiFreezeExecutionLock, 0
jc short @b
endif
;
; Add processor to active summary, and update BroadcastMasks
;
mov ecx, dword ptr KissPbNumber ; mark this processor as active
mov byte ptr fs:PcNumber, cl
mov eax, 1
shl eax, cl ; our affinity bit
mov fs:PcSetMember, eax
mov fs:PcPrcbData.PbSetMember, eax
;
; Initialize the interprocessor interrupt vector and increment ready
; processor count to enable kernel debugger.
;
stdCall _HalInitializeProcessor, <dword ptr KissPbNumber, KissLoaderBlock>
mov eax, fs:PcSetMember
or _KeActiveProcessors, eax ; New affinity of active processors
;
; Initialize ABIOS data structure if present.
; Note, the KiInitializeAbios MUST be called after the KeLoaderBlock is
; initialized.
;
stdCall _KiInitializeAbios, <dword ptr KissPbNumber>
inc _KeNumberProcessors ; One more processor now active
if NT_INST
lea eax, _KiFreezeExecutionLock
stdCall _KiReleaseSpinLock, <eax>
else
xor eax, eax ; release the executionlock
mov _KiFreezeExecutionLock, eax
endif
cmp byte ptr KissPbNumber, 0
jnz @f
; don't stop in debugger
stdCall _KdInitSystem, <_KeLoaderBlock,0>
if DEVL
;
; Give the debugger an opportunity to gain control.
;
POLL_DEBUGGER
endif ; DEVL
@@:
nop ; leave a spot for int-3 patch
;
; Set initial IRQL = HIGH_LEVEL for init
;
mov ecx, HIGH_LEVEL
fstCall KfRaiseIrql
mov KissIrql, al
;
; If the target machine does not implement the cmpxchg8b instruction,
; then patch the routines that use this instruction to simply jump
; to the corresponding routines that use spinlocks.
;
pushfd ; Save flags
cmp byte ptr KissPbNumber, 0
jnz cx8done ; only test on boot processor
pop ebx ; Get flags into eax
push ebx ; Save original flags
mov ecx, ebx
xor ecx, EFLAGS_ID ; flip ID bit
push ecx
popfd ; load it into flags
pushfd ; re-save flags
pop ecx ; get flags into eax
cmp ebx, ecx ; did bit stay flipped?
je short nocx8 ; No, don't try CPUID
or ebx, EFLAGS_ID
push ebx
popfd ; Make sure ID bit is set
.586p
mov eax, 1 ; Get feature bits
cpuid ; Uses eax, ebx, ecx, edx
.386p
test edx, 100h
jz short nocx8
or _KiBootFeatureBits, KF_CMPXCHG8B ; We're committed to using
jmp short cx8done ; this feature
nocx8:
lea eax, @ExInterlockedCompareExchange64@16 ; get target address
lea ecx, @ExpInterlockedCompareExchange64@16 ; get source address
mov byte ptr [eax], 0e9H ; set jump opcode value
lea edx, [eax] + 5 ; get simulated eip value
sub ecx, edx ; compute displacement
mov [eax] + 1, ecx ; set jump displacement value
lea eax, @ExInterlockedPopEntrySList@8 ; get target address
lea ecx, @ExfInterlockedPopEntrySList@8 ; get source address
mov byte ptr [eax], 0e9H ; set jump opcode value
lea edx, [eax] + 5 ; get simulated eip value
sub ecx, edx ; compute displacement
mov [eax] + 1, ecx ; set jump displacement value
lea eax, @ExInterlockedPushEntrySList@12 ; get target address
lea ecx, @ExfInterlockedPushEntrySList@12 ; get source address
mov byte ptr [eax], 0e9H ; set jump opcode value
lea edx, [eax] + 5 ; get simulated eip value
sub ecx, edx ; compute displacement
mov [eax] + 1, ecx ; set jump displacement value
lea eax, @ExInterlockedFlushSList@4 ; get target address
lea ecx, @ExfInterlockedFlushSList@4 ; get source address
mov byte ptr [eax], 0e9H ; set jump opcode value
lea edx, [eax] + 5 ; get simulated eip value
sub ecx, edx ; compute displacement
mov [eax] + 1, ecx ; set jump displacement value
lea eax, _ExInterlockedExchangeAddLargeInteger@16 ; get target address
lea ecx, _ExInterlockedAddLargeInteger@16 ; get source address
mov byte ptr [eax], 0e9H ; set jump opcode value
lea edx, [eax] + 5 ; get simulated eip value
sub ecx, edx ; compute displacement
mov [eax] + 1, ecx ; set jump displacement value
cx8done:
popfd
;
; Initialize ebp, esp, and argument registers for initializing the kernel.
;
mov ebx, KissIdleThread
mov edx, KissIdleStack
mov eax, KissPbNumber
and edx, NOT 3h ; align stack to 4 byte boundary
xor ebp, ebp ; (ebp) = 0. No more stack frame
mov esp, edx
;
; Reserve space for idle thread stack NPX_SAVE_AREA and initialization
;
sub esp, NPX_FRAME_LENGTH+KTRAP_FRAME_LENGTH+KTRAP_FRAME_ALIGN
push CR0_EM+CR0_TS+CR0_MP ; make space for Cr0NpxState
; arg6 - LoaderBlock
; arg5 - processor number
; arg4 - addr of prcb
; arg3 - idle thread's stack
; arg2 - addr of current thread obj
; arg1 - addr of current process obj
; initialize system data structures
; and HAL.
stdCall _KiInitializeKernel,<offset _KiIdleProcess,ebx,edx,dword ptr fs:PcPrcb,eax,_KeLoaderBlock>
;
; Set "shadow" priority value for Idle thread. This will keep the Mutex
; priority boost/drop code from dropping priority on the Idle thread, and
; thus avoids leaving a bit set in the ActiveMatrix for the Idle thread when
; there should never be any such bit.
;
mov ebx,fs:PcPrcbData+PbCurrentThread ; (eax)->Thread
mov byte ptr [ebx]+ThPriority,LOW_REALTIME_PRIORITY ; set pri.
;
; Control is returned to the idle thread with IRQL at HIGH_LEVEL. Lower IRQL
; to DISPATCH_LEVEL and set wait IRQL of idle thread.
;
sti
mov ecx, DISPATCH_LEVEL
fstCall KfLowerIrql
mov byte ptr [ebx]+ThWaitIrql, DISPATCH_LEVEL
;
; The following code represents the idle thread for a processor. The idle
; thread executes at IRQL DISPATCH_LEVEL and continually polls for work to
; do. Control may be given to this loop either as a result of a return from
; the system initialization routine or as the result of starting up another
; processor in a multiprocessor configuration.
;
mov ebx, PCR[PcSelfPcr] ; get address of PCR
;
; In a multiprocessor system the boot processor proceeds directly into
; the idle loop. As other processors start executing, however, they do
; not directly enter the idle loop - they spin until all processors have
; been started and the boot master allows them to proceed.
;
ifndef NT_UP
@@: cmp _KiBarrierWait, 0 ; check if barrier set
jnz short @b ; if nz, barrier set
endif
jmp KiIdleLoop ; enter idle loop
stdENDP _KiSystemStartup
INIT ends
_TEXT$00 SEGMENT DWORD PUBLIC 'CODE' ; Put IdleLoop in text section
ASSUME DS:FLAT, ES:FLAT, SS:NOTHING, FS:NOTHING, GS:NOTHING
page ,132
subttl "Idle Loop"
;++
;
; Routine Description:
;
; This routine continuously executes the idle loop and never returns.
;
; Arguments:
;
; ebx - Address of the current processor's PCR.
;
; Return value:
;
; None - routine never returns.
;
;--
public KiIdleLoop
KiIdleLoop proc
lea ebp, [ebx].PcPrcbData.PbDpcListHead ; set DPC listhead address
if DBG
xor edi, edi ; reset poll breakin counter
endif
jmp short kid20 ; Skip HalIdleProcessor on first iteration
;
; There are no entries in the DPC list and a thread has not been selected
; for execution on this processor. Call the HAL so power managment can be
; performed.
;
; N.B. The HAL is called with interrupts disabled. The HAL will return
; with interrupts enabled.
;
; N.B. Use a call instruction instead of a push-jmp, as the call instruction
; executes faster and won't invalidate the processor's call-return stack
; cache.
;
kid10: lea ecx, [ebx].PcPrcbData.PbPowerState
call dword ptr [ecx].PpIdleFunction ; (ecx) = Arg0
;
; Give the debugger an opportunity to gain control on debug systems.
;
; N.B. On an MP system the lowest numbered idle processor is the only
; processor that polls for a breakin request.
;
kid20:
if DBG
ifndef NT_UP
mov eax, _KiIdleSummary ; get idle summary
mov ecx, [ebx].PcSetMember ; get set member
dec ecx ; compute right bit mask
and eax, ecx ; check if any lower bits set
jnz short CheckDpcList ; if nz, not lowest numbered
endif
dec edi ; decrement poll counter
jg short CheckDpcList ; if g, not time to poll
POLL_DEBUGGER ; check if break in requested
endif
kid30:
if DBG
ifndef NT_UP
mov edi, 20 * 1000 ; set breakin poll interval
else
mov edi, 100 ; UP idle loop has a HLT in it
endif
endif
CheckDpcList0:
YIELD
;
; Disable interrupts and check if there is any work in the DPC list
; of the current processor or a target processor.
;
CheckDpcList:
;
; N.B. The following code enables interrupts for a few cycles, then
; disables them again for the subsequent DPC and next thread
; checks.
;
sti ; enable interrupts
nop ;
nop ;
cli ; disable interrupts
;
; Process the deferred procedure call list for the current processor.
;
cmp ebp, [ebp].LsFlink ; check if DPC list is empty
je short CheckNextThread ; if eq, DPC list is empty
mov cl, DISPATCH_LEVEL ; set interrupt level
fstCall HalClearSoftwareInterrupt ; clear software interrupt
call KiRetireDpcList ; process the current DPC list
if DBG
xor edi, edi ; clear breakin poll interval
endif
;
; Check if a thread has been selected to run on the current processor.
;
CheckNextThread: ;
cmp dword ptr [ebx].PcPrcbData.PbNextThread, 0 ; thread selected?
je short kid10 ; if eq, no thread selected
;
; A thread has been selected for execution on this processor. Acquire
; the dispatcher database lock, get the thread address again (it may have
; changed), clear the address of the next thread in the processor block,
; and call swap context to start execution of the selected thread.
;
; N.B. If the dispatcher database lock cannot be obtained immediately,
; then attempt to process another DPC rather than spinning on the
; dispatcher database lock.
; N.B. On MP systems, the dispatcher database is always locked at
; SYNCH level to ensure the lock is held for as short a period as
; possible (reduce contention). On UP systems there really is no
; lock, it is sufficient to be at DISPATCH level (which is the
; current level at this point in the code).
ifndef NT_UP
; see if dispatcher lock is available right now
cmp dword ptr _KiDispatcherLock, 0
jnz short CheckDpcList0
; attempt to acquire the dispatcher database lock
lea ecx, [ebx]+PcPrcbData+PbLockQueue+(8*LockQueueDispatcherLock)
fstCall KiTryToAcquireQueuedSpinLock
jz short CheckDpcList0 ; jif could not acquire lock
;
; Raise IRQL to synchronization level and enable interrupts.
;
mov ecx, SYNCH_LEVEL ; raise IRQL to synchronization level
fstCall KfRaiseIrql ;
endif
sti ; enable interrupts
mov esi, [ebx].PcPrcbData.PbNextThread ; get next thread address
mov edi, [ebx].PcPrcbData.PbCurrentThread ; set current thread address
mov dword ptr [ebx].PcPrcbData.PbNextThread, 0 ; clear next thread address
mov [ebx].PcPrcbData.PbCurrentThread, esi ; set current thread address
mov cl, 1 ; set APC interrupt bypass disable
call SwapContext ;
ifndef NT_UP
mov ecx, DISPATCH_LEVEL ; lower IRQL to dispatch level
fstCall KfLowerIrql ;
endif
lea ebp, [ebx].PcPrcbData.PbDpcListHead ; set DPC listhead address
jmp kid30 ;
KiIdleLoop endp
page ,132
subttl "Retire Deferred Procedure Call List"
;++
;
; Routine Description:
;
; This routine is called to retire the specified deferred procedure
; call list. DPC routines are called using the idle thread (current)
; stack.
;
; N.B. Interrupts must be disabled and the DPC list lock held on entry
; to this routine. Control is returned to the caller with the same
; conditions true.
;
; N.B. The registers ebx and ebp are preserved across the call.
;
; Arguments:
;
; ebx - Address of the target processor PCR.
; ebp - Address of the target DPC listhead.
;
; Return value:
;
; None.
;
;--
public KiRetireDpcList
KiRetireDpcList proc
?FpoValue = 0
ifndef NT_UP
?FpoValue = 1
push esi ; save register
lea esi, [ebx].PcPrcbData.PbDpcLock ; get DPC lock address
endif
FPOFRAME ?FpoValue,0
rdl5: mov PCR[PcPrcbData.PbDpcRoutineActive], esp ; set DPC routine active
;
; Process the DPC List.
;
rdl10: ;
ifndef NT_UP
ACQUIRE_SPINLOCK esi, rdl50, NoChecking ; acquire DPC lock
cmp ebp, [ebp].LsFlink ; check if DPC list is empty
je rdl45 ; if eq, DPC list is empty
endif
mov edx, [ebp].LsFlink ; get address of next entry
mov ecx, [edx].LsFlink ; get address of next entry
mov [ebp].LsFlink, ecx ; set address of next in header
mov [ecx].LsBlink, ebp ; set address of previous in next
sub edx, DpDpcListEntry ; compute address of DPC object
mov ecx, [edx].DpDeferredRoutine ; get DPC routine address
if DBG
push edi ; save register
mov edi, esp ; save current stack pointer
endif
FPOFRAME ?FpoValue,0
push [edx].DpSystemArgument2 ; second system argument
push [edx].DpSystemArgument1 ; first system argument
push [edx].DpDeferredContext ; get deferred context argument
push edx ; address of DPC object
mov dword ptr [edx]+DpLock, 0 ; clear DPC inserted state
dec dword ptr [ebx].PcPrcbData.PbDpcQueueDepth ; decrement depth
if DBG
mov PCR[PcPrcbData.PbDebugDpcTime], 0 ; Reset the time in DPC
endif
ifndef NT_UP
RELEASE_SPINLOCK esi, NoChecking ; release DPC lock
endif
sti ; enable interrupts
call ecx ; call DPC routine
if DBG
stdCall _KeGetCurrentIrql ; get current IRQL
cmp al, DISPATCH_LEVEL ; check if still at dispatch level
jne rdl55 ; if ne, not at dispatch level
cmp esp, edi ; check if stack pointer is correct
jne rdl60 ; if ne, stack pointer is not correct
rdl30: pop edi ; restore register
endif
FPOFRAME ?FpoValue,0
rdl35: cli ; disable interrupts
cmp ebp, [ebp].LsFlink ; check if DPC list is empty
jne rdl10 ; if ne, DPC list not empty
;
; Clear DPC routine active and DPC requested flags.
;
rdl40: mov [ebx].PcPrcbData.PbDpcRoutineActive, 0
mov [ebx].PcPrcbData.PbDpcInterruptRequested, 0
;
; Check one last time that the DPC list is empty. This is required to
; close a race condition with the DPC queuing code where it appears that
; a DPC routine is active (and thus an interrupt is not requested), but
; this code has decided the DPC list is empty and is clearing the DPC
; active flag.
;
cmp ebp, [ebp].LsFlink ; check if DPC list is empty
jne rdl5 ; if ne, DPC list not empty
ifndef NT_UP
pop esi ; retore register
endif
ret ; return
;
; Unlock DPC list and clear DPC active.
;
rdl45: ;
ifndef NT_UP
RELEASE_SPINLOCK esi, NoChecking ; release DPC lock
jmp short rdl40 ;
endif
ifndef NT_UP
rdl50: sti ; enable interrupts
SPIN_ON_SPINLOCK esi, <short rdl35> ; spin until lock is freee
endif
if DBG
rdl55: stdCall _KeBugCheckEx, <IRQL_NOT_GREATER_OR_EQUAL, ebx, eax, 0, 0> ;
rdl60: push dword ptr [edi+12] ; push address of DPC function
push offset FLAT:_MsgDpcTrashedEsp ; push message address
call _DbgPrint ; print debug message
add esp, 8 ; remove arguments from stack
int 3 ; break into debugger
mov esp, edi ; reset stack pointer
jmp rdl30 ;
endif
KiRetireDpcList endp
_TEXT$00 ends
_TEXT SEGMENT DWORD PUBLIC 'CODE' ; Put IdleLoop in text section
page ,132
subttl "Set up 80387, or allow for emulation"
;++
;
; Routine Description:
;
; This routine is called during kernel initialization once for each
; processor. It sets EM+TS+MP whether we are emulating or not.
;
; If the 387 hardware exists, EM+TS+MP will all be cleared on the
; first trap 07. Thereafter, EM will never be seen for this thread.
; MP+TS will only be set when an error is detected (via IRQ 13), and
; it will be cleared by the trap 07 that will occur on the next FP
; instruction.
;
; If we're emulating, EM+TS+MP are all always set to ensure that all
; FP instructions trap to the emulator (the trap 07 handler is edited
; to point to the emulator, rather than KiTrap07).
;
; Arguments:
;
; None.
;
; Return Value:
;
; None.
;
;--
cPublicProc _KiSetCR0Bits ,0
mov eax, cr0
;
; There are two useful bits in CR0 that we want to turn on if the processor
; is a 486 or above. (They don't exist on the 386)
;
; CR0_AM - Alignment mask (so we can turn on alignment faults)
;
; CR0_WP - Write protect (so we get page faults if we write to a
; write-protected page from kernel mode)
;
cmp byte ptr fs:PcPrcbData.PbCpuType, 3h
jbe @f
;
; The processor is not a 386, (486 or greater) so we assume it is ok to
; turn on these bits.
;
or eax, CR0_WP
@@:
mov cr0, eax
stdRET _KiSetCR0Bits
stdENDP _KiSetCR0Bits
ifdef DBGMP
cPublicProc _KiPollDebugger,0
cPublicFpo 0,3
push eax
push ecx
push edx
POLL_DEBUGGER
pop edx
pop ecx
pop eax
stdRET _KiPollDebugger
stdENDP _KiPollDebugger
endif
_TEXT ends
end
| 30.883905
| 130
| 0.584394
|
4ed61c40a38b3d195ec7785f3f0cee814610f896
| 340
|
asm
|
Assembly
|
libsrc/z80_crt0s/crt0/l_cmp.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/z80_crt0s/crt0/l_cmp.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
libsrc/z80_crt0s/crt0/l_cmp.asm
|
meesokim/z88dk
|
5763c7778f19a71d936b3200374059d267066bb2
|
[
"ClArtistic"
] | null | null | null |
;
; Z80 Runtime Library
;
; Signed integer compare
;
; $Id: l_cmp.asm,v 1.8 2015/01/19 01:33:25 pauloscustodio Exp $:
PUBLIC l_cmp
; signed compare of DE and HL
; carry is sign of difference [set => DE < HL]
; zero is zero/non-zero
.l_cmp
ld a,h
add $80
ld b,a
ld a,d
add $80
cp b
ret nz
ld a,e
cp l
ret
| 13.6
| 64
| 0.605882
|
920eb49e3dd61589d27a930a08e795445f0d8ec1
| 933
|
asm
|
Assembly
|
28-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | 1
|
2016-12-29T06:55:26.000Z
|
2016-12-29T06:55:26.000Z
|
28-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | null | null | null |
28-speed.asm
|
yuwanzeon/human-resource-machine-solutions
|
c95641bf409ed3419f7e71eafac0fcdabecb7204
|
[
"MIT"
] | null | null | null |
-- HUMAN RESOURCE MACHINE PROGRAM --
a:
b:
c:
d:
e:
f:
INBOX
COPYTO 0
INBOX
COPYTO 1
INBOX
COPYTO 2
SUB 1
JUMPN i
COPYFROM 1
SUB 0
JUMPN g
COPYFROM 0
OUTBOX
COPYFROM 1
OUTBOX
COPYFROM 2
OUTBOX
JUMP e
g:
COPYFROM 1
OUTBOX
COPYFROM 0
SUB 2
JUMPN h
COPYFROM 2
OUTBOX
COPYFROM 0
OUTBOX
JUMP d
h:
COPYFROM 0
OUTBOX
COPYFROM 2
OUTBOX
JUMP a
i:
COPYFROM 0
SUB 1
JUMPN j
COPYFROM 2
OUTBOX
COPYFROM 1
OUTBOX
COPYFROM 0
OUTBOX
JUMP b
j:
COPYFROM 0
SUB 2
JUMPN k
COPYFROM 2
OUTBOX
COPYFROM 0
OUTBOX
COPYFROM 1
OUTBOX
JUMP c
k:
COPYFROM 0
OUTBOX
COPYFROM 2
OUTBOX
COPYFROM 1
OUTBOX
JUMP f
| 12.276316
| 36
| 0.476956
|
9244ebaf9fb427f2a112df3e214e7d61224742cc
| 308
|
asm
|
Assembly
|
AssemblyExamples/using_gdb/debug.asm
|
jude-arokiam-uoit/csci-2050-assembly-examples
|
334c89128864e9763d1653702c773ae0effd04d9
|
[
"MIT"
] | 1
|
2019-03-09T23:55:01.000Z
|
2019-03-09T23:55:01.000Z
|
AssemblyExamples/using_gdb/debug.asm
|
jude-arokiam-uoit/csci-2050-assembly-examples
|
334c89128864e9763d1653702c773ae0effd04d9
|
[
"MIT"
] | null | null | null |
AssemblyExamples/using_gdb/debug.asm
|
jude-arokiam-uoit/csci-2050-assembly-examples
|
334c89128864e9763d1653702c773ae0effd04d9
|
[
"MIT"
] | 2
|
2019-04-01T23:57:18.000Z
|
2019-04-02T16:59:14.000Z
|
extern printf
global main
section .text
main:
mov rdi, format ; argument #1
mov rsi, message ; argument #2
mov rax, 0
call printf ; call printf
mov rax, 0
ret ; return 0
section .data
message: db "Hello, world!", 0
format: db "%s", 0xa, 0
courseCode: dq 2050
| 17.111111
| 35
| 0.597403
|
7ce5a98aff7437d5ed413cd1db2d72ce4bcd39ed
| 666
|
asm
|
Assembly
|
libsrc/_DEVELOPMENT/math/integer/z180/l_z180_mulu_24_16x8.asm
|
Toysoft/z88dk
|
f930bef9ac4feeec91a07303b79ddd9071131a24
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/math/integer/z180/l_z180_mulu_24_16x8.asm
|
Toysoft/z88dk
|
f930bef9ac4feeec91a07303b79ddd9071131a24
|
[
"ClArtistic"
] | null | null | null |
libsrc/_DEVELOPMENT/math/integer/z180/l_z180_mulu_24_16x8.asm
|
Toysoft/z88dk
|
f930bef9ac4feeec91a07303b79ddd9071131a24
|
[
"ClArtistic"
] | 1
|
2019-12-03T23:28:20.000Z
|
2019-12-03T23:28:20.000Z
|
; 2018 June feilipu
INCLUDE "config_private.inc"
SECTION code_clib
SECTION code_math
PUBLIC l_z180_mulu_24_16x8
l_z180_mulu_24_16x8:
; multiplication of 16-bit number and 8-bit number into a 24-bit product
;
; enter : hl = 16-bit multiplier = x
; e = 8-bit multiplicand = y
;
; exit : ahl = 24-bit product
; carry reset
;
; uses : af, de, hl
ld d,h ; xh
ld h,e ; yl
mlt hl ; yl*xl
mlt de ; xh*yl
ld a,h ; sum products
add a,e
ld h,a
ld a,d
adc a,0
ret
| 19.028571
| 76
| 0.477477
|
dd92ca8385212de70c8bee98b06a60e7dadd58b7
| 408
|
asm
|
Assembly
|
oeis/116/A116701.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/116/A116701.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/116/A116701.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A116701: Number of permutations of length n that avoid the patterns 132, 4321.
; Submitted by Christian Krause
; 1,1,2,5,13,31,66,127,225,373,586,881,1277,1795,2458,3291,4321,5577,7090,8893,11021,13511,16402,19735,23553,27901,32826,38377,44605,51563,59306,67891,77377,87825,99298,111861,125581,140527,156770,174383,193441,214021
mov $1,4
sub $1,$0
bin $0,2
add $1,$0
mul $1,$0
div $1,3
mov $0,$1
add $0,1
| 31.384615
| 217
| 0.742647
|
adbc8c675ad8ba84e0a68b1248d4e71e23577f92
| 9,138
|
asm
|
Assembly
|
calc-pi-ra.asm
|
cotarr/calc-pi-x86-64-asm
|
1135d8060d3bbcde411cca59587c52287b31ea70
|
[
"MIT"
] | null | null | null |
calc-pi-ra.asm
|
cotarr/calc-pi-x86-64-asm
|
1135d8060d3bbcde411cca59587c52287b31ea70
|
[
"MIT"
] | null | null | null |
calc-pi-ra.asm
|
cotarr/calc-pi-x86-64-asm
|
1135d8060d3bbcde411cca59587c52287b31ea70
|
[
"MIT"
] | null | null | null |
;-------------------------------------------------------------
;
; SINGLE THREAD FLOATING POINT MULTI-PRECISION CALCULATOR
;
; Calculation of Pi using Ramanujan Formula
;
; File: calc-pi-ra.asm
; Module: calc.asm, calc.o
; Exec: calc-pi
;
; Created 11/13/2014
; Last Edit 01/04/2015
;
;-------------------------------------------------------------
; MIT License
;
; Copyright 2014-2020 David Bolenbaugh
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
; The above copyright notice and this permission notice shall be included in all
; copies or substantial portions of the Software.
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
; SOFTWARE.
;-------------------------------------------------------------
; Function_calc_pi_ram:
;-------------------------------------------------------------
;
; Calculation of Pi using the Ramanujan formula
;
; Calculated using fixed point math
;
;===============================
;
; Calculations requires square root of 2 to full accuracy
; XReg must contain sqrt(2) at start calculated externally
;
; Summation Term A: [(4n)!(1103)] / [(n!^4)(396^4)]
;
; Summation Term B: [(4n)!(26360)(n)] / [(n!^4)(396^4)]
;
; Final Divisions pi = (9801/(2*sqrt(2))) / summations
;
; ACC = Sum
;
; Reg0 = Square root of 2 (for now from XREG)
; Reg1 = Term-A (4n)!( 1103 )/(n!)^4(396)^4
; Reg2 = Term-B (4n)!(26390*n)/(n!)^4(396)^4
;
; r15 = n
; r14 = 4n for running 4n! calculation
; r13 = (396)^4 = 24,591,257,856
; r12 - Flag, term B done
; r11 - Flag, term A done
;
; ACC contains result, copied to Xreg
;
Function_calc_pi_ram:
push rax ; General use
push rbx ; Pass data to display update counter
push rcx ; Loop counter
push rsi ; Variable handle number
push rdi ; Variable handle number
push r11 ; Flag Term A done
push r12 ; Flag Term B done
push r13 ; Holds (396)^4
push r14 ; 4n for running 4n! calculation
push r15 ; n counter
; mov rax, .msg_pi ;Print calculaton on screen
; call StrOut
;
;^^^^^^^^^^^^^^^^^^^^^^ Watch Progress ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
mov rbx, [iShowCalcStep] ; print each 100 term
mov rax, 0x06000000 ; set skip counter from rbx
call ShowCalcProgress ; initialize
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
;
; Initialize Register Variables
;
;
; At program start square root 2 expected in XREG
; Move square root of 2 from XREG to Reg0
;
mov rsi, HAND_XREG ; * * * XREG must contain Sqrt(2) at start
mov rdi, HAND_REG0
call CopyVariable ; Reg0 = sqrt(2)
;
; X-Reg: (Sum) Initialize to hold 1103 for term #0, Sum will start with term n=1
;
mov rsi, HAND_ACC
mov rax, 1103
call FIX_Load64BitNumber
;
; Reg1 (Term A) Initialize to 1103 n=0 in Term-A
;
mov rsi, HAND_REG1
mov rax, 1103
call FIX_Load64BitNumber
;
; Reg2 (Term B) Initialize to 25390 n=0 in Term-B
;
mov rsi, HAND_REG2
mov rax, 26390
call FIX_Load64BitNumber ; Reg2 = 26390
;
; Initialize to 0 for summation index n at term 0
;
mov r15, 0 ; R15 = 0 (n)
mov r14, 0 ; R14 = 0 (4n)
mov r13, (396*396*396*396) ; R13 = (396^4)
mov r12, 0 ; flag tern B not done
mov r11, 0 ; flag term A not done
;
;
; * * * * * * * * * * * * * * *
;
; M A I N L O O P
;
; * * * * * * * * * * * * * * *
;
;
.loop:
;
; Increment n in r15
;
inc r15 ; n = n+1;
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
; F I R S T T E R M A
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
; Skip if term was previously zero
;
or r11, r11 ; R11 flag for Term A done
jnz .skip05
;
; Using r14, build the (4n)! in numerator
;
mov rsi, HAND_REG1 ; RSI is Variable handle number
mov rcx, 4 ; RCX is couner for LOOP command
.loopx1:
inc r14 ; Previous n counter value
mov rax, r14 ; Input for division
call FIX_US_Multiplication ; Reg1 = Reg1 * RAX
loop .loopx1 ; Decrement RCX, loop again
sub r14, 4 ; reduce by 4 for use with term B
;
; Using n, build (n!)^4 in denominator
;
mov rcx, 4 ; REX is counter for LOOP command
.loopx2:
mov rax, r15 ; R15 = n
call FIX_US_Division ; Reg1 = Reg1 / RAX
loop .loopx2
;
; Divide to build (396)^(4n) in denominator)
;
mov rax, r13 ; RAX = (396)^4
call FIX_US_Division ; Reg1 = Reg1 / RAX
.skip05:
;
; At this point term-A is complete
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
; S E C O N D T E R M B
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
; Skip if term was previously zero
;
or r12, r12 ; R12 is flag for Term B done
jnz .skip07
;
; Using r14, build the (4n)! in numerator
;
mov rsi, HAND_REG2 ; RSI is variable handle number
mov rcx, 4 ; RCX is counter for LOOP command
.loopx3:
inc r14 ; R14 is n counter value
mov rax, r14 ; RAX input for multiplication
call FIX_US_Multiplication ; Reg2 = Reg2 / RAX
loop .loopx3 ; Decrement RCX and loop again
;
; Divide by previous by n-1 in numerator
;
mov rax, r15 ; RAX = n
dec rax ; RAX = n-1 to cancel previous term n
or rax, rax ; Skip term n=1 --> n=0 --> division by zero
jz .skip06 ; for term n=1 (first loop)
call FIX_US_Division ; Reg2 = Reg2 / RAX
.skip06:
;
; Multiply by n in numerator, will be reversed next loop by division
;
mov rax, r15 ; RAX = n
call FIX_US_Multiplication ; Reg2 = Reg2 / RAX
;
; Using n, build (n!)^4 in denominator
;
mov rcx, 4 ; RCX is loop couner
.loopx4:
mov rax, r15 ; R15 = n value
call FIX_US_Division ; Reg2 = Reg2 / RAX
loop .loopx4 ; Dec RCX and loop again
;
; Divide to build (396)^(4n) in denominator)
;
mov rax, r13 ; RAX = (396)^4
call FIX_US_Division ; Reg2 = Reg2 / RAX
.skip07:
;
; At this point term-B is complete
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
; Perform summation
;
;&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
;
;
; Add term-A to sum
;
or r11, r11
jnz .skip08
mov rsi, HAND_ACC
mov rdi, HAND_REG1
call FIX_Addition ; ACC = ACC + Reg1
.skip08:
;
; Add term-B to sum
;
or r12, r12
jnz .skip09
mov rsi, HAND_ACC
mov rdi, HAND_REG2
call FIX_Addition ; ACC = ACC + Reg2
.skip09:
;
;^^^^^^^^^^^^^^^^^^^^^^ Watch Progress ^^^^^^^^^^^^^^^^^^^
; -Print-- Inc/Rset -Format-
mov rax, (0x01110101 | 0x00000404 | 0x60000000 )
call ShowCalcProgress
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
;
; Debug
;www
; CMP r15, 3
; JE .done
; JMP .loop
;
; Check if done
;
mov rsi, HAND_REG1
call FIX_Check_Sum_Done ; is Term A significant?
mov r11, rax
mov rsi, HAND_REG2
call FIX_Check_Sum_Done ; is Term B significant?
mov r12, rax
ADD rax, r11 ; When done 1+1=2
CMP rax, 2 ; Done?
JNE .loop ; no, not 2, loop again
; ; else done
.done:
;
;^^^^^^^^^^^^^^^^^^^^^^ Watch Progress ^^^^^^^^^^^^^^^^^^^
; -Print-- Inc/Rset -Format-
mov rax, (0x00030303 | 0x00000800 | 0x30000000 )
call ShowCalcProgress
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
;
; In future will do [1/root(2)] / ACC
; So it is simple to divide by 9801 and mult x 2
;
mov rsi, HAND_ACC
mov rax, 9801
call FIX_US_Division ; ACC = ACC / 9801
;
mov rax, 2
call FIX_US_Multiplication ; ACC = ACC * 2
;
; Convert FIX to FP numbers
;
mov rsi, HAND_ACC
call Conv_FIX_to_FP
; mov rsi, HAND_REG1
; call Conv_FIX_to_FP
; mov rsi, HAND_REG2
; call Conv_FIX_to_FP
;
; Place 1 in OPR, divide by ACC
;
mov rsi, HAND_OPR
call SetToOne
call FP_Division ; ACC = Oper / ACC which is 1/sum
;
; Move ACC-->OPR, copy square root 2 from REG0 to ACC and divide sqrt(2)
;
mov rsi, HAND_ACC
mov rdi, HAND_OPR
call CopyVariable
mov rsi, HAND_REG0 ; Reg0 contains square root of 2
mov rdi, HAND_ACC
call CopyVariable
call FP_Division ; ACC = OPR/ACC Divide by square root 2
;
; Move result back to XReg
;
mov rsi, HAND_ACC
mov rdi, HAND_XREG
call CopyVariable ; XReg = Pi (Done)
;
; Clear Temporary Variables
;
mov rsi, HAND_REG0
call ClearVariable
mov rsi, HAND_REG1
call ClearVariable
mov rsi, HAND_REG2
call ClearVariable
;
; For debug
;
.exit:
;^^^^^^^^^^^^^^^^^^^^^^ Watch Progress ^^^^^^^^^^^^^^^^^^^
; -Print-- Inc/Rset -Format-
mov rax, (0x000F0303 | 0x00000000 | 0x30000000 )
call ShowCalcProgress
;^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pop r15
pop r14
pop r13
pop r12
pop r11
pop rdi
pop rsi
pop rcx
pop rbx
pop rax
ret
.msg_pi: DB 0xD, 0xA, 0xA, "Calculating Pi using Ramanujan formula", 0xD, 0xA, 0
| 25.383333
| 80
| 0.600897
|
cdcbdf25c557ecd5b53d5e8879800ccffdf627c3
| 268
|
asm
|
Assembly
|
ASM/src/every_frame.asm
|
deralex/Better-OoT
|
e8ed08ddd81f4921b6d1dd35cdad31e2ad9a3b7d
|
[
"MIT"
] | 75
|
2018-11-19T17:08:29.000Z
|
2022-03-04T12:37:51.000Z
|
ASM/src/every_frame.asm
|
deralex/Better-OoT
|
e8ed08ddd81f4921b6d1dd35cdad31e2ad9a3b7d
|
[
"MIT"
] | 13
|
2019-01-01T16:20:14.000Z
|
2021-12-27T01:10:13.000Z
|
ASM/src/every_frame.asm
|
deralex/Better-OoT
|
e8ed08ddd81f4921b6d1dd35cdad31e2ad9a3b7d
|
[
"MIT"
] | 16
|
2018-11-27T19:57:15.000Z
|
2022-01-24T17:42:56.000Z
|
before_game_state_update_hook:
addiu sp, sp, -0x18
sw ra, 0x10 (sp)
jal before_game_state_update
nop
lw ra, 0x10 (sp)
addiu sp, sp, 0x18
; Displaced code
lw t6, 0x0018 (sp)
jr ra
lui at, 0x8010
| 19.142857
| 36
| 0.541045
|
df781619412ec1cc8d9867347a5c1f2be5117cad
| 356
|
asm
|
Assembly
|
oeis/191/A191488.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/191/A191488.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/191/A191488.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A191488: A companion to Gould’s sequence A001316.
; Submitted by Jon Maiga
; 4,6,8,10,8,12,16,18,8,12,16,20,16,24,32,34,8,12,16,20,16,24,32,36,16,24,32,40,32,48,64,66,8,12,16,20,16,24,32,36,16,24,32,40,32,48,64,68,16,24,32,40,32,48,64,72,32,48,64,80,64,96,128
mul $0,2
add $0,2
seq $0,105321 ; Convolution of binomial(1,n) and Gould's sequence A001316.
| 44.5
| 184
| 0.691011
|
00f74d2ed07ee73d280fea408b06ae9ba5c34d32
| 334
|
asm
|
Assembly
|
programs/oeis/139/A139698.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | 1
|
2021-03-15T11:38:20.000Z
|
2021-03-15T11:38:20.000Z
|
programs/oeis/139/A139698.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
programs/oeis/139/A139698.asm
|
karttu/loda
|
9c3b0fc57b810302220c044a9d17db733c76a598
|
[
"Apache-2.0"
] | null | null | null |
; A139698: Binomial transform of [1, 25, 25, 25, ...].
; 1,26,76,176,376,776,1576,3176,6376,12776,25576,51176,102376,204776,409576,819176,1638376,3276776,6553576,13107176,26214376,52428776,104857576,209715176,419430376,838860776,1677721576,3355443176,6710886376,13421772776,26843545576
mov $1,2
pow $1,$0
sub $1,1
mul $1,25
add $1,1
| 37.111111
| 230
| 0.769461
|
584d1178b0c586d5566af2d0a8cba0add75dd99d
| 727
|
asm
|
Assembly
|
oeis/258/A258547.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 11
|
2021-08-22T19:44:55.000Z
|
2022-03-20T16:47:57.000Z
|
oeis/258/A258547.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 9
|
2021-08-29T13:15:54.000Z
|
2022-03-09T19:52:31.000Z
|
oeis/258/A258547.asm
|
neoneye/loda-programs
|
84790877f8e6c2e821b183d2e334d612045d29c0
|
[
"Apache-2.0"
] | 3
|
2021-08-22T20:56:47.000Z
|
2021-09-29T06:26:12.000Z
|
; A258547: Number of (n+1)X(1+1) 0..1 arrays with every 2X2 subblock ne-sw antidiagonal difference nondecreasing horizontally and nw+se diagonal sum nondecreasing vertically
; 16,44,104,228,480,988,2008,4052,8144,16332,32712,65476,131008,262076,524216,1048500,2097072,4194220,8388520,16777124,33554336,67108764,134217624,268435348,536870800,1073741708,2147483528,4294967172,8589934464,17179869052,34359738232,68719476596,137438953328,274877906796,549755813736,1099511627620,2199023255392,4398046510940,8796093022040,17592186044244,35184372088656,70368744177484,140737488355144,281474976710468,562949953421120,1125899906842428,2251799813685048,4503599627370292
add $0,3
mov $1,2
pow $1,$0
sub $1,$0
sub $1,1
mul $1,4
mov $0,$1
| 66.090909
| 485
| 0.84044
|
ba42c200f5faa4c44cfcb7a2229e6613ace35cab
| 2,667
|
asm
|
Assembly
|
Kernel/asm/interrupts.asm
|
Khato1319/naiveOS
|
1be1e941863b26641f0c94dec3b89178979addee
|
[
"BSD-3-Clause"
] | null | null | null |
Kernel/asm/interrupts.asm
|
Khato1319/naiveOS
|
1be1e941863b26641f0c94dec3b89178979addee
|
[
"BSD-3-Clause"
] | null | null | null |
Kernel/asm/interrupts.asm
|
Khato1319/naiveOS
|
1be1e941863b26641f0c94dec3b89178979addee
|
[
"BSD-3-Clause"
] | null | null | null |
GLOBAL _cli
GLOBAL _sti
GLOBAL picMasterMask
GLOBAL picSlaveMask
GLOBAL haltcpu
GLOBAL _hlt
GLOBAL _irq00Handler
GLOBAL _irq01Handler
GLOBAL _irq02Handler
GLOBAL _irq03Handler
GLOBAL _irq04Handler
GLOBAL _irq05Handler
GLOBAL _exception00Handler
GLOBAL _exception06Handler
GLOBAL _sysCallHandlerMaster
EXTERN irqDispatcher
EXTERN exceptionDispatcher
EXTERN sysCallDispatcher
SECTION .text
%macro pushState 0
push rax
push rbx
push rcx
push rdx
push rbp
push rdi
push rsi
push r8
push r9
push r10
push r11
push r12
push r13
push r14
push r15
%endmacro
%macro popState 0
pop r15
pop r14
pop r13
pop r12
pop r11
pop r10
pop r9
pop r8
pop rsi
pop rdi
pop rbp
pop rdx
pop rcx
pop rbx
pop rax
%endmacro
%macro pushStateSysCall 0
push rbx
push rcx
push rdx
push rbp
push rdi
push rsi
push r8
push r9
push r10
push r11
push r12
push r13
push r14
push r15
%endmacro
%macro popStateSysCall 0
pop r15
pop r14
pop r13
pop r12
pop r11
pop r10
pop r9
pop r8
pop rsi
pop rdi
pop rbp
pop rdx
pop rcx
pop rbx
%endmacro
%macro irqHandlerMaster 1
push rsp
pushState
mov rdi, %1 ; pasaje de parametro
mov rsi, rsp
call irqDispatcher
; ; signal pic EOI (End of Interrupt)
mov al, 20h
out 20h, al
popState
pop rsp
iretq
%endmacro
_sysCallHandlerMaster:
cli
pushStateSysCall
;sti
mov r8, rax ; el 4to argumento de sysCallDispatcher tendra el valor de rax
call sysCallDispatcher ; me llamaron a la syscall int 80h con los argumentos en registros rdi, rsi, rdx, rax. Llamo a la funcion 'sysCallDispatcher' que se encarga de manejar la llamada y retorna en rax el valor de retorno
popStateSysCall
;cli
sti
iretq
%macro exceptionHandler 1
push rsp
pushState
mov rdi, %1 ; pasaje de parametro
mov rsi, rsp ; puntero a los registros
call exceptionDispatcher
popState
pop rsp
iretq
%endmacro
_hlt:
sti
hlt
ret
_cli:
cli
ret
_sti:
sti
ret
picMasterMask:
push rbp
mov rbp, rsp
mov ax, di
out 21h,al
pop rbp
retn
picSlaveMask:
push rbp
mov rbp, rsp
mov ax, di ; ax = mascara de 16 bits
out 0A1h,al
pop rbp
retn
;8254 Timer (Timer Tick)
_irq00Handler:
irqHandlerMaster 0
;Keyboard
_irq01Handler:
irqHandlerMaster 1
; ;Cascade pic never called
; _irq02Handler:
; irqHandlerMaster 2
; ;Serial Port 2 and 4
; _irq03Handler:
; irqHandlerMaster 3
; ;Serial Port 1 and 3
; _irq04Handler:
; irqHandlerMaster 4
; ;USB
; _irq05Handler:
; irqHandlerMaster 5
;Zero Division Exception
_exception00Handler:
exceptionHandler 0
_exception06Handler:
exceptionHandler 6
haltcpu:
cli
hlt
ret
SECTION .bss
aux resq 1
| 12.521127
| 223
| 0.738658
|
86b92a14acd12d794f4eb0642a45fedf85b53531
| 1,041
|
asm
|
Assembly
|
programs/oeis/014/A014771.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 22
|
2018-02-06T19:19:31.000Z
|
2022-01-17T21:53:31.000Z
|
programs/oeis/014/A014771.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 41
|
2021-02-22T19:00:34.000Z
|
2021-08-28T10:47:47.000Z
|
programs/oeis/014/A014771.asm
|
neoneye/loda
|
afe9559fb53ee12e3040da54bd6aa47283e0d9ec
|
[
"Apache-2.0"
] | 5
|
2021-02-24T21:14:16.000Z
|
2021-08-09T19:48:05.000Z
|
; A014771: Squares of odd hexagonal numbers.
; 1,225,2025,8281,23409,53361,105625,189225,314721,494209,741321,1071225,1500625,2047761,2732409,3575881,4601025,5832225,7295401,9018009,11029041,13359025,16040025,19105641,22591009,26532801,30969225,35940025,41486481,47651409,54479161,62015625,70308225,79405921,89359209,100220121,112042225,124880625,138791961,153834409,170067681,187553025,206353225,226532601,248157009,271293841,296012025,322382025,350475841,380367009,412130601,445843225,481583025,519429681,559464409,601769961,646430625,693532225,743162121,795409209,850363921,908118225,968765625,1032401161,1099121409,1169024481,1242210025,1318779225,1398834801,1482481009,1569823641,1660970025,1756029025,1855111041,1958328009,2065793401,2177622225,2293931025,2414837881,2540462409,2670925761,2806350625,2946861225,3092583321,3243644209,3400172721,3562299225,3730155625,3903875361,4083593409,4269446281,4461572025,4660110225,4865202001,5076990009,5295618441,5521233025,5753981025,5994011241,6241474009
mul $0,4
add $0,2
bin $0,2
pow $0,2
| 130.125
| 958
| 0.876081
|
2e895987cc0b0d0baf2dd54fb4a97e897f3f99dc
| 3,300
|
asm
|
Assembly
|
Verilog/P5 - 副本 (2)/test/test_P4+.asm
|
JJLeo/BUAA-CO-2020
|
1d1a3797f7188530464a1dfbe8a017dd01bb817a
|
[
"MIT"
] | 9
|
2021-03-04T07:22:24.000Z
|
2021-11-30T02:56:08.000Z
|
Verilog/P5/test/test_P4+.asm
|
johnnyamazing/BUAA-CO-2020
|
1d1a3797f7188530464a1dfbe8a017dd01bb817a
|
[
"MIT"
] | null | null | null |
Verilog/P5/test/test_P4+.asm
|
johnnyamazing/BUAA-CO-2020
|
1d1a3797f7188530464a1dfbe8a017dd01bb817a
|
[
"MIT"
] | 3
|
2021-09-28T07:41:35.000Z
|
2021-12-14T08:55:28.000Z
|
subu $28 $28 $28
subu $29 $29 $29
ori $0, $0, 0
ori $1, $1, 1
ori $2, $2, 2
ori $3, $3, 3
ori $4, $4, 4
ori $5, $5, 5
ori $6, $6, 6
ori $7, $7, 7
ori $8, $8, 8
ori $9, $9, 9
ori $10, $10, 10
ori $11, $11, 11
ori $12, $12, 12
ori $13, $13, 13
ori $14, $14, 14
ori $15, $15, 15
ori $16, $16, 16
ori $17, $17, 17
ori $18, $18, 18
ori $19, $19, 19
ori $20, $20, 20
ori $21, $21, 21
ori $22, $22, 22
ori $23, $23, 23
ori $24, $24, 24
ori $25, $25, 25
ori $26, $26, 26
ori $27, $27, 27
ori $28, $28, 28
ori $29, $29, 29
ori $30, $30, 30
ori $31, $31, 31
ori $1, $1, 1
sw $1, 4($0)
sw $1, 8($0)
sw $1, 12($0)
sw $1, 16($0)
sw $1, 20($0)
sw $1, 24($0)
sw $1, 28($0)
sw $1, 32($0)
sw $1, 36($0)
sw $1, 40($0)
sw $1, 44($0)
sw $1, 48($0)
sw $1, 52($0)
sw $1, 56($0)
sw $1, 60($0)
sw $1, 64($0)
sw $1, 68($0)
sw $1, 72($0)
sw $1, 76($0)
sw $1, 80($0)
sw $1, 84($0)
sw $1, 88($0)
sw $1, 92($0)
sw $1, 96($0)
sw $1, 100($0)
sw $1, 104($0)
sw $1, 108($0)
sw $1, 112($0)
sw $1, 116($0)
sw $1, 120($0)
sw $1, 124($0)
ori $1, $1, 1
sw $1, 0($0)
lw $2, 0($0)
lw $3, 0($0)
lw $4, 0($0)
lw $5, 0($0)
lw $6, 0($0)
lw $7, 0($0)
lw $8, 0($0)
lw $9, 0($0)
lw $10, 0($0)
lw $11, 0($0)
lw $12, 0($0)
lw $13, 0($0)
lw $14, 0($0)
lw $15, 0($0)
lw $16, 0($0)
lw $17, 0($0)
lw $18, 0($0)
lw $19, 0($0)
lw $20, 0($0)
lw $21, 0($0)
lw $22, 0($0)
lw $23, 0($0)
lw $24, 0($0)
lw $25, 0($0)
lw $26, 0($0)
lw $27, 0($0)
lw $28, 0($0)
lw $29, 0($0)
lw $30, 0($0)
lw $31, 0($0)
ori $1 $1 907
sw $0 0($0)
lw $1 0($0)
sw $1 4($0)
lw $2 4($0)
sw $2 8($0)
lw $3 8($0)
sw $3 12($0)
lw $4 12($0)
sw $4 16($0)
lw $5 16($0)
sw $5 20($0)
lw $6 20($0)
sw $6 24($0)
lw $7 24($0)
sw $7 28($0)
lw $8 28($0)
sw $8 32($0)
lw $9 32($0)
sw $9 36($0)
lw $10 36($0)
sw $10 40($0)
lw $11 40($0)
sw $11 44($0)
lw $12 44($0)
sw $12 48($0)
lw $13 48($0)
sw $13 52($0)
lw $14 52($0)
sw $14 56($0)
lw $15 56($0)
sw $15 60($0)
lw $16 60($0)
sw $16 64($0)
lw $17 64($0)
sw $17 68($0)
lw $18 68($0)
sw $18 72($0)
lw $19 72($0)
sw $19 76($0)
lw $20 76($0)
sw $20 80($0)
lw $21 80($0)
sw $21 84($0)
lw $22 84($0)
sw $22 88($0)
lw $23 88($0)
sw $23 92($0)
lw $24 92($0)
sw $24 96($0)
lw $25 96($0)
sw $25 100($0)
lw $26 100($0)
sw $26 104($0)
lw $27 104($0)
sw $27 108($0)
lw $28 108($0)
sw $28 112($0)
lw $29 112($0)
sw $29 116($0)
lw $30 116($0)
sw $30 120($0)
lw $31 120($0)
sw $31 124($0)
lui $1 234
lui $2 234
lui $3 234
lui $4 234
lui $5 234
lui $6 234
lui $7 234
lui $8 234
lui $9 234
lui $10 234
lui $11 234
lui $12 234
lui $13 234
lui $14 234
lui $15 234
jal con
nop
lui $1 222
subu $16 $16 $1
subu $17 $17 $1
subu $18 $18 $1
subu $19 $19 $1
subu $20 $20 $1
subu $21 $21 $1
subu $22 $22 $1
subu $23 $23 $1
subu $24 $24 $1
subu $25 $25 $1
subu $26 $26 $1
subu $27 $27 $1
subu $28 $28 $1
subu $29 $29 $1
subu $30 $30 $1
jal end
nop
con:
addu $16 $16 $1
addu $17 $17 $2
addu $18 $18 $3
addu $19 $19 $4
addu $20 $20 $5
addu $21 $21 $6
addu $22 $22 $7
addu $23 $23 $8
addu $24 $24 $9
addu $25 $25 $10
addu $26 $26 $11
addu $27 $27 $12
addu $28 $28 $13
addu $29 $29 $14
addu $30 $30 $15
jr $31
nop
end:
ori $1 $0 1
ori $2 $0 2
beq $1 $2 beq1
nop
addu $1 $1 $1
beq1:
ori $12 $0 1
ori $13 $0 1
beq $12 $13 beq2
nop
addu $2 $2 $2
beq2:
jal con2
nop
jal end2
nop
addu $6 $6 $6
jal end2
nop
con2:
addu $15 $0 $31
ori $5 $0 4
addu $31 $31 $5
jr $15
nop
addu $1 $1 $1
end2:
| 13.580247
| 16
| 0.508182
|
2c81462844c4dc6e261a0bf6cdbd2668c5987bc3
| 5,443
|
asm
|
Assembly
|
Transynther/x86/_processed/AVXALIGN/_st_/i9-9900K_12_0xca_notsx.log_21829_1304.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_1304.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_1304.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 %r12
push %r13
push %r14
push %rbp
push %rbx
push %rcx
push %rdi
push %rdx
push %rsi
lea addresses_D_ht+0x7c1d, %r12
nop
nop
nop
nop
and %rcx, %rcx
mov (%r12), %rbp
nop
nop
nop
cmp $46162, %rdx
lea addresses_WC_ht+0xbd9f, %r14
add $32659, %r13
movw $0x6162, (%r14)
nop
nop
sub $46573, %rdx
lea addresses_WC_ht+0x1071d, %rsi
lea addresses_WC_ht+0x14c11, %rdi
nop
nop
nop
inc %r12
mov $24, %rcx
rep movsb
nop
nop
nop
nop
dec %rbx
lea addresses_UC_ht+0x2e03, %rsi
lea addresses_D_ht+0x1a05d, %rdi
nop
nop
and %r14, %r14
mov $115, %rcx
rep movsw
nop
nop
xor $57799, %r13
lea addresses_A_ht+0x3285, %rdx
nop
nop
nop
nop
and %rdi, %rdi
mov (%rdx), %cx
nop
nop
nop
sub %rcx, %rcx
lea addresses_WT_ht+0x1c9f1, %rsi
lea addresses_normal_ht+0x6d1d, %rdi
nop
nop
nop
nop
nop
and %r13, %r13
mov $90, %rcx
rep movsb
nop
nop
nop
nop
xor $31011, %rdx
pop %rsi
pop %rdx
pop %rdi
pop %rcx
pop %rbx
pop %rbp
pop %r14
pop %r13
pop %r12
ret
.global s_faulty_load
s_faulty_load:
push %r10
push %r11
push %r12
push %r14
push %r15
push %r8
// Faulty Load
lea addresses_A+0x10f1d, %r10
nop
nop
nop
nop
nop
xor %r12, %r12
mov (%r10), %r14
lea oracles, %r10
and $0xff, %r14
shlq $12, %r14
mov (%r10,%r14,1), %r14
pop %r8
pop %r15
pop %r14
pop %r12
pop %r11
pop %r10
ret
/*
<gen_faulty_load>
[REF]
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A', 'NT': False, 'AVXalign': False, 'size': 32, 'congruent': 0}}
[Faulty Load]
{'OP': 'LOAD', 'src': {'same': True, 'type': 'addresses_A', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 0}}
<gen_prepare_buffer>
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_D_ht', 'NT': True, 'AVXalign': False, 'size': 8, 'congruent': 6}}
{'OP': 'STOR', 'dst': {'same': False, 'type': 'addresses_WC_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 1}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 8, 'type': 'addresses_WC_ht'}, 'dst': {'same': False, 'congruent': 1, 'type': 'addresses_WC_ht'}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 1, 'type': 'addresses_UC_ht'}, 'dst': {'same': False, 'congruent': 6, 'type': 'addresses_D_ht'}}
{'OP': 'LOAD', 'src': {'same': False, 'type': 'addresses_A_ht', 'NT': False, 'AVXalign': False, 'size': 2, 'congruent': 2}}
{'OP': 'REPM', 'src': {'same': False, 'congruent': 2, 'type': 'addresses_WT_ht'}, 'dst': {'same': False, 'congruent': 8, 'type': 'addresses_normal_ht'}}
{'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
*/
| 40.318519
| 2,999
| 0.661033
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.