program ;

{$R *.res}

uses
  windows, system.SysUtils;


function sprintf(S: PAnsiChar; const Format: PAnsiChar): Integer; cdecl;
  varargs; external 'msvcrt.dll';


function GetRandomString(const ALen: Integer): string; inline;
const
  ValidChars =
    '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz+-/*_';
var
  I, len: Integer;
begin
  Result := '';
  for I := 1 to ALen do
    Result := Result + ValidChars[Random(67) + Low(string)];
end;

function Test_hash(const str: string): UInt64;
var
  pos, len: NativeUInt;
begin
  len := PNativeUInt(PByte(str) - 4)^;
  Result := 1;
  pos := 1;

  while len > 10 do
  begin
    Result := Result + (ord(str[pos]) + ord(str[pos + 1]) + ord(str[pos + 2]) +
      ord(str[pos + 3]) + ord(str[pos + 4]) + ord(str[pos + 5]) +
      ord(str[pos + 6]) + ord(str[pos + 7]) + ord(str[pos + 8]) +
      ord(str[pos + 9]));

    DEC(len, 10);
    inc(pos, 10);
  end;

  case len of
    1:
      Result := Result * 1 + ord(str[pos]);
    2:
      Result := Result * 2 + (ord(str[pos]) + ord(str[pos + 1]));
    3:
      Result := Result * 3 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]));
    4:
      Result := Result * 4 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]));
    5:
      Result := Result * 5 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]));
    6:
      Result := Result * 6 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]) +
        ord(str[pos + 5]));
    7:
      Result := Result * 7 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]) +
        ord(str[pos + 5]) + ord(str[pos + 6]));
    8:
      Result := Result * 8 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]) +
        ord(str[pos + 5]) + ord(str[pos + 6]) + ord(str[pos + 7]));
    9:
      Result := Result * 9 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]) +
        ord(str[pos + 5]) + ord(str[pos + 6]) + ord(str[pos + 7]) +
        ord(str[pos + 8]));
    10:
      Result := Result * 10 + (ord(str[pos]) + ord(str[pos + 1]) +
        ord(str[pos + 2]) + ord(str[pos + 3]) + ord(str[pos + 4]) +
        ord(str[pos + 5]) + ord(str[pos + 6]) + ord(str[pos + 7]) +
        ord(str[pos + 8]) + ord(str[pos + 9]));
  end;
end;

procedure SaveToFile(const FileName: string; const Str: UnicodeString);
const
  CByteOrderMarkUTF16LittleEndian: array [1 .. 2] of Byte = ($FF, $FE);
var
  hFile: THandle;
  Unused: DWORD;
begin
  hFile := FileCreate(FileName);
  if hFile <> INVALID_HANDLE_VALUE then
    try
      WriteFile(hFile, CByteOrderMarkUTF16LittleEndian,
        Length(CByteOrderMarkUTF16LittleEndian), Unused, nil);

      WriteFile(hFile, Pointer(Str)^, Length(Str) * SizeOf(WideChar),
        Unused, nil);
    finally
      FileClose(hFile);
    end;
end;


var
  startTime, stopTime, iCounterPerSec: Int64;
  time: Single;
  I: Int64;
  Output: AnsiString;
  str, str2: string;
  GT, GT2: NativeUInt;

begin
  try

    QueryPerformanceCounter(startTime);
    str2 := '';
    GT := Test_hash('Hello');

    Writeln('Hello:   ' + inttostr(GT));
    for I := 0 to 10000000 - 1 do
    begin
      str := GetRandomString(Random(10 - 1) + 1);

      if GT = Test_hash(str) then
      begin
        str2 := str2 + #13 + str + '   :  ' + inttostr(GT);
      end;
    end;

    if QueryPerformanceCounter(stopTime) then
    begin
      QueryPerformanceFrequency(iCounterPerSec);

      time := (0 - startTime + stopTime) / iCounterPerSec;

      SetLength(Output, 15);

      SetLength(Output, sprintf(PAnsiChar(Output), '%f сек.', time));

      Writeln(Output);
    end;

    SaveToFile('Lexem.txt', str2);

    Readln;

    exit;
  except
    on E: Exception do

    begin
      Writeln(E.ClassName, ': ', E.Message);
      Readln;
    end;
  end;

end.

function RSHash(const Name: string): integer; // UInt64 
var
  I: Integer;
begin;
  Result := 0;
  for I := 0 to Length(Name) - 1 do
  begin;
    Result := Result * 1041204193 + (ord(Name[I + 1]) + 1507220783);
  end;
  Result := Result * -1866451833;
end;

function RSHashInline(Name: string): Integer; inline;
var
  I: Integer;
  t: PWord;
begin;
  t := PWord(Name);
  Result := 0;

  while char(t^) <> #0 do
  begin
    Result := (Result * 1041204193) + (t^ + 1507220783);
    INC(t);
  end;

  Result := Result * -1866451833;
end;

function RSHash(const Name: string): Integer;
var
  I: Integer;
begin;
  Result := 0;
  for I := 0 to Length(Name) - 1 do
  begin;
    Result := (Result * 1041204193) + (ord(Name[I + 1]) + 1507220783);
  end;
  Result := Result * -1866451833;
end;

    for I := 0 to 50000000 - 1 do
    begin
      src := RSHashInline('Text');
    end;

function RSHashInline(Name: string): Cardinal; inline;
var
  t: PChar;
begin;
  t := PChar(Name);
  Result := 0;

  while t^ <> #0 do
  begin
    Result := (Result * 1041204193) + (word(t^) + 1507220783);
    INC(t);

  end;

  Result := Result * -1866451833;
end;

function RapidHashCode_UStr(const S: UnicodeString): Integer;
label
  hash0, hash1, hash2, hash3, hash4, hash5, hash6, hash7, hash8, hash9, hash10;
var
  Value: PByte;
  Count: NativeUInt;
  M: Integer;
begin
  if (Pointer(S) <> nil) then
  begin 
    Value := Pointer(S);
    Count := PInteger(@Value[-SizeOf(Integer)])^;
    Count := Count * 2 + 2;
    Count := Count and -4;

    Result := Integer(Count) + PInteger(@Value[Count - SizeOf(Integer)])^ * 63689;
    case (Count - 1) shr 2 of
     10: goto hash10;
      9: goto hash9;
      8: goto hash8;
      7: goto hash7;
      6: goto hash6;
      5: goto hash5;
      4: goto hash4;
      3: goto hash3;
      2: goto hash2;
      1: goto hash1;
      0: goto hash0;
    else
      Dec(Count);
      M := -1660269137;
      repeat
        Result := Result * M + PInteger(Value)^;
        Dec(Count, SizeOf(Integer));
        Inc(Value, SizeOf(Integer));
        M := M * 378551;
      until (Count <= 43);

      hash10:
        Result := Result * 631547855 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash9:
        Result := Result * -1987506439 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash8:
        Result := Result * -1653913089 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash7:
        Result := Result * -186114231 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash6:
        Result := Result * 915264303 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash5:
        Result := Result * -794603367 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash4:
        Result := Result * 135394143 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash3:
        Result := Result * 2012804575 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash2:
        Result := Result * -1092754919 + PInteger(Value)^;
        Inc(Value, SizeOf(Integer));
      hash1:
        Result := Result * -1660269137 + PInteger(Value)^;
      hash0:
    end;

    Inc(Result, ((Result shr 8) * 63689) + ((Result shr 16) * -1660269137) +
      ((Result shr 24) * -1092754919));
    Exit;
  end else
  begin
    Result := 0;
  end;
end;