// This is part from Call.cpp  

  if (Chfil_c[term_1-TT_START]==1)
  {
    if (Pointers[term_1=Ufil_c1[term_1-TT_START]]&OBSEG1) // large built_in
    {
      if (term_1==TT_VAR)
      {
        for (i=buda_br; Buda1[i]==TT_LINK; i=Buda2[i]);  // !!!
        if (!(Pointers[Buda1[i]]&OBSEG1) || Buda1[i]==TT_VAR)
        {
          pointer=Mtree[0][1];
          goto x12p;
        }
        term_1=Buda1[i];
      }
      i=D_field[(Pointers[term_1]&MASKA3)+2];
      buf_4[1]=term_1=Ufil_c2[buf_4[0]-TT_START];  // !!!
e1:   buf_6[0]++;
      buf_6[1]=0;
      br_buf1=1;
      DWORD br_buf8, Buda_br_old=buda_br, ekler_br_new=ekler_br, Argument=0;
      // in buf_8 we keep: Type | Argument number, Vars start (in Buda)
      //                   Pointer to parent, Maximal number of arguments,
      //                   N branches of the definition tree,
      //
      // Type is:          func, predicate, list, set, OLE, evaluete

      Argument=0;
      buf_8[0]=1;            // Type is predicate
      buf_8[1]=0;            // Argument
      buf_8[2]=0;            //   no - Pointer to parent
      buf_8[3]=F_field[i-2]; // Maximal number of arguments
      buf_8[4]=a1;           // Vars start
      buda_br=buf_8[3]+a1;  // Vars end
      buf_8[6]=i;            // Which is the function
      br_buf8=0;
      while (1)  // Calculate an expresion
      {
        t=buf_8[br_buf8+6];
        if (F_field[t+Argument]&TP_TAPA)
        {
          if ((F_field[t+Argument]&TP_LIST) && buf_8[br_buf8]<2)
          {
            //buf_8[br_buf8+1]=Argument;  // ??    // Save Argument
            i=CreateArray(0);
            if (F_field[t+Argument]&TP_STR)
              ObjectStore[i+6]=HALF | TT_STR; // Flag "Temporal object" | type str
            else if (F_field[t+Argument]&TP_INT)
              ObjectStore[i+6]=HALF | TT_INT;
            else if (F_field[t+Argument]&TP_FLOAT)
              ObjectStore[i+6]=HALF | TT_FLOAT;
            else if (F_field[t+Argument]&TP_OBJ)
              ObjectStore[i+6]=HALF | TT_OBJ;
            else
              ObjectStore[i+6]=HALF | TT_LINK;
            buf_8[br_buf8+7]=2;                           // Type is list
            buf_8[br_buf8+8]=0;                         // Argument
            buf_8[br_buf8+9]=br_buf8;                   // Pointer to parent
            buf_8[br_buf8+10]=0; // Maximal number of arguments - no arg.
            buf_8[br_buf8+11]=buf_8[br_buf8+4]+Argument; // where to return
            buf_8[br_buf8+12]=i;          // Which is the object
            buf_8[br_buf8+13]=t+Argument; // where is the model
            br_buf8+=7;
            Argument=0;
            //((DWORD *)ObjectStore[i+4])[0]=Buda2[j];
          }
          //if ((F_field[t+Argument]&(TP_LIST|TP_TERM))
          //  || !(F_field[t+Argument]&TP_CALK)))
        }
        if (term_1<TT_START) // Tapa
        {
          if (term_1==TT_VAR) // Var
          {
            CALC_VAR_J(0,w3)   /* 2,3  (6,7,10 are impossible) */
            j+=Buda_br_old;
w3:         for (; Buda1[j]==TT_LINK; j=Buda2[j]);
            if ((term_1=Buda1[j])>=TT_START)
            {
              buf_4[br_buf1]=j;
              buf_6[br_buf1]=2;
              goto e11;
            }
            else
              goto e11p;
          }
          if (term_1==TT_LIST) // Real Tapa
          {
            switch (buf_8[br_buf8])
            {
             case 2:  // Type List 
             case 3:  // Type Method
              br_buf8=buf_8[br_buf8+2]; // to parent
              Argument=buf_8[br_buf8+1];
              Buda1[buf_8[br_buf8+4] + Argument]=TT_OBJ;  // Vars start + Argument number
              Buda2[buf_8[br_buf8+4] + Argument]=buf_8[br_buf8+12];
              goto e8;
            }
            t=buf_8[br_buf8+6];
            if ((F_field[t+Argument]&TP_TAPA)==0) // We need more arguments.
            {
              k=100;
              goto err2;
            }
            if (!(F_field[t+Argument]&(TP_REAL_TAPA|TP_LIST|TP_TERM))
                 && (F_field[t+Argument]&TP_CALK))
            {
              k=1;
              goto err2;
            }
e8:         if ((F_field[(t=buf_8[br_buf8+6])-1]&HALF) && buf_8[br_buf8+4]>=a1)// calc immediately
            {
              if (!(F_field[t+Argument]&TP_REAL_TAPA))
                ;
              m=F_field[t-1]&(MASKA_TP^TP_TEMP_FLAG);
              if (buf_8[br_buf8]==0) // function
              {
                i=buf_8[br_buf8+2]; // parent
                switch (buf_8[i])
                {
                 case 2:  // Type List 
                  execute(Program[m]&HALFM, buf_8[br_buf8+4], buf_8[i+4]);
                  t=buf_8[i+5];
                  if (ObjectStore[t+2] >= ObjectStore[t+3] && correct_list(t, 0) )
                    goto FULL;
                  ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=Buda2[buf_8[i+4]];
                  Argument=++buf_8[i+1];
                  break;
                 case 3:  // Type Method
                  execute(Program[m]&HALFM, buf_8[br_buf8+4], buf_8[i+4]);
                  t=buf_8[i+5];
                  if (ObjectStore[t+2]+4 >= ObjectStore[t+3] && correct_list(t, 0) )
                    goto FULL;
                  if (Buda1[buf_8[i+4]]==TT_OBJ && ObjectStore[j=Buda2[buf_8[i+4]]]==CLASS_SYSTEM_CONTAINER)
                  {
                    if (ObjectStore[j+5]<TT_START && ObjectStore[j+5]>TT_LIST)
                      k=TP_VAR>>(ObjectStore[j+5]-TT_VAR); // calculate what we have
                    else
                      k=TP_TERM;
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=ObjectStore[j+3];  // Name
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=k+ObjectStore[j+4];// type
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=ObjectStore[j+6]; // input
                    if (ObjectStore[j+4]&HALF)
                      ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=ObjectStore[j+7]; // output
                    else
                      ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=ObjectStore[j+5]; // Buda1
                    ObjectStore[j+6]=the_free_container;
                    the_free_container=j;
                  }
                  else
                  {
                    if (Buda1[buf_8[i+4]]<TT_START && Buda1[buf_8[i+4]]>TT_LIST)
                      k=TP_VAR>>(Buda1[buf_8[i+4]]-TT_VAR); // calculate what we have
                    else
                      k=TP_TERM;
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=M1;               // Name
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=k+12;             // type
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=Buda2[buf_8[i+4]];// input
                    ((DWORD *)ObjectStore[t+4])[ObjectStore[t+2]++]=Buda1[buf_8[i+4]]; // Buda1
                  }
                  Argument=buf_8[i+1]+=4;
                  break;
                 default:
                  {
                    DWORD temp1=buda_br-buf_8[br_buf8+3], temp2=buda_br;
                    if((t=execute(Program[m]&HALFM, buf_8[br_buf8+4], buf_8[i+4]+buf_8[i+1]))==0)
                    {
                      a1=buda_br;
                      buda_br=Buda_br_old;
                      goto fail;
                    }
                    else if (t==7) // window
                    {
                      for ( ; temp1 < temp2; Buda1[temp1++]=TT_VAR);
                      Ekler[++ekler_br]=4*FIRST_ROWS-4; // 9
                      Stack[stack_br+3]=ekler_br | QUARTER;
                      buda_br=a1;
                      Link[sv_subv++]=my_gl;       
                      goto MX;
                    }
                  }
                  Argument=++buf_8[i+1];
                }
                t=buf_8[i+6];
                if (buf_8[i]<2)
                {
                  if (Buda1[j=buf_8[i+4]+buf_8[i+1]-1]<TT_START && Buda1[j]>TT_LIST)// check the output type
                  {
                    k=TP_VAR>>(Buda1[j]-TT_VAR); // calculate what we have
                    if ((F_field[t+buf_8[i+1]-1]&k)==0)
                    {
                      Argument=buf_8[i+1]-1;
                      goto err1;
                    }
                  }
                  else if ((F_field[t+Argument-1]&TP_CALK) && !(F_field[t+Argument-1]&TP_TERM))
                  {
                    k=1;
                    goto err2;
                  }
                }
                if (a1<buda_br)  // clean
                {
                  for (t=buda_br-buf_8[br_buf8+3]; t<buda_br; Buda1[t++]=TT_VAR);
                  buda_br-=buf_8[br_buf8+3];
                }
ex:             br_buf8=i;
                while (buf_6[--br_buf1]&1);
                buf_6[br_buf1++]++;
                buf_6[br_buf1]=0;
                if (buf_6[br_buf1-1]&2)
                  term_1=Ufil_c2[Buda1[buf_4[br_buf1-1]]-TT_START];
                else
                  term_1=Ufil_c2[buf_4[br_buf1-1]-TT_START];
                buf_4[br_buf1]=term_1;
                continue;
              }
              else // predicate
              {
                k=execute(Program[m]&HALFM, buf_8[br_buf8+4], M1);
                if (a1<buda_br)  // clean
                {
                  for (t=buda_br-buf_8[br_buf8+3]; t<buda_br; Buda1[t++]=TT_VAR);
                  //buda_br-=buf_8[br_buf8+3];
                }
                switch (k)
                {
                 case 0:
                  a1=buda_br;
                  buda_br=Buda_br_old;
                  goto fail;
                 case 1:
                  Ekler[++ekler_br]=4*FIRST_ROWS-4; // 9
                  Stack[stack_br+3]=ekler_br | QUARTER;
                  buda_br=a1;
                  Link[sv_subv++]=my_gl;       
                  goto MX;
                  //goto MX;  
                 case 7:  // only for windoe
                  goto MX;
                 case 2:  // weak return(0)
                  m=Link[j=Ekler[ekler_br]];
                  goto fail4;
                 case 3:
                  goto FULL;  
                 case 4:
                  goto E3;  
                 case 5: // Soft Terminate
                  Wait=Wait_d=0;
                  return(ret_fl=5);  
                 case 6: // Terminate goes up
                  return(ret_fl);  
                }
              }
            }
            else // put in ekler
            {
              m=F_field[t-1]&(MASKA_TP^TP_TEMP_FLAG);
              if (buf_8[br_buf8]==0) // function
              {
                a1=buda_br;
                if ((ekler_br_new+=3)>EKLER && correct_EKLER() )
                  goto FULLek;
                Ekler[ekler_br_new]=m;
                Ekler[ekler_br_new-1]=buf_8[br_buf8+4]-1; // vars
                i=buf_8[br_buf8+2];
                if (buf_8[i]<2)
                {
                  Buda1[buf_8[br_buf8+4]-1]=TT_LINK;
                  Buda2[buf_8[br_buf8+4]-1]=buf_8[i+4]+buf_8[i+1];
                  Ekler[ekler_br_new-2]=F_field[buf_8[i+6]+buf_8[i+1]]; // type
                }
                else
                {
                  Buda1[buf_8[br_buf8+4]-1]=TT_VAR;
                  Ekler[ekler_br_new-2]=F_field[buf_8[i+6]]; // type
                }
                Argument=++buf_8[i+1];
                goto ex;
              }
              else if (ekler_br_new>ekler_br)
              {
                if ((ekler_br_new+=3)>EKLER && correct_EKLER() )
                  goto FULLek;
                Ekler[ekler_br_new]=m;
                Ekler[ekler_br_new-1]=buf_8[br_buf8+4]; // vars
                //Ekler[ekler_br_new-2]=0; // type - no return type for predicate
#if 0
                for(i=ekler_br; i<ekler_br_new; i+=3)
                {
                  sprintf(string2, "m=%d, vars=%d, type=%x\r\n", Ekler[i+3], Ekler[i+2], Ekler[i+1]);
                  MitiText(string2);
                }
#endif
                Link[sv_subv]=a1;
                Stack[stack_br+2]=sv_subv++;  // sv_subv-1
                Stack[stack_br+3]=ekler_br_new; //? ekler_br
                stack_br+=4;
                Stack[stack_br]=QUARTER|(j=stack_br-4);
                k=ekler_br+3; // pointer
                ekler_br=ekler_br_new;
                Stack[stack_br+3]=ekler_br_new; // +1 missed for eficiency, this is for k<Stack[j+7]-1
                goto ex6;
              }
              else
              {
                a1=buf_8[br_buf8+4];   // I they are not eq only when read (scan)
                while (Program[m]&HALF)
                {
                  if (execute(Program[m]&HALFM, a1, M1))
                  {
                    i=3*(buda_br-a1)+4;    // move further the list for clean 
                    p=Stack[stack_br-2]+1; // and predicate memory: j=my_gl+Mem
                    for (j=sv_subv-p; p<sv_subv; sv_subv--, Link[sv_subv+i]=Link[sv_subv]);
                    goto e22;
                  }
                  if (ProgTail[m]==M1 || ProgTail[m]==m)
                  {
                    a1=buda_br;
                    buda_br=Buda_br_old;
                    goto fail;
                  }
                  m=ProgTail[m];
                }
                j=M1;
e22:            if (ekler_br++>EKLER && correct_EKLER() )
                  goto FULLek;
                for (p=a1; p<buda_br; Link[sv_subv]=p++, sv_subv+=3); // clean arguments
                Ekler[ekler_br]=sv_subv;
                Link[sv_subv]=m;
                Link[sv_subv+1]=Link[sv_subv+2]=0;
                Link[sv_subv+3]=buda_br-a1;
                sv_subv+=4;
                if (j!=M1)  // we need this only when system built-in predicate (goto e22)
                {
                  sv_subv+=j;
                  Link[sv_subv++]=my_gl;     
                }
                Stack[stack_br+3]=ekler_br;
                goto MX;
              }
            }
          }
        }
        else
e11:     if (Chfil_c[term_1-=TT_START]==1)  // also tapa
        {
e11p:     a1=buda_br;
          buda_br=Buda_br_old;
          goto fail;
        }
        else  // try to calculate the argument
        {
          if (buf_8[br_buf8]<2)
          {
            if (F_field[t+Argument]&TP_LIST)
            {
              buf_8[br_buf8+1]=Argument;     // Save Argument
              i=CreateArray(0);
              if (F_field[t+Argument]&TP_STR)
                ObjectStore[i+6]=HALF | TT_STR; // Flag "Temporal object" | type str
              else if (F_field[t+Argument]&TP_INT)
                ObjectStore[i+6]=HALF | TT_INT;
              else if (F_field[t+Argument]&TP_FLOAT)
                ObjectStore[i+6]=HALF | TT_FLOAT;
              else if (F_field[t+Argument]&TP_OBJ)
                ObjectStore[i+6]=HALF | TT_OBJ;
              else
                ObjectStore[i+6]=HALF | TT_LINK;
              buf_8[br_buf8+7]=2;                           // Type is list
              buf_8[br_buf8+8]=0;                         // Argument
              buf_8[br_buf8+9]=br_buf8;                   // Pointer to parent
              buf_8[br_buf8+10]=0; // Maximal number of arguments - no arg.
              buf_8[br_buf8+11]=buf_8[br_buf8+4]+Argument; // where to return
              buf_8[br_buf8+12]=i;          // Which is the object
              buf_8[br_buf8+13]=t+Argument; // where is the model
              br_buf8+=7;
/* tuk */     Argument=0;
/* tuk */     //((DWORD *)ObjectStore[i+4])[0]=Buda2[j];
              continue;
            }
            else if (F_field[t+Argument]&TP_SET) // set
            {
            }
          }
try_to:   buf_4[++br_buf1]=term_1=Ufil_c1[term_1];
          buf_6[br_buf1]=0;
          if (term_1<TT_START)
          {
            if (term_1==TT_VAR)
            {
              CALC_VAR_J(0,w2)   /* 2,3  (6,7,10 are impossible) */
              j+=Buda_br_old;
w2:           for (; Buda1[j]==TT_LINK; j=Buda2[j]);
              if (Buda1[j]>=TT_START)  // complicated term
              {
                term_1=Buda1[j];
                buf_4[br_buf1]=j;
                buf_6[br_buf1]=2;
                goto e12;
              }
              else if (Buda1[j]>TT_LIST)  // we have final result
              {
e14:            k=TP_VAR>>(Buda1[j]-TT_VAR); // calculate what we have
                switch (buf_8[br_buf8])
                {
                 case 2:  // Type List 
                  i=buf_8[br_buf8+5];
                  if ((ObjectStore[i+6]&HALFM)!=Buda1[j])
                  {
                    k=101;
                    goto err2;
                  }
                  if (ObjectStore[i+2]++ >= ObjectStore[i+3] && correct_list(i, 0) )
                    goto FULL;
                  ((DWORD *)ObjectStore[i+4])[Argument++]=Buda2[j];
                  goto e7;
                 case 3:  // Type Method
                  i=buf_8[br_buf8+5];
                  if ((ObjectStore[i+2]+=4) >= ObjectStore[i+3] && correct_list(i, 0) )
                    goto FULL;
                  ((DWORD *)ObjectStore[i+4])[Argument++]=M1;   // Name
                  ((DWORD *)ObjectStore[i+4])[Argument++]=k+12; // type
                  ((DWORD *)ObjectStore[i+4])[Argument++]=Buda2[j]; // input
                  Argument++;                                                  // output
                  goto e7;
                }
                if ((F_field[buf_8[br_buf8+6]+Argument]&(TP_SET|TP_OBJ))==(TP_SET|TP_OBJ))//method
                {
                  //if (Buda1[j]==TT_STR)
                  {
                    i=buf_8[br_buf8+2]; //father
                    Buda2[buf_8[i+4] + buf_8[i+1]]=F_field[buf_8[i+6]+buf_8[i+1]]&TP_IO;
                    Buda1[buf_8[br_buf8+4] + Argument]=Buda1[j];  // TT_STR
                    Buda2[buf_8[br_buf8+4] + Argument++]=Buda2[j];
                  }
                  goto e7;
                }
                t=buf_8[br_buf8+6];
                if ((F_field[t+Argument]&k) || (F_field[t+Argument]&TP_CALK)==0) // || nocalc
                {
                }
                else // no such function
                {
err1:             k=Buda1[j]-TT_VAR;
err2:             sprintf(string2,"Runtime Error at step %d:\r\n",
                                                      0x10000*lSteps_br+Steps_br-Corection);
                  MitiText(string2, &cf_red);
                  if (k==100)
                    sprintf(string2,"The arguments of \"");
                  else
                    sprintf(string2,"The argument %d of \"", Argument+1-(t<8));
                  MitiText(string2);
                  if (buf_8[br_buf8]==0) // func
                  {
try_func:           if (t<8) // t==2 || t==7
                      i=ObjectStore[Buda2[buf_8[br_buf8+4]]+1];
                    else
                      for (i=sv_c+TT_START-1; i && (!(Pointers[i]&OBSEG3) || D_field[(Pointers[i]&MASKA3)+4]!=t); i--);
                  }
                  else if (buf_8[br_buf8]==1) // pred
                    for (i=sv_c+TT_START-1; i && (!(Pointers[i]&OBSEG1) || D_field[(Pointers[i]&MASKA3)+2]!=t); i--);
                  else if (buf_8[br_buf8]==2) // list arg
                  {
                    for (i=sv_c+TT_START-1; i && (!(Pointers[i]&OBSEG1) || D_field[(Pointers[i]&MASKA3)+2]!=t); i--);
                    if (i==0)
                      goto try_func;
                  }
                  else
                    i=0;
                  if (i==0)
                    strcpy(string2,"something");
                  else if (i==M1)
                    strcpy(string2,"no name array");
                  else
                  {
                    len=0;
                    write_p( i, 4, 0);
                  }
                  if (k>99)
                  {
                    if (k==100)
                    {
                      MitiText(string2);
                      sprintf(string2, "\" are%s %d but they have to be %d.\r\n\r\n",
                      (Argument<F_field[t-2])?" only":"", Argument-(t<8), F_field[t-2]-(t<8));
                      MitiText(string2);
                    }
                    else if (k==101)
                      error_func(Buda1[j]-TT_VAR, F_field[t]);
                    else //if (k==102)
                      error_func(1, F_field[t]);
                  }
                  else
                    error_func(k, F_field[t+Argument]);
                  for (t=a1; t<=buda_br; Buda1[t++]=TT_VAR);
                  buda_br=Buda_br_old;
                  goto fail;
                }
                if (Buda1[j]==TT_VAR || (F_field[buf_8[br_buf8+6]+Argument]&TP_IO))
                {
                  Buda1[buf_8[br_buf8+4] + Argument]=TT_LINK;
                  Buda2[buf_8[br_buf8+4] + Argument++]=j;
                }
                else
                {
                  Buda1[buf_8[br_buf8+4] + Argument]=Buda1[j];  // Vars start + Argument number
                  Buda2[buf_8[br_buf8+4] + Argument++]=Buda2[j];
                }
e7:             if (buf_6[br_buf1-1]&2)    // this arg. is calculated, go up
                  term_1=Ufil_c2[Buda1[buf_4[br_buf1-1]]-TT_START];
                else
                  term_1=Ufil_c2[buf_4[br_buf1-1]-TT_START];
                buf_6[br_buf1-1]++;
                buf_4[br_buf1]=term_1;
                buf_6[br_buf1]=0;
                continue;
              }
              else
              {
                term_1=Buda1[j];
                buf_4[br_buf1]=j;
                buf_6[br_buf1]=2;
                t=buf_8[br_buf8+6];
                goto NS4;
              }
            }
            else
            {
              t=buf_8[br_buf8+6];
              goto NS4;
            }
          }
          else
e12:       if (Chfil_c[term_1-TT_START]==1)  // posible function
          {
            if (buf_8[br_buf8]<2)
            {
              if ((F_field[t+Argument]&TP_CALK)==0) // nocalc
                goto NS2;
              else if ( (F_field[t+Argument]&(TP_SET|TP_OBJ))==(TP_SET|TP_OBJ) )// method
              {
                buf_8[br_buf8+1]=Argument;     // Save Argument
                i=CreateArray(0);
                buf_8[br_buf8+7]=3;                           // Type is method
                buf_8[br_buf8+8]=0;                         // Argument
                buf_8[br_buf8+9]=br_buf8;                   // Pointer to parent
                buf_8[br_buf8+10]=0; // Maximal number of arguments - no arg.
                buf_8[br_buf8+11]=buf_8[br_buf8+4]+Argument; // where to return
                buf_8[br_buf8+12]=i;          // Which is the object
                buf_8[br_buf8+13]=0; // where is the model
                br_buf8+=7;
                Argument=0;
                term_1-=TT_START;
                goto try_to;
              }
            }
            j=Ufil_c1[term_1-TT_START];
            //if (buf_8[br_buf8]==3 && Pointers[j]&OBSEG7) // method spesifier
            //{
            //}
            //else
            if (Pointers[j]&OBSEG3) // function
            {
              if (j==TT_VAR)
              {
                if (buf_6[br_buf1]&2)
                  j=Link[Buda2[buf_4[br_buf1]]];
                else
                {
                  CALC_VAR_J(0,w1)
                  j+=Buda_br_old;
                }
w1:             for (; Buda1[j]==TT_LINK; j=Buda2[j]);
                if (Buda1[j]==TT_VAR)
                  goto e4;
                else if (Pointers[Buda1[j]]&OBSEG3)
                  j=Buda1[j];
                else if (Buda1[j]==TT_OBJ) // array by value
                {
                  i=Buda2[j];
                  goto e10p;
                }
                else if (Pointers[Buda1[j]]&OBSEG5)  // array by name
                {
                  j=Buda1[j];
                  goto e10;
                }
                else
                  goto e4;
              }
              i=D_field[(Pointers[j]&MASKA3)+4];
              buf_8[br_buf8+1]=Argument;     // Save Argument
              buf_8[br_buf8+8]=Argument=0;     // Argument
e9:           buf_8[br_buf8+7]=0;     // Type function
              buf_8[br_buf8+9]=br_buf8;         // Pointer to parent
              buf_8[br_buf8+10]=F_field[i-2]+1; // Maximal number of arguments
              buf_8[br_buf8+11]=buda_br+1;     // Vars start
              buda_br+=buf_8[br_buf8+10];       // Vars end
              br_buf8+=7;
              buf_8[br_buf8+6]=i;
              buf_6[br_buf1]++;
              buf_4[++br_buf1]=term_1=Ufil_c2[term_1-TT_START];
              buf_6[br_buf1]=0;
              continue;
            }
            else if (Pointers[j]&OBSEG5) // array
            {
e10:          i=D_field[(Pointers[j]&MASKA3)+6];
e10p:         if (SUBTYPE(ObjectStore[i],CLASS_SYSTEM_LIST))
              {
                Buda1[buda_br+1]=TT_OBJ; //?
                Buda2[buda_br+1]=i;
                i=(F_field[buf_8[br_buf8+6]+Argument]&TP_IO)?7:2; //arrayArgOut  or arrayArg
                buf_8[br_buf8+1]=Argument;     // Save Argument
                buf_8[br_buf8+8]=Argument=1;     // Argument
                goto e9;
              }
              else
                goto e4;
            }
            else // term, not list
            {
              //t=buf_8[br_buf8+6];
e4:           if (buf_8[br_buf8]>1)
                goto NS7;
              if (F_field[t+Argument]&TP_TERM)
                goto NS2;
              k=1;
              goto err2;
            }
          }
          else // list or term
          {
NS4:        if (buf_8[br_buf8]>1)
            {
              if (Pointers[term_1]&OBSEG4) // constant
                goto NS6;
NS7:          switch (buf_8[br_buf8])
              {
               case 2:  // Type List 
                k=102;
                goto err2;
               case 3:  // Type Method
                i=buf_8[br_buf8+5];
                if ((ObjectStore[i+2]+=4) >= ObjectStore[i+3] && correct_list(i, 0) )
                  goto FULL;
                ((DWORD *)ObjectStore[i+4])[Argument++]=M1;   // Name
                ((DWORD *)ObjectStore[i+4])[Argument++]=TP_TERM+12; // type
                if (term_1<MEMORY_c256)
                {
                  Argument++;
                  ((DWORD *)ObjectStore[i+4])[Argument++]=term_1; // Buda1
                }
                else
                {
                  ((DWORD *)ObjectStore[i+4])[Argument++]=sv_subv; // output
                  ((DWORD *)ObjectStore[i+4])[Argument++]=term_1; // Buda1
                  goto NS5;
                }
                goto e7;
              }
            }
            else if ((F_field[t+Argument]&TP_CALK)==0) // nocalc
              goto NS2;
            else if (Pointers[term_1]&OBSEG4) // constant
            {
NS6:          if ((m=D_field[(Pointers[term_1]&MASKA3)+5])&HALF)
              {
                i=Program[m&HALFM]&HALFM;
                switch(execute(i, M1, buf_8[br_buf8+4] + Argument))
                {
                 case 0:       /* back traking */
                  goto fail;
                 case 1:       /* go on */
                  j=buf_8[br_buf8+4] + Argument;
                  if (Buda1[j]>TT_VAR && Buda1[j]<TT_START)
                    goto e14;
                  else if (F_field[t+Argument]&TP_TERM)
                  {
                    Argument++;
                    goto e7;
                  }
                  k=1;
                  goto err2;
                }
              }
              else // put in ekler
              {
                if ((ekler_br_new+=3)>EKLER && correct_EKLER() )
                  goto FULLek;
                Ekler[ekler_br_new]=m;
                Ekler[ekler_br_new-1]=buda_br; // vars
                Buda1[buda_br]=TT_LINK;
                Buda2[buda_br]=buf_8[br_buf8+4]+Argument;
                Ekler[ekler_br_new-2]=F_field[buf_8[br_buf8+6]+Argument++]; // type
                a1= ++buda_br;
                goto e7;
              }
            }
            //t=buf_8[br_buf8+6];
            if (F_field[t+Argument]&TP_TERM)
            {
NS2:          if ((F_field[t+Argument]&TP_IO) && buf_6[br_buf1]==2)
              {
                Buda1[buf_8[br_buf8+4] + Argument]=TT_LINK;
                Buda2[buf_8[br_buf8+4] + Argument++]=buf_4[br_buf1];
                goto e7;
              }
NS3:          Buda1[buf_8[br_buf8+4] + Argument]=term_1;  // Vars start + Argument number
              if (buf_6[br_buf1]==2)
                Buda2[buf_8[br_buf8+4] + Argument++]=Buda2[buf_4[br_buf1]];
              else if (term_1<MEMORY_c256)
                Argument++;
              else
              {
                Buda2[buf_8[br_buf8+4] + Argument++]=sv_subv;
NS5:            q=Chfil_v[term_1-MEMORY_c256];
                for (k=0; k<q; k++)
                {
                  CALC_VAR_J(k,w4)   /* 2,3,6,7,10 */
                  j+=Buda_br_old;
w4:               for (; Buda1[j]==TT_LINK; j=Buda2[j]);
                  Link[sv_subv++]=j;
                }
              }
              goto e7;
            }
            else if ((F_field[t+Argument]&(TP_SET|TP_OBJ))==(TP_SET|TP_OBJ))//method
            {
              i=buf_8[br_buf8+2]; //father
              Buda2[buf_8[i+4] + buf_8[i+1]]=F_field[buf_8[i+6]+buf_8[i+1]]&TP_IO;
              goto NS3;
            }
            k=1;
            goto err2;
          }
        }
      }
    }
    pointer=Mtree[0][1]; // it is made OK, otherwise error
    goto x12p;
  }
  else if (Pointers[term_1]&OBSEG2)
  {
  e2:
    if ((m=D_field[(Pointers[term_1]&MASKA3)+3])&HALF)
    {
      i=Program[m&HALFM]&HALFM;
      if (i==0)  // fail
        goto fail;
      switch(execute(i, M1, M1))
      {
       case 0:       /* back traking */
        goto fail;
       case 1:       /* go on */
        if (ekler_br++>EKLER && correct_EKLER() )
          goto FULLek;
        Ekler[ekler_br]=4*FIRST_ROWS-4; // 9
        Stack[stack_br+3]=ekler_br | HALF;
        Link[sv_subv++]=0; // my_gl // for clean
        buda_br=a1; //?
        goto MX;
      }
    }
    else
    {
      while (Program[m]&HALF)
      {
        if (execute(Program[m]&HALFM, M1, M1))
          break;
        if (ProgTail[m]==M1 || ProgTail[m]==m)
          goto fail;
        m=ProgTail[m];
      }
      buda_br=a1; //?
      if (ekler_br++>EKLER && correct_EKLER() )
        goto FULLek;
      Ekler[ekler_br]=sv_subv;
      Link[sv_subv]=m;
      Link[sv_subv+1]=Link[sv_subv+2]=Link[sv_subv+3]=0;
      sv_subv+=4;
      Stack[stack_br+3]=ekler_br;
      Link[sv_subv++]=0; // my_gl // we need this only when break
      goto MX;
    }
  }
  goto x3;
