As a note, I have done some slight reorganization on the global variables. I stuck all of the global variables related to these functions in one record. It just makes more sense, and is easier to keep track of.

The ReadTimer function presented below just reads from the BIOS the number of clock ticks that have occured since midnight. To get this into seconds, we must divide by 18.2 since the clock ticks at 18.2 times a second.

Without any further ado (is that a word?)....

PROGRAM LineExample;
USES CRT;   { Include the "KeyPressed" function }
TYPE
  ScreenBufferType = ARRAY[0..63999] OF BYTE;
  ScreenBufferPtr = ^ScreenBufferType;
  ScreenType = RECORD
    Buffer : ScreenBufferPtr;
    YTable : ARRAY[0..199] OF WORD;   { Y can range from 0 - 199 }
    Width  : WORD;
  END;

VAR
  Screen : ScreenType;

PROCEDURE CalcScreenY(Width : WORD);  { Allow for future expansion }
VAR I : INTEGER;
BEGIN
  FOR I := 0 TO 199 DO
    Screen.YTable[I] := I*Width;
END;

PROCEDURE InitGraph;
BEGIN
  ASM
    mov AX, 0013h    { Function 0, mode 13h }
    int 10h
  END;
  Screen.Buffer := PTR($A000, 0);   { Set up the screen buffer pointer }
  Screen.Width := 320;
  CalcScreenY(320);
END;

PROCEDURE CloseGraph; ASSEMBLER;
ASM
  mov AX, 0003h      { Function 0, Mode 3}
  int 10h
END;

PROCEDURE HLine(X1, Y, X2 : INTEGER; Color : BYTE); ASSEMBLER;
ASM
  les DI, Screen.Buffer  { Only load ES and DI at the start }
  add DI, X1
  mov BX, Y       { Y is an index into the ScreenY array        }
  add BX, BX      { Multipy by two because each entry is a word }
  add DI, DS:[BX+OFFSET Screen.YTable]

  { At this point, DI points to the first pixel in the line.  }
  { Now we will calculate how many times to loop (X2-X1+1)... }

  mov CX, X2
  mov AL, Color   { Load the color }
  mov AH, AL
  sub CX, X1
  inc CX

  test DI, 1      { Are we on an odd address?  }
  jz @Even
  stosb           { Store the first byte       }
  dec CX          { Decrement the counter one  }
@Even:            { Even address               }
  shr CX, 1       { Do half as many transfers  }
  rep stosw       { Copy all of the even words }
  adc CX, 0       { If there is a pixel left over, set CX to 1 }
  rep stosb       { If there is a pixel left over, fill it!    }
END;

PROCEDURE VLine(X, Y1, Y2 : INTEGER; Color : BYTE); ASSEMBLER;
ASM
  les DI, Screen.Buffer  { Only load ES and DI at the start }
  add DI, X
  mov BX, Y1      { Y1 is an index into the ScreenY array       }
  add BX, BX      { Multipy by two because each entry is a word }
  add DI, DS:[BX+OFFSET Screen.YTable]

  { At this point, DI points to the first pixel in the line.  }
  { Now we will calculate how many times to loop (Y2-Y1+1)... }

  mov CX, Y2
  sub CX, Y1      { Calculate the Delta X  }
  inc CX

  mov DX, Screen.Width { 320 }
  mov AL, Color   { Load the color         }

  mov BX, CX
  and BX, 3       { Get remainder of CX DIV 4 }
  shr CX, 2       { Repeated four times    }
  add BX, BX      { Index into a word table}
  jmp WORD PTR CS:[@JumpTable+BX]

@JumpTable:
  dw OFFSET @Iteration5
  dw OFFSET @Iteration4
  dw OFFSET @Iteration3
  dw OFFSET @Iteration2

@Iteration1:
  mov ES:[DI], AL { Set a pixel            }
  add DI, DX      { Increment address      }

@Iteration2:
  mov ES:[DI], AL { Set a pixel            }
  add DI, DX      { Increment address      }

@Iteration3:
  mov ES:[DI], AL { Set a pixel            }
  add DI, DX      { Increment address      }

@Iteration4:
  mov ES:[DI], AL { Set a pixel            }
  add DI, DX      { Increment address      }

@Iteration5:
  dec CX          { Decrement loop counter }
  jns @Iteration1 { Repeat if neccesary    }
END;

FUNCTION ReadTimer : LONGINT; ASSEMBLER;
ASM mov AX, 40h; mov ES, AX; mov AX, ES:[6Ch]; mov DX, ES:[6Eh] END;

VAR
  I, J : INTEGER;
  HLineTimer,
  VLineTimer : LONGINT;
  HLineTime,
  VLineTime : REAL;
BEGIN
  InitGraph;

  HLineTimer := ReadTimer;
  FOR J := 0 TO 99 DO
  FOR I := 0 TO 199 DO
    HLine(0, I, 319, I);
  HLineTimer := ReadTimer - HLineTimer;
  HLineTime := HLineTimer / 18.2;

  VLineTimer := ReadTimer;
  FOR J := 0 TO 99 DO
  FOR I := 0 TO 319 DO
    VLine(I, 0, 199, I);
  VLineTimer := ReadTimer - VLineTimer;
  VLineTime := VLineTimer / 18.2;

{  WHILE NOT KeyPressed DO; {}
  CloseGraph;
  WRITELN('HLine time: ', HLineTime :4:4, ' seconds');
  WRITELN('Number of pixels in HLine test: ', 100*200*320);
  WRITELN('Millions of pixels per second: ', (100*200*320) / HLineTime / 1000000:4:6);
  WRITELN;

  WRITELN('VLine time: ', VLineTime :4:4, ' seconds');
  WRITELN('Number of pixels in VLine test: ', 100*320*200);
  WRITELN('Millions of pixels per second: ', (100*320*200) / VLineTime / 1000000:4:6);
  WRITELN;

  WRITELN('Press any key to continue or any other key to quit');
  WHILE NOT KeyPressed DO;
END.