diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Крутящийся треугольник 1 (простейший пример).pas b/InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.pas
similarity index 57%
rename from InstallerSamples/OpenGL и OpenCL/OpenGL/Крутящийся треугольник 1 (простейший пример).pas
rename to InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.pas
index 4ce8cb8f9..31d8fff70 100644
--- a/InstallerSamples/OpenGL и OpenCL/OpenGL/Крутящийся треугольник 1 (простейший пример).pas	
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.pas	
@@ -1,244 +1,172 @@
-{$reference System.Windows.Forms.dll}
-{$reference System.Drawing.dll}
-
-// Данный пример демонстрирует запуск простейшей программы с модулем OpenGL
-// Примите во внимание, что методы из gl_gdi. - могут служить только временной заменой в серьёзной программе
-// (По крайней мере в данной версии. В будущем, возможно, gl_gdi будет улучшено)
-// Они использованы тут, чтоб пример был проще
-
-uses System.Windows.Forms;
-uses System.Drawing;
-uses System;
-uses OpenGL;
-
-{$apptype windows} // убирает консоль
-
-var gl: OpenGL.gl<PlWin>;
-
-{$region Shader}
-
-function InitShader(fname: string; st: ShaderType): gl_shader;
-begin
-  Result := gl.CreateShader(st);
-  
-  var source := ReadAllText(fname);
-  
-  gl.ShaderSource(Result, 1,
-    new string[](source),
-    nil
-  );
-  
-  gl.CompileShader(Result);
-  // получаем состояние успешности компиляции
-  // 1=успешно
-  // 0=ошибка
-  var comp_ok: integer;
-  gl.GetShaderiv(Result, ShaderParameterName.COMPILE_STATUS, comp_ok);
-  if comp_ok = 0 then
-  begin
-    
-    // узнаём нужную длинную строки
-    var l: integer;
-    gl.GetShaderiv(Result, ShaderParameterName.INFO_LOG_LENGTH, l);
-    
-    // выделяем достаточно памяти чтоб сохранить строку
-    var ptr := System.Runtime.InteropServices.Marshal.AllocHGlobal(l);
-    
-    // получаем строку логов
-    gl.GetShaderInfoLog(Result, l, IntPtr.Zero, ptr);
-    
-    // преобразовываем в управляемую строку
-    var log := System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ptr);
-    Writeln(log);
-    
-    // и в конце обязательно освобождаем, чтобы не было утечек памяти
-    System.Runtime.InteropServices.Marshal.FreeHGlobal(ptr);
-    gl.DeleteShader(Result);
-    
-    Result := gl_shader.Zero;
-  end;
-  
-end;
-
-{$endregion Shader}
-
-{$region Program}
-
-function InitProgram(vertex_shader, fragment_shader: gl_shader): gl_program;
-begin
-  Result := gl.CreateProgram;
-  
-  gl.AttachShader(Result, vertex_shader);
-  if fragment_shader<>gl_shader.Zero then gl.AttachShader(Result, fragment_shader);
-  
-  gl.LinkProgram(Result);
-  // всё то же самое что и у шейдеров
-  var link_ok: integer;
-  gl.GetProgramiv(Result, ProgramPropertyARB.LINK_STATUS, link_ok);
-  if link_ok = 0 then
-  begin
-    
-    var l: integer;
-    gl.GetProgramiv(Result, ProgramPropertyARB.INFO_LOG_LENGTH, l);
-    var ptr := System.Runtime.InteropServices.Marshal.AllocHGlobal(l);
-    
-    gl.GetProgramInfoLog(Result, l, IntPtr.Zero, ptr);
-    var log := System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ptr);
-    Writeln(log);
-    
-    System.Runtime.InteropServices.Marshal.FreeHGlobal(ptr);
-    gl.DeleteProgram(Result);
-    
-    Result := gl_program.Zero;
-  end;
-  
-end;
-
-{$endregion Program}
-
-const dy = -Sin(Pi / 6) / 2;
-
-begin
-  
-  // Создаёт и настраиваем окно
-  var f := new Form;
-  f.StartPosition := FormStartPosition.CenterScreen;
-  f.ClientSize := new Size(500, 500);
-  f.FormBorderStyle := FormBorderStyle.Fixed3D;
-  // Если окно закрылось - надо сразу завершить программу
-  f.Closed += (o,e)->Halt();
-  
-  // Настраиваем поверхность рисования
-  var hdc := gl_gdi.InitControl(f);
-  
-  // Настраиваем перерисовку
-  gl_gdi.SetupControlRedrawing(f, hdc, EndFrame->
-  begin
-    
-    {$region Настройка глобальных параметров OpenGL}
-    
-    // При создании экземпляра OpenGL.gl инициализируются некоторые функции
-    // Это необходимо для всех функций из OpenGL1.2 и выше, потому что они локальны для контекста OpenGL
-    gl := new OpenGL.gl<PlWin>;
-    
-    {$endregion Настройка глобальных параметров OpenGL}
-    
-    {$region Инициализация переменных}
-    
-    var vertex_pos_buffer: gl_buffer;
-    gl.CreateBuffers(1, vertex_pos_buffer);
-    gl.NamedBufferData(
-      vertex_pos_buffer,
-      new IntPtr(3*sizeof(Vec2f)),
-      ArrGen(3, i->
-      begin
-        var rot := i * Pi * 2 / 3;
-        
-        Result := new Vec2f(
-          Sin(rot),
-          Cos(rot) + dy
-        );
-        
-      end),
-      VertexBufferObjectUsage.STATIC_DRAW
-    );
-    
-    var vertex_clr_buffer: gl_buffer;
-    gl.CreateBuffers(1, vertex_clr_buffer);
-    gl.NamedBufferData(
-      vertex_clr_buffer,
-      new IntPtr(3*sizeof(Vec3f)),
-      new Vec3f[](
-        new Vec3f(1,0,0),
-        new Vec3f(0,1,0),
-        new Vec3f(0,0,1)
-      ),
-      VertexBufferObjectUsage.STATIC_DRAW
-    );
-    
-    var element_buffer: gl_buffer;
-    gl.CreateBuffers(1, element_buffer);
-    gl.NamedBufferData(
-      element_buffer,
-      new IntPtr(3*sizeof(byte)),
-      new byte[](
-        0,1,2
-      ),
-      VertexBufferObjectUsage.STATIC_DRAW
-    );
-    
-    var vertex_shader := InitShader('Rot Triangle 1.vertex.glsl', ShaderType.VERTEX_SHADER);
-//    var fragment_shader := InitShader('fragment.glsl', ShaderType.FRAGMENT_SHADER);
-    
-    var sprog := InitProgram(vertex_shader, gl_shader.Zero {fragment_shader});
-    
-    var uniform_rot_k :=     gl.GetUniformLocation(sprog, 'rot_k');
-    
-    var attribute_position := gl.GetAttribLocation(sprog, 'position');
-    var attribute_color :=    gl.GetAttribLocation(sprog, 'color');
-    
-    var t := new Stopwatch;
-    t.Start;
-    
-    {$endregion Инициализация переменных}
-    
-    while true do
-    begin
-      // очищаем окно в начале перерисовки
-      gl.Clear(ClearBufferMask.COLOR_BUFFER_BIT);
-      
-      
-      
-      gl.UseProgram(sprog);
-      
-      gl.Uniform1f(uniform_rot_k, Cos( t.Elapsed.Ticks * 0.0000002 ) );
-      
-      gl.BindBuffer(BufferTargetARB.ARRAY_BUFFER, vertex_pos_buffer);
-      gl.VertexAttribPointer(
-        attribute_position,
-        2,
-        VertexAttribPointerType.FLOAT,
-        false,
-        8,
-        IntPtr.Zero
-      );
-      gl.EnableVertexAttribArray(attribute_position);
-      
-      gl.BindBuffer(BufferTargetARB.ARRAY_BUFFER, vertex_clr_buffer);
-      gl.VertexAttribPointer(
-        attribute_color,
-        3,
-        VertexAttribPointerType.FLOAT,
-        false,
-        12,
-        IntPtr.Zero
-      );
-      gl.EnableVertexAttribArray(attribute_color);
-      
-      gl.BindBuffer(BufferTargetARB.ELEMENT_ARRAY_BUFFER, element_buffer);
-      gl.DrawElements(
-        PrimitiveType.TRIANGLES,
-        3,
-        DrawElementsType.UNSIGNED_BYTE,
-        IntPtr.Zero
-      );
-      
-      gl.DisableVertexAttribArray(attribute_position);
-      gl.DisableVertexAttribArray(attribute_color);
-      
-      
-      
-      // получаем тип последней ошибки
-      var err := gl.GetError;
-      // и если ошибка есть - выводим её
-      if err<>ErrorCode.NO_ERROR then Writeln(err);
-      
-      gl.Finish;
-      // EndFrame меняет местами буферы и ждёт vsync
-      EndFrame;
-    end;
-    
-  end);
-  
-  Application.Run(f);
+{$reference System.Windows.Forms.dll}
+{$reference System.Drawing.dll}
+
+// Данный пример демонстрирует запуск простейшей программы с модулем OpenGL
+// Примите во внимание, что методы из gl_gdi. - могут служить только временной заменой в серьёзной программе
+// (По крайней мере в данной версии. В будущем, возможно, gl_gdi будет улучшено)
+// Они использованы тут, чтоб пример был проще
+
+uses System.Windows.Forms;
+uses System;
+uses OpenGL;
+
+uses Common in '..\Common';
+
+{$apptype windows} // убираем консоль
+
+const dy = -Sin(Pi / 6) / 2;
+
+begin
+  
+  // Создаём и настраиваем окно
+  var f := new Form;
+  f.StartPosition := FormStartPosition.CenterScreen;
+  f.ClientSize := new System.Drawing.Size(500, 500);
+  f.FormBorderStyle := FormBorderStyle.Fixed3D;
+  // Если окно закрылось - надо сразу завершить программу
+  f.Closed += (o,e)->Halt();
+  
+  // Настраиваем поверхность рисования
+  var hdc := gl_gdi.InitControl(f);
+  
+  // Настраиваем перерисовку
+  gl_gdi.SetupControlRedrawing(f, hdc, EndFrame->
+  begin
+    
+    {$region Настройка глобальных параметров OpenGL}
+    
+    // При создании экземпляра OpenGL.gl инициализируются некоторые функции
+    // Это необходимо для всех функций из OpenGL1.2 и выше, потому что они локальны для контекста OpenGL
+    gl := new OpenGL.gl<PlWin>;
+    
+    {$endregion Настройка глобальных параметров OpenGL}
+    
+    {$region Инициализация переменных}
+    
+    var vertex_pos_buffer: gl_buffer;
+    gl.CreateBuffers(1, vertex_pos_buffer);
+    gl.NamedBufferData(
+      vertex_pos_buffer,
+      new IntPtr(3*sizeof(Vec2f)),
+      ArrGen(3, i->
+      begin
+        var rot := i * Pi * 2 / 3;
+        
+        Result := new Vec2f(
+          Sin(rot),
+          Cos(rot) + dy
+        );
+        
+      end),
+      VertexBufferObjectUsage.STATIC_DRAW
+    );
+    
+    var vertex_clr_buffer: gl_buffer;
+    gl.CreateBuffers(1, vertex_clr_buffer);
+    gl.NamedBufferData(
+      vertex_clr_buffer,
+      new IntPtr(3*sizeof(Vec3f)),
+      new Vec3f[](
+        new Vec3f(1,0,0),
+        new Vec3f(0,1,0),
+        new Vec3f(0,0,1)
+      ),
+      VertexBufferObjectUsage.STATIC_DRAW
+    );
+    
+    var element_buffer: gl_buffer;
+    gl.CreateBuffers(1, element_buffer);
+    gl.NamedBufferData(
+      element_buffer,
+      new IntPtr(3*sizeof(byte)),
+      new byte[](
+        0,1,2
+      ),
+      VertexBufferObjectUsage.STATIC_DRAW
+    );
+    
+    var vertex_shader := InitShader('Крутящийся треугольник.vert', ShaderType.VERTEX_SHADER);
+    
+    var sprog := InitProgram(vertex_shader{, другие_шейдеры});
+    
+    var uniform_rot_k :=     gl.GetUniformLocation(sprog, 'rot_k');
+    
+    var attribute_position := gl.GetAttribLocation(sprog, 'position');
+    var attribute_color :=    gl.GetAttribLocation(sprog, 'color');
+    
+    var t := new Stopwatch;
+    t.Start;
+    
+    {$endregion Инициализация переменных}
+    
+    // Для поиска, где возникла ошибка
+//    var RaiseIfError := procedure->
+//    begin
+//      
+//      // получаем тип последней ошибки
+//      var err := gl.GetError;
+//      // и если ошибка есть - выводим её
+//      if err<>ErrorCode.NO_ERROR then raise new System.Exception(err.ToString);
+//      
+//    end;
+    
+    while true do
+    begin
+      // очищаем окно в начале перерисовки
+      gl.Clear(ClearBufferMask.COLOR_BUFFER_BIT);
+      
+      
+      
+      gl.UseProgram(sprog);
+      
+      gl.Uniform1f(uniform_rot_k, Cos( t.Elapsed.Ticks * 0.0000002 ) );
+      
+      gl.BindBuffer(BufferTarget.ARRAY_BUFFER, vertex_pos_buffer);
+      gl.VertexAttribPointer(
+        attribute_position,
+        2,
+        VertexAttribPointerType.FLOAT,
+        false,
+        8,
+        IntPtr.Zero
+      );
+      gl.EnableVertexAttribArray(attribute_position);
+      
+      gl.BindBuffer(BufferTarget.ARRAY_BUFFER, vertex_clr_buffer);
+      gl.VertexAttribPointer(
+        attribute_color,
+        3,
+        VertexAttribPointerType.FLOAT,
+        false,
+        12,
+        IntPtr.Zero
+      );
+      gl.EnableVertexAttribArray(attribute_color);
+      
+      gl.BindBuffer(BufferTarget.ELEMENT_ARRAY_BUFFER, element_buffer);
+      gl.DrawElements(
+        PrimitiveType.TRIANGLES,
+        3,
+        DrawElementsType.UNSIGNED_BYTE,
+        IntPtr.Zero
+      );
+      
+      gl.DisableVertexAttribArray(attribute_position);
+      gl.DisableVertexAttribArray(attribute_color);
+      
+      
+      
+      // получаем тип последней ошибки
+      var err := gl.GetError;
+      // и если ошибка есть - выводим её
+      if err<>ErrorCode.NO_ERROR then Writeln(err);
+      
+      gl.Finish;
+      // EndFrame меняет местами буферы и ждёт vsync
+      EndFrame;
+    end;
+    
+  end);
+  
+  Application.Run(f);
 end.
\ No newline at end of file
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Rot Triangle 1.vertex.glsl b/InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.vert
similarity index 82%
rename from InstallerSamples/OpenGL и OpenCL/OpenGL/Rot Triangle 1.vertex.glsl
rename to InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.vert
index 9d216f729..e1027495f 100644
--- a/InstallerSamples/OpenGL и OpenCL/OpenGL/Rot Triangle 1.vertex.glsl	
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/!Крутящийся треугольник/Крутящийся треугольник.vert	
@@ -1,7 +1,7 @@
 #version 460
 
-attribute vec2 position;
-attribute vec3 color;
+in vec2 position;
+in vec3 color;
 uniform float rot_k;
 
 void main()
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Common.pas b/InstallerSamples/OpenGL и OpenCL/OpenGL/Common.pas
new file mode 100644
index 000000000..1ea41354f
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Common.pas	
@@ -0,0 +1,87 @@
+unit Common;
+
+uses System;
+uses OpenGL;
+
+var gl: OpenGL.gl<PlWin>;
+
+{$region Shader}
+
+function InitShader(fname: string; st: ShaderType): gl_shader;
+begin
+  Result := gl.CreateShader(st);
+  
+  var source := ReadAllText(fname);
+  
+  gl.ShaderSource(Result, 1,
+    new string[](source),
+    nil
+  );
+  
+  gl.CompileShader(Result);
+  // Получаем состояние успешности компиляции
+  // 1=успешно
+  // 0=ошибка
+  var comp_ok: integer;
+  gl.GetShaderiv(Result, ShaderParameterName.COMPILE_STATUS, comp_ok);
+  if comp_ok = 0 then
+  begin
+    
+    // Узнаём нужную длинную строки
+    var l: integer;
+    gl.GetShaderiv(Result, ShaderParameterName.INFO_LOG_LENGTH, l);
+    
+    // Выделяем достаточно памяти чтоб сохранить строку
+    var ptr := System.Runtime.InteropServices.Marshal.AllocHGlobal(l);
+    
+    // Получаем строку логов
+    gl.GetShaderInfoLog(Result, l, IntPtr.Zero, ptr);
+    
+    // Преобразовываем в управляемую строку
+    var log := System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ptr);
+    
+    // И в конце обязательно освобождаем, чтобы не было утечек памяти
+    System.Runtime.InteropServices.Marshal.FreeHGlobal(ptr);
+    gl.DeleteShader(Result);
+    
+    raise new System.ArgumentException($'{fname}:{#10}{log}');
+  end;
+  
+end;
+
+{$endregion Shader}
+
+{$region Program}
+
+function InitProgram(params shaders: array of gl_shader): gl_program;
+begin
+  Result := gl.CreateProgram;
+  
+  foreach var sh in shaders do
+    gl.AttachShader(Result, sh);
+  
+  gl.LinkProgram(Result);
+  // Всё то же самое что и у шейдеров
+  var link_ok: integer;
+  gl.GetProgramiv(Result, ProgramPropertyARB.LINK_STATUS, link_ok);
+  if link_ok = 0 then
+  begin
+    
+    var l: integer;
+    gl.GetProgramiv(Result, ProgramPropertyARB.INFO_LOG_LENGTH, l);
+    var ptr := System.Runtime.InteropServices.Marshal.AllocHGlobal(l);
+    
+    gl.GetProgramInfoLog(Result, l, IntPtr.Zero, ptr);
+    var log := System.Runtime.InteropServices.Marshal.PtrToStringAnsi(ptr);
+    
+    System.Runtime.InteropServices.Marshal.FreeHGlobal(ptr);
+    gl.DeleteProgram(Result);
+    
+    raise new System.ArgumentException(log);
+  end;
+  
+end;
+
+{$endregion Program}
+
+end.
\ No newline at end of file
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Empty.vert b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Empty.vert
new file mode 100644
index 000000000..9c7708d1c
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Empty.vert	
@@ -0,0 +1,5 @@
+#version 460 core
+
+// Ничего не делаем
+// Какую точку передали - такую и вернёт
+void main() { }
\ No newline at end of file
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Mandelbrot.frag b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Mandelbrot.frag
new file mode 100644
index 000000000..c79922112
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Mandelbrot.frag	
@@ -0,0 +1,97 @@
+#version 460 core
+
+// Подсматривал сюда:
+// https://stackoverflow.com/questions/44354589/optimizing-mandelbrot-fractal
+
+noperspective in vec2 logic_pos;
+
+layout(location = 0) uniform int point_count;
+layout(binding = 0) buffer points_in {
+	dvec2 data[];
+} points;
+
+layout(location = 1) uniform double camera_aspect_ratio;
+layout(location = 2) uniform double camera_scale;
+layout(location = 3) uniform dvec2 camera_pos;
+
+/**
+layout(binding = 1) buffer temp_otp {
+	dvec2 data[3];
+} temp;
+/**/
+
+out vec3 color;
+
+// Радиус белой точки
+// (хотел сделать взаимодействие с основным рисунком, но и так лагает)
+const float point_r = 5;
+// Скорость затемнения при отдалении от точки
+const float fall_speed = 0.6;
+
+const float extra_scale = 0.01;
+
+const int MAX_DEPTH = 128;
+int CalculateMandelbrotDepth(dvec2 c, dvec2 start) {
+	c *= extra_scale;
+	//start *= extra_scale;
+	if (dot(start,start)>2) return 0;
+	
+	dvec2 prev[MAX_DEPTH];
+	dvec2 curr = start;
+	
+	for (int depth = 1; depth < MAX_DEPTH; ++depth) {
+		prev[depth-1] = curr;
+		
+		curr = dvec2( curr.x*curr.x - curr.y*curr.y, 2*curr.x*curr.y )+c;
+		
+		if (dot(curr,curr)>2) return depth;
+		for (int i = depth-1; i>=0; --i)
+			if (curr == prev[i]) return depth;
+	}
+	
+	return MAX_DEPTH;
+}
+
+// All components are in the range [0…1], including hue.
+vec3 hsv2rgb(float hue)
+{
+	vec3 c = {hue, 0.75, 0.5};
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+void main() {
+	
+	// Считаем в фрагментном шейдере, потому что интерполяция
+	// 64-битного logic_pos (с типом dvec2) в OpenGL запрещена
+	dvec2 pos = { logic_pos.x*camera_aspect_ratio, logic_pos.y };
+	pos *= camera_scale;
+	pos += camera_pos;
+	
+	for (int i=0; i<point_count; ++i) {
+		dvec2 dp = pos-points.data[i];
+		if (dot(dp,dp)<point_r*point_r) {
+			color = vec3(1);
+			return;
+		}
+	}
+	
+	int depth = CalculateMandelbrotDepth(pos, dvec2(0));
+	/**
+	for (int i=0; i<point_count; ++i) {
+		//TODO Какое-то взаимодействие
+	}
+	/**/
+	
+	if (depth == 0)
+		color = vec3(0); else
+	{
+		//color = vec3( float(depth) / MAX_DEPTH ); // Чёрно-белый рисунок
+		//color = hsv2rgb( float(depth) / MAX_DEPTH * 0.8 + 0.1 ); // Все цвета радуги
+		color = hsv2rgb( fract(float(depth) / MAX_DEPTH*radians(180)) ); // Псевдо-случайные цвета
+	}
+	
+}
+
+
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/SinglePointToScreen.geom b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/SinglePointToScreen.geom
new file mode 100644
index 000000000..6e3a37fb2
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/SinglePointToScreen.geom	
@@ -0,0 +1,23 @@
+#version 460 core
+
+layout(points) in;
+layout(triangle_strip, max_vertices = 4) out;
+out vec2 logic_pos;
+
+void SendVertex(float coord1, float coord2) {
+	logic_pos = vec2(coord1, coord2);
+	gl_Position = vec4(coord1, coord2, 0, 1);
+	EmitVertex();
+}
+
+// На вход приходит одна точка без данных
+// На выход посылаем 2 треугольника, покрывающих весь экран
+// При чём передаём логическую позицию на экране в виде logic_pos
+// В фрагментном шейдере значения logic_pos интерполируются с noperspective
+void main() {
+	SendVertex(-1,-1);
+	SendVertex(-1,+1);
+	SendVertex(+1,-1);
+	SendVertex(+1,+1);
+	EndPrimitive();
+}
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Волны.frag b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Волны.frag
new file mode 100644
index 000000000..4ef61efee
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Волны.frag	
@@ -0,0 +1,55 @@
+#version 460 core
+
+noperspective in vec2 logic_pos;
+
+layout(location = 0) uniform int point_count;
+layout(binding = 0) buffer points_in {
+	dvec2 data[];
+} points;
+
+layout(location = 1) uniform double camera_aspect_ratio;
+layout(location = 2) uniform double camera_scale;
+layout(location = 3) uniform dvec2 camera_pos;
+
+/**
+layout(binding = 1) buffer temp_otp {
+	dvec2 data[3];
+} temp;
+/**/
+
+out vec3 color;
+
+// Радиус красной точки
+const float point_r = 5;
+// Скорость затемнения при отдалении от точки
+const float fall_speed = 0.6;
+
+void main() {
+	
+	// Считаем в фрагментном шейдере, потому что интерполяция
+	// 64-битного logic_pos (с типом dvec2) в OpenGL запрещена
+	dvec2 pos = { logic_pos.x*camera_aspect_ratio, logic_pos.y };
+	pos *= camera_scale;
+	pos += camera_pos;
+	
+	for (int i=0; i<point_count; ++i) {
+		dvec2 dp = pos-points.data[i];
+		if (dot(dp,dp)<point_r*point_r) {
+			color = vec3(0.7, 0, 0);
+			return;
+		}
+	}
+	
+	double res = 0;
+	for (int i=0; i<point_count; ++i) {
+		double curr = distance(pos, points.data[i]) / 10;
+		curr = fract(curr);
+		res += curr;
+	}
+	res /= point_count;
+	//res = fract(res);
+	
+	color = vec3( res );
+}
+
+
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Минимум расстояний.frag b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Минимум расстояний.frag
new file mode 100644
index 000000000..bd77f26d9
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Минимум расстояний.frag	
@@ -0,0 +1,62 @@
+#version 460 core
+
+noperspective in vec2 logic_pos;
+
+layout(location = 0) uniform int point_count;
+layout(binding = 0) buffer points_in {
+	dvec2 data[];
+} points;
+
+layout(location = 1) uniform double camera_aspect_ratio;
+layout(location = 2) uniform double camera_scale;
+layout(location = 3) uniform dvec2 camera_pos;
+
+layout(binding = 1) buffer temp_otp {
+	dvec2 data[3];
+} temp;
+
+out vec3 color;
+
+// Радиус красной точки
+const float point_r = 5;
+const float point_r_sqr = point_r*point_r;
+// Скорость затемнения при отдалении от точки
+const float fall_speed = 0.3;
+
+void main() {
+	
+	// Считаем в фрагментном шейдере, потому что интерполяция
+	// 64-битного logic_pos (с типом dvec2) в OpenGL запрещена
+	dvec2 pos = { logic_pos.x*camera_aspect_ratio, logic_pos.y };
+	pos *= camera_scale;
+	pos += camera_pos;
+	
+	// Храним и сравниваем квадраты расстояний,
+	// чтобы не считать корень лишний раз - он дорогой
+	double min_r_sqr = double(1)/0;
+	
+	for (int i=0; i<point_count; ++i) {
+		dvec2 dp = pos - points.data[i];
+		double r_sqr = dot(dp, dp);
+		if (r_sqr<point_r_sqr) {
+			color = vec3(0.7, 0, 0);
+			return;
+		}
+		if (r_sqr<min_r_sqr) min_r_sqr = r_sqr;
+	}
+	
+	// Функция формы y=1/x, но маштабированная чтобы y(point_r)=1
+	double fall_sqr = point_r_sqr/min_r_sqr;
+	// И в данном случае результат в квадрате, поэтому дальше степень делим на 2
+	float fall = pow(float(fall_sqr), fall_speed/2);
+	
+	// Ступеньки из оттенков серого
+	if (false) {
+		int color_count = 64;
+		fall = round(fall*color_count) / color_count;
+	}
+	
+	color = vec3( fall );
+}
+
+
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Спирали.frag b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Спирали.frag
new file mode 100644
index 000000000..bc6255218
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Спирали.frag	
@@ -0,0 +1,65 @@
+#version 460 core
+
+noperspective in vec2 logic_pos;
+
+layout(location = 0) uniform int point_count;
+layout(binding = 0) buffer points_in {
+	dvec2 data[];
+} points;
+
+layout(location = 1) uniform double camera_aspect_ratio;
+layout(location = 2) uniform double camera_scale;
+layout(location = 3) uniform dvec2 camera_pos;
+
+/**
+layout(binding = 1) buffer temp_otp {
+	double data[3];
+} temp;
+/**/
+
+out vec3 color;
+
+const int arm_count = 5;
+
+void main() {
+	
+	// Считаем в фрагментном шейдере, потому что интерполяция
+	// 64-битного logic_pos (с типом dvec2) в OpenGL запрещена
+	dvec2 pos = { logic_pos.x*camera_aspect_ratio, logic_pos.y };
+	pos *= camera_scale;
+	pos += camera_pos;
+	
+	double total_ang = 0;
+	double total_r = 0;
+	
+	for (int i=0; i<point_count; ++i) {
+		dvec2 dp = pos - points.data[i];
+		dp /= point_count;
+		
+		// Угол от 0 до 1
+		float angle = atan(
+			float(dp.y/abs(dp.x)), float(sign(dp.x))
+		)/radians(360)+0.5;
+		total_ang += double(angle)*arm_count;
+		
+		double radius = sqrt(dot(dp,dp));
+		radius = log2(float(radius));
+		total_r += radius;
+		
+	}
+	
+	//total_r = log2(float(total_r));
+	double res = total_ang + total_r;
+	
+	/**
+	if (distance(pos, dvec2(temp.data[0],temp.data[1])) < camera_scale/500)
+		temp.data[2] = res;
+	/**/
+	
+	//res /= point_count;
+	res = fract(res);
+	
+	color = vec3( res );
+}
+
+
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Сумма расстояний.frag b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Сумма расстояний.frag
new file mode 100644
index 000000000..dcefb36e2
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Сумма расстояний.frag	
@@ -0,0 +1,86 @@
+#version 460 core
+
+noperspective in vec2 logic_pos;
+
+layout(location = 0) uniform int point_count;
+layout(binding = 0) buffer points_in {
+	dvec2 data[];
+} points;
+
+layout(location = 1) uniform double camera_aspect_ratio;
+layout(location = 2) uniform double camera_scale;
+layout(location = 3) uniform dvec2 camera_pos;
+
+/**
+layout(binding = 1) buffer temp_otp {
+	dvec2 data[3];
+} temp;
+/**/
+
+out vec3 color;
+
+// Радиус красной точки
+const float point_r = 5;
+// Скорость затемнения при отдалении от точки
+const float fall_speed = 0.6;
+
+const bool fall_range_debug = false;
+
+void main() {
+	
+	// В идеале это надо считать в геометрическом шейдере,
+	// или даже на CPU... Но для этого надо менять код, общий с другими примерами
+	float min_r_sum = 0;
+	dvec2 d_center = {0,0};
+	for (int i=0; i<point_count; ++i) d_center += points.data[i];
+	d_center /= point_count;
+	vec2 center = vec2( d_center );
+	
+	for (int i=0; i<point_count; ++i)
+		min_r_sum += distance(center, vec2(points.data[i]));
+	
+	// Считаем в фрагментном шейдере, потому что интерполяция
+	// 64-битного logic_pos (с типом dvec2) в OpenGL запрещена
+	dvec2 pos = { logic_pos.x*camera_aspect_ratio, logic_pos.y };
+	pos *= camera_scale;
+	pos += camera_pos;
+	
+	if (fall_range_debug && distance(pos, d_center)<point_r) {
+		color = vec3(0, 0, 0.7);
+		return;
+	}
+	
+	float r_sum = 0;
+	for (int i=0; i<point_count; ++i) {
+		dvec2 dp = pos - points.data[i];
+		float r = sqrt(float(dot(dp, dp)));
+		if (r<point_r) {
+			color = vec3(0.7, 0, 0);
+			return;
+		}
+		r_sum += r;
+	}
+	
+	// Функция формы y=1/x, но маштабированная чтобы y(min_r_sum)=1
+	double d_fall = min_r_sum/r_sum;
+	float fall = pow(float(d_fall), fall_speed);
+	
+	// Ступеньки из оттенков серого
+	if (true) {
+		int color_count = 64;
+		fall = round(fall*color_count) / color_count;
+	}
+	
+	// center всё же не всегда имеет наименьшую сумму расстояний
+	// Поэтому min_r_sum может считаться неправильно и fall оказываться >1
+	// Наверное, нужен итерационный алгоритм на стороне CPU, чтобы адекватно это сделать
+	// Напишите если есть идеи лучше
+	if (fall_range_debug && fall>1) {
+		color = vec3(0.8, 0, 0.8);
+		return;
+	}
+	
+	color = vec3( fall );
+}
+
+
diff --git a/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Точки.pas b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Точки.pas
new file mode 100644
index 000000000..fbfd44836
--- /dev/null
+++ b/InstallerSamples/OpenGL и OpenCL/OpenGL/Точки на поле/Точки.pas	
@@ -0,0 +1,285 @@
+{$reference System.Windows.Forms.dll}
+{$reference System.Drawing.dll}
+
+// Примеры фрагментных шейдеров
+//
+// ========== Управление ==========
+// ЛКМ: Поставить точку
+// СКМ: Удалить ближайшую точку
+// ПКМ: Схватить и тащить ближайшую точку
+// Колёсико мыши: Маштаб
+// Пробел: Вернуть камеру
+// Цифры от 1 до 5: Переключение шейдеров
+
+uses System.Windows.Forms;
+uses System;
+uses OpenGL;
+
+uses Common in '..\Common';
+
+{$apptype windows}
+
+type
+  CameraData = record
+    aspect := real.NaN;
+    scale := 500.0;
+    pos := default(Vec2d);
+  end;
+  
+begin
+  var f := new Form;
+  f.WindowState := FormWindowState.Maximized;
+//  f.ControlBox := false;
+  
+  // Моментальное закрытие при Alt+F4 и Esc
+  f.Closed += (o,e)->Halt();
+  f.KeyUp += (o,e)->
+  case e.KeyCode of
+    Keys.Escape: Halt;
+  end;
+  
+  var camera := new CameraData;
+  
+  var need_resize := false;
+  var ev_resized_render_complete := new System.Threading.AutoResetEvent(false);
+  f.Shown += (o,e)->
+  begin
+    need_resize := true;
+    f.Resize += (o,e)->
+    begin
+      need_resize := true;
+      // Чтобы не мигало - ждём завершения одной перерисовки
+      // в потоке формы, то есть блокируя отсыл информации системе
+      ev_resized_render_complete.WaitOne;
+    end;
+  end;
+  
+  var curr_fragment_shader := 0;
+  var point_count := 0;
+  var points := new Vec2d[4];
+  var mouse_pos := new Vec2d(real.NaN, real.NaN);
+  {$region Управление}
+  var points_updated := 0;
+  begin
+    
+    var CoordsFromScreen := function(X,Y: integer): Vec2d ->
+    begin
+      var logic_pos := new Vec2d(X/f.ClientSize.Width-0.5, 0.5-Y/f.ClientSize.Height)*2;
+      var pos := new Vec2d(logic_pos.val0*camera.aspect, logic_pos.val1);
+      Result := pos*camera.scale + camera.pos;
+    end;
+    
+    var ClosestPointInd := function(pos: Vec2d): integer ->
+    begin
+      Assert(point_count<>0);
+      var min_r_sqr := (pos-points[0]).SqrLength;
+      Result := 0;
+      for var i := 1 to point_count-1 do
+      begin
+        var r_sqr := (pos-points[i]).SqrLength;
+        if r_sqr < min_r_sqr then
+        begin
+          min_r_sqr := r_sqr;
+          Result := i;
+        end;
+      end;
+    end;
+    
+    f.MouseWheel += (o,e)->
+    begin
+      var pos := CoordsFromScreen(e.X, e.Y);
+      
+      var pow := 1 - Sign(e.Delta)*0.1;
+      camera.scale := camera.scale * pow;
+      
+      camera.pos := camera.pos + (pos-CoordsFromScreen(e.X, e.Y));
+    end;
+    
+    f.KeyDown += (o,e)->
+    case e.KeyCode of
+      Keys.Space:
+      begin
+        var n_camera := new CameraData;
+        camera.scale := n_camera.scale;
+        camera.pos := n_camera.pos;
+      end;
+      Keys.D1..Keys.D5: curr_fragment_shader := integer(e.KeyCode)-integer(Keys.D1);
+    end;
+    
+    var grabbed_point_ind := default(integer?);
+    f.MouseDown += (o,e)->
+    case e.Button of
+      MouseButtons.Left:
+      begin
+        if point_count=points.Length then
+          // По хорошему буфер OpenGL тоже надо ресайзить
+          // Но сейчас он полностью пересоздаётся
+          SetLength(points, points.Length*2);
+        points[point_count] := CoordsFromScreen(e.X,e.Y);
+        point_count += 1;
+        System.Threading.Interlocked.Exchange(points_updated, 1);
+      end;
+      MouseButtons.Middle:
+      if point_count<>0 then
+      begin
+        var pos := CoordsFromScreen(e.X,e.Y);
+        var ind := ClosestPointInd(pos);
+        point_count -= 1;
+        if ind<>point_count then points[ind] := points[point_count];
+        System.Threading.Interlocked.Exchange(points_updated, 1);
+      end;
+      MouseButtons.Right:
+      if point_count<>0 then
+      begin
+        var pos := CoordsFromScreen(e.X,e.Y);
+        var ind := ClosestPointInd(pos);
+        grabbed_point_ind := ind;
+        points[ind] := pos;
+        System.Threading.Interlocked.Exchange(points_updated, 1);
+      end;
+    end;
+    
+    f.MouseMove += (o,e)->
+    begin
+      var pos := CoordsFromScreen(e.X,e.Y);
+      mouse_pos := pos;
+      if grabbed_point_ind<>nil then
+      begin
+        points[grabbed_point_ind.Value] := pos;
+        System.Threading.Interlocked.Exchange(points_updated, 1);
+      end;
+    end;
+    
+    f.MouseUp += (o,e)->
+    case e.Button of
+      MouseButtons.Right:
+      if grabbed_point_ind<>nil then
+      begin
+        points[grabbed_point_ind.Value] := CoordsFromScreen(e.X,e.Y);
+        grabbed_point_ind := nil;
+        System.Threading.Interlocked.Exchange(points_updated, 1);
+      end;
+    end;
+    
+  end;
+  {$endregion Управление}
+  
+  gl_gdi.SetupControlRedrawing(f, gl_gdi.InitControl(f), EndFrame->
+  try
+    gl := new OpenGL.gl<PlWin>;
+    
+    var sprog: gl_program;
+    var last_fragment_shader := -1;
+    
+    var uniform_point_count := 0;
+    var buffer_points: gl_buffer;
+    gl.CreateBuffers(1, buffer_points);
+	  gl.BindBufferBase(BufferTarget.SHADER_STORAGE_BUFFER, 0, buffer_points);
+    
+    var uniform_aspect  := 1;
+    var uniform_scale   := 2;
+    var uniform_pos     := 3;
+    
+    // Для дебага
+//    var buffer_temp: gl_buffer;
+//    gl.CreateBuffers(1, buffer_temp);
+//    gl.NamedBufferData(buffer_temp, new IntPtr(3*sizeof(real)), IntPtr.Zero, VertexBufferObjectUsage.DYNAMIC_READ);
+//	  gl.BindBufferBase(BufferTarget.SHADER_STORAGE_BUFFER, 1, buffer_temp);
+    
+    var timings_max_count := 30;
+    var timings := new Queue<TimeSpan>(timings_max_count);
+    var total_time := TimeSpan.Zero;
+    var sw := new Stopwatch;
+    
+    while true do
+    begin
+      var need_set_resize_ev := false;
+      if need_resize then
+      begin
+        var w_size := f.ClientSize;
+        
+		    gl.Viewport(0,0, w_size.Width,w_size.Height);
+		    need_set_resize_ev := true;
+		    
+			  camera.aspect := w_size.Width/w_size.Height;
+      end;
+      
+      if last_fragment_shader<>curr_fragment_shader then
+      begin
+        last_fragment_shader := curr_fragment_shader;
+        
+        gl.DeleteProgram(sprog);
+        sprog := InitProgram(
+          InitShader('Empty.vert',                ShaderType.VERTEX_SHADER),
+          InitShader('SinglePointToScreen.geom',  ShaderType.GEOMETRY_SHADER),
+          InitShader(|
+            'Минимум расстояний.frag',
+            'Сумма расстояний.frag',
+            'Волны.frag',
+            'Спирали.frag',
+            'Mandelbrot.frag'
+          |[last_fragment_shader], ShaderType.FRAGMENT_SHADER)
+        );
+        // Применяем вне цикла, потому что это единственная шейдерная программа
+        gl.UseProgram(sprog);
+        points_updated := 1;
+      end;
+      
+      if System.Threading.Interlocked.Exchange(points_updated, 0)<>0 then
+      begin
+        gl.Uniform1i(uniform_point_count, point_count);
+        // Плохо - пересоздаём всё тело буфера при каждой перерисовке
+        // Но по сравнению с фрагментным шейдером - это капля в море
+        gl.NamedBufferData(buffer_points, new IntPtr(point_count*sizeof(vec2d)), points, VertexBufferObjectUsage.DYNAMIC_READ);
+        // Записать point_count точек из массива можно так:
+//        gl.NamedBufferSubData(buffer_points, IntPtr.Zero, new IntPtr(point_count * sizeof(Vec2d)), points);
+      end;
+      
+      sw.Restart;
+      
+      // Копируем все данные сразу в локальную переменную
+      var camera := camera;
+      // И затем в юниформы
+      gl.Uniform1d(uniform_aspect,  camera.aspect);
+      gl.Uniform1d(uniform_scale,   camera.scale);
+      gl.Uniform2dv(uniform_pos, 1, camera.pos);
+      
+//      gl.NamedBufferSubData(buffer_temp, new IntPtr(0*sizeof(real)), new IntPtr(2*sizeof(real)), mouse_pos);
+      
+      // Вызываем шейдерную программу один раз, не передавая данные
+      // Геометричейский шейдер сделает из этого 
+      gl.DrawArrays(PrimitiveType.POINTS, 0,1);
+      
+//      var temp_data := new real[1];
+//      gl.GetNamedBufferSubData(buffer_temp, new IntPtr(2*sizeof(real)), new IntPtr(1*sizeof(real)), temp_data);
+      
+      var err := gl.GetError;
+      if err<>ErrorCode.NO_ERROR then MessageBox.Show(err.ToString);
+      
+      gl.Finish;
+      if need_set_resize_ev then
+        ev_resized_render_complete.Set;
+      
+      var curr_time := sw.Elapsed;
+      if timings.Count=timings_max_count then
+        total_time := total_time-timings.Dequeue;
+      total_time := total_time+curr_time;
+      timings += curr_time;
+      
+      var fps := timings.Count/total_time.TotalSeconds;
+      var form_text := $'{fps:N2} fps, {1000/fps:N2} mspf, {point_count} points, scale={camera.scale}, pos={camera.pos}';
+//      form_text := $'temp_data={_ObjectToString(temp_data)}, '+form_text;
+      f.Text := form_text;
+      EndFrame;
+    end;
+    
+  except
+    on e: Exception do
+    begin
+      MessageBox.Show(e.ToString);
+      Halt;
+    end;
+  end);
+  
+  System.Windows.Forms.Application.Run(f);
+end.
\ No newline at end of file
diff --git a/bin/Lib/OpenCL.pas b/bin/Lib/OpenCL.pas
index 9fb45555f..46c3ba19f 100644
--- a/bin/Lib/OpenCL.pas
+++ b/bin/Lib/OpenCL.pas
@@ -1,12 +1,12 @@
 
 //*****************************************************************************************************\\
-// Copyright (©) Cergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
+// Copyright (©) Sergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
 // This code is distributed under the Unlicense
 // For details see LICENSE file or this:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
 // Copyright (©) Сергей Латченко ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
-// Этот код распространяется с лицензией Unlicense
+// Данный код распространяется с лицензией Unlicense
 // Подробнее в файле LICENSE или тут:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
diff --git a/bin/Lib/OpenCLABC.pas b/bin/Lib/OpenCLABC.pas
index 36b6199ef..d38edc819 100644
--- a/bin/Lib/OpenCLABC.pas
+++ b/bin/Lib/OpenCLABC.pas
@@ -1,12 +1,12 @@
 
 //*****************************************************************************************************\\
-// Copyright (©) Cergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
+// Copyright (©) Sergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
 // This code is distributed under the Unlicense
 // For details see LICENSE file or this:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
 // Copyright (©) Сергей Латченко ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
-// Этот код распространяется с лицензией Unlicense
+// Данный код распространяется с лицензией Unlicense
 // Подробнее в файле LICENSE или тут:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
@@ -29,6 +29,25 @@ unit OpenCLABC;
 //===================================
 // Обязательно сделать до следующей стабильной версии:
 
+//TODO Тесты:
+// - .ThenQuickConvert.Multiusable: сколько раз вычисляется?
+// - Потеря результата Quick обработки:
+// --- HFQ(()->5).ThenQuickConvert.ThenQuickUse + HPQ(()->begin end)
+// --- CombineQuickConv + HPQ(()->begin end)
+// - HPQ + HPQQ + HPQ: HPQQ должен выполнится последним
+
+//TODO Справка:
+// - ThenQuick[Convert,Use]
+// - CombineQuickConv[Sync,Async]Queue
+// --- Добавил Conv в название!!!
+// - AddQuickProc
+// - HPQQ/HFQQ
+//
+// - Quick очереди срабатывают в последний допустимый момент
+// --- HPQ + HPQQ + HPQ: HPQQ выполнится последним
+//
+// - В обработке исключений написать, что обработчики всегда Quick
+
 //===================================
 // Запланированное:
 
@@ -37,9 +56,7 @@ unit OpenCLABC;
 
 //TODO Использовать cl.EnqueueMapBuffer
 // - В виде .AddMap((MappedArray,Context)->())
-
-//TODO Синхронные (с припиской Fast, а может Quick) варианты всего работающего по принципу HostQueue
-//TODO Справка: В обработке исключений написать, что обработчики всегда Quick
+// - Недодел своей ветке
 
 //TODO .pcu с неправильной позицией зависимости, или не теми настройками - должен игнорироваться
 // - Иначе сейчас модули в примерах ссылаются на .pcu, который существует только во время работы Tester, ломая компилятор
@@ -53,7 +70,6 @@ unit OpenCLABC;
 //TODO .Cycle(integer)
 //TODO .Cycle // бесконечность циклов
 //TODO .CycleWhile(***->boolean)
-// - Возможность передать свой обработчик ошибок как Exception->Exception
 //TODO В продолжение Cycle: Однако всё ещё остаётся проблема - как сделать ветвление?
 // - И если уже делать - стоит сделать и метод CQ.ThenIf(res->boolean; if_true, if_false: CQ)
 //TODO И ещё - AbortQueue, который, по сути, может использоваться как exit, continue или break, если с обработчиками ошибок
@@ -2617,18 +2633,60 @@ type
     
     ///Создаёт очередь, которая выполнит данную
     ///А затем выполнит на CPU функцию f, используя результат данной очереди
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".ThenQuick..."
     public function ThenConvert<TOtp>(f: T->TOtp): CommandQueue<TOtp>;
     ///Создаёт очередь, которая выполнит данную
     ///А затем выполнит на CPU функцию f, используя результат данной очереди и контекст выполнения
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".ThenQuick..."
     public function ThenConvert<TOtp>(f: (T, Context)->TOtp): CommandQueue<TOtp>;
     
     ///Создаёт очередь, которая выполнит данную и вернёт её результат
     ///Но перед этим выполнит на CPU процедуру p, используя полученный результат
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".ThenQuick..."
     public function ThenUse(p: T->()           ): CommandQueue<T>;
     ///Создаёт очередь, которая выполнит данную и вернёт её результат
     ///Но перед этим выполнит на CPU процедуру p, используя полученный результат и контекст выполнения
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".ThenQuick..."
     public function ThenUse(p: (T, Context)->()): CommandQueue<T>;
     
+    ///Создаёт очередь, которая выполнит данную
+    ///А затем выполнит на CPU функцию f, используя результат данной очереди
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function ThenQuickConvert<TOtp>(f: T->TOtp): CommandQueue<TOtp>;
+    ///Создаёт очередь, которая выполнит данную
+    ///А затем выполнит на CPU функцию f, используя результат данной очереди и контекст выполнения
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function ThenQuickConvert<TOtp>(f: (T, Context)->TOtp): CommandQueue<TOtp>;
+    
+    ///Создаёт очередь, которая выполнит данную и вернёт её результат
+    ///Но перед этим выполнит на CPU процедуру p, используя полученный результат
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function ThenQuickUse(p: T->()           ): CommandQueue<T>;
+    ///Создаёт очередь, которая выполнит данную и вернёт её результат
+    ///Но перед этим выполнит на CPU процедуру p, используя полученный результат и контекст выполнения
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function ThenQuickUse(p: (T, Context)->()): CommandQueue<T>;
+    
   end;
   
   {$endregion ThenConvert}
@@ -3166,9 +3224,27 @@ type
     public function AddQueue(q: CommandQueueBase): KernelCCQ;
     
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: Kernel->()): KernelCCQ;
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: (Kernel, Context)->()): KernelCCQ;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: Kernel->()): KernelCCQ;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: (Kernel, Context)->()): KernelCCQ;
     
     ///Добавляет ожидание сигнала выполненности от заданного маркера
     public function AddWait(marker: WaitMarker): KernelCCQ;
@@ -3221,9 +3297,27 @@ type
     public function AddQueue(q: CommandQueueBase): MemorySegmentCCQ;
     
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: MemorySegment->()): MemorySegmentCCQ;
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: (MemorySegment, Context)->()): MemorySegmentCCQ;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: MemorySegment->()): MemorySegmentCCQ;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: (MemorySegment, Context)->()): MemorySegmentCCQ;
     
     ///Добавляет ожидание сигнала выполненности от заданного маркера
     public function AddWait(marker: WaitMarker): MemorySegmentCCQ;
@@ -3595,9 +3689,27 @@ type
     public function AddQueue(q: CommandQueueBase): CLArrayCCQ<T>;
     
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: CLArray<T>->()): CLArrayCCQ<T>;
     ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+    ///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на ".AddQuick..."
     public function AddProc(p: (CLArray<T>, Context)->()): CLArrayCCQ<T>;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: CLArray<T>->()): CLArrayCCQ<T>;
+    ///Добавляет выполнение процедуры на CPU в список обычных команд для GPU
+    ///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+    ///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+    ///Подробнее - читайте в документации функции "clSetEventCallback"
+    ///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+    ///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+    public function AddQuickProc(p: (CLArray<T>, Context)->()): CLArrayCCQ<T>;
     
     ///Добавляет ожидание сигнала выполненности от заданного маркера
     public function AddWait(marker: WaitMarker): CLArrayCCQ<T>;
@@ -3755,17 +3867,57 @@ type
 
 ///Создаёт очередь, выполняющую указанную функцию на CPU
 ///И возвращающую результат этой функци
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, с дополнительным "Q" (что значит Quick) в конце
 function HFQ<T>(f: ()->T): CommandQueue<T>;
 ///Создаёт очередь, выполняющую указанную функцию на CPU
 ///И возвращающую результат этой функци
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, с дополнительным "Q" (что значит Quick) в конце
 function HFQ<T>(f: Context->T): CommandQueue<T>;
+///Создаёт очередь, выполняющую указанную функцию на CPU
+///И возвращающую результат этой функци
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function HFQQ<T>(f: ()->T): CommandQueue<T>;
+///Создаёт очередь, выполняющую указанную функцию на CPU
+///И возвращающую результат этой функци
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function HFQQ<T>(f: Context->T): CommandQueue<T>;
 
 ///Создаёт очередь, выполняющую указанную процедуру на CPU
 ///И возвращающую nil
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, с дополнительным "Q" (что значит Quick) в конце
 function HPQ(p: ()->()): CommandQueueNil;
 ///Создаёт очередь, выполняющую указанную процедуру на CPU
 ///И возвращающую nil
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, с дополнительным "Q" (что значит Quick) в конце
 function HPQ(p: Context->()): CommandQueueNil;
+///Создаёт очередь, выполняющую указанную процедуру на CPU
+///И возвращающую nil
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function HPQQ(p: ()->()): CommandQueueNil;
+///Создаёт очередь, выполняющую указанную процедуру на CPU
+///И возвращающую nil
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function HPQQ(p: Context->()): CommandQueueNil;
 
 {$endregion HFQ/HPQ}
 
@@ -3830,36 +3982,126 @@ function CombineSyncQueue<T>(qs: sequence of CommandQueueBase; last: CommandQueu
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
 
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
 
 {$endregion NonContext}
 
@@ -3868,36 +4110,126 @@ function CombineSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRe
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
 
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одну за другой
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одну за другой
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
 
 {$endregion Context}
 
@@ -3947,36 +4279,126 @@ function CombineAsyncQueue<T>(qs: sequence of CommandQueueBase; last: CommandQue
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
 
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
 
 {$endregion NonContext}
 
@@ -3985,36 +4407,126 @@ function CombineAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TR
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
 
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
 ///Создаёт очередь, выполняющую указанные очереди одновременно
 ///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
 ///И возвращающую результат этой функции
-function CombineAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+///Переданный делегат выполняется в отдельном потоке выполнения (Thread)
+///Если делегат выполняется быстро и выделение нового потока излишне - используйте соответствующую функцию, начинающуюся на "CombineQuick..."
+function CombineConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>): CommandQueue<TRes>;
+
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>): CommandQueue<TRes>;
+///Создаёт очередь, выполняющую указанные очереди одновременно
+///Затем выполняющую указанную первым параметров функцию на CPU, передавая результаты всех очередей
+///И возвращающую результат этой функции
+///Переданный делегат выполняется в одном из уже существующих потоков выполнения и как можно позже, но так чтобы не нарушить порядок выполнения дерева очередей
+///Из делегата категорически нельзя вызывать функции модуля OpenCL блокирующие выполнение, как "cl.WaitForEvents", "clFinish" и блокирующий "cl.EnqueueReadBuffer"
+///Подробнее - читайте в документации функции "clSetEventCallback"
+///Так же в делегате не желательно использовать долго выполняющиеся алгоритмы, особенно ввод с клавиатуры
+///Если эти ограничения не подходят, используйте соответствующую функцию, без "Quick" в названии
+function CombineQuickConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>): CommandQueue<TRes>;
 
 {$endregion Context}
 
@@ -4872,21 +5384,6 @@ type
 
 {$region EventList}
 
-type
-  IEventListContainerT<TEventList> = interface
-    
-    function get_ev: TEventList;
-    function set_ev_base(val: TEventList): IEventListContainerT<TEventList>;
-    
-    procedure forbid_ev_swap;
-    
-  end;
-  
-function set_ev<TC,TV>(self: TC; val: TV): TC; extensionmethod; where TC: IEventListContainerT<TV>;
-begin
-  Result := TC(self.set_ev_base(val));
-end;
-
 type
   AttachCallbackData = sealed class
     public work: Action;
@@ -4924,19 +5421,10 @@ type
     
   end;
   
-  EventList = record(IEventListContainerT<EventList>)
+  EventList = record
     public evs: array of cl_event;
     public count := 0;
     
-    {$region IValueContainer}
-    
-    public function IEventListContainerT<TEventList>.get_ev: EventList := self;
-    public function IEventListContainerT<TEventList>.set_ev_base(val: EventList): IEventListContainerT<EventList> := val;
-    
-    public procedure IEventListContainerT<TEventList>.forbid_ev_swap := exit;
-    
-    {$endregion IValueContainer}
-    
     {$region Misc}
     
     public property Item[i: integer]: cl_event read evs[i]; default;
@@ -5032,7 +5520,7 @@ type
     
     {$endregion operator+}
     
-    {$region cl_event.AttachCallback}
+    {$region AttachCallback}
     
     private static procedure CheckEvErr(ev: cl_event{$ifdef EventDebug}; reason: string{$endif});
     begin
@@ -5074,9 +5562,9 @@ type
       OpenCLABCInternalException.RaiseIfError(ec);
     end;
     
-    {$endregion cl_event.AttachCallback}
+    {$endregion AttachCallback}
     
-    {$region EventList.AttachCallback}
+    {$region MultiAttachCallback}
     
     private static procedure InvokeMultiAttachedCallback(ev: cl_event; st: CommandExecutionStatus; data: IntPtr);
     begin
@@ -5111,7 +5599,7 @@ type
       end;
     end;
     
-    {$endregion EventList.AttachCallback}
+    {$endregion MultiAttachCallback}
     
     {$region Retain/Release}
     
@@ -5149,241 +5637,9 @@ type
     {$endregion Retain/Release}
     
   end;
-  IEventListContainer = IEventListContainerT<EventList>;
   
 {$endregion EventList}
 
-{$region QueueRes}
-
-type
-  {$region Misc}
-  
-  IPtrQueueRes<T> = interface
-    function GetPtr: ^T;
-  end;
-  QRPtrWrap<T> = sealed class(IPtrQueueRes<T>)
-    private ptr: ^T := pointer(Marshal.AllocHGlobal(Marshal.SizeOf&<T>));
-    
-    public constructor(val: T) := self.ptr^ := val;
-    private constructor := raise new OpenCLABCInternalException;
-    
-    protected procedure Finalize; override :=
-    Marshal.FreeHGlobal(new IntPtr(ptr));
-    
-    public function GetPtr: ^T := ptr;
-    
-  end;
-  
-  {$endregion Misc}
-  
-  {$region Base}
-  
-  QueueRes<T> = abstract partial class end;
-  QueueResBase = abstract partial class
-    public ev: EventList;
-    public can_set_ev := true;
-    
-    public constructor(ev: EventList) :=
-    self.ev := ev;
-    private constructor := raise new OpenCLABCInternalException;
-    
-    public function GetResBase: object; abstract;
-    
-    public function TrySetEvBase(new_ev: EventList): QueueResBase; abstract;
-    
-    public function CloneBase: QueueResBase; abstract;
-    
-    public function LazyQuickTransformBase<T2>(f: object->T2): QueueRes<T2>; abstract;
-    
-    public function StabiliseBase(err_handler: CLTaskErrHandler): QueueResBase; abstract;
-    
-  end;
-  
-  QueueRes<T> = abstract partial class(QueueResBase, IEventListContainer)
-    
-    public function GetRes: T; abstract;
-    public function GetResBase: object; override := GetRes;
-    
-    public function TrySetEv(new_ev: EventList): QueueRes<T>;
-    begin
-      if self.ev=new_ev then
-        Result := self else
-      begin
-        Result := if can_set_ev then self else Clone;
-        Result.ev := new_ev;
-      end;
-    end;
-    public function TrySetEvBase(new_ev: EventList): QueueResBase; override := TrySetEv(new_ev);
-    
-    public function CloneBase: QueueResBase; override := Clone;
-    public function Clone: QueueRes<T>; abstract;
-    
-    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; abstract;
-    public function LazyQuickTransformBase<T2>(f: object->T2): QueueRes<T2>; override :=
-    LazyQuickTransform(f as object as Func<T,T2>); //TODO #2221
-    
-    /// Должно выполнятся только после ожидания ивентов
-    public function ToPtr: IPtrQueueRes<T>; abstract;
-    
-    public function StabiliseBase(err_handler: CLTaskErrHandler): QueueResBase; override := Stabilise(err_handler);
-    public function Stabilise(err_handler: CLTaskErrHandler): QueueRes<T>; abstract;
-    
-    {$region IValueContainer}
-    
-    public function IEventListContainerT<TEventList>.get_ev: EventList := ev;
-    public function IEventListContainerT<TEventList>.set_ev_base(val: EventList): IEventListContainer := self.TrySetEv(val);
-    
-    public procedure IEventListContainerT<TEventList>.forbid_ev_swap := self.can_set_ev := false;
-    
-    {$endregion IValueContainer}
-    
-  end;
-  
-  {$endregion Base}
-  
-  {$region Const}
-  
-  IQueueResConst = interface end;
-  // Результат который просто есть
-  QueueResConst<T> = sealed partial class(QueueRes<T>, IQueueResConst)
-    private res: T;
-    
-    public constructor(res: T; ev: EventList);
-    begin
-      inherited Create(ev);
-      self.res := res;
-    end;
-    private constructor := inherited;
-    
-    public function Clone: QueueRes<T>; override := new QueueResConst<T>(res, ev);
-    
-    public function GetRes: T; override := res;
-    
-    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; override;
-    
-    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(res);
-    
-    public function Stabilise(err_handler: CLTaskErrHandler): QueueRes<T>; override := self;
-    
-  end;
-  
-  {$endregion Const}
-  
-  {$region Func}
-  
-  // Результат который надо будет сначала дождаться, а потом ещё досчитать
-  QueueResFunc<T> = sealed partial class(QueueRes<T>)
-    private f: ()->T;
-    
-    public constructor(f: ()->T; ev: EventList);
-    begin
-      inherited Create(ev);
-      self.f := f;
-    end;
-    private constructor := inherited;
-    
-    public function Clone: QueueRes<T>; override := new QueueResFunc<T>(f, ev);
-    
-    public function GetRes: T; override := f();
-    
-    public function LazyQuickTransform<T2>(f2: T->T2): QueueRes<T2>; override :=
-    new QueueResFunc<T2>(()->f2(self.f), self.ev);
-    
-    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(self.f());
-    
-    public function Stabilise(err_handler: CLTaskErrHandler): QueueRes<T>; override := new QueueResConst<T>(self.GetRes, self.ev);
-    
-  end;
-  
-  {$endregion Func}
-  
-  {$region Delayed}
-  
-  // Результат который будет сохранён куда то, надо только дождаться
-  QueueResDelayedBase<T> = abstract partial class(QueueRes<T>)
-    
-    public constructor := inherited Create(EventList.Empty);
-    
-    // QueueResFunc, потому что результат сохраняется именно в этот объект, а не в клон
-    public function Clone: QueueRes<T>; override := new QueueResFunc<T>(self.GetRes, ev);
-    
-    public procedure SetRes(value: T); abstract;
-    
-    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; override :=
-    new QueueResFunc<T2>(()->f(self.GetRes()), self.ev);
-    
-    public function Stabilise(err_handler: CLTaskErrHandler): QueueRes<T>; override := self;
-    
-  end;
-  
-  QueueResDelayedObj<T> = sealed partial class(QueueResDelayedBase<T>)
-    private res := default(T);
-    
-    public function GetRes: T; override := res;
-    public procedure SetRes(value: T); override := res := value;
-    
-    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(res);
-    
-  end;
-  
-  IQueueResDelayedPtr = interface end;
-  QueueResDelayedPtr<T> = sealed partial class(QueueResDelayedBase<T>, IPtrQueueRes<T>, IQueueResDelayedPtr)
-    private ptr: ^T := pointer(Marshal.AllocHGlobal(Marshal.SizeOf&<T>));
-    
-    static constructor :=
-    BlittableHelper.RaiseIfBad(typeof(T), 'использовать в некоторой внутренней ситуации (напишите об этом в issue)');
-    
-    public constructor(res: T; ev: EventList);
-    begin
-      inherited Create(ev);
-      self.ptr^ := res;
-    end;
-    public constructor := inherited Create;
-    
-    public function GetPtr: ^T := ptr;
-    public function GetRes: T; override := ptr^;
-    public procedure SetRes(value: T); override := ptr^ := value;
-    
-    protected procedure Finalize; override :=
-    Marshal.FreeHGlobal(new IntPtr(ptr));
-    
-    public function ToPtr: IPtrQueueRes<T>; override := self;
-    
-  end;
-  
-  QueueResDelayedBase<T> = abstract partial class(QueueRes<T>)
-    
-    public static function MakeNew(need_ptr_qr: boolean) :=
-    if need_ptr_qr then
-      new QueueResDelayedPtr<T> as QueueResDelayedBase<T> else
-      new QueueResDelayedObj<T> as QueueResDelayedBase<T>;
-    
-  end;
-  
-  {$endregion Delayed}
-  
-function QueueResConst<T>.LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>;
-begin
-  var n_res: T2;
-  try
-    n_res := f(self.res);
-  except
-    on e: Exception do
-    begin
-      var edi := System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(e);
-      Result := new QueueResFunc<T2>(()->
-      begin
-        Result := default(T2);
-        edi.Throw;
-      end, self.ev);
-      exit;
-    end;
-  end;
-  Result := new QueueResConst<T2>(n_res, self.ev);
-end;
-
-{$endregion QueueRes}
-
 {$region UserEvent}
 
 type
@@ -5476,15 +5732,365 @@ type
   
 {$endregion UserEvent}
 
+{$region QueueRes}
+
+type
+  {$region Base}
+  
+  QueueResBase = abstract partial class
+    public ev: EventList;
+    public can_set_ev := true;
+    
+    public constructor(ev: EventList) := self.ev := ev;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    public function CloneBase(new_ev: EventList): QueueResBase; abstract;
+    
+    public function TrySetEvBase(new_ev: EventList): QueueResBase;
+    begin
+      if object.ReferenceEquals(self.ev.evs, new_ev.evs) then
+        Result := self else
+      if can_set_ev then
+      begin
+        self.ev := new_ev;
+        Result := self;
+      end else
+        Result := self.CloneBase(new_ev);
+    end;
+    
+    public function ThenInvokeIfDelegateRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueResBase; abstract;
+    
+  end;
+  
+  {$endregion Base}
+  
+  {$region Nil}
+  
+  {$region General}
+  
+  QueueResNil = abstract partial class(QueueResBase)
+    
+    public function CloneBase(new_ev: EventList): QueueResBase; override := Clone(new_ev);
+    public function Clone(new_ev: EventList): QueueResNil; abstract;
+    
+    public function TrySetEv(new_ev: EventList) := QueueResNil(TrySetEvBase(new_ev));
+    
+    public function ThenInvokeIfProcRes(g: CLTaskGlobalData): QueueResNil; abstract;
+    public function ThenInvokeIfDelegateRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueResBase; override := self.ThenInvokeIfProcRes(g);
+    
+  end;
+  
+  {$endregion General}
+  
+  {$region Const}
+  
+  QueueResConstNil = sealed partial class(QueueResNil)
+    
+    public function Clone(new_ev: EventList): QueueResNil; override := new QueueResConstNil(new_ev);
+    
+    public function ThenInvokeIfProcRes(g: CLTaskGlobalData): QueueResNil; override := self;
+    
+  end;
+  
+  {$endregion Const}
+  
+  {$region Proc}
+  
+  QueueResProcNil = sealed partial class(QueueResNil)
+    private p: ()->();
+    
+    public constructor(p: ()->(); ev: EventList);
+    begin
+      inherited Create(ev);
+      self.p := p;
+    end;
+    private constructor := inherited Create;
+    
+    public function Clone(new_ev: EventList): QueueResNil; override := new QueueResProcNil(self.p, new_ev);
+    
+    {$ifdef DEBUG}
+    private was_invoked := false;
+    {$endif DEBUG}
+    public procedure Invoke;
+    begin
+      {$ifdef DEBUG}
+      if was_invoked then raise new System.InvalidProgramException($'{self.GetType}: {System.Environment.StackTrace}');
+      was_invoked := true;
+      {$endif DEBUG}
+      p();
+    end;
+    
+    {$ifdef DEBUG}
+    protected procedure Finalize; override :=
+    if not was_invoked then raise new System.InvalidProgramException($'{self.GetType}');
+    {$endif DEBUG}
+    
+    public function ThenInvokeIfProcRes(g: CLTaskGlobalData): QueueResNil; override;
+    begin
+      var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for QueueResProcNil.ThenInvokeIfProcRes'{$endif});
+      
+      var err_handler := g.curr_err_handler;
+      self.ev.MultiAttachCallback(false, ()->
+      begin
+        if not err_handler.HadError(true) then
+        try
+          self.Invoke;
+        except
+          on e: Exception do err_handler.AddErr(e);
+        end;
+        res_ev.SetComplete;
+      end{$ifdef EventDebug}, $'body of QueueResProcNil.ThenInvokeIfProcRes with res_ev={res_ev}'{$endif});
+      
+      
+      Result := new QueueResConstNil(res_ev);
+    end;
+    
+  end;
+  
+  {$endregion Proc}
+  
+  {$endregion Nil}
+  
+  {$region <T>}
+  
+  {$region Misc}
+  
+  IPtrQueueRes<T> = interface
+    function GetPtr: ^T;
+  end;
+  QRPtrWrap<T> = sealed class(IPtrQueueRes<T>)
+    private ptr: ^T := pointer(Marshal.AllocHGlobal(Marshal.SizeOf&<T>));
+    
+    public constructor(val: T) := self.ptr^ := val;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected procedure Finalize; override :=
+    Marshal.FreeHGlobal(new IntPtr(ptr));
+    
+    public function GetPtr: ^T := ptr;
+    
+  end;
+  
+  {$endregion Misc}
+  
+  {$region General}
+  
+  QueueRes<T> = abstract partial class(QueueResBase)
+    
+    public function GetRes: T; abstract;
+    
+    public function TrySetEv(new_ev: EventList) := QueueRes&<T>(TrySetEvBase(new_ev));
+    
+    public function CloneBase(new_ev: EventList): QueueResBase; override := Clone(new_ev);
+    public function Clone(new_ev: EventList): QueueRes<T>; abstract;
+    
+    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; abstract;
+    
+    // Only usable after waiting on .ev
+    public function ToPtr: IPtrQueueRes<T>; abstract;
+    
+    public function ThenInvokeIfFuncRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueRes<T>; abstract;
+    public function ThenInvokeIfDelegateRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueResBase; override := self.ThenInvokeIfFuncRes(g, need_ptr_qr);
+    
+  end;
+  
+  {$endregion General}
+  
+  {$region Const}
+  
+  IQueueResConst = interface end;
+  // Результат который просто есть
+  QueueResConst<T> = sealed partial class(QueueRes<T>, IQueueResConst)
+    private res: T;
+    
+    public constructor(res: T; ev: EventList);
+    begin
+      inherited Create(ev);
+      self.res := res;
+    end;
+    private constructor := inherited;
+    
+    public function Clone(new_ev: EventList): QueueRes<T>; override := new QueueResConst<T>(res, new_ev);
+    
+    public function GetRes: T; override := res;
+    
+    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; override;
+    
+    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(res);
+    
+    public function ThenInvokeIfFuncRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueRes<T>; override := self;
+    
+  end;
+  
+  {$endregion Const}
+  
+  {$region Delayed}
+  
+  // Результат который будет сохранён куда то, надо только дождаться
+  QueueResDelayedBase<T> = abstract partial class(QueueRes<T>)
+    
+    public constructor := inherited Create(EventList.Empty);
+    
+    public function Clone(new_ev: EventList): QueueRes<T>; override;
+    
+    public procedure SetRes(value: T); abstract;
+    
+    public function LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>; override;
+    
+    public function ThenInvokeIfFuncRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueRes<T>; override := self;
+    
+  end;
+  
+  QueueResDelayedObj<T> = sealed partial class(QueueResDelayedBase<T>)
+    private res := default(T);
+    
+    public function GetRes: T; override := res;
+    public procedure SetRes(value: T); override := res := value;
+    
+    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(res);
+    
+  end;
+  
+  IQueueResDelayedPtr = interface end;
+  QueueResDelayedPtr<T> = sealed partial class(QueueResDelayedBase<T>, IPtrQueueRes<T>, IQueueResDelayedPtr)
+    private ptr: ^T := pointer(Marshal.AllocHGlobal(Marshal.SizeOf&<T>));
+    
+    static constructor :=
+    BlittableHelper.RaiseIfBad(typeof(T), 'использовать в некоторой внутренней ситуации (напишите об этом в issue)');
+    
+    public constructor(res: T; ev: EventList);
+    begin
+      inherited Create(ev);
+      self.ptr^ := res;
+    end;
+    public constructor := inherited Create;
+    
+    public function GetPtr: ^T := ptr;
+    public function GetRes: T; override := ptr^;
+    public procedure SetRes(value: T); override := ptr^ := value;
+    
+    protected procedure Finalize; override :=
+    Marshal.FreeHGlobal(new IntPtr(ptr));
+    
+    public function ToPtr: IPtrQueueRes<T>; override := self;
+    
+  end;
+  
+  QueueRes<T> = abstract partial class(QueueResBase)
+    
+    public static function MakeNewConstOrPtr(need_ptr_qr: boolean; res: T; ev: EventList) :=
+    if need_ptr_qr then
+      new QueueResDelayedPtr<T>(res, ev) as QueueRes<T> else
+      new QueueResConst<T>(res, ev) as QueueRes<T>;
+    
+    public static function MakeNewDelayedOrPtr(need_ptr_qr: boolean) :=
+    if need_ptr_qr then
+      new QueueResDelayedPtr<T> as QueueResDelayedBase<T> else
+      new QueueResDelayedObj<T> as QueueResDelayedBase<T>;
+    
+  end;
+  
+  {$endregion Delayed}
+  
+  {$region Func}
+  
+  // Результат который надо будет сначала дождаться, а потом ещё досчитать
+  QueueResFunc<T> = sealed partial class(QueueRes<T>)
+    private f: ()->T;
+    
+    public constructor(f: ()->T; ev: EventList);
+    begin
+      inherited Create(ev);
+      self.f := f;
+    end;
+    private constructor := inherited;
+    
+    public function Clone(new_ev: EventList): QueueRes<T>; override := new QueueResFunc<T>(f, new_ev);
+    
+    {$ifdef DEBUG}
+    private was_invoked := false;
+    {$endif DEBUG}
+    public function GetRes: T; override;
+    begin
+      {$ifdef DEBUG}
+      if was_invoked then raise new System.InvalidProgramException($'{self.GetType}: {System.Environment.StackTrace}');
+      was_invoked := true;
+      {$endif DEBUG}
+      Result := f();
+    end;
+    
+    {$ifdef DEBUG}
+    protected procedure Finalize; override :=
+    if not was_invoked then raise new System.InvalidProgramException($'{self.GetType}');
+    {$endif DEBUG}
+    
+    public function LazyQuickTransform<T2>(f2: T->T2): QueueRes<T2>; override :=
+    new QueueResFunc<T2>(()->f2(self.GetRes), self.ev);
+    
+    public function ToPtr: IPtrQueueRes<T>; override := new QRPtrWrap<T>(self.GetRes);
+    
+    public function ThenInvokeIfFuncRes(g: CLTaskGlobalData; need_ptr_qr: boolean): QueueRes<T>; override;
+    begin
+      var res := QueueRes&<T>.MakeNewDelayedOrPtr(need_ptr_qr);
+      var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for QueueResFunc<{typeof(T)}>.ThenInvokeIfFuncRes'{$endif});
+      res.ev := res_ev;
+      
+      var err_handler := g.curr_err_handler;
+      self.ev.MultiAttachCallback(false, ()->
+      begin
+        if not err_handler.HadError(true) then
+        try
+          res.SetRes(self.GetRes);
+        except
+          on e: Exception do err_handler.AddErr(e);
+        end;
+        res_ev.SetComplete;
+      end{$ifdef EventDebug}, $'body of QueueResFunc<{typeof(T)}>.ThenInvokeIfFuncRes with res_ev={res_ev}'{$endif});
+      
+      Result := res;
+    end;
+    
+  end;
+  
+  {$endregion Func}
+  
+  {$endregion <T>}
+  
+function QueueResConst<T>.LazyQuickTransform<T2>(f: T->T2): QueueRes<T2>;
+begin
+  try
+    var n_res := f(self.res);
+    Result := new QueueResConst<T2>(n_res, self.ev);
+  except
+    on e: Exception do
+    begin
+      var edi := System.Runtime.ExceptionServices.ExceptionDispatchInfo.Capture(e);
+      Result := new QueueResFunc<T2>(()->
+      begin
+        Result := default(T2);
+        edi.Throw;
+      end, self.ev);
+    end;
+  end;
+end;
+
+function QueueResDelayedBase<T>.Clone(new_ev: EventList) :=
+new QueueResFunc<T>(self.GetRes, new_ev);
+
+function QueueResDelayedBase<T>.LazyQuickTransform<T2>(f: T->T2) :=
+new QueueResFunc<T2>(()->f(self.GetRes()), self.ev);
+
+{$endregion QueueRes}
+
 {$region MultiusableBase}
 
 type
   IMultiusableCommandQueueHub = interface end;
   MultiuseableResultData = record
-    public qres: IEventListContainer;
+    public qres: QueueResBase;
     public err_handler: CLTaskErrHandler;
     
-    public constructor(qres: IEventListContainer; err_handler: CLTaskErrHandler);
+    public constructor(qres: QueueResBase; err_handler: CLTaskErrHandler);
     begin
       self.qres := qres;
       self.err_handler := err_handler;
@@ -5499,6 +6105,7 @@ type
 type
   ICLTaskLocalData = interface
     property PrevEv: EventList read write;
+    property NeedPtrQr: boolean read;
   end;
   
   CLTaskLocalData = record(ICLTaskLocalData)
@@ -5507,6 +6114,7 @@ type
     
     //TODO #2607
     public property ICLTaskLocalData.PrevEv: EventList read EventList(prev_ev) write prev_ev := value;
+    public property ICLTaskLocalData.NeedPtrQr: boolean read boolean(need_ptr_qr);
     
     public procedure CheckInvalidNeedPtrQr(source: object) :=
     if need_ptr_qr then raise new OpenCLABCInternalException($'{source.GetType} with need_ptr_qr');
@@ -5517,6 +6125,7 @@ type
     
     //TODO #2607
     public property ICLTaskLocalData.PrevEv: EventList read EventList(prev_ev) write prev_ev := value;
+    public property ICLTaskLocalData.NeedPtrQr: boolean read boolean(false);
     
     public static function operator explicit(l: CLTaskLocalData): CLTaskLocalDataNil;
     begin
@@ -5557,7 +6166,7 @@ type
     private constructor := raise new OpenCLABCInternalException;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function InvokeBranch<TR>(branch: (CLTaskGlobalData, TLData)->TR): TR; where TR: IEventListContainer;
+    function InvokeBranch<TR>(branch: (CLTaskGlobalData, TLData)->TR): TR; where TR: QueueResBase;
     begin
       g.curr_err_handler := make_base_err_handler();
       
@@ -5569,7 +6178,7 @@ type
         g.curr_inv_cq := cl_command_queue.Zero;
         if prev_cq=cl_command_queue.Zero then
           prev_cq := cq else
-          Result.get_ev.MultiAttachCallback(true, ()->
+          Result.ev.MultiAttachCallback(true, ()->
           begin
             {$ifdef QueueDebug}
             QueueDebug.Add(cq, '----- return -----');
@@ -5631,7 +6240,7 @@ type
       
       // mu выполняют лишний .Retain, чтобы ивент не удалился пока очередь ещё запускается
       foreach var mrd in mu_res.Values do
-        mrd.qres.get_ev.Release({$ifdef EventDebug}$'excessive mu ev'{$endif});
+        mrd.qres.ev.Release({$ifdef EventDebug}$'excessive mu ev'{$endif});
       mu_res := nil;
       
     end;
@@ -5679,16 +6288,15 @@ type
   
   CommandQueueNil = abstract partial class(CommandQueueBase)
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; abstract;
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): EventList;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; abstract;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueResNil;
     begin
       {$ifdef DEBUG}
       l.CheckInvalidNeedPtrQr(self);
       {$endif DEBUG}
       Result := Invoke(g, CLTaskLocalDataNil(l));
     end;
-    protected function InvokeBase(g: CLTaskGlobalData; l: CLTaskLocalData): QueueResBase; override :=
-    new QueueResConst<object>(nil, Invoke(g,l));
+    protected function InvokeBase(g: CLTaskGlobalData; l: CLTaskLocalData): QueueResBase; override := Invoke(g, l);
     
   end;
   
@@ -5707,14 +6315,8 @@ type
 type
   ConstQueue<T> = sealed partial class(CommandQueue<T>)
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override;
-    begin
-      
-      if l.need_ptr_qr then
-        Result := new QueueResDelayedPtr<T> (self.res, l.prev_ev) else
-        Result := new QueueResConst<T>      (self.res, l.prev_ev);
-      
-    end;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override :=
+    QueueRes&<T>.MakeNewConstOrPtr(l.need_ptr_qr, self.res, l.prev_ev);
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
     
@@ -5737,7 +6339,7 @@ type
       var prev_qr := InvokeSubQs(g, CLTaskLocalDataNil(l));
       var c := g.c;
       
-      var qr := QueueResDelayedBase&<TRes>.MakeNew(l.need_ptr_qr);
+      var qr := QueueResDelayedBase&<TRes>.MakeNewDelayedOrPtr(l.need_ptr_qr);
       qr.ev := UserEvent.StartBackgroundWork(prev_qr.ev, ()->qr.SetRes( ExecFunc(prev_qr.GetRes(), c) ), g
         {$ifdef EventDebug}, $'body of {self.GetType}'{$endif}
       );
@@ -5769,7 +6371,7 @@ type
       var l_data := new CLTaskLocalDataNil;
       
       q.RegisterWaitables(g_data, new HashSet<IMultiusableCommandQueueHub>);
-      var res_ev := q.Invoke(g_data, l_data);
+      var res_ev := q.Invoke(g_data, l_data).ThenInvokeIfProcRes(g_data).ev;
       g_data.FinishInvoke;
       
       NativeUtils.StartNewBgThread(()->
@@ -5794,14 +6396,12 @@ type
       var l_data := new CLTaskLocalData;
       
       q.RegisterWaitables(g_data, new HashSet<IMultiusableCommandQueueHub>);
-      self.q_res := q.Invoke(g_data, l_data);
+      self.q_res := q.Invoke(g_data, l_data).ThenInvokeIfFuncRes(g_data, false);
       g_data.FinishInvoke;
       
       NativeUtils.StartNewBgThread(()->
       begin
         self.q_res.ev.WaitAndRelease({$ifdef EventDebug}$'CLTask<T>.FinishExecution'{$endif});
-        if not g_data.curr_err_handler.HadError(true) then
-          self.q_res := q_res.Stabilise(g_data.curr_err_handler);
         g_data.FinishExecution(self.err_lst);
         wh.Set;
       end);
@@ -5850,7 +6450,7 @@ type
     private constructor := raise new OpenCLABCInternalException;
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := q.RegisterWaitables(g, prev_hubs);
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override := new QueueResConst<T>(nil_val, q.Invoke(g, l));
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override := new QueueResConst<T>(nil_val, q.Invoke(g, l).ThenInvokeIfProcRes(g).ev);
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
     begin
@@ -5874,7 +6474,7 @@ type
       if typeof(TInp)=typeof(object) then exit;
       try
         var res := TRes(object(default(TInp)));
-        res := res;
+        System.GC.KeepAlive(res);
       except
         raise new System.InvalidCastException($'.Cast не может преобразовывать {typeof(TInp)} в {typeof(TRes)}');
       end;
@@ -5942,10 +6542,10 @@ end;
 
 {$endregion Cast}
 
-{$region ThenConvert}
+{$region ThenBackgroundConvert}
 
 type
-  CommandQueueThenConvertBase<TInp, TRes, TFunc> = abstract class(HostQueue<TInp, TRes>)
+  CommandQueueThenBackgroundConvertBase<TInp, TRes, TFunc> = abstract class(HostQueue<TInp, TRes>)
   where TFunc: Delegate;
     private q: CommandQueue<TInp>;
     private f: TFunc;
@@ -5976,29 +6576,29 @@ type
     
   end;
   
-  CommandQueueThenConvert<TInp, TRes> = sealed class(CommandQueueThenConvertBase<TInp, TRes, TInp->TRes>)
+  CommandQueueThenBackgroundConvert<TInp, TRes> = sealed class(CommandQueueThenBackgroundConvertBase<TInp, TRes, TInp->TRes>)
     
     protected function ExecFunc(o: TInp; c: Context): TRes; override := f(o);
     
   end;
-  CommandQueueThenConvertC<TInp, TRes> = sealed class(CommandQueueThenConvertBase<TInp, TRes, (TInp, Context)->TRes>)
+  CommandQueueThenBackgroundConvertC<TInp, TRes> = sealed class(CommandQueueThenBackgroundConvertBase<TInp, TRes, (TInp, Context)->TRes>)
     
     protected function ExecFunc(o: TInp; c: Context): TRes; override := f(o, c);
     
   end;
   
 function CommandQueue<T>.ThenConvert<TOtp>(f: T->TOtp) :=
-new CommandQueueThenConvert<T, TOtp>(self, f);
+new CommandQueueThenBackgroundConvert<T, TOtp>(self, f);
 
 function CommandQueue<T>.ThenConvert<TOtp>(f: (T, Context)->TOtp) :=
-new CommandQueueThenConvertC<T, TOtp>(self, f);
+new CommandQueueThenBackgroundConvertC<T, TOtp>(self, f);
 
 {$endregion ThenConvert}
 
 {$region ThenUse}
 
 type
-  CommandQueueThenUseBase<T, TProc> = abstract class(CommandQueue<T>)
+  CommandQueueThenBackgroundUseBase<T, TProc> = abstract class(CommandQueue<T>)
   where TProc: Delegate;
     private q: CommandQueue<T>;
     private p: TProc;
@@ -6020,21 +6620,25 @@ type
       var prev_qr := q.Invoke(g, l);
       var c := g.c;
       
+      var err_handler := g.curr_err_handler;
+      // QueueResFunc.GetRes shouldn't be called twice
       if prev_qr is QueueResFunc<T>(var prev_f_qr) then
       begin
-        var qr := QueueResDelayedBase&<T>.MakeNew(l.need_ptr_qr);
-        qr.ev := UserEvent.StartBackgroundWork(prev_qr.ev, ()->
+        var qr := QueueRes&<T>.MakeNewDelayedOrPtr(l.need_ptr_qr);
+        qr.ev := UserEvent.StartBackgroundWork(prev_f_qr.ev, ()->
+        if not err_handler.HadError(true) then
         begin
-          var res := prev_qr.GetRes;
+          var res := prev_f_qr.GetRes;
           ExecProc(res, c);
           qr.SetRes(res);
         end, g{$ifdef EventDebug}, $'body of {self.GetType}'{$endif});
         Result := qr;
       end else
         Result := prev_qr.TrySetEv(
-          UserEvent.StartBackgroundWork(prev_qr.ev, ()->ExecProc(prev_qr.GetRes, c), g
-            {$ifdef EventDebug}, $'body of {self.GetType}'{$endif}
-          )
+          UserEvent.StartBackgroundWork(prev_qr.ev, ()->
+            if not err_handler.HadError(true) then
+              ExecProc(prev_qr.GetRes, c),
+          g{$ifdef EventDebug}, $'body of {self.GetType}'{$endif})
         );
       
     end;
@@ -6053,25 +6657,156 @@ type
     
   end;
   
-  CommandQueueThenUse<T> = sealed class(CommandQueueThenUseBase<T, T->()>)
+  CommandQueueThenBackgroundUse<T> = sealed class(CommandQueueThenBackgroundUseBase<T, T->()>)
     
     protected procedure ExecProc(o: T; c: Context); override := p(o);
     
   end;
-  CommandQueueThenUseC<T> = sealed class(CommandQueueThenUseBase<T, (T, Context)->()>)
+  CommandQueueThenBackgroundUseC<T> = sealed class(CommandQueueThenBackgroundUseBase<T, (T, Context)->()>)
     
     protected procedure ExecProc(o: T; c: Context); override := p(o, c);
     
   end;
   
 function CommandQueue<T>.ThenUse(p: T->()): CommandQueue<T> :=
-new CommandQueueThenUse<T>(self, p);
+new CommandQueueThenBackgroundUse<T>(self, p);
 
 function CommandQueue<T>.ThenUse(p: (T, Context)->()): CommandQueue<T> :=
-new CommandQueueThenUseC<T>(self, p);
+new CommandQueueThenBackgroundUseC<T>(self, p);
 
 {$endregion ThenUse}
 
+{$region ThenQuickConvert}
+
+type
+  CommandQueueThenQuickConvertBase<TInp, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    private q: CommandQueue<TInp>;
+    private f: TFunc;
+    
+    public constructor(q: CommandQueue<TInp>; f: TFunc);
+    begin
+      self.q := q;
+      self.f := f;
+    end;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected function ExecFunc(o: TInp; c: Context): TRes; abstract;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var c := g.c;
+      Result := q.Invoke(g, l).LazyQuickTransform(o->ExecFunc(o, c));
+    end;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := q.RegisterWaitables(g, prev_hubs);
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      
+      q.ToString(sb, tabs, index, delayed);
+      
+      sb.Append(#9, tabs);
+      ToStringWriteDelegate(sb, f);
+      sb += #10;
+      
+    end;
+    
+  end;
+  
+  CommandQueueThenQuickConvert<TInp, TRes> = sealed class(CommandQueueThenQuickConvertBase<TInp, TRes, TInp->TRes>)
+    
+    protected function ExecFunc(o: TInp; c: Context): TRes; override := f(o);
+    
+  end;
+  CommandQueueThenQuickConvertC<TInp, TRes> = sealed class(CommandQueueThenQuickConvertBase<TInp, TRes, (TInp, Context)->TRes>)
+    
+    protected function ExecFunc(o: TInp; c: Context): TRes; override := f(o, c);
+    
+  end;
+  
+function CommandQueue<T>.ThenQuickConvert<TOtp>(f: T->TOtp) :=
+new CommandQueueThenQuickConvert<T, TOtp>(self, f);
+
+function CommandQueue<T>.ThenQuickConvert<TOtp>(f: (T, Context)->TOtp) :=
+new CommandQueueThenQuickConvertC<T, TOtp>(self, f);
+
+{$endregion ThenQuickConvert}
+
+{$region ThenQuickUse}
+
+type
+  CommandQueueThenQuickUseBase<T, TProc> = abstract class(CommandQueue<T>)
+  where TProc: Delegate;
+    private q: CommandQueue<T>;
+    private p: TProc;
+    
+    public constructor(q: CommandQueue<T>; p: TProc);
+    begin
+      self.q := q;
+      self.p := p;
+    end;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected procedure ExecProc(o: T; c: Context); abstract;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override;
+    begin
+      var prev_qr := q.Invoke(g, l).ThenInvokeIfFuncRes(g, l.need_ptr_qr);
+      
+      var c := g.c;
+      var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for {self.GetType}'{$endif});
+      var err_handler := g.curr_err_handler;
+      prev_qr.ev.MultiAttachCallback(false, ()->
+      begin
+        if not err_handler.HadError(true) then
+        try
+          ExecProc(prev_qr.GetRes, c);
+        except
+          on e: Exception do err_handler.AddErr(e);
+        end;
+        res_ev.SetComplete;
+      end{$ifdef EventDebug}, $'body of {self.GetType}'{$endif});
+      
+      Result := prev_qr.TrySetEv(res_ev);
+    end;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := q.RegisterWaitables(g, prev_hubs);
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      
+      q.ToString(sb, tabs, index, delayed);
+      
+      sb.Append(#9, tabs);
+      ToStringWriteDelegate(sb, p);
+      sb += #10;
+      
+    end;
+    
+  end;
+  
+  CommandQueueThenQuickUse<T> = sealed class(CommandQueueThenQuickUseBase<T, T->()>)
+    
+    protected procedure ExecProc(o: T; c: Context); override := p(o);
+    
+  end;
+  CommandQueueThenQuickUseC<T> = sealed class(CommandQueueThenQuickUseBase<T, (T, Context)->()>)
+    
+    protected procedure ExecProc(o: T; c: Context); override := p(o, c);
+    
+  end;
+  
+function CommandQueue<T>.ThenQuickUse(p: T->()) :=
+new CommandQueueThenQuickUse<T>(self, p);
+
+function CommandQueue<T>.ThenQuickUse(p: (T, Context)->()) :=
+new CommandQueueThenQuickUseC<T>(self, p);
+
+{$endregion ThenQuickUse}
+
 {$region +/*}
 
 {$region Simple}
@@ -6093,16 +6828,16 @@ type
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function InvokeSync<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_last: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: IEventListContainer;
+    function InvokeSync<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_last: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: QueueResBase;
     begin
       for var i := 0 to qs.Length-1 do
-        l.PrevEv := qs[i].InvokeBase(g, l.WithPtrNeed(false)).ev;
+        l.PrevEv := qs[i].InvokeBase(g, l.WithPtrNeed(false)).ThenInvokeIfDelegateRes(g, false).ev;
       
       Result := invoke_last(g, l);
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function InvokeAsync<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_last: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: IEventListContainer;
+    function InvokeAsync<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_last: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: QueueResBase;
     begin
       if l.PrevEv.count<>0 then loop qs.Length do
         l.PrevEv.Retain({$ifdef EventDebug}$'for all async branches'{$endif});
@@ -6113,15 +6848,15 @@ type
       begin
         for var i := 0 to qs.Length-1 do
           //TODO #2610
-          evs[i] := invoker.InvokeBranch&<EventList>((g,l)->
-            qs[i].InvokeBase(g, l.WithPtrNeed(false)).ev
-          );
+          evs[i] := invoker.InvokeBranch&<QueueResBase>((g,l)->
+            qs[i].InvokeBase(g, l.WithPtrNeed(false)).ThenInvokeIfDelegateRes(g, false)
+          ).ev;
         var l_res := invoker.InvokeBranch(invoke_last);
         res := l_res;
-        evs[qs.Length] := l_res.get_ev;
+        evs[qs.Length] := l_res.ev;
       end);
       
-      Result := res.set_ev( EventList.Combine(evs) );
+      Result := TR(res.TrySetEvBase( EventList.Combine(evs) ));
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -6162,10 +6897,10 @@ type
   end;
   
   SimpleSyncQueueArrayNil = sealed class(SimpleQueueArrayNil, ISimpleSyncQueueArray)
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := data.InvokeSync(g, l, data.last.Invoke);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override := data.InvokeSync(g, l, data.last.Invoke);
   end;
   SimpleAsyncQueueArrayNil = sealed class(SimpleQueueArrayNil, ISimpleAsyncQueueArray)
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := data.InvokeAsync(g, l, data.last.Invoke);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override := data.InvokeAsync(g, l, data.last.Invoke);
   end;
   
   SimpleQueueArray<T> = abstract class(CommandQueue<T>, ISimpleQueueArray)
@@ -6202,7 +6937,12 @@ type
 {$region Generic}
 
 type
-  ConvQueueArrayBase<TInp, TRes, TFunc> = abstract class(HostQueue<array of TInp, TRes>)
+  
+  {$region Background}
+  
+  {$region Base}
+  
+  BackgroundConvQueueArrayBase<TInp, TRes, TFunc> = abstract class(HostQueue<array of TInp, TRes>)
   where TFunc: Delegate;
     protected qs: array of CommandQueue<TInp>;
     protected f: TFunc;
@@ -6214,6 +6954,21 @@ type
     end;
     private constructor := raise new OpenCLABCInternalException;
     
+    protected function CombineQRs(qrs: array of QueueRes<TInp>; ev: EventList): QueueRes<array of TInp>;
+    begin
+      if qrs.All(qr->qr is QueueResConst<TInp>) then
+      begin
+        var res := qrs.ConvertAll(qr->QueueResConst&<TInp>(qr).res);
+        Result := new QueueResConst<array of TInp>(res, ev);
+      end else
+        Result := new QueueResFunc<array of TInp>(()->
+        begin
+          Result := new TInp[qrs.Length];
+          for var i := 0 to qrs.Length-1 do
+            Result[i] := qrs[i].GetRes;
+        end, ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override :=
     foreach var q in qs do q.RegisterWaitables(g, prev_hubs);
     
@@ -6231,9 +6986,11 @@ type
     
   end;
   
+  {$endregion Base}
+  
   {$region Sync}
   
-  ConvSyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(ConvQueueArrayBase<TInp, TRes, TFunc>)
+  BackgroundConvSyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(BackgroundConvQueueArrayBase<TInp, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueRes<array of TInp>; override;
@@ -6247,22 +7004,17 @@ type
         qrs[i] := qr;
       end;
       
-      Result := new QueueResFunc<array of TInp>(()->
-      begin
-        Result := new TInp[qrs.Length];
-        for var i := 0 to qrs.Length-1 do
-          Result[i] := qrs[i].GetRes;
-      end, l.prev_ev);
+      Result := CombineQRs(qrs, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray<TInp, TRes> = sealed class(ConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
+  BackgroundConvSyncQueueArray<TInp, TRes> = sealed class(BackgroundConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
     
     protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o);
     
   end;
-  ConvSyncQueueArrayC<TInp, TRes> = sealed class(ConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
+  BackgroundConvSyncQueueArrayC<TInp, TRes> = sealed class(BackgroundConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
     
     protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o, c);
     
@@ -6272,7 +7024,7 @@ type
   
   {$region Async}
   
-  ConvAsyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(ConvQueueArrayBase<TInp, TRes, TFunc>)
+  BackgroundConvAsyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(BackgroundConvQueueArrayBase<TInp, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueRes<array of TInp>; override;
@@ -6291,27 +7043,17 @@ type
       end);
       
       var res_ev := EventList.Combine(evs);
-      if qrs.All(qr->qr is QueueResConst<TInp>) then
-        Result := new QueueResConst<array of TInp>(
-          qrs.ConvertAll(qr->QueueResConst&<TInp>(qr).res), res_ev
-        ) else
-        Result := new QueueResFunc<array of TInp>(()->
-        begin
-          Result := new TInp[qrs.Length];
-          for var i := 0 to qrs.Length-1 do
-            Result[i] := qrs[i].GetRes;
-        end, res_ev);
-      
+      Result := CombineQRs(qrs, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray<TInp, TRes> = sealed class(ConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
+  BackgroundConvAsyncQueueArray<TInp, TRes> = sealed class(BackgroundConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
     
     protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o);
     
   end;
-  ConvAsyncQueueArrayC<TInp, TRes> = sealed class(ConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
+  BackgroundConvAsyncQueueArrayC<TInp, TRes> = sealed class(BackgroundConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
     
     protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o, c);
     
@@ -6319,12 +7061,142 @@ type
   
   {$endregion Async}
   
+  {$endregion Background}
+  
+  {$region Quick}
+  
+  {$region Base}
+  
+  QuickConvQueueArrayBase<TInp, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected qs: array of CommandQueue<TInp>;
+    protected f: TFunc;
+    
+    public constructor(qs: array of CommandQueue<TInp>; f: TFunc);
+    begin
+      self.qs := qs;
+      self.f := f;
+    end;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected function CombineQRs(qrs: array of QueueRes<TInp>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      if qrs.All(qr->qr is QueueResConst<TInp>) then
+      begin
+        var res := ExecFunc(qrs.ConvertAll(qr->QueueResConst&<TInp>(qr).res), c);
+        Result := QueueResConst&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->
+        begin
+          var res := new TInp[qrs.Length];
+          for var i := 0 to qrs.Length-1 do
+            res[i] := qrs[i].GetRes;
+          Result := ExecFunc(res, c);
+        end, ev);
+    end;
+    
+    protected function ExecFunc(o: array of TInp; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override :=
+    foreach var q in qs do q.RegisterWaitables(g, prev_hubs);
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      
+      foreach var q in qs do
+        q.ToString(sb, tabs, index, delayed);
+      
+      sb.Append(#9, tabs);
+      ToStringWriteDelegate(sb, f);
+      sb += #10;
+    end;
+    
+  end;
+  
+  {$endregion Base}
+  
+  {$region Sync}
+  
+  QuickConvSyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(QuickConvQueueArrayBase<TInp, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qrs := new QueueRes<TInp>[qs.Length];
+      
+      for var i := 0 to qs.Length-1 do
+      begin
+        var qr := qs[i].Invoke(g, l.WithPtrNeed(false));
+        l.prev_ev := qr.ev;
+        qrs[i] := qr;
+      end;
+      
+      Result := CombineQRs(qrs, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray<TInp, TRes> = sealed class(QuickConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
+    
+    protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o);
+    
+  end;
+  QuickConvSyncQueueArrayC<TInp, TRes> = sealed class(QuickConvSyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
+    
+    protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o, c);
+    
+  end;
+  
+  {$endregion Sync}
+  
+  {$region Async}
+  
+  QuickConvAsyncQueueArrayBase<TInp, TRes, TFunc> = abstract class(QuickConvQueueArrayBase<TInp, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop qs.Length-1 do
+        l.prev_ev.Retain({$ifdef EventDebug}$'for all async branches'{$endif});
+      var qrs := new QueueRes<TInp>[qs.Length];
+      var evs := new EventList[qs.Length];
+      
+      g.ParallelInvoke(l.WithPtrNeed(false), false, qs.Length, invoker->
+      for var i := 0 to qs.Length-1 do
+      begin
+        var qr := invoker.InvokeBranch(qs[i].Invoke);
+        qrs[i] := qr;
+        evs[i] := qr.ev;
+      end);
+      
+      var res_ev := EventList.Combine(evs);
+      Result := CombineQRs(qrs, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray<TInp, TRes> = sealed class(QuickConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, TRes>>)
+    
+    protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o);
+    
+  end;
+  QuickConvAsyncQueueArrayC<TInp, TRes> = sealed class(QuickConvAsyncQueueArrayBase<TInp, TRes, Func<array of TInp, Context, TRes>>)
+    
+    protected function ExecFunc(o: array of TInp; c: Context): TRes; override := f(o, c);
+    
+  end;
+  
+  {$endregion Async}
+  
+  {$endregion Quick}
+  
 {$endregion Generic}
 
 {$region [2]}
 
 type
-  ConvQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2>, TRes>)
+  BackgroundConvQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6338,6 +7210,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6353,7 +7237,50 @@ type
     
   end;
   
-  ConvSyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(ConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
+  QuickConvQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(BackgroundConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2>>; override;
@@ -6361,23 +7288,23 @@ type
       var l := l_nil.WithPtrNeed(false);
       var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
       var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray2<TInp1, TInp2, TRes> = sealed class(ConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
+  BackgroundConvSyncQueueArray2<TInp1, TInp2, TRes> = sealed class(BackgroundConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2>; c: Context): TRes; override := f(t.Item1, t.Item2);
     
   end;
-  ConvSyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(ConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
+  BackgroundConvSyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(BackgroundConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2>; c: Context): TRes; override := f(t.Item1, t.Item2, c);
     
   end;
   
-  ConvAsyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(ConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(BackgroundConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2>>; override;
@@ -6391,28 +7318,82 @@ type
         qr1 := invoker.InvokeBranch(q1.Invoke);
         qr2 := invoker.InvokeBranch(q2.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes()), EventList.Combine(|qr1.ev, qr2.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev|);
+      Result := CombineQRs(qr1, qr2, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray2<TInp1, TInp2, TRes> = sealed class(ConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
+  BackgroundConvAsyncQueueArray2<TInp1, TInp2, TRes> = sealed class(BackgroundConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2>; c: Context): TRes; override := f(t.Item1, t.Item2);
     
   end;
-  ConvAsyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(ConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
+  BackgroundConvAsyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(BackgroundConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2>; c: Context): TRes; override := f(t.Item1, t.Item2, c);
     
   end;
+  
+  QuickConvSyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(QuickConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      Result := CombineQRs(qr1, qr2, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray2<TInp1, TInp2, TRes> = sealed class(QuickConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; c: Context): TRes; override := f(o1, o2);
+    
+  end;
+  QuickConvSyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(QuickConvSyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; c: Context): TRes; override := f(o1, o2, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray2Base<TInp1, TInp2, TRes, TFunc> = abstract class(QuickConvQueueArray2Base<TInp1, TInp2, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 1 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      g.ParallelInvoke(l, false, 2, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev|);
+      Result := CombineQRs(qr1, qr2, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray2<TInp1, TInp2, TRes> = sealed class(QuickConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; c: Context): TRes; override := f(o1, o2);
+    
+  end;
+  QuickConvAsyncQueueArray2C<TInp1, TInp2, TRes> = sealed class(QuickConvAsyncQueueArray2Base<TInp1, TInp2, TRes, (TInp1, TInp2, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; c: Context): TRes; override := f(o1, o2, c);
+    
+  end;
 
 {$endregion [2]}
 
 {$region [3]}
 
 type
-  ConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3>, TRes>)
+  BackgroundConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6428,6 +7409,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2, TInp3>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2, TInp3>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6445,7 +7438,54 @@ type
     
   end;
   
-  ConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(ConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
+  QuickConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected q3: CommandQueue<TInp3>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.q3 := q3;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+      self.q3.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+      self.q3.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(BackgroundConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3>>; override;
@@ -6454,23 +7494,23 @@ type
       var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
       var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
       var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, qr3, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(ConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
+  BackgroundConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(BackgroundConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3);
     
   end;
-  ConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(ConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
+  BackgroundConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(BackgroundConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, c);
     
   end;
   
-  ConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(ConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(BackgroundConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3>>; override;
@@ -6486,28 +7526,85 @@ type
         qr2 := invoker.InvokeBranch(q2.Invoke);
         qr3 := invoker.InvokeBranch(q3.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes()), EventList.Combine(|qr1.ev, qr2.ev, qr3.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(ConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
+  BackgroundConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(BackgroundConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3);
     
   end;
-  ConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(ConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
+  BackgroundConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(BackgroundConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, c);
     
   end;
+  
+  QuickConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(QuickConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
+      Result := CombineQRs(qr1, qr2, qr3, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(QuickConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; c: Context): TRes; override := f(o1, o2, o3);
+    
+  end;
+  QuickConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(QuickConvSyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; c: Context): TRes; override := f(o1, o2, o3, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc> = abstract class(QuickConvQueueArray3Base<TInp1, TInp2, TInp3, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 2 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      var qr3: QueueRes<TInp3>;
+      g.ParallelInvoke(l, false, 3, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+        qr3 := invoker.InvokeBranch(q3.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes> = sealed class(QuickConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; c: Context): TRes; override := f(o1, o2, o3);
+    
+  end;
+  QuickConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes> = sealed class(QuickConvAsyncQueueArray3Base<TInp1, TInp2, TInp3, TRes, (TInp1, TInp2, TInp3, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; c: Context): TRes; override := f(o1, o2, o3, c);
+    
+  end;
 
 {$endregion [3]}
 
 {$region [4]}
 
 type
-  ConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4>, TRes>)
+  BackgroundConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6525,6 +7622,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2, TInp3, TInp4>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6544,7 +7653,58 @@ type
     
   end;
   
-  ConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(ConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
+  QuickConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected q3: CommandQueue<TInp3>;
+    protected q4: CommandQueue<TInp4>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.q3 := q3;
+      self.q4 := q4;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+      self.q3.RegisterWaitables(g, prev_hubs);
+      self.q4.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+      self.q3.ToString(sb, tabs, index, delayed);
+      self.q4.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(BackgroundConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4>>; override;
@@ -6554,23 +7714,23 @@ type
       var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
       var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
       var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(ConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
+  BackgroundConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(BackgroundConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4);
     
   end;
-  ConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(ConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
+  BackgroundConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(BackgroundConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, c);
     
   end;
   
-  ConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(ConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(BackgroundConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4>>; override;
@@ -6588,28 +7748,88 @@ type
         qr3 := invoker.InvokeBranch(q3.Invoke);
         qr4 := invoker.InvokeBranch(q4.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes()), EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(ConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
+  BackgroundConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(BackgroundConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4);
     
   end;
-  ConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(ConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
+  BackgroundConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(BackgroundConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, c);
     
   end;
+  
+  QuickConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(QuickConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
+      var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
+      Result := CombineQRs(qr1, qr2, qr3, qr4, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(QuickConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; c: Context): TRes; override := f(o1, o2, o3, o4);
+    
+  end;
+  QuickConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(QuickConvSyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; c: Context): TRes; override := f(o1, o2, o3, o4, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc> = abstract class(QuickConvQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 3 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      var qr3: QueueRes<TInp3>;
+      var qr4: QueueRes<TInp4>;
+      g.ParallelInvoke(l, false, 4, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+        qr3 := invoker.InvokeBranch(q3.Invoke);
+        qr4 := invoker.InvokeBranch(q4.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(QuickConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; c: Context): TRes; override := f(o1, o2, o3, o4);
+    
+  end;
+  QuickConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes> = sealed class(QuickConvAsyncQueueArray4Base<TInp1, TInp2, TInp3, TInp4, TRes, (TInp1, TInp2, TInp3, TInp4, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; c: Context): TRes; override := f(o1, o2, o3, o4, c);
+    
+  end;
 
 {$endregion [4]}
 
 {$region [5]}
 
 type
-  ConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>, TRes>)
+  BackgroundConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6629,6 +7849,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6650,7 +7882,62 @@ type
     
   end;
   
-  ConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(ConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
+  QuickConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected q3: CommandQueue<TInp3>;
+    protected q4: CommandQueue<TInp4>;
+    protected q5: CommandQueue<TInp5>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.q3 := q3;
+      self.q4 := q4;
+      self.q5 := q5;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+      self.q3.RegisterWaitables(g, prev_hubs);
+      self.q4.RegisterWaitables(g, prev_hubs);
+      self.q5.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+      self.q3.ToString(sb, tabs, index, delayed);
+      self.q4.ToString(sb, tabs, index, delayed);
+      self.q5.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(BackgroundConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>; override;
@@ -6661,23 +7948,23 @@ type
       var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
       var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
       var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(ConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
+  BackgroundConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(BackgroundConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5);
     
   end;
-  ConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(ConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
+  BackgroundConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(BackgroundConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, c);
     
   end;
   
-  ConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(ConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(BackgroundConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>; override;
@@ -6697,28 +7984,91 @@ type
         qr4 := invoker.InvokeBranch(q4.Invoke);
         qr5 := invoker.InvokeBranch(q5.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes()), EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(ConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
+  BackgroundConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(BackgroundConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5);
     
   end;
-  ConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(ConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
+  BackgroundConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(BackgroundConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, c);
     
   end;
+  
+  QuickConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(QuickConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
+      var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
+      var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(QuickConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; c: Context): TRes; override := f(o1, o2, o3, o4, o5);
+    
+  end;
+  QuickConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(QuickConvSyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; c: Context): TRes; override := f(o1, o2, o3, o4, o5, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc> = abstract class(QuickConvQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 4 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      var qr3: QueueRes<TInp3>;
+      var qr4: QueueRes<TInp4>;
+      var qr5: QueueRes<TInp5>;
+      g.ParallelInvoke(l, false, 5, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+        qr3 := invoker.InvokeBranch(q3.Invoke);
+        qr4 := invoker.InvokeBranch(q4.Invoke);
+        qr5 := invoker.InvokeBranch(q5.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(QuickConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; c: Context): TRes; override := f(o1, o2, o3, o4, o5);
+    
+  end;
+  QuickConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes> = sealed class(QuickConvAsyncQueueArray5Base<TInp1, TInp2, TInp3, TInp4, TInp5, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; c: Context): TRes; override := f(o1, o2, o3, o4, o5, c);
+    
+  end;
 
 {$endregion [5]}
 
 {$region [6]}
 
 type
-  ConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>, TRes>)
+  BackgroundConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6740,6 +8090,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; qr6: QueueRes<TInp6>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5)) and (qr6 is QueueResConst<TInp6>(var cqr6));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes(), cqr6.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6763,7 +8125,66 @@ type
     
   end;
   
-  ConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(ConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
+  QuickConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected q3: CommandQueue<TInp3>;
+    protected q4: CommandQueue<TInp4>;
+    protected q5: CommandQueue<TInp5>;
+    protected q6: CommandQueue<TInp6>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.q3 := q3;
+      self.q4 := q4;
+      self.q5 := q5;
+      self.q6 := q6;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; qr6: QueueRes<TInp6>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5)) and (qr6 is QueueResConst<TInp6>(var cqr6));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes(), cqr6.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+      self.q3.RegisterWaitables(g, prev_hubs);
+      self.q4.RegisterWaitables(g, prev_hubs);
+      self.q5.RegisterWaitables(g, prev_hubs);
+      self.q6.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+      self.q3.ToString(sb, tabs, index, delayed);
+      self.q4.ToString(sb, tabs, index, delayed);
+      self.q5.ToString(sb, tabs, index, delayed);
+      self.q6.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(BackgroundConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>; override;
@@ -6775,23 +8196,23 @@ type
       var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
       var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
       var qr6 := q6.Invoke(g, l); l.prev_ev := qr6.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(ConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
+  BackgroundConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(BackgroundConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6);
     
   end;
-  ConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(ConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
+  BackgroundConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(BackgroundConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, c);
     
   end;
   
-  ConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(ConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(BackgroundConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>; override;
@@ -6813,28 +8234,94 @@ type
         qr5 := invoker.InvokeBranch(q5.Invoke);
         qr6 := invoker.InvokeBranch(q6.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes()), EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(ConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
+  BackgroundConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(BackgroundConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6);
     
   end;
-  ConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(ConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
+  BackgroundConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(BackgroundConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, c);
     
   end;
+  
+  QuickConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(QuickConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
+      var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
+      var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
+      var qr6 := q6.Invoke(g, l); l.prev_ev := qr6.ev;
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(QuickConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6);
+    
+  end;
+  QuickConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(QuickConvSyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc> = abstract class(QuickConvQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 5 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      var qr3: QueueRes<TInp3>;
+      var qr4: QueueRes<TInp4>;
+      var qr5: QueueRes<TInp5>;
+      var qr6: QueueRes<TInp6>;
+      g.ParallelInvoke(l, false, 6, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+        qr3 := invoker.InvokeBranch(q3.Invoke);
+        qr4 := invoker.InvokeBranch(q4.Invoke);
+        qr5 := invoker.InvokeBranch(q5.Invoke);
+        qr6 := invoker.InvokeBranch(q6.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(QuickConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6);
+    
+  end;
+  QuickConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes> = sealed class(QuickConvAsyncQueueArray6Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, c);
+    
+  end;
 
 {$endregion [6]}
 
 {$region [7]}
 
 type
-  ConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>, TRes>)
+  BackgroundConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(HostQueue<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>, TRes>)
   where TFunc: Delegate;
     protected q1: CommandQueue<TInp1>;
     protected q2: CommandQueue<TInp2>;
@@ -6858,6 +8345,18 @@ type
     end;
     private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
     
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; qr6: QueueRes<TInp6>; qr7: QueueRes<TInp7>; ev: EventList): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5)) and (qr6 is QueueResConst<TInp6>(var cqr6)) and (qr7 is QueueResConst<TInp7>(var cqr7));
+      if all_const then
+      begin
+        var res := ValueTuple.Create(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes(), cqr6.GetRes(), cqr7.GetRes());
+        Result := new QueueResConst<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>(res, ev);
+      end else
+        Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes(), qr7.GetRes()), ev);
+    end;
+    
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
     begin
       self.q1.RegisterWaitables(g, prev_hubs);
@@ -6883,7 +8382,70 @@ type
     
   end;
   
-  ConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(ConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
+  QuickConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(CommandQueue<TRes>)
+  where TFunc: Delegate;
+    protected q1: CommandQueue<TInp1>;
+    protected q2: CommandQueue<TInp2>;
+    protected q3: CommandQueue<TInp3>;
+    protected q4: CommandQueue<TInp4>;
+    protected q5: CommandQueue<TInp5>;
+    protected q6: CommandQueue<TInp6>;
+    protected q7: CommandQueue<TInp7>;
+    protected f: TFunc;
+    
+    public constructor(q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>; f: TFunc);
+    begin
+      self.q1 := q1;
+      self.q2 := q2;
+      self.q3 := q3;
+      self.q4 := q4;
+      self.q5 := q5;
+      self.q6 := q6;
+      self.q7 := q7;
+      self.f := f;
+    end;
+    private constructor := raise new InvalidOperationException($'Был вызван не_применимый конструктор без параметров... Обратитесь к разработчику OpenCLABC');
+    
+    protected function CombineQRs(qr1: QueueRes<TInp1>; qr2: QueueRes<TInp2>; qr3: QueueRes<TInp3>; qr4: QueueRes<TInp4>; qr5: QueueRes<TInp5>; qr6: QueueRes<TInp6>; qr7: QueueRes<TInp7>; ev: EventList; need_ptr_qr: boolean; c: Context): QueueRes<TRes>;
+    begin
+      //TODO #????
+      var all_const := (qr1 is QueueResConst<TInp1>(var cqr1)) and (qr2 is QueueResConst<TInp2>(var cqr2)) and (qr3 is QueueResConst<TInp3>(var cqr3)) and (qr4 is QueueResConst<TInp4>(var cqr4)) and (qr5 is QueueResConst<TInp5>(var cqr5)) and (qr6 is QueueResConst<TInp6>(var cqr6)) and (qr7 is QueueResConst<TInp7>(var cqr7));
+      if all_const then
+      begin
+        var res := ExecFunc(cqr1.GetRes(), cqr2.GetRes(), cqr3.GetRes(), cqr4.GetRes(), cqr5.GetRes(), cqr6.GetRes(), cqr7.GetRes(), c);
+        Result := QueueRes&<TRes>.MakeNewConstOrPtr(need_ptr_qr, res, ev);
+      end else
+        Result := new QueueResFunc<TRes>(()->ExecFunc(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes(), qr7.GetRes(), c), ev);
+    end;
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; o7: TInp7; c: Context): TRes; abstract;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override;
+    begin
+      self.q1.RegisterWaitables(g, prev_hubs);
+      self.q2.RegisterWaitables(g, prev_hubs);
+      self.q3.RegisterWaitables(g, prev_hubs);
+      self.q4.RegisterWaitables(g, prev_hubs);
+      self.q5.RegisterWaitables(g, prev_hubs);
+      self.q6.RegisterWaitables(g, prev_hubs);
+      self.q7.RegisterWaitables(g, prev_hubs);
+    end;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += #10;
+      self.q1.ToString(sb, tabs, index, delayed);
+      self.q2.ToString(sb, tabs, index, delayed);
+      self.q3.ToString(sb, tabs, index, delayed);
+      self.q4.ToString(sb, tabs, index, delayed);
+      self.q5.ToString(sb, tabs, index, delayed);
+      self.q6.ToString(sb, tabs, index, delayed);
+      self.q7.ToString(sb, tabs, index, delayed);
+    end;
+    
+  end;
+  
+  BackgroundConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(BackgroundConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>; override;
@@ -6896,23 +8458,23 @@ type
       var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
       var qr6 := q6.Invoke(g, l); l.prev_ev := qr6.ev;
       var qr7 := q7.Invoke(g, l); l.prev_ev := qr7.ev;
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes(), qr7.GetRes()), l.prev_ev);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, qr7, l.prev_ev);
     end;
     
   end;
   
-  ConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(ConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
+  BackgroundConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(BackgroundConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7);
     
   end;
-  ConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(ConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
+  BackgroundConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(BackgroundConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7, c);
     
   end;
   
-  ConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(ConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
+  BackgroundConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(BackgroundConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
   where TFunc: Delegate;
     
     protected function InvokeSubQs(g: CLTaskGlobalData; l_nil: CLTaskLocalDataNil): QueueRes<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>; override;
@@ -6936,21 +8498,90 @@ type
         qr6 := invoker.InvokeBranch(q6.Invoke);
         qr7 := invoker.InvokeBranch(q7.Invoke);
       end);
-      Result := new QueueResFunc<ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>>(()->ValueTuple.Create(qr1.GetRes(), qr2.GetRes(), qr3.GetRes(), qr4.GetRes(), qr5.GetRes(), qr6.GetRes(), qr7.GetRes()), EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev, qr7.ev|));
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev, qr7.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, qr7, res_ev);
     end;
     
   end;
   
-  ConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(ConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
+  BackgroundConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(BackgroundConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7);
     
   end;
-  ConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(ConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
+  BackgroundConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(BackgroundConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
     
     protected function ExecFunc(t: ValueTuple<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7>; c: Context): TRes; override := f(t.Item1, t.Item2, t.Item3, t.Item4, t.Item5, t.Item6, t.Item7, c);
     
   end;
+  
+  QuickConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(QuickConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      var qr1 := q1.Invoke(g, l); l.prev_ev := qr1.ev;
+      var qr2 := q2.Invoke(g, l); l.prev_ev := qr2.ev;
+      var qr3 := q3.Invoke(g, l); l.prev_ev := qr3.ev;
+      var qr4 := q4.Invoke(g, l); l.prev_ev := qr4.ev;
+      var qr5 := q5.Invoke(g, l); l.prev_ev := qr5.ev;
+      var qr6 := q6.Invoke(g, l); l.prev_ev := qr6.ev;
+      var qr7 := q7.Invoke(g, l); l.prev_ev := qr7.ev;
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, qr7, l.prev_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(QuickConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; o7: TInp7; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, o7);
+    
+  end;
+  QuickConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(QuickConvSyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; o7: TInp7; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, o7, c);
+    
+  end;
+  
+  QuickConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc> = abstract class(QuickConvQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, TFunc>)
+  where TFunc: Delegate;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<TRes>; override;
+    begin
+      if l.prev_ev.count<>0 then loop 6 do l.prev_ev.Retain({$ifdef EventDebug}'for all async branches'{$endif});
+      var qr1: QueueRes<TInp1>;
+      var qr2: QueueRes<TInp2>;
+      var qr3: QueueRes<TInp3>;
+      var qr4: QueueRes<TInp4>;
+      var qr5: QueueRes<TInp5>;
+      var qr6: QueueRes<TInp6>;
+      var qr7: QueueRes<TInp7>;
+      g.ParallelInvoke(l, false, 7, invoker->
+      begin
+        qr1 := invoker.InvokeBranch(q1.Invoke);
+        qr2 := invoker.InvokeBranch(q2.Invoke);
+        qr3 := invoker.InvokeBranch(q3.Invoke);
+        qr4 := invoker.InvokeBranch(q4.Invoke);
+        qr5 := invoker.InvokeBranch(q5.Invoke);
+        qr6 := invoker.InvokeBranch(q6.Invoke);
+        qr7 := invoker.InvokeBranch(q7.Invoke);
+      end);
+      var res_ev := EventList.Combine(|qr1.ev, qr2.ev, qr3.ev, qr4.ev, qr5.ev, qr6.ev, qr7.ev|);
+      Result := CombineQRs(qr1, qr2, qr3, qr4, qr5, qr6, qr7, res_ev, l.need_ptr_qr, g.c);
+    end;
+    
+  end;
+  
+  QuickConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(QuickConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; o7: TInp7; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, o7);
+    
+  end;
+  QuickConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes> = sealed class(QuickConvAsyncQueueArray7Base<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes, (TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context)->TRes>)
+    
+    protected function ExecFunc(o1: TInp1; o2: TInp2; o3: TInp3; o4: TInp4; o5: TInp5; o6: TInp6; o7: TInp7; c: Context): TRes; override := f(o1, o2, o3, o4, o5, o6, o7, c);
+    
+  end;
 
 {$endregion [7]}
 
@@ -7077,7 +8708,7 @@ type
     if prev_hubs.Add(self) then q.RegisterWaitables(g, prev_hubs);
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_q: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: IEventListContainer;
+    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_q: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: QueueResBase;
     begin
       var prev_ev := l.PrevEv;
       
@@ -7095,17 +8726,19 @@ type
         
         l.PrevEv := EventList.Empty;
         Result := invoke_q(g, l);
-        Result.forbid_ev_swap;
+        // QueueResFunc shouldn't have it's .GetRes be called twice
+        Result := TR(Result.ThenInvokeIfDelegateRes(g, l.NeedPtrQr));
+        Result.can_set_ev := false;
         var q_err_handler := g.curr_err_handler;
         
         g.curr_err_handler := new CLTaskErrHandlerMultiusableRepeater(prev_err_handler, q_err_handler);
         g.mu_res[self] := new MultiuseableResultData(Result, q_err_handler);
       end;
       
-      var res_ev := Result.get_ev;
+      var res_ev := Result.ev;
       res_ev.Retain({$ifdef EventDebug}$'for all mu branches'{$endif});
       if prev_ev.count<>0 then
-        Result := Result.set_ev(res_ev+prev_ev);
+        Result := TR(Result.TrySetEvBase(res_ev+prev_ev));
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -7133,7 +8766,7 @@ type
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := hub.RegisterWaitables(g, prev_hubs);
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := hub.Invoke(g, l);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override := hub.Invoke(g, l);
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override :=
     hub.ToString(sb, tabs, index, delayed);
@@ -7901,11 +9534,11 @@ type
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override;
     begin
       var err_handler := g.curr_err_handler;
       l.prev_ev.MultiAttachCallback(true, ()->if not err_handler.HadError(true) then m.SendSignal{$ifdef EventDebug}, $'SendSignal'{$endif});
-      Result := l.prev_ev;
+      Result := new QueueResConstNil(l.prev_ev);
     end;
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
@@ -7971,7 +9604,7 @@ type
     procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>) := q.RegisterWaitables(g, prev_hubs);
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_q: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: IEventListContainer;
+    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_q: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: QueueResBase;
     begin
       Result := invoke_q(g, l);
       var err_handler := g.curr_err_handler;
@@ -7979,7 +9612,7 @@ type
       if signal_in_finally then
         callback := wrap.SendSignal else
         callback := ()->if not err_handler.HadError(true) then wrap.SendSignal;
-      Result.get_ev.MultiAttachCallback(true, callback{$ifdef EventDebug}, $'ExecuteMWHandlers'{$endif});
+      Result.ev.MultiAttachCallback(true, callback{$ifdef EventDebug}, $'ExecuteMWHandlers'{$endif});
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
@@ -8003,7 +9636,7 @@ type
     data: DetachedMarkerSignalCommon<CommandQueueNil>;
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := data.RegisterWaitables(g, prev_hubs);
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := data.Invoke(g, l, data.q.Invoke);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override := data.Invoke(g, l, data.q.Invoke);
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override :=
     data.ToString(sb, tabs, index, delayed);
@@ -8044,8 +9677,8 @@ type
     public marker: WaitMarker;
     public constructor(marker: WaitMarker) := self.marker := marker;
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override :=
-    marker.MakeWaitEv(g,l);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override :=
+    new QueueResConstNil(marker.MakeWaitEv(g,l));
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override :=
     marker.InitInnerHandles(g);
@@ -8146,7 +9779,7 @@ type
     end;
     
     public [System.Runtime.CompilerServices.MethodImpl(System.Runtime.CompilerServices.MethodImplOptions.AggressiveInlining)]
-    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_finally: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: IEventListContainer;
+    function Invoke<TLData,TR>(g: CLTaskGlobalData; l: TLData; invoke_finally: (CLTaskGlobalData,TLData)->TR): TR; where TLData: ICLTaskLocalData; where TR: QueueResBase;
     begin
       var origin_err_handler := g.curr_err_handler;
       
@@ -8154,7 +9787,7 @@ type
       var mid_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'mid_ev for {self.GetType}'{$endif});
       
       g.curr_err_handler := new CLTaskErrHandlerBranchBase(origin_err_handler);
-      var try_ev := try_do.InvokeBase(g, l.WithPtrNeed(false)).ev;
+      var try_ev := try_do.InvokeBase(g, l.WithPtrNeed(false)).ThenInvokeIfDelegateRes(g, false).ev;
       var try_handler := g.curr_err_handler;
       
       try_ev.MultiAttachCallback(false, ()->mid_ev.SetComplete(){$ifdef EventDebug}, $'Set mid_ev {mid_ev}'{$endif});
@@ -8196,7 +9829,7 @@ type
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override :=
     data.RegisterWaitables(g, prev_hubs);
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := data.Invoke(g, l, data.do_finally.Invoke);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override := data.Invoke(g, l, data.do_finally.Invoke);
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override :=
     data.ToString(sb, tabs, index, delayed);
@@ -8247,12 +9880,12 @@ type
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override :=
     q.RegisterWaitables(g, prev_hubs);
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override;
     begin
       var origin_err_handler := g.curr_err_handler;
       
       g.curr_err_handler := new CLTaskErrHandlerBranchBase(origin_err_handler);
-      var q_ev := q.InvokeBase(g, l.WithPtrNeed(false)).ev;
+      var q_ev := q.InvokeBase(g, l.WithPtrNeed(false)).ThenInvokeIfDelegateRes(g, false).ev;
       var q_err_handler := g.curr_err_handler;
       g.curr_err_handler := new CLTaskErrHandlerBranchCombinator(origin_err_handler, |q_err_handler|);
       
@@ -8263,7 +9896,7 @@ type
         res_ev.SetComplete;
       end{$ifdef EventDebug}, $'Set res_ev {res_ev}'{$endif});
       
-      Result := res_ev;
+      Result := new QueueResConstNil(res_ev);
     end;
     
     private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
@@ -8305,7 +9938,7 @@ type
       var q_err_handler := g.curr_err_handler;
       g.curr_err_handler := new CLTaskErrHandlerBranchCombinator(origin_err_handler, |q_err_handler|);
       
-      var res := QueueResDelayedBase&<T>.MakeNew(l.need_ptr_qr);
+      var res := QueueRes&<T>.MakeNewDelayedOrPtr(l.need_ptr_qr);
       var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for {self.GetType}'{$endif});
       res.ev := res_ev;
       
@@ -8363,7 +9996,7 @@ type
       var q_err_handler := new CLTaskErrHandlerThief(g.curr_err_handler);
       g.curr_err_handler := new CLTaskErrHandlerBranchCombinator(origin_err_handler, new CLTaskErrHandler[](q_err_handler));
       
-      var res := QueueResDelayedBase&<T>.MakeNew(l.need_ptr_qr);
+      var res := QueueRes&<T>.MakeNewDelayedOrPtr(l.need_ptr_qr);
       var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for {self.GetType}'{$endif});
       res.ev := res_ev;
       
@@ -8936,8 +10569,12 @@ type
     end;
     
     public static function MakeQueue(q: CommandQueueBase): BasicGPUCommand<T>;
-    public static function MakeProc(p: T->()): BasicGPUCommand<T>;
-    public static function MakeProc(p: (T,Context)->()): BasicGPUCommand<T>;
+    
+    public static function MakeBackgroundProc(p: T->()): BasicGPUCommand<T>;
+    public static function MakeBackgroundProc(p: (T,Context)->()): BasicGPUCommand<T>;
+    public static function MakeQuickProc(p: T->()): BasicGPUCommand<T>;
+    public static function MakeQuickProc(p: (T,Context)->()): BasicGPUCommand<T>;
+    
     public static function MakeWait(m: WaitMarker): BasicGPUCommand<T>;
     
   end;
@@ -8972,12 +10609,14 @@ type
   
   QueueCommandNil<TObj> = sealed class(QueueCommandCommon<TObj,CommandQueueNil>)
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := q.Invoke(g, l);
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override :=
+    q.Invoke(g, l).ThenInvokeIfProcRes(g).ev;
     
   end;
   QueueCommand<TObj,TQRes> = sealed class(QueueCommandCommon<TObj,CommandQueue<TQRes>>)
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override := q.Invoke(g, l.WithPtrNeed(false)).ev;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override :=
+    q.Invoke(g, l.WithPtrNeed(false)).ThenInvokeIfFuncRes(g,false).ev;
     
   end;
   
@@ -8998,6 +10637,8 @@ static function BasicGPUCommand<T>.MakeQueue(q: CommandQueueBase) := q.ConvertTy
 
 {$region Proc}
 
+{$region Base}
+
 type
   ProcCommandBase<T, TProc> = abstract class(BasicGPUCommand<T>)
   where TProc: Delegate;
@@ -9008,6 +10649,23 @@ type
     
     protected procedure ExecProc(o: T; c: Context); abstract;
     
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
+    begin
+      sb += ': ';
+      ToStringWriteDelegate(sb, p);
+      sb += #10;
+    end;
+    
+  end;
+  
+{$endregion Base}
+
+type
+  BackgroundProcCommandBase<T, TProc> = abstract class(ProcCommandBase<T, TProc>)
+  where TProc: Delegate;
+    
     protected function InvokeObj(o: T; g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override :=
     UserEvent.StartBackgroundWork(l.prev_ev, ()->ExecProc(o, g.c), g
       {$ifdef EventDebug}, $'const body of {self.GetType}'{$endif}
@@ -9021,30 +10679,88 @@ type
       );
     end;
     
-    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
-    
-    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override;
-    begin
-      sb += ': ';
-      ToStringWriteDelegate(sb, p);
-      sb += #10;
-    end;
-    
   end;
   
-  ProcCommand<T> = sealed class(ProcCommandBase<T, T->()>)
+  BackgroundProcCommand<T> = sealed class(BackgroundProcCommandBase<T, T->()>)
     
     protected procedure ExecProc(o: T; c: Context); override := p(o);
     
   end;
-  ProcCommandC<T> = sealed class(ProcCommandBase<T, (T,Context)->()>)
+  BackgroundProcCommandC<T> = sealed class(BackgroundProcCommandBase<T, (T,Context)->()>)
     
     protected procedure ExecProc(o: T; c: Context); override := p(o, c);
     
   end;
   
-static function BasicGPUCommand<T>.MakeProc(p: T->()) := new ProcCommand<T>(p);
-static function BasicGPUCommand<T>.MakeProc(p: (T,Context)->()) := new ProcCommandC<T>(p);
+static function BasicGPUCommand<T>.MakeBackgroundProc(p: T->()) := new BackgroundProcCommand<T>(p);
+static function BasicGPUCommand<T>.MakeBackgroundProc(p: (T,Context)->()) := new BackgroundProcCommandC<T>(p);
+
+type
+  QuickProcCommandBase<T, TProc> = abstract class(ProcCommandBase<T, TProc>)
+  where TProc: Delegate;
+    
+    protected function InvokeObj(o: T; g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override;
+    begin
+      var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for {self.GetType}'{$endif});
+      
+      var c := g.c;
+      var err_handler := g.curr_err_handler;
+      l.prev_ev.MultiAttachCallback(false, ()->
+      begin
+        if not err_handler.HadError(true) then
+        try
+          ExecProc(o, c);
+        except
+          on e: Exception do err_handler.AddErr(e);
+        end;
+        res_ev.SetComplete;
+      end{$ifdef EventDebug}, $'const body of {self.GetType}'{$endif});
+      
+      Result := res_ev;
+    end;
+    
+    protected function InvokeQueue(o_invoke: GPUCommandObjInvoker<T>; g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override;
+    begin
+      var prev_qr := o_invoke(g, l);
+      {$ifdef DEBUG}
+      // prev_qr.GetRes could be called >1 time
+      // But o_invoke wouldn't return QueueResFunc,
+      // because multiusable uses .ThenInvokeIfDelegateRes
+      if prev_qr is QueueResFunc<T> then raise new System.NotSupportedException;
+      {$endif DEBUG}
+      var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev for {self.GetType}'{$endif});
+      
+      var c := g.c;
+      var err_handler := g.curr_err_handler;
+      prev_qr.ev.MultiAttachCallback(false, ()->
+      begin
+        if not err_handler.HadError(true) then
+        try
+          ExecProc(prev_qr.GetRes, c);
+        except
+          on e: Exception do err_handler.AddErr(e);
+        end;
+        res_ev.SetComplete;
+      end{$ifdef EventDebug}, $'queue body of {self.GetType}'{$endif});
+      
+      Result := res_ev;
+    end;
+    
+  end;
+  
+  QuickProcCommand<T> = sealed class(QuickProcCommandBase<T, T->()>)
+    
+    protected procedure ExecProc(o: T; c: Context); override := p(o);
+    
+  end;
+  QuickProcCommandC<T> = sealed class(QuickProcCommandBase<T, (T,Context)->()>)
+    
+    protected procedure ExecProc(o: T; c: Context); override := p(o, c);
+    
+  end;
+  
+static function BasicGPUCommand<T>.MakeQuickProc(p: T->()) := new QuickProcCommand<T>(p);
+static function BasicGPUCommand<T>.MakeQuickProc(p: (T,Context)->()) := new QuickProcCommandC<T>(p);
 
 {$endregion Proc}
 
@@ -9240,8 +10956,10 @@ begin
   if comm<>nil then commands.Add(comm);
 end;
 
-function KernelCCQ.AddProc(p: Kernel->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeProc(p));
-function KernelCCQ.AddProc(p: (Kernel, Context)->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeProc(p));
+function KernelCCQ.AddProc(p: Kernel->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeBackgroundProc(p));
+function KernelCCQ.AddProc(p: (Kernel, Context)->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeBackgroundProc(p));
+function KernelCCQ.AddQuickProc(p: Kernel->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeQuickProc(p));
+function KernelCCQ.AddQuickProc(p: (Kernel, Context)->()) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeQuickProc(p));
 
 function KernelCCQ.AddWait(marker: WaitMarker) := AddCommand(self, BasicGPUCommand&<Kernel>.MakeWait(marker));
 
@@ -9271,8 +10989,10 @@ begin
   if comm<>nil then commands.Add(comm);
 end;
 
-function MemorySegmentCCQ.AddProc(p: MemorySegment->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeProc(p));
-function MemorySegmentCCQ.AddProc(p: (MemorySegment, Context)->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeProc(p));
+function MemorySegmentCCQ.AddProc(p: MemorySegment->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeBackgroundProc(p));
+function MemorySegmentCCQ.AddProc(p: (MemorySegment, Context)->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeBackgroundProc(p));
+function MemorySegmentCCQ.AddQuickProc(p: MemorySegment->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeQuickProc(p));
+function MemorySegmentCCQ.AddQuickProc(p: (MemorySegment, Context)->()) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeQuickProc(p));
 
 function MemorySegmentCCQ.AddWait(marker: WaitMarker) := AddCommand(self, BasicGPUCommand&<MemorySegment>.MakeWait(marker));
 
@@ -9304,8 +11024,10 @@ begin
   if comm<>nil then commands.Add(comm);
 end;
 
-function CLArrayCCQ<T>.AddProc(p: CLArray<T>->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeProc(p));
-function CLArrayCCQ<T>.AddProc(p: (CLArray<T>, Context)->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeProc(p));
+function CLArrayCCQ<T>.AddProc(p: CLArray<T>->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeBackgroundProc(p));
+function CLArrayCCQ<T>.AddProc(p: (CLArray<T>, Context)->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeBackgroundProc(p));
+function CLArrayCCQ<T>.AddQuickProc(p: CLArray<T>->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeQuickProc(p));
+function CLArrayCCQ<T>.AddQuickProc(p: (CLArray<T>, Context)->()) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeQuickProc(p));
 
 function CLArrayCCQ<T>.AddWait(marker: WaitMarker) := AddCommand(self, BasicGPUCommand&<CLArray<T>>.MakeWait(marker));
 
@@ -9531,7 +11253,7 @@ type
       
       var inv_data: EnqueueableGetCommandInvData<TObj, TRes>;
       inv_data.prev_qr  := prev_qr;
-      inv_data.res_qr   := QueueResDelayedBase&<TRes>.MakeNew(l.need_ptr_qr or ForcePtrQr);
+      inv_data.res_qr   := QueueResDelayedBase&<TRes>.MakeNewDelayedOrPtr(l.need_ptr_qr or ForcePtrQr);
       
       Result := inv_data.res_qr;
       Result.ev := EnqueueableCore.Invoke(self, inv_data, g, prev_qr.ev, not (prev_qr is IQueueResConst));
@@ -16936,6 +18658,8 @@ end;
 
 {$region HFQ/HPQ}
 
+{$region Common}
+
 type
   CommandQueueHostCommon<TDelegate> = record
   where TDelegate: Delegate;
@@ -16950,9 +18674,14 @@ type
     
   end;
   
-  {$region Func}
-  
-  CommandQueueHostFuncBase<T, TFunc> = abstract class(CommandQueue<T>)
+{$endregion Common}
+
+{$region Backgound}
+
+{$region Func}
+
+type
+  CommandQueueHostBackgoundFuncBase<T, TFunc> = abstract class(CommandQueue<T>)
   where TFunc: Delegate;
     private data: CommandQueueHostCommon<TFunc>;
     
@@ -16965,7 +18694,7 @@ type
     begin
       var c := g.c;
       
-      var qr := QueueResDelayedBase&<T>.MakeNew(l.need_ptr_qr);
+      var qr := QueueRes&<T>.MakeNewDelayedOrPtr(l.need_ptr_qr);
       qr.ev := UserEvent.StartBackgroundWork(l.prev_ev, ()->qr.SetRes( ExecFunc(c) ), g
         {$ifdef EventDebug}, $'body of {self.GetType}'{$endif}
       );
@@ -16979,22 +18708,28 @@ type
     
   end;
   
-  CommandQueueHostFunc<T> = sealed class(CommandQueueHostFuncBase<T, ()->T>)
+  CommandQueueHostBackgoundFunc<T> = sealed class(CommandQueueHostBackgoundFuncBase<T, ()->T>)
     
     protected function ExecFunc(c: Context): T; override := data.d();
     
   end;
-  CommandQueueHostFuncC<T> = sealed class(CommandQueueHostFuncBase<T, Context->T>)
+  CommandQueueHostBackgoundFuncC<T> = sealed class(CommandQueueHostBackgoundFuncBase<T, Context->T>)
     
     protected function ExecFunc(c: Context): T; override := data.d(c);
     
   end;
   
-  {$endregion Func}
-  
-  {$region Proc}
-  
-  CommandQueueHostProcBase<TProc> = abstract class(CommandQueueNil)
+function HFQ<T>(f: ()->T) :=
+new CommandQueueHostBackgoundFunc<T>(f);
+function HFQ<T>(f: Context->T) :=
+new CommandQueueHostBackgoundFuncC<T>(f);
+
+{$endregion Func}
+
+{$region Proc}
+
+type
+  CommandQueueHostBackgoundProcBase<TProc> = abstract class(CommandQueueNil)
   where TProc: Delegate;
     private data: CommandQueueHostCommon<TProc>;
     
@@ -17003,14 +18738,15 @@ type
     
     protected procedure ExecProc(c: Context); abstract;
     
-    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): EventList; override;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override;
     begin
       var c := g.c;
       
-      Result :=  UserEvent.StartBackgroundWork(l.prev_ev, ()->ExecProc(c), g
+      var res_ev :=  UserEvent.StartBackgroundWork(l.prev_ev, ()->ExecProc(c), g
         {$ifdef EventDebug}, $'body of {self.GetType}'{$endif}
       );
       
+      Result := new QueueResConstNil(res_ev);
     end;
     
     protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
@@ -17019,28 +18755,144 @@ type
     
   end;
   
-  CommandQueueHostProc = sealed class(CommandQueueHostProcBase<()->()>)
+  CommandQueueHostBackgoundProc = sealed class(CommandQueueHostBackgoundProcBase<()->()>)
     
     protected procedure ExecProc(c: Context); override := data.d();
     
   end;
-  CommandQueueHostProcC = sealed class(CommandQueueHostProcBase<Context->()>)
+  CommandQueueHostBackgoundProcC = sealed class(CommandQueueHostBackgoundProcBase<Context->()>)
     
     protected procedure ExecProc(c: Context); override := data.d(c);
     
   end;
   
-  {$endregion Proc}
-  
-function HFQ<T>(f: ()->T) :=
-new CommandQueueHostFunc<T>(f);
-function HFQ<T>(f: Context->T) :=
-new CommandQueueHostFuncC<T>(f);
-
 function HPQ(p: ()->()) :=
-new CommandQueueHostProc(p);
+new CommandQueueHostBackgoundProc(p);
 function HPQ(p: Context->()) :=
-new CommandQueueHostProcC(p);
+new CommandQueueHostBackgoundProcC(p);
+
+{$endregion Proc}
+
+{$endregion Backgound}
+
+{$region Quick}
+
+{$region Func}
+
+type
+  CommandQueueHostQuickFuncBase<T, TFunc> = abstract class(CommandQueue<T>)
+  where TFunc: Delegate;
+    private data: CommandQueueHostCommon<TFunc>;
+    
+    public constructor(f: TFunc) := data.d := f;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected function ExecFunc(c: Context): T; abstract;
+    
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalData): QueueRes<T>; override;
+    begin
+      if l.prev_ev.count=0 then
+        Result := new QueueResConst<T>(ExecFunc(g.c), EventList.Empty) else
+      if l.need_ptr_qr then
+      begin
+        var c := g.c;
+        var res := new QueueResDelayedPtr<T>;
+        var res_ev := new UserEvent(g.cl_c{$ifdef EventDebug}, $'res_ev of {self.GetType}'{$endif});
+        var err_handler := g.curr_err_handler;
+        l.prev_ev.MultiAttachCallback(false, ()->
+        begin
+          if not err_handler.HadError(true) then
+          try
+            res.SetRes(ExecFunc(c));
+          except
+            on e: Exception do err_handler.AddErr(e);
+          end;
+          res_ev.SetComplete;
+        end{$ifdef EventDebug}, $'body of {self.GetType}'{$endif});
+        res.ev := res_ev;
+        Result := res;
+      end else
+      begin
+        var c := g.c;
+        Result := new QueueResFunc<T>(()->ExecFunc(c), l.prev_ev);
+      end;
+    end;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override := data.ToString(sb);
+    
+  end;
+  
+  CommandQueueHostQuickFunc<T> = sealed class(CommandQueueHostQuickFuncBase<T, ()->T>)
+    
+    protected function ExecFunc(c: Context): T; override := data.d();
+    
+  end;
+  CommandQueueHostQuickFuncC<T> = sealed class(CommandQueueHostQuickFuncBase<T, Context->T>)
+    
+    protected function ExecFunc(c: Context): T; override := data.d(c);
+    
+  end;
+  
+function HFQQ<T>(f: ()->T) :=
+new CommandQueueHostQuickFunc<T>(f);
+function HFQQ<T>(f: Context->T) :=
+new CommandQueueHostQuickFuncC<T>(f);
+
+{$endregion Func}
+
+{$region Proc}
+
+type
+  CommandQueueHostQuickProcBase<TProc> = abstract class(CommandQueueNil)
+  where TProc: Delegate;
+    private data: CommandQueueHostCommon<TProc>;
+    
+    public constructor(p: TProc) := data.d := p;
+    private constructor := raise new OpenCLABCInternalException;
+    
+    protected procedure ExecProc(c: Context); abstract;
+    
+    private procedure InvokeProc(err_handler: CLTaskErrHandler; c: Context) :=
+    if not err_handler.HadError(true) then
+    try
+      ExecProc(c);
+    except
+      on e: Exception do err_handler.AddErr(e);
+    end;
+    protected function Invoke(g: CLTaskGlobalData; l: CLTaskLocalDataNil): QueueResNil; override;
+    begin
+      var c := g.c;
+      var err_handler := g.curr_err_handler;
+      Result := new QueueResProcNil(()->self.InvokeProc(err_handler, c), l.prev_ev); 
+    end;
+    
+    protected procedure RegisterWaitables(g: CLTaskGlobalData; prev_hubs: HashSet<IMultiusableCommandQueueHub>); override := exit;
+    
+    private procedure ToStringImpl(sb: StringBuilder; tabs: integer; index: Dictionary<object,integer>; delayed: HashSet<CommandQueueBase>); override := data.ToString(sb);
+    
+  end;
+  
+  CommandQueueHostQuickProc = sealed class(CommandQueueHostQuickProcBase<()->()>)
+    
+    protected procedure ExecProc(c: Context); override := data.d();
+    
+  end;
+  CommandQueueHostQuickProcC = sealed class(CommandQueueHostQuickProcBase<Context->()>)
+    
+    protected procedure ExecProc(c: Context); override := data.d(c);
+    
+  end;
+  
+function HPQQ(p: ()->()) :=
+new CommandQueueHostQuickProc(p);
+function HPQQ(p: Context->()) :=
+new CommandQueueHostQuickProcC(p);
+
+{$endregion Proc}
+
+{$endregion Quick}
 
 {$endregion HFQ/HPQ}
 
@@ -17069,29 +18921,49 @@ function CombineSyncQueue<T>(qs: sequence of CommandQueueBase; last: CommandQueu
 
 {$region NonContext}
 
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new ConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new ConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new BackgroundConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new BackgroundConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
 
-function CombineSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new ConvSyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
-function CombineSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new ConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
-function CombineSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new ConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
-function CombineSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new ConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
-function CombineSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new ConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
-function CombineSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new ConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+function CombineConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new BackgroundConvSyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new BackgroundConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new BackgroundConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new BackgroundConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new BackgroundConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new BackgroundConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new QuickConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new QuickConvSyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+
+function CombineQuickConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new QuickConvSyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineQuickConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new QuickConvSyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineQuickConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new QuickConvSyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineQuickConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new QuickConvSyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineQuickConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new QuickConvSyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineQuickConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new QuickConvSyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
 
 {$endregion NonContext}
 
 {$region Context}
 
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new ConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
-function CombineSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new ConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new BackgroundConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new BackgroundConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
 
-function CombineSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new ConvSyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
-function CombineSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new ConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
-function CombineSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new ConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
-function CombineSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new ConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
-function CombineSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new ConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
-function CombineSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new ConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+function CombineConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new BackgroundConvSyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new BackgroundConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new BackgroundConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new BackgroundConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new BackgroundConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new BackgroundConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new QuickConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineQuickConvSyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new QuickConvSyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+
+function CombineQuickConvSyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new QuickConvSyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineQuickConvSyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new QuickConvSyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineQuickConvSyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new QuickConvSyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineQuickConvSyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new QuickConvSyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineQuickConvSyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new QuickConvSyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineQuickConvSyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new QuickConvSyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
 
 {$endregion Context}
 
@@ -17122,29 +18994,49 @@ function CombineAsyncQueue<T>(qs: sequence of CommandQueueBase; last: CommandQue
 
 {$region NonContext}
 
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new ConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new ConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new BackgroundConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new BackgroundConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
 
-function CombineAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new ConvAsyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
-function CombineAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new ConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
-function CombineAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new ConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
-function CombineAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new ConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
-function CombineAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new ConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
-function CombineAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new ConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+function CombineConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new BackgroundConvAsyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new BackgroundConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new BackgroundConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new BackgroundConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new BackgroundConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new BackgroundConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; params qs: array of CommandQueue<TInp>) := new QuickConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, TRes>; qs: sequence of CommandQueue<TInp>) := new QuickConvAsyncQueueArray<TInp, TRes>(qs.ToArray, conv);
+
+function CombineQuickConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new QuickConvAsyncQueueArray2<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineQuickConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new QuickConvAsyncQueueArray3<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineQuickConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new QuickConvAsyncQueueArray4<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineQuickConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new QuickConvAsyncQueueArray5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineQuickConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new QuickConvAsyncQueueArray6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineQuickConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new QuickConvAsyncQueueArray7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
 
 {$endregion NonContext}
 
 {$region Context}
 
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new ConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
-function CombineAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new ConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new BackgroundConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new BackgroundConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
 
-function CombineAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new ConvAsyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
-function CombineAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new ConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
-function CombineAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new ConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
-function CombineAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new ConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
-function CombineAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new ConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
-function CombineAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new ConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+function CombineConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new BackgroundConvAsyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new BackgroundConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new BackgroundConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new BackgroundConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new BackgroundConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new BackgroundConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
+
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; params qs: array of CommandQueue<TInp>) := new QuickConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+function CombineQuickConvAsyncQueue<TInp, TRes>(conv: Func<array of TInp, Context, TRes>; qs: sequence of CommandQueue<TInp>) := new QuickConvAsyncQueueArrayC<TInp, TRes>(qs.ToArray, conv);
+
+function CombineQuickConvAsyncQueueN2<TInp1, TInp2, TRes>(conv: Func<TInp1, TInp2, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>) := new QuickConvAsyncQueueArray2C<TInp1, TInp2, TRes>(q1, q2, conv);
+function CombineQuickConvAsyncQueueN3<TInp1, TInp2, TInp3, TRes>(conv: Func<TInp1, TInp2, TInp3, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>) := new QuickConvAsyncQueueArray3C<TInp1, TInp2, TInp3, TRes>(q1, q2, q3, conv);
+function CombineQuickConvAsyncQueueN4<TInp1, TInp2, TInp3, TInp4, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>) := new QuickConvAsyncQueueArray4C<TInp1, TInp2, TInp3, TInp4, TRes>(q1, q2, q3, q4, conv);
+function CombineQuickConvAsyncQueueN5<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>) := new QuickConvAsyncQueueArray5C<TInp1, TInp2, TInp3, TInp4, TInp5, TRes>(q1, q2, q3, q4, q5, conv);
+function CombineQuickConvAsyncQueueN6<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>) := new QuickConvAsyncQueueArray6C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TRes>(q1, q2, q3, q4, q5, q6, conv);
+function CombineQuickConvAsyncQueueN7<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(conv: Func<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, Context, TRes>; q1: CommandQueue<TInp1>; q2: CommandQueue<TInp2>; q3: CommandQueue<TInp3>; q4: CommandQueue<TInp4>; q5: CommandQueue<TInp5>; q6: CommandQueue<TInp6>; q7: CommandQueue<TInp7>) := new QuickConvAsyncQueueArray7C<TInp1, TInp2, TInp3, TInp4, TInp5, TInp6, TInp7, TRes>(q1, q2, q3, q4, q5, q6, q7, conv);
 
 {$endregion Context}
 
diff --git a/bin/Lib/OpenGL.pas b/bin/Lib/OpenGL.pas
index ac47eb911..cfaef00a2 100644
--- a/bin/Lib/OpenGL.pas
+++ b/bin/Lib/OpenGL.pas
@@ -1,12 +1,12 @@
 
 //*****************************************************************************************************\\
-// Copyright (©) Cergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
+// Copyright (©) Sergey Latchenko ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
 // This code is distributed under the Unlicense
 // For details see LICENSE file or this:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
 // Copyright (©) Сергей Латченко ( github.com/SunSerega | forum.mmcs.sfedu.ru/u/sun_serega )
-// Этот код распространяется с лицензией Unlicense
+// Данный код распространяется с лицензией Unlicense
 // Подробнее в файле LICENSE или тут:
 // https://github.com/SunSerega/POCGL/blob/master/LICENSE
 //*****************************************************************************************************\\
@@ -1172,6 +1172,48 @@ type
     
   end;
   
+  BufferTarget = record
+    public val: UInt32;
+    public constructor(val: UInt32) := self.val := val;
+    
+    public static property PARAMETER_BUFFER:          BufferTarget read new BufferTarget($80EE);
+    public static property ARRAY_BUFFER:              BufferTarget read new BufferTarget($8892);
+    public static property ELEMENT_ARRAY_BUFFER:      BufferTarget read new BufferTarget($8893);
+    public static property PIXEL_PACK_BUFFER:         BufferTarget read new BufferTarget($88EB);
+    public static property PIXEL_UNPACK_BUFFER:       BufferTarget read new BufferTarget($88EC);
+    public static property UNIFORM_BUFFER:            BufferTarget read new BufferTarget($8A11);
+    public static property TEXTURE_BUFFER:            BufferTarget read new BufferTarget($8C2A);
+    public static property TRANSFORM_FEEDBACK_BUFFER: BufferTarget read new BufferTarget($8C8E);
+    public static property COPY_READ_BUFFER:          BufferTarget read new BufferTarget($8F36);
+    public static property COPY_WRITE_BUFFER:         BufferTarget read new BufferTarget($8F37);
+    public static property DRAW_INDIRECT_BUFFER:      BufferTarget read new BufferTarget($8F3F);
+    public static property SHADER_STORAGE_BUFFER:     BufferTarget read new BufferTarget($90D2);
+    public static property DISPATCH_INDIRECT_BUFFER:  BufferTarget read new BufferTarget($90EE);
+    public static property QUERY_BUFFER:              BufferTarget read new BufferTarget($9192);
+    public static property ATOMIC_COUNTER_BUFFER:     BufferTarget read new BufferTarget($92C0);
+    
+    public function ToString: string; override;
+    begin
+      if self.val = UInt32($80EE) then Result := 'PARAMETER_BUFFER' else
+      if self.val = UInt32($8892) then Result := 'ARRAY_BUFFER' else
+      if self.val = UInt32($8893) then Result := 'ELEMENT_ARRAY_BUFFER' else
+      if self.val = UInt32($88EB) then Result := 'PIXEL_PACK_BUFFER' else
+      if self.val = UInt32($88EC) then Result := 'PIXEL_UNPACK_BUFFER' else
+      if self.val = UInt32($8A11) then Result := 'UNIFORM_BUFFER' else
+      if self.val = UInt32($8C2A) then Result := 'TEXTURE_BUFFER' else
+      if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
+      if self.val = UInt32($8F36) then Result := 'COPY_READ_BUFFER' else
+      if self.val = UInt32($8F37) then Result := 'COPY_WRITE_BUFFER' else
+      if self.val = UInt32($8F3F) then Result := 'DRAW_INDIRECT_BUFFER' else
+      if self.val = UInt32($90D2) then Result := 'SHADER_STORAGE_BUFFER' else
+      if self.val = UInt32($90EE) then Result := 'DISPATCH_INDIRECT_BUFFER' else
+      if self.val = UInt32($9192) then Result := 'QUERY_BUFFER' else
+      if self.val = UInt32($92C0) then Result := 'ATOMIC_COUNTER_BUFFER' else
+        Result := $'BufferTarget[{self.val}]';
+    end;
+    
+  end;
+  
   ClearBufferMask = record
     public val: UInt32;
     public constructor(val: UInt32) := self.val := val;
@@ -9864,48 +9906,6 @@ type
     
   end;
   
-  BufferTargetARB = record
-    public val: UInt32;
-    public constructor(val: UInt32) := self.val := val;
-    
-    public static property PARAMETER_BUFFER:          BufferTargetARB read new BufferTargetARB($80EE);
-    public static property ARRAY_BUFFER:              BufferTargetARB read new BufferTargetARB($8892);
-    public static property ELEMENT_ARRAY_BUFFER:      BufferTargetARB read new BufferTargetARB($8893);
-    public static property PIXEL_PACK_BUFFER:         BufferTargetARB read new BufferTargetARB($88EB);
-    public static property PIXEL_UNPACK_BUFFER:       BufferTargetARB read new BufferTargetARB($88EC);
-    public static property UNIFORM_BUFFER:            BufferTargetARB read new BufferTargetARB($8A11);
-    public static property TEXTURE_BUFFER:            BufferTargetARB read new BufferTargetARB($8C2A);
-    public static property TRANSFORM_FEEDBACK_BUFFER: BufferTargetARB read new BufferTargetARB($8C8E);
-    public static property COPY_READ_BUFFER:          BufferTargetARB read new BufferTargetARB($8F36);
-    public static property COPY_WRITE_BUFFER:         BufferTargetARB read new BufferTargetARB($8F37);
-    public static property DRAW_INDIRECT_BUFFER:      BufferTargetARB read new BufferTargetARB($8F3F);
-    public static property SHADER_STORAGE_BUFFER:     BufferTargetARB read new BufferTargetARB($90D2);
-    public static property DISPATCH_INDIRECT_BUFFER:  BufferTargetARB read new BufferTargetARB($90EE);
-    public static property QUERY_BUFFER:              BufferTargetARB read new BufferTargetARB($9192);
-    public static property ATOMIC_COUNTER_BUFFER:     BufferTargetARB read new BufferTargetARB($92C0);
-    
-    public function ToString: string; override;
-    begin
-      if self.val = UInt32($80EE) then Result := 'PARAMETER_BUFFER' else
-      if self.val = UInt32($8892) then Result := 'ARRAY_BUFFER' else
-      if self.val = UInt32($8893) then Result := 'ELEMENT_ARRAY_BUFFER' else
-      if self.val = UInt32($88EB) then Result := 'PIXEL_PACK_BUFFER' else
-      if self.val = UInt32($88EC) then Result := 'PIXEL_UNPACK_BUFFER' else
-      if self.val = UInt32($8A11) then Result := 'UNIFORM_BUFFER' else
-      if self.val = UInt32($8C2A) then Result := 'TEXTURE_BUFFER' else
-      if self.val = UInt32($8C8E) then Result := 'TRANSFORM_FEEDBACK_BUFFER' else
-      if self.val = UInt32($8F36) then Result := 'COPY_READ_BUFFER' else
-      if self.val = UInt32($8F37) then Result := 'COPY_WRITE_BUFFER' else
-      if self.val = UInt32($8F3F) then Result := 'DRAW_INDIRECT_BUFFER' else
-      if self.val = UInt32($90D2) then Result := 'SHADER_STORAGE_BUFFER' else
-      if self.val = UInt32($90EE) then Result := 'DISPATCH_INDIRECT_BUFFER' else
-      if self.val = UInt32($9192) then Result := 'QUERY_BUFFER' else
-      if self.val = UInt32($92C0) then Result := 'ATOMIC_COUNTER_BUFFER' else
-        Result := $'BufferTargetARB[{self.val}]';
-    end;
-    
-  end;
-  
   BufferUsageARB = record
     public val: UInt32;
     public constructor(val: UInt32) := self.val := val;
@@ -23418,47 +23418,47 @@ type
     
     // added in gl1.5
     private z_BindBuffer_adr := GetFuncAdr('glBindBuffer');
-    private z_BindBuffer_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; buffer: gl_buffer)>(z_BindBuffer_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffer(target: BufferTargetARB; buffer: gl_buffer) :=
+    private z_BindBuffer_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; buffer: gl_buffer)>(z_BindBuffer_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffer(target: BufferTarget; buffer: gl_buffer) :=
     z_BindBuffer_ovr_0(target, buffer);
     
     // added in gl3.0
     private z_BindBufferBase_adr := GetFuncAdr('glBindBufferBase');
-    private z_BindBufferBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer)>(z_BindBufferBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTargetARB; index: UInt32; buffer: gl_buffer) :=
+    private z_BindBufferBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer)>(z_BindBufferBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTarget; index: UInt32; buffer: gl_buffer) :=
     z_BindBufferBase_ovr_0(target, index, buffer);
     
     // added in gl3.0
     private z_BindBufferRange_adr := GetFuncAdr('glBindBufferRange');
-    private z_BindBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    private z_BindBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
     z_BindBufferRange_ovr_0(target, index, buffer, offset, size);
     
     // added in gl4.4
     private z_BindBuffersBase_adr := GetFuncAdr('glBindBuffersBase');
-    private z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer)>(z_BindBuffersBase_adr);
-    private z_BindBuffersBase_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer) :=
+    private z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer)>(z_BindBuffersBase_adr);
+    private z_BindBuffersBase_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersBase_ovr_0(target, first, count, buffers[0]) else
       z_BindBuffersBase_ovr_0_anh00001(target, first, count, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer) :=
     z_BindBuffersBase_ovr_0(target, first, count, buffers);
-    private z_BindBuffersBase_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr) :=
+    private z_BindBuffersBase_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr) :=
     z_BindBuffersBase_ovr_2(target, first, count, buffers);
     
     // added in gl4.4
     private z_BindBuffersRange_adr := GetFuncAdr('glBindBuffersRange');
-    private z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000111 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000111 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         if (sizes<>nil) and (sizes.Length<>0) then
@@ -23474,10 +23474,10 @@ type
         if (sizes<>nil) and (sizes.Length<>0) then
           z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes[0]) else
           z_BindBuffersRange_ovr_0_anh0000111(target, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_1_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_1_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_1_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_1_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_1_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_1_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes) else
@@ -23485,11 +23485,11 @@ type
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
         z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets[0], sizes) else
@@ -23497,10 +23497,10 @@ type
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
         z_BindBuffersRange_ovr_2_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_3_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_3_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_3_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_3_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_3_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_3_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes[0]) else
@@ -23508,21 +23508,21 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
         z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_4_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_4_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_5_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_5_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes[0]) else
@@ -23530,21 +23530,21 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
         z_BindBuffersRange_ovr_6_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_7_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_7_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_8_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_8_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_8(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_8_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_9_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_9_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_9_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_9_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_9_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_9_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes[0]) else
@@ -23552,39 +23552,39 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
         z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_10_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_10_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_11_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_11_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_12_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_12_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer) :=
     z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_15_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_15_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer) :=
     z_BindBuffersRange_ovr_8(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_18 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_18 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes[0]) else
@@ -23592,36 +23592,36 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
         z_BindBuffersRange_ovr_18_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_19_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_19_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_20 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_20_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_20 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_20_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_20_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_21_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_21_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
     z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_24 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_24_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_24 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_24_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_24_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_26 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_26 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
     z_BindBuffersRange_ovr_26(target, first, count, buffers, offsets, sizes);
     
     // added in gl3.0
@@ -23993,8 +23993,8 @@ type
     
     // added in gl1.5
     private z_BufferData_adr := GetFuncAdr('glBufferData');
-    private z_BufferData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferData_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferData(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
+    private z_BufferData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferData_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferData(target: BufferTarget; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
     z_BufferData_ovr_0(target, size, data, usage);
     
     // added in gl4.4
@@ -24005,8 +24005,8 @@ type
     
     // added in gl1.5
     private z_BufferSubData_adr := GetFuncAdr('glBufferSubData');
-    private z_BufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubData_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubData(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
+    private z_BufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubData_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubData(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr) :=
     z_BufferSubData_ovr_0(target, offset, size, data);
     
     // added in gl3.0
@@ -24073,8 +24073,8 @@ type
     
     // added in gl4.3
     private z_ClearBufferSubData_adr := GetFuncAdr('glClearBufferSubData');
-    private z_ClearBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferSubData_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTargetARB; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
+    private z_ClearBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferSubData_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTarget; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
     z_ClearBufferSubData_ovr_0(target, internalformat, offset, size, format, &type, data);
     
     // added in gl3.0
@@ -24950,8 +24950,8 @@ type
     
     // added in gl3.0
     private z_FlushMappedBufferRange_adr := GetFuncAdr('glFlushMappedBufferRange');
-    private z_FlushMappedBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; length: IntPtr)>(z_FlushMappedBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr) :=
+    private z_FlushMappedBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; length: IntPtr)>(z_FlushMappedBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTarget; offset: IntPtr; length: IntPtr) :=
     z_FlushMappedBufferRange_ovr_0(target, offset, length);
     
     // added in gl4.5
@@ -25360,16 +25360,16 @@ type
     
     // added in gl3.0
     private z_GetBooleani_v_adr := GetFuncAdr('glGetBooleani_v');
-    private z_GetBooleani_v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleani_v_adr);
-    private z_GetBooleani_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
+    private z_GetBooleani_v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; var data: boolean)>(z_GetBooleani_v_adr);
+    private z_GetBooleani_v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTarget; index: UInt32; data: array of boolean) :=
     if (data<>nil) and (data.Length<>0) then
       z_GetBooleani_v_ovr_0(target, index, data[0]) else
       z_GetBooleani_v_ovr_0_anh0001(target, index, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; var data: boolean) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTarget; index: UInt32; var data: boolean) :=
     z_GetBooleani_v_ovr_0(target, index, data);
-    private z_GetBooleani_v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
+    private z_GetBooleani_v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleani_v_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleani_v(target: BufferTarget; index: UInt32; data: IntPtr) :=
     z_GetBooleani_v_ovr_2(target, index, data);
     
     // added in gl1.0
@@ -25384,45 +25384,45 @@ type
     
     // added in gl3.2
     private z_GetBufferParameteri64v_adr := GetFuncAdr('glGetBufferParameteri64v');
-    private z_GetBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int64)>(z_GetBufferParameteri64v_adr);
-    private z_GetBufferParameteri64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteri64v_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; &params: array of Int64) :=
+    private z_GetBufferParameteri64v_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; var &params: Int64)>(z_GetBufferParameteri64v_adr);
+    private z_GetBufferParameteri64v_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteri64v_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTarget; pname: BufferPNameARB; &params: array of Int64) :=
     if (&params<>nil) and (&params.Length<>0) then
       z_GetBufferParameteri64v_ovr_0(target, pname, &params[0]) else
       z_GetBufferParameteri64v_ovr_0_anh0001(target, pname, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int64) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTarget; pname: BufferPNameARB; var &params: Int64) :=
     z_GetBufferParameteri64v_ovr_0(target, pname, &params);
-    private z_GetBufferParameteri64v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteri64v_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr) :=
+    private z_GetBufferParameteri64v_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteri64v_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteri64v(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr) :=
     z_GetBufferParameteri64v_ovr_2(target, pname, &params);
     
     // added in gl1.5
     private z_GetBufferParameteriv_adr := GetFuncAdr('glGetBufferParameteriv');
-    private z_GetBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int32)>(z_GetBufferParameteriv_adr);
-    private z_GetBufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteriv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; &params: array of Int32) :=
+    private z_GetBufferParameteriv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; var &params: Int32)>(z_GetBufferParameteriv_adr);
+    private z_GetBufferParameteriv_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteriv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTarget; pname: BufferPNameARB; &params: array of Int32) :=
     if (&params<>nil) and (&params.Length<>0) then
       z_GetBufferParameteriv_ovr_0(target, pname, &params[0]) else
       z_GetBufferParameteriv_ovr_0_anh0001(target, pname, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int32) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTarget; pname: BufferPNameARB; var &params: Int32) :=
     z_GetBufferParameteriv_ovr_0(target, pname, &params);
-    private z_GetBufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteriv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr) :=
+    private z_GetBufferParameteriv_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameteriv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameteriv(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr) :=
     z_GetBufferParameteriv_ovr_2(target, pname, &params);
     
     // added in gl1.5
     private z_GetBufferPointerv_adr := GetFuncAdr('glGetBufferPointerv');
-    private z_GetBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; var &params: IntPtr)>(z_GetBufferPointerv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; var &params: IntPtr) :=
+    private z_GetBufferPointerv_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPointerNameARB; var &params: IntPtr)>(z_GetBufferPointerv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTarget; pname: BufferPointerNameARB; var &params: IntPtr) :=
     z_GetBufferPointerv_ovr_0(target, pname, &params);
-    private z_GetBufferPointerv_ovr_1 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; &params: pointer)>(z_GetBufferPointerv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTargetARB; pname: BufferPointerNameARB; &params: pointer) :=
+    private z_GetBufferPointerv_ovr_1 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPointerNameARB; &params: pointer)>(z_GetBufferPointerv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointerv(target: BufferTarget; pname: BufferPointerNameARB; &params: pointer) :=
     z_GetBufferPointerv_ovr_1(target, pname, &params);
     
     // added in gl1.5
     private z_GetBufferSubData_adr := GetFuncAdr('glGetBufferSubData');
-    private z_GetBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubData_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubData(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
+    private z_GetBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubData_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubData(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr) :=
     z_GetBufferSubData_ovr_0(target, offset, size, data);
     
     // added in gl1.3
@@ -25703,9 +25703,26 @@ type
     
     // added in gl4.5
     private z_GetNamedBufferSubData_adr := GetFuncAdr('glGetNamedBufferSubData');
-    private z_GetNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubData_adr);
+    private z_GetNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: Byte)>(z_GetNamedBufferSubData_adr);
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_GetNamedBufferSubData_ovr_0<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_GetNamedBufferSubData_ovr_0_anh00001(buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(nil)^);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: array of T); where T: record;
+    begin
+      if (data<>nil) and (data.Length<>0) then
+        temp_GetNamedBufferSubData_ovr_0(buffer, offset, size, data[0]) else
+        temp_GetNamedBufferSubData_ovr_0_anh00001(buffer, offset, size);
+    end;
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private z_GetNamedBufferSubData_ovr_2 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubData_adr);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr) :=
-    z_GetNamedBufferSubData_ovr_0(buffer, offset, size, data);
+    z_GetNamedBufferSubData_ovr_2(buffer, offset, size, data);
     
     // added in gl4.5
     private z_GetNamedFramebufferAttachmentParameteriv_adr := GetFuncAdr('glGetNamedFramebufferAttachmentParameteriv');
@@ -27230,14 +27247,14 @@ type
     
     // added in gl1.5
     private z_MapBuffer_adr := GetFuncAdr('glMapBuffer');
-    private z_MapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; access: BufferAccessARB): IntPtr>(z_MapBuffer_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBuffer(target: BufferTargetARB; access: BufferAccessARB): IntPtr :=
+    private z_MapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTarget; access: BufferAccessARB): IntPtr>(z_MapBuffer_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBuffer(target: BufferTarget; access: BufferAccessARB): IntPtr :=
     z_MapBuffer_ovr_0(target, access);
     
     // added in gl3.0
     private z_MapBufferRange_adr := GetFuncAdr('glMapBufferRange');
-    private z_MapBufferRange_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
+    private z_MapBufferRange_ovr_0 := GetFuncOrNil&<function(target: BufferTarget; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTarget; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
     z_MapBufferRange_ovr_0(target, offset, length, access);
     
     // added in gl4.5
@@ -27647,9 +27664,26 @@ type
     
     // added in gl4.5
     private z_NamedBufferSubData_adr := GetFuncAdr('glNamedBufferSubData');
-    private z_NamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubData_adr);
+    private z_NamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: Byte)>(z_NamedBufferSubData_adr);
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferSubData_ovr_0<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferSubData_ovr_0_anh00001(buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(nil)^);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: array of T); where T: record;
+    begin
+      if (data<>nil) and (data.Length<>0) then
+        temp_NamedBufferSubData_ovr_0(buffer, offset, size, data[0]) else
+        temp_NamedBufferSubData_ovr_0_anh00001(buffer, offset, size);
+    end;
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private z_NamedBufferSubData_ovr_2 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubData_adr);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr) :=
-    z_NamedBufferSubData_ovr_0(buffer, offset, size, data);
+    z_NamedBufferSubData_ovr_2(buffer, offset, size, data);
     
     // added in gl4.5
     private z_NamedFramebufferDrawBuffer_adr := GetFuncAdr('glNamedFramebufferDrawBuffer');
@@ -29318,9 +29352,12 @@ type
       z_Uniform1dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform1dv_ovr_0(location, count, value);
-    private z_Uniform1dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform1dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec1d)>(z_Uniform1dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: Vec1d) :=
     z_Uniform1dv_ovr_2(location, count, value);
+    private z_Uniform1dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform1dv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform1f_adr := GetFuncAdr('glUniform1f');
@@ -29338,9 +29375,12 @@ type
       z_Uniform1fv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; var value: single) :=
     z_Uniform1fv_ovr_0(location, count, value);
-    private z_Uniform1fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1fv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform1fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec1f)>(z_Uniform1fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; var value: Vec1f) :=
     z_Uniform1fv_ovr_2(location, count, value);
+    private z_Uniform1fv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1fv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform1fv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform1i_adr := GetFuncAdr('glUniform1i');
@@ -29358,9 +29398,12 @@ type
       z_Uniform1iv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; var value: Int32) :=
     z_Uniform1iv_ovr_0(location, count, value);
-    private z_Uniform1iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1iv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform1iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec1i)>(z_Uniform1iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; var value: Vec1i) :=
     z_Uniform1iv_ovr_2(location, count, value);
+    private z_Uniform1iv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1iv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform1iv_ovr_3(location, count, value);
     
     // added in gl3.0
     private z_Uniform1ui_adr := GetFuncAdr('glUniform1ui');
@@ -29378,9 +29421,12 @@ type
       z_Uniform1uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; var value: UInt32) :=
     z_Uniform1uiv_ovr_0(location, count, value);
-    private z_Uniform1uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1uiv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform1uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec1ui)>(z_Uniform1uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; var value: Vec1ui) :=
     z_Uniform1uiv_ovr_2(location, count, value);
+    private z_Uniform1uiv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1uiv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform1uiv_ovr_3(location, count, value);
     
     // added in gl4.0
     private z_Uniform2d_adr := GetFuncAdr('glUniform2d');
@@ -29398,9 +29444,12 @@ type
       z_Uniform2dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform2dv_ovr_0(location, count, value);
-    private z_Uniform2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec2d)>(z_Uniform2dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: Vec2d) :=
     z_Uniform2dv_ovr_2(location, count, value);
+    private z_Uniform2dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform2dv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform2f_adr := GetFuncAdr('glUniform2f');
@@ -29418,9 +29467,12 @@ type
       z_Uniform2fv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; var value: single) :=
     z_Uniform2fv_ovr_0(location, count, value);
-    private z_Uniform2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2fv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform2fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec2f)>(z_Uniform2fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; var value: Vec2f) :=
     z_Uniform2fv_ovr_2(location, count, value);
+    private z_Uniform2fv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2fv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform2fv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform2i_adr := GetFuncAdr('glUniform2i');
@@ -29438,9 +29490,12 @@ type
       z_Uniform2iv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; var value: Int32) :=
     z_Uniform2iv_ovr_0(location, count, value);
-    private z_Uniform2iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2iv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform2iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec2i)>(z_Uniform2iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; var value: Vec2i) :=
     z_Uniform2iv_ovr_2(location, count, value);
+    private z_Uniform2iv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2iv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform2iv_ovr_3(location, count, value);
     
     // added in gl3.0
     private z_Uniform2ui_adr := GetFuncAdr('glUniform2ui');
@@ -29458,9 +29513,12 @@ type
       z_Uniform2uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; var value: UInt32) :=
     z_Uniform2uiv_ovr_0(location, count, value);
-    private z_Uniform2uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2uiv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform2uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec2ui)>(z_Uniform2uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; var value: Vec2ui) :=
     z_Uniform2uiv_ovr_2(location, count, value);
+    private z_Uniform2uiv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2uiv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform2uiv_ovr_3(location, count, value);
     
     // added in gl4.0
     private z_Uniform3d_adr := GetFuncAdr('glUniform3d');
@@ -29478,9 +29536,12 @@ type
       z_Uniform3dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform3dv_ovr_0(location, count, value);
-    private z_Uniform3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec3d)>(z_Uniform3dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: Vec3d) :=
     z_Uniform3dv_ovr_2(location, count, value);
+    private z_Uniform3dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform3dv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform3f_adr := GetFuncAdr('glUniform3f');
@@ -29498,9 +29559,12 @@ type
       z_Uniform3fv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; var value: single) :=
     z_Uniform3fv_ovr_0(location, count, value);
-    private z_Uniform3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3fv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform3fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec3f)>(z_Uniform3fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; var value: Vec3f) :=
     z_Uniform3fv_ovr_2(location, count, value);
+    private z_Uniform3fv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3fv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform3fv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform3i_adr := GetFuncAdr('glUniform3i');
@@ -29518,9 +29582,12 @@ type
       z_Uniform3iv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; var value: Int32) :=
     z_Uniform3iv_ovr_0(location, count, value);
-    private z_Uniform3iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3iv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform3iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec3i)>(z_Uniform3iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; var value: Vec3i) :=
     z_Uniform3iv_ovr_2(location, count, value);
+    private z_Uniform3iv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3iv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform3iv_ovr_3(location, count, value);
     
     // added in gl3.0
     private z_Uniform3ui_adr := GetFuncAdr('glUniform3ui');
@@ -29538,9 +29605,12 @@ type
       z_Uniform3uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; var value: UInt32) :=
     z_Uniform3uiv_ovr_0(location, count, value);
-    private z_Uniform3uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3uiv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform3uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec3ui)>(z_Uniform3uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; var value: Vec3ui) :=
     z_Uniform3uiv_ovr_2(location, count, value);
+    private z_Uniform3uiv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3uiv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform3uiv_ovr_3(location, count, value);
     
     // added in gl4.0
     private z_Uniform4d_adr := GetFuncAdr('glUniform4d');
@@ -29558,9 +29628,12 @@ type
       z_Uniform4dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform4dv_ovr_0(location, count, value);
-    private z_Uniform4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec4d)>(z_Uniform4dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: Vec4d) :=
     z_Uniform4dv_ovr_2(location, count, value);
+    private z_Uniform4dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform4dv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform4f_adr := GetFuncAdr('glUniform4f');
@@ -29578,9 +29651,12 @@ type
       z_Uniform4fv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; var value: single) :=
     z_Uniform4fv_ovr_0(location, count, value);
-    private z_Uniform4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4fv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform4fv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec4f)>(z_Uniform4fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; var value: Vec4f) :=
     z_Uniform4fv_ovr_2(location, count, value);
+    private z_Uniform4fv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4fv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4fv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform4fv_ovr_3(location, count, value);
     
     // added in gl2.0
     private z_Uniform4i_adr := GetFuncAdr('glUniform4i');
@@ -29598,9 +29674,12 @@ type
       z_Uniform4iv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; var value: Int32) :=
     z_Uniform4iv_ovr_0(location, count, value);
-    private z_Uniform4iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4iv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform4iv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec4i)>(z_Uniform4iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; var value: Vec4i) :=
     z_Uniform4iv_ovr_2(location, count, value);
+    private z_Uniform4iv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4iv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4iv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform4iv_ovr_3(location, count, value);
     
     // added in gl3.0
     private z_Uniform4ui_adr := GetFuncAdr('glUniform4ui');
@@ -29618,9 +29697,12 @@ type
       z_Uniform4uiv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; var value: UInt32) :=
     z_Uniform4uiv_ovr_0(location, count, value);
-    private z_Uniform4uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4uiv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform4uiv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec4ui)>(z_Uniform4uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; var value: Vec4ui) :=
     z_Uniform4uiv_ovr_2(location, count, value);
+    private z_Uniform4uiv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4uiv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4uiv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform4uiv_ovr_3(location, count, value);
     
     // added in gl3.1
     private z_UniformBlockBinding_adr := GetFuncAdr('glUniformBlockBinding');
@@ -29896,8 +29978,8 @@ type
     
     // added in gl1.5
     private z_UnmapBuffer_adr := GetFuncAdr('glUnmapBuffer');
-    private z_UnmapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB): boolean>(z_UnmapBuffer_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBuffer(target: BufferTargetARB): boolean :=
+    private z_UnmapBuffer_ovr_0 := GetFuncOrNil&<function(target: BufferTarget): boolean>(z_UnmapBuffer_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBuffer(target: BufferTarget): boolean :=
     z_UnmapBuffer_ovr_0(target);
     
     // added in gl4.5
@@ -35552,8 +35634,8 @@ type
     z_BufferParameteriAPPLE_ovr_0(target, pname, param);
     
     private z_FlushMappedBufferRangeAPPLE_adr := GetFuncAdr('glFlushMappedBufferRangeAPPLE');
-    private z_FlushMappedBufferRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr)>(z_FlushMappedBufferRangeAPPLE_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRangeAPPLE(target: BufferTargetARB; offset: IntPtr; size: IntPtr) :=
+    private z_FlushMappedBufferRangeAPPLE_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; size: IntPtr)>(z_FlushMappedBufferRangeAPPLE_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRangeAPPLE(target: BufferTarget; offset: IntPtr; size: IntPtr) :=
     z_FlushMappedBufferRangeAPPLE_ovr_0(target, offset, size);
     
   end;
@@ -36166,8 +36248,8 @@ type
     z_ClearBufferData_ovr_0(target, internalformat, format, &type, data);
     
     private z_ClearBufferSubData_adr := GetFuncAdr('glClearBufferSubData');
-    private z_ClearBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferSubData_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTargetARB; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
+    private z_ClearBufferSubData_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr)>(z_ClearBufferSubData_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure ClearBufferSubData(target: BufferTarget; internalformat: SizedInternalFormat; offset: IntPtr; size: IntPtr; format: PixelFormat; &type: PixelType; data: IntPtr) :=
     z_ClearBufferSubData_ovr_0(target, internalformat, offset, size, format, &type, data);
     
   end;
@@ -36476,9 +36558,26 @@ type
     z_NamedBufferData_ovr_2(buffer, size, data, usage);
     
     private z_NamedBufferSubData_adr := GetFuncAdr('glNamedBufferSubData');
-    private z_NamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubData_adr);
+    private z_NamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: Byte)>(z_NamedBufferSubData_adr);
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferSubData_ovr_0<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_NamedBufferSubData_ovr_0_anh00001(buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(nil)^);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: array of T); where T: record;
+    begin
+      if (data<>nil) and (data.Length<>0) then
+        temp_NamedBufferSubData_ovr_0(buffer, offset, size, data[0]) else
+        temp_NamedBufferSubData_ovr_0_anh00001(buffer, offset, size);
+    end;
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_NamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private z_NamedBufferSubData_ovr_2 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_NamedBufferSubData_adr);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure NamedBufferSubData(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr) :=
-    z_NamedBufferSubData_ovr_0(buffer, offset, size, data);
+    z_NamedBufferSubData_ovr_2(buffer, offset, size, data);
     
     private z_CopyNamedBufferSubData_adr := GetFuncAdr('glCopyNamedBufferSubData');
     private z_CopyNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(readBuffer: gl_buffer; writeBuffer: gl_buffer; readOffset: IntPtr; writeOffset: IntPtr; size: IntPtr)>(z_CopyNamedBufferSubData_adr);
@@ -36550,9 +36649,26 @@ type
     z_GetNamedBufferPointerv_ovr_1(buffer, pname, &params);
     
     private z_GetNamedBufferSubData_adr := GetFuncAdr('glGetNamedBufferSubData');
-    private z_GetNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubData_adr);
+    private z_GetNamedBufferSubData_ovr_0 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: Byte)>(z_GetNamedBufferSubData_adr);
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_GetNamedBufferSubData_ovr_0<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure temp_GetNamedBufferSubData_ovr_0_anh00001(buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(nil)^);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: array of T); where T: record;
+    begin
+      if (data<>nil) and (data.Length<>0) then
+        temp_GetNamedBufferSubData_ovr_0(buffer, offset, size, data[0]) else
+        temp_GetNamedBufferSubData_ovr_0_anh00001(buffer, offset, size);
+    end;
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData<T>(buffer: gl_buffer; offset: IntPtr; size: IntPtr; var data: T); where T: record;
+    begin
+      z_GetNamedBufferSubData_ovr_0(buffer, offset, size, PByte(pointer(@data))^);
+    end;
+    private z_GetNamedBufferSubData_ovr_2 := GetFuncOrNil&<procedure(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetNamedBufferSubData_adr);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetNamedBufferSubData(buffer: gl_buffer; offset: IntPtr; size: IntPtr; data: IntPtr) :=
-    z_GetNamedBufferSubData_ovr_0(buffer, offset, size, data);
+    z_GetNamedBufferSubData_ovr_2(buffer, offset, size, data);
     
     private z_CreateFramebuffers_adr := GetFuncAdr('glCreateFramebuffers');
     private z_CreateFramebuffers_ovr_0 := GetFuncOrNil&<procedure(n: Int32; var framebuffers: gl_framebuffer)>(z_CreateFramebuffers_adr);
@@ -38313,9 +38429,12 @@ type
       z_Uniform1dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform1dv_ovr_0(location, count, value);
-    private z_Uniform1dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform1dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec1d)>(z_Uniform1dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; var value: Vec1d) :=
     z_Uniform1dv_ovr_2(location, count, value);
+    private z_Uniform1dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform1dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform1dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform1dv_ovr_3(location, count, value);
     
     private z_Uniform2dv_adr := GetFuncAdr('glUniform2dv');
     private z_Uniform2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform2dv_adr);
@@ -38326,9 +38445,12 @@ type
       z_Uniform2dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform2dv_ovr_0(location, count, value);
-    private z_Uniform2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform2dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec2d)>(z_Uniform2dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; var value: Vec2d) :=
     z_Uniform2dv_ovr_2(location, count, value);
+    private z_Uniform2dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform2dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform2dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform2dv_ovr_3(location, count, value);
     
     private z_Uniform3dv_adr := GetFuncAdr('glUniform3dv');
     private z_Uniform3dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform3dv_adr);
@@ -38339,9 +38461,12 @@ type
       z_Uniform3dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform3dv_ovr_0(location, count, value);
-    private z_Uniform3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform3dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec3d)>(z_Uniform3dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; var value: Vec3d) :=
     z_Uniform3dv_ovr_2(location, count, value);
+    private z_Uniform3dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform3dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform3dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform3dv_ovr_3(location, count, value);
     
     private z_Uniform4dv_adr := GetFuncAdr('glUniform4dv');
     private z_Uniform4dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: real)>(z_Uniform4dv_adr);
@@ -38352,9 +38477,12 @@ type
       z_Uniform4dv_ovr_0_anh0001(location, count, IntPtr.Zero);
     public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: real) :=
     z_Uniform4dv_ovr_0(location, count, value);
-    private z_Uniform4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
+    private z_Uniform4dv_ovr_2 := GetFuncOrNil&<procedure(location: Int32; count: Int32; var value: Vec4d)>(z_Uniform4dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; var value: Vec4d) :=
     z_Uniform4dv_ovr_2(location, count, value);
+    private z_Uniform4dv_ovr_3 := GetFuncOrNil&<procedure(location: Int32; count: Int32; value: IntPtr)>(z_Uniform4dv_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure Uniform4dv(location: Int32; count: Int32; value: IntPtr) :=
+    z_Uniform4dv_ovr_3(location, count, value);
     
     private z_UniformMatrix2dv_adr := GetFuncAdr('glUniformMatrix2dv');
     private z_UniformMatrix2dv_ovr_0 := GetFuncOrNil&<procedure(location: Int32; count: Int32; transpose: boolean; var value: real)>(z_UniformMatrix2dv_adr);
@@ -39284,13 +39412,13 @@ type
     public const _ExtStr = 'ARB_map_buffer_range';
     
     private z_MapBufferRange_adr := GetFuncAdr('glMapBufferRange');
-    private z_MapBufferRange_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
+    private z_MapBufferRange_ovr_0 := GetFuncOrNil&<function(target: BufferTarget; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr>(z_MapBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferRange(target: BufferTarget; offset: IntPtr; length: IntPtr; access: MapBufferAccessMask): IntPtr :=
     z_MapBufferRange_ovr_0(target, offset, length, access);
     
     private z_FlushMappedBufferRange_adr := GetFuncAdr('glFlushMappedBufferRange');
-    private z_FlushMappedBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; length: IntPtr)>(z_FlushMappedBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTargetARB; offset: IntPtr; length: IntPtr) :=
+    private z_FlushMappedBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; length: IntPtr)>(z_FlushMappedBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure FlushMappedBufferRange(target: BufferTarget; offset: IntPtr; length: IntPtr) :=
     z_FlushMappedBufferRange_ovr_0(target, offset, length);
     
   end;
@@ -39369,28 +39497,28 @@ type
     public const _ExtStr = 'ARB_multi_bind';
     
     private z_BindBuffersBase_adr := GetFuncAdr('glBindBuffersBase');
-    private z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer)>(z_BindBuffersBase_adr);
-    private z_BindBuffersBase_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer) :=
+    private z_BindBuffersBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer)>(z_BindBuffersBase_adr);
+    private z_BindBuffersBase_ovr_0_anh00001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersBase_ovr_0(target, first, count, buffers[0]) else
       z_BindBuffersBase_ovr_0_anh00001(target, first, count, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer) :=
     z_BindBuffersBase_ovr_0(target, first, count, buffers);
-    private z_BindBuffersBase_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr) :=
+    private z_BindBuffersBase_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr)>(z_BindBuffersBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersBase(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr) :=
     z_BindBuffersBase_ovr_2(target, first, count, buffers);
     
     private z_BindBuffersRange_adr := GetFuncAdr('glBindBuffersRange');
-    private z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_0_anh0000111 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_0_anh0000111 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         if (sizes<>nil) and (sizes.Length<>0) then
@@ -39406,10 +39534,10 @@ type
         if (sizes<>nil) and (sizes.Length<>0) then
           z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes[0]) else
           z_BindBuffersRange_ovr_0_anh0000111(target, first, count, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_1_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_1_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_1_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_1_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_1_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_1_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets[0], sizes) else
@@ -39417,11 +39545,11 @@ type
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
         z_BindBuffersRange_ovr_0_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_2_anh0000110 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_2_anh0000110 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets[0], sizes) else
@@ -39429,10 +39557,10 @@ type
       if (offsets<>nil) and (offsets.Length<>0) then
         z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets[0], sizes) else
         z_BindBuffersRange_ovr_2_anh0000110(target, first, count, IntPtr.Zero, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_3_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_3_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_3_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_3_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_3_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_3_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes[0]) else
@@ -39440,21 +39568,21 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
         z_BindBuffersRange_ovr_0_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_4_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_4_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_0_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_5_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_5_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; var offsets: IntPtr; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_2(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_2_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_6_anh0000101 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_6 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_6_anh0000101 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes[0]) else
@@ -39462,21 +39590,21 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes[0]) else
         z_BindBuffersRange_ovr_6_anh0000101(target, first, count, IntPtr.Zero, offsets, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_7_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_7_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; var sizes: IntPtr) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_6(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_6_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_8_anh0000100 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_8 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_8_anh0000100 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: array of gl_buffer; offsets: pointer; sizes: pointer) :=
     if (buffers<>nil) and (buffers.Length<>0) then
       z_BindBuffersRange_ovr_8(target, first, count, buffers[0], offsets, sizes) else
       z_BindBuffersRange_ovr_8_anh0000100(target, first, count, IntPtr.Zero, offsets, sizes);
-    private z_BindBuffersRange_ovr_9_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_9_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_9_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_9_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_9_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_9_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes[0]) else
@@ -39484,39 +39612,39 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
         z_BindBuffersRange_ovr_0_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_10_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_10_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_0_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_11_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_11_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: array of IntPtr; sizes: pointer) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_2_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_12_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_12_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_0_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_0(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; var offsets: IntPtr; sizes: pointer) :=
     z_BindBuffersRange_ovr_2(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_15_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_15_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_6_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_6(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; var buffers: gl_buffer; offsets: pointer; sizes: pointer) :=
     z_BindBuffersRange_ovr_8(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_18 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_18_anh0000011 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_18 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_18_anh0000011 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: array of IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes[0]) else
@@ -39524,36 +39652,36 @@ type
       if (sizes<>nil) and (sizes.Length<>0) then
         z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes[0]) else
         z_BindBuffersRange_ovr_18_anh0000011(target, first, count, buffers, IntPtr.Zero, IntPtr.Zero);
-    private z_BindBuffersRange_ovr_19_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
+    private z_BindBuffersRange_ovr_19_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; var sizes: IntPtr) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_18_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_20 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_20_anh0000010 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_20 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_20_anh0000010 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: IntPtr; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: array of IntPtr; sizes: pointer) :=
     if (offsets<>nil) and (offsets.Length<>0) then
       z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets[0], sizes) else
       z_BindBuffersRange_ovr_20_anh0000010(target, first, count, buffers, IntPtr.Zero, sizes);
-    private z_BindBuffersRange_ovr_21_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_21_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_18_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_18(target, first, count, buffers, offsets, sizes);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; var offsets: IntPtr; sizes: pointer) :=
     z_BindBuffersRange_ovr_20(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_24 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
-    private z_BindBuffersRange_ovr_24_anh0000001 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
+    private z_BindBuffersRange_ovr_24 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr)>(z_BindBuffersRange_adr);
+    private z_BindBuffersRange_ovr_24_anh0000001 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: IntPtr)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: array of IntPtr) :=
     if (sizes<>nil) and (sizes.Length<>0) then
       z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes[0]) else
       z_BindBuffersRange_ovr_24_anh0000001(target, first, count, buffers, offsets, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; var sizes: IntPtr) :=
     z_BindBuffersRange_ovr_24(target, first, count, buffers, offsets, sizes);
-    private z_BindBuffersRange_ovr_26 := GetFuncOrNil&<procedure(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTargetARB; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
+    private z_BindBuffersRange_ovr_26 := GetFuncOrNil&<procedure(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer)>(z_BindBuffersRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBuffersRange(target: BufferTarget; first: UInt32; count: Int32; buffers: IntPtr; offsets: pointer; sizes: pointer) :=
     z_BindBuffersRange_ovr_26(target, first, count, buffers, offsets, sizes);
     
     private z_BindTextures_adr := GetFuncAdr('glBindTextures');
@@ -43150,13 +43278,13 @@ type
     z_UniformBlockBinding_ovr_0(&program, uniformBlockIndex, uniformBlockBinding);
     
     private z_BindBufferRange_adr := GetFuncAdr('glBindBufferRange');
-    private z_BindBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRange_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    private z_BindBufferRange_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRange_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRange(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
     z_BindBufferRange_ovr_0(target, index, buffer, offset, size);
     
     private z_BindBufferBase_adr := GetFuncAdr('glBindBufferBase');
-    private z_BindBufferBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer)>(z_BindBufferBase_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTargetARB; index: UInt32; buffer: gl_buffer) :=
+    private z_BindBufferBase_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer)>(z_BindBufferBase_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBase(target: BufferTarget; index: UInt32; buffer: gl_buffer) :=
     z_BindBufferBase_ovr_0(target, index, buffer);
     
     private z_GetIntegeri_v_adr := GetFuncAdr('glGetIntegeri_v');
@@ -43503,8 +43631,8 @@ type
     public const _ExtStr = 'ARB_vertex_buffer_object';
     
     private z_BindBufferARB_adr := GetFuncAdr('glBindBufferARB');
-    private z_BindBufferARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; buffer: gl_buffer)>(z_BindBufferARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferARB(target: BufferTargetARB; buffer: gl_buffer) :=
+    private z_BindBufferARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; buffer: gl_buffer)>(z_BindBufferARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferARB(target: BufferTarget; buffer: gl_buffer) :=
     z_BindBufferARB_ovr_0(target, buffer);
     
     private z_DeleteBuffersARB_adr := GetFuncAdr('glDeleteBuffersARB');
@@ -43539,49 +43667,49 @@ type
     z_IsBufferARB_ovr_0(buffer);
     
     private z_BufferDataARB_adr := GetFuncAdr('glBufferDataARB');
-    private z_BufferDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferDataARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferDataARB(target: BufferTargetARB; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
+    private z_BufferDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; size: IntPtr; data: IntPtr; usage: BufferUsageARB)>(z_BufferDataARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferDataARB(target: BufferTarget; size: IntPtr; data: IntPtr; usage: BufferUsageARB) :=
     z_BufferDataARB_ovr_0(target, size, data, usage);
     
     private z_BufferSubDataARB_adr := GetFuncAdr('glBufferSubDataARB');
-    private z_BufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubDataARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
+    private z_BufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_BufferSubDataARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferSubDataARB(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr) :=
     z_BufferSubDataARB_ovr_0(target, offset, size, data);
     
     private z_GetBufferSubDataARB_adr := GetFuncAdr('glGetBufferSubDataARB');
-    private z_GetBufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubDataARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubDataARB(target: BufferTargetARB; offset: IntPtr; size: IntPtr; data: IntPtr) :=
+    private z_GetBufferSubDataARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr)>(z_GetBufferSubDataARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferSubDataARB(target: BufferTarget; offset: IntPtr; size: IntPtr; data: IntPtr) :=
     z_GetBufferSubDataARB_ovr_0(target, offset, size, data);
     
     private z_MapBufferARB_adr := GetFuncAdr('glMapBufferARB');
-    private z_MapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB; access: BufferAccessARB): IntPtr>(z_MapBufferARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferARB(target: BufferTargetARB; access: BufferAccessARB): IntPtr :=
+    private z_MapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTarget; access: BufferAccessARB): IntPtr>(z_MapBufferARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function MapBufferARB(target: BufferTarget; access: BufferAccessARB): IntPtr :=
     z_MapBufferARB_ovr_0(target, access);
     
     private z_UnmapBufferARB_adr := GetFuncAdr('glUnmapBufferARB');
-    private z_UnmapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTargetARB): boolean>(z_UnmapBufferARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBufferARB(target: BufferTargetARB): boolean :=
+    private z_UnmapBufferARB_ovr_0 := GetFuncOrNil&<function(target: BufferTarget): boolean>(z_UnmapBufferARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] function UnmapBufferARB(target: BufferTarget): boolean :=
     z_UnmapBufferARB_ovr_0(target);
     
     private z_GetBufferParameterivARB_adr := GetFuncAdr('glGetBufferParameterivARB');
-    private z_GetBufferParameterivARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int32)>(z_GetBufferParameterivARB_adr);
-    private z_GetBufferParameterivARB_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameterivARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; &params: array of Int32) :=
+    private z_GetBufferParameterivARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; var &params: Int32)>(z_GetBufferParameterivARB_adr);
+    private z_GetBufferParameterivARB_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameterivARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTarget; pname: BufferPNameARB; &params: array of Int32) :=
     if (&params<>nil) and (&params.Length<>0) then
       z_GetBufferParameterivARB_ovr_0(target, pname, &params[0]) else
       z_GetBufferParameterivARB_ovr_0_anh0001(target, pname, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; var &params: Int32) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTarget; pname: BufferPNameARB; var &params: Int32) :=
     z_GetBufferParameterivARB_ovr_0(target, pname, &params);
-    private z_GetBufferParameterivARB_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameterivARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTargetARB; pname: BufferPNameARB; &params: IntPtr) :=
+    private z_GetBufferParameterivARB_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr)>(z_GetBufferParameterivARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterivARB(target: BufferTarget; pname: BufferPNameARB; &params: IntPtr) :=
     z_GetBufferParameterivARB_ovr_2(target, pname, &params);
     
     private z_GetBufferPointervARB_adr := GetFuncAdr('glGetBufferPointervARB');
-    private z_GetBufferPointervARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; var &params: IntPtr)>(z_GetBufferPointervARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; var &params: IntPtr) :=
+    private z_GetBufferPointervARB_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPointerNameARB; var &params: IntPtr)>(z_GetBufferPointervARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTarget; pname: BufferPointerNameARB; var &params: IntPtr) :=
     z_GetBufferPointervARB_ovr_0(target, pname, &params);
-    private z_GetBufferPointervARB_ovr_1 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: BufferPointerNameARB; &params: pointer)>(z_GetBufferPointervARB_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTargetARB; pname: BufferPointerNameARB; &params: pointer) :=
+    private z_GetBufferPointervARB_ovr_1 := GetFuncOrNil&<procedure(target: BufferTarget; pname: BufferPointerNameARB; &params: pointer)>(z_GetBufferPointervARB_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferPointervARB(target: BufferTarget; pname: BufferPointerNameARB; &params: pointer) :=
     z_GetBufferPointervARB_ovr_1(target, pname, &params);
     
   end;
@@ -47361,16 +47489,16 @@ type
     z_GetIntegerIndexedvEXT_ovr_2(target, index, data);
     
     private z_GetBooleanIndexedvEXT_adr := GetFuncAdr('glGetBooleanIndexedvEXT');
-    private z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
-    private z_GetBooleanIndexedvEXT_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
+    private z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
+    private z_GetBooleanIndexedvEXT_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; data: array of boolean) :=
     if (data<>nil) and (data.Length<>0) then
       z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]) else
       z_GetBooleanIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; var data: boolean) :=
     z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
-    private z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
+    private z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; data: IntPtr) :=
     z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
     
     private z_CompressedTextureImage3DEXT_adr := GetFuncAdr('glCompressedTextureImage3DEXT');
@@ -48798,16 +48926,16 @@ type
     z_ColorMaskIndexedEXT_ovr_0(index, r, g, b, a);
     
     private z_GetBooleanIndexedvEXT_adr := GetFuncAdr('glGetBooleanIndexedvEXT');
-    private z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
-    private z_GetBooleanIndexedvEXT_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: array of boolean) :=
+    private z_GetBooleanIndexedvEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; var data: boolean)>(z_GetBooleanIndexedvEXT_adr);
+    private z_GetBooleanIndexedvEXT_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; data: array of boolean) :=
     if (data<>nil) and (data.Length<>0) then
       z_GetBooleanIndexedvEXT_ovr_0(target, index, data[0]) else
       z_GetBooleanIndexedvEXT_ovr_0_anh0001(target, index, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; var data: boolean) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; var data: boolean) :=
     z_GetBooleanIndexedvEXT_ovr_0(target, index, data);
-    private z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTargetARB; index: UInt32; data: IntPtr) :=
+    private z_GetBooleanIndexedvEXT_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; data: IntPtr)>(z_GetBooleanIndexedvEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBooleanIndexedvEXT(target: BufferTarget; index: UInt32; data: IntPtr) :=
     z_GetBooleanIndexedvEXT_ovr_2(target, index, data);
     
     private z_GetIntegerIndexedvEXT_adr := GetFuncAdr('glGetIntegerIndexedvEXT');
@@ -49796,8 +49924,8 @@ type
     z_TexStorageMem3DMultisampleEXT_ovr_0(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
     
     private z_BufferStorageMemEXT_adr := GetFuncAdr('glBufferStorageMemEXT');
-    private z_BufferStorageMemEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64)>(z_BufferStorageMemEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageMemEXT(target: BufferTargetARB; size: IntPtr; memory: UInt32; offset: UInt64) :=
+    private z_BufferStorageMemEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; size: IntPtr; memory: UInt32; offset: UInt64)>(z_BufferStorageMemEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferStorageMemEXT(target: BufferTarget; size: IntPtr; memory: UInt32; offset: UInt64) :=
     z_BufferStorageMemEXT_ovr_0(target, size, memory, offset);
     
     private z_TextureStorageMem2DEXT_adr := GetFuncAdr('glTextureStorageMem2DEXT');
@@ -51434,18 +51562,18 @@ type
     z_EndTransformFeedbackEXT_ovr_0;
     
     private z_BindBufferRangeEXT_adr := GetFuncAdr('glBindBufferRangeEXT');
-    private z_BindBufferRangeEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeEXT(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    private z_BindBufferRangeEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeEXT(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
     z_BindBufferRangeEXT_ovr_0(target, index, buffer, offset, size);
     
     private z_BindBufferOffsetEXT_adr := GetFuncAdr('glBindBufferOffsetEXT');
-    private z_BindBufferOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr)>(z_BindBufferOffsetEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetEXT(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr) :=
+    private z_BindBufferOffsetEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr)>(z_BindBufferOffsetEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetEXT(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr) :=
     z_BindBufferOffsetEXT_ovr_0(target, index, buffer, offset);
     
     private z_BindBufferBaseEXT_adr := GetFuncAdr('glBindBufferBaseEXT');
-    private z_BindBufferBaseEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer)>(z_BindBufferBaseEXT_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseEXT(target: BufferTargetARB; index: UInt32; buffer: gl_buffer) :=
+    private z_BindBufferBaseEXT_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer)>(z_BindBufferBaseEXT_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseEXT(target: BufferTarget; index: UInt32; buffer: gl_buffer) :=
     z_BindBufferBaseEXT_ovr_0(target, index, buffer);
     
     private z_TransformFeedbackVaryingsEXT_adr := GetFuncAdr('glTransformFeedbackVaryingsEXT');
@@ -59166,8 +59294,8 @@ type
     z_TexAttachMemoryNV_ovr_0(target, memory, offset);
     
     private z_BufferAttachMemoryNV_adr := GetFuncAdr('glBufferAttachMemoryNV');
-    private z_BufferAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; memory: UInt32; offset: UInt64)>(z_BufferAttachMemoryNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAttachMemoryNV(target: BufferTargetARB; memory: UInt32; offset: UInt64) :=
+    private z_BufferAttachMemoryNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; memory: UInt32; offset: UInt64)>(z_BufferAttachMemoryNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BufferAttachMemoryNV(target: BufferTarget; memory: UInt32; offset: UInt64) :=
     z_BufferAttachMemoryNV_ovr_0(target, memory, offset);
     
     private z_TextureAttachMemoryNV_adr := GetFuncAdr('glTextureAttachMemoryNV');
@@ -60839,16 +60967,16 @@ type
     z_IsNamedBufferResidentNV_ovr_0(buffer);
     
     private z_GetBufferParameterui64vNV_adr := GetFuncAdr('glGetBufferParameterui64vNV');
-    private z_GetBufferParameterui64vNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: DummyEnum; var &params: UInt64)>(z_GetBufferParameterui64vNV_adr);
-    private z_GetBufferParameterui64vNV_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: DummyEnum; &params: IntPtr)>(z_GetBufferParameterui64vNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; &params: array of UInt64) :=
+    private z_GetBufferParameterui64vNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; pname: DummyEnum; var &params: UInt64)>(z_GetBufferParameterui64vNV_adr);
+    private z_GetBufferParameterui64vNV_ovr_0_anh0001 := GetFuncOrNil&<procedure(target: BufferTarget; pname: DummyEnum; &params: IntPtr)>(z_GetBufferParameterui64vNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTarget; pname: DummyEnum; &params: array of UInt64) :=
     if (&params<>nil) and (&params.Length<>0) then
       z_GetBufferParameterui64vNV_ovr_0(target, pname, &params[0]) else
       z_GetBufferParameterui64vNV_ovr_0_anh0001(target, pname, IntPtr.Zero);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; var &params: UInt64) :=
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTarget; pname: DummyEnum; var &params: UInt64) :=
     z_GetBufferParameterui64vNV_ovr_0(target, pname, &params);
-    private z_GetBufferParameterui64vNV_ovr_2 := GetFuncOrNil&<procedure(target: BufferTargetARB; pname: DummyEnum; &params: IntPtr)>(z_GetBufferParameterui64vNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTargetARB; pname: DummyEnum; &params: IntPtr) :=
+    private z_GetBufferParameterui64vNV_ovr_2 := GetFuncOrNil&<procedure(target: BufferTarget; pname: DummyEnum; &params: IntPtr)>(z_GetBufferParameterui64vNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure GetBufferParameterui64vNV(target: BufferTarget; pname: DummyEnum; &params: IntPtr) :=
     z_GetBufferParameterui64vNV_ovr_2(target, pname, &params);
     
     private z_GetNamedBufferParameterui64vNV_adr := GetFuncAdr('glGetNamedBufferParameterui64vNV');
@@ -61099,18 +61227,18 @@ type
     z_TransformFeedbackAttribsNV_ovr_2(count, attribs, bufferMode);
     
     private z_BindBufferRangeNV_adr := GetFuncAdr('glBindBufferRangeNV');
-    private z_BindBufferRangeNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeNV(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
+    private z_BindBufferRangeNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr)>(z_BindBufferRangeNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferRangeNV(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr; size: IntPtr) :=
     z_BindBufferRangeNV_ovr_0(target, index, buffer, offset, size);
     
     private z_BindBufferOffsetNV_adr := GetFuncAdr('glBindBufferOffsetNV');
-    private z_BindBufferOffsetNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr)>(z_BindBufferOffsetNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetNV(target: BufferTargetARB; index: UInt32; buffer: gl_buffer; offset: IntPtr) :=
+    private z_BindBufferOffsetNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr)>(z_BindBufferOffsetNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferOffsetNV(target: BufferTarget; index: UInt32; buffer: gl_buffer; offset: IntPtr) :=
     z_BindBufferOffsetNV_ovr_0(target, index, buffer, offset);
     
     private z_BindBufferBaseNV_adr := GetFuncAdr('glBindBufferBaseNV');
-    private z_BindBufferBaseNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; index: UInt32; buffer: gl_buffer)>(z_BindBufferBaseNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseNV(target: BufferTargetARB; index: UInt32; buffer: gl_buffer) :=
+    private z_BindBufferBaseNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; index: UInt32; buffer: gl_buffer)>(z_BindBufferBaseNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindBufferBaseNV(target: BufferTarget; index: UInt32; buffer: gl_buffer) :=
     z_BindBufferBaseNV_ovr_0(target, index, buffer);
     
     private z_TransformFeedbackVaryingsNV_adr := GetFuncAdr('glTransformFeedbackVaryingsNV');
@@ -61248,8 +61376,8 @@ type
     public const _ExtStr = 'NV_transform_feedback2';
     
     private z_BindTransformFeedbackNV_adr := GetFuncAdr('glBindTransformFeedbackNV');
-    private z_BindTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTargetARB; id: gl_transform_feedback)>(z_BindTransformFeedbackNV_adr);
-    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedbackNV(target: BufferTargetARB; id: gl_transform_feedback) :=
+    private z_BindTransformFeedbackNV_ovr_0 := GetFuncOrNil&<procedure(target: BufferTarget; id: gl_transform_feedback)>(z_BindTransformFeedbackNV_adr);
+    public [MethodImpl(MethodImplOptions.AggressiveInlining)] procedure BindTransformFeedbackNV(target: BufferTarget; id: gl_transform_feedback) :=
     z_BindTransformFeedbackNV_ovr_0(target, id);
     
     private z_DeleteTransformFeedbacksNV_adr := GetFuncAdr('glDeleteTransformFeedbacksNV');