```Contributor: MARK LEWIS

Program PYTHAGOREAN_TRIPLES;
{written by Mark Lewis, April 1, 1990}
{developed and written in Turbo Pascal v3.0}

Const
hicnt     = 100;
ZERO      = 0;

Type
PythagPtr = ^PythagRec;           {Pointer to find the Record}
PythagRec = Record                {the Record we are storing}
A : Real;
B : Real;
C : Real;
total : Real;
next : PythagPtr    {Pointer to next Record in line}
end;

Var
Root      : PythagPtr;            {the starting point}
QUIT      : Boolean;
ch        : Char;

Procedure listdispose(Var root : pythagptr);

Var
holder : pythagptr;

begin
if root <> nil then               {if we have Records in the list}
Repeat                          {...}
holder := root^.next;         {save location of next Record}
dispose(root);                {remove this Record}
root := holder;               {go to next Record}
Until root = nil;               {Until they are all gone}
end;

Procedure findpythag(Var root : pythagptr);
Var
x,y,z,stored : Integer;
xy,zz,xx,yy  : Real;
abandon      : Boolean;
workrec      : pythagrec;
last,current : pythagptr;

begin
stored := zero;                   {init count at ZERO}
For z := 1 to hicnt do            {start loop 3}
begin
zz := sqr(z);                 {square loop counter}
if zz < zero then
zz := 65536.0 + zz;  {twiddle For negatives}
For y := 1 to hicnt do        {start loop 2}
begin
yy := sqr(y);             {square loop counter}
if yy < zero then
yy := 65536.0 + yy;  {twiddle For negatives}
For x := 1 to hicnt do    {start loop 1}
begin
abandon := False;     {keep this one}
xx := sqr(x);         {square loop counter}
xy := xx + yy;        {add sqr(loop2) and sqr(loop1)}
if not ((xy <> zz) or ((xy = zz) and (xy = 1.0))) then
begin
With workrec do
begin
a := x;       {put them into our storage Record}
b := y;
c := z;
total := zz;
end;
if root = nil then  {is this the first Record?}
begin
new(root);               {allocate space}
workrec.next := nil;     {anchor the Record}
root^ := workrec;        {store it}
stored := succ(stored);  {how many found?}
end
else                {this is not the first Record}
begin
current := root;  {save where we are now}
Repeat            {walk Records looking For dups}
if (current^.total = workrec.total) then
abandon := True; {is this one a dup?}{abandon it}
last := current;  {save where we are}
current := current^.next  {go to next Record}
Until (current = nil) or abandon;
if not abandon then {save this one?}
begin
{we're going to INSERT this Record into the}
{line between the ones greater than and less}
{than the A Var in the Record}
{ie: 5,12,13 goes between 3,4,5 and 6,8,10}
if root^.a > workrec.a then
begin
new(root);   {allocate mem For this one}
workrec.next := last; {point to next rec}
root^ := workrec;     {save this one}
stored := succ(stored); {how many found?}
end
else  {insert between last^.next and current}
begin
new(last^.next);  {allocate memory}
workrec.next := current; {point to current}
last^.next^ := workrec; {save this one}
stored := succ(stored); {how many found?}
end;
end;
end;
end;
end;
end;
end;
Writeln('I have found and stored ',stored,' Pythagorean Triples.');
end;

Procedure showRecord(workrec : pythagrec);

begin
With workrec do
begin
Writeln('A = ',a:6:0,'  ',sqr(a):6:0);
Writeln('B = ',b:6:0,'  ',sqr(b):6:0,'  ',sqr(a)+sqr(b):6:0);
Writeln('C = ',c:6:0,'  ',sqr(c):6:0,' <-^');
end
end;

Procedure viewlist(root  : pythagptr);

Var
i        : Integer;
current  : pythagptr;

begin
if root = nil then
begin
Writeln('<< Your list is empty! >>');
Write('>> Press (CR) to continue: ');
end
else
begin
Writeln('Viewing Records');
current := root;
While current <> nil do
begin
showRecord(current^);
Write('Press (CR) to view next Record. . . ');
current := current^.next
end;
end
end;

begin
Writeln('PYTHAGOREAN TRIPLES');
Writeln('-------------------');
Writeln;
Writeln('Remember the formula For a Right Triangle?');
Writeln('A squared + B squared = C squared');
Writeln;
Writeln('I call the set of numbers that fits this formula');
Writeln('         Pythagorean Triples');
Writeln;
Writeln('This Program Uses a "brute force" method of finding all');
Writeln('the Pythagorean Triples between 1 and 100');
Writeln;
root := nil;
quit := False;
Repeat
Writeln('Command -> [F]ind, [V]iew, [D]ispose, [Q]uit ');