Пожалуйста помогите с обьяснением пары прог на Free Pascal.

program lab_1;                                    // Начало программы. Её название
uses crt;                                         // Использовать модуль crt
const                                             // Константа (неизменяемая величина)
Ch:string='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'; // строкового типа. Значение задаётся тут
var                                               // Переменные
i:longint;                                        // целочисленного типа с макс. значением 2^31-1
K:string;                                         // строкового типа
B:longint;                                        // целочисленного типа
// Функция FDec - её имя, по нему она вызывается в основной программе или других процедурах и функциях
// n,r - параметры, которые передаются в функцию
// Результат функции - строка
// Функция преобразует число n в строковое представление в r-ичной системе счисления
function FDec(n,r:longint):string;                
var
s:String;                           // переменная строкового типа
 begin                              // начало функции
 s:='';                             // строка s сначала пуста
   repeat                           // цикл
   s:=Ch[(n mod r)+1]+s;            // тут к строке прибавляют символ, получаемый по индексу из строки. Индекс получается как остаток от деления n на r
   n:=n div r;                      // затем n делится на r
   until n=0;                       // пока n не станет = 0
 FDec:=s;                           // Результат работы функции - полученная строка
 end;                           // конец функции FDec
// Функция TDec.
// ей передаётся два параметра - s стркоа и r - целое число
// функция возвращает целое число
// Функция преобразует строковое представление числа, заданного в r-ичной системе счисления
// в целое число (в десятичной системе счисления)
function TDec(n:string;r:longint):longint;
var
m,i:longint;                // переменные целочисленного типа
 begin                      // начало функции TDec
 m:=0;                      // присвоение значения 0 переменной m
   while n[1]='0' do        // цикл, пока первый символ в строке s равен '0'
   delete(n,1,1);           // функция удаления из строки n символа по индексу 1, цисло удаляемых символов тоже = 1
 for i:=1 to length(n) do   // цикл от 1 до кол-ва символов в строке n с шагом = 1. Строковая функция Length возвращает длину переданной ей строки. 
 m:=m*r+pos(n[i],Ch)-1;     // берётся i-ый символ из строки, вычисляется его позиция в строке Ch (где хранятся все символы системы счисления по порядку)  и добавляется к результату, который сам сдвигается на основание системы счисления r
 TDec:=m;                   // результат работы функции и будет это число
 end;                       // конец функции TDec

 begin                      // начало программы
 clrscr;                    // очистка экрана
 writeln('Введите число c основанием 14:');  // вывод строки на экран
 readln(K);                                  // ожидание ввода с клавиатуры строки (завершается нажатием ENTER)
 for i:=1 to  length(K) do                   // цикл от 1 до длины введённой строки с шагом 1
 if ( pos(K[i],Ch)>14) or (pos(K[i],Ch)=0) then // провряется i-ый символ из строки, если он выходит из диапазона для 14-ричных чисел, или вообще нет символа в строке, где хранятся все символы систем счисления до 36
   begin                                        // то выполняются эти операторы:
   writeln('Введено некорректное число: ',K[i]); // выводится этот некорректный символ на экран
   readln;                                       // ожидается нажатие ENTER
   halt;                                         // программа завершается
   end;                                          // конец блока операторов по условию
 writeln('Перевод заданного числа в основание 10: ');  // вывод строки на экран
 B:=TDec(K,14);                                        // вызов функции TDec с параметрами - K - введённая строка, 14 - основание системы счисления, в которой задано число в строке K. Результат функции - число в десятичной системе счисления помещается в переменную B
 writeln(B);                                           // вывод значения B на экран
 writeln('Перевод из основания 10 в основание 23: ');  // вывод строки на экран
 writeln(FDec(B,23));                                  // вывод результата вызова функции FDec (перевод числа B в систему счисления с основанием 23) на экран
 writeln('Перевод из основания 10 в основание 27: ');  // вывод строки на экран
 writeln(FDec(B,27));                                  // вывод результата вызова функции FDec (перевод числа B в систему счисления с основанием 27) на экран
 readln;                                         // ожидается нажатие ENTER
 end.                                            // конец программы

program lab_1;    // Программа lab_1
uses              // используем модули:
crt,Math;         // crt - для функций работы с экраном, math - для математических функций
const             // Константы
S = 14;           // обозначения 
Q = 23;           // некоторых оснований
R = 27;           // систем счисления
digit:string='0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'; // разряды для систем счисления в порядке возрастания
var               // Переменные
i:integer;        // целочисленная
TD:string;        // строковая
a,b,c:string;
DT:real;          // из множества действительных чисел
S1,S2:String;     // строкового типа



{функция сложения двух чисел в произвольной системе счисления}
function Add(n1,n2:String;O:integer):string;
var                       // переменные
        s1,s2:string;
        s:string;
        k:integer;
        p1,p2:integer;
        a1,a2:integer;
        i:integer;
begin
        s:='';            // s - пустая строка. это для результата вычисления функции
        k:=0;             // эта переменная используется как признак переполнения разряда при сложении. пока он = 0
        s1:=n1;
        s2:=n2;
        p1:=pos('.',s1);  // ищется позиция точки в строковом представлении числа n1(s1)
        if p1=0 then insert('.0',s1,length(s1)+1); // если нет - добавялется к концу незначащий 0 после точки
        p2:=pos('.',s2);  // тоже для второго числа
        if p2=0 then insert('.0',s2,length(s2)+1);
        p1:=pos('.',s1);  // вычисляется позиция точки в первом числе
        p2:=pos('.',s2);  // во втором
        a1:=length(s1)-p1;  // длина дробной части (в символах) первого числа
        a2:=length(s2)-p2;  // аналогично для второго
        // далее определяется меньшее число из двух и оно дополняется до длины второго спереди нулями (для того, чтобы складывать ровно)
        if p1>p2 then for i:=1 to p1-p2 do insert('0',s2,1) else for i:=1 to p2-p1 do insert('0',s1,1);
        // определяется меньшая (по длине) дробная часть, и также дополняется, но уже справа незначащами нулями
        if a1>a2 then for i:=1 to a1-a2 do insert('0',s2,length(s2)+1) else for i:=1 to a2-a1 do insert('0',s1,length(s1)+1);
        // теперь строки получились одинаковой длины (из-за добавления нулей)
        // цикл от длина строки до 1 с шагом -1 (минус 1!!!) для того, чтобы складывать от младших разрядов к старшим
        for i:=length(s1) downto 1 do
                begin
                        if s1[i]='.' then  // если текущий символ - точка
                                begin      // то выполняется этот блок операторов:
                                        insert('.',s,1); //  то точка добавлляется и в результат (s)
                                        continue;        // команда продолжения цикла сначала, минуя дальнейшие операторы
                                end;       // конец блок операторов
                        // очередной  символ результата сложения вычисляется так:
                        // позиция i-го символа числа s1 + позиция i-го символа числа s2 - 2 (для коррекции, т.к. позиции в строках начинаются с 1, а цифры нужны с 0) и + k (признак переноса разряда - от предыдущего цикла сложения)
                        p1:=pos(s1[i],digit)+pos(s2[i],digit)-2+k;
                        k:=0;             // признак переноса = 0
                        if p1>=O then     // если результат сложения двух цифр стал больше системы счисления
                                begin     // то выполнются следующие операторы:
                                        k:=1;     // устанавливается признак перепонения
                                        p1:=p1-O; // корректируется цифра текущей позиции с учётом признака переполнения при сложении следующих разрядов
                                end;      // конец блока операторов при переполнении
                        insert(digit[p1+1],s,1);  // в строку-результат добавляется вычисленный символ
                end;                   // конец цикла сложения
        if k=1 then insert('1',s,1);   // Если в конце сложения возникло переполнение - то ставят 1 в начало числа.
        Add:=s;                        // результат работы функции - вычисленное число от сложения двух переданных чисел
end;    // конец функции



{функция перевода Dec числа в любую сс}
// n - число для перевода, r - основание системы счисления
// результат - строковое представление числа в заданной системе счисления (r)
function FromDec(n:real;r:integer):string;
var             // переменные
s:String;       // строка
m:longint;      // целое число (большое - от -2^31 до 2^31-1
l:real;         // действительное число
i:integer;      // целое число (не очень большое - от -2^15 до 2^15-1
begin           // начало функции
s:='';          // сначала резултат пуст
m:=trunc(n);    // получение целого числа из действительного
repeat          // цикл
s:=digit[(m mod r)+1]+s;  // вычисление очередного символа числа n по основанию r
m:=m div r;               // деление числа на основание системы счисления
until m=0;      // пока число не станет = 0
l:=frac(n);     // получение дробной части
s:=s+'.';       // добавление символа '.' в резултат
for i:=1 to 4 do         // цикл от 1 до 4 с шагом 1 (первые 4 цифры после точки)
begin
        l:=l*r;          // дробная часть умножается на основание
        s:=s+digit[trunc(l)+1];  // берётся целая часть (т.е. один символ) и переводится в символьное представление и добавляется к результату
        l:=frac(l);      // снова берётся дробная часть
end;                     // цонец цикла перевода дробной части


FromDec:=s;     // результат работы функции

end;            // конец функции



{фунция перевода любой сс в Dec}
function ToDec(n:string;r:real):real;
var                                      // перпеменные
i,p:longint;                             // целого типа (большие)
m:real;                                  // действительные числа
begin                                    // начало функции
m:=0;                                    // m = 0 (тут вычисляется результат)
p:=pos('.',n);                           // позиция точки в числе
if p=0 then p:=length(n)+1;              // если p=0, то p = длина строкового представления числа + 1
for i:=1 to length(n) do                 // цикл от 1 до длины строкового представления числа с шагом 1
if i<>p then                             // если текущий индекс не равен p, то
if i<p then                              // если индекс меньше p (т.е. индекс указывает на символ до точки
m:=m+(pos(n[i],digit)-1)*power(r,p-i-1)  // то вычисляют очередной разряд числа, возводят его в степень в зависимости от позиции с учётом коррекции позиции с отнимаением 1 и добавляют к результату
else                                     
m:=m+(pos(n[i],digit)-1)*power(r,p-i);   // иначе (если индекс указывает после точки) вычисляют очередной разряд числа, возводят его в степень в зависимости от позиции с учётом коррекции позиции с отнимаением 1 и прибавлением 1 (позиция точки), таким образом -1+1 взаимно уничтожаются и добавляют к результату
ToDec:=m;                                // результат присваивается функции
end;                                     // конец функции

// процедура проверки числа S (заданного строкой) по основанию O
// т.к. ничего не возвращает - оформлена не как функция, а как процедура.
// Хотя логичнее было бы как раз функцией с возвратом логического значения и обработки
// его в вызывающей программе, а не прерыванием работы всей программы
procedure CheckCorrect(s:string;o:integer);
var
        n:integer;            // переменная целочисленного типа
        i:integer;            // аналогично
begin
        n:=0;                 // сначала n=0
        for i:=1 to length(s) do // цикл от одного до длины строки S с шагом 1
        if s[i]='.' then inc(n); // если точка - то n увеличивают на 1
        if n>1 then              // если n>1, т.е. точек больше одной в строке
                begin            // то выполняется этот блок операторов:
                        writeln('Введено некорректное число');  // вывод строки на экран
                        readln;                                 // ожидание нажатия ENTER
                        halt;                                   // аварийное завершение программы
                end;             // конец блока операторов, если точек больше одной
        for i:=1 to length(s) do // опять цикл от 1 до длины строки S с шагом 1
        if ((pos(s[i],digit)>o) or (pos(s[i],digit)=0)) and (s[i]<>'.') then // проверка очередного символа на корректность
                begin   // и в слдучае некооректного символа
                        writeln('Некорректное число. ',s[i]); // вывод строки с указанием на символ
                        readln;                               // ожидание нажатия ENTER
                        halt;                                 // аварийное завершение программы
                end;    // конец блока операторов при неправильном символе
end;    // конец процедуры проверки

{основная программа}
begin                                // начало основной программы
clrscr;                              // очистка экрана
write('Введите начало интервала: '); // вывод строки на экран
CheckCorrect(A,S);  // вызов процедуры проверки числа A по основанию S ???!?!?!?!?!?
readln(A);                           // ожидание ввода строки в переменную A ???!?!?!?!?!?!?!
write('Введите конец интервала: ');  // вывод строки на экран
CheckCorrect(B,S);  // вызов процедуры проверки числа B по основанию S ???!?!?!?!?!?
readln(B);                           // ожидание ввода строки в переменную B ???!?!?!?!?!?!?!
write('Введите шаг = ');             // вывод строки на экран
readln(C);                           // ожидание ввода строки в переменную C
CheckCorrect(C,S);  // вызов процедуры проверки числа C по основанию S

if ToDec(a,s)>ToDec(b,s) then        // сравление двух чисел (после перевода в 10-ичную системы счисления)
begin                                // если a > b, то интервал задан неверно
        writeln('Начало и конец интервала заданы некорректно.'); // вывод строки на экран
        readln;                      // ожидание нажатия  ENTER
        halt;                        // аварийное завершение программы
end;

// вывод строк на экран
writeln('|-----------|-----------|-----------|-----------|');
writeln('|____14_____|____10_____|_____23____|____27_____|');

// основной цикл. пока число a <= b
While ToDec(a,S)<= ToDec(b,S) do
begin

        for i:=1 to 5 do write(' ');  // цикл от 1 до 5 с шагом 1. вывод пробела на экран (5 раз).
        write(A);                     // вывод числа A
        for i:=1 to 10-length(a) do write(' ');  // после числа A выводится столько пробелов, сколько не хватает от длины числа А до 10
        DT:=ToDec(A,S);               // число А переводят в 10-ичную систему счисления
        write(DT:4:4);                // выводят его на экран

        for i:=15 to 22 do write(' '); // цикл от 15 до 22 с шагом 1. вывод пробела. (итого 7 пробелов)
        s1:=FromDec(DT,Q);             // перевод числа А в систему счисления по основанию Q (Q=23, как мы знаем из 6-ой строки нашей программы)
        write(s1);                     // вывод результата (число А в 23-чной системе счисления)

        for i:=1 to 11-length(s1) do write(' '); // цикл от 1 до 11-длина числа А в 23-чной системе счисления. вывод пробела
        writeln(FromDec(DT,R));        // вывод на экран результата работы функции перевода числа А в систему счисления R (R=27)

        A:=Add(A,C,S);                 // к числу А увеличивают на С (шаг)

end;                                   // конец основного цикла
writeln('|-----------|-----------|-----------|-----------|'); // вывод окончания таблицы
readln;                                // ожидание нажатия  ENTER
end.                                   // конец программы