My first big Assembly program

I wrote this back in high school when I was 15 and absolutely terribad. I figured it could be good for a laugh.

  .model small ;Sets segement size
  .stack 100h ;Sets stack size
  .data
  flag db 0
  again db "Would you like to convert another number?" ,13,10, "Y/N?", "$"
  welcome db "Enter the first letter of the number type you are converting, the supported types are: Decimal, Hexadecimal, and Binary",13,10,"press Q to quit",13,10,"$"
  innumb db "Enter the decimal number that is to be converted, the number can be as low as 0 and as high as 255, other values will cause errors, once you type in the number press D.",13,10,"$"
  error db "Error- improper input",13,10,"$"
  inerror db "Error- You have not entered a number" ,13,10, "$"
  spice db "                                            ", "$"
   a db "A" ,"$"
  b db "B" ,"$"
  c db "C","$"
  d db "D","$"
  e db "E","$"
  f db "F","$"
  h db "h","$"
  nine db "9","$"
  eight db "8" ,"$"
  seven db "7" ,"$"
  six db "6", "$"
  five db "5", "$"
  four db "4", "$"
  three db "3", "$"
  two db "2", "$"
  one db "1", "$"
  zero db "0", "$"
  .code
  mainstart:
   mov  ax,@data
   mov ds,ax

   jmp cased

   converter:
   cmp al, '1'
   je con1
   cmp al,'2'
   je con2
   cmp al,'3'
   je con3
   cmp al, '4'
   je con4
   cmp al,'5'
   je con5
   cmp al,'6'
   je con6
   cmp al,'7'
   je con7
   cmp al,'8'
   je con8
   cmp al,'9'
   je con9
   cmp al,'0'
   je con0
   mov ah, 9
   mov dx, offset error
   int 21h
   jmp cased

   con1:
   mov al, 1d
   ret
   con2:
   mov al, 2d
   ret
   con3:
   mov al,3d
   ret
   con4:
   mov al, 4d
   ret
   con5:
   mov al, 5d
   ret
   con6:
   mov al, 6d
   ret
   con7:
   mov al, 7d
   ret
   con8:
   mov al, 8d
   ret
   con9:
   mov al, 9d
   ret
   con0:
   mov al, 0
   ret

   inputerror:
   mov dx, offset inerror
   mov ah, 9
   int 21h
   jmp input

   Flagrunner:
   mov CL, AL
   mov flag, 1

   input:
   mov ah, 1
   int 21h
   or al, 20h
   cmp al,'d'
   je finishinput
   call converter
   cmp flag, 1
   jc flagrunner
   mov bl, cl
   shl cl, 3
   shl bl, 1
   add cl, bl
   add cl, al
   jmp input

   finishinput:
   cmp flag, 1
   jc inputerror
   mov dx, offset spice
   mov ah, 9
   int 21h
   mov al, cl
   mov flag, 0
   ret

   caseD:
   mov flag, 0
   mov ah, 9
   mov dx, offset innumb
   int 21h
   mov dx, offset spice
   int 21h
   call input
   call DTB ; decimal to binary
   mov ah, 9
   mov dx, offset spice
   int 21h
   call BTH ; binary to hex
   jmp finisher

   secondhalf:
   and cl, 00001111b
   cmp cl, 0
   je p0r
   cmp cl, 1d
   je p1r
   cmp cl, 2d
   je p2r
   cmp cl, 3d
   je p3r
   cmp cl, 4d
   je p4r
   cmp cl, 5d
   je p5r
   cmp cl, 6d
   je p6r
   cmp cl, 7d
   je p7r
   cmp cl, 8d
   je p8r
   cmp cl, 9d
   je p9r
   cmp cl, 10d
   je par
   cmp cl, 11d
   je pbr
   cmp cl, 12d
   je pcr
   cmp cl, 13d
   je pdr
   cmp cl, 14d
   je per
   cmp cl, 15d
   je pfr

   p0r:
   jmp p0

   p1r:
   jmp p1

   p2r:
   jmp p2

   p3r:
   jmp p3

   p4r:
   jmp p4

   p5r:
   jmp p5

   p6r:
   jmp p6

   p7r:
   jmp p7

   p8r:
   jmp p8

   p9r:
   jmp p9

   par:
   jmp pa

   pbr:
   jmp pb
   pcr:
   jmp pc
   pdr:
   jmp pd
   per:
   jmp pe
   pfr:
   jmp pf
   BTH:
   mov dx, offset zero
   mov ah, 9
   int 21h
   mov cl, bh
   call firsthalf
   call secondhalf
   mov dx, offset h
   mov ah, 9
   int 21h
   ret
   firsthalf:
   and bh, 11110000b
   cmp bh, 0
   je p0
   cmp bh, 00010000b
   je p1
   cmp bh, 00100000b
   je p2
   cmp bh, 00110000b
   je p3
   cmp bh, 01000000b
   je p4
   cmp bh, 01010000b
   je p5
   cmp bh, 01100000b
   je p6
   cmp bh, 01110000b
   je p7
   cmp bh, 10000000b
   je p8
   cmp bh, 10010000b
   je p9
   cmp bh, 10100000b
   je pa
   cmp bh, 10110000b
   je pb
   cmp bh, 11000000b
   je pc
   cmp bh, 11010000b
   je pd
   cmp bh, 11100000b
   je pe
   cmp bh, 11110000b
   je pf
   p0:
   mov dx, offset zero
   int 21h
   ret
   p1:
   mov dx, offset one
   mov ah, 9
   int 21h
   ret
   p2:
   mov dx, offset two
   mov ah, 9
   int 21h
   ret
   p3:
   mov dx, offset three
   mov ah, 9
   int 21h
   ret
   p4:
   mov dx, offset four
   mov ah, 9
   int 21h
   ret
   p5:
   mov dx, offset five
   mov ah, 9
   int 21h
   ret
   p6:
   mov dx, offset six
   mov ah, 9
   int 21h
   ret
   p7:
   mov dx, offset seven
   mov ah, 9
   int 21h
   ret
   p8:
   mov dx, offset eight
   mov ah, 9
   int 21h
   ret
   p9:
   mov dx, offset nine
   mov ah, 9
   int 21h
   ret
   pa:
   mov dx, offset a
   mov ah, 9
   int 21h
   ret
   pb:
   mov dx, offset b
   mov ah, 9
   int 21h
   ret
   pc:
   mov dx, offset c
   mov ah, 9
   int 21h
   ret
   pd:
   mov dx, offset d
   mov ah, 9
   int 21h
   ret
   pe:
   mov dx, offset e
   mov ah, 9
   int 21h
   ret
   pf:
   mov dx, offset f
   mov ah, 9
   int 21h
   ret
   DTB:
   mov bl, cl
   and cl, 10000000b
   cmp cl, 10000000b
   je printone
   call printzero
   DTB2:
   mov cl, bl
   and cl, 01000000b
   cmp cl, 01000000b
   je printone
   call printzero
   DTB3:
   mov cl, bl
   and cl, 00100000b
   cmp cl, 00100000b
   je printone
   call printzero
   DTB4:
   mov cl, bl
   and cl, 00010000b
   cmp cl, 00010000b
   je printone
   call printzero
   DTB5:
   mov cl, bl
   and cl, 00001000b
   cmp cl, 00001000b
   je printone
   call printzero
   DTB6:
   mov cl, bl
   and cl, 00000100b
   cmp cl, 00000100b
   je printone
   call printzero
   DTB7:
   mov cl, bl
   and cl, 00000010b
   cmp cl, 00000010b
   je printone
   call printzero
   DTB8:
   mov cl, bl
   and cl, 00000001b
   cmp cl, 00000001b
   je printone
   call printzero
   DTB9:
   ret
   printone:           
   mov ah, 9
   mov dx, offset one
   int 21h
   shl bh, 1
   inc bh
   cmp cl, 10000000b
   je DTB2
   cmp cl, 01000000b
   je DTB3
   cmp cl, 00100000b
   je DTB4
   cmp cl, 00010000b
   je DTB5
   cmp cl, 00001000b
   je DTB6
   cmp cl, 00000100b
   je DTB7
   cmp cl, 00000010b
   je DTB8
   jmp DTB9
   printzero:
   shl bh, 1
   mov ah,9
   mov dx, offset zero
   int 21h
   ret
   casedr:
   jmp cased
   finisher:
   mov ah, 9
   mov dx, offset spice
   int 21h
   mov dx, offset again
   int 21h
   mov ah, 7
   int 21h
   cmp al, 'y'
   je casedr
   mov ah,4ch ; DOS terminate programm
   mov al,0
   int 21h
  end mainstart

[code] arghhhh

Ain't no ASM I know.

big
Hm.