From 29d6c889e474418b81c123b247fc2d2e3f4b78f5 Mon Sep 17 00:00:00 2001 From: Lumek4 Date: Fri, 23 Jan 2026 11:43:15 +0100 Subject: [PATCH 1/5] Workshop 8 --- content/labs/lab14/index.en.md | 85 +++++++++++++++++++ content/labs/lab14/index.pl.md | 82 ++++++++++++++++++ .../labs/lab14/solution/Binding/Binding.sln | 31 +++++++ .../PatternGeneration/NativeMethods.cs | 17 ++++ .../Binding/PatternGeneration/Pattern.cs | 43 ++++++++++ .../PatternGeneration.csproj | 46 ++++++++++ .../Binding/PatternGeneration/Point.cs | 15 ++++ .../Properties/AssemblyInfo.cs | 1 + .../PatternGeneration/StripeSettings.cs | 18 ++++ .../PatternGeneration/native/CMakeLists.txt | 13 +++ .../Binding/PatternGeneration/native/color.h | 4 + .../Binding/PatternGeneration/native/export.c | 2 + .../PatternGeneration/native/pattern.c | 56 ++++++++++++ .../PatternGeneration/native/pattern.h | 31 +++++++ .../Binding/PatternGeneration/native/point.h | 4 + .../PatternGenerationDemo.csproj | 14 +++ .../Binding/PatternGenerationDemo/Program.cs | 34 ++++++++ .../FileInteraction/FileInteraction.csproj | 19 +++++ .../SafeHandles/FileInteraction/MyFile.cs | 24 ++++++ .../SafeHandles/FileInteraction/Program.cs | 53 ++++++++++++ .../SafeHandles/FileInteraction/UnixFile.cs | 58 +++++++++++++ .../FileInteraction/WindowsFile.cs | 65 ++++++++++++++ .../solution/SafeHandles/SafeHandles.sln | 25 ++++++ static/labs/lab14/student/Binding/Binding.sln | 31 +++++++ .../PatternGeneration/NativeMethods.cs | 9 ++ .../Binding/PatternGeneration/Pattern.cs | 22 +++++ .../PatternGeneration.csproj | 46 ++++++++++ .../Binding/PatternGeneration/Point.cs | 15 ++++ .../Properties/AssemblyInfo.cs | 1 + .../PatternGeneration/StripeSettings.cs | 18 ++++ .../PatternGeneration/native/CMakeLists.txt | 13 +++ .../Binding/PatternGeneration/native/color.h | 4 + .../Binding/PatternGeneration/native/export.c | 2 + .../PatternGeneration/native/pattern.c | 58 +++++++++++++ .../PatternGeneration/native/pattern.h | 31 +++++++ .../Binding/PatternGeneration/native/point.h | 4 + .../PatternGenerationDemo.csproj | 14 +++ .../Binding/PatternGenerationDemo/Program.cs | 25 ++++++ .../FileInteraction/FileInteraction.csproj | 19 +++++ .../SafeHandles/FileInteraction/MyFile.cs | 24 ++++++ .../SafeHandles/FileInteraction/Program.cs | 53 ++++++++++++ .../SafeHandles/FileInteraction/UnixFile.cs | 37 ++++++++ .../FileInteraction/WindowsFile.cs | 39 +++++++++ .../lab14/student/SafeHandles/SafeHandles.sln | 25 ++++++ 44 files changed, 1230 insertions(+) create mode 100644 content/labs/lab14/index.en.md create mode 100644 content/labs/lab14/index.pl.md create mode 100644 static/labs/lab14/solution/Binding/Binding.sln create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/NativeMethods.cs create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/Pattern.cs create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/PatternGeneration.csproj create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/Point.cs create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/Properties/AssemblyInfo.cs create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/StripeSettings.cs create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/CMakeLists.txt create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/color.h create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/export.c create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.c create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h create mode 100644 static/labs/lab14/solution/Binding/PatternGeneration/native/point.h create mode 100644 static/labs/lab14/solution/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj create mode 100644 static/labs/lab14/solution/Binding/PatternGenerationDemo/Program.cs create mode 100644 static/labs/lab14/solution/SafeHandles/FileInteraction/FileInteraction.csproj create mode 100644 static/labs/lab14/solution/SafeHandles/FileInteraction/MyFile.cs create mode 100644 static/labs/lab14/solution/SafeHandles/FileInteraction/Program.cs create mode 100644 static/labs/lab14/solution/SafeHandles/FileInteraction/UnixFile.cs create mode 100644 static/labs/lab14/solution/SafeHandles/FileInteraction/WindowsFile.cs create mode 100644 static/labs/lab14/solution/SafeHandles/SafeHandles.sln create mode 100644 static/labs/lab14/student/Binding/Binding.sln create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/NativeMethods.cs create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/Pattern.cs create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/PatternGeneration.csproj create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/Point.cs create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/Properties/AssemblyInfo.cs create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/StripeSettings.cs create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/CMakeLists.txt create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/color.h create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/export.c create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/pattern.c create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h create mode 100644 static/labs/lab14/student/Binding/PatternGeneration/native/point.h create mode 100644 static/labs/lab14/student/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj create mode 100644 static/labs/lab14/student/Binding/PatternGenerationDemo/Program.cs create mode 100644 static/labs/lab14/student/SafeHandles/FileInteraction/FileInteraction.csproj create mode 100644 static/labs/lab14/student/SafeHandles/FileInteraction/MyFile.cs create mode 100644 static/labs/lab14/student/SafeHandles/FileInteraction/Program.cs create mode 100644 static/labs/lab14/student/SafeHandles/FileInteraction/UnixFile.cs create mode 100644 static/labs/lab14/student/SafeHandles/FileInteraction/WindowsFile.cs create mode 100644 static/labs/lab14/student/SafeHandles/SafeHandles.sln diff --git a/content/labs/lab14/index.en.md b/content/labs/lab14/index.en.md new file mode 100644 index 0000000..ce91cb1 --- /dev/null +++ b/content/labs/lab14/index.en.md @@ -0,0 +1,85 @@ +--- +title: "Lab14" +weight: 10 +--- + +# Laboratory 14: Interoperability, Marshalling, Unsafe context + +## Safe handles + +Create a program reading files using external functions from native system libraries. + +### Starting code + +> [!NOTE] +> **Student** +> {{< filetree dir="labs/lab14/student/SafeHandles" >}} + +### Task description + +Caution is required when interacting with code that is not [managed](https://csharp.mini.pw.edu.pl/en/lectures/01.introduction/#main-features-of-the-language) - e.g. base C++, C. Safety measures provided by the .NET environment stop guaranteeing protection the moment code calls into external code. Structures created in unmanaged code are often represented by pointers or other identifiers that have unique values reserved for invalid states (commonly 0 or -1). Use classes inheriting from `SafeHandle` to make sure that resources you requested are valid before use. + +A partially implemented class that imports system functions for handling files can be found in the `FileInteraction` project - in `WindowsFile.cs` or `UnixFile.cs` depending which operating system you use. Only the relevant one will be used for compilation. Take a look at the project file `FileInteraction.csproj` - conditional exclusion of the file that doesn't match your system is implemented for you. + +Check what values the file opening function declares as invalid. Make the `MyFile` class inherit from the correct `SafeHandle` so it matches the invalid values. Make sure you do it in `WindowsFile.cs` if you're on Windows or `UnixFile.cs` if you're on OSX or Linux. Finish the correct implementation for your system. Fill in `Open` and `Read` in the file `MyFile.cs`. You can test the program by running it. + +After the workshop you're encouraged to try this task for the other system setup. + +{{% hint info %}} +**Useful links:** + +- [Microsoft Learn: MSBuild conditions](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-conditions) +- [Microsoft Learn: SafeHandles namespace](https://learn.microsoft.com/en-us/dotnet/api/microsoft.win32.safehandles?view=net-9.0) +- [POSIX Manual: open](https://www.man7.org/linux/man-pages/man3/open.3p.html) +- [Microsoft Learn: CreateFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea) + + +{{% /hint %}} + + +### Example solution + +> [!TIP] +> **Solution** +> {{< filetree dir="labs/lab14/solution/SafeHandles" >}} + +## Binding and Marshalling + +Use an unmanaged library to create visual patterns. + +### Starting code + +> [!NOTE] +> **Student** +> {{< filetree dir="labs/lab14/student/Binding" >}} + +### Task description + +Import the functions shared in `pattern.h` using `LibraryImport` in the `PatternGeneration` project, `NativeMethods.cs`. Declare all required classes and structures. Implement wrapping functions in the `Pattern` class (`Pattern.cs`) so that the library user only has to interact with managed functions. +- Some arguments might require the `[In]` attribute to specify the direction of information exchange. Similarily, if there was a change in an argument that needed to be shown back to the caller, the `[Out]` tag would be appropriate. +- Structures on the managed side of the interaction need to be laid out precisely like the ones on the unmanaged side. Alternatively, one can define custom marshalling. That requires the programmer to define rules for turning the unmanaged structures into their managed counterparts and vice versa using the [`CustomMarshaller`](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/tutorial-custom-marshaller) attribute. +- Treat the `pattern_t` structure as opaque. Simply treat its pointer as one of the `SafeHandles` and don't worry about transfering data. Use the handle itself for calling the other imported functions, especially after you implement the inheritance. + +The library distributors might not release the full internal data layout for the user. The user might care about only a small part of the structure and not need it whole. Use `Marshall.Copy` in the `GetImage` function (`Pattern.cs`) to extract the dimensions and contents of the `color_t[] values` array hidden under the opaque handle. Utilise the fact that the fields will be laid out sequentially like in `pattern.h` (with offset 0, then offset `sizeof(int)` and `sizeof(int)*2`). The struct `color_t` has the same layout as the `Rgb24` structure. Use the acquired data to create an image with `Image.LoadPixelData`. + +Fill in the `Main` function in the `PatternGenerationDemo` project to create at least one image each with the functions `pattern_enstripen` and `pattern_populate`. + +Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło się co najmniej po jednym obrazie z użyciem fukcji `pattern_enstripen` oraz `pattern_populate`. + +{{% hint info %}} +**Useful links:** + +- [Microsoft Learn: P/Invoke](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke-source-generation) +- [Microsoft Learn: Struct layout](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.structlayoutattribute?view=net-9.0) +- [Microsoft Learn: Type marshalling](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/type-marshalling) +- [Microsoft Learn: Built-in type marshalling](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.disableruntimemarshallingattribute?view=net-9.0) + + +{{% /hint %}} + + +### Example solution + +> [!TIP] +> **Solution** +> {{< filetree dir="labs/lab14/solution/Binding" >}} \ No newline at end of file diff --git a/content/labs/lab14/index.pl.md b/content/labs/lab14/index.pl.md new file mode 100644 index 0000000..2811247 --- /dev/null +++ b/content/labs/lab14/index.pl.md @@ -0,0 +1,82 @@ +--- +title: "Lab14" +weight: 10 +--- + +# Laboratorium 14: Współdziałanie, Marshalling, Kontekst Niebezpieczny + +## Bezpieczne uchwyty + +Celem zadania jest stworzenie programu odczytującego pliki z użyciem zewnętrznych funkcji pochodzących z bibliotek systemowych. + +### Kod początkowy + +> [!NOTE] +> **Student** +> {{< filetree dir="labs/lab14/student/SafeHandles" >}} + +### Opis zadania + +Współpraca z kodem o ręcznym zarządzaniu pamięci - jak np. napisanym w C++ lub C - wymaga ostrożności przy wymianie informacji. Zabezpieczenia które zapewnia nam platforma .NET tracą siłę w momencie przejścia do kodu zewnętrznego. Struktury tworzone w takim kodzie często przekazywane są w postaci wskaźników lub innych identyfikatorów które posiadają szczególne wartości sygnalizujące błąd (często 0 lub -1). Użyj klas dziedziczących po `SafeHandle`, aby upewnić się że zasoby zostały poprawnie przekazane przed ich użyciem. + +W projekcie `FileInteraction` znajdziesz częściowo zaimplementowaną klasę ładującą funkcje systemowe obsługujące pliki - zależnie od systemu operacyjnego odpowiednio w pliku `WindowsFile.cs` oraz `UnixFile.cs`. Tylko ta, która odpowiada Twojemu systemowi będzie dołączona do skompilowanego programu. Zwróć uwagę na plik projektu `FileInteraction.csproj`, już za Ciebie użyte w nim zostało warunkowe wykluczenie niepasującego pliku źródłowego. + +Sprawdź jakie wartości zwracane przez funkcję otwierającą plik powinny być interpretowane jako niewłaściwe. Dokończ implementację części odpowiadającej systemowi którego używasz. Dodaj do klasy `MyFile` w pliku `WindowsFile.cs` lub `UnixFile.cs` dziedziczenie po odpowiedniej klasie z rodziny `SafeHandle` i zaimplementuj potrzebne funkcje. W pliku `MyFile.cs` uzupełnij funkcje `Open` oraz `Read`. Program możesz przetestować uruchamiając go. + +Po zakończeniu zajęć zachęcamy do próby wykonania zadania w innym systemie. + +{{% hint info %}} +**Materiały pomocnicze:** + +- [Microsoft Learn: MSBuild conditions](https://learn.microsoft.com/en-us/visualstudio/msbuild/msbuild-conditions) +- [Microsoft Learn: SafeHandles namespace](https://learn.microsoft.com/en-us/dotnet/api/microsoft.win32.safehandles?view=net-9.0) +- [POSIX Manual: open](https://www.man7.org/linux/man-pages/man3/open.3p.html) +- [Microsoft Learn: CreateFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea) + + +{{% /hint %}} + + +### Przykładowe rozwiązanie + +> [!TIP] +> **Rozwiązanie** +> {{< filetree dir="labs/lab14/solution/SafeHandles" >}} + +## Wiązania oraz Marshalling +Celem zadania jest użycie biblioteki niezarządzanej do stworzenia wzoru graficznego. + +### Kod początkowy + +> [!NOTE] +> **Student** +> {{< filetree dir="labs/lab14/student/Binding" >}} + +### Opis zadania + +W projekcie `PatternGeneration`, pliku `NativeMethods.cs` zaimportuj za pomocą `LibraryImport` funkcje, które udostępnia plik `pattern.h`. Zadeklaruj również wszystkie potrzebne dla nich struktury i klasy. Następnie zaimplementuj w klasie `Pattern` w `Pattern.cs` funkcje opakowujące, które pozwolą konsumentowi biblioteki wchodzić w interakcję jedynie z zarządzanym kodem. +- Niektóre argumenty wymagają dodania atrybutu `[In]`, aby sprecyzować kierunek wymiany danych. Analogicznie, jeśli jeden z argumentów podległby zmianie wewnątrz funkcji i potrzebne byłoby odzwierciedlenie tych zmian po stronie wywołującego, stosowny byłby atrybut `[Out]`. +- Struktury po stronie zarządzanej muszą mieć określone ułożenie pól ściśle zgodne ze strukturami, aby marshalling dokonywał się automatycznie. Alternatywą jest ręczny marshalling, do którego potrzebne jest zdefiniowanie reguł zmiany danych niezarządzanych w klasę lub strukturę zarządzaną z użyciem atrybutu [`CustomMarshaller`](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/tutorial-custom-marshaller). +- Potraktuj strukturę `pattern_t` jako nieprzejrzystą (ang. opaque). Nie martw się przenoszeniem danych. Wystarczy potraktować wskaźnik tej struktury jako jeden z `SafeHandle` do wywoływania innych funkcji, analogicznie do poprzedniego zadania. + +Dystrybutor biblioteki może czasem nie udostępniać całego rozkładu struktury lub przenoszenie wszystich danych przez barierę biblioteka-aplikacja może nie być potrzebne. W funkcji `GetImage` w `Pattern.cs` użyj funkcji `Marshall.Copy`, aby wydobyć dane o wymiarach oraz zawartości tablicy `color_t[] values` ukrytej pod nieprzejrzystem uchwytem. Zwróć uwagę na to, że pola ułożone będą po kolei tak jak w `pattern.h` (a więc kolejno z przesunięciem 0, `sizeof(int)`, `2*sizeof(int)`), a struktura `color_t` odpowiada bezpośrednio strukturze `Rgb24`. Użyj pozyskanych danych do stworzenia obrazu z `Image.LoadPixelData`. + +Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło się co najmniej po jednym obrazie z użyciem fukcji `pattern_enstripen` oraz `pattern_populate`. + +{{% hint info %}} +**Materiały pomocnicze:** + +- [Microsoft Learn: P/Invoke](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/pinvoke-source-generation) +- [Microsoft Learn: Struct layout](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.structlayoutattribute?view=net-9.0) +- [Microsoft Learn: Type marshalling](https://learn.microsoft.com/en-us/dotnet/standard/native-interop/type-marshalling) +- [Microsoft Learn: Built-in type marshalling](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.compilerservices.disableruntimemarshallingattribute?view=net-9.0) + + +{{% /hint %}} + + +### Przykładowe rozwiązanie + +> [!TIP] +> **Rozwiązanie** +> {{< filetree dir="labs/lab14/solution/Binding" >}} \ No newline at end of file diff --git a/static/labs/lab14/solution/Binding/Binding.sln b/static/labs/lab14/solution/Binding/Binding.sln new file mode 100644 index 0000000..eb4b2ae --- /dev/null +++ b/static/labs/lab14/solution/Binding/Binding.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36811.4 d17.14 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PatternGeneration", "PatternGeneration\PatternGeneration.csproj", "{0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PatternGenerationDemo", "PatternGenerationDemo\PatternGenerationDemo.csproj", "{85A2E662-3F5B-43A7-91FD-3205C4837ACB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Release|Any CPU.Build.0 = Release|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {D6DF6AAC-0198-4959-BBDA-1CABB72333E4} + EndGlobalSection +EndGlobal diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/NativeMethods.cs b/static/labs/lab14/solution/Binding/PatternGeneration/NativeMethods.cs new file mode 100644 index 0000000..387e63f --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/NativeMethods.cs @@ -0,0 +1,17 @@ +using System.Drawing; +using System.Runtime.InteropServices; +using Microsoft.Win32.SafeHandles; +using PatternGeneration; + +internal static partial class NativeMethods +{ + private const string LibName = "pg"; + [LibraryImport(LibName)] + public static partial nint pattern_init(int width, int height); + [LibraryImport(LibName)] + public static partial void pattern_populate(Pattern pattern, [In] PatternGeneration.Point[] points, int n); + [LibraryImport(LibName)] + public static partial void pattern_enstripen(Pattern pattern, StripeSettings settings); + [LibraryImport(LibName)] + public static partial void pattern_destroy(Pattern pattern); +} diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/Pattern.cs b/static/labs/lab14/solution/Binding/PatternGeneration/Pattern.cs new file mode 100644 index 0000000..d9cfd32 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/Pattern.cs @@ -0,0 +1,43 @@ +using Microsoft.Win32.SafeHandles; +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.PixelFormats; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + public class Pattern : SafeHandleZeroOrMinusOneIsInvalid + { + public Pattern(int width, int height) : base(true) + { + handle = NativeMethods.pattern_init(width, height); + } + + public void Populate(PatternGeneration.Point[] points) + { + NativeMethods.pattern_populate(this, points, points.Length); + } + public void Enstripen(StripeSettings settings) + { + NativeMethods.pattern_enstripen(this, settings); + } + public Image GetImage() + { + var dimensions = new int[2]; + Marshal.Copy(handle, dimensions, 0, dimensions.Length); + var content = new byte[dimensions[0]*dimensions[1]*3]; + Marshal.Copy(handle + sizeof(int) * 2, content, 0, content.Length); + return Image.LoadPixelData(content, dimensions[0], dimensions[1]); + } + protected override bool ReleaseHandle() + { + NativeMethods.pattern_destroy(this); + return true; + } + } +} diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/PatternGeneration.csproj b/static/labs/lab14/solution/Binding/PatternGeneration/PatternGeneration.csproj new file mode 100644 index 0000000..5820be6 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/PatternGeneration.csproj @@ -0,0 +1,46 @@ + + + + net9.0 + enable + enable + true + + $(MSBuildProjectDirectory)\obj\native\$(Configuration) + + + + + + + + + + $(NativeBuildDir)/libpg.so + + + $(NativeBuildDir)/$(Configuration)/pg.dll + + + $(NativeBuildDir)/libpg.dylib + + + + + %(FileName)%(Extension) + PreserveNewest + false + + + + + + + + + + + + + + \ No newline at end of file diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/Point.cs b/static/labs/lab14/solution/Binding/PatternGeneration/Point.cs new file mode 100644 index 0000000..09a3bc5 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/Point.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + [StructLayout(LayoutKind.Sequential)] + public struct Point(double x, double y) + { + public double x = x, y = y; + } +} diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/Properties/AssemblyInfo.cs b/static/labs/lab14/solution/Binding/PatternGeneration/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..4d6f1a1 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/Properties/AssemblyInfo.cs @@ -0,0 +1 @@ +[assembly: System.Runtime.CompilerServices.DisableRuntimeMarshalling] diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/StripeSettings.cs b/static/labs/lab14/solution/Binding/PatternGeneration/StripeSettings.cs new file mode 100644 index 0000000..4e1194e --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/StripeSettings.cs @@ -0,0 +1,18 @@ +using SixLabors.ImageSharp.PixelFormats; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + [StructLayout(LayoutKind.Sequential)] + public struct StripeSettings + { + public Rgb24 a, b; + public double stripe_a_width, stripe_b_width; + public double slope; + } +} diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/CMakeLists.txt b/static/labs/lab14/solution/Binding/PatternGeneration/native/CMakeLists.txt new file mode 100644 index 0000000..4ad79df --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.10) +project(pg C) + +set(CMAKE_C_STANDARD 11) + +include_directories(.) + +add_library(pg SHARED export.c) + +set_target_properties(pg PROPERTIES + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" +) diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/color.h b/static/labs/lab14/solution/Binding/PatternGeneration/native/color.h new file mode 100644 index 0000000..0ee7a35 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/color.h @@ -0,0 +1,4 @@ +typedef struct color +{ + unsigned char r, g, b; +} color_t; diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/export.c b/static/labs/lab14/solution/Binding/PatternGeneration/native/export.c new file mode 100644 index 0000000..1865271 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/export.c @@ -0,0 +1,2 @@ +#define LIBRARY_EXPORT +#include"pattern.c" \ No newline at end of file diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.c b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.c new file mode 100644 index 0000000..3a0cf3a --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.c @@ -0,0 +1,56 @@ +#include "pattern.h" +#include +#include +#include + +pattern_t* pattern_init(int width, int height) +{ + pattern_t* p = (pattern_t*)malloc(sizeof(pattern_t) + + sizeof(color_t) * width * height); + if (p == NULL) + return p; + p->height = height; + p->width = width; +} + +void pattern_populate(pattern_t* pattern, point_t* points, int point_count) +{ + srand(time(NULL)); + for (int y = 0; y < pattern->height; y++) + for (int x = 0; x < pattern->width; x++) + { + point_t p = {x * 1.0 / pattern->width, y * 1.0 / pattern->height}; + + int id1 = rand() % point_count; + point_t dp1 = {p.x - points[id1].x, p.y - points[id1].y}; + double score1 = dp1.x * dp1.x + dp1.y * dp1.y; + + pattern->values[x + y * pattern->width].r = + (unsigned char)(fmax(1 - score1 * 64, 0) * 255); + pattern->values[x + y * pattern->width].g = + (unsigned char)(fmax(0.75 - score1 * 32, 0) * 255); + pattern->values[x + y * pattern->width].b = + (unsigned char)(fmax(0.75 - score1 * 32, 0) * 255); + } +} +void pattern_enstripen(pattern_t* pattern, stripe_settings_t* settings) +{ + if (settings->slope == -1) + return; + for (int y = 0; y < pattern->height; y++) + for (int x = 0; x < pattern->width; x++) + { + point_t p = {x * 1.0 / pattern->width, y * 1.0 / pattern->height}; + + double f = + fmod(p.x + p.y * settings->slope, + (settings->stripe_a_width + settings->stripe_b_width) * + (1 + settings->slope)); + color_t* c = + (f < settings->stripe_a_width * (1 + settings->slope)) ? &settings->a : &settings->b; + pattern->values[x + y * pattern->width].r = c->r; + pattern->values[x + y * pattern->width].g = c->g; + pattern->values[x + y * pattern->width].b = c->b; + } +} +void pattern_destroy(pattern_t* pattern) { free(pattern); } diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h new file mode 100644 index 0000000..a45fd76 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h @@ -0,0 +1,31 @@ +#include "color.h" +#include "point.h" + +#ifdef _WIN32 +#ifdef LIBRARY_EXPORT +#define LIBRARY __declspec(dllexport) +#else +#define LIBRARY __declspec(dllimport) +#endif +#else +#define LIBRARY +#endif + +typedef struct pattern +{ + int width, height; + color_t values[]; +} pattern_t; + +typedef struct stripe_settings +{ + color_t a, b; + double stripe_a_width, stripe_b_width; + double slope; +} stripe_settings_t; + +LIBRARY pattern_t* pattern_init(int width, int height); +LIBRARY void pattern_populate(pattern_t* pattern, point_t* points, + int point_count); +LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t settings); +LIBRARY void pattern_destroy(pattern_t* pattern); diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/point.h b/static/labs/lab14/solution/Binding/PatternGeneration/native/point.h new file mode 100644 index 0000000..88591ad --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/point.h @@ -0,0 +1,4 @@ +typedef struct point +{ + double x, y; +} point_t; \ No newline at end of file diff --git a/static/labs/lab14/solution/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj b/static/labs/lab14/solution/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj new file mode 100644 index 0000000..46e06b9 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj @@ -0,0 +1,14 @@ + + + + Exe + net9.0 + enable + enable + + + + + + + diff --git a/static/labs/lab14/solution/Binding/PatternGenerationDemo/Program.cs b/static/labs/lab14/solution/Binding/PatternGenerationDemo/Program.cs new file mode 100644 index 0000000..99d0fa9 --- /dev/null +++ b/static/labs/lab14/solution/Binding/PatternGenerationDemo/Program.cs @@ -0,0 +1,34 @@ +using PatternGeneration; +using SixLabors.ImageSharp.Formats.Png; + +namespace PatternGenerationDemo +{ + internal class Program + { + static void Main(string[] args) + { + Pattern p = new(800, 600); + var pts = new PatternGeneration.Point[10]; + for (int i = 0; i < pts.Length; i++) + pts[i] = new(Random.Shared.NextDouble(), Random.Shared.NextDouble()); + p.Populate(pts); + { + var s = File.OpenWrite("Image1.png"); + p.GetImage().Save(s, new PngEncoder()); + } + + StripeSettings stripe = new StripeSettings(); + stripe.a = new(255, 0, 255); + stripe.b = new(0, 0, 0); + stripe.slope = 0.5; + stripe.stripe_a_width = 0.1; + stripe.stripe_b_width = 0.1; + + p.Enstripen(stripe); + { + var s = File.OpenWrite("Image2.png"); + p.GetImage().Save(s, new PngEncoder()); + } + } + } +} diff --git a/static/labs/lab14/solution/SafeHandles/FileInteraction/FileInteraction.csproj b/static/labs/lab14/solution/SafeHandles/FileInteraction/FileInteraction.csproj new file mode 100644 index 0000000..673d2cd --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/FileInteraction/FileInteraction.csproj @@ -0,0 +1,19 @@ + + + + Exe + net9.0 + enable + true + enable + + + + + + + + $(DefineConstants);OSX + + + diff --git a/static/labs/lab14/solution/SafeHandles/FileInteraction/MyFile.cs b/static/labs/lab14/solution/SafeHandles/FileInteraction/MyFile.cs new file mode 100644 index 0000000..cc190d7 --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/FileInteraction/MyFile.cs @@ -0,0 +1,24 @@ +using Microsoft.Win32.SafeHandles; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile + { + public MyFile(string? fileName) + : this(Environment.OSVersion.Platform) + { + this.fileName = fileName; + if (fileName != null) + Open(fileName); + } + public void Open(string fileName) => NativeOpen(fileName); + public string? Read(int amount) => NativeRead(amount); + + protected string? fileName; + } +} diff --git a/static/labs/lab14/solution/SafeHandles/FileInteraction/Program.cs b/static/labs/lab14/solution/SafeHandles/FileInteraction/Program.cs new file mode 100644 index 0000000..55607ec --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/FileInteraction/Program.cs @@ -0,0 +1,53 @@ +using System.Drawing; +using System.Text; + +namespace FileInteraction +{ + internal class Program + { + static void Main() + { + // Prepare + string name1 = "text.txt"; + { + using var fs = System.IO.File.Create(name1); + fs.Write(Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet!")); + } + { + var f = new MyFile(name1); + string? output; + do + { + output = f.Read(1); + Console.Write(output); + } while (!string.IsNullOrEmpty(output)); + Console.WriteLine(); + } + + Console.WriteLine(); + Console.WriteLine("===================="); + Console.WriteLine(); + + // Prepare + string name2 = "values.csv"; + { + using var fs = System.IO.File.Create(name2); + for (int i = 0; i < 30; i++) + { + double value = Random.Shared.NextDouble(); + fs.Write(Encoding.UTF8.GetBytes($"{value:0.00000};")); + } + } + { + int n = 4; + Console.WriteLine($"First {n} values of the file {name2}:"); + var f = new MyFile(name2); + for (int i = 0; i < n; i++) + { + Console.WriteLine(f.Read(7)); + f.Read(1); + } + } + } + } +} diff --git a/static/labs/lab14/solution/SafeHandles/FileInteraction/UnixFile.cs b/static/labs/lab14/solution/SafeHandles/FileInteraction/UnixFile.cs new file mode 100644 index 0000000..3d360e0 --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/FileInteraction/UnixFile.cs @@ -0,0 +1,58 @@ +using Microsoft.Win32.SafeHandles; +using System.Runtime.InteropServices; +using System.Security; +using System.Buffers; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile : SafeHandleMinusOneIsInvalid + { + private MyFile(PlatformID platformID) : base(true) + { + if (platformID != PlatformID.Unix) + throw new PlatformNotSupportedException(); + } + private void NativeOpen(string fileName) + { + if (!IsInvalid) + if (!ReleaseHandle()) + throw new Exception(""); + handle = NativeFile.open(fileName, 0); + } + private string? NativeRead(int characters) + { + byte[] buf = ArrayPool.Shared.Rent(characters); + int read = NativeFile.read(this, buf, (uint)characters); + if (read < 0) + throw new Exception(""); + var ret = Encoding.UTF8.GetString(buf, 0, read); + ArrayPool.Shared.Return(buf); + return ret; + } + protected override bool ReleaseHandle() + { + return NativeFile.close(this) != 0; + } + + [SuppressUnmanagedCodeSecurity()] + private partial class NativeFile + { +#if OSX + private const string lib = "libSystem"; +#else + private const string lib = "libc"; +#endif + [LibraryImport(lib, SetLastError = true, StringMarshalling = StringMarshalling.Utf8)] + internal static partial nint open(string fileName, int oFlag); + [LibraryImport(lib, SetLastError = true)] + internal static partial int read(MyFile fd, byte[] buf, uint nByte); + [LibraryImport(lib, SetLastError = true)] + internal static partial int close(MyFile fd); + } + } +} diff --git a/static/labs/lab14/solution/SafeHandles/FileInteraction/WindowsFile.cs b/static/labs/lab14/solution/SafeHandles/FileInteraction/WindowsFile.cs new file mode 100644 index 0000000..fa064d5 --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/FileInteraction/WindowsFile.cs @@ -0,0 +1,65 @@ +using Microsoft.Win32.SafeHandles; +using System; +using System.Buffers; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile : SafeHandleZeroOrMinusOneIsInvalid + { + private MyFile(PlatformID platformID) : base(true) + { + if (platformID != PlatformID.Win32NT) + throw new PlatformNotSupportedException(); + } + private void NativeOpen(string fileName) + { + if (!IsInvalid) + if (!ReleaseHandle()) + throw new Win32Exception(Marshal.GetLastWin32Error()); + handle = NativeFile.CreateFile(fileName, System.IO.FileAccess.ReadWrite, System.IO.FileShare.None, 0, System.IO.FileMode.Open, 0, 0); + } + unsafe private string? NativeRead(int characters) + { + string? readString; + + // byte* buf = stackalloc byte[characters]; + var array = ArrayPool.Shared.Rent(characters); + fixed (byte* buf = array) + { + if (0 == NativeFile.ReadFile(this, buf, characters, out int read, 0)) + throw new Win32Exception(Marshal.GetLastWin32Error()); + readString = Encoding.UTF8.GetString(buf, read); + } + ArrayPool.Shared.Return(array); + return readString; + } + protected override bool ReleaseHandle() + { + return NativeFile.CloseHandle(this); + } + + [SuppressUnmanagedCodeSecurity()] + private partial class NativeFile + { + [LibraryImport("kernel32", EntryPoint = "CreateFileA", SetLastError = true, StringMarshalling = StringMarshalling.Utf8)] + internal static partial nint CreateFile(string fileName, + System.IO.FileAccess dwDesiredAccess, System.IO.FileShare dwShareMode, + IntPtr securityAttrs_MustBeZero, System.IO.FileMode dwCreationDisposition, + int dwFlagsAndAttributes, IntPtr hTemplateFile_MustBeZero); + [LibraryImport("kernel32", SetLastError = true)] + internal static unsafe partial int ReadFile(MyFile handle, byte* bytes, + int numBytesToRead, out int numBytesRead, IntPtr overlapped_MustBeZero); + [return: MarshalAs(UnmanagedType.Bool)] + [LibraryImport("kernel32", SetLastError = true)] + internal static partial bool CloseHandle(MyFile handle); + } + } +} diff --git a/static/labs/lab14/solution/SafeHandles/SafeHandles.sln b/static/labs/lab14/solution/SafeHandles/SafeHandles.sln new file mode 100644 index 0000000..c7fef23 --- /dev/null +++ b/static/labs/lab14/solution/SafeHandles/SafeHandles.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36811.4 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FileInteraction", "FileInteraction\FileInteraction.csproj", "{50346E0A-0DA6-4340-BF3F-914ABDEFAC19}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Debug|Any CPU.Build.0 = Debug|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Release|Any CPU.ActiveCfg = Release|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {EDBC7DBE-1B59-4C69-AD59-DFAE9DB99518} + EndGlobalSection +EndGlobal diff --git a/static/labs/lab14/student/Binding/Binding.sln b/static/labs/lab14/student/Binding/Binding.sln new file mode 100644 index 0000000..eb4b2ae --- /dev/null +++ b/static/labs/lab14/student/Binding/Binding.sln @@ -0,0 +1,31 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36811.4 d17.14 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PatternGeneration", "PatternGeneration\PatternGeneration.csproj", "{0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PatternGenerationDemo", "PatternGenerationDemo\PatternGenerationDemo.csproj", "{85A2E662-3F5B-43A7-91FD-3205C4837ACB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0BAF5E86-AE4D-D0FE-43AF-765BA1F81D35}.Release|Any CPU.Build.0 = Release|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {85A2E662-3F5B-43A7-91FD-3205C4837ACB}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {D6DF6AAC-0198-4959-BBDA-1CABB72333E4} + EndGlobalSection +EndGlobal diff --git a/static/labs/lab14/student/Binding/PatternGeneration/NativeMethods.cs b/static/labs/lab14/student/Binding/PatternGeneration/NativeMethods.cs new file mode 100644 index 0000000..37d70fb --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/NativeMethods.cs @@ -0,0 +1,9 @@ +using System.Drawing; +using System.Runtime.InteropServices; +using Microsoft.Win32.SafeHandles; +using PatternGeneration; + +internal static partial class NativeMethods +{ + private const string LibName = "pg"; +} diff --git a/static/labs/lab14/student/Binding/PatternGeneration/Pattern.cs b/static/labs/lab14/student/Binding/PatternGeneration/Pattern.cs new file mode 100644 index 0000000..070b0ec --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/Pattern.cs @@ -0,0 +1,22 @@ +using Microsoft.Win32.SafeHandles; +using SixLabors.ImageSharp; +using SixLabors.ImageSharp.PixelFormats; +using System; +using System.Collections.Generic; +using System.Drawing; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + public class Pattern // : SafeHandleZeroOrMinusOneIsInvalid + { + public Image GetImage() + { + throw new NotImplementedException(); + // return Image.LoadPixelData(content, width, height); + } + } +} diff --git a/static/labs/lab14/student/Binding/PatternGeneration/PatternGeneration.csproj b/static/labs/lab14/student/Binding/PatternGeneration/PatternGeneration.csproj new file mode 100644 index 0000000..5820be6 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/PatternGeneration.csproj @@ -0,0 +1,46 @@ + + + + net9.0 + enable + enable + true + + $(MSBuildProjectDirectory)\obj\native\$(Configuration) + + + + + + + + + + $(NativeBuildDir)/libpg.so + + + $(NativeBuildDir)/$(Configuration)/pg.dll + + + $(NativeBuildDir)/libpg.dylib + + + + + %(FileName)%(Extension) + PreserveNewest + false + + + + + + + + + + + + + + \ No newline at end of file diff --git a/static/labs/lab14/student/Binding/PatternGeneration/Point.cs b/static/labs/lab14/student/Binding/PatternGeneration/Point.cs new file mode 100644 index 0000000..09a3bc5 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/Point.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + [StructLayout(LayoutKind.Sequential)] + public struct Point(double x, double y) + { + public double x = x, y = y; + } +} diff --git a/static/labs/lab14/student/Binding/PatternGeneration/Properties/AssemblyInfo.cs b/static/labs/lab14/student/Binding/PatternGeneration/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..4d6f1a1 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/Properties/AssemblyInfo.cs @@ -0,0 +1 @@ +[assembly: System.Runtime.CompilerServices.DisableRuntimeMarshalling] diff --git a/static/labs/lab14/student/Binding/PatternGeneration/StripeSettings.cs b/static/labs/lab14/student/Binding/PatternGeneration/StripeSettings.cs new file mode 100644 index 0000000..4e1194e --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/StripeSettings.cs @@ -0,0 +1,18 @@ +using SixLabors.ImageSharp.PixelFormats; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PatternGeneration +{ + [StructLayout(LayoutKind.Sequential)] + public struct StripeSettings + { + public Rgb24 a, b; + public double stripe_a_width, stripe_b_width; + public double slope; + } +} diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/CMakeLists.txt b/static/labs/lab14/student/Binding/PatternGeneration/native/CMakeLists.txt new file mode 100644 index 0000000..4ad79df --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/CMakeLists.txt @@ -0,0 +1,13 @@ +cmake_minimum_required(VERSION 3.10) +project(pg C) + +set(CMAKE_C_STANDARD 11) + +include_directories(.) + +add_library(pg SHARED export.c) + +set_target_properties(pg PROPERTIES + LIBRARY_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}" +) diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/color.h b/static/labs/lab14/student/Binding/PatternGeneration/native/color.h new file mode 100644 index 0000000..0ee7a35 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/color.h @@ -0,0 +1,4 @@ +typedef struct color +{ + unsigned char r, g, b; +} color_t; diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/export.c b/static/labs/lab14/student/Binding/PatternGeneration/native/export.c new file mode 100644 index 0000000..1865271 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/export.c @@ -0,0 +1,2 @@ +#define LIBRARY_EXPORT +#include"pattern.c" \ No newline at end of file diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.c b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.c new file mode 100644 index 0000000..1d44139 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.c @@ -0,0 +1,58 @@ +#include "pattern.h" +#include +#include +#include + +pattern_t* pattern_init(int width, int height) +{ + pattern_t* p = (pattern_t*)malloc(sizeof(pattern_t) + + sizeof(color_t) * width * height); + if (p == NULL) + return p; + p->height = height; + p->width = width; +} + +void pattern_populate(pattern_t* pattern, point_t* points, int point_count) +{ + srand(time(NULL)); + for (int y = 0; y < pattern->height; y++) + for (int x = 0; x < pattern->width; x++) + { + point_t p = {x * 1.0 / pattern->width, y * 1.0 / pattern->height}; + + int id1 = rand() % point_count; + point_t dp1 = {p.x - points[id1].x, p.y - points[id1].y}; + double score1 = dp1.x * dp1.x + dp1.y * dp1.y; + + pattern->values[x + y * pattern->width].r = + (unsigned char)(fmax(1 - score1 * 64, 0) * 255); + pattern->values[x + y * pattern->width].g = + (unsigned char)(fmax(0.75 - score1 * 32, 0) * 255); + pattern->values[x + y * pattern->width].b = + (unsigned char)(fmax(0.75 - score1 * 32, 0) * 255); + } +} + +void pattern_enstripen(pattern_t* pattern, stripe_settings_t* settings) +{ + if (settings->slope == -1) + return; + for (int y = 0; y < pattern->height; y++) + for (int x = 0; x < pattern->width; x++) + { + point_t p = {x * 1.0 / pattern->width, y * 1.0 / pattern->height}; + + double f = + fmod(p.x + p.y * settings->slope, + (settings->stripe_a_width + settings->stripe_b_width) * + (1 + settings->slope)); + color_t* c = (f < settings->stripe_a_width * (1 + settings->slope)) + ? &settings->a + : &settings->b; + pattern->values[x + y * pattern->width].r = c->r; + pattern->values[x + y * pattern->width].g = c->g; + pattern->values[x + y * pattern->width].b = c->b; + } +} +void pattern_destroy(pattern_t* pattern) { free(pattern); } diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h new file mode 100644 index 0000000..a45fd76 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h @@ -0,0 +1,31 @@ +#include "color.h" +#include "point.h" + +#ifdef _WIN32 +#ifdef LIBRARY_EXPORT +#define LIBRARY __declspec(dllexport) +#else +#define LIBRARY __declspec(dllimport) +#endif +#else +#define LIBRARY +#endif + +typedef struct pattern +{ + int width, height; + color_t values[]; +} pattern_t; + +typedef struct stripe_settings +{ + color_t a, b; + double stripe_a_width, stripe_b_width; + double slope; +} stripe_settings_t; + +LIBRARY pattern_t* pattern_init(int width, int height); +LIBRARY void pattern_populate(pattern_t* pattern, point_t* points, + int point_count); +LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t settings); +LIBRARY void pattern_destroy(pattern_t* pattern); diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/point.h b/static/labs/lab14/student/Binding/PatternGeneration/native/point.h new file mode 100644 index 0000000..88591ad --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/point.h @@ -0,0 +1,4 @@ +typedef struct point +{ + double x, y; +} point_t; \ No newline at end of file diff --git a/static/labs/lab14/student/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj b/static/labs/lab14/student/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj new file mode 100644 index 0000000..46e06b9 --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGenerationDemo/PatternGenerationDemo.csproj @@ -0,0 +1,14 @@ + + + + Exe + net9.0 + enable + enable + + + + + + + diff --git a/static/labs/lab14/student/Binding/PatternGenerationDemo/Program.cs b/static/labs/lab14/student/Binding/PatternGenerationDemo/Program.cs new file mode 100644 index 0000000..3a4ab4a --- /dev/null +++ b/static/labs/lab14/student/Binding/PatternGenerationDemo/Program.cs @@ -0,0 +1,25 @@ +using PatternGeneration; +using SixLabors.ImageSharp.Formats.Png; + +namespace PatternGenerationDemo +{ + internal class Program + { + static void Main(string[] args) + { + Pattern p = new Pattern(); + + //p.Populate(points); + { + var s = File.OpenWrite("Image1.png"); + p.GetImage().Save(s, new PngEncoder()); + } + + //p.Enstripen(stripe); + { + var s = File.OpenWrite("Image2.png"); + p.GetImage().Save(s, new PngEncoder()); + } + } + } +} diff --git a/static/labs/lab14/student/SafeHandles/FileInteraction/FileInteraction.csproj b/static/labs/lab14/student/SafeHandles/FileInteraction/FileInteraction.csproj new file mode 100644 index 0000000..673d2cd --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/FileInteraction/FileInteraction.csproj @@ -0,0 +1,19 @@ + + + + Exe + net9.0 + enable + true + enable + + + + + + + + $(DefineConstants);OSX + + + diff --git a/static/labs/lab14/student/SafeHandles/FileInteraction/MyFile.cs b/static/labs/lab14/student/SafeHandles/FileInteraction/MyFile.cs new file mode 100644 index 0000000..89115bc --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/FileInteraction/MyFile.cs @@ -0,0 +1,24 @@ +using Microsoft.Win32.SafeHandles; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile + { + public MyFile(string? fileName) + : this(Environment.OSVersion.Platform) + { + this.fileName = fileName; + if (fileName != null) + Open(fileName); + } + public void Open(string fileName) { } + public string? Read(int amount) { return null; } + + protected string? fileName; + } +} diff --git a/static/labs/lab14/student/SafeHandles/FileInteraction/Program.cs b/static/labs/lab14/student/SafeHandles/FileInteraction/Program.cs new file mode 100644 index 0000000..008d42f --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/FileInteraction/Program.cs @@ -0,0 +1,53 @@ +using System.Drawing; +using System.Text; + +namespace FileInteraction; + +internal class Program +{ + static void Main() + { + // Prepare + string name1 = "text.txt"; + { + using var fs = System.IO.File.Create(name1); + fs.Write(Encoding.UTF8.GetBytes("Lorem ipsum dolor sit amet!")); + } + { + var f = new MyFile(name1); + string? output; + do + { + output = f.Read(1); + Console.Write(output); + } while (!string.IsNullOrEmpty(output)); + Console.WriteLine(); + } + + Console.WriteLine(); + Console.WriteLine("===================="); + Console.WriteLine(); + + // Prepare + string name2 = "values.csv"; + { + using var fs = System.IO.File.Create(name2); + for (int i = 0; i < 30; i++) + { + double value = Random.Shared.NextDouble(); + fs.Write(Encoding.UTF8.GetBytes($"{value:0.00000};")); + } + } + { + int n = 4; + Console.WriteLine($"First {n} values of the file {name2}:"); + var f = new MyFile(name2); + for (int i = 0; i < n; i++) + { + Console.WriteLine(f.Read(7)); + f.Read(1); + } + } + } +} + diff --git a/static/labs/lab14/student/SafeHandles/FileInteraction/UnixFile.cs b/static/labs/lab14/student/SafeHandles/FileInteraction/UnixFile.cs new file mode 100644 index 0000000..c9124ed --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/FileInteraction/UnixFile.cs @@ -0,0 +1,37 @@ +using Microsoft.Win32.SafeHandles; +using System.Runtime.InteropServices; +using System.Security; +using System.Buffers; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile + { + private MyFile(PlatformID platformID) + { + if (platformID != PlatformID.Unix) + throw new PlatformNotSupportedException(); + } + + [SuppressUnmanagedCodeSecurity()] + private partial class NativeFile + { +#if OSX + private const string lib = "libSystem"; +#else + private const string lib = "libc"; +#endif + [LibraryImport(lib, SetLastError = true, StringMarshalling = StringMarshalling.Utf8)] + internal static partial nint open(string fileName, int oFlag); + [LibraryImport(lib, SetLastError = true)] + internal static partial int read(MyFile fd, byte[] buf, uint nByte); + [LibraryImport(lib, SetLastError = true)] + internal static partial int close(MyFile fd); + } + } +} diff --git a/static/labs/lab14/student/SafeHandles/FileInteraction/WindowsFile.cs b/static/labs/lab14/student/SafeHandles/FileInteraction/WindowsFile.cs new file mode 100644 index 0000000..0d06aed --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/FileInteraction/WindowsFile.cs @@ -0,0 +1,39 @@ +using Microsoft.Win32.SafeHandles; +using System; +using System.Buffers; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Runtime.ConstrainedExecution; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; +using System.Threading.Tasks; + +namespace FileInteraction +{ + internal partial class MyFile + { + private MyFile(PlatformID platformID) + { + if (platformID != PlatformID.Win32NT) + throw new PlatformNotSupportedException(); + } + + [SuppressUnmanagedCodeSecurity()] + private partial class NativeFile + { + [LibraryImport("kernel32", EntryPoint = "CreateFileA", SetLastError = true, StringMarshalling = StringMarshalling.Utf8)] + internal static partial nint CreateFile(string fileName, + System.IO.FileAccess dwDesiredAccess, System.IO.FileShare dwShareMode, + IntPtr securityAttrs_MustBeZero, System.IO.FileMode dwCreationDisposition, + int dwFlagsAndAttributes, IntPtr hTemplateFile_MustBeZero); + [LibraryImport("kernel32", SetLastError = true)] + internal static unsafe partial int ReadFile(/*MyFile*/ IntPtr handle, byte* bytes, + int numBytesToRead, out int numBytesRead, IntPtr overlapped_MustBeZero); + [return: MarshalAs(UnmanagedType.Bool)] + [LibraryImport("kernel32", SetLastError = true)] + internal static partial bool CloseHandle(/*MyFile*/ IntPtr handle); + } + } +} diff --git a/static/labs/lab14/student/SafeHandles/SafeHandles.sln b/static/labs/lab14/student/SafeHandles/SafeHandles.sln new file mode 100644 index 0000000..c7fef23 --- /dev/null +++ b/static/labs/lab14/student/SafeHandles/SafeHandles.sln @@ -0,0 +1,25 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.14.36811.4 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FileInteraction", "FileInteraction\FileInteraction.csproj", "{50346E0A-0DA6-4340-BF3F-914ABDEFAC19}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Release|Any CPU = Release|Any CPU + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Debug|Any CPU.Build.0 = Debug|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Release|Any CPU.ActiveCfg = Release|Any CPU + {50346E0A-0DA6-4340-BF3F-914ABDEFAC19}.Release|Any CPU.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {EDBC7DBE-1B59-4C69-AD59-DFAE9DB99518} + EndGlobalSection +EndGlobal From 698b5ccd8d9cfd1e066e78df7fed42c55fb7e279 Mon Sep 17 00:00:00 2001 From: Lumek4 Date: Fri, 23 Jan 2026 14:36:24 +0100 Subject: [PATCH 2/5] Review --- content/labs/lab14/data/Image1.png | Bin 0 -> 201900 bytes content/labs/lab14/data/Image2.png | Bin 0 -> 12210 bytes content/labs/lab14/index.en.md | 11 +++++++---- content/labs/lab14/index.pl.md | 9 ++++++--- 4 files changed, 13 insertions(+), 7 deletions(-) create mode 100644 content/labs/lab14/data/Image1.png create mode 100644 content/labs/lab14/data/Image2.png diff --git a/content/labs/lab14/data/Image1.png b/content/labs/lab14/data/Image1.png new file mode 100644 index 0000000000000000000000000000000000000000..29f131b481342eb465344e0f72baa146160a1814 GIT binary patch literal 201900 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

{n$jQm;i2c6 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

6=3(X#$+gGATZ{UVm0c2F2|ls=%UYgQ>hx z&T(CF;(CYP48QHg+iEbaz-s&_p9sxguF(XDn%#cV2G^a@t66cGpumfwV7f{C*CnQx zYK`Xont;Nk;=fM#BFZn1MpivxVl`DIXAX$0+3yS^;4YG`nu7452?Dlq%M;I*9YC7vOzFZ zIuxN}7X6n7vayZWvceW24hM>g@hObDVu!1+V-z4{`Ep zt;zIXaViXbgb(rX#sAB}m!27RJ$k5E`nPTJq$<{_mfepOp?j!)&`JXe{Z16&jSPPT zljZ1=Vf8dwb+1Eg6&T$D#*8b=yTCdQj2i!n9G#e(GJ3CEV9F`cSTUT-mnFkpQ2cY< zdjrrkNUuy>=FP9FHquU==(w)-?IFI8F=V)R-gErIpRi!)xk6$OkXD;pcL}lNj^+OyM5QzS*uTL3@Njlzxd3q(YC~I+t_NZC@6{ONHMp;5~*=C{Rp!l z=G#QgH`@nZhf+s<;G@=W zKl|c2{a4Gi*$LjCRFhr3YOoey9?B zXHul)*Ppxg5>$5)lMT5ikq=uS1kzucNsW5(*bTuy)zm7Ds=?yMJ$ysbo?KHCCGLYh zpXem&Ohb(O-|F<#*(B;%j@2Dpq2tKtkWuz%iBsCG*+Zmji?2_!Jlj#&k_Zpelg*f4 zzuaOY{YD2x_F!knS7*=MNgMwzTj!a|SAvT^@WHw*A6i2C%sK-lU&yA|q%piY=c6SP zt@diTgZ{f}GTNUC=ypBJ8woia(mkJj@Ersk38g$|+S^qFce<8O*pH7&MSX+P1|2lh zgvHqxrzQ#<_YdDUx)WH?eu~R`8z?Vv2>nVa2E(b-ZXCSHx^pcDixJTvv6-yEY6?Nk z-O0@gAj&Nzm^NT4T*Xa`we>gvDmMRP0B3IsF$-F@g1nZCRKmp=V^n@F0z+OLtuXc3u16GO5-t!`W~f)AnV)HZDeNyR0%!v`a_hqZ$yBg(mLIj9u;tHCJ$*G2 zi&k5Ru_u$ReapX7aPDUsz(q;PvF?82v8Y)GF8h5dm}%_`Y@r26-Zzud7Im@YYY;?)LXqT>XzgXEed@j8dNJjL9FzDGv zHwF8~>JF-IX}|JqEPNk^NzwAgXimi1!fPybnbeC3jt_{q^mt7%sK+RqkGSP|+vivf zG5>VgLxk&Zw#*@tSoyEApbzh-Yo8jKk9-(dUQYioaL5OSp)&)ED={Xz30K6$#ltPP zpRA|+KWKl8)Yj%OzjCew6BWj{xh|IQ136eLgN8bs2&;v<1C0EKIZ$nzsr{rHYZ{x0 zzW+$fn=>`Z&knH49LlyX3Z9;LN*JfZ9_4iWXq^!}^-QLK6vP^8k)iFgA6}&Gn+W!P z$?W0B`U86O{smE*Em5SQ%aU>?of+R_Pz4 zg&;KQAx3KMM0F}7fSEw_vjQCQS&)M@;M0p-=tn8Y@63m1Gc(SD*w-64idZjo1+Rj8 z)8?)?O34=8Eq)GJb`4LUBqxyXdLrn-Iu~A3{qR7sM;0pjvkyuWEm89gDBad*FdzXP zP*v#h0NAs%nTi~TSjH>w@M#TM*x6zvFc(`OQr962fF%{BR<#=a#NNpE3l;~5eHt6R zs&XaVGCL7rbM_&z)zp|A$T&E&{0FMTyG+-FoU%QlgggX{)ovKaa=p=3>OOMmr{cH{#jYjM7@t&>>Wu<720SAXbI&1WOvt zms-4-hr?&8UavTOU>-N^{dPC#8Z$RhuAalak`OdXAZh-qqbffqDHzS_1pcXZ_^#_-t?LZ8=*~N0 zsWy1vCd1wPji)o+jmbw}FJE&Ez&}d^mS5GL=cuO?yGyGu^!b_k3ZIPc#Ua9R1Ve!2 z4o0exA^``n-s+y@t0+5ehG3CL=KU04OW{*=duiIfbsYHH`qh7Af2KMkB_a^E|UR zwbKWR zVD#PCnV%u7;-rXhkkVslYOq`IeM`?anj2;UX~PoX2WIeqo#7m+pC=v3=XSW7#B<~} zU7$Wz9q4G@Yn+;6Z0HUI<~Z5T9mBw@2L^SE*5^g^)!FCmgK0tEDRzW6tRQ#HUF?yN z0Me{EQ1;7cjg(evrUW}kM`?HPS4R(S63MeS|8BecC&AjALuG%?@r@ywIt~>~W!Z}L zBp1X=ZywM;anIGe%AAgO5XL`rNa1&Q>+W;wu_5|5$C}ATqF}aS&9T838&#y=6WOz_ zydf$L14$^{D)}CvQ}AZ8LRy4f#FtuWkm2@Auj!diFdz&d-ObS5AxMh|2uQ=wIdn*O4-L``-T57TzyDqe$8+|6Vy%1GJ7Ei|_h`FE z=;w(pz%P=n&mb*;%DUb5u-!XM6#u@x!3Ez6sr}>sbC~oCw^rO#YRjnIw+5~9^(r$! zMx@Et=>M+2%KBBTqZ?rA{;l25K#OsfL_g?7tA)ABbA5sdLUu{Ly9J4P%@$Ex9eAZ` z_Ju1l;wnzxgh4duv?R}%f4owOt`PXtMiW6R%b28}yypdy`BI%LK0z9&2YLv6pL*OC z8%L7bm6^!f`V(Vj&XDBx%IMrTZ7@5U@8B`jbcE*Y2`tYMhM&AS(i`OoPloUyC#?V& ztaIhfPjQ8HEMgh$EVVtXz_jI`CA?2%%0Vlw|Qq(n(6PM)dq;F z=8ljf?!WVnJPXpYG24!@ZsPwg1TiXGumt~$1Y)3EcEsT}!7_f$n($NQQ3Ag1dsVG3Ex{6Qu|HV5 z-j)4W{*A(xz8z~YWj6s^7#|A$XbXN+3o>y~88&I1DjKql1^4&^8H)X*Jx6|WnZ{u9 z0(;ZVq4qCSyJ>3X;6EBL=-GO+xBKo?SLvV}QhQUcn}ahn;A(PD6^jgsBr z_n4xNB7Kj(dP8t0+;)yo>>`Y}sSr3@kxJFFJdw)vA$+(r$-XS8OQY`n98--nH|W0c z;^eWbvx#7zAUKvA7Uiw95#WP!?s?`=fK!l#DmLk07Z)QErDR9_hKE@$Jbe z+x?t8H*6=fJR8pXZ_w4b)&bJ|Zza(3Gy)l)9oG*jPzAyoR`~rnZQ(*J?qcVyRpcL#e!q z^~`srkN(?G`Qp^^1_~aUh*KKm$vg&pLp+4jBhO92GZLpVdK*T-=)(jY*b1|R?t6uC zJUHa3TC!|&b z=e1Ur#sP|a_9f+tqJ+;K8~u@dvm{UTuWkjYen5l2AYEqqmg9>wH7d}G8Y|I%DC_%} z-JEABrv9djT{Z$Q(FnVFmwdVwrC45BQQDb zz~i?cOjE;>H3tLp?U}T6*nB*oCIftKW=!e>Y#*onpCr$LDTVjn*#GoF9-$x$ftPN@ z-mP+qCu#yn_Q~k}NWqnWQ>e2$dGp@X@2=H|{St$Lo*ER=NEg`};@XTq%A|jFoH4hJ zlefa^bB%c+GJ+?c&fe!cNDE|w4FAA{=HQS^!@s|FuOJ+J#}fX;04%=?wBL&R9SP8D z(u_{sx4YZwowexri_gF8%(n$jPZk2zopsu(847K{y87&~U6yN!LE_mrlEJ@|ECy0S zQhWn&hq`*6eD~_?J`xbtSlOYF{8uUBXIhg-5m~NgnnG!NIE$tJCN`wU7*z~5IXZLZ zliY5$0ogM^UE&2?og(9&9gv&xO0>Z1bH`tj5BJwRUklkqp5n?+LmM6&d;~;4+U%u* zQ?Id|Ug)~^I_O$K>fTXQUPK1kg&APy_AtY)&J4iyj@pTAsCzp}I_yUpQ|JP)z?_rK z2VK~!#o7E=hBW^{&f!RBCX zd7DSM2omT=`hapqeVqS?KmU^hP@yVGylaKtSB z`%{WH?@>{(({AzrT!AzPApLg+`bc`$-lNR=cG!HYcrEZ=xF^8vzr2B8JR(g43nNzi z+rLnzjgEtWFJkn4j&X$JK71Ilw=L*3GPL~DIjUz7<-8ByT+tM?5CYpe)aEn?lI;h_ zvng5^E&H7nGp@QDAgtVvS%c|)eE6NWCM13Q=WkrAqFrbPR z+C@hFtkgx)x3AjbWcB*&Hp&tVb!W8%>wPZ!_94X1F`RI9kgwzkPG3bP!JEkWdIpP} zTjgN&^HP4 z*Z{0ts&|*)RQlEQ%~*8%AT}A(#rC*fv;!*q6R(pgUyS1S0>J2IhV*+K#Bw1K? z+;6gufb!VwOa#4qbpO-?kK#q+iV%A6K)u_mJpI^~hfnsVMWM#nM ze$5=LRS{tI+cXC0sjI20P89xEtTSo4@{Abo*G!_LG{rffFAUwW|45~^U+#~8i@twfR#WvVPn1e^0_F(fP4;{BWz5BLI; zOuFLDp}+g{tx3h~6$kRo;hhuN()+r-eXh|6yJZ$sQ&D8PA(6 zs<0YQGzGVky`kk!tuZ+O{L_7w+LIBGXId2qY8n1^zm<;74{1A2=b>(~L-hR`PjGXt!`I+CIKqq+_P12k?7*_bIx}zU`vF5(L_pB&tthSQrmhF() z#+oHLJfBzGwGvOVA*O3zj>YkeF4Df~a^q zEx;1HEDzVM{`19my5*p0k4X(%QmI?$9(m&lxZ?TN_k-4SDotx9{^L;=%apCwsA7-nsrbkr~Q9f7IiLQ)l zzQbbNuVKd(W+TMpHvmX5Gc3i($?2;#JGN^x+nBmU0(We5fpR5O3=))m+&-V{lA-he z@T0>Rx>M)4_Wjo{x@hWhrjy2p<`+}ZJvey~%$nESw7^VqYLX**!%76b%_WKZ_;2gy zwKjTG?p8%2Sk(2!oO5zuHf$wM&SYkc_jlj!M~rOLKtD;xYi52x8stW{^Qm{hk*{ zzuXu_JPz}#rX``_YTUCt4#Lc?;)&gkXTq(%DSDM*0ffv2%6thR3-6s4e)t6D3`Eh6ecOUf<-?9c$ea{lG!46h?`LBV% zzkh5Ej3VWG)nqCiszFVez(B4G|KBsC^B7BUIF`kA!_*@1mO@@EjJ#yHno!cl(B z`x>T?ZVhe$)ugbt{n$xq_^f&^&gnhu+QS--lG`s@rrlhcF`jF;bcRi8P)meJY&Wu* zQ~QOs#CPbQz6`waEhASL$dU>>i6@7;5pDIuUV`Qhk_k*|N!J;u()8S+L z1+JUMO~Pf-hV8bZM$+(&PzG3BX5OP!B53o)DBba`}%mg*N|briSrL>_LW(Z3sD^|^vOm{DFU zCw5vNJUlmT1c-kgwqx>I#wcCoYs`;A=5WMOCj0tfEWPUb@=xHD0v@NtrX1}8;fxxz zBWFf{e#gFqhTkv<98%Z*-#)mI&Z!PEsHlLA{o1cf$OO{_l-2GLLlDuh&|nfGfzJKL z&47GXwg@c`#w7)`ZK9&6hre^kKj^}$yLwwZizWL`ZXw#h1|B9Ps|AogiE8nd; z@x}5lVr>MYx%JWn5vNoyeS!I(#oUxLJgf6@P*LLIlA^%2G1$wx%n;n3-nrWMTqlH7 zDRs(h=G8OoS8NEkoEePOl3crfqvt1^R9eeCo_GmpesU-o$W12{#uV`0OOd*$!*w zqnTkPK9I}S;jcXkwWkY*hs+JK>c$B}Zx6nr(Yaw_A+fT_k^vROWb;7jHxYQ{$%`Op z&ck?1D0fqDbzRQiUHH$pWwDD8-9|Zu+M@lyrzVI%w=2~2o}RRzpdPA7sFdXQ*Bxnd z8Xp4M8i9z5@ZHAqPb*I@mL3Yz51u2jtno$p5fbL~NJ}?MwtGR?R3tR#RR2J);w3rG z)WIUeICxwLO8mJVd2bJw*mh9-{H_jSlFlEil7l677$C0=)4{f|7%Li0zXSkJ62%E! zq3^OGO?9>qfz3KAw6dbVVyk|vB#=6@61AvDl~p|T3`ti%#XnPoegX!tL&K=%Cgb8< z^yoJ+8QJ(Nju(PPL32iXK3lykOH1iQV#yje{6^=7OIu|@x(0N^;!jh!&)z?Z(%b8c zU`Z3vEUtrWQ&ngVrHo_3Bx`=ema{4gzKXt{dRg+k`-swmoWlHD3Z_0wa<%;3wO$HY zEI!!3Fz$F+;VOlR>E(}wCO8nbU}v{8 zf%U+gStKxBXSVBq&NOgVNZ=okTN&QnUfHOr@eX7x2{LwV+P*|}^QAYV!qyqm98MV* zUp)0tyPUl4WOHR5)ou3yy{A^$5!qswj?*-sJJ&|2`5D!+`bx+{b{|M-eJzNE(6bQTqgv0h&ON|%wBUAsEVV`YEs zQmrMrGkzLU@WSgZ?f(a&bS>zm=8Gq~QjScFcg}xg_W`FBw5AFK)%Z_mP2xDw`wUJm z$V8kOB>x!N^&}@~p&@!eP643B-kGrT$B7z+RQS|d4pG-BhiVB;jwanAbb2hWVM_PP;>WLjpWBq-fRqHzLkxn7ND%LfqQO`0clyQ zK`CZeA&O-nV)FyUudfBB?xoGw*fAwP6L9@4p6TR-R)^}lk24*uCr|NdJt`n{KTuxN zYuc&{AyvFzZE*QX{BMoy+Q}l2od(tMMW`CxG(b0WKJho zu^-Xn`*jjK#9_APg;(+zTjrDnDpjgmUgTP11F~f1xwRQ*5?!L)+bNhVqBDwj;(UCW zG4q!?A!L<*iO%$IVj!ver`JeP=<3N_u1}nRoIae<+i3*m$B!&rD*Jpgk7!tVxGu2l z;w}oBOKPG;Si_?$eg);Q0$e0yBq@(eKSmg){>A(C_V6yzUdf61G($cFzM;;uUf3a+ z7X4w=@%i?bcC#2nA_0dWbfEKXF_oRO@7$8lO*5b@S*nmq;N$@EYx=Qe0CoGgVK7?v-_bmS6YH=AFWsTD8*^r~B>}>pu znk62wm_+Em*tF{3(2o1t!>9~5H3#HpTx=DBu0$;Dq_pv-?uIa<9w8>nfo^%WfD}*( z?an!2@^Na7^xaopq+APY>tqhSQV0Uzi3D8oMsSI6!X(e8b412{)fbP`ne`_2u$O|K zJKfPVLW@xB!cUBDrwb=~E@%mC?26T=Tjx@6L|Qtn!J6a6ue|YcvcU?NNndHb@oyZ_ zL-N4t9)>p9=~H8mAm2ayD}p2=w(mx8e-{-l(F$Yx z*vh&9)+jpPEjK!3k_j+>9ksR+dH_;+uJg)mOvzVvXJR|dDG%lIEXmpQL(Ad*IkN5D zvQiS)b?;(R?NsSQX*XR<%6g>7%H(2nq_@XaghHY{X}NRR%k#N%qkD@3@~NMBpG^`i z*}02FZ^jwnW3>(#F)YQRk|FFrUU&SH#E47wnzU-9&evHR5b!tJi z&xWvKv%>fcz`aeL>IQ^&bhQR&xFPb+fqJ#(Wm^B590#I8#|{G!JLp0PP48iKA zP>#~OUx5a@x-CCG+9?_pxc5A;}ku5zyGPaS=8;7ewyIY-T55g zXO_8t1P~XNjIp1toK&OK>bWzHo%>8fE-~uXqNdRED)lVhdN2M_dTgY35QT>zIXC#c z$h4#psu1MnWkqeFCZH|z@duPq*f}E5d;fk^8|Xp;gS+*hUGAQ{Qv^5QaiF=|;--i( zHh$SFws2h@QR-oxx)>N-tY7vY*YFjrPGZpH5pz$5zSp_-AJdig)d7lKKgzikJU{{# z255nRzib;|?@7E00~_)m?ksB}N(@&K`Z;qN!Yt4(9i6aG5cqNGKTW3D$z;ti2)bVA zQMayAp3}TYpI>Dv$fHS4&Vn5rEBKpW)QkfeAs+*nsN}w$KY}t|K9{(B;&!TP)gEV! zY#*MEH9lYTq+0Y;?&+KFL(Wb1xXBe3#~#ua?+@`lr-Q2@YCCK%-0iyY%8Kw^kqsRw zR;^d(%WYJKT`xL=D9hZKNtso3K&L6DZV<21JYbQXS8In}&9*}=lRuZZOIJwtvF!zu zXI{|1{_JTDf7lsLO%ApZefAa)c?D?mR3F>}vk!4| zKFvdp(Mi;}I3}d{+9w?VG175R4@(v0p0ZVe5;(4>))bNfI@NRp3Y1R0;)(KGh_JUu zsg^$;12FeIET5XKj6B)go?>DLEjnV)l7y|%ryrXKjE&8M5{waSOFj%uFiG%!B)s_ksYohew zXtAje|7tGL!0GgIz_bihIzodwSE8nc8aTp9*g6%Ao!b2g5;W5)i zOY}F2{U3X_mch7MOLT(H9N1AkG~L(FWx_4Oh}M1isheXB0X1o5+QXg&;0^~MQS|cB z)T^5rmAC4j6nATlx-Z$XZNad&`=dr?#UgtjkhhskI!UAYc6PD*Td2{6?eb@30V%9aV$U zvGw!6UM@drI60h{C}?bjuC%wlHfj{rHlB`S#B}_K2OFc+udgVCB)WfI5Zu}Du^G=* zWlCj`7u_VgIY&eBZyYcnt{3;pUAJGY1+A3xf9vO1o2c%%+k-*SL@XVT<|b>T zBF(dl?qi7B%N2Qw`;bq^1OHN7G{sTYDt)iI92SB6Rq>3QUH>;`WdJjM^l_^M3v^Nu zhI2d{&;iUTxF=3x$uU@TQoLYoK~`X*M^G2zt_VK@58}<101~VyP7qDkPR$r|5EL zwx+r13tM}79Q_tU@b2cI6@!BIHM?;cXux5F?v)_u6P~ADjYl|QL03@Va5|9!i)U{(zB}ylV;O(tLWugmo+epjXyxUz?>n+w2v)Ztw$U6eGMEpBH=I5u)8uxPq@-bEinoXN%L=uJ7xDDtFmli)|bp zfN-M_(Z>n~{$1q{BXS9d1o9%Nln{EynC6;A6Co5uQ_t+`-(c{qb(qLaaGGRsJp?nR zMQ;Vph7A1VVEo@GOg636L3-O}(=F=5s1fidSbu!2E&`mrBF)wm?vikyJHl0rNY^x+ zK!ZhR<``dSAf%p2b=xwynvr@cM2hJl7TPXZ5+rk=pe^(RvlP0e<0cJ2^x7bV82-7B(OLI;w8IW8Nk*sWrX^Yz^- zQ?~~#!*U8#U%&5Mb3JZO?^?=W2A330lrv0XxO7V;7~%tBNT4)srRIXSo2wK{xDWcA zzfh`{aD*$;vp=Va^*CReZEiC6Qry=zLHv^In30Aozy!|^Vz?Xss)0iKQ#;=~92ri) z?tPzBtLD|rp~Y3xR;puAqjA64eGP_>kH3CKytnh$)bLhabw~QTkERx6pX;aV*uE#f zq8sdP)Snc`@o5=+O%p!NYsa}>%!09@BY1uP9^9BDY820rT4&$puo20%^)-ea6<#=3 zGS_Uf>@wAmqohG0i(`bJr|f>Q$l@#&zt9K9y$*$V#`koW{=wOLL}F5*I{ z)Rkr3PL-E{yWZQm4@I`e?(WHczA2k0-E{b}mxk2CS5amqDsE9^e~_9p><|5;*#d>& zyw76}h)HJ8i;#|$Im)-KsRrOY*FBc8U%g^Lt0}`|Fxv7s0hPTB)J-fgYr*`jtmfof zl$?-SV#@p>`uM`^gW11vVNg$EzomyThgssXz>8{XlRj^^ZJR-LIh4qlAlK&S@l zeT!brMuP3^@kFlT`dp17&eIh!X3dg9j&UBe-Gl9s(j`k?pKl%UIA@5&WXR}C)9G!x zFg5B`Xz=WkGtu;A&lmf7Eb7K48=Z2~!7alLN#TnXWk~d7RV%ClffrMp%7-sW4LFH7 zlTtEO*fKIs2KfRoIir~o=FGM#{F=WgiX?)`)@Mvn;HBnVEBG?ee~R_)^0H;FyvuM% zF@w2OU&JA!0Wt1Re$OdOSrm9*yqUzoqS5a!RPr5-)r=CrR=kR8!uJ^m9aZXIQ3ZKq ztCJ`M8Bs$z#!fR`5a6XqaF8MC)1}0v!skW=D<@-Y5pg51WectvKHneIZ)v7|r~iKH z&sGdl)GiYpK=qehpEq130nCA!8)n@+0<}dMtvP|Z34x8Vf5Yh3hwKM(5hi%UT68{S zrP-rUP=%&Fb^N@hLfvux;AD4dv=(m$!e8a}8(H{pxZ`Hs@#qZ#pGo{PRQIzlr&4ul63Re& zrxVP4ww=wKi3kAw0Mv9JT4gV0Ei9f?3vggP2g0=wVWC_X z$Vf3~;L*i-Z@tKRrvdt`yrw$wWe-bFP7f}??n_; zf4}MS3E=!%98hSRQ0pHg4GK%w-k( zhD&vTl@V)jWB@$D_WC(I{KcvvnD%|>v)6ExnwiSli(X1&K#L5hM2Of2qMZH{_hS2! z+h=3}i6y>IufNJqg;#$wNzdtRvRL~=ETv19ySn~&D=_DO<`Is!hb2X1*KSp`I@PC0 zSAKluQ|4qwAA{fD4^s&V;sU;ny6y4b(fDrOnorMKmuBE|wUJ^U2GV&S0_G_-BmUX0 zITcRdqAtMp8x(rN8}(2@V7y*cXNf7czjEu8dGQT-0RIKN50VrVfUWE1e4)%heDm=W zO*fohYk)}nM>XirnCn>m(NK+zKmQvB)Hy0&3pYkIf`7k0a9Vl$m(&sh*b>6xzx(qC zcPD>-nMEI+gAUMQ@ocaP#;+ak?b$1*bq}Xq&Coa_RIk|zMTO)=&Rwl%#^mo$ndn{* zMI<*F;p)7H2eecHh%^@7cRJ`wK=|~5G7yhaTVu_-n1z-CFqj{Jh{x-0H0PY7FJmfPgg{+euPtK7%|l^(BT2aq3h z*}JWrZae#aC$s%~IO`@Yx2r@`TY3nE?iCvMZf&$Vt`~2eN04-J4}XQwi$c+;$DiKW zex(|BhEt|||4x9zcK1$`Fs?@SS1~~*khIZIWqYyTw`UAivYFRH=!L97RAd2}{bHqz z`a{lF%(n3b5*bUsils&DPoSuN7@*z!UY@}Ib`^jY9|(4<@NO-NjGf$XWydTybgNrU z=|Y;Whh<`#yG)5u48S|tXea=VRp4uEIfOO1`9x{BEsz!N>((8uewG;z)?@X#QS5vi zJ-AY^5A-Gq%^IJQ*z}hgDT?a!G$?Gr0l`Mw9NJYsT=z#Z{gN8?Bi{Ig()t60bH-j+ zS<%AgV~76W`{ZJvj(^F(Ah+90SP`kJZ`R$Leyh)anH&5kl{dNO`OI!0F}>BlXZ0Ik zZ`fZf#O|BY4*CT;Xzk*t{uB?4(XPlR^!vlTm7J%CtE`x|N{Um0{uNe@luzjcgKL&A z=SVmk5>3$P+gzT#C_X@q-k50$iB!ZU@&FXc^J~|$E4SbNQq&1&C)~KIuLz$qyuX@$?@JG(7 zE_0ADX+IM&$uk{B=krM5BtxNRCGKuwXVOcRoH3CUE3zJ!1$AhDu_Uw+F46CCvtTt5Y zV2k?SS7irl()4<0>c4{TN3b)DNndNBrs4fUeeOP+SSI-xaHz%-;HbT-8dHdT;2J*p zftalZm4SZv2lA~IKtz^f8-}hJpp2X@@ySC%b2TJ3Q&H!yUdTtF&LkEY)kD43p1v*v zQG;H-`mMeJc98x;i#sKi6iBn>MxExUUQ_IL?+zG(HA{aJ)yKu@%{A5=pKJgvbvL>g z!0m99y??zoX66|dwBV>FEK{o4nDji?q|yiU@4nX zDKADNiREmPi(mA_Y?A!SL=!h6iBC`bY`ZDYq#O=~yzi_CfF(kL2W}5Mha1g?Jo|<0 zvTi)@hvRSDy;hCCeTeIA^>W-7SYkj%S?=DawYQiTLfWbdEWwsz5hU!9U2!d=2oi?P zKyzR;&Art2`hHhbx9(s&Z%MC3FXHE~Dn+FsHIF$nL!;_qk@V_m5(gs{kD3CLiIlcP9QaJ<9bB-^5Y4wf_>o*0s6f6A zX{ljp8T$B%@P%CaJP^Mj2A!|#U8MK2{i}A;`-3Z})=kp~@xAMhYFeYkUOb*qM{8e+ zK}oNYAP(~+*e(Y>me#!{E8p5TlSP)=nhU%^4riJpclt|o6t++W4K{>;`JQ8eGS&UW zswIibI%Xw;v9(1}=10s^rHeav13}mw} zX3nR(0VNR<;#JSH0)wbDP)^IC zC$0hi1SC%8`9B$j{VErC;}I$I68Ome>qD2{NbI|K$kn?qh32;M+LptbDPmA*iXhuX zxeuFp=lxtbJfq(7@7Ohgprp+etn8b8C#a7n5-U%BNvjqQ#yXilx~Ws+^?dcoTVS}p zw%0|roz_EyukZER`gCjimlh$&@a`Ty%on_^kL%*E^^J}xlPP229zBWCx6&K_abY4? z`0~#udd5WN&o5OSSvS`wi$2F(#wLP5u6yK+&}#3aRq9g6Ye)W``D2nK%sizZ{Dym4 zRiM@-*f(>`vcK;Jd&9(2j>8DqI+*Q3rI70?eEmCL=)S3X1xv+*H|t-8!F9~pgj~Gz z7PJq@4>+)tq&O6o71RtQP(3@hfwbZwp)0{8)I4b$$ptE+*mo`Z9bC~a@ zBL8yCyXV!$^rE}O&t`&ANU*nKp2kq3k^OelSEMJkqJ^{oL++BBvp}?9jOIhJ`G&Ki ztS4OlSZ)~#p8)E{4NGY=q8zj|I$eBvTGQ-a`3asi(zFov;Ky9z+`j#}{Lw}Nf%${r zRXesx*r{)oL$)vVllQ8Akk=P7Drqws-d#eIaj($vKg*!bl;DNl4|-hu?m`aGKKsO; zbQ}Dg3(M=y<+g&-H#n5P5A>oM6#Z6+G)SOf{#OJYaJ`-sh9d@i z;%^MKfBbkdCQ1Df)NoDKI_t^9IMz~1F-+Zps6k41Tro%>BO(~Q`ke(%7Xbx*T(0TH zzC zgp5cfO{YztZAj$ANsE32-@4)fV@PS(Btp)Pp?rm!O-N04;BUT%FJ;wtM69&1;$ z1QUGCtp*Jhn`KC?Oi2u1h_AK6c3gIAB>#+jYOBy(zgV^1-P|+) zAT~G&@Ve1Qh}C|7Nqrs%7wG6&SK86TCLOM^`D#pws_PaW*lHfaFp!!-IX`#>I#XK z7kt*O?=dk*+x*1^$tYgcJV6=zfDLMc8GK8=UwChR@v_8Z-=6Qwe~$yx_2|ckaKgQQ zE~DfH0e3o1-{al@IXSVgr|e82U6%?T^`sn&8tROYbOtkYC27C0*CqGZc=mu2)DxO4 z9tfN)aT1xj9Mm62c|+S!=^6zM84{*o6LA`Qwq0}jx;Y~u&JT@d_?$=UP^rLJuirPU zRY;nS?gOjYV~*NQOgCKt#vm=H4>sm2Uuf6yxsnU_B||HIz3c@(mdkOY+_&Sd7Yppv zL(&i?_xBKIVw}T$Ck3>ghMRy_oYOZ8*)WA#Hy9fKI*sA}9b5Fxn87;) zZ(W&ua3qlI-!Zz>s$cX$FDhRPc=)nn=7-r z66jDBgZ4)pC|U=>TbLmLnyHrUJ#mm+`+nNG+9z8DVB~e~e}xAL=am8>QmEe#w|GvY zv_#x!N^du~GoWkrZ+Aumb;$1eZPEG-%e7E#TNG}qzho8vz{a=_jHK#oz@@A*KDRzg zDmQGF7j_GU4B7`NFw`YjdkFG4Vb22}oO8E|Wmy?U6RET7`qrR?Lb7(Xq6S zcZ-wRvrJJ$aC4k$+xo-aoa=17ay!rF1roHUr)h^D8a`5)!x2R?okqf>%brG11u}0N z6)kgk&zEQoM#<=y`cXi64Sa? z9%IlF?EXnR?fq~V5pCmGkG4GfY=*(#hwz80ii^#*M`Zx^O?JHb#uixM`R+4!?}JJp zuSWx=mXI=f>{kjEH6+OhlDs&f=S*i;?GpN?-&zINpmd=L%OfvrKg+=%P;D@Cc3N)E zA@ZCmaKn%NCF@*5V^!;%&Ksa-n?(|+ua)pwou3OjlYJK{xjeMoFuOq%1oz>iVnJZ>Y zhuD3&G)L5e+nV1wQr+c*pmmQ`Js5w$_r}C`Av8y40a#O`C zgYtuc)V)W_yhwGg)`)HK zQ!=#26IcqG$sSy{Ky8yr$wRoK6|vt3%;iMSOK1wlB*G3YG&qCvhr{=y}Sm{ zLuG?JnN0&#%i{bw$E>zgr0E#rj>Ur6!=h4CFbeq%!(ob*hJvTqueVzLm%aBva!75oDEY5Dvn^g!qNh6wv zu^iaVJkmq6EB~w{5i!>qXnh|Qe9lz{vbbwySX`nbgzDPpmi;iUZ` zFZ6z!C%J>_$APC=#!jjrx>nIY<9ko!TdVatDdEp{+lx}0*I^KnLcP1%C+HvH4S7&aZ%iH~ zCxT#p^Q!2@&J7&=_7hb2n!xH)cTP7)GPEO4>595ToJtebkcLgO*s-4@6kL+UXRca; zczPk%gN#UI8O?Lq6=*NNtTfE6kP2lr(@_gyEAv@wv}XyD`-Omf@ul9EQ{xk?1+mMI zrmDg{JQoB#zTzVF%LbTNb_VYHlO|tfVDgT4b;xkolI@nGdf-#D z8XI66uSGd^v=%C**Abs4bO1mC->hC03H=cMYX>&A#6;VIG0#Et6FAlzL6)PT-ARd%y)Y{~0zbU3V?yQdeh$xM|~-e6csOzU>s z-`UmiGlM{)_(v^@Q#tp&d?nj+b*^)7dY&cqm4Bx-W3115Z_g})=B4xFTorE9!S;iq>awD0 zr_B&adSUuW(sC5Uob6~yyYH_^4y>}OHwc!++owhS@u%7R_}otx(CdWJhiz&jnFIT z)Lu#XX$&UAr)E)U61*skM8_x1*Hml*^)|4KmC z2BF`xx4UC(Ogh+t@kRbnv&5^!+(>F3*KHXK2JOgB=6$BoEi%H zH(n4sOi@VQi+IiS#X%$g-9^gtTq%~vZBJMyVWb~27CmRmVEYQ$=TZUx{6y_5_HoA* zn;iv%sU0uAuP_m^cmQ7>yM9X6`#aX^^4QnoAcENGn~vZ$if?EYz^BJUYk*)rQKQY=J0KvHFy_$#5*T)h8dw_2o@`;!*^ zDiCt_;yfzqdNBz55#h<&K@qfT=4&j2nNrHC_N`Yp%`P5|;Xw9ZKU~&wrdPh5ZbdQUz&wwKr?| zM<)JJ+VZ5J>y-2djSp1@I;*P3ME)7kC-zd=U%62>>n(}2zO?E|X$yKn!Pnf1s0a=H z&tOCj_9NaJD`bTBzl)tr6(_94v!CMw7Gprtcj3(DcY0qevg-IHRAf4}ke6netk^>y2JK*>8 zA5vYpo>*TT+LPFSaX*V5sH!@@yHSv__LtY4@8hTkfZ4#Cl>&Fpgg81Xy^OQjx12WoR}+HsAr8RN0!<~FJzNPr=J=cu z&IRx-w4bwX2hGVb%#sjMt!}|FkrDN!7b@0Y172wSWFT+Q`{{bQfJ@cqp0_S?5(q1> zkBGq1j5V+%DV1=qjwvEZE-X`PlOL-#zH)|3nl)MYJ!>(w1z#e+P2nr}%dw4YMvKVx zn+02klhc(RZvi%4Pc;PPUB;g*V(054;) zg3-t3>Ugg++-UjqZ8&m*^-}CqlZ!0v-4NCxuy`8$&Lfj7Di6PYx-D4uY^LQUO-?3c zRJ*YOwz@aalV4QyprJTHhL6T(3r0`oDxIq54vHTQd!vpbR9!S5()!p!J@1^k&G8e^ z{dRFgh^7N@Pcn0^3z56ix!vh;tAAJgZD&rhAQljkdo6bNhiH@Icis50MvnZ7JwK`L zuQl9t@*ec+okQS9%$A)LM?+ffu6F%(2R9kZ*&H04zOs;l>-DjwIw-{dwr^NFm>)`$ z!i6Ut9pZIAEyrTysZ_6ypcW*CeM)RG8D(kGv-E%Pez;diP<>xrsduyfxe(6k@G-b0 zNhV7bsoD*59x0ifoHg15SV;hY^iJ%|kGa?gz9tJfwmW7@fnlkO} z1{+Arww>3*)rIk;@6<`cC+BW4mG#MJ0Z6#9U6x1}1@@?YQe zu-KFuj?UK1s{66*xrE%kntW1FS%}*?VbISAUau+;o{gt61s^9XF_s}1Vb0>q%k^nu zMyMhWZO;-=a)}F$pLpTr2Skodt`APYzVT&?(dXI=ar`TpeYz$B6Z<)W=)yEj%8I(@ zsy$VE+th|*KG?$pDsjx81Q3DFOwSSsQD!E?i`g+u6M%>TxXS~EIe0*47NyKR(!EL1 z3QSn{`1*8Xa7*hJuI{?nl$3V&mG9C2$ouNAsJi!U=@J2907bePBm||qyB%t1rKDj< zr9-+yK)PW-8iq!?yStH+lIA`7e17=;4=)SWnl-RkbM`rV?|WbO6@<$9lea%9N(D#V z+kCc`I}PcG`Se=un)4J4LnMXm_2zN3%D+%E1{*Tz761vYh?7g#MK32`^}OY)6Nv~@ zW1?x7nIBc=={Wd)Eb}J_yqED}^UD}fulN*RiK>u_d?|%6FcoPOJhT7BFD5VZT(Aw$8pVeI{CY2?XL*Lw`iAgt}+5EShjKVX$x(@d* z7t+6*2+|CGjss>EARM+M>AWn4T9U=3@W%ZcgZ;Fb2Ysw5xW#oprT%8PY@APZFu4l) z7~Etgj)s^v<=H;LTDj*Rd4a6fm4>Pibt8eQ4+?ZIg=*Zno=Fvx1&+Zhni%J_+Fm~G z(l`{I;lvM16LMH5_qYT^OEBU$c-9=3^*UAE7SyAf0=QuDVA z-?%=F!N&`fHb!_@uQ!RcSBMsak=b@Qm&k0l^H=r7?arK$rBW%0y~4Ooj7r{@BPdvb zrO*cU-~E*;HUbt+PWARvfaQy)Bw8EClmqMQ19}J`+ad{T2& z=WP54wBzQa=Cfx_I6J+=d9*TYp{MAt2-M|yteitHn`jG^`37+NDm#EQy-x;B$qOJN znIv$Tcpp${h0&?I%nkhfz0u=A_%^P~fFTY#wi`MKpgr)#)m7?JyGGKlr5QZOdo7;< zlIM!JKFWI6bKg3dJDkvB0J0@{t{Zn2Jg*hqk${TY*`iz=?hQ0V$#H7_^)SGI+c*HJ z=3^4BRqefKW6m`IXzqhst=sPC`Iy(o(;pJ{pNSrZvOyjIv@se!_sR#GSZEtXP+E#j zVGAs|l!gM!JKBlK#5Jpk;b4)+ys|ODnFmT_3M{JhyRBE>7IolPM~Kbcd_Z{IIef`mhNBumrX=}^T32Ti+MLgy!n$N% z@tL2`{)l5#Mn$N<9YDoJ-+&zaDhLAH&aO?mVL;b5wm^aXW5)Qr|rL0e+Ym{3;1!>G2~)L|I4xSxGvq#5nC{ zkd`fQbqV(2e6!iI)U3;BCKaI828?8~3#oPtwx1`{aL*;+K?qv2wCF8lgR$QuISnI| zf>2F<%J)%I zirXMsCjNz7R2Ychnp&#@-f}9h&9?i=U)U)~P9}i$U9f}wj`H=5AKF~ttookz^CFyL z!I?-+HO?*I$@@mnX?nVul_S&nK?9Cd2mZ)Jo8?$^QBYc4T`ON*Bw_&(dwF6Gff|i z=)GCKB3iSlE7~w(2%RZ6b7V)yPI zvRz$wd!CPDeA(gJUn5s;AeR+g?Mr$PY7N9+OqE`-=8{yD>;VY{WJ3ISHphdw&*R{m zBgPdaf`Ta|L&?6dz*e`yOeppE4YS2v@KN=$L@--2rv!_>TpSY+Kew=kUZZi<>1Y>5 zd>oR&Py@b7aYQthN=G~%tl&ZZgR7rger6}cZXsW8&as^ETRTCF2+4RO zwAwS(^e+!a0N<Uqd(5;{;7CAai?rd}9^@(63Ua5LSxIF_%%Q_-%k| z%7?&2n-Xy0uP_PZ;-bFX`56_}MVy`t{c0+<(?O_GVcL_1!>FvUS1|0FeRfaxk*CcJ z{76p47>p%yM%52VT^uR#dl@4?|Ih|k{PtF{SAH2)K_C&>U200gb*dWiC}+IZ zsfn-E2c}hK+T$N|VHSQsgPJ>o5`H+=vP>nw_2$$FqT15ojPi1OSeA^qw8+95iv!1kX2l=>%GrWAkn@?o)M*mS$AGj3ArH$ zMNug6$d1RF4Zs%(9fL8?0jkeh zKN(F0B#6M0*bq_-EVH1AguIOlDZ6R(Y50@>Vf=^1s??VYb_f074Om{_{1k0eMeAd_ zR%ve}Wvl(kD%vrwvBz%n&i5RMJZvgkB?E{Q*g)8e`yO}vY6p(dJt4KEwh*ytkE;U9 z)|m8rA0A|RoEosSGM2FtZvF5UQf1K-CX20hIR5&{0Pq<3%-32s{9W=Wu?zz~j=(c#Ou&wXSkgp5DMvv+^C&e>*b(bL{M7IQ^zR zVF9?}-f@~WR>N5m=Xe)j&u06-wwLU-p?R>kCWFaEaSTFSK+?*%^P)&w;dNwqxW~sH z;1`V+a2Xu z@v>%>dBvcJyFa1#)5ZGlIZOM_Qk>&pbp9Bfss^VO#(Q*v#uHeywtX>_8~s2F?vQ$We2nZ87g8N~ z&l*h1^?=IW`6|3FxG#8B?)xi^vXWM~^wvmne7qbX!%2Cf9(x2-)Il-z9WKNq)nYOS zqXsO0{m#abCT3wjlr0)FIfW;MUh*LgeWTm77i^o+#Gyd*4I>##g_ zE;^b80p%6f*$VgdK$~LTeD@&DXGVI;9i~YhNSEzPjM>=r(B{WQCs*bkbKP9`W=hxN z#Nh))7+R*RoHXbn@`Bp!jay)0T>BW^!(L6pfenv?*;ap=1^4r>qG;Bh($e=&qQ1w= zz594DD`)aNg0K$!=4a2CcbxY<`1XKnyOFmJeBJGw;Kr?6p<9Dv^5krPz9xO!_4f}( zk;hkd&llWXAMSwW%yo)77k~wbFQg~gkK#(hBcRsdHGu|$ z@;RhCK0Y36^U5x^zVu5?H7f>e3NS@Zu(Y%RERHsYk+}D!a9+;T*87sMFiw{?s9bpn zcCu0}!YRHaH{TThLzo^jVO=o?Kteq^q9a~5e2rKRcM%SEJMA;PJmgxcdsmbNxI3YB z7^j_mEATW%F(RREy0H@QR*IREfxt^Af8<;Wqs)WOhJW3A&af2=gjkwV(e~k}Hy5i$ zynI}0eH>r>#I>2W^kakH?s`8A=;jkQU*mhDL97tvObN|+IJ3+7XgJ?CKN8~1Cj{es zC)~Kwe7u;cvTKciPRn;T|9O~MC@0();`vQMj%eH>-suc9?P5|7`25&><4}dD6OBRpV zM`uCzD#HVam5q9P z=cHovoNjKtD$EwMZAvi#EHH+5_mM-qa3eBbNrZ+I3AlCyHW!{n)U)8omv1-b%=6wo z2DF(Owvk0C$-N-C>K?pxxg-^w6`2GauLCD{CoNkS`jn9XyU$XczbAa;;8H{{Kqc1z3#irBvXNS^ zuxQ5uD ze}3EPcx#mwj7^MN(KV$g6KUUrO#&w7^Wse`2~bh1^9qEyxSnnEn#R<93IyOI^U#-g z9c6hl(bQS0A(uEEgj&{+QTf7VCo9N#GRS9A!wV7$@o6QmN9Z2*7Z8WQrr7x0T|D@Q zYGUVS3Cf_zE^dua^{>|hoG-C+NG6-^~MyB%S=vNk<_>-UftlD0$axHo>Zlze0HZ?|!E z@O7*g;nX3&h0Dqwte& zef{m=eIozkbV+SXfogs{QqdW)+M@*$TWJl6cDNOwVq8F+cY7cERn7D^HT7Zw(p^N` zKb*syh-DL?u5R`Js9T9_Es+hXCeHa(_3;YKJ_|wzJrGdwTg)BI$*tMT{18NazklO} zIhz2(rF2G2H1{sT6(hT(Fy;r#i!^p_p@`7QA`~D^Y1s8iUZ`R8c-0rc+zI=S#FzOh z3`a?N1agYTEj)SLBd{cWZQ;7-=HgHCVLxhJ2@tWZhfshvHae`$H~FZUb__YGFLm{Ow40=H!yA=k6C%m+ z!eXt;*r1nmq14)9GZ02`&tyy^^aS1WSa?<*^EXVEsghj%rxsAdqkF3=+<_Mw=2jESnIpul!o_T4e3UEB> z@C?AQv>WvaRVEmVLPJdm9hocl6dm!;M*u`*%z7& zH&4mGS=ma*ud0Ix=<90lZyXS@mkU?^t%t8j){M(Hi{?rEDGq?ZB>^P+9`b{nsDEe4 zu*g5lVbIJm$(~3lz|kkQ&4kbvvM(dD3}2$QBO|T>H=1-|ye-O#U~_7URn5_v!iW=DttwD_Avug;dHK=A(J^-!fv}paPmVkL9YY(bkS-LK zYQNfjFrl)+vjwAXmbDgGEN=|GKPPlLd)*GV{WQ7?cKu3?jD!C;T}l7RwOv--LeTG& zrKSWOfPDsf0k`a$qZ#&8R{n$0)<>4(qHI+3eCwFTvHKZmu@vl;t^tndlA02JDB|dp z0_{Nz=y%?`ej8ke;kadr@D9sRa_arV@MFXS)5OI0GNWOQs=2E&4<>sZhOFh~dVdzu z1%5zLW^Ou|jREfavwdZ(cDM)Li%KeS^ za1(0`mXDzZ_E7-A^r3dMp>F$uB=RB`L_b5-5gxAhH;%b5klI}-3l>QPN3F|PcACXG z^VsJE!mrhico_8PdyVB@9|;tJ@b)dTUw|Sa;%aB*IN`1JLz8Ry*|2#AAAwF+Xx9h^ zyMD-_h4{pC2l?+@lEx4qO)mCh``KuW)Q0=ub^XY${O(Q zpAJ_o7nGdXb@ltcGH3#jgAh+f^3*&1cNDf(`EUkHt3rb-AXmHOx!g|8_pJQ~%e+9t z<}C;a#OWz-IO2z0mYPE772XI&#`x5a^-#LX6ZAwv)yw9OvlqzcZGS-hTZ_B=YS9+q zlLs<%cCZ@$*Gh=Qb2x3!d9UG83z|<6-iav9rp|J3=p5 zSMno9(nr4z5O1Hu2;GyV+)xI$|B(bVDvdiQvInn$aQUPSZh8`rBkjA^Hy_fROJ)q5 zLi4x!`Md+R@Cgct>cG8TNz&Y?Qu~u?VcPMYdev?iuF7$KiJ?U*B|r>RD$%{wTtSo> zgnL8-dHZ(N5kR?1&z*}_1~f@0=Czt_mtfJ@uO>H(opl~=Bov7O;j!wgy;w-rc#jZJC=7bLs+Qz^ zNh_r*2aXZ8(S5@QmPDu{mR#9^Q;lBT{Xo);>h?BW1?OGo&Uf%a6JKqFMn$~VpqB|I z%!MtPMNaZLy(uS8jM(iKbvaz;4DgO-2doIS5iqP{jAVHwSHk7zjVZ|0VjkW&Xcm+_u@ISq3Ow@50 z&=-`>SIjg?JfscuePX)pZ6S+4G(WGkPA9$V;qj{a?D^y7;*tKPk8PnL;AY$cl&m)% z7cEOIP=3^=_Rk~=A6TM$0q93DL{}7H(ujc@9fY9->+-eX`p+lT%AoEPD_ydaF;%`u z-H{MaU+&!|Z?xb$P<06nAbwTZ*7LX5|D#_v|08Eo#!ZY*JKk+rpnELWeB`2|Z88(; zofc}!js4ohN+n@$Q;7GRH(^2RZjrc9KLv)&yV_E^_+O7Rxf^cVx|DK~ed2Alq$3U( zll=G+4+UBZC$pBTnTuPYr`|(vwh;;pApPXbapTRewgaaGVck zi=k`TAPf^a?;@>VGNl|}3sk)%o`l9D>PMaO5>=Uq$;D|=P#F*%%Iyo^xUrtADj#A; zF2l$|^(K9H`^bgVH$_4Ym-k83>-6f<4U)3!G#9$+p<8@aEpGQWhIT7#O9ee}(zwG= z&Iss|yZNUr|F79nW&hYGee_8cE8a=v0ZpF@U)du%WL<$1eF~RC?}{p-vBh=?Sx(N1 za4@5?E+Ebvu?|Q;3exH*ajc~FW751SnCrj~%`3B+NSgwqBI@PF**pZTe*fFvP>u&s&qeDO0b64Ib0)o1wn)#7mi>somO?7{C^t~lm#d3eJdo>Y_o z^Ik&2`@{!ySnT+LttXn=@8>&doVLH*3O8!T0>zDPM!91(@w=#Hi@-fsi3A0p`pgQ! zqguv${oS&2^J=9O2)+68T7ay){rb80>VQC<(+&t&UuoR6;3sw99jCPaigJ1YvgR2l z2V+=3SlgM`>KbeKghfrUZz-$n<|^%(G?)JTJSlVebp**?o;oU2Z$W##%^$a~?l$y~ zF)fGBZ4X{cH+3mXdk))LnX; zL@M;>L9u>=8%p9d905G(qaKAjhO^<*Qu-OkR6UlZ@uXWP={O0Qqj zj3LUL1cPELxF(SBG{^44Pzuaqf~PG`eh#~huX*sM{}oBztH0$%joc_W0&U6MN^KUB zsw#6KNlkMJ@5~l4GP1-6-DMCS=Jz+z3#l$LRUh;5?hXP;t`=HfGTdq^+s&z~?*i*; zp{5$b&kXjZopF_g8lTC-=-Lq;`xjE2ssXoFem^qf;CfrrEZaG=ZU-TSc27mXh^7t} z-R*q%&}ols#gse&*QJ9=W=2~gm=9kQ1&B^l zH20&I=OtrofErU4q+(eA1CK>C5gj1A=QJ^VuJ0J?OWd7$MLl$yKE0B!zU9M=g}zP| z5_kp39>in0KN(aP{+QLQcj|lo#eW`(D0T`|Ul}K}o*9RJA&sYRe;ZOVCBkEa-2!f; z8)L3f*XjnntpM}l{}j1c;Rq4^fsO5=zGk&?cRjSI8uYh^E`Qx$4YQx!9UHgW2|-{+ z1?i#B3Fc&p`pz!CtdnV%r|yQ{GPx)kYp zoW<=J0t@{5oCq)|c-#Xrhw%4kUdFSGmImw9eVGC=SmMfNG>%B{ zR=O@+e#yhMuKE~9;@aDA@?Eksiy467G0CX&AMdgJJ22YG%W!Sh7#$HoywCmEC)U;R z97W@$uE!BL#8(065ibQUbv}UD@&+=+7Ju;LzG8x|%r2n}+2pXLfCcNl_&!FrB&S^S z>R{gcki}d~&)58^vkHVsDgDZcAQSVqb(q?pP)fDM&DX*7!aV%F?iz+xRk^GTi-XD; z3gQwah##iL^p;#Uc8X1?@9g#82rjx~i15|}gj_v~WTb-@7S%G{Pa5@B5c@lfsnP+q zv%9edr(wPMJNW6%ukW8x!qpJ#n@oCn?QnRp4i^#jy{w{wr_a?)cZ3KR_owD9=@!nh zkw3QCPW&gu5IH^;Vf;)Vl!m&umd_)kML<&;+huj>G=V&r{g9DgBey@x3_e z8j0E-SrR_Y;!}*1k#Tc;M*96$vR#fyFox70%K6{v+V8Qp7>4#4M6?&LYUzGGmioJJ z9%RPnh$x=QQ}DHSi?e0KB1G633oK0b#aSx)m_h0jc}=HT_u}pEo7~q_3md4*7e#`I z#0B!eC=9J!c6|N8e=>dHL@z-MQ}u)?Ze`_n?d5(5ht7g zk3-z(1MIf(Z{9}Dl;dvLm~3}M$#o;Kd+NIQf}O9`>6XO{I{&SeJ#_SZk41!mu~5$K z7pv=!+^J-tc7>2*LjhRf45MQI5n$7NI;lA?C25LGH%itB9$(GSWCQ#H0ZC3n<>~4E z6y9y*HZ>_Kd(0?&d8r~xKaALwIqSXK%fbs5Nix1QN?7223I;;ma1d<4B(z|Iw4=Z0n}h&F`{AcVyHXf*MH!8lA= zDrxUOa|>Q&p8bp)U+}&iax$?H_QVd*j74(fvXtfN29|WKGToDObej9s}8AX(PHBLjim^7qQo(@w)A5XTQseUTURK{k?QjA!9khkx32}0CTp#> zkl@yTdxP?CXfs1UR)Vkmt^;ktNY2>vV+7cN$6H)0orz-BvVS%c4`VRwq(X{WMrgpF zf@(ruz!o?^T1`h7erX_F=*E30$S^Uc0cP8{(yquSCXn?Q+%J{5Z}Tan=s9-asN)xh z0cdslFPXDb%dZN>TDQ>D?|=uXfETH--MR-z>XtVL+8&EuWJd4X{9eE8igqMIhaavq zNoDu10`NqRBot>z99h~OW);4GAxx2@%^*si7eFOurYJ8T+uI`l`v`m>@G03@p`v8U z(vksTa^$%CjV3C7VG8h4DUR;-5B=$wnH#XD!+_}bcgqTq6(Gc8Go)~tD9dF}o)9I1 z(>d0lGs?^i1`wjBUH0{*?Cm|cW-IXpcZx;m(S;Xo89sM51igN#U~Xi4>bcf2tf!HT z$!)jf9QO%Qx7;s$&;0<`tum%5N}C5Iy*_eUR6eoCZK@DQ+woA(k62Zv`0#=TzgS&r zeqqDk6tW-s;n|`@_No0*{r%-^EIKz`*}NYVX~gHx{!l!Y>Xp=2r+T z?^*N8UtO0;H8!CSOO2g(eE6T8$9{!I|+F;U|XKY!`iPAIZb9-VRT*bNrz%~gtm8-KO=D(no3A;i0*DDgGyQv4(w`&*zKmgUnRirM`cy8c;^Mar?_*z+_D4j2RuF4-!0Zk;CJRg z)6wGc#%5^Zcp0(oOEo_QsG*)6Ra5nUxT&^`ku~$7mX9wfemOJj+Y2s&)x4(7$p?Go ze_-$ZGf$i?L*ZZ$rNrn^VYnDDxuQ{TKUg;kU)*w~sOORG57cu-7N0q}hFD*niHsmT z3Z>*+k!LUj+naX21GJ$|OX0W52fAG8=f+dmguP#GBewoES-QmApiSx^BsDzj-)Na8 zQm{K-gL|Q`La6N?BRtFGhu9D?Cj|B>eUvJTc5-as=qsnkR~S|hL=qcrgVJxU&r=wM z7HrPs1`U;=9L4fq{Yrr}YIPZNw^wl_Fe*+Xrlh`Q8BsI^rRLyg(ADoxzqJMWFT!^t zn=+I8MV`zj@DU3>EBn}<^$uXvzy7PQl9bVX=DGyJ*;;QA57Vm#8_GvuoHk*_Oc&+~ z_^P0KH{?G147xxdF5VZcN~WJ~r*7zwhQM;4d>LyzSKp!VI)#4z@fUqzHK+(dGb#rI zFg?E+!QI8T*#uO!b0)w}FZgS0sZ$NM$6~#M_UQUxvY`9!?%2Jv?GLZZgJEDAiv9)N zHNyFi3@QV@)&yP2+$O$0<5Sl}Ld*k6(zq*8^WS5PD@!iUwxx2^YVtnqmFhrUUO-M% zue{(oM}wIjg)=}dQ3MXjH(`z$SYX==V)>_eZVmb1Sjrg?dnh5Y+U60ZfhY{$SB^QAK;3MpS7{!YK%^EP_ouQ8cn*#%CT&%Xi z|E{kP`kREs3i70;Wuf?~F1y#%uw_VJLL-+LP+MgHw+ns7=O7Vchm9M%c6&W{@c?C>W2w!?l# z*myx!&k7tp>J`@8+$>vzs7fwiI_S+6zbMWBD{d~deO{48 zhInFu=o$k;?1%h_Zm%Z_{-^~prR-L|jEkiaV!aa!lgx3-SMIWIeEO=Mbykh_6z^Dm zBNLV<9{fP%g+#n@$E@#?pz$+XXg;L6u&oE4Tl*RwBwSTJ-=BuJ2-Wm%JR80;1V0q) z7fd{OpeTL1a?2Kz-!jMc_WE)o=Opy#Ipke*#bx%dLiGP7Uco4G=RJ>w;71d0UY|*Vf0IGe|`Nm)N{dSMi3uOIg@N? z=?}1kO9Iseuxs+1OjX{js~Bq6pD;U>3u$@vX+PaGQFCJb=lVHwjRHo>s+t) zJ;nfi4&&(PXI7Qq{PRyBrd78DSdGO0o-rgJ?{WecDx3rCm&;i%28J+L^mC+r?XUFg z(17=zrBYZe-P9a>Duce=n{%4TmU<0fg9(ZG_l+L~Z%aM4EYkHhQ$EUvo15AdeRa3l z%RXIbozA;@J2I4k2P8)irOv4DYQj7`tU31!$LCTt@FMP?NZPcls*k*tQW3~N- z`R}rkk91a$aTDSx5S8S)3To|T?@`OZEx1E z?{9HLu5&N9?Pq^Rpkhn_`(XyrGfKxgObMLHMkAZ!PMN4_hFFz!UWWio=g~@w?ZNNz zr6{<<{> z=P)~40bIct3uo-P#0c1w&1fb)O&CCvKi!v9%Vzl7-YBtIfR}0P2)qIB2TyXr- zBTTXbLyjnd65Iioi>%!9^B_aU+&D?huyxpnQ!?yF9KSNCdK8Iw(gMhPV6Y%=-a&+J z%^ZWH8<`T-qI~d|rjhM`OGg7zB=zJf4Xc{qd2}Q0O}3pvj~-q5sl~@_Lb?MZfI9wQ zs9a7hVK2g6SCW+@UG(;~6=eTYx*0^_;}EvHKOSI~0BD)#{~W6vvIq#JmrTt!IK5D# z2YvB>zs>DlujesTIah^v`Z54kW8WQqv2Uuc@wL-We)9)_LF9P$@yiD)gdZpW!_QTb&xa1Pk1ur-d=uQCpbKy=Wo^Elar078 ziWF^S26S8ws@VZGSv1nQXf&8V~pt+}e0cTWznN57K_1MD2GqYCQzslmRu zhICn(PieNcc7$bQoOZFqPo@|s-H|8BMo*JH>Yz;%kquTrc&Et`>R*!3M81-LGWbDs zD=Q=YYsL~{84jazIK=J-LVBMc>cn=6J;=1ZXL@`dsj0xV<>>G`_IYk@C`lRD^{Y0^ z+tI9m?Ko`o2}UCb#GvoX!<^gWsQ!hw?SGW^AG=tAY2HaVpz)tPCG1!yr*Z}TfWA-D z2neVDeZ<77j;Iwr23p1tm5YPxj%=y9Yzv|^b6Hhlc&yH57$Ul8F=}7S-iq4$e zocI*!EvccN6_Ci`1UmTvz7(;9V~6~^D`V8(GR_A$cT3RDliCIfE=hOul6E}-R>ym) zSHu2LB=(SMSJn^I=@?HlQG%R5XNdrWnt;y&Sf+dgQ}D#WZ-FlC9&^D`Tp!Qr@|eR7 zF%a_UZ=`e`xLn3_Ex7r|N9E9AZ_PG)Q~IMbu@oEso^YIY(quPB`xBgpS8?f;hz>&g z9ZZ1aM6|8PZg};HA>H$NQ0X^e?`2xB_U@av!zlR?m_)lM5(xEU4rBKySn9pE|G!Uu zjY6krk*isJe%tQfKEl#pXX#`z^m4Bsu&aa;xrF35dk7utBG;8f-rtrhD)>XY<_YC& za0FQtL=ofS5%M+Q-j!H+jY;@;zVe}n32G~cXMem{N693bAMN0VFVNtR)2ZE?v5ROp zs9S;h6QV}EDuKBiH-EcROzt>aBw>CeVr4phb=QjYCFTSJuQr|`Vo49>F?kT!5pQCoDOGcNqq8+`<}(N^gyUdnaW>~KDQdvU)J%#I z?|F~Vr`~<`c=qgrIyNzDka02@%D3&4os9L`g-Hf$G}b;q)d3Ag!$wVQ7Jd{g!jlu% zYmH(2jw!6}cvCGawwQQn8>9S0M{TtcIwGZ?~yRlzk?PB+E z?kiU9r=1);=+%vJ)czYL-nWNAwbr_^?fke0`~lx>nf1ou7GXR$)3i~jk3bHNlc?qu zlY2pk>jshLa40dZFbS*+|@&AIN-^3gqOMKs4#kF6if9<7_(I((pbFRuZ!cU z(?-@H-aA{Xff(9CG!iz{D9d#8g|(tjNZLcOmzQ(qYb_}~lq$tvm}7P|vGX|6h10Lf z{k#%K$A#A#sBuR+;r0|&=L&n$w$d&=FeZ$3PKyo+;Fq~+2s``?H&xH$gKzV_n% zrB8hrIvuf#!y+sR#g2?nh`1`Hk@90ffok+mi`boR;RqABBKt|2+%Ql z6>+IhEOURL%x_oKkZNFZT}hwZL|v_ZA$WBpaOSjzq#fC~^W7*cc?=$YzehA!9Ic+f z9Jf{%7Gi`jv3;doK^kOiODs75{mCA^u%SAffeA;l8!?w42{@4{rTVfJMw^<)W9;Hy zWx9%6=fxf??bFr()Dg_`H?a5D_kPBDh%8#HVwxXz?Y)qlm z^k0b>CiA05gFg(vif8OC@2T_s_5H~o2xk%Mzro-}Pw$iHOCHP8pQQ!v4M*UBd0(uV z!Wy1>E-n1=23)9tFGYRO=krNZaX;YiWMzmDJ7l4uvHWn@50Z(iSLatBEitTK(Z@I| z%s^@1ul;?FNuaxEFq5by=D28S) zBq;ZO@d}dLsxaaNCfL)?T#kRg0$wve#UcLt4u>Lk=igBWUdMI(|MO>eBHFwPZx@be ze*fRa_Uk(P;5^rCsiDXkf~HZCMv}=Np123#jHg>+b>#+LoVSNO()g%i_<0fbFoG}l zE+-`+6ri?9@r0X;xvzxn{=t+0W%u4|H@ZGgz2v>2TbLa_42|#D{!=B`*9xM~dM8Xd z6S)}>Kx&?eQb4)iuO2253w2mIz4l5E!WAI-V&+q5D#pzua$*aKwhkNtylD8nA28_! z;vbW*7Wy>u2WzKMp^lO>I*7LbFC+6VsN`$@?i(RI;ok4=`B!?f&3^jmnYwRb`$UM} z(wDz`x{{zy5vJ3;b09H%R5gAqnTjXJw>#}{-k!+5C<0~P_hAqBXA={FP^2+h8QY41 z*VHL|rqXH9;WbzSuetIkuRFlBvPUs(*RecYD(q&~I;6go-m7Gz!g$?8BS8V#wJ6MD zbVwlyR@FgUsjiNVgX75(gn{<14=!3Jog6oZR^_sR<|~{dW3FvAWpicE+4W+UWVlc) zC78lQMdXkdCE}1b2|&j&{(S?VQ7m3pA8lZVYg_1>UoGdK6+`Z!KfV~VP9ta;rD{1& zL6**SA`e%d@5`&@TZ9y3MnBAQu){zkl*fN=2|o^fAM{ zd+vU2@@yV;6Ow0D>JHT=M~uYqBh81BIX}#ECxO(17z7>P9CQGxdvBsX zcy;p2g@FXX7wwH76{a84(49!@yA%yR@EeN%`@DFBVv0Wcx^equvQ%3-eVSl6vPW{( z$}#P!=)jS=25yad^s`sO6>h~ z^K0Fv4@t?ImMafMF29~t+)+{F>^;@a`kU1kc~&h=XJgn@Zy7~F!J~SE;lli77YMT} z=Y`&T>_*3SoT)(OWTF5~KkkF{+Ky(~d>l>K2 zZNXR(RAsbzN{9Mx*brOO13!BCz5ZOIUfJ8!sqrA1yXY` z$0hNs4{7XOoygm7GP_87OUe(Oc8^#|6ml8PQZyT!lCxK?t8q`l*E_L)B(rChh(0=@ z`6P%)qA}UN0bPDE^{hvMF3pwB={5Px7_wjpc^XM%fqOJ{_4aUxtB;lzQsJn-D9k7phJZWZ`=Fk8>?UJ(iL~%UekH0A}{v#^HWQ|Ni9)yEab<2OoVzp_=)~2wWhEl=PeUS6}sf{G7EKDorB2Ogn=z21p+e!=`y7@-KJ* z0bLaM54)kk2#jvW!*ZkhH1>xN+}T@A%3_t-YXCQBSnAxT5tq53O_{V z81{oZH(awcD6XGLL7pQMH9B4pRY<)zW=e;AF3a?%pFE{)U)sFjBf`a)~Juym7G@A*Z%=d6;4R+R=NVrP(Zwf%0h90qT!l;4Q+n zw7VnvOr0c(Jg;ln<7L6rS~2&eR=yP&zyldL3xB z)o|y@bi``bE;s>-DJUE}m1l;^yx3z|fBKPhPaeyVxjCTg0OD3=-g~%Irbj!ryYyPO ztu_W8zCIDmk4su1_`2*@rWiMe`Ax3ew3`u0nKPwVfb)f_`uM;bQjL7e3Bos0yIY>N z`U0Ssx?Xo?MIgyZ96M1N5|?YcD%UZ}A{2?(9ql{Lei|1we5 zRAsRoVv3HPo?72cXeGqQ7i@mT9|sxaE~~I)&?s<)D>FxpeBGxP4!>T^oz`Wh$LpW1V+U-9tEFdETLKXXC8R@ZBW;+&LyTeUgJv< zAnG;g2^M9nsnGm-*Vo_u6|#2bW^I+IkJrYmQrtl=?x*{z?qn*MSrX=%tuP0dVKU-z57#B=@MjhuMHLl zuVav*SnoJ`{NaK`WM7a=veNhY+p#O)#gJoX*ku%8A*x+A&zw0TLkSuYw!W9pZ+t$e zx7kF*uyM1`>Da?(Jz`ah*4PoaNcv`trqQwJ)lKjOe0?7v$#H&Aer&YSV=idM#N692 zMdQ7YU8rT3759tKU=294cYFgHxo=QPZIyL&3{zfOsNB+f@xqnI?u*y2_j#4_bycnT z02BFeeu&2YAv0n~S}MUU7S9}V?L}Y8jy4vG46(Q0pq9(qW%;{;dSgEUABT28q#M;) z+~;(7^Z7!j%WhG)UIx0{L)|@;oI$R`^FWlXxk@^}*JL3eh$4Uvr3t!MoVU}AMZa=> zF}1h9`|a%%zq7q(BEpO{Sn_D+A@IvDZaw_H{qq=FY61Mb(S*?Vx}sr-cTDv#EF2SK z)UcJY*HO&cq4?=9kKStiL4mff?9a;{d~ETZD%f}3b7Xk_`!bmx$6teVL84I{VA3R% zuNhNo^KJ~2^2)e}FRBsWstEu1NW1+mhp3#5tW3qZk%qRgo*2(Oi{#VC4%~r54RJC% zrK>RVq{i|O1Ia208g_l)sDTWTajoA00V;G50w@9S<2&daNQZrk5~Uln^uvRU>fz70k&XB1LV}?+XhBK#4TcYGthomhYNcb`+=p?AJiybmLX6FZT(WF z{W2_UcR%prS7(+g+V*uWq~58Kzrpj*MJ>3ogH42-*IwsvUW8JR6g!Yfp^(T(?OT*g z1+Vf8r@)RB?WWP@=Oq=l2j)b9<@G#5qacrnmYDC~$s?q*$ATBhu$)SMnD!v^DMijm zg_PM4wPzD$8ScfQJS;c|#$ImyuratE9&+Pc467oz#|_HT@E{xDf|@JV?5w!hJZ57I>t!{mBd02SZSC2#pHurB>H zH*=I_^jHqKdOoOI)|-)Ef}x?}!@3@*IH=B2%;I=LXt~o9(1QTl|9)*yRuHxBGBmZCS{qR7m#M0CA6rGd6K&$5ulaK}(Y*;Y)v^I$LPo z<>9@cz%fmlfQyyL`{z8%8ITv)d;2k)ndxk5PEC)e ze9$F_VE!Tey-#3V%;TMQPkBi4we6hbE*EhfT7VOtuZx16aheRRCgpze;#=)Br4I*hf zgiNEye`_#4U;%~WC5jM0wdCX)s9r^q{p|nU9{W5Wb9x_0T>=t96b!ckD1GxlkVnh@ z8I2~5Hl^8zrF>9jw2>Us$8WL{5dj^+N)ns9WA-&x(<@bZV7Epl!@Um`6&6d4U1^wZ zv^f&S1(*q6zFbt~?j71g{k7Vz~^v zh#L*x{~BEbrXD{O%QQw{+DNOADv~@5>NFy>epqL^K$KU1#6K`dzAOI&eXG6TF}9HR z+l=Xpt#{yWe%dWUJr1m(aZsb6z5(K08rNOt=TUq+Svrv2;uWDrE5&Gn0Yl!eZGeUq z=Q`7aOaqPCLnn4zyUYU!DvnntD#6d%5kB|0L^B6gB*K%NS zPF!p}X;-3QbXA|5E;Ce6DW9!9)Hr&F3q^mb&FT5hHV$u^HwoKSRYu1@fwdDN z3fbL^bUJ@ls;yR_K+HUwI@35odc|Jp`R(|G<_*;T-r?ob}_3!hC|b8yng@ z+mxbGSU)E5eo3>ZahA9%miC#^)`r#xNr;{8oTFjMdwG(z3F{eQhJgwzg;aEBN62pI zKq@@o6~&^>s_4CkA^|egp`2lmd(836ho#1qGghu?BVbtwfukxAtQWpol3r_7f{6cg z$Zh&9T>=^_p!Km!H~CF*J}R!_WJa<9ZQ;lx5^->qxatkAdoVw8l~HTL?u{yC+68^* zck1SxW?+N56X_CInNIc}4o1J?`RUE`k&5`O1;pF6VzGW zhe-@0o7x>+!$P#DhV2$VRv0_wE1jK5TJH?MCjFbrlKR7*n!jP=RWtt^biyQffMOtK z99aRJ^75Enx13^ZY6Jt%gAQBHJo1&p2BTz2;b*R{Or$;eI#QR38r+va2x2ArfOeI4 zMpZ9)2Kk-%{t^%w7ic z0o|WjT@sjS0bAlIcCjolt(`Fz2~_jzWvL_=l8_n44RT{8V~TDzFTDze6FXQ#Gxh6iDgB`GJ#NlPAx;kt7pIxQfF>@uG112mtUcukp3L-4K}y4xtYGZ|taF%-}>xkL2jxk~I^dJA@SZ zy-BVOKz~i~NRNSHBq{B(`cH~Ug#9Emq}zD6x_k3Co~7SOAn~h>%pe>p!qBA_1MNbZ zE!)=9Ei9Rz46a0)yp78oiW3=VEK{f_g-p!Iz;6@ue@U026%?4 zBaKoiD^G$L0JMnCMNVnfpo)Wz^l~2fQL^tx$>5y(&qjT`sZ{|M@HG33k`F`38?aQFQ>V>~G@ zVC6MycMjO0J;L3Y^`tTvq?xPwWYF#~M+7jla8~#pLV}9B86*a8Dg9+OKqP;(#=vV0d*dTuJhBhtB>6=%Y)l& z8D@>`N>qKf*%iBx3SxQq@`Rb;Flv7rA5}}w&AM2VFfNNOtR9225M;~HKkj)Al*BfpE`j|O!WY#|i!>6J{T+Buf;$!j;(p(5 zjiDaX;nKn;x!Stskb8!;Q42e4?vW$FDBSJ%B!0JNAp2@Tn$Aw~gZq|;G!(0aD;qSw zhYJm1c=Bq#NWmgFOgqh@RDBt`X8&#3mvx&qpY5x9~BcLRQ;4>DTX|ArcNolw6Nu zwPq2vZrdF%Ie`t0)t0C3zR&sw%KS9)0pv!GKjTh*cG4R3t5~0Ft?G=}B9G6ZH=CC( zK4In)oh<{`9$B-DzvgTKx==Rk4x}gdjC5Y6-t+!8&*M3qDGy|BbV#60z+4DZ-kX-# zFj!^Cg>^HyoF1M4Ehf&}3k7gnl^2b_K|~5BS&)`|aE*m>ejGy9-Rp*V0Fkp$5KCl4 zEKVY@s)JqajYzrA{kx^yAVwL=5hqZ>kejkPg1xC7!HDA<-|OLMD~Y?wIn1a5Y$uE( zIqX6Z34N<76bl_G1Ky8U{o%u|ifcMk8FEii_IxhW?WfgKJ%6iYjY$cIGOvpQyHhQ9 zNV)y|t^zpQh>T2p9|k3V|2CO%0y}rs`d!xRFiz}4q`RX|yJXfgB-!XiQf=-?(fi@W zPBj3F0q}04 zv6lKHj!#0MSYhp3$|6&d!6fU)xq1gNZHQ+Sp-zn~>1}qm4Vzc-GDR{wB!mhJnAa?z zN2NZ+TKOF}2i;8+KbFm&{tf-nSrx07&@1#7FbFiMClN*xQ6r4u1NU=?dW17z?4dFz z;b8FBrWQ}M!qx7n0r9=Lp59ya9ZfQ?V(*lXcvj6rEg}%jenQupXg$;2d0&hjy47|Z zm;7#UsT79$aBXMgT$lJznsC_x!u*y-4eT3Al<~?JX_jm`|4-0&EbjOB-A|W0hCx`+ z5HyMqY~|!?5zgvgmB7a4V2yUekKlmiC5iVmaHV$IZY&n`i% zoz61HEd8e=EZ(yzoA@naKRY`cpid+nu|o6$j$?sj;c`6I^bRVo`lkTTNuf_Vod#x_ z75l@GmrenR&I~!D5uc2PN6F&7)p?yaOu+;Z(%Tyx`VjQv=va8NRL zb~9qOOzJ_@^xYD{frw*P(!|{;-7dJH%O5L2?Rqq zXbqtI>*jlNoW=po$K8q`F*txoNu;OW=9G4^1PQhlkkB;p@nr`><$0LvWgaS^JcG&N z0Y$+zVesLWFDdpMq%6Rz-UlD)l2SX#EN61fJ7=LelK8qaFe4jpyiRhk8(j^e7yAPLca0zTIkhCs&V3vDdAuZ}pCP=XDj2Zk{2^*X<^YVf zi~x;?ylTW2G@so8Q^iv%1P*1y3CYrs0z)P4Ksmak8*`p-y^Woa=yL~|cx$64CHN3e z>&3&Rs$F!h5>LKSicR?;j^LI}EPc$QYjT;A&)_a`kgt!w@s_Y*ghS)VHNmCp$-rNn zHkSf+d@9Xsm=4Fz%X9#rP31Zf1APf!jk8A-2TJw#UW#|KdCbYS5gSxz?Aby)KiI2 zLIXZKy@1cDM#9-5e2bImg?~#mjcHA$8XJtYMrn;|gF|pbW!%$BMWT_0wUl3Fe!^5| zb6-4mMatm1$dxhpH!95`6{?rT3-bUKzctk~hWNjPL*=HXajNbLdq&NTeiLvf*k5Qg zjeuo*>E{Yym~fMKR=6BLC3hQ$w1ClW;eN|?ClQBF%B2LMCO`Fb98@_o}-iwQtq(*z*Eo7Fw;;Ip#S))B+zNTBP|{(4Acth2l7 zG|_J#Qr*y|6COfU4EV)$aJ~RlctmZ?_4kVzRWH_Ed348+R5?odHdqZ!ji)AjfyWkY z(lp=AHT!n5BFz`KZO@G*w<0c-BtO!c$_uVfw)l89!6DJ#5MJlIF&Nk$;+?E0e+1w) z?~=hWr#g5@(N?Vneg?-#u24N{|M#=o@>l&fqWAf#nc}|(DR?qo3%DMd0rTyf7TfJLR!f4rM9%Kdq~Nm|upv-krU6i6F`I@OT@})z%k8pV_^dcu6;V zvGAa`L>65dSfrbMn+Kd@8i&jB17m>1M<`#Q^x?%MmHE6T3%9EwT`YsI%?$0b*O< zkZdiqPZV zj_!9e6v*X_porN5v71D#c@vm+p)7yknUeD{K>>Q{rPk(lJMp+kF9leC31mAslyDy3 zD5eFV)P5+NertXF{wq%Kp0{Yx(G91;8!u0VNc=@kI>zE(7OY`ltX_9uMg7CNik1Y4 zn+j<*OFkL&{r#qkqAE2^5_1BYd8Qd~&N|13sAK`H%?QCytG{g$UaSaXSNtB$sJ1=d zRpZ)>Z?M)R5Yw!8zdFX|*9n5=e|xnKJ^QcM8nVRrX~8e;Nv-5e4G8m+J-nMG+k%{; z3?$9floN@nc0pbo zv7u*$NCh|pAWJe9Fq3~piS|sy8*k|Fs{B?>HSIpy{I5Vk1f4u!5yeAIG?XTpvDquD z1m0O6v|lJ+0E$#kbCF?+Wakz6Jisvp z%amxNZ?slA8EkQ~NE|^5x$V{vg4g5q0Oo-OUmi=VLzZK>2g9C3Agu zS#vM=m}h>7yZ$hNJtS+EXH?@yy{l%+{r=r42G%u%6KIuyL>(wOS2s7Ak!1VH`!o=U zX5ru)BD(Czx>xpI(juSoK2tV^1~FOwet@C4`j- z)GZ)z;6~Yk;t->``!vBr=&;469RYWjp{~W5w_aFFpcjis+ums?Vl^GI(fgb;{sab| zh}{|inEi^AI&|;y+Pc1ao=l(bsWhQm2S~eT@jET!uE+5KQ)^EPQr~Npn^@(Hyqn1g zC@Gf$YL{y3fcu=zCuEXS4NpvZt`3CnWT^#jU+QWwz+H4-?33cjB9WUp=~Mo*smgC8 z2%2MnO;-#Al7LwF>7OrVJRwLRTXNBs=#Z*QV5Nva@SZA&HoJl#K6&;tRKlNr*{gwz zi0-b-zKgvA6eaU*Y;LbdK6JhNm@4#3&5YySB6G<>j0eLt(0EhCfaby6`2`LlLJbbT z)J?k(`YQYkPUq%ceI#cVvwXbIc$Ez@$AO!utNVX>TGR5cX44`cRitn3w6k%eSMruWTR)bI)5MT(`R}xW932qzN6QLrh>!S;!83l_Lli#rK;F{=&^fIW5_#_h%cP$WW`W?%kf@9%#agbtVHEv1 zS0f#i;C<1YmDK5|0<@`Vo_3%kxB0Ax-*@Rh$&fC6n(+MbQz7NaT73o0Xj1E;N{c@d z8+s=(%PSW1vz2Q+jMAk>bH!nc92+!gIo7p;bJ@W+D~F#AYmJ*kAWddDAm*UAy+WIm z1q+ok+0qW`s!Os>H3^BSKYm!CPQWT}UnAYh{AdYHzaM=20*|!HcjX@*NI>`8X*@-f z3#4q33K(nwa1CRQ7XdlfhVtr{kDt!sSI$4L@93IR8-b`j&J=Xq~e|l=3%LvigR8~6CdI-vYD{g>iEzh&Z{$V63XAhVj-y6Z$ zvR!HP?3q@g^DV0Kx2Tv>1i-G_?QcPJ@#icMj^!y^uA2L?toN$-0qDRzDGvCN{*`Px zJh(>@&}VU44z4lJfdP1tv@Dn8??m7dVtG27Skq>t>P6D=CQ!Ld-_j*I91PaD^u!16 z&-I|BCtP+W!2A>~v?0aqEe>wj>FiVNa?2z zs?!x8-zMzOrS&=urfm$VZ;!p068s#y8IfWVO)X@LPivG2k{B+bAX08?O>97&(7PAO zMrv-t!Y!uJAXxb1?Bzi7Q%b7~JrbXyqvFHiLs(CFD|ORwXwf6czY&1;4t)_r>QJd~ z^kQzemq!i0<9MUz|L#Zcx0ENb-nt7q4wmZ>l1KH%DD-upp3Z*tR%opCbTOEzjEtfN z6bL)r_A(9X;LbPasrzzBQG~Na#$bl|hl@&!=#R5-yc5)NbaEfy8TW%fs1YF{meMIW zyAjo;ah(sVwCJ=e@2ri6vgJ8h829B%0U!7}m*d~l_A==kQ?WrfIJHp!ZuYut`szaH zL+~N4^dbl|_G%IC$BG0iB%4*)Ao7BqsE3ZZ`7B7?{>b@W4`}Bl?W_COuMLh4SvOAW z`1$u;Vs z0;UJeMs#l+^r`I8{!7XGfGyQP6rrE$o?6CfjLh({LDeZp;#iNMK>eTP&S-VDj`k;o zLKvWw7b^P`2|+SJ=pju=!|s@G%C^kqT!ebSrJ0R+3-c(&tKsFzMEdCYcAn;pIO*pE zx0a5drkq=<<|8K%SyW|NuZZWBA_S}SlamX;HBTVXPsQ8<#oCY~y5ot74|WIrLAfQB zZ~VlvF$8`eYX5pF{ZWowlafG_B-WLT>?`IJ9`h&j$L5dmRK5h$%aGxcNVPq~#BsuS z6|9L#C5PSjm=yc0dyzkIkvPc-E&hJauW(_&)7|rqY>{~Dgrj69AC<75SG293;j(|x zSdi9y{SMsB8J#cmq6mw`O}7BT1I%x=2q_`jh%f9}XW_jRb-QNHk=Z|oT>bU`gow88ORToR1ysALCkRO}|Y^sNYM==rw3Fx0_<@jp+0m9%=1%!6x$NM~|iTc*sU(De7Ppk(ALD_j;U$C>mj> z<>^`DEj79iU-u$ZHbT_`{;tqy?nnWuUrT(_Bpr@)WTm_qj4w(J1Q1=i5^7<4_{r%W z4}Yo`-SV4E2|w6)YXPHU^^oE>9UsBZY@UQwJfXX{U8A}EFo$g6M8g53J8^^^lb;Vn zCLOtzs;WxRDFvIbHY-MCI@iJWVBniOzkBX_4IIs!?F7hISi#4ST-5}@A4W&@xJ>$A z0#oo>S`ov8(g;{g5Kary9OE7@b2lP{({#M7Pc1$6fED!&ciAu)6V(4Jt92GW+i=jl z82{v`c&e6rrmlSUCC}H2dWd;9O%_N!(XcMu7Kb>f;{T_DXBQzu1CbmKvPAnxnp1NO^f+^`J$2e7q=8T0u;x z+)#P~*lB*ff1l%)WJk||8(v!h+TH#;Ir%cvJ0=N_ZjMJf6bCP`-i^5xAN*%XSbUEt zPG0o;FSkypn3m-5Sv&%AMkjGy92ltDm&}J!5po{Q8@E2DS4Vl*!Mc-q=tcY*fzPB5 zAq}g7A$WTwGhS4TG)?GdB_-z0!45NU^q2RjKhp_&o0~e7f4)v5|R!v23ha2xt<%C{87*f*U8lZmSw{z8C4bq;EL=n693R{%qr%3I3!zdZnPo&>gN3 zf@&jYgFa&K?`ci@S+}}z5;*VEsB%EB*@~N#E=uFGB`lDMm@UdWX?q-$Usw z*)qe5Fx&&T&M6os2bym}!mFgUg!z1l?wXa6^z@}#pVPXkSB$33;`5vjN^bdUYc+Oa zGr33omCxQLeMTg2`IW`CV(RA^Y&9~eUaYhzAlEXUT5RR>?>M&k|Bex|LqGWZJJ!F{ z^x$~a5RmFqK(xbIe+XL~v>eoLoX<>cWC;W^h4BVqg3=$MO7!C(Nb=?H9u3>Hg^wPQ zOT3kn*1-_01+7o=xkEyUs4jLjTW$vT=N>E^gB%zbABMUaCz^ljo#4|;U!QJ0qaJI5 zh|qD58)T)4b&QfafaR~Q@Yr`|t7*PtxSfsWe(TbgCQeaSMmXPX@9o{)IG|dyQcD%3zy}{%td|;mH!$$1V~G{_ z2KY+VTVqs1X@w<01hN_xp)=zJ7JYIb z0hdLynuVBg*os0-R0Y++XO>o$4d%7tcVnlsCrFU*uYtbg@M+rH>YwK?pG{H3#?TbZ z!V4@u7WwBSO-;Rh@`BQ^%Hd91t5)9%8}*GY-2HVLZpCK}?@V%NIv{~B{n~XKk?;b8 z%EEX=mIU)C?JH&^0!R%oN|*-oW%#BoxYX4SP)%Egy-|?&bqr}tp>>eqb@T19;fyT9 zPc9*vC#HVBt(D7*nEp01E`WvA=KTx)3)$GH9OcQD6Y=-tGjd#Gf>)QjfZfO3&uCW; z+W`#u`q<3*G5tU>8=d+yc;5t6OpdcOzCt;D*H1hwJMD)1e(dg-KsZ ziVD^I;<3P!;{b$`JP9b@rHYQ9ZUdnSTRrv5fv5Nz#+NF3Fy(lNgk8;e2i$_)mk*qW zsYCU5eU(r)T1|RC5bMc63%QH17S^*O$N+SFngUpprY0|XzvH(~#3rJi^A@MdyL#v- zXS5lL4}`@puLEnKRp)1DL~hg8zg9@+UjuQ ztFX|it5`SP)C3GG3{_PH1Pse%J@N9+7*xeCa3!y&m#ojjx@+6N+5@VrQhfKL`uPi- z^46sT^E8Pg%7jE{PpQx(Jhc+4r7S&WW(xwB4-Td~&8}Eb#saD06#<@}N6;Sr%K*48 zNWYh#9u4*2=eDV_n4=3=cMH`^11!t_53M{)gR-G|VPRhaBdEO>tf?Soe%1{FKC_s+ z!dA`d4=^Cz7q?mxYGr!dZV7kI$&K8)Hqu~OftO+g=2nt`iT2y z9oWy|n<8hDF!Z&Goo_uB&ueG&otyxX?h?qq+_Cd-hfI^Mj1^+E>ldme{jGSU#JJ{` z-x+a2>B@zG{eU3T-4vP@W?*hPUIyM9vals|z7xB^(*%9UmVwmTu_AOS#G*YyDYoY^DW| z);cv@{>t|HWjmh5v$04N8SUR*Jt=dq1a^3J6d?k{ZeU?yseD#)x;3V9d%t^ived^1 z)a`wNyPx>_c{UT$Z##OE)D6S0ZilEd6055ah?T|Ga)-&`=X^)es%f(eK4+Vo0!7!< z2pGUKC~txL3)9hdxOFzHQJ$Yo91DQJM7J%-&#lxRDkPXrkEH`C&T*THbT~+c4;LP= z;i?k!_p8{C(be2m!){6NnZ~umgwM4TzhTV+oh#-^NDnVzu&!-PqA3u(k z?or;uR^Gq_Pj-s;z*F<1CN&x$HH?C|z21PFoj3MSQ4=Hq5ICri9*2tnO5Kf20Fr!0 z$kh7m( z2v{;69)*u2K)WOhEcz*{i&|#Q%OmGDm9)O~NDVZ#8Gybts>U6%bZXM)_rFgBQVr)( z-k4>7YC=*zwl&^CT!hj7FJUPM@D%}748TY95**?zG0)|HP3Nz|=GVeo67^JI-77|i z;*?&%awme~b2Q5|8nwHNbW7*=*Ho_~8$dSRWVyZ~KtaLJsvjIOM725h$p2Cn5#u_h zy1Q%8J=XEpq{!^;iT*6yu-XiV2=TW}rPPGE4%V9?diO~znZS{X;%Fumn{d)`O=Oq< zT{D$|=J%BBpm35g@T^C&zG`&{dnVLYp$lCs*yZaE&&LFaO{dDPq26A^Yu8>2)fx|# zHmn*qtQyfXKhi;--EI7!{~pU6=;qV!D$`7}07>`*5GV*{YtR59xf`IOJ&JBH59l$m z1pWC4c15|0RrsQy8-5dsT+(qFN<3f2MOj{`_SRKavK|IV#?f2I(2@-8^|IYDvuca` zuuSR#;zBCB9H7>sKRVjZKt+?8s~};KQu;nV-dKy8=3?vQr*q?CP}vrbQQj3K8U7GvGi1-ey^m9a(*GoQ5-mQf!@m)s_CHF zwp2RUvs6b?_1f!r6&Jk3t>WbBebzmff7o?CqiueMPbp&vv7y{ zfV;~Ni$8WFn8Fajn312KEi>Sea+Se6Lgsr~(kt^XM1e!Cd!!_SaID z28}*^XyH|T5Sc12YJZ}~xkZ`(!*#@#iE@+1c4cfVWtt6+^>x7aOKR9?EqMdP!tlb% z(gG_}+)htVk8&2frBAYlJ=OjVE1!99qPW#$@F8c#5puY}c9Lrz!q3BZjB1kEh0AO^t77pKt|1 zLNI4^e>Z^sr6M4Tay=s-1_}DU!$-yEJa<)U-x4tin9-f9uYV%uRzIVQ3cxtJy>Xj+ zE9;c$(8M!rZ1Ks^u(?iGoO2dF%JjSUxbR9@m#~uJom+^(nz3C5uUjdA6`!MQzsEkZ z!opnpUT-_a|2gwC!(Hah$zP)>DpP7;Rd!UqsRE3lU`AGbIreO@$A0=fAUOr_umT8d z@KH8nqnFqLF4QWCm0zCp?#m=KeUqR(ehp~ZbfkM?h!YQeGVjVSeChJHDX(Duy?o{$ zM>K`P0!k5X<@diPE7DF*mXN=jKW{8`bWH47gL>fabRr`}>+DjF%*Cu(1ZUyK|HZ9F z=GJFC#DF*RF6Nwz`Y-sOYF11WqPy;*qJzhbSMC?PS3TP5OL|~{XGQ#JYE+c(NY&+8 z0|NB204tvb0iurW{#H@~9nt82@)p03Fj@%#`}yQ~sX*di;hnsaox`P}H`nZW6)MCv zG`x$h8;n0S59T}l-sqq?`me?fW%-^1W#w{we7UKIw0QRboEHHl<9!U_gCyhp<5C66 zd*nN>Nfi_+eb#6V#b=(I`2_B7(An@lQIrI&>Gl8vH-rhF$WV`rn@a8+=&)jWr%zr?cgc3**uMT^sl)4QX*H?U#6;||8T<$k^Aq2 z=Yp3y0}WaC#vG{0&B6ZxEfV4X`v;|jk?CXX(wBl7LY&H#AfYs!RLWWy&dtTel@CrM zeW?qxLq{0>ATO?_k5}8&3g8Yiu+|o4aQ2&7)~(#M+&4!5_huXY9LnFe23?njoN9sO z>D9{q+>dU6SGT7?ZQlN<4m3-d_)EC!4(0P8iwnR}O(jGaC^%*8BQOJ2Z~uqg11)tg z;v`7of#-Okrsu%@e3NwPgudqaGMbGNOkO51mYdXm*l##{A~E^d*PCG?`PAypLZ0@o zP4#YND2OW!Kjv;k3mgCtbsw=hfjzYbO4XPH3xL@FEBz8f2UAXgLt78|$&*I9!Z4?|D0 zJFmb+sm{i|WFy#SV0*GB3%sn7pBc9WJq|&%!ofbFFOh0qXyubyYwulEZ_a)Fcm66g zdHYw}r=1R)B3*AxH_#O~u`_FF1F8Nr@DyK6H+uext~WgLM+fkYSWSyU^kN6aVLNdv zK}9XF{Q@$nBk84;uTo}d8@QCpYH8- z7IAo0Un#gZw&82RbN|>SlX635s<77S@l-)xsD6qXMI!r$D5`<|#SqR&u#1ri-@8zCO069um?tAJ%cjEjc| zH#x#}z6>+O(xx?G4(KRK)=nHWns$xzabI8f&q+2H^5l53GY2f}gS#5@4u|RzlNoD4 zJpO)N)dYdt9i171c{47k(UuS5UHc5dq*`<~p-e!*Y9SRUZ*0@+UjJ?mwsMEX!UCwk zN5$L^eq>PF-yT_+98+JIt12AYaGCP+c=Xsg9DDZe?z*+p?*#MC*Y~E`YCNY}sOqbP zH$z2tr=)O;XdNsK1$~__CT$ZuquZC<<@(BFb~{0RRWZM2fK?wjT`6e5YvtqFfd8xQ zWyKX&!|j~99^ck`zrsvZabv@x{1X#>H_8zE#&Y13Z{XKuS@Z_&Xs-*&Rl;oaykZUn z$a1{jY=+pc5&=WbAu}eM=km35g;D7509T%$GxZcWyCn+IQcgR&2C8A~xnqIAf0_Wn zAC8^`Lb0{DpxQzocE(*wr_cbGkHw$>;!6yi)ela4(@R(T3+~&e2}04V(davS{0ca5Fsa{7qL+s)AHk1l5V?v$6K%xV*=(H&=s=6B$-7fr zQx4?@_|E`Df#pnzZ5NVM=uN;)4bV2{uT<(Bx_2?6G-8&i>N-2`0Fq=w z`(DZWP@d5^|?01fUqY|H39LVg!w=R4)C zJ0-d*-!4>?G?OQ><<2_uA-~risnRFy&hJ9(TPpz~$Iu2K(#uhStINW2wMRUNRxB`2#Eb72_a648@?{eb)`sEtWnSa# z%zp}wvnVE^RE8=LMQK&wNCg5Cp@>PUW+wH6Z zudu{#-G@h}Ne}N@f|=0W`Xq(xvBcqzZz^2FN|sH)AKZ^>-9fiyj1xB&Ds5)rKQF=3 zCiaJ*1_*UKnpq{k7%7+dJu5mTP3GB(I~znE$7G?B__TM~Vfe%HZE>zb1Tk_J`aWUR z6tcSPH74c`grJ$XN#A)4zJnlptr-`3Xgegd0dvAcGS4KZ*FU^W;Yz$}LLb?Jnn>9O z2qkqE%g%*nWkU>{M$P$-Jg!V+Q?4*XysQ`w$Ho%;JxMtG#<&M-G z1Aj-P$C;A4Emp^5vo%Aov)Dx3NWAFQrLqK>dZdC29Sga*t$F z?jM7ameaE~+SmdSt(@;61k27_t_=$F+G7zZMWz%=zyr~l__Uw;mdGx-D>95dC@||e^a<4g zJCkg>b_s?rSz?y0*TD4=vL}+4=cKQI*B^z*xldU&U{{SMXPBxZRBIV8#*TrQ z_PQ7@YuJr~ofZGB4STyiJM86<*{13<~{}4Z;5o}-VyD|jCJ}@v(+OL zvBhv`4zL3f)Un-W&o-*cSE*mXqYmCl@4wy;MJD#N^eVod`z-7jU@<`?N4GhCklbJxPWEmF_4$9-|uv|DU*PG<4ptuCB!0v&$Ohj_F9_RYt zn_#p`xh+#%FNfT=s+SuA1BOWOCKO~A4P@4bnu3~3$2=jolLu%DU;q&vI&a7LP^Vf& zwSLW$PGyibqOHAx)(!Rzqvou7FO2O)iMv2*4KIE+9dieZ|AXrzu+4VpY%{m2E*4+C zaN4p}WY$L$1Jm`QrLgHQ*}QGgmiU5>Ed-YH7u<#|-{m!XK~sE;KN=6}%m>9Rkg{Vn zsi=BDRRy`x`vb4pRc*lVBWz^vILcT`_40Yma0WKj=Ox|%g{0F2_Bu8k!vm|+7bLN9 zSi;P=5G#kNj04g&H+44hf+g4^k%xacXsV;7$Zd9egWo>T>wGA(9@;A1=(V*MSuqaC zKGiAEXfRq zMRA_N=v2O&PW`og&>w#nxaWvOY#E-GvtPHNmRHczr@_uVp$}Ptf_1~lG^b4dflkSm zWRyz3gPmcVCY*5%L8tPTPte_GbLi>TuyJqAObztnQrDrZ`3nonH6`3yva`b~m8XB0@8Ms+Q0^RZT2l)DQo=*c6paY@m1 zns5^Ko~yQpy8WwLnF~7;a$im%W`EDOkLrJT#5gte1&V_539_vJnX*amg$MG_bzV50 zHNI$ysS(ksgD&t&^&-EWp6E=>2~>O}VdfKWnpJ%Y&(@Bb_KH2c176t8{i=2%?|w3; zQ&fN0d(XeImrKw^{Z(l?NG9@xBeCIe6G57pf>4mttn-mv0IzI)39+*MS={JYyIG*R zjN+Q@#%IcAc((p$HNyw=vQpNk62lv0el4-ILvm<;@aw>)oKx6T-V%I70}J!(^YG%F z!HxF7&Xl(lWoe%C8}hi(^Tmzse?g<}TEr|r3MjSeG28ZlV2!s1gkv!y&>v8vx_^SH z9grqyp5M>ox{&$Fi<;8{whxNtz7Nuypez82d$}&(llo<%6{8Fksy~b=ske0*Gs~J0 zM8cQh{alwM**GL&JDN+?HMy7~+d!(>USFWaw?H>2brv#`06q{fXv-e{nya9Z&>_$X zP$=F^lO|g;l8l$!B8HZ3N9kk|E}-I@o0@X~F9c(2+Pwv(my-Z9Q!~&QpNr1GKO<4K z#cSk&)3%`;jAYSVV=A)>0r-C#vRWs0(Y%!3DzPd{q z_>N|+6UhUYFAxsn2%_y|tmzc6L!2nGa56OfEd)hvOO_$>!amUpK#J-X21xOlk|u^a zv|sci?zqMt7sHH7ALAcP*On1yg>G=B`3nfe>qOKq64B|Fu>(lt6}T&o@EkuB`a3SJ zb{3sXP;pA`lg95l3Xk{0HUbt$juQkbT{C)$ifWbe2Btw&QQ8Nn)DSrs>IrdkT60_z z3u^uG^?*tzB7e-wp9)hM6NgPQA(lL2VPNC;EVG@2qp+?cGG2@=^+w=G?6oT} zX-E2DLoiM*j%#A#47U|9D4Cok&GJbQ!?m8`#aMxetlN};W3$d~u>F6Gop!H;2kZwgEkxBJ@2O!m+q!R)&B*vWszi>qwWek7eCjNz(BJhQX0&}QN z5d;c<;<@q&H#({~1g};5X(QI$lBNq2YCi-&l*Z`nXX?X`h`U%w79tM4+!MC7Oa;@ne5>NI5Avh#1V$$EDVFlK7pR- zGU};X1q6rd&HbJB-hcxOj*wK|W69#$ctBa!!y> zNd1~UFrqg+azAebe3EQEwU2OS7<`xPOsfZdM9=qQ_#ObKwO1^#B!CdK$2cvFR*FB+ z2si#hrUnsq@s_8Z&~jtpcFd@*$UnTbZH!wRN4a$-;MU40uTc|4Op45bUl1vGS)~zd zEV~;(H3gEE$A0OW);2BT_JyEnQe8k%n&Mw~rvy8ZI-(pf{R$E~0u5EI;F`3O+S~AP zt_x7obn-3`?`%MnrI67mk%<A(){ND6fiyXvA|ncdMw%=+z*Sh0_%>#tFykB9I5gU*j-pcy`r^GPvH;S=r)@{)tKGvabW+8!yDb_tC8C9EemUSrAhf@<(I%tm7wC68i$N_B0V%pvErsN%<*)LE z!eMZ<(ScZZO6oz`xQxT47}E(fy81&rThA3H^gRA$yvOypXk|jrJGHn-7I6#~$^Mo+ z`WU3Ld+k#_4Eqx>72v(w(9#B`!E~NrAw+}2?aDbI_oqjtz{IAK$cN#kc?>621j((` z6ZGP+#c-!L#YxowxqdqzhME5hSrm{ef`k{;!hF)z&dP$(hl!IalC&~pAq*%(aZOtw znx@qNQU%pu&OK9@kE?lNJBU#H`hZAkh-BQq2~RSXFWmqW+XGxAMUeAXpTKShw6lsK zw|lqZA}Nw|XPztUwm2@}E68nXJL??4df~opaE2_nBy}-@L}(FDj2EbhKo5l|EGUl0 zflYU_`f<}Iv*BfrT!zUfL4bFd&5Hrc?y%!`IHOLAT2!I+v53Z ztiCG)+v@NrmI}s>O7A@bA}R2Mn*vX=x{r1b(iVTiMN$LNwoMy{j&H@MIVFNPb5;0` zN}}SiivzO()iBpbq%i!by%H>?&V5o^i8KbDWC3V}H!F(*k`^h4t``)TIE>Yp&L^MK zOPP2GbsTTS*)(D^Q01GR;<~7=`GJ0ac!&4 z+DbMd(pBrpL@f4vSfg98fe>9g`}8!ZJVksLEGo_JB>H%!JJ9pU3{u6zY+y0+XAM-W z)6>H$B=VQAz_q%Gz$aT=EF>Er<}C-3Bbmcfa7sp;>H(NS>e=N!+ICpWo2Vdw#fYjW zU0#-M)Kl{OHDNiYXMAqIN(G0-;yDo(`XW8gAMt=X1*y@$Yr=9sPmRuLk_YL@g#V+_ z{X}{TN@thEz!PoMkXaX44T$^JVa-5tCPy((6Gb;Yy|`bdybLc;9KCVU$ABtp63} z$es-m#c5?^1Wii)iSM2cBvE6DM&~@9>7NI{(!XSx?%4cMTwMxqwM?HuUurM?Q^AeB zLBx!@$tD!pKPDAM#;Wh~!5u8Fhzi#H@9*a;?ld#mMi!~Pv>h*}yYyA~_NkmH!PLMr zI#;^?wI+%iZMrAgY5*!RxM}1yr0~=vD!!<5`B91z5KO;Ax_nl-P-NC5yekFu7yo+) za6hkmOC4`Yku4w%?EXSCP(&X1XBeus2mn;qqUr;RERJL`OXDMld_n%F2&%Toxl6YA zHboXhvIzK-7)bWxc0+cuK-N}GxJZv0&=G~)1KYkPd{%{6a>EpYU?~U%+knOlW@bofcSdy<&zm=uT=(xNyRD$hF_-^pw z$&R?^9!(ZA6oW}Y9hcVzUM!iT*x&KV&psFBKaQ`+E_qS7E-++q>1@TUCy^KCdGqa) zFADBnjr4k;^yvtWy3~DD7Q1<0O~1jfHENe}-;aHn`Wf@Y=*yka37>X+@>{F#=6(Kt z)HQ)egIg2M%TsH_ZR?wZ#l89Cv&F_!)&(9N^j2siCSHpADvth|Ik>g)brH)qbw96m zS?&AM&HFqWwJ!_g!D|D(?P4Cze8S#(aPX49?SOM;;Mo$_3xfgIzA5loQLGoS>$44` zE(vH|HI|L9i`Z3;XaV6e?)$8VGiw^OFUMsD9v*!6Md1UB8DjG#H5;EkEX-ms&e2u{#E?aTchuS-ywUc`d6yYl(#BG#yvpl`PHn=Soj sOM{;CW=p^6(r>!-pL5NdE{$X4n=budfw#&yDm7#Jdr1i;x@U?109nxk&Hw-a literal 0 HcmV?d00001 diff --git a/content/labs/lab14/index.en.md b/content/labs/lab14/index.en.md index ce91cb1..5d015c8 100644 --- a/content/labs/lab14/index.en.md +++ b/content/labs/lab14/index.en.md @@ -23,7 +23,7 @@ A partially implemented class that imports system functions for handling files c Check what values the file opening function declares as invalid. Make the `MyFile` class inherit from the correct `SafeHandle` so it matches the invalid values. Make sure you do it in `WindowsFile.cs` if you're on Windows or `UnixFile.cs` if you're on OSX or Linux. Finish the correct implementation for your system. Fill in `Open` and `Read` in the file `MyFile.cs`. You can test the program by running it. -After the workshop you're encouraged to try this task for the other system setup. +After the workshop you're encouraged to try this task for the other operating system setup. {{% hint info %}} **Useful links:** @@ -62,9 +62,7 @@ Import the functions shared in `pattern.h` using `LibraryImport` in the `Pattern The library distributors might not release the full internal data layout for the user. The user might care about only a small part of the structure and not need it whole. Use `Marshall.Copy` in the `GetImage` function (`Pattern.cs`) to extract the dimensions and contents of the `color_t[] values` array hidden under the opaque handle. Utilise the fact that the fields will be laid out sequentially like in `pattern.h` (with offset 0, then offset `sizeof(int)` and `sizeof(int)*2`). The struct `color_t` has the same layout as the `Rgb24` structure. Use the acquired data to create an image with `Image.LoadPixelData`. -Fill in the `Main` function in the `PatternGenerationDemo` project to create at least one image each with the functions `pattern_enstripen` and `pattern_populate`. - -Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło się co najmniej po jednym obrazie z użyciem fukcji `pattern_enstripen` oraz `pattern_populate`. +Fill in the `Main` function in the `PatternGenerationDemo` project to create at least one image each with the functions `pattern_enstripen` and `pattern_populate`. {{% hint info %}} **Useful links:** @@ -77,6 +75,11 @@ Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło si {{% /hint %}} +### Example results +`populate` +![populate](Data/Image1.png) +`enstripen` +![enstripen](Data/Image2.png) ### Example solution diff --git a/content/labs/lab14/index.pl.md b/content/labs/lab14/index.pl.md index 2811247..8df0f3c 100644 --- a/content/labs/lab14/index.pl.md +++ b/content/labs/lab14/index.pl.md @@ -23,7 +23,7 @@ W projekcie `FileInteraction` znajdziesz częściowo zaimplementowaną klasę ł Sprawdź jakie wartości zwracane przez funkcję otwierającą plik powinny być interpretowane jako niewłaściwe. Dokończ implementację części odpowiadającej systemowi którego używasz. Dodaj do klasy `MyFile` w pliku `WindowsFile.cs` lub `UnixFile.cs` dziedziczenie po odpowiedniej klasie z rodziny `SafeHandle` i zaimplementuj potrzebne funkcje. W pliku `MyFile.cs` uzupełnij funkcje `Open` oraz `Read`. Program możesz przetestować uruchamiając go. -Po zakończeniu zajęć zachęcamy do próby wykonania zadania w innym systemie. +Po zakończeniu zajęć zachęcamy do próby wykonania zadania na innym systemie operacyjnym. {{% hint info %}} **Materiały pomocnicze:** @@ -33,10 +33,8 @@ Po zakończeniu zajęć zachęcamy do próby wykonania zadania w innym systemie. - [POSIX Manual: open](https://www.man7.org/linux/man-pages/man3/open.3p.html) - [Microsoft Learn: CreateFile](https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-createfilea) - {{% /hint %}} - ### Przykładowe rozwiązanie > [!TIP] @@ -74,6 +72,11 @@ Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło si {{% /hint %}} +### Przykładowy rezultat +`populate` +![populate](Data/Image1.png) +`enstripen` +![enstripen](Data/Image2.png) ### Przykładowe rozwiązanie From 89b712084752e93d784ee4b5fbfba34acf29dde4 Mon Sep 17 00:00:00 2001 From: Lumek4 Date: Fri, 23 Jan 2026 16:27:31 +0100 Subject: [PATCH 3/5] hotfix images --- content/labs/lab14/index.en.md | 4 ++-- {content => static}/labs/lab14/data/Image1.png | Bin {content => static}/labs/lab14/data/Image2.png | Bin 3 files changed, 2 insertions(+), 2 deletions(-) rename {content => static}/labs/lab14/data/Image1.png (100%) rename {content => static}/labs/lab14/data/Image2.png (100%) diff --git a/content/labs/lab14/index.en.md b/content/labs/lab14/index.en.md index 5d015c8..8b75567 100644 --- a/content/labs/lab14/index.en.md +++ b/content/labs/lab14/index.en.md @@ -77,9 +77,9 @@ Fill in the `Main` function in the `PatternGenerationDemo` project to create at ### Example results `populate` -![populate](Data/Image1.png) +![populate](data/Image1.png) `enstripen` -![enstripen](Data/Image2.png) +![enstripen](data/Image2.png) ### Example solution diff --git a/content/labs/lab14/data/Image1.png b/static/labs/lab14/data/Image1.png similarity index 100% rename from content/labs/lab14/data/Image1.png rename to static/labs/lab14/data/Image1.png diff --git a/content/labs/lab14/data/Image2.png b/static/labs/lab14/data/Image2.png similarity index 100% rename from content/labs/lab14/data/Image2.png rename to static/labs/lab14/data/Image2.png From dc85740ef1aa6a53e6e4cb223e73e06e96480776 Mon Sep 17 00:00:00 2001 From: Lumek4 Date: Fri, 23 Jan 2026 16:32:57 +0100 Subject: [PATCH 4/5] pointer --- .../lab14/solution/Binding/PatternGeneration/native/pattern.h | 2 +- .../lab14/student/Binding/PatternGeneration/native/pattern.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h index a45fd76..f350451 100644 --- a/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h +++ b/static/labs/lab14/solution/Binding/PatternGeneration/native/pattern.h @@ -27,5 +27,5 @@ typedef struct stripe_settings LIBRARY pattern_t* pattern_init(int width, int height); LIBRARY void pattern_populate(pattern_t* pattern, point_t* points, int point_count); -LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t settings); +LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t* settings); LIBRARY void pattern_destroy(pattern_t* pattern); diff --git a/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h index a45fd76..f350451 100644 --- a/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h +++ b/static/labs/lab14/student/Binding/PatternGeneration/native/pattern.h @@ -27,5 +27,5 @@ typedef struct stripe_settings LIBRARY pattern_t* pattern_init(int width, int height); LIBRARY void pattern_populate(pattern_t* pattern, point_t* points, int point_count); -LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t settings); +LIBRARY void pattern_enstripen(pattern_t* pattern, stripe_settings_t* settings); LIBRARY void pattern_destroy(pattern_t* pattern); From 2d0a9c74caa71114f0069cda93469c388e6d54d1 Mon Sep 17 00:00:00 2001 From: Lumek4 Date: Fri, 23 Jan 2026 16:41:51 +0100 Subject: [PATCH 5/5] typo --- content/labs/lab14/index.pl.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/content/labs/lab14/index.pl.md b/content/labs/lab14/index.pl.md index 8df0f3c..089bce9 100644 --- a/content/labs/lab14/index.pl.md +++ b/content/labs/lab14/index.pl.md @@ -74,9 +74,9 @@ Uzupełnij funkcję `Main` w projekcie `PatternGenerationDemo` aby tworzyło si ### Przykładowy rezultat `populate` -![populate](Data/Image1.png) +![populate](data/Image1.png) `enstripen` -![enstripen](Data/Image2.png) +![enstripen](data/Image2.png) ### Przykładowe rozwiązanie