Procedure SumLongTwo(A, B : Nlong; Var C : Tlong);
Var i, k : Integer;
Begin
FillChar(C, SizeOf (C), 0)
If A[0] > B[0] Then k :=A[0] Else k :=B[0];
For i :=l To k Do
Begin С [i+1] :=(C[i] + A[i] + B[i]) Div Osn;
C[i] :=(C[i] + A[i] + B[i]) Mod Osn
{Есть ли в этих операторах ошибка?}
End;
If C[k+l]=0 Then C[0] :=k Else C[0] :=k + l
End;

Function Eq(A, B : TLong) : Boolean;
Var i : Integer;
Begin
Eq :=False;
If A[0] <> B[0] Then Exit
Else Begin
i :=l;
While (i <=A[0]) And (A[i]=B[i]) Do Inc(i);
Eq :=i=A[0] + l
End
End;

Function More(A, B : Tlong) : Boolean;
Var i : Integer;
Begin If A[0] < B[0] Then More :=False
Else If A[0] > B[0] Then More :=True
Else Begin
i :=A[0];
While (i > 0) And (A[i]=B[i]) Do Dec(i);
If i=0 Then More :=False
Else If A[i] > B[i] Then More :=True
Else More:=False
End
End;

Function Less(A, B : Tlong) : Boolean; {A < B}
Begin
Less :=Not(More(A, B) Or Eq(A, B))
End;
Function More_Eq(A, B : Tlong) : Boolean; {A >=B}
Begin
More_Eq :=More(A, B) Or Eq(A, B)
End;
Function Less_Eq(A, B : Tlong) : Boolean; {A <=B}
Begin
Less_Eq :=Not More(A, B)
End;

Function More(Const А, В : Tlong; Const sdvig : Integer) : Byte;
Var i : Integer;
Begin
If A[0] > B[0] + sdvig Then More :=0
Else
If A[0] < B[0] + sdvig Then More :=l
Else Begin
i :=A[0];
While (i > sdvig) And
(A[i]=B[i-sdvig]) Do Dec(i);
If i=sdvig Then Begin
More:=0;
{совпадение чисел с учетом сдвига}
For i :=1 To sdvig Do
If A[i] > 0 Then Exit;
More :=2;
{числа равны, "хвост" числа А равен нулю}
End
Else More :=Byte(A[i] < B[i-sdvig])
End
End;

Procedure Mul(Const A : TLong; Const К : Longlnt; Var С : TLong);
Var i : Integer;
{результат - значение переменной С}
Begin
FillChar (С, SizeOf(С), 0);
If K=0 Then Inc(С[0]){умножение на ноль}
Else Begin
For i:=l To A[0] Do
Begin
C[i+l] :=(LongInt(A[i]) * K + C[i]) Div Osn;
C[i] :=(LongInt(A[i])* K + C[i]) Mod Osn
End;
If C[A[0]+1] > 0 Then C[0]:=A[0] + 1
Else C[0]:=A[0]
{определяем длину результата}
End
End;

Procedure Sub (Var A : TLong; Const B : TLong; Const sp : Integer);
Var i, j : Integer;
{из А вычитаем В с учетом сдвига sp, результат вычитания в А}
Begin
For i :=l To B[0] Do
Begin Dec(A[i+sp], B[i]);
j:=i;{*}
{реализация сложного заимствования}
while (A[j+sp] < 0) and (j <=A[0]) Do
Begin{*}
Inc(A[j+sp], Osn)
Dec(A[j+sp+l]); Inc(j); {*}
end; {*}
{Реализация простого заимствования.
Если операторы, отмеченные *, заменить
на нижеприведенные операторы в фигурных скобках, то,
по понятным причинам, логика не будет работать
при всех исходных данных. Можно сознательно сделать
ошибку и предложить найти ее - принцип "обучение через ошибку"}
{If A[i+sp]<0 Then Begin Inc(A[i+sp], Osn);
Dec (A[i+sp+l]);End;}
End;
i :=A[0];
While (i > l) And (A[i]=0) Do Dec(i);
A[0] :=i
{корректировка длины результата операции}
End;

Procedure Long_Div_Long(Const A, B : TLong; Var Res, Ost : TLong);
Begin
FillChar(Res, SizeOf(Res), 0); Res[0] :=1;
FillChar(Ost, SizeOf(Ost), 0); 0st[0] :=1;
Case More(A, B, 0) Of
0: MakeDel(A, B, Res, Ost);
{А больше В, пока не знаем, как выполнять операцию - "выносим" в процедуру}
1: Ost:=A; {А меньше В}
2: Res[l] :=l; {А равно В}
End;
End;

1000143123567 |73859998
- 73859998 |----------
--------- |13541 (Целая часть частного)
261543143
- 221579994
----------
399631495
- 369299990
---------
303315056
- 295439992
----------
78750647
- 73859998
--------
4890649 (Остаток)

Function FindBin(Var Ost : Tlong; Const В: TLong; Const sp : Integer) : Longint;
Var Down, Up : Word; C : TLong;
Begin
Down :=0;Up :=0sn;
{основание системы счисления}
While Up - l > Down Do
Begin
{Есть возможность преподавателю сделать
сознательную ошибку. Изменить условие
цикла на Up>Down. Результат - зацикливание
программы}
Mul(В, (Up + Down) Div 2, C);
Case More(Ost, C, sp) Of
0: Down :=(Down + Up) Div 2;
1: Up :=(Up + Down) Div 2;
2: Begin Up :=(Up + Down) Div 2; Down :=Up End;
End;
End;
Mul(B, (Up + Down) Div 2, C);
If More (Ost, C, 0)=0 Then Sub(Ost, C, sp)
{находим остаток от деления}
Else begin Sub (C, Ost, sp); Ost :=C end;
FindBin :=(Up + Down) Div 2;
{целая часть частного}
End;

Procedure MakeDel(Const A, B : TLong; Var Res, Ost : TLong);
Var sp : Integer;
Begin
Ost :=A; {первоначальное значение остатка}
sp :=A[0] - B[0];
If More(A, B, sp)=l Then Dec(sp);
{B * Osn > A, в результате одна цифра}
Res[0] :=sp + l;
While sp >=0 Do
Begin
{находим очередную цифру результата}
Res[sp + 1] :=FindBin(Ost, B, sp);
Dec(sp)
End
End;