sortingLib Plugin (Example) [Simba]

type
  TSortOrder = (so_LowToHigh, so_HighToLow);

type
  TSortAlgorithm = (sa_BubbleSort, sa_HeapSort, sa_InsertionSort,
                    sa_MergeSort, sa_MergeSortBU, sa_SelectionSort,
                    sa_ShellSort, sa_QuickSort, sa_QuickSort3W,
                    sa_JnlbSort, sa_JnlbSortDnmc);

function Min(a, b: Integer): Integer;
begin
  case (a < b) of
    True: Result := a;
    False: Result := b;
  end;
end;

procedure TIAJnlbSort(var TIA: array of Integer; order: TSortOrder);
var
  a, b, x, i, l, hi, lo, s, tmp: Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TIA[hi] < TIA[lo]) then
        begin
          tmp := TIA[hi];
          TIA[hi] := TIA[lo];
          TIA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TIA[x] < TIA[lo]) then
            lo := x
          else
            if (TIA[x] > TIA[hi]) then
              hi := x;
        if (lo > a) then
        begin
          tmp := TIA[a];
          TIA[a] := TIA[lo];
          TIA[lo] := tmp;
        end;
        if (hi < b) then
        begin
          tmp := TIA[b];
          TIA[b] := TIA[hi];
          TIA[hi] := tmp;
        end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TIA[hi] > TIA[lo]) then
        begin
          tmp := TIA[hi];
          TIA[hi] := TIA[lo];
          TIA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TIA[x] > TIA[lo]) then
            lo := x
          else
            if (TIA[x] < TIA[hi]) then
              hi := x;
        if (lo < a) then
        begin
          tmp := TIA[a];
          TIA[a] := TIA[lo];
          TIA[lo] := tmp;
        end;
        if (hi > b) then
        begin
          tmp := TIA[b];
          TIA[b] := TIA[hi];
          TIA[hi] := tmp;
        end;
      end;
    end;
  end;
end;

procedure TSAJnlbSort(var TSA: array of string; order: TSortOrder);
var
  a, b, x, i, l, hi, lo, s: Integer;
  tmp: string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TSA[hi] < TSA[lo]) then
        begin
          tmp := TSA[hi];
          TSA[hi] := TSA[lo];
          TSA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TSA[x] < TSA[lo]) then
            lo := x
          else
            if (TSA[x] > TSA[hi]) then
              hi := x;
        if (lo > a) then
        begin
          tmp := TSA[a];
          TSA[a] := TSA[lo];
          TSA[lo] := tmp;
        end;
        if (hi < b) then
        begin
          tmp := TSA[b];
          TSA[b] := TSA[hi];
          TSA[hi] := tmp;
        end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TSA[hi] > TSA[lo]) then
        begin
          tmp := TSA[hi];
          TSA[hi] := TSA[lo];
          TSA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TSA[x] > TSA[lo]) then
            lo := x
          else
            if (TSA[x] < TSA[hi]) then
              hi := x;
        if (lo < a) then
        begin
          tmp := TSA[a];
          TSA[a] := TSA[lo];
          TSA[lo] := tmp;
        end;
        if (hi > b) then
        begin
          tmp := TSA[b];
          TSA[b] := TSA[hi];
          TSA[hi] := tmp;
        end;
      end;
    end;
  end;
end;

procedure TEAJnlbSort(var TEA: array of Extended; order: TSortOrder);
var
  a, b, x, i, l, hi, lo, s: Integer;
  tmp: Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TEA[hi] < TEA[lo]) then
        begin
          tmp := TEA[hi];
          TEA[hi] := TEA[lo];
          TEA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TEA[x] < TEA[lo]) then
            lo := x
          else
            if (TEA[x] > TEA[hi]) then
              hi := x;
        if (lo > a) then
        begin
          tmp := TEA[a];
          TEA[a] := TEA[lo];
          TEA[lo] := tmp;
        end;
        if (hi < b) then
        begin
          tmp := TEA[b];
          TEA[b] := TEA[hi];
          TEA[hi] := tmp;
        end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TEA[hi] > TEA[lo]) then
        begin
          tmp := TEA[hi];
          TEA[hi] := TEA[lo];
          TEA[lo] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TEA[x] > TEA[lo]) then
            lo := x
          else
            if (TEA[x] < TEA[hi]) then
              hi := x;
        if (lo < a) then
        begin
          tmp := TEA[a];
          TEA[a] := TEA[lo];
          TEA[lo] := tmp;
        end;
        if (hi > b) then
        begin
          tmp := TEA[b];
          TEA[b] := TEA[hi];
          TEA[hi] := tmp;
        end;
      end;
    end;
  end;
end;

procedure TCAJnlbSort(var TCA: array of Char; order: TSortOrder);
var
  a, b, x, i, l, hi, lo, s: Integer;
  t: Char;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TCA[hi] < TCA[lo]) then
        begin
          t := TCA[hi];
          TCA[hi] := TCA[lo];
          TCA[lo] := t;
        end;
        for x := (a + 1) to (b - 1) do
          if (TCA[x] < TCA[lo]) then
            lo := x
          else
            if (TCA[x] > TCA[hi]) then
              hi := x;
        if (lo > a) then
        begin
          t := TCA[a];
          TCA[a] := TCA[lo];
          TCA[lo] := t;
        end;
        if (hi < b) then
        begin
          t := TCA[b];
          TCA[b] := TCA[hi];
          TCA[hi] := t;
        end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        lo := i;
        hi := ((l - 1) - i);
        a := lo;
        b := hi;
        if (TCA[hi] > TCA[lo]) then
        begin
          t := TCA[hi];
          TCA[hi] := TCA[lo];
          TCA[lo] := t;
        end;
        for x := (a + 1) to (b - 1) do
          if (TCA[x] > TCA[lo]) then
            lo := x
          else
            if (TCA[x] < TCA[hi]) then
              hi := x;
        if (lo < a) then
        begin
          t := TCA[a];
          TCA[a] := TCA[lo];
          TCA[lo] := t;
        end;
        if (hi > b) then
        begin
          t := TCA[b];
          TCA[b] := TCA[hi];
          TCA[hi] := t;
        end;
      end;
    end;
  end;
end;

procedure TIAJnlbSortDnmc(var TIA: array of Integer; order: TSortOrder);
var
  a, b, x, i, l, s, tmp: Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TIA[b] < TIA[a]) then
        begin
          tmp := TIA[b];
          TIA[b] := TIA[a];
          TIA[a] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TIA[x] < TIA[a]) then
          begin
            tmp := TIA[x];
            TIA[x] := TIA[a];
            TIA[a] := tmp;
          end else
            if (TIA[x] > TIA[b]) then
            begin
              tmp := TIA[x];
              TIA[x] := TIA[b];
              TIA[b] := tmp;
            end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TIA[a] > TIA[b]) then
        begin
          tmp := TIA[a];
          TIA[a] := TIA[b];
          TIA[b] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TIA[x] > TIA[a]) then
          begin
            tmp := TIA[x];
            TIA[x] := TIA[a];
            TIA[a] := tmp;
          end else
            if (TIA[x] < TIA[b]) then
            begin
              tmp := TIA[x];
              TIA[x] := TIA[b];
              TIA[b] := tmp;
            end;
      end;
    end;
  end;
end;

procedure TSAJnlbSortDnmc(var TSA: array of string; order: TSortOrder);
var
  a, b, x, i, l, s: Integer;
  tmp: string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TSA[b] < TSA[a]) then
        begin
          tmp := TSA[b];
          TSA[b] := TSA[a];
          TSA[a] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TSA[x] < TSA[a]) then
          begin
            tmp := TSA[x];
            TSA[x] := TSA[a];
            TSA[a] := tmp;
          end else
            if (TSA[x] > TSA[b]) then
            begin
              tmp := TSA[x];
              TSA[x] := TSA[b];
              TSA[b] := tmp;
            end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TSA[a] > TSA[b]) then
        begin
          tmp := TSA[a];
          TSA[a] := TSA[b];
          TSA[b] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TSA[x] > TSA[a]) then
          begin
            tmp := TSA[x];
            TSA[x] := TSA[a];
            TSA[a] := tmp;
          end else
            if (TSA[x] < TSA[b]) then
            begin
              tmp := TSA[x];
              TSA[x] := TSA[b];
              TSA[b] := tmp;
            end;
      end;
    end;
  end;
end;

procedure TEAJnlbSortDnmc(var TEA: array of Extended; order: TSortOrder);
var
  a, b, x, i, l, s: Integer;
  tmp: Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TEA[b] < TEA[a]) then
        begin
          tmp := TEA[b];
          TEA[b] := TEA[a];
          TEA[a] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TEA[x] < TEA[a]) then
          begin
            tmp := TEA[x];
            TEA[x] := TEA[a];
            TEA[a] := tmp;
          end else
            if (TEA[x] > TEA[b]) then
            begin
              tmp := TEA[x];
              TEA[x] := TEA[b];
              TEA[b] := tmp;
            end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TEA[a] > TEA[b]) then
        begin
          tmp := TEA[a];
          TEA[a] := TEA[b];
          TEA[b] := tmp;
        end;
        for x := (a + 1) to (b - 1) do
          if (TEA[x] > TEA[a]) then
          begin
            tmp := TEA[x];
            TEA[x] := TEA[a];
            TEA[a] := tmp;
          end else
            if (TEA[x] < TEA[b]) then
            begin
              tmp := TEA[x];
              TEA[x] := TEA[b];
              TEA[b] := tmp;
            end;
      end;
    end;
  end;
end;

procedure TCAJnlbSortDnmc(var TCA: array of Char; order: TSortOrder);
var
  a, b, x, i, l, s: Integer;
  t: Char;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    s := ((l - 1) div 2);
    case order of
      so_LowToHigh:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TCA[b] < TCA[a]) then
        begin
          t := TCA[b];
          TCA[b] := TCA[a];
          TCA[a] := t;
        end;
        for x := (a + 1) to (b - 1) do
          if (TCA[x] < TCA[a]) then
          begin
            t := TCA[x];
            TCA[x] := TCA[a];
            TCA[a] := t;
          end else
            if (TCA[x] > TCA[b]) then
            begin
              t := TCA[x];
              TCA[x] := TCA[b];
              TCA[b] := t;
            end;
      end;
      so_HighToLow:
      for i := 0 to s do
      begin
        a := i;
        b := ((l - 1) - i);
        if (TCA[a] > TCA[b]) then
        begin
          t := TCA[a];
          TCA[a] := TCA[b];
          TCA[b] := t;
        end;
        for x := (a + 1) to (b - 1) do
          if (TCA[x] > TCA[a]) then
          begin
            t := TCA[x];
            TCA[x] := TCA[a];
            TCA[a] := t;
          end else
            if (TCA[x] < TCA[b]) then
            begin
              t := TCA[x];
              TCA[x] := TCA[b];
              TCA[b] := t;
            end;
      end;
    end;
  end;
end;

procedure TIABubbleSort(var TIA: array of Integer; order: TSortOrder);
var
  a, b, h, tmp: Integer;
begin
  h := High(TIA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TIA[(b - 1)] > TIA[b]) then
        begin
          tmp := TIA[(b - 1)];
          TIA[(b - 1)] := TIA[b];
          TIA[b] := tmp;
        end;
    so_HighToLow:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TIA[(b - 1)] < TIA[b]) then
        begin
          tmp := TIA[(b - 1)];
          TIA[(b - 1)] := TIA[b];
          TIA[b] := tmp;
        end;
  end;
end;

procedure TSABubbleSort(var TSA: array of string; order: TSortOrder);
var
  a, b, h: Integer;
  tmp: string;
begin
  h := High(TSA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TSA[(b - 1)] > TSA[b]) then
        begin
          tmp := TSA[(b - 1)];
          TSA[(b - 1)] := TSA[b];
          TSA[b] := tmp;
        end;
    so_HighToLow:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TSA[(b - 1)] < TSA[b]) then
        begin
          tmp := TSA[(b - 1)];
          TSA[(b - 1)] := TSA[b];
          TSA[b] := tmp;
        end;
  end;
end;

procedure TEABubbleSort(var TEA: array of Extended; order: TSortOrder);
var
  a, b, h: Integer;
  tmp: Extended;
begin
  h := High(TEA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TEA[(b - 1)] > TEA[b]) then
        begin
          tmp := TEA[(b - 1)];
          TEA[(b - 1)] := TEA[b];
          TEA[b] := tmp;
        end;
    so_HighToLow:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TEA[(b - 1)] < TEA[b]) then
        begin
          tmp := TEA[(b - 1)];
          TEA[(b - 1)] := TEA[b];
          TEA[b] := tmp;
        end;
  end;
end;

procedure TCABubbleSort(var TCA: array of Char; order: TSortOrder);
var
  t: Char;
  a, b, h: Integer;
begin
  h := High(TCA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TCA[(b - 1)] > TCA[b]) then
        begin
          t := TCA[(b - 1)];
          TCA[(b - 1)] := TCA[b];
          TCA[b] := t;
        end;
    so_HighToLow:
    for a := 0 to h do
      for b := 1 to (h - a) do
        if (TCA[(b - 1)] < TCA[b]) then
        begin
          t := TCA[(b - 1)];
          TCA[(b - 1)] := TCA[b];
          TCA[b] := t;
        end;
  end;
end;

procedure TIAInsertionSort(var TIA: array of Integer; order: TSortOrder);
var
  a, b, h, tmp: Integer;
begin
  h := High(TIA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TIA[b] < TIA[(b - 1)]) then
          Break;
        tmp := TIA[(b - 1)];
        TIA[(b - 1)] := TIA[b];
        TIA[b] := tmp;
      end;
    so_HighToLow:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TIA[b] > TIA[(b - 1)]) then
          Break;
        tmp := TIA[(b - 1)];
        TIA[(b - 1)] := TIA[b];
        TIA[b] := tmp;
      end;
  end;
end;

procedure TSAInsertionSort(var TSA: array of string; order: TSortOrder);
var
  a, b, h: Integer;
  tmp: string;
begin
  h := High(TSA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TSA[b] < TSA[(b - 1)]) then
          Break;
        tmp := TSA[(b - 1)];
        TSA[(b - 1)] := TSA[b];
        TSA[b] := tmp;
      end;
    so_HighToLow:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TSA[b] > TSA[(b - 1)]) then
          Break;
        tmp := TSA[(b - 1)];
        TSA[(b - 1)] := TSA[b];
        TSA[b] := tmp;
      end;
  end;
end;

procedure TEAInsertionSort(var TEA: array of Extended; order: TSortOrder);
var
  a, b, h: Integer;
  tmp: Extended;
begin
  h := High(TEA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TEA[b] < TEA[(b - 1)]) then
          Break;
        tmp := TEA[(b - 1)];
        TEA[(b - 1)] := TEA[b];
        TEA[b] := tmp;
      end;
    so_HighToLow:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TEA[b] > TEA[(b - 1)]) then
          Break;
        tmp := TEA[(b - 1)];
        TEA[(b - 1)] := TEA[b];
        TEA[b] := tmp;
      end;
  end;
end;

procedure TCAInsertionSort(var TCA: array of Char; order: TSortOrder);
var
  t: Char;
  a, b, h: Integer;
begin
  h := High(TCA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TCA[b] < TCA[(b - 1)]) then
          Break;
        t := TCA[(b - 1)];
        TCA[(b - 1)] := TCA[b];
        TCA[b] := t;
      end;
    so_HighToLow:
    for a := 1 to h do
      for b := a downto 1 do
      begin
        if not (TCA[b] > TCA[(b - 1)]) then
          Break;
        t := TCA[(b - 1)];
        TCA[(b - 1)] := TCA[b];
        TCA[b] := t;
      end;
  end;
end;

procedure TIAShellSort(var TIA: array of Integer; order: TSortOrder);
var
  x, a, b, l, tmp: Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    x := 0;
    while (x < (l div 3)) do
      x := ((x * 3) + 1);
    case order of
      so_HighToLow:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TIA[b] > TIA[(b - x)])) do
          begin
            tmp := TIA[b];
            TIA[b] := TIA[(b - x)];
            TIA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
      so_LowToHigh:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TIA[b] < TIA[(b - x)])) do
          begin
            tmp := TIA[b];
            TIA[b] := TIA[(b - x)];
            TIA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
    end;
  end;
end;

procedure TSAShellSort(var TSA: array of string; order: TSortOrder);
var
  x, a, b, l: Integer;
  tmp: string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    x := 0;
    while (x < (l div 3)) do
      x := ((x * 3) + 1);
    case order of
      so_HighToLow:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TSA[b] > TSA[(b - x)])) do
          begin
            tmp := TSA[b];
            TSA[b] := TSA[(b - x)];
            TSA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
      so_LowToHigh:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TSA[b] < TSA[(b - x)])) do
          begin
            tmp := TSA[b];
            TSA[b] := TSA[(b - x)];
            TSA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
    end;
  end;
end;

procedure TEAShellSort(var TEA: array of Extended; order: TSortOrder);
var
  x, a, b, l: Integer;
  tmp: Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    x := 0;
    while (x < (l div 3)) do
      x := ((x * 3) + 1);
    case order of
      so_HighToLow:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TEA[b] > TEA[(b - x)])) do
          begin
            tmp := TEA[b];
            TEA[b] := TEA[(b - x)];
            TEA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
      so_LowToHigh:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TEA[b] < TEA[(b - x)])) do
          begin
            tmp := TEA[b];
            TEA[b] := TEA[(b - x)];
            TEA[(b - x)] := tmp;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
    end;
  end;
end;

procedure TCAShellSort(var TCA: array of Char; order: TSortOrder);
var
  t: Char;
  x, a, b, l: Integer;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    x := 0;
    while (x < (l div 3)) do
      x := ((x * 3) + 1);
    case order of
      so_HighToLow:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TCA[b] > TCA[(b - x)])) do
          begin
            t := TCA[(b - x)];
            TCA[(b - x)] := TCA[b];
            TCA[b] := t;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
      so_LowToHigh:
      while (x >= 1) do
      begin
        for a := x to (l - 1) do
        begin
          b := a;
          while ((b >= x) and (TCA[b] < TCA[(b - x)])) do
          begin
            t := TCA[(b - x)];
            TCA[(b - x)] := TCA[b];
            TCA[b] := t;
            b := (b - x);
          end;
        end;
        x := (x div 3);
      end;
    end;
  end;
end;

procedure TIASelectionSort(var TIA: array of Integer; order: TSortOrder);
var
  c, t, h, m, tmp: Integer;
begin
  h := High(TIA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TIA[m] > TIA[t]) then
          m := t;
      tmp := TIA[m];
      TIA[m] := TIA[c];
      TIA[c] := tmp;
    end;
    so_HighToLow:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TIA[m] < TIA[t]) then
          m := t;
      tmp := TIA[m];
      TIA[m] := TIA[c];
      TIA[c] := tmp;
    end;
  end;
end;

procedure TSASelectionSort(var TSA: array of string; order: TSortOrder);
var
  c, t, h, m: Integer;
  tmp: string;
begin
  h := High(TSA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TSA[m] > TSA[t]) then
          m := t;
      tmp := TSA[m];
      TSA[m] := TSA[c];
      TSA[c] := tmp;
    end;
    so_HighToLow:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TSA[m] < TSA[t]) then
          m := t;
      tmp := TSA[m];
      TSA[m] := TSA[c];
      TSA[c] := tmp;
    end;
  end;
end;

procedure TEASelectionSort(var TEA: array of Extended; order: TSortOrder);
var
  c, t, h, m: Integer;
  tmp: Extended;
begin
  h := High(TEA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TEA[m] > TEA[t]) then
          m := t;
      tmp := TEA[m];
      TEA[m] := TEA[c];
      TEA[c] := tmp;
    end;
    so_HighToLow:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TEA[m] < TEA[t]) then
          m := t;
      tmp := TEA[m];
      TEA[m] := TEA[c];
      TEA[c] := tmp;
    end;
  end;
end;

procedure TCASelectionSort(var TCA: array of Char; order: TSortOrder);
var
  c, t, h, m: Integer;
  z: Char;
begin
  h := High(TCA);
  if (h > 0) then
  case order of
    so_LowToHigh:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TCA[m] > TCA[t]) then
          m := t;
      z := TCA[m];
      TCA[m] := TCA[c];
      TCA[c] := z;
    end;
    so_HighToLow:
    for c := 0 to h do
    begin
      m := c;
      for t := (c + 1) to h do
        if (TCA[m] < TCA[t]) then
          m := t;
      z := TCA[m];
      TCA[m] := TCA[c];
      TCA[c] := z;
    end;
  end;
end;

procedure TIAHeapSort(var TIA: array of Integer; order: TSortOrder);
var
  a, b, r, c, l, tmp: Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    a := ((l - 1) div 2);
    b := (l - 1);
    case order of
      so_LowToHigh:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TIA[c] < TIA[(c + 1)])) then
              c := (c + 1);
            if (TIA[r] < TIA[c]) then
            begin
              tmp := TIA[r];
              TIA[r] := TIA[c];
              TIA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TIA[b];
          TIA[b] := TIA[0];
          TIA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TIA[c] < TIA[(c + 1)])) then
              c := (c + 1);
            if (TIA[r] < TIA[c]) then
            begin
              tmp := TIA[r];
              TIA[r] := TIA[c];
              TIA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
      so_HighToLow:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TIA[c] > TIA[(c + 1)])) then
              c := (c + 1);
            if (TIA[r] > TIA[c]) then
            begin
              tmp := TIA[r];
              TIA[r] := TIA[c];
              TIA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TIA[b];
          TIA[b] := TIA[0];
          TIA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TIA[c] > TIA[(c + 1)])) then
              c := (c + 1);
            if (TIA[r] > TIA[c]) then
            begin
              tmp := TIA[r];
              TIA[r] := TIA[c];
              TIA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
    end;
  end;
end;

procedure TSAHeapSort(var TSA: array of string; order: TSortOrder);
var
  a, b, r, c, l: Integer;
  tmp: string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    a := ((l - 1) div 2);
    b := (l - 1);
    case order of
      so_LowToHigh:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TSA[c] < TSA[(c + 1)])) then
              c := (c + 1);
            if (TSA[r] < TSA[c]) then
            begin
              tmp := TSA[r];
              TSA[r] := TSA[c];
              TSA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TSA[b];
          TSA[b] := TSA[0];
          TSA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TSA[c] < TSA[(c + 1)])) then
              c := (c + 1);
            if (TSA[r] < TSA[c]) then
            begin
              tmp := TSA[r];
              TSA[r] := TSA[c];
              TSA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
      so_HighToLow:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TSA[c] > TSA[(c + 1)])) then
              c := (c + 1);
            if (TSA[r] > TSA[c]) then
            begin
              tmp := TSA[r];
              TSA[r] := TSA[c];
              TSA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TSA[b];
          TSA[b] := TSA[0];
          TSA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TSA[c] > TSA[(c + 1)])) then
              c := (c + 1);
            if (TSA[r] > TSA[c]) then
            begin
              tmp := TSA[r];
              TSA[r] := TSA[c];
              TSA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
    end;
  end;
end;

procedure TEAHeapSort(var TEA: array of Extended; order: TSortOrder);
var
  a, b, r, c, l: Integer;
  tmp: Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    a := ((l - 1) div 2);
    b := (l - 1);
    case order of
      so_LowToHigh:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TEA[c] < TEA[(c + 1)])) then
              c := (c + 1);
            if (TEA[r] < TEA[c]) then
            begin
              tmp := TEA[r];
              TEA[r] := TEA[c];
              TEA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TEA[b];
          TEA[b] := TEA[0];
          TEA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TEA[c] < TEA[(c + 1)])) then
              c := (c + 1);
            if (TEA[r] < TEA[c]) then
            begin
              tmp := TEA[r];
              TEA[r] := TEA[c];
              TEA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
      so_HighToLow:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TEA[c] > TEA[(c + 1)])) then
              c := (c + 1);
            if (TEA[r] > TEA[c]) then
            begin
              tmp := TEA[r];
              TEA[r] := TEA[c];
              TEA[c] := tmp;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          tmp := TEA[b];
          TEA[b] := TEA[0];
          TEA[0] := tmp;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TEA[c] > TEA[(c + 1)])) then
              c := (c + 1);
            if (TEA[r] > TEA[c]) then
            begin
              tmp := TEA[r];
              TEA[r] := TEA[c];
              TEA[c] := tmp;
              r := c;
            end else
              Break;
          end;
        end;
      end;
    end;
  end;
end;

procedure TCAHeapSort(var TCA: array of Char; order: TSortOrder);
var
  a, b, r, c, l: Integer;
  t: Char;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    a := ((l - 1) div 2);
    b := (l - 1);
    case order of
      so_LowToHigh:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TCA[c] < TCA[(c + 1)])) then
              c := (c + 1);
            if (TCA[r] < TCA[c]) then
            begin
              t := TCA[r];
              TCA[r] := TCA[c];
              TCA[c] := t;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          t := TCA[b];
          TCA[b] := TCA[0];
          TCA[0] := t;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TCA[c] < TCA[(c + 1)])) then
              c := (c + 1);
            if (TCA[r] < TCA[c]) then
            begin
              t := TCA[r];
              TCA[r] := TCA[c];
              TCA[c] := t;
              r := c;
            end else
              Break;
          end;
        end;
      end;
      so_HighToLow:
      begin
        while (a >= 0) do
        begin
          r := a;
          while (((r * 2) + 1) <= (l - 1)) do
          begin
            c := ((r * 2) + 1);
            if ((c < (l - 1)) and (TCA[c] > TCA[(c + 1)])) then
              c := (c + 1);
            if (TCA[r] > TCA[c]) then
            begin
              t := TCA[r];
              TCA[r] := TCA[c];
              TCA[c] := t;
              r := c;
            end else
              Break;
          end;
          a := (a - 1);
        end;
        while (b > 0) do
        begin
          t := TCA[b];
          TCA[b] := TCA[0];
          TCA[0] := t;
          b := (b - 1);
          r := 0;
          while (((r * 2) + 1) <= b) do
          begin
            c := ((r * 2) + 1);
            if ((c < b) and (TCA[c] > TCA[(c + 1)])) then
              c := (c + 1);
            if (TCA[r] > TCA[c]) then
            begin
              t := TCA[r];
              TCA[r] := TCA[c];
              TCA[c] := t;
              r := c;
            end else
              Break;
          end;
        end;
      end;
    end;
  end;
end;

procedure __TIA_LH_QS(TIA: array of Integer; Lo, Hi: Integer);
var
  L, R, v, m, tmp: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  v := TIA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v < TIA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v > TIA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TIA[L];
    TIA[L] := TIA[R];
    TIA[R] := tmp;
  end;
  tmp := TIA[R];
  TIA[R] := TIA[Lo];
  TIA[Lo] := tmp;
  m := R;
  __TIA_LH_QS(TIA, Lo, (m - 1));
  __TIA_LH_QS(TIA, (m + 1), Hi);
end;

procedure __TIA_HL_QS(TIA: array of Integer; Lo, Hi: Integer);
var
  L, R, v, m, tmp: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  v := TIA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v > TIA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v < TIA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TIA[L];
    TIA[L] := TIA[R];
    TIA[R] := tmp;
  end;
  tmp := TIA[R];
  TIA[R] := TIA[Lo];
  TIA[Lo] := tmp;
  m := R;
  __TIA_HL_QS(TIA, Lo, (m - 1));
  __TIA_HL_QS(TIA, (m + 1), Hi);
end;

procedure __TEA_LH_QS(TEA: array of Extended; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, tmp: Extended;
begin
  if (Lo >= Hi) then
    Exit;
  v := TEA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v < TEA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v > TEA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TEA[L];
    TEA[L] := TEA[R];
    TEA[R] := tmp;
  end;
  tmp := TEA[R];
  TEA[R] := TEA[Lo];
  TEA[Lo] := tmp;
  m := R;
  __TEA_LH_QS(TEA, Lo, (m - 1));
  __TEA_LH_QS(TEA, (m + 1), Hi);
end;

procedure __TEA_HL_QS(TEA: array of Extended; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, tmp: Extended;
begin
  if (Lo >= Hi) then
    Exit;
  v := TEA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v > TEA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v < TEA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TEA[L];
    TEA[L] := TEA[R];
    TEA[R] := tmp;
  end;
  tmp := TEA[R];
  TEA[R] := TEA[Lo];
  TEA[Lo] := tmp;
  m := R;
  __TEA_HL_QS(TEA, Lo, (m - 1));
  __TEA_HL_QS(TEA, (m + 1), Hi);
end;

procedure __TSA_LH_QS(TSA: array of string; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, tmp: string;
begin
  if (Lo >= Hi) then
    Exit;
  v := TSA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v < TSA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v > TSA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TSA[L];
    TSA[L] := TSA[R];
    TSA[R] := tmp;
  end;
  tmp := TSA[R];
  TSA[R] := TSA[Lo];
  TSA[Lo] := tmp;
  m := R;
  __TSA_LH_QS(TSA, Lo, (m - 1));
  __TSA_LH_QS(TSA, (m + 1), Hi);
end;

procedure __TSA_HL_QS(TSA: array of string; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, tmp: string;
begin
  if (Lo >= Hi) then
    Exit;
  v := TSA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v > TSA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v < TSA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    tmp := TSA[L];
    TSA[L] := TSA[R];
    TSA[R] := tmp;
  end;
  tmp := TSA[R];
  TSA[R] := TSA[Lo];
  TSA[Lo] := tmp;
  m := R;
  __TSA_HL_QS(TSA, Lo, (m - 1));
  __TSA_HL_QS(TSA, (m + 1), Hi);
end;

procedure __TCA_LH_QS(TCA: array of Char; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, t: char;
begin
  if (Lo >= Hi) then
    Exit;
  v := TCA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v < TCA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v > TCA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    t := TCA[L];
    TCA[L] := TCA[R];
    TCA[R] := t;
  end;
  t := TCA[R];
  TCA[R] := TCA[Lo];
  TCA[Lo] := t;
  m := R;
  __TCA_LH_QS(TCA, Lo, (m - 1));
  __TCA_LH_QS(TCA, (m + 1), Hi);
end;

procedure __TCA_HL_QS(TCA: array of Char; Lo, Hi: Integer);
var
  L, R, m: Integer;
  v, t: Char;
begin
  if (Lo >= Hi) then
    Exit;
  v := TCA[Lo];
  L := Lo;
  R := (Hi + 1);
  while True do
  begin
    repeat
      Inc(L);
      if ((v > TCA[L]) or (L = Hi)) then
        Break;
    until False;
    repeat
      Dec(R);
      if ((v < TCA[R]) or (R = Lo)) then
        Break;
    until False;
    if (L >= R) then
      Break;
    t := TCA[L];
    TCA[L] := TCA[R];
    TCA[R] := t;
  end;
  t := TCA[R];
  TCA[R] := TCA[Lo];
  TCA[Lo] := t;
  m := R;
  __TCA_HL_QS(TCA, Lo, (m - 1));
  __TCA_HL_QS(TCA, (m + 1), Hi);
end;

procedure TIAQuickSort(TIA: array of Integer; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TIA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TIA_LH_QS(TIA, 0, h);
    so_HighToLow: __TIA_HL_QS(TIA, 0, h);
  end;
end;

procedure TSAQuickSort(TSA: array of string; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TSA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TSA_LH_QS(TSA, 0, h);
    so_HighToLow: __TSA_HL_QS(TSA, 0, h);
  end;
end;

procedure TEAQuickSort(TEA: array of Extended; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TEA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TEA_LH_QS(TEA, 0, h);
    so_HighToLow: __TEA_HL_QS(TEA, 0, h);
  end;
end;

procedure TCAQuickSort(TCA: array of Char; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TCA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TCA_LH_QS(TCA, 0, h);
    so_HighToLow: __TCA_HL_QS(TCA, 0, h);
  end;
end;

procedure __TSA_HL_QS3W(var TSA: array of string; const L, H: Integer);
var
  ls, rs, p: Integer;
  x, tmp: string;
begin
  if (L >= H) then
    Exit;
  x := TSA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TSA[p] > x) then
    begin
      tmp := TSA[ls];
      TSA[ls] := TSA[p];
      TSA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TSA[p] < x) then
    begin
      tmp := TSA[rs];
      TSA[rs] := TSA[p];
      TSA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TSA_HL_QS3W(TSA, L, (ls - 1));
  __TSA_HL_QS3W(TSA, (rs + 1), H);
end;

procedure __TSA_LH_QS3W(var TSA: array of string; const L, H: Integer);
var
  ls, rs, p: Integer;
  x, tmp: string;
begin
  if (L >= H) then
    Exit;
  x := TSA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TSA[p] < x) then
    begin
      tmp := TSA[ls];
      TSA[ls] := TSA[p];
      TSA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TSA[p] > x) then
    begin
      tmp := TSA[rs];
      TSA[rs] := TSA[p];
      TSA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TSA_LH_QS3W(TSA, L, (ls - 1));
  __TSA_LH_QS3W(TSA, (rs + 1), H);
end;

procedure __TEA_HL_QS3W(var TEA: array of Extended; const L, H: Integer);
var
  ls, rs, p: Integer;
  x, tmp: Extended;
begin
  if (L >= H) then
    Exit;
  x := TEA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TEA[p] > x) then
    begin
      tmp := TEA[ls];
      TEA[ls] := TEA[p];
      TEA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TEA[p] < x) then
    begin
      tmp := TEA[rs];
      TEA[rs] := TEA[p];
      TEA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TEA_HL_QS3W(TEA, L, (ls - 1));
  __TEA_HL_QS3W(TEA, (rs + 1), H);
end;

procedure __TEA_LH_QS3W(var TEA: array of Extended; const L, H: Integer);
var
  ls, rs, p: Integer;
  x, tmp: Extended;
begin
  if (L >= H) then
    Exit;
  x := TEA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TEA[p] < x) then
    begin
      tmp := TEA[ls];
      TEA[ls] := TEA[p];
      TEA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TEA[p] > x) then
    begin
      tmp := TEA[rs];
      TEA[rs] := TEA[p];
      TEA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TEA_LH_QS3W(TEA, L, (ls - 1));
  __TEA_LH_QS3W(TEA, (rs + 1), H);
end;

procedure __TCA_HL_QS3W(var TCA: array of Char; const L, H: Integer);
var
  t: Char;
  ls, rs, p: Integer;
  x: string;
begin
  if (L >= H) then
    Exit;
  x := TCA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TCA[p] > x) then
    begin
      t := TCA[ls];
      TCA[ls] := TCA[p];
      TCA[p] := t;
      Inc(p);
      Inc(ls);
    end else
    if (TCA[p] < x) then
    begin
      t := TCA[rs];
      TCA[rs] := TCA[p];
      TCA[p] := t;
      Dec(rs);
    end else
      Inc(p);
  __TCA_HL_QS3W(TCA, L, (ls - 1));
  __TCA_HL_QS3W(TCA, (rs + 1), H);
end;

procedure __TCA_LH_QS3W(var TCA: array of Char; const L, H: Integer);
var
  t: Char;
  ls, rs, p: Integer;
  x: string;
begin
  if (L >= H) then
    Exit;
  x := TCA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TCA[p] < x) then
    begin
      t := TCA[ls];
      TCA[ls] := TCA[p];
      TCA[p] := t;
      Inc(p);
      Inc(ls);
    end else
    if (TCA[p] > x) then
    begin
      t := TCA[rs];
      TCA[rs] := TCA[p];
      TCA[p] := t;
      Dec(rs);
    end else
      Inc(p);
  __TCA_LH_QS3W(TCA, L, (ls - 1));
  __TCA_LH_QS3W(TCA, (rs + 1), H);
end;

procedure __TIA_HL_QS3W(var TIA: array of Integer; const L, H: Integer);
var
  ls, rs, p, x, tmp: Integer;
begin
  if (L >= H) then
    Exit;
  x := TIA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TIA[p] > x) then
    begin
      tmp := TIA[ls];
      TIA[ls] := TIA[p];
      TIA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TIA[p] < x) then
    begin
      tmp := TIA[rs];
      TIA[rs] := TIA[p];
      TIA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TIA_HL_QS3W(TIA, L, (ls - 1));
  __TIA_HL_QS3W(TIA, (rs + 1), H);
end;

procedure __TIA_LH_QS3W(var TIA: array of Integer; const L, H: Integer);
var
  ls, rs, p, x, tmp: Integer;
begin
  if (L >= H) then
    Exit;
  x := TIA[L];
  ls := L;
  rs := H;
  p := (L + 1);
  while (p <= rs) do
    if (TIA[p] < x) then
    begin
      tmp := TIA[ls];
      TIA[ls] := TIA[p];
      TIA[p] := tmp;
      Inc(p);
      Inc(ls);
    end else
    if (TIA[p] > x) then
    begin
      tmp := TIA[rs];
      TIA[rs] := TIA[p];
      TIA[p] := tmp;
      Dec(rs);
    end else
      Inc(p);
  __TIA_LH_QS3W(TIA, L, (ls - 1));
  __TIA_LH_QS3W(TIA, (rs + 1), H);
end;

procedure TIAQuickSort3W(var TIA: array of Integer; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TIA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TIA_LH_QS3W(TIA, 0, h);
    so_HighToLow: __TIA_HL_QS3W(TIA, 0, h);
  end;
end;

procedure TSAQuickSort3W(var TSA: array of string; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TSA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TSA_LH_QS3W(TSA, 0, h);
    so_HighToLow: __TSA_HL_QS3W(TSA, 0, h);
  end;
end;

procedure TEAQuickSort3W(var TEA: array of Extended; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TEA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TEA_LH_QS3W(TEA, 0, h);
    so_HighToLow: __TEA_HL_QS3W(TEA, 0, h);
  end;
end;

procedure TCAQuickSort3W(var TCA: array of Char; order: TSortOrder);
var
  h: Integer;
begin
  h := High(TCA);
  if (h > 0) then
  case order of
    so_LowToHigh: __TCA_LH_QS3W(TCA, 0, h);
    so_HighToLow: __TCA_HL_QS3W(TCA, 0, h);
  end;
end;

procedure __TIA_LH_M(var TIA, tmp: array of Integer; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TIA_LH_M(TIA, tmp, Lo, m);
  __TIA_LH_M(TIA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TIA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TIA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TIA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TIA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TIA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TIA_HL_M(var TIA, tmp: array of Integer; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TIA_HL_M(TIA, tmp, Lo, m);
  __TIA_HL_M(TIA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TIA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TIA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TIA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TIA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TIA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TEA_LH_M(var TEA, tmp: array of Extended; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TEA_LH_M(TEA, tmp, Lo, m);
  __TEA_LH_M(TEA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TEA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TEA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TEA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TEA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TEA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TEA_HL_M(var TEA, tmp: array of Extended; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TEA_HL_M(TEA, tmp, Lo, m);
  __TEA_HL_M(TEA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TEA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TEA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TEA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TEA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TEA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TSA_LH_M(var TSA, tmp: array of string; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TSA_LH_M(TSA, tmp, Lo, m);
  __TSA_LH_M(TSA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TSA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TSA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TSA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TSA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TSA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TSA_HL_M(var TSA, tmp: array of string; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TSA_HL_M(TSA, tmp, Lo, m);
  __TSA_HL_M(TSA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TSA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TSA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TSA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TSA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TSA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TCA_LH_M(var TCA, tmp: array of Char; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TCA_LH_M(TCA, tmp, Lo, m);
  __TCA_LH_M(TCA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TCA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TCA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TCA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TCA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TCA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TCA_HL_M(var TCA, tmp: array of Char; const Lo, Hi: Integer);
var
  L, R, i, m: Integer;
begin
  if (Lo >= Hi) then
    Exit;
  m := (Lo + (Hi - Lo) div 2);
  __TCA_HL_M(TCA, tmp, Lo, m);
  __TCA_HL_M(TCA, tmp, (m + 1), Hi);
  L := Lo;
  R := (m + 1);
  for i := Lo to Hi do
    tmp[i] := TCA[i];
  for i := Lo to Hi do
    if (L > m) then
    begin
      TCA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TCA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TCA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TCA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure TIAMergeSort(var TIA: array of Integer; order: TSortOrder);
var
  l: Integer;
  t: array of Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    SetLength(t, l);
    case order of
      so_LowToHigh: __TIA_LH_M(TIA, t, 0, (l - 1));
      so_HighToLow: __TIA_HL_M(TIA, t, 0, (l - 1));
    end;
  end;
end;

procedure TSAMergeSort(var TSA: array of string; order: TSortOrder);
var
  l: Integer;
  t: array of string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    SetLength(t, l);
    case order of
      so_LowToHigh: __TSA_LH_M(TSA, t, 0, (l - 1));
      so_HighToLow: __TSA_HL_M(TSA, t, 0, (l - 1));
    end;
  end;
end;

procedure TEAMergeSort(var TEA: array of Extended; order: TSortOrder);
var
  l: Integer;
  t: array of Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    SetLength(t, l);
    case order of
      so_LowToHigh: __TEA_LH_M(TEA, t, 0, (l - 1));
      so_HighToLow: __TEA_HL_M(TEA, t, 0, (l - 1));
    end;
  end;
end;

procedure TCAMergeSort(var TCA: array of Char; order: TSortOrder);
var
  l: Integer;
  t: array of Char;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    SetLength(t, l);
    case order of
      so_LowToHigh: __TCA_LH_M(TCA, t, 0, (l - 1));
      so_HighToLow: __TCA_HL_M(TCA, t, 0, (l - 1));
    end;
  end;
end;

procedure __TIA_LH_MBU(var TIA, tmp: array of Integer; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TIA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TIA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TIA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TIA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TIA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TIA_HL_MBU(var TIA, tmp: array of Integer; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TIA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TIA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TIA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TIA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TIA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TEA_LH_MBU(var TEA, tmp: array of Extended; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TEA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TEA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TEA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TEA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TEA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TEA_HL_MBU(var TEA, tmp: array of Extended; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TEA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TEA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TEA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TEA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TEA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TSA_LH_MBU(var TSA, tmp: array of string; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TSA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TSA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TSA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TSA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TSA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TSA_HL_MBU(var TSA, tmp: array of string; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TSA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TSA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TSA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TSA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TSA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TCA_LH_MBU(var TCA, tmp: array of Char; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TCA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TCA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TCA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] < tmp[L]) then
        begin
          TCA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TCA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure __TCA_HL_MBU(var TCA, tmp: array of Char; const Lo, Mid, Hi: Integer);
var
  L, R, i: Integer;
begin
  L := Lo;
  R := (Mid + 1);
  for i := Lo to Hi do
    tmp[i] := TCA[i];
  for i := Lo to Hi do
    if (L > Mid) then
    begin
      TCA[i] := tmp[R];
      Inc(R);
    end else
      if (R > Hi) then
      begin
        TCA[i] := tmp[L];
        Inc(L);
      end else
        if (tmp[R] > tmp[L]) then
        begin
          TCA[i] := tmp[R];
          Inc(R);
        end else
        begin
          TCA[i] := tmp[L];
          Inc(L);
        end;
end;

procedure TIAMergeSortBU(var TIA: array of Integer; order: TSortOrder);
var
  l, s, Lo: Integer;
  tmp: array of Integer;
begin
  l := Length(TIA);
  if (l > 1) then
  begin
    SetLength(tmp, l);
    s := 1;
    case order of
      so_LowToHigh:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TIA_LH_MBU(TIA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
      so_HighToLow:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TIA_HL_MBU(TIA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
    end;
  end;
end;

procedure TSAMergeSortBU(var TSA: array of string; order: TSortOrder);
var
  l, s, Lo: Integer;
  tmp: array of string;
begin
  l := Length(TSA);
  if (l > 1) then
  begin
    SetLength(tmp, l);
    s := 1;
    case order of
      so_LowToHigh:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TSA_LH_MBU(TSA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
      so_HighToLow:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TSA_HL_MBU(TSA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
    end;
  end;
end;

procedure TEAMergeSortBU(var TEA: array of Extended; order: TSortOrder);
var
  l, s, Lo: Integer;
  tmp: array of Extended;
begin
  l := Length(TEA);
  if (l > 1) then
  begin
    SetLength(tmp, l);
    s := 1;
    case order of
      so_LowToHigh:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TEA_LH_MBU(TEA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
      so_HighToLow:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TEA_HL_MBU(TEA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
    end;
  end;
end;

procedure TCAMergeSortBU(var TCA: array of Char; order: TSortOrder);
var
  l, s, Lo: Integer;
  tmp: array of Char;
begin
  l := Length(TCA);
  if (l > 1) then
  begin
    SetLength(tmp, l);
    s := 1;
    case order of
      so_LowToHigh:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TCA_LH_MBU(TCA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
      so_HighToLow:
      while (s < l) do
      begin
        Lo := 0;
        while (Lo < (l - s)) do
        begin
          __TCA_HL_MBU(TCA, tmp, Lo, ((Lo + s) - 1), Min(((Lo + (s * 2)) - 1), (l - 1)));
          Lo := (Lo + (s * 2));
        end;
        s := (s + s);
      end;
    end;
  end;
end;

procedure TIASort(var TIA: array of Integer; algorithm: TSortAlgorithm; order: TSortOrder); // register;
begin
  case algorithm of
    sa_BubbleSort: TIABubbleSort(TIA, order);
    sa_InsertionSort: TIAInsertionSort(TIA, order);
    sa_QuickSort3W: TIAQuickSort3W(TIA, order);
    sa_QuickSort: TIAQuickSort(TIA, order);
    sa_ShellSort: TIAShellSort(TIA, order);
    sa_SelectionSort: TIASelectionSort(TIA, order);
    sa_JnlbSort: TIAJnlbSort(TIA, order);
    sa_JnlbSortDnmc: TIAJnlbSortDnmc(TIA, order);
    sa_HeapSort: TIAHeapSort(TIA, order);
    sa_MergeSort: TIAMergeSort(TIA, order);
    sa_MergeSortBU: TIAMergeSortBU(TIA, order);
  end;
end;

procedure TSASort(var TSA: array of string; algorithm: TSortAlgorithm; order: TSortOrder); // register;
begin
  case algorithm of
    sa_BubbleSort: TSABubbleSort(TSA, order);
    sa_InsertionSort: TSAInsertionSort(TSA, order);
    sa_QuickSort3W: TSAQuickSort3W(TSA, order);
    sa_QuickSort: TSAQuickSort(TSA, order);
    sa_ShellSort: TSAShellSort(TSA, order);
    sa_SelectionSort: TSASelectionSort(TSA, order);
    sa_JnlbSort: TSAJnlbSort(TSA, order);
    sa_JnlbSortDnmc: TSAJnlbSortDnmc(TSA, order);
    sa_HeapSort: TSAHeapSort(TSA, order);
    sa_MergeSort: TSAMergeSort(TSA, order);
    sa_MergeSortBU: TSAMergeSortBU(TSA, order);
  end;
end;

procedure TEASort(var TEA: array of Extended; algorithm: TSortAlgorithm; order: TSortOrder); // register;
begin
  case algorithm of
    sa_BubbleSort: TEABubbleSort(TEA, order);
    sa_InsertionSort: TEAInsertionSort(TEA, order);
    sa_QuickSort3W: TEAQuickSort3W(TEA, order);
    sa_QuickSort: TEAQuickSort(TEA, order);
    sa_ShellSort: TEAShellSort(TEA, order);
    sa_SelectionSort: TEASelectionSort(TEA, order);
    sa_JnlbSort: TEAJnlbSort(TEA, order);
    sa_JnlbSortDnmc: TEAJnlbSortDnmc(TEA, order);
    sa_HeapSort: TEAHeapSort(TEA, order);
    sa_MergeSort: TEAMergeSort(TEA, order);
    sa_MergeSortBU: TEAMergeSortBU(TEA, order);
  end;
end;

procedure TCASort(var TCA: array of Char; algorithm: TSortAlgorithm; order: TSortOrder); // register;
begin
  case algorithm of
    sa_BubbleSort: TCABubbleSort(TCA, order);
    sa_InsertionSort: TCAInsertionSort(TCA, order);
    sa_QuickSort3W: TCAQuickSort3W(TCA, order);
    sa_QuickSort: TCAQuickSort(TCA, order);
    sa_ShellSort: TCAShellSort(TCA, order);
    sa_SelectionSort: TCASelectionSort(TCA, order);
    sa_JnlbSort: TCAJnlbSort(TCA, order);
    sa_JnlbSortDnmc: TCAJnlbSortDnmc(TCA, order);
    sa_HeapSort: TCAHeapSort(TCA, order);
    sa_MergeSort: TCAMergeSort(TCA, order);
    sa_MergeSortBU: TCAMergeSortBU(TCA, order);
  end;
end;

{==============================================================================]
  Explanation: Returns a TIA that contains all the value from start value (aStart) to finishing value (aFinish)..
[==============================================================================}
function TIAByRange(aStart, aFinish: Integer): TIntegerArray;
var
  i, s, f: Integer;
begin
  if (aStart <> aFinish) then
  begin
    s := Integer(aStart);
    f := Integer(aFinish);
    SetLength(Result, (IAbs(aStart - aFinish) + 1));
    case (aStart > aFinish) of
      True:
      for i := s downto f do
        Result[(s - i)] := i;
      False:
      for i := s to f do
        Result[(i - s)] := i;
    end;
  end else
    Result := [Integer(aStart)];
end;

{==============================================================================]
  Explanation: Returns a TIA that contains all the value from start value (aStart) to finishing value (aFinish)..
  NOTE: Works with 2-bit method, that cuts loop in half.
[==============================================================================}
function TIAByRange2bit(aStart, aFinish: Integer): TIntegerArray;
var
  g, l, i, s, f: Integer;
begin
  if (aStart <> aFinish) then
  begin
    s := Integer(aStart);
    f := Integer(aFinish);
    l := (IAbs(aStart - aFinish) + 1);
    SetLength(Result, l);
    g := ((l - 1) div 2);
    case (aStart < aFinish) of
      True:
      begin
        for i := 0 to g do
        begin
          Result[i] := (s + i);
          Result[((l - 1) - i)] := (f - i);
        end;
        if ((l mod 2) <> 0) then
          Result[i] := (s + i);
      end;
      False:
      begin
        for i := 0 to g do
        begin
          Result[i] := (s - i);
          Result[((l - 1) - i)] := (f + i);
        end;
        if ((l mod 2) <> 0) then
          Result[i] := (s - i);
      end;
    end;
  end else
    Result := [Integer(aStart)];
end;

{==============================================================================]
  Explanation: Randomizes TIA.
               Example: [1, 2, 3] => [2, 3, 1]
               The higher count of shuffles is, the "stronger" randomization you'll get.
[==============================================================================}
procedure TIARandomizeEx(var TIA: TIntegerArray; shuffles: Integer);
var
  l, i, t: Integer;
begin
  l := Length(TIA);
  if ((l > 1) and (shuffles > 0)) then
    for t := 1 to shuffles do
      for i := 0 to (l - 1) do
        Swap(TIA[Random(l)], TIA[Random(l)]);
end;

{==============================================================================]
  Explanation: Fills TIA items with x.
[==============================================================================}
procedure TIAFillEx(var TIA: TIntegerArray; x: TIntegerArray);
var
  i, h, l: Integer;
begin
  h := High(TIA);
  l := Length(x);
  for i := 0 to h do
    TIA[i] := Integer(x[i mod l]);
end;

{==============================================================================]
  Explanation: Clones (a.K.a returns copy of) TIA.
[==============================================================================}
function TIAClone(TIA: TIntegerArray): TIntegerArray;
var
  h, i: Integer;
begin
  h := High(TIA);
  SetLength(Result, (h + 1));
  for i := 0 to h do
    Result[i] := Integer(TIA[i]);
end;

{==============================================================================]
  Explanation: Reverses TIA.
[==============================================================================}
procedure TIAReverse(var TIA: TIntegerArray);
var
  g, i, l: Integer;
begin
  l := (Length(TIA) - 1);
  if (l < 1) then
    Exit;
  g := (l div 2);
  for i := 0 to g do
    Swap(TIA[i], TIA[(l - i)]);
end;

procedure SortingTimer(TIA: TIntegerArray; algorithm: TSortAlgorithm);
var
  t: Integer;
  s: string;
  arr: TIntegerArray;
begin
  arr := TIAClone(TIA);
  t := GetSystemTime;
  case algorithm of
    sa_BubbleSort:
    begin
      TIABubbleSort(arr, so_LowToHigh);
      s := 'BubbleSort()';
    end;
    sa_HeapSort:
    begin
      TIAHeapSort(arr, so_LowToHigh);
      s := 'HeapSort()';
    end;
    sa_InsertionSort:
    begin
      TIAInsertionSort(arr, so_LowToHigh);
      s := 'InsertionSort()';
    end;
    sa_MergeSort:
    begin
      TIAMergeSort(arr, so_LowToHigh);
      s := 'MergeSort()';
    end;
    sa_MergeSortBU:
    begin
      TIAMergeSortBU(arr, so_LowToHigh);
      s := 'MergeSortBU()';
    end;
    sa_SelectionSort:
    begin
      TIASelectionSort(arr, so_LowToHigh);
      s := 'SelectionSort()';
    end;
    sa_ShellSort:
    begin
      TIAShellSort(arr, so_LowToHigh);
      s := 'ShellSort()';
    end;
    sa_QuickSort:
    begin
      TIAQuickSort(arr, so_LowToHigh);
      s := 'QuickSort()';
    end;
    sa_QuickSort3W:
    begin
      TIAQuickSort3W(arr, so_LowToHigh);
      s := 'QuickSort3W()';
    end;
    sa_JnlbSort:
    begin
      TIAJnlbSort(arr, so_LowToHigh);
      s := 'JnlbSort()';
    end;
    sa_JnlbSortDnmc:
    begin
      TIAJnlbSortDnmc(arr, so_LowToHigh);
      s := 'JnlbSortDnmc()';
    end;
  end;
  t := (GetSystemTime - t);
  WriteLn(MD5(ToStr(arr)) + ': ' + IntToStr(t) + ' ms. [' + s + ']');
  SetLength(arr, 0);
end;

var
  original: TIntegerArray;

begin
  ClearDebug;
  original := TIAByRange2bit(500, -500);
  WriteLn(MD5(ToStr(original)) + ' (REVERSED):');

  SortingTimer(original, sa_JnlbSort);
  SortingTimer(original, sa_JnlbSortDnmc);
  SortingTimer(original, sa_BubbleSort);
  SortingTimer(original, sa_ShellSort);
  SortingTimer(original, sa_SelectionSort);
  SortingTimer(original, sa_InsertionSort);
  SortingTimer(original, sa_MergeSort);
  SortingTimer(original, sa_MergeSortBU);
  SortingTimer(original, sa_HeapSort);
  SortingTimer(original, sa_QuickSort);
  SortingTimer(original, sa_QuickSort3W);

  WriteLn('');
  TIAReverse(original);
  WriteLn(MD5(ToStr(original)) + ' (ALREADY SORTED):');

  SortingTimer(original, sa_JnlbSort);
  SortingTimer(original, sa_JnlbSortDnmc);
  SortingTimer(original, sa_BubbleSort);
  SortingTimer(original, sa_ShellSort);
  SortingTimer(original, sa_SelectionSort);
  SortingTimer(original, sa_InsertionSort);
  SortingTimer(original, sa_MergeSort);
  SortingTimer(original, sa_MergeSortBU);
  SortingTimer(original, sa_HeapSort);
  SortingTimer(original, sa_QuickSort);
  SortingTimer(original, sa_QuickSort3W);

  WriteLn('');
  TIARandomizeEx(original, 2);
  WriteLn(MD5(ToStr(original)) + ' (RANDOMIZED):');

  SortingTimer(original, sa_JnlbSort);
  SortingTimer(original, sa_JnlbSortDnmc);
  SortingTimer(original, sa_BubbleSort);
  SortingTimer(original, sa_ShellSort);
  SortingTimer(original, sa_SelectionSort);
  SortingTimer(original, sa_InsertionSort);
  SortingTimer(original, sa_MergeSort);
  SortingTimer(original, sa_MergeSortBU);
  SortingTimer(original, sa_HeapSort);
  SortingTimer(original, sa_QuickSort);
  SortingTimer(original, sa_QuickSort3W);

  WriteLn('');
  TIAFillEx(original, [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384]);
  WriteLn(MD5(ToStr(original)) + ' ("FEW" UNIQUE):');

  SortingTimer(original, sa_JnlbSort);
  SortingTimer(original, sa_JnlbSortDnmc);
  SortingTimer(original, sa_BubbleSort);
  SortingTimer(original, sa_ShellSort);
  SortingTimer(original, sa_SelectionSort);
  SortingTimer(original, sa_InsertionSort);
  SortingTimer(original, sa_MergeSort);
  SortingTimer(original, sa_MergeSortBU);
  SortingTimer(original, sa_HeapSort);
  SortingTimer(original, sa_QuickSort);
  SortingTimer(original, sa_QuickSort3W);

  SetLength(original, 0);
end.