uses crt;
  const
    n=32;
  type
    TMass=string[n];
  var a,b,c:TMass;
  function HexToBin(d,e:integer):string;
    begin
      {корректируем под 16-е число}
{      dec(d,7*ord(d>9));}
if d>9 then dec(d,7);
      HexToBin:='';
      {рекурсивно формируем 16-е число ввиде строки}
      if e>0 then HexToBin:=chr(ord('0') + d mod 2) + HexToBin(d div 2,e-1);
    end;
  procedure inputHex(var d:TMass;e:char);
    begin{inputHex}
      {вводим число в обратном порядке}
      write('Enter number',e:2,':');
      d:='';
      repeat
        e:=ReadKey;{символ без эхо}
        case e of
        '0'..'9','A'..'F','a'..'f':
          begin
{            e:=chr(ord(e) - 32*ord(e>'Z'));{приводим число к единому регистру}
if e>'Z'then e:=chr(ord(e) - 32);
            write(e);{выводим его}
            d:=HexToBin(ord(e)-ord('0'),4)+d;{формируем двоичную строку}
          end;
          end;{case}
      until (e=chr(13))or(length(d)=n);{}
      writeln;
    end;{inputHex}
  procedure outputHex(d:TMass);
    var
      i,j:integer;
      e:TMass;
    begin{outputHex}
      if length(d)>0 then
        begin{if}
          e:=copy(d,1,4);{получаем четыре бита}
{          delete(d,1,4);{удаляем их их числа}
          outputHex(copy(d,5,length(d)-4));{рекурсивно вызываем себя}
          i:=0;
          j:=length(e);
          while j>0 do{преобразовываем строку в число}
            begin{while}
              i:=i*2 + ord(e[j]) - ord('0');
              dec(j);
            end;{while}
if i>9 then inc(i,7);{*ord(i>9));{корректируем его с учетом 16-ой системы}
          e:=chr(ord('0')+i);{формируем символ и выводим его}
          write(e);
        end;{if}
    end;{outputHex}
  procedure doSummaBin(var d,e:Tmass);
    var
      f:char;
      i:integer;
    begin{doSummaBin}
      f:='0';{флаг переноса для старшего разряда}
      for i:=1 to length(d) do
        begin{for}
          if (e[i]<>d[i])then
            {обрабатываем ситуацию когда биты различны}
            begin{ed=10,01}
              if f='1'
                then d[i]:='0' {edf=101,011}
                else d[i]:='1';{edf=100,010}
            end{10,01}
            else
            {обрабатываем ситуацию когда биты одинаковы}
            begin{ed=00,11}
              {edf=001,000,111,110}
              d[i]:=f;
              f:=e[i];
            end;{00,11}
        end;{for}
    end;{doSummaBin}
  procedure rangeBin(var d:Tmass);
    begin{rangeBin}
      while length(d)<n do
        d:=d+'0';{}
    end;{rangeBin}
  procedure convertBin(var d:TMass;e:TMass);
    var
      i:integer;
    begin{convertBin}
      for i:=1 to length(d)do
        {инвертируем биты}
        case d[i]of{case}
          '0':d[i]:='1';
          '1':d[i]:='0';
          end;{case}
      rangeBin(e);{выравниваем строку}
      doSummaBin(d,e);{суммируем}
    end;{convertBin}
  begin{main}
    {вводим числа}
    inputHex(a,'A');
    inputHex(b,'B');
    {выравниваем к одному размеру}
    rangeBin(a);
    rangeBin(b);
    {переводим в дополнительный код}
    convertBin(b,'1');
    {суммируем А + Вд}
    doSummaBin(a,b);
    {выводим результат}
    outputHex(a);
    ReadKey;
  end.{main}

 Булевы типы
Имеются четыре предопределенных булевых типа:Boolean, WordBool, LongBool и ByteBool.
 Синтаксис:
 Type Boolean = (False, True);
     WordBool = (False, True);
     LongBool = (False, True);
     ByteBool = (False, True);
 Замечания:
Эти типы имеют следующие размеры:
  - Boolean  - Byte    (8 бит)
  - WordBool - Word    (16 бит)
  - LongBool - LongInt (32 бита)
  - ByteBool - Byte    (8 бит)
Поскольку данные типы являются перечислимыми порядковыми типами, то существуют следующие связи:
  False < True
  Ord(False) = 0
  Ord(True) = 1
  Succ(False) = True
  Pred(True) = False
Тип Boolean является предпочтительным, так как он использует наименьшее количество памяти.
ByteBool, WordBool и LongBool существуют только для совместимости с Windows.
В выражениях, следующие операторы сравнения производят результат типа Boolean:
    =   <>   >   <   >=   <=   IN
Для совместимости с Windows, булевы типы могут принимать порядковые значения не только 0 и 1.
Булево выражение является ложью (False), если его порядковое значение равно нулю и истиной (True), если его порядковое значение не равно нулю.
Булевы операторы Not, And, Or и Xor работают проверяя значения на 0 (False) или не 0 (True), но всегда возвращают результат с порядковым значением 0 или 1.