++ <<>> +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+                                                                }Nߊt@C                                                                                   +
+      () #<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>                                                                                                                      +
+Ӈ@.́A}CO[VfBNeBułB                                                                                                                          +
+      }CO[VfBNeBuƃ}N߂́Al[~O`ARɒǉEҏWE폜ł܂B                                                               +
+      eLXgȂAłΉ邽߁ÃvO~OꂾłȂAVavO~OłΉ܂B                                           +
+ӇA}CO[VfBNeBuƃ}N߂́Al[~O`Rɒǉł܂B                                                                               +
+ӇB\fBNeBu(if`elseif`else,for,while,do`while,switch`case,break,continue,goto)́A}N߂ŎĂ܂B                        +
+ӇC_Agoto΁AvbgtH[EvO킸A\vO~O邱Ƃł܂B                                           +
+ӇD}N߂́AׂĂ̈vꍇɁAeLXgu܂BłvȂƁAeLXguꂸAԃR[hfo܂B                         +
+      ֐^}N̕Iȃ}N߂܂B                                                                                                                 +
+      L[[h̏ꍇ̓vvZbT߁i#definejAL[[hȏ̏ꍇ̓}N߂ƋʂĂB                                                +
+      xȎgƂāAvvZbT߁i#definejƃ}N߂gݍ킹Ďgp邱Ƃł܂B                                                              +
+      ́isj/óisj̕s̃}N߂ɑΉ܂B                                                                                                +
+ӇE#́A}Nߒ`̊JnEIłB                                                                                                                          +
+ӇF:́A}Nߒ`̋؂蕶łB                                                                                                                              +
+ӇG}Nϐ́A<,>ň͂ĂB                                                                                                                                +
+ӇHIyh̎ނ́Aȉ̂ƂłB                                                                                                                             +
+      Iyh̎އ@DATA ------------- "DATA"B                                                                                                                +
+      Iyh̎އA<DATA> ----------- }NϐDATABWX^̎ʐݒƑΉ܂Bl[~ORB`Ŏwł܂B                                        +
+      Iyh̎އB<...> ------------ }Nϐ...BόłB\B<...>ȍ~̃}N܂Ƃ߂Ĉ̃}NƂĈ܂B`Ŏwł܂B+
+      Iyh̎އC<user> ----------- }NϐuserB[U[`L[[hu܂B\B`Ŏwł܂B                                      +
+      Iyh̎އD<imm> ------------ }NϐimmBl̎ʐݒƑΉ܂B\B`Ŏwł܂B                                                     +
+      Iyh̎އE<class> ---------- }NϐclassBNXu܂B\B                                                                               +
+      Iyh̎އF<keyword> -------- }NϐkeywordBXe[ggubNL[[h̎n[u܂B\B                                               +
+                                           <keyword>́APƎgpłA<keywordend>ƃyAŎgpĂ\܂B                                                         +
+      Iyh̎އG<keywordend> ----- }NϐkeywordendBXe[ggubNL[[h̏I[u܂B\B                                            +
+                                           <keywordend>́A<keyword>ƃyAŎgpĂB<keywordend>́A<keyword>ƃyAŎgpȂƁA}Nϊł܂B+
+      Iyh̎އH<size> ----------- ߃IyhTCYu܂B(Iyh̃WX^̃TCYvȂꍇATCY̏I܂)\B        +
+      Iyh̎އI<size2> ---------- ߃IyhTCYu܂B(Iyh̃WX^̃TCYvȂꍇATCY̑傫I܂)\B        +
+      Iyh̎އJ<trueaddress> ---- ^̎̃WvAhXu܂B\B                                                                      +
+                                           <trueaddress>́A䕶(if`elseif`else,for,while,do`while,switch`case)̏ɑ΂āALłB              +
+      Iyh̎އK<falseaddress> --- U̎̃WvAhXu܂B\B                                                                      +
+                                           <falseaddress>́A䕶(if`elseif`else,for,while,do`while,switch`case)̏ɑ΂āALłB             +
+      Iyh̎އL<address> -------- 䕶(break,continue)̃WvAhXu܂B\B                                                          +
+                                           <address>́A䕶(break,continue)̏ɑ΂āALłB                                                           +
+      OWvł̊֌WZqƂ́A\fBNeBuŁA<trueaddress><falseaddress>gpāA}NߋLq֌WZq̂ƂłB                      +
+      V[gWvł̊֌WZqƂ́A\fBNeBuŁA<falseaddress>݂̂ŁA}NߋLq֌WZq̂ƂłB                                       +
+      OłAV[gWvł̊֌WZq𑽗pقAR[hTCY邱Ƃł܂B                                                         +
+      V[gWvł̊֌WZq́ARɍ쐬ĂBOWvł̊֌WZqƏd܂̂ŁAl[~Oɂ͋CtĂB                     +
+        (OWv)                           (V[gWv)                                                                                                +
+        #<Ra> >=+ <imm>:   cmp   <Ra>,<imm>          #<Ra> >=+ <imm>:   cmp   <Ra>,<imm>                                                                                 +
+                       :   jae   <trueaddress>  --->                :   jb    <falseaddress>                                                                             +
+                       :   jmp   <falseaddress>                                                                                                                          +
+      V[gWvł̊֌WZqŁAjmp size error\ꂽꍇ́AY֌WZqOWvłɐ؂ւĂB                                       +
+      V[gWvł̊֌WZqgpꍇA\fBNeBu̘_ZqgpȂłB                                                           +
+        ̖ŁA}Nϊ܂B͉\łAR[h̃WbNώGɂȂׁAΉ\͂܂B                                     +
+      򖽗߂̍œK(֌WZqV[gWvłɂ邩AOWvłɂ邩̒)́A蓮Ń`[jOĂB                                     +
+      <imm>,<user>,<...>,<class>,<keyword>,<keywordend>,<size>,<size2>,<trueaddress>,<falseaddress>,<address>,\<,\:,\#́A\łB                                 +
+      }Nϐ̐擪ṔApɂĂB                                                                                                                   +
+      }Nϐ̐擪AWX^̎ʐݒ̎́AWX^Ƃ݂Ȃ܂B                                                                                       +
+      }Nϐ̐擪Al̎ʐݒ̎́AlƂ݂Ȃ܂B                                                                                               +
+      <size><size2>̒ĺAb,w,l,q,o,' '6ނłB                                                                                                                +
+      <size><size2>̒ĺAWX^̎ʐݒ肩擾Ă܂B                                                                                                    +
+ӇIbreak,continue,goto,b=,w=,l=,q=,o=, =,imm=,labelhead=,labelend=,file=́A\łB                                                                              +
+ӇJb=,w=,l=,q=,o=, =́AWX^̎ʐݒłB̋Aɓo^B                                                                                    +
+ӇKimm=́Al̎ʐݒłB̋Aɓo^B                                                                                                     +
+ӇLkeyword=́AXe[ggubNL[[h̎n[łB̋Aɓo^B                                                                         +
+ӇMkeywordend=́AXe[ggubNL[[h̏I[łB̋Aɓo^B                                                                      +
+ӇNuser=́A[U[`L[[hłB̋Aɓo^B`Ŏwł܂B                                                                +
+ӇOlabelhead=,labelend=́Ax̎ʐݒłB                                                                                                                     +
+ӇPfile=́A\[Xt@C̊gq̎ʐݒłB                                                                                                                    +
+ӇQ}N߂Lɂ邽߂ɁA}Nϐƃ}Nϐ̊ԁA}Nϐƃ}NZq̊Ԃɂ́A󔒂Pċ敪ĂB                                     +
+      󔒂A󔒂2ȏ゠ƐA}Nϊł܂B                                                                                              +
+ӇR҂悤ȃ}NϊłȂ́AʂɃ}N߂ĂB                                                                                         +
+ӇSL̃}N߂ƕϊ̃R[hQlɁAvO~OĂB                                                                                             +
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.C# to Java
#class <Ra> \: IVehicle {:class <Ra> implements Vehicle {
#class <Ra> \: <Rb> {:class <Ra> extends <Rb> {
#var <Ra> = new List \< <Rb> \> <...>:List<<Rb>\> <Ra> = new ArrayList<><...>
#var <Ra> = new Dictionary \< <...> \> <...2>:Map<<...>\> <Ra> = new HashMap<><...2>
#foreach ( var <Ra> in <Rb> ):for(String <Ra> \: <Rb>)
#<Ra> is not null:<Ra> != null
#var <Ra> = <Rb> ?? <imm> ;:String <Ra> = <Rb> != null ? <Rb> \: <imm>;
#async Task <Ra> ( ):CompletableFuture<Void> <Ra>()
#[ <Ra> ]:@<Ra>
#static <Ra> <Rb> ( <...> ):public static <Ra> <Rb>(<...>)
#namespace <Ra> ;:package <Ra>;
#using System.Text ;:import java.util.*;
#class <...>:class <...> {
 {          :
#<user1> class <...>:<user1> class <...> {
 {                  :
#<user1> void <Ra> ( ):<user1> void <Ra>() {
 {                    :
#<user1> <Ra> ( <...> ):<user1> <Ra>(<...>) {
 {                     :
#<user1> <user> <Ra> { get ; set ; }:private <user> <Ra>;
                                    :<user1> <user> get<Ra>() { return <Ra>; }
                                    :<user1> void set<Ra>(<user> <Ra>) { this.<Ra> = <Ra>; }
#<Ra> = <Ra> ;:this.<Ra> = <Ra>;
#<Ra> == <Ra> . <Rb>:<Ra> -> <Ra>.get<Rb>()
#<Ra> . <Rb>:<Ra>.get<Rb>()
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#user=byte,short,int,long,,float,double,char,boolean,String
#user1=public,private,internal,protected,protected internal
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=java
.Java to C#
#class <Ra> implements Vehicle {:class <Ra> \: IVehicle {
#class <Ra> extends <Rb> {:class <Ra> \: <Rb> {
#List \< <Rb> \> <Ra> = new ArrayList ^^ ;:var <Ra> = new List<<Rb>\>();
#Map \< <...> \> <Ra> = new HashMap ^^ ;:var <Ra> = new Dictionary<<...>\>();
#for ( <user> <Ra> \: <Rb> ):foreach(var <Ra> in <Rb>)
#<Ra> != null:<Ra> is not null
#<user> <Ra> = <Rb> != null ?? <Rb> \: <imm> ;:var <Ra> = <Rb> ?? <imm>;
#CompletableFuture<Void> <Ra> **:async Task <Ra>()
#@ <Ra>:[<Ra>]
#public static <Ra> <Rb> ( <...> ):static <Ra> <Rb>(<...>)
#package <Ra> ;:namespace <Ra>;
#import java.util.* ;:using System.Text;
#class <...> {:class <...>
              :{
#<user1> class <...> {:<user1> class <...>
                      :{
#<user1> void <Ra> ** {:<user1> void <Ra>()
                    :{
#<user1> <Ra> ( <...> ) {:<user1> <Ra>(<...>)
                         :{
#private <user> <Ra> ;                                        :<user1> <user> <Ra> { get ; set ; }
 <user1> <user> get <Ra> ** { return <Ra> ; }                 :
 <user1> void set <Ra> ( <user> <Ra> ) { this. <Ra> = <Ra> ; }:
#this. <Ra> = <Ra> ;:<Ra> = <Ra>;
#<Ra> -- <Ra> . get <Rb> **:<Ra> => <Ra>.<Rb>
#<Ra> . get <Rb> **:<Ra>.<Rb>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#user=byte,short,int,long,,float,double,char,bool,string
#user1=public,private,internal,protected,protected internal
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=cs
.C# to VB.NET
#<Ra> <Rb> = ( <Ra> ) <Rc> ;:Dim <Rb> As <Ra> = CType(<Rc>,<Ra>)
#var <Ra> ;:Dim <Ra>
#<user> ( ) <Rb> = <imm> ;:Dim <Rb> As <user>() = <imm>
#<user> <Rb> = <imm> ;:Dim <Rb> As <user> = <imm>
#<user> ( ) <Ra> ;:Dim <Ra> As <user>()
#<user> <Ra> ;:Dim <Ra> As <user>
#<user> ( ) <Rb> = <imm>:<Rb> As <user>() = <imm>
#<user> <Rb> = <imm>:<Rb> As <user> = <imm>
#<user> ( ) <Ra>:<Ra> As <user>()
#<user> <Ra>:<Ra> As <user>
#<Ra> as <Rb>:CType(<Ra>,<Rb>)
#<Ra> += <...> ;:AddHandler <Ra> , AddressOf <...>
#<Ra> -= <...> ;:RemoveHandler <Ra> , AddressOf <...>
#<Ra> ++:<Ra> += 1
#<Ra> --:<Ra> -= 1
#Private <Rb> <Ra> = <imm> ;:Private <Ra> As <Rb> = <imm>
#[ Flags ]   :\<Flags()\> Class <...>
 Class <...> :
 {           :
#[ Flags ]  :\<Flags()\> Enum <...>
 Enum <...> :
 {          :
#[ Flags ]        :\<Flags()\> <Ra> Class <...>
 <Ra> Class <...> :
 {                :
#[ Flags ]       :\<Flags()\> <Ra> Enum <...>
 <Ra> Enum <...> :
 {               :
#[ Flags ]             :\<Flags()\> <Rb> <Ra> Class <...>
 <Rb> <Ra> Class <...> :
 {                     :
#[ Flags ]            :\<Flags()\> <Rb> <Ra> Enum <...>
 <Rb> <Ra> Enum <...> :
 {                    :
#[ <...> ]    :\<<...>\> Class <...2>
 Class <...2> :
 {            :
#[ <...> ]   :\<<...>\> Enum <...2>
 Enum <...2> :
 {           :
#[ <...> ]         :\<<...>\> <Rb> Class <...2>
 <Rb> Class <...2> :
 {                 :
#[ <...> ]        :\<<...>\> <Rb> Enum <...2>
 <Rb> Enum <...2> :
 {                :
#[ <...> ]              :\<<...>\> <Rc> <Rb> Class <...2>
 <Rc> <Rb> Class <...2> :
 {                      :
#[ <...> ]             :\<<...>\> <Rc> <Rb> Enum <...2>
 <Rc> <Rb> Enum <...2> :
 {                     :
#Class <Ra> \: <...>:Class <Ra> Inherits <...>
 {                  :
#Class <Ra> \: <...>:Class <Ra> Implements <...>
 {                  :
#<Rd> this ( <...> ):Default ReadOnly Property Accounts(<...>) As <Rd>
 {                  :
#<Rd> this ( ):Default ReadOnly Property Accounts() As <Rd>
 {            :
#<Rb> <Ra> { Get; Set; }:Property <Ra> As <Rb> = <imm>
 <class> ( )            :
 {                      :
  <Ra> = <imm> ;        :
 }                      :
#<Rb> <Ra> { Get; Private Set; }:ReadOnly Property <Ra> As <Rb> = <imm>
 <class> ( )                    :
 {                              :
 <Ra> = <imm> ;                 :
 }                              :
#<Rb> <Ra> { Private Get; Set; }:WriteOnly Property <Ra> As <Rb> = <imm>
 <class> ( )                    :
 {                              :
 <Ra> = <imm> ;                 :
 }                              :
#<Rb> <Ra>     :Property <Ra>() As <Rb>
 {             :Get
 Get           :<Rc> <Rd>
 {             :End Get
 <Rc> <Rd> ;   :Set(ByVal <Rf> As <Rb>)
 }             :<Re> = <Rf>
 Set           :End Set
 {             :End Property
 <Re> = <Rf> ; :
 }             :
 }             :
#<Rb> <Ra>     :ReadOnly Property <Ra>() As <Rb>
 {             :Get
 Get           :<Rc> <Rd>
 {             :End Get
 <Rc> <Rd> ;   :End Property
 }             :
 }             :
#<Rb> <Ra>     :WriteOnly Property <Ra>() As <Rb>
 {             :Set(ByVal <Rd> As <Rb>)
 Set           :<Rc> = <Rd>
 {             :End Set
 <Rc> = <Rd> ; :End Property
 }             :
 }             :
#<Rb> Class <Ra> \: <...>:<Rb> Class <Ra> Inherits <...>
 {                       :
#<Rb> Class <Ra> \: <...>:<Rb> Class <Ra> Implements <...>
 {                       :
#<user1> <Rd> this ( <...> ):<user1> Default ReadOnly Property Accounts(<...>) As <Rd>
 {                          :
#<user1> <Rd> this ( ):<user1> Default ReadOnly Property Accounts() As <Rd>
 {                    :
#<Rc> <Rb> <Ra> { Get; Set; }:<Rc> Property <Ra> As <Rb> = <imm>
 <Rc> <class> ( )            :
 {                           :
  <Ra> = <imm> ;             :
 }                           :
#<Rc> <Rb> <Ra> { Get; Private Set; }:<Rc> ReadOnly Property <Ra> As <Rb> = <imm>
 <Rc> <class> ( )                    :
 {                                   :
 <Ra> = <imm> ;                      :
 }                                   :
#<Rc> <Rb> <Ra> { Private Get; Set; }:<Rc> WriteOnly Property <Ra> As <Rb> = <imm>
 <Rc> <class> ( )                    :
 {                                   :
 <Ra> = <imm> ;                      :
 }                                   :
#<Rg> <Rb> <Ra> :<Rg> Property <Ra>() As <Rb>
 {              :Get
 Get            :<Rc> <Rd>
 {              :End Get
 <Rc> <Rd> ;    :Set(ByVal <Rf> As <Rb>)
 }              :<Re> = <Rf>
 Set            :End Set
 {              :End Property
 <Re> = <Rf> ;  :
 }              :
 }              :
#<Re> <Rb> <Ra> :<Re> ReadOnly Property <Ra>() As <Rb>
 {              :Get
 Get            :<Rc> <Rd>
 {              :End Get
 <Rc> <Rd> ;    :End Property
 }              :
 }              :
#<Re> <Rb> <Ra> :<Re> WriteOnly Property <Ra>() As <Rb>
 {              :Set(ByVal <Rd> As <Rb>)
 Set            :<Rc> = <Rd>
 {              :End Set
 <Rc> = <Rd> ;  :End Property
 }              :
 }              :
#Namespace <...>:Namespace <...>
 {              :
#using <...> ;:Imports <...>
#<Ra> <Rb> = Shadows <Ra> ( ) ;:Dim <Rb> As <Ra> = New <Ra>()
#<Ra> <Rb> = Shadows <Ra> ( <Rc> ) ;:Dim <Rb> As <Ra> = AddressOf <Rc>
#var <Ra> = Shadows <Rb> ( <Rc> ) ;:Dim <Ra> = New <Rb>(<Rc>)
#[Optional] ref <Rb> <Ra>:Optional ByRef <Ra> As <Rb>
#[Optional] out ref <Rb> <Ra>:Optional \<Out()\> ByRef <Ra> As <Rb>
#[Optional] out <Rb> <Ra>:Optional \<Out()\> <Ra> As <Rb>
#[Optional] <Rb> <Ra>:Optional <Ra> As <Rb>
#ParamArray <Rb> <Ra>:ParamArray <Ra> As <Rb>
#ref <Rb> <Ra>:ByRef <Ra> As <Rb>
#out ref <Rb> <Ra>:\<Out()\> ByRef <Ra> As <Rb>
#out <Rb> <Ra>:\<Out()\> <Ra> As <Rb>
#Class <...>:Class <...>
 {          :
#<user1> Class <...>:<user1> Class <...>
 {                  :
#<user1> <Rb> Class <...>:<user1> <Rb> Class <...>
 {                       :
#Enum <...>:Enum <...>
 {         :
#<Ra> Enum <...>:<Ra> Enum <...>
 {              :
#<Ra> <Rb> Enum <...>:<Ra> <Rb> Enum <...>
 {                   :
#End For:Next
#End Foreach:Next
#}:<keywordend> <keyword>
#End Do <...>:Loop While <...>
#return <...>:Return <...>
#return ;:Return
#Exit Foreach:Exit For
#Continue Foreach:Continue For
#break:Exit <keyword>
#continue:Continue <keyword>
#Select ( <...> ):Select Case <...>
 {               :       Case <...2>
 case <...2> \:  :
#break ;      :Case <...>
 case <...> \::
#break ;   :Case Else
 default \::
#Do:Do
 { :
#} While ( <...> ) ;:<keywordend> <keyword> <...>
#While ( <...> ):While <...>
 {              :
#If ( <...> ):If <...> Then
 {           :
#}                :ElseIf <...> Then
 else If ( <...> ):
 {                :
#}   :Else
 else:
 {   :
#Get:Get
 {  :
#Set:Set
 {  :
#Foreach ( <Rb> <Ra> in <Rc> ):For Each <Ra> As <Rb> In <Rc>
 {                            :
#For ( <Ra> = 0 ; <Ra> <= <imm> ; <Ra> ++ ):For <Ra> = 0 To <imm>
 {                                         :
#For ( <Ra> = 0 ; <Ra> <= <imm> ; <Ra> = <Ra> + <imm2> ):For <Ra> = 0 To <imm> Step <imm2>
 {                                                      :
#For ( <Ra> = 0 ; <Ra> <= <Rb> ; <Ra> ++ ):For <Ra> = 0 To <Rb>
 {                                        :
#For ( <Ra> = 0 ; <Ra> <= <Rb> ; <Ra> = <Ra> + <imm> ):For <Ra> = 0 To <Rb> Step <imm>
 {                                                    :
#For ( <Ra> = <imm> ; <Ra> >= 0 ; <Ra> -- ):For <Ra> = <imm> To 0
 {                                         :
#For ( <Ra> = <imm> ; <Ra> >= 0 ; <Ra> = <Ra> - <imm2> ):For <Ra> = <imm> To 0 Step -<imm2>
 {                                                      :
#<Re> <Rd> = ( <Ra> ) ? <Rb> \: <Rc>:Dim <Rd> As <Re> = IIf(<Ra>,<Rb>,<Rc>)
#<Re> = ( <Ra> ) ? <Rb> \: <Rc>:<Re> = IIf(<Ra>,<Rb>,<Rc>)
#( <Ra> ) ? <Rb> \: <Rc>:IIf(<Ra>,<Rb>,<Rc>)
#<Rc> <Rb> Structure <Ra>:<Rc> <Rb> Structure <Ra>
 {                       :
#<Rb> Structure <Ra>:<Rb> Structure <Ra>
 {                  :
#Structure <Ra>:Structure <Ra>
 {             :
#Try:Try
 {  :
#}                  :Catch <Ra> As <Rb>
 catch ( <Rb> <Ra> ):
 {                  :
#}    :Catch
 catch:
 {    :
#}      :Finally
 finally:
 {      :
#System.Type <Ra> = <...> ( ) ;:Dim <Ra> As Type = <...>
#Overrides NotOverridable void <Ra> ( <...> ):NotOverridable Overrides Sub <Ra>(<...>)
 {                                           :
#Overrides NotOverridable void <Ra> ( ):NotOverridable Overrides Sub <Ra>()
 {                                     :
#NotOverridable Class <Ra> \: <...>:NotInheritable Class <Ra> Inherits <...>
 {                                 :
#Interface <Ra> \: <...>:Interface <Ra> Inherits <...>
 {                      :
#Interface <Ra>:Interface <Ra>
 {             :
#<Ra> Overrides NotOverridable void <Rb> ( <...> ):<Ra> NotOverridable Overrides Sub <Rb>(<...>)
 {                                                :
#<Ra> Overrides NotOverridable void <Rb> ( ):<Ra> NotOverridable Overrides Sub <Rb>()
 {                                          :
#<Rb> NotOverridable Class <Ra> \: <...>:<Rb> NotInheritable Class <Ra> Inherits <...>
 {                                      :
#<Rb> Interface <Ra> \: <...>:<Rb> Interface <Ra> Inherits <...>
 {                           :
#<Rb> Interface <Ra>:<Rb> Interface <Ra>
 {                  :
#<Rc> <Ra> Overrides NotOverridable void <Rb> ( <...> ):<Rc> <Ra> NotOverridable Overrides Sub <Rb>(<...>)
 {                                                     :
#<Rc> <Ra> Overrides NotOverridable void <Rb> ( ):<Rc> <Ra> NotOverridable Overrides Sub <Rb>()
 {                                               :
#<Rc> <Rb> NotOverridable Class <Ra> \: <...>:<Rc> <Rb> NotInheritable Class <Ra> Inherits <...>
 {                                           :
#<Rc> <Rb> Interface <Ra> \: <...>:<Rc> <Rb> Interface <Ra> Inherits <...>
 {                                :
#<Rc> <Rb> Interface <Ra>:<Rc> <Rb> Interface <Ra>
 {                       :
#delegate void <Ra> ( <...> ) ;:Delegate Sub <Ra>(<...>)
#delegate <Rb> <Ra> ( <...> ) ;:Delegate Function <Ra>(<...>) As <Rb>
#delegate void <Ra> ( ) ;:Delegate Sub <Ra>()
#delegate <Rb> <Ra> ( ) ;:Delegate Function <Ra>() As <Rb>
#var <Ra> = Shadows <Rb> ( ) { <...> } ;:Dim <Ra> = New <Rb> With {. <...> }
#List \< <Ra> \> <Rb> = Shadows List \< <Ra> \> <...2> ;:Dim <Rb> As List(Of <Ra>) = New List(Of <Ra>) From <...2>
#var <Ra> = Shadows Dictionary \< <...> \> <...2> ;:Dim <Ra> = New Dictionary(Of <...>) From <...2>
#Event <Rb> <Ra> ;:Event <Ra> As <Rb>
#<Rc> Event <Rb> <Ra> ;:<Rc> Event <Ra> As <Rb>
#<Rd> <Rc> Event <Rb> <Ra> ;:<Rd> <Rc> Event <Ra> As <Rb>
#~ <class> ( <...> ):Protected Overrides Sub Finalize(<...>)
 {                  :
#~ <Ra> <class> ( <...> ):<Ra> Protected Overrides Sub Finalize(<...>)
 {                       :
#~ <Ra> <Rb> <class> ( <...> ):<Ra> <Rb> Protected Overrides Sub Finalize(<...>)
 {                            :
#~ <class> ( ):Protected Overrides Sub Finalize()
 {            :
#~ <Ra> <class> ( ):<Ra> Protected Overrides Sub Finalize()
 {                 :
#~ <Ra> <Rb> <class> ( ):<Ra> <Rb> Protected Overrides Sub Finalize()
 {                      :
#<user> ( ) <Rb> ( <...> ):Function <Rb>(<...>) As <user>()
 {                        :
#<user> <Rb> ( <...> ):Function <Rb>(<...>) As <user>
 {                    :
#<Ra> <user> ( ) <Rb> ( <...> ):<Ra> Function <Rb>(<...>) As <user>()
 {                             :
#<Ra> <user> <Rb> ( <...> ):<Ra> Function <Rb>(<...>) As <user>
 {                         :
#void <Rb> ( ):Sub <Rb>()
 {            :
#void <Rb> ( <...> ):Sub <Rb>(<...>)
 {                  :
#<class> ( ):Sub New()
 {          :
#<user1> <class> ( ):<user1> Sub New()
 {                  :
#<class> ( <...> ):Sub New(<...>)
 {                :
#<user1> <class> ( <...> ):<user1> Sub New(<...>)
 {                        :
#<Ra> <class> ( ):<Ra> Sub New()
 {               :
#<user1> <Rb> <class> ( ):<user1> <Rb> Sub New()
 {                       :
#<Ra> <class> ( <...> ):<Ra> Sub New(<...>)
 {                     :
#<user1> <Rb> <class> ( <...> ):<user1> <Rb> Sub New(<...>)
 {                             :
#<class> ( ) \: base ( <Ra> ):Sub New()
 {                           :MyBase.New(<Ra>)
#<user1> <class> ( ) \: base ( <Ra> ):<user1> Sub New()
 {                                   :MyBase.New(<Ra>)
#<class> ( <...> ) \: base ( <Ra> ):Sub New(<...>)
 {                                 :MyBase.New(<Ra>)
#<user1> <class> ( <...> ) \: base ( <Ra> ):<user1> Sub New(<...>)
 {                                         :MyBase.New(<Ra>)
#<Ra> <class> ( ) \: base ( <Rb> ):<Ra> Sub New()
 {                                :MyBase.New(<Rb>)
#<user1> <Rb> <class> ( ) \: base ( <Ra> ):<user1> <Rb> Sub New()
 {                                        :MyBase.New(<Ra>)
#<Ra> <class> ( <...> ) \: base ( <Rb> ):<Ra> Sub New(<...>)
 {                                      :MyBase.New(<Rb>)
#<user1> <Rb> <class> ( <...> ) \: base ( <Ra> ):<user1> <Rb> Sub New(<...>)
 {                                              :MyBase.New(<Ra>)
#<class> ( ) \: this ( <Ra> ):Sub New()
 {                           :Me.New(<Ra>)
#<user1> <class> ( ) \: this ( <Ra> ):<user1> Sub New()
 {                                   :Me.New(<Ra>)
#<class> ( <...> ) \: this ( <Ra> ):Sub New(<...>)
 {                                 :Me.New(<Ra>)
#<user1> <class> ( <...> ) \: this ( <Ra> ):<user1> Sub New(<...>)
 {                                         :Me.New(<Ra>)
#<Ra> <class> ( ) \: this ( <Rb> ):<Ra> Sub New()
 {                                :Me.New(<Rb>)
#<user1> <Rb> <class> ( ) \: this ( <Ra> ):<user1> <Rb> Sub New()
 {                                        :Me.New(<Ra>)
#<Ra> <class> ( <...> ) \: this ( <Rb> ):<Ra> Sub New(<...>)
 {                                      :Me.New(<Rb>)
#<user1> <Rb> <class> ( <...> ) \: this ( <Ra> ):<user1> <Rb> Sub New(<...>)
 {                                              :Me.New(<Ra>)
#SyncLock ( <Ra> ) :SyncLock <Ra>
 {                 :
#<Ra> void <Rb> ( ):<Ra> Sub <Rb>()
 {                 :
#<Ra> void <Rb> ( <...> ):<Ra> Sub <Rb>(<...>)
 {                       :
#<Ra> <Rc> void <Rb> ( ):<Ra> <Rc> Sub <Rb>()
 {                      :
#<Ra> <Rc> void <Rb> ( <...> ):<Ra> <Rc> Sub <Rb>(<...>)
 {                            :
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=AddHandler,Class,Enum,Event,Function,Get,If,Interface,Module,Namespace,Operator,Property,RaiseEvent,RemoveHandler,Select,Set,Structure,Sub,SyncLock,Try,While,With,For,Foreach,Do
#keywordend=End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End
#user=SByte,Byte,Short,UShort,Integer,UInteger,Long,ULong,Single,Double,Char,Boolean,Decimal,String,Object
#user1=Public,Private,Friend,Protected,Protected Friend
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=vb
.VB.NET to C#
#AddHandler <Ra> , AddressOf <...>:<Ra> += <...> ;
#RemoveHandler <Ra> , AddressOf <...>:<Ra> -= <...> ;
#<Ra> += 1:<Ra>++
#<Ra> -= 1:<Ra>--
#<Ra> = <Ra> + 1:<Ra>++
#<Ra> = <Ra> - 1:<Ra>--
#private <Ra> As <Rb> = <imm>:private <Rb> <Ra> = <imm> ;
#\< Flags ( ) \> Class <...>:[Flags]
                            :class <...>
                            :{
#\< Flags ( ) \> Enum <...>:[Flags]
                           :enum <...>
                           :{
#\< Flags ( ) \> <Ra> Class <...>:[Flags]
                                 :<Ra> class <...>
                                 :{
#\< Flags ( ) \> <Ra> Enum <...>:[Flags]
                                :<Ra> enum <...>
                                :{
#\< Flags ( ) \> <Rb> <Ra> Class <...>:[Flags]
                                      :<Rb> <Ra> class <...>
                                      :{
#\< Flags ( ) \> <Rb> <Ra> Enum <...>:[Flags]
                                     :<Rb> <Ra> enum <...>
                                     :{
#\< <...> \> Class <...2>:[<...>]
                         :class <...2>
                         :{
#\< <...> \> Enum <...2>:[<...>]
                        :enum <...2>
                        :{
#\< <...> \> <Rb> Class <...2>:[<...>]
                              :<Rb> class <...2>
                              :{
#\< <...> \> <Rb> Enum <...2>:[<...>]
                             :<Rb> enum <...2>
                             :{
#\< <...> \> <Rc> <Rb> Class <...2>:[<...>]
                                   :<Rc> <Rb> class <...2>
                                   :{
#\< <...> \> <Rc> <Rb> Enum <...2>:[<...>]
                                  :<Rc> <Rb> enum <...2>
                                  :{
#Class <...>:class <...>
            :{
#Default ReadOnly Property <Ra> ( <Rb> ) As <Rd>:<Rd> this[<Rb>]
                                                :{
#Default ReadOnly Property <Ra> ( ) As <Rd>:<Rd> this[]
                                           :{
#Property <Ra> ( ) As <Rc>:<Rc> <Ra>
                          :{
#ReadOnly Property <Ra> <Rb> As <Rc>:<Rc> <Ra>
                                    :{
#WriteOnly Property <Ra> <Rb> As <Rc>:<Rc> <Ra>
                                     :{
#ReadOnly Property <Ra> ( ) As <Rb>:<Rb> <Ra>
                                   :{
#WriteOnly Property <Ra> ( ) As <Rb>:<Rb> <Ra>
                                    :{
#Default ReadOnly Property <Ra> <Rb> As <Rc>:<Rc> this[<Rb>]
                                            :{
#Property <Ra> As <Rb>:<Rb> <Ra>
                      :{
#ReadOnly Property <Ra> As <Rb>:<Rb> <Ra>
                               :{
#WriteOnly Property <Ra> As <Rb>:<Rb> <Ra>
                                :{
#Property <Ra> As <Rb> = <imm>:<Rb> <Ra> { Get; set; }
                              :<class>()
                              :{
                              :<Ra> = <imm> ;
                              :}
#ReadOnly Property <Ra> As <Rb> = <imm>:<Rb> <Ra> { Get; private set; }
                                       :<class>()
                                       :{
                                       :<Ra> = <imm> ;
                                       :}
#WriteOnly Property <Ra> As <Rb> = <imm>:<Rb> <Ra> { private get; set; }
                                        :<class>()
                                        :{
                                        :<Ra> = <imm> ;
                                        :}
#<user1> Class <...>:<user1> class <...>
                    :{
#<Rc> Default ReadOnly Property <Ra> ( <Rb> ) As <Rd>:<Rc> <Rd> this[<Rb>]
                                                     :{
#<Rc> Default ReadOnly Property <Ra> ( ) As <Rd>:<Rc> <Rd> this[]
                                                :{
#<Rb> Property <Ra> ( ) As <Rc>:<Rb> <Rc> <Ra>
                               :{
#<Rd> ReadOnly Property <Ra> <Rb> As <Rc>:<Rd> <Rc> <Ra>
                                         :{
#<Rd> WriteOnly Property <Ra> <Rb> As <Rc>:<Rd> <Rc> <Ra>
                                          :{
#<Rc> ReadOnly Property <Ra> ( ) As <Rb>:<Rc> <Rb> <Ra>
                                        :{
#<Rc> WriteOnly Property <Ra> ( ) As <Rb>:<Rc> <Rb> <Ra>
                                         :{
#<Rd> Default ReadOnly Property <Ra> <Rb> As <Rc>:<Rd> <Rc> this[<Rb>]
                                                 :{
#<Rc> Property <Ra> As <Rb>:<Rc> <Rb> <Ra>
                           :{
#<Rc> ReadOnly Property <Ra> As <Rb>:<Rc> <Rb> <Ra>
                                    :{
#<Rc> WriteOnly Property <Ra> As <Rb>:<Rc> <Rb> <Ra>
                                     :{
#<Rc> Property <Ra> As <Rb> = <imm>:<Rc> <Rb> <Ra> { get; set; }
                                   :<Rc> <class>()
                                   :{
                                   :<Ra> = <imm> ;
                                   :}
#<Rc> ReadOnly Property <Ra> As <Rb> = <imm>:<Rc> <Rb> <Ra> { get; private set; }
                                            :<Rc> <class>()
                                            :{
                                            :<Ra> = <imm> ;
                                            :}
#<Rc> WriteOnly Property <Ra> As <Rb> = <imm>:<Rc> <Rb> <Ra> { private get; set; }
                                             :<Rc> <class>()
                                             :{
                                             :<Ra> = <imm> ;
                                             :}
#<user1> <Rc> Class <...>:<user1> <Rc> class <...>
                         :{
#<Re> <Rc> Default ReadOnly Property <Ra> ( <Rb> ) As <Rd>:<Re> <Rc> <Rd> this[<Rb>]
                                                          :{
#<Re> <Rc> Default ReadOnly Property <Ra> ( ) As <Rd>:<Re> <Rc> <Rd> this[]
                                                     :{
#<Rd> <Rb> Property <Ra> ( ) As <Rc>:<Rd> <Rb> <Rc> <Ra>
                                    :{
#<Re> <Rd> ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rc> <Ra>
                                              :{
#<Re> <Rd> WriteOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rc> <Ra>
                                               :{
#<Rd> <Rc> ReadOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Rb> <Ra>
                                             :{
#<Rd> <Rc> WriteOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Rb> <Ra>
                                              :{
#<Re> <Rd> Default ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rc> this[<Rb>]
                                                      :{
#<Rd> <Rc> Property <Ra> As <Rb>:<Rd> <Rc> <Rb> <Ra>
                                :{
#<Rd> <Rc> ReadOnly Property <Ra> As <Rb>:<Rd> <Rc> <Rb> <Ra>
                                         :{
#<Rd> <Rc> WriteOnly Property <Ra> As <Rb>:<Rd> <Rc> <Rb> <Ra>
                                          :{
#<Rd> <Rc> Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Rb> <Ra> { get; set; }
                                        :<Rd> <Rc> <class>()
                                        :{
                                        :<Ra> = <imm> ;
                                        :}
#<Rd> <Rc> ReadOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Rb> <Ra> { get; private set; }
                                                 :<Rd> <Rc> <class>()
                                                 :{
                                                 :<Ra> = <imm> ;
                                                 :}
#<Rd> <Rc> WriteOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Rb> <Ra> { private get; set; }
                                                  :<Rd> <Rc> <class>()
                                                  :{
                                                  :<Ra> = <imm> ;
                                                  :}
#<user1> <Rc> <Rf> Class <...>:<user1> <Rc> <Rf> class <...>
                              :{
#<Re> <Rc> <Rf> Default ReadOnly Property <Ra> ( <Rb> ) As <Rd>:<Re> <Rc> <Rf> <Rd> this[<Rb>]
                                                               :{
#<Re> <Rc> <Rf> Default ReadOnly Property <Ra> ( ) As <Rd>:<Re> <Rc> <Rf> <Rd> this[]
                                                          :{
#<Rd> <Rb> <Re> Property <Ra> ( ) As <Rc>:<Rd> <Rb> <Re> <Rc> <Ra>
                                         :{
#<Re> <Rd> <Rf> ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rf> <Rc> <Ra>
                                                   :{
#<Re> <Rd> <Rf> WriteOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rf> <Rc> <Ra>
                                                    :{
#<Rd> <Rc> <Re> ReadOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Re> <Rb> <Ra>
                                                  :{
#<Rd> <Rc> <Re> WriteOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Re> <Rb> <Ra>
                                                   :{
#<Re> <Rd> <Rf> Default ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rf> <Rc> this[<Rb>]
                                                           :{
#<Rd> <Rc> <Re> Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rb> <Ra>
                                     :{
#<Rd> <Rc> <Re> ReadOnly Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rb> <Ra>
                                              :{
#<Rd> <Rc> <Re> WriteOnly Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rb> <Ra>
                                               :{
#<Rd> <Rc> <Re> Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rb> <Ra> { get; set; }
                                             :<Rd> <Rc> <Re> <class>()
                                             :{
                                             :<Ra> = <imm> ;
                                             :}
#<Rd> <Rc> <Re> ReadOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rb> <Ra> { get; private set; }
                                                      :<Rd> <Rc> <Re> <class>()
                                                      :{
                                                      :<Ra> = <imm> ;
                                                      :}
#<Rd> <Rc> <Re> WriteOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rb> <Ra> { private get; set; }
                                                       :<Rd> <Rc> <Re> <class>()
                                                       :{
                                                       :<Ra> = <imm> ;
                                                       :}
#<user1> <Rc> <Rf> <Rg> Class <...>:<user1> <Rc> <Rf> <Rg> class <...>
                                   :{
#<Re> <Rc> <Rf> <Rg> Default ReadOnly Property <Ra> ( <Rb> ) As <Rd>:<Re> <Rc> <Rf> <Rg> <Rd> this[<Rb>]
                                                                    :{
#<Re> <Rc> <Rf> <Rg> Default ReadOnly Property <Ra> ( ) As <Rd>:<Re> <Rc> <Rf> <Rg> <Rd> this[]
                                                               :{
#<Rd> <Rb> <Re> <Rf> Property <Ra> ( ) As <Rc>:<Rd> <Rb> <Re> <Rf> <Rc> <Ra>
                                              :{
#<Re> <Rd> <Rf> <Rg> ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rf> <Rg> <Rc> <Ra>
                                                        :{
#<Re> <Rd> <Rf> <Rg> WriteOnly Property <Ra> <Rb> As <Rc>:<Re> <Rd> <Rf> <Rg> <Rc> <Ra>
                                                         :{
#<Rd> <Rc> <Re> <Rf> ReadOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra>
                                                       :{
#<Rd> <Rc> <Re> <Rf> WriteOnly Property <Ra> ( ) As <Rb>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra>
                                                        :{
#<Re> <Rd> <Rf> <Rg> Default ReadOnly Property <Ra> <Rb> As <Rc>:<Re> <Rg> <Rd> <Rf> <Rc> this[<Rb>]
                                                                :{
#<Rd> <Rc> <Re> <Rf> Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra>
                                          :{
#<Rd> <Rc> <Re> <Rf> ReadOnly Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra>
                                                   :{
#<Rd> <Rc> <Re> <Rf> WriteOnly Property <Ra> As <Rb>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra>
                                                    :{
#<Rd> <Rc> <Re> <Rf> Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra> { get; set; }
                                                  :<Rd> <Rc> <Re> <Rf> <class>()
                                                  :{
                                                  :<Ra> = <imm> ;
                                                  :}
#<Rd> <Rc> <Re> <Rf> ReadOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra> { get; private set; }
                                                           :<Rd> <Rc> <Re> <Rf> <class>()
                                                           :{
                                                           :<Ra> = <imm> ;
                                                           :}
#<Rd> <Rc> <Re> <Rf> WriteOnly Property <Ra> As <Rb> = <imm>:<Rd> <Rc> <Re> <Rf> <Rb> <Ra> { private get; set; }
                                                            :<Rd> <Rc> <Re> <Rf> <class>()
                                                            :{
                                                            :<Ra> = <imm> ;
                                                            :}
#Dim <Ra> = New <Rb> With {. <...>:var <Ra> = new <Rb>() { <...> ;
#Namespace <...>:namespace <...>
                :{
#Imports <...>:using <...> ;
#<Ra> As <Rb>:<Rb> <Ra>
#Dim <Ra> = New <...>:var <Ra> = new <...>() ;
#Dim <Rb> As List ( <Ra> ) = New List ( <Ra> ) From <...>:List<<Ra>\> <Rb> = new List<<Ra>\> <...>;
#Dim <Ra> = New Dictionary ( <...> ) From <...2>:var <Ra> = new Dictionary<<...>\> <...2>;
#Dim <Ra> As <Rb>:<Rb> <Ra> ;
#Dim <Ra> As <Rb> = New <...>:<Rb> <Ra> = new <...> ;
#Dim <Ra> As New <Rb>:<Rb> <Ra> = new <Rb>() ;
#<Ra> = New <...>:<Ra> = new <...> ;
#Optional ByVal <Ra> As <Rb>:[Optional] <Rb> <Ra>
#Optional ByRef <Ra> As <Rb>:[Optional] ref <Rb> <Ra>
#Optional out ByRef <Ra> As <Rb>:[Optional] out ref <Rb> <Ra>
#Optional out <Ra> As <Rb>:[Optional] out <Rb> <Ra>
#Optional <Ra> As <Rb>:[Optional] <Rb> <Ra>
#params <Ra> As <Rb>:params <Rb> <Ra>
#ByVal <Ra> As <Rb>:<Rb> <Ra>
#ByRef <Ra> As <Rb>:ref <Rb> <Ra>
#out ByRef <Ra> As <Rb>:out ref <Rb> <Ra>
#out <Ra> As <Rb>:out <Rb> <Ra>
#Delegate Function <Ra> ( <Rb> ) As <Rc>:delegate <Rc> <Ra>(<Rb>) ;
#Delegate Sub <Ra> ( <...> ):delegate void <Ra>(<...>) ;
#Delegate Function <Ra> ( ) As <Rc>:delegate <Rc> <Ra>() ;
#Delegate Sub <Ra> ( ):delegate void <Ra>() ;
#Sub <Rb> ( ):void <Rb>()
             :{
#<Ra> Sub <Rb> ( ):<Ra> void <Rb>()
                  :{
#<Ra> <Rc> Sub <Rb> ( ):<Ra> <Rc> void <Rb>()
                       :{
#<Rc> <Ra> <Rd> Sub <Rb> ( ):<Rc> <Ra> <Rd> void <Rb>()
                            :{
#Sub <Rb> ( <...> ):void <Rb>(<...>)
                   :{
#<Ra> Sub <Rb> ( <...> ):<Ra> void <Rb>(<...>)
                        :{
#<Ra> <Rc> Sub <Rb> ( <...> ):<Ra> <Rc> void <Rb>(<...>)
                             :{
#<Rc> <Ra> <Rd> Sub <Rb> ( <...> ):<Rc> <Ra> <Rd> void <Rb>(<...>)
                                  :{
#Sub <Rb> ( ):void <Rb>()
             :{
#<Ra> Sub <Rb> ( ):<Ra> void <Rb>()
                  :{
#<Ra> <Rc> Sub <Rb> ( ):<Ra> <Rc> void <Rb>()
                       :{
#<Rc> <Ra> <Rd> Sub <Rb> ( ):<Rc> <Ra> <Rd> void <Rb>()
                            :{
#Function <Rb> ( <...> ) As <Rc>:<Rc> <Rb>(<...>)
                                :{
#<Ra> Function <Rb> ( <...> ) As <Rc>:<Ra> <Rc> <Rb>(<...>)
                                     :{
#<Ra> <Rd> Function <Rb> ( <...> ) As <Rc>:<Ra> <Rd> <Rc> <Rb>(<...>)
                                          :{
#<Ra> <Rd> <Re> Function <Rb> ( <...> ) As <Rc>:<Ra> <Rd> <Re> <Rc> <Rb>(<...>)
                                               :{
#Function <Rb> ( ) As <Rc>:<Rc> <Rb>()
                          :{
#<Ra> Function <Rb> ( ) As <Rc>:<Ra> <Rc> <Rb>()
                               :{
#<Ra> <Rd> Function <Rb> ( ) As <Rc>:<Ra> <Rd> <Rc> <Rb>()
                                    :{
#<Ra> <Rd> <Re> Function <Rb> ( ) As <Rc>:<Ra> <Rd> <Re> <Rc> <Rb>()
                                         :{
#Return <...>:return <...> ;
#Return:return;
#End:System.Environment.Exit(1) ;
#Class <Ra> Inherits <...>:class <Ra> \: <...>
                          :{
#Class <Ra> Implements <...>:class <Ra> \: <...>
                            :{
#Class <...>:class <...>
            :{
#Enum <...>:enum <...>
           :{
#End For:}
#<keywordend> <keyword>:}
#Exit Function:return
#Exit <keyword>:break
#Continue <keyword>:continue
#Next:}
#Select Case <...>:switch(<...>)
       Case <...2>:{
                  :case <...2>\:
#Case <...>:break;
           :case <...>\:
#Case Else:break;
          :default \:
#Do:do
   :{
#Loop While <...>:} while(<...>) ;
#Do While <...>:while(<...>)
               :{
#While <...>:while(<...>)
            :{
#If <...>:if(<...>)
         :{
#ElseIf <...>:}
             :else if(<...>)
             :{
#Else:}
     :else
     :{
#Dim <Rd> As <Re> = IIf ( <Ra> , <Rb> , <Rc> ):<Re> <Rd> = (<Ra>) ? <Rb> \: <Rc>
#<Re> = IIf ( <Ra> , <Rb> , <Rc> ):<Re> = (<Ra>) ? <Rb> \: <Rc>
#IIf ( <Ra> , <Rb> , <Rc> ):(<Ra>) ? <Rb> \: <Rc>
#Dim <Rd> As <Re> = If ( <Ra> , <Rb> , <Rc> ):<Re> <Rd> = (<Ra>) ? <Rb> \: <Rc>
#<Re> = If ( <Ra> , <Rb> , <Rc> ):<Re> = (<Ra>) ? <Rb> \: <Rc>
#If ( <Ra> , <Rb> , <Rc> ):(<Ra>) ? <Rb> \: <Rc>
#Get:get
    :{
#Set:set
    :{
#Set ( <...> ):set
              :{
#Set ( ):set
        :{
#For Each <Ra> As <Rb> In <Rc>:foreach(<Rb> <Ra> in <Rc>)
                              :{
#For <Ra> = 0 To <imm>:for(<Ra>=0;<Ra><=<imm>;<Ra>++)
                      :{
#For <Ra> = 0 To <imm> Step <imm2>:for(<Ra>=0;<Ra><=<imm>;<Ra>=<Ra>+<imm2>)
                                  :{
#For <Ra> = 0 To <Rb>:for(<Ra>=0;<Ra><=<Rb>;<Ra>++)
                     :{
#For <Ra> = 0 To <Rb> Step <imm>:for(<Ra>=0;<Ra><=<Rb>;<Ra>=<Ra>+<imm>)
                                :{
#For <Ra> = <imm> To 0:for(<Ra>=<imm>;<Ra>>=0;<Ra>--)
                      :{
#For <Ra> = <imm> To 0 Step <imm2>:for(<Ra>=<imm>;<Ra>>=0;<Ra>=<Ra><imm2>)
                                  :{
#<Rc> <Rb> Structure <Ra>:<Rc> <Rb> struct <Ra>
                         :{
#<Rb> Structure <Ra>:<Rb> struct <Ra>
                    :{
#Try:try
    :{
#Catch <Ra> As <Rb>:}
                   :catch(<Rb> <Ra>)
                   :{
#Catch:}
      :catch
      :{
#Finally:}
        :finally
        :{
#Dim <Ra> As Type = <...>:System.Type <Ra> = <...>() ;
#NotOverridable Overrides Sub <Ra> ( <...> ):override sealed void <Ra>(<...>)
                                            :{
#NotOverridable Overrides Sub <Ra> ( ):override sealed void <Ra>()
                                      :{
#NotInheritable Class <Ra> Inherits <Rb>:sealed class <Ra> \: <Rb>
                                        :{
#Interface <Ra> Inherits <...>:interface <Ra> \: <...>
                              :{
#Interface <Ra>:interface <Ra>
               :{
#<Ra> NotOverridable Overrides Sub <Rb> ( <...> ):<Ra> override sealed void <Rb>(<...>)
                                                 :{
#<Ra> NotOverridable Overrides Sub <Rb> ( ):<Ra> override sealed void <Rb>()
                                           :{
#<Rc> NotInheritable Class <Ra> Inherits <Rb>:<Rc> sealed class <Ra> \: <Rb>
                                             :{
#<Rb> Interface <Ra> Inherits <...>:<Rb> interface <Ra> \: <...>
                                   :{
#<Rb> Interface <Ra>:<Rb> interface <Ra>
                    :{
#<Rc> <Ra> NotOverridable Overrides Sub <Rb> ( <...> ):<Rc> <Ra> override sealed void <Rb>(<...>)
                                                      :{
#<Rc> <Ra> NotOverridable Overrides Sub <Rb> ( ):<Rc> <Ra> override sealed void <Rb>()
                                                :{
#<Rd> <Rc> NotInheritable Class <Ra> Inherits <Rb>:<Rd> <Rc> sealed class <Ra> \: <Rb>
                                                  :{
#<Rc> <Rb> Interface <Ra> Inherits <...>:<Rc> <Rb> interface <Ra> \: <...>
                                        :{
#<Rc> <Rb> Interface <Ra>:<Rc> <Rb> interface <Ra>
                         :{
#<Rc> <Ra> <Re> NotOverridable Overrides Sub <Rb> ( <...> ):<Rc> <Ra> <Re> override sealed void <Rb>(<...>)
                                                           :{
#<Rc> <Ra> <Re> NotOverridable Overrides Sub <Rb> ( ):<Rc> <Ra> <Re> override sealed void <Rb>()
                                                     :{
#<Rd> <Rc> <Re> NotInheritable Class <Ra> Inherits <Rb>:<Rd> <Rc> <Re> sealed class <Ra> \: <Rb>
                                                       :{
#<Rc> <Rb> <Re> Interface <Ra> Inherits <...>:<Rc> <Rb> <Re> interface <Ra> \: <...>
                                             :{
#<Rc> <Rb> <Re> Interface <Ra>:<Rc> <Rb> <Re> interface <Ra>
                              :{
#Dim <Ra> As <Rb> = <...>:<Rb> <Ra> = <...> ;
#Dim <Ra> As <Rb> = AddressOf <...>:<Rb> <Ra> = new <Rb>(<...>) ;
#Event <Ra> As <Rb>:event <Rb> <Ra> ;
#<Rc> Event <Ra> As <Rb>:<Rc> event <Rb> <Ra> ;
#<Rd> <Rc> Event <Ra> As <Rb>:<Rd> <Rc> event <Rb> <Ra> ;
#Sub New ( )  :<class>() \: base(<Ra>)
 base ( <Ra> ):{
#<user1> Sub New ( ):<user1> <class>() \: base(<Ra>)
 base ( <Ra> )      :{
#Sub New ( <...> ):<class>(<...>) \: base(<Ra>)
 base ( <Ra> )    :{
#<user1> Sub New ( <...> ):<user1> <class>(<...>) \: base(<Ra>)
 base ( <Ra> )            :{
#<Ra> Sub New ( ):<Ra> <class>() \: base(<Rb>)
 base ( <Rb> )   :{
#<user1> <Rb> Sub New ( ):<user1> <Rb> <class>() \: base(<Ra>)
 base ( <Ra> )           :{                                        
#<Ra> Sub New ( <...> ):<Ra> <class>(<...>) \: base(<Rb>)
 base ( <Rb> )         :{
#<user1> <Rb> Sub New ( <...> ):<user1> <Rb> <class>(<...>) \: base(<Ra>)
 base ( <Ra> )                 :{
#Sub New ( )  :<class>() \: this(<Ra>)
 this ( <Ra> ):{
#<user1> Sub New ( ):<user1> <class>() \: this(<Ra>)
 this ( <Ra> )      :{
#Sub New ( <...> ):<class>(<...>) \: this(<Ra>)
 this ( <Ra> )    :{
#<user1> Sub New ( <...> ):<user1> <class>(<...>) \: this(<Ra>)
 this ( <Ra> )            :{
#<Ra> Sub New ( ):<Ra> <class>() \: this(<Rb>)
 this ( <Rb> )   :{
#<user1> <Rb> Sub New ( ):<user1> <Rb> <class>() \: this(<Ra>)
 this ( <Ra> )           :{                                        
#<Ra> Sub New ( <...> ):<Ra> <class>(<...>) \: this(<Rb>)
 this ( <Rb> )         :{
#<user1> <Rb> Sub New ( <...> ):<user1> <Rb> <class>(<...>) \: this(<Ra>)
 this ( <Ra> )                 :{
#Sub New ( ):<class>()
            :{
#<Ra> Sub New ( ):<Ra> <class>()
                 :{
#<Ra> <Rb> Sub New ( ):<Ra> <Rb> <class>()
                      :{
#<Ra> <Rb> <Rc> Sub New ( ):<Ra> <Rb> <Rc> <class>()
                           :{
#Sub New ( <...> ):<class>(<...>)
                  :{
#<Ra> Sub New ( <...> ):<Ra> <class>(<...>)
                       :{
#<Ra> <Rb> Sub New ( <...> ):<Ra> <Rb> <class>(<...>)
                            :{
#<Ra> <Rb> <Rc> Sub New ( <...> ):<Ra> <Rb> <Rc> <class>(<...>)
                                 :{
#Sub Finalize ( ):~<class>()
                 :{
#<Ra> Sub Finalize ( ):~<class>()
                      :{
#<Ra> <Rb> Sub Finalize ( ):~<class>()
                           :{
#<Ra> <Rb> <Rc> Sub Finalize ( ):~<class>()
                                :{
#Sub Finalize ( <...> ):~<class>(<...>)
                       :{
#<Ra> Sub Finalize ( <...> ):~<class>(<...>)
                            :{
#<Ra> <Rb> Sub Finalize ( <...> ):~<class>(<...>)
                                 :{
#<Ra> <Rb> <Rc> Sub Finalize ( <...> ):~<class>(<...>)
                                      :{
#SyncLock <Ra>:lock(<Ra>)
              :{
#Dim <Ra>:var <Ra> ;
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=AddHandler,Class,Enum,Event,Function,Get,If,Interface,Module,Namespace,Operator,Property,RaiseEvent,RemoveHandler,Select,Set,Structure,Sub,SyncLock,Try,While,With,For,Foreach,Do
#keywordend=End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End,End
#user=sbyte,byte,short,ushort,int,uint,long,ulong,float,double,char,bool,decimal,string,object
#user1=public,private,internal,protected,protected internal
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=cs
.VB 6.0 to VB.NET
#Dim <Ra> As String * <imm>: Dim <Ra> As New VB6.FixedLengthString(<imm>)
#Debug.Print <...>: Trace.WriteLine(<...>)
#Call <...>: <...>
#Set <...>: <...>
#Open <...>: FileOpen(<...>)
#Get <...>: FileGet(<...>)
#Put <...>: FilePut(<...>)
#Close <...>: FileClose(<...>)
#MsgBox <...>: MessageBox.Show(<...>)
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=vb
.COBOL
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=cbl
.Java
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=java
.PHP
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=php
.Perl
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=pl
.Android
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=java
.Swift
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=swift
.Python
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=py
.Ruby
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=rb
.VBA
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=
#file=bas
.N88BASIC
#break: GOTO <address>
#continue: GOTO <address>
#goto <Ra>: GOTO <Ra>
#<Ra>: IF <Ra> THEN GOTO <trueaddress> ELSE GOTO <falseaddress>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=*
#labelend=
#file=bas
.MS-DOS
#break: goto         <address>
#continue: goto        <address>
#goto <Ra>: goto        <Ra>
#<Ra>: if <Ra> goto        <trueaddress>
     : goto        <falseaddress>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=:
#labelend=
#file=bat
.Fortran90
#break: GOTO <address>
#continue: GOTO <address>
#goto <Ra>: GOTO <Ra>
#<Ra>: IF(<Ra>) GOTO <trueaddress>
     :  GOTO <falseaddress>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#imm=0,1,2,3,4,5,6,7,8,9,+,-,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=f90
.i386
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :jae        <trueaddress>
               :jmp        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :jbe        <trueaddress>
               :jmp        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :ja        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :jb        <trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :jne        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :jge        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :jle        <trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :je        <trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :jg        <trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :jl        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :jae        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :jbe        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :ja        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :jb        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :jne        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :jge        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :jle        <trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :je        <trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :jg        <trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :jl        <trueaddress>
            :jmp        <falseaddress>
#>=+:jae        <trueaddress>
    :jmp        <falseaddress>
#<=+:jbe        <trueaddress>
    :jmp        <falseaddress>
#>+:ja        <trueaddress>
   :jmp        <falseaddress>
#<+:jb        <trueaddress>
   :jmp        <falseaddress>
#!=:jne        <trueaddress>
   :jmp        <falseaddress>
#>=:jge        <trueaddress>
   :jmp        <falseaddress>
#<=:jle        <trueaddress>
   :jmp        <falseaddress>
#==:je        <trueaddress>
   :jmp        <falseaddress>
#>:jg        <trueaddress>
  :jmp        <falseaddress>
#<:jl        <trueaddress>
  :jmp        <falseaddress>
#zero:je        <trueaddress>
     :jmp        <falseaddress>
#nonzero:jne        <trueaddress>
        :jmp        <falseaddress>
#carry:jc        <trueaddress>
      :jmp        <falseaddress>
#noncarry:jnc        <trueaddress>
         :jmp        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp        <falseaddress>
#sign:js        <trueaddress>
     :jmp        <falseaddress>
#nonsign:jns        <trueaddress>
        :jmp        <falseaddress>
#parity:jp        <trueaddress>
       :jmp        <falseaddress>
#nonparity:jnp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Rb>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Rb> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <imm> <Ra> /+ <imm2>:push        ax
                            :push        bx
                            :push        dx
                            :mov        ax,<Ra>
                            :mov        dx,<imm>
                            :mov        bx,<imm2>
                            :div        bx
                            :mov        <Ra>,ax
                            :pop        dx
                            :pop        bx
                            :pop        ax
#<Ra> = <imm> <Ra> / <imm2>:push        ax
                           :push        bx
                           :push        dx
                           :mov        ax,<Ra>
                           :mov        dx,<imm>
                           :mov        bx,<imm2>
                           :idiv        bx
                           :mov        <Ra>,ax
                           :pop        dx
                           :pop        bx
                           :pop        ax
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:push        cx
                      :mov        cl,<imm>
                      :sar        <Ra>,cl
                      :pop        cx
#<Ra> = <Ra> >> <imm>:push        cx
                     :mov        cl,<imm>
                     :shr        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> << <imm>:push        cx
                     :mov        cl,<imm>
                     :shl        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Ra>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Ra> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#putc ( <imm> ):push        ax
              :push        dx
              :mov        dl,<imm>
              :mov        ah,2
              :int        21h
              :pop        dx
              :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<imm> ):push        ax
                                :push        bx
                                :push        cx
                                :push        dx
                                :mov        bx,<Ra>
                                :mov        ah,3fh
                                :mov        dx,<Rb>
                                :mov        cx,<imm>
                                :int        21h
                                :mov        <Rd>,ax
                                :pop        dx
                                :pop        cx
                                :pop        bx
                                :pop        ax
#<Re> <Rf> = fseek ( <imm>,<Rb>,<Rc>,<imm> ):push        ax
                                           :push        bx
                                           :push        cx
                                           :push        dx
                                           :mov        al,<imm>
                                           :mov        bx,<Rb>
                                           :mov        ah,42h
                                           :mov        dx,<Rc>
                                           :mov        cx,<imm>
                                           :int        21h
                                           :mov        <Re>,dx
                                           :mov        <Rf>,ax
                                           :pop        dx
                                           :pop        cx
                                           :pop        bx
                                           :pop        ax
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> *+ <Rc>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<Rc>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Rb> * <Rc>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Rb>
                   :mov        bx,<Rc>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#<Ra> = <Rb> <Ra> /+ <Rd>:push        ax
                         :push        bx
                         :push        dx
                         :mov        ax,<Ra>
                         :mov        dx,<Rb>
                         :mov        bx,<Rd>
                         :div        bx
                         :mov        <Ra>,ax
                         :pop        dx
                         :pop        bx
                         :pop        ax
#<Ra> = <Rb> <Ra> / <Rd>:push        ax
                        :push        bx
                        :push        dx
                        :mov        ax,<Ra>
                        :mov        dx,<Rb>
                        :mov        bx,<Rd>
                        :idiv        bx
                        :mov        <Ra>,ax
                        :pop        dx
                        :pop        bx
                        :pop        ax
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:push        cx
                     :mov        cl,<Rb>
                     :sar        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> >> <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shr        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> << <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shl        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> *+ <Rb>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<Rb>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Ra> * <Rb>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Ra>
                   :mov        bx,<Rb>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#putc ( <Ra> ):push        ax
             :push        dx
             :mov        dl,<Ra>
             :mov        ah,2
             :int        21h
             :pop        dx
             :pop        ax
#puts ( <Ra> ):push        ax
             :push        dx
             :mov        dx,<Ra>
             :mov        ah,9
             :int        21h
             :pop        dx
             :pop        ax
#gets ( <Ra> ):push        ax
             :push        dx
             :mov        ah,0ah
             :mov        dx,<Ra>
             :int        21h
             :pop        dx
             :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<Rc> ):push        ax
                               :push        bx
                               :push        cx
                               :push        dx
                               :mov        bx,<Ra>
                               :mov        ah,3fh
                               :mov        dx,<Rb>
                               :mov        cx,<Rc>
                               :int        21h
                               :mov        <Rd>,ax
                               :pop        dx
                               :pop        cx
                               :pop        bx
                               :pop        ax
#<Re> <Rf> = fseek ( <Ra>,<Rb>,<Rc>,<Rd> ):push        ax
                                         :push        bx
                                         :push        cx
                                         :push        dx
                                         :mov        al,<Ra>
                                         :mov        bx,<Rb>
                                         :mov        ah,42h
                                         :mov        dx,<Rc>
                                         :mov        cx,<Rd>
                                         :int        21h
                                         :mov        <Re>,dx
                                         :mov        <Rf>,ax
                                         :pop        dx
                                         :pop        cx
                                         :pop        bx
                                         :pop        ax
#exit ( ):mov        ah,4ch
       :int        21h
#char <Ra> = <...>:<Ra>        db        <...>
#int <Ra> = <...>:<Ra>        dw        <...>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#o=oword ptr ,oword ,[,@
#q=rax,rbx,rcx,rdx,rsi,rdi,rbp,rsp,r8,r9,r10,r11,r12,r13,r14,r15,offset ,qword ptr ,qword 
#l=eax,ebx,ecx,edx,esi,edi,ebp,esp,r8d,r9d,r10d,r11d,r12d,r13d,r14d,r15d,dword ptr ,dword 
#w=ax,bx,cx,dx,si,di,bp,sp,r8w,r9w,r10w,r11w,r12w,r13w,r14w,r15w,word ptr ,word 
#b=ah,bh,ch,dh,al,bl,cl,dl,sil,dil,bpl,spl,r8b,r9b,r10b,r11b,r12b,r13b,r14b,r15b,byte ptr ,byte 
#imm=0,1,2,3,4,5,6,7,8,9,+,-
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.x86_64
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :jae        <trueaddress>
               :jmp        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :jbe        <trueaddress>
               :jmp        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :ja        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :jb        <trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :jne        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :jge        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :jle        <trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :je        <trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :jg        <trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :jl        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :jae        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :jbe        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :ja        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :jb        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :jne        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :jge        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :jle        <trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :je        <trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :jg        <trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :jl        <trueaddress>
            :jmp        <falseaddress>
#>=+:jae        <trueaddress>
    :jmp        <falseaddress>
#<=+:jbe        <trueaddress>
    :jmp        <falseaddress>
#>+:ja        <trueaddress>
   :jmp        <falseaddress>
#<+:jb        <trueaddress>
   :jmp        <falseaddress>
#!=:jne        <trueaddress>
   :jmp        <falseaddress>
#>=:jge        <trueaddress>
   :jmp        <falseaddress>
#<=:jle        <trueaddress>
   :jmp        <falseaddress>
#==:je        <trueaddress>
   :jmp        <falseaddress>
#>:jg        <trueaddress>
  :jmp        <falseaddress>
#<:jl        <trueaddress>
  :jmp        <falseaddress>
#zero:je        <trueaddress>
     :jmp        <falseaddress>
#nonzero:jne        <trueaddress>
        :jmp        <falseaddress>
#carry:jc        <trueaddress>
      :jmp        <falseaddress>
#noncarry:jnc        <trueaddress>
         :jmp        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp        <falseaddress>
#sign:js        <trueaddress>
     :jmp        <falseaddress>
#nonsign:jns        <trueaddress>
        :jmp        <falseaddress>
#parity:jp        <trueaddress>
       :jmp        <falseaddress>
#nonparity:jnp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Rb>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Rb> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <imm> <Ra> /+ <imm2>:push        ax
                            :push        bx
                            :push        dx
                            :mov        ax,<Ra>
                            :mov        dx,<imm>
                            :mov        bx,<imm2>
                            :div        bx
                            :mov        <Ra>,ax
                            :pop        dx
                            :pop        bx
                            :pop        ax
#<Ra> = <imm> <Ra> / <imm2>:push        ax
                           :push        bx
                           :push        dx
                           :mov        ax,<Ra>
                           :mov        dx,<imm>
                           :mov        bx,<imm2>
                           :idiv        bx
                           :mov        <Ra>,ax
                           :pop        dx
                           :pop        bx
                           :pop        ax
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:push        cx
                      :mov        cl,<imm>
                      :sar        <Ra>,cl
                      :pop        cx
#<Ra> = <Ra> >> <imm>:push        cx
                     :mov        cl,<imm>
                     :shr        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> << <imm>:push        cx
                     :mov        cl,<imm>
                     :shl        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Ra>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Ra> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#putc ( <imm> ):push        ax
              :push        dx
              :mov        dl,<imm>
              :mov        ah,2
              :int        21h
              :pop        dx
              :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<imm> ):push        ax
                                :push        bx
                                :push        cx
                                :push        dx
                                :mov        bx,<Ra>
                                :mov        ah,3fh
                                :mov        dx,<Rb>
                                :mov        cx,<imm>
                                :int        21h
                                :mov        <Rd>,ax
                                :pop        dx
                                :pop        cx
                                :pop        bx
                                :pop        ax
#<Re> <Rf> = fseek ( <imm>,<Rb>,<Rc>,<imm> ):push        ax
                                           :push        bx
                                           :push        cx
                                           :push        dx
                                           :mov        al,<imm>
                                           :mov        bx,<Rb>
                                           :mov        ah,42h
                                           :mov        dx,<Rc>
                                           :mov        cx,<imm>
                                           :int        21h
                                           :mov        <Re>,dx
                                           :mov        <Rf>,ax
                                           :pop        dx
                                           :pop        cx
                                           :pop        bx
                                           :pop        ax
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> *+ <Rc>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<Rc>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Rb> * <Rc>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Rb>
                   :mov        bx,<Rc>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#<Ra> = <Rb> <Ra> /+ <Rd>:push        ax
                         :push        bx
                         :push        dx
                         :mov        ax,<Ra>
                         :mov        dx,<Rb>
                         :mov        bx,<Rd>
                         :div        bx
                         :mov        <Ra>,ax
                         :pop        dx
                         :pop        bx
                         :pop        ax
#<Ra> = <Rb> <Ra> / <Rd>:push        ax
                        :push        bx
                        :push        dx
                        :mov        ax,<Ra>
                        :mov        dx,<Rb>
                        :mov        bx,<Rd>
                        :idiv        bx
                        :mov        <Ra>,ax
                        :pop        dx
                        :pop        bx
                        :pop        ax
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:push        cx
                     :mov        cl,<Rb>
                     :sar        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> >> <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shr        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> << <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shl        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> *+ <Rb>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<Rb>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Ra> * <Rb>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Ra>
                   :mov        bx,<Rb>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#putc ( <Ra> ):push        ax
             :push        dx
             :mov        dl,<Ra>
             :mov        ah,2
             :int        21h
             :pop        dx
             :pop        ax
#puts ( <Ra> ):push        ax
             :push        dx
             :mov        dx,<Ra>
             :mov        ah,9
             :int        21h
             :pop        dx
             :pop        ax
#gets ( <Ra> ):push        ax
             :push        dx
             :mov        ah,0ah
             :mov        dx,<Ra>
             :int        21h
             :pop        dx
             :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<Rc> ):push        ax
                               :push        bx
                               :push        cx
                               :push        dx
                               :mov        bx,<Ra>
                               :mov        ah,3fh
                               :mov        dx,<Rb>
                               :mov        cx,<Rc>
                               :int        21h
                               :mov        <Rd>,ax
                               :pop        dx
                               :pop        cx
                               :pop        bx
                               :pop        ax
#<Re> <Rf> = fseek ( <Ra>,<Rb>,<Rc>,<Rd> ):push        ax
                                         :push        bx
                                         :push        cx
                                         :push        dx
                                         :mov        al,<Ra>
                                         :mov        bx,<Rb>
                                         :mov        ah,42h
                                         :mov        dx,<Rc>
                                         :mov        cx,<Rd>
                                         :int        21h
                                         :mov        <Re>,dx
                                         :mov        <Rf>,ax
                                         :pop        dx
                                         :pop        cx
                                         :pop        bx
                                         :pop        ax
#exit ( ):mov        ah,4ch
       :int        21h
#char <Ra> = <...>:<Ra>        db        <...>
#int <Ra> = <...>:<Ra>        dw        <...>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#o=oword ptr ,oword ,[,@
#q=rax,rbx,rcx,rdx,rsi,rdi,rbp,rsp,r8,r9,r10,r11,r12,r13,r14,r15,offset ,qword ptr ,qword 
#l=eax,ebx,ecx,edx,esi,edi,ebp,esp,r8d,r9d,r10d,r11d,r12d,r13d,r14d,r15d,dword ptr ,dword 
#w=ax,bx,cx,dx,si,di,bp,sp,r8w,r9w,r10w,r11w,r12w,r13w,r14w,r15w,word ptr ,word 
#b=ah,bh,ch,dh,al,bl,cl,dl,sil,dil,bpl,spl,r8b,r9b,r10b,r11b,r12b,r13b,r14b,r15b,byte ptr ,byte 
#imm=0,1,2,3,4,5,6,7,8,9,+,-
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.Itanium
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :jae        <trueaddress>
               :jmp        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :jbe        <trueaddress>
               :jmp        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :ja        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :jb        <trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :jne        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :jge        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :jle        <trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :je        <trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :jg        <trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :jl        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :jae        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :jbe        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :ja        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :jb        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :jne        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :jge        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :jle        <trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :je        <trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :jg        <trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :jl        <trueaddress>
            :jmp        <falseaddress>
#>=+:jae        <trueaddress>
    :jmp        <falseaddress>
#<=+:jbe        <trueaddress>
    :jmp        <falseaddress>
#>+:ja        <trueaddress>
   :jmp        <falseaddress>
#<+:jb        <trueaddress>
   :jmp        <falseaddress>
#!=:jne        <trueaddress>
   :jmp        <falseaddress>
#>=:jge        <trueaddress>
   :jmp        <falseaddress>
#<=:jle        <trueaddress>
   :jmp        <falseaddress>
#==:je        <trueaddress>
   :jmp        <falseaddress>
#>:jg        <trueaddress>
  :jmp        <falseaddress>
#<:jl        <trueaddress>
  :jmp        <falseaddress>
#zero:je        <trueaddress>
     :jmp        <falseaddress>
#nonzero:jne        <trueaddress>
        :jmp        <falseaddress>
#carry:jc        <trueaddress>
      :jmp        <falseaddress>
#noncarry:jnc        <trueaddress>
         :jmp        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp        <falseaddress>
#sign:js        <trueaddress>
     :jmp        <falseaddress>
#nonsign:jns        <trueaddress>
        :jmp        <falseaddress>
#parity:jp        <trueaddress>
       :jmp        <falseaddress>
#nonparity:jnp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Rb>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Rb> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <imm> <Ra> /+ <imm2>:push        ax
                            :push        bx
                            :push        dx
                            :mov        ax,<Ra>
                            :mov        dx,<imm>
                            :mov        bx,<imm2>
                            :div        bx
                            :mov        <Ra>,ax
                            :pop        dx
                            :pop        bx
                            :pop        ax
#<Ra> = <imm> <Ra> / <imm2>:push        ax
                           :push        bx
                           :push        dx
                           :mov        ax,<Ra>
                           :mov        dx,<imm>
                           :mov        bx,<imm2>
                           :idiv        bx
                           :mov        <Ra>,ax
                           :pop        dx
                           :pop        bx
                           :pop        ax
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:push        cx
                      :mov        cl,<imm>
                      :sar        <Ra>,cl
                      :pop        cx
#<Ra> = <Ra> >> <imm>:push        cx
                     :mov        cl,<imm>
                     :shr        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> << <imm>:push        cx
                     :mov        cl,<imm>
                     :shl        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> *+ <imm>:push        ax
                     :push        bx
                     :push        dx
                     :mov        ax,<Ra>
                     :mov        bx,<imm>
                     :mul        bx
                     :mov        <Ra>,ax
                     :pop        dx
                     :pop        bx
                     :pop        ax
#<Ra> = <Ra> * <imm>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<imm>
                    :imul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#putc ( <imm> ):push        ax
              :push        dx
              :mov        dl,<imm>
              :mov        ah,2
              :int        21h
              :pop        dx
              :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<imm> ):push        ax
                                :push        bx
                                :push        cx
                                :push        dx
                                :mov        bx,<Ra>
                                :mov        ah,3fh
                                :mov        dx,<Rb>
                                :mov        cx,<imm>
                                :int        21h
                                :mov        <Rd>,ax
                                :pop        dx
                                :pop        cx
                                :pop        bx
                                :pop        ax
#<Re> <Rf> = fseek ( <imm>,<Rb>,<Rc>,<imm> ):push        ax
                                           :push        bx
                                           :push        cx
                                           :push        dx
                                           :mov        al,<imm>
                                           :mov        bx,<Rb>
                                           :mov        ah,42h
                                           :mov        dx,<Rc>
                                           :mov        cx,<imm>
                                           :int        21h
                                           :mov        <Re>,dx
                                           :mov        <Rf>,ax
                                           :pop        dx
                                           :pop        cx
                                           :pop        bx
                                           :pop        ax
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> *+ <Rc>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Rb>
                    :mov        bx,<Rc>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Rb> * <Rc>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Rb>
                   :mov        bx,<Rc>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#<Ra> = <Rb> <Ra> /+ <Rd>:push        ax
                         :push        bx
                         :push        dx
                         :mov        ax,<Ra>
                         :mov        dx,<Rb>
                         :mov        bx,<Rd>
                         :div        bx
                         :mov        <Ra>,ax
                         :pop        dx
                         :pop        bx
                         :pop        ax
#<Ra> = <Rb> <Ra> / <Rd>:push        ax
                        :push        bx
                        :push        dx
                        :mov        ax,<Ra>
                        :mov        dx,<Rb>
                        :mov        bx,<Rd>
                        :idiv        bx
                        :mov        <Ra>,ax
                        :pop        dx
                        :pop        bx
                        :pop        ax
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:push        cx
                     :mov        cl,<Rb>
                     :sar        <Ra>,cl
                     :pop        cx
#<Ra> = <Ra> >> <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shr        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> << <Rb>:push        cx
                    :mov        cl,<Rb>
                    :shl        <Ra>,cl
                    :pop        cx
#<Ra> = <Ra> *+ <Rb>:push        ax
                    :push        bx
                    :push        dx
                    :mov        ax,<Ra>
                    :mov        bx,<Rb>
                    :mul        bx
                    :mov        <Ra>,ax
                    :pop        dx
                    :pop        bx
                    :pop        ax
#<Ra> = <Ra> * <Rb>:push        ax
                   :push        bx
                   :push        dx
                   :mov        ax,<Ra>
                   :mov        bx,<Rb>
                   :imul        bx
                   :mov        <Ra>,ax
                   :pop        dx
                   :pop        bx
                   :pop        ax
#putc ( <Ra> ):push        ax
             :push        dx
             :mov        dl,<Ra>
             :mov        ah,2
             :int        21h
             :pop        dx
             :pop        ax
#puts ( <Ra> ):push        ax
             :push        dx
             :mov        dx,<Ra>
             :mov        ah,9
             :int        21h
             :pop        dx
             :pop        ax
#gets ( <Ra> ):push        ax
             :push        dx
             :mov        ah,0ah
             :mov        dx,<Ra>
             :int        21h
             :pop        dx
             :pop        ax
#<Rd> = fread ( <Ra>,<Rb>,<Rc> ):push        ax
                               :push        bx
                               :push        cx
                               :push        dx
                               :mov        bx,<Ra>
                               :mov        ah,3fh
                               :mov        dx,<Rb>
                               :mov        cx,<Rc>
                               :int        21h
                               :mov        <Rd>,ax
                               :pop        dx
                               :pop        cx
                               :pop        bx
                               :pop        ax
#<Re> <Rf> = fseek ( <Ra>,<Rb>,<Rc>,<Rd> ):push        ax
                                         :push        bx
                                         :push        cx
                                         :push        dx
                                         :mov        al,<Ra>
                                         :mov        bx,<Rb>
                                         :mov        ah,42h
                                         :mov        dx,<Rc>
                                         :mov        cx,<Rd>
                                         :int        21h
                                         :mov        <Re>,dx
                                         :mov        <Rf>,ax
                                         :pop        dx
                                         :pop        cx
                                         :pop        bx
                                         :pop        ax
#exit ( ):mov        ah,4ch
       :int        21h
#char <Ra> = <...>:<Ra>        db        <...>
#int <Ra> = <...>:<Ra>        dw        <...>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#o=oword ptr ,oword ,[,@
#q=rax,rbx,rcx,rdx,rsi,rdi,rbp,rsp,r8,r9,r10,r11,r12,r13,r14,r15,offset ,qword ptr ,qword 
#l=eax,ebx,ecx,edx,esi,edi,ebp,esp,r8d,r9d,r10d,r11d,r12d,r13d,r14d,r15d,dword ptr ,dword 
#w=ax,bx,cx,dx,si,di,bp,sp,r8w,r9w,r10w,r11w,r12w,r13w,r14w,r15w,word ptr ,word 
#b=ah,bh,ch,dh,al,bl,cl,dl,sil,dil,bpl,spl,r8b,r9b,r10b,r11b,r12b,r13b,r14b,r15b,byte ptr ,byte 
#imm=0,1,2,3,4,5,6,7,8,9,+,-
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.Z80
#break:jp                <address>
#continue:jp        <address>
#goto        <Ra>:jp        <Ra>
#a != <imm>:cp        <imm>
           :jp        nz,<trueaddress>
           :jp        <falseaddress>
#a == <imm>:cp        <imm>
           :jp        z,<trueaddress>
           :jp        <falseaddress>
#a zero <imm>:cp        <imm>
             :jp        z,<trueaddress>
             :jp        <falseaddress>
#a nonzero <imm>:cp        <imm>
                :jp        nz,<trueaddress>
                :jp        <falseaddress>
#a carry <imm>:cp        <imm>
              :jp        c,<trueaddress>
              :jp        <falseaddress>
#a noncarry <imm>:cp        <imm>
                 :jp        nc,<trueaddress>
                 :jp        <falseaddress>
#a parity <imm>:cp        <imm>
               :jp        pe,<trueaddress>
               :jp        <falseaddress>
#a nonparity <imm>:cp        <imm>
                  :jp        po,<trueaddress>
                  :jp        <falseaddress>
#a plus <imm>:cp        <imm>
             :jp        p,<trueaddress>
             :jp        <falseaddress>
#a minus <imm>:cp        <imm>
              :jp        m,<trueaddress>
              :jp        <falseaddress>
#a != <Rb>:cp        <Rb>
          :jp        nz,<trueaddress>
          :jp        <falseaddress>
#a == <Rb>:cp        <Rb>
          :jp        z,<trueaddress>
          :jp        <falseaddress>
#a zero <Rb>:cp        <Rb>
            :jp        z,<trueaddress>
            :jp        <falseaddress>
#a nonzero <Rb>:cp        <Rb>
               :jp        nz,<trueaddress>
               :jp        <falseaddress>
#a carry <Rb>:cp        <Rb>
             :jp        c,<trueaddress>
             :jp        <falseaddress>
#a noncarry <Rb>:cp        <Rb>
                :jp        nc,<trueaddress>
                :jp        <falseaddress>
#a parity <Rb>:cp        <Rb>
              :jp        pe,<trueaddress>
              :jp        <falseaddress>
#a nonparity <Rb>:cp        <Rb>
                 :jp        po,<trueaddress>
                 :jp        <falseaddress>
#a plus <Rb>:cp        <Rb>
            :jp        p,<trueaddress>
            :jp        <falseaddress>
#a minus <Rb>:cp        <Rb>
             :jp        m,<trueaddress>
             :jp        <falseaddress>
#!=:jp        nz,<trueaddress>
   :jp        <falseaddress>
#==:jp        z,<trueaddress>
   :jp        <falseaddress>
#zero:jp        z,<trueaddress>
     :jp        <falseaddress>
#nonzero:jp        nz,<trueaddress>
        :jp        <falseaddress>
#carry:jp        c,<trueaddress>
      :jp        <falseaddress>
#noncarry:jp        nc,<trueaddress>
         :jp        <falseaddress>
#parity:jp        pe,<trueaddress>
       :jp        <falseaddress>
#nonparity:jp        po,<trueaddress>
          :jp        <falseaddress>
#plus:jp        p,<trueaddress>
     :jp        <falseaddress>
#minus:jp        m,<trueaddress>
      :jp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:cpl        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:ld        <Ra>,<imm>
#a = a + <imm>:add        a,<imm>
#a = a - <imm>:sub        <imm>
#a = a & <imm>:and        <imm>
#a = a | <imm>:or        <imm>
#a = a ^ <imm>:xor        <imm>
#<Ra> = <Rb> + <imm>:ld        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:ld        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:ld        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:ld        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:ld        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Rb>:ld        <Ra>,<Rb>
#a = a + <Rb>:add        a,<Rb>
#a = a - <Rb>:sub        <Rb>
#a = a & <Rb>:and        <Rb>
#a = a | <Rb>:or        <Rb>
#a = a ^ <Rb>:xor        <Rb>
#<Ra> = <Rb> + <Rc>:ld        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:ld        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:ld        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:ld        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:ld        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=bc,de,hl,sp,[,@
#b=b,c,d,e,h,l,a
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.MIPS
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.ARM
#break:b        <address>
#continue:b        <address>
#goto        <Ra>:b        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :bcs        <trueaddress>
               :b        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :bls        <trueaddress>
               :b        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :bhi        <trueaddress>
              :b        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :bcc        <trueaddress>
              :b        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :bne        <trueaddress>
              :b        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :beq        <trueaddress>
              :b        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :bcs        <trueaddress>
              :b        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :bls        <trueaddress>
              :b        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :bhi        <trueaddress>
             :b        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :bcc        <trueaddress>
             :b        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :bne        <trueaddress>
             :b        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :bge        <trueaddress>
             :b        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :ble        <trueaddress>
             :b        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :beq        <trueaddress>
             :b        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :bgt        <trueaddress>
            :b        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :blt        <trueaddress>
            :b        <falseaddress>
#>=+:bcs        <trueaddress>
    :b        <falseaddress>
#<=+:bls        <trueaddress>
    :b        <falseaddress>
#>+:bhi        <trueaddress>
   :b        <falseaddress>
#<+:bcc        <trueaddress>
   :b        <falseaddress>
#!=:bne        <trueaddress>
   :b        <falseaddress>
#>=:bge        <trueaddress>
   :b        <falseaddress>
#<=:ble        <trueaddress>
   :b        <falseaddress>
#==:beq        <trueaddress>
   :b        <falseaddress>
#>:bgt        <trueaddress>
  :b        <falseaddress>
#<:blt        <trueaddress>
  :b        <falseaddress>
#zero:beq        <trueaddress>
     :b        <falseaddress>
#nonzero:bne        <trueaddress>
        :b        <falseaddress>
#overflow:bvs        <trueaddress>
         :b        <falseaddress>
#nonoverflow:bvc        <trueaddress>
            :b        <falseaddress>
#plus:bpl        <trueaddress>
     :b        <falseaddress>
#minus:bmi        <trueaddress>
      :b        <falseaddress>
#<Ra> ++:add        <Ra>,<Ra>,#1
#<Ra> --:sub        <Ra>,<Ra>,#1
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:orr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:eor        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:asr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:lsr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:lsl        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:add        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> - <imm>:sub        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:and        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:orr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:eor        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:asr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:lsr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:lsl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:orr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:eor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:asr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:lsr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:lsl        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:sub        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:orr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:eor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:asr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:lsr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:lsl        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,a1,a2,a3,a4,v1,v2,v3,v4,v5,v6,v7,v8,ip,sp,lr,pc,wr,sb,sl,fp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.PowerPC G5
#break:b        <address>
#continue:b        <address>
#goto        <Ra>:b        <Ra>
#<Ra> >=+ <imm>:cmplwi        <Ra>,<imm>
               :bge        <trueaddress>
               :b        <falseaddress>
#<Ra> <=+ <imm>:cmplwi        <Ra>,<imm>
               :ble        <trueaddress>
               :b        <falseaddress>
#<Ra> >+ <imm>:cmplwi        <Ra>,<imm>
              :bgt        <trueaddress>
              :b        <falseaddress>
#<Ra> <+ <imm>:cmplwi        <Ra>,<imm>
              :blt        <trueaddress>
              :b        <falseaddress>
#<Ra> != <imm>:cmpwi        <Ra>,<imm>
              :bne        <trueaddress>
              :b        <falseaddress>
#<Ra> >= <imm>:cmpwi        <Ra>,<imm>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <= <imm>:cmpwi        <Ra>,<imm>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> == <imm>:cmpwi        <Ra>,<imm>
              :beq        <trueaddress>
              :b        <falseaddress>
#<Ra> > <imm>:cmpwi        <Ra>,<imm>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> < <imm>:cmpwi        <Ra>,<imm>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> >=+ <Rb>:cmplw        <Ra>,<Rb>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <=+ <Rb>:cmplw        <Ra>,<Rb>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> >+ <Rb>:cmplw        <Ra>,<Rb>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> <+ <Rb>:cmplw        <Ra>,<Rb>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> != <Rb>:cmpw        <Ra>,<Rb>
             :bne        <trueaddress>
             :b        <falseaddress>
#<Ra> >= <Rb>:cmpw        <Ra>,<Rb>
             :bge        <trueaddress>
             :b        <falseaddress>
#<Ra> <= <Rb>:cmpw        <Ra>,<Rb>
             :ble        <trueaddress>
             :b        <falseaddress>
#<Ra> == <Rb>:cmpw        <Ra>,<Rb>
             :beq        <trueaddress>
             :b        <falseaddress>
#<Ra> > <Rb>:cmpw        <Ra>,<Rb>
            :bgt        <trueaddress>
            :b        <falseaddress>
#<Ra> < <Rb>:cmpw        <Ra>,<Rb>
            :blt        <trueaddress>
            :b        <falseaddress>
#>=+:bge        <trueaddress>
    :b        <falseaddress>
#<=+:ble        <trueaddress>
    :b        <falseaddress>
#>+:bgt        <trueaddress>
   :b        <falseaddress>
#<+:blt        <trueaddress>
   :b        <falseaddress>
#!=:bne        <trueaddress>
   :b        <falseaddress>
#>=:bge        <trueaddress>
   :b        <falseaddress>
#<=:ble        <trueaddress>
   :b        <falseaddress>
#==:beq        <trueaddress>
   :b        <falseaddress>
#>:bgt        <trueaddress>
  :b        <falseaddress>
#<:blt        <trueaddress>
  :b        <falseaddress>
#<Ra> ++:addi        <Ra>,<Ra>,1
#<Ra> --:subi        <Ra>,<Ra>,1
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> - <imm>:subfi        <Ra>,<imm>,<Ra>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:srawi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srwi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:slwi        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> - <imm>:subfi        <Ra>,<imm>,<Rb>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:srawi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srwi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:slwi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:addi        <Ra>,<Rb>,0
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subf        <Ra>,<Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sraw        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srw        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:slw        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subf        <Ra>,<Rc>,<Rb>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:sraw        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srw        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:slw        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.PowerPC
#break:b        <address>
#continue:b        <address>
#goto        <Ra>:b        <Ra>
#<Ra> >=+ <imm>:cmplwi        <Ra>,<imm>
               :bge        <trueaddress>
               :b        <falseaddress>
#<Ra> <=+ <imm>:cmplwi        <Ra>,<imm>
               :ble        <trueaddress>
               :b        <falseaddress>
#<Ra> >+ <imm>:cmplwi        <Ra>,<imm>
              :bgt        <trueaddress>
              :b        <falseaddress>
#<Ra> <+ <imm>:cmplwi        <Ra>,<imm>
              :blt        <trueaddress>
              :b        <falseaddress>
#<Ra> != <imm>:cmpwi        <Ra>,<imm>
              :bne        <trueaddress>
              :b        <falseaddress>
#<Ra> >= <imm>:cmpwi        <Ra>,<imm>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <= <imm>:cmpwi        <Ra>,<imm>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> == <imm>:cmpwi        <Ra>,<imm>
              :beq        <trueaddress>
              :b        <falseaddress>
#<Ra> > <imm>:cmpwi        <Ra>,<imm>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> < <imm>:cmpwi        <Ra>,<imm>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> >=+ <Rb>:cmplw        <Ra>,<Rb>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <=+ <Rb>:cmplw        <Ra>,<Rb>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> >+ <Rb>:cmplw        <Ra>,<Rb>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> <+ <Rb>:cmplw        <Ra>,<Rb>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> != <Rb>:cmpw        <Ra>,<Rb>
             :bne        <trueaddress>
             :b        <falseaddress>
#<Ra> >= <Rb>:cmpw        <Ra>,<Rb>
             :bge        <trueaddress>
             :b        <falseaddress>
#<Ra> <= <Rb>:cmpw        <Ra>,<Rb>
             :ble        <trueaddress>
             :b        <falseaddress>
#<Ra> == <Rb>:cmpw        <Ra>,<Rb>
             :beq        <trueaddress>
             :b        <falseaddress>
#<Ra> > <Rb>:cmpw        <Ra>,<Rb>
            :bgt        <trueaddress>
            :b        <falseaddress>
#<Ra> < <Rb>:cmpw        <Ra>,<Rb>
            :blt        <trueaddress>
            :b        <falseaddress>
#>=+:bge        <trueaddress>
    :b        <falseaddress>
#<=+:ble        <trueaddress>
    :b        <falseaddress>
#>+:bgt        <trueaddress>
   :b        <falseaddress>
#<+:blt        <trueaddress>
   :b        <falseaddress>
#!=:bne        <trueaddress>
   :b        <falseaddress>
#>=:bge        <trueaddress>
   :b        <falseaddress>
#<=:ble        <trueaddress>
   :b        <falseaddress>
#==:beq        <trueaddress>
   :b        <falseaddress>
#>:bgt        <trueaddress>
  :b        <falseaddress>
#<:blt        <trueaddress>
  :b        <falseaddress>
#<Ra> ++:addi        <Ra>,<Ra>,1
#<Ra> --:subi        <Ra>,<Ra>,1
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> - <imm>:subfi        <Ra>,<imm>,<Ra>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:srawi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srwi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:slwi        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> - <imm>:subfi        <Ra>,<imm>,<Rb>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:srawi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srwi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:slwi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:addi        <Ra>,<Rb>,0
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subf        <Ra>,<Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sraw        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srw        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:slw        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subf        <Ra>,<Rc>,<Rb>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:sraw        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srw        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:slw        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.AVR
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> >=+ <imm>:cpi        <Ra>,<imm>
               :brsh        <trueaddress>
               :jmp        <falseaddress>
#<Ra> <=+ <imm>:cpi        <imm>,<Ra>
               :brsh        <trueaddress>
               :jmp        <falseaddress>
#<Ra> >+ <imm>:cpi        <imm>,<Ra>
              :brlo        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:cpi        <Ra>,<imm>
              :brlo        <trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:cpi        <Ra>,<imm>
              :brne        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:cpi        <Ra>,<imm>
              :brge        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:cpi        <imm>,<Ra>
              :brge        <trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:cpi        <Ra>,<imm>
              :breq        <trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:cpi        <imm>,<Ra>
             :brlt        <trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:cpi        <Ra>,<imm>
             :brlt        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >=+ <Rb>:cp        <Ra>,<Rb>
              :brsh        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <=+ <Rb>:cp        <Rb>,<Ra>
              :brsh        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >+ <Rb>:cp        <Rb>,<Ra>
             :brlo        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:cp        <Ra>,<Rb>
             :brlo        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:cp        <Ra>,<Rb>
             :brne        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:cp        <Ra>,<Rb>
             :brge        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:cp        <Rb>,<Ra>
             :brge        <trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:cp        <Ra>,<Rb>
             :breq        <trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:cp        <Rb>,<Ra>
            :brlt        <trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:cp        <Ra>,<Rb>
            :brlt        <trueaddress>
            :jmp        <falseaddress>
#>=+:brsh        <trueaddress>
    :jmp        <falseaddress>
#<=+:brsh        <trueaddress>
    :jmp        <falseaddress>
#>+:brlo        <trueaddress>
   :jmp        <falseaddress>
#<+:brlo        <trueaddress>
   :jmp        <falseaddress>
#!=:brne        <trueaddress>
   :jmp        <falseaddress>
#>=:brge        <trueaddress>
   :jmp        <falseaddress>
#<=:brge        <trueaddress>
   :jmp        <falseaddress>
#==:breq        <trueaddress>
   :jmp        <falseaddress>
#>:brlt        <trueaddress>
  :jmp        <falseaddress>
#<:brlt        <trueaddress>
  :jmp        <falseaddress>
#zero:breq        <trueaddress>
     :jmp        <falseaddress>
#nonzero:brne        <trueaddress>
        :jmp        <falseaddress>
#carry:brcs        <trueaddress>
      :jmp        <falseaddress>
#noncarry:brcc        <trueaddress>
         :jmp        <falseaddress>
#overflow:brvs        <trueaddress>
         :jmp        <falseaddress>
#nonoverflow:brvc        <trueaddress>
            :jmp        <falseaddress>
#plus:brpl        <trueaddress>
     :jmp        <falseaddress>
#minus:brmi        <trueaddress>
      :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:com        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:ldi        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:subi        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:ldi        <Ra>,<imm>
                    :add        <Ra>,<Rb>
#<Ra> = <Rb> - <imm>:mov        <Ra>,<Rb>
                    :subi        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<Rb>
                    :andi        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<Rb>
                    :ori        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:ldi        <Ra>,<imm>
                    :eor        <Ra>,<Rb>
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:eor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ 1:asr        <Ra>
#<Ra> = <Ra> >> 1:lsr        <Ra>
#<Ra> = <Ra> << 1:lsl        <Ra>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :eor        <Ra>,<Rc>
#<Ra> = <Rb> >>+ 1:mov        <Ra>,<Rb>
                  :asr        <Ra>
#<Ra> = <Rb> >> 1:mov        <Ra>,<Rb>
                 :lsr        <Ra>
#<Ra> = <Rb> << 1:mov        <Ra>,<Rb>
                 :lsl        <Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.H8
#break:bra                <eaddress>
#continue:bra        <eaddress>
#goto        <Ra>:bra        <Ra>
#<Ra> >=+ <imm>:cmp.<size>        <imm>,<Ra>
               :bcc                <trueaddress>
               :bra                <falseaddress>
#<Ra> <=+ <imm>:cmp.<size>        <imm>,<Ra>
               :bls                <trueaddress>
               :bra                <falseaddress>
#<Ra> >+ <imm>:cmp.<size>        <imm>,<Ra>
              :bhi                <trueaddress>
              :bra                <falseaddress>
#<Ra> <+ <imm>:cmp.<size>        <imm>,<Ra>
              :bcs                <trueaddress>
              :bra                <falseaddress>
#<Ra> != <imm>:cmp.<size>        <imm>,<Ra>
              :bne                <trueaddress>
              :bra                <falseaddress>
#<Ra> >= <imm>:cmp.<size>        <imm>,<Ra>
              :bge                <trueaddress>
              :bra                <falseaddress>
#<Ra> <= <imm>:cmp.<size>        <imm>,<Ra>
              :ble                <trueaddress>
              :bra                <falseaddress>
#<Ra> == <imm>:cmp.<size>        <imm>,<Ra>
              :beq                <trueaddress>
              :bra                <falseaddress>
#<Ra> > <imm>:cmp.<size>        <imm>,<Ra>
             :bgt                <trueaddress>
             :bra                <falseaddress>
#<Ra> < <imm>:cmp.<size>        <imm>,<Ra>
             :blt                <trueaddress>
             :bra                <falseaddress>
#<Ra> >=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :bcc                <trueaddress>
              :bra                <falseaddress>
#<Ra> <=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :bls                <trueaddress>
              :bra                <falseaddress>
#<Ra> >+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :bhi                <trueaddress>
             :bra                <falseaddress>
#<Ra> <+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :bcs                <trueaddress>
             :bra                <falseaddress>
#<Ra> != <Rb>:cmp.<size>        <Rb>,<Ra>
             :bne                <trueaddress>
             :bra                <falseaddress>
#<Ra> >= <Rb>:cmp.<size>        <Rb>,<Ra>
             :bge                <trueaddress>
             :bra                <falseaddress>
#<Ra> <= <Rb>:cmp.<size>        <Rb>,<Ra>
             :ble                <trueaddress>
             :bra                <falseaddress>
#<Ra> == <Rb>:cmp.<size>        <Rb>,<Ra>
             :beq                <trueaddress>
             :bra                <falseaddress>
#<Ra> > <Rb>:cmp.<size>        <Rb>,<Ra>
            :bgt                <trueaddress>
            :bra                <falseaddress>
#<Ra> < <Rb>:cmp.<size>        <Rb>,<Ra>
            :blt                <trueaddress>
            :bra                <falseaddress>
#>=+:bcc                <trueaddress>
    :bra                <falseaddress>
#<=+:bls                <trueaddress>
    :bra                <falseaddress>
#>+:bhi                <trueaddress>
   :bra                <falseaddress>
#<+:bcs                <trueaddress>
   :bra                <falseaddress>
#!=:bne                <trueaddress>
   :bra                <falseaddress>
#>=:bge                <trueaddress>
   :bra                <falseaddress>
#<=:ble                <trueaddress>
   :bra                <falseaddress>
#==:beq                <trueaddress>
   :bra                <falseaddress>
#>:bgt                <trueaddress>
  :bra                <falseaddress>
#<:blt                <trueaddress>
  :bra                <falseaddress>
#zero:beq                <trueaddress>
     :bra                <falseaddress>
#nonzero:bne        <trueaddress>
        :bra        <falseaddress>
#overflow:bvs        <trueaddress>
         :bra        <falseaddress>
#nonoverflow:bvc        <trueaddress>
            :bra        <falseaddress>
#plus:bpl                <trueaddress>
     :bra                <falseaddress>
#minus:bmi                <trueaddress>
      :bra                <falseaddress>
#true:bra                <trueaddress>
     :bra                <falseaddress>
#false:brn                <trueaddress>
      :bra                <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:mov.<size>                <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add.<size>        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and                <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or                <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor                <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov.<size>        <Rb>,<Ra>
                    :add.<size>        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov.<size>        <Rb>,<Ra>
                    :and                <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov.<size>        <Rb>,<Ra>
                    :or                <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor                <imm>,<Ra>
#<Ra> = <Rb>:mov.<size>                <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b                <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w                <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l                <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b                <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w                <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l                <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add.<size>        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub.<size>        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and                <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or                <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor                <Rb>,<Ra>
#<Ra> = <Ra> <<+ 1:shal                <Ra>
#<Ra> = <Ra> >>+ 1:shar                <Ra>
#<Ra> = <Ra> << 1:shll                <Ra>
#<Ra> = <Ra> >> 1:shlr                <Ra>
#<Ra> = <Rb> + <Rc>:mov.<size>        <Rb>,<Ra>
                   :add.<size>        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov.<size>        <Rb>,<Ra>
                   :sub.<size>        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov.<size>        <Rb>,<Ra>
                   :and                <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov.<size>        <Rb>,<Ra>
                   :or                <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor                <Ra>,<Rc>
#<Ra> = <Rb> <<+ 1:mov.<size>        <Rb>,<Ra>
                  :shal                <Ra>
#<Ra> = <Rb> >>+ 1:mov.<size>        <Rb>,<Ra>
                  :shar                <Ra>
#<Ra> = <Rb> << 1:mov.<size>        <Rb>,<Ra>
                 :shll                <Ra>
#<Ra> = <Rb> >> 1:mov.<size>        <Rb>,<Ra>
                 :shlr                <Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=er0,er1,er2,er3,er4,er5,er6,er7,[,@
#w=e0,e1,e2,e3,e4,e5,e6,e7,r0,r1,r2,r3,r4,r5,r6,r7,sp,pc
#b=ccr,r0h,r1h,r2h,r3h,r4h,r5h,r6h,r7h,r0l,r1l,r2l,r3l,r4l,r5l,r6l,r7l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.SuperH
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> > 0:cmp/pl        <Ra>
         :bt        <trueaddress>
         :bra        <falseaddress>
         :nop
#<Ra> >= 0:cmp/pz        <Ra>
          :bt        <trueaddress>
          :bra        <falseaddress>
          :nop
#<Ra> <= 0:cmp/pl        <Ra>
          :bf        <trueaddress>
          :bra        <falseaddress>
          :nop
#<Ra> < 0:cmp/pz        <Ra>
         :bf        <trueaddress>
         :bra        <falseaddress>
         :nop
#<Ra> == <imm>:cmp/eq        <imm>,<Ra>
              :bt        <trueaddress>
              :bra        <falseaddress>
              :nop
#<Ra> >=+ <Rb>:cmp/hs        <Rb>,<Ra>
              :bt        <trueaddress>
              :bra        <falseaddress>
              :nop
#<Ra> <=+ <Rb>:cmp/hi        <Rb>,<Ra>
              :bf        <trueaddress>
              :bra        <falseaddress>
              :nop
#<Ra> >+ <Rb>:cmp/hi        <Rb>,<Ra>
             :bt        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> <+ <Rb>:cmp/hs        <Rb>,<Ra>
             :bf        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> != <Rb>:cmp/eq        <imm>,<Ra>
             :bf        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> >= <Rb>:cmp/ge        <Rb>,<Ra>
             :bt        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> <= <Rb>:cmp/gt        <Rb>,<Ra>
             :bf        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> == <Rb>:cmp/eq        <Rb>,<Ra>
             :bt        <trueaddress>
             :bra        <falseaddress>
             :nop
#<Ra> > <Rb>:cmp/gt        <Rb>,<Ra>
            :bt        <trueaddress>
            :bra        <falseaddress>
            :nop
#<Ra> < <Rb>:cmp/ge        <Rb>,<Ra>
            :bf        <trueaddress>
            :bra        <falseaddress>
            :nop
#<Ra> ++:add        #H'01,<Ra>
#<Ra> --:add        #H'ff,<Ra>
#<Ra> = ~ <Ra>:not        <Rb>,<Ra>
#<Ra> = - <Rb>:neg        <Rb>,<Ra>
#<Ra> = <imm>:mov        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and        <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or        <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov        <Rb>,<Ra>
                    :add        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov        <Rb>,<Ra>
                    :and        <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov        <Rb>,<Ra>
                    :or        <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov        <Rb>,<Ra>
                    :xor        <imm>,<Ra>
#<Ra> = <Rb>:mov        <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor        <Rb>,<Ra>
#<Ra> = <Ra> <<+ 1:shal        <Ra>
#<Ra> = <Ra> >>+ 1:shar        <Ra>
#<Ra> = <Ra> << 1:shll        <Ra>
#<Ra> = <Ra> >> 1:shlr        <Ra>
#<Ra> = <Rb> + <Rc>:mov        <Rb>,<Ra>
                   :add        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov        <Rb>,<Ra>
                   :sub        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov        <Rb>,<Ra>
                   :and        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov        <Rb>,<Ra>
                   :or        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov        <Rb>,<Ra>
                   :xor        <Rc>,<Ra>
#<Ra> = <Rb> <<+ 1:mov        <Rb>,<Ra>
                  :shal        <Ra>
#<Ra> = <Rb> <<+ 1:mov        <Rb>,<Ra>
                  :shar        <Ra>
#<Ra> = <Rb> << 1:mov        <Rb>,<Ra>
                 :shll        <Ra>
#<Ra> = <Rb> >> 1:mov        <Rb>,<Ra>
                 :shlr        <Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.RX
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> >=+ <imm>:cmp        <imm>,<Ra>
               :bgeu        <trueaddress>
               :bra        <falseaddress>
#<Ra> <=+ <imm>:cmp        <imm>,<Ra>
               :bleu        <trueaddress>
               :bra        <falseaddress>
#<Ra> >+ <imm>:cmp        <imm>,<Ra>
              :bgtu        <trueaddress>
              :bra        <falseaddress>
#<Ra> <+ <imm>:cmp        <imm>,<Ra>
              :bltu        <trueaddress>
              :bra        <falseaddress>
#<Ra> != <imm>:cmp        <imm>,<Ra>
              :bne        <trueaddress>
              :bra        <falseaddress>
#<Ra> >= <imm>:cmp        <imm>,<Ra>
              :bge        <trueaddress>
              :bra        <falseaddress>
#<Ra> <= <imm>:cmp        <imm>,<Ra>
              :ble        <trueaddress>
              :bra        <falseaddress>
#<Ra> == <imm>:cmp        <imm>,<Ra>
              :beq        <trueaddress>
              :bra        <falseaddress>
#<Ra> > <imm>:cmp        <imm>,<Ra>
             :bgt        <trueaddress>
             :bra        <falseaddress>
#<Ra> < <imm>:cmp        <imm>,<Ra>
             :blt        <trueaddress>
             :bra        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Rb>,<Ra>
              :bgeu        <trueaddress>
              :bra        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Rb>,<Ra>
              :bleu        <trueaddress>
              :bra        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Rb>,<Ra>
             :bgtu        <trueaddress>
             :bra        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Rb>,<Ra>
             :bltu        <trueaddress>
             :bra        <falseaddress>
#<Ra> != <Rb>:cmp        <Rb>,<Ra>
             :bne        <trueaddress>
             :bra        <falseaddress>
#<Ra> >= <Rb>:cmp        <Rb>,<Ra>
             :bge        <trueaddress>
             :bra        <falseaddress>
#<Ra> <= <Rb>:cmp        <Rb>,<Ra>
             :ble        <trueaddress>
             :bra        <falseaddress>
#<Ra> == <Rb>:cmp        <Rb>,<Ra>
             :beq        <trueaddress>
             :bra        <falseaddress>
#<Ra> > <Rb>:cmp        <Rb>,<Ra>
            :bgt        <trueaddress>
            :bra        <falseaddress>
#<Ra> < <Rb>:cmp        <Rb>,<Ra>
            :blt        <trueaddress>
            :bra        <falseaddress>
#>=+:bgeu        <trueaddress>
    :bra        <falseaddress>
#<=+:bleu        <trueaddress>
    :bra        <falseaddress>
#>+:bgtu        <trueaddress>
   :bra        <falseaddress>
#<+:bltu        <trueaddress>
   :bra        <falseaddress>
#!=:bne        <trueaddress>
   :bra        <falseaddress>
#>=:bge        <trueaddress>
   :bra        <falseaddress>
#<=:ble        <trueaddress>
   :bra        <falseaddress>
#==:beq        <trueaddress>
   :bra        <falseaddress>
#>:bgt        <trueaddress>
  :bra        <falseaddress>
#<:blt        <trueaddress>
  :bra        <falseaddress>
#overflow:bo        <trueaddress>
         :bra        <falseaddress>
#nonoverflow:bno        <trueaddress>
            :bra        <falseaddress>
#pluszero:bpz        <trueaddress>
         :bra        <falseaddress>
#minus:bn        <trueaddress>
      :bra        <falseaddress>
#<Ra> ++:add        #1,<Ra>
#<Ra> --:sub        #1,<Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:mov.<size>        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add                <imm>,<Ra>
#<Ra> = <Ra> - <imm>:sub                <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and                <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or                <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor                <imm>,<Ra>
#<Ra> = <Ra> * <imm>:mul                <imm>,<Ra>
#<Ra> = <Ra> /+ <imm>:div                <imm>,<Ra>
#<Ra> = <Ra> / <imm>:divu                <imm>,<Ra>
#<Ra> = <Ra> >>+ <imm>:shar                <imm>,<Ra>
#<Ra> = <Ra> >> <imm>:shlr                <imm>,<Ra>
#<Ra> = <Ra> << <imm>:shll                <imm>,<Ra>
#<Ra> = <Rb> + <imm>:add                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> - <imm>:sub                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> & <imm>:and                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> | <imm>:or                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor                <imm>,<Ra>
#<Ra> = <Rb> * <imm>:mul                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> /+ <imm>:mov.<size>        <Rb>,<Ra>
                     :div                <imm>,<Ra>
#<Ra> = <Rb> / <imm>:mov.<size>        <Rb>,<Ra>
                    :divu                <imm>,<Ra>
#<Ra> = <Rb> >>+ <imm>:shar                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> >> <imm>:shlr                <imm>,<Rb>,<Ra>
#<Ra> = <Rb> << <imm>:shll                <imm>,<Rb>,<Ra>
#<Ra> = <Rb>:mov.<size>        <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add                <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub                <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and                <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or                <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor                <Rb>,<Ra>
#<Ra> = <Ra> * <Rb>:mul                <Rb>,<Ra>
#<Ra> = <Ra> /+ <Rb>:div                <Rb>,<Ra>
#<Ra> = <Ra> / <Rb>:divu                <Rb>,<Ra>
#<Ra> = <Ra> >>+ <Rb>:shar                <Rb>,<Ra>
#<Ra> = <Ra> >> <Rb>:shlr                <Rb>,<Ra>
#<Ra> = <Ra> << <Rb>:shll                <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:add                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> - <Rc>:sub                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> & <Rc>:and                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> | <Rc>:or                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor                <Rc>,<Ra>
#<Ra> = <Rb> * <Rc>:mul                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> /+ <Rc>:mov.<size>        <Rb>,<Ra>
                    :div                <Rc>,<Ra>
#<Ra> = <Rb> / <Rc>:mov.<size>        <Rb>,<Ra>
                   :divu                <Rc>,<Ra>
#<Ra> = <Rb> >>+ <Rc>:shar                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> >> <Rc>:shlr                <Rc>,<Rb>,<Ra>
#<Ra> = <Rb> << <Rc>:shll                <Rc>,<Rb>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,isp,usp,intb,pc,psw,bpc,bpsw,fintv,fpsw,sp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.M32C
#break:jmp.a                <address>
#continue:jmp.a        <address>
#goto        <Ra>:jmp.a        <Ra>
#<Ra> >=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jgeu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> <=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jleu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> >+ <imm>:cmp.<size>        <imm>,<Ra>
              :jgtu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <+ <imm>:cmp.<size>        <imm>,<Ra>
              :jltu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> != <imm>:cmp.<size>        <imm>,<Ra>
              :jne                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >= <imm>:cmp.<size>        <imm>,<Ra>
              :jge                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <= <imm>:cmp.<size>        <imm>,<Ra>
              :jle                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> == <imm>:cmp.<size>        <imm>,<Ra>
              :jeq                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> > <imm>:cmp.<size>        <imm>,<Ra>
             :jgt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> < <imm>:cmp.<size>        <imm>,<Ra>
             :jlt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jgeu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jleu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jgtu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jltu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> != <Rb>:cmp.<size>        <Rb>,<Ra>
             :jne                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jge                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jle                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> == <Rb>:cmp.<size>        <Rb>,<Ra>
             :jeq                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> > <Rb>:cmp.<size>        <Rb>,<Ra>
            :jgt                <trueaddress>
            :jmp.a                <falseaddress>
#<Ra> < <Rb>:cmp.<size>        <Rb>,<Ra>
            :jlt                <trueaddress>
            :jmp.a                <falseaddress>
#>=+:jgeu        <trueaddress>
    :jmp.a        <falseaddress>
#<=+:jleu        <trueaddress>
    :jmp.a        <falseaddress>
#>+:jgtu        <trueaddress>
   :jmp.a        <falseaddress>
#<+:jltu        <trueaddress>
   :jmp.a        <falseaddress>
#!=:jne        <trueaddress>
   :jmp.a        <falseaddress>
#>=:jge        <trueaddress>
   :jmp.a        <falseaddress>
#<=:jle        <trueaddress>
   :jmp.a        <falseaddress>
#==:jeq        <trueaddress>
   :jmp.a        <falseaddress>
#>:jgt        <trueaddress>
  :jmp.a        <falseaddress>
#<:jlt        <trueaddress>
  :jmp.a        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp.a        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp.a        <falseaddress>
#pluszero:jpz        <trueaddress>
         :jmp.a        <falseaddress>
#minus:jn        <trueaddress>
      :jmp.a        <falseaddress>
#<Ra> ++:inc.<size>        <Ra>
#<Ra> --:dec.<size>        <Ra>
#<Ra> = ~ <Ra>:not.<size>        <Ra>
#<Ra> = - <Ra>:neg.<size>        <Ra>
#<Ra> = <imm>:mov.<size>        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov.<size>        <Rb>,<Ra>
                    :add.<size>        <imm>,<Ra>
#<Ra> = <Rb> - <imm>:mov.<size>        <Rb>,<Ra>
                    :sub.<size>        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov.<size>        <Rb>,<Ra>
                    :and.<size>        <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov.<size>        <Rb>,<Ra>
                    :or.<size>        <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor.<size>        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add.<size>        <imm>,<Ra>
#<Ra> = <Ra> - <imm>:sub.<size>        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and.<size>        <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or.<size>        <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor.<size>        <imm>,<Ra>
#<Ra> = <Rb>:mov.<size>        <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov.<size>        <Rb>,<Ra>
                   :add.<size>        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov.<size>        <Rb>,<Ra>
                   :sub.<size>        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov.<size>        <Rb>,<Ra>
                   :and.<size>        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov.<size>        <Rb>,<Ra>
                   :or.<size>        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor.<size>        <Rc>,<Ra>
#<Ra> = <Ra> + <Rb>:add.<size>        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub.<size>        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and.<size>        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or.<size>        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor.<size>        <Rb>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r2r0,r3r1,a1a0,[,@
#w=r0,r1,r2,r3,a0,a1,fb,usp,isp,sb,flg,intbh,intbl
#b=r0h,r1h,r0l,r1l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.M16C
#break:jmp.a                <address>
#continue:jmp.a        <address>
#goto        <Ra>:jmp.a        <Ra>
#<Ra> >=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jgeu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> <=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jleu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> >+ <imm>:cmp.<size>        <imm>,<Ra>
              :jgtu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <+ <imm>:cmp.<size>        <imm>,<Ra>
              :jltu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> != <imm>:cmp.<size>        <imm>,<Ra>
              :jne                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >= <imm>:cmp.<size>        <imm>,<Ra>
              :jge                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <= <imm>:cmp.<size>        <imm>,<Ra>
              :jle                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> == <imm>:cmp.<size>        <imm>,<Ra>
              :jeq                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> > <imm>:cmp.<size>        <imm>,<Ra>
             :jgt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> < <imm>:cmp.<size>        <imm>,<Ra>
             :jlt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jgeu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jleu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jgtu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jltu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> != <Rb>:cmp.<size>        <Rb>,<Ra>
             :jne                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jge                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jle                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> == <Rb>:cmp.<size>        <Rb>,<Ra>
             :jeq                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> > <Rb>:cmp.<size>        <Rb>,<Ra>
            :jgt                <trueaddress>
            :jmp.a                <falseaddress>
#<Ra> < <Rb>:cmp.<size>        <Rb>,<Ra>
            :jlt                <trueaddress>
            :jmp.a                <falseaddress>
#>=+:jgeu        <trueaddress>
    :jmp.a        <falseaddress>
#<=+:jleu        <trueaddress>
    :jmp.a        <falseaddress>
#>+:jgtu        <trueaddress>
   :jmp.a        <falseaddress>
#<+:jltu        <trueaddress>
   :jmp.a        <falseaddress>
#!=:jne        <trueaddress>
   :jmp.a        <falseaddress>
#>=:jge        <trueaddress>
   :jmp.a        <falseaddress>
#<=:jle        <trueaddress>
   :jmp.a        <falseaddress>
#==:jeq        <trueaddress>
   :jmp.a        <falseaddress>
#>:jgt        <trueaddress>
  :jmp.a        <falseaddress>
#<:jlt        <trueaddress>
  :jmp.a        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp.a        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp.a        <falseaddress>
#pluszero:jpz        <trueaddress>
         :jmp.a        <falseaddress>
#minus:jn        <trueaddress>
      :jmp.a        <falseaddress>
#<Ra> ++:inc.<size>        <Ra>
#<Ra> --:dec.<size>        <Ra>
#<Ra> = ~ <Ra>:not.<size>        <Ra>
#<Ra> = - <Ra>:neg.<size>        <Ra>
#<Ra> = <imm>:mov.<size>        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add.<size>        <imm>,<Ra>
#<Ra> = <Ra> - <imm>:sub.<size>        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and.<size>        <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or.<size>        <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor.<size>        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov.<size>        <Rb>,<Ra>
                    :add.<size>        <imm>,<Ra>
#<Ra> = <Rb> - <imm>:mov.<size>        <Rb>,<Ra>
                    :sub.<size>        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov.<size>        <Rb>,<Ra>
                    :and.<size>        <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov.<size>        <Rb>,<Ra>
                    :or.<size>        <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor.<size>        <imm>,<Ra>
#<Ra> = <Rb>:mov.<size>                <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add.<size>        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub.<size>        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and.<size>        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or.<size>        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor.<size>        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov.<size>        <Rb>,<Ra>
                   :add.<size>        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov.<size>        <Rb>,<Ra>
                   :sub.<size>        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov.<size>        <Rb>,<Ra>
                   :and.<size>        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov.<size>        <Rb>,<Ra>
                   :or.<size>        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor.<size>        <Rc>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r2r0,r3r1,a1a0,[,@
#w=r0,r1,r2,r3,a0,a1,fb,usp,isp,sb,flg,intbh,intbl
#b=r0h,r1h,r0l,r1l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.R8C
#break:jmp.a                <address>
#continue:jmp.a        <address>
#goto        <Ra>:jmp.a        <Ra>
#<Ra> >=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jgeu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> <=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jleu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> >+ <imm>:cmp.<size>        <imm>,<Ra>
              :jgtu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <+ <imm>:cmp.<size>        <imm>,<Ra>
              :jltu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> != <imm>:cmp.<size>        <imm>,<Ra>
              :jne                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >= <imm>:cmp.<size>        <imm>,<Ra>
              :jge                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <= <imm>:cmp.<size>        <imm>,<Ra>
              :jle                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> == <imm>:cmp.<size>        <imm>,<Ra>
              :jeq                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> > <imm>:cmp.<size>        <imm>,<Ra>
             :jgt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> < <imm>:cmp.<size>        <imm>,<Ra>
             :jlt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jgeu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jleu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jgtu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jltu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> != <Rb>:cmp.<size>        <Rb>,<Ra>
             :jne                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jge                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jle                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> == <Rb>:cmp.<size>        <Rb>,<Ra>
             :jeq                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> > <Rb>:cmp.<size>        <Rb>,<Ra>
            :jgt                <trueaddress>
            :jmp.a                <falseaddress>
#<Ra> < <Rb>:cmp.<size>        <Rb>,<Ra>
            :jlt                <trueaddress>
            :jmp.a                <falseaddress>
#>=+:jgeu        <trueaddress>
    :jmp.a        <falseaddress>
#<=+:jleu        <trueaddress>
    :jmp.a        <falseaddress>
#>+:jgtu        <trueaddress>
   :jmp.a        <falseaddress>
#<+:jltu        <trueaddress>
   :jmp.a        <falseaddress>
#!=:jne        <trueaddress>
   :jmp.a        <falseaddress>
#>=:jge        <trueaddress>
   :jmp.a        <falseaddress>
#<=:jle        <trueaddress>
   :jmp.a        <falseaddress>
#==:jeq        <trueaddress>
   :jmp.a        <falseaddress>
#>:jgt        <trueaddress>
  :jmp.a        <falseaddress>
#<:jlt        <trueaddress>
  :jmp.a        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp.a        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp.a        <falseaddress>
#pluszero:jpz        <trueaddress>
         :jmp.a        <falseaddress>
#minus:jn        <trueaddress>
      :jmp.a        <falseaddress>
#<Ra> ++:inc.<size>        <Ra>
#<Ra> --:dec.<size>        <Ra>
#<Ra> = ~ <Ra>:not.<size>        <Ra>
#<Ra> = - <Ra>:neg.<size>        <Ra>
#<Ra> = <imm>:mov.<size>        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add.<size>        <imm>,<Ra>
#<Ra> = <Ra> - <imm>:sub.<size>        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and.<size>        <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or.<size>        <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor.<size>        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov.<size>        <Rb>,<Ra>
                    :add.<size>        <imm>,<Ra>
#<Ra> = <Rb> - <imm>:mov.<size>        <Rb>,<Ra>
                    :sub.<size>        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov.<size>        <Rb>,<Ra>
                    :and.<size>        <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov.<size>        <Rb>,<Ra>
                    :or.<size>        <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor.<size>        <imm>,<Ra>
#<Ra> = <Rb>:mov.<size>                <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add.<size>        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub.<size>        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and.<size>        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or.<size>        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor.<size>        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov.<size>        <Rb>,<Ra>
                   :add.<size>        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov.<size>        <Rb>,<Ra>
                   :sub.<size>        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov.<size>        <Rb>,<Ra>
                   :and.<size>        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov.<size>        <Rb>,<Ra>
                   :or.<size>        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor.<size>        <Rc>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r2r0,r3r1,a1a0,[,@
#w=r0,r1,r2,r3,a0,a1,fb,usp,isp,sb,flg,intbh,intbl
#b=r0h,r1h,r0l,r1l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.R32C
#break:jmp.a                <address>
#continue:jmp.a        <address>
#goto        <Ra>:jmp.a        <Ra>
#<Ra> >=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jgeu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> <=+ <imm>:cmp.<size>        <imm>,<Ra>
               :jleu                <trueaddress>
               :jmp.a                <falseaddress>
#<Ra> >+ <imm>:cmp.<size>        <imm>,<Ra>
              :jgtu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <+ <imm>:cmp.<size>        <imm>,<Ra>
              :jltu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> != <imm>:cmp.<size>        <imm>,<Ra>
              :jne                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >= <imm>:cmp.<size>        <imm>,<Ra>
              :jge                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <= <imm>:cmp.<size>        <imm>,<Ra>
              :jle                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> == <imm>:cmp.<size>        <imm>,<Ra>
              :jeq                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> > <imm>:cmp.<size>        <imm>,<Ra>
             :jgt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> < <imm>:cmp.<size>        <imm>,<Ra>
             :jlt                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jgeu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> <=+ <Rb>:cmp.<size>        <Rb>,<Ra>
              :jleu                <trueaddress>
              :jmp.a                <falseaddress>
#<Ra> >+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jgtu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <+ <Rb>:cmp.<size>        <Rb>,<Ra>
             :jltu                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> != <Rb>:cmp.<size>        <Rb>,<Ra>
             :jne                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> >= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jge                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> <= <Rb>:cmp.<size>        <Rb>,<Ra>
             :jle                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> == <Rb>:cmp.<size>        <Rb>,<Ra>
             :jeq                <trueaddress>
             :jmp.a                <falseaddress>
#<Ra> > <Rb>:cmp.<size>        <Rb>,<Ra>
            :jgt                <trueaddress>
            :jmp.a                <falseaddress>
#<Ra> < <Rb>:cmp.<size>        <Rb>,<Ra>
            :jlt                <trueaddress>
            :jmp.a                <falseaddress>
#>=+:jgeu        <trueaddress>
    :jmp.a        <falseaddress>
#<=+:jleu        <trueaddress>
    :jmp.a        <falseaddress>
#>+:jgtu        <trueaddress>
   :jmp.a        <falseaddress>
#<+:jltu        <trueaddress>
   :jmp.a        <falseaddress>
#!=:jne        <trueaddress>
   :jmp.a        <falseaddress>
#>=:jge        <trueaddress>
   :jmp.a        <falseaddress>
#<=:jle        <trueaddress>
   :jmp.a        <falseaddress>
#==:jeq        <trueaddress>
   :jmp.a        <falseaddress>
#>:jgt        <trueaddress>
  :jmp.a        <falseaddress>
#<:jlt        <trueaddress>
  :jmp.a        <falseaddress>
#overflow:jo        <trueaddress>
         :jmp.a        <falseaddress>
#nonoverflow:jno        <trueaddress>
            :jmp.a        <falseaddress>
#pluszero:jpz        <trueaddress>
         :jmp.a        <falseaddress>
#minus:jn        <trueaddress>
      :jmp.a        <falseaddress>
#<Ra> ++:inc.<size>        <Ra>
#<Ra> --:dec.<size>        <Ra>
#<Ra> = ~ <Ra>:not.<size>        <Ra>
#<Ra> = - <Ra>:neg.<size>        <Ra>
#<Ra> = <imm>:mov.<size>        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:add.<size>        <imm>,<Ra>
#<Ra> = <Ra> - <imm>:sub.<size>        <imm>,<Ra>
#<Ra> = <Ra> & <imm>:and.<size>        <imm>,<Ra>
#<Ra> = <Ra> | <imm>:or.<size>        <imm>,<Ra>
#<Ra> = <Ra> ^ <imm>:xor.<size>        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:mov.<size>        <Rb>,<Ra>
                    :add.<size>        <imm>,<Ra>
#<Ra> = <Rb> - <imm>:mov.<size>        <Rb>,<Ra>
                    :sub.<size>        <imm>,<Ra>
#<Ra> = <Rb> & <imm>:mov.<size>        <Rb>,<Ra>
                    :and.<size>        <imm>,<Ra>
#<Ra> = <Rb> | <imm>:mov.<size>        <Rb>,<Ra>
                    :or.<size>        <imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:mov.<size>        <Rb>,<Ra>
                    :xor.<size>        <imm>,<Ra>
#<Ra> = <Rb>:mov.<size>                <Rb>,<Ra>
#byte <Ra> = <Rb>:mov.b        <Rb>,<Ra>
#word <Ra> = <Rb>:mov.w        <Rb>,<Ra>
#dword <Ra> = <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = byte <Rb>:mov.b        <Rb>,<Ra>
#<Ra> = word <Rb>:mov.w        <Rb>,<Ra>
#<Ra> = dword <Rb>:mov.l        <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add.<size>        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub.<size>        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and.<size>        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or.<size>        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor.<size>        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov.<size>        <Rb>,<Ra>
                   :add.<size>        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov.<size>        <Rb>,<Ra>
                   :sub.<size>        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov.<size>        <Rb>,<Ra>
                   :and.<size>        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov.<size>        <Rb>,<Ra>
                   :or.<size>        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov.<size>        <Rb>,<Ra>
                   :xor.<size>        <Rc>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#o=r7r5r6r4r3r1r2r0,a3a2a1a0,[,@
#q=r3r1r2r0,r7r5r6r4,a1a0,a3a2
#l=r2r0,r3r1,r6r4,r7r5,a0,a1,a2,a3
#w=r0,r1,r2,r3,r4,r5,r6,r7,fb,usp,isp,sb,flg,intbh,intbl,pc,svf,svp,vct
#b=r0h,r1h,r2h,r3h,r0l,r1l,r2l,r3l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.M32R
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> == 0:beqz        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :bra        <falseaddress>
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :bra        <falseaddress>
#<Ra> != 0:bnez        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> >=+ <imm>:cmpui        <Ra>,<imm>
               :bnc        <trueaddress>
               :bra        <falseaddress>
#<Ra> <+ <imm>:cmpui        <Ra>,<imm>
              :bc        <trueaddress>
              :bra        <falseaddress>
#<Ra> >= <imm>:cmpi        <Ra>,<imm>
              :bnc        <trueaddress>
              :bra        <falseaddress>
#<Ra> < <imm>:cmpi        <Ra>,<imm>
             :bc        <trueaddress>
             :bra        <falseaddress>
#<Ra> >=+ <Rb>:cmpu        <Ra>,<Rb>
              :bnc        <trueaddress>
              :bra        <falseaddress>
#<Ra> <+ <Rb>:cmpu        <Ra>,<Rb>
             :bc        <trueaddress>
             :bra        <falseaddress>
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :bnc        <trueaddress>
             :bra        <falseaddress>
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :bc        <trueaddress>
            :bra        <falseaddress>
#<Ra> ++:add3        <Ra>,<Ra>,#H'01
#<Ra> --:add3        <Ra>,<Ra>,#H'ff
#<Ra> = ~ <Ra>:not        <Ra>,<Ra>
#<Ra> = - <Ra>:neg        <Ra>,<Ra>
#<Ra> = <imm>:ldi        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:and3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:or3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll3        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:add3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:and3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:or3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xor3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:mv                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> /+ <Rb>:div        <Ra>,<Rb>
#<Ra> = <Ra> / <Rb>:divu        <Ra>,<Rb>
#<Ra> = <Ra> * <Rb>:mul        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sra        <Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srl        <Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sll        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mv        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mv        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mv        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mv        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mv        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> /+ <Rc>:mv        <Ra>,<Rb>
                    :div        <Ra>,<Rc>
#<Ra> = <Rb> / <Rc>:mv        <Ra>,<Rb>
                   :divu        <Ra>,<Rc>
#<Ra> = <Rb> * <Rc>:mv        <Ra>,<Rb>
                   :mul        <Ra>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:mv        <Ra>,<Rb>
                     :sra        <Ra>,<Rc>
#<Ra> = <Rb> >> <Rc>:mv        <Ra>,<Rb>
                    :srl        <Ra>,<Rc>
#<Ra> = <Rb> << <Rc>:mv        <Ra>,<Rb>
                    :sll        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,cr0,cr1,cr2,cr3,cr6,psw,cbr,spi,spu,bpc,pc,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.V850
#break:br        <address>
#continue:br        <address>
#goto        <Ra>:br        <Ra>
#<Ra> >=+ <imm>:cmp        <imm>,<Ra>
               :bl        <trueaddress>
               :br        <falseaddress>
#<Ra> <=+ <imm>:cmp        <imm>,<Ra>
               :bnh        <trueaddress>
               :br        <falseaddress>
#<Ra> >+ <imm>:cmp        <imm>,<Ra>
              :bh        <trueaddress>
              :br        <falseaddress>
#<Ra> <+ <imm>:cmp        <imm>,<Ra>
              :bnl        <trueaddress>
              :br        <falseaddress>
#<Ra> != <imm>:cmp        <imm>,<Ra>
              :bnz        <trueaddress>
              :br        <falseaddress>
#<Ra> >= <imm>:cmp        <imm>,<Ra>
              :bge        <trueaddress>
              :br        <falseaddress>
#<Ra> <= <imm>:cmp        <imm>,<Ra>
              :ble        <trueaddress>
              :br        <falseaddress>
#<Ra> == <imm>:cmp        <imm>,<Ra>
              :bz        <trueaddress>
              :br        <falseaddress>
#<Ra> > <imm>:cmp        <imm>,<Ra>
             :bgt        <trueaddress>
             :br        <falseaddress>
#<Ra> < <imm>:cmp        <imm>,<Ra>
             :blt        <trueaddress>
             :br        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Rb>,<Ra>
              :bl        <trueaddress>
              :br        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Rb>,<Ra>
              :bnh        <trueaddress>
              :br        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Rb>,<Ra>
             :bh        <trueaddress>
             :br        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Rb>,<Ra>
             :bnl        <trueaddress>
             :br        <falseaddress>
#<Ra> != <Rb>:cmp        <Rb>,<Ra>
             :bnz        <trueaddress>
             :br        <falseaddress>
#<Ra> >= <Rb>:cmp        <Rb>,<Ra>
             :bge        <trueaddress>
             :br        <falseaddress>
#<Ra> <= <Rb>:cmp        <Rb>,<Ra>
             :ble        <trueaddress>
             :br        <falseaddress>
#<Ra> == <Rb>:cmp        <Rb>,<Ra>
             :bz        <trueaddress>
             :br        <falseaddress>
#<Ra> > <Rb>:cmp        <Rb>,<Ra>
            :bgt        <trueaddress>
            :br        <falseaddress>
#<Ra> < <Rb>:cmp        <Rb>,<Ra>
            :blt        <trueaddress>
            :br        <falseaddress>
#>=+:bl        <trueaddress>
    :br        <falseaddress>
#<=+:bnh        <trueaddress>
    :br        <falseaddress>
#>+:bh        <trueaddress>
   :br        <falseaddress>
#<+:bnl        <trueaddress>
   :br        <falseaddress>
#!=:bnz        <trueaddress>
   :br        <falseaddress>
#>=:bge        <trueaddress>
   :br        <falseaddress>
#<=:ble        <trueaddress>
   :br        <falseaddress>
#==:bz        <trueaddress>
   :br        <falseaddress>
#>:bgt        <trueaddress>
  :br        <falseaddress>
#<:blt        <trueaddress>
  :br        <falseaddress>
#zero:bz        <trueaddress>
     :br        <falseaddress>
#nonzero:bnz        <trueaddress>
        :br        <falseaddress>
#carry:bc        <trueaddress>
      :br        <falseaddress>
#noncarry:bnc        <trueaddress>
         :br        <falseaddress>
#overflow:bv        <trueaddress>
         :br        <falseaddress>
#nonoverflow:bnv        <trueaddress>
            :br        <falseaddress>
#sign:bn        <trueaddress>
     :br        <falseaddress>
#nonsign:bp        <trueaddress>
        :br        <falseaddress>
#<Ra> ++:add        1,<Ra>
#<Ra> --:sub        1,<Ra>
#<Ra> = ~ <Rb>:not        <Rb>,<Ra>
#<Ra> = - <Rb>:neg        <Rb>,<Ra>
#<Ra> = <imm>:mov        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:addi        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> & <imm>:andi        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> | <imm>:ori        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> ^ <imm>:xori        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> >>+ <imm>:sar        <imm>,<Ra>
#<Ra> = <Ra> >> <imm>:shr        <imm>,<Ra>
#<Ra> = <Ra> << <imm>:shl        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:addi        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> & <imm>:andi        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> | <imm>:ori        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> ^ <imm>:xori        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> >>+ <imm>:mov        <Rb>,<Ra>
                      :sar        <imm>,<Ra>
#<Ra> = <Rb> >> <imm>:mov        <Rb>,<Ra>
                     :shr        <imm>,<Ra>
#<Ra> = <Rb> << <imm>:mov        <Rb>,<Ra>
                     :shl        <imm>,<Ra>
#<Ra> = <Rb>:mov                <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor        <Rb>,<Ra>
#<Ra> = <Ra> >>+ <Rb>:sar        <Rb>,<Ra>
#<Ra> = <Ra> >> <Rb>:shr        <Rb>,<Ra>
#<Ra> = <Ra> << <Rb>:shl        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov        <Rb>,<Ra>
                   :add        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov        <Rb>,<Ra>
                   :sub        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov        <Rb>,<Ra>
                   :and        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov        <Rb>,<Ra>
                   :or        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov        <Rb>,<Ra>
                   :xor        <Rc>,<Ra>
#<Ra> = <Rb> >>+ <Rc>:mov        <Rb>,<Ra>
                     :sar        <Rc>,<Ra>
#<Ra> = <Rb> >> <Rc>:mov        <Rb>,<Ra>
                    :shr        <Rc>,<Ra>
#<Ra> = <Rb> << <Rc>:mov        <Rb>,<Ra>
                    :shl        <Rc>,<Ra>
#<Ra> = sbyte <Rb>:ld.b        <Rb>,<Ra>
#<Ra> = byte <Rb>:ld.bu        <Rb>,<Ra>
#<Ra> = sword <Rb>:ld.h        <Rb>,<Ra>
#<Ra> = word <Rb>:ld.hu        <Rb>,<Ra>
#<Ra> = dword <Rb>:ld.w        <Rb>,<Ra>
#<Ra> = qword <Rb>:ld.dw        <Rb>,<Ra>
#byte <Ra> = <Rb>:st.b        <Rb>,<Ra>
#word <Ra> = <Rb>:st.h        <Rb>,<Ra>
#dword <Ra> = <Rb>:st.w        <Rb>,<Ra>
#qword <Ra> = <Rb>:st.dw        <Rb>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,pc,sp,gp,tp,ep,lp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.78K
#break:br        <address>
#continue:br        <address>
#goto        <Ra>:br        <Ra>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :bnz        <trueaddress>
              :br        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :bz        <trueaddress>
              :br        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :bnz        <trueaddress>
             :br        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :bz        <trueaddress>
             :br        <falseaddress>
#!=:bnz        <trueaddress>
   :br        <falseaddress>
#==:bz        <trueaddress>
   :br        <falseaddress>
#zero:bz        <trueaddress>
     :br        <falseaddress>
#nonzero:bnz        <trueaddress>
        :br        <falseaddress>
#carry:bc        <trueaddress>
      :br        <falseaddress>
#noncarry:bnc        <trueaddress>
         :br        <falseaddress>
#<Ra> ++:inc<size>        <Ra>
#<Ra> --:dec<size>        <Ra>
#<Ra> = <imm>:mov<size>        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add<size>        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub<size>        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov<size>        <Ra>,<Rb>
                    :add<size>        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov<size>        <Ra>,<Rb>
                    :sub<size>        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov<size>        <Ra>,<Rb>
                    :and                <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov<size>        <Ra>,<Rb>
                    :or                <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov<size>        <Ra>,<Rb>
                    :xor                <Ra>,<imm>
#<Ra> = <Rb>:mov<size>        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add<size>        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub<size>        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and                <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or                <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor                <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov<size>        <Ra>,<Rb>
                   :add<size>        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov<size>        <Ra>,<Rb>
                   :sub<size>        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov<size>        <Ra>,<Rb>
                   :and                <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov<size>        <Ra>,<Rb>
                   :or                <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov<size>        <Ra>,<Rb>
                   :xor                <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=ax,bc,de,hl,rp0,rp1,rp2,rp3,[,@
# =a,x,b,c,d,e,h,l,r0,r1,r2,r3,r4,r5,r6,r7
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.MeP
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> != 0:bnez        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> == 0:beqz        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> != <imm>:bnei        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> >= <imm>:bgei        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> == <imm>:beqi        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> < <imm>:blti        <Ra>,<imm>,<trueaddress>
             :bra        <falseaddress>
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> >= <Rb>:bge        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> < <Rb>:blt        <Ra>,<Rb>,<trueaddress>
            :bra        <falseaddress>
#<Ra> ++:add3        <Ra>,<Ra>,0x0001
#<Ra> --:add3        <Ra>,<Ra>,0xffff
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Rb>:neg        <Ra>,<Rb>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:and3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:or3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll3        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:add3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:and3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:or3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xor3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:mov        <Ra>,<Rb>
                      :sra        <Ra>,<imm>
#<Ra> = <Rb> >> <imm>:mov        <Ra>,<Rb>
                     :srl        <Ra>,<imm>
#<Ra> = <Rb> << <imm>:sll3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:mov                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add3        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sra        <Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srl        <Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sll        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add3        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:mov        <Ra>,<Rb>
                     :sra        <Ra>,<Rc>
#<Ra> = <Rb> >> <Rc>:mov        <Ra>,<Rb>
                    :srl        <Ra>,<Rc>
#<Ra> = <Rb> << <Rc>:mov        <Ra>,<Rb>
                    :sll        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=$0,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$tp,$sp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TX99
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TX79
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TX49
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TX39
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TX19
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TLCS-900
#break:jp        <address>
#continue:jp        <address>
#goto        <Ra>:jp        <Ra>
#<Ra> >=+ <imm>:cp        <Ra>,<imm>
               :jp        ult,<trueaddress>
               :jp        <falseaddress>
#<Ra> <=+ <imm>:cp        <Ra>,<imm>
               :jp        ule,<trueaddress>
               :jp        <falseaddress>
#<Ra> >+ <imm>:cp        <Ra>,<imm>
              :jp        ugt,<trueaddress>
              :jp        <falseaddress>
#<Ra> <+ <imm>:cp        <Ra>,<imm>
              :jp        uge,<trueaddress>
              :jp        <falseaddress>
#<Ra> != <imm>:cp        <Ra>,<imm>
              :jp        ne,<trueaddress>
              :jp        <falseaddress>
#<Ra> >= <imm>:cp        <Ra>,<imm>
              :jp        ge,<trueaddress>
              :jp        <falseaddress>
#<Ra> <= <imm>:cp        <Ra>,<imm>
              :jp        le,<trueaddress>
              :jp        <falseaddress>
#<Ra> == <imm>:cp        <Ra>,<imm>
              :jp        eq,<trueaddress>
              :jp        <falseaddress>
#<Ra> > <imm>:cp        <Ra>,<imm>
             :jp        gt,<trueaddress>
             :jp        <falseaddress>
#<Ra> < <imm>:cp        <Ra>,<imm>
             :jp        lt,<trueaddress>
             :jp        <falseaddress>
#<Ra> >=+ <Rb>:cp        <Ra>,<Rb>
              :jp        ult,<trueaddress>
              :jp        <falseaddress>
#<Ra> <=+ <Rb>:cp        <Ra>,<Rb>
              :jp        ule,<trueaddress>
              :jp        <falseaddress>
#<Ra> >+ <Rb>:cp        <Ra>,<Rb>
             :jp        ugt,<trueaddress>
             :jp        <falseaddress>
#<Ra> <+ <Rb>:cp        <Ra>,<Rb>
             :jp        uge,<trueaddress>
             :jp        <falseaddress>
#<Ra> != <Rb>:cp        <Ra>,<Rb>
             :jp        ne,<trueaddress>
             :jp        <falseaddress>
#<Ra> >= <Rb>:cp        <Ra>,<Rb>
             :jp        ge,<trueaddress>
             :jp        <falseaddress>
#<Ra> <= <Rb>:cp        <Ra>,<Rb>
             :jp        le,<trueaddress>
             :jp        <falseaddress>
#<Ra> == <Rb>:cp        <Ra>,<Rb>
             :jp        eq,<trueaddress>
             :jp        <falseaddress>
#<Ra> > <Rb>:cp        <Ra>,<Rb>
            :jp        gt,<trueaddress>
            :jp        <falseaddress>
#<Ra> < <Rb>:cp        <Ra>,<Rb>
            :jp        lt,<trueaddress>
            :jp        <falseaddress>
#>=+:jp        ult,<trueaddress>
    :jp        <falseaddress>
#<=+:jp        ule,<trueaddress>
    :jp        <falseaddress>
#>+:jp        ugt,<trueaddress>
   :jp        <falseaddress>
#<+:jp        uge,<trueaddress>
   :jp        <falseaddress>
#!=:jp        ne,<trueaddress>
   :jp        <falseaddress>
#>=:jp        ge,<trueaddress>
   :jp        <falseaddress>
#<=:jp        le,<trueaddress>
   :jp        <falseaddress>
#==:jp        eq,<trueaddress>
   :jp        <falseaddress>
#>:jp        gt,<trueaddress>
  :jp        <falseaddress>
#<:jp        lt,<trueaddress>
  :jp        <falseaddress>
#zero:jp        eq,<trueaddress>
     :jp        <falseaddress>
#nonzero:jp        ne,<trueaddress>
        :jp        <falseaddress>
#carry:jp        c,<trueaddress>
      :jp        <falseaddress>
#noncarry:jp        nc,<trueaddress>
         :jp        <falseaddress>
#overflow:jp        ov,<trueaddress>
         :jp        <falseaddress>
#nonoverflow:jp        nov,<trueaddress>
            :jp        <falseaddress>
#plus:jp        pl,<trueaddress>
     :jp        <falseaddress>
#minus:jp        mi,<trueaddress>
      :jp        <falseaddress>
#parity:jp        pe,<trueaddress>
       :jp        <falseaddress>
#nonparity:jp        po,<trueaddress>
          :jp        <falseaddress>
#<Ra> ++:inc        1,<Ra>
#<Ra> --:dec        1,<Ra>
#<Ra> = ~ <Ra>:cpl        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:ld        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <imm>,<Ra>
#<Ra> = <Ra> >> <imm>:srl        <imm>,<Ra>
#<Ra> = <Ra> << <imm>:sll        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:ld        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:ld        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:ld        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:ld        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:ld        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb> >>+ <imm>:ld        <Ra>,<Rb>
                      :sra        <imm>,<Ra>
#<Ra> = <Rb> >> <imm>:ld        <Ra>,<Rb>
                     :srl        <imm>,<Ra>
#<Ra> = <Rb> << <imm>:ld        <Ra>,<Rb>
                     :sll        <imm>,<Ra>
#<Ra> = <Rb>:ld                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sra        <Rb>,<Ra>
#<Ra> = <Ra> >> <Rb>:srl        <Rb>,<Ra>
#<Ra> = <Ra> << <Rb>:sll        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:ld        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:ld        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:ld        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:ld        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:ld        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:ld        <Ra>,<Rb>
                     :sra        <Rc>,<Ra>
#<Ra> = <Rb> >> <Rc>:ld        <Ra>,<Rb>
                    :srl        <Rc>,<Ra>
#<Ra> = <Rb> << <Rc>:ld        <Ra>,<Rb>
                    :sll        <Rc>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=xwa,xbc,xde,xhl,xix,xiy,xiz,xsp,[,@
#w=wa,bc,de,hl,ix,iy,iz,sp
#b=w,a,b,c,d,e,h,l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.TLCS-870
#break:jr        <address>
#continue:jr        <address>
#goto        <Ra>:jr        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :jr        lt,<trueaddress>
               :jr        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :jr        le,<trueaddress>
               :jr        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :jr        gt,<trueaddress>
              :jr        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :jr        ge,<trueaddress>
              :jr        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :jr        ne,<trueaddress>
              :jr        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :jr        sge,<trueaddress>
              :jr        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :jr        sle,<trueaddress>
              :jr        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :jr        eq,<trueaddress>
              :jr        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :jr        sgt,<trueaddress>
             :jr        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :jr        slt,<trueaddress>
             :jr        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :jr        lt,<trueaddress>
              :jr        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :jr        le,<trueaddress>
              :jr        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :jr        gt,<trueaddress>
             :jr        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :jr        ge,<trueaddress>
             :jr        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :jr        ne,<trueaddress>
             :jr        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :jr        sge,<trueaddress>
             :jr        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :jr        sle,<trueaddress>
             :jr        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :jr        eq,<trueaddress>
             :jr        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :jr        sgt,<trueaddress>
            :jr        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :jr        slt,<trueaddress>
            :jr        <falseaddress>
#>=+:jr        ult,<trueaddress>
    :jr        <falseaddress>
#<=+:jr        ule,<trueaddress>
    :jr        <falseaddress>
#>+:jr        ugt,<trueaddress>
   :jr        <falseaddress>
#<+:jr        uge,<trueaddress>
   :jr        <falseaddress>
#!=:jr        ne,<trueaddress>
   :jr        <falseaddress>
#>=:jr        sge,<trueaddress>
   :jr        <falseaddress>
#<=:jr        sle,<trueaddress>
   :jr        <falseaddress>
#==:jr        eq,<trueaddress>
   :jr        <falseaddress>
#>:jr        sgt,<trueaddress>
  :jr        <falseaddress>
#<:jr        slt,<trueaddress>
  :jr        <falseaddress>
#zero:jr        eq,<trueaddress>
     :jr        <falseaddress>
#nonzero:jr        ne,<trueaddress>
        :jr        <falseaddress>
#overflow:jr        vs,<trueaddress>
         :jr        <falseaddress>
#nonoverflow:jr        nov,<trueaddress>
            :jr        <falseaddress>
#sign:jr        m,<trueaddress>
     :jr        <falseaddress>
#nonsign:jr        p,<trueaddress>
        :jr        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:cpl        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:ld        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:ld        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:ld        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:ld        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:ld        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:ld        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb>:ld                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:ld        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:ld        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:ld        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:ld        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:ld        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=xwa,xbc,xde,xhl,xix,xiy,xiz,xsp,[,@
#w=wa,bc,de,hl,ix,iy,iz,sp
#b=w,a,b,c,d,e,h,l
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.SPARC
#break:b        <address>
#continue:b        <address>
#goto        <Ra>:b        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :bcc        <trueaddress>
               :nop                
               :b        <falseaddress>
               :nop                
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :bleu        <trueaddress>
               :nop                
               :b        <falseaddress>
               :nop                
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :bgu        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :bcs        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :bne        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :bge        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :ble        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :be        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :bg        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :bl        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :bcc        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :bleu        <trueaddress>
              :nop                
              :b        <falseaddress>
              :nop                
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :bgu        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :bcs        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :bne        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :bge        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :ble        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :be        <trueaddress>
             :nop                
             :b        <falseaddress>
             :nop                
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :bg        <trueaddress>
            :nop                
            :b        <falseaddress>
            :nop                
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :bl        <trueaddress>
            :nop                
            :b        <falseaddress>
            :nop                
#>=+:bcc        <trueaddress>
    :nop                
    :b        <falseaddress>
    :nop                
#<=+:bleu        <trueaddress>
    :nop                
    :b        <falseaddress>
    :nop                
#>+:bgu        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#<+:bcs        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#!=:bne        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#>=:bge        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#<=:ble        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#==:be        <trueaddress>
   :nop                
   :b        <falseaddress>
   :nop                
#>:bg        <trueaddress>
  :nop                
  :b        <falseaddress>
  :nop                
#<:bl        <trueaddress>
  :nop                
  :b        <falseaddress>
  :nop                
#zero:be        <trueaddress>
     :nop                
     :b        <falseaddress>
     :nop                
#nonzero:bne        <trueaddress>
        :nop                
        :b        <falseaddress>
        :nop                
#overflow:bvs        <trueaddress>
         :nop                
         :b        <falseaddress>
         :nop                
#nonoverflow:bvc        <trueaddress>
            :nop                
            :b        <falseaddress>
            :nop                
#sign:bneg        <trueaddress>
     :nop                
     :b        <falseaddress>
     :nop                
#nonsign:bpos        <trueaddress>
        :nop                
        :b        <falseaddress>
        :nop
#<Rb> = - <Ra>:neg        <Ra>,<Rb>
#<Ra> = <imm>:set        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:add        <Rb>,<imm>,<Ra>
#<Ra> = <Rb> - <imm>:sub        <Rb>,<imm>,<Ra>
#<Ra> = <Rb> & <imm>:and        <Rb>,<imm>,<Ra>
#<Ra> = <Rb> | <imm>:or        <Rb>,<imm>,<Ra>
#<Ra> = <Rb> ^ <imm>:xor        <Rb>,<imm>,<Ra>
#<Ra> = <Rb>:mov                <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:add        <Rb>,<Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:sub        <Rb>,<Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:and        <Rb>,<Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:or        <Rb>,<Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:xor        <Rb>,<Rc>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
# =g0,g1,g2,g3,g4,g5,g6,g7,i0,i1,i2,i3,i4,i5,i6,i7,l0,l1,l2,l3,l4,l5,l6,l7,o0,o1,o2,o3,o4,o5,o6,o7
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.PIC
#break:goto                <address>
#continue:goto        <address>
#goto        <Ra>:goto        <Ra>
#<Ra> != 0:movf        <Ra>,W
          :btfss        STATUS,Z
          :goto        <trueaddress>
          :goto        <falseaddress>
#<Ra> >= 0:btfss        <Ra>,7
          :goto        <trueaddress>
          :goto        <falseaddress>
#<Ra> <= 0:movf        <Ra>,W
          :btfss        <Ra>,7
          :btfss        STATUS,Z
          :goto        <trueaddress>
          :goto        <falseaddress>
#<Ra> == 0:movf        <Ra>,W
          :btfsc        STATUS,Z
          :goto        <trueaddress>
          :goto        <falseaddress>
#<Ra> > 0:movf        <Ra>,W
         :btfsc        <Ra>,7
         :bsf        STATUS,Z
         :btfss        STATUS,Z
         :goto        <trueaddress>
         :goto        <falseaddress>
#<Ra> < 0:btfsc        <Ra>,7
         :goto        <trueaddress>
         :goto        <falseaddress>
#<Ra> != <imm>:movlw        <imm>
              :subwf        <Ra>,W
              :btfss        STATUS,Z
              :goto        <trueaddress>
              :goto        <falseaddress>
#<Ra> >= <imm>:movlw        <imm>
              :subwf        <Ra>,W
              :btfsc        STATUS,C
              :goto        <trueaddress>
              :goto        <falseaddress>
#<Ra> <= <imm>:movlw        <imm>
              :subwf        <Ra>,W
              :btfss        STATUS,Z
              :btfss        STATUS,C
              :goto        <trueaddress>
              :goto        <falseaddress>
#<Ra> == <imm>:movlw        <imm>
              :subwf        <Ra>,W
              :btfsc        STATUS,Z
              :goto        <trueaddress>
              :goto        <falseaddress>
#<Ra> > <imm>:movlw        <imm>
             :subwf        <Ra>,W
             :btfsc        STATUS,Z
             :bcf        STATUS,C
             :btfsc        STATUS,C
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> < <imm>:movlw        <imm>
             :subwf        <Ra>,W
             :btfss        STATUS,C
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> != <Rb>:movf        <Rb>,W
             :subwf        <Ra>,W
             :btfss        STATUS,Z
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> >= <Rb>:movf        <Rb>,W
             :subwf        <Ra>,W
             :btfsc        STATUS,C
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> <= <Rb>:movf        <Rb>,W
             :subwf        <Ra>,W
             :btfss        STATUS,Z
             :btfss        STATUS,C
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> == <Rb>:movf        <Rb>,W
             :subwf        <Ra>,W
             :btfsc        STATUS,Z
             :goto        <trueaddress>
             :goto        <falseaddress>
#<Ra> > <Rb>:movf        <Rb>,W
            :subwf        <Ra>,W
            :btfsc        STATUS,Z
            :bcf        STATUS,C
            :btfsc        STATUS,C
            :goto        <trueaddress>
            :goto        <falseaddress>
#<Ra> < <Rb>:movf        <Rb>,W
            :subwf        <Ra>,W
            :btfss        STATUS,C
            :goto        <trueaddress>
            :goto        <falseaddress>
#<Ra> ++:incf        <Ra>,F
#<Ra> --:decf        <Ra>,F
#<Ra> = ~ <Ra>:comf        <Ra>,F
#<Ra> = - <Ra>:comf        <Ra>,F
              :incf        <Ra>,F
#w = <imm>:movlw        <imm>
#<Ra> = <imm>:movlw        <imm>
             :movwf        <Ra>
#w = w + <imm>:addlw        <imm>
#w = w - <imm>:sublw        <imm>
#w = w & <imm>:andlw        <imm>
#w = w | <imm>:iorlw        <imm>
#w = w ^ <imm>:xorlw        <imm>
#<Ra> = <Ra> + <imm>:movlw        <imm>
                    :addwf        <Ra>,F
#<Ra> = <Ra> - <imm>:movlw        <imm>
                    :subwf        <Ra>,F
#<Ra> = <Ra> & <imm>:movlw        <imm>
                    :andwf        <Ra>,F
#<Ra> = <Ra> | <imm>:movlw        <imm>
                    :iorwf        <Ra>,F
#<Ra> = <Ra> ^ <imm>:movlw        <imm>
                    :xorwf        <Ra>,F
#w = <Rb>:movf        <Rb>,W
#<Ra> = w:movwf        <Ra>
#<Ra> = <Rb>:movf        <Rb>,W
            :movwf        <Ra>
#w = w + <Ra>:addwf        <Ra>,W
#w = w - <Ra>:subwf        <Ra>,W
#w = w & <Ra>:andwf        <Ra>,W
#w = w | <Ra>:iorwf        <Ra>,W
#w = w ^ <Ra>:xorwf        <Ra>,W
#<Ra> = <Ra> + <Rb>:movf        <Rb>,W
                   :addwf        <Ra>,F
#<Ra> = <Ra> - <Rb>:movf        <Rb>,W
                   :subwf        <Ra>,F
#<Ra> = <Ra> & <Rb>:movf        <Rb>,W
                   :andwf        <Ra>,F
#<Ra> = <Ra> | <Rb>:movf        <Rb>,W
                   :iorwf        <Ra>,F
#<Ra> = <Ra> ^ <Rb>:movf        <Rb>,W
                   :xorwf        <Ra>,F
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=STATUS,W,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',",D',H',O',B',A',d',h',o',b',a',0x
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.SX
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> != 0:mov        w,<Ra>
          :sb        STATUS,Z
          :jmp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> >= 0:sb        <Ra>,7
          :jmp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> <= 0:mov        w,<Ra>
          :sb        <Ra>,7
          :sb        STATUS,Z
          :jmp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> == 0:mov        w,<Ra>
          :snb        STATUS,Z
          :jmp        <trueaddress>
          :jmp        <falseaddress>
#<Ra> > 0:mov        w,<Ra>
         :snb        <Ra>,7
         :bsf        STATUS,Z
         :sb        STATUS,Z
         :jmp        <trueaddress>
         :jmp        <falseaddress>
#<Ra> < 0:snb        <Ra>,7
         :jmp        <trueaddress>
         :jmp        <falseaddress>
#<Ra> != <imm>:mov        w,<imm>
              :sub        <Ra>,W
              :sb        STATUS,Z
              :jmp        <trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:mov        w,<imm>
              :sub        <Ra>,W
              :snb        STATUS,C
              :jmp        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:mov        w,<imm>
              :sub        <Ra>,W
              :sb        STATUS,Z
              :sb        STATUS,C
              :jmp        <trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:mov        w,<imm>
              :sub        <Ra>,W
              :snb        STATUS,Z
              :jmp        <trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:mov        w,<imm>
             :sub        <Ra>,W
             :snb        STATUS,Z
             :bcf        STATUS,C
             :snb        STATUS,C
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:mov        w,<imm>
             :sub        <Ra>,W
             :sb        STATUS,C
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:mov        w,<Rb>
             :sub        <Ra>,W
             :sb        STATUS,Z
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:mov        w,<Rb>
             :sub        <Ra>,W
             :snb        STATUS,C
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:mov        w,<Rb>
             :sub        <Ra>,W
             :sb        STATUS,Z
             :sb        STATUS,C
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:mov        w,<Rb>
             :sub        <Ra>,W
             :snb        STATUS,Z
             :jmp        <trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:mov        w,<Rb>
            :sub        <Ra>,W
            :snb        STATUS,Z
            :bcf        STATUS,C
            :snb        STATUS,C
            :jmp        <trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:mov        w,<Rb>
            :sub        <Ra>,W
            :sb        STATUS,C
            :jmp        <trueaddress>
            :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb>:mov                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=STATUS,W,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.6809
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> >=+ <imm>:cmp<Ra>        <imm>
               :bhs        <trueaddress>
               :bra        <falseaddress>
#<Ra> <=+ <imm>:cmp<Ra>        <imm>
               :bls        <trueaddress>
               :bra        <falseaddress>
#<Ra> >+ <imm>:cmp<Ra>        <imm>
              :bhi        <trueaddress>
              :bra        <falseaddress>
#<Ra> <+ <imm>:cmp<Ra>        <imm>
              :blo        <trueaddress>
              :bra        <falseaddress>
#<Ra> != <imm>:cmp<Ra>        <imm>
              :bne        <trueaddress>
              :bra        <falseaddress>
#<Ra> >= <imm>:cmp<Ra>        <imm>
              :bge        <trueaddress>
              :bra        <falseaddress>
#<Ra> <= <imm>:cmp<Ra>        <imm>
              :ble        <trueaddress>
              :bra        <falseaddress>
#<Ra> == <imm>:cmp<Ra>        <imm>
              :beq        <trueaddress>
              :bra        <falseaddress>
#<Ra> > <imm>:cmp<Ra>        <imm>
             :bgt        <trueaddress>
             :bra        <falseaddress>
#<Ra> < <imm>:cmp<Ra>        <imm>
             :blt        <trueaddress>
             :bra        <falseaddress>
#<Ra> >=+ <Rb>:cmp<Ra>        <Rb>
              :bhs        <trueaddress>
              :bra        <falseaddress>
#<Ra> <=+ <Rb>:cmp<Ra>        <Rb>
              :bls        <trueaddress>
              :bra        <falseaddress>
#<Ra> >+ <Rb>:cmp<Ra>        <Rb>
             :bhi        <trueaddress>
             :bra        <falseaddress>
#<Ra> <+ <Rb>:cmp<Ra>        <Rb>
             :blo        <trueaddress>
             :bra        <falseaddress>
#<Ra> != <Rb>:cmp<Ra>        <Rb>
             :bne        <trueaddress>
             :bra        <falseaddress>
#<Ra> >= <Rb>:cmp<Ra>        <Rb>
             :bge        <trueaddress>
             :bra        <falseaddress>
#<Ra> <= <Rb>:cmp<Ra>        <Rb>
             :ble        <trueaddress>
             :bra        <falseaddress>
#<Ra> == <Rb>:cmp<Ra>        <Rb>
             :beq        <trueaddress>
             :bra        <falseaddress>
#<Ra> > <Rb>:cmp<Ra>        <Rb>
            :bgt        <trueaddress>
            :bra        <falseaddress>
#<Ra> < <Rb>:cmp<Ra>        <Rb>
            :blt        <trueaddress>
            :bra        <falseaddress>
#>=+:bhs        <trueaddress>
    :bra        <falseaddress>
#<=+:bls        <trueaddress>
    :bra        <falseaddress>
#>+:bhi        <trueaddress>
   :bra        <falseaddress>
#<+:blo        <trueaddress>
   :bra        <falseaddress>
#!=:bne        <trueaddress>
   :bra        <falseaddress>
#>=:bge        <trueaddress>
   :bra        <falseaddress>
#<=:ble        <trueaddress>
   :bra        <falseaddress>
#==:beq        <trueaddress>
   :bra        <falseaddress>
#>:bgt        <trueaddress>
  :bra        <falseaddress>
#<:blt        <trueaddress>
  :bra        <falseaddress>
#zero:beq        <trueaddress>
     :bra        <falseaddress>
#nonzero:bne        <trueaddress>
        :bra        <falseaddress>
#carry:bcs        <trueaddress>
      :bra        <falseaddress>
#noncarry:bcc        <trueaddress>
         :bra        <falseaddress>
#overflow:bvs        <trueaddress>
         :bra        <falseaddress>
#nonoverflow:bvc        <trueaddress>
            :bra        <falseaddress>
#plus:bpl        <trueaddress>
     :bra        <falseaddress>
#minus:bmi        <trueaddress>
      :bra        <falseaddress>
#a ++:inca
#b ++:incb
#<Ra> ++:inc        <Ra>
#a --:deca
#b --:decb
#<Ra> --:dec        <Ra>
#a = ~ a:coma
#b = ~ b:comb
#<Ra> = ~ <Ra>:com        <Ra>
#a = - a:nega
#b = - b:negb
#<Ra> = - <Ra>:neg        <Ra>
#a = <imm>:lda        <imm>
#b = <imm>:ldb        <imm>
#d = <imm>:ldd        <imm>
#x = <imm>:ldx        <imm>
#y = <imm>:ldy        <imm>
#u = <imm>:ldu        <imm>
#s = <imm>:lds        <imm>
#<Ra> = <Ra> + <imm>:add<Ra>        <imm>
#<Ra> = <Ra> - <imm>:sub<Ra>        <imm>
#<Ra> = <Ra> & <imm>:and<Ra>        <imm>
#<Ra> = <Ra> | <imm>:or<Ra>        <imm>
#<Ra> = <Ra> ^ <imm>:eor<Ra>        <imm>
#a = <Ra>:lda        <Ra>
#b = <Ra>:ldb        <Ra>
#d = <Ra>:ldd        <Ra>
#x = <Ra>:ldx        <Ra>
#y = <Ra>:ldy        <Ra>
#u = <Ra>:ldu        <Ra>
#s = <Ra>:lds        <Ra>
#<Ra> = a:sta        <Ra>
#<Ra> = b:stb        <Ra>
#<Ra> = d:std        <Ra>
#<Ra> = x:stx        <Ra>
#<Ra> = y:sty        <Ra>
#<Ra> = u:stu        <Ra>
#<Ra> = s:sts        <Ra>
#<Ra> = <Ra> + <Rb>:add<Ra>        <Rb>
#<Ra> = <Ra> - <Rb>:sub<Ra>        <Rb>
#<Ra> = <Ra> & <Rb>:and<Ra>        <Rb>
#<Ra> = <Ra> | <Rb>:or<Ra>        <Rb>
#<Ra> = <Ra> ^ <Rb>:eor<Ra>        <Rb>
#<Ra> = <Ra> >>+ 1:lsr        <Ra>
#a = a >>+ 1:lsra
#b = b >>+ 1:lsrb
#<Ra> = <Ra> >> 1:asr        <Ra>
#a = a >> 1:asra
#b = b >> 1:asrb
#<Ra> = <Ra> << 1:asl        <Ra>
#a = a << 1:asla
#b = b << 1:aslb
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=d,x,y,u,s,pc,dp,[,@
#b=a,b
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.6502
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#a != <imm>:cmp        <imm>
           :bne        <trueaddress>
           :jmp        <falseaddress>
#a == <imm>:cmp        <imm>
           :beq        <trueaddress>
           :jmp        <falseaddress>
#x != <imm>:cpx        <imm>
           :bne        <trueaddress>
           :jmp        <falseaddress>
#x == <imm>:cpx        <imm>
           :beq        <trueaddress>
           :jmp        <falseaddress>
#y != <imm>:cpy        <imm>
           :bne        <trueaddress>
           :jmp        <falseaddress>
#y == <imm>:cpy        <imm>
           :beq        <trueaddress>
           :jmp        <falseaddress>
#a != <Rb>:cmp        <Rb>
          :bne        <trueaddress>
          :jmp        <falseaddress>
#a == <Rb>:cmp        <Rb>
          :beq        <trueaddress>
          :jmp        <falseaddress>
#x != <Rb>:cpx        <Rb>
          :bne        <trueaddress>
          :jmp        <falseaddress>
#x == <Rb>:cpx        <Rb>
          :beq        <trueaddress>
          :jmp        <falseaddress>
#y != <Rb>:cpy        <Rb>
          :bne        <trueaddress>
          :jmp        <falseaddress>
#y == <Rb>:cpy        <Rb>
          :beq        <trueaddress>
          :jmp        <falseaddress>
#!=:bne        <trueaddress>
   :jmp        <falseaddress>
#==:beq        <trueaddress>
   :jmp        <falseaddress>
#zero:beq        <trueaddress>
     :jmp        <falseaddress>
#nonzero:bne        <trueaddress>
        :jmp        <falseaddress>
#carry:bcs        <trueaddress>
      :jmp        <falseaddress>
#noncarry:bcc        <trueaddress>
         :jmp        <falseaddress>
#overflow:bvs        <trueaddress>
         :jmp        <falseaddress>
#nonoverflow:bvc        <trueaddress>
            :jmp        <falseaddress>
#plus:bpl        <trueaddress>
     :jmp        <falseaddress>
#minus:bmi        <trueaddress>
      :jmp        <falseaddress>
#x ++:inx
#y ++:iny
#<Ra> ++:inc        <Ra>
#x --:dex
#y --:dey
#<Ra> --:dec        <Ra>
#x = a:tax
#y = a:tay
#x = s:tsx
#a = x:txa
#s = x:txs
#a = y:tya
#x = <imm>:ldx        <imm>
#y = <imm>:ldy        <imm>
#a = <imm>:lda        <imm>
#a = a + <imm>:adc        <imm>
#a = a - <imm>:sbc        <imm>
#a = a & <imm>:and        <imm>
#a = a | <imm>:ora        <imm>
#a = a ^ <imm>:eor        <imm>
#x = <Ra>:ldx        <Ra>
#y = <Ra>:ldy        <Ra>
#a = <Ra>:lda        <Ra>
#<Ra> = a:sta        <Ra>
#<Ra> = x:stx        <Ra>
#<Ra> = y:sty        <Ra>
#a = a + <Rb>:adc        <Rb>
#a = a - <Rb>:sbc        <Rb>
#a = a & <Rb>:and        <Rb>
#a = a | <Rb>:ora        <Rb>
#a = a ^ <Rb>:eor        <Rb>
#<Ra> = <Ra> << 1:asl        <Ra>
#<Ra> = <Ra> >> 1:lsr        <Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=pc,[,@
#b=a,x,y,s,p
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.NiosU
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> >=+ <imm>:bgeu        <Ra>,<imm>,<trueaddress>
               :jmp        <falseaddress>
#<Ra> <=+ <imm>:bleu        <Ra>,<imm>,<trueaddress>
               :jmp        <falseaddress>
#<Ra> >+ <imm>:bgtu        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:bltu        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> >= <imm>:bge        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> <= <imm>:ble        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> > <imm>:bgt        <Ra>,<imm>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> < <imm>:blt        <Ra>,<imm>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> >=+ <Rb>:bgeu        <Ra>,<Rb>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> <=+ <Rb>:bleu        <Ra>,<Rb>,<trueaddress>
              :jmp        <falseaddress>
#<Ra> >+ <Rb>:bgtu        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:bltu        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> >= <Rb>:bge        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> <= <Rb>:ble        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :jmp        <falseaddress>
#<Ra> > <Rb>:bgt        <Ra>,<Rb>,<trueaddress>
            :jmp        <falseaddress>
#<Ra> < <Rb>:blt        <Ra>,<Rb>,<trueaddress>
            :jmp        <falseaddress>
#<Ra> ++:inc        <Ra>
#<Ra> --:dec        <Ra>
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Ra>:neg        <Ra>
#<Ra> = <imm>:movi        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addi        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:subi        <Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:asri        <Ra>,<imm>
#<Ra> = <Ra> >> <imm>:lsri        <Ra>,<imm>
#<Ra> = <Ra> << <imm>:lsli        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov        <Ra>,<Rb>
                    :addi        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov        <Ra>,<Rb>
                    :subi        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov        <Ra>,<imm>
                    :and        <Ra>,<Rb>
#<Ra> = <Rb> | <imm>:mov        <Ra>,<imm>
                    :or        <Ra>,<Rb>
#<Ra> = <Rb> ^ <imm>:mov        <Ra>,<imm>
                    :eor        <Ra>,<Rb>
#<Ra> = <Rb> >>+ <imm>:mov        <Ra>,<Rb>
                      :asri        <Ra>,<imm>
#<Ra> = <Rb> >> <imm>:mov        <Ra>,<Rb>
                     :lsri        <Ra>,<imm>
#<Ra> = <Rb> << <imm>:mov        <Ra>,<Rb>
                     :lsli        <Ra>,<imm>
#<Ra> = <Rb>:mov                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:eor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:asr        <Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:lsr        <Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:lsl        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :eor        <Ra>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:mov        <Ra>,<Rb>
                     :asr        <Ra>,<Rc>
#<Ra> = <Rb> >> <Rc>:mov        <Ra>,<Rb>
                    :lsr        <Ra>,<Rc>
#<Ra> = <Rb> << <Rc>:mov        <Ra>,<Rb>
                    :lsl        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.MicroBlaze
#break:jmp                <address>
#continue:jmp        <address>
#goto        <Ra>:jmp        <Ra>
#<Ra> != 0:bnei        <Ra>,<trueaddress>
          :jmp        <falseaddress>
#<Ra> >= 0:bgei        <Ra>,<trueaddress>
          :jmp        <falseaddress>
#<Ra> <= 0:blei        <Ra>,<trueaddress>
          :jmp        <falseaddress>
#<Ra> == 0:beqi        <Ra>,<trueaddress>
          :jmp        <falseaddress>
#<Ra> > 0:bgti        <Ra>,<trueaddress>
         :jmp        <falseaddress>
#<Ra> < 0:blti        <Ra>,<trueaddress>
         :jmp        <falseaddress>
#<Ra> = <Rb> + <imm>:addi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:addi                <Ra>,<Rb>,0
#<Ra> = <Rb> + <Rc>:add        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:sub        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.PicoBlaze
#break:jump                <address>
#continue:jump        <address>
#goto        <Ra>:jump        <Ra>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :jump        nz,<trueaddress>
              :jump        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :jump        z,<trueaddress>
              :jump        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :jump        nz,<trueaddress>
             :jump        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :jump        z,<trueaddress>
             :jump        <falseaddress>
#!=:jump        nz,<trueaddress>
   :jump        <falseaddress>
#==:jump        z,<trueaddress>
   :jump        <falseaddress>
#zero:jump        z,<trueaddress>
     :jump        <falseaddress>
#nonzero:jump        nz,<trueaddress>
        :jump        <falseaddress>
#carry:jump        c,<trueaddress>
      :jump        <falseaddress>
#noncarry:jump        nc,<trueaddress>
         :jump        <falseaddress>
#<Ra> ++:add        <Ra>,1
#<Ra> --:sub        <Ra>,1
#<Ra> = <imm>:load        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or        <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor        <Ra>,<imm>
#<Ra> = <Rb> + <imm>:load        <Ra>,<Rb>
                    :add        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:load        <Ra>,<Rb>
                    :sub        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:load        <Ra>,<Rb>
                    :and        <Ra>,<imm>
#<Ra> = <Rb> | <imm>:load        <Ra>,<Rb>
                    :or        <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:load        <Ra>,<Rb>
                    :xor        <Ra>,<imm>
#<Ra> = <Rb>:load                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:load        <Ra>,<Rb>
                   :add        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:load        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:load        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:load        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:load        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#b=s0,s1,s2,s3,s4,s5,s6,s7,s8,s9,sA,sB,sC,sD,sE,sF,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.RL78
#break:br        <address>
#continue:br        <address>
#goto        <Ra>:br        <Ra>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :bh        <trueaddress>
              :jmp        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :bnh        <trueaddress>
              :jmp        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :bnz        <trueaddress>
              :br        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :bz        <trueaddress>
              :br        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :bh        <trueaddress>
             :jmp        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :bnh        <trueaddress>
             :jmp        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :bnz        <trueaddress>
             :br        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :bz        <trueaddress>
             :br        <falseaddress>
#>+:bh        <trueaddress>
   :jmp        <falseaddress>
#<+:bnh        <trueaddress>
   :jmp        <falseaddress>
#!=:bnz        <trueaddress>
   :br        <falseaddress>
#==:bz        <trueaddress>
   :br        <falseaddress>
#zero:bz        <trueaddress>
     :br        <falseaddress>
#nonzero:bnz        <trueaddress>
        :br        <falseaddress>
#carry:bc        <trueaddress>
      :br        <falseaddress>
#noncarry:bnc        <trueaddress>
         :br        <falseaddress>
#<Ra> ++:inc<size>        <Ra>
#<Ra> --:dec<size>        <Ra>
#<Ra> = <imm>:mov<size>        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add<size>        <Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub<size>        <Ra>,<imm>
#<Ra> = <Ra> & <imm>:and                <Ra>,<imm>
#<Ra> = <Ra> | <imm>:or                <Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor                <Ra>,<imm>
#<Ra> = <Rb> + <imm>:mov<size>        <Ra>,<Rb>
                    :add<size>        <Ra>,<imm>
#<Ra> = <Rb> - <imm>:mov<size>        <Ra>,<Rb>
                    :sub<size>        <Ra>,<imm>
#<Ra> = <Rb> & <imm>:mov<size>        <Ra>,<Rb>
                    :and                <Ra>,<imm>
#<Ra> = <Rb> | <imm>:mov<size>        <Ra>,<Rb>
                    :or                <Ra>,<imm>
#<Ra> = <Rb> ^ <imm>:mov<size>        <Ra>,<Rb>
                    :xor                <Ra>,<imm>
#<Ra> = <Rb>:mov<size>                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add<size>        <Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub<size>        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and                <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or                <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor                <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:mov<size>        <Ra>,<Rb>
                   :add<size>        <Ra>,<Rc>
#<Ra> = <Rb> - <Rc>:mov<size>        <Ra>,<Rb>
                   :sub<size>        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov<size>        <Ra>,<Rb>
                   :and                <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov<size>        <Ra>,<Rb>
                   :or                <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov<size>        <Ra>,<Rb>
                   :xor                <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=ax,bc,de,hl,rp0,rp1,rp2,rp3,[,@
# =a,x,b,c,d,e,h,l,r0,r1,r2,r3,r4,r5,r6,r7
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.R3000
#break:j        <address>
      :nop
#continue:j        <address>
         :nop
#goto        <Ra>:j        <Ra>
          :nop
#<Ra> >= 0:bgez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> <= 0:blez        <Ra>,<trueaddress>
          :nop
          :j        <falseaddress>
          :nop
#<Ra> > 0:bgtz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> < 0:bltz        <Ra>,<trueaddress>
         :nop
         :j        <falseaddress>
         :nop
#<Ra> != <imm>:bne        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> == <imm>:beq        <Ra>,<imm>,<trueaddress>
              :nop
              :j        <falseaddress>
              :nop
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :nop
             :j        <falseaddress>
             :nop
#<Ra> ++:addiu        <Ra>,<Ra>,$0001
#<Ra> --:addiu        <Ra>,<Ra>,$ffff
#<Ra> = - <Ra>:negu        <Ra>,<Ra>
#<Ra> = <imm>:li        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:addiu        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:andi        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:ori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xori        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:addiu        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:andi        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:ori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xori        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:sra        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:srl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:sll        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:move        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:addu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:subu        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:srav        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srlv        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sllv        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:addu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:subu        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:or        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:xor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:srav        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:srlv        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:sllv        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
# =zero,at,v0,v1,a0,a1,a2,a3,t0,t1,t2,t3,t4,t5,t6,t7,s0,s1,s2,s3,s4,s5,s6,s7,t8,t9,k0,k1,gp,sp,s8,fp,ra,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.RH850
#break:br        <address>
#continue:br        <address>
#goto        <Ra>:br        <Ra>
#<Ra> >=+ <imm>:cmp        <imm>,<Ra>
               :bl        <trueaddress>
               :br        <falseaddress>
#<Ra> <=+ <imm>:cmp        <imm>,<Ra>
               :bnh        <trueaddress>
               :br        <falseaddress>
#<Ra> >+ <imm>:cmp        <imm>,<Ra>
              :bh        <trueaddress>
              :br        <falseaddress>
#<Ra> <+ <imm>:cmp        <imm>,<Ra>
              :bnl        <trueaddress>
              :br        <falseaddress>
#<Ra> != <imm>:cmp        <imm>,<Ra>
              :bnz        <trueaddress>
              :br        <falseaddress>
#<Ra> >= <imm>:cmp        <imm>,<Ra>
              :bge        <trueaddress>
              :br        <falseaddress>
#<Ra> <= <imm>:cmp        <imm>,<Ra>
              :ble        <trueaddress>
              :br        <falseaddress>
#<Ra> == <imm>:cmp        <imm>,<Ra>
              :bz        <trueaddress>
              :br        <falseaddress>
#<Ra> > <imm>:cmp        <imm>,<Ra>
             :bgt        <trueaddress>
             :br        <falseaddress>
#<Ra> < <imm>:cmp        <imm>,<Ra>
             :blt        <trueaddress>
             :br        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Rb>,<Ra>
              :bl        <trueaddress>
              :br        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Rb>,<Ra>
              :bnh        <trueaddress>
              :br        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Rb>,<Ra>
             :bh        <trueaddress>
             :br        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Rb>,<Ra>
             :bnl        <trueaddress>
             :br        <falseaddress>
#<Ra> != <Rb>:cmp        <Rb>,<Ra>
             :bnz        <trueaddress>
             :br        <falseaddress>
#<Ra> >= <Rb>:cmp        <Rb>,<Ra>
             :bge        <trueaddress>
             :br        <falseaddress>
#<Ra> <= <Rb>:cmp        <Rb>,<Ra>
             :ble        <trueaddress>
             :br        <falseaddress>
#<Ra> == <Rb>:cmp        <Rb>,<Ra>
             :bz        <trueaddress>
             :br        <falseaddress>
#<Ra> > <Rb>:cmp        <Rb>,<Ra>
            :bgt        <trueaddress>
            :br        <falseaddress>
#<Ra> < <Rb>:cmp        <Rb>,<Ra>
            :blt        <trueaddress>
            :br        <falseaddress>
#>=+:bl        <trueaddress>
    :br        <falseaddress>
#<=+:bnh        <trueaddress>
    :br        <falseaddress>
#>+:bh        <trueaddress>
   :br        <falseaddress>
#<+:bnl        <trueaddress>
   :br        <falseaddress>
#!=:bnz        <trueaddress>
   :br        <falseaddress>
#>=:bge        <trueaddress>
   :br        <falseaddress>
#<=:ble        <trueaddress>
   :br        <falseaddress>
#==:bz        <trueaddress>
   :br        <falseaddress>
#>:bgt        <trueaddress>
  :br        <falseaddress>
#<:blt        <trueaddress>
  :br        <falseaddress>
#zero:bz        <trueaddress>
     :br        <falseaddress>
#nonzero:bnz        <trueaddress>
        :br        <falseaddress>
#carry:bc        <trueaddress>
      :br        <falseaddress>
#noncarry:bnc        <trueaddress>
         :br        <falseaddress>
#overflow:bv        <trueaddress>
         :br        <falseaddress>
#nonoverflow:bnv        <trueaddress>
            :br        <falseaddress>
#sign:bn        <trueaddress>
     :br        <falseaddress>
#nonsign:bp        <trueaddress>
        :br        <falseaddress>
#<Ra> ++:add        1,<Ra>
#<Ra> --:sub        1,<Ra>
#<Ra> = ~ <Rb>:not        <Rb>,<Ra>
#<Ra> = - <Rb>:neg        <Rb>,<Ra>
#<Ra> = <imm>:mov        <imm>,<Ra>
#<Ra> = <Ra> + <imm>:addi        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> & <imm>:andi        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> | <imm>:ori        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> ^ <imm>:xori        <imm>,<Ra>,<Ra>
#<Ra> = <Ra> >>+ <imm>:sar        <imm>,<Ra>
#<Ra> = <Ra> >> <imm>:shr        <imm>,<Ra>
#<Ra> = <Ra> << <imm>:shl        <imm>,<Ra>
#<Ra> = <Rb> + <imm>:addi        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> & <imm>:andi        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> | <imm>:ori        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> ^ <imm>:xori        <imm>,<Rb>,<Ra>
#<Ra> = <Rb> >>+ <imm>:mov        <Rb>,<Ra>
                      :sar        <imm>,<Ra>
#<Ra> = <Rb> >> <imm>:mov        <Rb>,<Ra>
                     :shr        <imm>,<Ra>
#<Ra> = <Rb> << <imm>:mov        <Rb>,<Ra>
                     :shl        <imm>,<Ra>
#<Ra> = <Rb>:mov                <Rb>,<Ra>
#<Ra> = <Ra> + <Rb>:add        <Rb>,<Ra>
#<Ra> = <Ra> - <Rb>:sub        <Rb>,<Ra>
#<Ra> = <Ra> & <Rb>:and        <Rb>,<Ra>
#<Ra> = <Ra> | <Rb>:or        <Rb>,<Ra>
#<Ra> = <Ra> ^ <Rb>:xor        <Rb>,<Ra>
#<Ra> = <Ra> >>+ <Rb>:sar        <Rb>,<Ra>
#<Ra> = <Ra> >> <Rb>:shr        <Rb>,<Ra>
#<Ra> = <Ra> << <Rb>:shl        <Rb>,<Ra>
#<Ra> = <Rb> + <Rc>:mov        <Rb>,<Ra>
                   :add        <Rc>,<Ra>
#<Ra> = <Rb> - <Rc>:mov        <Rb>,<Ra>
                   :sub        <Rc>,<Ra>
#<Ra> = <Rb> & <Rc>:mov        <Rb>,<Ra>
                   :and        <Rc>,<Ra>
#<Ra> = <Rb> | <Rc>:mov        <Rb>,<Ra>
                   :or        <Rc>,<Ra>
#<Ra> = <Rb> ^ <Rc>:mov        <Rb>,<Ra>
                   :xor        <Rc>,<Ra>
#<Ra> = <Rb> >>+ <Rc>:mov        <Rb>,<Ra>
                     :sar        <Rc>,<Ra>
#<Ra> = <Rb> >> <Rc>:mov        <Rb>,<Ra>
                    :shr        <Rc>,<Ra>
#<Ra> = <Rb> << <Rc>:mov        <Rb>,<Ra>
                    :shl        <Rc>,<Ra>
#<Ra> = sbyte <Rb>:ld.b        <Rb>,<Ra>
#<Ra> = byte <Rb>:ld.bu        <Rb>,<Ra>
#<Ra> = sword <Rb>:ld.h        <Rb>,<Ra>
#<Ra> = word <Rb>:ld.hu        <Rb>,<Ra>
#<Ra> = dword <Rb>:ld.w        <Rb>,<Ra>
#<Ra> = qword <Rb>:ld.dw        <Rb>,<Ra>
#byte <Ra> = <Rb>:st.b        <Rb>,<Ra>
#word <Ra> = <Rb>:st.h        <Rb>,<Ra>
#dword <Ra> = <Rb>:st.w        <Rb>,<Ra>
#qword <Ra> = <Rb>:st.dw        <Rb>,<Ra>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30,r31,pc,sp,gp,tp,ep,lp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.RZ
#break:b        <address>
#continue:b        <address>
#goto        <Ra>:b        <Ra>
#<Ra> >=+ <imm>:cmp        <Ra>,<imm>
               :bcs        <trueaddress>
               :b        <falseaddress>
#<Ra> <=+ <imm>:cmp        <Ra>,<imm>
               :bls        <trueaddress>
               :b        <falseaddress>
#<Ra> >+ <imm>:cmp        <Ra>,<imm>
              :bhi        <trueaddress>
              :b        <falseaddress>
#<Ra> <+ <imm>:cmp        <Ra>,<imm>
              :bcc        <trueaddress>
              :b        <falseaddress>
#<Ra> != <imm>:cmp        <Ra>,<imm>
              :bne        <trueaddress>
              :b        <falseaddress>
#<Ra> >= <imm>:cmp        <Ra>,<imm>
              :bge        <trueaddress>
              :b        <falseaddress>
#<Ra> <= <imm>:cmp        <Ra>,<imm>
              :ble        <trueaddress>
              :b        <falseaddress>
#<Ra> == <imm>:cmp        <Ra>,<imm>
              :beq        <trueaddress>
              :b        <falseaddress>
#<Ra> > <imm>:cmp        <Ra>,<imm>
             :bgt        <trueaddress>
             :b        <falseaddress>
#<Ra> < <imm>:cmp        <Ra>,<imm>
             :blt        <trueaddress>
             :b        <falseaddress>
#<Ra> >=+ <Rb>:cmp        <Ra>,<Rb>
              :bcs        <trueaddress>
              :b        <falseaddress>
#<Ra> <=+ <Rb>:cmp        <Ra>,<Rb>
              :bls        <trueaddress>
              :b        <falseaddress>
#<Ra> >+ <Rb>:cmp        <Ra>,<Rb>
             :bhi        <trueaddress>
             :b        <falseaddress>
#<Ra> <+ <Rb>:cmp        <Ra>,<Rb>
             :bcc        <trueaddress>
             :b        <falseaddress>
#<Ra> != <Rb>:cmp        <Ra>,<Rb>
             :bne        <trueaddress>
             :b        <falseaddress>
#<Ra> >= <Rb>:cmp        <Ra>,<Rb>
             :bge        <trueaddress>
             :b        <falseaddress>
#<Ra> <= <Rb>:cmp        <Ra>,<Rb>
             :ble        <trueaddress>
             :b        <falseaddress>
#<Ra> == <Rb>:cmp        <Ra>,<Rb>
             :beq        <trueaddress>
             :b        <falseaddress>
#<Ra> > <Rb>:cmp        <Ra>,<Rb>
            :bgt        <trueaddress>
            :b        <falseaddress>
#<Ra> < <Rb>:cmp        <Ra>,<Rb>
            :blt        <trueaddress>
            :b        <falseaddress>
#>=+:bcs        <trueaddress>
    :b        <falseaddress>
#<=+:bls        <trueaddress>
    :b        <falseaddress>
#>+:bhi        <trueaddress>
   :b        <falseaddress>
#<+:bcc        <trueaddress>
   :b        <falseaddress>
#!=:bne        <trueaddress>
   :b        <falseaddress>
#>=:bge        <trueaddress>
   :b        <falseaddress>
#<=:ble        <trueaddress>
   :b        <falseaddress>
#==:beq        <trueaddress>
   :b        <falseaddress>
#>:bgt        <trueaddress>
  :b        <falseaddress>
#<:blt        <trueaddress>
  :b        <falseaddress>
#zero:beq        <trueaddress>
     :b        <falseaddress>
#nonzero:bne        <trueaddress>
        :b        <falseaddress>
#overflow:bvs        <trueaddress>
         :b        <falseaddress>
#nonoverflow:bvc        <trueaddress>
            :b        <falseaddress>
#plus:bpl        <trueaddress>
     :b        <falseaddress>
#minus:bmi        <trueaddress>
      :b        <falseaddress>
#<Ra> ++:add        <Ra>,<Ra>,#1
#<Ra> --:sub        <Ra>,<Ra>,#1
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> - <imm>:sub        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:and        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:orr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:eor        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:asr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >> <imm>:lsr        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> << <imm>:lsl        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:add        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> - <imm>:sub        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:and        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:orr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:eor        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:asr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >> <imm>:lsr        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> << <imm>:lsl        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:mov        <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:orr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:eor        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:asr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:lsr        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:lsl        <Ra>,<Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:sub        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> & <Rc>:and        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> | <Rc>:orr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> ^ <Rc>:eor        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:asr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> >> <Rc>:lsr        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> << <Rc>:lsl        <Ra>,<Rb>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#l=r0,r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,a1,a2,a3,a4,v1,v2,v3,v4,v5,v6,v7,v8,ip,sp,lr,pc,wr,sb,sl,fp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,$,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
#file=asm
.Visconti4
#break:bra                <address>
#continue:bra        <address>
#goto        <Ra>:bra        <Ra>
#<Ra> != 0:bnez        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> == 0:beqz        <Ra>,<trueaddress>
          :bra        <falseaddress>
#<Ra> != <imm>:bnei        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> >= <imm>:bgei        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> == <imm>:beqi        <Ra>,<imm>,<trueaddress>
              :bra        <falseaddress>
#<Ra> < <imm>:blti        <Ra>,<imm>,<trueaddress>
             :bra        <falseaddress>
#<Ra> != <Rb>:bne        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> >= <Rb>:bge        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> == <Rb>:beq        <Ra>,<Rb>,<trueaddress>
             :bra        <falseaddress>
#<Ra> < <Rb>:blt        <Ra>,<Rb>,<trueaddress>
            :bra        <falseaddress>
#<Ra> ++:add3        <Ra>,<Ra>,0x0001
#<Ra> --:add3        <Ra>,<Ra>,0xffff
#<Ra> = ~ <Ra>:not        <Ra>
#<Ra> = - <Rb>:neg        <Ra>,<Rb>
#<Ra> = <imm>:mov        <Ra>,<imm>
#<Ra> = <Ra> + <imm>:add3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> & <imm>:and3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> | <imm>:or3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> ^ <imm>:xor3        <Ra>,<Ra>,<imm>
#<Ra> = <Ra> >>+ <imm>:sra        <Ra>,<imm>
#<Ra> = <Ra> >> <imm>:srl        <Ra>,<imm>
#<Ra> = <Ra> << <imm>:sll3        <Ra>,<Ra>,<imm>
#<Ra> = <Rb> + <imm>:add3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> & <imm>:and3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> | <imm>:or3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> ^ <imm>:xor3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb> >>+ <imm>:mov        <Ra>,<Rb>
                      :sra        <Ra>,<imm>
#<Ra> = <Rb> >> <imm>:mov        <Ra>,<Rb>
                     :srl        <Ra>,<imm>
#<Ra> = <Rb> << <imm>:sll3        <Ra>,<Rb>,<imm>
#<Ra> = <Rb>:mov                <Ra>,<Rb>
#<Ra> = <Ra> + <Rb>:add3        <Ra>,<Ra>,<Rb>
#<Ra> = <Ra> - <Rb>:sub        <Ra>,<Rb>
#<Ra> = <Ra> & <Rb>:and        <Ra>,<Rb>
#<Ra> = <Ra> | <Rb>:or        <Ra>,<Rb>
#<Ra> = <Ra> ^ <Rb>:xor        <Ra>,<Rb>
#<Ra> = <Ra> >>+ <Rb>:sra        <Ra>,<Rb>
#<Ra> = <Ra> >> <Rb>:srl        <Ra>,<Rb>
#<Ra> = <Ra> << <Rb>:sll        <Ra>,<Rb>
#<Ra> = <Rb> + <Rc>:add3        <Ra>,<Rb>,<Rc>
#<Ra> = <Rb> - <Rc>:mov        <Ra>,<Rb>
                   :sub        <Ra>,<Rc>
#<Ra> = <Rb> & <Rc>:mov        <Ra>,<Rb>
                   :and        <Ra>,<Rc>
#<Ra> = <Rb> | <Rc>:mov        <Ra>,<Rb>
                   :or        <Ra>,<Rc>
#<Ra> = <Rb> ^ <Rc>:mov        <Ra>,<Rb>
                   :xor        <Ra>,<Rc>
#<Ra> = <Rb> >>+ <Rc>:mov        <Ra>,<Rb>
                     :sra        <Ra>,<Rc>
#<Ra> = <Rb> >> <Rc>:mov        <Ra>,<Rb>
                    :srl        <Ra>,<Rc>
#<Ra> = <Rb> << <Rc>:mov        <Ra>,<Rb>
                    :sll        <Ra>,<Rc>
#WX^ElExEgq̎ʐݒ(\)(Rɒǉł܂B)
#w=$0,$1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$tp,$sp,[,@
#imm=0,1,2,3,4,5,6,7,8,9,+,-,#,',"
#keyword=
#keywordend=
#user=
#user1=
#user2=
#user3=
#user4=
#user5=
#user6=
#user7=
#user8=
#user9=
#user10=
#labelhead=
#labelend=:
