Using assembly to convert the temperature from Celsius into Fahrenheit, and back again

I am using the following x86 assembly instructions to convert from degrees Celsius into degrees Fahrenheit:

  imul dword [NINE]
  idiv dword [FIVE]
  add  eax, 32

For rather a lot of inputs this produces an off-by-one error:

> 1 °C produces 33 °F, but expecting 34 °F (33.8 °F)
> -1 °C produces 31 °F, but expecting 30 °F (30.2 °F)

For now, I solved the issue through inspection of the remainder from the signed division by 5 and then rounding accordingly:

  imul dword [NINE]
  idiv dword [FIVE]   ; -> Remainder EDX=[-4,4]
  add  eax, 32+1
  cmp  edx, 2
  jg   @f
  dec  eax
  cmp  edx, -2
  jge  @f
  dec  eax
@@:

I would very much prefer a branchless solution since I've heard it would be faster, generally speaking.
Additionally, how can I change the code so it returns a decimal fraction?

From Celsius to Fahrenheit

The straightforward implementation in x86 assembly for the conversion from Celsius to Fahrenheit uses next formula:

> Fahrenheit = (Celsius * 9 / 5) + 32

; IN (eax) OUT (eax) MOD (edx)
C2F_a:  imul    dword [NINE]
        idiv    dword [FIVE]
        add     eax, 32
        ret

Signed operations are needed because both Celsius and Fahrenheit also exist in the negative numbers range. Their scales begin at absolute zero (0 K): Celsius starts at -273.15 °C and Fahrenheit starts at -459.67 °F.

Rounding

An important drawback of the above code is that the results don't get properly rounded to the nearest integer. (idiv rounds toward zero, aka truncation.) The simplest way to achieve this kind of rounding would be to add 2 to the dividend prior to dividing by 5. Sadly, this only works well for positive inputs. For negative inputs, we would rather need to subtract 2 before dividing by 5.
Next solution therefore avoids signed division by first adding a suitable bias to the input. The remainder of the code no longer needs to consider negative numbers. A bias of 275 will render any legal input positive, and will not introduce a further rounding issue because the value that will eventually remove the bias is an integer: (275 * 9 / 5) = 495.

> Fahrenheit = (((Celsius + 275) * 9) + 2) / 5 + (32 - 495)

; IN (eax) OUT (eax) MOD (edx)
C2F_b:  add     eax, 275
        imul    eax, 9
        add     eax, 2
        xor     edx, edx
        div     dword [FIVE]
        add     eax, 32-495
        ret

Optimization

It is possible to replace the multiplication by 9 with a LEA instruction that at the same time absorbs several additions.
It is equally possible to replace the division by 5 with a multiplication by 5's multiplicative inverse.

> Fahrenheit = (((Celsius + 275) * 9) + 2) / 5 + (32 - 495)

; IN (eax) OUT (eax) MOD (edx)
C2F_c:  lea     eax, [eax+eax*8+(275*9)+2]
        mov     edx, 0CCCCCCCDh
        mul     edx
        shr     edx, 2
        lea     eax, [edx+32-495]
        ret

Precision

Using decimal fixed-point numbers with scaling 1/100, we can deliver results that are accurate to 2 decimal places. eg. -273.15 °C gets stored as the signed integer -27315, and will output the signed integer -45967 which represents -459.67 °F.

> Fahrenheit = (((Celsius + 27500) * 9) + 2) / 5 + (3200 - 49500)

; IN (eax) OUT (eax) MOD (edx)
C2F_d:  lea     eax, [eax+eax*8+(27500*9)+2]
        mov     edx, 0CCCCCCCDh
        mul     edx
        shr     edx, 2
        lea     eax, [edx+3200-49500]
        ret

From Fahrenheit to Celsius

The straightforward implementation in x86 assembly for the conversion from
Fahrenheit to Celsius uses next formula:

> Celsius = (Fahrenheit - 32) * 5 / 9

; IN (eax) OUT (eax) MOD (edx)
F2C_a:  sub     eax, 32
        imul    dword [FIVE]
        idiv    dword [NINE]
        ret

Signed operations are needed because both Celsius and Fahrenheit also exist in the negative numbers range. Their scales begin at absolute zero (0 K): Celsius starts at -273.15 °C and Fahrenheit starts at -459.67 °F.

Rounding

An important drawback of the above code is that the results don't get properly rounded to the nearest integer. The simplest way to achieve this kind of rounding would be to add 4 to the dividend prior to dividing by 9. Sadly, this only works well for positive inputs. For negative inputs, we would rather need to subtract 4 before dividing by 9.
Next solution therefore avoids signed division by first adding a suitable bias to the input. The remainder of the code no longer needs to consider negative numbers. A bias of 495 will render any legal input positive, and will not introduce a further rounding issue because the value that will eventually remove the bias is an integer: (495 * 5 / 9) = 275.

> Celsius = (((Fahrenheit + 495 - 32) * 5) + 4) / 9 - 275

; IN (eax) OUT (eax) MOD (edx)
F2C_b:  add     eax, 495-32
        imul    eax, 5
        add     eax, 4
        xor     edx, edx
        div     dword [NINE]
        sub     eax, 275
        ret

Optimization

It is possible to replace the multiplication by 5 with a LEA instruction that at the same time absorbs several additions.
It is equally possible to replace the division by 9 with a multiplication by 9's multiplicative inverse.

> Celsius = (((Fahrenheit + 495 - 32) * 5) + 4) / 9 - 275

; IN (eax) OUT (eax) MOD (edx)
F2C_c:  lea     eax, [eax+eax*4+(495-32)*5+4]
        mov     edx, 38E38E39h
        mul     edx
        shr     edx, 1
        lea     eax, [edx-275]
        ret

Precision

Using decimal fixed-point numbers with scaling 1/100, we can deliver results that are accurate to 2 decimal places. eg. -459.67 °F gets stored as the signed integer -45967, and will output the signed integer -27315 which represents -273.15 °C.

> Celsius = (((Fahrenheit + 49500 - 3200) * 5) + 4) / 9 - 27500

; IN (eax) OUT (eax) MOD (edx)
F2C_d:  lea     eax, [eax+eax*4+(49500-3200)*5+4]
        mov     edx, 38E38E39h
        mul     edx
        shr     edx, 1
        lea     eax, [edx-27500]
        ret