Разложить на множители целое число

function Множители(self: BigInteger): sequence of BigInteger; extensionmethod;
begin
  var i: BigInteger := 2;
  while i*i <= self do
  begin
    
    while self mod i = 0 do
    begin
      yield i;
      self := self div i;
    end;
    
    i += 1;
  end;
end;
 
begin
  BigInteger.Parse(ReadString)
  .Множители
  .PrintLines;
end.

uses System;
uses System.Runtime.InteropServices;
 
{$region ErrorCode}
 
type
  ErrorCode = (
    Success = 0,
    
    DeviceNotFound = -1,
    DeviceNotAvailable = -2,
    CompilerNotAvailable = -3,
    MemObjectAllocationFailure = -4,
    OutOfResources = -5,
    OutOfHostMemory = -6,
    ProfilingInfoNotAvailable = -7,
    MemCopyOverlap = -8,
    ImageFormatMismatch = -9,
    ImageFormatNotSupported = -10,
    BuildProgramFailure = -11,
    MapFailure = -12,
    MisalignedSubBufferOffset = -13,
    ExecStatusErrorForEventsInWaitList = -14,
    CompileProgramFailure = -15,
    LinkerNotAvailable = -16,
    LinkProgramFailure = -17,
    DevicePartitionFailed = -18,
    KernelArgInfoNotAvailable = -19,
    
    InvalidValue = -30,
    InvalidDeviceType = -31,
    InvalidPlatform = -32,
    InvalidDevice = -33,
    InvalidContext = -34,
    InvalidQueueProperties = -35,
    InvalidCommandQueue = -36,
    InvalidHostPtr = -37,
    InvalidMemObject = -38,
    InvalidImageFormatDescriptor = -39,
    InvalidImageSize = -40,
    InvalidSampler = -41,
    InvalidBinary = -42,
    InvalidBuildOptions = -43,
    InvalidProgram = -44,
    InvalidProgramExecutable = -45,
    InvalidKernelName = -46,
    InvalidKernelDefinition = -47,
    InvalidKernel = -48,
    InvalidArgIndex = -49,
    InvalidArgValue = -50,
    InvalidArgSize = -51,
    InvalidKernelArgs = -52,
    InvalidWorkDimension = -53,
    InvalidWorkGroupSize = -54,
    InvalidWorkItemSize = -55,
    InvalidGlobalOffset = -56,
    InvalidEventWaitList = -57,
    InvalidEvent = -58,
    InvalidOperation = -59,
    InvalidGlObject = -60,
    InvalidBufferSize = -61,
    InvalidMipLevel = -62,
    InvalidGlobalWorkSize = -63,
    InvalidProperty = -64,
    InvalidImageDescriptor = -65,
    InvalidCompilerOptions = -66,
    InvalidLinkerOptions = -67,
    InvalidDevicePartitionCount = -68,
    
    CL_INVALID_GL_SHAREGROUP_REFERENCE_KHR = -1000,
    CL_PLATFORM_NOT_FOUND_KHR = -1001,
    CL_INVALID_D3D10_DEVICE_KHR = -1002,
    CL_INVALID_D3D10_RESOURCE_KHR = -1003,
    CL_D3D10_RESOURCE_ALREADY_ACQUIRED_KHR = -1004,
    CL_D3D10_RESOURCE_NOT_ACQUIRED_KHR = -1005);
  
{$endregion ErrorCode}
  
{$region MemoryFlags}
  
  [Flags]
  MemoryFlags = (
    None = 0,
    ReadWrite = 1 shl 0,
    WriteOnly = 1 shl 1,
    ReadOnly = 1 shl 2,
    UseHostPointer = 1 shl 3,
    AllocateHostPointer = 1 shl 4,
    CopyHostPointer = 1 shl 5,
    //Reserved = 1 shl 6,
    HostWriteOnly = 1 shl 7,
    HostReadOnly = 1 shl 8,
    HostNoAccess = 1 shl 9
  );
 
  {$endregion MemoryFlags}
 
{$region CommandQueueProperties}
 
  [Flags]
  CommandQueueProperties = (
    cqNone = 0,
    OutOfOrderExecutionModeEnable = 1 shl 0,
    ProfilingEnable = 1 shl 1
  );
 
{$endregion CommandQueueProperties}
 
{$region external}
 
type
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  CreateContextCallback = procedure(
    [MarshalAs(UnmanagedType.LPStr)] errorInfo: string;
    privateInfo: IntPtr;
    cb: UIntPtr;
    userData: IntPtr
  );
  
  [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  BuildProgramCallback = procedure(prog, userData: IntPtr);
 
function clGetPlatformIDs(
  numEntries: cardinal;
  platforms: ^IntPtr;
  numPlatforms: ^cardinal
): ErrorCode; external 'opencl.dll';
 
function clGetDeviceIDs(
  platform: IntPtr;
  deviceType: uint64;
  numEntries: cardinal;
  devices: ^IntPtr;
  numDevices: ^cardinal
): ErrorCode; external 'opencl.dll';
 
function clCreateContext(
  [MarshalAs(UnmanagedType.LPArray)] properties: array of IntPtr;
  numDevices: cardinal;
  devices: ^IntPtr;
  pfnNotify: CreateContextCallback;
  userData: IntPtr;
  var ec: ErrorCode
): IntPtr; external 'opencl.dll';
 
function clCreateCommandQueue(
  context: IntPtr;
  device: IntPtr;
  properties: CommandQueueProperties;
  var ec: ErrorCode
): IntPtr; external 'opencl.dll';
 
function clCreateProgramWithSource(
  context: IntPtr;
  count: cardinal;
  [MarshalAs(UnmanagedType.LPArray, ArraySubType = UnmanagedType.LPStr)] strings: array of string;
  lengths: ^IntPtr;
  var ec: ErrorCode
): IntPtr; external 'opencl.dll';
 
function clBuildProgram(
  prog: IntPtr;
  numDevices: cardinal;
  devices: ^IntPtr;
  [MarshalAs(UnmanagedType.LPStr)] options: string;
  pfnNotify: BuildProgramCallback;
  userData: IntPtr
): ErrorCode; external 'opencl.dll';
 
function clCreateKernel(
  prog: IntPtr;
  [MarshalAs(UnmanagedType.LPStr)] kernelName: string;
  var ec: ErrorCode
): IntPtr; external 'opencl.dll';
 
function clCreateBuffer(
  context: IntPtr;
  flags: uint64;
  size: IntPtr;
  hostPointer: IntPtr;
  var ec: ErrorCode
): IntPtr; external 'opencl.dll';
 
function clSetKernelArg(
  kernel: IntPtr;
  argumentIndex: integer;
  argSize: UIntPtr;
  argValue: IntPtr
): ErrorCode; external 'opencl.dll';
 
function clEnqueueNDRangeKernel(
  commandQueue: IntPtr;
  kernel: IntPtr;
  workDim: cardinal;
  [MarshalAs(UnmanagedType.LPArray)] globalWorkOffset: array of IntPtr;
  [MarshalAs(UnmanagedType.LPArray)] globalWorkSize: array of IntPtr;
  [MarshalAs(UnmanagedType.LPArray)] localWorkSize: array of IntPtr;
  numEventsInWaitList: cardinal;
  eventWaitList: IntPtr; // [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] array of IntPtr;
  var ev: IntPtr
): ErrorCode; external 'opencl.dll';
 
function clFinish(
  commandQueue: IntPtr
): ErrorCode; external 'opencl.dll';
 
function clEnqueueReadBuffer(
  commandQueue: IntPtr;
  buffer: IntPtr;
  [MarshalAs(UnmanagedType.Bool)] blockingRead: boolean;
  offset: IntPtr;
  size: IntPtr;
  destination: IntPtr;
  numEventsInWaitList: cardinal;
  eventWaitList: IntPtr; // [MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(SafeHandleArrayMarshaler))] array of IntPtr;
  ev: ^IntPtr
): ErrorCode; external 'opencl.dll';
 
{$endregion external}
 
function GetMaxResCount(max_n: BigInteger): integer; //Ceil(BigInteger.Log(n,2)); // для n=(40!) - результатов будет (sqrt(40)!)
begin
  var n := BigInteger(1);
  var i := 1;
  
  while n < max_n do
  begin
    i += 1;
    n *= i;
  end;
  
  Result := i*(i-1) + 1;
end;
 
function ReadResBigInts(res: IntPtr; c: cardinal): sequence of BigInteger;
begin
  while true do
  begin
    
    var l := PLongword(pointer(res))^;
    res := res + 4;
    if c < (l+1)*4 then raise new System.IO.EndOfStreamException('Результат был нечитаем');
    
    var a := new byte[l*4];
    Marshal.Copy(res,a,0,l*4);
    yield new BigInteger(a);
    
    res := res + l*4;
    c -= (l+1)*4;
    
    if c=0 then exit;
  end;
end;
 
begin
  
  try
    var ec: ErrorCode;
    
    //==================================================
    //                 Поиск устройств
    //==================================================
    
    var platform: IntPtr;
    ec := clGetPlatformIDs(1, @platform, nil);
    if ec <> ErrorCode.Success then raise new System.NotSupportedException($'Похоже, на вашем компьютере нету драйверов OpenCL. Ошибка: {ec}');
    
    var device: IntPtr;
    ec := clGetDeviceIDs(platform, 1, 1, @device, nil);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка получения дескриптора устройства: {ec}');
    
    //==================================================
    //          Создание контекста выполнения
    //==================================================
    
    var context := clCreateContext(nil, 1, @device, nil, IntPtr.Zero, ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания контекста выполнения: {ec}');
    
    var command_queue := clCreateCommandQueue(context, device, cqNone, ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания очереди выполнения: {ec}');
    
    //==================================================
    //           Компиляция программы для GPU
    //==================================================
    
    {$resource prog.cl} // можно редактировать любым текстовым редактором. язык программы - разновидность языка C, переделанная под OpenCL
    var prog_str := System.IO.StreamReader.Create(GetResourceStream('prog.cl')).ReadToEnd;
    var prog_len := new IntPtr(prog_str.Length);
    var prog := clCreateProgramWithSource(
      context,
      1,
      new string[](prog_str),
      @prog_len,
      ec
    );
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка парсинга программы: {ec}');
    
    ec := clBuildProgram(prog, 1, @device, nil, nil, IntPtr.Zero);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка компиляции программы: {ec}');
    
    //==================================================
    //             Создание карнела (ядра)
    //==================================================
    
    var kernel := clCreateKernel(prog, 'FindAllMultipliers', ec); // обязательно то же имя с учётом регистра, что в .cl файле
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания карнела: {ec}');
    
    //==================================================
    //               Создание аргументов
    //==================================================
    var gc_hnd: GCHandle;
    
    var n := BigInteger.Parse(ReadString('Введите большое число:'));
    var last := BigInteger.Create(System.Math.Ceiling(Power(e, BigInteger.Log(n)/2))); // Ceil корня из n
    var n_arr := n.ToByteArray;
    var last_arr := last.ToByteArray;
    
    var max_res_count := GetMaxResCount(n);
    var max_big_int_len := 5; // обязательно то же самое что в .cl файле
    var max_res_size := (max_big_int_len*4 + 4) * max_res_count;
    
    if n < 4 then raise new System.NotSupportedException('Числа меньше 4 не поддерживаются');
    if n_arr.Length > max_big_int_len*4 then raise new System.NotSupportedException('Число слишком большое');
    
    
    
    gc_hnd := GCHandle.Alloc(n_arr, GCHandleType.Pinned); // @n_arr[0] писать нельзя, это создаёт утечку памяти
    var n_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(n_arr.Length), gc_hnd.AddrOfPinnedObject, ec);
    // ReadWrite это уровень доступа из карнела, а UseHostPointer значит скопировать данные из массива в область которая будет выделена на GPU
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "n": {ec}');
    gc_hnd.Free;
    
    var n_len := n_arr.Length;
    var n_len_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(4), new IntPtr(@n_len), ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "n_len": {ec}');
    
    
    
    gc_hnd := GCHandle.Alloc(last_arr, GCHandleType.Pinned);
    var last_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(last_arr.Length), gc_hnd.AddrOfPinnedObject, ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "last": {ec}');
    gc_hnd.Free;
    
    var last_len := n_arr.Length;
    var last_len_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(4), new IntPtr(@last_len), ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "last_len": {ec}');
    
    
    
    var res_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite), IntPtr(max_res_size), IntPtr.Zero, ec);
    // UseHostPointer не надо, ибо его читать не будет, а значит можно чтоб изначально там был мусор
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "res": {ec}');
    
    var res_pos := 0;
    var res_pos_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(4), new IntPtr(@res_pos), ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "res_pos": {ec}');
    
    
    
    var mutex := int64(0);
    var mutex_arg := clCreateBuffer(context, uint64(MemoryFlags.ReadWrite or MemoryFlags.UseHostPointer), IntPtr(8), new IntPtr(@mutex), ec);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка создания аргумента "mutex": {ec}');
    
    //==================================================
    //                    Выполнение
    //==================================================
    
    ec := clSetKernelArg(kernel, 0, new UIntPtr(sizeof(pointer)), new IntPtr(@n_arg));        if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #0: {ec}');
    ec := clSetKernelArg(kernel, 1, new UIntPtr(sizeof(pointer)), new IntPtr(@n_len_arg));    if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #1: {ec}');
    ec := clSetKernelArg(kernel, 2, new UIntPtr(sizeof(pointer)), new IntPtr(@last_arg));     if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #2: {ec}');
    ec := clSetKernelArg(kernel, 3, new UIntPtr(sizeof(pointer)), new IntPtr(@last_len_arg)); if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #3: {ec}');
    ec := clSetKernelArg(kernel, 4, new UIntPtr(sizeof(pointer)), new IntPtr(@res_arg));      if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #4: {ec}');
    ec := clSetKernelArg(kernel, 5, new UIntPtr(sizeof(pointer)), new IntPtr(@res_pos_arg));  if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #5: {ec}');
    ec := clSetKernelArg(kernel, 6, new UIntPtr(sizeof(pointer)), new IntPtr(@mutex_arg));    if ec<>ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка установки аргумента #6: {ec}');
    
    ec := clEnqueueNDRangeKernel(command_queue, kernel, 1, nil, new IntPtr[](IntPtr(256*256*256)),nil, 0,IntPtr.Zero,IntPtr.Zero);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка запуска выполнения: {ec}');
    
    //==================================================
    //                      Вывод
    //==================================================
    
    var res_mem := Marshal.AllocHGlobal(max_res_size);
    ec := clEnqueueReadBuffer(command_queue, res_arg,true,IntPtr(0),IntPtr(max_res_size), res_mem, 0,IntPtr.Zero,nil);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка чтения res_arg: {ec}');
    
    ec := clEnqueueReadBuffer(command_queue, res_pos_arg,true,IntPtr(0),IntPtr(4), new IntPtr(@res_pos), 0,IntPtr.Zero,nil);
    if ec <> ErrorCode.Success then raise new System.InvalidOperationException($'Ошибка чтения res_pos_arg: {ec}');
    
    ReadResBigInts(res_mem, res_pos)
    .PrintLines;
    
  except
    on e: Exception do writeln(e);
  end;
  
  if not System.Console.IsInputRedirected then readln; // срабатывает только в Shift+F9 режиме (ну и запуске самого .exe)
end.