//replace restart {
//        pop  %1
//        push %1
//} by {
//        ; Peephole 1     removed pop %1 push %1 (not push pop)
//}

//replace restart {
//        pop  %1
//        mov  %2,%3
//        push %1
//} by {
//        ; Peephole 2     removed pop %1 push %1 (not push pop)
//        mov  %2,%3
//}

//
// added by Jean Louis VERN for
// his shift stuff
replace restart {
        xch  a,%1
        xch  a,%1
} by {
        ; Peephole 2.a   removed redundant xch xch
}

replace restart {
// saving 2 byte
        mov  %1,#0x00
        mov  a,#0x00
} by {
        ; Peephole 3.a   changed mov to clr
        clr  a
        mov  %1,a
}

replace restart {
// saving 1 byte
        mov  %1,#0x00
        clr  a
} by {
        ; Peephole 3.b   changed mov to clr
        clr  a
        mov  %1,a
}

replace restart {
// saving 1 byte, loosing 1 cycle but maybe allowing peephole 3.b to start
        mov  %1,#0x00
        mov  %2,#0x00
        mov  a,%3
} by {
        ; Peephole 3.c   changed mov to clr
        clr  a
        mov  %1,a
        mov  %2,a
        mov  a,%3
}

replace restart {
	mov	a,#0
} by {
        ; Peephole 3.d   changed mov to clr
	clr	a
}

replace {
        mov  %1,a
        mov  dptr,#%2
        mov  a,%1
        movx @dptr,a
} by {
        ; Peephole 100   removed redundant mov
        mov  %1,a
        mov  dptr,#%2
        movx @dptr,a
}

replace {
	mov  a,acc
} by {
	;  Peephole 100.a   removed redundant mov
}

replace {
        mov  a,%1
        movx @dptr,a
        inc  dptr
        mov  a,%1
        movx @dptr,a
} by {
        ; Peephole 101   removed redundant mov
        mov  a,%1
        movx @dptr,a
        inc  dptr
        movx @dptr,a
}

replace {
        mov  %1,%2
        ljmp %3
%4:
        mov  %1,%5
%3:
        mov  dpl,%1
%7:
        mov  sp,bp
        pop  bp
} by {
        ; Peephole 102   removed redundant mov
        mov  dpl,%2
        ljmp %3
%4:
        mov  dpl,%5
%3:
%7:
        mov  sp,bp
        pop  bp
}

replace {
        mov  %1,%2
        ljmp %3
%4:
        mov  a%1,%5
%3:
        mov  dpl,%1
%7:
        mov  sp,bp
        pop  bp
} by {
        ; Peephole 103   removed redundant mov
        mov  dpl,%2
        ljmp %3
%4:
        mov  dpl,%5
%3:
%7:
        mov  sp,bp
        pop  bp
}

replace {
        mov  a,bp
        clr  c
        add  a,#0x01
        mov  r%1,a
} by {
        ; Peephole 104   optimized increment (acc not set to r%1, flags undefined)
        mov  r%1,bp
        inc  r%1
}

replace {
        mov  %1,a
        mov  a,%1
} by {
        ; Peephole 105   removed redundant mov
        mov  %1,a
}

replace {
        mov  %1,a
        clr  c
        mov  a,%1
} by {
        ; Peephole 106   removed redundant mov
        mov  %1,a
        clr  c
}

replace {
        ljmp %1
%1:
} by {
        ; Peephole 107   removed redundant ljmp
%1:
}

replace {
        jc   %1
        ljmp %5
%1:
} by {
        ; Peephole 108   removed ljmp by inverse jump logic
        jnc  %5
%1:
} if labelInRange(%5)

replace {
        jz   %1
        ljmp %5
%1:
} by {
        ; Peephole 109   removed ljmp by inverse jump logic
        jnz  %5
%1:
} if labelInRange(%5)

replace {
        jnz  %1
        ljmp %5
%1:
} by {
        ; Peephole 110   removed ljmp by inverse jump logic
        jz  %5
%1:
} if labelInRange(%5)

replace {
        jb   %1,%2
        ljmp %5
%2:
} by {
        ; Peephole 111   removed ljmp by inverse jump logic
        jnb  %1,%5
%2:
} if labelInRange(%5)

replace {
        jnb  %1,%2
        ljmp %5
%2:
} by {
       ; Peephole 112   removed ljmp by inverse jump logic
        jb   %1,%5
%2:
} if labelInRange(%5)

replace {
        ljmp %5
%1:
} by {
        ; Peephole 132   changed ljmp to sjmp
        sjmp %5
%1:
} if labelInRange(%5)


replace {
        clr  a
        cjne %1,%2,%3
        cpl  a
%3:
        rrc  a
        mov  %4,c
} by {
        ; Peephole 113   optimized misc sequence
        clr  %4
        cjne %1,%2,%3
        setb %4
%3:
} if labelRefCount %3 1

replace {
        clr  a
        cjne %1,%2,%3
        cjne %10,%11,%3
        cpl  a
%3:
        rrc  a
        mov  %4,c
} by {
        ; Peephole 114   optimized misc sequence
        clr  %4
        cjne %1,%2,%3
        cjne %10,%11,%3
        setb %4
%3:
} if labelRefCount %3 2

replace {
        clr  a
        cjne %1,%2,%3
        cpl  a
%3:
        jnz  %4
} by {
        ; Peephole 115   jump optimization
        cjne %1,%2,%3
        sjmp %4
%3:
} if labelRefCount %3 1

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cpl  a
%3:
        jnz  %4
} by {
        ; Peephole 116   jump optimization
        cjne %1,%2,%3
        cjne %9,%10,%3
        sjmp %4
%3:
} if labelRefCount %3 2

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        cpl  a
%3:
        jnz %4
} by {
        ; Peephole 117   jump optimization
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        sjmp %4
%3:
} if labelRefCount %3 3

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        cjne %13,%14,%3
        cpl  a
%3:
        jnz %4
} by {
        ; Peephole 118   jump optimization
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        cjne %13,%14,%3
        sjmp %4
%3:
} if labelRefCount %3 4

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        clr  a
%3:
        jnz  %4
} by {
        ; Peephole 119   jump optimization
        cjne %1,%2,%4
%3:
} if labelRefCount %3 1

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        clr  a
%3:
        jnz  %4
} by {
        ; Peephole 120   jump optimization
        cjne %1,%2,%4
        cjne %10,%11,%4
%3:
} if labelRefCount %3 2

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        clr  a
%3:
        jnz  %4
} by {
        ; Peephole 121   jump optimization
        cjne %1,%2,%4
        cjne %10,%11,%4
        cjne %12,%13,%4
%3:
} if labelRefCount %3 3

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        cjne %14,%15,%3
        clr  a
%3:
        jnz  %4
} by {
        ; Peephole 122   jump optimization
        cjne %1,%2,%4
        cjne %10,%11,%4
        cjne %12,%13,%4
        cjne %14,%15,%4
%3:
} if labelRefCount %3 4

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        clr  a
%3:
        jz   %4
} by {
        ; Peephole 123   jump optimization
        cjne %1,%2,%3
        smp  %4
%3:
} if labelRefCount %3 1

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        clr  a
%3:
        jz   %4
} by {
        ; Peephole 124   jump optimization
        cjne %1,%2,%3
        cjne %10,%11,%3
        sjmp  %4
%3:
} if labelRefCount %3 2

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        clr  a
%3:
        jz   %4
} by {
        ; Peephole 125   jump optimization
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        sjmp %4
%3:
} if labelRefCount %3 3

replace {
        mov  a,#0x01
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        cjne %14,%15,%3
        clr  a
%3:
        jz   %4
} by {
        ; Peephole 126   jump optimization
        cjne %1,%2,%3
        cjne %10,%11,%3
        cjne %12,%13,%3
        cjne %14,%15,%3
        sjmp %4
%3:
} if labelRefCount %3 4

replace {
        push psw
        mov  psw,%1
        push bp
        mov  bp,%2
%3:
        mov  %2,bp
        pop  bp
        pop  psw
        ret
} by {
        ; Peephole 127   removed misc sequence
        ret
} if labelRefCount %3 0

replace {
        clr  a
        rlc  a
        jz   %1
} by {
        ; Peephole 128   jump optimization
        jnc  %1
}

replace {
        clr  a
        rlc  a
        jnz  %1
} by {
        ; Peephole 129   jump optimization
        jc   %1
}

replace {
        mov  r%1,@r%2
} by {
        ; Peephole 130   changed target address mode r%1 to ar%1
        mov  ar%1,@r%2
}

replace {
        mov  a,%1
        subb a,#0x01
        mov  %2,a
        mov  %1,%2
} by {
        ; Peephole 131   optimized decrement (not caring for c)
        dec  %1
        mov  %2,%1
}

replace {
        mov  r%1,%2
        mov  ar%3,@r%1
        inc  r%3
        mov  r%4,%2
        mov  @r%4,ar%3
} by {
        ; Peephole 133   removed redundant moves
        mov  r%1,%2
        inc  @r%1
        mov  ar%3,@r%1
}

replace {
        mov  r%1,%2
        mov  ar%3,@r%1
        dec  r%3
        mov  r%4,%2
        mov  @r%4,ar%3
} by {
        ; Peephole 134   removed redundant moves
        mov  r%1,%2
        dec  @r%1
        mov  ar%3,@r%1
}

replace {
        mov  r%1,a
        mov  a,r%2
        orl  a,r%1
} by {
        ; Peephole 135   removed redundant mov
        mov  r%1,a
        orl  a,r%2
}

replace {
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
	mov  dpx,%4
        mov  a,%1
} by {
        ; Peephole 136a   removed redundant moves
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
	mov  dpx,%4
} if 24bitMode

replace {
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
        mov  a,%1
} by {
        ; Peephole 136   removed redundant moves
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
}

// WTF? Doesn't look sensible to me...
//replace {
//        mov  b,#0x00
//        mov  a,%1
//        cjne %2,%3,%4
//        mov  b,#0x01
//%4:
//        mov  a,b
//        jz   %5
//} by {
//        ; Peephole 137   optimized misc jump sequence
//        mov  a,%1
//        cjne %2,%3,%5
//%4:
//} if labelRefCount %4 1
//
//replace {
//        mov  b,#0x00
//        mov  a,%1
//        cjne %2,%3,%4
//        mov  b,#0x01
//%4:
//        mov  a,b
//        jnz  %5
//} by {
//        ; Peephole 138   optimized misc jump sequence
//        mov  a,%1
//        cjne %2,%3,%4
//        sjmp %5
//%4:
//} if labelRefCount %4 1

replace {
        mov  r%1,a
        anl  ar%1,%2
        mov  a,r%1
} by {
        ; Peephole 139   removed redundant mov
        anl  a,%2
        mov  r%1,a
}

replace {
        mov  r%1,a
        orl  ar%1,%2
        mov  a,r%1
} by {
        ; Peephole 140   removed redundant mov
        orl  a,%2
        mov  r%1,a }

replace {
        mov  r%1,a
        xrl  ar%1,%2
        mov  a,r%1
} by {
        ; Peephole 141   removed redundant mov
        xrl  a,%2
        mov  r%1,a
}

replace {
        mov  r%1,a
        mov  r%2,ar%1
        mov  ar%1,@r%2
} by {
        ; Peephole 142   removed redundant moves
        mov  r%2,a
        mov  ar%1,@r%2
}

replace {
        rlc  a
        mov  acc.0,c
} by {
        ; Peephole 143   converted rlc to rl
        rl   a
}

replace {
        rrc  a
        mov  acc.7,c
} by {
        ; Peephole 144   converted rrc to rc
        rr   a
}

replace {
        clr  c
        addc a,%1
} by {
        ; Peephole 145   changed to add without carry
        add  a,%1
}

replace {
        clr  c
        mov  a,%1
        addc a,%2
} by {
        ; Peephole 146   changed to add without carry
        mov  a,%1
        add  a,%2
}

replace {
        orl  r%1,a
} by {
        ; Peephole 147   changed target address mode r%1 to ar%1
        orl  ar%1,a
}

replace {
        anl  r%1,a
} by {
        ; Peephole 148   changed target address mode r%1 to ar%1
        anl  ar%1,a
}

replace {
        xrl  r%1,a
} by {
        ; Peephole 149   changed target address mode r%1 to ar%1
        xrl  ar%1,a
}

replace {
        mov  %1,dpl
        mov  dpl,%1
%9:
        ret
} by {
        ; Peephole 150   removed misc moves via dpl before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  dpl,%1
        mov  dph,%2
%9:
        ret
} by {
        ; Peephole 151   removed misc moves via dph, dpl before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  dpl,%1
%9:
        ret
} by {
        ; Peephole 152   removed misc moves via dph, dpl before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  dpl,%1
        mov  dph,%2
        mov  b,%3
%9:
        ret
} by {
        ; Peephole 153   removed misc moves via dph, dpl, b before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  dpl,%1
%9:
        ret
} by {
        ; Peephole 154   removed misc moves via dph, dpl, b before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  dpl,%1
        mov  dph,%2
%9:
        ret
} by {
        ; Peephole 155   removed misc moves via dph, dpl, b before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  %4,a
        mov  dpl,%1
        mov  dph,%2
        mov  b,%3
        mov  a,%4
%9:
        ret
} by {
        ; Peephole 156   removed misc moves via dph, dpl, b, a before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  %4,a
        mov  dpl,%1
        mov  dph,%2
%9:
        ret
} by {
        ; Peephole 157   removed misc moves via dph, dpl, b, a before return
%9:
        ret
}

replace {
        mov  %1,dpl
        mov  %2,dph
        mov  %3,b
        mov  %4,a
        mov  dpl,%1
%9:
        ret } by {
        ; Peephole 158   removed misc moves via dph, dpl, b, a before return
%9:
        ret }

replace {
        mov  %1,#%2
        xrl  %1,#0x80
} by {
        ; Peephole 159   avoided xrl during execution
        mov  %1,#(%2 ^ 0x80)
}

replace {
        jnc  %1
        sjmp %2
%1:
} by {
        ; Peephole 160   removed sjmp by inverse jump logic
        jc   %2
%1:}

replace {
        jc   %1
        sjmp %2
%1:
} by {
        ; Peephole 161   removed sjmp by inverse jump logic
        jnc  %2
%1:}

replace {
        jnz  %1
        sjmp %2
%1:
} by {
        ; Peephole 162   removed sjmp by inverse jump logic
        jz   %2
%1:}

replace {
        jz   %1
        sjmp %2
%1:
} by {
        ; Peephole 163   removed sjmp by inverse jump logic
        jnz  %2
%1:}

replace {
        jnb  %3,%1
        sjmp %2
%1:
} by {
        ; Peephole 164   removed sjmp by inverse jump logic
        jb   %3,%2
%1:
}

replace {
        jb   %3,%1
        sjmp %2
%1:
} by {
        ; Peephole 165   removed sjmp by inverse jump logic
        jnb  %3,%2
%1:
}

replace {
        mov  %1,%2
        mov  %3,%1
        mov  %2,%1
} by {
        ; Peephole 166   removed redundant mov
        mov  %1,%2
        mov  %3,%1 }

replace {
        mov  c,%1
        cpl  c
        mov  %1,c
} by {
        ; Peephole 167   removed redundant bit moves (c not set to %1)
        cpl  %1 }

replace {
        jnb  %1,%2
        sjmp %3
%2:} by {
        ; Peephole 168   jump optimization
        jb   %1,%3
%2:}

replace {
        jb   %1,%2
        sjmp %3
%2:} by {
        ; Peephole 169   jump optimization
        jnb  %1,%3
%2:}

replace {
        clr  a
        cjne %1,%2,%3
        cpl  a
%3:
        jz   %4
} by {
        ; Peephole 170   jump optimization
        cjne %1,%2,%4
%3:
} if labelRefCount %3 1

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cpl  a
%3:
        jz   %4
} by {
        ; Peephole 171   jump optimization
        cjne %1,%2,%4
        cjne %9,%10,%4
%3:
} if labelRefCount %3 2

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        cpl  a
%3:
        jz   %4
} by {
        ; Peephole 172   jump optimization
        cjne %1,%2,%4
        cjne %9,%10,%4
        cjne %11,%12,%4
%3:
} if labelRefCount %3 3

replace {
        clr  a
        cjne %1,%2,%3
        cjne %9,%10,%3
        cjne %11,%12,%3
        cjne %13,%14,%3
        cpl  a
%3:
        jz   %4
} by {
        ; Peephole 173   jump optimization
        cjne %1,%2,%4
        cjne %9,%10,%4
        cjne %11,%12,%4
        cjne %13,%14,%4
%3:
} if labelRefCount %3 4

replace {
        mov  r%1,%2
        clr  c
        mov  a,r%1
        subb a,#0x01
        mov  %2,a
} by {
        ; Peephole 174   optimized decrement (acc not set to %2, flags undefined)
        mov  r%1,%2
        dec  %2
}


replace {
        mov  r%1,%2
        mov  a,r%1
        add  a,#0x01
        mov  %2,a
} by {
        ; Peephole 175   optimized increment (acc not set to %2, flags undefined)
        mov  r%1,%2
        inc  %2
}

replace {
        mov  %1,@r%2
        inc  %1
        mov  @r%2,%1
} by {
        ; Peephole 176   optimized increment, removed redundant mov
        inc  @r%2
        mov  %1,@r%2
}

// this one will screw assignes to volatile/sfr's
//replace {
//        mov  %1,%2
//        mov  %2,%1
//} by {
//        ; Peephole 177   removed redundant mov
//        mov  %1,%2
//}

replace {
        mov  a,%1
        mov  b,a
        mov  a,%2
} by {
        ; Peephole 178   removed redundant mov
        mov  b,%1
        mov  a,%2
}

// rules 179-182 provided by : Frieder <fe@lake.iup.uni-heidelberg.de>
// saving 2 byte, 1 cycle
replace {
        mov  b,#0x00
        mov  a,#0x00
} by {
        ; Peephole 179   changed mov to clr
        clr  a
        mov  b,a
}

// saving 1 byte, 0 cycles
replace {
        mov  a,#0x00
} by {
        ; Peephole 180   changed mov to clr
        clr  a
}

replace {
        mov  dpl,#0x00
        mov  dph,#0x00
 	mov  dpx,#0x00
} by {
        ; Peephole 181a   used 24 bit load of dptr
        mov  dptr,#0x0000
} if 24bitMode

// saving 3 byte, 2 cycles, return(NULL) profits here
replace {
        mov  dpl,#0x00
        mov  dph,#0x00
} by {
        ; Peephole 181   used 16 bit load of dptr
        mov  dptr,#0x0000
}

replace {
	mov dpl,#%1
	mov dph,#(%1 >> 8)
	mov dpx,#(%1 >> 16)
} by {
	; Peephole 182b used 24 bit load of DPTR
	mov dptr,#%1
}

// saves 2 bytes, ?? cycles.
replace {
        mov  dpl,#0x%1
        mov  dph,#0x%2
	mov  dpx,#0x%3
} by {
        ; Peephole 182a   used 24 bit load of dptr
        mov	dptr,#0x%3%2%1
} if 24bitMode(), isPort('ds390' 'ds400')

// saves 2 bytes, ?? cycles.
replace {
        mov  dpl,#%1
        mov  dph,#%2
	mov  dpx,#%3
} by {
        ; Peephole 182b   used 24 bit load of dptr
        mov  dptr,#((%3 << 16) + (%2 << 8) + %1)
} if 24bitMode(), isPort('ds390' 'ds400')

// saving 3 byte, 2 cycles, return(float_constant) profits here
replace {
        mov  dpl,#0x%1
        mov  dph,#0x%2
} by {
        ; Peephole 182c   used 16 bit load of dptr
        mov  dptr,#0x%2%1
}

// saving 3 byte, 2 cycles, return(float_constant) profits here
replace {
        mov  dpl,#%1
        mov  dph,#%2
} by {
        ; Peephole 182   used 16 bit load of dptr
        mov  dptr,#(((%2)<<8) + %1)
}

replace {
        anl  %1,#%2
        anl  %1,#%3
} by {
        ; Peephole 183   avoided anl during execution
        anl  %1,#(%2 & %3)
}

replace {
        mov  %1,a
        cpl  a
        mov  %1,a
} by {
        ; Peephole 184   removed redundant mov
        cpl  a
        mov  %1,a
}

replace {
// acc being incremented might cause problems
        mov  %1,a
        inc  %1
} by {
        ; Peephole 185   changed order of increment (acc incremented also!)
        inc  a
        mov  %1,a
}

// char indexed access to: long code table[] = {4,3,2,1};
replace restart {
	add  a,#%1
	mov  dpl,a
	clr  a
	addc a,#(%1 >> 8)
	mov  dph,a
	clr  a
	movc a,@a+dptr
	mov  %2,a
	inc  dptr
	clr  a
	movc a,@a+dptr
	mov  %3,a
	inc  dptr
	clr  a
	movc a,@a+dptr
	mov  %4,a
	inc  dptr
	clr  a
	movc a,@a+dptr
} by {
	; Peephole 186.a   optimized movc sequence
	mov  b,a
	mov  dptr,#%1
	movc a,@a+dptr
	mov  %2,a
	inc  dptr
	mov  a,b
	movc a,@a+dptr
	mov  %3,a
	inc  dptr
	mov  a,b
	movc a,@a+dptr
	mov  %4,a
	inc  dptr
	mov  a,b
	movc a,@a+dptr
}

// char indexed access to: void* code table[] = {4,3,2,1};
replace restart {
	add  a,#%1
	mov  dpl,a
	clr  a
	addc a,#(%1 >> 8)
	mov  dph,a
	clr  a
	movc a,@a+dptr
	mov  %2,a
	inc  dptr
	clr  a
	movc a,@a+dptr
	mov  %3,a
	inc  dptr
	clr  a
	movc a,@a+dptr
} by {
	; Peephole 186.b   optimized movc sequence
	mov  b,a
	mov  dptr,#%1
	movc a,@a+dptr
	mov  %2,a
	inc  dptr
	mov  a,b
	movc a,@a+dptr
	mov  %3,a
	inc  dptr
	mov  a,b
	movc a,@a+dptr
}

// char indexed access to: int code table[] = {4,3,2,1};
replace restart {
	add  a,#%1
	mov  dpl,a
	clr  a
	addc a,#(%1 >> 8)
	mov  dph,a
	clr  a
	movc a,@a+dptr
	mov  %2,a
	inc  dptr
	clr  a
	movc a,@a+dptr
} by {
	; Peephole 186.c   optimized movc sequence
	mov  %2,a
	mov  dptr,#%1
	movc a,@a+dptr
	xch  a,%2
	inc  dptr
	movc a,@a+dptr
}

// char indexed access to: char code table[] = {4,3,2,1};
replace {
	add  a,#%1
	mov  dpl,a
	clr  a
	addc a,#(%1 >> 8)
	mov  dph,a
	clr  a
	movc a,@a+dptr
} by {
	; Peephole 186.d  optimized movc sequence
	mov  dptr,#%1
	movc a,@a+dptr
}

replace {
        mov  r%1,%2
        anl  ar%1,#%3
        mov  a,r%1
} by {
        ; Peephole 187   used a instead of ar%1 for anl
        mov  a,%2
        anl  a,#%3
        mov  r%1,a
}

replace {
        mov  %1,a
        mov  dptr,%2
        movc a,@a+dptr
        mov  %1,a
} by {
        ; Peephole 188   removed redundant mov
        mov  dptr,%2
        movc a,@a+dptr
        mov  %1,a
}

replace {
        anl  a,#0x0f
        mov  %1,a
        mov  a,#0x0f
        anl  a,%1
} by {
        ; Peephole 189   removed redundant mov and anl
        anl  a,#0x0f
        mov  %1,a
}

// rules 190 & 191 need to be in order
replace {
        mov  a,%1
        lcall __gptrput
        mov  a,%1
} by {
        ; Peephole 190   removed redundant mov
        mov  a,%1
        lcall __gptrput
}

replace {
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
        mov  b,%4
        mov  a,%1
} by {
        ; Peephole 191   removed redundant mov
        mov  %1,a
        mov  dpl,%2
        mov  dph,%3
        mov  b,%4
}

replace {
        mov  r%1,a
        mov  @r%2,ar%1
} by {
        ; Peephole 192   used a instead of ar%1 as source
        mov  r%1,a
        mov  @r%2,a
}

replace {
        jnz  %3
        mov  a,%4
        jnz  %3
        mov  a,%9
        jnz  %3
        mov  a,%12
        cjne %13,%14,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 193.a optimized misc jump sequence
        jnz  %8
        mov  a,%4
        jnz  %8
        mov  a,%9
        jnz  %8
        mov  a,%12
        cjne %13,%14,%8
        sjmp %7
;%3:
} if labelRefCount %3 4

replace {
        cjne %1,%2,%3
        mov  a,%4
        cjne %5,%6,%3
        mov  a,%9
        cjne %10,%11,%3
        mov  a,%12
        cjne %13,%14,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 193   optimized misc jump sequence
        cjne %1,%2,%8
        mov  a,%4
        cjne %5,%6,%8
        mov  a,%9
        cjne %10,%11,%8
        mov  a,%12
        cjne %13,%14,%8
        sjmp %7
;%3:
} if labelRefCount %3 4

replace {
        cjne @%1,%2,%3
        inc  %1
        cjne @%1,%6,%3
        inc  %1
        cjne @%1,%11,%3
       	inc  %1
        cjne @%1,%14,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 193.a   optimized misc jump sequence
        cjne @%1,%2,%8
        inc  %1
        cjne @%1,%6,%8
        inc  %1
        cjne @%1,%11,%8
        inc  %1
        cjne @%1,%14,%8
        sjmp %7
;%3:
} if labelRefCount %3 4

replace {
        cjne %1,%2,%3
        cjne %5,%6,%3
        cjne %10,%11,%3
        cjne %13,%14,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 194   optimized misc jump sequence
        cjne %1,%2,%8
        cjne %5,%6,%8
        cjne %10,%11,%8
        cjne %13,%14,%8
        sjmp %7
;%3:
} if labelRefCount %3 4

replace {
        jnz  %3
        mov  a,%4
        jnz  %3
        mov  a,%9
        cjne %10,%11,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 195.a optimized misc jump sequence
        jnz  %8
        mov  a,%4
        jnz  %8
        mov  a,%9
        cjne %10,%11,%8
        sjmp %7
;%3:
} if labelRefCount %3 3

replace {
        cjne %1,%2,%3
        mov  a,%4
        cjne %5,%6,%3
        mov  a,%9
        cjne %10,%11,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 195   optimized misc jump sequence
        cjne %1,%2,%8
        mov  a,%4
        cjne %5,%6,%8
        mov  a,%9
        cjne %10,%11,%8
        sjmp %7
;%3:
} if labelRefCount %3 3

replace {
        cjne @%1,%2,%3
        inc  %1
        cjne @%1,%6,%3
        inc  %1
        cjne @%1,%11,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 195.a   optimized misc jump sequence
        cjne @%1,%2,%8
        inc  %1
        cjne @%1,%6,%8
        inc  %1
        cjne @%1,%11,%8
        sjmp %7
;%3:
} if labelRefCount %3 3

replace {
        cjne %1,%2,%3
        cjne %5,%6,%3
        cjne %10,%11,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 196   optimized misc jump sequence
        cjne %1,%2,%8
        cjne %5,%6,%8
        cjne %10,%11,%8
        sjmp %7
;%3:
} if labelRefCount %3 3

replace {
        jnz  %3
        mov  a,%4
        cjne %5,%6,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 197.a optimized misc jump sequence
        jnz  %8
        mov  a,%4
        cjne %5,%6,%8
        sjmp %7
;%3:
} if labelRefCount %3 2

replace {
        cjne %1,%2,%3
        mov  a,%4
        cjne %5,%6,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 197   optimized misc jump sequence
        cjne %1,%2,%8
        mov  a,%4
        cjne %5,%6,%8
        sjmp %7
;%3:
} if labelRefCount %3 2

replace {
        cjne @%1,%2,%3
        inc  %1
        cjne @%1,%6,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 197.a   optimized misc jump sequence
        cjne @%1,%2,%8
        inc   %1
        cjne @%1,%6,%8
        sjmp %7
;%3:
} if labelRefCount %3 2

replace {
        cjne %1,%2,%3
        cjne %5,%6,%3
        sjmp %7
%3:
        sjmp %8
} by {
        ; Peephole 198   optimized misc jump sequence
        cjne %1,%2,%8
        cjne %5,%6,%8
        sjmp %7
;%3:
} if labelRefCount %3 2

replace {
        cjne %1,%2,%3
        sjmp %4
%3:
        sjmp %5
} by {
        ; Peephole 199   optimized misc jump sequence
        cjne %1,%2,%5
        sjmp %4
;%3:
} if labelRefCount %3 1

replace {
        sjmp %1
%1:
} by {
        ; Peephole 200   removed redundant sjmp
%1:
}

replace {
        sjmp %1
%2:
%1:
} by {
        ; Peephole 201   removed redundant sjmp
%2:
%1:
}

replace {
        push  acc
        mov   dptr,%1
        pop   acc
} by {
        ; Peephole 202   removed redundant push pop
        mov   dptr,%1
}

replace {
        push  acc
        pop   acc
} by {
        ; Peephole 202b   removed redundant push pop
}

replace {
        mov  r%1,_spx
        lcall %2
        mov  r%1,_spx
} by {
        ; Peephole 203   removed mov  r%1,_spx
        lcall %2
}

replace {
        mov  %1,a
        add  a,acc
        mov  %1,a
} by {
        ; Peephole 204   removed redundant mov
        add  a,acc
        mov  %1,a
}

replace {
        djnz %1,%2
        sjmp  %3
%2:
        sjmp  %4
%3:
} by {
        ; Peephole 205   optimized misc jump sequence
        djnz %1,%4
%2:
%3:
} if labelRefCount %2 1

replace {
        mov  %1,%1
} by {
        ; Peephole 206   removed redundant mov %1,%1
}

replace {
        mov  a,_bp
        add  a,#0x00
        mov  %1,a
} by {
        ; Peephole 207   removed zero add (acc not set to %1, flags undefined)
        mov  %1,_bp
}

replace {
        push  acc
        mov   r%1,_bp
        pop   acc
} by {
        ; Peephole 208   removed redundant push pop
        mov   r%1,_bp
}

replace {
        mov  a,_bp
        add  a,#0x00
        inc  a
        mov  %1,a
} by {
        ; Peephole 209   optimized increment (acc not set to %1, flags undefined)
        mov  %1,_bp
        inc  %1
}

replace {
        mov  dptr,#((((%1 >> 16)) <<16) + (((%1 >> 8)) <<8) + %1)
} by {
        ; Peephole 210a   simplified expression
        mov  dptr,#%1
} if 24bitMode

replace {
        mov  dptr,#((((%1 >> 8)) <<8) + %1)
} by {
        ; Peephole 210   simplified expression
        mov  dptr,#%1
}

replace restart {
        push ar%1
        pop  ar%1
} by {
        ; Peephole 211   removed redundant push r%1 pop r%1
}

replace {
	mov  a,_bp
	add  a,#0x01
	mov  r%1,a
} by {
	; Peephole 212  reduced add sequence to inc
	mov  r%1,_bp
	inc  r%1
}

replace {
	mov  %1,#(( %2 >> 8 ) ^ 0x80)
} by {
	; Peephole 213.a inserted fix
	mov  %1,#(%2 >> 8)
	xrl  %1,#0x80
} if isPort('ds390' 'ds400')

replace {
	mov  %1,#(( %2 >> 16 ) ^ 0x80)
} by {
	; Peephole 213.b inserted fix
	mov  %1,#(%2 >> 16)
	xrl  %1,#0x80
} if isPort('ds390' 'ds400')

replace {
	mov  %1,#(( %2 + %3 >> 8 ) ^ 0x80)
} by {
	; Peephole 213.c inserted fix
	mov  %1,#((%2 + %3) >> 8)
	xrl  %1,#0x80
} if isPort('ds390' 'ds400')

replace  {
	mov  %1,a
	mov  a,%2
	add  a,%1
} by {
	; Peephole 214 reduced some extra movs
	mov  %1,a
	add  a,%2
} if notSame(%1 %2)

replace {
	mov  %1,a
	add  a,%2
	mov  %1,a
} by {
	; Peephole 215 removed some movs
	add  a,%2
	mov  %1,a
} if notSame(%1 %2)

replace {
	mov   r%1,%2
	clr   a
	inc   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
} by {
	; Peephole 216 simplified clear (2bytes)
	mov   r%1,%2
	clr   a
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
}

replace {
	mov   r%1,%2
	clr   a
	inc   r%1
	inc   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
} by {
	; Peephole 217 simplified clear (3bytes)
	mov   r%1,%2
	clr   a
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
}

replace {
	mov   r%1,%2
	clr   a
	inc   r%1
	inc   r%1
	inc   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
	dec   r%1
	mov   @r%1,a
} by {
	; Peephole 218 simplified clear (4bytes)
	mov   r%1,%2
	clr   a
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
	inc   r%1
	mov   @r%1,a
}

replace {
	clr   a
	movx  @dptr,a
	mov   dptr,%1
	clr   a
	movx  @dptr,a
} by {
	; Peephole 219 removed redundant clear
	clr   a
	movx  @dptr,a
	mov   dptr,%1
	movx  @dptr,a
}

replace {
	clr   a
	movx  @dptr,a
	mov   dptr,%1
	movx  @dptr,a
	mov   dptr,%2
	clr   a
	movx  @dptr,a
} by {
	; Peephole 219a removed redundant clear
	clr   a
	movx  @dptr,a
	mov   dptr,%1
	movx  @dptr,a
	mov   dptr,%2
	movx  @dptr,a
}

replace {
        mov     dps, #0
        mov     dps, #1
} by {
        ; Peephole 220a removed bogus DPS set
        mov     dps, #1
}

replace {
        mov     dps, #1
        mov     dps, #0
} by {
        ; Peephole 220b removed bogus DPS set
        mov     dps, #0
}

replace {
        mov     dps, #0
        mov     dps, #0x01
} by {
        ; Peephole 220c removed bogus DPS set
}

replace {
        mov     dps,#1
	inc	dptr
        mov     dps,#1
} by {
        ; Peephole 220d removed bogus DPS set
        mov     dps,#1
	inc	dptr
}

replace {
	mov	%1 + %2,(%2 + %1)
} by {
	; Peephole 221a remove redundant move
}

replace {
	mov	(%1 + %2 + %3),((%2 + %1) + %3)
} by {
	; Peephole 221b remove redundant move
}

replace {
	dec	r%1
	inc	r%1
} by {
	; removed dec/inc pair
}

replace {
	mov     dps, #0
	mov     %1,a
	mov     dps, #1
} by {
	; Peephole 222 removed DPS abuse.
	mov     %1,a
        mov     dps, #1
}

replace {
	mov	dps, #0
	xch	a, ap
	mov 	%1, ap
	mov	dps, #1
} by {
	; Peephole 222a removed DPS abuse.
	xch     a, ap
        mov     %1, ap
        mov     dps, #1
}

replace {
	mov 	dps, #%1
	inc	dptr
	movx	a,@dptr
	mov	%2,a
	mov	dps, #%1
} by {
	mov     dps, #%1
        inc     dptr
        movx    a,@dptr
        mov     %2,a
; Peephole 223: yet more DPS abuse removed.
}

replace {
	mov	dps, #0
	inc	dps
} by {
	mov	dps, #1
}

replace {
	mov	dps, #%1
	mov	dptr, %2
	mov	dps, #%1
} by {
	mov     dps, #%1
        mov     dptr, %2
}

replace {
	mov	dps, #1
	mov	dptr, %1
	mov	dps, #0
	mov	dptr, %2
	inc	dps
} by {
	mov	dps, #0
	mov	dptr, %2
	inc	dps
	mov	dptr, %1
; Peephole 224a: DPS usage re-arranged.
}

replace {
	mov	dps, #%1
	mov	dptr, %2
	mov	dps, #%3
	mov	dptr, %4
	mov	dps, #%1
} by {
	mov	dps, #%3
	mov	dptr, %4
	mov	dps, #%1
	mov	dptr, %2
; Peephole 224: DPS usage re-arranged.
}

replace {
	mov	dps, #1
	mov	dptr, %1
	mov	dps, #0
} by {
	mov	dps, #1
	mov	dptr, %1
	dec	dps
}

replace {
	xch	a, ap
	add	a, ap
} by {
	add 	a, ap
}

replace {
	xch	a, ap
	addc	a, ap
} by {
	addc 	a, ap
}

replace {
	inc 	dps
	mov	dps, #%1
} by {
	mov     dps, #%1
}

replace {
	dec 	dps
	mov	dps, #%1
} by {
	mov     dps, #%1
}


// char indexed access to: long code table[] = {4,3,2,1};
replace restart {
	add	a,#%1
	mov	dpl,a
	clr  a
	addc	a,#(%1 >> 8)
	mov	dph,a
	clr  a
	addc	a,#(%1 >> 16)
	mov	dpx,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%2,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%3,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%4,a
	clr	a
	movc	a,@a+dptr
} by {
	; Peephole 227.a movc optimize
	mov	b,a
	mov	dptr,#%1
	movc	a,@a+dptr
	inc	dptr
	mov	%2,a
	mov	a,b
	movc	a,@a+dptr
	inc	dptr
	mov	%3,a
	mov	a,b
	movc	a,@a+dptr
	inc	dptr
	mov	%4,a
	mov	a,b
	movc	a,@a+dptr
}

// char indexed access to: void* code table[] = {4,3,2,1};
replace restart {
	add	a,#%1
	mov	dpl,a
	clr  a
	addc	a,#(%1 >> 8)
	mov	dph,a
	clr  a
	addc	a,#(%1 >> 16)
	mov	dpx,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%2,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%3,a
	clr	a
	movc	a,@a+dptr
} by {
	; Peephole 227.b movc optimize
	mov	b,a
	mov	dptr,#%1
	movc	a,@a+dptr
	inc	dptr
	mov	%2,a
	mov	a,b
	movc	a,@a+dptr
	inc	dptr
	mov	%3,a
	mov	a,b
	movc	a,@a+dptr
}

// char indexed access to: int code table[] = {4,3,2,1};
replace restart {
	add	a,#%1
	mov	dpl,a
	clr  a
	addc	a,#(%1 >> 8)
	mov	dph,a
	clr  a
	addc	a,#(%1 >> 16)
	mov	dpx,a
	clr	a
	movc	a,@a+dptr
	inc	dptr
	mov	%2,a
	clr	a
	movc	a,@a+dptr
} by {
	; Peephole 227.c movc optimize
	mov	%2,a
	mov	dptr,#%1
	movc	a,@a+dptr
	inc	dptr
	xch	a,%2
	movc	a,@a+dptr
}

// char indexed access to: char code table[] = {4,3,2,1};
replace {
	add	a,#%1
	mov	dpl,a
	clr  a
	addc	a,#(%1 >> 8)
	mov	dph,a
	clr  a
	addc	a,#(%1 >> 16)
	mov	dpx,a
	clr	a
	movc	a,@a+dptr
} by {
	; Peephole 227.d movc optimize
	mov	dptr,#%1
	movc	a,@a+dptr
}

replace {
	mov	r%1,%2
	mov	ar%1,%3
} by {
	; Peephole 228 redundant move
	mov	ar%1,%3
}

replace {
	mov	r%1,a
	dec	r%1
	mov	a,r%1
} by {
	; Peephole 229.a redundant move
	dec	a
	mov	r%1,a
}

replace {
	mov	r%1,a
	mov	r%2,b
	mov	a,r%1
} by {
	; Peephole 229.b redundant move
	mov	r%1,a
	mov	r%2,b
}

replace {
	mov	r%1,a
	mov	r%2,b
	add	a,#%3
	mov	r%1,a
	mov	a,r%2
	addc	a,#(%3 >> 8)
	mov	r%2,a
} by {
	; Peephole 229.c redundant move
	add	a,#%3
	mov	r%1,a
	mov	a,b
	addc	a,#(%3 >> 8)
	mov	r%2,a
}

replace {
	mov	a,%1
	mov	b,a
	movx	a,%2
} by {
	; Peephole 229.d redundant move
	mov	b,%1
	movx	a,%2
}

replace {
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	mov  	r%4,a
	add  	a,#0x01
	mov  	r%5,a
	mov  	dpl,r%1
	mov  	dph,r%2
	mov  	dpx,r%3
	movx	@dptr,a
} by {
	; Peephole 230.a save reload dptr
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	mov  	r%4,a
	add  	a,#0x01
	mov  	r%5,a
	movx	@dptr,a
}

replace {
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	mov	r%4,a
	dec	r%4
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	mov	a,r%4
	movx	@dptr,a
} by {
	; Peephole 230.b save reload dptr
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	dec	a
	mov	r%4,a
	movx	@dptr,a
}

replace {
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	inc  	a
	mov  	r%4,a
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	mov	a,r%4
	movx	@dptr,a
} by {
	; Peephole 230.c save reload dptr
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
	movx	a,@dptr
	inc  	a
	mov  	r%4,a
	movx	@dptr,a
}

replace {
	mov	r%1,dpl
	mov	r%2,dph
	mov	r%3,dpx
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
} by {
	; Peephole 230.d save reload dptr
	mov	r%1,dpl
	mov	r%2,dph
	mov	r%3,dpx
}

replace {
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        movx    a,@dptr
        mov     r%4,a
        orl     ar%4,#%5
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        mov     a,r1
        movx    @dptr,a
} by {
	; Peephole 230.e save reload dptr
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        movx    a,@dptr
        orl     a,#%5
        mov     r%4,a
        movx    @dptr,a
}

replace {
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        movx    a,@dptr
        mov     r%4,a
        anl     ar%4,#%5
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        mov     a,r1
        movx    @dptr,a
} by {
	; Peephole 230.e save reload dptr
        mov     dpl,r%1
        mov     dph,r%2
        mov     dpx,r%3
        movx    a,@dptr
        anl     a,#%5
        mov     r%4,a
        movx    @dptr,a
}

replace {
	mov	r%1,dpl
	mov	r%2,dph
	mov	r%3,dpx
	mov	a,r%4
	inc	dps
	movx	@dptr,a
	inc	dptr
	mov	dps,#0
	mov	dpl,r%1
	mov	dph,r%2
	mov	dpx,r%3
} by {
	; Peephole 230.f save reload dptr
	mov	r%1,dpl
	mov	r%2,dph
	mov	r%3,dpx
	mov	a,r%4
	inc	dps
	movx	@dptr,a
	inc	dptr
	mov	dps,#0
}

replace {
	mov	ar%1,r%2
	mov	ar%3,r%1
	mov	r%1,#0x00
	mov	ar%2,r%4
	mov	r3,#0x00
} by {
	; Peephole 231.a simplified moves
	mov	ar%3,r%2
	mov	ar%2,r%4
	mov	r%4,#0
	mov	r%1,#0
}

replace {
	mov	r%1,#0
	mov	r%2,#0
	mov	a,r%2
	orl	a,r%3
	mov	%4,a
	mov	a,r%5
	orl	a,r%1
	mov	%6,a
} by {
	; Peephole 231.b simplified or
	mov	r%1,#0
	mov	r%2,#0
	mov	a,r%3
	mov	%4,a
	mov	a,r%5
	mov	%6,a
}

replace {
	mov	a,r%1
	mov	b,r%2
	mov	r%1,b
	mov	r%2,a
} by {
	; Peehole 232.a simplified xch
	mov	a,r%1
	xch	a,r%2
	mov	r%1,a
}

replace {
	mov	a,#%1
	mov	b,#%2
	mov	r%3,b
	mov	r%4,a
} by {
	; Peehole 232.b simplified xch
	mov	r%3,#%2
	mov	r%4,#%1
}

replace {
	mov	dpl1,#%1
	mov	dph1,#(%1 >> 8)
	mov	dpx1,#(%1 >> 16)
} by {
	; Peephole 233 24 bit load of dptr1
	inc	dps
	mov	dptr,#%1
	dec	dps
}

// 14 rules by Fiorenzo D. Ramaglia <fd.ramaglia@tin.it>

replace {
        add  a,ar%1
} by {
        ; Peephole 236a
        add  a,r%1
}

replace {
        addc  a,ar%1
} by {
        ; Peephole 236b
        addc  a,r%1
}

replace {
        anl  a,ar%1
} by {
        ; Peephole 236c
        anl  a,r%1
}

replace {
        dec  ar%1
} by {
        ; Peephole 236d
        dec  r%1
}

replace {
        djnz  ar%1,%2
} by {
        ; Peephole 236e
        djnz  r%1,%2
}

replace {
        inc  ar%1
} by {
        ; Peephole 236f
        inc  r%1
}

replace {
        mov  a,ar%1
} by {
        ; Peephole 236g
        mov  a,r%1
}

replace {
        mov  ar%1,#%2
} by {
        ; Peephole 236h
        mov  r%1,#%2
}

replace {
        mov  ar%1,a
} by {
        ; Peephole 236i
        mov  r%1,a
}

replace {
        mov  ar%1,ar%2
} by {
        ; Peephole 236j
        mov  r%1,ar%2
}

replace {
        orl  a,ar%1
} by {
        ; Peephole 236k
        orl  a,r%1
}

replace {
        subb  a,ar%1
} by {
        ; Peephole 236l
        subb  a,r%1
}

replace {
        xch  a,ar%1
} by {
        ; Peephole 236m
        xch  a,r%1
}

replace {
        xrl  a,ar%1
} by {
        ; Peephole 236n
        xrl  a,r%1
}

replace {
        sjmp    %1
%2:
        mov     %3,%4
%1:
        ret
} by {
        ; Peephole 237a  removed sjmp to ret
        ret
%2:
        mov     %3,%4
%1:
        ret
}

replace {
        sjmp    %1
%2:
        mov     %3,%4
        mov     dpl,%5
        mov     dph,%6
%1:
        ret
} by {
        ; Peephole 237b  removed sjmp to ret
        ret
%2:
        mov     %3,%4
        mov     dpl,%5
        mov     dph,%6
%1:
        ret
}

// applies to f.e. device/lib/log10f.c
replace {
        mov     %1,%9
        mov     %2,%10
        mov     %3,%11
        mov     %4,%12

        mov     %5,%13
        mov     %6,%14
        mov     %7,%15
        mov     %8,%16

        mov     %9,%1
        mov     %10,%2
        mov     %11,%3
        mov     %12,%4
} by {
        mov     %1,%9
        mov     %2,%10
        mov     %3,%11
        mov     %4,%12

        mov     %5,%13
        mov     %6,%14
        mov     %7,%15
        mov     %8,%16
        ;       Peephole 238.a  removed 4 redundant moves
} if notSame(%1 %2 %3 %4 %5 %6 %7 %8)

// applies to device/lib/log10f.c
replace {
        mov     %1,%5
        mov     %2,%6
        mov     %3,%7
        mov     %4,%8

        mov     %5,%1
        mov     %6,%2
        mov     %7,%3
} by {
        mov     %1,%5
        mov     %2,%6
        mov     %3,%7
        mov     %4,%8
        ;       Peephole 238.b  removed 3 redundant moves
} if notSame(%1 %2 %3 %4 %5 %6 %7)

// applies to f.e. device/lib/time.c
replace {
        mov     %1,%5
        mov     %2,%6

        mov     %3,%7
        mov     %4,%8

        mov     %5,%1
        mov     %6,%2
} by {
        mov     %1,%5
        mov     %2,%6

        mov     %3,%7
        mov     %4,%8
        ;       Peephole 238.c  removed 2 redundant moves
} if notSame(%1 %2 %3 %4)

// applies to f.e. support/regression/tests/bug-524209.c
replace {
        mov     %1,%4
        mov     %2,%5
        mov     %3,%6

        mov     %4,%1
        mov     %5,%2
        mov     %6,%3
} by {
        mov     %1,%4
        mov     %2,%5
        mov     %3,%6
        ;       Peephole 238.d  removed 3 redundant moves
} if notSame(%1 %2 %3 %4 %5 %6)

// applies to f.e. ser_ir.asm
replace {
        mov     r%1,acc
} by {
        ;       Peephole 239    used a instead of acc
        mov     r%1,a
}

replace restart {
	mov	a,%1
	addc	a,#0x00
} by {
	;	Peephole 240    use clr instead of addc a,#0
	clr	a
	addc	a,%1
}

// peepholes 241.a to 241.c and 241.d to 241.f need to be in order
replace {
        cjne    r%1,#%2,%3
        cjne    r%4,#%5,%3
        cjne    r%6,#%7,%3
        cjne    r%8,#%9,%3
        mov     a,#0x01
        sjmp    %10
%3:
        clr     a
%10:
} by {
        ;       Peephole 241.a  optimized compare
        clr     a
        cjne    r%1,#%2,%3
        cjne    r%4,#%5,%3
        cjne    r%6,#%7,%3
        cjne    r%8,#%9,%3
        inc     a
%3:
%10:
}

// applies to f.e. time.c
replace {
        cjne    r%1,#%2,%3
        cjne    r%4,#%5,%3
        mov     a,#0x01
        sjmp    %6
%3:
        clr     a
%6:
} by {
        ;       Peephole 241.b  optimized compare
        clr     a
        cjne    r%1,#%2,%3
        cjne    r%4,#%5,%3
        inc     a
%3:
%6:
}

// applies to f.e. malloc.c
replace {
        cjne    r%1,#%2,%3
        mov     a,#0x01
        sjmp    %4
%3:
        clr     a
%4:
} by {
        ;       Peephole 241.c  optimized compare
        clr     a
        cjne    r%1,#%2,%3
        inc     a
%3:
%4:
}

// applies to f.e. j = (k!=0x1000);
// with volatile idata long k;
replace {
        cjne    @r%1,#%2,%3
	inc	r%1
        cjne    @r%1,#%4,%3
	inc	r%1
        cjne    @r%1,#%5,%3
	inc	r%1
        cjne    @r%1,#%6,%3
        mov     a,#0x01
        sjmp    %7
%3:
        clr     a
%7:
} by {
        ;       Peephole 241.d  optimized compare
        clr     a
        cjne    @r%1,#%2,%3
	inc	r%1
        cjne    @r%1,#%4,%3
	inc	r%1
        cjne    @r%1,#%5,%3
	inc	r%1
        cjne    @r%1,#%6,%3
        inc     a
%3:
%7:
}

// applies to f.e. j = (k!=0x1000);
// with volatile idata int k;
replace {
        cjne    @r%1,#%2,%3
	inc	r%1
        cjne    @r%1,#%4,%3
        mov     a,#0x01
        sjmp    %7
%3:
        clr     a
%7:
} by {
        ;       Peephole 241.e  optimized compare
        clr     a
        cjne    @r%1,#%2,%3
	inc	r%1
        cjne    @r%1,#%4,%3
        inc     a
%3:
%7:
}

// applies to f.e. vprintf.asm (--stack-auto)
replace {
        cjne    @r%1,#%2,%3
        mov     a,#0x01
        sjmp    %7
%3:
        clr     a
%7:
} by {
        ;       Peephole 241.f  optimized compare
        clr     a
        cjne    @r%1,#%2,%3
        inc     a
%3:
%7:
}

// applies to f.e. scott-bool1.c
replace {
        jnz     %1
        mov     %2,%3
%1:
        jz      %4
} by {
        ;       Peephole 242.a  avoided branch jnz to jz
        jnz     %1
        mov     %2,%3
        jz      %4
%1:
} if labelRefCount %1 1

// applies to f.e. scott-bool1.c
replace {
        jnz     %1
        mov     %2,%3
        orl     a,%5
%1:
        jz      %4
} by {
        ;       Peephole 242.b  avoided branch jnz to jz
        jnz     %1
        mov     %2,%3
        orl     a,%5
        jz      %4
%1:
} if labelRefCount %1 1

// applies to f.e. logic.c
replace {
        jnz     %1
        mov     %2,%3
        orl     a,%5
        orl     a,%6
        orl     a,%7
%1:
        jz      %4
} by {
        ;       Peephole 242.c  avoided branch jnz to jz
        jnz     %1
        mov     %2,%3
        orl     a,%5
        orl     a,%6
        orl     a,%7
        jz      %4
%1:
} if labelRefCount %1 1

replace {
        jnz     %1
%1:
} by {
        ;       Peephole 243a    jump optimization
} if labelRefCount %1 1

replace {
        jz      %1
%1:
} by {
        ;       Peephole 243b    jump optimization
} if labelRefCount %1 1


// This allows non-interrupt and interrupt code to safely compete
// for a resource without the non-interrupt code having to disable
// interrupts:
// volatile bit resource_is_free;
// if( resource_is_free ) {
//     resource_is_free=0; do_something; resource_is_free=1;
// }
replace {
        jnb     %1,%2
%3:
        clr     %1
} by {
        ;       Peephole 244.a  using atomic test and clear
        jbc     %1,%3
        sjmp    %2
%3:
} if labelRefCount %3 0

replace {
        jb      %1,%2
        ljmp    %3
%2:
        clr     %1
} by {
        ;       Peephole 244.b  using atomic test and clear
        jbc     %1,%2
        ljmp    %3
%2:
} if labelRefCount %2 1

