TOP > プログラミング関係解説＆調査 > スプライトについて > サブルーチン

$CE/D47E PHB                     ;DBレジスタをスタックにプッシュ
$CE/D47F LDA $65    [$00:0065]   ;Aに[$00:0065]をロード
$CE/D481 PHA                     ;Aレジスタをスタックにプッシュ
$CE/D482 PLB                     ;DBレジスタにスタックからプル
$CE/D483 LDY #$0001              ;Yに$0001をロード
$CE/D486 LDX $63    [$00:0063]   ;Xに[$00:0063]をロード
$CE/D488 LDA [$60],y[$CF:074A]   ;Aに[$CF:074A]をロード
$CE/D48A INY                     ;Yをインクリメント +1
$CE/D48B CMP #$F0                ;Aと$F0を減算比較（ステータスレジスタ変更のみ）
$CE/D48D BCC $0E    [$D49D]      ;キャリーフラグが立っていないとき[$D49D]分岐
$CE/D49D INC A                   ;Aをインクリメント +1
$CE/D49E LSR A                   ;Aを論理右シフト　(/2)
$CE/D49F STA $66    [$00:0066]   ;Aを[$00:0066]に書き込み
$CE/D4A1 BCC $0B    [$D4AE]      ;キャリーフラグが立っていないとき[$D4AE]分岐
$CE/D4AE STZ $67    [$00:0067]   ;[$00:0067]に$00を書き込み
$CE/D4B0 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア

;ループ開始
$CE/D4B2 LDA [$60],y[$CF:074B]   ;Aに[$CF:074B]をロード
$CE/D4B4 STA $0000,x[$7E:8000]   ;Aを[$7E:8000]に書き込み
$CE/D4B7 INX                     ;Xをインクリメント +1
$CE/D4B8 INX                     ;Xをインクリメント +1
$CE/D4B9 INY                     ;Yをインクリメント +1
$CE/D4BA INY                     ;Yをインクリメント +1
$CE/D4BB DEC $66    [$00:0066]   ;[$00:0066]をデクリメント -1
$CE/D4BD BNE $F3    [$D4B2]      ;ゼロフラグが立っていないとき[$D4B2]分岐
;ループここまで

$CE/D48F STX $63    [$00:0063]   ;Xを[$00:0063]に書き込み
$CE/D491 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$CE/D493 AND #$000F              ;Aと$000Fで論理積
$CE/D496 ASL A                   ;Aを算術左シフト *2
$CE/D497 TAX                     ;Aの値をXレジスタに転送
$CE/D498 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$CE/D49A JMP ($D89E,x)[$CE:D4C3] ;[$CE:D4C3]へジャンプ(レジスタをスタックに積まない)
;（中略）
$CE/D4BD BNE $F3    [$D4B2]      ;ゼロフラグが立っていないとき[$D4B2]分岐
$CE/D4B2 LDA [$60],y[$CF:0905]   ;Aに[$CF:0905]をロード
$CE/D4B4 STA $0000,x[$7E:81FE]   ;Aを[$7E:81FE]に書き込み
$CE/D4B7 INX                     ;Xをインクリメント +1
$CE/D4B8 INX                     ;Xをインクリメント +1
$CE/D4B9 INY                     ;Yをインクリメント +1
$CE/D4BA INY                     ;Yをインクリメント +1
$CE/D4BB DEC $66    [$00:0066]   ;[$00:0066]をデクリメント -1
$CE/D4BD BNE $F3    [$D4B2]      ;ゼロフラグが立っていないとき[$D4B2]分岐
$CE/D4BF SEP #$20                ;MフラグON　Aレジスタは8bit幅
$CE/D4C1 BRA $C5    [$D488]      ;フラグにかかわりなく常に分岐[$D488]
$CE/D488 LDA [$60],y[$CF:0907]   ;Aに[$CF:0907]をロード
$CE/D48A INY                     ;Yをインクリメント +1
$CE/D48B CMP #$F0                ;Aと$F0を減算比較（ステータスレジスタ変更のみ）
$CE/D48D BCC $0E    [$D49D]      ;キャリーフラグが立っていないとき[$D49D]分岐
$CE/D48F STX $63    [$00:0063]   ;Xを[$00:0063]に書き込み
$CE/D491 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$CE/D493 AND #$000F              ;Aと$000Fで論理積
$CE/D496 ASL A                   ;Aを算術左シフト *2
$CE/D497 TAX                     ;Aの値をXレジスタに転送
$CE/D498 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$CE/D49A JMP ($D89E,x)[$CE:D89C] ;[$CE:D89C]へジャンプ(レジスタをスタックに積まない)
$CE/D89C PLB                     ;DBレジスタにスタックからプル
$CE/D89D RTL                     ;サブルーチン戻り

$C0/4DC4 LDA #$01                ;Aに$01をロード
$C0/4DC6 STA $4300  [$00:4300]   ;Aを[$00:4300]に書き込み
$C0/4DC9 LDA #$18                ;Aに$18をロード
$C0/4DCB STA $4301  [$00:4301]   ;Aを[$00:4301]に書き込み
$C0/4DCE LDX #$0000              ;Xに$0000をロード
$C0/4DD1 STX $2116  [$00:2116]   ;Xを[$00:2117][$00:2116]に書き込み
$C0/4DD4 LDX #$2000              ;Xに$2000をロード
$C0/4DD7 STX $26    [$00:0026]   ;Xを[$00:0026]に書き込み
$C0/4DD9 LDA $0120  [$00:0120]   ;Aに[$00:0120]をロード
$C0/4DDC STA $20    [$00:0020]   ;Aを[$00:0020]に書き込み
$C0/4DDE STZ $22    [$00:0022]   ;[$00:0022]に$00を書き込み
$C0/4DE0 JSR $4E8A  [$C0:4E8A]   ;[$C0:4E8A]へジャンプ
;（中略）
$C0/4ECE LDX #$8000              ;Xに$8000をロード
$C0/4ED1 STX $4302  [$00:4302]   ;Xを[$00:4303][$00:4302]に書き込み
$C0/4ED4 LDA #$7E                ;Aに$7Eをロード
$C0/4ED6 STA $4304  [$00:4304]   ;Aを[$00:4304]に書き込み
$C0/4ED9 LDY #$2000              ;Yに$2000をロード
$C0/4EDC STY $4305  [$00:4305]   ;Yを[$00:4306][$00:4305]に書き込み
$C0/4EDF LDA #$01                ;Aに$01をロード
$C0/4EE1 STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み

$C0/9ACA LDA #$00                ;Aに$00をロード
$C0/9ACC STA $4300  [$00:4300]   ;Aを[$00:4300]に書き込み
$C0/9ACF LDA #$22                ;Aに$22をロード
$C0/9AD1 STA $4301  [$00:4301]   ;Aを[$00:4301](転送先指定 $22=CGRAM)に書き込み
;（中略）
$C0/9A09 LDY #$3900              ;Yに$3900をロード
$C0/9A0C LDA $0A00  [$00:0A00]   ;Aに[$00:0A00]をロード
$C0/9A0F CMP #$08                ;Aと$08を減算比較（ステータスレジスタ変更のみ）
$C0/9A11 BNE $03    [$9A16]      ;ゼロフラグが立っていないとき[$9A16]分岐
;ゼロフラグON（最終編）
$C0/9A13 LDA $0A10  [$00:0A10]   ;Aに[$00:0A10]（主人公ID）をロード
;ゼロフラグOFF（最終編以外）
$C0/9A16 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/9A18 AND #$00FF              ;Aと$00FFで論理積
$C0/9A1B ASL A                   ;Aを算術左シフト *2
$C0/9A1C ASL A                   ;Aを算術左シフト *2
$C0/9A1D ASL A                   ;Aを算術左シフト *2
$C0/9A1E ASL A                   ;Aを算術左シフト *2
$C0/9A1F ASL A                   ;Aを算術左シフト *2
$C0/9A20 CLC                     ;キャリーフラグクリア
$C0/9A21 ADC #$F960              ;A + $F960
$C0/9A24 TAX                     ;Aの値をXレジスタに転送
$C0/9A25 PHB                     ;DBレジスタをスタックにプッシュ
$C0/9A26 LDA #$001F              ;Aに$001Fをロード
$C0/9A29 MVN CF 7E               ;データ転送
;A: 1F (転送データサイズ-1)
;X: 主人公ID*$20 + $F960 (転送元アドレス)
;Y: 3900 (転送先アドレス)
;オペランド: 転送元バンクCF 転送先バンク7E
;$CF:(主人公ID*$20 + $F960) -> $7E:3900 +$20
$C0/9A29 MVN CF 7E               ;データ転送
$C0/9A2C PLB                     ;DBレジスタにスタックからプル
$C0/9A2D SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/9A2F LDA $0A0B  [$00:0A0B]   ;Aに[$00:0A0B]をロード
$C0/9A32 BIT #$01                ;Aと$01で論理積（ステータスフラグ変更のみ）
$C0/9A34 BNE $05    [$9A3B]      ;ゼロフラグが立っていないとき[$9A3B]分岐
;ゼロフラグON
$C0/9A36 LDX #$FA60              ;Xに$FA60をロード
$C0/9A39 BRA $03    [$9A3E]      ;フラグにかかわりなく常に分岐[$9A3E]
;ゼロフラグOFF
$C0/9A3B LDX #$FE20              ;Xに$FE20をロード
$C0/9A3E REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/9A40 PHB                     ;DBレジスタをスタックにプッシュ
$C0/9A41 LDA #$007F              ;Aに$007Fをロード
$C0/9A44 MVN CF 7E               ;データ転送
;A: 7F (転送データサイズ-1)
;X: FE20またはFA60 (転送元アドレス)
;Y: 3920 (転送先アドレス)
;オペランド: 転送元バンクCF 転送先バンク7E
;$CF:FE20/FA60 -> $7E:3920 +$7F
$C0/9A44 MVN CF 7E               ;データ転送
$C0/9A47 PLB                     ;DBレジスタにスタックからプル
$C0/9A48 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/9A4A LDA $0A0B  [$00:0A0B]   ;Aに[$00:0A0B]をロード
$C0/9A4D BIT #$02                ;Aと$02で論理積（ステータスフラグ変更のみ）
$C0/9A4F BNE $19    [$9A6A]      ;ゼロフラグが立っていないとき[$9A6A]分岐
;ゼロフラグON
$C0/9A51 LDA $0ACF  [$00:0ACF]   ;Aに[$00:0ACF]（操作中のキャラID）をロード
$C0/9A54 XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C0/9A55 LDA #$00                ;Aに$00をロード
$C0/9A57 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/9A59 LSR A                   ;Aを論理右シフト　(/2)
$C0/9A5A LSR A                   ;Aを論理右シフト　(/2)
$C0/9A5B STA $32    [$00:0032]   ;Aを[$00:0032]に書き込み
$C0/9A5D LSR A                   ;Aを論理右シフト　(/2)
$C0/9A5E CLC                     ;キャリーフラグクリア
$C0/9A5F ADC $32    [$00:0032]   ;A + [$00:0032]
$C0/9A61 CLC                     ;キャリーフラグクリア
$C0/9A62 ADC #$FAE0              ;A + $FAE0
$C0/9A65 TAX                     ;Aの値をXレジスタに転送
$C0/9A66 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/9A68 BRA $18    [$9A82]      ;フラグにかかわりなく常に分岐[$9A82]
;ゼロフラグOFF
$C0/9A6A LDA $0ACF  [$00:0ACF]   ;Aに[$00:0ACF]（操作中のキャラID）をロード
$C0/9A6D CMP #$04                ;Aと$04を減算比較（ステータスレジスタ変更のみ）
$C0/9A6F BEQ $0E    [$9A7F]      ;ゼロフラグが立っているとき[$9A7F]分岐(西部)
$C0/9A71 CMP #$07                ;Aと$07を減算比較（ステータスレジスタ変更のみ）
$C0/9A73 BEQ $05    [$9A7A]      ;ゼロフラグが立っているとき[$9A7A]分岐(幕末)
$C0/9A75 LDX #$FEA0              ;Xに$FEA0をロード
$C0/9A78 BRA $08    [$9A82]      ;フラグにかかわりなく常に分岐[$9A82]
$C0/9A7A LDX #$FF60              ;Xに$FF60をロード
$C0/9A7D BRA $03    [$9A82]      ;フラグにかかわりなく常に分岐[$9A82]
$C0/9A7F LDX #$FF00              ;Xに$FF00をロード
;処理合流
$C0/9A82 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/9A84 PHB                     ;DBレジスタをスタックにプッシュ
$C0/9A85 LDA #$005F              ;Aに$005Fをロード
$C0/9A88 MVN CF 7E               ;データ転送
;A: 5F (転送データサイズ-1)
;X: ???? (転送元アドレス)
;Y: 39A0 (転送先アドレス)
;オペランド: 転送元バンクCF 転送先バンク7E
;$CF:???? -> $7E:39A0 +$5F
$C0/9A88 MVN CF 7E               ;データ転送
$C0/9A8B PLB                     ;DBレジスタにスタックからプル
$C0/9A8C SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/9A8E LDY #$3920              ;Yに$3920をロード
$C0/9A91 LDA #$07                ;Aに$07をロード
$C0/9A93 JSR $C449  [$C0:C449]   ;[$C0:C449]へジャンプ

$C0/C449 STA $30    [$00:0030]   ;Aを[$00:0030]に書き込み
$C0/C44B LDA $10E2  [$00:10E2]   ;Aに[$00:10E2]をロード
$C0/C44E BEQ $4D    [$C49D]      ;ゼロフラグが立っているとき[$C49D]分岐
$C0/C49D RTS                     ;サブルーチン戻り

$C0/9A96 LDA $70    [$00:0070]   ;Aに[$00:0070]をロード
$C0/9A98 CMP #$01                ;Aと$01を減算比較（ステータスレジスタ変更のみ）
$C0/9A9A BEQ $12    [$9AAE]      ;ゼロフラグが立っているとき[$9AAE]分岐
$C0/9A9C REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/9A9E PHB                     ;DBレジスタをスタックにプッシュ
$C0/9A9F LDX #$F920              ;Xに$F920をロード
$C0/9AA2 LDY #$3800              ;Yに$3800をロード
$C0/9AA5 LDA #$003F              ;Aに$003Fをロード
$C0/9AA8 MVN CF 7E               ;データ転送
;A: 3F (転送データサイズ-1)
;X: F920 (転送元アドレス)
;Y: 3800 (転送先アドレス)
;オペランド: 転送元バンクCF 転送先バンク7E
;$CF:F920 -> $7E:3800 +$3F
$C0/9AA8 MVN CF 7E               ;データ転送
$C0/9AAB PLB                     ;DBレジスタにスタックからプル
$C0/9AAC SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/9AAE LDA #$80                ;Aに$80をロード
$C0/9AB0 STA $2121  [$00:2121]   ;Aを[$00:2121](パレットアドレス)に書き込み
$C0/9AB3 LDX #$3900              ;Xに$3900をロード
$C0/9AB6 STX $4302  [$00:4302]   ;Xを[$00:4303][$00:4302]に書き込み
$C0/9AB9 LDA #$7E                ;Aに$7Eをロード
$C0/9ABB STA $4304  [$00:4304]   ;Aを[$00:4304]に書き込み
$C0/9ABE LDX #$0100              ;Xに$0100をロード
$C0/9AC1 STX $4305  [$00:4305]   ;Xを[$00:4306][$00:4305]に書き込み
$C0/9AC4 LDA #$01                ;Aに$01をロード
$C0/9AC6 STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
$C0/9AC9 RTS                     ;サブルーチン戻り

LDA #$22
STA $4301  [$00:4301]

$C0/BC6D STZ $2102  [$00:2102]   ;[$00:2102]に$00を書き込み
$C0/BC70 STZ $2103  [$00:2103]   ;[$00:2103]に$00を書き込み
$C0/BC73 LDA #$00                ;Aに$00をロード
$C0/BC75 STA $4300  [$00:4300]   ;Aを[$00:4300]に書き込み
$C0/BC78 LDA #$04                ;Aに$04をロード
$C0/BC7A STA $4301  [$00:4301]   ;Aを[$00:4301]に書き込み
$C0/BC7D LDX #$0700              ;Xに$0700をロード
$C0/BC80 STX $4302  [$00:4302]   ;Xを[$00:4303][$00:4302]に書き込み
$C0/BC83 LDA #$00                ;Aに$00をロード
$C0/BC85 STA $4304  [$00:4304]   ;Aを[$00:4304]に書き込み
$C0/BC88 LDX #$0220              ;Xに$0220をロード
$C0/BC8B STX $4305  [$00:4305]   ;Xを[$00:4306][$00:4305]に書き込み
$C0/BC8E LDA #$01                ;Aに$01をロード
$C0/BC90 STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
$C0/BC93 RTS                     ;サブルーチン戻り

$C0/BB15 STZ $0103  [$00:0103]   ;[$00:0103]に$00を書き込み
$C0/BB18 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/BB1A LDX #$0700              ;Xに$0700をロード
$C0/BB1D LDY #$0010              ;Yに$0010をロード

;ループ開始
$C0/BB20 LDA #$E000              ;Aに$E000をロード
$C0/BB23 STA $00,x  [$00:0700]   ;Aを[$00:0700+20x]に書き込み
$C0/BB25 STZ $02,x  [$00:0702]   ;[$00:0702+20x]に$00を書き込み
$C0/BB27 STA $04,x  [$00:0704]   ;Aを[$00:0704+20x]に書き込み
$C0/BB29 STZ $06,x  [$00:0706]   ;[$00:0706+20x]に$00を書き込み
$C0/BB2B STA $08,x  [$00:0708]   ;Aを[$00:0708+20x]に書き込み
$C0/BB2D STZ $0A,x  [$00:070A]   ;[$00:070A+20x]に$00を書き込み
$C0/BB2F STA $0C,x  [$00:070C]   ;Aを[$00:070C+20x]に書き込み
$C0/BB31 STZ $0E,x  [$00:070E]   ;[$00:070E+20x]に$00を書き込み
$C0/BB33 STA $10,x  [$00:0710]   ;Aを[$00:0710+20x]に書き込み
$C0/BB35 STZ $12,x  [$00:0712]   ;[$00:0712+20x]に$00を書き込み
$C0/BB37 STA $14,x  [$00:0714]   ;Aを[$00:0714+20x]に書き込み
$C0/BB39 STZ $16,x  [$00:0716]   ;[$00:0716+20x]に$00を書き込み
$C0/BB3B STA $18,x  [$00:0718]   ;Aを[$00:0718+20x]に書き込み
$C0/BB3D STZ $1A,x  [$00:071A]   ;[$00:071A+20x]に$00を書き込み
$C0/BB3F STA $1C,x  [$00:071C]   ;Aを[$00:071C+20x]に書き込み
$C0/BB41 STZ $1E,x  [$00:071E]   ;[$00:071E+20x]に$00を書き込み
$C0/BB43 TXA                     ;Xレジスタの値をAレジスタに転送
$C0/BB44 CLC                     ;キャリーフラグクリア
$C0/BB45 ADC #$0020              ;A + $0020
$C0/BB48 TAX                     ;Aの値をXレジスタに転送
$C0/BB49 DEY                     ;Yをデクリメント -1
$C0/BB4A BNE $D4    [$BB20]      ;ゼロフラグが立っていないとき[$BB20]分岐
;ループここまで

$C0/BB4C STZ $00,x  [$00:0900]   ;[$00:0900]に$00を書き込み
$C0/BB4E STZ $02,x  [$00:0902]   ;[$00:0902]に$00を書き込み
$C0/BB50 STZ $04,x  [$00:0904]   ;[$00:0904]に$00を書き込み
$C0/BB52 STZ $06,x  [$00:0906]   ;[$00:0906]に$00を書き込み
$C0/BB54 STZ $08,x  [$00:0908]   ;[$00:0908]に$00を書き込み
$C0/BB56 STZ $0A,x  [$00:090A]   ;[$00:090A]に$00を書き込み
$C0/BB58 STZ $0C,x  [$00:090C]   ;[$00:090C]に$00を書き込み
$C0/BB5A STZ $0E,x  [$00:090E]   ;[$00:090E]に$00を書き込み
$C0/BB5C STZ $10,x  [$00:0910]   ;[$00:0910]に$00を書き込み
$C0/BB5E STZ $12,x  [$00:0912]   ;[$00:0912]に$00を書き込み
$C0/BB60 STZ $14,x  [$00:0914]   ;[$00:0914]に$00を書き込み
$C0/BB62 STZ $16,x  [$00:0916]   ;[$00:0916]に$00を書き込み
$C0/BB64 STZ $18,x  [$00:0918]   ;[$00:0918]に$00を書き込み
$C0/BB66 STZ $1A,x  [$00:091A]   ;[$00:091A]に$00を書き込み
$C0/BB68 STZ $1C,x  [$00:091C]   ;[$00:091C]に$00を書き込み
$C0/BB6A STZ $1E,x  [$00:091E]   ;[$00:091E]に$00を書き込み
$C0/BB6C LDA $0100  [$00:0100]   ;Aに[$00:0100]をロード
$C0/BB6F BNE $03    [$BB74]      ;ゼロフラグが立っていないとき[$BB74]分岐
$C0/BB74 LDY #$0700              ;Yに$0700をロード
$C0/BB77 LDA #$0900              ;Aに$0900をロード
$C0/BB7A STA $32    [$00:0032]   ;Aを[$00:0032]に書き込み
$C0/BB7C STZ $34    [$00:0034]   ;[$00:0034]に$00を書き込み
$C0/BB7E LDA $0102  [$00:0102]   ;Aに[$00:0102]をロード
$C0/BB81 BEQ $74    [$BBF7]      ;ゼロフラグが立っているとき[$BBF7]分岐
;ゼロフラグOFF
$C0/BB83 STA $30    [$00:0030]   ;Aを[$00:0030]に書き込み
;（中略）
$C0/BBF5 BNE $91    [$BB88]      ;ゼロフラグが立っていないとき[$BB88]分岐
;ゼロフラグON
$C0/BBF7 LDA $0100  [$00:0100]   ;Aに[$00:0100]をロード
$C0/BBFA STA $30    [$00:0030]   ;Aを[$00:0030]に書き込み
$C0/BBFC LDX #$1A00              ;Xに$1A00をロード

;ループ開始
$C0/BBFF LDA $00,x  [$00:1A00]   ;Aに[$00:1A00]をロード
$C0/BC01 BIT #$0080              ;Aと$0080で論理積（ステータスフラグ変更のみ）
$C0/BC04 BNE $56    [$BC5C]      ;ゼロフラグが立っていないとき[$BC5C]分岐
$C0/BC06 LDA $01,x  [$00:1A01]   ;Aに[$00:1A01]をロード
$C0/BC08 STA $0000,y[$00:0700]   ;Aを[$00:0700]に書き込み
$C0/BC0B LDA $03,x  [$00:1A03]   ;Aに[$00:1A03]をロード
$C0/BC0D STA $0002,y[$00:0702]   ;Aを[$00:0702]に書き込み
$C0/BC10 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/BC12 PHY                     ;Yレジスタをスタックへプッシュ
$C0/BC13 LDY $32    [$00:0032]   ;Yに[$00:0032]をロード
$C0/BC15 LDA $34    [$00:0034]   ;Aに[$00:0034]をロード
$C0/BC17 BEQ $32    [$BC4B]      ;ゼロフラグが立っているとき[$BC4B]分岐
$C0/BC4B LDA $00,x  [$00:1A00]   ;Aに[$00:1A00]をロード
$C0/BC4D AND #$03                ;Aと$03で論理積
$C0/BC4F STA $0000,y[$00:0900]   ;Aを[$00:0900]に書き込み
$C0/BC52 INC $34    [$00:0034]   ;A[$00:0034]をインクリメント +1
$C0/BC54 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C0/BC56 PLA                     ;Aレジスタにスタックからプル
$C0/BC57 CLC                     ;キャリーフラグクリア
$C0/BC58 ADC #$0004              ;A + $0004
$C0/BC5B TAY                     ;Aの値をYレジスタに転送
$C0/BC5C TXA                     ;Xレジスタの値をAレジスタに転送
$C0/BC5D CLC                     ;キャリーフラグクリア
$C0/BC5E ADC #$0005              ;A + $0005
$C0/BC61 TAX                     ;Aの値をXレジスタに転送
$C0/BC62 DEC $30    [$00:0030]   ;[$00:0030]をデクリメント -1
$C0/BC64 BNE $99    [$BBFF]      ;ゼロフラグが立っていないとき[$BBFF]分岐
;ループここまで

$C0/BC66 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C0/BC68 RTS                     ;サブルーチン戻り

$C1/F2D1 LDA #$01                ;Aに$01をロード
$C1/F2D3 STA $4300  [$00:4300]   ;Aを[$00:4300]に書き込み
$C1/F2D6 LDA #$18                ;Aに$18をロード
$C1/F2D8 STA $4301  [$00:4301]   ;Aを[$00:4301]に書き込み
$C1/F2DB LDA #$00                ;Aに$00をロード
$C1/F2DD STA $4310  [$00:4310]   ;Aを[$00:4310]に書き込み
$C1/F2E0 LDA #$22                ;Aに$22をロード
$C1/F2E2 STA $4311  [$00:4311]   ;Aを[$00:4311]に書き込み
$C1/F2E5 LDA #$80                ;Aに$80をロード
$C1/F2E7 STA $4321  [$00:4321]   ;Aを[$00:4321]に書き込み
$C1/F2EA LDA #$00                ;Aに$00をロード
$C1/F2EC STA $4330  [$00:4330]   ;Aを[$00:4330]に書き込み
$C1/F2EF LDA #$04                ;Aに$04をロード
$C1/F2F1 STA $4331  [$00:4331]   ;Aを[$00:4331]に書き込み
$C1/F2F4 JSR $F31F  [$C1:F31F]   ;[$C1:F31F]へジャンプ

$C1/F31F LDX #$A700              ;Xに$A700をロード
$C1/F322 STX $4342  [$00:4342]   ;Xを[$00:4342]に書き込み
$C1/F325 LDA #$41                ;Aに$41をロード
$C1/F327 STA $4340  [$00:4340]   ;Aを[$00:4340]に書き込み
$C1/F32A LDA #$26                ;Aに$26をロード
$C1/F32C STA $4341  [$00:4341]   ;Aを[$00:4341]に書き込み
$C1/F32F LDA #$7E                ;Aに$7Eをロード
$C1/F331 STA $4344  [$00:4344]   ;Aを[$00:4344]に書き込み
$C1/F334 STA $4347  [$00:4347]   ;Aを[$00:4347]に書き込み
$C1/F337 RTS                     ;サブルーチン戻り

$C1/F2F7 LDA #$01                ;Aに$01をロード
$C1/F2F9 STA $4350  [$00:4350]   ;Aを[$00:4350]に書き込み
$C1/F2FC LDA #$26                ;Aに$26をロード
$C1/F2FE STA $4351  [$00:4351]   ;Aを[$00:4351]に書き込み
$C1/F301 LDX #$E9FD              ;Xに$E9FDをロード
$C1/F304 STX $4352  [$00:4352]   ;Xを[$00:4352]に書き込み
$C1/F307 LDA #$C1                ;Aに$C1をロード
$C1/F309 STA $4354  [$00:4354]   ;Aを[$00:4354]に書き込み
$C1/F30C STA $4357  [$00:4357]   ;Aを[$00:4357]に書き込み
$C1/F30F LDA #$09                ;Aに$09をロード
$C1/F311 STA $4370  [$00:4370]   ;Aを[$00:4370]に書き込み
$C1/F314 LDA #$18                ;Aに$18をロード
$C1/F316 STA $4371  [$00:4371]   ;Aを[$00:4371]に書き込み
$C1/F319 RTS                     ;サブルーチン戻り

$C1/5FE0 STA $18    [$00:0318]   ;Aを[$00:0318]に書き込み
;(中略、アドレスなど計算)
$C1/6072 STA $10    [$00:0310]   ;Aを[$00:0310]に書き込み
$C1/6074 LDA #$10                ;Aに$10をロード
$C1/6076 STA $08    [$00:0308]   ;Aを[$00:0308]に書き込み
$C1/6078 ASL $15    [$00:0315]   ;A[$00:0315]を算術左シフト *2
$C1/607A ROL $14    [$00:0314]   ;A[$00:0314]をキャリーフラグを含めた9bitで左ローテート
$C1/607C BCS $2C    [$60AA]      ;キャリーフラグが立っているとき[$60AA]分岐
;キャリーフラグON
$C1/60AA LDA #$00                ;Aに$00をロード
$C1/60AC STA $4320  [$00:4320]   ;Aを[$00:4320]に書き込み
$C1/60AF LDX $12    [$00:0312]   ;Xに[$00:0313][$00:0312]をロード
$C1/60B1 STX $4322  [$00:4322]   ;Xを[$00:4323][$00:4322]に書き込み
$C1/60B4 LDA $10    [$00:0310]   ;Aに[$00:0310]をロード
$C1/60B6 STA $4324  [$00:4324]   ;Aを[$00:4324]に書き込み
$C1/60B9 LDX #$0020              ;Xに$0020をロード
$C1/60BC STX $4325  [$00:4325]   ;Xを[$00:4326][$00:4325]に書き込み
$C1/60BF LDX $1C    [$00:031C]   ;Xに[$00:031D][$00:031C]をロード
$C1/60C1 STX $2181  [$00:2181]   ;Xを[$00:2182][$00:2181]に書き込み
$C1/60C4 LDA #$00                ;Aに$00をロード
$C1/60C6 STA $2183  [$00:2183]   ;Aを[$00:2183]に書き込み
$C1/60C9 JSR $34EA  [$C1:34EA]   ;[$C1:34EA]へジャンプ
;
;おぼろ丸の時
;[$00:4320] GDMA/HDMA設定レジスタ $00
;[$00:4323][$00:4322] データ元アドレス（開始位置） $EE00
;[$00:4324] データ元バンク $D9
;[$00:4326][$00:4325] 転送するデータ量 $0020
;[$00:2183]~[$00:2181] WRAM転送先 $00D000
;
$C1/34EA JSR $34F6  [$C1:34F6]   ;[$C1:34F6]へジャンプ
;
$C1/34F6 LDA $2137  [$00:2137]   ;Aに[$00:2137]をロード　H/Vカウンタラッチ
$C1/34F9 LDA $213F  [$00:213F]   ;Aに[$00:213F]をロード　PPU2ステータス
$C1/34FC LDA $213C  [$00:213C]   ;Aに[$00:213C]をロード　Hカウンタ
$C1/34FF XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C1/3500 LDA $213C  [$00:213C]   ;Aに[$00:213C]をロード　Hカウンタ
$C1/3503 XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C1/3504 RTS                     ;サブルーチン戻り
;
$C1/34ED CMP #$E0                ;Aと$E0(224)を減算比較（ステータスレジスタ変更のみ）
$C1/34EF BCS $04    [$34F5]      ;キャリーフラグが立っているとき[$34F5]分岐
;キャリーフラグOFF
$C1/34F1 CMP #$50                ;Aと$50(80)を減算比較（ステータスレジスタ変更のみ）
$C1/34F3 BCS $F5    [$34EA]      ;キャリーフラグが立っているとき[$34EA]分岐
;キャリーフラグON
$C1/34F5 RTS                     ;サブルーチン戻り
;
$C1/60CC LDA #$04                ;Aに$04をロード
$C1/60CE STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
;GDMA n=2チャネルの転送を開始
;（中略）
$C1/60C9 JSR $34EA  [$C1:34EA]   ;[$C1:34EA]へジャンプ

$C1/8DC0 LDA $FE    [$00:03FE]   ;Aに[$00:03FE]をロード
$C1/8DC2 BNE $01    [$8DC5]      ;ゼロフラグが立っていないとき[$8DC5]分岐
$C1/8DC5 LDA #$7E                ;Aに$7Eをロード
$C1/8DC7 STA $4304  [$00:4304]   ;Aを[$00:4304]に書き込み
$C1/8DCA LDY #$D000              ;Yに$D000をロード
$C1/8DCD STY $4302  [$00:4302]   ;Yを[$00:4303][$00:4302]に書き込み
$C1/8DD0 LDX #$0000              ;Xに$0000をロード
;
;[$00:4300] GDMA/HDMA設定レジスタ $01
;[$00:4303][$00:4302] データ元アドレス（開始位置） $D000
;[$00:4304] データ元バンク $7E
;
;ループ処理
$C1/8DD3 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C1/8DD5 LDA $7EE000,x           ;Aに[$7E:E001+x][$7E:E000+x]をロード
$C1/8DD9 STA $28    [$00:0328]   ;A(初期値2000)を[$00:0329][$00:0328]に書き込み
$C1/8DDB INX                     ;Xをインクリメント +1
$C1/8DDC INX                     ;Xをインクリメント +1
$C1/8DDD SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C1/8DDF LDA #$04                ;Aに$04をロード
$C1/8DE1 STA $2C    [$00:032C]   ;Aを[$00:032C]に書き込み
;
;ループ処理
$C1/8DE3 LDY #$0080              ;Yに$0080をロード
$C1/8DE6 STY $4305  [$00:4305]   ;Yを[$00:4306][$00:4305](転送するデータ量)に書き込み
$C1/8DE9 LDY $28    [$00:0328]   ;Yに[$00:0329][$00:0328]をロード
$C1/8DEB STY $2116  [$00:2116]   ;Yを[$00:2117][$00:2116](VRAMアドレス2バイト)に書き込み
$C1/8DEE LDA #$01                ;Aに$01をロード
$C1/8DF0 STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
$C1/8DF3 INC $29    [$00:0329]   ;[$00:0329]をインクリメント +1
$C1/8DF5 DEC $2C    [$00:032C]   ;[$00:032C](初期値$04)をデクリメント -1
$C1/8DF7 BNE $EA    [$8DE3]      ;ゼロフラグが立っていないとき[$8DE3]分岐
;ゼロフラグOFFなら$C1/8DE3ループ頭へ
;ゼロフラグON
$C1/8DF9 DEC $FE    [$00:03FE]   ;[$00:03FE]をデクリメント -1
$C1/8DFB BNE $D6    [$8DD3]      ;ゼロフラグが立っていないとき[$8DD3]分岐
;ループ処理ここまで
;
$C1/8DFD RTS                     ;サブルーチン戻り

$C1/62BF TXA                     ;Xレジスタの値をAレジスタに転送
$C1/62C0 LSR A                   ;Aを論理右シフト　(/2)
$C1/62C1 LSR A                   ;Aを論理右シフト　(/2)
$C1/62C2 ADC #$80                ;A + $80
$C1/62C4 STA $2121  [$00:2121]   ;Aを[$00:2121]に書き込み
$C1/62C7 LDA $0000,x             ;Aに[$00:1C00+40n](キャラID)をロード
$C1/62CA XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C1/62CB LDA #$00                ;Aに$00をロード
$C1/62CD REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C1/62CF LSR A                   ;Aを論理右シフト　(/2)
$C1/62D0 LSR A                   ;Aを論理右シフト　(/2)
$C1/62D1 LSR A                   ;Aを論理右シフト　(/2)
$C1/62D2 ADC $D60010[$D6:0010]   ;A + [$D6:0011][$D6:0010]($0080)
$C1/62D6 ADC #$2000              ;A + $2000
$C1/62D9 STA $4312  [$00:4312]   ;Aを[$00:4313][$00:4312]に書き込み
$C1/62DC SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C1/62DE LDA #$D6                ;Aに$D6をロード
$C1/62E0 STA $4314  [$00:4314]   ;Aを[$00:4314]に書き込み
$C1/62E3 LDX #$0020              ;Xに$0020をロード
$C1/62E6 STX $4315  [$00:4315]   ;Xを[$00:4316][$00:4315]に書き込み
$C1/62E9 LDA #$02                ;Aに$02をロード
$C1/62EB STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
$C1/62EE RTS                     ;サブルーチン戻り

$C1/8D9C LDA $FD    [$00:03FD]   ;Aに[$00:03FD]をロード
$C1/8D9E BNE $01    [$8DA1]      ;ゼロフラグが立っていないとき[$8DA1]分岐
$C1/8DA1 STZ $FD    [$00:03FD]   ;[$00:03FD]に$00を書き込み
$C1/8DA3 LDX #$0000              ;Xに$0000をロード
$C1/8DA6 STX $2102  [$00:2102]   ;Xを[$00:2103][$00:2102]に書き込み
$C1/8DA9 LDX #$0700              ;Xに$0700をロード
$C1/8DAC STX $4332  [$00:4332]   ;Xを[$00:4333][$00:4332]に書き込み
$C1/8DAF LDA #$7E                ;Aに$7Eをロード
$C1/8DB1 STA $4334  [$00:4334]   ;Aを[$00:4334]に書き込み
$C1/8DB4 LDX #$0220              ;Xに$0220をロード
$C1/8DB7 STX $4335  [$00:4335]   ;Xを[$00:4336][$00:4335]に書き込み
$C1/8DBA LDA #$08                ;Aに$08をロード
$C1/8DBC STA $420B  [$00:420B]   ;Aを[$00:420B]に書き込み
$C1/8DBF RTS                     ;サブルーチン戻り

;味方キャラの下位テーブル用データ獲得
$C1/5AC2 LDA $7EA4A7[$7E:A4A7]   ;Aに[$7E:A4A7]をロード
$C1/5AC6 BEQ $21    [$5AE9]      ;ゼロフラグが立っているとき[$5AE9]分岐
$C1/5AE9 LDY $D0    [$00:03D0]   ;Yに[$00:03D0]をロード
$C1/5AEB REP #$21                ;Aを16bit幅に変更、キャリーフラグクリア
$C1/5AED LDA $0010,x[$7E:1C50]   ;Aに[$7E:1C50]をロード
$C1/5AF0 ADC #$001F              ;A + $001F
$C1/5AF3 CMP #$011F              ;Aと$011Fを減算比較（ステータスレジスタ変更のみ）
$C1/5AF6 BCS $0D    [$5B05]      ;キャリーフラグが立っているとき[$5B05]分岐
$C1/5AF8 LDA $0012,x[$7E:1C52]   ;Aに[$7E:1C52]をロード
$C1/5AFB ADC #$001F              ;A + $001F
$C1/5AFE CMP #$00FF              ;Aと$00FFを減算比較（ステータスレジスタ変更のみ）
$C1/5B01 BCS $02    [$5B05]      ;キャリーフラグが立っているとき[$5B05]分岐
$C1/5B03 BRA $03    [$5B08]      ;フラグにかかわりなく常に分岐[$5B08]
$C1/5B08 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C1/5B0A LDA $0010,x[$7E:1C50]   ;Aに[$7E:1C50]をロード
$C1/5B0D STA $0700,y[$7E:0700]   ;Aを[$7E:0700](OAM X座標)に書き込み
$C1/5B10 INY                     ;Yをインクリメント +1
$C1/5B11 LDA $0012,x[$7E:1C52]   ;Aに[$7E:1C52]をロード
$C1/5B14 STA $0700,y[$7E:0701]   ;Aを[$7E:0701](OAM Y座標)に書き込み
$C1/5B17 INY                     ;Yをインクリメント +1
$C1/5B18 LDA $0005,x[$7E:1C45]   ;Aに[$7E:1C45]をロード
$C1/5B1B CMP #$20                ;Aと$20を減算比較（ステータスレジスタ変更のみ）
$C1/5B1D BNE $07    [$5B26]      ;ゼロフラグが立っていないとき[$5B26]分岐
$C1/5B26 LDA $8E    [$00:038E]   ;Aに[$00:038E]をロード
$C1/5B28 AND #$20                ;Aと$20で論理積
$C1/5B2A LSR A                   ;Aを論理右シフト　(/2)
$C1/5B2B LSR A                   ;Aを論理右シフト　(/2)
$C1/5B2C LSR A                   ;Aを論理右シフト　(/2)
$C1/5B2D ADC $000B,x[$7E:1C4B]   ;A + [$7E:1C4B]
$C1/5B30 STA $0700,y[$7E:0702]   ;Aを[$7E:0702](OAM VRAMアドレス)に書き込み
$C1/5B33 INY                     ;Yをインクリメント +1
$C1/5B34 LDA $001D,x[$7E:1C5D]   ;Aに[$7E:1C5D]をロード
$C1/5B37 AND #$81                ;Aと$81で論理積
$C1/5B39 BEQ $0C    [$5B47]      ;ゼロフラグが立っているとき[$5B47]分岐
$C1/5B3B CMP #$01                ;Aと$01を減算比較（ステータスレジスタ変更のみ）
$C1/5B3D BEQ $0C    [$5B4B]      ;ゼロフラグが立っているとき[$5B4B]分岐
$C1/5B4B LDA #$40                ;Aに$40をロード
$C1/5B4D BRA $02    [$5B51]      ;フラグにかかわりなく常に分岐[$5B51]
$C1/5B51 CLC                     ;キャリーフラグクリア
$C1/5B52 ADC $0009,x[$7E:1C49]   ;A + [$7E:1C49]
$C1/5B55 ADC #$30                ;A + $30
$C1/5B57 STA $0700,y[$7E:0703]   ;Aを[$7E:0703](OAM カラーパレットの値など)に書き込み
$C1/5B5A LDA $0011,x[$7E:1C51]   ;Aに[$7E:1C51]をロード
$C1/5B5D ROR A                   ;Aをキャリーフラグを含めた9bitで右ローテート
$C1/5B5E ROR A                   ;Aをキャリーフラグを含めた9bitで右ローテート
$C1/5B5F ROR A                   ;Aをキャリーフラグを含めた9bitで右ローテート
$C1/5B60 AND #$40                ;Aと$40で論理積
$C1/5B62 ORA #$80                ;Aと$80で論理和
$C1/5B64 JSR $5EF5  [$C1:5EF5]   ;[$C1:5EF5]へジャンプ

$C1/5EF5 CPY #$01FC              ;Yと$01FCを減算比較（ステータスレジスタ変更のみ）
;（中略 味方キャラの上位テーブル用データ獲得）
$C1/5F1C RTS                     ;サブルーチン戻り

;（中略）

$C1/0273 JSR $5F1D  [$C1:5F1D]   ;[$C1:5F1D]へジャンプ

$C1/5F1D LDA #$FF                ;Aに$FFをロード
$C1/5F1F STA $FD    [$00:03FD]   ;Aを[$00:03FD]に書き込み
$C1/5F21 LDY $D0    [$00:03D0]   ;Yに[$00:03D0]をロード
$C1/5F23 CPY #$0200              ;Yと$0200を減算比較（ステータスレジスタ変更のみ）
$C1/5F26 BNE $01    [$5F29]      ;ゼロフラグが立っていないとき[$5F29]分岐
;ループ開始
$C1/5F29 LDA #$10                ;Aに$10をロード
$C1/5F2B STA $0700,y[$00:0708]   ;Aを[$00:0708+y]に書き込み
$C1/5F2E INY                     ;Yをインクリメント +1
$C1/5F2F INY                     ;Yをインクリメント +1
$C1/5F30 INY                     ;Yをインクリメント +1
$C1/5F31 INY                     ;Yをインクリメント +1
$C1/5F32 CPY #$0200              ;Yと$0200を減算比較（ステータスレジスタ変更のみ）
$C1/5F35 BNE $F2    [$5F29]      ;ゼロフラグが立っていないとき[$5F29]分岐
;ループここまで
$C1/5F37 LDY $D0    [$00:03D0]   ;Yに[$00:03D0]をロード
$C1/5F39 TYA                     ;Yレジスタの値をAレジスタに転送
$C1/5F3A AND #$0C                ;Aと$0Cで論理積
$C1/5F3C BEQ $26    [$5F64]      ;ゼロフラグが立っているとき[$5F64]分岐
$C1/5F3E LSR A                   ;Aを論理右シフト　(/2)
$C1/5F3F LSR A                   ;Aを論理右シフト　(/2)
$C1/5F40 STA $08    [$00:0308]   ;Aを[$00:0308]に書き込み
$C1/5F42 LDA #$04                ;Aに$04をロード
$C1/5F44 SEC                     ;キャリーフラグON
$C1/5F45 SBC $08    [$00:0308]   ;A - [$00:0308]
$C1/5F47 STA $08    [$00:0308]   ;Aを[$00:0308]に書き込み
$C1/5F49 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C1/5F4B TYA                     ;Yレジスタの値をAレジスタに転送
$C1/5F4C LSR A                   ;Aを論理右シフト　(/2)
$C1/5F4D LSR A                   ;Aを論理右シフト　(/2)
$C1/5F4E LSR A                   ;Aを論理右シフト　(/2)
$C1/5F4F LSR A                   ;Aを論理右シフト　(/2)
$C1/5F50 AND #$001F              ;Aと$001Fで論理積
$C1/5F53 TAY                     ;Aの値をYレジスタに転送
$C1/5F54 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C1/5F56 LDA $0900,y[$00:0900]   ;Aに[$00:0900]をロード
$C1/5F59 LSR A                   ;Aを論理右シフト　(/2)
$C1/5F5A LSR A                   ;Aを論理右シフト　(/2)
$C1/5F5B ORA #$C0                ;Aと$C0で論理和
$C1/5F5D DEC $08    [$00:0308]   ;[$00:0308]をデクリメント -1
$C1/5F5F BNE $F8    [$5F59]      ;ゼロフラグが立っていないとき[$5F59]分岐
$C1/5F59 LSR A                   ;Aを論理右シフト　(/2)
$C1/5F5A LSR A                   ;Aを論理右シフト　(/2)
$C1/5F5B ORA #$C0                ;Aと$C0で論理和
$C1/5F5D DEC $08    [$00:0308]   ;[$00:0308]をデクリメント -1
$C1/5F5F BNE $F8    [$5F59]      ;ゼロフラグが立っていないとき[$5F59]分岐
$C1/5F61 STA $0900,y[$00:0900]   ;Aを[$00:0900]に書き込み
$C1/5F64 REP #$21                ;Aを16bit幅に変更、キャリーフラグクリア
$C1/5F66 LDA $D0    [$00:03D0]   ;Aに[$00:03D0]をロード
$C1/5F68 ADC #$000C              ;A + $000C
$C1/5F6B LSR A                   ;Aを論理右シフト　(/2)
$C1/5F6C LSR A                   ;Aを論理右シフト　(/2)
$C1/5F6D LSR A                   ;Aを論理右シフト　(/2)
$C1/5F6E LSR A                   ;Aを論理右シフト　(/2)
$C1/5F6F CMP #$0020              ;Aと$0020を減算比較（ステータスレジスタ変更のみ）
$C1/5F72 BEQ $12    [$5F86]      ;ゼロフラグが立っているとき[$5F86]分岐
$C1/5F74 AND #$001F              ;Aと$001Fで論理積
$C1/5F77 TAY                     ;Aの値をYレジスタに転送
$C1/5F78 SEP #$20                ;MフラグON　Aレジスタは8bit幅
;ループ開始
$C1/5F7A LDA #$FF                ;Aに$FFをロード
$C1/5F7C STA $0900,y             ;Aを[$00:0901+y]に書き込み
$C1/5F7F INY                     ;Yをインクリメント +1
$C1/5F80 CPY #$0020              ;Yと$0020を減算比較（ステータスレジスタ変更のみ）
$C1/5F83 BNE $F5    [$5F7A]      ;ゼロフラグが立っていないとき[$5F7A]分岐
;ループここまで
$C1/5F85 RTS                     ;サブルーチン戻り

$C2/3534 LDA $0675  [$7E:0675]   ;Aに[$7E:0675]をロード
$C2/3537 AND #$001F              ;Aと$001Fで論理積
$C2/353A XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C2/353B LSR A                   ;Aを論理右シフト　(/2)
$C2/353C PHA                     ;Aレジスタをスタックにプッシュ
$C2/353D LDA $0677  [$7E:0677]   ;Aに[$7E:0677]をロード
$C2/3540 AND #$001F              ;Aと$001Fで論理積
$C2/3543 ASL A                   ;Aを算術左シフト *2
$C2/3544 ASL A                   ;Aを算術左シフト *2
$C2/3545 CLC                     ;キャリーフラグクリア
$C2/3546 ADC $01,s  [$00:1FED]   ;A + [$00:1FED]
$C2/3548 CLC                     ;キャリーフラグクリア
$C2/3549 ADC $D50020[$D5:0020]   ;A + [$D5:0020]
$C2/354D TAX                     ;Aの値をXレジスタに転送
$C2/354E PLA                     ;Aレジスタにスタックからプル
$C2/354F LDA $D50002,x[$D5:5F4D] ;Aに[$D5:5F4D]をロード
$C2/3553 XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C2/3554 STA $067D  [$7E:067D]   ;Aを[$7E:067D]に書き込み
$C2/3557 LDA $D50000,x[$D5:5F4B] ;Aに[$D5:5F4B]をロード
$C2/355B AND #$07FF              ;Aと$07FFで論理積
$C2/355E ASL A                   ;Aを算術左シフト *2
$C2/355F ASL A                   ;Aを算術左シフト *2
$C2/3560 ASL A                   ;Aを算術左シフト *2
$C2/3561 ASL A                   ;Aを算術左シフト *2
$C2/3562 ASL A                   ;Aを算術左シフト *2
$C2/3563 TAY                     ;Aの値をYレジスタに転送
$C2/3564 LDA $D50000,x[$D5:5F4B] ;Aに[$D5:5F4B]をロード
$C2/3568 AND #$1800              ;Aと$1800で論理積
$C2/356B XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C2/356C LSR A                   ;Aを論理右シフト　(/2)
$C2/356D LSR A                   ;Aを論理右シフト　(/2)
$C2/356E TAX                     ;Aの値をXレジスタに転送
$C2/356F LDA $C274F8,x[$C2:74FC] ;Aに[$C2:74FC]をロード
$C2/3573 STA $0679  [$7E:0679]   ;Aを[$7E:0679]に書き込み
$C2/3576 TYX                     ;Yレジスタの値をXレジスタに転送
$C2/3577 LDA #$0010              ;Aに$0010をロード
$C2/357A STA $067B  [$7E:067B]   ;Aを[$7E:067B]に書き込み
$C2/357D LDY #$C000              ;Yに$C000をロード
$C2/3580 ASL $067D  [$7E:067D]   ;A[$7E:067D]を算術左シフト *2
$C2/3583 BCS $08    [$358D]      ;キャリーフラグが立っているとき[$358D]分岐
$C2/358D LDA #$001F              ;Aに$001Fをロード
$C2/3590 PER $0002  [$3595]      ;PCの値にオペランドとして指定した
                                 ;16bit値を足した値をスタックに積み
$C2/3593 JMP ($0679)[$C2:35A5]   ;[$C2:35A5]へジャンプ(レジスタをスタックに積まない)
$C2/35A5 MVN D9 7E               ;データ転送
;
;A:転送データサイズ-1 $001F
;X:転送元アドレス $FC20
;Y:転送先アドレス $C000
;オペランド:転送元と転送先バンク D9 -> 7E
;$D9:FC20 -> $7E:C000 +1Fバイト
;
$C2/35A8 RTS                     ;サブルーチン戻り
;
;（中略）
;
$C2/3596 DEC $067B  [$7E:067B]   ;[$7E:067B]をデクリメント -1
$C2/3599 BNE $E5    [$3580]      ;ゼロフラグが立っていないとき[$3580]分岐
$C2/3580 ASL $067D  [$7E:067D]   ;A[$7E:067D]を算術左シフト *2
$C2/3583 BCS $08    [$358D]      ;キャリーフラグが立っているとき[$358D]分岐
$C2/358D LDA #$001F              ;Aに$001Fをロード
$C2/3590 PER $0002  [$3595]      ;PCの値にオペランドとして指定した
                                 ;16bit値を足した値をスタックに積み[$3595]
$C2/3593 JMP ($0679)[$C2:35A5]   ;[$C2:35A5]へジャンプ(レジスタをスタックに積まない)
$C2/35A5 MVN D9 7E               ;データ転送
;
;A:転送データサイズ-1 $001F
;X:転送元アドレス $FD80
;Y:転送先アドレス $C1C0
;オペランド:転送元と転送先バンク D9 -> 7E
;$D9:FD80 -> $7E:C1C0 +1Fバイト
;
$C2/35A8 RTS                     ;サブルーチン戻り

$C2/34AC ASL A                   ;Aを算術左シフト *2
$C2/34AD ASL A                   ;Aを算術左シフト *2
$C2/34AE ASL A                   ;Aを算術左シフト *2
$C2/34AF CLC                     ;キャリーフラグクリア
$C2/34B0 ADC #$7528              ;A + $7528
$C2/34B3 TAX                     ;Aの値をXレジスタに転送
$C2/34B4 LDY #$0689              ;Yに$0689をロード
$C2/34B7 LDA #$0007              ;Aに$0007をロード
$C2/34BA MVN C2 00               ;データ転送
;
;A:転送データサイズ-1 $07
;X:転送元アドレス $7528
;Y:転送先アドレス $0689
;オペランド:転送元と転送先バンク C2 -> 00
;$C2:7528 -> $00:0689 +07バイト
;
$C2/34BD LDX #$C000              ;Xに$C000をロード
$C2/34C0 LDY $0689  [$00:0689]   ;Yに[$00:0689]をロード
$C2/34C3 LDA #$007F              ;Aに$007Fをロード
$C2/34C6 MVN 7E 7E               ;データ転送
;
;A:転送データサイズ-1 $7F
;X:転送元アドレス $C000
;Y:転送先アドレス $C800
;オペランド:転送元と転送先バンク 7E -> 7E
;$7E:C000 -> $7E:C800 +7Fバイト
;
$C2/34C9 LDY $068B  [$7E:068B]   ;Yに[$7E:068B]をロード
$C2/34CC LDA #$007F              ;Aに$007Fをロード
$C2/34CF MVN 7E 7E               ;データ転送
;
;A:転送データサイズ-1 $7F
;X:転送元アドレス $C080
;Y:転送先アドレス $CA00
;オペランド:転送元と転送先バンク 7E -> 7E
;$7E:C080 -> $7E:CA00 +7Fバイト
;
$C2/34D2 LDY $068D  [$7E:068D]   ;Yに[$7E:068D]をロード
$C2/34D5 LDA #$007F              ;Aに$007Fをロード
$C2/34D8 MVN 7E 7E               ;データ転送
;
;A:転送データサイズ-1 $7F
;X:転送元アドレス $C100
;Y:転送先アドレス $CC00
;オペランド:転送元と転送先バンク 7E -> 7E
;$7E:C100 -> $7E:CC00 +7Fバイト
;
$C2/34DB LDY $068F  [$7E:068F]   ;Yに[$7E:068F]をロード
$C2/34DE LDA #$007F              ;Aに$007Fをロード
$C2/34E1 MVN 7E 7E               ;データ転送
;
;A:転送データサイズ-1 $7F
;X:転送元アドレス $C180
;Y:転送先アドレス $CE00
;オペランド:転送元と転送先バンク 7E -> 7E
;$7E:C180 -> $7E:CE00 +7Fバイト
;
$C2/34E4 RTS                     ;サブルーチン戻り

$C2/3481 PLY                     ;Yレジスタにスタックからプル
$C2/3482 INY                     ;Yをインクリメント +1
$C2/3483 DEC $067F  [$7E:067F]   ;[$7E:067F]をデクリメント -1
$C2/3486 BPL $BE    [$3446]      ;ネガティブフラグが立っていないとき[$3446]分岐
$C2/3488 LDX #$7500              ;Xに$7500をロード
$C2/348B LDY #$4340              ;Yに$4340をロード
$C2/348E LDA #$0007              ;Aに$0007をロード
$C2/3491 PHB                     ;DBレジスタをスタックにプッシュ
$C2/3492 MVN C2 00               ;データ転送
;
;A:転送データサイズ-1 $0007
;X:転送元アドレス $7500
;Y:転送先アドレス $4340
;オペランド:転送元と転送先バンク C2 -> 00
;$C2:7500 -> $00:4340 +8バイト
;GDMA転送チャネル4の設定になる
;
$C2/3492 MVN C2 00               ;データ転送
$C2/3495 PLB                     ;DBレジスタにスタックからプル
$C2/3496 LDA #$4400              ;Aに$4400をロード
$C2/3499 STA $002116[$00:2116]   ;Aを[$00:2117][$00:2116]に書き込み
$C2/349D SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/349F LDA #$80                ;Aに$80をロード
$C2/34A1 STA $002115[$00:2115]   ;Aを[$00:2115]に書き込み
$C2/34A5 LDA #$10                ;Aに$10をロード
$C2/34A7 JSR $4C88  [$C2:4C88]   ;[$C2:4C88]へジャンプ

$C2/4C88 PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/4C89 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/4C8B XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C2/4C8C LDA $0600  [$7E:0600]   ;Aに[$7E:0600]をロード
$C2/4C8F BPL $07    [$4C98]      ;ネガティブフラグが立っていないとき[$4C98]分岐
$C2/4C91 XBA                     ;Aレジスタの上位バイトと下位バイトを交換
$C2/4C92 STA $00420B[$00:420B]   ;A($10=%0001 0000)を[$00:420B]に書き込み
$C2/4C96 BRA $07    [$4C9F]      ;フラグにかかわりなく常に分岐[$4C9F]
$C2/4C9F PLP                     ;Pレジスタにスタックからプル
$C2/4CA0 RTS                     ;サブルーチン戻り

$C2/0115 LDX #$72A8              ;Xに$72A8をロード
$C2/0118 LDY #$8C00              ;Yに$8C00をロード
$C2/011B LDA #$001F              ;Aに$001Fをロード
$C2/011E MVN C2 7E               ;データ転送
;
;A:転送データサイズ-1 $1F
;X:転送元アドレス $72A8
;Y:転送先アドレス $8C00
;オペランド:転送元と転送先バンク C2 -> 7E
;$C2:72A8 -> $7E:8C00 +$1Fバイト
;
$C2/0121 JSR $2DBC  [$C2:2DBC]   [$C2:2DBC]にジャンプ

$C2/34FC PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/34FD REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C2/34FF ASL A                   ;Aを算術左シフト *2
$C2/3500 ASL A                   ;Aを算術左シフト *2
$C2/3501 ASL A                   ;Aを算術左シフト *2
$C2/3502 ASL A                   ;Aを算術左シフト *2
$C2/3503 ASL A                   ;Aを算術左シフト *2
$C2/3504 CLC                     ;キャリーフラグクリア
$C2/3505 ADC #$8D00              ;A + $8D00
$C2/3508 TAY                     ;Aの値をYレジスタに転送
$C2/3509 LDA $0675  [$7E:0675]   ;Aに[$7E:0675]をロード
$C2/350C AND #$001F              ;Aと$001Fで論理積
$C2/350F ORA #$0100              ;Aと$0100で論理和
$C2/3512 ASL A                   ;Aを算術左シフト *2
$C2/3513 ASL A                   ;Aを算術左シフト *2
$C2/3514 ASL A                   ;Aを算術左シフト *2
$C2/3515 ASL A                   ;Aを算術左シフト *2
$C2/3516 ASL A                   ;Aを算術左シフト *2
$C2/3517 CLC                     ;キャリーフラグクリア
$C2/3518 ADC $D60010[$D6:0010]   ;A + [$D6:0010]
$C2/351C TAX                     ;Aの値をXレジスタに転送
$C2/351D LDA #$001F              ;Aに$001Fをロード
$C2/3520 PHB                     ;DBレジスタをスタックにプッシュ
$C2/3521 MVN D6 7E               ;データ転送
;
;A:転送データサイズ-1 $1F
;X:転送元アドレス $22A0
;Y:転送先アドレス $8D00
;オペランド:転送元と転送先バンク D6 -> 7E
;$D6:22A0 -> $7E:8D00 +$1Fバイト
;
$C2/3524 PLB                     ;DBレジスタにスタックからプル
$C2/3525 PLP                     ;Pレジスタにスタックからプル
$C2/3526 RTS                     ;サブルーチン戻り

$C2/4D55 PHB                     ;DBレジスタをスタックにプッシュ
$C2/4D56 PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/4D57 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/4D59 LDA #$02                ;Aに$02をロード
$C2/4D5B AND $7A    [$00:057A]   ;Aと[$00:057A]で論理積
$C2/4D5D BNE $17    [$4D76]      ;ゼロフラグが立っていないとき[$4D76]分岐
$C2/4D5F REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C2/4D61 LDX #$7912              ;Xに$7912をロード
$C2/4D64 LDY #$4310              ;Yに$4310をロード
$C2/4D67 LDA #$0007              ;Aに$0007をロード
$C2/4D6A MVN C2 00               ;データ転送
;
;A:転送データサイズ-1 $0007
;X:転送元アドレス $7912
;Y:転送先アドレス $4310
;オペランド:転送元と転送先バンク C2 -> 00
;$C2:7912 -> $00:4310 +8バイト
;GDMA転送チャネル1の設定になる

$C2/4D6D SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/4D6F STZ $2121  [$00:2121]   ;[$00:2121]に$00を書き込み
$C2/4D72 LDA #$02                ;Aに$02をロード
$C2/4D74 TSB $7A    [$00:057A]   ;Aと[$00:057A]で論理和を取り、メモリに書き戻し
$C2/4D76 PLP                     ;Pレジスタにスタックからプル
$C2/4D77 PLB                     ;DBレジスタにスタックからプル
$C2/4D78 RTS                     ;サブルーチン戻り

$C2/016F JSR $0526  [$C2:0526]   ;[$C2:0526]へジャンプ

$C2/0526 PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/0527 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/0529 LDA $004200[$00:4200]   ;Aに[$00:4200](割り込み有効化レジスタ)をロード
$C2/052D BMI $0B    [$053A]      ;ネガティブフラグが立っているとき[$053A]分岐
$C2/052F JSR $4B00  [$C2:4B00]   ;[$C2:4B00]へジャンプ

;*NMI割り込み
$00/00F8 JMP $C24DB0[$C2:4DB0]   ;[$C2:4DB0]へジャンプ(レジスタをスタックに積まない)
$C2/4DB0 REP #$30                ;Aを16bit幅に変更、X/Yレジスタを16bit幅に変更
$C2/4DB2 PHA                     ;Aレジスタをスタックにプッシュ
$C2/4DB3 PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/4DB4 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/4DB6 LDA $004210[$00:4210]   ;Aに[$00:4210](NMIフラグ)をロード
$C2/4DBA LDA #$00                ;Aに$00をロード
$C2/4DBC STA $00420C[$00:420C]   ;Aを[$00:420C](HDMAチャネルレジスタ)に書き込み
$C2/4DC0 STA $002102[$00:2102]   ;Aを[$00:2102](OAMアドレス(下位8bit))に書き込み
$C2/4DC4 LDA #$80                ;Aに$80をロード
$C2/4DC6 STA $002103[$00:2103]   ;Aを[$00:2103](OAMアドレス(上位1bit))に書き込み
$C2/4DCA LDA $00057A[$00:057A]   ;Aに[$00:057A]をロード
$C2/4DCE BEQ $0A    [$4DDA]      ;ゼロフラグが立っているとき[$4DDA]分岐
;ゼロフラグOFF（GDMA転送を行う）
$C2/4DD0 STA $00420B[$00:420B]   ;Aを[$00:420B](GDMAチャネルレジスタ)に書き込み

$C2/04FE PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/04FF REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C2/0501 LDX $00    [$00:0500]   ;Xに[$00:0501][$00:0500]をロード
$C2/0503 LDA #$E0FF              ;Aに$E0FFをロード
;ループ処理開始
$C2/0506 STA $0700,x             ;Aを[$7E:0701][$7E:0700]
                                 ;～[$7E:08FD][$7E:08FC]に書き込み
$C2/0509 STZ $0702,x             ;[$7E:0703][$7E:0702]
                                 ;～[$7E:08FF][$7E:08FE]に$00を書き込み
$C2/050C INX                     ;Xをインクリメント +1
$C2/050D INX                     ;Xをインクリメント +1
$C2/050E INX                     ;Xをインクリメント +1
$C2/050F INX                     ;Xをインクリメント +1
$C2/0510 CPX #$0200              ;Xと$0200を減算比較（ステータスレジスタ変更のみ）
$C2/0513 BMI $F1    [$0506]      ;ネガティブフラグが立っているとき[$0506]分岐
;ループ処理ここまで
$C2/0515 LDX $00    [$00:0500]   ;Xに[$00:0501][$00:0500]をロード
$C2/0517 LDA #$0000              ;Aに$0000をロード
;ループ処理開始
$C2/051A STA $0900,x             ;Aを[$7E:0901][$7E:0900]
                                 ;～[$7E:091F][$7E:091E]に書き込み
$C2/051D INX                     ;Xをインクリメント +1
$C2/051E INX                     ;Xをインクリメント +1
$C2/051F CPX #$0020              ;Xと$0020を減算比較（ステータスレジスタ変更のみ）
$C2/0522 BMI $F6    [$051A]      ;ネガティブフラグが立っているとき[$051A]分岐
;ループ処理ここまで
$C2/0524 PLP                     ;Pレジスタにスタックからプル
$C2/0525 RTS                     ;サブルーチン戻り

$C2/35F5 ASL A                   ;Aを算術左シフト *2
$C2/35F6 PHA                     ;Aレジスタをスタックにプッシュ
$C2/35F7 INX                     ;Xをインクリメント +1
$C2/35F8 PHX                     ;Xレジスタをスタックにプッシュ
$C2/35F9 TAX                     ;Aの値をXレジスタに転送
$C2/35FA LDA $C275DF,x[$C2:75E9] ;Aに[$C2:75E9]をロード
$C2/35FE PLX                     ;Xレジスタにスタックからプル
$C2/35FF CMP #$0000              ;Aと$0000を減算比較（ステータスレジスタ変更のみ）
$C2/3602 BEQ $09    [$360D]      ;ゼロフラグが立っているとき[$360D]分岐
$C2/3604 DEC A                   ;をデクリメント -1
$C2/3605 LDY #$0691              ;Yに$0691をロード
$C2/3608 PHB                     ;DBレジスタをスタックにプッシュ
$C2/3609 MVN C2 00               ;データ転送
;
;A:転送データサイズ-1 $0005
;X:転送元アドレス $7D2E
;Y:転送先アドレス $0691
;オペランド:転送元と転送先バンク C2 -> 00
;$C2:7D2E -> $00:0691 +6バイト
;
$C2/360C PLB                     ;DBレジスタにスタックからプル
$C2/360D PLA                     ;Aレジスタにスタックからプル
$C2/360E RTS                     ;サブルーチン戻り

$C2/35C3 PHX                     ;Xレジスタをスタックにプッシュ
$C2/35C4 TAX                     ;Aの値をXレジスタに転送
$C2/35C5 JSR ($75F3,x)[$C2:3789] ;[$C2:3789]へジャンプ

$C2/3789 JSR $36CF  [$C2:36CF]   ;[$C2:36CF]へジャンプ

$C2/36CF PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/36D0 LDA $0691  [$7E:0691]   ;Aに[$7E:0692][$7E:0691]をロード
$C2/36D3 AND #$007F              ;Aと$007Fで論理積
$C2/36D6 ASL A                   ;Aを算術左シフト *2
$C2/36D7 ASL A                   ;Aを算術左シフト *2
$C2/36D8 TAX                     ;Aの値をXレジスタに転送
$C2/36D9 LDA $0692  [$7E:0692]   ;Aに[$7E:0693][$7E:0692]をロード
$C2/36DC STA $0700,x[$7E:0710]   ;Aを[$7E:0711][$7E:0710]に書き込み
$C2/36DF LDA $0694  [$7E:0694]   ;Aに[$7E:0695][$7E:0694]をロード
$C2/36E2 STA $0702,x[$7E:0712]   ;Aを[$7E:0713][$7E:0712]に書き込み
$C2/36E5 LDA $0691  [$7E:0691]   ;Aに[$7E:0692][$7E:0691]をロード
$C2/36E8 AND #$007F              ;Aと$007Fで論理積
$C2/36EB LSR A                   ;Aを論理右シフト　(/2)
$C2/36EC LSR A                   ;Aを論理右シフト　(/2)
$C2/36ED TAY                     ;Aの値をYレジスタに転送
$C2/36EE LDA $0691  [$7E:0691]   ;Aに[$7E:0692][$7E:0691]をロード
$C2/36F1 AND #$0003              ;Aと$0003で論理積
$C2/36F4 TAX                     ;Aの値をXレジスタに転送
$C2/36F5 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/36F7 LDA $0691  [$7E:0691]   ;Aに[$7E:0691]をロード
$C2/36FA BMI $0B    [$3707]      ;ネガティブフラグが立っているとき[$3707]分岐
$C2/3707 LDA $C2761B,x[$C2:761B] ;Aに[$C2:761B]をロード
$C2/370B ORA $0900,y[$7E:0901]   ;Aと[$7E:0901]で論理和
$C2/370E STA $0900,y[$7E:0901]   ;Aを[$7E:0901]に書き込み
$C2/3711 PLP                     ;Pレジスタにスタックからプル
$C2/3712 RTS                     ;サブルーチン戻り

$C2/0782 REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C2/0784 LDA $7E8E02,x[$7E:8E02] ;Aに[$7E:8E03][$7E:8E02]をロード
$C2/0788 STA $000700[$00:0700]   ;Aを[$00:0701][$00:0700]に書き込み
$C2/078C LDA $34    [$00:0534]   ;Aに[$00:0535][$00:0534]をロード
$C2/078E STA $000702[$00:0702]   ;Aを[$00:0703][$00:0702]に書き込み
$C2/0792 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/0794 LDA $7E8E00,x[$7E:8E00] ;Aに[$7E:8E00]をロード
$C2/0798 STA $42    [$00:0542]   ;Aを[$00:0542]に書き込み
$C2/079A LDA $7E8E01,x[$7E:8E01] ;Aに[$7E:8E01]をロード
$C2/079E STA $44    [$00:0544]   ;Aを[$00:0544]に書き込み
$C2/07A0 JSR $4D35  [$C2:4D35]   ;[$C2:4D35]へジャンプ

$C2/4D35 PHB                     ;DBレジスタをスタックにプッシュ
$C2/4D36 PHP                     ;ステータスレジスタをスタックへプッシュ
$C2/4D37 SEP #$20                ;MフラグON　Aレジスタは8bit幅
$C2/4D39 LDA #$01                ;Aに$01をロード
$C2/4D3B AND $7A    [$00:057A]   ;Aと[$00:057A]で論理積
$C2/4D3D BNE $13    [$4D52]      ;ゼロフラグが立っていないとき[$4D52]分岐
$C2/4D3F REP #$20                ;Aを16bit幅に変更、Mフラグをクリア
$C2/4D41 LDX #$790A              ;Xに$790Aをロード
$C2/4D44 LDY #$4300              ;Yに$4300をロード
$C2/4D47 LDA #$0007              ;Aに$0007をロード
$C2/4D4A MVN C2 00               ;データ転送
;
;A:転送データサイズ-1 $0007
;X:転送元アドレス $790A
;Y:転送先アドレス $4300
;オペランド:転送元と転送先バンク C2 -> 00
;$C2:790A -> $00:4300 +8バイト
;GDMA転送チャネル0の設定になる
;
$C2/4D4D LDA #$0001              ;Aに$0001をロード
$C2/4D50 TSB $7A    [$00:057A]   ;Aと[$00:057A]で論理和を取り、メモリに書き戻し
$C2/4D52 PLP                     ;Pレジスタにスタックからプル
$C2/4D53 PLB                     ;DBレジスタにスタックからプル
$C2/4D54 RTS                     ;サブルーチン戻り