Yeah! That's very nasty!
This code does not belong here. You should have translated it into fasm first and then posted it here.
What's the purpose of it? Tell me you stupid, blockhead, dumb creature!

I can't understand it, or compile it with fasm/nasm/masm/gas/goasm and to top it all it's horrible to look at!

Go learn some ettiquettes before posting here.

Go learn some ettiquettes before posting here.

62-byte Sudoku solver (using Octasm) (six lines, good for a sig):

Code:

LANG OCTASM,0.1 org 100h use16 file_out \sudoku.com ah=3Fh dx=bp # int 21h
xchg ax,cx inc bx # [bp+si]=al # dec si js <3 ax=4031h # cmp b[bp+si],'.'
jne <2 di=cx # dec di pusha js <4 cmp [bp+di],al jne >2 xchg ax,di # aam 19
imul ax,11 xchg ax,si inc bx jpo <1 xor ax,si test ax,0E0C0h jle >2 # mul ah
# popa jo <4 b[bp+si]='.' cmp al,39h je <1 jmp <5-1 ; solver: `sudoku.com < 1.puz'
; G3=tgm80@@mail,ru  TFx=tfx@@bitmaster,it  Digimind=digimind@@aha,ru
    

Comparing files entry.old and entry.ASM
***** entry.old

        model tiny
        codeseg
        startupcode
        .486

***** entry.ASM

;        model tiny
;        codeseg
;        startupcode
;        .486
ptr equ
org 100h

*****

***** entry.old
        jmp     ChkDgt-1
        end
***** entry.ASM
        jmp     ChkDgt-1
;        end
*****
    

here is my quick try to beat you. It's 360 bytes of pure oldschool 16bit DOS code.

it shows ALL possible solutions (yours seem to get stuck in endless loop if there is more than 1 solution)

btw, code is still not after some heavy optimizations.

sources may be released after it is optimized. anyway, 360 bytes isn't that much to reverse

; ss.com - DOS sudoku solver (for multiple solution puzzles)
; author: vid / M. Mocko
; assembler: FASM
; license: ??? (but permission to disassemble, so I did)
; URL: http://board.flatassembler.net/topic.php?t=6076

org 100h
  
Komenco:
  mov di,space
  mov cx,2d00h ; 11520
  mov al,0
  rep stosb

  xor bx,bx
  jmp Boop

Booga:
  int 21h
  cmp al,13
  jnz Eraro
  int 21h
  cmp al,10
  jnz Eraro

Boop:
  mov bl,0
  jmp Getkey

Blerp:
  int 21h
  cmp al,' '
  jnz Eraro

Getkey:
  mov ah,8
  int 21h

  cmp al,'1'
  jc Eraro
  cmp al,'9'
  jna Donkey
  cmp al,'x'
  jnz Eraro
  sub al,'H'
  inc byte [last]

Donkey:
  sub al,'0'
  mov [bx+space],al
  inc bl
  cmp bl,9
  jc Blerp
  inc bh
  cmp bh,bl
  jc Booga
  call Stooges
  add word [Droop+2],900h
  or byte [DroopJump],1
  mov word [DroopNop],09b3h ; "nop,nop" -> "mov bl,9" (self-modify)
  mov byte [MagicOne+1],0
  mov byte [MagicTwo+1],0
  call Yup
  ret

Eraro:
  mov ah,9
  mov dx,msg
  int 21h
  ret

msg db 'Bad input!$'

Yup:
  cmp byte [last],0
  ja Stooges
  call Boring
  ret

Stooges:
  mov si,9
Moe:
  mov cx,3
Larry:
  mov dx,3
Curly:
  mov bh,dl
  add bh,[si+smelly-1]
  mov bl,cl
  add bl,[si+dollar]

Droop:
  mov al,[bx+last-100h]
  mov [bx+last+800h],al
  cmp al,0
DroopJump:
  jz Moo
  xchg ax,bx
DroopNop:
  nop
  nop

Ook:
  push ax
  mov bh,al
  mov di,bx
  mov al,0
  or ax,si
  xchg bh,al
  mov al,bl
  mov bp,ax
  pop ax
MagicOne:
  jmp Plop

  cmp byte [bx+last+2300h],0
  jnz Frog
  cmp byte [di+last+1100h],0
  jnz Frog
  cmp byte [bp+last+1A00h],0
  jnz Frog

Plop:
  mov byte [bx+last+2300h],1
  mov byte [bp+last+1A00h],1
  mov byte [di+last+1100h],1
MagicTwo:
  jmp Moo
  xchg ax,bx
  mov [bx+last+800h],al
  dec byte [last]
  pusha
  call Yup
  popa
  inc byte [last]
  mov byte [bx+last+800h],0
  xchg ax,bx
  mov byte [bx+last+2300h],0
  mov byte [bp+last+1A00h],0
  mov byte [di+last+1100h],0
Frog:
  dec bl
  jnz Ook
  ret

Moo:
  dec dx
  jnz word Curly
  dec cx
  jnz word Larry
  dec si
  jnz word Moe
  ret

Boring:
  pusha
  xor bx,bx
Quux:
  mov bl,0
  jmp Grok
Borg:
  mov dl,' '
  int 21h

Grok:
  mov dl,[bx+space+900h]
  add dl,'0'
  mov ah,2
  int 21h
  inc bx
  cmp bl,9
  jc Borg
  mov dx,crlf
  mov ah,bl
  int 21h
  inc bh
  cmp bh,bl
  jc Quux
  int 21h
  popa
Fino:
  ret

crlf   db 13,10
dollar db '$'
doydoy db 0,3,6
       db 0,3,6
       db 0,3,6
smelly db 0,0,0
       db 3,3,3
       db 6,6,6
last   db 0

space:

; EOF