Program laba2;

Uses
    System.SysUtils, Math;

Type
    TArr = Array Of Integer;

Const
    MIN_NUMBER = 1;
    MAX_NUMBER = 1000;
    MIN_SOLUTION = 7;
    MAX_NUMBER_OF_PRIMES = 168;
    MAX_NUMBER_OF_MULTIPLICATIONS = 289;

Procedure OutputOfTaskInfo();
Begin
    Writeln('This program helps you to find all natural numbers not exceeding P [', MIN_NUMBER , ', ', MAX_NUMBER, '], ', #10#13, 'which can be represented as a product of two primes.');
End;

Function InputNumber(): Integer;
Var
    Number: Integer;
    IsCorrect: Boolean;
Begin
    Write('Enter P: ');
    Repeat
        IsCorrect := True;

        Try
            Read(Number);
        Except
            Write('ERROR! Please enter a number: ');
            IsCorrect := False;
        End;

        If (IsCorrect And ((Number > MAX_NUMBER) Or (Number < MIN_NUMBER))) Then
        Begin
                Write('ERROR! Please enter a number between ', MIN_NUMBER, ' and ', MAX_NUMBER, ' :');
                IsCorrect := False;
        End
        Else If (IsCorrect And (Number < MIN_SOLUTION)) Then
        Begin
                Write('No solutions. Try to enter another P: ');
                IsCorrect := False;
        End;

    Until IsCorrect;

    InputNumber := Number;
End;

Function SortingOfArray(Const MaxNumber: Integer; Arr: TArr): TArr;
Var
    I: Integer;
    SortedArr: TArr;
Begin
    SetLength(SortedArr, MaxNumber);
    For I := 0 To MaxNumber Do
    Begin
        SortedArr[I] := Arr[I];
    End;


    SortingOfArray := SortedArr;
End;

Function FindingOfPrimes(Const P: Integer): TArr;
Var
    ArrOfPrimes: TArr;
    SortedArrOfPrimes: TArr;
    Rounded, J, I, LastNum, Num, NumberOfPrimes: Integer;
    IsPrime: Boolean;
Begin
    J := 0;
    SetLength(ArrOfPrimes, MAX_NUMBER_OF_PRIMES);
    LastNum := P Div 2;
    For Num := 2 To LastNum Do
    Begin
        IsPrime := True;
        Rounded := Floor(Sqrt(Num));
        For I := 2 To Rounded Do
            If (Num Mod I = 0) Then
                IsPrime := False;

        If (IsPrime) Then
        Begin
            ArrOfPrimes[J] := Num;
            Inc(J);
        End;

    End;

    NumberOfPrimes := J;

    FindingOfPrimes := SortingOfArray(NumberOfPrimes, ArrOfPrimes);

End;

Function SortedArrayOfMultiplications(Const P: Integer; Const SortedArrOfPrimes: TArr): TArr;
Var
    K, J, I, Res, LastMult, NumberOfMult, LastNumberOfPrimes: Integer;
    ArrOfMultiplications: TArr;
    SortedArrOfMultiplications: TArr;
Begin
    K := 0;
    LastMult := P + 1;
    LastNumberOfPrimes := Length(SortedArrOfPrimes) - 1;

    For I := 0 To Length(SortedArrOfPrimes) Do
    Begin
        J := I;
        Res := 0;
        SetLength(ArrOfMultiplications, MAX_NUMBER_OF_MULTIPLICATIONS);

        While (J < LastNumberOfPrimes) Do
        Begin
            Res := SortedArrOfPrimes[I] * SortedArrOfPrimes[J + 1];
            If (Res < LastMult) Then
            Begin
                ArrOfMultiplications[K] := Res;
                Inc(J);
                Inc(K);
            End

            Else
                Inc(J);
        End;
    End;

    NumberOfMult := K;

    SortedArrayOfMultiplications := SortingOfArray(NumberOfMult, ArrOfMultiplications);

End;

Function BubbleSort(Arr: TArr): TArr;
Var
    IsSorted: Boolean;
    LastElem, Buf, I: Integer;
Begin
    LastElem := Length(Arr) - 2;

    Repeat
        IsSorted := True;
        For I := 0 To LastElem Do
            If (Arr[I] > Arr[I + 1]) Then
            Begin
                IsSorted := False;
                Buf := Arr[I];
                Arr[I] := Arr[I + 1];
                Arr[I + 1] := Buf;
            End;

    Until IsSorted;


    BubbleSort := SortingOfArray(I ,Arr);

End;

Procedure OutputOfArrayOfMultiplications(Const BubbleSortedArray: TArr);
Var
    I: Integer;
Begin
    Write('Multiplied primes => ');
    For I := 0 To Length(BubbleSortedArray) Do
        Write(BubbleSortedArray[I], ' ');
End;

Procedure Main();
Var
    P: Integer;
Begin
    OutputOfTaskInfo();
    P := InputNumber();
    OutputOfArrayOfMultiplications(BubbleSort(SortedArrayOfMultiplications(P, FindingOfPrimes(P))));
End;

Begin
    Main();
    Readln;
    Readln;
End.