From b3547c90f134cdcfb692c539cd38ea31312d953a Mon Sep 17 00:00:00 2001 From: Roz K Date: Sun, 28 Aug 2022 04:23:13 +0200 Subject: [PATCH] Renderer and Python ctypes bindings. --- BUILDING | 1 + DEPENDENCIES | 6 + Makefile | 16 + __init__.py | 350 +++++++++++++ cpp/math.cpp | 53 ++ cpp/math.hpp | 54 ++ cpp/opengl/render_context.hpp | 38 ++ cpp/opengl/render_context_glx.cpp | 254 ++++++++++ cpp/opengl/render_opengles.cpp | 816 ++++++++++++++++++++++++++++++ cpp/opengl/render_opengles.hpp | 143 ++++++ cpp/render.cpp | 48 ++ cpp/render.hpp | 208 ++++++++ cpp/types.hpp | 36 ++ docs/batch.odg | Bin 0 -> 31649 bytes docs/batch.pdf | Bin 0 -> 31436 bytes docs/batch.png | Bin 0 -> 101617 bytes 16 files changed, 2023 insertions(+) create mode 100644 BUILDING create mode 100644 DEPENDENCIES create mode 100644 Makefile create mode 100644 __init__.py create mode 100644 cpp/math.cpp create mode 100644 cpp/math.hpp create mode 100644 cpp/opengl/render_context.hpp create mode 100644 cpp/opengl/render_context_glx.cpp create mode 100644 cpp/opengl/render_opengles.cpp create mode 100644 cpp/opengl/render_opengles.hpp create mode 100644 cpp/render.cpp create mode 100644 cpp/render.hpp create mode 100644 cpp/types.hpp create mode 100644 docs/batch.odg create mode 100644 docs/batch.pdf create mode 100644 docs/batch.png diff --git a/BUILDING b/BUILDING new file mode 100644 index 0000000..bee6666 --- /dev/null +++ b/BUILDING @@ -0,0 +1 @@ +make all diff --git a/DEPENDENCIES b/DEPENDENCIES new file mode 100644 index 0000000..674b64e --- /dev/null +++ b/DEPENDENCIES @@ -0,0 +1,6 @@ +C/C++ libraries (dev versions): + +- X11 +- GLX +- GLESv2 +- GLM diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..89e81ca --- /dev/null +++ b/Makefile @@ -0,0 +1,16 @@ +SOURCES = cpp/opengl/render_context_glx.cpp cpp/opengl/render_opengles.cpp cpp/math.cpp cpp/render.cpp +OUTPUTFILE = engine.so + +CXXFLAGS = -fpic -std=c++20 -Wall -Werror -O2 -flto -fomit-frame-pointer -ffast-math -funroll-loops -fno-rtti -fno-exceptions + +.PHONY: all +all: clean $(OUTPUTFILE) + find . -name "*.o" -type f -delete + +.PHONY: clean +clean: + rm -f $(OUTPUTFILE) + find . -name "*.o" -type f -delete + +$(OUTPUTFILE): $(subst .cpp,.o,$(SOURCES)) + $(CXX) -shared $(CXXFLAGS) -s -o $@ $^ -lGLESv2 -lGLX -lX11 diff --git a/__init__.py b/__init__.py new file mode 100644 index 0000000..8ef28dd --- /dev/null +++ b/__init__.py @@ -0,0 +1,350 @@ +# Copyright (C) 2022 RozK +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see . + +import ctypes +import struct +from array import array + +_lib = ctypes.cdll.LoadLibrary("./engine/engine.so") + +def _flag(x): + return 1 << x + +INPUT_IDENTITY = 0 +INPUT_VIEW_POSITION = 1 +INPUT_VIEW_ORIENTATION = 2 + +TEXTURE_FORMAT_SRGB8_A8 = 0 +TEXTURE_FORMAT_RGBA8 = 1 +TEXTURE_FORMAT_RGB10_A2 = 2 +TEXTURE_FORMAT_32F = 3 + +TEXTURE_FORMAT_TYPECODE = ('B', 'B', 'I', 'f') +TEXTURE_FORMAT_NELEMS = (4, 4, 1, 1) + +TEXTURE_FLAG_3D = _flag(0) +TEXTURE_FLAG_MIPMAPS = _flag(1) +TEXTURE_FLAG_MIN_NEAREST = 0 +TEXTURE_FLAG_MIN_LINEAR = _flag(2) +TEXTURE_FLAG_MAG_NEAREST = 0 +TEXTURE_FLAG_MAG_LINEAR = _flag(3) + +VERTEX_FORMAT_VEC2_FLOAT = 1 +VERTEX_FORMAT_VEC2_USHORT = 2 +VERTEX_FORMAT_VEC3_FLOAT = 3 +VERTEX_FORMAT_VEC3_INT10 = 4 + +def vertex_format(*format): + return array('B', format).tobytes() + +INSTANCE_FLAG_SPAWNED = _flag(0) +INSTANCE_FLAG_VISIBLE = _flag(1) + +BATCH_MAX_SIZE = 65536 + +BATCH_TRANSLATION_FORMAT_FLOAT = 0 +BATCH_TRANSLATION_FORMAT_SHORT = 1 + +BATCH_ORIENTATION_FORMAT_NONE = 0 +BATCH_ORIENTATION_FORMAT_FLOAT = 1 +BATCH_ORIENTATION_FORMAT_INT10 = 2 + +#TODO: remove from engine +vec2_zero = (0.0, 0.0) +vec3_zero = (0.0, 0.0, 0.0) +vec3_right = (1.0, 0.0, 0.0) +vec3_forward = (0.0, 1.0, 0.0) +vec3_up = (0.0, 0.0, 1.0) +vec4_zero = (0.0, 0.0, 0.0, 1.0) +mat3_identity = ( + 1.0, 0.0, 0.0, + 0.0, 1.0, 0.0, + 0.0, 0.0, 1.0) +mat4_identity = ( + 1.0, 0.0, 0.0, 0.0, + 0.0, 1.0, 0.0, 1.0, + 0.0, 0.0, 1.0, 0.0, + 0.0, 0.0, 0.0, 1.0) + +def vec2(v = vec2_zero): + assert len(v) == 2 + return array('f', v) + +def vec3(v = vec3_zero): + assert len(v) == 3 + return array('f', v) + +def vec4(v = vec4_zero): + assert len(v) == 4 + return array('f', v) + +def mat3(m = mat3_identity): + assert len(m) == 9 + return array('f', m) + +def mat4(m = mat4_identity): + assert len(m) == 16 + return array('f', m) + +_vec2_t = (ctypes.c_float * 2) +_vec2 = _vec2_t.from_buffer + +_vec3_t = (ctypes.c_float * 3) +_vec3 = _vec3_t.from_buffer + +_vec4_t = (ctypes.c_float * 4) +_vec4 = _vec4_t.from_buffer + +_mat3_t = (ctypes.c_float * 9) +_mat3 = _mat3_t.from_buffer + +_mat4_t = (ctypes.c_float * 16) +_mat4 = _mat4_t.from_buffer + +def _voidp(x): + return x.buffer_info()[0] + +def _ubytep(x): + assert x.typecode == 'B' + return x.buffer_info()[0] + +def _ushortp(x): + assert x.typecode == 'H' + return x.buffer_info()[0] + +def _uintp(x): + assert x.typecode == 'I' + return x.buffer_info()[0] + +def _floatp(x): + assert x.typecode == 'f' + return x.buffer_info()[0] + +_mat3_rotation = _lib.rk_mat3_rotation +_mat3_rotation.argtypes = ( + _mat3_t, # ret + _vec3_t, # axis + ctypes.c_float) # angle + +def mat3_rotation(ret, axis, angle): + assert len(ret) == 9 and len(axis) == 3 + _mat3_rotation(_mat3(ret), _vec3(axis), angle) + +_mat3_mul_vec3 = _lib.rk_mat3_mul_vec3 +_mat3_mul_vec3.argtypes = ( + _vec3_t, # ret + _mat3_t, # a + _vec3_t) # b + +def mat3_mul_vec3(ret, a, b): + assert len(ret) == 3 and len(a) == 9 and len(b) == 3 + _mat3_mul_vec3(_vec3(ret), _mat3(a), _vec3(b)) + +_mat3_mul_mat3 = _lib.rk_mat3_mul_mat3 +_mat3_mul_mat3.argtypes = ( + _mat3_t, # ret + _mat3_t, # a + _mat3_t) # b + +def mat3_mul_mat3(ret, a, b): + assert len(ret) == 9 and len(a) == 9 and len(b) == 9 + _mat3_mul_mat3(_mat3(ret), _mat3(a), _mat3(b)) + +_mat4_mul_vec4 = _lib.rk_mat4_mul_vec4 +_mat4_mul_vec4.argtypes = ( + _vec4_t, # ret + _mat4_t, # a + _vec4_t) # b + +def mat4_mul_vec4(ret, a, b): + assert len(ret) == 4 and len(a) == 16 and len(b) == 4 + _mat4_mul_vec4(_vec4(ret), _mat4(a), _vec4(b)) + +_mat4_mul_mat4 = _lib.rk_mat4_mul_mat4 +_mat4_mul_mat4.argtypes = ( + _mat4_t, # ret + _mat4_t, # a + _mat4_t) # b + +def mat4_mul_mat4(ret, a, b): + assert len(ret) == 16 and len(a) == 16 and len(b) == 16 + _mat4_mul_mat4(_mat4(ret), _mat4(a), _mat4(b)) + +initialize = _lib.rk_initialize +initialize.restype = ctypes.c_void_p +initialize.argtypes = ( + ctypes.c_char_p,) # name + +_load_shader = _lib.rk_load_shader +_load_shader.restype = ctypes.c_void_p +_load_shader.argtypes = ( + ctypes.c_char_p,) # name + +def load_shader(name): + print("Loading shader", str(name, 'utf-8')); + return _load_shader(name) + +select_shader = _lib.rk_select_shader +select_shader.argtypes = ( + ctypes.c_void_p,) # shader + +resolve_input = _lib.rk_resolve_input +resolve_input.restype = ctypes.c_void_p +resolve_input.argtypes = ( + ctypes.c_char_p,) # name + +set_input_float = _lib.rk_set_input_float +set_input_float.argtypes = ( + ctypes.c_void_p, # input + ctypes.c_float) # value + +_set_input_vec3 = _lib.rk_set_input_vec3 +_set_input_vec3.argtypes = ( + ctypes.c_void_p, # input + _vec3_t, # value + ctypes.c_uint) # mode + +def set_input_vec3(input, value, mode = INPUT_IDENTITY): + assert len(value) == 3 + _set_input_vec3(input, _vec3(value), mode) + +_create_texture = _lib.rk_create_texture +_create_texture.restype = ctypes.c_void_p +_create_texture.argtypes = ( + ctypes.c_uint, # slot + ctypes.c_char_p, # input + ctypes.c_uint, # format + ctypes.c_uint, # width + ctypes.c_uint, # height + ctypes.c_uint, # nlevels + ctypes.c_uint, # flags + ctypes.c_void_p) # pixels + +def create_texture(slot, input, format, width, height, nlevels, flags, pixels): + assert pixels.typecode == TEXTURE_FORMAT_TYPECODE[format] + assert len(pixels) == width * height * max(1, nlevels) * TEXTURE_FORMAT_NELEMS[format] + return _create_texture(slot, input, format, width, height, nlevels, flags, _voidp(pixels)) + +_create_triangles = _lib.rk_create_triangles +_create_triangles.restype = ctypes.c_void_p +_create_triangles.argtypes = ( + ctypes.c_uint, # nvertices + ctypes.c_void_p) # vertices + +def create_triangles(vertices): + assert len(vertices) % 9 == 0 + return _create_triangles(len(vertices) // 3, _floatp(vertices)) + +_create_vertices = _lib.rk_create_vertices +_create_vertices.restype = ctypes.c_void_p +_create_vertices.argtypes = ( + ctypes.c_char_p, # format + ctypes.c_uint, # nvertices + ctypes.c_void_p, # vertices + ctypes.c_uint, # nindices + ctypes.c_void_p) # indices + +def create_vertices(format, nvertices, vertices, indices): + return _create_vertices(format, nvertices, _ubytep(vertices), len(indices), _ushortp(indices)) + +create_batch = _lib.rk_create_batch +create_batch.restype = ctypes.c_void_p +create_batch.argtypes = ( + ctypes.c_uint, # max_size + ctypes.c_uint, # translation_format + ctypes.c_uint) # orientation_format + +set_projection = _lib.rk_set_projection +set_projection.argtypes = ( + ctypes.c_float, # hfov + ctypes.c_float, # ratio + ctypes.c_float, # near + ctypes.c_float) # far + +_set_view = _lib.rk_set_view +_set_view.argtypes = ( + _vec3_t, # position + _vec3_t) # lookat + +def set_view(position, lookat): + assert len(position) == 3 and len(lookat) == 3 + _set_view(_vec3(position), _vec3(lookat)) + +begin_frame = _lib.rk_begin_frame + +select_texture = _lib.rk_select_texture +select_texture.argtypes = ( + ctypes.c_void_p,) # texture + +draw_triangles = _lib.rk_draw_triangles +draw_triangles.argtypes = ( + ctypes.c_void_p,) # triangles + +select_vertices = _lib.rk_select_vertices +select_vertices.argtypes = ( + ctypes.c_void_p,) # vertices + +_draw_batch = _lib.rk_draw_batch +_draw_batch.argtypes = ( + ctypes.c_void_p, # batch + ctypes.c_uint, # size + ctypes.c_void_p, # flags + ctypes.c_void_p, # texlevels + ctypes.c_void_p, # meshes + ctypes.c_void_p, # translations + ctypes.c_void_p) # orientations + +def draw_batch(batch, flags, texlevels, meshes, translations, orientations): + size = len(flags) + assert len(texlevels) == size and len(meshes) == size and len(translations) == size * 3 + assert not orientations or len(orientations) == size * 3 + _draw_batch(batch, size, _ubytep(flags), _ushortp(texlevels), _uintp(meshes), _floatp(translations), + _floatp(orientations) if orientations else None) + +unselect_vertices = _lib.rk_unselect_vertices +unselect_vertices.argtypes = ( + ctypes.c_void_p,) # vertices + +unselect_texture = _lib.rk_unselect_texture +unselect_texture.argtypes = ( + ctypes.c_void_p,) # texture + +unselect_shader = _lib.rk_unselect_shader +unselect_shader.argtypes = ( + ctypes.c_void_p,) # shader + +end_frame = _lib.rk_end_frame + +destroy_batch = _lib.rk_destroy_batch +destroy_batch.argtypes = ( + ctypes.c_void_p,) # batch + +destroy_triangles = _lib.rk_destroy_triangles +destroy_triangles.argtypes = ( + ctypes.c_void_p,) # triangles + +destroy_vertices = _lib.rk_destroy_vertices +destroy_vertices.argtypes = ( + ctypes.c_void_p,) # vertices + +destroy_texture = _lib.rk_destroy_texture +destroy_texture.argtypes = ( + ctypes.c_void_p,) # texture + +destroy_shader = _lib.rk_destroy_shader +destroy_shader.argtypes = ( + ctypes.c_void_p,) # shader + +terminate = _lib.rk_terminate diff --git a/cpp/math.cpp b/cpp/math.cpp new file mode 100644 index 0000000..2d34ff3 --- /dev/null +++ b/cpp/math.cpp @@ -0,0 +1,53 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#include "math.hpp" + +//TODO: benchmark this ctypes interface against pure python maths + +void rk_mat3_rotation( + rk_mat3 & ret, + rk_vec3 const & axis, + float const angle) { + ret = glm::mat3_cast(glm::angleAxis(angle, axis)); +} + +void rk_mat3_mul_vec3( + rk_vec3 & ret, + rk_mat3 const & a, + rk_vec3 const & b) { + ret = a * b; +} + +void rk_mat3_mul_mat3( + rk_mat3 & ret, + rk_mat3 const & a, + rk_mat3 const & b) { + ret = a * b; +} + +void rk_mat4_mul_vec4( + rk_vec4 & ret, + rk_mat4 const & a, + rk_vec4 const & b) { + ret = a * b; +} + +void rk_mat4_mul_mat4( + rk_mat4 & ret, + rk_mat4 const & a, + rk_mat4 const & b) { + ret = a * b; +} diff --git a/cpp/math.hpp b/cpp/math.hpp new file mode 100644 index 0000000..0d82ee3 --- /dev/null +++ b/cpp/math.hpp @@ -0,0 +1,54 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef _RK_ENGINE_MATH_H +#define _RK_ENGINE_MATH_H + +#include "types.hpp" +#include +#include + +typedef glm::vec2 rk_vec2; +typedef glm::vec3 rk_vec3; +typedef glm::vec4 rk_vec4; +typedef glm::mat3 rk_mat3; +typedef glm::mat4 rk_mat4; + +RK_EXPORT void rk_mat3_rotation( + rk_mat3 & ret, + rk_vec3 const & axis, + float const angle); + +RK_EXPORT void rk_mat3_mul_vec3( + rk_vec3 & ret, + rk_mat3 const & a, + rk_vec3 const & b); + +RK_EXPORT void rk_mat3_mul_mat3( + rk_mat3 & ret, + rk_mat3 const & a, + rk_mat3 const & b); + +RK_EXPORT void rk_mat4_mul_vec4( + rk_vec4 & ret, + rk_mat4 const & a, + rk_vec4 const & b); + +RK_EXPORT void rk_mat4_mul_mat4( + rk_mat4 & ret, + rk_mat4 const & a, + rk_mat4 const & b); + +#endif // _RK_ENGINE_MATH_H diff --git a/cpp/opengl/render_context.hpp b/cpp/opengl/render_context.hpp new file mode 100644 index 0000000..1d632a0 --- /dev/null +++ b/cpp/opengl/render_context.hpp @@ -0,0 +1,38 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef _RK_ENGINE_RENDER_OPENGL_CONTEXT_H +#define _RK_ENGINE_RENDER_OPENGL_CONTEXT_H + +#include "../render.hpp" + +RK_EXPORT rk_window_t rk_create_context( + char const * name, + int profile, + int major, + int minor); + +RK_EXPORT char ** rk_load_shader_source( + char const * filename, + rk_uint * length); + +RK_EXPORT void rk_free_shader_source( + char ** shader, + rk_uint length); + +RK_EXPORT void rk_swap_buffers(); +RK_EXPORT void rk_destroy_context(); + +#endif // _RK_ENGINE_RENDER_OPENGL_CONTEXT_H diff --git a/cpp/opengl/render_context_glx.cpp b/cpp/opengl/render_context_glx.cpp new file mode 100644 index 0000000..884ecd1 --- /dev/null +++ b/cpp/opengl/render_context_glx.cpp @@ -0,0 +1,254 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +// Adapted from https://www.khronos.org/opengl/wiki/Tutorial:_OpenGL_3.0_Context_Creation_(GLX) + +#include "render_context.hpp" +#include +#include +#include +#include + +static Display * rk_display = nullptr; +static Colormap rk_colormap = 0; +static Window rk_window = 0; +static GLXContext rk_context = nullptr; +static bool rk_error_occured = false; + +#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091 +#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092 +typedef GLXContext (*glXCreateContextAttribsARBProc)(Display *, GLXFBConfig, GLXContext, Bool, int const *); + +static void rk_printf( + char const * messsage) { + printf("[GLX] %s\n", messsage); +} + +static bool rk_extension_supported( + char const * extlist, + char const * extension) { + char const * where = strchr(extension, ' '); + if (where || *extension == '\0') { + return false; + } + for (char const * start = extlist;;) { + where = strstr(start, extension); + if (!where) { + break; + } + char const * const terminator = where + strlen(extension); + if ((where == start || *(where - 1) == ' ') && (*terminator == ' ' || *terminator == '\0')) { + return true; + } + start = terminator; + } + return false; +} + +static int rk_error_handler( + Display * display, + XErrorEvent * event) { + rk_error_occured = true; + return 0; +} + +rk_window_t rk_create_context( + char const * name, + int profile, + int major, + int minor) { + rk_display = XOpenDisplay(nullptr); + if (!rk_display) { + rk_printf("Failed to open X display."); + return nullptr; + } + + static int const visual_attribs[] = { + GLX_X_RENDERABLE, True, + GLX_DRAWABLE_TYPE, GLX_WINDOW_BIT, + GLX_RENDER_TYPE, GLX_RGBA_BIT, + GLX_X_VISUAL_TYPE, GLX_TRUE_COLOR, + GLX_RED_SIZE, 8, + GLX_GREEN_SIZE, 8, + GLX_BLUE_SIZE, 8, + GLX_ALPHA_SIZE, 8, + GLX_DEPTH_SIZE, 24, + GLX_STENCIL_SIZE, 8, + GLX_DOUBLEBUFFER, True, + None + }; + + int glx_major, glx_minor; + if (!glXQueryVersion(rk_display, &glx_major, &glx_minor) || (glx_major == 1 && glx_minor < 3) || glx_major < 1) { + rk_printf("Invalid GLX version."); + rk_destroy_context(); + return nullptr; + } + + int fbcount; + GLXFBConfig * const fbc = glXChooseFBConfig(rk_display, DefaultScreen(rk_display), visual_attribs, &fbcount); + if (!fbc) { + rk_printf("Failed to retrieve a framebuffer config."); + rk_destroy_context(); + return nullptr; + } + + int best_fbc = -1; + int best_num_samp = -1; + for (int i = 0; i < fbcount; ++i) { + XVisualInfo * vi = glXGetVisualFromFBConfig(rk_display, fbc[i]); + if (vi) { + int srgb = 0; + glXGetFBConfigAttrib(rk_display, fbc[i], GLX_FRAMEBUFFER_SRGB_CAPABLE_ARB, &srgb); + if (srgb) { + int samp_buf, samples; + glXGetFBConfigAttrib(rk_display, fbc[i], GLX_SAMPLE_BUFFERS, &samp_buf); + glXGetFBConfigAttrib(rk_display, fbc[i], GLX_SAMPLES, &samples); + if (best_fbc < 0 || (samp_buf && samples > best_num_samp)) { + best_fbc = i; + best_num_samp = samples; + } + } + XFree(vi); + } + } + if (best_fbc == -1) { + XFree(fbc); + rk_printf("Failed to find sRGB framebuffer."); + rk_destroy_context(); + return nullptr; + } + GLXFBConfig const bestFbc = fbc[best_fbc]; + XFree(fbc); + + XVisualInfo * const vi = glXGetVisualFromFBConfig(rk_display, bestFbc); + rk_colormap = XCreateColormap(rk_display, RootWindow(rk_display, vi->screen), vi->visual, AllocNone); + XSetWindowAttributes swa; + swa.colormap = rk_colormap; + swa.background_pixmap = None; + swa.border_pixel = 0; + swa.event_mask = StructureNotifyMask; + rk_window = XCreateWindow(rk_display, RootWindow(rk_display, vi->screen), + 0, 0, 1600, 900, 0, vi->depth, InputOutput, vi->visual, + CWBorderPixel | CWColormap | CWEventMask, &swa); + if (!rk_window) { + rk_printf("Failed to create window."); + rk_destroy_context(); + return nullptr; + } + XFree(vi); + XStoreName(rk_display, rk_window, name); + XMapWindow( rk_display, rk_window ); + + char const * const glxExts = glXQueryExtensionsString(rk_display, DefaultScreen(rk_display)); + glXCreateContextAttribsARBProc glXCreateContextAttribsARB = 0; + glXCreateContextAttribsARB = (glXCreateContextAttribsARBProc) + glXGetProcAddressARB((const GLubyte *)("glXCreateContextAttribsARB")); + + rk_error_occured = false; + int (*oldHandler)(Display *, XErrorEvent *) = XSetErrorHandler(&rk_error_handler); + if (!rk_extension_supported(glxExts, "GLX_ARB_create_context") || !glXCreateContextAttribsARB) { + rk_printf("glXCreateContextAttribsARB() not found."); + rk_destroy_context(); + return nullptr; + } else { + const int context_attribs[] = { + GLX_CONTEXT_MAJOR_VERSION_ARB, major, + GLX_CONTEXT_MINOR_VERSION_ARB, minor, + GLX_CONTEXT_PROFILE_MASK_ARB, profile, + None + }; + rk_context = glXCreateContextAttribsARB(rk_display, bestFbc, 0, True, context_attribs); + XSync(rk_display, False); + if (rk_error_occured || !rk_context) { + rk_printf("Failed to create context."); + rk_destroy_context(); + return nullptr; + } + } + XSetErrorHandler(oldHandler); + + if (!glXIsDirect(rk_display, rk_context)) { + rk_printf("Warning: Rendering context is indirect."); + } + glXMakeCurrent(rk_display, rk_window, rk_context); + return reinterpret_cast(rk_window); +} + +void rk_swap_buffers() { + if (rk_display && rk_window) { + glXSwapBuffers(rk_display, rk_window); + } +} + +char ** rk_load_shader_source( + char const * filename, + rk_uint * length) { + char ** shader = nullptr; + char buffer[1024]; + FILE * const file = fopen(filename, "rt"); + if (file) { + int nlines = 0; + while (fgets(buffer, sizeof(buffer), file)) { + ++nlines; + } + if (nlines) { + rewind(file); + shader = new char*[nlines]; + for (int line = 0; line < nlines; ++line) { + shader[line] = new char[sizeof(buffer)]; + fgets(shader[line], sizeof(buffer), file); + } + } else { + printf("Shader %s is empty.\n", filename); + } + fclose(file); + *length = nlines; + } else { + printf("Cannot open shader %s.\n", filename); + } + return shader; +} + +void rk_free_shader_source( + char ** shader, + rk_uint length) { + if (shader) { + for (rk_uint line = 0; line < length; ++line) { + delete[] shader[line]; + } + } + delete[] shader; +} + +void rk_destroy_context() { + if (rk_display) { + glXMakeCurrent(rk_display, 0, nullptr); + if (rk_context) { + glXDestroyContext(rk_display, rk_context); + rk_context = nullptr; + } + if (rk_window) { + XDestroyWindow(rk_display, rk_window); + rk_window = 0; + } + if (rk_colormap) { + XFreeColormap(rk_display, rk_colormap); + rk_colormap = 0; + } + XCloseDisplay(rk_display); + rk_display = nullptr; + } +} diff --git a/cpp/opengl/render_opengles.cpp b/cpp/opengl/render_opengles.cpp new file mode 100644 index 0000000..23e0830 --- /dev/null +++ b/cpp/opengl/render_opengles.cpp @@ -0,0 +1,816 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#include "render_opengles.hpp" +#include +#include + +//TODO: move the GLX stuff to render_context_glx.cpp +#include + +static rk_shader const * rk_current_shader = nullptr; +static rk_vertices const * rk_current_vertices = nullptr; +static bool rk_frame = false; + +static PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC rk_DrawElementsInstancedBaseInstance = nullptr; +static PFNGLMULTIDRAWELEMENTSINDIRECTPROC rk_MultiDrawElementsIndirect = nullptr; + +static void rk_printf(char const * messsage) { + printf("[RK_ENGINE] %s\n", messsage); +} + +#define rk_error(message) { if (glGetError() != GL_NO_ERROR) { rk_printf(message); } } + +static void rk_debug_message_callback( + GLenum source, + GLenum type, + GLuint id, + GLenum severity, + GLsizei length, + GLchar const * message, + void const * userParam) { + if (id == 131169 || id == 131185 || id == 131218 || id == 131204) { + return; + } + printf("[RK_ENGINE][GL] (id=%d) %s\n", id, message); +} + +static __GLXextFuncPtr rk_extension( + char const * const name, + char const * const func) { + __GLXextFuncPtr ext_ptr = nullptr; + GLint num_exts = 0; + glGetIntegerv(GL_NUM_EXTENSIONS, &num_exts); + for (int ext_index = 0; ext_index < num_exts; ++ext_index) { + char const * const ext_name = reinterpret_cast(glGetStringi(GL_EXTENSIONS, ext_index)); + if (strcmp(name, ext_name) == 0) { + ext_ptr = glXGetProcAddressARB(reinterpret_cast(func)); + printf("[RK_ENGINE] Using extension %s::%s\n", name, func); + break; + } + } + return ext_ptr; +} + +rk_window_t rk_initialize( + char const * name) { + rk_window_t const window = rk_create_context(name, GLX_CONTEXT_ES_PROFILE_BIT_EXT, 3, 2); + if (window) { + GLubyte const * const vendor = glGetString(GL_VENDOR); + GLubyte const * const renderer = glGetString(GL_RENDERER); + printf("[RK_ENGINE] vendor: %s, renderer: %s\n", vendor, renderer); + GLubyte const * const version = glGetString(GL_VERSION); + GLubyte const * const language = glGetString(GL_SHADING_LANGUAGE_VERSION); + printf("[RK_ENGINE] version: %s, language: %s\n", version, language); + + rk_DrawElementsInstancedBaseInstance = + reinterpret_cast( + rk_extension("GL_EXT_base_instance", "DrawElementsInstancedBaseInstance")); + if (rk_DrawElementsInstancedBaseInstance) { + rk_MultiDrawElementsIndirect = + reinterpret_cast( + rk_extension("GL_EXT_multi_draw_indirect", "MultiDrawElementsIndirectEXT")); + } + + GLint context_flags = 0; + glGetIntegerv(GL_CONTEXT_FLAGS, &context_flags); + if (context_flags & GL_CONTEXT_FLAG_DEBUG_BIT) { + printf("[RK_ENGINE] Debug context enabled\n"); + glDebugMessageCallback(rk_debug_message_callback, nullptr); + glEnable(GL_DEBUG_OUTPUT); + } else { + glDisable(GL_DEBUG_OUTPUT); + } + + glDisable(GL_BLEND); + glEnable(GL_DITHER); + glEnable(GL_DEPTH_TEST); + glDisable(GL_SCISSOR_TEST); + glDisable(GL_STENCIL_TEST); + glEnable(GL_CULL_FACE); + glFrontFace(GL_CCW); + glCullFace(GL_BACK); + glHint(GL_GENERATE_MIPMAP_HINT, GL_NICEST); + } + return window; +} + +static void rk_print_shader_infolog(GLuint shader) { + int length; + char infolog[1024]; + glGetShaderInfoLog(shader, sizeof(infolog), &length, infolog); + if (length > 0) { + rk_printf(infolog); + } +} + +static void rk_print_program_infolog(GLuint program) { + int length; + char infolog[1024]; + glGetProgramInfoLog(program, sizeof(infolog), &length, infolog); + if (length > 0) { + rk_printf(infolog); + } +} + +//TODO: external loading of shader sources +//TODO: error handling +rk_shader_t rk_load_shader( + char const * name) { + rk_shader * const shader = new rk_shader; + shader->vertex = glCreateShader(GL_VERTEX_SHADER); + shader->fragment = glCreateShader(GL_FRAGMENT_SHADER); + shader->program = glCreateProgram(); + + char vertex_name[256]; + snprintf(vertex_name, sizeof(vertex_name), "%s_opengles.vert", name); + printf("[RK_ENGINE] Loading vertex shader %s...\n", vertex_name); + rk_uint vertex_length = 0; + char ** vertex_source = rk_load_shader_source(vertex_name, &vertex_length); + if (vertex_source) { + rk_printf("Compiling vertex shader..."); + glShaderSource(shader->vertex, vertex_length, vertex_source, nullptr); + } + glCompileShader(shader->vertex); + rk_error("glCompileShader() failed."); + rk_print_shader_infolog(shader->vertex); + + char fragment_name[256]; + snprintf(fragment_name, sizeof(fragment_name), "%s_opengles.frag", name); + printf("[RK_ENGINE] Loading fragment shader %s...\n", fragment_name); + rk_uint fragment_length = 0; + char ** fragment_source = rk_load_shader_source(fragment_name, &fragment_length); + if (fragment_source) { + rk_printf("Compiling fragment shader..."); + glShaderSource(shader->fragment, fragment_length, fragment_source, nullptr); + } + glCompileShader(shader->fragment); + rk_error("glCompileShader() failed."); + rk_print_shader_infolog(shader->fragment); + + rk_printf("Linking program..."); + glAttachShader(shader->program, shader->vertex); + glAttachShader(shader->program, shader->fragment); + glLinkProgram(shader->program); + rk_error("glLinkProgram() failed."); + rk_print_program_infolog(shader->program); + + rk_printf("Done."); + + glReleaseShaderCompiler(); + if (vertex_source != nullptr) { + rk_free_shader_source(vertex_source, vertex_length); + } + if (fragment_source != nullptr) { + rk_free_shader_source(fragment_source, fragment_length); + } + + shader->uniforms.view = glGetUniformLocation(shader->program, "u_view"); + shader->uniforms.view_km = glGetUniformLocation(shader->program, "u_view_km"); + shader->uniforms.projection = glGetUniformLocation(shader->program, "u_projection"); + + return shader; +} + +void rk_select_shader( + rk_shader_t _shader) { + rk_shader * const shader = reinterpret_cast(_shader); + if (shader) { + rk_current_shader = shader; + glUseProgram(shader->program); + if (rk_frame) { + if (shader->uniforms.view > -1) { + glUniformMatrix4fv(shader->uniforms.view, 1, GL_FALSE, glm::value_ptr(rk_view)); + } + if (shader->uniforms.view_km > -1) { + glUniformMatrix4fv(shader->uniforms.view_km, 1, GL_FALSE, glm::value_ptr(rk_view_km)); + } + if (shader->uniforms.projection > -1) { + glUniformMatrix4fv(shader->uniforms.projection, 1, GL_FALSE, glm::value_ptr(rk_projection)); + } + } + } +} + +rk_input_t rk_resolve_input( + char const * name) { + if (!rk_current_shader || !name) { + return nullptr; + } + GLint const uniform = glGetUniformLocation(rk_current_shader->program, name); + return reinterpret_cast(uniform + 1); +} + +void rk_set_input_float( + rk_input_t _input, + float value) { + GLint const input = reinterpret_cast(_input) - 1; + if (rk_current_shader && input > -1) { + glUniform1f(input, value); + } +} + +void rk_set_input_vec3( + rk_input_t _input, + rk_vec3 const & value, + rk_input_mode mode) { + GLint const input = reinterpret_cast(_input) - 1; + if (rk_current_shader && input > -1) { + switch (mode) { + case RK_INPUT_IDENTITY: + glUniform3fv(input, 1, glm::value_ptr(value)); + break; + case RK_INPUT_VIEW_POSITION: { + glUniform3fv(input, 1, glm::value_ptr(rk_view * rk_vec4(value, 1.0))); + break; + } + case RK_INPUT_VIEW_ORIENTATION: { + glUniform3fv(input, 1, glm::value_ptr(rk_view * rk_vec4(value, 0.0))); + break; + } + } + } +} + +rk_texture_t rk_create_texture( + rk_uint slot, + char const * input, + rk_texture_format format, + rk_uint width, + rk_uint height, + rk_uint nlevels, + rk_texture_flags flags, + void const * pixels) { + if (!input || width == 0 || height == 0 || !pixels || !rk_current_shader) { + return nullptr; + } + GLint internal_format; + GLenum source_format; + GLenum source_type; + switch (format) { + case RK_TEXTURE_FORMAT_SRGB8_A8: + internal_format = GL_SRGB8_ALPHA8; + source_format = GL_RGBA; + source_type = GL_UNSIGNED_BYTE; + break; + case RK_TEXTURE_FORMAT_RGBA8: + internal_format = GL_RGBA8; + source_format = GL_RGBA; + source_type = GL_UNSIGNED_BYTE; + break; + case RK_TEXTURE_FORMAT_RGB10_A2: + internal_format = GL_RGB10_A2; + source_format = GL_RGBA; + source_type = GL_UNSIGNED_INT_2_10_10_10_REV; + break; + case RK_TEXTURE_FORMAT_32F: + internal_format = GL_R32F; + source_format = GL_RED; + source_type = GL_FLOAT; + break; + default: + return nullptr; + break; + } + rk_texture * const texture = new rk_texture; + glActiveTexture(GL_TEXTURE0 + slot); + glGenTextures(1, &texture->texture); + GLenum target; + if (nlevels) { + if (flags & RK_TEXTURE_FLAG_3D) { + target = GL_TEXTURE_3D; + } else { + target = GL_TEXTURE_2D_ARRAY; + } + glBindTexture(target, texture->texture); + //TODO: glTexStorage3D + glTexImage3D(target, 0, internal_format, width, height, nlevels, 0, source_format, source_type, pixels); + } else { + target = GL_TEXTURE_2D; + glBindTexture(target, texture->texture); + //TODO: glTexStorage2D + glTexImage2D(target, 0, internal_format, width, height, 0, source_format, source_type, pixels); + } + if (flags & RK_TEXTURE_FLAG_MIPMAPS) { + if (flags & RK_TEXTURE_FLAG_MIN_LINEAR) { + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); + } else { + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR); + } + } else { + if (flags & RK_TEXTURE_FLAG_MIN_LINEAR) { + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); + } else { + glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); + } + } + if (flags & RK_TEXTURE_FLAG_MAG_LINEAR) { + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); + } else { + glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); + } + glTexParameteri(target, GL_TEXTURE_WRAP_S, GL_REPEAT); + glTexParameteri(target, GL_TEXTURE_WRAP_T, GL_REPEAT); + glTexParameteri(target, GL_TEXTURE_WRAP_R, GL_REPEAT); + if (flags & RK_TEXTURE_FLAG_MIPMAPS) { + glGenerateMipmap(target); + } + texture->slot = slot; + texture->nlevels = nlevels; + texture->sampler = glGetUniformLocation(rk_current_shader->program, input); + if (texture->sampler == -1) { + printf("[RK_ENGINE] glGetUniformLocation(%s) failed\n", input); + } + glBindTexture(target, 0); + return texture; +} + +rk_triangles_t rk_create_triangles( + rk_uint nvertices, + rk_vec3 const * vertices) { + if (nvertices == 0 || !vertices || !rk_current_shader) { + return nullptr; + } + rk_triangles * const triangles = new rk_triangles; + triangles->size = nvertices; + glGenVertexArrays(1, &triangles->array); + glBindVertexArray(triangles->array); + glGenBuffers(1, &triangles->vertices); + glBindBuffer(GL_ARRAY_BUFFER, triangles->vertices); + glBufferData(GL_ARRAY_BUFFER, nvertices * sizeof(rk_vec3), vertices, GL_STATIC_DRAW); + glEnableVertexAttribArray(0); + glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); + glBindBuffer(GL_ARRAY_BUFFER, 0); + glBindVertexArray(0); + return triangles; +} + +rk_vertices_t rk_create_vertices( + rk_vertex_format const * format, + rk_uint nvertices, + void const * _vertices, + rk_uint nindices, + rk_ushort const * indices) { + if (!format || !nvertices || !_vertices || !nindices || !indices || !rk_current_shader) { + return nullptr; + } + rk_uint vertex_size = 0; + for (rk_vertex_format const * f = format; *f; ++f) { + switch (*f) { + case RK_VERTEX_FORMAT_VEC2_FLOAT: + vertex_size += sizeof(float) * 2; + break; + case RK_VERTEX_FORMAT_VEC2_USHORT: + vertex_size += sizeof(rk_ushort) * 2; + break; + case RK_VERTEX_FORMAT_VEC3_FLOAT: + vertex_size += sizeof(float) * 3; + break; + case RK_VERTEX_FORMAT_VEC3_INT10: + vertex_size += sizeof(rk_uint); + break; + default: + rk_printf("rk_create_vertices(): invalid format."); + return nullptr; + break; + } + } + if (!vertex_size) { + rk_printf("rk_create_vertices(): empty format."); + return nullptr; + } + rk_vertices * const vertices = new rk_vertices; + glGenVertexArrays(1, &vertices->array); + glBindVertexArray(vertices->array); + glGenBuffers(1, &vertices->vertices); + glBindBuffer(GL_ARRAY_BUFFER, vertices->vertices); + glBufferData(GL_ARRAY_BUFFER, nvertices * vertex_size, _vertices, GL_STATIC_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); + vertices->vertex_size = vertex_size; + vertices->layout = 0; + rk_uint offset = 0; + for (rk_vertex_format const * f = format; *f; ++f, ++vertices->layout) { + glEnableVertexAttribArray(vertices->layout); + switch (*f) { + case RK_VERTEX_FORMAT_VEC2_FLOAT: + glVertexAttribFormat(vertices->layout, 2, GL_FLOAT, GL_FALSE, offset); + glVertexAttribBinding(vertices->layout, RK_VERTICES_BINDING); + offset += sizeof(float) * 2; + break; + case RK_VERTEX_FORMAT_VEC2_USHORT: + glVertexAttribFormat(vertices->layout, 2, GL_UNSIGNED_SHORT, GL_TRUE, offset); + glVertexAttribBinding(vertices->layout, RK_VERTICES_BINDING); + offset += sizeof(rk_ushort) * 2; + break; + case RK_VERTEX_FORMAT_VEC3_FLOAT: + glVertexAttribFormat(vertices->layout, 3, GL_FLOAT, GL_FALSE, offset); + glVertexAttribBinding(vertices->layout, RK_VERTICES_BINDING); + offset += sizeof(float) * 3; + break; + case RK_VERTEX_FORMAT_VEC3_INT10: + glVertexAttribFormat(vertices->layout, GL_BGRA, GL_INT_2_10_10_10_REV, GL_TRUE, offset); + glVertexAttribBinding(vertices->layout, RK_VERTICES_BINDING); + offset += sizeof(rk_uint); + break; + default: + break; + } + } + glBindVertexBuffer(RK_VERTICES_BINDING, vertices->vertices, 0, vertices->vertex_size); + glGenBuffers(1, &vertices->indices); + glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, vertices->indices); + glBufferData(GL_ELEMENT_ARRAY_BUFFER, nindices * sizeof(rk_ushort), indices, GL_STATIC_DRAW); + glBindVertexArray(0); + return vertices; +} + +//TODO: support for mat3 orientations with packing into int10 * 3 +// - maybe from quaternions inputs +// - maybe it's possible to implement efficient quaternions in glsl? + +rk_batch_t rk_create_batch( + rk_uint max_size, + rk_batch_translation_format translation_format, + rk_batch_orientation_format orientation_format) { + if (!max_size || max_size > RK_BATCH_MAX_SIZE || !rk_current_shader || !rk_current_vertices) { + return nullptr; + } + rk_uint translation_size = 0; + switch (translation_format) { + case RK_BATCH_TRANSLATION_FORMAT_FLOAT: + translation_size = sizeof(float) * 4; + break; + case RK_BATCH_TRANSLATION_FORMAT_SHORT: + translation_size = sizeof(rk_short) * 4; + break; + default: + rk_printf("rk_create_batch(): invalid translation format."); + return nullptr; + break; + } + rk_uint orientation_size = 0; + switch (orientation_format) { + case RK_BATCH_ORIENTATION_FORMAT_NONE: + orientation_size = 0; + break; + case RK_BATCH_ORIENTATION_FORMAT_FLOAT: + orientation_size = sizeof(float) * 3; + break; + case RK_BATCH_ORIENTATION_FORMAT_INT10: + orientation_size = sizeof(rk_uint); + break; + default: + rk_printf("rk_create_batch(): invalid orientation format."); + return nullptr; + break; + } + rk_uint const params_size = translation_size + orientation_size; + rk_batch * batch = new rk_batch; + batch->size = max_size; + batch->translation_format = translation_format; + batch->orientation_format = orientation_format; + batch->params_size = params_size; + batch->indices = new rk_ushort[batch->size]; + batch->params = new rk_ubyte[batch->size * params_size]; + batch->commands = new rk_command[batch->size * sizeof(rk_command)]; + glGenBuffers(1, &batch->params_buffer); + rk_uint const translation_layout = rk_current_vertices->layout; + glEnableVertexAttribArray(translation_layout); + switch (translation_format) { + case RK_BATCH_TRANSLATION_FORMAT_FLOAT: + glVertexAttribFormat(translation_layout, 4, GL_FLOAT, GL_FALSE, 0); + break; + case RK_BATCH_TRANSLATION_FORMAT_SHORT: + glVertexAttribFormat(translation_layout, 4, GL_SHORT, GL_FALSE, 0); + break; + } + glVertexAttribBinding(translation_layout, RK_PARAMS_BINDING); + rk_uint const orientation_layout = rk_current_vertices->layout + 1; + switch (orientation_format) { + case RK_BATCH_ORIENTATION_FORMAT_NONE: + break; + case RK_BATCH_ORIENTATION_FORMAT_FLOAT: + glEnableVertexAttribArray(orientation_layout); + glVertexAttribFormat(orientation_layout, 3, GL_FLOAT, GL_FALSE, translation_size); + glVertexAttribBinding(orientation_layout, RK_PARAMS_BINDING); + break; + case RK_BATCH_ORIENTATION_FORMAT_INT10: + glEnableVertexAttribArray(orientation_layout); + glVertexAttribFormat(orientation_layout, GL_BGRA, GL_INT_2_10_10_10_REV, GL_TRUE, translation_size); + glVertexAttribBinding(orientation_layout, RK_PARAMS_BINDING); + break; + } + glVertexBindingDivisor(RK_PARAMS_BINDING, 1); + glBindVertexBuffer(RK_PARAMS_BINDING, batch->params_buffer, 0, batch->params_size); + if (rk_MultiDrawElementsIndirect) { + glGenBuffers(1, &batch->commands_buffer); + } + return batch; +} + +void rk_begin_frame() { + rk_frame = true; + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); +} + +void rk_select_texture( + rk_texture_t _texture) { + rk_texture const * const texture = reinterpret_cast(_texture); + if (texture) { + glActiveTexture(GL_TEXTURE0 + texture->slot); + if (texture->nlevels) { + glBindTexture(GL_TEXTURE_2D_ARRAY, texture->texture); + } else { + glBindTexture(GL_TEXTURE_2D, texture->texture); + } + if (texture->sampler > -1) { + glUniform1i(texture->sampler, texture->slot); + } + } +} + +RK_EXPORT void rk_draw_triangles( + rk_triangles_t _triangles) { + rk_triangles const * const triangles = reinterpret_cast(_triangles); + if (triangles && rk_current_shader && !rk_current_vertices) { + glBindVertexArray(triangles->array); + glDrawArrays(GL_TRIANGLES, 0, triangles->size); + glBindVertexArray(0); + } +} + +void rk_select_vertices( + rk_vertices_t _vertices) { + rk_vertices * const vertices = reinterpret_cast(_vertices); + if (vertices && rk_current_shader) { + glBindVertexArray(vertices->array); + rk_current_vertices = vertices; + } +} + +static rk_uint rk_batch_filter( + rk_uint const size, + rk_ushort * const _indices, + rk_instance_flags const * flags) { + rk_ushort * indices = _indices; + for (rk_ushort index = 0; index < size; ++index, ++flags) { + if ((*flags & RK_INSTANCE_FLAGS_SPAWNED_VISIBLE) == RK_INSTANCE_FLAGS_SPAWNED_VISIBLE) { + *indices++ = index; + } + } + return indices - _indices; +} + +static rk_uint rk_batch_build_commands( + rk_uint const count, + rk_ushort * const indices, + rk_command * const _commands, + rk_mesh const * const meshes) { + rk_command * commands = _commands; + rk_ushort * base = indices; + rk_ushort * const last = indices + count; + for (rk_ushort * first = indices; first < last; base = first, ++commands) { + rk_mesh const & mesh = meshes[*first++]; + for ( ; first < last && meshes[*first].packed == mesh.packed; ++first) { + } + for (rk_ushort * second = first; second < last; ++second) { + rk_ushort const index = *second; + if (meshes[index].packed == mesh.packed) { + *second = *first; + *first++ = index; + } + } + commands->count = static_cast(mesh.count) * 3; + commands->ninstances = first - base; + commands->base_index = mesh.offset; + commands->base_vertex = 0; + commands->base_instance = base - indices; + } + return commands - _commands; +} + +template < typename _instance_params_t > +static void rk_batch_convert_params( + rk_uint const count, + rk_ushort const * const _indices, + rk_ubyte * const _params, + rk_vec3 const * const translations, + rk_ushort const * const texlevels, + rk_vec3 const * const orientations) { + _instance_params_t * params = reinterpret_cast<_instance_params_t *>(_params); + rk_ushort const * const last = _indices + count; + for (rk_ushort const * indices = _indices; indices < last; ++indices, ++params) { + rk_uint const index = *indices; + params->set(translations[index], texlevels[index], orientations[index]); + } +} + +template < typename _instance_params_t > +static void rk_batch_convert_params( + rk_uint const count, + rk_ushort const * const _indices, + rk_ubyte * const _params, + rk_vec3 const * const translations, + rk_ushort const * const texlevels) { + _instance_params_t * params = reinterpret_cast<_instance_params_t *>(_params); + rk_ushort const * const last = _indices + count; + for (rk_ushort const * indices = _indices; indices < last; ++indices, ++params) { + rk_uint const index = *indices; + params->set(translations[index], texlevels[index]); + } +} + +void rk_draw_batch( + rk_batch_t _batch, + rk_uint size, + rk_instance_flags const * flags, + rk_ushort const * texlevels, + rk_mesh const * meshes, + rk_vec3 const * translations, + rk_vec3 const * orientations) { + rk_batch & batch = *reinterpret_cast(_batch); + if (!size || size > batch.size || !flags || !texlevels || !meshes || !translations || + !rk_current_shader || !rk_current_vertices) { + return; + } + if (batch.orientation_format != RK_BATCH_ORIENTATION_FORMAT_NONE && !orientations) { + return; + } + rk_uint const count = rk_batch_filter(size, batch.indices, flags); + if (!count) { + return; + } + rk_uint const ncommands = rk_batch_build_commands(count, batch.indices, batch.commands, meshes); + if (rk_MultiDrawElementsIndirect) { + glBindBuffer(GL_DRAW_INDIRECT_BUFFER, batch.commands_buffer); + glBufferData(GL_DRAW_INDIRECT_BUFFER, ncommands * sizeof(rk_command), batch.commands, GL_STREAM_DRAW); + } + switch (batch.translation_format) { + case RK_BATCH_TRANSLATION_FORMAT_FLOAT: + switch (batch.orientation_format) { + case RK_BATCH_ORIENTATION_FORMAT_NONE: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels); + break; + case RK_BATCH_ORIENTATION_FORMAT_FLOAT: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels, orientations); + break; + case RK_BATCH_ORIENTATION_FORMAT_INT10: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels, orientations); + break; + } + break; + case RK_BATCH_TRANSLATION_FORMAT_SHORT: + switch (batch.orientation_format) { + case RK_BATCH_ORIENTATION_FORMAT_NONE: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels); + break; + case RK_BATCH_ORIENTATION_FORMAT_FLOAT: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels, orientations); + break; + case RK_BATCH_ORIENTATION_FORMAT_INT10: + rk_batch_convert_params( + count, batch.indices, batch.params, translations, texlevels, orientations); + break; + } + break; + } + glBindBuffer(GL_ARRAY_BUFFER, batch.params_buffer); + glBufferData(GL_ARRAY_BUFFER, count * batch.params_size, batch.params, GL_STREAM_DRAW); + glBindBuffer(GL_ARRAY_BUFFER, 0); + if (batch.orientation_format == RK_BATCH_ORIENTATION_FORMAT_NONE) { + rk_vec3 const forward(0.f, 1.f, 0.f); + glVertexAttrib3fv(rk_current_vertices->layout + 1, glm::value_ptr(forward)); + } + if (rk_DrawElementsInstancedBaseInstance) { + if (rk_MultiDrawElementsIndirect) { + rk_MultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, nullptr, ncommands, sizeof(rk_command)); + glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0); + } else { + rk_command const * const last_command = batch.commands + ncommands; + for (rk_command const * command = batch.commands; command < last_command; ++command) { + rk_DrawElementsInstancedBaseInstance( + GL_TRIANGLES, command->count, GL_UNSIGNED_SHORT, + reinterpret_cast(command->base_index << 1), + command->ninstances, command->base_instance); + } + } + } else { + rk_uint params_offset = 0; + rk_command const * const last_command = batch.commands + ncommands; + for (rk_command const * command = batch.commands; command < last_command; ++command) { + glBindVertexBuffer(RK_PARAMS_BINDING, batch.params_buffer, params_offset, batch.params_size); + params_offset += command->ninstances * batch.params_size; + glDrawElementsInstanced( + GL_TRIANGLES, command->count, GL_UNSIGNED_SHORT, + reinterpret_cast(command->base_index << 1), + command->ninstances); + } + } +} + +void rk_unselect_vertices( + rk_vertices_t _vertices) { + rk_current_vertices = nullptr; + glBindVertexArray(0); +} + +void rk_unselect_texture( + rk_texture_t _texture) { + rk_texture const * const texture = reinterpret_cast(_texture); + if (texture) { + glActiveTexture(GL_TEXTURE0 + texture->slot); + if (texture->nlevels) { + glBindTexture(GL_TEXTURE_2D, 0); + } else { + glBindTexture(GL_TEXTURE_2D_ARRAY, 0); + } + } +} + +void rk_unselect_shader( + rk_shader_t _shader) { + rk_current_shader = nullptr; + glUseProgram(0); +} + +void rk_end_frame() { + rk_swap_buffers(); + rk_frame = false; +} + +void rk_destroy_batch( + rk_batch_t _batch) { + rk_batch * const batch = reinterpret_cast(_batch); + if (batch) { + delete[] batch->indices; + delete[] batch->params; + delete[] batch->commands; + glDeleteBuffers(1, &batch->params_buffer); + if (rk_MultiDrawElementsIndirect) { + glDeleteBuffers(1, &batch->commands_buffer); + } + delete batch; + } +} + +void rk_destroy_triangles( + rk_triangles_t _triangles) { + rk_triangles * const triangles = reinterpret_cast(_triangles); + if (triangles) { + glDeleteBuffers(1, &triangles->vertices); + glDeleteVertexArrays(1, &triangles->array); + delete triangles; + } +} + +void rk_destroy_vertices( + rk_vertices_t _vertices) { + rk_vertices * const vertices = reinterpret_cast(_vertices); + if (vertices) { + glDeleteBuffers(1, &vertices->indices); + glDeleteBuffers(1, &vertices->vertices); + glDeleteVertexArrays(1, &vertices->array); + delete vertices; + } +} + +void rk_destroy_texture( + rk_texture_t _texture) { + rk_texture * const texture = reinterpret_cast(_texture); + if (texture) { + glDeleteTextures(1, &texture->texture); + delete texture; + } +} + +void rk_destroy_shader( + rk_shader_t _shader) { + rk_shader * const shader = reinterpret_cast(_shader); + if (shader) { + glDeleteShader(shader->vertex); + glDeleteShader(shader->fragment); + glDeleteProgram(shader->program); + delete shader; + } +} + +void rk_terminate() { + rk_destroy_context(); +} diff --git a/cpp/opengl/render_opengles.hpp b/cpp/opengl/render_opengles.hpp new file mode 100644 index 0000000..ee48709 --- /dev/null +++ b/cpp/opengl/render_opengles.hpp @@ -0,0 +1,143 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef _RK_ENGINE_RENDER_OPENGLES_H +#define _RK_ENGINE_RENDER_OPENGLES_H + +#include "../render.hpp" +#include "render_context.hpp" +#include +#include +#include + +enum : rk_uint { + RK_VERTICES_BINDING = 0, + RK_PARAMS_BINDING = 1 +}; + +struct rk_uniforms { + GLint view; + GLint view_km; + GLint projection; +}; + +struct rk_shader { + GLuint vertex; + GLuint fragment; + GLuint program; + rk_uniforms uniforms; +}; + +struct rk_texture { + rk_uint slot; + rk_uint nlevels; + GLint sampler; + GLuint texture; +}; + +struct rk_triangles { + rk_uint size; + GLuint array; + GLuint vertices; +}; + +struct rk_vertices { + rk_uint vertex_size; + rk_uint layout; + GLuint array; + GLuint vertices; + GLuint indices; +}; + +struct rk_command { + GLuint count; + GLuint ninstances; + GLuint base_index; + GLint base_vertex; + GLuint base_instance; +}; + +struct rk_batch { + rk_uint size; + rk_batch_translation_format translation_format; + rk_batch_orientation_format orientation_format; + rk_uint params_size; + rk_ushort * indices; + rk_ubyte * params; + rk_command * commands; + GLuint params_buffer; + GLuint commands_buffer; +}; + +struct rk_translation_float { + rk_vec3 xyz; + float l; + + inline void set(rk_vec3 const & translation, rk_ushort const texlevel) { + xyz = translation; + l = static_cast(texlevel); + } +}; + +struct rk_translation_short { + rk_short x; + rk_short y; + rk_short z; + rk_ushort l; + + inline void set(rk_vec3 const & translation, rk_ushort const texlevel) { + x = static_cast(translation.x); + y = static_cast(translation.y); + z = static_cast(translation.z); + l = texlevel; + } +}; + +struct rk_orientation_float { + rk_vec3 xyz; + + inline void set(rk_vec3 const & orientation) { + xyz = orientation; + } +}; + + +struct rk_orientation_int10 { + rk_uint xyz; + + inline void set(rk_vec3 const & orientation) { + #define _pack_10(x) static_cast(static_cast((x) * ((x) < 0.f ? 512.f : 511.f)) & 1023) + xyz = _pack_10(orientation.x) << 20 | _pack_10(orientation.y) << 10 | _pack_10(orientation.z); + #undef _pack_10 + } +}; + +template < typename _translation_t, typename _orientation_t > +struct rk_params { + _translation_t translation; + _orientation_t orientation; + + inline void set(rk_vec3 const & translation, rk_ushort const texlevel, rk_vec3 const & orientation) { + this->translation.set(translation, texlevel); + this->orientation.set(orientation); + } +}; + +typedef rk_params rk_params_float_float; +typedef rk_params rk_params_float_int10; +typedef rk_params rk_params_short_float; +typedef rk_params rk_params_short_int10; + +#endif // _RK_ENGINE_RENDER_OPENGLES_H diff --git a/cpp/render.cpp b/cpp/render.cpp new file mode 100644 index 0000000..21a44f5 --- /dev/null +++ b/cpp/render.cpp @@ -0,0 +1,48 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#include "render.hpp" + +rk_vec3 rk_view_origin; +rk_vec3 rk_view_lookat; +rk_mat4 rk_view; +rk_mat4 rk_view_km; + +float rk_projection_hfov; +float rk_projection_ratio; +float rk_projection_near; +float rk_projection_far; +rk_mat4 rk_projection; + +void rk_set_projection( + float hfov, + float ratio, + float near, + float far) { + rk_projection_hfov = hfov; + rk_projection_ratio = ratio; + rk_projection_near = near; + rk_projection_far = far; + rk_projection = glm::perspectiveRH(hfov, ratio, near, far); +} + +extern void rk_set_view( + rk_vec3 const & position, + rk_vec3 const & lookat) { + rk_view_origin = position; + rk_view_lookat = lookat; + rk_view = glm::lookAtRH(position, lookat, glm::vec3(0.0f, 0.0f, 1.0f)); + rk_view_km = glm::lookAtRH(position * 0.001f, lookat * 0.001f, glm::vec3(0.0f, 0.0f, 1.0f)); +} diff --git a/cpp/render.hpp b/cpp/render.hpp new file mode 100644 index 0000000..6f22d48 --- /dev/null +++ b/cpp/render.hpp @@ -0,0 +1,208 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +#ifndef _RK_ENGINE_RENDER_H +#define _RK_ENGINE_RENDER_H + +#include "types.hpp" +#include "math.hpp" + +extern rk_vec3 rk_view_origin; +extern rk_vec3 rk_view_lookat; +extern rk_mat4 rk_view; +extern rk_mat4 rk_view_km; //TODO: remove from engine + +extern float rk_projection_hfov; +extern float rk_projection_ratio; +extern float rk_projection_near; +extern float rk_projection_far; +extern rk_mat4 rk_projection; + +typedef rk_handle_t rk_window_t; +typedef rk_handle_t rk_shader_t; +typedef rk_handle_t rk_input_t; +typedef rk_handle_t rk_texture_t; +typedef rk_handle_t rk_triangles_t; +typedef rk_handle_t rk_vertices_t; +typedef rk_handle_t rk_batch_t; + +#define RK_FLAG(bit) (1 << (bit)) + +enum rk_input_mode : rk_uint { + RK_INPUT_IDENTITY = 0, + RK_INPUT_VIEW_POSITION = 1, + RK_INPUT_VIEW_ORIENTATION = 2 +}; + +enum rk_texture_format : rk_uint { + RK_TEXTURE_FORMAT_SRGB8_A8 = 0, + RK_TEXTURE_FORMAT_RGBA8 = 1, + RK_TEXTURE_FORMAT_RGB10_A2 = 2, + RK_TEXTURE_FORMAT_32F = 3 +}; + +enum rk_texture_flags : rk_uint { + RK_TEXTURE_FLAG_3D = RK_FLAG(0), + RK_TEXTURE_FLAG_MIPMAPS = RK_FLAG(1), + RK_TEXTURE_FLAG_MIN_NEAREST = 0, + RK_TEXTURE_FLAG_MIN_LINEAR = RK_FLAG(2), + RK_TEXTURE_FLAG_MAG_NEAREST = 0, + RK_TEXTURE_FLAG_MAG_LINEAR = RK_FLAG(3), +}; + +enum rk_vertex_format : rk_ubyte { + RK_VERTEX_FORMAT_END = 0, + RK_VERTEX_FORMAT_VEC2_FLOAT = 1, + RK_VERTEX_FORMAT_VEC2_USHORT = 2, + RK_VERTEX_FORMAT_VEC3_FLOAT = 3, + RK_VERTEX_FORMAT_VEC3_INT10 = 4, +}; + +enum rk_instance_flags : rk_ubyte { + RK_INSTANCE_FLAG_SPAWNED = RK_FLAG(0), + RK_INSTANCE_FLAG_VISIBLE = RK_FLAG(1) +}; + +enum : rk_ubyte { RK_INSTANCE_FLAGS_SPAWNED_VISIBLE = RK_INSTANCE_FLAG_SPAWNED | RK_INSTANCE_FLAG_VISIBLE }; + +enum : rk_uint { RK_BATCH_MAX_SIZE = 65536 }; + +enum rk_batch_translation_format : rk_uint { + RK_BATCH_TRANSLATION_FORMAT_FLOAT = 0, + RK_BATCH_TRANSLATION_FORMAT_SHORT = 1 +}; + +enum rk_batch_orientation_format : rk_uint { + RK_BATCH_ORIENTATION_FORMAT_NONE = 0, + RK_BATCH_ORIENTATION_FORMAT_FLOAT = 1, + RK_BATCH_ORIENTATION_FORMAT_INT10 = 2 +}; + +union rk_mesh { + rk_uint packed; + struct { + rk_ushort offset; + rk_ushort count; + }; +}; + +RK_EXPORT rk_window_t rk_initialize( + char const * name); + +RK_EXPORT rk_shader_t rk_load_shader( + char const * name); + +RK_EXPORT void rk_select_shader( + rk_shader_t _shader); + +RK_EXPORT rk_input_t rk_resolve_input( + char const * name); + +RK_EXPORT void rk_set_input_float( + rk_input_t input, + float value); + +RK_EXPORT void rk_set_input_vec3( + rk_input_t input, + rk_vec3 const & value, + rk_input_mode mode); + +RK_EXPORT rk_texture_t rk_create_texture( + rk_uint slot, + char const * input, + rk_texture_format format, + rk_uint width, + rk_uint height, + rk_uint nlevels, + rk_texture_flags flags, + void const * pixels); + +RK_EXPORT rk_triangles_t rk_create_triangles( + rk_uint nvertices, + rk_vec3 const * vertices); + +RK_EXPORT rk_vertices_t rk_create_vertices( + rk_vertex_format const * format, + rk_uint nvertices, + void const * vertices, + rk_uint nindices, + rk_ushort const * indices); + +RK_EXPORT rk_batch_t rk_create_batch( + rk_uint max_size, + rk_batch_translation_format translation_format, + rk_batch_orientation_format orientation_format); + +//TODO: export math function and take a projection matrix instead of its parameters +RK_EXPORT void rk_set_projection( + float hfov, + float ratio, + float near, + float far); + +//TODO: export math function and take a view matrix instead of its parameters +RK_EXPORT void rk_set_view( + rk_vec3 const & position, + rk_vec3 const & lookat); + +RK_EXPORT void rk_begin_frame(); + +RK_EXPORT void rk_select_texture( + rk_texture_t texture); + +RK_EXPORT void rk_draw_triangles( + rk_triangles_t triangles); + +RK_EXPORT void rk_select_vertices( + rk_vertices_t vertices); + +RK_EXPORT void rk_draw_batch( + rk_batch_t batch, + rk_uint size, + rk_instance_flags const * flags, + rk_ushort const * texlevels, + rk_mesh const * meshes, + rk_vec3 const * translations, + rk_vec3 const * orientations); + +RK_EXPORT void rk_unselect_vertices( + rk_vertices_t vertices); + +RK_EXPORT void rk_unselect_texture( + rk_texture_t texture); + +RK_EXPORT void rk_unselect_shader( + rk_shader_t shader); + +RK_EXPORT void rk_end_frame(); + +RK_EXPORT void rk_destroy_batch( + rk_batch_t batch); + +RK_EXPORT void rk_destroy_triangles( + rk_triangles_t triangles); + +RK_EXPORT void rk_destroy_vertices( + rk_vertices_t vertices); + +RK_EXPORT void rk_destroy_texture( + rk_texture_t texture); + +RK_EXPORT void rk_destroy_shader( + rk_shader_t shader); + +RK_EXPORT void rk_terminate(); + +#endif // _RK_ENGINE_RENDER_H diff --git a/cpp/types.hpp b/cpp/types.hpp new file mode 100644 index 0000000..ad9e82b --- /dev/null +++ b/cpp/types.hpp @@ -0,0 +1,36 @@ +// Copyright (C) 2022 RozK +// +// This program is free software: you can redistribute it and/or modify +// it under the terms of the GNU Affero General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU Affero General Public License for more details. +// +// You should have received a copy of the GNU Affero General Public License +// along with this program. If not, see . + +//TODO: use glm types + +#ifndef _RK_ENGINE_TYPES_H +#define _RK_ENGINE_TYPES_H + +#include +#include +#include + +#define RK_EXPORT extern "C" + +typedef void * rk_handle_t; +typedef uint8_t rk_ubyte; +typedef int16_t rk_short; +typedef uint16_t rk_ushort; +typedef int32_t rk_int; +typedef uint32_t rk_uint; +typedef int64_t rk_long; +typedef uint64_t rk_ulong; + +#endif // _RK_ENGINE_TYPES_H diff --git a/docs/batch.odg b/docs/batch.odg new file mode 100644 index 0000000000000000000000000000000000000000..ca56d7979a81fc103273b0a1a429bf6fcadcabf4 GIT binary patch literal 31649 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 S)1L{llo;X3$%Q@$!~Z|a))659 literal 0 HcmV?d00001 diff --git a/docs/batch.png b/docs/batch.png new file mode 100644 index 0000000000000000000000000000000000000000..fd9773ab1a3b4e66a0b6d148cb4358e03828c984 GIT binary patch literal 101617 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 P+nbAW@^|VnpY+#SDJGp^o~}D+sSh@ z^M5@0tO#53f}Ea`y>B^3=DTq2!6xgjE^Ft=xXB{#N?x9K(r3ApEyO;HTnC)oeKCnq zsbzTdM-kpw>NUHj+g?5g<{Z3I*Lr(>PTA}F`rc8IJ?HuQv|&_oVuhwl4jrM_VNXHf z+P;bUX6anyb@>Z%Mh!k-h0MxMqB8d}SGU{NY*(a$`)bmf^ zLFu=5tCr5IK2ZDOWM=D|_^I=H7MIAn(^*@^%#qI9FS*A5$mO37^B<%K+Rr=kNWWEi zGBds{J=a-}*8Z$Pjqs{!rcSrOosGis*p|f_P6Q}$0Q~WXUSL4ey=2W~V|{W{`m!2} zp+f50HzcsWY=5d;>p+foor6^yP{4ZtL_c9ynj6qxeAum?7?I%;hmHWL0X$02gpcJf2Nf7c=v<@RfOClJJ zT6&>h=S`J%cjuxeR`YBsj_!H?8Gg2d@TwP21z~Phm@5LtifRLdlM}OWK_z%FJ|-q3 z4Rj{sTR<7P04Cy_F$uVPI`wIi;vE}o>M#}HY)c6h$OGvMh3k zUf*zVYKNHOA;W8MsiQ-;76aCMxnp7zKCCnWSBCr@)g%f1`{e+@v|%2gvn*<1MjE4W zPg?;s^plRn%kJhUwYK)F1Vu4NdEGp$Y9w_A14zjk*&k!Uhx53?kI}EFPf{ZyykX(1 zz_|y_3CW7^HTY{(g%{(+ zdyF--cWG7in4-RAt#%(@S~6Yr2@Ad~PTZL_e%W(c00knuh^T=X{TD8T*8CjL!Vjex ze6^Gnv+A11^hGq#5SbZD>g04ic7A5TrlqXLMSeQBEeZBb4J}M=1J|u*lwenm}<|As*k+Qq$x7HRX+UlOo~zBQ{c_Rr zoCi6MKxnvd0;r6IGCgEJ3dcmX)lJRs!IQR|KFK9Q9NN9Tajo=o-@TbG$8)4f=SZNO zHzb9d5;dFGg%zFdOO{0*SCx}D)Q#cbt<)^lJzmMY`eTM3ujkWH65W;{%3?o_Sy`iZ(K;L6V?fpkg5cE297(7;!?pbwuQ7 zN`_>Lx}(ccrZ%^uhP2u#HO-b`%w2-`+{&tqs-*cJMH?PCpWV+1UbOFOyYJE6p-%ViR>Ho<)oc?GbH#52V>if$T{FA*l^L8EtEdZ0>r1{S> zLarux<0UCO182bYKql~{+=!|%`TBXP)_5^rqqlrUBBM8jJ0ke%=uZw@#Xmds2fP6M z;Ia_x$tYy@KBN9GFK7GP&?J3E1qyUR=tsM{_;xix z>pjZR)X2c({)t^Qhx}1yLDA63Sk+9Q1d=PrFyD*GXS%_PYkU-j$y_qFis3yG`s&| z33)ciUi(FZNFLRv$4^^>{C+^cfMu(|K>o6^HJU{l1xQ7~cF|^J-c>w>1;i5cR$vTz znB_4Iwm^?@9^NtlqUW)lyzri8P$z`xOo8`E!ZbW&j^h^~^hs?*LmE|$=K9avFI?uB zm8sU{zPEiZ!2!Vop>Z0+|7~=1*>d7E^X|LwO`*{@72gLWCs$TnoVy40dM~Y)S62%s z8z(My2z(oyyVn@;n=Cjvs^T(0&SDYh3?mJ>K(Mo2iXG=F<;34FzmGv`ML>Hv7330S zMWbf=;i=nY#(Ox%9vsFkP_%%uEi`K=iTBTwGVH~yF}u^;wQ z%^}N@oby&V9Dk>~wWZTBdf#!r=TRjbJXj!S@-%G9n42&DnLO$e6R7{7pQa%S5-e7h zFU6rXSU>>P#a4#RUmp^#EK3|@=Dzag4F7p3b;^H*JwW`D#Je)w+e66Fd$=` zbqiysJvvxv>#1*+mXzE&c?R{{F^}Fi{K{PvUIdwYAz%G6&K4DZ~zbMDDfQ{|)f zKuSa7cpa`O(JvQOW@&&?Hfl@^Vq$hOP@V++au-GNuHU_m>=KpqRa~r=QbrNTncKQ0 z5dQyEMJf}IPZilwAyjjr2HmCyWC6F`7Rw?U&YgO}MeAN(%g@-`*ZuA{rX#T7@dH!z z>%jbpQysIXCO#bQ7zgy9uEEQo0v`S5NAZe-Z^=+PAny$znN)!4kq2=(>YgazG{>ZR z2JA`;6Y^gj&TY2~wDuV6F(NnLt&=4DET#G$7;@ZPHCAV+(|LOXhX ze@LF~m1~?jmcO<9mKN%QIM7ka;G8GEv}HvL02f<#CRsNvL4^oDw72LKLF|{YAQ8v* z!5+L=yYXlRT)4?N#$8fY3sD&Y9km}+Cqh3MQv zi1NVpxBYd>hbM@57*BCh1FsY;5I_v6+p%mOM$n^2RKSUh5?BlxJQ%#s??kV6VLlC7 zGPs4drwu5%4!;Cc7ON8pV5J@pr6ALx)Glo88LNP~j$ry^4zMzUsyTJlz$g*})msxk z2+9sHg6vINKS}6l#!CUqFtg)MR7PWLj4!E!&HV!9eG}4W)b#z{*`pAa_Zi=<>_6RE z@!(FrtzBA|HU{e|O9SxGo!f@(Jholqoq3Bl((*2P2|G4T3yJ+&F62g&JHA|V;YCWm zAfehqJ(l+9v%?@Y1&p7~(;7x#kdhI&Qo-=+@M|*Y(L-$z<=&0!CLsKW05n5gW`$Y8 zvULNaVpL;7w4=5q4P44J!Fe-aX_nGQk)>sg#_wUuW-%kb9n^J>{jO z4>AlUVQq=~pyoXmhk_3+76h&zIyz87Uz9|o%dPZXVqbZsQzG!0enDDf3R=5NfQBkT zhL+hZ34}SwJOFHG$2?tyio%ekjC+up};pRAmoihVu%6JE&J)i zm%!90dH%3w$blJXf9Ck+@&*kF9%yTleR;k`QdceV4k=gMsIgxLxa!q=PwcVbk+^rq zj-T2lL`M??HfAW34?+jolRT>>D72|B?Z+}Y?B(0mW@D&Njp9K6ctU7gt1Xu&ote*C2dDQ+K zpm~f-m4fNSn!)!L(D}*l`bBOLR752DiQU&~UNni^0~nTul$m)nlI>lte_Z33{hZRv zJ%|(55EiKGC$OLiOEVpaV@oaGc^r}aGf-Zj<}6`tl*Hh5fq8_$p}6kz5n#9Ap+>rK zx$S<=sUa9isU)73vcS$-s}NYURGQ1w$HJ!qQx>91AhKBp5fEynu3!nB-|1U%;EJ(S zr>+NV?bjPiQAA$}3{ba=poo}e{zHs9-y(6*tE}9ep69QAQPLS&Y=Axtewo90EbZk> zm&@*fMI+_zajfiDb`9jHuccp?(Wi0L5jhS z@hL|cU}ObzS6YZ(gwThF2M~3lYEUOl-7%znU@Q~Ira)l#d?P|~r5G6*dtXQpjYw3U zPBznV@BU=d6K9z8Y+R#d)Uf=y*$>g+w`4fsltNbagx~hh=myXIew(y}0nt76G0Gg? za5YVB#1h#5kvRP67OcieJP9CCduD+leM0~~b84t3PcAJl`z_sgDKj+sePC#4z{X;b znSD=use5o>z-;gltDNZ||H{Y1G9RZge$NaPKoUkZ3a{p@V<4xO8Ccr?_R`2CJn%CZ z3xt}0R)qvogtK0tg4m$;g;`pMP>|-2e8=Wjv~59MDPpPhtCAD%^Dv{8W>WVdCE`Ue z2M~&^F&fA+fyn_Nb{Gpt8{rHs`j5g3%{?J#K-vS?AgSIBLpl)8*Ma>@dnary=p%`5 zLcmr9YHl_VSpgc05uZLV&<*+Xq%T9!uJ?I_NOS)SHHhx^=GldlxDO2%{^QX>)F%uo zP@G19=CrrJHUSK9UT1*d7#2LL?L;3xY-j2U5rV|RBm-C@_#C7VSMwv<{}vgc2MIu? z@oVeb>xKoq2~JouL7NuA&x?OL znL|wD24J|>WfvkC2;k!z`H&bHlLU=$x4>me0I2J%tCUK|;RGQ#byMkq=~ZS}@htia zfD;PLsVn#LQJm&r#U3+;HngVskL*ke6ToV`#vqjmC1r&u$Fm`jc`kxPSJ+eFR*yDc z{2O|ufdwUSQgTwF@QN6uIHNNRhcA0j_FQkX{1ih2!HW2|$hN>#<8xq)MvRZYsa*sq z(N}_Cu#7?*>e4GPv*%wD8bOLJz=y<_S*V&Q9Nri%jg>Q|7>&CGK0G1$EGIcwqh4bC zC6ALG$AS>TB9~N-ax^1nCTtD9*aPzaf@kojfKJgBT~(GIg@EX1p6)$4aA$B7y3A3d z*~~Di1D{vBCdNaa`kJud5O!+LLeKQAYPX7_Ag}5M>DikLL|FkS{EJYJd{j|7w*#P= z?1W7tpybErG5mVk`W`l7AL_*@C;Gh=@E6uK$!r0KbX` zsNw%(fe3Iq7g8=mJ+ESz`?Nh{6xo41LiL z|2latzrpMIqZ_)%3MB&-H7|9*WTgbtWlDnYewTI*21=k9WZfUFv#rq3)4OrwhTepu z=7o`Hv5{y6(e{e_gL!NZjE}2U5u(KgCWa@i=oblL($9fWR(0mvx0!y8M*-HW{7%Jg z;0upsm^xzagrh{u{Isb{2f_^TfumSkXJ_a9vuEQ6Jw3hvVTvq1hUb8Rdz`iaAKP$& zkINp$9;U8p0;%tT9yy`mhNV9`VKQM7FjML7sDFXE`p1<*eUa3yf$nr0^&knjyyzOI$?Susdc0bJTq+PcU zO3u{rm&2%_U<%>mZ$_*!C2r{$5paBNfX^QP_eDKk{y z4)y!4(+dZ;$bg7|?Qo}f`7ai@h=3ZxO2v;xq@VtvWH}69{5U+4^~COB70<#SnAmkZ+=rM&X9i>&HPEa%Ie z-_6j7JKijIO_*|<9DAfaH>X7X-caZyWKX?QoqTXP9sUpzi44ETAm%Z~y*a2qt%E`* zhh>{&M3VUwa+W3@ZD{mf7wmC}0b^t1!rHsDmwX(K1P@*Fzc*4CjCGP$<#!Ba*_97J z-r0nDn=3W#mtzoH&_oX4LS}B0?k3R=T+DxWVeu>f?EnhNP=TR| z3HP9eB!?wyd-pl-+oQQ2v?rN)AHDTm9vr4cKR%16-Cg^wc2{xOq4Y74m-O zM#YfFlc#?;^`e5rP4YsnZ!`)cbS5TW=l9i~;r*1zCro}8SvtPUWg`cV`IPQ@5n~N+ zsa-jN=)3Wv0ZfbCp-r*)@Do7`A@tw|C@8p7+#j3?XzGX`oe!Ap_g+}{5AxyPrmfQp zo+Z`d0{H=?N`m7-ktV6Y(UcNINc-&Xdc^!9MDM_S{1Bn^Db=N$J{=LfRKN)C-da6H zw-pBXrKF^Uj}Rjx8;|)nL!8AbUAVA(8E{`aOXg4HUVMuUn%r(BA02q^8`&8Z&I&P< z7O1&K9g70}6u=QgeiO38m@26mmI;d#|GZH%4~*`<-ttmb?oOwe?l^KU%U5RN^!jHO zgLjX&jyR9?j~q|B@$`6j43vh{CsuApHHgw@w7I^*&SF6pJito|RCaTR2TuJg5fYs2 zlKv*HnAMDAta)) ziVvEMdi>50^my=*gWl3NsC&W269x+~Lpt&9j&}8?cvaRZ!ua9GGr-FY#6;WRM#y?8 z8i{ec=yRu=4}+(syUl4N^8NxcM66LI|K=nYvhIgE>+Q#SI3)vhHLS2a;=cq_9uj<8C)S&~|lo(RzTXmI`6#Gtw>uGX2 z8{_*KHJ~M_mb*?M`N3QxOg=*>&}KP*;sjaqhoAk#ZjFu{%b6CRTj?iu|dNYEu;5*^O30`v7|Y}Blx@_Tm@o`o) zcFSsjv$c4Hfm`&MC zo<<*M+TNTlWYBi}^nk&5Q=OK_l=Lc5k~RRO0O}AlP>e3@c(=}&#OXp*+%*eBitRI9 z@d+*0HfR$P6FPv{sJ{tYQ9*-F>|u>gU6KA$;>(@=g+cwtqH?1WQvNwrl77XFb4{;} zt!4S;JQe#?WX;V?zM;XeDe&3BXQAKU79$KV4uxRo3jHTT>dlNxJT_=b-)u!iMMk!Y zFvv=3v@pW@9U)|DJ;3OrW8Oa8yS_4xCWnqtFAA zjP8hahkwHn%?5aQLBRwP($5Q*g-;R~H*f;B0SoSrZsVFfGx`C%<#6=e8U=Vhi{6@& zDWm5mf;#pif4eCb5U{qStXTzPPk;w~WPn*T&hIV>p#~7W;);hog8sHDz|vEX?c+&e z!e4}<$Be;|S{zXG3-5H~x&b|yZU6u$<4)z^il=zuC37L&mqn-c?u7JZJq-Rx_&$J~ z0{Fu26+@Z}dO_rb#t8Sg^SDvq=#Oa2wpIekI=YXYK;dT61D-yYg*1%jzY$o`hUDq! z;}A3k(G6a)f=BQLw|_%G4PKUJPB_OVqz66oCf0-$S?QB2{lBN3h=E;Y86905+i7z$ zGB~WHu#uyoA|gF%9PT8-xD(1^zS801-TTwf7Dfj$;E*4UHurs{gSBP+Z7ekKAV=>< z8-ucn)H2GIn0X5{Vdua~;dgMC0{moYAm1?*y#BwNqmKy9-|uWsWDx}`6pq`j zGxJmT6>vfh0uSKm0;CGyVpeZ%$0x}r(gFHXqPKf*GQUsU?4|y-cAHhRzT`9!@=*vy z5A0~3>UDhjdIklgLJcu^b!vEi_Mj|x0-gd(0b`F?Xj+Z)%b@@t>EhhU+u=@x%LpKs zz)B88gAix}_cDQkz)S1{p6;LnYpHZ#X)1sW9zwBR9|bJ-npps%g~lEs-@vdUIMvUX zr~=$vO=)nYFc{VWTx2j%;oiFP{yuzi5eNkJ+--Qbn zIJ1L>?OnnpTrGsf>*BacgKH~pTFq~2nu8Ik$Nc|%k%em+sipx_~7wdWsl4 zPIIY39Z^Fh&Aw=zNKUB`WvK{nWTc^Senf4Q01trIE?Bw4 z1l;d>2BZ!S;!6Z}@S6RhuNRt=MbJMYVCU>)ASVivNkMP#BIWQGweTx6b0^-pR@B=6 zV0MxobC&)y_42!e_zP$AoxZm=x%g_L-yM^e{1W|68X|B-^{z z_vDK3jAj9;{oe97i=bC?>+ei+W?tLmmL^=Yu&Z6s^zG)91CE4Q^dbevh}zBrqAx|A z*KMWa%OPGN{I_OW`)#G{>SJhp6qmc9(a^TagZN@`(+IZuuoFF{=M)@1Q{O47Z|t%z zxixQx&|V*AD}3`zYWv~?)$VI-!WT8{hFH%UWz{}A`5?U9^i9|a9@n%MJL#|GYFytS zn*~4x72w>@dPupSJBmuGm#H{h-&!wP1nUJ|k)tVT^HHs|7I z7CIFX`cmSnZWU@D$Wp66FETuE(Z0cPoJ}mhtx9S5vk4}%?fZ55tq_`OIaaDCG}TRf z&$9;3C^5QAs7bKkRfQH9+pyx79{xKK%s})ss!Z*gp12-Ghe;=&M zG#;l#9fx%iI+!EO`rYv!R$`{xaHYD?Z+`9l>a+#r2yS`VlmHZYag$j2b!7p zM?@$6YUt5Y=*u1$c=|#{lGVGy@IIEzxf$ z{@Xt=ZDe~kModAf@4M&ze7rjv801qwyW$(~_mlGgYYA1yhrub+vF1e#aHgOhP8~>0ABc{H zr=YOZ;1UW?dpPlFXSZ=He0D#*h5YbvHTZB`F%MGq9EF1l&0zl79!Dy**vp~{fbHG2 zZr9$qd95?CYG~kV!$k>hOJofRI6Q-Rz+1fEPXWF24}z|oE-a~_v1Ua@qX`GA1~CYL zCaGav6jl(O>Yy(bsimc>n;J=sOg#V7_c8eP+l7no3hZTwqAwl8S9Wujy4)bz`Wt-k zN$@FnmHiYLEBV(|+&RWgerU0%%AS$D+V{ZG1)qlJ09w^&e|1*<( z50DtLWXB&qvZt`Dy?lCOPq(J$Brbn*x>r%l*pCAdMq$YhA?-~B84nNPnIR|Hj|dNF zG9B+^z;EKuqGKl10{^|5zG`P!r$* zr(Q97p{SOXRVVkhLiat^#)DiB?`{uJbVfxr#b0zbTVEi*6F}qp&J4Xo}jK@CK)`KD>cECg(x0y<(H}B$g4p zoiuvFxaU`|yh~siK}H!0->x2IQ~?uRb>){(MXkSFaJXIaOgk#w(2VWGqWq|;BXC(# z9+WsQK5Q6tTZR&)z1)NHaTVT!<`Of2)!G_|(H5kVewdde7gImHlv^;=>|1n(#k6_# z7$IOh%(iW_EIYFo}R)GZZoCuBrxTT&%`$4sDRBo*Wh6^4xqOL}Xaz0j}i~XDI zH;Q$Z>CXGTX=*i0nr1|FI+)+SStkzX%u*{fSa2Sgm|?$e)EfFRsM09Qz*w3z`<8QG zH&dBW!5fn|+$X&uPwH$Fio9C$7w0g+@EnR$aWonWucKK3y$EsY2@p5V)^&{fx=wKKEHlXHHC*?31^|zYVb)o{C(dD zV4DD9l$CR6;40OPoSa$Q#!}+=AI}m zPP?0rlb{Ik`9#D0lURZb*-K0iZKLbKN|SLg85ouVXMZU6$kx!&h@KS$Wnv~j>bZF? z_}qH77}JaV5cw=Da=AG>c<66T+MlW4KQ9sxeh59xhX?Ih;7Grkn0}h=zBKOPi^e^+ zdl?O@zpbrWGl>9YF<)|4Wbs4r%VmH|!LK6Ci1_TN%L%`l)#0Vn;%Dn5`-jWj-meaq z?F$idNh_^^ZOgH)`GhJcEmiOXt!l*>b}}L zGPm;Oll?v+5C0~I@0z%d|CSAKilbUE@U$pu+#Bi}4J;-CGy~pWy*E9%gnwrVJdEA_ zw(BBYUBd!}1@NDWz-(czHNE6D8mb3Qm7p?iT_*wgBpFffc%(=fJw?w7hpN*Kb;mlZ zw#xr%p2+b&4I^4FuThO`7@b=>VJAF)rnTElDGxG|AR~?-14AhtgLQbwhFAmqZAKtc zg2H{CkhrJMgGg33eo2ipB70j1aAx_z_}N~$o$iPq+++kT!@nZ~sudtl+lgWobTFeb z*f=-J2&N8#iGfbnl?@CZZFh_?OAdd79xdUGS4Z0l&f*o|c8(LQpW{==D>2J1Ka}q0 zpaizenLy0sRMv&JOa!gTMRsmN*VL+NYhM@xH<3aZZ2exD`BhS4;Oh*C!Mqi~u974` z*&oW@aM&UF<6S*$+FWKC9t7zDTUT53L7>*|-h<4XNC1)Xd3Z1dVT6sefPeNR%sHwI zX*zO~1W~@-kj@I$3aH&YeW!g*IFO{1xW{iq7l>)FceCN1j#dC=wRLqAfPab+3AtP6 z)|k{z%LRLAX~2%>E6fK-ojafx@}$9izWVNWu)WQhIufw#;tp(RxMFuPG*CP14YB;c|vuty`>G+0vd?eHbRS{hv6kLlQ0 zQFp*>8txK3X)D47HH`pS%O=5!y^#3t{T+6GSs>fE3Ap7z)~B%2QEr3XmY+l4vt$-F zd$$_kCK*+%E!|M_-jAe#nlnU!hBSTgdheZ?XtYK?hWqJl4JwMJSyGldUZSsO_cORl z*acmgLT7EJMp*@{K;1M2$Y=;bW33cW$TP^= zQF63ClkSSX9O%72foT zcR^xqv+u3~bsC59rL!zAQw&N-WF;i{!t8u&#AVkk1!`lQsB4%cZ)&!w< zdMlvJSQU9c_&Kl2dSx#eBLPiFq)5i6Bme|az~7k2&bH%)@6~m-8)2;UpNmxJRL2S` zo~(ayDcjz{`+=3j_~Y*~_=gS8@Gy#9`%9|YtEF42c1Co$PCGcRZ>R=!XSx5?9TR%F2!e*MyDq7-V3mWvnj}nFn`q* zK@qy2OtClo-TLar;RAvTVz#(8N4cxFCMNluAQIZYiAlBw>@qp>TiVA9nt<6u@iQ z{r)w*vlA|3lK_A(EjVL@2Cua5)s46a6nezcjklZ3)-+skW@ZFr-=rSdynj>i`Sf#* zliez+q$)OH=2_pYE0eEh(Sm4ZQrwyDJZcl2s=TvlX*wsfIxdepk$)t5*1@NC0)$vo z5>ZWAF)Xn;hh$lJ`B;-85zF4+z85hUcd4VWj~<}3RrH*~Q52;{Gtn{J zt#SL!^k_OU3#Q{SGYgA1eLD)skpP|;tyQ0^RGt-QM9KGGb_mXsTpu{q;~&+(>wYZ5 z)an$E+6l31ekyx+IrwA}97(dPB*~p0nBAd1NgPcBC$S?S^0l&^O%)SU{3Rx)uGy5O zQp+c8ROTpz&76ef$@d@BOhr3yztsE!ZZ_IEy-qGYZNSnD1BCjI2b$d8u^F1MawMbnKYl>y^d@X`db)9kK7fw#w6_aSsG=r2R2HE+O}{?b7Q4s3?{N z?oFSN1iBaDZ`#a)>*#Xv7X{D}cL7o3`2g&dJRL7^UMs{ysixKm=7U3VzPY(PQ!T67 zl=rtynZ2>n^T_O>!2s$g2q!ntD8}GzhAC9t8Sx$wDiLTLU>`MOAbUc?G{Q$r-TT4r zr2nD@D!Uog9Z1ZRX_Yl z5xTTTB3y0#G}zvz7dbC+Iw1`3B*#92XZ}&McYdH&#NL=Uo)wr8x-NCcaBNl+!OY8x z*wh%?(tng@3%*p?QL?!5#|`vN0M-ThcR?w?=+slT-uTU68w-sl>1v3O#~7@VG@43U zx3SeegRW_=Bh^LJ)jDODG*wDR!toFBs8a-n&V51f1ZT|+ihUx?XP2)2*M%ER@OZZ7 zKM3Ah+9j@Lga=;-Oe-_sS-v!ud8L1G$mAgzOgT6t6+-+){#og{9&PCy4Qe6O>rPbJ z`-P6G7xMP=TpsLFCTloV1281s?FV|Uf}T#*ua+@w(km9yu9Rw8X4~ zJaLq{0fXDZ)cE83nlSyd+W=6(194rqP{P5ra)Y~$8#_a+$ z$ZVX!hYMlmCIKzR_7x5!Q^~L6WNEe|Uc=25xB#YJ5EN!kJM2D+tGB0>FA>Bbm^TOQ z=a~{tNvtJU`F`B_s?3Vy57TLLEJJA#5r59ZT}9@|t1rY!gxS)rKC}D%l*057snl7b zi$QCIW1?f1$sz5){YBwPKPzk#LF_f)|Bk|XT(j$#4QL$6xawH&ZO=nm)Z&iPaFO@Z zx~mSPRKv3_ftBvtzBLy_Wyl|1(p5<|DVET*pOdbKYyZgdWEn<-r3WkS23Jb*VD)$8 zz{5-Facr;U#)EWRQ22ODrYYa6Q`0(bF;R;NT*YQ#Mk~}*KJk(gqKqd&b~y>|6%@8$ zxwJ9jD*i4z3T|*O2=x3ygIpUSJ=$P;KPUFR-8GcAVfAo$fr2M+HzZ8CJqkGwHIqF57;QLsh{VgwLacI}1ioa4Ol#{kcT*3Wwt6 zL}w479$!qbJg<{T&e|jUDe}G3a}3?4%3A!5PaczOgrfnrQo#wl7%@KzzQk(GT{?I= z8PJ5m*$`>)03tc{%E4c+mn&MY8vSx}*P;B5_aF|{N$hd0B+vYQJOgG@_#s{RMaB0l zKF&9iulYfVO?B6Z0KaVoZQB)j3eNXmY&HpOBkraB9b!YcJo&Q#zJgK!1$uRIUp;7L zAOcPok%1gQlwxFTP-v^IwDyckzuYgRGtbJy(B{4jE7alKrT=W)bLz_Q@8`NXpsy84QHXTjsT*f%TQmwLNiv?m8J$7@qPk*=2GCL6OE zIzyQ9#bY2KaXX`j8NIWDg4T7|a<@`lV{9n$5ou~8{iG+x|FkZkIGvkIuVjvwq}|DU zh4kb@y1Gf@5)^c5L?i6Y0h*F?}%WyDk4@&1xbC>DfPD-*1Qd5fvcsf;+ zi}b%zQRAZ?d(e5au++hA?JA)AkuVt_7C}>?S~eukbcT{k?8=45-Y?dfNGek}Ta!~C z^!sRx6=IACDgo$%))F?mLMc`@qJLCLPkE zlc}lfXkS<<_n9p%7jXbXyjY6w;1jm7b?J8zT-;`)fS#cU=K0~c6-=CrZ^Zz1tGPt$ zJ5E!W!TGZ;rP1P-LLm7VRssQG+beQMU8DdPPv%OE@sy`tTGV+NaOgkaskG*nk=b_z zg>^g`^*|@#Bdx^^>d|J?Do$cZokzh4y;wmzbId~~ak=w^x@(>hN5?{>nBHAf^3OZR8|75kw$+Zw+ZlO20xx z=2^gXK&u+O)55+=hYu=%iAI(9qq@6yf98N83{pqW{Yui}Ca|+Q>!ONT=bhQ*_(cJu zYr#_H4cwF`;nzt3*#?%3{sdAA{B z%kblrLcmO}@GZ`49Ln;U)UT({pzKBs`8ZHkqGx@9^@>VJK7_erN*SN-s${AZmN?$) z{In+y$!6G~lk}Vw3Xun#M$crb(85@N6}a$qS_lkOI3KF@Ha=xP3|?=(CI?)GPQ)!i zFC~X+cW_b_*=G}fXz-bZ_B{#UoYvwISmlcQa=gK4hOo}sY=Eq|bUZJcaw7Dvnm7G? zO!x;>0T*DnjibZ%Y>Zs1uNT7@KMp>=wU=S;!S(A@XHD%VP6F;>$vbDntG((mZhTX> z7{SUs&1FCrhvL4M`0xd^G0UA4cPE_v}Tvb_NGRbun|5i-3Q8(WvE&Cg7IjFS+k*K#iy=i45o(bT|qi0iK}xH+t()1s!&t8SQRZ z<`<~SKAzvphPf?KI3#~j36s@Jnn{Bs$3F#Tf1efzdfwsN|Ex$7uVY~|LA4$-5gDQO zm5V~2+M)hJ;hP?L+L8-dg9~ruDHG5nAX`1^V7eyJJ2>Gy2?E)Ts#ZY9-+$#!@Xe7k z0AKI^VmM1$2`XdTzKS9trQ7 z{%Oi54LZ4etc!`F)4cASYf7=f4^sPouXPmeZ{74#Z=^dho5<|rE;sk-;ibm!F5Y)F zPh%S$mr#%yz;?V@TO4t?kHS^!gT|f0!wn&rc4n0ktId5%4Inbn`8?z-zf=TmslYYE z9o6@0CbW7U6;Cl(n-?Bl?KK>UYyDG- zhWnmdxZ^bRG7u)k8!rbgi%t^mY4U+BYKOu~Wtes6opR#$tG3=^YBG(#z_l%V$(px6 zN^H_DmaKz_T@mjRRsbN76!x)u4Y4PgM z{KAZqZZ}2FLPI{~YZ5&BLMaK=5j)!EM~Y7-ys~XeDYa8urPs|;&xl>o?&V;@24gaUNwF$_n@Xv1csrXF8IP;?E z;%%MfqVCmbHz55m816whd-Q&PolY-+44GIO>Em%|xD~5!z)8_^U*`vaq$R zNYE@_Bqe~LM1sRFt58_h?R><~_1ktD3QuYe&gkS72%xkqL`9XyJ$7;oLKsPE|0ce4 zmG{iQf<~SsJm+N*xt3U^bqV12uZS9^D;O8oiY2U_#Kqfo7T!g1&qL~;VGTixOETny zG=ltpOj(d!bH?f!m8K1M8Q%4;ZGL znsWw23^vCa4+M#kxx#|i<^KIv!UYS*z^r}@Cb#9ixx>3e2U2b|b`zW}8jhSSaKf93DRk4412 zOnbpG60E5+yD6UdI=3r78&zq>2>h-Y-%bG0ClF@CuLCsSVUXGJ)1@+#bN+`DhbY3* zxJmjyqdm~e`Gks&ntdLLltU0kNCD-Vb+&K-0JSvf9%DzO6k%c56>u)oo)b$SJYih+SnyP&L-5!ble*%E zjm4j@g(5#oiSj-lltXmtS+IEfH1;YZ(K&Y+MhcQ?)498PbXHzZF6uQ5MCsZZR;x!b z$wg|jF>sVp8PQOa{CR^u_76ArgrhA!erDt+&@$8C(Ae#&Kd-^JFWj#`$wiE;&gn|ci9MUh)boJ|crponn zVy^d|rWU_?<%@lIWH{AJ0?}+auSqPuw%TG|uC7inGes`(s%zG&wUBhD#~Ps*eYXdS z%iAFK$UwV5sM%_g*Vs_o;P_pjv1MU(8lF))fKHJlve!W=+nymWJoty%tHSrZnyN_V zLUfn4l>LU}xN^q1_f##9*o>6vC`{HPO1eIV$?}>yO0!?5b>UA=DL+b&d^5Le^$C)wNUTt?Ce z!OjljZBWT4a+B1b84`H3RiK&Gyufk?u=4l&Kgh)A5BLj!Ye}*^ZKlTySt)9-B`7@L zzkW?xiFG~3DxVlvMSf8OhAYqfpxxCmXn&ItbVP8v=SA9+o%~P9Ax;MRo169ZgPrum zS8^Xs8wQ^t@%M9y6u7b*IX*wf@lHnS?95hcd&vdguWk6Z14P)G2(9kdT%dtPVHfgA z_9URU>3UAy;?=Lu?dvWCoqB_M%G^O@{W$H-6CRzcm|x5L^YY^P-i2`REGspIgI$KS zIOSMVBstCi?&@>WbNM%&LLe#eynKTw?WH<9R9nD;-E+;$)lD#<1^&59xj_2!0mKr& zKw-toU2+~-G>2{pZpRRTx>x$YXJ@L^?gQk4!}1>o$1K3jviIb6W6PAC0GH=usNbK?fpsv7O^P9a#ZrWQiFCfmM*^6a%-gmOz20$8(ZOS5+Zw zNa)_X{8agR7%cO$$wYUq={?Z48PM2iUt>D#3GkHLLX2K`N6CGj(k@(Q#D!s?iV&o! z&=KP3+5H;_CgMVzVD1Xney<>p&`aMtpHAZ?z zdurwU#5it&m;`*k2db-7;mNb(034+DJ0y+1sG_h=+yF1y-+J>H|4R(s^6Z0~SUZzt zuwp1*dRuH(77d`n3{RM+qY`Im2AJawM7|0sFkZ)ic|fKXN`0wz$O6Vj{LUIyHQwR` z5X%sKlQw(Dtvyl*nSlo@IF3PLo}B1~yh+DjPw>NmSM&|0g86PB1>%y)5YX%F@gzkb zSbMZ}RYBE55XSM;_tZY#Z3iT+D4C=#V}Rx{!CMO!EF_yU*Z6d%pK2!Uj!=W}8dr$# zgPyWP;T_`mnMHXFi-`ph>sre7D~(b2uFb!Tq(Rh+y*K~tztEH!v6zw1{m)^zm&KGz6WW@EDPUPf#YEY5|5c$m0J9GD) zoIq`Os{6uZb~MM$@2B0At~TUk)BPkpZ~cDu-uoTj+Vb?p>D~6~HUT2{ys%iUkc@*a#$5B}SZz0neccbf%I8FtdMe&VwrqoA(bCLIDr4S+s`!#HUYhuGg{dBIhYY zznpM3<0@d88=8G}i!j(1S&m=~PuJUP4#_~Y07zPJbary8m&-c;_NK-7H}%T>i3Z1e z-l8%(V@|^IL%oVMJ)`wyRgwee-ns3%2U^ugo)4(WDlhkUzxs_pfv|*Hfn|+}nf9mM zSX&{KQsDY!d0_eau7#C)>!(25GwmVmJ3qs}mYAJ&IYs-SnDmjkf|pIj`u!x z&~@$Wo&(+G0eA z_8d3TdsqEDYLb{yY9J#>hh}_qBImoR{$1Q{1p-Trh0Fl_jbNe;Xs}x*Fsio($2c|H z&|Hg`d#0O0KSaiwGExGLzQ;W7?7#J1y5tdbrU?FM!C2>M;#VhaiHAs%UNhpR991_) zvm_*0)p>XHW%{)_nP`Qby?{&GISW;gVR&537rqIQe-t44xT60)7X&e8XH#0PeQW>u zGpji3mi%h45PjO^09R4Y$VqSsWGL48_@7xf zOR@+<_cBp*wbExBH`Nz?bEvVZ=dG)Uz$*-0{&6brEK2SgW^`>Z7bS}4ADZbsSQ)g2 zjx{Hc^&%o!gJ56t`MpAA`ASLeU-D(REf8rsx%igF{~iz~BzFEC=hc+2sg zn^4fSyTj%hHCEL4xigAC!KnvX?S(;Nl(4Kcur5_FbIG@cHAQrytY zzr#Tc8rVm0Fd=IJI;qazTfBm`2OY>A_9s;C^hHsfv9z01-QA&c(!S%F0qieRQg1-a zXE@Z+pdpSYV_joItZ96kmuW1!?yCYoMp3wV=#=|}ewnKwYZfD?RHCHE8LS@4h&5q) znG#cWtLiNiL_C0%z4oZ_`+b?T4D}n`N@vTwr@}0P_jmo*J{~SBZ}W|hrf_ZZ>Ar-W zB?glH>AF&2vulPMd>%;8{(3CQb+o-74Jx2l?Lk3CoM5scE5(&gu7jy|^YhE&K4U(U zxEq4_7*arH3L6@hmM zOB-&GYtS&>sqD*ZG`>~J4R0KYn1HOqA8bvh*O!}*Z*g%WP;C0oYX!PlmA$q&+-7%m zI*Awt(A*#bLftQO@R<8Y0y^wBz=cmL^B|3nNTXH3%534dNEzf<2&5L0?7v%wl`=o) zEcT_89`Biw(;XQ&VXJ6RCwstv-eUKG6rzX(p@le2h+4yiLEgv_;15XQc`ZD7$nNTM zK*B`~xWf&AP~#J9 zWBKo&s~er^0^guYi?1T9hlQv^6!m4#|-LM7!lqizq2<<-Y>o|9|BH;gUdvkWW6czY$)d zpaz_Q(+k(h;0s3`gsxfyCtf%%1lMD&Tko{mdmdLVerBkMO(lGo zI2ufcSjlC^^uszznMRY^nINRZS_)jR)0_Wv{HS*9BYuJ|NY+*5|F~f zy>LUQ2!)&D_FQoAzyELptXD308L$oms4UlWK)*wRBBg9^vuwMd5 zg#GkHbGO89L?dCOt8>cB=dxR$MQLZ}kgaSxto!d9FV}C|94W`z0rs=+thT_Hw+8?OhoN+XF#Gq3tVp31Z1-MTSQbkj<(2tAL3%%jUIy&cJ&AXK;Vkn7B!I&v(giDb2(P6 z{-qXkY^f(V&-nS@Im5ch@eGaoSX?4xR&yr1n0Kw5p}uBzCFW(JvA^2yViay&L)X~2 zd*#|U6gLU%PLBwHzyFeek4Wdxuc;}%U!%`#QaaVSh(=xRdyhE%R(OR+>c3o;dG6eV z6n^=|eDOi+*w9>TH-4!~O5r@Ze%X`yaYL7MO1N>Ct>eNv1vHkt(|KQCd3dB|0sKDT zt$A0TxuUqNg8#y`_WXP5nj$fF!OI2n@}n~PW{UJEWTH~kIK40ks^Au#q6$;rbrZQw6H~vo!0(NOD#D|Z8G%XyAXA}po;R7nMW^Bv11vxQhZJC7>3Tv zMlL+4*K*8*Hs<}Q`|6{M=VqY~+Y_ZVsj{$$*1{k3;D`NCg5mKFNoHkza3do=o~j0w zK@C+tg-@E+40tCEDw|7<#@W)@8h6%+>DyYn<72VPgV*}lFQX#T1ebW;`)le(bwA_C zPv}w%yzJ@dRei@K@Y&ZR%adrfMi${>hn%`Y%o? z5H)^JICvc|KrkAx!Dv*{xN>7VYMe)`X2+PWRBwio!c867jLqqUd@^t|{^#yueW4Z$ zhyNA%wLymE?q`ObW)G|e<0zm7aMwsneR8;Ubyn-uZZE-;r#x|7-`%SgB$}wOy@KmCBO^!dl(+&ef>Db(^>A_m{_?jUA4q++F``u@AM|9+BHi$_M)_3!6c% zOTUjC_r6Kcg8K!UrHs6C>HJC81ulgJ#D}3@wej*%Prr(`D4ih(c02Z$Y77(*C!xZh zDz7rQ>+Kpe7qWn!(49j$sR?2kUJkZ3L%70(iwxM3w#7;R83Pi~xQzLM6*5EDcDa0- zmA;sJIU&6wNO>P`NZ;?KHHOK`$v&sx`HSSqa~8HQvN?E-lNKldRYHRK@e}D|I_&u6 zAW`2>;fJn4%k>N}1@%N|XlTUBrTKKeLDBvHeEkkwZ8?GL(p@F@@zSrp(|z@9)XC-S zQu=cZ27_9zzgfu`S4fH_KQzgn^2^Hxbo9P1IA~e#@qtoh4%hwu0dni>DFF?WlEnC- z*&@zE^Rwjt4%rH*nKmrgf3BItpihc(ljBX?xeUbi+^uU00wO;8z7S;E=~{H(ws1AB>??oNV_-?KK_xl^=9+6-D|em~S1r>Qc%Oiy2s01WTkI7%K+9YiLk- z(=Bn?+|NQ2g||5DCi3%^^xKS@3_UzthwkIPV8t%t;#5Ov#77?iOSZw6(fYNz0Q>YO zgpbIlQvn@vAV@_7eEcKTjBng%cR>RMtJp4Yb$P=c!$KP&_EeO|5!Jpy24I*y@IybX zRw_^9>2AGfVOJy6v&JMwt*d$I#>fR-?yn!=%vmfIsIZcS5cQAvjX%=`1|jzE*zo>$ zKO7zkOr69fW2pMm$boFT*pdJV5=eEAw^9{3XN=jiuUk3%WX_0cK_iWe(ZRcb&dKQb z=ol6${6-Jr44%}r+6yW zPmhhQ0pEGz&*ruzt!89)4vX`hxqSMABwJ_@{o(K)!0MoJ?}>nm4K?UlX_RqBQmX}} ziSeeDiy`gMyFaOaE^rNz1sU0Zsy7rNa+PqLBAC^oR7VZ;vzAy;CG3#G$;;loEQpQ{ z2fE8#<~4rE{E$ZeHFBRTp7wq)yjSOGgkk1yR5tV-a0JoNYl>S4#eLr6kC*H*U>%O( z4m+$zA;^WUT}qLfG9#kvuQ$Vp`u#xOQw)fIgxp*f4c*g*E*ET5X7YZ5cbKr|`ND)A zWCRc)+228@ZsZkbL_d9eu~?{C|Ni0N+{grP6*bl#V_l+gH|VYE+D6!BjYoSuGC5eP zVJ8;2zq2b2>c-tYHO;ML+oc|QPk>9%B?@-R@|98(?F&U3?5VwFYVg=-NJLE^MKg5q z4=PjT4*8i$umzz?%`fcYW`xgDFD?M2|FSSiW*Sc}#dW6(a$Fg!|J1UKwHUFWY!A19 z2bXqv>n9l|>pfN*M~(@scYEcVyoTX>mX=SxC)E`yM$L2<>bB|jVrzARaRz+CMAq4q zDB_z;RezLkkaA~yt@U|Xc|8)E)ZfwoB1)@YTUc9RXAGkj+xx_sKpO23f~_111s)*D z3?c@-hZn;*MR`U3C4IQrUJudtZuHxwA5phHMJ#PqnYuCR`oSgV#-4bKCU|n0e3Q< zT&Q?2D{F-^!$G@*Z6Xe{|V_Z1@74U0T;Nsr0DcZ zs2S;hh+G&uLwxtX3+0p4tS`M>r=sM|nvhOjQOc?3%tTY8UVhFzQJtb`KkO^z6fd?w zC^Qu0;MSo9e{VvFs`fAnaOYO z!))TVG+U@t(*y3toqrLfHgk0j=GrTh9Z~NZzU%Kk+P2-BV(sXtK5jiVwMO|Ro(mwbZ_IEYnmE%Ye89BZFN8IL@m!gt-t+zrezv|pf16b!&aYgrIWgQ`%@Y~)H`+UE1xkKcF`rY#NkDoqugeNa3 zooP(Uw37K{WdJ0WNaGE>x^0<(bl9OH5fZ@iPu+C!j^Alq{a5L5a3~HtBngtvtEepW z#{PeNy=6dELAO6V=g=JzN~eGzAtikPNm05)LZsWEYh!^REmG1F0t%vl^ie=U>F(|h z>3H|S=ehrTzr6dy$sIFmt(jT#Tg62t*eK4G1?OcI4Br{BfR}A*ZqLk>Zhfh^@3-J>%XHHZ`YEs7WQmKIl)JDmV1^8cItH5#sgj_eF7!NJ zPZbDiD%f;2c2&GQY@t^n8@+iM3)m`?(e{;le(On)+My%p|CAN`2 znc03*jvQ>l;p&wZOCA(Y+~ylW=Wu(q$IkknKUD*ZA51?=<9o(V`scVlwsEofmhxgZ zHl|)sLh|XG2g@odDjVGkDePNy2iqpGv9aY#j`pS@lHijPt*d6chI;UNRkA!d2o{(Q zhxecua25u>n(yLS6x4lCfHU$@x|vv;%lPfj)@G`5uiGR%{DkMy{u{@A%0;rqF!Pw> zbtN8G+$T7=%>RgsK1*J1v|W&v)|?pN?ejd@-|R%(D2;zY5F5-cA82p?#Y8Dpgh9gp z8-A3m^A^dW_rkp^jSlHx^WLMT>c@84yPX;UO@q8Z-Y^XrT7qBR(a>dmF;rg`76Qc^ zD9_p69gZ`m@b<-)-P9#rr*l;b^sIbNR^)3c#Gf?Q1+`8bG((uQYeEj)EKRMfzJ~Aw z!xjCyVgg_japTWiNS~k@lWHv%4rnCS`qc}Y4B!L$M&Jz36ns5Yz#^F%;8~8W*u6J| zlgv68!)=ZTs77l|7!uuMDH=U5A<(66s|42dlk02rjM_{Y zvOj|o?|@FjhC+S%S0nq3Z&jZm(f8D*r>zzEo(#dz5ruk%*9R~S(0G^~-x6%Eg43vp znmSZIeLWsE(%hEaChjhd`Ap!9EfW6FbM$(4~v1Hckr{>EjtDam=Yk0e4Bu){&@uZF!APp$J-%c-I=swrbldL67C@YufgPRbKYVx zG=~HHP3WG}o87}A&Y3Jy^bhwZ+Z7|9{sxn+vd0+AMW?w>y(ytYG3)knZ9RW0#!?<^ zO9`9E;?Z}msuPEKR?$Z?O0&plYD?om3hFBD03}ShXWz*PBOjQ@>>k>_ETgob#0ZuV zFftrtuAYvoH`CZW(&6q;q7BF1(=6jWcDTD&_9l;(nSrGiB8kZ zjI6Gu1FbLLDAA*8A89PMO5ReWTl)yq-q`q6fY5=%?~ETp5~IWZzHeoy{Ie= z(s>{c%pLySXG8-5d$m6kLl1f!4sIWp4*jj90-rt#tP{DeBh$IkUHeJ0sU}^7!rM4* zrM=h02SRZt-NONj>Ta&@M>2^}2&l!02dR+{_YSt*yusud!vx8M#(|wuqI7mTOYw5V zXShn}fbIMMCm~yhPprW#4{Qgxp>>KJ>t}-T#-i(mj>EA@6qca~_R%jN@!i%J-#J6# z!f;G90XZ+iCK}G>g-M0*8K+pL>u-RI>lgA)Iyey8OnfOPf!w>_Gfb^HO(K62!5Z{D z7LJ0yrw%vr%B#k($5#~yM;xUUXsO0mLFYFmjj8EBy#u$5Fvy+SEqT4gDq$ku=?h{S z~Jcr_hlEZp40V3PK0t;VnkIVK@x~_MBEZsWVdCS&7=Q%()q`6WdyKu zWoO9xtSU5+L0E8Rxr?Lt>V25(QF-|3DX;wIh+~VWX&cv&=~Lp5+t7_8cq@^gOmV%I zuHQIzeM7fz#cw_lokyVc2!y)w=KTDV7_t+XZ0xv|Tgo`>s$~U;H1&3-kW~;v0xaw6% zcFsPSpA1^8tPP7#^j8tT&Q`6~{W4&MY&3y2_r70z4wWPgdm}F1(R|CV#1XErN)`L2 z38X*U@MkT*hb|8y6wn-qDF1=0v^2C=rJ6%xV{c}^pHF!&cz}e&RZ?(W_u6wB+WGl;TJh?nip0a0i!HQlo-GCUNBGE+ zlgV6V=RC}mJ+Pp`Kb2xm(G#{&S8ro`B?t!TjsC5V~>QIr|5v)IMSyCc%_<&946VQjX-CJX@*->M32 zO4cGy(qq?Y;fU8L6`K(VgPovZb=`{LB5C7bkj>TC>v!+ER3`E`0k^MWRX?nH?M#`T zcYUyJ`}R3a_=~8`6Kcnto0H-N#5P|u+V~J?)Tdu|_IaHW&;C1fFrrk#4D5IV{7Qp~ z7{D$~9m~zZYgsDzk8$tFy|yDMOrdRrUY6o2W~KYvVCN{ufrzIdqwC2}~J-Ou8u@^QLhubuuyoggffqSo?amhQP$^N&Hr%t`BzlHTI8lXD=_^`qGgfUdTxCxYkg@#en|D-Kc`3>9W!}K}~O_sti=YD_NF87PS z(l}ORf%ZB!IJj2Yb7!u*Kmxwh;&;)fNG55F&J4%LHj9J7$hb#li?2=wY> zXTm9aXYB)EcNRGD`EQwL27~}tIV|1K-02Pj(Dm)#UNaN@YBJ_hd{q)6;Z zYjR2yOjmNMuwhTOo<1)py5+N-GW9#wiIx3I@yO5ln2SC3RxonBiVs>{NfttIH95`j zCbLwG@PK-wBp_p6w_^mUv6kN#=bm+E2i$y()d1!8h@yE7&vz=NWDs2)YLQBH-@;PW zW@n!h%Hp8U4qUr4&F5G5cU$WtWibSRN&n`W=ZiRyp@Bf(g>8P>0Gu7t+jpfcIFZ+@ z!%Ez@#ijByW6~v0CM z_w=7-tl1F(Uj%1hoLRPYJy|3IsFI&LXv|d?M{_JcBo{cN`OoLzzrX(9chq?9|M~#| z2r0qY|5;K|Q*fLA_kkJq|8rQlB2c@yRe_u1 zo<6@l^!y72U1tK`n>e48)T~SIH3raxYb;fCMeEyUJ1V@KL zVWnF86S)J&3a7(#Eq|Fi4RFLHKw&J?YFBS`VqJJ7R?Jc;Yqw4840Kk?68K6CBJ zT8L&M5d5h;f4sDOS*>Gd(Yt5o_$2UL93Nn_guf(GAqo+G0_*>AI4sM8M@CJxs3&?3 zg5L*`+67%{(Fks$lD%_IY6^VxDFr0=9H3y<-OFJXP9Vg6{-6}EzI*jPB@&47gWq4D z{N85)rhW5Jchv-|g6!*4T4C(;tLo-2ez(?>1AMdt$AZlz%!jM^=u}>3oS!NJbYf=~ z@OUW2N7JRY_#nxL3>jk1BZj=hSor&5K$;njh4m@+&unVURW#Vh;yc)riR0182aEV{ zVCN%5-XDITEQ8?YRiQ@vJ76E!x}G!sq{RlvbZV#uhaHqh%EK4{Ep&RM4^o}3KsT(w zdOSFR&FTmUF1d$!b$SOHR;3qj%bEwz>d+x*4rg>eZLtj?VOJkG-W4CN$gn~Uxm$yG z=V#^Qz%31jWnFaGex)|z^c||Y@qT?JLX6h%)lAHYmL@HkK{^Tgx&6g`QJ^dwoa`+G zX2FTzL2)9Iyo{zop$n>?ee>%fX_hcmIBsEKN8QBz^^H*6RfAY%U?%{|e=rd?kspbh zfPiq=Rt&f9Gax3m4x7MAHphuFGSaw)+?+~VFzf9(8 zU#3T+##+YjxMJTNkgI%836Z%|!8@>iG4jqynY*}DTNUp~&bTA3&t44=haqZ>dKdDY z?Own1M^r|oiIZ&}hTyAS=Z_Z;?W`L@ZYDqTzsvRNScse)+d>$d#g`pD;=fOx?V1o_ z^>!C;QOaK>-^IlT7bQx`atSWzbG`)=wKxFreSZn!RO>!9Ic9UF#y)HNjNGIx0Tvu6 zSnS$?-_zMxUvfz02DZhd75iy!xu@NZFt~z@O2vVNr;P>_QwsxgMGVIvcYO3vzUFoe zV$pwo^mG|Fj|&X*!SsUpkqr*U&+uTe2gqVE#A21Vm#ggtTGf1`vol=GfWC8NsGlcv ztEOgkt_|Tmb+?j_8e+T;j$FRI)|5MJ)>EN9zhxHZGA9 z8(XnyT^sZo!}0?2tmzt5bdCc*1t5$HfXJHYmDC|$>)F-uvR}ELWzlH=vgNK6sr~-H zC4{H!HQ@rXl}|dML~ zmT>ebTJEiAkFJf)(PefIc-s9m=GID(qW(gJsJoejWga`{-o6Ic=ci>g`x<>D#(>U~ z!C~1+YM@&2Q^H8sGtFwG@G7PpOnU4t)T!1hju->shQlq#~W_%w!`At*>O=i$>D zdf(I~#={Sx2Ad^&?$(CR9j!k|uo?h#kPjY#zJavkwb_;n(~ zHxc+`|3__fdx{1)FetGGwE_{eLu10KD*C;%tlSc zvC{bWD7sr487l2#myNRNC*@AvvQFmYU^n%)OMu6tLx-hNkZ$v;4N$#xtnyE!%@B5! zMf93X`T4_Du|#Mln&#lUtE(LH=f(E>Q(u|?=2Rj`?@PER@KrUrDewYuPs2yL2Ok{v zNw$}@)PeFaY0@5p#K4}~XBQ~&gxMft&9F5s@bjg!^Ap$e9(&jzFOAq78QpgPKW6wZ zV+IjG4BkV!y^P%QZGKw#WvMmpQX*1tyCqInU|mFClq5tM@^{an?TEJSNbJU$)Mf?# zc+6{W3r^=GUySF(>Pu+^eMP&9v_1;3{m6Bs!q!8C0P)>Y(l53g(fkMav5D0#C|82cAjEL{ z`uJFx1QJy*=YxQ*^MbAjw|0G#e8vBaj7@l6|Ipm-a2kAfnGn!RdM$iGnBiz~<&z|J z<3QGD#m1Sy>!iXEnu)1Z9Pw@Kx1KxV-rV)!odoCu6VeMe_mu zD&yvj(JX3^)Kd3Y7yGZGe>H^#qj~PWst;Vk=`G!Rx^5fba(_yyyJAN#U;(Kbcg6}P z1MpFXoy<`^f4j885JPnw^aS zEX+wRk)!LaZ!iBurdlNQ@(dO4Mgb*_YNzOE1525>KOg9S$=I?&Jw5`?Rz&p zt>a5{++bU36nc9#sP`&zZqG>CrhwFR)K$pD>D%{-xr~ChgC{zp<_;q7-d4_RrDqj> zAG|-6$xr_Io9Fk|ur|(i!7+sf{RdYaOA=o_q%CNneJk-S52=Mc3Fm^w%-+9<(Vc4b zKPscP>~61@-IM~JW2=^~A9-#3Vy zuoaJ@jcKy`8}pY}-DLVl*qlwdI60X~_+9g`0h`A$KmETK{<7acs_Da}9f}L7x7$A& z&0ZZD{pH|_Hg_z;jm8ur!z>>~;LYew_k-rR=p5Z@?eVq9y9|Bcd=EOA#RPThRT@#Q!Rj&OhhCTU%0KK^=Lx{rp{R{86y22wKDvK!@EvN8b z_1Pz}MlY%tgf`2bMJL5rB!SDLPCUNRa!f;pl+)pOs`lpiC=T>^=+K)sJ=lGieR`^- zB*JU;dsj!H2g<>;QLwr;YK|DRER+W^zaO9EBBQRHZG?f* z!-L#rKvfARC*<*VMWVxYO+}SylCteMDECZAZ%vzeWU+TP4n)1j)qMM4LEa<W$pxfbnt@48RJAXq9A*`Txlrfjl;IIH30l-@@ z9)X!D>-j-}AtLW!ZDR4o`7s-?!`dXrM=x7l0>K>Wi?WozPwuXqg@)>2Q9xd32foiA z|90&i3njx{;TF2DaS1RLCxQk=kE}zehu+c|-!TEGX5gB%)rM}f@q=nV<{?dN7Nhsq zR#nI@=O5Bi(I;u+XdNKkCW0_3)@4UK?7RTkbK5bM6Ca#Oex5%Qr_&LX!5abITz{tv z1UCG(vX#Ml$=pULb)DX)15VQze`17J9u7K@60)nQ`03rXutTMb2vPBiXl0v`)qG0` z^|5ZwlS5wd9cl(2?LxYr30;ETwPwz^6m^)i;aD(-9hx4iP086A5TFCH?wldiWT}KQiXU)Xi31JrTJo9FE>Eyq8REktFTFCRoupW-i@=Xx zBjUXRMP*CBC(Kj|dLuA6t`F+GN626if{Cbx%c6pa|Ix^nR9`GdN#^VASZ$$pM`T@mxbizG_J>tu=hWQN zaYSe+|1iFwDt7vdg+qTER`8J+niVWg#FrwC5|_cnqsJCpCd#B|nHg|B#}{&1OQ)X{ zqkvM}ZHZpi6cC|qBzhve!sm_yHLwm-n9mb%X36Xr&QG#kzt)~J2X5ebCIY{+{#Yjf zSiyv495PMjxI3k&_GDcAFl>Ppykr9f<7z|L=+!r>It})D@zZ9ppPrwrl^C}wKB^mH zddtDnii@*ondrx}TsoLJgu`O-r9{8l#`lf>wW#nl@z`_a(=vzWum>TiSI1=;clv1e zTFsRI((BWyWlMomq-V5n=r!mkEi~)Djtvo`_sF4-jIR_d-Qwzv6B6#XmxIly)1?^! ze^zm#>f5zKG`ie9}C{Hs=@rJo0p=EH<5aN2=vo6aApc zgWSIPcbTa(c!li{m3{FL7DaHZKK?C7Mm=oH0KCIm+<9!BX6pijS`vN08)(>!gfbvj zklcqmIj*6$g(hf{!TZiWZq z$q%Usuk+u0SD+>(+)1p9C&G0*;jx+y-2h~|;^;f%pq|W|8XYSzR&g9*w2yTS$ered zw0qjqgL*u8-2UB){AvYKXGxIjwM6ht1mSh#PHv2!318@3TE)msiyPooxe@W%l6c+z z+?crcL%7hu2ju2ZdD{6Kva_AD_-gvej#U38T~oxtbf4?#o0Dewlc}&dQ9J?i>bgt&86hM;EOJY~C3rX3+(zE$61& z%fI*2UcxgY8Vh!*zrbbm5QSAF=;We+&5eMgc5(C5lL8DucI3{6G{=2*X1LPMmu$`b zk5XJ~j$_lRcRmfs#;YJto{3^LQ$a1*8n`F55g76B?)eu@zJQXbpfta~jk#$7SBH=N&z5r2dhE|+&)>Y- z7ihe#vv>Ypz-?hiYIaQOsoFT#<~n07FrL8-4naQ*RP}Gi0TH8Etw2CbF!W?WcbsT4 z#Wet~=>ec)0Z@0m|B|5|(-SKYL0t$=4oqCT3elQreoIdj=|*yyO9=r$Ykh;2=2w5q7a>g@RrSD1s~lyxT5kS z#|;x2c=1<1F9_=qhTA*%9dP928fv%1&33aruos$1%XT_1bl+<9<1<4io8AiocE+iR zX3yZql$C=*Gn``FxK{uY#Rp!^+^a6oep(S`!g}V2jgP=cMW;1bmum)2mk?fX(jyE# zP#82GQw$f=lmG4j;Tppj8er5vSh{I8Z~*4&e{Czv0DJ=1Gw4~Gp92oVnpl86Su5|- zGOM zfm3Gz?3D-wAV>=@!6Ss|Wp>1~PaUrJ0(!UEk%t`{b*INCuG`BUXBnN?fE_+jOy%NS zxOoV#n}#)zgLmdeD)Y+j2e_*nQ@G@3bRT|J-uv4tV+h_gxu2Kk0v+|Np+D=@OV3UcyF?`~-wm*F00 zxp7>2-4~z+6Bif3;;BPfmm7Q?XEPZYP&~FULIH~sx*mqFVE`Acn1DRs#TNQct1+!B zGbfxBzX=;u{^vKRDk^Y6UKCx+oB|R?AR++YbL8|!!1=&U0>=er7+YES={u+h46Hw% zDj*)YGr{MC!Z|o90b#K4oUI#W|C7pAk=42hDK~puWbxr2X&Y`1WmaGjhL0-ggAH(e zm9g+bZF}@Zg+7_^#jkvQ9E%5!uMxoPqJJt?l*UbEp2I&?E_WrzN zHsiTb@hjt)7ceh#U$FRsS^WaQIY+nLP_5V2cjH%kJ=T6H;bi?kK>I%rUvb4A9PnV@ zN2a*@Ct9EDrabLyZ;w7sK{V^ZM2En|&~;Lvhm=#+O4pox$>G)DMC*UIAPErfj;~VN z9|y5+hf=NM;l7PL@+u1qsqOLHxpePGVAaN~usGh}v0_^D3aLnvEL%Z=;o4lmc#iA- z-_{9v*`+o5R!>}1!NoLj(f{V_pyrOs-ug$${#*4=My7rxbM2?nFG>4F`1g8wZS>%+ z7~QQ~ax>W&dah}h!qRw>qZpY)%5)a;Vw;yMKXu&qphiJVV>m4cyn8QE^b4< zZ~onYTUe(m!O61T8S3XTf0dYk!sIvtA{fLx_xcYWtC%6EA14Q?EGdYD{_9Z zztZ(*7w^!&a`(L>WjOGSjMkTf5$7)DYv7fxI~N_jrp)$Jt_iz`GZoKsoKkSaI6w&! zh2bei)>(3aNYY(D1*tQ}fEOfLLgs-w%{rDVOt_D?;P-)G{H46AMT za0IInh{=EO_=SYsM|OJN5*c&M6smJxSihT1Zvk&e#Eq!~QkDp*A;rR}z}P813W#=S z&u3)V=z3sQ2JGWjq9aG=z)vjGQy74 zSr$vXs+N(`@RTw$_yr)2F7fFz{zX97NKdjbEA;FwF}fLL@^I|+C6)X|TL*;QjrX&R zK=Mv7ZV2cN=SB*;_3ti5KXI<9s6?D?P0Y_5%GDk69%|MQqti~>&bMG}do&Di1XjR{ zBRmRauqP?B4bH7LnAkw%dj_2wApDg~Ft$6EJrXSp{M}(QhWGlYugVP^DEK6rUWzma zJ3W>VM8DG2k4(sK-?Qle#9U8=;S%wzXTA1Vn_PiA`*lk6z%3HFIdHxQ<9zTG;GBTa zA_A|c{jr`=jKL`7QbRavKflG=6>#s@hO_TRdQhoMb-5WJiq&m#3J3NFDgv-;KSEXG z?p1hFOtUAxm@_6HP(!<7aCUw>;S{aXo*oJ)h&@NFt9Rr6x)`{Ju&90Xr`Mwcna*|x zcpU`8#z+D{u*rJ`nJxqiCftf(eHc5HX7fQ@UVilr$+C~Uyi_A0l4*$3>1oI1xH93( zT|;5v+SgM}i#8sfH`m2+`})N0){=xq{5t;Z<0D{4m>w(f zLJ~{R?XhO^<-okP)CFWGEu@EOGYJ9I3d=M+yE65=Kq8cBb`FlxRz9wFw~`T)^@pbR z(m!ztoIc1LStBk>+TZN*vYu^?s0p9lsVqy;H*|^NB&{6~`S1qYEC1tKP5#&&cKa(( zneARGC%ufl*lb=^yxLq7c+%h=Ik>|;d5DXmhw*ZV2wi19%6hWla8|An z@Nqs(7;#V&C>nTUH0wIIhn`EnMwZIpRKK&zR)D|`Wks%Gj~7h>q&I^t(H_j z4&3A0Chj2tH;SW&Ko1TKGhUG5d|BWO4jH8Vd9HDgh97v88+ar@aLzs#XmR5CLhdL_ z?xM;^)HOMWY0WX+|vfOQzmER^ed!Tb#0g@T|*Snfvb-&j!xiuHr_d>>-h$=92Z}qX3W>_kW5vX2u5YKJU^Hq}%Vq8~92qAC}R~H$$=IrPv^S z_C}{Rn=M8c{B&`3a=zM?K_V2#(eUCo@zaH{H#P<3jxxT>!gRV#V}wYs_NV z7YO32>1kd-6*;{8eLGU=&32Do4Y*^yohR)H&|GEOFUam4$C$aLQ3zP6x^oBj!zGx> z7Bk3AU%3lItu24eiaxzXnyVs-r@KIqyARV8*Hg zQq5>h2@kdFAm)hbOW&+M^4&c(_2c2)?5}5Sb&2{2as;_2D$Fu6A4_e`YFPOhr*+1+ z+j&EEA*GUR_5zB(x`*p@!`$`O$uRr%$abFZ_6^7-`zl!n!eju&wjg<_8qk-m~s7X zSGj+ehE>vG?2E-KP`q}lnzW#A%KE{`4Dm~PCj;9sD)xbe4zbIovuF1N>R2d#ff|Q$?(Ce zOp;PQn$nx5eAm}Jk4o^t`L<8ljCMRPWnSs<{S2=LXD;9N+GOXxN71H{Hn{@xPmG-Z z&Px4kSC0)h3y%mRt!jHD^qvwt7R}t9tx%|5%M5#;>=XEA^UZh55IC!cD*p9=DFa1sUl$U4={QB7*miBScAtb30 zA$Y$-O{O13X8d@-vmbTf%pZxI3TN~%`*0jJmC@{YS5+dk)-3BJ;CrW zC9`dfays55`n{pZ_{&Skn4+JSMWylYycWAT4JHDT>mB&_8rk=5D8B5w5?1ktx{0yu z29YUCb3R~;i>q}gs5fxR*-&E4@h9aX;K`)05Me5Pci8${HBo!}T~B!Ym+&U6{!F^6 zzWefeO$JUkE!=-MT^TZ`fejTc&Lx*()9J5q(uejZ?GG`EJ*h}*P|1qCja8t;g4dTR z0Fv0lRt5I^8OjamoaCj(2#Cg%8;teT_NtrdEc@{9J~mjz(})Z5>a-EkyJxBs;s=+i zpw-8tLVUM#tGKqdclwLYNBNMGN4&~XTO~WASN;CW_gfCZS;Iz(16v8B{3TufxV$8T zjI)*u<;LnC4?{M@?qRLkh235)Z7PsSB1TEyZ@B>;&`)H>rG7w_Ca&s)d&%#0EamY% z_Tae!Pgre+YWxoP+(z0-jr9oFX?!Wu&>kdVB z{E^qo3NdvPk+)r64Rz+NkGq{@nV!S@bqoLj|G&3)Br*W+`C1M z`d-389y{H(gd{JeSFKpd{Bq>QGD=PMHmJXmTf>L z=|ksRF>IxJmpO9n)3~lFF}%Xsi=x`0-eA{$?bOE{XBp&AlgZAQ{f;hBBec>U6<$HS zZY07aXreglh=pf&7-I`Fw-L`zn`im@Fmnc;0V9WbmzDw!3(6O9>l2NmBDaQFoPJbW zW72+HRJi9*sC2Z^+kj70Uy@ISI5WRpcJ2~^MUl_?0ULPd;2GuAY^bN`!RGU&nT|C& zDK$NB4MlMMtw*2UtG_rbTJ4dmQ1(lM&g6oY&)5aweV;?9oCTx9*hI+%Vm|PfM|0kL zlf7s0X7!4ME2V^Mt&v8)xah5x3~!@85?WA{@l)P|(o1|2` zQv3OHClQ?vIzJx`>IgTDWjJa76?Z!NW&*f^6Ha%nl-51Q z#-?f6KM!x!Odn+Zq6}?+!Fvf*`D2%x+3?;xjc=JU2sUonM;S`r|8a>-o35@!%sflsx1z|Tu3WV2j-Je_#1=b&s+2_9H2iJKJ>6(Av5Q9j1rfjd@!|9C< zEn+h+bmKG^HI!RBg9bB#0G zn=;7TXxNpY6*(zxfX4wF%qibvosg?WMQloo`WF{qqj{&@wF*606bMU5{Ls%nCl~JWh2X;d>9QkSyX0woUCnt^eG;U0IuHLre07)*gH3if+?7C6YWNpq^K!Ia-M{ z!Pu?J&f?BteKs`()3R|?7A1!*1yZ?y55&~ZhN=#m0W&P~7F&)Yg+}T&p&B#t4@PEY zbU8@0FX_S3J*Gz{O6)?94V3n^#3gt+Dt(k(al1&0Lo7t#8a5vv#{abDP*sWSAx7OZ zQQ^M^8^juLLaPZ4jZVJk2?Wvg%}efSFA?8sHDZ6EisP+>{jxMaMCq+b%(%(wx2S@J zmw-wS*CPJovPDMmCD_hjfWVK7RmtnsnvED~ZDYIf>i3`R_}J&H{FHFvWGkdw zm&IJc%{zQy=!fpT?ZQo|zPpOK=oNT2So##zH&^DRhvvM!Lb&Egmo$H5J z>!0}G01%HgfsFX#X3Kr-N)CR|x5}oB_0+N5k{`sGRtFJ!&xz+OA1cz!)p8R(dGc6| z9Qx^i?Uhx8I=~JGKl&-4x>{HpjC#+ZrIi0E`k=A^Fo^W63vFY2#}|D2-fiF8>trxEcsa!#I!wg;Pq>Cr$!I1N3$ zO@z1z%geK<7z9i9q-s7kA9i})%fRT8t!`AW&E^Ub;OQ%~(nGvZZ=Mixq!4HfPNBIi zDzRr-IR#aih2CS-$?Lu2(b&4YAv^+JsOy;D#X+-Sr_0lT$9_uNl*ZU7!kew(O4JcF zYMkI?8?K98kk{lOL}Ox%1zSynX6C!;lH2Zmpn+_zfl_5nhso!?o+A&tu%-pEY$&sI z!$Fpdfi`n-;_t$zVItpdUysnq@=lB03ofP$oeTGZ|L0||?oQRG^meAns(9tDK#n9Y zPQG2R)X%2@_Eh4Cq4yM1@$KBMNkolGx^N6gIOxJBM{X7qp#^H&9obQIybhdljHE0U z-S*h3OqH+}kx$R^`rbFRZuq^p+J^ZrPz93J4GV+~%Sv_##Uc-Y9wP#tl&Vkr+5% zyG%L3_)ZU*zJz<3EZzjUI7a;Syro0>0}RFX&N& zjqb(*a7|sWzG=w@c(D*0dCOoGA&ar&h*2s89Tc(O#L- zhZ(+UNNql7lw!Hpzgqja{|dy(KfE$KN9ASRXBBhQL@$05sN&}%6VI0`x+F2 z-^X~I2oD}pvwNYWao@)ZMLvy?Xt{7PMK-|fYXuFnENop4)-s5YR{cp4B=;34Jq8id zyJ^Q<%A*fpGWguDdDL}wcU#g}0QB8|$zMTX@o^NFWnRnxcSao-MS2H8M1Q5paP~>J zpz^8$$-; z(Lz*iO+l7ozf1;QHna#J*au?hLy%a%c$@jmyBpZ)L94dT)?xT}ne=g4`fwrXPREa? z2Vwd(;5??Hr2$812sZ&A06SR4ALV8|8gIgGYLb$|Ewu6Bql3wjyfjTQJfBuJZx|>}&&~a9BK->C&BgQ@mKr`` z0UQUrf@i4gSVsH2XAOradkM`bqow2@l>FdW2RZp^bF)Z1_Rb6SMXmsLdUpxC>t!#x zZvdg(7HVtvJEX(g4ejeh=HV(aRc|l`AToy=Ecn1E8JrBzQvka29RVOz6%r218<|QM*|takYXDKzjnt_&+wLOY9BQR3Ije?OzYZ(0qv<>t8L4q4-&^GU zT)k>ixMvh5Jrzv2@a3@t>+XdKBphMl<66%IZgKwS}GzO zqla|H$(=v)<$qwOqWbzJ`oodsxER`2o3YB25|3`mygh=?a*ln-yG;W~?sZ|s-E*29 z32j}eccPc>VJhyt8xwS@tfNOd@Q#+6miGVa?YrZmc%nReNQ!`>BoPUcB_m04R>?VM z6cC9LBxewjob#ZPM@>yvSG|5!)m7E+ zecvmM+I2RM$=E+`lo($@EclN}@^*%*+V1w~euE>d;o zv%DZLWyY37ZW_Z{T6$Gg%lGK9^I)vlwUN2a!dbiIOVH!xKUjcRuU9y;OVU5v z-UpY5ZO5cy?M$>GspUSZ@TB_lt1I3iN9L_K<3uAJ9N@j5d`VU*|{6PU*ZQ&UX9gH`C_k1%L<7~ShG)p8gxqb;mYv$7+*keyV#-`aE;K# z^liTZzba|r=pUjIyU^-MT?Te(%uem8WXYmk1}q%&l06CW29U@0zK?L9(+o(V{n#SH zJH7n=SdUt^`jK(}P6^d+CM6!0YSig-7%}##=a$_1S5rGz*X_HgN#EvP5z%=~7Q&Uz zHRULg9h%-=C){r(zVqWfb5ur8;^HDVnyjOe>_cI6EYgxrP^wyALfkG=x2lh4@gw4f zfvx(%y?#+~Pfjx)I6PizpZkvMOc0|*_gcKszvxed@T0qJr*)n_b?U(sR1YfyC>bwA zyx*bNq|wNc=;1MPgHIFGNnVQxE)v)JsJ_PG_wa;xOCW}yAZ}iD);u&4uNrvzrHm#g z6%-_{smi(Rxs$tNw>>M{-HB2k*Zd0pF0?A2=4Uh#gO0Pyj}fr{ zsGz)~^CoQp{{s3xFNlq*F*EsE`UEDqWh6gyZ{@Icr3IT&t5CYeDQ0-R<(*gu@a-WL zhH)Vd+~>yUYCi5pEipMcImG9{j^5ndyLi>e5rV%jngJSRVLY$;{E@hd!|#zEXy^71 z7DdkhD1o7zbdbA7LyfVQR`h_wWiT+~LK|5IvGCk{(LDyMoNJGaxskU zm9>Dl(+3b&;Nc&Yv9R(|v#TD9Pi?n~_d7`tZ9{!o2>|{Fld9%d(#S(!b+A4mKthv@ z2~uT^2^aC8z5kEYUYi`8#zTR1M#w{7qw6MSurvtU!v8HZaeo{ORP6r>zO|E>kb)@3 z-#h~VYf~?@+bwT2SlXHna*Ej1{HwHz`U?*z?ZsFaZ_@L-RVs;L-J;jvyac}S^TlES zsF(jo&}BT04F@qtx08}_w>gktZa#>IzakDKSePe(1a21>5Rm{{8(~m6g4Sc8{tmo# z70vf=4j2vG#s3G(^RF~+70|b69jd>unA;Z(A5^D-8vy|AFW}%d53J*FMFn8)zg+fx z<@>Mj1u;I55_s4Ds7CDeiN*ecf^HuPOje}>Gfx@u&r!4hrKb+#C48?z(8&Mtz}6cB zPKpUwV=3NRSOUX~H0=>jY2KZ!C83nO6Q<$jl)a(AW5aX9?|b!&ox6St3zL_3#ga$O z%VTaPoo>odk@nqpg0sv7qTToofIC?&qYZ=) z--V-Jgh&7=IBG;2!WlhL3KaE3k_farbEoC~qS~Zu07Nwt) ztFc?8STDaWlVjkQjbTpGG>;aQhHUh{azCk9)r|`E3z@5KW&d&=m=Nn$PuTgm~49i-#Bb)uf<8KAeMNV%)T`BH!Mm7Ar1=iHC3098|Bi1*Lf;H#)vLn2|f){bomz zZs6J$6=dr$t#3O0Lhf~@wc03m z=e5<7DUUyDl=LO#)!Yx(rCe4$$ZE4|d5q?TQ;2EJVcElTqVc-4gOc+f==MK+Pru5Z zEi?0WJ(QO>9L`QpKRp`@JF!!+l_(EeY5sLCi_fWf!}O=JZeXhT-1UsuLy2HXV|QOP z_~3x7I}>0DH*$Y=)atr*nRJdswO@9hpQxHH4LRnowMPtBtA?_AWe9t(R{f6s4#yN@ zh@vEFJ6z%UWWX>Is`QijdPd6OlNK+8%EV^_?-RQv+YPtgcbmU{1vYanZz*W$QU&L+}1p3 zhESPGC!Q@~uJMy{dG)4VvO?5ith3pY|a2@4saq2*7?XUIf(m9?75$GWLB@kO8Q zH{ihSeY`QKIK4%-LriM96R$@^U>@wfMqVs7y5w_ml z{iTo2=|)F0GK1_}N`9|&5YaW<;Evbqj17y_p@ZUh$CCSfJ!H zOB}SWK51V1#5BrwB$Rki#FowgGt%jB$CTgZ@GZh@@#IZUv-r4}@Kk{Koa?P#VH&yi z`_T~3p91pbS^=FsQ36TTv+1LgHG@(m-#Vyg!!CP_+3i@FgS^6<8C)N_F=^=b`4Xj+ zPl#Wr8~V(5*4Q@0rfYYyy&W&<%>V92zOUNUego|q-%d)5>22mo_n+D1%FpHXST2~8 zfr@6-tahUY6@CVH2W=~#GucBPuPR*|;7($?g#BcO8Yf@osuJ;sCa!Qq*Eh<2hW)6| zGBH|1G3enHpf1w%_e(bs!xoB7)boMh3A1ku)iE3lzv34vSsIABvFu@?l@|=5E+wAG z^GLB7oFyc4ejLLBv1am$l^&1LUJXMtHbwu#uw)4*Z20oIDnVS2xk+ z|HYCe{)MKgy+a&k$gu7jw5y2D)TS5jGp9ny#`_OtbZn7zy75@t-OECn4J-v2tN9vR zFH@#si3YI-IKG@lZ|{$`EZ>l3Cp$YJ^TcN(VhsWg+(8UaI=i^G} z{ALLagTS)Z$D=u~p?kqHMtu_+_b69&pBSeNP(vpMPc1apDp+#fdR_!;ky39g`!QY-Iv6pq<1m-;G z=wUM}qwRkn%$c|I=w+>BI#1FMm?7z0b_u#M9*+DlvslJ+XiyzDjBTj&SWD&+98t_lE!w3Wq&swctp%yhBZyQO(%m@@l$>>bX08PjQw7 z*9hI^j+7#4EVceM5W-*g)XSI_9fgHm5mY;ufb+ z@~SkEzh=*$s-;0M<=@+5Y=5D$^>jRKt!>Auc($eJt+jbrhPv+P24Viu{Pe&MYMV7T zF-}^$`|elSnPtp*ehoQqXnPa1wk=1U4r!)f$xlu$h~JAwe?au0rnBNhD$x+TWfMnNd$W#bSe>S1v+9*z z3v_0f z68LlS9;cHUQu>XJmEHV#vH6r=-qX%RfW>(;ttUQyW6;uUoz9t8^6I|e4^r~|p-&wP z0le1nn!cCO)-O}Ww0stktY%M{$~sung;!;~hx4v~<38c`Y6Q2OL}&LbFidMOMXOuo zx*a~B>be7cd6LR(O*z<%c2@AN-2>}zgN^+F7xI;Or5Pr7S9W!kJMd}1&|qFTJ}Gsc zJ{(Irb7qWNR1MF(%Uz}Pck(IGMD(1Z(3QM6Fv7PtqYu?h-3N6u)0JmqR_^Gnbi+$$ z+OO2VlL8Gx)voMz8fNa(scPG5=E@^ZrzAf)^5@3VcoU!Ln~7+R20_Wc;EFXC0Q94* z?9M*o)Gm%z{06{;cesUSP?mGYLZc%yrBc?)<;<&4iF)t(xIqIa{;PbOA+;j2xt`ti zz&V(yU?qg*cHz)IVp&VyjuW^-XwDIE@b}ez(eKC`U39*%cto0LB=~NANhSMI#Jc0D zv9gYTBt=KDX&N6r{?*vog2ZNzwQYufBy#BIg8ciypu`$P zlwi8mssGm5k!R&6LLPj6E{0fAet&+mCMgk9U53}3nVbnwPoZcO$0I7G>qhA2;l2e5 zr*`=)`~V9>$pG5%G}@PB;ge0|u`VVn5K79!ADUZ<;%z~byTGj@n(L@1a(eZ3ArmK+ zZC-V-QPMC>FqnP=o`D6+t)(oDxgl^A5`XrJ(EOooyTF0h^lQL%3?UI=3Mr)drg1Km zXu7V`n+?Llo`J}{?(g!n-MN}N`s6-s1N;Q}s5Mn{`$p&*udh3uC&eLGz*5&zv3jWR z_MR(O%A@^2`k?-{_f9h1Ki#Fn$yxA9mK0AM()inCI+Bp2v?#Iw8Lxd=E0T^)PSlW) z<1!kR>;``wvRqcOg{+qEIz}iE9+8rk#VKFEUEA5Mj0hlmnu(tQ^YS`6Obc3GZA;}YV zai)iS@>3uEt|UZozKR{Woh0}>-lHKsf0eFoJz5LOF=SMog3LU zAN>#LfaR1i>%!0JI)e|qlFPXT^PZSlNaU{7E5hpWzN~ zl(#+8e*iHpO~O{_)Atb*SNTC)b7+guJFja?5_YrNdI|l+7JKkvVp^_wY{iOGbP9?r z;V)DpilKk2$Ak`ly{YBAZk8ehx zDs6sQo+oVd>EnLmo=}oYT}B$r>i!(Ik@sw*%Qir5^(!*KP~O9!CO@{Ao+vgSJdt7Z z+mKx5+9(%xJ++eZv)a#gv7FQQbO0$E`-n~|P0ctC~(J4`~)tXXr2C&0Zs063BuVqhSYBcJ%=0g{>%;j$$qdVHmee*OWw@ zcJ5o%czh0Vg>v>?>ocW&@W5ZMoSYt@`N2@0{=HW6BF%P2a}`HEl{%5~zEuUB0LV`t z&p?UAyeJbpl-Hgnbr0uj9;WO`*t+XK#n6T04m?F*-7;^K-?PJl$0kxVyV} za(9QEE;dHec9gzcXlDggcP7~cu>f**>p}xO!{Q|!0g&u)j?Bt{!sN{B)RJTTT93!G ziSdhAQo7GGw`Ej$fQMv0UlYwIDTV|9Xqm2EOF7ti!%9U%Tjoe?gup(R*Yi4{qYd~( zj#+6&&qfl z)<@6X7(3PWFuN6$X}Zz>hJ`I| zbuf93jpL)RT`w2t+>F4o4VYtAhU*3GL#1JBX~TRq+=8APX8dP+HM83cMl2Y5oz%~7&fZYg< zqd0`C@E+XMe6YImHFQfHwpMQltDh0%uC1soeJ@w+3Dcnw{RnKML94VB($X43haGV4 zLNDI*A{b77$mM*mLhr4vfVl)lwk_%_Js8AN$rq4`IC%ACJD;A+o#4@@NOokZB62DF z&-5xRxH<>uA@>Suw(?`oo-%-$D9$6?+#Wp>v3-9G2?X~DINm`Sg6zNSH;@ZkG2ST) z{If=pNpf%0I5H-q`Co{+d=Lv^(E!Txy|;w!u)GkE8 zfrpA_lbQDP?vq)7PaL4<4wB$x6gy6WFS~g}E@Ej8wk)EnI0^6IF;d`_>sK5Q6jC|=d+UjCry(tzjJtf5yaorL3QkjFcHCcqN2 zDxb5z&!l!i;^(B2m(Hx8+bt5~Lj0ZIv0R<+A!F)$hSOk7zUt?;$x00!77sQwv+vc7 z+k@U94NWKxUstP4xKA(RBkhTb@~->DlKb=k)-@&^=BycA1bop;#wp90dj17N63m6 z@Tzk5n%?Q+Cp%rmzKiw_Mrl#!+fDhXOunbROb`4ztpX-v>)mYt#AKNBy~fz_5#bBX z7r}dLK?~Sr;hP1?xl>w{ckIO-XEvc)E{pCb)(-LL3R;|;L3R@Hz1l+!#0Sa3FJhN1 zx9{bm_+Bml!Ssz>NZ=f#+{|hlZuk*2F$L~B#I*0dXa|}>@fsbFh?j!xQXU79pM1;C zUhQKvj8!UJj?H+>r66Dbp^R5fhFrK}caa3eo2YS!{NC@N+Hnshn+#iDm_k_B zg(If%0njP)^mr*xDvO6v&lP@F7sTu0@~D-)t4x4&PUekNhMDYltofja0<@%5KkMaY$PNG z8H_>OT3UvZN(;&gQ`K>%)Afd{PL^E3T!3~c1#>SnIpa8)j07-Lv6H1NsTSplE}Y9M z=_+Gk@3m5-v&-s5UOD1Yfp4+ygUVftrsfSxw5th0=<_?Cx}w`rUXDsx#LF!h*?8g& z_J%xBK|g+zh%)#<*{^C+s8%UF zUySt4ASMhdWvq+SbV}qRY^k>|il`zOcj$>roXha079NZ`^GF)tA5bx64wzh`*GhIO zTo?~_Ug;J#C{y$ZJLIGo@uH%v2fl1*vA^H_0JTJH!w%`45qDk)yI&2FvG>3G^C$s= zkABxK(M=CW8vxI~jMqtZ%*I}crhd_@>T%|#hfX2q8tmP&i42}XQ{oloOaFN9LQa%z( zUy#%ew~v5tvda0wE9$|hx1|A6)pOB92Hm_4QH(H`{>{AhIHaoCbGDG^K#dHxqpWcC zih&ex$vWU5fphG3XWFpWI?-!HEJ(sPDu^E8Rq;e(L2=A&00+F=&X$!g&IV5}z}OzL zL+?PZuEJYTOXlejMw%e$DVK|Zxbt7FBcuUO3kVC9pJ49^_~I10yqTOsD}{SFH43p& z?hdUpcU5$IQc%$;%kP)eS*$Qe>Hq4RAB<2zgG_ir@Q)_P&k=fpHH-qOWxTcmA!Z73 z%bQ(-354N$wq~sF*x1c~ikYJJBoa#FG@Ff}ln6}3rqE@U^MRH*A4QKqpy;%5zpFd8 z$Qt1*(oas4MiTni4e6Iv_I-aR?=RP*xdF=Hl4S!p zzxw)^&kT36J@&4{neayqrzhJ`15h%y_J?hM{p|;Zydr9z#6#K!28ELmEPFC+G1ai~ z!;#93pjOn-%sQqB)xn_7BtmUmXN2T WFVt(Ng|!sGi(F~`)Pr%BKN{#<${nKseJ z&C**x%&mQQI&HMiLG@g>e}vj7ktA$-JdsiF*PH;a*;$&H zSLg{pHR;>sG4tr~AB2kojFJ>lu>VQj9kphFNQw_+n=izOtNYhTsKsHg;29-l3 z+pochr$@+>tk?Bg=_CXZ-DPtuk17mjyOMoJqG4p8pfreeT+3U>| zUf*#phKpqx4DbWdN0)*h89!_hA;N(5WM;57tLp0_clWPcUf=0A03qzfmOG;7Y#dSU z9w*|fUEEDja9H4g33b1^OwL3p8{yu9ylaVG!f{2HQs(%r!8`HJTs zryYva5WNDcXZ`B-Hr$oL^%;^-diI_Gpon(mnVv$w*Ue?}c!t{NBQFzyqY>UM*R3*x zL!T|tNa5qh#c%Y9tx^m{e9opu<<{EpQ8}C4`4y!htZZY{Hygo#bxqVqT_3~7%3SO} zT)}Y)bZ*prL!gTqwv+s`q<5y;&qklr zCDf7J)b~vl*b%0q9dOG?f*NzP{Q?;~+6kP?&q+Qyb_;ffBtkGg#$Vv6RaNkuv%T-E z?6)JM7>|lw8(9q*A${&|er|zZtqW;RIPQky49JOH-mWDe;h;(z{7!0;o`wzy z7FWwn-g|RL^Cg;Nx$OmY35{VF=z-5 zrZ;MZ+P&XtaOUruXgz-D8;{s11W%?z@(eD7^rFX!>`9njN+5%4H=X)D9WYniH6y~; z=n$Ow!xOBWqr(MHHe5_)$b208D9T@!sQPM}y_*u^Os5!f|1&z{!QbSRwV1z} z#a-O{5hbDt46)P9C9M6C22EnGog3x*3Ov`QncRf3#I?8|k_H@u_G4 z@%-5Dc(Jr2F-IxL?RdOsjz0H@Hx8Rj$2R3EAJ0|p@}Q>v#-BK+9jkMrp68_iXWg%& zh@GvcEU*|e{PB;jrnWMUfuPjzSDS5n{7SQWzsB+7UsJ*Yh2Hl;t*b!3y*QL|J8=RZ zmDrJzpP4>nV7K+%tND_|m3MBlq5aNCYskb(xq#dq@#GewiAO9I7NiRF$?}v2pM(b& z=EgB=MMFK<1lEmk2GNXvicyem>V8ZW6{iCA>O9R{oh^4k@afs{3_ABMB4FV=yTScc zJ0Wdlj;V2<2mk$|DRp~A^}@5t#>*-I14LVhJ!{rGR$7v>rZJyZ3lIcdz5TL7h9{^{ z8C9!#SG5Fpkx6k(i0nbg>{t;epIT$_&;U(l+wh2G85|TS#?^)*w;50`X@wX8Vmr%R z?5;cA%bC9dr~qT4s?j&T#$1@+M2#frP!Yb%jBuMoK?{zXeNiPE2uSA^{_q^!$qKNw z(C&0^i#vQa+zGji7`O|9LqPA!lxkE< zI!4vV_Lmqu4B$3^tbjr6Zw!E-1Tg&j8NR^6UmyJc>4N`xQvXr{?eA0lTVRd<;ta9B z_5Fuh;s2PKe`x%FVCHr#gW*5YrT>@A{6m8Zc!_yS@ZTRj|0SgUq2YT=?JoohjQ^iD h=zn6U!-bu|8JM$WEubf literal 0 HcmV?d00001