How to use the reil.x86.operand.set_register function in reil

def x86_lods(ctx, i, size):
    src = ctx.source

    value = ctx.tmp(size)

    if i.mnemonic.startswith('rep'):
        rep_prologue(ctx, i)

    ctx.emit(  ldm_  (src, value))

    if size == 8:
        operand.set_register(ctx, i, 'al', value)
    elif size == 16:
        operand.set_register(ctx, i, 'ax', value)
    elif size == 32:
        operand.set_register(ctx, i, 'eax', value)
    else:
        operand.set_register(ctx, i, 'rax', value)

    ctx.emit(  jcc_  (r('df', 8), 'decrement'))
    ctx.emit('increment')
    ctx.emit(  add_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit(  jcc_  (imm(1, 8), 'set'))
    ctx.emit('decrement')
    ctx.emit(  sub_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit('set')
    ctx.emit(  str_  (src, ctx.source))

    if i.mnemonic.startswith('rep'):
        rep_epilogue(ctx, i)

value = ctx.tmp(size)

    if i.mnemonic.startswith('rep'):
        rep_prologue(ctx, i)

    ctx.emit(  ldm_  (src, value))

    if size == 8:
        operand.set_register(ctx, i, 'al', value)
    elif size == 16:
        operand.set_register(ctx, i, 'ax', value)
    elif size == 32:
        operand.set_register(ctx, i, 'eax', value)
    else:
        operand.set_register(ctx, i, 'rax', value)

    ctx.emit(  jcc_  (r('df', 8), 'decrement'))
    ctx.emit('increment')
    ctx.emit(  add_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit(  jcc_  (imm(1, 8), 'set'))
    ctx.emit('decrement')
    ctx.emit(  sub_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit('set')
    ctx.emit(  str_  (src, ctx.source))

    if i.mnemonic.startswith('rep'):
        rep_epilogue(ctx, i)

def x86_lods(ctx, i, size):
    src = ctx.source

    value = ctx.tmp(size)

    if i.mnemonic.startswith('rep'):
        rep_prologue(ctx, i)

    ctx.emit(  ldm_  (src, value))

    if size == 8:
        operand.set_register(ctx, i, 'al', value)
    elif size == 16:
        operand.set_register(ctx, i, 'ax', value)
    elif size == 32:
        operand.set_register(ctx, i, 'eax', value)
    else:
        operand.set_register(ctx, i, 'rax', value)

    ctx.emit(  jcc_  (r('df', 8), 'decrement'))
    ctx.emit('increment')
    ctx.emit(  add_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit(  jcc_  (imm(1, 8), 'set'))
    ctx.emit('decrement')
    ctx.emit(  sub_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit('set')
    ctx.emit(  str_  (src, ctx.source))

def x86_lods(ctx, i, size):
    src = ctx.source

    value = ctx.tmp(size)

    if i.mnemonic.startswith('rep'):
        rep_prologue(ctx, i)

    ctx.emit(  ldm_  (src, value))

    if size == 8:
        operand.set_register(ctx, i, 'al', value)
    elif size == 16:
        operand.set_register(ctx, i, 'ax', value)
    elif size == 32:
        operand.set_register(ctx, i, 'eax', value)
    else:
        operand.set_register(ctx, i, 'rax', value)

    ctx.emit(  jcc_  (r('df', 8), 'decrement'))
    ctx.emit('increment')
    ctx.emit(  add_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit(  jcc_  (imm(1, 8), 'set'))
    ctx.emit('decrement')
    ctx.emit(  sub_  (src, imm(value.size // 8, ctx.word_size), src))
    ctx.emit('set')
    ctx.emit(  str_  (src, ctx.source))

    if i.mnemonic.startswith('rep'):
        rep_epilogue(ctx, i)

result_rdx = ctx.tmp(64)

    ctx.emit(  lshl_  (rdx, imm(64, 8), rdx_rax))
    ctx.emit(  str_   (rax, tmp0))
    ctx.emit(  or_    (rdx_rax, tmp0, rdx_rax))

    ctx.emit(  equ_  (value, rdx_rax, tmp1))
    ctx.emit(  jcc_  (tmp1, 'equal'))

    ctx.emit('not-equal')
    ctx.emit(  str_  (value, result_rax))
    ctx.emit(  lshr_ (value, imm(64, 8), value))
    ctx.emit(  str_  (value, result_rdx))

    operand.set_register(ctx, i, 'rdx', result_rdx)
    operand.set_register(ctx, i, 'rax', result_rax)

    ctx.emit(  str_  (imm(0, 8), r('zf', 8)))
    ctx.emit(  jcc_  (imm(1, 8), 'done'))

    ctx.emit('equal')
    ctx.emit(  lshl_  (rcx, imm(64, 8), rcx_rbx))
    ctx.emit(  str_   (rbx, tmp0))
    ctx.emit(  or_    (rcx_rbx, tmp0, rcx_rbx))

    operand.set(ctx, i, 0, rcx_rbx)

    ctx.emit(  str_  (imm(1, 8), r('zf', 8)))

    ctx.emit('done')
    ctx.emit(  nop_())

result_ah = imm(0, 8)
    tmp0 = ctx.tmp(16)

    ctx.emit(  div_  (al, base, result_ah))
    ctx.emit(  mod_  (al, tmp0, result_al))

    set_sf(ctx, result_al)
    set_zf(ctx, result_al)
    set_pf(ctx, result_al)

    ctx.emit(  undef_(r('of', 8)))
    ctx.emit(  undef_(r('af', 8)))
    ctx.emit(  undef_(r('cf', 8)))

    operand.set_register(ctx, i, 'al', result_al)
    operand.set_register(ctx, i, 'ah', result_ah)

ctx.emit(  str_  (tmp0, result_al))

    ctx.emit(  add_  (ah, imm(1, 8), tmp0))
    ctx.emit(  str_  (tmp0, result_ah))

    ctx.emit(  str_  (imm(1, 8), r('af', 8)))
    ctx.emit(  str_  (imm(1, 8), r('cf', 8)))

    ctx.emit('done')

    ctx.emit(  undef_(r('of', 8)))
    ctx.emit(  undef_(r('sf', 8)))
    ctx.emit(  undef_(r('zf', 8)))
    ctx.emit(  undef_(r('pf', 8)))

    operand.set_register(ctx, i, 'al', result_al)
    operand.set_register(ctx, i, 'ah', result_ah)

result_eax = ctx.tmp(32)
    result_edx = ctx.tmp(32)

    ctx.emit(  lshl_  (edx, imm(32, 8), edx_eax))
    ctx.emit(  str_   (eax, tmp0))
    ctx.emit(  or_    (edx_eax, tmp0, edx_eax))

    ctx.emit(  equ_  (value, edx_eax, tmp1))
    ctx.emit(  jcc_  (tmp1, 'equal'))

    ctx.emit('not-equal')
    ctx.emit(  str_  (value, result_eax))
    ctx.emit(  lshr_ (value, imm(32, 8), value))
    ctx.emit(  str_  (value, result_edx))

    operand.set_register(ctx, i, 'edx', result_edx)
    operand.set_register(ctx, i, 'eax', result_eax)

    ctx.emit(  str_  (imm(0, 8), r('zf', 8)))
    ctx.emit(  jcc_  (imm(1, 8), 'done'))

    ctx.emit('equal')
    ctx.emit(  lshl_  (ecx, imm(32, 8), ecx_ebx))
    ctx.emit(  str_   (ebx, tmp0))
    ctx.emit(  or_    (ecx_ebx, tmp0, ecx_ebx))

    operand.set(ctx, i, 0, ecx_ebx)

    ctx.emit(  str_  (imm(1, 8), r('zf', 8)))

    ctx.emit('done')
    ctx.emit(  nop_())