cubeWidth  = 127;
  cubeHeight = 127;
  cubeDepth  = 1;

if Cube^[i]^[jt]^[ks] <= Cube^[i]^[js]^[ks] then

  cubeWidth  = 16129;
  cubeHeight = 1;
  cubeDepth  = 1;

    writeln(finishtime.hours - starttime.hours, ':',
            finishtime.minutes - starttime.minutes, ':',
            finishtime.seconds - starttime.seconds, '.',
            finishtime.hseconds - starttime.hseconds);

  function PCube_SelectExchange2_byTruthIndex(var Cube: PCube; const p, m, n: word): longint;
  var
    B: MyType;
    i,
    ks, js,
    jt, kt: word;
    StartTime, FinishTime: TTime;
    cnt : longint; // <--- 1
  Begin
    cnt := 0;
    with StartTime do GetTime(Hours,Minutes,Seconds,HSeconds);
    for i := 1 to p do
      for ks := 1 to n do
        for js := 1 to m do
        begin
          for jt := js+1 to m do
          begin
             inc(cnt); // <--- 2
            if Cube^[i]^[jt]^[ks] <= Cube^[i]^[js]^[ks] then
            begin
              b := Cube^[i]^[jt]^[ks];
              Cube^[i]^[jt]^[ks] := Cube^[i]^[js]^[ks];
              Cube^[i]^[js]^[ks] := b;
            end;
          end;
          for kt := ks+1 to n do
          begin
            inc(cnt); // <--- 3
            for jt :=1 to m do
              if Cube^[i]^[jt]^[kt] <= Cube^[i]^[js]^[ks] then
              begin
                b := Cube^[i]^[jt]^[kt];
                Cube^[i]^[jt]^[kt] := Cube^[i]^[js]^[ks];
                Cube^[i]^[js]^[ks] := b;
              end;
          end;
        end;
    with FinishTime do GetTime(Hours,Minutes,Seconds,HSeconds);
    writeln ('count = ', cnt); // <--- 4
    PCube_SelectExchange2_byTruthIndex := ResTime(StartTime, FinishTime);
  end;

for kt := ks+1 to n do
          begin
            inc(cnt); // <--- 3
            for jt :=1 to m do
            //сюда

Сравним количество перемещений: (Показать/Скрыть)

  function PCube_SelectExchange2_byTruthIndex(var Cube: PCube; const p, m, n: word): longint;
  var
    B: MyType;
    i,
    ks, js,
    jt, kt: word;
    StartTime, FinishTime: TTime;
    cnt : longint;
  Begin
    cnt := 0;
    with StartTime do GetTime(Hours,Minutes,Seconds,HSeconds);
    for i := 1 to p do
      for ks := 1 to n do
        for js := 1 to m do
        begin
          for jt := js+1 to m do
          begin
            if Cube^[i]^[jt]^[ks] <= Cube^[i]^[js]^[ks] then
            begin
              inc(cnt);
              b := Cube^[i]^[jt]^[ks];
              Cube^[i]^[jt]^[ks] := Cube^[i]^[js]^[ks];
              Cube^[i]^[js]^[ks] := b;
            end;
          end;
          for kt := ks+1 to n do
          begin
            for jt :=1 to m do
              if Cube^[i]^[jt]^[kt] <= Cube^[i]^[js]^[ks] then
              begin
                inc(cnt);
                b := Cube^[i]^[jt]^[kt];
                Cube^[i]^[jt]^[kt] := Cube^[i]^[js]^[ks];
                Cube^[i]^[js]^[ks] := b;
              end;
          end;
        end;
    with FinishTime do GetTime(Hours,Minutes,Seconds,HSeconds);
    writeln ('count = ', cnt);
    PCube_SelectExchange2_byTruthIndex := ResTime(StartTime, FinishTime);
  end;

(я надеюсь, теперь я не ошибся с местом? )

  // -- 60 randoms for test --
  const RSize = 5 * 6 * 2;
  var R : array[1 .. RSize] of MyType;

   procedure PCube_Init(var Cube: PCube; const p, m, n: word);
   var
     i, j, k: word;
     curr : Word;
   begin
     curr := 1;
     for i := 1 to p do
       for j := 1 to m do
         for k := 1 to n do
         begin
           Cube^[i]^[j]^[k] := R[curr];
           Inc(Curr);
         end;
   end;
   procedure PCube_Print(var Cube: PCube; const p, m, n: word);
   var
     i, j, k: word;
   begin
     for i := 1 to p do
     begin
       writeln;
       writeln('Layer:', i);
       for j := 1 to m do
       begin
         for k := 1 to n do
         begin
           write(Cube^[i]^[j]^[k]:5);
         end;
         writeln;
       end;
     end;
   end;

При входе в Menu, еще до Repeat, выполняется
    for i := 1 to RSize do
    begin
      R[i] := Random(100);
    end;

      2: // Выбрана сортировка Cube в меню
      begin
      (*
        Create(Cube,p,m,n);
        CubeFill[FillType](Cube,p,m,n);
        Time := CubeSort[SortType](Cube,p,m,n);
        writeln('Time = ',Time);
        Destroy(Cube,p,m,n);
      *)
        writeln('first');
        p := 5; m := 6; n := 2;
        PCube_Create(Cube,p,m,n);
        PCube_Init(Cube,p,m,n);
        PCube_Print(Cube,p,m,n);
        readln;

        Time := CubeSort[3](Cube,p,m,n);
        PCube_Print(Cube,p,m,n);
        writeln('Time = ',Time);
        Destroy(Cube,p,m,n);

        readln;

        writeln('second');
        p := 5; m := 3; n := 4;
        PCube_Create(Cube,p,m,n);
        PCube_Init(Cube,p,m,n);
        PCube_Print(Cube,p,m,n);
        readln;

        Time := CubeSort[3](Cube,p,m,n);
        PCube_Print(Cube,p,m,n);
        writeln('Time = ',Time);
        Destroy(Cube,p,m,n);
      end;

1. Vector Sort
2. Cube Sort
3. Complex
4. Exit
2
first

Layer:1
   54   59
   71   84
   60   85
   54   84
   42   62
   64   38

Layer:2
   43   29
   89    5
   96   27
   38   47
   79   81
   52   47

Layer:3
   56   39
   92   83
    7   33
    8   64
    2   36
   83   95

Layer:4
   77   14
   87   87
   97   47
   79   80
   46   52
   78   67

Layer:5
   11   72
   63   58
   14   53
   94   75
   52   10
   41   47

count = 170

Layer:1
   38   62
   42   64
   54   71
   54   84
   59   84
   60   85

Layer:2
    5   47
   27   52
   29   79
   38   81
   43   89
   47   96

Layer:3
    2   56
    7   64
    8   83
   33   83
   36   92
   39   95

Layer:4
   14   78
   46   79
   47   80
   52   87
   67   87
   77   97

Layer:5
   10   53
   11   58
   14   63
   41   72
   47   75
   52   94
Time = 0

second

Layer:1
   54   59   71   84
   60   85   54   84
   42   62   64   38

Layer:2
   43   29   89    5
   96   27   38   47
   79   81   52   47

Layer:3
   56   39   92   83
    7   33    8   64
    2   36   83   95

Layer:4
   77   14   87   87
   97   47   79   80
   46   52   78   67

Layer:5
   11   72   63   58
   14   53   94   75
   52   10   41   47

count = 135

Layer:1
   38   54   62   84
   42   59   64   84
   54   60   71   85

Layer:2
    5   38   47   81
   27   43   52   89
   29   47   79   96

Layer:3
    2   33   56   83
    7   36   64   92
    8   39   83   95

Layer:4
   14   52   78   87
   46   67   79   87
   47   77   80   97

Layer:5
   10   41   53   72
   11   47   58   75
   14   52   63   94
Time = 0

procedure PCube_Init(var Cube: PCube; const p, m, n: word);
   var
     i, j, k: word;
     curr : Word;
   begin
     curr := 1;
     for i := 1 to p do
       for k := 1 to n do     //эта   
          for j := 1 to m do //и эта строки у Вас были наоборот. 
         
         begin
           Cube^[i]^[j]^[k] := R[curr];
           Inc(Curr);
         end;
   end;