LittleEndianDataInput.inc

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

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

; <fold avt.io.LittleEndianDataInput — родной код>
    if(used avt.io.LittleEndianDataInput$readChar$) ; <fold returns char, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readChar$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedShort$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedShort$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readShort$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readShort$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readInt$) ; <fold returns int, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readInt$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedByte2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedByte2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $02
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedShort2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedShort2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    mov         r00d, [r01+$00]
                    vmovd       xmm0, r00d
                    vpmovzxwd   xmm0, xmm0
                    mleave
                    eleave
    end if ; </fold>

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

    if(used avt.io.LittleEndianDataInput$readInt2$) ; <fold returns int2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readInt2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedByte4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedByte4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedShort4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedShort4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readByte4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readByte4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readShort4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readShort4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readInt4$) ; <fold returns int4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readInt4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedByte8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedByte8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readUnsignedShort8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readUnsignedShort8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readByte8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readByte8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readShort8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readShort8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readInt8$) ; <fold returns int8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readInt8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readLong$) ; <fold returns long, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readLong$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readLong2$) ; <fold returns long2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readLong2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readLong4$) ; <fold returns long4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readLong4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readLong8$) ; <fold returns long8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readLong8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readFloat$) ; <fold returns float, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readFloat$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $04
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readFloat2$) ; <fold returns float2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readFloat2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readFloat4$) ; <fold returns float4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readFloat4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readFloat8$) ; <fold returns float8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readFloat8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readDouble$) ; <fold returns double, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readDouble$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $08
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readDouble2$) ; <fold returns double2, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readDouble2$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $10
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readDouble4$) ; <fold returns double4, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readDouble4$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $20
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readDouble8$) ; <fold returns double8, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readDouble8$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $40
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$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.LittleEndianDataInput$readReal$) ; <fold returns real, throws avt.io.IOException>
                    method      avt.io.LittleEndianDataInput$readReal$, \
                                this, avt.io.LittleEndianDataInput
                    menter      $2
                    loadr_l     this
                    tpushr
                    loadi_g     $0a
                    tpushi
                    invvirt     avt.io.LittleEndianDataInput$readData$int$
                    mov         r01q, [.this]
                    mov         r01q, [r01+avt.io.LittleEndianDataInput$fldData]
                    lea         r01q, [r01+$40]
                    add         r01q, [r01+avt.lang.Array$fldOffset-$40]
                    fld         tbyte [r01+$00]
                    mleave
                    eleave
    end if ; </fold>
; </fold>