# File lib/z80/math_i.rb, line 440
def add24_16(th8=c, tl16=hl, tt=de, signed:true)
    th, tl = tt.split
    tlh, tll = tl16.split
    if ![bc, de, sp].include?(tt) or ![hl, ix, iy].include?(tl16) or [tlh, tll, th, tl, a].include?(th8)
        raise ArgumentError, "add24_16: invalid arguments!"
    end
    ns do
        if signed
            ld   a, th
            add  a
            sbc  a
        else
            sub  a
        end
            add  tl16, tt
            adc  th8
    end
end

# File lib/z80/math_i.rb, line 384
def adda_to(th, tl)
    if th == tl or [th,tl].include?(a)
        raise ArgumentError, "adda_to: invalid arguments!"
    end
    ns do
            add  tl
            ld   tl, a
            adc  th
            sub  tl
            ld   th, a
    end
end

# File lib/z80/math_i.rb, line 2926
def bcdtoa(buffer=hl, size=b, skip_leading0:false, preserve_in:nil, &block)
    raise ArgumentError unless (address?(buffer) or buffer == hl) and
                               (address?(size) or (register?(size) and size.bit8?)) and
                               (!preserve_in or [c,d,e].include?(preserve_in))
    isolate do
        if pointer?(size)
                ld   a, size
                ld   b, a
        elsif size != b
                ld   b, size
        end
                ld   hl, buffer unless buffer == hl
                xor  a
        if skip_leading0
                ld   preserve_in, [hl] if preserve_in
                rld
                jr   NZ, noskip0
                jr   skip0
        else
                scf
        end
    loop_a      label
                ld   preserve_in, [hl] if preserve_in
                rld
    noskip0     ns(&block)
                xor  a
    skip0       rld
                ns(&block)
                ld   [hl], preserve_in if preserve_in
                inc  hl
                xor  a
                djnz loop_a
    end
end

# File lib/z80/math_i.rb, line 168
def cmp_i16n(th, tl, value, lt:nil, gt:nil, eq:nil, jump_rel:false)
    cmp_i16r(th, tl, value>>8, value, lt:lt, gt:gt, eq:eq, jump_rel:jump_rel)
end

# File lib/z80/math_i.rb, line 184
def cmp_i16r(th, tl, sh, sl, lt:nil, gt:nil, eq:nil, jump_rel:false)
    raise ArgumentError, "only th can be the accumulator" if [tl, sh, sl].include?(a)
    raise ArgumentError, "lt, gt or eq should be labels if specified" unless (lt.nil? or lt == :ret or (address?(lt) and !pointer?(lt))) and
                                                                             (gt.nil? or gt == :ret or (address?(gt) and !pointer?(gt))) and
                                                                             (eq.nil? or eq == :ret or (address?(eq) and !pointer?(eq)))
    raise ArgumentError, "specify at least one of: lt or gt" if lt == gt or (!lt and !gt)
    raise ArgumentError, "specify at most two of: lt, gt or eq" if lt and gt and eq
    gte = gt if gt == eq
    jump = proc do |cond, target|
        if target == :ret
                    ret  cond
        elsif jump_rel && (cond.nil? || cond.jr_ok?)
                    jr   cond, target
        else
                    jp   cond, target
        end
    end
    isolate do |eoc|
                    ld   a, th unless th == a
        if sh == 0                          # 8bit optimization
                    ora  a
        else
                    sub  sh
        end
                    jump.call Z, equal_msb
        unless sh == 0                      # 8bit optimization
                    jp   NV, no_xor         # VF: 0, no XORing
                    xor  0x80               # SF: SF ^ VF
            no_xor  label
        end
                    jump.call M, lt if lt
                    jump.call P, gt if gt
                    jump.call nil, eoc if !lt or !gt
        equal_msb   ld   a, tl
                    cp   sl
        if gte
                    jump.call NC, gte
        elsif gt
            if lt
                    jump.call C, lt
                    jump.call NZ, gt
            else
                    jump.call Z, eq || eoc
                    jump.call NC, gt
            end
        else
                    jump.call Z, eq if eq
                    jump.call C, lt
        end
    end
end

# File lib/z80/math_i.rb, line 121
def cmp_i8(va, vb, lt:nil, gt:nil, eq:nil, jump_rel:false)
    raise ArgumentError, "only va can be the accumulator" if vb == a
    raise ArgumentError, "lt, gt or eq should be labels if specified" unless (lt.nil? or lt == :ret or (address?(lt) and !pointer?(lt))) and
                                                                             (gt.nil? or gt == :ret or (address?(gt) and !pointer?(gt))) and
                                                                             (eq.nil? or eq == :ret or (address?(eq) and !pointer?(eq)))
    raise ArgumentError, "specify at least one of: lt or gt" if lt == gt or (!lt and !gt)
    raise ArgumentError, "specify at most two of: lt, gt or eq" if lt and gt and eq
    isolate do |eoc|
                    ld   a, va unless va == a
                    sub  vb
        if eq == :ret
                    ret  Z
        elsif jump_rel
                    jr   Z, eq || eoc
        else
                    jp   Z, eq || eoc
        end
                    jp   NV, skip_xor       # VF: 0, no XORing
                    xor  0x80               # SF: SF ^ VF
        skip_xor    label
        if lt == :ret
                    ret  M
        elsif lt
                    jp   M, lt
        end
        if gt == :ret
                    ret  P
        elsif gt
                    jp   P, gt
        end
    end
end

# File lib/z80/math_i.rb, line 2039
def divmod(k, m, clrrem:true, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
    unless clrrem
        check0 = false
        check1 = false
        k_leq_m = false
    end
    raise ArgumentError, "divmod: invalid arguments" unless [d, e, h, l, c].include?(k) and
                                                            [d, e, h, l, c].include?(m) and k != m
    opt_alt = case optimize
    when :time_alt
        optimize = :time
        true
    when :unroll_alt
        optimize = :unroll
        true
    when :size, :time, :unroll then false
    else
        raise ArgumentError, "divmod: optimize should be :size, :time, :time_alt, :unroll or :unroll_alt"
    end
    if k_leq_m.nil?
        k_leq_m = (optimize != :size)
    end
    isolate do |eoc|
        if check0 == true
            check0 = eoc
            check0_far = (optimize == :unroll && opt_alt)
        end
        check1 = eoc if check1 == true
        if check0 or check1 or k_leq_m
                        ld  a, m
                        cp  1 if check0 or check1 
            if check0
                if check0_far && optimize == :size
                        jp  C, check0 # division by 0
                elsif check0_far
                        jr  C, fw_check0 # division by 0
                else
                        jr  C, check0 # division by 0
                end
            end
            if check1
                if optimize == :size && !k_leq_m
                        jr  NZ, divstrt  # division by m > 1
                        xor a            # clear rest
                    if check1 == eoc
                        jr  eoc          # division by 1
                    else
                        jp  check1
                    end
                else
                        jr  Z, divone    # division by m == 1
                end
            end
            if k_leq_m
                        cp  k            # m < k ?
                if optimize == :size
                        jr  C, divstrt   # m < k
                kislqm  jr  Z, kiseqm    # k == m
                        ld  a, k         # k <  m
                        ld  k, 0 unless modulo
                        jr  eoc
                kiseqm  label            # k == m
                        ld  k, 1 unless modulo
                    if check1 && check1 == eoc
                divone  xor a
                        jr  eoc
                    else
                        xor a 
                        jr  eoc
                        if check1
                    divone  xor a
                            jp  check1
                        end
                    end
                else
                        jr  NC, kislqm   # m >= k
                end
            end
        end
        if optimize == :unroll
            if clrrem
                        xor a
                7.times do |i|
                        sla k      # align highest set bit at CF
                        jr  C, define_label("iter#{i}").found1
                end
                if k_leq_m
                        jp  iter7  # k == 0x80
                else
                        sla k
                        jr  C, iter7.found1
            fw_check0   label if check0 && check0_far && check0 == eoc
                        jp  eoc    # k == 0
                end
                if k_leq_m
                kislqm  jr  Z, kiseqm   # k == m
                        ld  a, k        # k <  m
                        ld  k, 0 unless modulo
            fw_check0   label if check0 && check0_far && check0 == eoc
                        jp  eoc
                kiseqm  label           # k == m
                        ld  k, 1 unless modulo
                    unless check1 && check1 == eoc
                        xor a 
                        jp  eoc
                    end
                end
                if check1
                divone  xor a      # clear rest
            fw_check0   label if check0 && check0_far && !(check0 == eoc) && check0 == check1
                        jp  check1 # division by 1
                end
            fw_check0   jp  check0 if check0 && check0_far && !(check0 == eoc) && !(check0 == check1)
            end
            if opt_alt
                8.times do |i|
                    ns :"iter#{i}" do
                            sla k unless clrrem && i.zero?
                    found1  adc a
                            jr  C, :"fits#{i+1}" unless clrrem
                            cp  m
                            jr  NC, :"fits#{i+1}"
                    end
                end
                            sla k unless modulo # clear carry, shift quotient into position
                if modulo && check0 && !ignore_cf
                            jp  quitccf # clear carry
                else
                            jp  eoc
                end
                (1..7).each do |i|
                    ns :"fits#{i}" do
                            sub m
                            sll k
                            adc a
                            jr  C, :"fits#{i+1}" unless clrrem
                            cp  m
                        if i != 7
                            jr  C, :"iter#{i+1}"
                        else
                            jr  NC, fits8
                            sla k unless modulo # clear carry, shift quotient into position
                            if modulo && check0 && !ignore_cf
                                jp  quitccf # clear carry
                            else
                                jp  eoc
                            end
                        end
                    end
                end
                    fits8   sub m
                    quitccf anda a if modulo && check0 && !ignore_cf # clear carry
                            sll k unless modulo # clear carry, shift quotient into position
            else
                8.times do |i|
                    isolate :"iter#{i}" do |skipadd|
                            sla k unless clrrem && i.zero?
                    found1  adc a
                            jr  C, fits unless clrrem
                            cp  m
                            jr  C, skipadd
                    fits    sub m
                            inc k unless modulo
                    end
                end
                            anda a if check0 && !ignore_cf # clear carry
            end
        else # optimize != :unroll
            divstrt     ld  b, 8
            if clrrem
                        xor a            # a = 0
                if optimize == :time
                findhi  sla k            # align highest set bit at CF
                        jr  C, found1
                        djnz findhi
                        jp  eoc unless k_leq_m # k == 0
                    if k_leq_m
                kislqm  jr  Z, kiseqm   # k == m
                        ld  a, k        # k <  m
                        ld  k, 0 unless modulo
                        jp  eoc
                kiseqm  label           # k == m
                        ld  k, 1 unless modulo
                        unless check1 && check1 == eoc
                            xor a       # clear rest
                            jp  eoc
                        end
                    end
                    if check1
                divone  xor a            # clear rest
            fw_check0   label if check0 && check0_far && check0 == check1
                        jp  check1       # division by 1
                    end
            fw_check0   jp  check0 if check0 && check0_far && !(check0 == check1)
                end
            end
            if optimize == :time
                unless clrrem
                        sla k            # carry <- k <- 0 (quotient)
                        adc a            # carry <- a <- carry
                        jr  C, fits unless clrrem # a >= 256
                        cp  m
                        jr  NC, fits     # a >= m
                        djnz loopfit     # b = 7
                end
                fits    sub m            # a = a - m (rest)
                if opt_alt && !modulo
                        sll k            # carry <- k <- 1 (quotient)
                        djnz found1      # loop
                else
                        inc k unless modulo # k <- 1 (quotient)
                        djnz loopfit     # loop
                end
                if !(opt_alt && !modulo) && check0 && !ignore_cf
                        jp  quitccf      # quit with clear carry
                else
                        jp  eoc
                end
                loopfit sla k            # carry <- k <- 0
                found1  adc a            # carry <- a <- carry
                        jr  C, fits unless clrrem # a >= 256
                        cp  m            # a - m
                        jr  NC, fits     # a >= m
                nfits   djnz loopfit     # loop
                if opt_alt && !modulo
                        sla k            # clear carry, shift quotient into position
                elsif check0 && !ignore_cf
                quitccf anda a           # clear carry only when check0
                end
            elsif optimize == :size
                loopfit sla k            # carry <- k <- 0
                        adc a            # carry <- a <- carry
                if modulo && clrrem
                        sub m
                        jr  NC, fits
                        add m
                fits    djnz loopfit
                else
                        jr  C, fits unless clrrem # a >= 256
                        cp  m
                        jr  C, nfits
                fits    sub m
                        inc k unless modulo # k <- 1 (quotient)
                nfits   djnz loopfit
                end
                        anda a if check0 && !ignore_cf # clear carry
            end
        end
    end
end

# File lib/z80/math_i.rb, line 2406
def divmod16(x=ixl, check0:true, check1:true, modulo:false, quick8:true)
    raise ArgumentError unless [ixh, ixl, iyh, iyl].include?(x)
    isolate do |eoc|
        check0 = eoc if check0 == true
        check1 = eoc if check1 == true
        if check0 or check1 or quick8
                            xor a
                            ora d
                            jp  NZ, div16strt
            if quick8
                if quick8 == :divmod8
                            divmod8 e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo
                else
                            divmod h, e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo, optimize: :time, ignore_cf:true
                            divmod l, e, clrrem:false, optimize: :time
                            anda a if check0
                end
                            ld  c, a
                if check0 == eoc
                qcheck0     label
                end
                            jp  eoc
                if check1
                qcheck1     ld  b, a
                            ld  c, a
                            jp  check1
                end
                if check0 && !(check0 == eoc)
                qcheck0     jp  check0
                end
            elsif check0 or check1
                            ld  a, e
                            cp  1
                            jr  C, check0 if check0 # division by 0
                if check1
                            jr  Z, divone     # division by m == 1
                end
            end
        end
        div16strt           xor a            # a = 0 hi remainder
                            ld  c, a         # c = 0 lo remainder
                            ld  b, 16
        findhi              add hl, hl       # align highest set bit at CF
                            jr  C, found
                            djnz findhi
                            jp  eoc          # hl == 0, bc == 0
        loopfit             add hl, hl       # carry <- hl <- 0
        found               rl  c            # carry <- c <- carry
                            adc a            # carry <- a <- carry
                            cp  d            # a - d
                            jr  NC, fitshi   # a >= d
                            djnz loopfit     # loop
                            ccf if check0
                            jp  over
        if check1 && !quick8
            divone          ld  bc, 0         # clear rest
                            jp  check1        # division by 1
        end
        fitshi              ld  x, a
                            ld  a, c
                            jr  NZ, fitslo   # a > d, ignore e
                            cp  e            # a == d: c - e
                            jr  NC, fitslo   # a >= e
                            ld  a, x
                            djnz loopfit     # loop
                            ccf if check0
                            jp  over
        fitslo              sub e            # a = c - e
                            ld  c, a         # c = c - e
                            ld  a, x
                            sbc d            # a -= d
        unless modulo
                            inc l            # hl <- 1 (quotient)
        end
                            djnz loopfit     # loop
        over                ld  b, a         # bc = remainder
    end
end

# File lib/z80/math_i.rb, line 2376
def divmod16_8(kh, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
    raise ArgumentError unless [kh, kl, m].uniq.size == 3
    isolate do |eoc|
        if check0 == true
            check0 = eoc
            check0_far = (optimize == :unroll || optimize == :unroll_alt)
        end
        check1 = eoc if check1 == true
        divmod kh, m, check0:check0, check0_far:check0_far, check1:check1, k_leq_m:k_leq_m, modulo:modulo, optimize:optimize, ignore_cf:true
        divmod kl, m, clrrem:false, modulo:modulo, optimize:optimize
        anda a if check0 && !ignore_cf # clear CF unless ignored
    end
end

# File lib/z80/math_i.rb, line 2509
def divmod24_8(kh, km, kl, m, check0:true, check0_far:false, check1:true, k_leq_m:nil, modulo:false, ignore_cf:false, optimize: :time)
    raise ArgumentError unless [kh, km, kl, m].uniq.size == 4
    isolate do |eoc|
        if check0 == true
            check0 = eoc
            check0_far = (optimize == :unroll || optimize == :unroll_alt)
        end
        check1 = eoc if check1 == true
        divmod kh, m, check0:check0, check0_far:check0_far, check1:check1, k_leq_m:k_leq_m, modulo:modulo, optimize:optimize, ignore_cf:true
        divmod km, m, clrrem:false, modulo:modulo, optimize:optimize
        divmod kl, m, clrrem:false, modulo:modulo, optimize:optimize
        anda a if check0 && !ignore_cf # clear CF unless ignored
    end
end

# File lib/z80/math_i.rb, line 2610
def divmod32_16(x:ixl, check0:true, check1:true, modulo:false, quick8:true)
    raise ArgumentError unless [ixh, ixl, iyh, iyl].include?(x)
    isolate do |eoc|
        check0 = eoc if check0 == true
        check1 = eoc if check1 == true
        if check0 or check1 or quick8
                            xor a
                            ora d
                            jp  NZ, div32strt
            if quick8
                            divmod32_8 e, check0:(check0 && qcheck0), check1:(check1 && qcheck1), modulo:modulo
                            ld  c, a
                if check0 == eoc
                qcheck0     label
                end
                            jp  eoc
                if check1
                qcheck1     ld  b, a
                            ld  c, a
                            jp  check1
                end
                if check0 && !(check0 == eoc)
                qcheck0     jp  check0
                end
            elsif check0 or check1
                            ld  a, e
                            cp  1
                            jr  C, check0 if check0 # division by 0
                if check1
                            jp  NZ, div32strt # division by m > 1
                            ld  bc, 0
                            jp  check1        # division by 1
                end
            end
        end
        div32strt           xor a            # a = 0 hi remainder
                            ld  c, a         # c = 0 lo remainder
                            ld  b, 16
        loopfit1            add hl, hl       # carry <- hl <- 0
                            rl  c            # carry <- c <- carry
                            adc a            # carry <- a <- carry
                            cp  d            # a - d
                            jr  NC, fitshi1  # a >= d
                            djnz loopfit1    # loop
                            jp  divlo16
        fitshi1             ld  x, a
                            ld  a, c
                            jr  NZ, fitslo1  # a > d, ignore e
                            cp  e            # a == d: c - e
                            jr  NC, fitslo1  # a >= e
                            ld  a, x 
                            djnz loopfit1    # loop
                            jp  divlo16
        fitslo1             sub e            # a = c - e
                            ld  c, a         # c = c - e
                            ld  a, x
                            sbc d            # a -= d
        unless modulo
                            inc l            # hl <- 1 (quotient)
        end
                            djnz loopfit1    # loop

        divlo16             push de
                            ld  x, c
                            exx              # hl' <-> hl
                            pop de           # de' = de
                            ld  c, x         # c' = c

                            ld  b, 16
        loopfit2            add hl, hl       # carry <- hl' <- 0
                            rl  c            # carry <- c' <- carry
                            adc a            # carry <- a <- carry
                            jr  C, fitshi2c  # a > d
                            cp  d            # a - d'
                            jr  NC, fitshi2  # a >= d'
                            djnz loopfit2    # loop
                            ccf if check0
                            jp  over
        fitshi2             ld  x, a
                            ld  a, c
                            jr  NZ, fitslo2  # a > d, ignore e
                            cp  e            # a == d: c - e
                            jr  NC, fitslo2  # a >= e
                            ld  a, x
                            djnz loopfit2    # loop
                            ccf if check0
                            jp  over
        fitshi2c            ld  x, a
                            ld  a, c
        fitslo2             sub e            # a = c' - e'
                            ld  c, a         # c' = c' - e'
                            ld  a, x
                            sbc d            # a -= d'
        unless modulo
                            inc l            # hl' <- 1 (quotient)
        end
                            djnz loopfit2    # loop
                            ora  a if check0 # clear carry only when check0
        over                ld  x, c
                            exx
                            ld  b, a         # bc = remainder
                            ld  c, x
    end
end

# File lib/z80/math_i.rb, line 2541
def divmod32_8(m=c, mt:c, check0:true, check1:true, modulo:false)
    raise ArgumentError unless [c, d, e].include?(m)
    isolate do |eoc|
        check0 = eoc if check0 == true
        check1 = eoc if check1 == true
        if check0 or check1
                            ld  a, m
                            cp  1
                            jr  C, check0 if check0 # division by 0
            if check1
                            jp  NZ, divstrt  # division by m > 1
                            xor a            # clear rest
                            jp  check1       # division by 1
            end
        end
        divstrt             xor a            # a = 0
                            ld  b, 16
        loopfit1            add hl, hl       # carry <- hl <- 0
                            adc a            # carry <- a <- carry
                            jr  C, fits1     # a > m
                            cp  m            # a - m
                            jr  NC, fits1    # a >= m
                            djnz loopfit1    # loop
                            jp  divlo16
        fits1               sub m            # a = a - m (rest)
        unless modulo
                            inc l            # hl <- 1 (quotient)
        end
                            djnz loopfit1    # loop

        divlo16             ex  af, af
                            ld  a, m
                            exx
                            ld  mt, a
                            ex  af, af
                            ld  b, 16
        loopfit2            add hl, hl       # carry <- hl <- 0
                            adc a            # carry <- a <- carry
                            jr  C, fits2     # a > m
                            cp  mt           # a - m
                            jr  NC, fits2    # a >= m
                            djnz loopfit2    # loop
                            ccf if check0    # clear carry only when check0
                            jp  over
        fits2               sub mt           # a = a - m (rest)
        unless modulo
                            inc l            # hl <- 1 (quotient)
        end
                            djnz loopfit2    # loop
                            ora  a if check0 # clear carry only when check0
        over                exx
    end
end

# File lib/z80/math_i.rb, line 2306
def divmod8(m=c, check0:true, check1:true, modulo:false)
    raise ArgumentError unless [c, d, e].include?(m)
    isolate do |eoc|
        check1 = eoc if check1 == true
        check0 = eoc if check0 == true
        if check0 or check1
                        ld  a, m
                        cp  1
                        jr  C, check0 if check0 # division by 0
            if check1
                        jr  Z, divone    # division by m == 1
            end
        end
        divstrt         xor a            # a = 0
                        ld  b, 16
        findhi          add hl, hl       # align highest set bit at CF
                        jr  C, found
                        djnz findhi
                        jp  eoc          # hl == 0
        if check1
            divone      xor a            # clear rest
                        jp  check1       # division by 1
        end
        loopfit         add hl, hl       # carry <- hl <- 0
        found           adc a            # carry <- a <- carry
                        jr  C, fits      # a >= 256
                        cp  m            # a - m
                        jr  NC, fits     # a >= m
                        djnz loopfit     # loop
        if check0
                        jp  quitccf      # clear carry only when check0
        else
                        jp  eoc
        end
        fits            sub m            # a = a - m (rest)
        unless modulo
                        inc l            # hl <- 1 (quotient)
        end
                        djnz loopfit     # loop
        quitccf         anda a if check0 # clear carry only when check0
    end
end

# File lib/z80/math_i.rb, line 79
def int(bitsize, value, byteorder: :lsb)
    raise ArgumentError, "int bitsize must be > 0" unless bitsize.is_a?(Integer) and bitsize > 0
    raise ArgumentError, "int bitsize must be multiple of 8" unless (bitsize & 7).zero?
    bytesize = bitsize >> 3
    klass_name = "Int#{bitsize}"
    int_klass = if Z80::MathInt::Integers.const_defined?(klass_name)
        Z80::MathInt::Integers.const_get(klass_name)
    else
        klass = Class.new(Z80::Label) do
            value  byte bytesize
            bytes  value byte, bytesize
            words  value word, bytesize >> 1 if (bytesize & 1).zero?
        end
        Z80::MathInt::Integers.const_set klass_name, klass
    end
    bytes = []
    bytesize.times do
        case byteorder
        when :lsb then bytes.push(value & 0xFF)
        when :msb then bytes.unshift(value & 0xFF)
        else
            raise ArgumentError, "byteorder must be :lsb or :msb"
        end
        value >>= 8
    end
    data int_klass, bytes.pack('c*'.freeze)
end

# File lib/z80/math_i.rb, line 972
def mul(k=d, m=a, tt:de, clrhl:true, signed_k:false, kbit9_carry:false, tl_is_zero:false, optimize: :time)
    raise ArgumentError, "mul: invalid arguments" if tt == hl or k == a
    raise ArgumentError, "mul: optimize should be :time or :size" unless [:size, :time].include?(optimize)
    th, tl = tt.split
    srx = if signed_k
        proc {|t| sra t}
    else
        proc {|t| srl t}
    end
    isolate do |eoc|
                ld   a, m unless m == a
                ld   th, k unless k == th
        if clrhl
                ld   hl, 0
                ld   tl, l unless tl_is_zero
        else
                ld   tl, 0 unless tl_is_zero
        end
        if kbit9_carry
                rr   th
            if optimize == :time
                rr   tl
                add  a, a
                jr   NC, noadd9
                add  hl, tt
        noadd9  jr   Z, eoc
            else
                jr   cont9
            end
        elsif optimize == :time
                srx[th]
                rr   tl
                add  a, a
                jr   NC, noadd8
                add  hl, tt
        noadd8  jr   Z, eoc
        end
        loop1   srx[th]
        cont9   rr   tl
                add  a, a
        if optimize == :time
                jr   NC, loop1
        else
                jr   NC, noadd
        end
                add  hl, tt
        if optimize == :time
                jp   NZ, loop1
        else
        noadd   jr   NZ, loop1
        end
    end
end

# File lib/z80/math_i.rb, line 672
def mul16(kh=h, kl=l, m=a, tt:de, mbit9_carry:false, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul16: invalid arguments" if tt == hl or [kh, kl].include?(a)
    raise ArgumentError, "mul16: tt must be +de+ if optimize is :compact" if tt == bc &&
                                                                        optimize == :compact
    isolate do |eoc|
                        ld   a, m  unless  m == a
        if kh == tl
            raise ArgumentError, "mul16: invalid arguments" if kl == th
                        ld   th, kh
                        ld   tl, kl unless kl == tl
        else
                        ld   tl, kl unless kl == tl
                        ld   th, kh unless kh == th
        end
        if optimize == :time
                        ld   l, tl unless kl == l
                        ld   h, th unless kh == h
            if mbit9_carry
                        jr   C, start9    # bit9 of m
            end
                        scf               # terminator
                        adc  a, a         # CF <- m <- 1
                        jr   C, cont1
                loop0   add  a, a         # CF <- m <- 0
                        jr   NC, loop0
                        jp   NZ, cont1
                        ld   h, a         # m == 0
                        ld   l, a
                        jp   eoc
            if mbit9_carry
                start9  adc  a, a         # CF <- m <- 1
                        jr   C, doadd1
            end
                loop1   add  hl, hl       # hl * 2
                cont1   add  a, a         # CF <- m <- 0
                        jr   NC, loop1
                        jr   Z, eoc
                doadd1  add  hl, hl       # hl * 2
                        add  hl, tt       # hl + tt
                        add  a, a         # CF <- m <- 0
                        jr   NC, loop1
                        jp   NZ, doadd1
        elsif optimize == :compact
                        ld   hl, 0
            if mbit9_carry
                        ld   b, 9
                        jr   cont1
            else
                        ld   b, 8
            end
                loop1   add  hl, hl       # hl * 2
                        add  a, a         # CF <- m <- 0
                cont1   jr   NC, skip1
                        add  hl, tt       # hl + tt
                skip1   djnz loop1
        elsif optimize == :size
                        ld   hl, 0
            if mbit9_carry
                        jr   NC, start8   # bit9 of m
                        add  hl, tt
            end
            start8      scf               # terminator
                        adc  a, a         # CF <- m <- 1
                        jr   cont2
                loop1   add  hl, hl       # hl * 2
                cont1   add  a, a         # CF <- m <- 0
                cont2   jr   NC, loop1
                        jr   Z, eoc
                doadd1  add  hl, hl       # hl * 2
                        add  hl, tt       # hl + tt
                        jr   cont1
        elsif optimize == :unroll
                        ld   l, tl unless kl == l
                        ld   h, th unless kh == h
            if mbit9_carry
                        jr   C, iter0     # bit9 of m
            end
            7.times do |i|
                        add  a, a
                        jr   C, :"iter#{i+1}"
            end
                        add  a, a
                        jr   C, eoc
                        ld   h, a         # m == 0
                        ld   l, a
                        jp   eoc
            (if mbit9_carry then 0 else 1 end..7).each do |i|
                ns :"iter#{i}" do |eoc|
                        add  hl, hl
                skip9   add  a, a
                        jr   NC, eoc
                doadd   add  hl, tt
                end
            end
        else
            raise ArgumentError, "mul16: optimize should be :compact, :size, :time or :unroll"
        end
    end
end

# File lib/z80/math_i.rb, line 1838
def mul16_32(mm=bc, tt:bc, clrhlhl:true, signed_hl:false, optimize: :time)
    raise ArgumentError unless [bc, de].include?(mm) and [bc, de].include?(tt)
    mh, ml = mm.split
    th, tl = tt.split
    srx = if signed_hl
        ->(x) { sra x }
    else
        ->(x) { srl x }
    end
    isolate do |eoc|
        if optimize == :size
                        ld  a, ml
                        scf
                        adc a, a         # carry <- ml <- 1
                        ex  af, af       # a' = ml, CF' = carry, ZF = 0
                        ld  a, mh
                        ld  mh, h
                        ld  ml, l
            if address?(clrhlhl)
                        ld  hl, clrhlhl >> 16
            elsif clrhlhl
                        ld  hl, 0        # hl = 0
            end
                        srx[mh]
                        rr  ml
                        exx
            if address?(clrhlhl)
                        ld  hl, clrhlhl & 0xFFFF
                        ld  tt, 0        # th'|tl' = 0
            elsif clrhlhl
                        ld  hl, 0        # hl' = 0
                        ld  th, h
                        ld  tl, l
            end
                        rr  th
                        scf
                        adc a, a         # carry <- mh <- 1
                        jr  C, doadd1
            shadd0      exx
            shadd1      srx[mh]          # mh -> ml -> th'
                        rr  ml
                        exx
                        rr  th
                        rr  tl
                        add a, a         # carry <- mh|ml
                        jr  Z, multlo
            backloop    jr  NC, shadd0
            doadd1      add hl, th|tl    # hl' += th'|tl'
                        exx
                        adc hl, mh|ml    # hl  += mh|ml + carry
                        jr  shadd1

            multlo      ex  af, af       # a = ml, ZF = a == 0
                        jr  NZ, backloop
                        exx

        elsif optimize == :time

                        ld  a, ml
                        ora a            # a' ?= 0
                        ex  af, af       # a' = ml, ZF' = a' == 0
                        xor a            # a  = 0
                        exx
            if address?(clrhlhl)
                        ld  hl, clrhlhl & 0xFFFF
            elsif clrhlhl
                        ld  h, a         # hl' = 0
                        ld  l, a
            end
                        ld  th, a        # th'|tl' = 0
                        ld  tl, a
                        exx
                        ora mh           # a |= mh
                        jr  Z, multlo0   # mh <> 0

                        ld  mh, h        # mh|ml = hl
                        ld  ml, l
            if address?(clrhlhl)
                        ld  hl, clrhlhl >> 16
            elsif clrhlhl
                        ld  hl, 0        # hl = 0
            end
                        scf
                        adc a            # carry <- mh <- 1
                        jr  NC, noadd1

            shadd1      srx[mh]          # mh -> ml -> th'
                        rr  ml
                        exx
                        rr  th
                        add hl, th|tl    # hl' += th'|tl'
                        exx
                        adc hl, mh|ml    # hl  += mh|ml + carry
                        add a            # carry <- mh
                        jr  Z, multlo
                        jp  C, shadd1

            noadd1      srx[mh]          # mh -> ml -> mh'
                        rr  ml
                        exx
                        rr  th
                        exx
                        add a            # carry <- ml
                        jr  Z, multlo
                        jp  C, shadd1
                        jp  noadd1

            multlo0     ld  ml, h        # mh = 0, ml = h, th' = l, tl' = 0
                        ld  a, l
                        exx
                        ld  th, a
                        exx
                        ld  hl, 0        # hl = 0

            multlo      ex  af, af       # a = ml, ZF = a == 0
                        jr  Z, eoc
                        add a            # carry <- ml
                        jr  NC, noadd2

            shadd2      srx[ml]          # ml -> mh' -> ml'
                        exx
                        rr  th
                        rr  tl
                        add hl, th|tl    # hl' += th'|tl'
                        exx
                        adc hl, mh|ml    # hl  += mh|ml + carry
                        add a            # carry <- ml
                        jr  Z, finlo
                        jp  C, shadd2

            noadd2      srx[ml]          # ml -> mh' -> ml'
                        exx
                        rr  th
                        rr  tl
                        exx
                        add a            # carry <- ml
                        jr  Z, finlo
                        jp  C, shadd2
                        jp  noadd2

            finlo       jr  NC, eoc
                        srx[ml]          # ml -> mh' -> ml'
                        exx
                        rr  th
                        rr  tl
                        add hl, th|tl    # hl' += th'|tl'
                        exx
                        adc hl, mh|ml    # hl  += mh|ml + carry
        else
            raise ArgumentError, "optimize should be :time or :size"
        end
    end
end

# File lib/z80/math_i.rb, line 631
def mul16_signed(kh=h, kl=l, m=b, tt:de, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul16_signed: invalid arguments" if [kh, kl].include?(m)
    t = if register?(m) && m.bit8? && m != a
        m
    else
        [l, h, tl, th].find {|r| r != kh && r != kl}
    end
    isolate do
                ld   a, m unless m == a
                anda a
                jp   P, mult        # m >= 0
                ld   t, a unless t == m
                neg16 kh, kl
                xor  a
                sub  t              # a: -m
        mult    mul16(kh, kl, a, tt:tt, optimize:optimize)
    end
end

# File lib/z80/math_i.rb, line 560
def mul16_signed9(kh=h, kl=l, m=c, s:nil, tt:de, m_overflow:nil, m_neg_cond:C, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul16_signed9: invalid arguments" if [kh, kl].include?(m) or
                                                        (!s.nil? and (m == a or
                                                            [kh, kl, th, tl, h, l, m, a].include?(s) or
                                                            !register?(m) or !m.bit8?))
    unless m_neg_cond.nil? and !s.nil?
        raise ArgumentError, "mul16_signed9: m_neg_cond must be a Condition" unless m_neg_cond.is_a?(Condition)
    end
    t = if register?(m) && m.bit8? && m != a
        m
    else
        [l, h, tl, th].find {|r| r != kh && r != kl}
    end
    jump = proc do |cond, target|
        if optimize == :size || optimize == :compact
                jr   cond, target
        else
                jp   cond, target
        end
    end
    isolate do |eoc|
        if s
            if m_neg_cond.jr_ok?
                    jr   m_neg_cond, negmul
            else
                    jp   m_neg_cond, negmul
            end unless m_neg_cond.nil?
            posmul  sign_extend(s, kh)
                    ld   a, m
                    anda a    # clear CF, test zero
                    jump.call NZ, mult
                    ld   s, a # clear sign
                    ld   h, a
                    ld   l, a
                    jump.call nil, eoc
            negmul  neg16 kh, kl
                    sign_extend(s, a)
        else
                    ld   a, m unless m == a
            if m_neg_cond.jr_ok?        # m >= 0
                    jr   m_neg_cond.not, mult
            else
                    jp   m_neg_cond.not, mult
            end
                    ld   t, a unless t == m
                    neg16 kh, kl
        end
                    xor  a
                    sub  t              # a: -m
            if m_overflow
                    jr   NC, m_overflow # m == 256
            elsif m_overflow.nil?
                    ccf                 # CF: 1 when m == 256, otherwise CF: 0
            end
            mult    mul16(kh, kl, a, tt:tt, mbit9_carry:m_overflow.nil?, optimize:optimize)
    end
end

# File lib/z80/math_i.rb, line 1285
def mul8(kh=h, kl=l, m=a, tt:de, clrhl:true, double:false, optimize: :time)
    raise ArgumentError, "mul8: optimize should be :time or :size" unless [:size, :time].include?(optimize)
    th, tl = tt.split
    raise ArgumentError, "mul8: invalid arguments" if tt == hl or [th, tl].include?(m) or
                                                      !register?(m) or !m.bit8?
    isolate do |eoc|
        if kh == tl
            raise ArgumentError, "mul8: invalid arguments" if kl == th
                ld   th, kh
                ld   tl, kl unless kl == tl
        else
                ld   tl, kl unless kl == tl
                ld   th, kh unless kh == th
        end
                ld   hl, 0 if clrhl
        if optimize == :time
            if double
                sla  tl
                rl   th
            end
                srl  m
                jr   C, doadd
                jr   Z, eoc
        elsif !double
                jr   muls1
        end
        loop1   sla  tl
                rl   th
        muls1   srl  m
        if optimize == :time
                jr   NC, loop1
        else
                jr   NC, noadd
        end
        doadd   add  hl, tt
        if optimize == :time
                jp   NZ, loop1
        else
        noadd   jr   NZ, loop1
        end
    end
end

# File lib/z80/math_i.rb, line 1441
def mul8_24(kh=h, kl=l, m=b, t:c, tt:de, clrahl:true, k_int24:false, mbit9_carry:false, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul8_24: invalid arguments" if tt == hl or [a, th, tl, t].include?(m) or
                                                        [a, th, tl, m].include?(t) or
                                                        !register?(m) or !register?(t) or
                                                        !m.bit8? or !t.bit8?
    isolate do |eoc|
        if kh == tl
            raise ArgumentError, "mul8_24: invalid arguments" if kl == th
                    ld  th, kh
                    ld  tl, kl unless kl == tl
        else
                    ld  tl, kl unless kl == tl
                    ld  th, kh unless kh == th
        end
        if clrahl
                    xor a
                    ld  h, a
                    ld  l, a
                    ld  t, a unless k_int24
        elsif !k_int24
                    ld  t, 0
        end
        if optimize == :size        # 20 bytes (+~10 cycles per m bit)
            if mbit9_carry
                    rr  m           # CF -> multiplier -> CF
                    jr  cont1
            end
            loop1   srl m           # 0 -> multiplier -> CF
            cont1   jr  Z, last
                    jr  NC, noadd   # CF == 0 ? don't add
                    add hl, tt      # add multiplicand to result lo16
                    adc a, t        # add multiplicand to result hi8
            noadd   sla tl          # multiplicand *= 2
                    rl  th
                    rl  t
                    jr  loop1       # m != 0 ? loop
            last    jr  NC, eoc
                    add hl, tt      # last add
                    adc a, t
        elsif optimize == :time     # 29 bytes
            if mbit9_carry
                    rr  m           # CF -> multiplier -> CF
            else
                    srl m           # 0 -> multiplier -> CF
            end
                    jp  NZ, skip0   # m != 0 ? start regular loop
                    jr  C, skadd    # m == 1 ? add and quit
                    jp  eoc         # m == 0 ? just quit
            skip0   jr  NC, noadd   # CF == 0 ? don't add
            doadd   add hl, tt      # add multiplicand to result lo16
                    adc a, t        # add multiplicand to result hi8
            noadd   sla tl          # multiplicand *= 2
                    rl  th
                    rl  t
                    srl m           # 0 -> multiplier -> carry
                    jr  NC, noadd   # carry == 0 ? don't add
                    jp  NZ, doadd   # carry == 1 and m != 0 ? loop
            skadd   add hl, tt      # last add b.c. carry == 1
                    adc a, t
        else
            raise ArgumentError, "optimize should be :time or :size"
        end
    end
end

# File lib/z80/math_i.rb, line 1507
def mul8_24a(kh=h, kl=l, m=b, t:c, tt:de, k_int24:false, mbit9_carry:false, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul8_24a: invalid arguments" if tt == hl or [a, h, l, th, tl, t].include?(m) or
                                                        [a, th, tl, m].include?(t) or
                                                        !register?(m) or !register?(t) or
                                                        !m.bit8? or !t.bit8?
    isolate do |eoc|
        if kh == tl
            raise ArgumentError, "mul8_24a: invalid arguments" if kl == th
                        ld  th, kh
                        ld  tl, kl unless kl == tl
        else
                        ld  tl, kl unless kl == tl
                        ld  th, kh unless kh == th
        end
        case optimize
        when :unroll
            if k_int24
                        ld   a, t
            else
                        xor  a
                        ld   t, a
            end
                        ld   l, tl unless kl == l
                        ld   h, th unless kh == h
            if mbit9_carry
                        jr   C, iter0     # bit9 of m
            end
            7.times do |i|
                        sla  m            # CF <- m <- 0
                        jr   C, :"iter#{i+1}"
            end
                        sla  m            # CF <- m <- 0
                        jr   C, eoc
                        ld   h, a         # m == 0
                        ld   l, a
                        jp   eoc
            (if mbit9_carry then 0 else 1 end..7).each do |i|
                ns :"iter#{i}" do |eoc|
                        add  hl, hl
                        adc  a, a
                skip9   sla  m            # CF <- m <- 0
                        jr   NC, eoc
                doadd   add  hl, tt
                        adc  a, t
                end
            end
        when :time, :size
            if optimize == :size
                        xor  a
                        ld   t, a unless k_int24
                        ld   l, a
                        ld   h, a
                if mbit9_carry
                        jr   NC, start8
                        add  hl, tt
                        adc  a, t
                end
            else
                if k_int24
                        ld   a, t
                else
                        xor  a
                        ld   t, a
                end
                        ld   l, tl unless kl == l
                        ld   h, th unless kh == h
                if mbit9_carry
                        jr   C, start9    # bit9 of m
                end
            end
            start8      sll  m            # CF <- m <- 1 (terminator)
            if optimize == :size
                        jr   cont2
            else
                        jr   C, cont1
                loop0   sla  m            # CF <- m <- 0
                        jr   NC, loop0
                        jp   NZ, cont1
                        ld   h, a         # m == 0
                        ld   l, a
                        jp   eoc
            end
            if mbit9_carry && optimize != :size
                start9  sll  m            # CF <- m <- 1 (terminator)
                        jr   C, doadd1
            end
                loop1   add  hl, hl       # hl * 2
                        adc  a, a         # a|hl * 2
                cont1   sla  m            # CF <- m <- 0
                cont2   jr   NC, loop1
                        jr   Z, eoc
                doadd1  add  hl, hl       # hl * 2
                        adc  a, a         # a|hl * 2
                        add  hl, tt       # hl + tt
                        adc  a, t         # a|hl + t|tt
                if optimize == :size
                        jr   cont1
                else
                        sla  m            # CF <- m <- 0
                        jr   NC, loop1
                        jp   NZ, doadd1
                end
        else
            raise ArgumentError, "optimize should be :size, :time or :unroll"
        end
    end
end

# File lib/z80/math_i.rb, line 1191
def mul8_c(kh=h, kl=l, m=a, tt:de, clrhl:true)
    th, tl = tt.split
    raise ArgumentError, "mul8_c: invalid arguments" if tt == hl or [th, tl].include?(m) or
                                                        !register?(m) or !m.bit8?
    isolate do |eoc|
        if kh == tl
            raise ArgumentError, "mul8_c: invalid arguments" if kl == th
                ld   th, kh
                ld   tl, kl unless kl == tl
        else
                ld   tl, kl unless kl == tl
                ld   th, kh unless kh == th
        end
                ld   hl, 0 if clrhl
        loop1   srl  m
                jr   NC, noadd
                add  hl, tt
                jr   C, eoc
        noadd   jr   Z, eoc
        skip1   sla  tl
                rl   th
                jp   NC, loop1
    end
end

# File lib/z80/math_i.rb, line 1238
def mul8_signed(kh=h, kl=l, m=c, tt:de, t:m, clrhl:true, double:false, optimize: :time)
    th, tl = tt.split
    raise ArgumentError, "mul8_signed: invalid arguments" if !register?(t) or !t.bit8? or
                                                             [a, tl, th].include?(t) or
                                                             [kh, kl].include?(a)

    isolate do
                ld   a, m unless m == a
        if kh == tl
            raise ArgumentError, "mul8_signed: invalid arguments" if kl == th
                ld   th, kh
                ld   tl, kl unless kl == tl
        else
                ld   tl, kl unless kl == tl
                ld   th, kh unless kh == th
        end
                anda a
                jp   P, mul_it      # m >= 0
                ld   t, a unless t == m
                neg16 th, tl
                xor  a
                sub  t              # a: -m
        mul_it  mul8(th, tl, a, tt:tt, clrhl:clrhl, double:double, optimize:optimize)
    end
end

# File lib/z80/math_i.rb, line 1048
def mul_const(k=d, m=0, tt:de, clrhl:true, signed_k:false)
    raise ArgumentError unless tt != hl and m.is_a?(Integer) and (0..256).include?(m)
    tt = hl if clrhl and (m & (m - 1)) == 0
    th, tl = tt.split
    if m == 0
        return isolate do
                ld   hl, 0 if clrhl
        end
    end

    ml, tsl, clrhlt = m, 4+7, clrhl
    tsl += 19.5 if signed_k
    while (ml & 1) == 0
        tsl += 11
        ml >>= 1
    end if clrhlt
    just_cleared = false
    while tt != hl
        if (ml & 1) != 0
            tsl += if clrhlt
                clrhlt = false
                just_cleared = true
                8
            else
                just_cleared = false
                11
            end
        end
        break if (ml >>= 1) == 0
        if tt == de and ((ml & 1) == 0 or ml == 1 or just_cleared)
            tsl += 4 unless just_cleared
            tsl += 11
            while (ml & 1) == 0
                tsl += 11
                ml >>= 1
            end
            tsl += 4 if ml != 1
        else
            tsl += 16
        end
    end

    mr, tsr, clrhlt = m, 4+7, clrhl
    while mr != 0
        if tt != hl and (mr & 0x100) != 0
            tsr += if clrhlt
                clrhlt = false
                8
            else
                11
            end
        end
        break if (mr & 0xFF) == 0
        tsr += 16
        mr <<= 1
    end

    isolate do
        if tsl <= tsr
            th, tl = hl.split if clrhl
                    ld   tl, k unless k == tl
                    ld   th, 0
            if signed_k
                    bit  7, tl
                    jr   Z, sk_neg
                    dec  th
            sk_neg  label
            end
            th, tl = tt.split if clrhl
            while (m & 1) == 0
                add  hl, hl
                m >>= 1
            end if clrhl
            just_cleared = false
            while tt != hl
                if (m & 1) != 0
                    if clrhl
                        clrhl = false
                        just_cleared = true
                        ld16 tt, hl
                    else
                        just_cleared = false
                        add  hl, tt
                    end
                end
                break if (m >>= 1) == 0
                if tt == de and ((m & 1) == 0 or m == 1 or just_cleared)
                    ex   de, hl unless just_cleared
                    add  hl, hl
                    while (m & 1) == 0
                        add  hl, hl
                        m >>= 1
                    end
                    ex   de, hl if m != 1
                else
                    sla  tl
                    rl   th
                end
            end
        else
                    ld   th, k unless k == th
                    ld   tl, 0
            while m != 0
                if tt != hl and (m & 0x100) != 0
                    if clrhl
                        clrhl = false
                        ld16 hl, tt
                    else
                        add  hl, tt
                    end
                end
                break if (m & 0xFF) == 0
                if signed_k
                    sra  th
                else
                    srl  th
                end
                    rr   tl
                m <<= 1
            end
        end
    end
end

# File lib/z80/math_i.rb, line 1638
def mul_const8_24(kh=h, kl=l, m=0, t:c, tt:de, clrahl:true, signed_k:false)
    th, tl = tt.split
    throw ArgumentError unless m.is_a?(Integer) and (0..256).include?(m) and [bc, de].include?(tt) and
                                                         ![h, l, th, tl, a].include?(t)
    if clrahl and (m & (m - 1)) == 0
        t, tt = a, hl
        th, tl = tt.split
    end
    if m == 0
        return isolate do
            if clrahl
                xor  a
                ld   h, a
                ld   l, a
            end
        end
    end

    ml, tsl, clrahlt = m, 8, clrahl
    if clrahlt
        tsl += if signed_k
            12
        else
            4
        end
    else
        tsl += 7
        tsl += 19.5 if signed_k
    end
    while (ml & 1) == 0
        tsl += 15
        ml >>= 1
    end if clrahlt
    just_cleared = false
    while tt != hl
        if (ml & 1) != 0
            if clrahlt
                clrahlt = false
                just_cleared = true
                tsl += 12
            else
                just_cleared = false
                tsl += 15
            end
        end
        break if (ml >>= 1) == 0
        if tt == de and ((ml & 1) == 0 or ml == 1 or just_cleared)
            tsl += 4 unless just_cleared
            tsl += 19
            while (ml & 1) == 0
                tsl += 19
                ml >>= 1
            end
            tsl += 4 if ml != 1
        else
            tsl += 24
        end
    end

    mr, tsr, clrahlt = m, 8+7, clrahl
    while mr != 0
        if tt != hl and (mr & 0x100) != 0
            if clrahlt
                clrahlt = false
                tsr += 12
            else
                tsr += 15
            end
        end
        break if (mr & 0xFF) == 0
            tsr += 24
        mr <<= 1
    end
    tsr += 4 if t == a

    isolate do
        if tsl <= tsr
            th, tl = hl.split if clrahl
            if th == kl and tl != kh
                        ld   tl, kl
                        ld   th, kh unless th == kh
            elsif th != kl
                        ld   th, kh unless th == kh
                        ld   tl, kl unless tl == kl
            else
                throw ArgumentError, "mul_const8_24 condition violated: kh<>tl or kl<>th"
            end
            if clrahl
                if signed_k
                        ld   a, th
                        add  a, a
                        sbc  a
                else
                        xor  a
                end
            else
                        ld   t, 0
                if signed_k
                        bit  7, th
                        jr   Z, sk_neg
                        dec  t
                sk_neg  label
                end
            end
            th, tl = tt.split if clrahl
            while (m & 1) == 0
                        add  hl, hl
                        adc  a, a
                m >>= 1
            end if clrahl
            just_cleared = false
            while tt != hl
                if (m & 1) != 0
                    if clrahl
                        clrahl = false
                        just_cleared = true
                        ld16 tt, hl
                        ld   t, a
                    else
                        just_cleared = false
                        add  hl, tt
                        adc  a, t  # CF=0 and ZF=1 in case when result 16 bit
                    end
                end
                break if (m >>= 1) == 0
                if tt == de and ((m & 1) == 0 or m == 1 or just_cleared)
                        ex   de, hl unless just_cleared
                        add  hl, hl
                    while (m & 1) == 0
                        rl   t
                        add  hl, hl
                        m >>= 1
                    end
                        ex   de, hl if m != 1
                else
                        sla  tl
                        rl   th
                end
                        rl   t
            end
        else
            if t == kl and th != kh
                        ld   th, kl
                        ld   t,  kh unless t == kh
            elsif t != kl
                        ld   t,  kh unless t == kh
                        ld   th, kl unless th == kl
            else
                throw ArgumentError, "mul_const8_24 condition violated: kh<>th or kl<>t"
            end
                        ld   tl, 0
            while m != 0
                if tt != hl and (m & 0x100) != 0
                    if clrahl
                        clrahl = false
                        ld16 hl, tt
                        ld   a, t
                    else
                        add  hl, tt
                        adc  a, t
                    end
                end
                break if (m & 0xFF) == 0
                if signed_k
                        sra  t
                else
                        srl  t
                end
                        rr   th
                        rr   tl
                m <<= 1
            end
                        anda a if t == a # CF=0 and ZF=1, SF sign
        end
    end
end