DataInputStreamLittleEndian.inc

Переключить прокрутку окна
Загрузить этот исходный код

;
  ; Реализация среды исполнения языка программирования
  ; Объектно-ориентированный продвинутый векторный транслятор
  ;
  ; Copyright © 2021, 2024, 2026 Малик Разработчик
  ;
  ; Это свободная программа: вы можете перераспространять ее и/или изменять
  ; ее на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
  ; в каком она была опубликована Фондом свободного программного обеспечения;
  ; либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
  ;
  ; Эта программа распространяется в надежде, что она будет полезной,
  ; но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
  ; или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
  ; общественной лицензии GNU.
  ;
  ; Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
  ; вместе с этой программой. Если это не так, см.
  ; <https://www.gnu.org/licenses/>.
;

; <fold avt.io.DataInputStreamLittleEndian — родной код>
    if(used avt.io.DataInputStreamLittleEndian$readChar$) ; <fold returns char, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readChar$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    movzx       r00d, word  [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedShort$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedShort$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    movzx       r00d, word  [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readShort$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readShort$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    movsx       r00d, word  [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readInt$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readInt$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         r00d, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedByte2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedByte2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    movzx       r00d, word  [r01+$00]
                    vmovd       xmm0, r00d
                    vpmovzxbd   xmm0, xmm0
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedShort2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedShort2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       xmm0, [r01+$00]
                    vpmovzxwd   xmm0, xmm0
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readByte2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readByte2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    movzx       r00d, word  [r01+$00]
                    vmovd       xmm0, r00d
                    vpmovsxbd   xmm0, xmm0
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readShort2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readShort2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       xmm0, [r01+$00]
                    vpmovsxwd   xmm0, xmm0
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readInt2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readInt2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedByte4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedByte4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovzxbd   xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedShort4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedShort4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovzxwd   xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readByte4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readByte4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovsxbd   xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readShort4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readShort4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovsxwd   xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readInt4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readInt4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedByte8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedByte8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovzxbd   ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readUnsignedShort8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readUnsignedShort8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovzxwd   ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readByte8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readByte8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovsxbd   ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readShort8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readShort8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vpmovsxwd   ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readInt8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readInt8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readLong$) ; <fold returns long, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readLong$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         r00q, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readLong2$) ; <fold returns long2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readLong2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readLong4$) ; <fold returns long4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readLong4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readLong8$) ; <fold returns long8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readLong8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa64   zmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readFloat$) ; <fold returns float, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readFloat$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovd       xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readFloat2$) ; <fold returns float2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readFloat2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readFloat4$) ; <fold returns float4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readFloat4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readFloat8$) ; <fold returns float8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readFloat8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readDouble$) ; <fold returns double, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readDouble$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovq       xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readDouble2$) ; <fold returns double2, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readDouble2$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     xmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readDouble4$) ; <fold returns double4, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readDouble4$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa     ymm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readDouble8$) ; <fold returns double8, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readDouble8$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    vmovdqa64   zmm0, [r01+$00]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.io.DataInputStreamLittleEndian$readReal$) ; <fold returns real, throws avt.io.IOException>
                    method      avt.io.DataInputStreamLittleEndian$readReal$, \
                                this, avt.io.DataInputStreamLittleEndian
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $0a
                    tpushi
                    invvirt     avt.io.DataInputStreamLittleEndian$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.DataInputStreamLittleEndian$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    fld         tbyte [r01+$00]
                    mleave
                    eleave
    end if ; </fold>
; </fold>