Array.inc
;
; Реализация среды исполнения языка программирования
; Объектно-ориентированный продвинутый векторный транслятор
;
; Copyright © 2021, 2024, 2026 Малик Разработчик
;
; Это свободная программа: вы можете перераспространять ее и/или изменять
; ее на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
; в каком она была опубликована Фондом свободного программного обеспечения;
; либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
;
; Эта программа распространяется в надежде, что она будет полезной,
; но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
; или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
; общественной лицензии GNU.
;
; Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
; вместе с этой программой. Если это не так, см.
; <https://www.gnu.org/licenses/>.
;
; <fold avt.lang.Array — родной код>
if(used avt.lang.Array$indexOf$boolean$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOf$boolean$boolean.01d$int$int$, \
avt.lang.Array$indexOf$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$indexOf$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOf$int$char.01d$int$int$, \
avt.lang.Array$indexOf$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$indexOf$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOf$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, byte [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*1+$00]
cld
repne scasb
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$01]
sub r00q, r06q
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOf$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOf$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, word [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*2+$00]
cld
repne scasw
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$02]
sub r00q, r06q
sar r00q, $01
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOf$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOf$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsxd r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*4+$00]
cld
repne scasd
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$04]
sub r00q, r06q
sar r00q, $02
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOf$long$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOf$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: mov r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*8+$00]
cld
repne scasq
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$08]
sub r00q, r06q
sar r00q, $03
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOf$avt.lang.Object$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOf$avt.lang.Object$avt.lang.Object.01d$int$int$, \
avt.lang.Array$indexOf$long$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$boolean$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOf$boolean$boolean.01d$int$int$, \
avt.lang.Array$lastIndexOf$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOf$int$char.01d$int$int$, \
avt.lang.Array$lastIndexOf$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOf$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, byte [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*1+$00]
std
repne scasb
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$01]
sub r00q, r06q
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOf$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, word [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*2+$00]
std
repne scasw
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$02]
sub r00q, r06q
sar r00q, $01
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOf$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsxd r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*4+$00]
std
repne scasd
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$04]
sub r00q, r06q
sar r00q, $02
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$long$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOf$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: mov r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*8+$00]
std
repne scasq
je .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$08]
sub r00q, r06q
sar r00q, $03
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOf$avt.lang.Object$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOf$avt.lang.Object$avt.lang.Object.01d$int$int$, \
avt.lang.Array$lastIndexOf$long$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$indexOfNon$boolean$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOfNon$boolean$boolean.01d$int$int$, \
avt.lang.Array$indexOfNon$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$indexOfNon$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOfNon$int$char.01d$int$int$, \
avt.lang.Array$indexOfNon$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$indexOfNon$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOfNon$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, byte [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*1+$00]
cld
repe scasb
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$01]
sub r00q, r06q
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOfNon$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOfNon$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, word [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*2+$00]
cld
repe scasw
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$02]
sub r00q, r06q
sar r00q, $01
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOfNon$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOfNon$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsxd r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*4+$00]
cld
repe scasd
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$04]
sub r00q, r06q
sar r00q, $02
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOfNon$long$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$indexOfNon$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r01d
jge .L.0000
sub r01d, r02d
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: mov r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*8+$00]
cld
repe scasq
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07-$08]
sub r00q, r06q
sar r00q, $03
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$indexOfNon$avt.lang.Object$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$indexOfNon$avt.lang.Object$avt.lang.Object.01d$int$int$, \
avt.lang.Array$indexOfNon$long$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$boolean$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOfNon$boolean$boolean.01d$int$int$, \
avt.lang.Array$lastIndexOfNon$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOfNon$int$char.01d$int$int$, \
avt.lang.Array$lastIndexOfNon$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOfNon$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, byte [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*1+$00]
std
repe scasb
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$01]
sub r00q, r06q
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOfNon$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsx r00q, word [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*2+$00]
std
repe scasw
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$02]
sub r00q, r06q
sar r00q, $01
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOfNon$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: movsxd r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*4+$00]
std
repe scasd
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$04]
sub r00q, r06q
sar r00q, $02
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$long$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$lastIndexOfNon$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r07q, [.array]
test r07q, r07q
jz .L.0000
mov r01d, [r07+avt.lang.Array$fldLength]
mov r02d, [.startFromIndex]
cmp r02d, r01d
jl @F
lea r02d, [r01d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r02d+$01]
mov r06d, [.maximumScanLength]
cmp r06d, $00
jle @F
cmp r01d, r06d
jle @F
mov r01d, r06d
@@: mov r00q, [.value]
lea r06q, [r07+$40]
add r06q, [r06+avt.lang.Array$fldOffset-$40]
lea r07q, [r06+r02*8+$00]
std
repe scasq
jne .L.0001
.L.0000: mov r00d, -$01
jmp .L.EXIT
.L.0001: lea r00q, [r07+$08]
sub r00q, r06q
sar r00q, $03
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$lastIndexOfNon$avt.lang.Object$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$lastIndexOfNon$avt.lang.Object$avt.lang.Object.01d$int$int$, \
avt.lang.Array$lastIndexOfNon$long$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$boolean.01d$int$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfEqual$boolean.01d$int$boolean.01d$int$int$, \
avt.lang.Array$offsetOfEqual$byte.01d$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$char.01d$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfEqual$char.01d$int$char.01d$int$int$, \
avt.lang.Array$offsetOfEqual$short.01d$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$byte.01d$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfEqual$byte.01d$int$byte.01d$int$int$, \
array0, byte.01d, \
array0StartFromIndex, int, \
array1, byte.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*1+$00]
lea r07q, [r09+r02*1+$00]
cld
repne cmpsb
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$01]
sub r00q, r09q
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$short.01d$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfEqual$short.01d$int$short.01d$int$int$, \
array0, short.01d, \
array0StartFromIndex, int, \
array1, short.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*2+$00]
lea r07q, [r09+r02*2+$00]
cld
repne cmpsw
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$02]
sub r00q, r09q
sar r00q, $01
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$int.01d$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfEqual$int.01d$int$int.01d$int$int$, \
array0, int.01d, \
array0StartFromIndex, int, \
array1, int.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*4+$00]
lea r07q, [r09+r02*4+$00]
cld
repne cmpsd
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$04]
sub r00q, r09q
sar r00q, $02
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$long.01d$int$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfEqual$long.01d$int$long.01d$int$int$, \
array0, long.01d, \
array0StartFromIndex, int, \
array1, long.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*8+$00]
lea r07q, [r09+r02*8+$00]
cld
repne cmpsq
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$08]
sub r00q, r09q
sar r00q, $03
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$, \
avt.lang.Array$offsetOfEqual$long.01d$int$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$boolean.01d$int$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfNonEqual$boolean.01d$int$boolean.01d$int$int$, \
avt.lang.Array$offsetOfNonEqual$byte.01d$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$char.01d$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfNonEqual$char.01d$int$char.01d$int$int$, \
avt.lang.Array$offsetOfNonEqual$short.01d$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$byte.01d$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfNonEqual$byte.01d$int$byte.01d$int$int$, \
array0, byte.01d, \
array0StartFromIndex, int, \
array1, byte.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*1+$00]
lea r07q, [r09+r02*1+$00]
cld
repe cmpsb
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$01]
sub r00q, r09q
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$short.01d$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfNonEqual$short.01d$int$short.01d$int$int$, \
array0, short.01d, \
array0StartFromIndex, int, \
array1, short.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*2+$00]
lea r07q, [r09+r02*2+$00]
cld
repe cmpsw
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$02]
sub r00q, r09q
sar r00q, $01
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$int.01d$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfNonEqual$int.01d$int$int.01d$int$int$, \
array0, int.01d, \
array0StartFromIndex, int, \
array1, int.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*4+$00]
lea r07q, [r09+r02*4+$00]
cld
repe cmpsd
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$04]
sub r00q, r09q
sar r00q, $02
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$long.01d$int$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$offsetOfNonEqual$long.01d$int$long.01d$int$int$, \
array0, long.01d, \
array0StartFromIndex, int, \
array1, long.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, $00
jge @F
xor r00d, r00d
@@: cmp r00d, r01d
jge .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, $00
jge @F
xor r02d, r02d
@@: cmp r02d, r08d
jge .L.0000
sub r01d, r00d
sub r08d, r02d
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*8+$00]
lea r07q, [r09+r02*8+$00]
cld
repe cmpsq
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07-$08]
sub r00q, r09q
sar r00q, $03
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$offsetOfNonEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$offsetOfNonEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$, \
avt.lang.Array$offsetOfNonEqual$long.01d$int$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$boolean.01d$int$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfEqual$boolean.01d$int$boolean.01d$int$int$, \
avt.lang.Array$negOffsetOfEqual$byte.01d$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$char.01d$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfEqual$char.01d$int$char.01d$int$int$, \
avt.lang.Array$negOffsetOfEqual$short.01d$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$byte.01d$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfEqual$byte.01d$int$byte.01d$int$int$, \
array0, byte.01d, \
array0StartFromIndex, int, \
array1, byte.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*1+$00]
lea r07q, [r09+r02*1+$00]
std
repne cmpsb
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$01]
sub r00q, r09q
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$short.01d$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfEqual$short.01d$int$short.01d$int$int$, \
array0, short.01d, \
array0StartFromIndex, int, \
array1, short.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*2+$00]
lea r07q, [r09+r02*2+$00]
std
repne cmpsw
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$02]
sub r00q, r09q
sar r00q, $01
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$int.01d$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfEqual$int.01d$int$int.01d$int$int$, \
array0, int.01d, \
array0StartFromIndex, int, \
array1, int.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*4+$00]
lea r07q, [r09+r02*4+$00]
std
repne cmpsd
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$04]
sub r00q, r09q
sar r00q, $02
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$long.01d$int$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfEqual$long.01d$int$long.01d$int$int$, \
array0, long.01d, \
array0StartFromIndex, int, \
array1, long.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*8+$00]
lea r07q, [r09+r02*8+$00]
std
repne cmpsq
je .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$08]
sub r00q, r09q
sar r00q, $03
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$, \
avt.lang.Array$negOffsetOfEqual$long.01d$int$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$boolean.01d$int$boolean.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfNonEqual$boolean.01d$int$boolean.01d$int$int$, \
avt.lang.Array$negOffsetOfNonEqual$byte.01d$int$byte.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$char.01d$int$char.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfNonEqual$char.01d$int$char.01d$int$int$, \
avt.lang.Array$negOffsetOfNonEqual$short.01d$int$short.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$byte.01d$int$byte.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfNonEqual$byte.01d$int$byte.01d$int$int$, \
array0, byte.01d, \
array0StartFromIndex, int, \
array1, byte.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*1+$00]
lea r07q, [r09+r02*1+$00]
std
repe cmpsb
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$01]
sub r00q, r09q
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$short.01d$int$short.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfNonEqual$short.01d$int$short.01d$int$int$, \
array0, short.01d, \
array0StartFromIndex, int, \
array1, short.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*2+$00]
lea r07q, [r09+r02*2+$00]
std
repe cmpsw
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$02]
sub r00q, r09q
sar r00q, $01
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$int.01d$int$int.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfNonEqual$int.01d$int$int.01d$int$int$, \
array0, int.01d, \
array0StartFromIndex, int, \
array1, int.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*4+$00]
lea r07q, [r09+r02*4+$00]
std
repe cmpsd
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$04]
sub r00q, r09q
sar r00q, $02
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$long.01d$int$long.01d$int$int$) ; <fold returns int>
method avt.lang.Array$negOffsetOfNonEqual$long.01d$int$long.01d$int$int$, \
array0, long.01d, \
array0StartFromIndex, int, \
array1, long.01d, \
array1StartFromIndex, int, \
maximumScanLength, int
menter $00
savetp
mov r06q, [.array0]
test r06q, r06q
jz .L.0000
mov r07q, [.array1]
test r07q, r07q
jz .L.0000
mov r01d, [r06+avt.lang.Array$fldLength]
mov r08d, [r07+avt.lang.Array$fldLength]
mov r00d, [.array0StartFromIndex]
cmp r00d, r01d
jl @F
lea r00d, [r01d-$01]
@@: cmp r00d, $00
jl .L.0000
mov r02d, [.array1StartFromIndex]
cmp r02d, r08d
jl @F
lea r02d, [r08d-$01]
@@: cmp r02d, $00
jl .L.0000
lea r01d, [r00d+$01]
lea r08d, [r02d+$01]
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: mov r08d, [.maximumScanLength]
cmp r08d, $00
jle @F
cmp r01d, r08d
jle @F
mov r01d, r08d
@@: lea r08q, [r06+$40]
lea r09q, [r07+$40]
add r08q, [r08+avt.lang.Array$fldOffset-$40]
add r09q, [r09+avt.lang.Array$fldOffset-$40]
lea r06q, [r08+r00*8+$00]
lea r07q, [r09+r02*8+$00]
std
repe cmpsq
jne .L.0001
.L.0000: mov r00d, avt.lang.Comparable$INDEFINITE
jmp .L.EXIT
.L.0001: lea r00q, [r07+$08]
sub r00q, r09q
sar r00q, $03
sub r00d, r02d
.L.EXIT: rstortp
mleave
eleave
end if ; </fold>
if(used avt.lang.Array$negOffsetOfNonEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$) ; <fold returns int>
alias avt.lang.Array$negOffsetOfNonEqual$avt.lang.Object.01d$int$avt.lang.Object.01d$int$int$, \
avt.lang.Array$negOffsetOfNonEqual$long.01d$int$long.01d$int$int$
end if ; </fold>
if(used avt.lang.Array$fillByByte$long$int$byte8$int$) ; <fold >
fast avt.lang.Array$fillByByte$long$int$byte8$int$, \
dstPtr, long, \
length, int, \
value, byte8, \
capacity, int
fenter
savetbp
mov r00q, [.value]
mov r01d, [.length]
mov r02d, [.capacity]
mov r07q, [.dstPtr]
cmp r02d, $01
je .L.0000
cmp r02d, $02
je .L.0001
cmp r02d, $04
je .L.0002
cmp r02d, $08
je .L.0003
jmp .L.EXIT
.L.0000: cld
rep stosb
jmp .L.EXIT
.L.0001: cld
rep stosw
jmp .L.EXIT
.L.0002: cld
rep stosd
jmp .L.EXIT
.L.0003: cld
rep stosq
.L.EXIT: rstortbp
fleave
end if ; </fold>
if(used avt.lang.Array$fillByShort$long$int$short8$int$) ; <fold >
fast avt.lang.Array$fillByShort$long$int$short8$int$, \
dstPtr, long, \
length, int, \
value, short8, \
capacity, int
fenter
savetbp
vmovdqa xmm0, [.value]
mov r00q, [.value]
mov r01d, [.length]
mov r02d, [.capacity]
mov r07q, [.dstPtr]
cmp r02d, $01
je .L.0000
cmp r02d, $02
je .L.0001
cmp r02d, $04
je .L.0002
cmp r02d, $08
je .L.0003
jmp .L.EXIT
.L.0000: cld
rep stosw
jmp .L.EXIT
.L.0001: cld
rep stosd
jmp .L.EXIT
.L.0002: cld
rep stosq
jmp .L.EXIT
.L.0003: vmovdqu xword [r07+$00], xmm0
lea r07q, [r07+$10]
loop .L.0003
.L.EXIT: rstortbp
fleave
end if ; </fold>
if(used avt.lang.Array$fillByInt$long$int$int8$int$) ; <fold >
fast avt.lang.Array$fillByInt$long$int$int8$int$, \
dstPtr, long, \
length, int, \
value, int8, \
capacity, int
fenter
savetbp
vmovdqu ymm0, [.value]
mov r00q, [.value]
mov r01d, [.length]
mov r02d, [.capacity]
mov r07q, [.dstPtr]
cmp r02d, $01
je .L.0000
cmp r02d, $02
je .L.0001
cmp r02d, $04
je .L.0002
cmp r02d, $08
je .L.0003
jmp .L.EXIT
.L.0000: cld
rep stosd
jmp .L.EXIT
.L.0001: cld
rep stosq
jmp .L.EXIT
.L.0002: vmovdqu xword [r07+$00], xmm0
lea r07q, [r07+$10]
loop .L.0002
jmp .L.EXIT
.L.0003: vmovdqu yword [r07+$00], ymm0
lea r07q, [r07+$20]
loop .L.0003
.L.EXIT: rstortbp
fcltag_y value
fleave
end if ; </fold>
if(used avt.lang.Array$fillByLong$long$int$long8$int$) ; <fold >
fast avt.lang.Array$fillByLong$long$int$long8$int$, \
dstPtr, long, \
length, int, \
value, long8, \
capacity, int
fenter
savetbp
vmovdqu64 zmm0, [.value]
mov r00q, [.value]
mov r01d, [.length]
mov r02d, [.capacity]
mov r07q, [.dstPtr]
cmp r02d, $01
je .L.0000
cmp r02d, $02
je .L.0001
cmp r02d, $04
je .L.0002
cmp r02d, $08
je .L.0003
jmp .L.EXIT
.L.0000: cld
rep stosq
jmp .L.EXIT
.L.0001: vmovdqu xword [r07+$00], xmm0
lea r07q, [r07+$10]
loop .L.0001
jmp .L.EXIT
.L.0002: vmovdqu yword [r07+$00], ymm0
lea r07q, [r07+$20]
loop .L.0002
jmp .L.EXIT
.L.0003: vmovdqu64 zword [r07+$00], zmm0
lea r07q, [r07+$40]
loop .L.0003
.L.EXIT: rstortbp
fcltag_z value
fleave
end if ; </fold>
if(used avt.lang.Array$fillByFloat$long$int$float8$int$) ; <fold >
alias avt.lang.Array$fillByFloat$long$int$float8$int$, \
avt.lang.Array$fillByInt$long$int$int8$int$
end if ; </fold>
if(used avt.lang.Array$fillByDouble$long$int$double8$int$) ; <fold >
alias avt.lang.Array$fillByDouble$long$int$double8$int$, \
avt.lang.Array$fillByLong$long$int$long8$int$
end if ; </fold>
if(used avt.lang.Array$fillByReal$long$int$real$) ; <fold >
fast avt.lang.Array$fillByReal$long$int$real$, \
dstPtr, long, \
length, int, \
value, real
fenter
savetbp
fld tbyte [.value]
mov r01d, [.length]
mov r07q, [.dstPtr]
@@: fld esc0
fstp tbyte [r07+$00]
lea r07q, [r07+$0a]
loop @B
ffree esc0
fincstp
rstortbp
fleave
end if ; </fold>
if(used avt.lang.Array$fillByRef$long$int$avt.lang.Object$) ; <fold >
fast avt.lang.Array$fillByRef$long$int$avt.lang.Object$, \
dstPtr, long, \
length, int, \
value, avt.lang.Object
fenter
savetbp
mov r00q, [.value]
mov r01d, [.length]
mov r07q, [.dstPtr]
tstaddrcobj r00q, r01q
@@: mov r02q, r00q
xchg qword [r07+$00], r02q
lea r07q, [r07+$08]
tstdecrcobj r02q
loop @B
rstortbp
tstdecrcoth r00q
fcltag_x value
fleave
end if ; </fold>
if(used avt.lang.Array$copyForwardByRaw$long$long$long$) ; <fold >
fast avt.lang.Array$copyForwardByRaw$long$long$long$, \
srcPtr, long, \
dstPtr, long, \
length, long
fenter
savetp
mov r01q, [.length]
mov r06q, [.srcPtr]
mov r07q, [.dstPtr]
cld
cmp r01q, $40
jge .L.0000
rep movsb
jmp .L.EXIT
.L.0000: lea r00q, [r07+$00]
lea r02q, [r07+r01*1+$00]
neg r00q
and r00d, $3f
and r02d, $3f
sub r01q, r00q
sub r01q, r02q
sar r01q, $06
xchg r01q, r00q
mov r08d, r06d
mov r09d, r07d
and r08d, $3f
and r09d, $3f
cmp r08d, r09d
je .L.0005
jrcxz .L.0001
rep movsb
.L.0001: mov r01q, r00q
jrcxz .L.0003
.L.0002: vmovdqu64 zmm0, [r06+$00]
vmovdqa64 zword [r07+$00], zmm0
lea r06q, [r06+$40]
lea r07q, [r07+$40]
loop .L.0002
.L.0003: mov r01q, r02q
jrcxz .L.0004
rep movsb
.L.0004: jmp .L.EXIT
.L.0005: jrcxz .L.0006
rep movsb
.L.0006: mov r01q, r00q
jrcxz .L.0008
.L.0007: vmovdqa64 zmm0, [r06+$00]
vmovdqa64 zword [r07+$00], zmm0
lea r06q, [r06+$40]
lea r07q, [r07+$40]
loop .L.0007
.L.0008: mov r01q, r02q
jrcxz .L.EXIT
rep movsb
.L.EXIT: rstortp
fleave
end if ; </fold>
if(used avt.lang.Array$copyBackwardByRaw$long$long$long$) ; <fold >
fast avt.lang.Array$copyBackwardByRaw$long$long$long$, \
srcPtr, long, \
dstPtr, long, \
length, long
fenter
savetp
mov r01q, [.length]
mov r06q, [.srcPtr]
mov r07q, [.dstPtr]
std
cmp r01q, $40
jge .L.0000
lea r06q, [r06-$01]
lea r07q, [r07-$01]
rep movsb
jmp .L.EXIT
.L.0000: lea r00q, [r07+$00]
lea r02q, [r07+$00]
sub r00q, r01q
neg r00q
and r00d, $3f
and r02d, $3f
sub r01q, r00q
sub r01q, r02q
sar r01q, $06
xchg r01q, r02q
mov r08d, r06d
mov r09d, r07d
and r08d, $3f
and r09d, $3f
cmp r08d, r09d
je .L.0005
jrcxz .L.0001
lea r06q, [r06-$01]
lea r07q, [r07-$01]
rep movsb
lea r06q, [r06+$01]
lea r07q, [r07+$01]
.L.0001: mov r01q, r02q
jrcxz .L.0003
.L.0002: lea r06q, [r06-$40]
lea r07q, [r07-$40]
vmovdqu64 zmm0, [r06-$00]
vmovdqa64 zword [r07-$00], zmm0
loop .L.0002
.L.0003: mov r01q, r00q
jrcxz .L.0004
lea r06q, [r06-$01]
lea r07q, [r07-$01]
rep movsb
.L.0004: jmp .L.EXIT
.L.0005: jrcxz .L.0006
lea r06q, [r06-$01]
lea r07q, [r07-$01]
rep movsb
lea r06q, [r06+$01]
lea r07q, [r07+$01]
.L.0006: mov r01q, r02q
jrcxz .L.0008
.L.0007: lea r06q, [r06-$40]
lea r07q, [r07-$40]
vmovdqa64 zmm0, [r06-$00]
vmovdqa64 zword [r07-$00], zmm0
loop .L.0007
.L.0008: mov r01q, r00q
jrcxz .L.EXIT
lea r06q, [r06-$01]
lea r07q, [r07-$01]
rep movsb
.L.EXIT: rstortp
fleave
end if ; </fold>
if(used avt.lang.Array$copyForwardByRef$long$long$long$) ; <fold >
fast avt.lang.Array$copyForwardByRef$long$long$long$, \
srcPtr, long, \
dstPtr, long, \
length, long
fenter
savetp
mov r01q, [.length]
mov r06q, [.srcPtr]
mov r07q, [.dstPtr]
cld
@@: lodsq
tstincrcobj r00q
xchg qword [r07+$00], r00q
lea r07q, [r07+$08]
tstdecrcobj r00q
loop @B
rstortp
fleave
end if ; </fold>
if(used avt.lang.Array$copyBackwardByRef$long$long$long$) ; <fold >
fast avt.lang.Array$copyBackwardByRef$long$long$long$, \
srcPtr, long, \
dstPtr, long, \
length, long
fenter
savetp
mov r01q, [.length]
mov r06q, [.srcPtr]
mov r07q, [.dstPtr]
lea r06q, [r06-$08]
lea r07q, [r07-$08]
std
@@: lodsq
tstincrcobj r00q
xchg qword [r07-$00], r00q
lea r07q, [r07-$08]
tstdecrcobj r00q
loop @B
rstortp
fleave
end if ; </fold>
if(used avt.lang.Array$getArrayPointer$avt.lang.array.Measureable$) ; <fold returns long>
fast avt.lang.Array$getArrayPointer$avt.lang.array.Measureable$, \
array, avt.lang.array.Measureable
fenter
mov r01q, [.array]
lea r00q, [r01+$40]
add r00q, [r00+avt.lang.Array$fldOffset-$40]
decrcoth r01q
fcltag_x array
fleave
end if ; </fold>
; </fold>