переделать код с С++ на Паскаль ( ну или хотя бы просто алгоритм пояснить)

/****************************************/
        /* Џа®Ја ¬¬  ¤«п ЁЈал ў Љ « е.        */
        /* ЋЇЁб ­ЁҐ б¬. ў д ©«Ґ kalah.doc   */
        /* ‘®бв®Ёв Ё§ ®¤­®Ј® ¬®¤г«п,      */
        /* § Ј®«®ў®Є - ў д ©«Ґ kalah.c.      */
        /* Љ®¬ЇЁ«ЁагҐвбп ў ’гаЎ® ‘Ё ЎҐ§ Їа®ҐЄв .*/
        /****************************************/

#include <time.h>
#include <stdlib.h>
#include <stdio.h>  /* putchar  */
#include <bios.h>   /* bioskey  */

#include <xm.h>
#include <kbdcodes.h>
#include <kbd.h>

#include "kalah.h"

NODE rootPos, *root;
NODE  wStack[MAXLEVEL];
NODE  bestMove;
int   maxLevel=MAXLEVEL;
int   cL;

                /********************************/
        /* Џа®в®вЁЇл «®Є «м­ле дг­ЄжЁ©.    */
                /********************************/
float ABprune(PNODE p, float alpha, float beta);
PNODE first(PNODE p);   /* ЏҐаўл© Ё§ ­ б«Ґ¤­ЁЄ®ў Ї®§ЁжЁЁ p Ё«Ё NULL,    */
                        /* Ґб«Ё ¤®бвЁЈ­гв ¬ ЄбЁ¬ «м­л© га®ўҐ­м.         */
void retPos(PNODE p);

PNODE next(PNODE p);    /* ЋзҐаҐ¤­®© 室 Ё§ Ї®§ЁжЁЁ p Ё«Ё NULL,         */
                        /* Ґб«Ё ¤®ЇгбвЁ¬ле 室®ў Ў®«миҐ ­Ґв.            */

int scatterStones(int desk[14], int move);
                        /* ‘¤Ґ« вм 室 move Ё§ Ї®§ЁжЁЁ desk.            */

float estimate(PNODE p);/* ‚лзЁб«Ёвм ®жҐ­Єг Ї®§ЁжЁЁ.                    */
int isEmpty(PNODE p);   /* …б«Ё Ї®«п ®¤­®Ј® Ё§ Їа®вЁў­ЁЄ®ў Їгбвл,       */
                        /* ЇаЁ¬Ґ­Ёвм Їа ўЁ«® 1.4 Ё ўҐа­гвм 1.           */
                        /* ‚ Їа®вЁў­®¬ б«гз Ґ ўҐа­гвм 0.                */
void setLocs(void);     /* “бв ­®ўЁвм "нЄа ­­лҐ" Є®®а¤Ё­ вл Ї®«Ґ©.      */
void initialize(void);  /* ‚бпЄЁҐ ­ з «м­лҐ гбв ­®ўЄЁ.                  */


LOCAL float ABprune(PNODE p, float alpha, float beta)
/* Alpha-beta pruning (¬Ґв®¤ Ја ­Ґ© Ё ®жҐ­®Є) Ё§ бв вмЁ „.Љ­гв .        */
/* ‚®§ўа й Ґв ®жҐ­Єг § ¤ ­­®© Ї®§ЁжЁЁ p.                */
{
   float    m, t;
   PNODE    curPos;

   cL++;
   curPos = first(p);       /* …б«Ё г Ї®§ЁжЁЁ p ­Ґв бл­®ўҐ©, */
                /* ўҐа­Ґ¬ NULL.               */
   if(curPos == NULL) {
      cL--;
      return estimate(p);   /* ‡„…‘њ ўл室 Ё§ Їа®жҐ¤гал,       */
   }                /* Є®Ј¤  Ї®§ЁжЁп вҐа¬Ё­ «м­ .        */
   else {
      m = alpha;
      while((curPos != NULL) && (m < beta)) {
         t = -ABprune(curPos, -beta, -m);
         if(t > m)
            m = t;
         curPos = next(p);
      }
   }
   cL--;
   return m;            /* Ђ ‡„…‘њ - ўл室 ¤«п ўбҐе ®бв «м­ле   */
                /* Ї®§ЁжЁ©.              */
}/*ABprune*/

ENTRY int findMove(PNODE p)
{
   PNODE    pcurPos;
   NODE     curPos;
   int      res=0;
   float    t,m;

   cL=0;                        /* —в®Ўл ў®бЇ®«м§®ў вмбп first!         */
   pcurPos = first(p);          /* ‘ЈҐ­ҐаЁа㥬 ЇҐаў®Ј® бл­  p.          */

   if(pcurPos == NULL) {
      return 0;         /* ‡„…‘њ ўл室 Ё§ Їа®жҐ¤гал,       */
   }                /* Є®Ј¤  Ї®§ЁжЁп вҐа¬Ё­ «м­ .        */
   else {
      m = -200;
      while(pcurPos != NULL) {
         cL = -1;               /* "ЏаҐ¤ЇҐаў®Ґ" б®бв®п­ЁҐ га®ў­п.       */
         curPos = wStack[0];    /* ‚®§м¬Ґ¬ Ї®§ЁжЁо Ё§ б⥪ .            */
         t = -ABprune(&curPos, -200, 200);
         if((t > m) || (t == m && random(2))) {
            m = t;
            bestMove = curPos;
            res++;
         }
         wStack[0] = curPos; cL = 0;    /* Џ®«®¦Ё¬ Ї®§ЁжЁо ў б⥪ Ё     */
         pcurPos = next(p);             /* бЈҐ­ҐаЁа㥬 б«Ґ¤гойго.       */
      }
   }
   return res;
}/*findMove*/

LOCAL PNODE first(PNODE p)
{
   if(cL < maxLevel) {
      wStack[cL].extent = 0;
      wStack[cL].move[0] = Aplays(*p) ? -1 : 6;
      return next(p);
   }
   return NULL;
}/*first*/

LOCAL void retPos(PNODE p)
{
   int i;

                      /* ‘­ з «  бЄ®ЇЁа㥬 Ї®§ЁжЁо Ё§ p         */
   memmove(wStack[cL].desk,p->desk,sizeof(p->desk));
                      /* ’ҐЇҐам Їа®¤Ґ« Ґ¬ д®абЁа®ў ­­лҐ е®¤л    */
                      /* ¤® Ї®§ЁжЁЁ, ЇаҐ¤иҐбвўго饩 ⥪г饩.    */
   for(i=0;i<wStack[cL].extent;i++) {
      scatterStones(wStack[cL].desk,wStack[cL].move[i]);
      if (isEmpty(&wStack[cL])) break;
   }
}/*retPos*/

LOCAL PNODE next(PNODE p)
{
   int U = Aplays(*p) ? 6 : 13;
   int move,t;
        /**** Ќ ©¤Ґ¬ ®зҐаҐ¤­®© 室.   ****/
   retPos(p); /* Џ®бва®Ё¬ Ї®§ЁжЁо ¤® ®зҐаҐ¤­®Ј® 室 .     */
                         /* Ќ ©¤Ґ¬ ¤®ЇгбвЁ¬л© е®¤.         */
   move = wStack[cL].move[wStack[cL].extent];
   while(++move < U && wStack[cL].desk[move] == 0);
   wStack[cL].move[wStack[cL].extent] = move;

   if(move == U)
      return (wStack[cL].extent-- == 0) ? NULL : next(p);
   else {       /* move < U */
      t = scatterStones(wStack[cL].desk,move);
      if(t) {
         if(isEmpty(&wStack[cL]))
            return &wStack[cL];
         else { /* 1.2. (!) */
            wStack[cL].move[++wStack[cL].extent] =
                    Aplays(*p) ? -1 : 6;
            return next(p);
         }
      }
      else
         return &wStack[cL];
   }
}/*next*/

#define INC(i)          i++;                                    \
      if (move < 6 /* •®¤ ЁЈа®Є  A */ &&                        \
          i == 13  /* ‘®ЎЁа Ґ¬бп Є« бвм ў Є « е ЁЈа®Є  B */     \
          ||                                                    \
          move > 6 /* •®¤ ЁЈа®Є  B */ &&                        \
          i == 14  /* „®и«Ё ¤® Є®­ж  ¬ ббЁў  */) i = 0;         \
      else                                                      \
      if (move > 6 /* •®¤ ЁЈа®Є  B */ &&                        \
          i == 6   /* Џа®ЇгбвЁ¬ Є « е ЁЈа®Є  A */) i++;

LOCAL int scatterStones(int desk[14], int move)
{
   int i, fin=0, stones;

   i = move;
   stones = desk[i];            /* Љ®«ЁзҐбвў® а бЇаҐ¤Ґ«пҐ¬ле Є ¬­Ґ©     */
   desk[i] = 0;
   while(stones--) {                            /* ђ §«®¦Ё¬ Є ¬гиЄЁ:    */
      INC(i);                            /* “ўҐ«ЁзЁ¬ i Ё                */
      desk[i]++;                         /* Ї®«®¦Ё¬ ®зҐаҐ¤­®© Є ¬г襪.  */
   }
                             /*** Џа ўЁ«® 1.3: ***/
                             /* •®¤ § Є®­зЁ«бп ­  ‘‚Ћ…Њ Їгб⮬ Ї®«Ґ.    */
   if(desk[i] == 1 && desk[12-i] > 0 &&      /* Џ®«Ґ ­ Їа®вЁў ­ҐЇгбв®. */
      ((move < 6 &&                          /* •®¤ ЁЈа®Є  A            */
         i < 6) ||                           /* Ё Є®­зЁ«Ё ­  ҐЈ® Ї®«Ґ.  */
       (move > 6 &&                          /* •®¤ ЁЈа®Є  B            */
        i > 6 && i < 13))) {                 /* Ё Є®­зЁ«Ё ­  ҐЈ® Ї®«Ґ.  */
      desk[move<6? 6:13] += desk[i] + desk[12-i];
      desk[i] = desk[12-i] = 0;
   }
        /*** ‘®®ЎйЁ¬ ® ⮬, зв® ­г¦­® ЇаЁ¬Ґ­Ёвм Їа ўЁ«® 1.2. ***/
   if (move < 6 && i == 6 || move > 6 && i == 13) fin = 1;
   return fin;
}/*scatterStones*/

#undef INC

LOCAL float estimate(PNODE p)
/* ‚лзЁб«Ёвм ®жҐ­Єг Ї®§ЁжЁЁ.         */
{
    float value;
    value  = p->desk[6] - p->desk[13];
/*    value += 17.3/(37.5 - p->desk[6]) -
                        17.3/(37.5 - p->desk[13]) + 1.72;*/
    if(!Aplays(*p))
       value = -value;
    return value;
}/*estimate*/

LOCAL int isEmpty(PNODE p)
{
   int i,fin;
                                /*** Џа ўЁ«® 1.4. ***/
   fin = 1;
   for(i=0;i<6;i++) if(p->desk[i]) fin = 0;
   if(fin) {
      for(i=7;i<13;i++) {
         p->desk[13] += p->desk[i]; p->desk[i] = 0;
      }
      return 1;
   }
   fin = 1;
   for(i=7;i<13;i++) if(p->desk[i]) fin = 0;
   if(fin)
      for(i=0;i<6;i++) {
         p->desk[6] += p->desk[i]; p->desk[i] = 0;
      }
   return fin;
}/*isEmpty*/

/**********************************************************************/
/*       ‚‚Ћ„ •Ћ„Ђ ЏЋ‹њ‡Ћ‚Ђ’…‹џ                                       */
/**********************************************************************/

#include <conio.h>  /* gotoxy   */

ENTRY int getMove(void)
{
   int ch, move;

   while(1) {           /* –ЁЄ« ўў®¤  ­ ¦ вЁп Ї®«м§®ў вҐ«п */
      gotoxy(1,1);
      printf("‚ўҐ¤Ё 室:         "); gotoxy(12,1);
      if((ch = bioskey(0)) == KBD_NORMAL(ESC))       /* ¦¤Ґ¬ ­ ¦ вЁп     */
     exit(-1);          /* ­ ¦ в <ESC> - ўлў «Ёў Ґ¬бп ў „Ћ‘  */
      putchar(ch);
      move = kbd_ascii(ch) - '0';       /* Љ®¤Ёа㥬 ­ ¦ вЁҐ     */
      if (move < 0 || move > 5 || root->desk[move] == 0 ) {
         putchar('\a');         /* Ќ ¦ в® ­Ґ в® - "Јг¤­Ґ¬" Ё   */
         continue;          /* Ї®¤®¦¤Ґ¬ б«Ґ¤го饣® ­ ¦ вЁп */
      }
      break;                /* ‡¤Ґбм - ўл室 Ё§ жЁЄ«  */
   }
   return move;
}/*getMove*/

/**************************************************************************/
/*      “‘’ЂЌЋ‚ЉЂ ЉЋЋђ„€ЌЂ’ € ЌЂ—Ђ‹њЌЋ‰ ЏЋ‡€–€€                           */
/**************************************************************************/

int x[14],y[14];    /* Љ®®а¤Ё­ вл Ї®«Ґ© ­  нЄа ­Ґ.   */

LOCAL void setLocs(void)
{
   int i;

   for (i=0; i < 6; i++) {      /* ®ЇаҐ¤Ґ«Ґ­ЁҐ Є®®а¤Ё­ в    */
      y[i] = 20;            y[i+7] = 15;
      x[i] = 8+9*(i+1);     x[i+7] = 71-9*(i+1);
   }
   x[6] = 7+9*7; x[13] = 71-9*7;
   y[6] = 18;    y[13] = 18;
}/*setLocs*/

ENTRY void drawScreen(void)
{
   int i;

   for(i=0;i<14;i++) {
      gotoxy (x[i],y[i]);
      printf ("%2d",root->desk[i]);
   }
}/*drawScreen*/

LOCAL void initialize(void)
{
   int i;

   randomize();
   clrscr();
   root = &rootPos;
   for(i=0; i < 6;i++)
      root->desk[i] = root->desk[i+7] = 6;
   root->desk[6] = root->desk[13] = 0;

   setLocs();
   for(i=6;i<=72;i++) {
      gotoxy(i,14) ; printf("-");
      gotoxy(i,21); printf("-");
   }
   for(i=1;i<=6;i++) {
      gotoxy(9*i+9,22); printf("%d",i-1);
      gotoxy(9*i+9,13); printf("%d",13-i);
   }
   drawScreen();
}/*initialize*/

NODE gameA[100];
NODE gameB[100];
int gameLength=0;

void main(void)
{
   int i,k,done=0;
   FILE *file;

   initialize();
                /* ‚ нв®© ўҐабЁЁ ЇҐаўл© 室 ¤Ґ« Ґв Їа®Ја ¬¬ ,           */
                /* Ї®н⮬㠯®бва®Ё¬ "ЇаҐ¤ЇҐаў®Ґ" б®бв®п­ЁҐ:             */
                /* ЇаЁвў®аЁ¬бп, зв® ЇҐаўл© 室 㦥 ᤥ« ­ - ЁЈа®Є®¬ B.  */
   rootPos.extent = 0; rootPos.move[0] = 13;
   while(!done) {

      for(k=0;k!=-1;) {
         rootPos.move[k] = getMove();
         gameA[gameLength].extent = k+1;
         gameA[gameLength].move[k] = rootPos.move[k];
         if(scatterStones(rootPos.desk, rootPos.move[k])) k++;
         else k = -1;
         drawScreen();
         if(isEmpty(root)) {
            done = 1;
            break;
         }
      }
      if(!done) {

         if(!findMove(root)) {
            drawScreen();
            break;
         }
         gameB[gameLength].extent = bestMove.extent+1;
         for(k=0;k<=bestMove.extent;k++) {
            gameB[gameLength].move[k] = bestMove.move[k];
            gotoxy(1,1); clreol();
            printf("Џ®©¤г б Ї®«п ");
            for(i=k;i<=bestMove.extent;i++)
               printf(" %2d",bestMove.move[i]);
            bioskey(0);
            scatterStones(rootPos.desk,bestMove.move[k]);
            drawScreen();
            if(isEmpty(root)) {
               done = 1;
               break;
            }
         }

         gameLength++;
      }
   }
   drawScreen();

   file = fopen("lastGame.klh","wt");
   gotoxy(1,1);
   for(i=0; i<gameLength; i++) {
      printf("\n%3d) A:",i+1);
      fprintf(file,"\n%2d) A:",i+1);
      for(k=0; k<gameA[i].extent;k++) {
         printf(" %2d",gameA[i].move[k]);
         fprintf(file," %2d",gameA[i].move[k]);
      }
      printf("\t\tB:");
      fprintf(file,"\t\tB:");
      for(k=0; k<gameB[i].extent;k++) {
         printf(" %2d",gameB[i].move[k]);
         fprintf(file," %2d",gameB[i].move[k]);
      }
   }
   fprintf(file,"\n\nЉ ¬­Ґ© Ї® ®Є®­з ­ЁЁ ЁЈал:\n"
            "\tў Є « еҐ Ђ - %d\n"
            "\tў Є « еҐ B - %d\n",
                rootPos.desk[6],rootPos.desk[13]);
   fclose(file);
}/*main*/