From d544091fb3ec42d39b40ef8d56ae80bf03e6d945 Mon Sep 17 00:00:00 2001 From: root Date: Sat, 26 Apr 2025 21:36:17 +0800 Subject: [PATCH 01/10] Split monolithic guide into scenario-specific files; refactor index and README; add robust feature & Next.js prompt templates --- README.md | 52 +++++ learning-to-code-guide.md | 78 +++++++ modifying-existing-code.md | 83 ++++++++ troubleshooting.md | 67 +++++++ ultimate-coding-prompt-guide.md | 346 +------------------------------- writing-new-code.md | 171 ++++++++++++++++ 6 files changed, 457 insertions(+), 340 deletions(-) create mode 100644 README.md create mode 100644 learning-to-code-guide.md create mode 100644 modifying-existing-code.md create mode 100644 troubleshooting.md create mode 100644 writing-new-code.md diff --git a/README.md b/README.md new file mode 100644 index 0000000..c58d669 --- /dev/null +++ b/README.md @@ -0,0 +1,52 @@ +# AI Coding Prompt Guides + +This repository contains two comprehensive Markdown guides designed to help developers +learn to code using AI and craft effective AI-driven coding prompts. + +## Guides + +- [LearnToCode.md](LearnToCode.md): A curated collection of AI prompts to help you learn programming + concepts, write code, maintain quality, troubleshoot issues, and deepen your + understanding of core software engineering topics. Includes a glossary of terms. +- [ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md): An index to scenario-specific prompt guides. See: + - [Writing New Code](writing-new-code.md) + - [Modifying Existing Code](modifying-existing-code.md) + - [Troubleshooting](troubleshooting.md) + - [Learning To Code](learning-to-code-guide.md) + +## Getting Started + +1. Clone this repository: + ```bash + git clone https://github.com//.git + cd + ``` +2. Open the guides in your preferred Markdown viewer or editor: + - [LearnToCode.md](LearnToCode.md) + - [ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md) + +## Usage + +Copy and paste the prompts from these guides into your AI coding assistant (e.g., ChatGPT, +Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubleshooting. + +## Changelog + +- ultimate-coding-prompt-guide.md: Updated initial prompt to a robust feature prompt template with clear requirements, best practices, error handling, and unit tests. + +- ultimate-coding-prompt-guide.md: Added Next.js-specific frontend prompt template with SSR/SSG, dynamic routing, and testing guidelines. + +## Contributing + +Contributions, issues, and suggestions are welcome! To contribute: +1. Fork the repository. +2. Create a new branch (`git checkout -b feature-name`). +3. Make your changes and commit them. +4. Push to the branch and open a pull request. + +Please follow the existing style and guidelines when adding or modifying prompts. + +## License + +This repository is currently unlicensed. Please contact the repository owner for permissions +to use or modify the content. \ No newline at end of file diff --git a/learning-to-code-guide.md b/learning-to-code-guide.md new file mode 100644 index 0000000..9110df6 --- /dev/null +++ b/learning-to-code-guide.md @@ -0,0 +1,78 @@ + # AI Coding 101: Learning To Code + + The following tips match what was covered in the AI Coding 101 episode, but the [LearnToCode.md](LearnToCode.md) page contains more detailed prompts and a technology glossary. + + #### 31. Tell AI to keep it simple + that you are a new dev + + **Example:** + ``` + I am learning how to code. Can you simply explain how the frontend connects to the backend? + ``` +--- + + #### 32. Ask AI to explain code "line by line" + + **Prompt:** + ``` + Please add comments explaining [function] line by line + ``` + + **Example:** + ``` + I am learning how to code. Can you explain the getContactDetails function line by line? + ``` +--- + + #### 33. Ask AI to explain specific technologies & concepts + + **Prompt:** + ``` + Can you explain how [concept] works? What does [technology] do? + ``` + + **Example:** + ``` + I'm a new dev. Can you explain what databases are for, when I should use them, and what Postgres is specifically? + ``` +--- + + #### 34. Ask AI how to build something + + **Prompt:** + ``` + I want to build a [app/feature]. How would you approach this problem from a technical perspective? + ``` + + **Example:** + ``` + I want to build a chat app. How would you architect this and what considerations do we need to take into account? + ``` +--- + + #### 35. Ask AI to show you examples + + **Prompt:** + ``` + Can you show me a working example of a [concept] and explain it? + ``` + + **Example:** + ``` + I am learning to code and want to understand how objects work. Can you create some examples and explain them? + ``` +--- + + #### 36. Tell the AI what you already know vs what is unclear + + **Prompt:** + ``` + I know how [concept] works but can you explain how it relates to [concept 2]? + ``` + + **Example:** + ``` + I have an API and understand how requests come in but can you explain how I could add authentication to my endpoints? + ``` +--- + + ### 37. Focus on learning and understanding core concepts \ No newline at end of file diff --git a/modifying-existing-code.md b/modifying-existing-code.md new file mode 100644 index 0000000..b2ca369 --- /dev/null +++ b/modifying-existing-code.md @@ -0,0 +1,83 @@ + # AI Coding 101: Modifying Existing Code + + #### 14. Keep code organized by asking AI to refactor & simplify + + **Prompt:** + ``` + Please refactor the code in [file / function] to split it up into [list of files / functions] + ``` + + **Example:** + ``` + Please split up dataParser.ts into dedicated files including csvParser.ts, xmlParser.ts, and pdfParser.ts + ``` +--- + + ## 15. Manage and balance the CONTEXT you give to the AI + +--- + + #### 16. Tag specific relevant files as context + + **Prompt:** + ``` + Please implement [feature]. You’ll need to modify [list of files]. Here are additional files for context: [list of files] + ``` +--- + + #### 17. Keep your files at 300 lines of code or less + +--- + + #### 18. Keep in mind that the full conversation is used as context + +--- + + #### 19. Start a new conversation for each new feature + +--- + + #### 20. Tell the AI what works well and what needs to be changed + + **Prompt:** + ``` + This was a good start. [list of features] are working well but [list of problems] still needs to be fixed. Can you fix that? + ``` + + **Example:** + ``` + The new search feature is properly calling the API and showing results but it is not properly searching by product description. Can you please fix that? + ``` +--- + + #### 21. Ask AI to find edge cases or bugs + + **Prompt:** + ``` + Are there any edge cases we should consider or handle? + ``` +--- + + #### 22. Ask AI to review the code + + **Prompt:** + ``` + Now that we have finished building [feature], can you do a full review of the implementation and the new code? + ``` +--- + + #### 23. Ask AI about what the current code does + + **Prompt:** + ``` + How does the code in [@file] work? Give a high level overview + ``` + + ``` + How does the [function] work? Give a detailed description + ``` + + **Example:** + ``` + What does the code in @serverComm.ts do? How does it handle authentication? + ``` \ No newline at end of file diff --git a/troubleshooting.md b/troubleshooting.md new file mode 100644 index 0000000..5b2ea3d --- /dev/null +++ b/troubleshooting.md @@ -0,0 +1,67 @@ + # AI Coding 101: Troubleshooting + + #### 24. Be specific about what is not working (and what is) + + **Prompt:** + ``` + When I do [X], I see [Y], but when I do [Z], it seems to work. + ``` + + ``` + Right now the [feature 1] is working correctly but [feature 2] is failing [failure description]. Can you fix that? + ``` + + **Example:** + ``` + The buttons are visible now but when I click them nothing seems to happen. Can you fix that? + ``` +--- + + #### 25. Share screenshots to show what is wrong + + **Example:** + ``` + The layout is still incorrect. Please see [@screenshot] and note how the sidebar is not properly expanding. + ``` +--- + + #### 26. Share the exact errors + + **Prompt:** + ``` + It’s still failing - here are the errors: [full error logs] + ``` +--- + + ## 27. The Beaver Method + The Beaver Method is a troubleshooting approach that works by asking AI to add logs throughout the code, running the software, and feeding the logs back to AI for context. + + **Step 1 Prompt:** + ``` + Please add logs at every step of the process to make it easier to troubleshoot and figure out where the problem is. + ``` + + **Step 2 Prompt:** + ``` + I ran the process and here is the result: [full logs generated from step 1] + ``` +--- + + #### 28. Ask AI to explain the code + Similar to #23 but in the context of troubleshooting to bridge the disconnect between expectations and reality. + + **Example:** + ``` + This code doesn’t convert dates correctly. Can you explain how it works? + ``` +--- + + #### 29. Ask AI to use a "radically different approach" + + **Prompt:** + ``` + This still isn’t working. Let’s try a radically different approach. + ``` +--- + + ## 30. Know when to stop asking AI and read the code yourself \ No newline at end of file diff --git a/ultimate-coding-prompt-guide.md b/ultimate-coding-prompt-guide.md index 6ec9677..3d514c2 100644 --- a/ultimate-coding-prompt-guide.md +++ b/ultimate-coding-prompt-guide.md @@ -1,4 +1,5 @@ # AI Coding 101: Ultimate Prompt Guide + This is a companion document to go along with my AI Coding 101 video. This document contains all the prompts discussed in the video - though I suggest you watch the video for all of the additional context and explanation that relates to these prompts and tips. You can watch the full video here: @@ -6,344 +7,9 @@ You can watch the full video here: [![AI Coding 101: Ultimate Prompt Guide](https://img.youtube.com/vi/uwA3MMYBfAQ/0.jpg)](https://youtu.be/uwA3MMYBfAQ) > 🎥 AI Coding 101: Ultimate Prompt Guide (37 tips) +This guide is split into the following scenario-specific files: -# Writing New Code -#### 1. Specify technologies and frameworks - -**Prompt**: -``` -Please create [app/feature description] using [technology list] -``` - -**Example:** -``` -Create a weather tracking app using React (vite), TypeScript, ShadCN, and Tailwind -``` ---- -#### 2. Choose Popular Technologies - -**Recommendations:** -``` -Frontend: TypeScript, React, Tailwind, ShadCN -Backend: TypeScript, Python, Express.js, FastAPI, Django -Databases: Postgres, MongoDB, Redis -Cloud: Cloud Storage (S3), Supabase Auth, Cloud/Edge Functions -``` ---- -#### 3. Design the solution, then implement with AI - -**Prompt:** -``` -I am building a [feature]. It should work like this: [list of requirements] -We should [implementation tips]. It should also handle these edge cases: [list] -``` - -**Example:** -``` -We’re building a search feature. It should perform the search based on the product title and description. - -Create a new component, SearchBar, and add it to the existing NavBar component. Also, create a new search endpoint in the @server.ts file. - -When no results are found, we should display 'No Results' in place of the product list. -``` ---- -#### 4. Break things down, give the AI a list of tasks - -**Prompt:** -``` -Please implement the following: -1. [Requirement #1] -2. [Requirement #2] -3. [Requirement #3] -``` ---- -## 5. Find the right balance of task scope (not too big or small) - ---- -#### 6. Use examples in your prompts - -**Prompt:** -``` -Please create a [feature] that follows this example: [example]” -``` - -**Example:** -``` -Create a date formatting function. It should work like this: -1.Input: '2024-02-07' → Output: 'Feb 7, 2024' -2.Input: '2024-02-07T15:30:00' → Output: 'Feb 7, 2024 3:30 PM' -``` ---- -#### 7. Provide sample code for the AI to follow - -**Prompt:** -``` -Please create a [feature]. Here is working sample code: [code] -``` ---- -#### 8. Use @Docs and @Web context utilities - -**Prompt:** -``` -Please build a [feature]. Reference the [@Docs / link] docs -``` - -``` -Please build a [feature]. Find the best practices and examples for building this on the [@Web]” -``` ---- -#### 9. Make sure the code is secure and performs well - -**Prompt:** -``` -Please implement [feature]. Make sure to account for any potential security issues. -``` - -``` -We just implemented [feature]. Can you check to make sure that it use the most efficient approach? -``` ---- -#### 10. Proactively check for additional considerations - -**Prompt:** -``` -Are there any additional considerations for building [feature]? -``` ---- -#### 11. Ask the AI to write tests & try Test-Driven Development - -**Prompt:** -``` -Please write the tests for the new feature we just implemented -``` - -**Test-Driven Development:** -``` -We are building [feature]. Please write the tests to cover the following cases: [list]. Once complete, build the actual feature. -``` ---- -#### 12. Have AI generate your documentation - -**Example:** -``` -Please add an explanation of this code to our README -``` ---- -#### 13. Use precise naming - -**Example:** -``` -Please create a new csvParser method and add it to the dataParsers.ts file -``` - ---- -# Modifying Existing Code -#### 14. Keep code organized by asking AI to refactor & simplify - -**Prompt:** -``` -Please refactor the code in [file / function] to split it up into [list of files / functions] -``` - -**Example:** -``` -Please split up dataParser.ts into dedicated files including csvParser.ts, xmlParser.ts, and pdfParser.ts -``` ---- -## 15. Manage and balance the CONTEXT you give to the AI - ---- -#### 16. Tag specific relevant files as context - -**Prompt:** -``` -Please implement [feature]. You’ll need to modify [list of files]. Here are additional files for context: [list of files] -``` ---- -#### 17. Keep your files at 300 lines of code or less - ---- -#### 18. Keep in mind that the full conversation is used as context - ---- -#### 19. Start a new conversation for each new feature - ---- -#### 20. Tell the AI what works well and what needs to be changed - -**Prompt:** -``` -This was a good start. [list of features] are working well but [list of problems] still needs to be fixed. Can you fix that? -``` - -**Example:** -``` -The new search feature is properly calling the API and showing results but it is not properly searching by product description. Can you please fix that? -``` ---- -#### 21. Ask AI to find edge cases or bugs - -**Prompt:** -``` -Are there any edge cases we should consider or handle? -``` ---- -#### 22. Ask AI to review the code - -**Prompt:** -``` -Now that we have finished building [feature], can you do a full review of the implementation and the new code? -``` ---- -#### 23. Ask AI about what the current code does - -**Prompt:** -``` -How does the code in [@file] work? Give a high level overview -``` - -``` -How does the [function] work? Give a detailed description” -``` - -**Example:** -``` -What does the code in @serverComm.ts do? How does it handle authentication? -``` ---- -# Troubleshooting -#### 24. Be specific about what is not working (and what is) - -**Prompt:** -``` -When I do [X], I see [Y], but when I do [Z], it seems to work. -``` - -``` -Right now the [feature 1] is working correctly but [feature 2] is failing [failure description]. Can you fix that? -``` - -**Example:** -``` -The buttons are visible now but when I click them nothing seems to happen. Can you fix that? -``` ---- -#### 25. Share screenshots to show what is wrong - -**Example:** -``` -The layout is still incorrect. Please see [@screenshot] and note how the sidebar is not properly expanding. -``` ---- -#### 26. Share the exact errors - -**Prompt:** -``` -It’s still failing - here are the errors: [full error logs] -``` ---- -## 27. The Beaver Method -The beaver method is a troubleshooting approach that works by asking AI to add logs throughout the code that you are troubleshooting, running the software, and feeding the logs back into the AI so that it can troubleshoot with all the relevant runtime context. - -**Step 1 Prompt:** -``` -Please add logs at every step of the process to make it easier to troubleshoot and figure out where the problem is. -``` - -**Step 2 Prompt:** -``` -I ran the process and here is the result: [full logs generated from step 1] -``` ---- -#### 28. Ask AI to explain the code -Similar to #23 but in the context of troubleshooting to help bridge the disconnect between developer expectations and the way the code actually works (which the developer currently perceives as incorrect). - -**Example:** -``` -This code doesn’t convert dates correctly. Can you explain how it works? -``` ---- -#### 29. Ask AI to use a "radically different approach" - -**Prompt:** -``` -This still isn’t working. Let’s try a radically different approach. -``` ---- -## 30. Know when to stop asking AI and read the code yourself - ---- -# Learning To Code - -The following tips match what was covered in the AI Coding 101 episode, but the [Learn To Code](https://github.com/VoloBuilds/prompts/blob/main/LearnToCode.md) page contains more detailed tips for learning to code specifically including a **technology glossary** that can help guide your exploration. - -#### 31. Tell AI to keep it simple + that you are a new dev - -**Example:** -``` -I am learning how to code. Can you simply explain how the frontend connects to the backend? -``` ---- -#### 32. Ask AI to explain code "line by line" - -**Prompt:** -``` -Please add comments explaining [function] line by line -``` - -**Example:** -``` -I am learning how to code. Can you explain the getContactDetails function line by line? -``` ---- -#### 33. Ask AI to explain specific technologies & concepts - -**Prompt:** -``` -Can you explain how [concept] works? What does [technology] do? -``` - -**Example:** -``` -I'm a new dev. Can you explain what databases are for, when I should use them, and what Postgres is specifically? -``` ---- -#### 34. Ask AI how to build something - -**Prompt:** -``` -I want to build a [app/feature]. How would you approach this problem from a technical perspective? -``` - -**Example:** -``` -I want to build a chat app. How would you architect this and what considerations do we need to take into account? -``` ---- -#### 35. Ask AI to show you examples - -**Prompt:** -``` -Can you show me a working example of a [concept] and explain it? -``` - -**Example:** -``` -I am learning to code and want to understand how objects work. Can you create some examples and explain them? -``` ---- -#### 36. Tell the AI what you already know vs what is unclear - -**Prompt:** -``` -I know how [concept] works but can you explain how it relates to [concept 2]? -``` - -**Example:** -``` -I have an API and understand how requests come in but can you explain how I could add authentication to my endpoints? -``` ---- -### 37. Focus on learning and understanding core concepts - ---- +- [Writing New Code](writing-new-code.md) +- [Modifying Existing Code](modifying-existing-code.md) +- [Troubleshooting](troubleshooting.md) +- [Learning To Code](learning-to-code-guide.md) diff --git a/writing-new-code.md b/writing-new-code.md new file mode 100644 index 0000000..ec741dd --- /dev/null +++ b/writing-new-code.md @@ -0,0 +1,171 @@ + # AI Coding 101: Writing New Code + + #### 1. Robust feature prompt template + + **Prompt Template:** + ``` + You are an expert [technology] developer. Implement [app/feature description] with these requirements: + - [Requirement 1] + - [Requirement 2] + - [Requirement 3] + Use [technology list], follow best practices, include error handling, and provide unit tests. + ``` + + **Example:** + ``` + You are an expert full-stack developer. Implement a weather tracking app using React (Vite) and TypeScript with these requirements: + - Fetch real-time data from the OpenWeather API. + - Display temperature, humidity, and conditions. + - Handle loading and error states gracefully. + - Include unit tests for data-fetching functions. + ``` +--- + + #### Next.js frontend prompt template + + **Prompt Template:** + ``` + You are an expert Next.js developer. Implement [app/feature description] in a Next.js project with these requirements: + - [Requirement 1] + - [Requirement 2] + - [Requirement 3] + Fetch data using getStaticProps or getServerSideProps, set up dynamic routes with getStaticPaths, and style with [CSS framework]. Include error handling and unit tests. + ``` + + **Example:** + ``` + You are an expert Next.js developer. Build a blog homepage in Next.js with these requirements: + - Create a page at /blog. + - Fetch posts from Contentful using getStaticProps. + - Implement dynamic routes under /blog/[slug] with getStaticPaths. + - Style with Tailwind CSS. + - Handle loading, error, and fallback states. + - Write unit tests for data fetching and page rendering. + ``` +--- + + #### 2. Choose Popular Technologies + + **Recommendations:** + ``` + Frontend: TypeScript, React, Tailwind, ShadCN + Backend: TypeScript, Python, Express.js, FastAPI, Django + Databases: Postgres, MongoDB, Redis + Cloud: Cloud Storage (S3), Supabase Auth, Cloud/Edge Functions + ``` +--- + + #### 3. Design the solution, then implement with AI + + **Prompt:** + ``` + I am building a [feature]. It should work like this: [list of requirements] + We should [implementation tips]. It should also handle these edge cases: [list] + ``` + + **Example:** + ``` + We’re building a search feature. It should perform the search based on the product title and description. + + Create a new component, SearchBar, and add it to the existing NavBar component. Also, create a new search endpoint in the @server.ts file. + + When no results are found, we should display 'No Results' in place of the product list. + ``` +--- + + #### 4. Break things down, give the AI a list of tasks + + **Prompt:** + ``` + Please implement the following: + 1. [Requirement #1] + 2. [Requirement #2] + 3. [Requirement #3] + ``` +--- + + ## 5. Find the right balance of task scope (not too big or small) +--- + + #### 6. Use examples in your prompts + + **Prompt:** + ``` + Please create a [feature] that follows this example: [example] + ``` + + **Example:** + ``` + Create a date formatting function. It should work like this: + 1. Input: '2024-02-07' → Output: 'Feb 7, 2024' + 2. Input: '2024-02-07T15:30:00' → Output: 'Feb 7, 2024 3:30 PM' + ``` +--- + + #### 7. Provide sample code for the AI to follow + + **Prompt:** + ``` + Please create a [feature]. Here is working sample code: [code] + ``` +--- + + #### 8. Use @Docs and @Web context utilities + + **Prompt:** + ``` + Please build a [feature]. Reference the [@Docs / link] docs + ``` + + ``` + Please build a [feature]. Find the best practices and examples for building this on the [@Web] + ``` +--- + + #### 9. Make sure the code is secure and performs well + + **Prompt:** + ``` + Please implement [feature]. Make sure to account for any potential security issues. + ``` + + ``` + We just implemented [feature]. Can you check to make sure that it use the most efficient approach? + ``` +--- + + #### 10. Proactively check for additional considerations + + **Prompt:** + ``` + Are there any additional considerations for building [feature]? + ``` +--- + + #### 11. Ask the AI to write tests & try Test-Driven Development + + **Prompt:** + ``` + Please write the tests for the new feature we just implemented + ``` + + **Test-Driven Development:** + ``` + We are building [feature]. Please write the tests to cover the following cases: [list]. Once complete, build the actual feature. + ``` +--- + + #### 12. Have AI generate your documentation + + **Example:** + ``` + Please add an explanation of this code to our README + ``` +--- + + #### 13. Use precise naming + + **Example:** + ``` + Please create a new csvParser method and add it to the dataParsers.ts file + ``` \ No newline at end of file From 95fe7e09d4faaec1648617c55d52d3f7d6e63e01 Mon Sep 17 00:00:00 2001 From: root Date: Sat, 26 Apr 2025 21:37:45 +0800 Subject: [PATCH 02/10] Update README changelog with guide splitting details --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index c58d669..2d85033 100644 --- a/README.md +++ b/README.md @@ -36,6 +36,8 @@ Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubles - ultimate-coding-prompt-guide.md: Added Next.js-specific frontend prompt template with SSR/SSG, dynamic routing, and testing guidelines. +- ultimate-coding-prompt-guide.md: Split the monolithic guide into four scenario-specific files (`writing-new-code.md`, `modifying-existing-code.md`, `troubleshooting.md`, `learning-to-code-guide.md`), and refactored `ultimate-coding-prompt-guide.md` into an index linking to them. + ## Contributing Contributions, issues, and suggestions are welcome! To contribute: From 3ea773293ce5c81357db2c04e1ca29e1f6b4758d Mon Sep 17 00:00:00 2001 From: root Date: Sat, 26 Apr 2025 21:42:50 +0800 Subject: [PATCH 03/10] Add MIT License and update README.md to reference LICENSE --- LICENSE | 21 +++++++++++++++++++++ README.md | 3 +-- 2 files changed, 22 insertions(+), 2 deletions(-) create mode 100644 LICENSE diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..72c147c --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2025 Tony Cai + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index 2d85033..bddf7eb 100644 --- a/README.md +++ b/README.md @@ -50,5 +50,4 @@ Please follow the existing style and guidelines when adding or modifying prompts ## License -This repository is currently unlicensed. Please contact the repository owner for permissions -to use or modify the content. \ No newline at end of file +This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. \ No newline at end of file From 16a7354070ec81bea838ce4d30d41b5e9876db60 Mon Sep 17 00:00:00 2001 From: root Date: Sat, 26 Apr 2025 21:51:45 +0800 Subject: [PATCH 04/10] Add user-story.md with project user personas and goals --- user-story.md | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) create mode 100644 user-story.md diff --git a/user-story.md b/user-story.md new file mode 100644 index 0000000..1b35827 --- /dev/null +++ b/user-story.md @@ -0,0 +1,27 @@ +# User Stories for AI Coding Prompt Guides + +This document outlines the key user personas and their primary goals for using the AI Coding Prompt Guides repository. + +## 1. New Developer / Learner +- As a beginner learning to code, I want a curated set of AI prompts that explain fundamental programming concepts, so that I can build confidence and foundational knowledge. +- As a learner, I want line-by-line explanations and simple examples, so that complex ideas become accessible and memorable. + +## 2. Feature Developer +- As a developer building new functionality, I want robust feature prompt templates, so that I can generate production-ready code with error handling and unit tests quickly. +- As a Next.js developer, I want dedicated Next.js templates (SSG, SSR, routing, styling), so that I can scaffold pages and data fetching efficiently without manually writing boilerplate. + +## 3. Code Maintainer / Refactorer +- As a code maintainer, I want prompts that suggest refactoring and modularization strategies, so that I can keep the codebase organized, DRY, and maintainable. + +## 4. Troubleshooter +- As a developer encountering errors, I want targeted AI prompts for diagnosing and fixing issues, so that I can resolve bugs and performance problems faster. +- As a troubleshooter, I want guidance on adding logs and interpreting outputs (The Beaver Method), so that I can systematically debug complex flows. + +## 5. Continuous Learner +- As a continuous learner, I want deep-dive prompts into specific technologies and best practices, so that I can expand my skill set and adopt industry-standard approaches. + +## 6. Contributor / Collaborator +- As a contributor, I want clear contribution guidelines and scenario-based templates, so that I can easily propose changes or add new prompts aligned with the project structure. + +## 7. Project Owner / Maintainer +- As a project owner, I want an index and concise README that guide users to scenario-specific guides, so that they can find relevant prompts without wading through a monolithic document. \ No newline at end of file From 4e445fb5b0f88537b44328cb6b8269564de84a97 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 26 May 2025 21:06:55 +0800 Subject: [PATCH 05/10] Enhance README.md with comprehensive job-specific prompt guides, quick start instructions, and a roadmap for upcoming guides. Added new guides for UI Designers, Test Engineers, Product Managers, Node.js Sails.js, Frontend React/Next.js, and Rust Backend Engineers. --- README.md | 133 ++++- frontend-react-nextjs-prompts.md | 399 ++++++++++++++ job-specific-prompts-index.md | 331 ++++++++++++ nodejs-sailsjs-backend-prompts.md | 820 +++++++++++++++++++++++++++++ product-manager-prompts.md | 737 ++++++++++++++++++++++++++ rust-backend-engineer-prompts.md | 638 ++++++++++++++++++++++ test-engineer-pytest-prompts.md | 849 ++++++++++++++++++++++++++++++ ui-designer-figma-prompts.md | 768 +++++++++++++++++++++++++++ 8 files changed, 4660 insertions(+), 15 deletions(-) create mode 100644 frontend-react-nextjs-prompts.md create mode 100644 job-specific-prompts-index.md create mode 100644 nodejs-sailsjs-backend-prompts.md create mode 100644 product-manager-prompts.md create mode 100644 rust-backend-engineer-prompts.md create mode 100644 test-engineer-pytest-prompts.md create mode 100644 ui-designer-figma-prompts.md diff --git a/README.md b/README.md index bddf7eb..2f13312 100644 --- a/README.md +++ b/README.md @@ -1,53 +1,156 @@ # AI Coding Prompt Guides -This repository contains two comprehensive Markdown guides designed to help developers -learn to code using AI and craft effective AI-driven coding prompts. +This repository contains comprehensive Markdown guides designed to help developers +learn to code using AI and craft effective AI-driven coding prompts tailored to specific job roles and technologies. ## Guides -- [LearnToCode.md](LearnToCode.md): A curated collection of AI prompts to help you learn programming +### Job-Specific Prompt Guides +- **[Job-Specific Prompts Index](job-specific-prompts-index.md)**: Complete index of role-based prompt guides +- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)**: Specialized prompts for React and Next.js developers +- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)**: Comprehensive guide for Rust backend development with AI integration +- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)**: Complete guide for Node.js Sails.js framework development +- **[UI Designer (Figma)](ui-designer-figma-prompts.md)**: Complete guide for UI Designers using Figma for prototypes and design systems +- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)**: Comprehensive guide for Test Engineers using pytest framework +- **[Product Manager](product-manager-prompts.md)**: Comprehensive guide for Product Managers covering prototypes, research, and strategy + +### General Coding Guides +- **[LearnToCode.md](LearnToCode.md)**: A curated collection of AI prompts to help you learn programming concepts, write code, maintain quality, troubleshoot issues, and deepen your understanding of core software engineering topics. Includes a glossary of terms. -- [ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md): An index to scenario-specific prompt guides. See: +- **[ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md)**: An index to scenario-specific prompt guides: - [Writing New Code](writing-new-code.md) - [Modifying Existing Code](modifying-existing-code.md) - [Troubleshooting](troubleshooting.md) - [Learning To Code](learning-to-code-guide.md) +## Quick Start by Role + +### Frontend Developers (React/Next.js) +```bash +# Start with the Frontend React/Next.js guide +open frontend-react-nextjs-prompts.md +``` +Perfect for: Component development, state management, Next.js features, performance optimization, testing + +### Backend Developers (Rust) +```bash +# Start with the Rust Backend guide +open rust-backend-engineer-prompts.md +``` +Perfect for: Actix-web development, RIG AI integration, database setup, authentication, API design + +### Backend Developers (Node.js Sails.js) +```bash +# Start with the Node.js Sails.js guide +open nodejs-sailsjs-backend-prompts.md +``` +Perfect for: Sails.js MVC architecture, Waterline ORM, real-time features, RESTful APIs, Socket.io + +### UI Designers (Figma) +```bash +# Start with the UI Designer Figma guide +open ui-designer-figma-prompts.md +``` +Perfect for: Interactive prototypes, design systems, component design, accessibility, design handoff + +### Test Engineers (Pytest) +```bash +# Start with the Test Engineer Pytest guide +open test-engineer-pytest-prompts.md +``` +Perfect for: Test automation, unit/integration testing, UI testing, performance testing, CI/CD integration + +### Product Managers +```bash +# Start with the Product Manager guide +open product-manager-prompts.md +``` +Perfect for: Prototype creation, user research, feature planning, market analysis, product strategy + +### General Development +```bash +# Start with the general coding guides +open ultimate-coding-prompt-guide.md +open LearnToCode.md +``` +Perfect for: Learning fundamentals, general coding tasks, troubleshooting + ## Getting Started -1. Clone this repository: +1. **Choose your guide based on your role**: + - Browse the [Job-Specific Prompts Index](job-specific-prompts-index.md) to find guides tailored to your technology stack and responsibilities + - Use general guides for learning fundamentals or cross-cutting concerns + +2. **Clone this repository**: ```bash git clone https://github.com//.git cd ``` -2. Open the guides in your preferred Markdown viewer or editor: - - [LearnToCode.md](LearnToCode.md) - - [ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md) + +3. **Open the relevant guides** in your preferred Markdown viewer or editor ## Usage Copy and paste the prompts from these guides into your AI coding assistant (e.g., ChatGPT, Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubleshooting. -## Changelog +### Example Workflow +1. **Identify your role and tech stack** using the job-specific index +2. **Find relevant prompts** for your current task +3. **Customize the prompts** with your specific requirements +4. **Use with your AI assistant** to generate code, solve problems, or learn concepts + +## What's New + +### Job-Specific Guides +- **NEW**: [UI Designer Figma Guide](ui-designer-figma-prompts.md) - 30 comprehensive prompts covering interactive prototypes, design systems, component design, responsive layouts, accessibility, and design handoff +- **NEW**: [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) - 33 specialized prompts for pytest framework, test automation, unit/integration testing, UI testing, performance testing, and CI/CD integration +- **NEW**: [Product Manager Guide](product-manager-prompts.md) - 30 comprehensive prompts covering prototype development, user research, feature planning, market analysis, product strategy, and stakeholder communication +- **NEW**: [Node.js Sails.js Backend Engineer Guide](nodejs-sailsjs-backend-prompts.md) - 33 specialized prompts for Sails.js development, Waterline ORM, real-time features, and deployment +- **NEW**: [Frontend React/Next.js Engineer Guide](frontend-react-nextjs-prompts.md) - 23 specialized prompts covering component development, Next.js features, performance optimization, and testing +- **NEW**: [Rust Backend Engineer Guide](rust-backend-engineer-prompts.md) - 32 comprehensive prompts for Actix-web, RIG integration, database management, and deployment +- **NEW**: [Job-Specific Index](job-specific-prompts-index.md) - Central hub for all role-based guides with selection guidance +### Recent Updates - ultimate-coding-prompt-guide.md: Updated initial prompt to a robust feature prompt template with clear requirements, best practices, error handling, and unit tests. - - ultimate-coding-prompt-guide.md: Added Next.js-specific frontend prompt template with SSR/SSG, dynamic routing, and testing guidelines. - - ultimate-coding-prompt-guide.md: Split the monolithic guide into four scenario-specific files (`writing-new-code.md`, `modifying-existing-code.md`, `troubleshooting.md`, `learning-to-code-guide.md`), and refactored `ultimate-coding-prompt-guide.md` into an index linking to them. ## Contributing Contributions, issues, and suggestions are welcome! To contribute: -1. Fork the repository. -2. Create a new branch (`git checkout -b feature-name`). -3. Make your changes and commit them. -4. Push to the branch and open a pull request. + +### Adding New Job-Specific Guides +1. Follow the format established in existing job-specific guides +2. Include role-specific scenarios and technology-focused prompts +3. Provide both template and example prompts +4. Add best practices and workflow guidance + +### General Contributions +1. Fork the repository +2. Create a new branch (`git checkout -b feature-name`) +3. Make your changes and commit them +4. Push to the branch and open a pull request Please follow the existing style and guidelines when adding or modifying prompts. +## Roadmap + +### Upcoming Job-Specific Guides +- Python Backend Engineer (Django/FastAPI) +- DevOps Engineer (Docker, Kubernetes, CI/CD) +- Mobile Developer (React Native/Flutter) +- Data Engineer (Python, SQL, ETL pipelines) +- Machine Learning Engineer (Python, TensorFlow, PyTorch) +- UX/UI Designer (Design systems, prototyping, user research) + +### Planned Features +- Interactive prompt builder +- Technology-specific prompt collections +- Integration examples with popular AI assistants +- Video tutorials for complex workflows + ## License This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. \ No newline at end of file diff --git a/frontend-react-nextjs-prompts.md b/frontend-react-nextjs-prompts.md new file mode 100644 index 0000000..d7810d6 --- /dev/null +++ b/frontend-react-nextjs-prompts.md @@ -0,0 +1,399 @@ +# Frontend React/Next.js Engineer Prompts Guide + +A comprehensive collection of AI prompts specifically designed for Frontend React/Next.js engineers to accelerate development, solve common challenges, and follow best practices. + +## Table of Contents +1. [Component Development](#component-development) +2. [State Management](#state-management) +3. [Next.js Specific Features](#nextjs-specific-features) +4. [Performance Optimization](#performance-optimization) +5. [Testing & Quality Assurance](#testing--quality-assurance) +6. [UI/UX Implementation](#uiux-implementation) +7. [API Integration](#api-integration) +8. [Debugging & Troubleshooting](#debugging--troubleshooting) + +--- + +## Component Development + +### 1. React Component Creation Template + +**Prompt Template:** +``` +You are an expert React developer. Create a [component type] component called [ComponentName] with these requirements: +- [Requirement 1] +- [Requirement 2] +- [Requirement 3] +Use TypeScript, follow React best practices, implement proper prop validation, and include JSDoc comments. +``` + +**Example:** +``` +You are an expert React developer. Create a reusable Card component with these requirements: +- Accept title, description, and optional image props +- Support different card variants (default, outlined, elevated) +- Include hover animations and accessibility features +- Be responsive and work with Tailwind CSS +Use TypeScript, follow React best practices, implement proper prop validation, and include JSDoc comments. +``` + +### 2. Custom Hook Development + +**Prompt Template:** +``` +Create a custom React hook called use[HookName] that: +- [Functionality 1] +- [Functionality 2] +- [Functionality 3] +Include TypeScript types, error handling, and cleanup logic where needed. +``` + +**Example:** +``` +Create a custom React hook called useLocalStorage that: +- Stores and retrieves values from localStorage +- Handles JSON serialization/deserialization automatically +- Provides loading and error states +- Syncs across multiple components using the same key +Include TypeScript types, error handling, and cleanup logic where needed. +``` + +--- + +## State Management + +### 3. Context API Implementation + +**Prompt:** +``` +Create a React Context for [feature] management that includes: +- State interface with TypeScript +- Provider component with initial state +- Custom hook for consuming the context +- Actions for [list specific actions] +Follow the reducer pattern and include error boundaries. +``` + +### 4. Zustand Store Setup + +**Prompt:** +``` +Create a Zustand store for [feature] with these requirements: +- TypeScript interfaces for state shape +- Actions for [list actions] +- Persist middleware for localStorage +- DevTools integration for debugging +Include selectors and proper state immutability. +``` + +--- + +## Next.js Specific Features + +### 5. Page with Data Fetching + +**Prompt Template:** +``` +Create a Next.js page at [route] that: +- Fetches data using [getStaticProps/getServerSideProps/App Router] +- Implements [specific functionality] +- Handles loading and error states +- Includes proper SEO meta tags +- Is fully responsive with [CSS framework] +``` + +**Example:** +``` +Create a Next.js page at /products/[category] that: +- Fetches products using getStaticProps with ISR +- Implements filtering and sorting functionality +- Handles loading and error states gracefully +- Includes proper SEO meta tags and Open Graph data +- Is fully responsive with Tailwind CSS +``` + +### 6. API Route Implementation + +**Prompt:** +``` +Create a Next.js API route at /api/[endpoint] that: +- Handles [HTTP methods] +- Validates request data using [validation library] +- Connects to [database/external API] +- Implements proper error handling and status codes +- Includes rate limiting and authentication if needed +``` + +### 7. Middleware Setup + +**Prompt:** +``` +Create Next.js middleware that: +- [Functionality 1] +- [Functionality 2] +- Runs on specific routes: [route patterns] +- Handles redirects and rewrites appropriately +Include proper TypeScript types and error handling. +``` + +--- + +## Performance Optimization + +### 8. Component Optimization + +**Prompt:** +``` +Optimize this React component for performance: +[paste component code] + +Focus on: +- Memoization with React.memo, useMemo, useCallback +- Lazy loading and code splitting +- Bundle size optimization +- Render optimization techniques +``` + +### 9. Image Optimization + +**Prompt:** +``` +Implement an optimized image component using Next.js Image that: +- Supports responsive images with multiple breakpoints +- Includes lazy loading and blur placeholder +- Handles different image formats (WebP, AVIF) +- Provides fallback for unsupported formats +- Includes proper alt text and accessibility features +``` + +--- + +## Testing & Quality Assurance + +### 10. Component Testing + +**Prompt Template:** +``` +Write comprehensive tests for this [component type] using React Testing Library and Jest: +[paste component code] + +Include tests for: +- Rendering with different props +- User interactions and event handling +- Accessibility compliance +- Error states and edge cases +``` + +### 11. E2E Testing with Playwright + +**Prompt:** +``` +Create Playwright E2E tests for the [feature] workflow: +- [Step 1 of user journey] +- [Step 2 of user journey] +- [Step 3 of user journey] +Include proper page object models and test data setup. +``` + +### 12. Performance Testing + +**Prompt:** +``` +Create performance tests for [component/page] that measure: +- Core Web Vitals (LCP, FID, CLS) +- Bundle size impact +- Runtime performance metrics +- Memory usage patterns +Use appropriate testing tools and provide optimization recommendations. +``` + +--- + +## UI/UX Implementation + +### 13. Responsive Design Implementation + +**Prompt:** +``` +Convert this design mockup to a responsive React component: +[describe design or paste image] + +Requirements: +- Mobile-first approach +- Breakpoints: mobile (320px), tablet (768px), desktop (1024px) +- Use [CSS framework] for styling +- Ensure accessibility compliance (WCAG 2.1 AA) +- Include smooth animations and transitions +``` + +### 14. Form Implementation + +**Prompt:** +``` +Create a complex form component for [purpose] with: +- Form validation using [validation library] +- Multi-step wizard if applicable +- File upload capabilities +- Real-time validation feedback +- Accessibility features (ARIA labels, keyboard navigation) +- Loading states and error handling +Use React Hook Form and TypeScript. +``` + +### 15. Animation Implementation + +**Prompt:** +``` +Implement smooth animations for [component/interaction] using [animation library]: +- [Animation 1] +- [Animation 2] +- [Animation 3] +Ensure animations are performant, respect user preferences (prefers-reduced-motion), and enhance UX. +``` + +--- + +## API Integration + +### 16. Data Fetching with React Query + +**Prompt:** +``` +Set up React Query (TanStack Query) for [API endpoint] with: +- Query and mutation hooks +- Caching strategies +- Error handling and retry logic +- Optimistic updates +- Background refetching +Include TypeScript types for API responses. +``` + +### 17. Real-time Data with WebSockets + +**Prompt:** +``` +Implement WebSocket connection for [real-time feature] that: +- Establishes connection on component mount +- Handles connection states (connecting, connected, disconnected) +- Processes incoming messages and updates UI +- Includes reconnection logic +- Properly cleans up on unmount +``` + +--- + +## Debugging & Troubleshooting + +### 18. Performance Debugging + +**Prompt:** +``` +Help me debug performance issues in this React component: +[paste component code] + +Analyze: +- Unnecessary re-renders +- Memory leaks +- Bundle size impact +- Runtime performance bottlenecks +Provide specific optimization recommendations. +``` + +### 19. Build Error Resolution + +**Prompt:** +``` +I'm getting this build error in my Next.js project: +[paste error message] + +Help me: +- Understand the root cause +- Provide step-by-step solution +- Suggest preventive measures +- Update configuration if needed +``` + +### 20. Runtime Error Debugging + +**Prompt:** +``` +Debug this runtime error in my React application: +Error: [error message] +Component: [component name] +Context: [describe when error occurs] + +Provide: +- Root cause analysis +- Step-by-step debugging approach +- Code fix with explanation +- Error boundary implementation if needed +``` + +--- + +## Advanced Patterns + +### 21. Compound Component Pattern + +**Prompt:** +``` +Create a compound component for [UI element] that: +- Uses the compound component pattern +- Provides flexible composition +- Shares state between child components +- Includes proper TypeScript support +- Follows accessibility best practices +``` + +### 22. Render Props Pattern + +**Prompt:** +``` +Implement a render props component for [functionality] that: +- Encapsulates [specific logic] +- Provides flexible rendering options +- Includes proper TypeScript generics +- Handles loading and error states +- Is reusable across different UI implementations +``` + +### 23. Higher-Order Component (HOC) + +**Prompt:** +``` +Create a HOC called with[FeatureName] that: +- Adds [specific functionality] to wrapped components +- Preserves original component props and ref +- Includes proper TypeScript support +- Handles edge cases and error scenarios +- Provides debugging information in development +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Always specify TypeScript** - Include type safety requirements +2. **Mention accessibility** - Ensure WCAG compliance +3. **Include error handling** - Handle edge cases and error states +4. **Request tests** - Ask for comprehensive test coverage +5. **Specify styling approach** - Mention CSS framework or styling method +6. **Consider performance** - Ask for optimization recommendations +7. **Include documentation** - Request JSDoc comments and README updates + +## Example Workflow + +``` +1. Use Component Development prompts to create base components +2. Apply State Management prompts for complex state logic +3. Implement Next.js features using specific prompts +4. Optimize with Performance prompts +5. Ensure quality with Testing prompts +6. Debug issues using Troubleshooting prompts +``` + +--- + +*This guide is designed to help Frontend React/Next.js engineers work more efficiently with AI assistants. Customize the prompts based on your specific project requirements and tech stack.* \ No newline at end of file diff --git a/job-specific-prompts-index.md b/job-specific-prompts-index.md new file mode 100644 index 0000000..dcab2ee --- /dev/null +++ b/job-specific-prompts-index.md @@ -0,0 +1,331 @@ +# Job-Specific AI Prompts Guide + +A comprehensive collection of AI prompts tailored for different software engineering roles and specializations. Each guide contains role-specific scenarios, best practices, and optimized prompts to accelerate development and solve common challenges. + +## Available Guides + +### Frontend Development +- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)** - Complete guide for React and Next.js developers + - Component development and custom hooks + - State management (Context API, Zustand) + - Next.js specific features (SSR, SSG, API routes) + - Performance optimization and testing + - UI/UX implementation and accessibility + +### Backend Development +- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)** - Specialized guide for Rust backend developers + - Actix-web server development + - RIG integration for AI capabilities + - Database integration with SQLx + - Authentication, authorization, and security + - Performance optimization and deployment + +- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)** - Comprehensive guide for Node.js Sails.js developers + - Sails.js MVC architecture and conventions + - Waterline ORM and database integration + - Real-time features with Socket.io + - RESTful API development and GraphQL + - Authentication, middleware, and deployment + +### Design & User Experience +- **[UI Designer (Figma)](ui-designer-figma-prompts.md)** - Complete guide for UI Designers using Figma + - Interactive prototype creation and design systems + - Component design and responsive layouts + - Accessibility and usability testing + - Design handoff and developer collaboration + - Performance optimization and conversion rate optimization + +### Quality Assurance & Testing +- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)** - Comprehensive guide for Test Engineers using pytest + - Test framework setup and organization + - Unit, integration, and API testing + - UI/E2E testing with Selenium and Playwright + - Test data management and fixtures + - Performance testing and CI/CD integration + +### Product Management +- **[Product Manager](product-manager-prompts.md)** - Complete guide for Product Managers + - Interactive prototype creation and MVP definition + - User research, personas, and journey mapping + - Feature planning and prioritization frameworks + - Market research and competitive analysis + - Product strategy, roadmapping, and go-to-market + - Data analysis, metrics, and stakeholder communication + +### Coming Soon +- **Python Backend Engineer** (Django/FastAPI) +- **DevOps Engineer** (Docker, Kubernetes, CI/CD) +- **Mobile Developer** (React Native/Flutter) +- **Data Engineer** (Python, SQL, ETL pipelines) +- **Machine Learning Engineer** (Python, TensorFlow, PyTorch) +- **UX Researcher** (User research, usability testing, analytics) + +## How to Choose the Right Guide + +### By Technology Stack +- **React/Next.js Frontend** → [Frontend React/Next.js Guide](frontend-react-nextjs-prompts.md) +- **Rust + Actix-web Backend** → [Rust Backend Guide](rust-backend-engineer-prompts.md) +- **Node.js + Sails.js Backend** → [Node.js Sails.js Guide](nodejs-sailsjs-backend-prompts.md) +- **Figma Design** → [UI Designer Figma Guide](ui-designer-figma-prompts.md) +- **Pytest Testing** → [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) +- **Product Management** → [Product Manager Guide](product-manager-prompts.md) +- **Python Backend** → Coming soon + +### By Role Responsibilities +- **Frontend Focus**: UI/UX, component development, state management +- **Backend Focus**: APIs, databases, authentication, performance +- **Design Focus**: Prototyping, design systems, user experience +- **Testing Focus**: Test automation, quality assurance, CI/CD +- **Product Management**: Strategy, research, prototyping, stakeholder communication +- **Full-Stack**: Use both frontend and backend guides +- **DevOps Focus**: Infrastructure, deployment, monitoring + +### By Experience Level +- **Junior Developers**: Start with basic setup and component/API development prompts +- **Mid-Level Developers**: Focus on architecture, testing, and optimization prompts +- **Senior Developers**: Use advanced patterns, performance, and system design prompts +- **Designers**: Begin with prototype and component prompts, advance to design systems +- **Test Engineers**: Start with framework setup, progress to advanced testing patterns +- **Product Managers**: Begin with user research and prototype prompts, advance to strategy + +## Universal Prompts for All Roles + +### 1. Code Review and Quality +``` +Review this code for: +- Best practices adherence +- Security vulnerabilities +- Performance issues +- Code maintainability +- Documentation quality + +[paste code] + +Provide specific recommendations for improvement. +``` + +### 2. Architecture Design +``` +Design a [system type] architecture for [use case] with these requirements: +- [Requirement 1] +- [Requirement 2] +- [Requirement 3] + +Consider scalability, maintainability, and performance. Include technology recommendations and trade-offs. +``` + +### 3. Debugging Assistant +``` +Help me debug this issue: +Problem: [describe the problem] +Expected behavior: [what should happen] +Actual behavior: [what's happening] +Code context: [relevant code snippets] +Error messages: [any error messages] + +Provide step-by-step debugging approach and potential solutions. +``` + +### 4. Documentation Generation +``` +Generate comprehensive documentation for this [component/function/API]: +[paste code] + +Include: +- Purpose and functionality +- Parameters and return values +- Usage examples +- Edge cases and limitations +- Integration guidelines +``` + +### 5. Test Case Generation +``` +Generate comprehensive test cases for this [component/function]: +[paste code] + +Include: +- Unit tests for core functionality +- Edge case testing +- Error scenario testing +- Integration tests if applicable +- Performance tests if relevant + +Use [testing framework] and follow best practices. +``` + +## Cross-Role Collaboration Prompts + +### Frontend-Backend Integration +``` +Design API contract between frontend and backend for [feature]: +Frontend needs: [list requirements] +Backend capabilities: [list what backend provides] + +Include: +- API endpoint specifications +- Request/response schemas +- Error handling strategies +- Authentication requirements +``` + +### Design-Development Collaboration +``` +Create design-to-development handoff documentation for [feature/component]: +Design specifications: [Figma designs and requirements] +Technical constraints: [development limitations] +Implementation timeline: [development schedule] + +Include: +- Component specifications and measurements +- Asset export requirements +- Interaction and animation details +- Responsive behavior documentation +- Accessibility requirements +``` + +### Testing-Development Integration +``` +Create testing strategy for [feature/component] that covers: +Development requirements: [functionality to test] +Quality standards: [coverage and performance targets] +Testing timeline: [when tests should be implemented] + +Include: +- Unit test requirements and coverage targets +- Integration test scenarios +- UI/E2E test workflows +- Performance testing criteria +- CI/CD integration requirements +``` + +### Product-Engineering Collaboration +``` +Create technical requirements document for [product feature] that bridges product and engineering: +Product requirements: [list product needs] +Technical constraints: [list technical limitations] +User experience goals: [list UX objectives] + +Include: +- Feature specifications and acceptance criteria +- Technical implementation approach +- Timeline and resource estimates +- Risk assessment and mitigation strategies +``` + +### DevOps-Development Integration +``` +Create deployment strategy for [application] with: +Development requirements: [list dev needs] +Infrastructure constraints: [list limitations] +Performance targets: [specify metrics] + +Include: +- CI/CD pipeline design +- Environment configuration +- Monitoring and alerting setup +- Rollback procedures +``` + +## Best Practices Across All Roles + +### 1. Always Specify Context +- Mention your tech stack and versions +- Include project constraints and requirements +- Specify target environment (development, staging, production) + +### 2. Include Quality Requirements +- Request error handling and edge case coverage +- Ask for security considerations +- Include performance requirements +- Specify testing needs + +### 3. Ask for Documentation +- Request code comments and documentation +- Ask for README updates +- Include API documentation for backend work +- Request component documentation for frontend work + +### 4. Consider Maintainability +- Ask for clean, readable code +- Request modular, reusable components +- Include refactoring suggestions +- Ask for code organization best practices + +## Example Multi-Role Workflow + +### Building a Full-Stack Feature +1. **Product Planning**: Use Product Manager prompts for user research and requirements +2. **Design Phase**: Use UI Designer prompts for prototypes and design systems +3. **Architecture Design**: Use universal architecture prompts +4. **Backend Development**: Use Rust/Node.js backend prompts for API development +5. **Frontend Development**: Use React/Next.js prompts for UI implementation +6. **Testing**: Use Test Engineer prompts for comprehensive testing +7. **Integration**: Use cross-role collaboration prompts +8. **Deployment**: Use DevOps prompts for deployment strategy + +### Product Development Cycle +1. **Research Phase**: Use Product Manager user research prompts +2. **Strategy Phase**: Use Product Manager strategy and roadmap prompts +3. **Design Phase**: Use UI Designer prototype and design system prompts +4. **Development Phase**: Use appropriate engineering guides +5. **Testing Phase**: Use Test Engineer prompts for quality assurance +6. **Launch Phase**: Use Product Manager go-to-market prompts +7. **Optimization Phase**: Use data analysis and performance prompts + +### Design-to-Development Workflow +1. **User Research**: Use Product Manager research prompts +2. **Prototype Creation**: Use UI Designer prototype prompts +3. **Design System**: Use UI Designer design system prompts +4. **Component Development**: Use Frontend development prompts +5. **Testing**: Use Test Engineer UI testing prompts +6. **Handoff**: Use design-development collaboration prompts + +### Quality Assurance Process +1. **Test Planning**: Use Test Engineer framework setup prompts +2. **Unit Testing**: Use Test Engineer unit testing prompts +3. **Integration Testing**: Use Test Engineer integration prompts +4. **UI Testing**: Use Test Engineer UI/E2E testing prompts +5. **Performance Testing**: Use Test Engineer performance prompts +6. **Reporting**: Use Test Engineer reporting prompts + +## Contributing New Role-Specific Guides + +To contribute a new job-specific guide: + +1. **Follow the established format**: + - Clear table of contents + - Categorized prompt sections + - Template and example prompts + - Best practices section + +2. **Include role-specific scenarios**: + - Common daily tasks + - Technology-specific challenges + - Industry best practices + - Performance considerations + +3. **Provide practical examples**: + - Real-world use cases + - Complete prompt templates + - Expected outcomes + - Integration guidelines + +4. **Consider experience levels**: + - Basic prompts for beginners + - Advanced patterns for experienced professionals + - Leadership prompts for senior roles + +## Feedback and Updates + +These guides are living documents that should evolve with: +- New technology releases +- Changing best practices +- Community feedback +- Real-world usage patterns + +Please contribute improvements, new prompts, and additional role-specific guides to help the entire development community work more efficiently with AI assistants. + +--- + +*Choose the guide that best matches your role and technology stack. For full-stack development or cross-functional teams, use multiple guides as needed. Remember to customize prompts based on your specific project requirements and constraints.* \ No newline at end of file diff --git a/nodejs-sailsjs-backend-prompts.md b/nodejs-sailsjs-backend-prompts.md new file mode 100644 index 0000000..77de7f0 --- /dev/null +++ b/nodejs-sailsjs-backend-prompts.md @@ -0,0 +1,820 @@ +# Node.js Sails.js Backend Engineer Prompts Guide + +A comprehensive collection of AI prompts specifically designed for Node.js backend engineers working with Sails.js framework to build scalable, maintainable, and robust web applications and APIs. + +## Table of Contents +1. [Project Setup & Architecture](#project-setup--architecture) +2. [Sails.js Application Development](#sailsjs-application-development) +3. [Model & Database Integration](#model--database-integration) +4. [API Development & Controllers](#api-development--controllers) +5. [Authentication & Authorization](#authentication--authorization) +6. [Real-time Features with Sockets](#real-time-features-with-sockets) +7. [Middleware & Policies](#middleware--policies) +8. [Testing & Quality Assurance](#testing--quality-assurance) +9. [Performance & Optimization](#performance--optimization) +10. [Deployment & DevOps](#deployment--devops) + +--- + +## Project Setup & Architecture + +### 1. New Sails.js Project Setup + +**Prompt Template:** +``` +You are an expert Node.js backend developer. Set up a new Sails.js project with these requirements: +- Sails.js version: [specify version] +- Database: [MongoDB/PostgreSQL/MySQL] +- Authentication: [JWT/Passport/custom] +- Real-time features: [WebSocket requirements] +- API type: [REST/GraphQL/both] +- Environment setup: [development/staging/production] + +Include: +- Project structure and configuration +- Database connection setup +- Environment variable management +- Package.json with necessary dependencies +- Basic security configurations +``` + +**Example:** +``` +You are an expert Node.js backend developer. Set up a new Sails.js project with these requirements: +- Sails.js version: 1.5.x (latest stable) +- Database: PostgreSQL with Waterline ORM +- Authentication: JWT-based with Passport.js integration +- Real-time features: Socket.io for live notifications and chat +- API type: RESTful APIs with GraphQL endpoint +- Environment setup: Docker-ready for development and production + +Include: +- Project structure with organized controllers, models, and services +- PostgreSQL connection with connection pooling +- Environment variables for different deployment stages +- Package.json with security, testing, and development dependencies +- CORS, helmet, and rate limiting configurations +``` + +### 2. Sails.js Architecture Design + +**Prompt:** +``` +Design a scalable Sails.js architecture for [application type] with: +- Modular controller organization +- Service layer for business logic +- Helper functions for utilities +- Policy-based authorization +- Hook system for custom functionality +- Configuration management strategy + +Include: +- Directory structure and naming conventions +- Separation of concerns principles +- Dependency injection patterns +- Error handling strategy +- Logging and monitoring setup +``` + +### 3. Environment Configuration + +**Prompt:** +``` +Set up comprehensive environment configuration for Sails.js application with: +- Development, staging, and production environments +- Database configurations for each environment +- Security settings and secrets management +- Third-party service integrations +- Feature flags and environment-specific settings + +Include: +- config/ directory structure +- Environment variable validation +- Configuration inheritance and overrides +- Secure credential management +- Docker and deployment configurations +``` + +--- + +## Sails.js Application Development + +### 4. Controller Development + +**Prompt Template:** +``` +Create a Sails.js controller for [resource/feature] with these requirements: +- CRUD operations: [specify which operations] +- Input validation and sanitization +- Error handling and response formatting +- Pagination and filtering support +- Authentication and authorization checks +- [Additional specific requirements] + +Include: +- RESTful action methods +- Request/response handling +- Waterline query optimization +- Proper HTTP status codes +- API documentation comments +``` + +**Example:** +``` +Create a Sails.js controller for user management with these requirements: +- CRUD operations: Create, read, update, delete, and list users +- Input validation using joi or express-validator +- Password hashing and secure user creation +- Pagination with limit/offset and search functionality +- Role-based access control for admin operations +- Profile picture upload with file validation + +Include: +- RESTful action methods (GET, POST, PUT, DELETE) +- Async/await error handling with try-catch blocks +- Waterline queries with population and associations +- Standardized JSON response format +- JSDoc comments for API documentation +``` + +### 5. Service Layer Implementation + +**Prompt:** +``` +Implement Sails.js services for [business domain] that: +- Encapsulate business logic separate from controllers +- Handle complex data operations and transformations +- Integrate with external APIs and services +- Provide reusable functionality across controllers +- Include proper error handling and logging + +Create services for: +- [Service 1]: [specific functionality] +- [Service 2]: [specific functionality] +- [Service 3]: [specific functionality] + +Include dependency injection and testing strategies. +``` + +### 6. Helper Functions Development + +**Prompt:** +``` +Create Sails.js helper functions for [utility purpose] that: +- Provide reusable utility functions +- Handle common operations like [specific operations] +- Include input validation and error handling +- Support both synchronous and asynchronous operations +- Are well-documented and testable + +Include: +- Helper function definitions with proper inputs/outputs +- Error handling and validation +- Usage examples and documentation +- Unit tests for each helper +- Performance considerations +``` + +--- + +## Model & Database Integration + +### 7. Waterline Model Definition + +**Prompt Template:** +``` +Create Waterline models for [domain/entity] with these requirements: +- Attributes: [list specific attributes and types] +- Associations: [relationships with other models] +- Validations: [validation rules and constraints] +- Lifecycle callbacks: [beforeCreate, afterUpdate, etc.] +- Custom methods: [model-specific functionality] + +Include: +- Proper attribute types and validations +- Association definitions (one-to-one, one-to-many, many-to-many) +- Index definitions for performance +- Custom instance and class methods +- Migration considerations +``` + +**Example:** +``` +Create Waterline models for an e-commerce system with these requirements: +- User model: email, password, profile info, roles +- Product model: name, description, price, inventory, categories +- Order model: user reference, products, status, payment info +- Associations: User has many Orders, Order has many Products (through OrderItems) +- Validations: Email format, price ranges, required fields + +Include: +- Proper attribute types (string, number, boolean, json) +- Association definitions with foreign keys +- Unique indexes on email, SKU fields +- Password hashing in beforeCreate callback +- Custom methods for order calculations and user authentication +``` + +### 8. Database Migration Strategy + +**Prompt:** +``` +Design database migration strategy for Sails.js application with: +- Schema versioning and migration files +- Data migration for existing records +- Rollback procedures and safety measures +- Environment-specific migration handling +- Performance considerations for large datasets + +Include: +- Migration file structure and naming +- Safe migration practices +- Data backup and recovery procedures +- Testing migration scripts +- Production deployment strategy +``` + +### 9. Advanced Waterline Queries + +**Prompt:** +``` +Implement advanced Waterline queries for [specific use case] that: +- Use complex filtering and sorting +- Include population of associations +- Implement aggregation and grouping +- Handle pagination efficiently +- Optimize for performance + +Include: +- Query optimization techniques +- Index usage and performance monitoring +- Error handling for database operations +- Caching strategies for frequently accessed data +- Raw query integration when needed +``` + +--- + +## API Development & Controllers + +### 10. RESTful API Design + +**Prompt Template:** +``` +Design and implement RESTful APIs for [resource] using Sails.js with: +- Standard HTTP methods and status codes +- Consistent request/response formats +- Input validation and sanitization +- Error handling and meaningful error messages +- API versioning strategy +- Documentation and examples + +Include: +- Route definitions and controller actions +- Request/response schemas +- Validation middleware +- Error response standardization +- API documentation with examples +``` + +**Example:** +``` +Design and implement RESTful APIs for blog management using Sails.js with: +- Posts: CRUD operations with author association +- Comments: Nested under posts with moderation +- Categories: Hierarchical structure with parent/child relationships +- Tags: Many-to-many relationship with posts +- Search and filtering capabilities across all resources + +Include: +- Route definitions in config/routes.js +- Controller actions with proper HTTP methods +- JSON schema validation for request bodies +- Standardized error responses with error codes +- OpenAPI/Swagger documentation with examples +``` + +### 11. GraphQL Integration + +**Prompt:** +``` +Integrate GraphQL with Sails.js application for [use case] that: +- Defines GraphQL schema for existing models +- Implements resolvers with Waterline integration +- Handles authentication and authorization +- Supports real-time subscriptions +- Includes query optimization and N+1 prevention + +Include: +- Schema definition and type resolvers +- Authentication middleware for GraphQL +- Subscription setup with Socket.io +- Query complexity analysis and rate limiting +- Integration with existing REST endpoints +``` + +### 12. API Versioning Strategy + +**Prompt:** +``` +Implement API versioning strategy for Sails.js application with: +- Version management approach: [URL path/header/query parameter] +- Backward compatibility maintenance +- Deprecation and sunset policies +- Documentation for multiple versions +- Migration guides for API consumers + +Include: +- Routing configuration for versions +- Controller organization by version +- Shared code and DRY principles +- Version-specific middleware +- Client communication strategy +``` + +--- + +## Authentication & Authorization + +### 13. JWT Authentication System + +**Prompt:** +``` +Implement JWT authentication system for Sails.js with: +- User registration and login endpoints +- JWT token generation and validation +- Refresh token mechanism +- Password reset functionality +- Account verification and activation +- Security best practices + +Include: +- Passport.js integration with JWT strategy +- Secure password hashing with bcrypt +- Token expiration and refresh logic +- Email verification workflow +- Rate limiting for auth endpoints +- Security headers and CORS configuration +``` + +### 14. Role-Based Access Control (RBAC) + +**Prompt:** +``` +Implement RBAC system for Sails.js application with: +- User roles and permissions model +- Policy-based authorization +- Resource-level access control +- Dynamic permission checking +- Admin interface for role management + +Include: +- Role and permission models with associations +- Policy functions for different access levels +- Middleware for route protection +- Helper functions for permission checking +- Admin dashboard for user and role management +``` + +### 15. OAuth2 and Social Authentication + +**Prompt:** +``` +Integrate OAuth2 and social authentication with [providers] using: +- Passport.js strategies for social providers +- Account linking and profile merging +- Secure token storage and management +- User profile synchronization +- Error handling for OAuth failures + +Include: +- Provider configuration and setup +- Callback handling and user creation +- Profile data mapping and validation +- Account conflict resolution +- Security considerations and best practices +``` + +--- + +## Real-time Features with Sockets + +### 16. Socket.io Integration + +**Prompt Template:** +``` +Implement real-time features using Sails.js sockets for [use case] with: +- Socket connection management +- Room-based messaging and broadcasting +- Authentication for socket connections +- Event handling and message routing +- Error handling and reconnection logic + +Include: +- Socket event definitions and handlers +- Room management and user presence +- Message validation and sanitization +- Performance optimization for high concurrency +- Client-side integration examples +``` + +**Example:** +``` +Implement real-time chat system using Sails.js sockets with: +- Multi-room chat with private and public rooms +- User presence indicators and typing notifications +- Message history and persistence +- File sharing and media upload +- Moderation tools and user management + +Include: +- Socket event handlers for join/leave/message +- Room-based broadcasting with user lists +- Message validation and content filtering +- Database integration for message persistence +- React/Vue.js client integration examples +``` + +### 17. Real-time Notifications + +**Prompt:** +``` +Create real-time notification system with: +- Push notifications to connected clients +- Notification persistence and history +- User preference management +- Different notification types and priorities +- Integration with external push services + +Include: +- Notification model and delivery system +- Socket broadcasting to specific users +- Preference-based filtering +- Mobile push notification integration +- Email fallback for offline users +``` + +### 18. Live Data Synchronization + +**Prompt:** +``` +Implement live data synchronization for [data type] that: +- Broadcasts model changes to connected clients +- Handles concurrent updates and conflicts +- Maintains data consistency across clients +- Supports offline/online synchronization +- Includes conflict resolution strategies + +Include: +- Model lifecycle hooks for broadcasting +- Client-side state management +- Optimistic updates and rollback +- Conflict detection and resolution +- Performance optimization for large datasets +``` + +--- + +## Middleware & Policies + +### 19. Custom Middleware Development + +**Prompt:** +``` +Create custom middleware for Sails.js that: +- [Specific middleware functionality] +- Integrates with Sails.js request/response cycle +- Handles errors gracefully +- Is configurable and reusable +- Includes proper logging and monitoring + +Include: +- Middleware function implementation +- Configuration options and defaults +- Error handling and next() calls +- Integration with Sails.js hooks +- Testing and documentation +``` + +### 20. Policy Implementation + +**Prompt:** +``` +Implement Sails.js policies for [authorization scenario] that: +- Check user authentication and authorization +- Validate request parameters and headers +- Implement rate limiting and throttling +- Handle CORS and security headers +- Provide detailed error responses + +Include: +- Policy function definitions +- Integration with controller actions +- Configuration in config/policies.js +- Error handling and response formatting +- Testing strategies for policies +``` + +### 21. Request Validation Middleware + +**Prompt:** +``` +Create request validation middleware using [validation library] that: +- Validates request body, query, and parameters +- Provides detailed validation error messages +- Supports custom validation rules +- Integrates with Sails.js error handling +- Includes sanitization and transformation + +Include: +- Validation schema definitions +- Custom validator functions +- Error message formatting +- Integration with controllers +- Performance optimization +``` + +--- + +## Testing & Quality Assurance + +### 22. Unit Testing Strategy + +**Prompt:** +``` +Create comprehensive unit testing strategy for Sails.js application using [testing framework] with: +- Controller action testing +- Model method and validation testing +- Service function testing +- Helper function testing +- Mock and stub strategies for external dependencies + +Include: +- Test setup and teardown procedures +- Database testing with test fixtures +- Mocking external services and APIs +- Code coverage requirements and reporting +- Continuous integration setup +``` + +### 23. Integration Testing + +**Prompt:** +``` +Implement integration tests for [API endpoints/features] that: +- Test complete request/response cycles +- Validate database interactions +- Test authentication and authorization flows +- Include error scenario testing +- Test real-time socket functionality + +Include: +- Test database setup and cleanup +- API endpoint testing with supertest +- Socket.io testing strategies +- Test data management and fixtures +- Performance and load testing basics +``` + +### 24. API Testing and Documentation + +**Prompt:** +``` +Create API testing suite and documentation for [API endpoints] that: +- Tests all CRUD operations and edge cases +- Validates request/response schemas +- Includes authentication testing +- Generates API documentation +- Supports automated testing in CI/CD + +Include: +- Postman/Insomnia collection setup +- OpenAPI/Swagger documentation +- Automated schema validation +- Test data generation and management +- Documentation hosting and maintenance +``` + +--- + +## Performance & Optimization + +### 25. Database Query Optimization + +**Prompt:** +``` +Optimize database queries for [specific use case] in Sails.js by: +- Analyzing slow queries and bottlenecks +- Implementing proper indexing strategies +- Using query optimization techniques +- Implementing caching layers +- Monitoring query performance + +Include: +- Query analysis and profiling tools +- Index creation and maintenance +- Waterline query optimization +- Redis caching implementation +- Performance monitoring and alerting +``` + +### 26. Caching Implementation + +**Prompt:** +``` +Implement comprehensive caching strategy using [Redis/Memcached] with: +- API response caching +- Database query result caching +- Session and user data caching +- Cache invalidation strategies +- Performance monitoring and metrics + +Include: +- Cache configuration and setup +- Cache key design and naming conventions +- TTL strategies for different data types +- Cache warming and preloading +- Fallback mechanisms for cache failures +``` + +### 27. Application Performance Monitoring + +**Prompt:** +``` +Set up application performance monitoring for Sails.js with: +- Request/response time tracking +- Database query performance monitoring +- Memory and CPU usage tracking +- Error rate and exception monitoring +- Custom business metrics tracking + +Include: +- APM tool integration (New Relic, DataDog, etc.) +- Custom middleware for performance tracking +- Alerting and notification setup +- Performance dashboard creation +- Optimization recommendations based on metrics +``` + +--- + +## Deployment & DevOps + +### 28. Docker Configuration + +**Prompt:** +``` +Create Docker configuration for Sails.js application with: +- Multi-stage build for optimization +- Development and production environments +- Database and Redis service integration +- Environment variable management +- Health checks and monitoring + +Include: +- Dockerfile with best practices +- Docker Compose for local development +- Production-ready container configuration +- Security considerations and non-root user +- Volume management for persistent data +``` + +### 29. CI/CD Pipeline + +**Prompt:** +``` +Set up CI/CD pipeline for Sails.js application using [GitHub Actions/GitLab CI/Jenkins] with: +- Automated testing on multiple Node.js versions +- Code quality checks and linting +- Security vulnerability scanning +- Automated deployment to [cloud provider] +- Database migration handling + +Include: +- Pipeline configuration files +- Test automation and reporting +- Deployment strategies (blue-green, rolling) +- Environment-specific configurations +- Rollback procedures and monitoring +``` + +### 30. Cloud Deployment + +**Prompt:** +``` +Deploy Sails.js application to [AWS/GCP/Azure/Heroku] with: +- Container orchestration or serverless deployment +- Database setup and connection management +- Load balancing and auto-scaling +- Environment variable and secrets management +- Monitoring and logging setup + +Include: +- Infrastructure as code (Terraform/CloudFormation) +- Database migration and backup strategies +- SSL/TLS certificate management +- CDN setup for static assets +- Cost optimization strategies +``` + +--- + +## Advanced Patterns + +### 31. Microservices Architecture + +**Prompt:** +``` +Design microservices architecture using Sails.js with: +- Service decomposition strategy +- Inter-service communication patterns +- Data consistency and transaction management +- Service discovery and load balancing +- Monitoring and observability + +Include: +- Service boundary definitions +- API gateway configuration +- Event-driven communication +- Distributed tracing setup +- Fault tolerance and circuit breakers +``` + +### 32. Event-Driven Architecture + +**Prompt:** +``` +Implement event-driven architecture with: +- Event sourcing and CQRS patterns +- Message queue integration (RabbitMQ/Apache Kafka) +- Event handlers and processors +- Saga pattern for distributed transactions +- Event replay and recovery mechanisms + +Include: +- Event schema design +- Message broker configuration +- Event handler implementation +- Error handling and dead letter queues +- Monitoring and alerting for events +``` + +### 33. API Gateway Integration + +**Prompt:** +``` +Integrate Sails.js application with API Gateway for: +- Request routing and load balancing +- Authentication and authorization +- Rate limiting and throttling +- Request/response transformation +- Monitoring and analytics + +Include: +- Gateway configuration and setup +- Service registration and discovery +- Security policy implementation +- Performance optimization +- Monitoring and logging integration +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Follow Node.js best practices** - Use async/await, proper error handling, and security measures +2. **Leverage Sails.js conventions** - Follow MVC patterns and use built-in features +3. **Include comprehensive testing** - Unit, integration, and API testing +4. **Implement proper security** - Authentication, authorization, input validation, and HTTPS +5. **Optimize for performance** - Database queries, caching, and monitoring +6. **Document thoroughly** - API documentation, code comments, and deployment guides +7. **Plan for scalability** - Database design, caching strategies, and load balancing + +## Example Workflow + +``` +1. Start with Project Setup prompts for architecture +2. Use Model & Database prompts for data layer +3. Implement APIs using Controller Development prompts +4. Add Authentication & Authorization +5. Implement real-time features with Socket prompts +6. Add middleware and policies for security +7. Ensure quality with Testing prompts +8. Optimize with Performance prompts +9. Deploy using DevOps prompts +``` + +## Sails.js-Specific Tips + +- **Use Waterline ORM effectively** - Leverage associations and lifecycle callbacks +- **Implement proper policies** - Use Sails.js policy system for authorization +- **Leverage built-in features** - Use Sails.js blueprints, hooks, and helpers +- **Follow conventions** - Use Sails.js naming conventions and directory structure +- **Optimize for real-time** - Use Socket.io integration for live features +- **Monitor performance** - Use Sails.js built-in logging and monitoring capabilities + +--- + +*This guide is designed to help Node.js backend engineers build robust, scalable applications using Sails.js framework. Customize the prompts based on your specific project requirements and infrastructure needs.* \ No newline at end of file diff --git a/product-manager-prompts.md b/product-manager-prompts.md new file mode 100644 index 0000000..d4f386b --- /dev/null +++ b/product-manager-prompts.md @@ -0,0 +1,737 @@ +# Product Manager Prompts Guide + +A comprehensive collection of AI prompts specifically designed for Product Managers to accelerate product development, create prototypes, conduct research, and make data-driven decisions. + +## Table of Contents +1. [Prototype Development](#prototype-development) +2. [User Research & Analysis](#user-research--analysis) +3. [Feature Planning & Prioritization](#feature-planning--prioritization) +4. [Market Research & Competitive Analysis](#market-research--competitive-analysis) +5. [Product Strategy & Roadmapping](#product-strategy--roadmapping) +6. [Stakeholder Communication](#stakeholder-communication) +7. [Data Analysis & Metrics](#data-analysis--metrics) +8. [User Experience & Design](#user-experience--design) +9. [Go-to-Market Strategy](#go-to-market-strategy) +10. [Product Documentation](#product-documentation) + +--- + +## Prototype Development + +### 1. Interactive Prototype Creation + +**Prompt Template:** +``` +You are an expert product designer. Create a detailed interactive prototype for [product/feature] with these requirements: +- Target users: [user personas] +- Core functionality: [list key features] +- Platform: [web/mobile/desktop] +- Design constraints: [technical or business limitations] + +Include: +- User flow diagrams +- Wireframes for key screens +- Interactive elements and transitions +- Technical implementation notes +- User testing scenarios +``` + +**Example:** +``` +You are an expert product designer. Create a detailed interactive prototype for a task management mobile app with these requirements: +- Target users: Remote workers and small team leads +- Core functionality: Task creation, assignment, progress tracking, team collaboration +- Platform: Mobile-first (iOS/Android) with web companion +- Design constraints: Must work offline, simple onboarding process + +Include: +- User flow diagrams for task creation and team collaboration +- Wireframes for dashboard, task detail, and team views +- Interactive elements like swipe gestures and notifications +- Technical implementation notes for offline sync +- User testing scenarios for different user types +``` + +### 2. MVP Prototype Definition + +**Prompt:** +``` +Define an MVP prototype for [product concept] that: +- Validates core hypothesis: [main assumption to test] +- Serves target market: [specific user segment] +- Delivers essential value: [primary benefit] +- Can be built in [timeframe] with [resource constraints] + +Create: +- Feature prioritization matrix +- User story mapping +- Technical architecture overview +- Success metrics and KPIs +- Risk assessment and mitigation strategies +``` + +### 3. Rapid Prototyping Framework + +**Prompt:** +``` +Create a rapid prototyping framework for [product category] that includes: +- Design system components +- Reusable UI patterns +- User interaction templates +- Data flow structures +- Testing methodologies + +Focus on speed and iteration while maintaining quality standards. +``` + +--- + +## User Research & Analysis + +### 4. User Persona Development + +**Prompt Template:** +``` +Create detailed user personas for [product/service] based on: +- Market research data: [available data sources] +- User interviews: [key insights] +- Behavioral patterns: [observed behaviors] +- Pain points: [identified problems] + +For each persona, include: +- Demographics and psychographics +- Goals and motivations +- Frustrations and pain points +- Technology usage patterns +- Preferred communication channels +- Decision-making process +``` + +**Example:** +``` +Create detailed user personas for a financial planning app based on: +- Market research data: Millennials struggle with retirement planning +- User interviews: 50 interviews with ages 25-40 +- Behavioral patterns: Mobile-first, prefer visual data representation +- Pain points: Complex financial jargon, lack of personalized advice + +For each persona, include: +- Demographics (age, income, education, location) +- Financial goals and current challenges +- Technology comfort level and app usage +- Preferred learning styles and communication +- Decision-making triggers for financial products +``` + +### 5. User Journey Mapping + +**Prompt:** +``` +Create a comprehensive user journey map for [specific user goal] including: +- Pre-awareness stage +- Discovery and research phase +- Evaluation and decision-making +- Onboarding and first use +- Regular usage patterns +- Advanced feature adoption +- Potential churn points + +For each stage, identify: +- User emotions and motivations +- Touchpoints and interactions +- Pain points and friction +- Opportunities for improvement +- Success metrics +``` + +### 6. User Interview Guide Creation + +**Prompt:** +``` +Create a user interview guide for [research objective] that: +- Uncovers [specific insights needed] +- Avoids leading questions +- Encourages storytelling +- Explores emotional responses +- Validates or challenges assumptions: [list assumptions] + +Include: +- Opening questions to build rapport +- Core questions organized by theme +- Follow-up probes for deeper insights +- Scenario-based questions +- Closing questions for additional feedback +``` + +--- + +## Feature Planning & Prioritization + +### 7. Feature Prioritization Framework + +**Prompt:** +``` +Create a feature prioritization framework for [product] considering: +- Business impact: [revenue, growth, retention metrics] +- User value: [user satisfaction, engagement, adoption] +- Technical complexity: [development effort, dependencies] +- Strategic alignment: [company goals, market positioning] + +Include: +- Scoring methodology +- Weighting criteria +- Decision matrix template +- Stakeholder input process +- Regular review schedule +``` + +### 8. User Story Creation + +**Prompt Template:** +``` +Write comprehensive user stories for [feature/epic] that include: +- User persona: [specific user type] +- Goal: [what they want to accomplish] +- Motivation: [why it's important] +- Acceptance criteria: [definition of done] +- Edge cases and error scenarios +- Dependencies and assumptions + +Format: As a [user type], I want [goal] so that [benefit/motivation]. +``` + +**Example:** +``` +Write comprehensive user stories for a social sharing feature that include: +- User persona: Content creators and casual users +- Goal: Share achievements and progress with friends +- Motivation: Social validation and community building +- Acceptance criteria: Share to multiple platforms, privacy controls +- Edge cases: Network failures, privacy violations, spam prevention +- Dependencies: Social platform APIs, user authentication + +Format: As a [user type], I want [goal] so that [benefit/motivation]. +``` + +### 9. Feature Impact Assessment + +**Prompt:** +``` +Assess the impact of implementing [feature] by analyzing: +- User adoption potential +- Revenue impact (direct and indirect) +- Development and maintenance costs +- Competitive advantage +- Risk factors and mitigation strategies +- Success metrics and measurement plan + +Provide recommendation with supporting rationale. +``` + +--- + +## Market Research & Competitive Analysis + +### 10. Competitive Analysis Framework + +**Prompt:** +``` +Conduct comprehensive competitive analysis for [product category] including: +- Direct competitors: [list known competitors] +- Indirect competitors: [alternative solutions] +- Emerging threats: [new market entrants] + +For each competitor, analyze: +- Product features and capabilities +- Pricing strategy and business model +- Target market and positioning +- Strengths and weaknesses +- Market share and growth trends +- User reviews and feedback patterns + +Identify opportunities for differentiation. +``` + +### 11. Market Opportunity Assessment + +**Prompt:** +``` +Assess market opportunity for [product/feature] by analyzing: +- Total Addressable Market (TAM) +- Serviceable Addressable Market (SAM) +- Serviceable Obtainable Market (SOM) +- Market trends and growth drivers +- Regulatory environment +- Technology enablers and barriers + +Include market sizing methodology and assumptions. +``` + +### 12. SWOT Analysis + +**Prompt:** +``` +Perform SWOT analysis for [product/company] in context of [specific market/opportunity]: + +Strengths: +- Internal capabilities and advantages +- Unique value propositions +- Resource advantages + +Weaknesses: +- Internal limitations and gaps +- Areas for improvement +- Resource constraints + +Opportunities: +- Market trends and openings +- Unmet customer needs +- Technology developments + +Threats: +- Competitive pressures +- Market risks +- External challenges + +Provide strategic recommendations based on analysis. +``` + +--- + +## Product Strategy & Roadmapping + +### 13. Product Vision Creation + +**Prompt:** +``` +Create a compelling product vision for [product] that: +- Articulates long-term aspirations +- Aligns with company mission and values +- Resonates with target users +- Differentiates from competitors +- Inspires the development team + +Include: +- Vision statement (1-2 sentences) +- Supporting narrative +- Success visualization +- Key principles and values +- Stakeholder alignment strategy +``` + +### 14. Product Roadmap Development + +**Prompt Template:** +``` +Develop a [timeframe] product roadmap for [product] that includes: +- Strategic themes and initiatives +- Major feature releases +- Technical infrastructure improvements +- Market expansion opportunities +- Resource allocation and dependencies + +Organize by: +- Now (current quarter): [immediate priorities] +- Next (following quarter): [planned features] +- Later (future quarters): [strategic initiatives] + +Include success metrics and review checkpoints. +``` + +**Example:** +``` +Develop a 12-month product roadmap for an e-commerce platform that includes: +- Strategic themes: Mobile optimization, AI personalization, international expansion +- Major feature releases: Advanced search, social commerce, subscription services +- Technical infrastructure: Performance improvements, security enhancements +- Market expansion: European market entry, B2B marketplace + +Organize by: +- Now (Q1): Mobile app redesign, payment system upgrade +- Next (Q2): AI recommendation engine, social sharing features +- Later (Q3-Q4): International localization, B2B portal launch + +Include conversion rate, user engagement, and revenue growth metrics. +``` + +### 15. OKR (Objectives and Key Results) Setting + +**Prompt:** +``` +Create OKRs for [product/team] for [time period] that: +- Align with company strategic goals +- Are ambitious yet achievable +- Include measurable key results +- Focus on outcomes over outputs + +Structure: +Objective: [Qualitative goal statement] +Key Results: +- KR1: [Specific, measurable outcome] +- KR2: [Specific, measurable outcome] +- KR3: [Specific, measurable outcome] + +Include tracking methodology and review schedule. +``` + +--- + +## Stakeholder Communication + +### 16. Executive Summary Creation + +**Prompt:** +``` +Create an executive summary for [project/initiative] that: +- Communicates key points in 1-2 pages +- Addresses executive concerns and priorities +- Includes clear recommendations +- Supports decision-making + +Structure: +- Problem statement and opportunity +- Proposed solution and approach +- Expected outcomes and benefits +- Resource requirements and timeline +- Risks and mitigation strategies +- Next steps and decision points +``` + +### 17. Stakeholder Alignment Strategy + +**Prompt:** +``` +Develop stakeholder alignment strategy for [initiative] considering: +- Key stakeholders: [list stakeholders and their interests] +- Potential conflicts and concerns +- Communication preferences and channels +- Decision-making authority and influence +- Success criteria from each perspective + +Create: +- Stakeholder mapping and analysis +- Communication plan and timeline +- Influence and engagement strategies +- Conflict resolution approaches +``` + +### 18. Product Update Communication + +**Prompt:** +``` +Create product update communication for [audience] covering: +- Recent achievements and milestones +- Key metrics and performance indicators +- Upcoming features and improvements +- User feedback and testimonials +- Market developments and competitive updates + +Tailor message for: +- Internal teams (detailed, tactical) +- Executive leadership (strategic, high-level) +- External customers (benefit-focused, engaging) +- Investors (growth-focused, data-driven) +``` + +--- + +## Data Analysis & Metrics + +### 19. Metrics Framework Development + +**Prompt:** +``` +Develop comprehensive metrics framework for [product/feature] including: + +Primary Metrics (North Star): +- [Key business metric that drives growth] + +Secondary Metrics: +- User engagement indicators +- Business performance measures +- Product quality metrics + +Counter Metrics: +- Metrics to prevent gaming or negative outcomes + +Include: +- Measurement methodology +- Data collection requirements +- Reporting frequency and format +- Action triggers and thresholds +``` + +### 20. A/B Test Design + +**Prompt:** +``` +Design A/B test for [hypothesis] with: +- Null and alternative hypotheses +- Target audience and segmentation +- Test variations and control group +- Primary and secondary metrics +- Sample size and duration calculations +- Success criteria and statistical significance + +Include: +- Test implementation plan +- Data collection methodology +- Analysis framework +- Decision-making criteria +``` + +### 21. Data-Driven Decision Framework + +**Prompt:** +``` +Create framework for data-driven decision making that: +- Defines types of decisions requiring data +- Establishes data quality standards +- Outlines analysis methodologies +- Includes bias recognition and mitigation +- Balances quantitative and qualitative insights + +Include templates for: +- Decision documentation +- Data analysis reports +- Recommendation presentations +- Post-decision reviews +``` + +--- + +## User Experience & Design + +### 22. UX Research Planning + +**Prompt:** +``` +Plan UX research study for [research question] that: +- Defines research objectives and hypotheses +- Selects appropriate research methods +- Identifies target participants and recruitment strategy +- Outlines data collection and analysis approach +- Establishes timeline and resource requirements + +Include: +- Research protocol and scripts +- Participant screening criteria +- Data analysis framework +- Reporting and presentation plan +``` + +### 23. Design System Requirements + +**Prompt:** +``` +Define requirements for design system that: +- Ensures consistency across [product/platform] +- Supports [team size] designers and developers +- Accommodates [accessibility/internationalization] needs +- Scales with product growth + +Include: +- Component library specifications +- Design token definitions +- Documentation requirements +- Governance and maintenance processes +- Implementation guidelines +``` + +### 24. Accessibility Assessment + +**Prompt:** +``` +Assess accessibility of [product/feature] against: +- WCAG 2.1 guidelines (AA level) +- Platform-specific accessibility standards +- User needs for different disabilities +- Assistive technology compatibility + +Provide: +- Current state assessment +- Gap analysis and prioritization +- Implementation recommendations +- Testing and validation approach +- Ongoing compliance strategy +``` + +--- + +## Go-to-Market Strategy + +### 25. Launch Strategy Development + +**Prompt:** +``` +Develop go-to-market strategy for [product/feature] including: +- Target market segmentation and positioning +- Value proposition and messaging +- Pricing strategy and business model +- Distribution channels and partnerships +- Marketing and promotion tactics +- Sales enablement and support + +Create: +- Launch timeline and milestones +- Success metrics and KPIs +- Risk assessment and contingency plans +- Post-launch optimization strategy +``` + +### 26. Pricing Strategy Framework + +**Prompt:** +``` +Develop pricing strategy for [product] considering: +- Cost structure and margin requirements +- Competitive pricing landscape +- Customer willingness to pay +- Value-based pricing opportunities +- Market penetration vs. skimming strategies + +Include: +- Pricing model recommendations +- Tier structure and feature differentiation +- Promotional pricing strategies +- Price testing and optimization plan +- Revenue impact projections +``` + +### 27. Customer Acquisition Strategy + +**Prompt:** +``` +Create customer acquisition strategy for [product] that: +- Identifies high-value customer segments +- Maps customer acquisition channels +- Defines acquisition cost targets +- Outlines conversion optimization approach +- Includes retention and expansion strategies + +Analyze: +- Channel effectiveness and ROI +- Customer lifetime value (CLV) +- Acquisition cost (CAC) by channel +- Conversion funnel optimization +- Referral and viral growth opportunities +``` + +--- + +## Product Documentation + +### 28. Product Requirements Document (PRD) + +**Prompt Template:** +``` +Create comprehensive PRD for [feature/product] including: + +1. Overview and Objectives + - Problem statement and user needs + - Success criteria and metrics + - Assumptions and constraints + +2. User Experience + - User flows and scenarios + - Functional requirements + - Non-functional requirements + +3. Technical Specifications + - Architecture and dependencies + - Integration requirements + - Performance and scalability needs + +4. Implementation Plan + - Development phases and timeline + - Resource requirements + - Risk assessment and mitigation + +5. Success Measurement + - Key metrics and KPIs + - Testing and validation approach + - Launch and rollout strategy +``` + +### 29. Release Notes Creation + +**Prompt:** +``` +Create user-friendly release notes for [version/update] that: +- Highlight new features and improvements +- Explain benefits in user terms +- Address known issues and fixes +- Provide migration or setup guidance +- Include visual aids and examples + +Structure for different audiences: +- End users: Benefit-focused, simple language +- Technical users: Detailed specifications +- Internal teams: Implementation details and dependencies +``` + +### 30. Product Knowledge Base + +**Prompt:** +``` +Develop product knowledge base structure for [product] that: +- Organizes information by user journey +- Includes searchable content categories +- Provides multiple content formats +- Supports self-service and support teams + +Include: +- Information architecture +- Content creation guidelines +- Maintenance and update processes +- User feedback integration +- Performance measurement approach +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Always include user context** - Specify target users and their needs +2. **Define success metrics** - Include measurable outcomes and KPIs +3. **Consider constraints** - Mention technical, business, and resource limitations +4. **Include stakeholder perspectives** - Address different viewpoints and concerns +5. **Plan for iteration** - Build in feedback loops and optimization opportunities +6. **Document assumptions** - Make underlying assumptions explicit +7. **Think strategically** - Connect tactical decisions to broader business goals + +## Example Workflow for Product Managers + +``` +1. Start with User Research prompts to understand needs +2. Use Market Research prompts to assess opportunities +3. Apply Feature Planning prompts to prioritize development +4. Create prototypes using Prototype Development prompts +5. Develop strategy using Product Strategy prompts +6. Plan launch using Go-to-Market prompts +7. Measure success using Data Analysis prompts +8. Communicate results using Stakeholder Communication prompts +``` + +## Integration with Development Teams + +### Collaboration with Engineers +- Use technical requirement prompts when working with backend/frontend teams +- Include implementation feasibility in feature planning +- Align on technical architecture and constraints + +### Working with Designers +- Collaborate on UX research and design system requirements +- Ensure accessibility and usability standards +- Balance user needs with technical constraints + +### Stakeholder Management +- Use executive communication prompts for leadership updates +- Apply data analysis prompts for evidence-based decisions +- Leverage competitive analysis for strategic positioning + +--- + +*This guide is designed to help Product Managers work more efficiently with AI assistants across all aspects of product development. Customize the prompts based on your specific product, market, and organizational context.* \ No newline at end of file diff --git a/rust-backend-engineer-prompts.md b/rust-backend-engineer-prompts.md new file mode 100644 index 0000000..8b69c81 --- /dev/null +++ b/rust-backend-engineer-prompts.md @@ -0,0 +1,638 @@ +# Rust Backend Engineer Prompts Guide (RIG + Actix-web) + +A comprehensive collection of AI prompts specifically designed for Rust backend engineers working with RIG (Rust Intelligence Gateway) and Actix-web to build robust, performant, and secure backend systems. + +## Table of Contents +1. [Project Setup & Architecture](#project-setup--architecture) +2. [Actix-web Server Development](#actix-web-server-development) +3. [RIG Integration & AI Features](#rig-integration--ai-features) +4. [Database Integration](#database-integration) +5. [Authentication & Authorization](#authentication--authorization) +6. [API Development](#api-development) +7. [Error Handling & Logging](#error-handling--logging) +8. [Testing & Quality Assurance](#testing--quality-assurance) +9. [Performance & Optimization](#performance--optimization) +10. [Deployment & DevOps](#deployment--devops) + +--- + +## Project Setup & Architecture + +### 1. New Rust Backend Project Setup + +**Prompt Template:** +``` +You are an expert Rust backend developer. Set up a new Rust project with these requirements: +- Use Actix-web as the web framework +- Integrate RIG for AI capabilities +- Include [database type] for data persistence +- Set up [authentication method] +- Configure logging and error handling +- Include Docker configuration +- Set up proper project structure with modules + +Create the Cargo.toml, main.rs, and necessary module files with proper dependencies and versions. +``` + +**Example:** +``` +You are an expert Rust backend developer. Set up a new Rust project with these requirements: +- Use Actix-web 4.x as the web framework +- Integrate RIG for LLM integration capabilities +- Include PostgreSQL with SQLx for data persistence +- Set up JWT-based authentication +- Configure structured logging with tracing +- Include Docker configuration for containerization +- Set up proper project structure with modules for handlers, models, services + +Create the Cargo.toml, main.rs, and necessary module files with proper dependencies and versions. +``` + +### 2. Modular Architecture Setup + +**Prompt:** +``` +Design a modular Rust backend architecture for [application type] with: +- Clean separation of concerns (handlers, services, repositories) +- Dependency injection pattern +- Configuration management +- Error handling strategy +- Middleware organization +- Module structure for scalability + +Include file structure and module declarations. +``` + +--- + +## Actix-web Server Development + +### 3. Basic Actix-web Server + +**Prompt Template:** +``` +Create an Actix-web server with these features: +- [Feature 1] +- [Feature 2] +- [Feature 3] +- CORS configuration +- Request/response logging middleware +- Health check endpoint +- Graceful shutdown handling + +Include proper error handling and configuration management. +``` + +**Example:** +``` +Create an Actix-web server with these features: +- RESTful API endpoints for user management +- File upload capabilities with size limits +- Rate limiting middleware +- CORS configuration for frontend integration +- Request/response logging middleware +- Health check endpoint at /health +- Graceful shutdown handling + +Include proper error handling and configuration management. +``` + +### 4. Custom Middleware Development + +**Prompt:** +``` +Create custom Actix-web middleware for [purpose] that: +- [Functionality 1] +- [Functionality 2] +- [Functionality 3] +- Handles errors gracefully +- Includes proper logging +- Is configurable and reusable + +Include unit tests and documentation. +``` + +### 5. Request/Response Handling + +**Prompt:** +``` +Implement Actix-web handlers for [endpoint purpose] with: +- Input validation using serde and validator +- Proper HTTP status codes +- Error response formatting +- Request/response DTOs +- Async processing where appropriate +- Documentation with examples + +Include both success and error scenarios. +``` + +--- + +## RIG Integration & AI Features + +### 6. RIG Setup and Configuration + +**Prompt:** +``` +Set up RIG (Rust Intelligence Gateway) in an Actix-web application with: +- [LLM provider] integration (OpenAI/Anthropic/local models) +- Configuration for API keys and endpoints +- Error handling for AI service failures +- Rate limiting for AI requests +- Caching for repeated queries +- Proper async handling + +Include environment configuration and fallback strategies. +``` + +### 7. AI-Powered API Endpoints + +**Prompt Template:** +``` +Create an AI-powered endpoint using RIG that: +- Accepts [input type] from users +- Processes data through [AI model/provider] +- Returns [output format] +- Handles streaming responses if applicable +- Includes proper error handling +- Implements request validation and sanitization + +Use RIG's built-in features for [specific functionality]. +``` + +**Example:** +``` +Create an AI-powered endpoint using RIG that: +- Accepts text documents from users via POST /api/analyze +- Processes content through OpenAI GPT-4 for sentiment analysis +- Returns structured JSON with sentiment scores and key insights +- Handles streaming responses for real-time feedback +- Includes proper error handling for API failures +- Implements request validation and content sanitization + +Use RIG's built-in features for prompt templating and response parsing. +``` + +### 8. RAG (Retrieval-Augmented Generation) Implementation + +**Prompt:** +``` +Implement a RAG system using RIG with: +- Vector database integration ([Qdrant/Pinecone/Weaviate]) +- Document embedding and indexing +- Similarity search functionality +- Context retrieval and augmentation +- LLM integration for generation +- Caching strategies for performance + +Include endpoints for document upload, indexing, and querying. +``` + +--- + +## Database Integration + +### 9. SQLx Database Setup + +**Prompt:** +``` +Set up SQLx with [database type] for a Rust backend with: +- Connection pool configuration +- Migration system setup +- Model definitions with proper types +- Repository pattern implementation +- Transaction handling +- Error handling for database operations + +Include CRUD operations for [entity type]. +``` + +### 10. Database Models and Migrations + +**Prompt:** +``` +Create SQLx models and migrations for [domain] with: +- Proper table relationships (foreign keys, indexes) +- Data validation constraints +- Timestamp fields (created_at, updated_at) +- Soft delete functionality if needed +- Migration files for schema changes + +Include both up and down migrations. +``` + +### 11. Repository Pattern Implementation + +**Prompt:** +``` +Implement the repository pattern for [entity] with: +- Trait definition for repository interface +- SQLx implementation with connection pool +- CRUD operations with proper error handling +- Query optimization and indexing +- Pagination support +- Transaction support for complex operations + +Include unit tests with mock implementations. +``` + +--- + +## Authentication & Authorization + +### 12. JWT Authentication System + +**Prompt:** +``` +Implement JWT authentication for Actix-web with: +- User registration and login endpoints +- JWT token generation and validation +- Refresh token mechanism +- Password hashing with bcrypt/argon2 +- Middleware for protected routes +- Role-based access control (RBAC) + +Include proper error handling and security best practices. +``` + +### 13. OAuth2 Integration + +**Prompt:** +``` +Integrate OAuth2 authentication with [provider] using: +- OAuth2 flow implementation +- State parameter for CSRF protection +- Token exchange and validation +- User profile retrieval +- Account linking functionality +- Session management + +Include error handling for OAuth failures. +``` + +### 14. Authorization Middleware + +**Prompt:** +``` +Create authorization middleware that: +- Validates JWT tokens +- Extracts user claims and roles +- Implements permission checking +- Handles token expiration gracefully +- Supports role-based and resource-based permissions +- Includes audit logging + +Integrate with Actix-web's middleware system. +``` + +--- + +## API Development + +### 15. RESTful API Design + +**Prompt Template:** +``` +Design and implement RESTful APIs for [resource] with: +- Standard HTTP methods (GET, POST, PUT, DELETE) +- Proper status codes and error responses +- Input validation and sanitization +- Pagination for list endpoints +- Filtering and sorting capabilities +- API versioning strategy + +Include OpenAPI/Swagger documentation. +``` + +**Example:** +``` +Design and implement RESTful APIs for blog posts with: +- Standard HTTP methods (GET, POST, PUT, DELETE) +- Proper status codes and error responses +- Input validation using serde and validator +- Pagination for list endpoints with cursor-based pagination +- Filtering by author, tags, and date ranges +- API versioning strategy using URL prefixes + +Include OpenAPI/Swagger documentation with examples. +``` + +### 16. GraphQL API Implementation + +**Prompt:** +``` +Implement a GraphQL API using async-graphql with: +- Schema definition for [domain models] +- Query and mutation resolvers +- Subscription support for real-time updates +- Authentication and authorization integration +- Error handling and validation +- Performance optimization (N+1 problem prevention) + +Include integration with Actix-web. +``` + +### 17. WebSocket Implementation + +**Prompt:** +``` +Implement WebSocket functionality for [real-time feature] with: +- Connection management and authentication +- Message broadcasting and routing +- Room/channel management +- Heartbeat and reconnection handling +- Rate limiting and abuse prevention +- Integration with existing REST API + +Use Actix-web's WebSocket support. +``` + +--- + +## Error Handling & Logging + +### 18. Comprehensive Error Handling + +**Prompt:** +``` +Implement a comprehensive error handling system with: +- Custom error types for different error categories +- Error conversion and propagation +- User-friendly error responses +- Internal error logging with context +- Error codes for client identification +- Recovery strategies where possible + +Include integration with Actix-web's error handling. +``` + +### 19. Structured Logging Setup + +**Prompt:** +``` +Set up structured logging using tracing with: +- Different log levels for various components +- Request tracing and correlation IDs +- Performance metrics logging +- Error tracking and alerting +- Log formatting for different environments +- Integration with external logging services + +Include configuration for development and production. +``` + +### 20. Monitoring and Observability + +**Prompt:** +``` +Implement monitoring and observability with: +- Prometheus metrics collection +- Health check endpoints with detailed status +- Performance monitoring and profiling +- Distributed tracing setup +- Custom metrics for business logic +- Alerting configuration + +Include dashboard configuration examples. +``` + +--- + +## Testing & Quality Assurance + +### 21. Unit Testing Strategy + +**Prompt:** +``` +Create comprehensive unit tests for [component] with: +- Test fixtures and mock data +- Database testing with test containers +- HTTP client testing with mock servers +- Error scenario testing +- Performance benchmarks +- Property-based testing where applicable + +Use tokio-test and mockall for async testing. +``` + +### 22. Integration Testing + +**Prompt:** +``` +Implement integration tests for [API endpoints] with: +- Test database setup and cleanup +- Full request/response cycle testing +- Authentication flow testing +- Error handling verification +- Performance testing under load +- Test data management + +Include CI/CD pipeline integration. +``` + +### 23. Load Testing + +**Prompt:** +``` +Create load testing scenarios for [application] using: +- Realistic user behavior simulation +- Gradual load increase patterns +- Database connection pool testing +- Memory and CPU usage monitoring +- Bottleneck identification +- Performance regression detection + +Include test scripts and result analysis. +``` + +--- + +## Performance & Optimization + +### 24. Database Query Optimization + +**Prompt:** +``` +Optimize database queries for [specific use case] by: +- Analyzing query execution plans +- Adding appropriate indexes +- Implementing query result caching +- Using connection pooling effectively +- Optimizing N+1 query problems +- Implementing read replicas if needed + +Include before/after performance metrics. +``` + +### 25. Caching Implementation + +**Prompt:** +``` +Implement caching strategy using [Redis/in-memory] with: +- Cache key design and naming conventions +- TTL strategies for different data types +- Cache invalidation patterns +- Cache warming strategies +- Fallback mechanisms for cache failures +- Performance monitoring and metrics + +Include integration with existing API endpoints. +``` + +### 26. Async Processing and Queues + +**Prompt:** +``` +Implement background job processing with: +- Job queue system ([Redis/RabbitMQ/database]) +- Worker process management +- Job retry and failure handling +- Priority queue implementation +- Job status tracking and monitoring +- Graceful shutdown handling + +Include examples for common background tasks. +``` + +--- + +## Deployment & DevOps + +### 27. Docker Configuration + +**Prompt:** +``` +Create Docker configuration for Rust backend with: +- Multi-stage build for optimization +- Security best practices (non-root user) +- Health check configuration +- Environment variable management +- Volume mounting for persistent data +- Docker Compose for local development + +Include both development and production configurations. +``` + +### 28. CI/CD Pipeline + +**Prompt:** +``` +Set up CI/CD pipeline for Rust backend using [GitHub Actions/GitLab CI] with: +- Automated testing on multiple Rust versions +- Code quality checks (clippy, fmt) +- Security vulnerability scanning +- Docker image building and pushing +- Automated deployment to [cloud provider] +- Rollback strategies + +Include environment-specific configurations. +``` + +### 29. Cloud Deployment + +**Prompt:** +``` +Deploy Rust backend to [AWS/GCP/Azure] with: +- Container orchestration ([Kubernetes/ECS]) +- Load balancer configuration +- Database setup and connection +- Environment variable management +- Logging and monitoring setup +- Auto-scaling configuration + +Include infrastructure as code (Terraform/CloudFormation). +``` + +--- + +## Advanced Patterns + +### 30. Event-Driven Architecture + +**Prompt:** +``` +Implement event-driven architecture with: +- Event sourcing pattern +- CQRS (Command Query Responsibility Segregation) +- Event store implementation +- Event handlers and processors +- Saga pattern for distributed transactions +- Event replay and recovery mechanisms + +Include integration with message brokers. +``` + +### 31. Microservices Communication + +**Prompt:** +``` +Implement microservices communication with: +- Service discovery mechanism +- Circuit breaker pattern +- Retry policies with exponential backoff +- Request/response correlation +- Distributed tracing +- API gateway integration + +Include error handling and fallback strategies. +``` + +### 32. Security Hardening + +**Prompt:** +``` +Implement security hardening measures with: +- Input validation and sanitization +- SQL injection prevention +- XSS protection +- CSRF protection +- Rate limiting and DDoS protection +- Security headers configuration +- Dependency vulnerability scanning + +Include security testing and audit procedures. +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Specify Rust edition** - Use latest stable Rust features +2. **Include error handling** - Rust's Result type and proper error propagation +3. **Memory safety** - Leverage Rust's ownership system +4. **Async/await** - Use tokio for async operations +5. **Testing** - Include unit and integration tests +6. **Documentation** - Add rustdoc comments +7. **Performance** - Consider zero-cost abstractions +8. **Security** - Follow Rust security best practices + +## Example Workflow + +``` +1. Start with Project Setup prompts for architecture +2. Use Actix-web prompts for server implementation +3. Integrate RIG for AI capabilities +4. Add Database Integration for persistence +5. Implement Authentication & Authorization +6. Build APIs using API Development prompts +7. Add comprehensive Error Handling & Logging +8. Ensure quality with Testing prompts +9. Optimize with Performance prompts +10. Deploy using DevOps prompts +``` + +## RIG-Specific Tips + +- **Model Selection**: Choose appropriate LLM providers based on use case +- **Prompt Engineering**: Use RIG's prompt templating for consistency +- **Error Handling**: Implement fallbacks for AI service failures +- **Caching**: Cache AI responses to reduce costs and latency +- **Monitoring**: Track AI usage and performance metrics +- **Security**: Sanitize inputs before sending to AI models + +--- + +*This guide is designed to help Rust backend engineers build robust, scalable, and AI-powered applications using RIG and Actix-web. Customize the prompts based on your specific project requirements and infrastructure.* \ No newline at end of file diff --git a/test-engineer-pytest-prompts.md b/test-engineer-pytest-prompts.md new file mode 100644 index 0000000..9124b44 --- /dev/null +++ b/test-engineer-pytest-prompts.md @@ -0,0 +1,849 @@ +# Test Engineer Pytest Prompts Guide + +A comprehensive collection of AI prompts specifically designed for Test Engineers using pytest framework to build robust test automation suites, ensure software quality, and implement effective testing strategies. + +## Table of Contents +1. [Test Framework Setup](#test-framework-setup) +2. [Unit Testing](#unit-testing) +3. [Integration Testing](#integration-testing) +4. [API Testing](#api-testing) +5. [Database Testing](#database-testing) +6. [UI/E2E Testing](#uie2e-testing) +7. [Test Data Management](#test-data-management) +8. [Test Fixtures & Configuration](#test-fixtures--configuration) +9. [Performance Testing](#performance-testing) +10. [Test Reporting & CI/CD](#test-reporting--cicd) + +--- + +## Test Framework Setup + +### 1. Pytest Project Setup + +**Prompt Template:** +``` +You are an expert test engineer. Set up a comprehensive pytest testing framework for [project type] with these requirements: +- Testing scope: [unit/integration/e2e/all] +- Application stack: [technology stack] +- Test environment: [local/CI/cloud] +- Reporting needs: [HTML/XML/dashboard/coverage] +- Integration requirements: [CI/CD tools, databases, APIs] + +Include: +- Project structure and organization +- pytest.ini configuration +- conftest.py setup with fixtures +- Requirements and dependencies +- Test discovery and execution setup +``` + +**Example:** +``` +You are an expert test engineer. Set up a comprehensive pytest testing framework for a Python web application with these requirements: +- Testing scope: Unit, integration, and API testing +- Application stack: Flask/Django, PostgreSQL, Redis, REST APIs +- Test environment: Local development and GitHub Actions CI +- Reporting needs: HTML reports, coverage reports, JUnit XML +- Integration requirements: Database fixtures, API mocking, Docker containers + +Include: +- Organized test directory structure (tests/unit, tests/integration, tests/api) +- pytest.ini with markers, test paths, and coverage configuration +- conftest.py with database fixtures, API clients, and test data +- requirements-test.txt with pytest plugins and testing dependencies +- Makefile or scripts for running different test suites +``` + +### 2. Test Configuration Management + +**Prompt:** +``` +Create a test configuration management system for pytest that handles: +- Multiple test environments (dev, staging, prod) +- Environment-specific test data and settings +- Secure credential management for testing +- Feature flags and test toggles +- Database and service connection configurations + +Include: +- Configuration file structure +- Environment variable management +- Fixture-based configuration injection +- Test environment isolation +- Configuration validation and error handling +``` + +### 3. Test Organization Strategy + +**Prompt:** +``` +Design a test organization strategy for [application type] using pytest that: +- Separates different types of tests logically +- Enables selective test execution +- Supports parallel test execution +- Facilitates test maintenance and updates +- Provides clear test categorization + +Include: +- Directory structure and naming conventions +- Pytest markers for test categorization +- Test collection and filtering strategies +- Documentation and team guidelines +- Scalability considerations for large test suites +``` + +--- + +## Unit Testing + +### 4. Unit Test Creation + +**Prompt Template:** +``` +Create comprehensive unit tests using pytest for [function/class/module] with these requirements: +- Code under test: [describe the functionality] +- Test scenarios: [happy path, edge cases, error conditions] +- Dependencies: [external services, databases, file systems] +- Coverage target: [percentage or specific areas] +- Testing approach: [TDD/BDD/traditional] + +Include: +- Test class organization and naming +- Parametrized tests for multiple scenarios +- Mock and patch strategies for dependencies +- Assertion patterns and custom assertions +- Test documentation and comments +``` + +**Example:** +``` +Create comprehensive unit tests using pytest for a user authentication service with these requirements: +- Code under test: User login, registration, password reset functionality +- Test scenarios: Valid credentials, invalid passwords, expired tokens, rate limiting +- Dependencies: Database ORM, email service, Redis cache, JWT tokens +- Coverage target: 95% line coverage with focus on security-critical paths +- Testing approach: TDD with security-focused test cases + +Include: +- TestUserAuth class with logical test grouping +- Parametrized tests for different credential combinations +- Mock strategies for database, email, and cache dependencies +- Custom assertions for security validations +- Clear test documentation explaining security test rationale +``` + +### 5. Test-Driven Development (TDD) + +**Prompt:** +``` +Implement TDD approach using pytest for [feature/functionality] that: +- Starts with failing tests that define requirements +- Implements minimal code to pass tests +- Refactors code while maintaining test coverage +- Follows red-green-refactor cycle +- Ensures comprehensive test coverage + +Include: +- Initial failing test cases +- Incremental implementation steps +- Refactoring opportunities and improvements +- Test evolution and maintenance +- Documentation of TDD process and decisions +``` + +### 6. Mock and Patch Strategies + +**Prompt:** +``` +Create effective mocking strategies using pytest for [system/component] that: +- Isolates units under test from dependencies +- Provides realistic mock behaviors +- Handles complex dependency chains +- Supports different testing scenarios +- Maintains test reliability and speed + +Include: +- Mock object creation and configuration +- Patch decorators and context managers +- Side effects and return value management +- Mock assertion and verification patterns +- Best practices for mock maintenance +``` + +--- + +## Integration Testing + +### 7. Integration Test Design + +**Prompt Template:** +``` +Design integration tests using pytest for [system integration] with these requirements: +- Integration scope: [components/services/systems involved] +- Test environment: [local/containerized/cloud] +- Data requirements: [test data setup and cleanup] +- External dependencies: [APIs, databases, message queues] +- Performance considerations: [execution time, resource usage] + +Include: +- Test setup and teardown procedures +- Integration test scenarios and workflows +- Error handling and failure recovery +- Test data management strategies +- Environment configuration and isolation +``` + +**Example:** +``` +Design integration tests using pytest for an e-commerce order processing system with these requirements: +- Integration scope: Order service, payment gateway, inventory system, notification service +- Test environment: Docker containers with test databases and mock services +- Data requirements: Customer data, product catalog, payment methods +- External dependencies: Stripe API, email service, inventory database +- Performance considerations: Tests should complete within 30 seconds + +Include: +- Docker-compose setup for test environment +- End-to-end order processing test scenarios +- Payment gateway mock and real API testing +- Test data factories for orders, customers, and products +- Cleanup procedures for test data and external service calls +``` + +### 8. Service Integration Testing + +**Prompt:** +``` +Create service integration tests for [microservices/APIs] that: +- Test service-to-service communication +- Validate data flow and transformations +- Handle service failures and timeouts +- Test authentication and authorization +- Verify contract compliance + +Include: +- Service mock and stub implementations +- Contract testing with schema validation +- Error scenario and resilience testing +- Authentication token management +- Service discovery and configuration testing +``` + +### 9. Database Integration Testing + +**Prompt:** +``` +Implement database integration tests using pytest that: +- Test database operations and transactions +- Validate data integrity and constraints +- Test migration and schema changes +- Handle concurrent access scenarios +- Verify performance characteristics + +Include: +- Database fixture setup and cleanup +- Transaction isolation and rollback strategies +- Data validation and constraint testing +- Migration testing procedures +- Performance benchmarking and monitoring +``` + +--- + +## API Testing + +### 10. REST API Testing + +**Prompt Template:** +``` +Create comprehensive REST API tests using pytest for [API/endpoint] with these requirements: +- API endpoints: [list specific endpoints to test] +- Authentication: [API keys, JWT, OAuth, etc.] +- Test scenarios: [CRUD operations, error cases, edge cases] +- Data validation: [request/response schema validation] +- Performance requirements: [response time, throughput] + +Include: +- API client setup and configuration +- Request/response validation +- Authentication and authorization testing +- Error handling and status code verification +- Performance and load testing basics +``` + +**Example:** +``` +Create comprehensive REST API tests using pytest for a blog management API with these requirements: +- API endpoints: /posts, /comments, /users, /auth endpoints +- Authentication: JWT tokens with role-based access control +- Test scenarios: CRUD for posts/comments, user registration/login, permission checks +- Data validation: JSON schema validation for all requests/responses +- Performance requirements: 95% of requests under 200ms response time + +Include: +- API client with automatic JWT token management +- JSON schema validation for all endpoints +- Role-based permission testing (admin, author, reader) +- Comprehensive error response testing (400, 401, 403, 404, 500) +- Basic load testing with concurrent requests +``` + +### 11. GraphQL API Testing + +**Prompt:** +``` +Implement GraphQL API testing using pytest that covers: +- Query and mutation testing +- Schema validation and introspection +- Error handling and validation +- Authentication and authorization +- Performance and complexity analysis + +Include: +- GraphQL client setup and query execution +- Schema introspection and validation +- Query complexity and depth limiting tests +- Authentication context and permission testing +- Error response format validation +``` + +### 12. API Contract Testing + +**Prompt:** +``` +Create API contract tests using pytest that: +- Validate API specification compliance +- Test backward compatibility +- Verify schema evolution +- Check breaking changes +- Ensure consumer-provider compatibility + +Include: +- OpenAPI/Swagger specification validation +- Contract testing with Pact or similar tools +- Schema versioning and migration testing +- Consumer-driven contract testing +- Breaking change detection and reporting +``` + +--- + +## Database Testing + +### 13. Database Test Fixtures + +**Prompt:** +``` +Create database test fixtures using pytest that: +- Provide clean test data for each test +- Handle database setup and teardown +- Support multiple database engines +- Enable test isolation and parallelization +- Manage test data relationships and constraints + +Include: +- Database connection and session management +- Test data factory patterns +- Transaction isolation strategies +- Fixture scoping and lifecycle management +- Database migration and schema testing +``` + +### 14. ORM Testing + +**Prompt:** +``` +Implement ORM testing strategies using pytest for [ORM framework] that: +- Test model definitions and relationships +- Validate query generation and optimization +- Test data validation and constraints +- Handle migration and schema changes +- Verify performance characteristics + +Include: +- Model factory and fixture creation +- Relationship and association testing +- Query optimization and N+1 problem testing +- Migration testing procedures +- Performance profiling and optimization +``` + +### 15. Data Migration Testing + +**Prompt:** +``` +Create data migration tests using pytest that: +- Validate migration scripts and procedures +- Test data transformation and integrity +- Handle large dataset migrations +- Verify rollback procedures +- Test migration performance + +Include: +- Migration test data setup +- Before/after data validation +- Performance benchmarking +- Rollback and recovery testing +- Data integrity verification procedures +``` + +--- + +## UI/E2E Testing + +### 16. Selenium Integration + +**Prompt Template:** +``` +Set up Selenium-based UI testing with pytest for [web application] with these requirements: +- Browser support: [Chrome, Firefox, Safari, Edge] +- Test scenarios: [user workflows to test] +- Page object model: [implementation approach] +- Test data: [user accounts, test data requirements] +- CI/CD integration: [headless execution, reporting] + +Include: +- WebDriver setup and configuration +- Page Object Model implementation +- Test data management and cleanup +- Screenshot and video capture on failures +- Cross-browser testing strategies +``` + +**Example:** +``` +Set up Selenium-based UI testing with pytest for an e-commerce web application with these requirements: +- Browser support: Chrome and Firefox with headless options for CI +- Test scenarios: User registration, product search, cart management, checkout process +- Page object model: Separate page classes with element locators and actions +- Test data: Test user accounts, product catalog, payment methods +- CI/CD integration: Headless execution with screenshot capture on failures + +Include: +- WebDriver factory with browser selection and configuration +- Page Object classes for home, product, cart, and checkout pages +- Test user factory with different user types and permissions +- Automatic screenshot capture and HTML source saving on test failures +- Docker-based browser execution for CI environments +``` + +### 17. Playwright Integration + +**Prompt:** +``` +Implement Playwright-based testing with pytest that: +- Supports multiple browsers and devices +- Handles modern web application features +- Provides fast and reliable test execution +- Includes visual regression testing +- Supports API and UI testing combination + +Include: +- Playwright setup and browser management +- Modern web feature testing (SPA, PWA) +- Visual comparison and screenshot testing +- API interception and mocking +- Mobile and responsive testing +``` + +### 18. Visual Regression Testing + +**Prompt:** +``` +Create visual regression testing suite using pytest that: +- Captures and compares screenshots +- Handles responsive design testing +- Manages baseline image updates +- Provides detailed diff reporting +- Integrates with CI/CD pipelines + +Include: +- Screenshot capture and comparison logic +- Baseline image management +- Responsive breakpoint testing +- Visual diff reporting and analysis +- CI integration with artifact storage +``` + +--- + +## Test Data Management + +### 19. Test Data Factories + +**Prompt:** +``` +Create test data factories using pytest that: +- Generate realistic test data +- Handle complex object relationships +- Support different data scenarios +- Provide data cleanup and isolation +- Enable parameterized testing + +Include: +- Factory pattern implementation +- Relationship and dependency management +- Data variation and randomization +- Cleanup and teardown procedures +- Integration with test fixtures +``` + +### 20. Database Seeding + +**Prompt:** +``` +Implement database seeding strategies for pytest that: +- Provide consistent test data across environments +- Handle data dependencies and relationships +- Support incremental and full data refresh +- Manage sensitive and anonymized data +- Enable selective data loading + +Include: +- Seed data definition and management +- Data loading and refresh procedures +- Dependency resolution and ordering +- Data anonymization and privacy protection +- Performance optimization for large datasets +``` + +### 21. Mock Data Generation + +**Prompt:** +``` +Create mock data generation system using pytest that: +- Generates realistic fake data +- Supports different data types and formats +- Handles localization and internationalization +- Provides consistent data across test runs +- Enables custom data patterns + +Include: +- Faker integration and customization +- Custom data providers and generators +- Localization and cultural data variations +- Seed management for reproducible data +- Performance optimization for large datasets +``` + +--- + +## Test Fixtures & Configuration + +### 22. Advanced Fixture Design + +**Prompt:** +``` +Design advanced pytest fixtures for [testing scenario] that: +- Provide efficient resource management +- Support different fixture scopes +- Handle complex setup and teardown +- Enable fixture composition and reuse +- Manage fixture dependencies + +Include: +- Fixture hierarchy and dependency management +- Resource pooling and sharing strategies +- Error handling and cleanup procedures +- Fixture parameterization and customization +- Performance optimization techniques +``` + +### 23. Configuration Management + +**Prompt:** +``` +Implement test configuration management using pytest that: +- Handles multiple test environments +- Manages sensitive configuration data +- Supports configuration inheritance +- Enables runtime configuration changes +- Provides configuration validation + +Include: +- Configuration file structure and formats +- Environment-specific overrides +- Secure credential management +- Configuration injection into tests +- Validation and error handling +``` + +### 24. Plugin Development + +**Prompt:** +``` +Create custom pytest plugins for [specific functionality] that: +- Extend pytest capabilities +- Provide reusable testing utilities +- Integrate with external tools +- Support team-specific workflows +- Maintain compatibility with pytest ecosystem + +Include: +- Plugin architecture and hooks +- Custom markers and decorators +- Command-line option integration +- Configuration and setup procedures +- Documentation and usage examples +``` + +--- + +## Performance Testing + +### 25. Load Testing Integration + +**Prompt:** +``` +Integrate load testing with pytest using [tool/framework] that: +- Tests application performance under load +- Validates response times and throughput +- Identifies performance bottlenecks +- Supports different load patterns +- Provides detailed performance reporting + +Include: +- Load test scenario definition +- Performance metric collection +- Baseline and threshold management +- Result analysis and reporting +- CI/CD integration for performance gates +``` + +### 26. Stress Testing + +**Prompt:** +``` +Implement stress testing using pytest that: +- Tests system behavior under extreme conditions +- Identifies breaking points and limits +- Validates error handling and recovery +- Tests resource exhaustion scenarios +- Provides stability and reliability metrics + +Include: +- Stress test scenario design +- Resource monitoring and measurement +- Failure detection and analysis +- Recovery testing procedures +- Performance degradation analysis +``` + +### 27. Performance Benchmarking + +**Prompt:** +``` +Create performance benchmarking suite using pytest that: +- Measures and tracks performance metrics +- Compares performance across versions +- Identifies performance regressions +- Provides statistical analysis +- Integrates with monitoring systems + +Include: +- Benchmark test implementation +- Statistical analysis and reporting +- Performance trend tracking +- Regression detection algorithms +- Integration with monitoring and alerting +``` + +--- + +## Test Reporting & CI/CD + +### 28. Test Reporting + +**Prompt Template:** +``` +Create comprehensive test reporting for pytest that includes: +- Test execution results and metrics +- Coverage reports and analysis +- Performance and timing data +- Error analysis and debugging information +- Historical trend analysis + +Generate reports for: +- Development teams: [detailed technical reports] +- Management: [executive summaries and dashboards] +- CI/CD: [machine-readable formats] +- Quality assurance: [detailed test analysis] + +Include multiple output formats and integration options. +``` + +**Example:** +``` +Create comprehensive test reporting for pytest that includes: +- Test execution results with pass/fail rates and execution times +- Code coverage reports with line, branch, and function coverage +- Performance metrics with response times and resource usage +- Detailed error logs with stack traces and debugging information +- Historical trend analysis with regression detection + +Generate reports for: +- Development teams: HTML reports with detailed coverage and error analysis +- Management: Executive dashboards with quality metrics and trends +- CI/CD: JUnit XML and JSON formats for pipeline integration +- Quality assurance: Detailed test case analysis with risk assessment + +Include Allure reporting, coverage.py integration, and custom dashboard creation. +``` + +### 29. CI/CD Integration + +**Prompt:** +``` +Integrate pytest with CI/CD pipeline for [platform] that: +- Runs tests automatically on code changes +- Provides fast feedback to developers +- Manages test environments and dependencies +- Handles test result reporting and notifications +- Supports parallel test execution + +Include: +- Pipeline configuration and setup +- Test environment provisioning +- Artifact management and storage +- Notification and alerting setup +- Performance optimization strategies +``` + +### 30. Quality Gates + +**Prompt:** +``` +Implement quality gates using pytest that: +- Define quality criteria and thresholds +- Block deployments on quality failures +- Provide clear feedback on quality issues +- Support different quality metrics +- Enable quality trend monitoring + +Include: +- Quality metric definition and measurement +- Threshold configuration and management +- Gate evaluation and decision logic +- Reporting and notification systems +- Quality improvement recommendations +``` + +--- + +## Advanced Testing Patterns + +### 31. Behavior-Driven Development (BDD) + +**Prompt:** +``` +Implement BDD testing using pytest with [pytest-bdd/behave] that: +- Translates business requirements into tests +- Enables collaboration between technical and non-technical stakeholders +- Provides living documentation +- Supports scenario-based testing +- Maintains traceability between requirements and tests + +Include: +- Feature file creation and management +- Step definition implementation +- Scenario outline and data tables +- Background and hook management +- Reporting and documentation generation +``` + +### 32. Property-Based Testing + +**Prompt:** +``` +Implement property-based testing using pytest with Hypothesis that: +- Generates test cases automatically +- Finds edge cases and boundary conditions +- Validates system properties and invariants +- Provides shrinking and minimization +- Integrates with existing test suites + +Include: +- Property definition and specification +- Custom data generation strategies +- Invariant testing and validation +- Integration with traditional unit tests +- Performance and execution optimization +``` + +### 33. Mutation Testing + +**Prompt:** +``` +Implement mutation testing using pytest that: +- Evaluates test suite effectiveness +- Identifies weak spots in test coverage +- Validates test quality and reliability +- Provides mutation score metrics +- Guides test improvement efforts + +Include: +- Mutation testing setup and configuration +- Mutant generation and execution +- Survival analysis and reporting +- Test improvement recommendations +- Integration with quality metrics +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Follow pytest conventions** - Use proper naming, fixtures, and markers +2. **Write maintainable tests** - Clear, readable, and well-documented test code +3. **Ensure test isolation** - Tests should not depend on each other +4. **Use appropriate test types** - Unit, integration, and E2E tests for different purposes +5. **Manage test data effectively** - Clean setup and teardown procedures +6. **Optimize test execution** - Parallel execution and efficient resource usage +7. **Integrate with CI/CD** - Automated testing and quality gates + +## Example Workflow for Test Engineers + +``` +1. Start with Test Framework Setup for project foundation +2. Implement Unit Tests for individual components +3. Add Integration Tests for component interactions +4. Create API Tests for service interfaces +5. Implement Database Tests for data layer validation +6. Add UI/E2E Tests for user workflow validation +7. Set up Test Data Management for reliable test execution +8. Configure Test Reporting for visibility and tracking +9. Integrate with CI/CD for automated quality assurance +10. Implement Advanced Testing Patterns for comprehensive coverage +``` + +## Pytest-Specific Tips + +- **Use fixtures effectively** - Leverage pytest's powerful fixture system for setup and teardown +- **Implement proper markers** - Organize tests with custom markers for selective execution +- **Utilize parametrization** - Test multiple scenarios with parametrized tests +- **Handle test discovery** - Follow pytest naming conventions for automatic test discovery +- **Optimize test execution** - Use pytest-xdist for parallel execution +- **Integrate plugins** - Leverage pytest ecosystem for extended functionality + +## Integration with Development Teams + +### Collaboration with Developers +- Use TDD prompts for collaborative test-first development +- Implement code review processes that include test quality +- Provide clear test documentation and examples + +### Working with DevOps +- Integrate testing with CI/CD pipelines +- Implement infrastructure testing and monitoring +- Collaborate on test environment management + +### Quality Assurance +- Implement comprehensive test coverage strategies +- Use reporting prompts for quality metrics and tracking +- Establish quality gates and standards + +--- + +*This guide is designed to help Test Engineers build comprehensive, maintainable, and effective test suites using pytest. Customize the prompts based on your specific application requirements, testing strategy, and team needs.* \ No newline at end of file diff --git a/ui-designer-figma-prompts.md b/ui-designer-figma-prompts.md new file mode 100644 index 0000000..cd75a29 --- /dev/null +++ b/ui-designer-figma-prompts.md @@ -0,0 +1,768 @@ +# UI Designer Figma Prompts Guide + +A comprehensive collection of AI prompts specifically designed for UI Designers working with Figma to create stunning prototypes, design systems, and user interfaces efficiently. + +## Table of Contents +1. [Prototype Development](#prototype-development) +2. [Design System Creation](#design-system-creation) +3. [Component Design](#component-design) +4. [User Interface Layout](#user-interface-layout) +5. [Interactive Design & Animation](#interactive-design--animation) +6. [Responsive Design](#responsive-design) +7. [Accessibility & Usability](#accessibility--usability) +8. [Design Handoff & Documentation](#design-handoff--documentation) +9. [User Research & Testing](#user-research--testing) +10. [Design Optimization](#design-optimization) + +--- + +## Prototype Development + +### 1. Interactive Prototype Creation + +**Prompt Template:** +``` +You are an expert UI designer. Create a detailed Figma prototype for [product/feature] with these requirements: +- User flow: [specific user journey] +- Platform: [web/mobile/tablet/desktop] +- Design style: [modern/minimalist/corporate/playful] +- Key interactions: [list specific interactions] +- Target audience: [user demographics] + +Include: +- Frame structure and organization +- Interactive hotspots and transitions +- Micro-interactions and animations +- Navigation patterns and flow +- Prototype testing scenarios +``` + +**Example:** +``` +You are an expert UI designer. Create a detailed Figma prototype for a food delivery mobile app with these requirements: +- User flow: Browse restaurants → Select items → Checkout → Track order +- Platform: Mobile-first (iOS/Android) +- Design style: Modern, clean with vibrant food imagery +- Key interactions: Swipe gestures, pull-to-refresh, animated cart updates +- Target audience: Urban millennials and Gen Z users + +Include: +- Frame structure with proper mobile dimensions +- Interactive hotspots for navigation and actions +- Smooth transitions between screens +- Bottom navigation with active states +- Order tracking with real-time updates simulation +``` + +### 2. High-Fidelity Prototype Framework + +**Prompt:** +``` +Design a high-fidelity prototype framework in Figma for [application type] that includes: +- Consistent navigation patterns +- Reusable interaction components +- State management for UI elements +- Error handling and feedback states +- Loading and transition animations + +Focus on: +- User experience flow optimization +- Visual hierarchy and information architecture +- Accessibility considerations +- Performance and usability testing preparation +``` + +### 3. Rapid Prototyping System + +**Prompt:** +``` +Create a rapid prototyping system in Figma for [design team/project] that: +- Enables quick iteration and testing +- Uses modular design components +- Supports multiple device breakpoints +- Includes pre-built interaction patterns +- Facilitates stakeholder feedback collection + +Include: +- Template library organization +- Component naming conventions +- Prototype sharing and collaboration workflows +- Version control and iteration tracking +``` + +--- + +## Design System Creation + +### 4. Comprehensive Design System + +**Prompt Template:** +``` +Create a comprehensive design system in Figma for [brand/product] with these specifications: +- Brand identity: [colors, typography, tone] +- Platform requirements: [web/mobile/both] +- Component scope: [basic/advanced/enterprise] +- Team size: [number of designers/developers] +- Accessibility level: [WCAG compliance level] + +Include: +- Color palette with semantic tokens +- Typography scale and hierarchy +- Spacing and layout grids +- Component library with variants +- Documentation and usage guidelines +``` + +**Example:** +``` +Create a comprehensive design system in Figma for a fintech startup with these specifications: +- Brand identity: Professional blue/green palette, clean typography, trustworthy tone +- Platform requirements: Web dashboard and mobile app +- Component scope: Advanced with complex data visualization components +- Team size: 5 designers, 8 developers +- Accessibility level: WCAG 2.1 AA compliance + +Include: +- Primary/secondary color palette with semantic tokens +- Typography scale optimized for financial data +- 8px grid system with responsive breakpoints +- Component library with form elements, charts, and data tables +- Comprehensive documentation with do's and don'ts +``` + +### 5. Component Library Architecture + +**Prompt:** +``` +Design a scalable component library architecture in Figma for [organization] that: +- Supports atomic design methodology +- Enables consistent cross-platform design +- Facilitates easy maintenance and updates +- Includes proper component documentation +- Supports design token integration + +Structure: +- Atoms: [basic elements] +- Molecules: [simple combinations] +- Organisms: [complex components] +- Templates: [page layouts] +- Pages: [specific instances] +``` + +### 6. Design Token System + +**Prompt:** +``` +Create a design token system in Figma for [product/brand] that includes: +- Color tokens (primitive, semantic, component-specific) +- Typography tokens (font families, sizes, weights, line heights) +- Spacing tokens (margins, padding, gaps) +- Border radius and shadow tokens +- Animation and timing tokens + +Include: +- Token naming conventions +- Hierarchical organization structure +- Documentation for developers +- Implementation guidelines +- Maintenance and update procedures +``` + +--- + +## Component Design + +### 7. UI Component Creation + +**Prompt Template:** +``` +Design a [component type] component in Figma with these requirements: +- Functionality: [specific features and behaviors] +- States: [default, hover, active, disabled, loading, error] +- Variants: [size, style, or type variations] +- Accessibility: [ARIA labels, keyboard navigation, screen reader support] +- Platform: [web/mobile/both] + +Include: +- Component structure and auto-layout +- Property panels and variant organization +- Interaction states and transitions +- Documentation and usage examples +- Developer handoff specifications +``` + +**Example:** +``` +Design a button component in Figma with these requirements: +- Functionality: Primary actions, secondary actions, icon support +- States: Default, hover, active, disabled, loading +- Variants: Small, medium, large sizes; filled, outlined, text styles +- Accessibility: Proper contrast ratios, focus indicators, touch targets +- Platform: Web and mobile responsive + +Include: +- Auto-layout with proper padding and spacing +- Organized variant properties panel +- Smooth hover and press state transitions +- Clear documentation with usage guidelines +- CSS specifications for developer implementation +``` + +### 8. Form Component System + +**Prompt:** +``` +Create a comprehensive form component system in Figma that includes: +- Input fields (text, email, password, number, search) +- Selection components (dropdown, radio, checkbox, toggle) +- Date and time pickers +- File upload components +- Form validation and error states + +For each component, include: +- Multiple size variants +- Validation states (success, warning, error) +- Accessibility features +- Responsive behavior +- Clear labeling and helper text patterns +``` + +### 9. Navigation Component Library + +**Prompt:** +``` +Design a navigation component library for [application type] that includes: +- Primary navigation (header, sidebar, bottom nav) +- Secondary navigation (tabs, breadcrumbs, pagination) +- Menu systems (dropdown, mega menu, context menu) +- Search and filtering components +- Mobile navigation patterns + +Include: +- Responsive behavior across breakpoints +- Active and inactive states +- Accessibility considerations +- Animation and transition specifications +- Integration with overall design system +``` + +--- + +## User Interface Layout + +### 10. Dashboard Design + +**Prompt Template:** +``` +Design a dashboard interface in Figma for [domain/industry] with these requirements: +- Primary metrics: [key performance indicators] +- User roles: [different user types and permissions] +- Data visualization: [charts, graphs, tables needed] +- Layout structure: [grid system, sidebar, header configuration] +- Responsive behavior: [desktop, tablet, mobile considerations] + +Include: +- Information hierarchy and visual organization +- Interactive data visualization components +- Filtering and search functionality +- Customization and personalization options +- Export and sharing capabilities +``` + +**Example:** +``` +Design a dashboard interface in Figma for e-commerce analytics with these requirements: +- Primary metrics: Sales revenue, conversion rates, traffic sources, top products +- User roles: Store owners, marketing managers, analysts +- Data visualization: Line charts, bar graphs, pie charts, data tables +- Layout structure: Left sidebar navigation, top header, main content grid +- Responsive behavior: Desktop-first with tablet and mobile adaptations + +Include: +- Clear metric hierarchy with prominent KPIs +- Interactive charts with hover states and drill-down capabilities +- Advanced filtering with date ranges and category selection +- Customizable widget arrangement and dashboard personalization +- Export functionality for reports and data sharing +``` + +### 11. Landing Page Design + +**Prompt:** +``` +Create a high-converting landing page design in Figma for [product/service] that: +- Communicates value proposition clearly +- Includes compelling call-to-action elements +- Optimizes for conversion and user engagement +- Supports A/B testing variations +- Works across all device types + +Include: +- Hero section with strong visual hierarchy +- Feature highlights and benefits +- Social proof and testimonials +- Clear conversion funnel design +- Mobile-first responsive layout +``` + +### 12. E-commerce Interface Design + +**Prompt:** +``` +Design an e-commerce interface in Figma for [product category] that includes: +- Product listing and grid layouts +- Product detail pages with image galleries +- Shopping cart and checkout flow +- User account and order management +- Search and filtering functionality + +Focus on: +- Conversion optimization +- Trust and security indicators +- Mobile commerce best practices +- Accessibility and usability +- Performance considerations +``` + +--- + +## Interactive Design & Animation + +### 13. Micro-interaction Design + +**Prompt:** +``` +Design micro-interactions in Figma for [specific UI elements] that: +- Provide clear user feedback +- Enhance usability and delight +- Support accessibility requirements +- Maintain performance standards +- Align with brand personality + +Create interactions for: +- Button hover and click states +- Form field focus and validation +- Loading and progress indicators +- Navigation transitions +- Data visualization animations + +Include timing, easing, and implementation notes. +``` + +### 14. Prototype Animation System + +**Prompt:** +``` +Create an animation system in Figma for [application] that includes: +- Transition types and timing functions +- Loading and progress animations +- Feedback and confirmation animations +- Navigation and page transitions +- Data visualization animations + +Define: +- Animation principles and guidelines +- Duration and easing standards +- Performance considerations +- Accessibility and reduced motion support +- Implementation specifications for developers +``` + +### 15. Interactive Component States + +**Prompt:** +``` +Design comprehensive interactive states for [component type] in Figma that cover: +- Default and resting states +- Hover and focus interactions +- Active and pressed states +- Loading and processing states +- Success and error feedback states +- Disabled and unavailable states + +Include: +- Smooth transition specifications +- Accessibility considerations +- Touch and mouse interaction differences +- Animation timing and easing +- Developer implementation guidelines +``` + +--- + +## Responsive Design + +### 16. Multi-Device Design System + +**Prompt Template:** +``` +Create a responsive design system in Figma for [application] that works across: +- Desktop: [specific breakpoints and layouts] +- Tablet: [orientation and size considerations] +- Mobile: [iOS and Android specifications] +- Wearable: [if applicable] + +Include: +- Flexible grid systems +- Responsive typography scales +- Adaptive component behaviors +- Touch target optimizations +- Platform-specific design patterns +``` + +**Example:** +``` +Create a responsive design system in Figma for a news application that works across: +- Desktop: 1440px, 1920px with sidebar navigation and multi-column layouts +- Tablet: 768px, 1024px with collapsible navigation and two-column grids +- Mobile: 375px, 414px with bottom navigation and single-column layouts +- Apple Watch: Article summaries and breaking news notifications + +Include: +- 12-column grid system with flexible gutters +- Responsive typography scale from 14px to 48px +- Adaptive card components that stack and resize +- 44px minimum touch targets for mobile +- Platform-specific navigation patterns and interactions +``` + +### 17. Breakpoint Strategy + +**Prompt:** +``` +Define a comprehensive breakpoint strategy in Figma for [project] that: +- Covers all target devices and screen sizes +- Ensures optimal content layout at each breakpoint +- Maintains design consistency across devices +- Supports both portrait and landscape orientations +- Considers emerging device categories + +Include: +- Breakpoint definitions and rationale +- Layout behavior at each breakpoint +- Component adaptation strategies +- Typography and spacing adjustments +- Testing and validation approaches +``` + +### 18. Mobile-First Design Approach + +**Prompt:** +``` +Implement a mobile-first design approach in Figma for [application] that: +- Prioritizes mobile user experience +- Progressively enhances for larger screens +- Optimizes for touch interactions +- Considers mobile-specific constraints +- Ensures fast loading and performance + +Focus on: +- Essential content and feature prioritization +- Thumb-friendly navigation patterns +- Efficient use of screen real estate +- Mobile-specific interaction patterns +- Performance optimization considerations +``` + +--- + +## Accessibility & Usability + +### 19. Accessibility-First Design + +**Prompt:** +``` +Create an accessibility-first design in Figma for [application] that meets: +- WCAG 2.1 AA compliance standards +- Color contrast requirements (4.5:1 for normal text) +- Keyboard navigation support +- Screen reader compatibility +- Motor accessibility considerations + +Include: +- High contrast color schemes +- Clear focus indicators +- Proper heading hierarchy +- Alternative text specifications +- Touch target size requirements (44px minimum) +- Error handling and feedback systems +``` + +### 20. Inclusive Design Patterns + +**Prompt:** +``` +Design inclusive UI patterns in Figma that accommodate: +- Visual impairments (low vision, color blindness) +- Motor disabilities (limited dexterity, tremors) +- Cognitive differences (memory, attention, processing) +- Hearing impairments (deaf, hard of hearing) +- Temporary disabilities (broken arm, bright sunlight) + +Create: +- Multiple ways to access information +- Clear and simple language patterns +- Consistent navigation and interaction patterns +- Error prevention and recovery mechanisms +- Customizable interface options +``` + +### 21. Usability Testing Preparation + +**Prompt:** +``` +Prepare Figma prototypes for usability testing of [feature/application] that: +- Support realistic user task scenarios +- Include error states and edge cases +- Enable natural user interactions +- Collect meaningful feedback data +- Test across different user groups + +Include: +- Task flow documentation +- Prototype interaction specifications +- Testing scenario scripts +- Data collection points +- Iteration and improvement plans +``` + +--- + +## Design Handoff & Documentation + +### 22. Developer Handoff Specifications + +**Prompt:** +``` +Create comprehensive developer handoff documentation in Figma for [project] that includes: +- Detailed design specifications +- Component implementation guidelines +- Asset export requirements +- Interaction and animation specifications +- Responsive behavior documentation + +Provide: +- CSS specifications and measurements +- Color codes and typography details +- Spacing and layout specifications +- Asset naming conventions +- Implementation priority and phasing +``` + +### 23. Design System Documentation + +**Prompt:** +``` +Create thorough design system documentation in Figma that covers: +- Component usage guidelines +- Design principles and philosophy +- Brand guidelines and voice +- Accessibility standards +- Implementation best practices + +Include: +- Do's and don'ts for each component +- Code snippets and implementation examples +- Accessibility considerations +- Maintenance and update procedures +- Team collaboration guidelines +``` + +### 24. Asset Organization System + +**Prompt:** +``` +Develop an asset organization system in Figma for [team/project] that: +- Enables efficient file management +- Supports team collaboration +- Maintains version control +- Facilitates asset reuse +- Ensures consistency across projects + +Include: +- File naming conventions +- Folder structure and organization +- Component library management +- Version control workflows +- Team access and permissions +``` + +--- + +## User Research & Testing + +### 25. User Research Integration + +**Prompt:** +``` +Integrate user research findings into Figma designs for [product] by: +- Translating user insights into design decisions +- Creating user-centered design solutions +- Validating design concepts with user data +- Iterating based on user feedback +- Documenting research-driven design rationale + +Include: +- User persona integration in design decisions +- Journey mapping visualization +- Pain point identification and solutions +- User testing scenario preparation +- Research findings documentation +``` + +### 26. A/B Testing Design Variants + +**Prompt:** +``` +Create A/B testing design variants in Figma for [specific feature/page] that test: +- Different layout approaches +- Alternative interaction patterns +- Various visual treatments +- Content presentation methods +- Call-to-action variations + +Include: +- Clear variant documentation +- Hypothesis and success metrics +- Implementation specifications +- Testing timeline and methodology +- Results analysis framework +``` + +### 27. User Feedback Integration + +**Prompt:** +``` +Design a system in Figma for collecting and integrating user feedback that: +- Captures user sentiment and preferences +- Identifies usability issues and pain points +- Tracks user behavior patterns +- Enables rapid iteration and improvement +- Maintains user-centered design focus + +Include: +- Feedback collection mechanisms +- User testing result integration +- Design iteration workflows +- Stakeholder communication methods +- Continuous improvement processes +``` + +--- + +## Design Optimization + +### 28. Performance-Optimized Design + +**Prompt:** +``` +Create performance-optimized designs in Figma for [application] that: +- Minimize loading times and resource usage +- Optimize images and assets for web/mobile +- Consider bandwidth and device limitations +- Prioritize critical content and features +- Support progressive loading strategies + +Include: +- Asset optimization guidelines +- Image compression and format recommendations +- Critical path design prioritization +- Loading state and skeleton screen designs +- Performance budget considerations +``` + +### 29. Conversion Rate Optimization + +**Prompt:** +``` +Design for conversion rate optimization in Figma by: +- Optimizing user flow and reducing friction +- Improving call-to-action visibility and effectiveness +- Enhancing trust signals and social proof +- Streamlining form and checkout processes +- Testing and iterating on key conversion points + +Focus on: +- Clear value proposition communication +- Reduced cognitive load and decision fatigue +- Trust and credibility indicators +- Mobile conversion optimization +- A/B testing preparation +``` + +### 30. Design System Scalability + +**Prompt:** +``` +Design a scalable design system in Figma that: +- Supports future product growth and expansion +- Enables efficient team collaboration +- Maintains consistency across multiple products +- Facilitates easy updates and maintenance +- Supports international and accessibility requirements + +Include: +- Modular component architecture +- Scalable naming and organization systems +- Documentation and governance processes +- Integration with development workflows +- Long-term maintenance strategies +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Follow Figma best practices** - Use auto-layout, components, and proper layer organization +2. **Design for accessibility** - Ensure WCAG compliance and inclusive design principles +3. **Consider all device types** - Design responsive layouts for multiple screen sizes +4. **Document thoroughly** - Provide clear specifications for developers and stakeholders +5. **Test early and often** - Create prototypes for user testing and validation +6. **Maintain consistency** - Use design systems and component libraries effectively +7. **Optimize for performance** - Consider loading times and resource constraints + +## Example Workflow for UI Designers + +``` +1. Start with User Research prompts to understand user needs +2. Use Design System prompts to establish visual foundation +3. Create layouts using Interface Layout prompts +4. Build components with Component Design prompts +5. Add interactions using Interactive Design prompts +6. Ensure accessibility with Accessibility prompts +7. Create prototypes using Prototype Development prompts +8. Prepare handoff using Documentation prompts +9. Optimize designs using Design Optimization prompts +``` + +## Figma-Specific Tips + +- **Use Auto Layout effectively** - Create responsive components that adapt to content +- **Organize with proper naming** - Use consistent naming conventions for layers and components +- **Leverage component variants** - Create flexible components with multiple states and options +- **Utilize design tokens** - Implement consistent colors, typography, and spacing +- **Create interactive prototypes** - Use Figma's prototyping features for realistic user testing +- **Collaborate efficiently** - Use comments, sharing, and version history for team collaboration + +## Integration with Development Teams + +### Collaboration with Engineers +- Use developer handoff prompts for clear implementation specifications +- Include technical constraints in design decisions +- Provide detailed interaction and animation specifications + +### Working with Product Managers +- Align designs with product requirements and user stories +- Create prototypes that validate product concepts +- Document design decisions and rationale + +### Stakeholder Communication +- Use visual presentations and interactive prototypes +- Provide clear design rationale and user research backing +- Create design variations for stakeholder feedback + +--- + +*This guide is designed to help UI Designers work more efficiently with AI assistants while creating exceptional user interfaces in Figma. Customize the prompts based on your specific project requirements, brand guidelines, and user needs.* \ No newline at end of file From 7b7de6e046d28d2f96aa1f3b6057f5517a494fb4 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 26 May 2025 21:44:34 +0800 Subject: [PATCH 06/10] Enhance job-specific prompts index with new guides for Blockchain Architects and HR Managers. Add foundational communication techniques for developers and update README.md to reflect these changes, including quick start instructions and role-specific guidance. --- README.md | 81 +- blockchain-architect-prompts.md | 864 ++++++++++++++++++ hr-manager-hiring-prompts.md | 793 ++++++++++++++++ job-specific-prompts-index.md | 199 +++- ...communication-techniques-for-developers.md | 823 +++++++++++++++++ 5 files changed, 2694 insertions(+), 66 deletions(-) create mode 100644 blockchain-architect-prompts.md create mode 100644 hr-manager-hiring-prompts.md create mode 100644 llm-communication-techniques-for-developers.md diff --git a/README.md b/README.md index 2f13312..1a00678 100644 --- a/README.md +++ b/README.md @@ -5,16 +5,8 @@ learn to code using AI and craft effective AI-driven coding prompts tailored to ## Guides -### Job-Specific Prompt Guides -- **[Job-Specific Prompts Index](job-specific-prompts-index.md)**: Complete index of role-based prompt guides -- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)**: Specialized prompts for React and Next.js developers -- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)**: Comprehensive guide for Rust backend development with AI integration -- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)**: Complete guide for Node.js Sails.js framework development -- **[UI Designer (Figma)](ui-designer-figma-prompts.md)**: Complete guide for UI Designers using Figma for prototypes and design systems -- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)**: Comprehensive guide for Test Engineers using pytest framework -- **[Product Manager](product-manager-prompts.md)**: Comprehensive guide for Product Managers covering prototypes, research, and strategy - -### General Coding Guides +### Core Communication & Learning Guides +- **[LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md)**: Comprehensive guide to effective communication strategies with LLMs for robust software development - **[LearnToCode.md](LearnToCode.md)**: A curated collection of AI prompts to help you learn programming concepts, write code, maintain quality, troubleshoot issues, and deepen your understanding of core software engineering topics. Includes a glossary of terms. @@ -24,8 +16,26 @@ learn to code using AI and craft effective AI-driven coding prompts tailored to - [Troubleshooting](troubleshooting.md) - [Learning To Code](learning-to-code-guide.md) +### Job-Specific Prompt Guides +- **[Job-Specific Prompts Index](job-specific-prompts-index.md)**: Complete index of role-based prompt guides +- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)**: Specialized prompts for React and Next.js developers +- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)**: Comprehensive guide for Rust backend development with AI integration +- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)**: Complete guide for Node.js Sails.js framework development +- **[Blockchain Architect](blockchain-architect-prompts.md)**: Complete guide for Blockchain Architects and Web3 developers +- **[UI Designer (Figma)](ui-designer-figma-prompts.md)**: Complete guide for UI Designers using Figma for prototypes and design systems +- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)**: Comprehensive guide for Test Engineers using pytest framework +- **[Product Manager](product-manager-prompts.md)**: Comprehensive guide for Product Managers covering prototypes, research, and strategy +- **[HR Manager (Hiring & Recruitment)](hr-manager-hiring-prompts.md)**: Comprehensive guide for HR Managers covering hiring, recruitment, and talent acquisition + ## Quick Start by Role +### Learning Effective LLM Communication +```bash +# Start with the LLM Communication Techniques guide +open llm-communication-techniques-for-developers.md +``` +Perfect for: Structuring thoughts clearly, crafting precise prompts, maintaining productive AI conversations, debugging communication issues + ### Frontend Developers (React/Next.js) ```bash # Start with the Frontend React/Next.js guide @@ -68,6 +78,20 @@ open product-manager-prompts.md ``` Perfect for: Prototype creation, user research, feature planning, market analysis, product strategy +### HR Managers (Hiring & Recruitment) +```bash +# Start with the HR Manager guide +open hr-manager-hiring-prompts.md +``` +Perfect for: Job descriptions, talent sourcing, interview design, candidate assessment, employer branding + +### Blockchain Architects (Web3) +```bash +# Start with the Blockchain Architect guide +open blockchain-architect-prompts.md +``` +Perfect for: Blockchain architecture, smart contracts, DeFi protocols, consensus mechanisms, tokenomics + ### General Development ```bash # Start with the general coding guides @@ -78,17 +102,21 @@ Perfect for: Learning fundamentals, general coding tasks, troubleshooting ## Getting Started -1. **Choose your guide based on your role**: +1. **Master LLM Communication First**: + - Start with [LLM Communication Techniques](llm-communication-techniques-for-developers.md) to learn how to structure thoughts and communicate effectively with AI assistants + - This foundational skill will improve your experience with all other guides + +2. **Choose your guide based on your role**: - Browse the [Job-Specific Prompts Index](job-specific-prompts-index.md) to find guides tailored to your technology stack and responsibilities - Use general guides for learning fundamentals or cross-cutting concerns -2. **Clone this repository**: +3. **Clone this repository**: ```bash git clone https://github.com//.git cd ``` -3. **Open the relevant guides** in your preferred Markdown viewer or editor +4. **Open the relevant guides** in your preferred Markdown viewer or editor ## Usage @@ -96,19 +124,24 @@ Copy and paste the prompts from these guides into your AI coding assistant (e.g. Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubleshooting. ### Example Workflow -1. **Identify your role and tech stack** using the job-specific index -2. **Find relevant prompts** for your current task -3. **Customize the prompts** with your specific requirements -4. **Use with your AI assistant** to generate code, solve problems, or learn concepts +1. **Learn effective communication** using the LLM Communication Techniques guide +2. **Identify your role and tech stack** using the job-specific index +3. **Find relevant prompts** for your current task +4. **Customize the prompts** with your specific requirements +5. **Use with your AI assistant** to generate code, solve problems, or learn concepts ## What's New +### Core Communication & Learning +- **NEW**: [LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md) - Comprehensive guide with 30+ communication strategies including the CLEAR framework, STAR method, context management, structured problem-solving, debugging communication, architecture discussions, and advanced techniques like Socratic method and collaborative problem solving + ### Job-Specific Guides +- **NEW**: [HR Manager Hiring Guide](hr-manager-hiring-prompts.md) - 30 comprehensive prompts covering job description creation, talent sourcing, interview design, candidate assessment, employer branding, diversity initiatives, compensation strategy, and legal compliance +- **NEW**: [Blockchain Architect Guide](blockchain-architect-prompts.md) - 30 specialized prompts for blockchain architecture design, smart contract development, DeFi protocols, consensus mechanisms, scalability solutions, security frameworks, and tokenomics design - **NEW**: [UI Designer Figma Guide](ui-designer-figma-prompts.md) - 30 comprehensive prompts covering interactive prototypes, design systems, component design, responsive layouts, accessibility, and design handoff - **NEW**: [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) - 33 specialized prompts for pytest framework, test automation, unit/integration testing, UI testing, performance testing, and CI/CD integration - **NEW**: [Product Manager Guide](product-manager-prompts.md) - 30 comprehensive prompts covering prototype development, user research, feature planning, market analysis, product strategy, and stakeholder communication - **NEW**: [Node.js Sails.js Backend Engineer Guide](nodejs-sailsjs-backend-prompts.md) - 33 specialized prompts for Sails.js development, Waterline ORM, real-time features, and deployment -- **NEW**: [Frontend React/Next.js Engineer Guide](frontend-react-nextjs-prompts.md) - 23 specialized prompts covering component development, Next.js features, performance optimization, and testing - **NEW**: [Rust Backend Engineer Guide](rust-backend-engineer-prompts.md) - 32 comprehensive prompts for Actix-web, RIG integration, database management, and deployment - **NEW**: [Job-Specific Index](job-specific-prompts-index.md) - Central hub for all role-based guides with selection guidance @@ -121,6 +154,12 @@ Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubles Contributions, issues, and suggestions are welcome! To contribute: +### Adding New Communication Techniques +1. Follow the structured format established in the LLM Communication Techniques guide +2. Include practical templates and real-world examples +3. Focus on developer-specific scenarios and challenges +4. Provide both basic and advanced techniques + ### Adding New Job-Specific Guides 1. Follow the format established in existing job-specific guides 2. Include role-specific scenarios and technology-focused prompts @@ -137,6 +176,12 @@ Please follow the existing style and guidelines when adding or modifying prompts ## Roadmap +### Upcoming Communication Guides +- Advanced Debugging Communication Patterns +- Team Collaboration with AI Assistants +- Code Review Communication Strategies +- Technical Documentation with AI + ### Upcoming Job-Specific Guides - Python Backend Engineer (Django/FastAPI) - DevOps Engineer (Docker, Kubernetes, CI/CD) diff --git a/blockchain-architect-prompts.md b/blockchain-architect-prompts.md new file mode 100644 index 0000000..4ae8b27 --- /dev/null +++ b/blockchain-architect-prompts.md @@ -0,0 +1,864 @@ +# Blockchain Architect Prompts Guide + +A comprehensive collection of AI prompts specifically designed for Blockchain Architects to design robust technology stacks, architect distributed systems, and implement cutting-edge blockchain solutions. + +## Table of Contents +1. [Blockchain Architecture Design](#blockchain-architecture-design) +2. [Technology Stack Selection](#technology-stack-selection) +3. [Smart Contract Architecture](#smart-contract-architecture) +4. [Consensus Mechanism Design](#consensus-mechanism-design) +5. [Scalability & Performance](#scalability--performance) +6. [Security & Cryptography](#security--cryptography) +7. [Interoperability & Cross-Chain](#interoperability--cross-chain) +8. [DeFi & Protocol Design](#defi--protocol-design) +9. [Infrastructure & DevOps](#infrastructure--devops) +10. [Governance & Tokenomics](#governance--tokenomics) + +--- + +## Blockchain Architecture Design + +### 1. Comprehensive Blockchain System Architecture + +**Prompt Template:** +``` +You are an expert blockchain architect. Design a comprehensive blockchain system architecture for [use case/industry] with these requirements: +- Use case: [specific application or problem to solve] +- Scale requirements: [transaction throughput, user base, data volume] +- Performance needs: [latency, finality time, availability] +- Security level: [enterprise/consumer/critical infrastructure] +- Regulatory compliance: [specific regulations or standards] + +Include: +- Overall system architecture and component design +- Blockchain layer selection and configuration +- Consensus mechanism recommendation +- Data storage and management strategy +- API and integration layer design +- Security framework and threat model +- Scalability roadmap and optimization strategies +``` + +**Example:** +``` +You are an expert blockchain architect. Design a comprehensive blockchain system architecture for supply chain traceability with these requirements: +- Use case: End-to-end tracking of pharmaceutical products from manufacturing to patient +- Scale requirements: 10M+ products tracked, 1000+ participants, 100K+ transactions/day +- Performance needs: <5 second confirmation time, 99.9% uptime, real-time tracking +- Security level: Enterprise-grade with regulatory compliance (FDA, EU MDR) +- Regulatory compliance: 21 CFR Part 11, GDPR, serialization requirements + +Include: +- Hybrid blockchain architecture with permissioned consortium chain +- Proof of Authority consensus with enterprise validator nodes +- IPFS for document storage with on-chain hash verification +- RESTful APIs with GraphQL for complex queries +- Zero-knowledge proofs for privacy-preserving verification +- Multi-signature wallets and role-based access control +- Horizontal scaling through sharding and layer-2 solutions +``` + +### 2. Distributed System Architecture + +**Prompt:** +``` +Design a distributed blockchain system architecture for [application type] that: +- Handles high availability and fault tolerance +- Ensures data consistency across nodes +- Implements efficient peer-to-peer networking +- Supports dynamic node discovery and management +- Provides robust monitoring and observability + +Include: +- Network topology and node architecture +- Data replication and synchronization strategies +- Fault detection and recovery mechanisms +- Load balancing and traffic management +- Monitoring, logging, and alerting systems +- Disaster recovery and backup procedures +``` + +### 3. Microservices Blockchain Architecture + +**Prompt:** +``` +Create a microservices-based blockchain architecture for [platform/application] that: +- Separates concerns into independent services +- Enables independent scaling and deployment +- Supports multiple blockchain protocols +- Implements service discovery and communication +- Ensures data consistency across services + +Include: +- Service decomposition and boundaries +- Inter-service communication patterns +- Data management and consistency strategies +- API gateway and service mesh configuration +- Container orchestration and deployment +- Testing and quality assurance approaches +``` + +--- + +## Technology Stack Selection + +### 4. Blockchain Platform Evaluation + +**Prompt Template:** +``` +Evaluate and recommend blockchain platforms for [project requirements] considering: +- Technical requirements: [performance, scalability, features needed] +- Business constraints: [budget, timeline, team expertise] +- Ecosystem factors: [developer tools, community, documentation] +- Long-term considerations: [roadmap, sustainability, upgradability] +- Integration needs: [existing systems, third-party services] + +Compare platforms including: +- Ethereum and Layer 2 solutions +- Hyperledger Fabric/Besu +- Polygon, Solana, Avalanche +- Cosmos SDK, Polkadot Substrate +- Enterprise solutions (R3 Corda, JPM Coin) + +Provide detailed analysis with pros/cons and final recommendation. +``` + +**Example:** +``` +Evaluate and recommend blockchain platforms for a decentralized identity management system considering: +- Technical requirements: 10K+ TPS, sub-second finality, privacy features, smart contracts +- Business constraints: $500K budget, 12-month timeline, team experienced in JavaScript/TypeScript +- Ecosystem factors: Strong developer tools, active community, comprehensive documentation +- Long-term considerations: Sustainable tokenomics, regular upgrades, enterprise adoption +- Integration needs: OAuth/SAML compatibility, mobile SDKs, cloud infrastructure + +Compare platforms including: +- Ethereum with Polygon Layer 2 for cost efficiency +- Hyperledger Indy for identity-specific features +- Solana for high performance and low costs +- Cosmos SDK for custom blockchain development +- Microsoft ION on Bitcoin for enterprise trust + +Provide detailed technical analysis, cost comparison, and implementation roadmap. +``` + +### 5. Development Framework Selection + +**Prompt:** +``` +Select and configure development frameworks for [blockchain project] that: +- Accelerate development and reduce time-to-market +- Provide robust testing and debugging capabilities +- Support multiple deployment environments +- Enable efficient smart contract development +- Integrate with existing development workflows + +Evaluate frameworks such as: +- Truffle, Hardhat, Foundry for Ethereum +- Anchor for Solana development +- CosmWasm for Cosmos ecosystem +- Substrate for Polkadot parachains +- Hyperledger Composer for Fabric + +Include setup instructions, best practices, and toolchain integration. +``` + +### 6. Infrastructure Technology Stack + +**Prompt:** +``` +Design infrastructure technology stack for [blockchain application] that includes: +- Cloud platform selection and configuration +- Container orchestration and management +- Database and storage solutions +- Monitoring and observability tools +- CI/CD pipeline and deployment automation +- Security and compliance tools + +Consider: +- Multi-cloud and hybrid deployment strategies +- Auto-scaling and resource optimization +- Backup and disaster recovery +- Cost optimization and budget management +- Performance monitoring and optimization +- Security scanning and vulnerability management +``` + +--- + +## Smart Contract Architecture + +### 7. Smart Contract System Design + +**Prompt:** +``` +Design a smart contract system architecture for [DApp/protocol] that: +- Implements modular and upgradeable contract design +- Ensures security and gas optimization +- Supports complex business logic and workflows +- Enables efficient state management +- Provides comprehensive testing and verification + +Include: +- Contract architecture and interaction patterns +- Upgrade mechanisms and governance +- Security patterns and access controls +- Gas optimization strategies +- Testing framework and coverage +- Formal verification approaches +``` + +### 8. DeFi Protocol Architecture + +**Prompt Template:** +``` +Create a DeFi protocol architecture for [financial product/service] with these specifications: +- Protocol type: [DEX, lending, yield farming, derivatives, insurance] +- Supported assets: [tokens, NFTs, real-world assets] +- Liquidity mechanisms: [AMM, order book, liquidity mining] +- Risk management: [collateralization, liquidation, insurance] +- Governance model: [DAO structure, voting mechanisms, treasury] + +Include: +- Core protocol smart contracts and interactions +- Tokenomics and incentive mechanisms +- Oracle integration for price feeds +- Security measures and audit requirements +- User interface and experience design +- Integration with other DeFi protocols +``` + +**Example:** +``` +Create a DeFi protocol architecture for a decentralized lending platform with these specifications: +- Protocol type: Over-collateralized lending with flash loans +- Supported assets: ETH, WBTC, USDC, USDT, and governance token +- Liquidity mechanisms: Liquidity mining rewards, dynamic interest rates +- Risk management: 150% collateralization ratio, automated liquidations, insurance fund +- Governance model: Token-based DAO with time-locked proposals and treasury management + +Include: +- LendingPool, CollateralManager, LiquidationEngine, and InterestRateModel contracts +- Dual-token system with utility and governance tokens +- Chainlink price oracles with fallback mechanisms +- Multi-signature admin controls and emergency pause functionality +- React-based frontend with Web3 wallet integration +- Composability with Uniswap, Compound, and Aave protocols +``` + +### 9. NFT and Digital Asset Architecture + +**Prompt:** +``` +Design NFT and digital asset architecture for [marketplace/platform] that: +- Supports multiple NFT standards and formats +- Implements efficient minting and trading mechanisms +- Enables royalty distribution and creator economics +- Provides metadata management and IPFS integration +- Supports fractionalization and derivative products + +Include: +- NFT contract standards and customizations +- Marketplace smart contract design +- Metadata schema and storage strategy +- Royalty enforcement mechanisms +- Cross-chain compatibility considerations +- User experience and wallet integration +``` + +--- + +## Consensus Mechanism Design + +### 10. Custom Consensus Algorithm + +**Prompt:** +``` +Design a custom consensus algorithm for [specific use case] that: +- Optimizes for specific performance requirements +- Addresses unique security and trust assumptions +- Balances decentralization with efficiency +- Supports the target network topology +- Enables future upgrades and modifications + +Consider: +- Consensus algorithm type (PoW, PoS, DPoS, PBFT, etc.) +- Validator selection and rotation mechanisms +- Finality guarantees and fork resolution +- Network partition tolerance +- Economic incentives and penalties +- Implementation complexity and verification +``` + +### 11. Proof of Stake Implementation + +**Prompt:** +``` +Implement a Proof of Stake consensus mechanism for [blockchain network] that includes: +- Validator selection and staking requirements +- Slashing conditions and penalty mechanisms +- Reward distribution and inflation model +- Delegation and liquid staking support +- Governance integration and voting power + +Design: +- Staking contract architecture +- Validator node requirements and setup +- Economic security analysis +- Attack vector mitigation +- Upgrade and parameter adjustment mechanisms +- Performance benchmarks and optimization +``` + +### 12. Hybrid Consensus Design + +**Prompt:** +``` +Create a hybrid consensus mechanism for [enterprise/consortium blockchain] that: +- Combines multiple consensus algorithms +- Adapts to different network conditions +- Supports permissioned and permissionless modes +- Enables gradual decentralization +- Maintains regulatory compliance + +Include: +- Multi-layer consensus architecture +- Transition mechanisms between modes +- Governance and decision-making processes +- Performance and security trade-offs +- Implementation roadmap and migration strategy +- Compliance and audit considerations +``` + +--- + +## Scalability & Performance + +### 13. Layer 2 Scaling Solution + +**Prompt Template:** +``` +Design a Layer 2 scaling solution for [blockchain/application] with these requirements: +- Scaling approach: [state channels, sidechains, rollups, plasma] +- Performance targets: [TPS, latency, cost reduction] +- Security model: [trust assumptions, fraud proofs, validity proofs] +- User experience: [seamless onboarding, fast withdrawals] +- Interoperability: [cross-L2 communication, L1 settlement] + +Include: +- Technical architecture and protocol design +- Smart contract implementation strategy +- Bridge and settlement mechanisms +- Economic model and fee structure +- Developer tools and SDK design +- Migration and adoption strategy +``` + +**Example:** +``` +Design a Layer 2 scaling solution for a gaming platform with these requirements: +- Scaling approach: Optimistic rollup with custom fraud proofs +- Performance targets: 10,000+ TPS, <100ms latency, 99% cost reduction +- Security model: 7-day challenge period with economic incentives +- User experience: Instant deposits, fast withdrawals for small amounts +- Interoperability: Cross-game asset transfers, NFT marketplace integration + +Include: +- Custom rollup architecture with game-specific optimizations +- EVM-compatible execution environment with gaming primitives +- Optimized bridge contracts with batched settlements +- Tiered withdrawal system based on amount and urgency +- Unity/Unreal Engine SDKs with wallet abstraction +- Gradual migration from L1 with backward compatibility +``` + +### 14. Sharding Architecture + +**Prompt:** +``` +Implement a sharding architecture for [blockchain network] that: +- Partitions state and computation efficiently +- Maintains security across shards +- Enables cross-shard communication +- Supports dynamic shard management +- Provides data availability guarantees + +Design: +- Shard allocation and management algorithms +- Cross-shard transaction protocols +- State synchronization mechanisms +- Validator assignment and rotation +- Data availability and recovery procedures +- Performance monitoring and optimization +``` + +### 15. Performance Optimization Strategy + +**Prompt:** +``` +Create a comprehensive performance optimization strategy for [blockchain system] that: +- Identifies bottlenecks and performance constraints +- Implements caching and data optimization +- Optimizes network communication and protocols +- Reduces computational overhead +- Monitors and measures performance improvements + +Include: +- Performance profiling and analysis tools +- Database and storage optimization +- Network protocol improvements +- Smart contract gas optimization +- Load testing and capacity planning +- Continuous performance monitoring +``` + +--- + +## Security & Cryptography + +### 16. Cryptographic Protocol Design + +**Prompt:** +``` +Design cryptographic protocols for [blockchain application] that: +- Implement zero-knowledge proofs for privacy +- Use advanced signature schemes and multi-party computation +- Provide quantum-resistant security measures +- Enable efficient verification and validation +- Support regulatory compliance and auditability + +Include: +- Cryptographic primitive selection and implementation +- Zero-knowledge circuit design and optimization +- Key management and rotation strategies +- Privacy-preserving computation protocols +- Post-quantum cryptography integration +- Security analysis and formal verification +``` + +### 17. Security Framework Implementation + +**Prompt Template:** +``` +Implement a comprehensive security framework for [blockchain platform] that addresses: +- Threat modeling: [identify attack vectors and vulnerabilities] +- Access control: [authentication, authorization, role management] +- Data protection: [encryption, privacy, confidentiality] +- Network security: [DDoS protection, secure communication] +- Smart contract security: [formal verification, audit processes] + +Include: +- Security architecture and design principles +- Threat detection and response procedures +- Incident response and recovery plans +- Security testing and penetration testing +- Compliance and regulatory requirements +- Security training and awareness programs +``` + +**Example:** +``` +Implement a comprehensive security framework for a DeFi lending protocol that addresses: +- Threat modeling: Flash loan attacks, oracle manipulation, governance attacks, smart contract bugs +- Access control: Multi-signature admin controls, time-locked operations, role-based permissions +- Data protection: User privacy, transaction confidentiality, off-chain data encryption +- Network security: Front-running protection, MEV mitigation, secure RPC endpoints +- Smart contract security: Formal verification, multiple audits, bug bounty programs + +Include: +- Defense-in-depth architecture with multiple security layers +- Real-time monitoring with automated threat detection +- Emergency pause mechanisms and circuit breakers +- Comprehensive testing including fuzzing and property-based testing +- SOC 2 Type II compliance and regular security assessments +- Security-focused developer training and secure coding practices +``` + +### 18. Privacy-Preserving Architecture + +**Prompt:** +``` +Design privacy-preserving architecture for [blockchain application] that: +- Protects user identity and transaction privacy +- Implements selective disclosure mechanisms +- Enables compliance with privacy regulations +- Maintains auditability for authorized parties +- Supports efficient verification and validation + +Include: +- Privacy protocol selection and implementation +- Zero-knowledge proof systems and circuits +- Confidential transaction mechanisms +- Identity management and selective disclosure +- Regulatory compliance and audit trails +- Performance optimization for privacy features +``` + +--- + +## Interoperability & Cross-Chain + +### 19. Cross-Chain Bridge Architecture + +**Prompt:** +``` +Design a cross-chain bridge architecture for [blockchain ecosystems] that: +- Enables secure asset transfers between chains +- Supports multiple token standards and protocols +- Implements robust validation and consensus mechanisms +- Provides efficient liquidity management +- Ensures decentralization and trustlessness + +Include: +- Bridge protocol design and security model +- Validator network and consensus mechanisms +- Liquidity pool management and optimization +- User interface and experience design +- Risk management and insurance mechanisms +- Monitoring and incident response procedures +``` + +### 20. Multi-Chain Protocol Design + +**Prompt:** +``` +Create a multi-chain protocol for [application/service] that: +- Operates seamlessly across multiple blockchains +- Maintains state consistency and synchronization +- Enables efficient cross-chain communication +- Supports chain-specific optimizations +- Provides unified user and developer experience + +Design: +- Protocol architecture and communication patterns +- State management and synchronization mechanisms +- Chain-specific adapter and integration layers +- Unified API and SDK design +- Deployment and governance strategies +- Performance optimization and monitoring +``` + +### 21. Interoperability Standards + +**Prompt:** +``` +Develop interoperability standards for [blockchain ecosystem] that: +- Define common protocols and data formats +- Enable seamless integration between different chains +- Support standardized asset and data transfers +- Provide compatibility with existing standards +- Enable future extensibility and upgrades + +Include: +- Protocol specification and documentation +- Reference implementation and test suites +- Compliance and certification procedures +- Adoption and migration strategies +- Governance and evolution mechanisms +- Community engagement and feedback processes +``` + +--- + +## DeFi & Protocol Design + +### 22. Automated Market Maker (AMM) Design + +**Prompt Template:** +``` +Design an innovative AMM protocol for [trading/liquidity] with these features: +- Pricing mechanism: [constant product, stable swap, concentrated liquidity] +- Fee structure: [dynamic fees, LP rewards, protocol revenue] +- Liquidity incentives: [yield farming, liquidity mining, bribes] +- Impermanent loss mitigation: [insurance, hedging, alternative models] +- MEV protection: [batch auctions, commit-reveal, private mempools] + +Include: +- Mathematical models and pricing algorithms +- Smart contract architecture and gas optimization +- Liquidity provider experience and incentives +- Integration with aggregators and other protocols +- Risk management and security measures +- Governance and parameter adjustment mechanisms +``` + +**Example:** +``` +Design an innovative AMM protocol for stablecoin trading with these features: +- Pricing mechanism: Hybrid curve combining constant product and stable swap +- Fee structure: Dynamic fees based on volatility and volume with 50% to LPs +- Liquidity incentives: Gauge-based voting for reward distribution +- Impermanent loss mitigation: Insurance fund and IL protection tokens +- MEV protection: Commit-reveal scheme with time-weighted average pricing + +Include: +- StableSwap curve with reduced slippage for correlated assets +- Multi-token pool architecture with efficient rebalancing +- Vote-escrowed governance token with time-locked rewards +- Automated insurance payouts based on IL thresholds +- Integration with Flashbots and private mempool solutions +- DAO governance with parameter optimization and fee adjustment +``` + +### 23. Yield Farming Protocol + +**Prompt:** +``` +Create a yield farming protocol for [asset type/strategy] that: +- Implements innovative yield generation strategies +- Provides sustainable and attractive returns +- Manages risk through diversification and hedging +- Enables composability with other DeFi protocols +- Supports governance and community participation + +Include: +- Yield strategy design and implementation +- Risk assessment and management framework +- Token economics and reward distribution +- Smart contract architecture and security +- User interface and experience optimization +- Integration and partnership strategies +``` + +### 24. Derivatives and Synthetic Assets + +**Prompt:** +``` +Design a derivatives protocol for [financial instruments] that: +- Creates synthetic exposure to various assets +- Implements efficient collateralization mechanisms +- Provides accurate price discovery and oracle integration +- Enables complex trading strategies and products +- Manages counterparty and systemic risks + +Include: +- Synthetic asset creation and management +- Collateral and liquidation mechanisms +- Oracle design and price feed aggregation +- Trading interface and order management +- Risk management and insurance protocols +- Regulatory compliance and reporting +``` + +--- + +## Infrastructure & DevOps + +### 25. Blockchain Node Infrastructure + +**Prompt:** +``` +Design blockchain node infrastructure for [network/application] that: +- Provides high availability and reliability +- Supports efficient synchronization and consensus +- Enables monitoring and observability +- Implements security and access controls +- Supports scaling and resource optimization + +Include: +- Node architecture and configuration +- Network topology and peer management +- Storage and database optimization +- Monitoring and alerting systems +- Backup and disaster recovery procedures +- Performance tuning and optimization +``` + +### 26. DevOps and CI/CD Pipeline + +**Prompt Template:** +``` +Implement DevOps and CI/CD pipeline for [blockchain project] that: +- Automates testing, building, and deployment +- Supports multiple environments and networks +- Implements security scanning and compliance checks +- Enables rapid iteration and continuous delivery +- Provides comprehensive monitoring and logging + +Include: +- Pipeline architecture and workflow design +- Testing strategies including unit, integration, and security tests +- Deployment automation and environment management +- Security scanning and vulnerability assessment +- Monitoring, logging, and alerting configuration +- Documentation and team collaboration tools +``` + +**Example:** +``` +Implement DevOps and CI/CD pipeline for a DeFi protocol that: +- Automates Solidity testing, compilation, and deployment across testnets and mainnet +- Supports staging environment with forked mainnet for realistic testing +- Implements Slither, MythX, and custom security checks +- Enables safe mainnet deployments with multi-signature approvals +- Provides real-time monitoring of protocol metrics and user activity + +Include: +- GitHub Actions workflow with Hardhat and Foundry integration +- Comprehensive test suite with fuzzing and property-based testing +- Automated security scanning with manual audit integration +- Gnosis Safe integration for production deployments +- Grafana dashboards with protocol TVL, volume, and health metrics +- Slack/Discord integration for alerts and team communication +``` + +### 27. Monitoring and Observability + +**Prompt:** +``` +Create monitoring and observability system for [blockchain infrastructure] that: +- Tracks network health and performance metrics +- Monitors smart contract execution and gas usage +- Provides real-time alerting and incident response +- Enables capacity planning and optimization +- Supports debugging and troubleshooting + +Include: +- Metrics collection and aggregation strategy +- Dashboard design and visualization +- Alerting rules and escalation procedures +- Log management and analysis tools +- Performance profiling and optimization +- Incident response and post-mortem processes +``` + +--- + +## Governance & Tokenomics + +### 28. DAO Governance Architecture + +**Prompt:** +``` +Design DAO governance architecture for [protocol/organization] that: +- Implements democratic and efficient decision-making +- Balances stakeholder interests and participation +- Provides transparency and accountability +- Enables evolution and adaptation over time +- Manages treasury and resource allocation + +Include: +- Governance token design and distribution +- Voting mechanisms and proposal processes +- Delegation and liquid democracy features +- Treasury management and spending controls +- Dispute resolution and appeals processes +- Governance evolution and upgrade mechanisms +``` + +### 29. Tokenomics Design + +**Prompt Template:** +``` +Create comprehensive tokenomics for [protocol/platform] with these parameters: +- Token utility: [governance, fees, staking, rewards] +- Supply mechanics: [total supply, inflation, burning] +- Distribution: [team, investors, community, treasury] +- Incentive alignment: [user rewards, validator incentives, developer grants] +- Value accrual: [fee sharing, buybacks, staking yields] + +Include: +- Economic model and mechanism design +- Token flow analysis and simulations +- Incentive structure and game theory analysis +- Launch strategy and distribution timeline +- Governance integration and voting power +- Long-term sustainability and evolution +``` + +**Example:** +``` +Create comprehensive tokenomics for a decentralized storage protocol with these parameters: +- Token utility: Storage payments, validator staking, governance voting, network fees +- Supply mechanics: 1B max supply, 2% annual inflation, storage fee burning +- Distribution: 20% team (4yr vest), 15% investors, 40% mining rewards, 25% ecosystem +- Incentive alignment: Storage rewards, retrieval incentives, developer grants +- Value accrual: Fee burning, staking yields, governance premium + +Include: +- Storage mining algorithm with proof-of-spacetime rewards +- Token flow model with supply/demand dynamics simulation +- Game theory analysis of storage provider and user incentives +- Phased launch with testnet rewards and mainnet migration +- Quadratic voting for governance with delegation mechanisms +- Sustainability analysis with fee market and inflation adjustment +``` + +### 30. Economic Security Model + +**Prompt:** +``` +Develop economic security model for [blockchain protocol] that: +- Analyzes attack vectors and economic incentives +- Calculates security budgets and validator rewards +- Models token price impact on network security +- Designs slashing and penalty mechanisms +- Ensures long-term economic sustainability + +Include: +- Security analysis and threat modeling +- Economic incentive design and game theory +- Validator economics and profitability analysis +- Attack cost calculations and security margins +- Token price sensitivity and stability mechanisms +- Long-term sustainability and adaptation strategies +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Security First** - Always prioritize security in architecture decisions +2. **Scalability Planning** - Design for future growth and adoption +3. **Interoperability** - Consider integration with existing systems and protocols +4. **Regulatory Compliance** - Address legal and regulatory requirements early +5. **User Experience** - Focus on usability and developer experience +6. **Economic Sustainability** - Design sustainable tokenomics and incentive structures +7. **Community Governance** - Plan for decentralized governance and community participation + +## Example Workflow for Blockchain Architects + +``` +1. Start with Architecture Design for overall system structure +2. Select Technology Stack based on requirements and constraints +3. Design Smart Contract Architecture for core functionality +4. Choose Consensus Mechanism for network security and performance +5. Plan Scalability Solutions for future growth +6. Implement Security Framework for comprehensive protection +7. Design Interoperability for ecosystem integration +8. Create DeFi Protocols for financial functionality +9. Set up Infrastructure for reliable operations +10. Establish Governance for sustainable evolution +``` + +## Blockchain Technology Integration + +- **Layer 1 Protocols** - Ethereum, Bitcoin, Solana, Avalanche, Cosmos +- **Layer 2 Solutions** - Polygon, Arbitrum, Optimism, StarkNet +- **Development Frameworks** - Hardhat, Truffle, Foundry, Anchor +- **Infrastructure Tools** - IPFS, The Graph, Chainlink, Alchemy +- **Security Tools** - Slither, MythX, Certora, OpenZeppelin +- **Monitoring Solutions** - Tenderly, Blocknative, Dune Analytics + +## Integration with Development Teams + +### Collaboration with Smart Contract Developers +- Use smart contract architecture prompts for secure and efficient code +- Implement testing frameworks for comprehensive coverage +- Provide security guidelines and best practices + +### Working with Frontend Developers +- Design APIs and SDKs for seamless integration +- Create user experience guidelines for Web3 applications +- Implement wallet integration and transaction management + +### Partnership with DevOps Engineers +- Use infrastructure prompts for reliable deployment and operations +- Implement monitoring and alerting for blockchain networks +- Create disaster recovery and backup procedures + +--- + +*This guide is designed to help Blockchain Architects build secure, scalable, and innovative blockchain solutions. Customize the prompts based on your specific project requirements, technology preferences, and business objectives.* \ No newline at end of file diff --git a/hr-manager-hiring-prompts.md b/hr-manager-hiring-prompts.md new file mode 100644 index 0000000..27b6ceb --- /dev/null +++ b/hr-manager-hiring-prompts.md @@ -0,0 +1,793 @@ +# HR Manager Hiring Prompts Guide + +A comprehensive collection of AI prompts specifically designed for HR Managers to streamline hiring processes, create compelling job descriptions, and implement effective talent acquisition strategies. + +## Table of Contents +1. [Job Description Creation](#job-description-creation) +2. [Talent Sourcing & Recruitment](#talent-sourcing--recruitment) +3. [Interview Process Design](#interview-process-design) +4. [Candidate Assessment & Evaluation](#candidate-assessment--evaluation) +5. [Employer Branding & Attraction](#employer-branding--attraction) +6. [Diversity, Equity & Inclusion](#diversity-equity--inclusion) +7. [Compensation & Benefits Strategy](#compensation--benefits-strategy) +8. [Onboarding & Integration](#onboarding--integration) +9. [Recruitment Analytics & Metrics](#recruitment-analytics--metrics) +10. [Legal Compliance & Documentation](#legal-compliance--documentation) + +--- + +## Job Description Creation + +### 1. Comprehensive Job Description Writing + +**Prompt Template:** +``` +You are an expert HR professional. Create a comprehensive job description for [position title] with these requirements: +- Company: [company name and industry] +- Department: [specific department/team] +- Reporting structure: [manager/team lead] +- Experience level: [entry/mid/senior level] +- Work arrangement: [remote/hybrid/on-site] + +Include: +- Compelling job title and summary +- Key responsibilities and duties +- Required and preferred qualifications +- Skills and competencies needed +- Compensation range and benefits +- Company culture and values alignment +- Growth and development opportunities +``` + +**Example:** +``` +You are an expert HR professional. Create a comprehensive job description for Senior Software Engineer with these requirements: +- Company: TechFlow Solutions, a fast-growing fintech startup +- Department: Engineering team (backend focus) +- Reporting structure: Reports to Engineering Manager +- Experience level: Senior level (5+ years) +- Work arrangement: Hybrid (3 days in office, 2 remote) + +Include: +- Compelling job title that attracts top talent +- Key responsibilities including system design and mentoring +- Required qualifications (languages, frameworks, experience) +- Preferred skills (cloud platforms, DevOps, leadership) +- Competitive salary range ($120k-$160k) and equity package +- Company culture emphasizing innovation and work-life balance +- Career advancement opportunities and learning budget +``` + +### 2. Role-Specific Requirements Analysis + +**Prompt:** +``` +Analyze and define specific requirements for [job role] in [industry/company type] that includes: +- Core technical/functional competencies +- Soft skills and behavioral traits +- Industry-specific knowledge requirements +- Certification or educational prerequisites +- Experience level expectations and progression paths + +Create: +- Detailed competency framework +- Skills assessment criteria +- Performance indicators and success metrics +- Career development pathway +- Training and development needs +``` + +### 3. Job Description Optimization + +**Prompt:** +``` +Optimize this job description for [specific goals] by: +- Improving candidate attraction and engagement +- Enhancing SEO and job board visibility +- Ensuring inclusive and bias-free language +- Aligning with current market standards +- Incorporating employer branding elements + +Current job description: [paste existing description] + +Provide: +- Revised job description with improvements +- Explanation of changes made +- Keywords for better searchability +- Suggestions for posting platforms +- A/B testing recommendations +``` + +--- + +## Talent Sourcing & Recruitment + +### 4. Sourcing Strategy Development + +**Prompt Template:** +``` +Develop a comprehensive talent sourcing strategy for [position/department] with these parameters: +- Target candidate profile: [demographics, experience, skills] +- Hiring timeline: [urgency and timeline constraints] +- Budget considerations: [recruitment budget and resources] +- Market conditions: [competitive landscape, talent availability] +- Company constraints: [location, remote work, industry reputation] + +Include: +- Multi-channel sourcing approach +- Passive candidate engagement strategies +- Talent pipeline development +- Competitive intelligence and market analysis +- Success metrics and KPIs +``` + +**Example:** +``` +Develop a comprehensive talent sourcing strategy for Data Scientists with these parameters: +- Target candidate profile: PhD/Masters in data science, 3-7 years experience, Python/R expertise +- Hiring timeline: Need to fill 5 positions within 3 months +- Budget considerations: $15k recruitment budget, internal recruiter + agency support +- Market conditions: High competition, limited talent pool, remote work expectations +- Company constraints: Series B startup, hybrid work model, healthcare industry + +Include: +- LinkedIn, GitHub, Kaggle, and academic conference sourcing +- Passive candidate engagement through thought leadership content +- University partnerships and internship-to-hire programs +- Competitive analysis of compensation and benefits packages +- Metrics: time-to-fill, cost-per-hire, source effectiveness, candidate quality scores +``` + +### 5. Candidate Persona Development + +**Prompt:** +``` +Create detailed candidate personas for [role/department] that include: +- Demographic and professional characteristics +- Career motivations and aspirations +- Preferred communication channels and timing +- Decision-making factors and priorities +- Pain points and challenges in job searching +- Values and cultural fit indicators + +For each persona, provide: +- Sourcing channel recommendations +- Messaging and outreach strategies +- Interview and assessment approaches +- Offer negotiation considerations +- Retention and engagement tactics +``` + +### 6. Recruitment Marketing Strategy + +**Prompt:** +``` +Design a recruitment marketing strategy for [company/role] that: +- Builds employer brand awareness +- Attracts passive candidates +- Showcases company culture and values +- Highlights career growth opportunities +- Differentiates from competitors + +Include: +- Content marketing calendar and themes +- Social media strategy and platforms +- Employee advocacy programs +- Recruitment events and networking +- Measurement and optimization approaches +``` + +--- + +## Interview Process Design + +### 7. Structured Interview Framework + +**Prompt:** +``` +Design a structured interview process for [position] that includes: +- Interview stages and progression criteria +- Interviewer roles and responsibilities +- Question banks for different competencies +- Assessment rubrics and scoring methods +- Candidate experience optimization + +Create: +- Interview guide templates for each stage +- Behavioral and situational question sets +- Technical assessment criteria (if applicable) +- Reference check procedures +- Decision-making framework and documentation +``` + +### 8. Behavioral Interview Questions + +**Prompt Template:** +``` +Create behavioral interview questions for [role/competency] that assess: +- Core competencies: [list specific competencies] +- Leadership and teamwork abilities +- Problem-solving and decision-making skills +- Adaptability and learning agility +- Cultural fit and values alignment + +For each question, provide: +- The specific competency being assessed +- Follow-up probing questions +- Evaluation criteria and red flags +- Example strong and weak responses +- Scoring guidelines and benchmarks +``` + +**Example:** +``` +Create behavioral interview questions for Product Manager role that assess: +- Core competencies: Strategic thinking, stakeholder management, data-driven decision making +- Leadership abilities in cross-functional teams +- Problem-solving in ambiguous situations +- Customer-centric mindset and market awareness +- Cultural fit with innovation and collaboration values + +For each question, provide: +- Clear competency mapping (e.g., "Tell me about a time you had to pivot a product strategy" → Strategic thinking) +- Follow-up questions to dig deeper into decision-making process +- Red flags like blame-shifting or lack of data usage +- Examples of strong responses showing impact and learning +- 1-5 scoring scale with specific behavioral indicators +``` + +### 9. Technical Assessment Design + +**Prompt:** +``` +Design technical assessments for [technical role] that: +- Evaluate job-relevant skills and knowledge +- Provide fair and unbiased evaluation +- Respect candidate time and experience +- Simulate real work scenarios +- Allow for different solution approaches + +Include: +- Assessment format and duration +- Evaluation criteria and rubrics +- Sample problems or case studies +- Interviewer training materials +- Feedback and communication protocols +``` + +--- + +## Candidate Assessment & Evaluation + +### 10. Competency-Based Evaluation + +**Prompt:** +``` +Create a competency-based evaluation framework for [role] that: +- Maps to job requirements and success factors +- Provides objective assessment criteria +- Reduces bias and increases consistency +- Supports data-driven hiring decisions +- Enables candidate comparison and ranking + +Include: +- Competency definitions and behavioral indicators +- Assessment methods for each competency +- Scoring scales and interpretation guidelines +- Interviewer calibration procedures +- Documentation and reporting templates +``` + +### 11. Reference Check Strategy + +**Prompt:** +``` +Develop a comprehensive reference check strategy for [position level] that: +- Verifies candidate claims and experience +- Assesses cultural fit and work style +- Identifies potential performance issues +- Gathers insights for onboarding success +- Maintains legal compliance and confidentiality + +Include: +- Reference selection criteria and requirements +- Structured question sets for different reference types +- Documentation and record-keeping procedures +- Red flag identification and follow-up protocols +- Integration with final hiring decision process +``` + +### 12. Candidate Scoring and Ranking + +**Prompt:** +``` +Create a candidate scoring and ranking system for [hiring process] that: +- Weights different assessment components appropriately +- Provides transparent and defensible decisions +- Enables comparison across different interview panels +- Supports diversity and inclusion goals +- Facilitates hiring committee discussions + +Include: +- Scoring methodology and calculations +- Weighting rationale for different criteria +- Calibration and consistency checks +- Reporting and visualization tools +- Decision-making guidelines and thresholds +``` + +--- + +## Employer Branding & Attraction + +### 13. Employer Value Proposition + +**Prompt Template:** +``` +Develop an employer value proposition (EVP) for [company/department] that: +- Differentiates from competitors in [industry] +- Appeals to [target candidate demographics] +- Aligns with company mission and values +- Addresses candidate motivations and needs +- Supports recruitment and retention goals + +Include: +- Core EVP messaging and themes +- Proof points and supporting evidence +- Channel-specific adaptations +- Employee testimonials and stories +- Measurement and feedback mechanisms +``` + +**Example:** +``` +Develop an employer value proposition (EVP) for a renewable energy startup that: +- Differentiates from traditional energy companies and tech startups +- Appeals to environmentally conscious engineers and business professionals +- Aligns with mission to accelerate clean energy adoption +- Addresses desires for meaningful work and career growth +- Supports recruitment of top talent in competitive market + +Include: +- Core messaging around impact, innovation, and growth opportunities +- Proof points like sustainability metrics, patent portfolio, funding milestones +- LinkedIn, job board, and career page adaptations +- Employee stories about project impact and career development +- Surveys and feedback loops to validate and refine messaging +``` + +### 14. Recruitment Content Strategy + +**Prompt:** +``` +Create a recruitment content strategy for [company/role] that: +- Showcases company culture and work environment +- Highlights employee experiences and career journeys +- Demonstrates thought leadership and expertise +- Builds trust and credibility with candidates +- Drives engagement and applications + +Include: +- Content themes and messaging pillars +- Content formats and distribution channels +- Employee advocacy and participation plans +- Content calendar and production workflow +- Performance metrics and optimization strategies +``` + +### 15. Candidate Experience Optimization + +**Prompt:** +``` +Design an optimal candidate experience for [hiring process] that: +- Creates positive impressions at every touchpoint +- Provides transparency and clear communication +- Respects candidate time and effort +- Gathers feedback for continuous improvement +- Supports employer brand regardless of hiring outcome + +Include: +- Candidate journey mapping and touchpoint analysis +- Communication templates and timing +- Feedback collection and response protocols +- Technology and process improvements +- Training for hiring team members +``` + +--- + +## Diversity, Equity & Inclusion + +### 16. Inclusive Hiring Practices + +**Prompt:** +``` +Develop inclusive hiring practices for [organization] that: +- Remove bias from job descriptions and requirements +- Expand sourcing to underrepresented communities +- Ensure fair and equitable assessment processes +- Create welcoming interview experiences +- Support diverse candidate success + +Include: +- Bias audit and mitigation strategies +- Diverse sourcing channels and partnerships +- Structured interview training and calibration +- Accommodation and accessibility considerations +- Metrics and accountability measures +``` + +### 17. Diversity Sourcing Strategy + +**Prompt:** +``` +Create a diversity sourcing strategy for [role/department] that: +- Identifies and engages underrepresented talent pools +- Partners with diversity-focused organizations +- Leverages employee networks and referrals +- Addresses systemic barriers to application +- Measures and tracks diversity outcomes + +Include: +- Target diversity goals and metrics +- Sourcing channel identification and activation +- Partnership development and management +- Bias interruption and inclusive messaging +- Progress tracking and reporting mechanisms +``` + +### 18. Bias Mitigation Framework + +**Prompt:** +``` +Implement a bias mitigation framework for [hiring process] that: +- Identifies potential bias points in the process +- Implements evidence-based interventions +- Trains hiring team on unconscious bias +- Monitors outcomes for bias indicators +- Continuously improves based on data + +Include: +- Bias assessment and mapping +- Intervention design and implementation +- Training curriculum and delivery methods +- Monitoring dashboard and alerts +- Feedback loops and process improvements +``` + +--- + +## Compensation & Benefits Strategy + +### 19. Compensation Benchmarking + +**Prompt Template:** +``` +Conduct compensation benchmarking for [role/level] in [location/market] that: +- Analyzes market rates and trends +- Considers company size, industry, and stage +- Evaluates total compensation packages +- Identifies competitive positioning strategy +- Supports offer negotiation and decisions + +Include: +- Data sources and methodology +- Peer company identification and analysis +- Base salary, bonus, and equity comparisons +- Benefits and perquisites evaluation +- Recommendations for competitive positioning +``` + +**Example:** +``` +Conduct compensation benchmarking for Senior Data Engineer in San Francisco Bay Area that: +- Analyzes market rates from Glassdoor, Levels.fyi, and salary surveys +- Considers Series B startup vs. FAANG and established tech companies +- Evaluates base salary, annual bonus, equity grants, and benefits +- Identifies 75th percentile positioning strategy to attract top talent +- Supports offer negotiations within budget constraints + +Include: +- Multiple data sources with sample sizes and recency +- Peer companies: similar stage startups, established tech, consulting firms +- Total compensation ranges: $140k-$200k base, 10-20% bonus, 0.1-0.3% equity +- Benefits comparison: health insurance, 401k, PTO, learning budgets +- Recommendation: Target 75th percentile with competitive equity upside +``` + +### 20. Benefits Package Design + +**Prompt:** +``` +Design a competitive benefits package for [company type/size] that: +- Meets diverse employee needs and preferences +- Aligns with company values and culture +- Fits within budget and administrative constraints +- Differentiates from competitors +- Supports recruitment and retention goals + +Include: +- Core benefits requirements and options +- Voluntary and supplemental benefits +- Work-life balance and wellness programs +- Professional development and learning benefits +- Communication and enrollment strategies +``` + +### 21. Offer Strategy and Negotiation + +**Prompt:** +``` +Develop offer strategy and negotiation guidelines for [role/level] that: +- Balances candidate expectations with budget constraints +- Maintains internal equity and fairness +- Provides flexibility for different candidate priorities +- Supports quick decision-making and closure +- Protects company interests and relationships + +Include: +- Offer structure and component flexibility +- Negotiation parameters and approval processes +- Alternative value propositions and creative solutions +- Timeline management and urgency tactics +- Documentation and communication protocols +``` + +--- + +## Onboarding & Integration + +### 22. Pre-boarding Strategy + +**Prompt:** +``` +Create a pre-boarding strategy for [role/company] that: +- Maintains candidate engagement between offer and start date +- Prepares new hires for successful integration +- Reduces anxiety and buyer's remorse +- Builds excitement and commitment +- Ensures smooth first-day experience + +Include: +- Communication timeline and touchpoints +- Information sharing and preparation materials +- Technology setup and access provisioning +- Team introductions and relationship building +- First-day and first-week planning +``` + +### 23. Role-Specific Onboarding Plan + +**Prompt:** +``` +Design a role-specific onboarding plan for [position] that: +- Accelerates time to productivity +- Builds necessary relationships and networks +- Provides role-specific training and resources +- Sets clear expectations and success metrics +- Integrates with company culture and values + +Include: +- 30-60-90 day milestone and goal setting +- Training curriculum and learning resources +- Mentorship and buddy system assignment +- Performance check-ins and feedback loops +- Success metrics and evaluation criteria +``` + +### 24. New Hire Integration Support + +**Prompt:** +``` +Develop new hire integration support for [department/team] that: +- Facilitates social and professional connections +- Provides ongoing guidance and resources +- Addresses common challenges and obstacles +- Measures integration success and satisfaction +- Supports long-term retention and engagement + +Include: +- Integration milestone tracking +- Support resource identification and access +- Feedback collection and response mechanisms +- Manager and team training on integration +- Continuous improvement based on outcomes +``` + +--- + +## Recruitment Analytics & Metrics + +### 25. Hiring Metrics Dashboard + +**Prompt Template:** +``` +Create a comprehensive hiring metrics dashboard for [organization/department] that tracks: +- Recruitment funnel performance and conversion rates +- Time-to-fill and time-to-hire metrics +- Cost-per-hire and budget utilization +- Source effectiveness and ROI +- Quality of hire and retention rates + +Include: +- Key performance indicators and benchmarks +- Data visualization and reporting formats +- Automated data collection and updates +- Stakeholder-specific views and insights +- Action triggers and improvement recommendations +``` + +**Example:** +``` +Create a comprehensive hiring metrics dashboard for Engineering department that tracks: +- Recruitment funnel: applications → phone screens → technical interviews → offers → acceptances +- Time-to-fill: average 45 days target, tracking by role level and urgency +- Cost-per-hire: $8k target including agency fees, job boards, and internal costs +- Source effectiveness: LinkedIn, referrals, agencies, job boards with quality scores +- Quality metrics: 90-day retention, performance ratings, hiring manager satisfaction + +Include: +- Weekly/monthly KPI summaries with red/yellow/green status indicators +- Interactive charts showing trends and drill-down capabilities +- Automated data feeds from ATS, HRIS, and performance management systems +- Executive summary for leadership, detailed views for recruiters and hiring managers +- Alert system for metrics falling below thresholds with improvement action plans +``` + +### 26. Recruitment ROI Analysis + +**Prompt:** +``` +Conduct recruitment ROI analysis for [hiring initiative/program] that: +- Calculates total investment and associated costs +- Measures hiring outcomes and business impact +- Compares different sourcing channels and methods +- Identifies optimization opportunities +- Supports budget allocation and strategy decisions + +Include: +- Cost calculation methodology and components +- Benefit quantification and measurement approaches +- ROI calculation and interpretation guidelines +- Comparative analysis across channels and programs +- Recommendations for investment optimization +``` + +### 27. Predictive Hiring Analytics + +**Prompt:** +``` +Develop predictive hiring analytics for [organization] that: +- Forecasts hiring needs based on business growth +- Predicts candidate success and retention likelihood +- Identifies optimal sourcing strategies and timing +- Anticipates market conditions and competition +- Supports proactive talent planning + +Include: +- Data requirements and collection strategies +- Predictive modeling approaches and algorithms +- Validation and accuracy measurement methods +- Implementation and integration considerations +- Actionable insights and decision support tools +``` + +--- + +## Legal Compliance & Documentation + +### 28. Hiring Compliance Framework + +**Prompt:** +``` +Establish a hiring compliance framework for [organization/jurisdiction] that: +- Ensures adherence to employment laws and regulations +- Protects against discrimination and bias claims +- Maintains proper documentation and records +- Supports audit and investigation requirements +- Provides training and guidance for hiring teams + +Include: +- Legal requirement identification and mapping +- Policy and procedure documentation +- Training curriculum and delivery methods +- Documentation templates and retention policies +- Monitoring and audit procedures +``` + +### 29. Interview Documentation Standards + +**Prompt:** +``` +Create interview documentation standards for [organization] that: +- Capture objective assessment information +- Support hiring decisions and rationale +- Protect against legal challenges +- Enable performance tracking and improvement +- Maintain candidate privacy and confidentiality + +Include: +- Documentation templates and formats +- Required information and assessment criteria +- Storage and retention procedures +- Access controls and privacy protections +- Training on proper documentation practices +``` + +### 30. Background Check and Verification + +**Prompt:** +``` +Implement background check and verification procedures for [role/organization] that: +- Verify candidate credentials and experience +- Assess potential risks and red flags +- Comply with legal requirements and restrictions +- Maintain fairness and consistency +- Protect candidate rights and privacy + +Include: +- Background check scope and requirements +- Vendor selection and management procedures +- Candidate consent and communication protocols +- Decision-making criteria and appeal processes +- Documentation and record-keeping requirements +``` + +--- + +## Best Practices Reminders + +When using these prompts, remember to: + +1. **Ensure legal compliance** - Always consider employment laws and regulations +2. **Focus on candidate experience** - Create positive interactions at every touchpoint +3. **Promote diversity and inclusion** - Actively work to reduce bias and increase representation +4. **Use data-driven decisions** - Leverage metrics and analytics for continuous improvement +5. **Maintain confidentiality** - Protect candidate and employee information appropriately +6. **Document thoroughly** - Keep detailed records for legal protection and process improvement +7. **Stay current with trends** - Adapt to changing market conditions and best practices + +## Example Workflow for HR Managers + +``` +1. Start with Job Description Creation for clear role definition +2. Develop Sourcing Strategy for targeted candidate attraction +3. Design Interview Process for consistent evaluation +4. Implement Assessment Framework for objective decisions +5. Create Employer Branding for competitive positioning +6. Ensure DEI Practices for inclusive hiring +7. Establish Compensation Strategy for competitive offers +8. Plan Onboarding Process for successful integration +9. Monitor Analytics and Metrics for continuous improvement +10. Maintain Compliance Framework for legal protection +``` + +## HR Technology Integration + +- **Applicant Tracking Systems (ATS)** - Leverage technology for process automation and tracking +- **HRIS Integration** - Connect hiring data with employee lifecycle management +- **Assessment Platforms** - Use validated tools for skills and personality assessment +- **Video Interviewing** - Implement remote interview capabilities and recording +- **Analytics Dashboards** - Create real-time visibility into hiring performance +- **AI and Automation** - Use technology to reduce bias and improve efficiency + +## Integration with Business Teams + +### Collaboration with Hiring Managers +- Use interview design prompts for structured evaluation processes +- Implement assessment frameworks for consistent candidate evaluation +- Provide training on bias mitigation and inclusive practices + +### Working with Leadership +- Use analytics prompts for strategic workforce planning +- Implement ROI analysis for budget justification and optimization +- Create executive dashboards for visibility into hiring performance + +### Partnership with Legal/Compliance +- Use compliance framework prompts for legal protection +- Implement documentation standards for audit readiness +- Ensure background check procedures meet regulatory requirements + +--- + +*This guide is designed to help HR Managers build effective, compliant, and inclusive hiring processes. Customize the prompts based on your specific organizational needs, industry requirements, and legal jurisdiction.* \ No newline at end of file diff --git a/job-specific-prompts-index.md b/job-specific-prompts-index.md index dcab2ee..08500cb 100644 --- a/job-specific-prompts-index.md +++ b/job-specific-prompts-index.md @@ -2,6 +2,16 @@ A comprehensive collection of AI prompts tailored for different software engineering roles and specializations. Each guide contains role-specific scenarios, best practices, and optimized prompts to accelerate development and solve common challenges. +## Foundational Communication Guide + +### Essential for All Developers +- **[LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md)** - Master effective communication with AI assistants + - CLEAR framework and STAR method for structured prompts + - Context management and progressive disclosure techniques + - Debugging and troubleshooting communication patterns + - Architecture discussions and collaborative problem solving + - Advanced techniques like Socratic method and rubber duck debugging + ## Available Guides ### Frontend Development @@ -27,6 +37,14 @@ A comprehensive collection of AI prompts tailored for different software enginee - RESTful API development and GraphQL - Authentication, middleware, and deployment +### Blockchain & Web3 +- **[Blockchain Architect](blockchain-architect-prompts.md)** - Complete guide for Blockchain Architects and Web3 developers + - Blockchain architecture design and technology stack selection + - Smart contract architecture and DeFi protocol design + - Consensus mechanisms and scalability solutions + - Security, cryptography, and interoperability + - Infrastructure, governance, and tokenomics + ### Design & User Experience - **[UI Designer (Figma)](ui-designer-figma-prompts.md)** - Complete guide for UI Designers using Figma - Interactive prototype creation and design systems @@ -52,6 +70,15 @@ A comprehensive collection of AI prompts tailored for different software enginee - Product strategy, roadmapping, and go-to-market - Data analysis, metrics, and stakeholder communication +### Human Resources & Talent +- **[HR Manager (Hiring & Recruitment)](hr-manager-hiring-prompts.md)** - Comprehensive guide for HR Managers + - Job description creation and optimization + - Talent sourcing and recruitment strategies + - Interview process design and candidate assessment + - Employer branding and diversity initiatives + - Compensation strategy and onboarding processes + - Recruitment analytics and legal compliance + ### Coming Soon - **Python Backend Engineer** (Django/FastAPI) - **DevOps Engineer** (Docker, Kubernetes, CI/CD) @@ -62,21 +89,33 @@ A comprehensive collection of AI prompts tailored for different software enginee ## How to Choose the Right Guide +### Start with Communication Fundamentals +**All developers should begin with**: [LLM Communication Techniques](llm-communication-techniques-for-developers.md) +- Learn to structure thoughts clearly and concisely +- Master prompt engineering for technical scenarios +- Understand context management strategies +- Practice effective debugging communication +- Develop collaborative problem-solving skills + ### By Technology Stack - **React/Next.js Frontend** → [Frontend React/Next.js Guide](frontend-react-nextjs-prompts.md) - **Rust + Actix-web Backend** → [Rust Backend Guide](rust-backend-engineer-prompts.md) - **Node.js + Sails.js Backend** → [Node.js Sails.js Guide](nodejs-sailsjs-backend-prompts.md) +- **Blockchain/Web3 Development** → [Blockchain Architect Guide](blockchain-architect-prompts.md) - **Figma Design** → [UI Designer Figma Guide](ui-designer-figma-prompts.md) - **Pytest Testing** → [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) - **Product Management** → [Product Manager Guide](product-manager-prompts.md) +- **HR & Recruitment** → [HR Manager Guide](hr-manager-hiring-prompts.md) - **Python Backend** → Coming soon ### By Role Responsibilities - **Frontend Focus**: UI/UX, component development, state management - **Backend Focus**: APIs, databases, authentication, performance +- **Blockchain Focus**: Smart contracts, DeFi protocols, consensus mechanisms - **Design Focus**: Prototyping, design systems, user experience - **Testing Focus**: Test automation, quality assurance, CI/CD - **Product Management**: Strategy, research, prototyping, stakeholder communication +- **HR & Talent**: Hiring, recruitment, job descriptions, candidate assessment - **Full-Stack**: Use both frontend and backend guides - **DevOps Focus**: Infrastructure, deployment, monitoring @@ -84,74 +123,94 @@ A comprehensive collection of AI prompts tailored for different software enginee - **Junior Developers**: Start with basic setup and component/API development prompts - **Mid-Level Developers**: Focus on architecture, testing, and optimization prompts - **Senior Developers**: Use advanced patterns, performance, and system design prompts +- **Architects**: Use blockchain architecture and system design prompts - **Designers**: Begin with prototype and component prompts, advance to design systems - **Test Engineers**: Start with framework setup, progress to advanced testing patterns - **Product Managers**: Begin with user research and prototype prompts, advance to strategy +- **HR Managers**: Start with job description creation, advance to analytics and compliance ## Universal Prompts for All Roles -### 1. Code Review and Quality +### 1. Effective Communication Check ``` -Review this code for: -- Best practices adherence -- Security vulnerabilities -- Performance issues -- Code maintainability -- Documentation quality - -[paste code] - -Provide specific recommendations for improvement. +Using the CLEAR framework, help me structure this request: +Context: [Current situation and environment] +Language: [Technical terms and scope] +Expectations: [What I want as output] +Actions: [Specific things to do] +Results: [How I'll validate success] + +My current request: [Your original question/need] ``` -### 2. Architecture Design +### 2. Progressive Problem Solving ``` -Design a [system type] architecture for [use case] with these requirements: -- [Requirement 1] -- [Requirement 2] -- [Requirement 3] +Let's use progressive disclosure to solve this step by step: -Consider scalability, maintainability, and performance. Include technology recommendations and trade-offs. -``` +High-level question: [Your main challenge] -### 3. Debugging Assistant -``` -Help me debug this issue: -Problem: [describe the problem] -Expected behavior: [what should happen] -Actual behavior: [what's happening] -Code context: [relevant code snippets] -Error messages: [any error messages] - -Provide step-by-step debugging approach and potential solutions. +Based on your response, I'll ask follow-up questions to drill down into: +- Implementation details +- Edge cases and error handling +- Testing and validation approaches +- Performance and optimization considerations ``` -### 4. Documentation Generation +### 3. Context-Rich Code Review ``` -Generate comprehensive documentation for this [component/function/API]: -[paste code] +CODE REVIEW REQUEST using structured communication: -Include: -- Purpose and functionality -- Parameters and return values -- Usage examples -- Edge cases and limitations -- Integration guidelines -``` +PURPOSE: [What this code accomplishes] +CONTEXT: [Technology stack and constraints] +CHANGES: [Summary of modifications] +CONCERNS: [Specific areas of uncertainty] +FOCUS: [What to pay attention to] -### 5. Test Case Generation +[CODE BLOCK] + +Specific questions: +1. [Technical concern #1] +2. [Performance/security question] +3. [Maintainability consideration] ``` -Generate comprehensive test cases for this [component/function]: -[paste code] -Include: -- Unit tests for core functionality -- Edge case testing -- Error scenario testing -- Integration tests if applicable -- Performance tests if relevant +### 4. Collaborative Architecture Discussion +``` +COLLABORATIVE ARCHITECTURE SESSION: +Let's work together on: [System/component design challenge] + +My current thinking: +- Approach: [How I'm considering solving it] +- Constraints: [Technical and business limitations] +- Concerns: [What worries me about this approach] +- Unknowns: [Areas where I need guidance] + +Please: +- Challenge my assumptions +- Suggest alternative approaches +- Point out potential issues I haven't considered +- Help me think through edge cases and failure scenarios +``` -Use [testing framework] and follow best practices. +### 5. Structured Debugging Session +``` +DEBUGGING SESSION using systematic approach: + +PROBLEM: [Clear problem statement] +ENVIRONMENT: [Technical context and setup] +SYMPTOMS: [What's actually happening] +EXPECTED: [What should happen instead] +INVESTIGATION: [What I've already tried] +HYPOTHESIS: [What I think might be wrong] + +CODE CONTEXT: +[Relevant code sections] + +ASSISTANCE NEEDED: +- Logic review and reasoning validation +- Alternative debugging strategies +- Tool recommendations +- Pattern recognition from similar issues ``` ## Cross-Role Collaboration Prompts @@ -213,6 +272,34 @@ Include: - Risk assessment and mitigation strategies ``` +### HR-Engineering Collaboration +``` +Create technical hiring strategy for [engineering role] that aligns HR and engineering needs: +Role requirements: [technical skills and experience needed] +Team dynamics: [cultural fit and collaboration needs] +Growth trajectory: [career development and advancement] + +Include: +- Technical assessment design and evaluation criteria +- Interview process with engineering team involvement +- Onboarding plan with technical mentorship +- Performance evaluation and career development framework +``` + +### Blockchain-Traditional Development Integration +``` +Create integration strategy between blockchain and traditional systems for [use case]: +Blockchain requirements: [decentralization, security, transparency needs] +Traditional system constraints: [existing infrastructure, compliance, performance] +User experience goals: [seamless interaction, familiar interfaces] + +Include: +- Hybrid architecture design with on-chain and off-chain components +- API design for blockchain integration +- User authentication and wallet management +- Data synchronization and consistency strategies +``` + ### DevOps-Development Integration ``` Create deployment strategy for [application] with: @@ -264,6 +351,22 @@ Include: 7. **Integration**: Use cross-role collaboration prompts 8. **Deployment**: Use DevOps prompts for deployment strategy +### Blockchain Product Development +1. **Research Phase**: Use Product Manager user research prompts +2. **Architecture Phase**: Use Blockchain Architect system design prompts +3. **Smart Contract Development**: Use Blockchain Architect smart contract prompts +4. **Frontend Integration**: Use Frontend development with Web3 integration +5. **Testing Phase**: Use Test Engineer prompts adapted for blockchain testing +6. **Security Audit**: Use Blockchain Architect security framework prompts +7. **Launch Phase**: Use Product Manager go-to-market prompts + +### Hiring and Team Building +1. **Role Definition**: Use HR Manager job description prompts +2. **Technical Assessment**: Use role-specific technical prompts for evaluation +3. **Interview Process**: Use HR Manager interview design prompts +4. **Onboarding**: Use HR Manager onboarding prompts with technical mentorship +5. **Performance Management**: Use role-specific performance evaluation prompts + ### Product Development Cycle 1. **Research Phase**: Use Product Manager user research prompts 2. **Strategy Phase**: Use Product Manager strategy and roadmap prompts diff --git a/llm-communication-techniques-for-developers.md b/llm-communication-techniques-for-developers.md new file mode 100644 index 0000000..9e0e35a --- /dev/null +++ b/llm-communication-techniques-for-developers.md @@ -0,0 +1,823 @@ +# LLM Communication Techniques for Developers + +A comprehensive guide to effective communication strategies with Large Language Models (LLMs) for robust software development. Learn how to structure thoughts, craft precise prompts, and maintain productive conversations with AI assistants. + +## Table of Contents +1. [Fundamental Communication Principles](#fundamental-communication-principles) +2. [Prompt Engineering for Developers](#prompt-engineering-for-developers) +3. [Context Management Strategies](#context-management-strategies) +4. [Structured Problem-Solving Frameworks](#structured-problem-solving-frameworks) +5. [Code-Specific Communication Patterns](#code-specific-communication-patterns) +6. [Debugging and Troubleshooting Communication](#debugging-and-troubleshooting-communication) +7. [Architecture and Design Discussions](#architecture-and-design-discussions) +8. [Iterative Development Communication](#iterative-development-communication) +9. [Documentation and Knowledge Transfer](#documentation-and-knowledge-transfer) +10. [Advanced Communication Techniques](#advanced-communication-techniques) + +--- + +## Fundamental Communication Principles + +### 1. The CLEAR Framework + +**C**ontext - **L**anguage - **E**xpectations - **A**ctions - **R**esults + +**Context Setting:** +``` +I'm working on a [project type] using [technology stack]. +Current situation: [brief description] +My role: [your position/responsibility] +Team context: [team size, experience level, constraints] +``` + +**Language Precision:** +``` +Technical terms: Use specific terminology +Scope boundaries: Define what's included/excluded +Assumptions: State what you're assuming +Constraints: Mention limitations upfront +``` + +**Clear Expectations:** +``` +Expected output: [code, explanation, analysis, recommendations] +Format preference: [structured list, code blocks, diagrams] +Detail level: [high-level overview, detailed implementation, step-by-step] +Timeline: [immediate, planning phase, long-term consideration] +``` + +**Actionable Requests:** +``` +Specific actions: "Generate", "Review", "Optimize", "Explain" +Measurable outcomes: "Reduce latency by X", "Improve coverage to Y%" +Concrete deliverables: "Working code", "Test cases", "Documentation" +``` + +**Results Validation:** +``` +Success criteria: How will you know it worked? +Testing approach: How will you validate the solution? +Feedback loop: What will you do with the output? +``` + +### 2. The Inverted Pyramid Structure + +Start with the most critical information first, then provide supporting details. + +**Template:** +``` +IMMEDIATE NEED: [What you need right now] +CONTEXT: [Why you need it] +CONSTRAINTS: [What limitations exist] +DETAILS: [Additional specifications] +BACKGROUND: [Nice-to-have context] +``` + +**Example:** +``` +IMMEDIATE NEED: Fix memory leak in Node.js application causing crashes +CONTEXT: Production service handling 10k+ requests/minute, crashes every 2 hours +CONSTRAINTS: Cannot restart service during business hours (9 AM - 6 PM EST) +DETAILS: Using Express.js 4.18, MongoDB with Mongoose, Redis for caching +BACKGROUND: Legacy codebase inherited from previous team, limited documentation +``` + +### 3. Precision in Technical Language + +**Instead of vague terms:** +- "It's slow" → "Response time increased from 200ms to 2.5s" +- "It's broken" → "Function returns undefined instead of expected array" +- "Make it better" → "Reduce memory usage by 30% while maintaining current throughput" + +**Use specific technical vocabulary:** +- "Optimize" → "Reduce time complexity", "Minimize memory allocation", "Improve cache hit rate" +- "Fix" → "Resolve race condition", "Handle null pointer exception", "Correct algorithm logic" +- "Improve" → "Refactor for readability", "Enhance error handling", "Increase test coverage" + +--- + +## Prompt Engineering for Developers + +### 4. The STAR Method for Technical Prompts + +**S**ituation - **T**ask - **A**ction - **R**esult + +**Template:** +``` +SITUATION: [Current technical context and environment] +TASK: [Specific technical challenge or requirement] +ACTION: [What you want the LLM to do] +RESULT: [Expected outcome and success criteria] +``` + +**Example:** +``` +SITUATION: Building a microservices architecture with Docker containers, using Node.js and PostgreSQL +TASK: Implement distributed tracing to monitor request flows across 5 services +ACTION: Design a tracing solution using OpenTelemetry with Jaeger backend +RESULT: Complete implementation with code examples, configuration files, and monitoring dashboard setup +``` + +### 5. Multi-Layered Prompt Structure + +**Layer 1: Core Request** +``` +Primary objective: [Main thing you want] +``` + +**Layer 2: Technical Context** +``` +Technology stack: [Languages, frameworks, tools] +Current architecture: [System design overview] +Performance requirements: [Specific metrics] +``` + +**Layer 3: Constraints and Preferences** +``` +Must have: [Non-negotiable requirements] +Should have: [Preferred features] +Could have: [Nice-to-have additions] +Won't have: [Explicit exclusions] +``` + +**Layer 4: Output Specifications** +``` +Format: [Code blocks, explanations, diagrams] +Detail level: [Implementation-ready, conceptual, reference] +Examples: [Include working examples, test cases] +``` + +### 6. Progressive Disclosure Technique + +Start with a high-level request, then drill down based on the response. + +**Initial Prompt:** +``` +I need to implement user authentication for a React application. +What are the main approaches and their trade-offs? +``` + +**Follow-up Prompts:** +``` +Based on your JWT recommendation, show me the implementation for: +1. Login component with form validation +2. Protected route wrapper +3. Token refresh mechanism +4. Logout functionality +``` + +**Deep Dive Prompts:** +``` +For the token refresh mechanism you showed: +- How do I handle race conditions when multiple requests trigger refresh? +- What's the best way to queue pending requests during token refresh? +- How should I handle refresh token expiration? +``` + +--- + +## Context Management Strategies + +### 7. Context Anchoring + +Establish and maintain context throughout the conversation. + +**Context Anchor Template:** +``` +PROJECT CONTEXT: +- Application: [Type and purpose] +- Tech Stack: [Primary technologies] +- Team: [Size and experience] +- Timeline: [Development phase and deadlines] +- Constraints: [Technical and business limitations] + +CURRENT FOCUS: +- Feature: [What you're working on] +- Goal: [Specific objective] +- Blockers: [Current challenges] +``` + +**Maintaining Context:** +``` +Continuing with our [project name] discussion... +Building on the [previous solution/approach]... +Given our [constraint/requirement] from earlier... +``` + +### 8. Context Compression + +When conversations get long, compress previous context into concise summaries. + +**Compression Template:** +``` +SUMMARY OF PREVIOUS DISCUSSION: +- Problem: [Core issue identified] +- Solution approach: [Chosen strategy] +- Implementation status: [What's been done] +- Current challenge: [New issue or next step] + +NEW REQUEST: +[Current specific need] +``` + +### 9. Context Switching Signals + +Clearly indicate when changing topics or focus areas. + +**Switching Signals:** +``` +"Shifting focus to..." +"Moving to a different aspect..." +"New topic: ..." +"Changing context from X to Y..." +"Pivoting to discuss..." +``` + +--- + +## Structured Problem-Solving Frameworks + +### 10. The 5W1H Technical Framework + +**Who:** Stakeholders and users affected +**What:** Specific technical problem or requirement +**When:** Timeline and deadlines +**Where:** Environment and platform constraints +**Why:** Business justification and goals +**How:** Technical approach and implementation + +**Template:** +``` +WHO: [Users, team members, systems affected] +WHAT: [Precise technical problem statement] +WHEN: [Deadlines, milestones, time constraints] +WHERE: [Environment, platform, infrastructure] +WHY: [Business value, technical necessity] +HOW: [Preferred approach, constraints, alternatives] +``` + +### 11. Root Cause Analysis Communication + +**Problem Statement Framework:** +``` +SYMPTOM: [What users/systems experience] +IMPACT: [Business and technical consequences] +FREQUENCY: [How often it occurs] +ENVIRONMENT: [Where it happens] +REPRODUCTION: [Steps to recreate] +HYPOTHESIS: [Initial theory about cause] +``` + +**Investigation Request:** +``` +Help me analyze this issue using: +1. Timeline analysis: [When did it start?] +2. Change correlation: [What changed recently?] +3. Pattern identification: [Are there commonalities?] +4. Dependency mapping: [What systems are involved?] +5. Data analysis: [What logs/metrics show?] +``` + +### 12. Solution Evaluation Framework + +**Criteria-Based Evaluation:** +``` +SOLUTION OPTIONS: [List alternatives] + +EVALUATION CRITERIA: +- Technical feasibility: [Implementation complexity] +- Performance impact: [Speed, memory, scalability] +- Maintenance burden: [Long-term support needs] +- Risk assessment: [Potential failure points] +- Resource requirements: [Time, people, infrastructure] +- Integration complexity: [How it fits with existing systems] + +RECOMMENDATION: [Preferred option with justification] +``` + +--- + +## Code-Specific Communication Patterns + +### 13. Code Review Communication + +**Review Request Template:** +``` +CODE REVIEW REQUEST: +Purpose: [What this code accomplishes] +Changes: [Summary of modifications] +Testing: [How it was tested] +Concerns: [Areas you're unsure about] +Focus areas: [What to pay attention to] + +[CODE BLOCK] + +Specific questions: +1. [Specific concern #1] +2. [Specific concern #2] +3. [Performance/security/maintainability question] +``` + +### 14. Implementation Guidance Requests + +**Feature Implementation Template:** +``` +FEATURE REQUEST: +Functionality: [What it should do] +User story: [As a X, I want Y, so that Z] +Acceptance criteria: [Specific requirements] +Technical constraints: [Limitations to consider] + +IMPLEMENTATION GUIDANCE NEEDED: +- Architecture approach: [How to structure the solution] +- Technology choices: [Which tools/libraries to use] +- Integration points: [How it connects to existing code] +- Testing strategy: [How to ensure quality] +- Performance considerations: [Scalability requirements] +``` + +### 15. Code Optimization Requests + +**Optimization Template:** +``` +OPTIMIZATION TARGET: +Current performance: [Specific metrics] +Target performance: [Desired improvements] +Constraints: [What cannot be changed] + +CURRENT CODE: +[Code block with performance issues] + +ANALYSIS REQUEST: +1. Bottleneck identification: [Where are the slow parts?] +2. Algorithmic improvements: [Better approaches?] +3. Data structure optimization: [More efficient structures?] +4. Caching opportunities: [What can be cached?] +5. Parallel processing: [What can run concurrently?] +``` + +--- + +## Debugging and Troubleshooting Communication + +### 16. Bug Report Structure + +**Comprehensive Bug Report:** +``` +BUG REPORT: +Summary: [One-line description] +Environment: [OS, browser, versions] +Steps to reproduce: +1. [Step 1] +2. [Step 2] +3. [Step 3] + +Expected behavior: [What should happen] +Actual behavior: [What actually happens] +Error messages: [Exact error text] +Logs: [Relevant log entries] +Screenshots: [If applicable] + +Additional context: +- Frequency: [Always, sometimes, rarely] +- Impact: [Critical, major, minor] +- Workaround: [Temporary solution if any] +``` + +### 17. Debugging Session Communication + +**Debugging Request Template:** +``` +DEBUGGING SESSION: +Problem: [Clear problem statement] +Hypothesis: [What you think might be wrong] +Investigation done: [What you've already tried] +Current state: [Where you're stuck] + +CODE CONTEXT: +[Relevant code sections] + +DEBUGGING ASSISTANCE NEEDED: +1. Logic review: [Check my reasoning] +2. Alternative approaches: [Different debugging strategies] +3. Tool recommendations: [Better debugging tools] +4. Pattern recognition: [Similar issues you've seen] +``` + +### 18. Performance Investigation + +**Performance Analysis Request:** +``` +PERFORMANCE INVESTIGATION: +Baseline metrics: [Current performance numbers] +Performance goals: [Target metrics] +User impact: [How performance affects users] + +PROFILING DATA: +[Performance measurements, bottlenecks identified] + +ANALYSIS REQUEST: +- Hotspot identification: [Where is time spent?] +- Memory analysis: [Memory usage patterns] +- I/O bottlenecks: [Database, file, network issues] +- Algorithmic complexity: [Big O analysis] +- Optimization priorities: [What to fix first] +``` + +--- + +## Architecture and Design Discussions + +### 19. Architecture Decision Records (ADR) Communication + +**ADR Template for LLM Discussion:** +``` +ARCHITECTURE DECISION: +Title: [Brief decision description] +Status: [Proposed, Accepted, Deprecated] +Context: [Forces at play, constraints] +Decision: [What we decided] +Consequences: [Positive and negative outcomes] + +DISCUSSION NEEDED: +- Alternative evaluation: [Other options considered] +- Risk assessment: [Potential problems] +- Implementation strategy: [How to execute] +- Success metrics: [How to measure success] +``` + +### 20. System Design Communication + +**System Design Template:** +``` +SYSTEM DESIGN REQUEST: +Requirements: +- Functional: [What the system must do] +- Non-functional: [Performance, scalability, reliability] +- Constraints: [Technical and business limitations] + +DESIGN AREAS: +1. High-level architecture: [Overall system structure] +2. Data model: [How data is organized] +3. API design: [Interface specifications] +4. Scalability strategy: [How to handle growth] +5. Security considerations: [Protection mechanisms] +6. Monitoring and observability: [How to track health] + +SPECIFIC GUIDANCE NEEDED: +[Areas where you want detailed advice] +``` + +### 21. Technology Selection Framework + +**Technology Evaluation Template:** +``` +TECHNOLOGY SELECTION: +Use case: [What you're trying to accomplish] +Requirements: +- Performance: [Speed, throughput, latency needs] +- Scalability: [Growth expectations] +- Team expertise: [Current skills and learning capacity] +- Ecosystem: [Integration requirements] +- Budget: [Cost constraints] + +OPTIONS UNDER CONSIDERATION: +[List of technologies being evaluated] + +EVALUATION CRITERIA: +1. Technical fit: [How well it solves the problem] +2. Learning curve: [Time to productivity] +3. Community support: [Documentation, help available] +4. Long-term viability: [Sustainability, roadmap] +5. Integration complexity: [How it fits with existing stack] + +DECISION SUPPORT NEEDED: +[Specific areas where you want analysis] +``` + +--- + +## Iterative Development Communication + +### 22. Sprint Planning Communication + +**Sprint Planning Template:** +``` +SPRINT PLANNING: +Sprint goal: [What we want to achieve] +Duration: [Sprint length] +Team capacity: [Available development time] + +BACKLOG ITEMS: +[List of features/tasks to consider] + +PLANNING ASSISTANCE NEEDED: +- Story estimation: [Help sizing tasks] +- Dependency identification: [What blocks what] +- Risk assessment: [What could go wrong] +- Task breakdown: [How to split large items] +- Capacity planning: [Realistic sprint scope] +``` + +### 23. Progress Review Communication + +**Progress Review Template:** +``` +PROGRESS REVIEW: +Sprint/milestone: [Current period] +Completed: [What was finished] +In progress: [Current work] +Blocked: [Items that can't proceed] +Risks: [Potential issues ahead] + +REVIEW ASSISTANCE NEEDED: +- Velocity analysis: [Are we on track?] +- Blocker resolution: [How to unblock items] +- Scope adjustment: [What to add/remove] +- Quality assessment: [Technical debt concerns] +- Next steps: [Priorities for next period] +``` + +### 24. Retrospective Communication + +**Retrospective Template:** +``` +RETROSPECTIVE: +Period: [Time frame being reviewed] +Goals: [What we aimed to achieve] +Outcomes: [What actually happened] + +ANALYSIS AREAS: +- What went well: [Successes to continue] +- What didn't work: [Problems to address] +- What we learned: [New insights gained] +- What to try: [Experiments for next period] + +IMPROVEMENT PLANNING: +- Process changes: [How to work differently] +- Tool improvements: [Better technology/tools] +- Skill development: [Learning priorities] +- Communication enhancements: [Better collaboration] +``` + +--- + +## Documentation and Knowledge Transfer + +### 25. Documentation Generation + +**Documentation Request Template:** +``` +DOCUMENTATION REQUEST: +Audience: [Who will read this] +Purpose: [Why they need it] +Scope: [What to cover] +Format: [README, API docs, tutorial, etc.] + +CONTENT TO DOCUMENT: +[Code, system, process to explain] + +DOCUMENTATION REQUIREMENTS: +- Getting started: [How to begin using it] +- Core concepts: [Key ideas to understand] +- Examples: [Practical usage scenarios] +- Troubleshooting: [Common problems and solutions] +- Reference: [Complete API/configuration details] +``` + +### 26. Knowledge Transfer Communication + +**Knowledge Transfer Template:** +``` +KNOWLEDGE TRANSFER: +From: [Current knowledge holder] +To: [Knowledge recipient] +Subject: [What knowledge is being transferred] +Timeline: [When transfer needs to complete] + +KNOWLEDGE AREAS: +- System architecture: [How things are structured] +- Business logic: [Why things work this way] +- Operational procedures: [How to maintain/deploy] +- Troubleshooting: [Common issues and solutions] +- Development workflow: [How to make changes] + +TRANSFER FORMAT: +- Documentation: [Written explanations] +- Code walkthrough: [Guided code review] +- Hands-on training: [Practical exercises] +- Q&A sessions: [Interactive discussion] +``` + +### 27. Technical Writing Assistance + +**Technical Writing Template:** +``` +TECHNICAL WRITING REQUEST: +Document type: [Tutorial, reference, explanation] +Target audience: [Experience level, role] +Technical complexity: [Beginner, intermediate, advanced] + +CONTENT OUTLINE: +[Structure of what needs to be written] + +WRITING ASSISTANCE NEEDED: +- Structure optimization: [Better organization] +- Clarity improvement: [Clearer explanations] +- Example generation: [Practical demonstrations] +- Completeness check: [Missing information] +- Audience appropriateness: [Right level of detail] +``` + +--- + +## Advanced Communication Techniques + +### 28. Socratic Method for Problem Solving + +Use guided questioning to explore problems deeply. + +**Question Frameworks:** +``` +PROBLEM EXPLORATION: +- What exactly is the problem we're trying to solve? +- What assumptions are we making? +- What would happen if we didn't solve this? +- What are the constraints we must work within? + +SOLUTION EXPLORATION: +- What are all the possible approaches? +- What are the trade-offs of each approach? +- What would success look like? +- How would we measure success? + +IMPLEMENTATION EXPLORATION: +- What could go wrong with this approach? +- What dependencies do we need to consider? +- How would we test this solution? +- What would we do if this doesn't work? +``` + +### 29. Rubber Duck Debugging with LLMs + +Structure your thoughts by explaining the problem step-by-step. + +**Rubber Duck Template:** +``` +RUBBER DUCK SESSION: +I'm going to walk through this problem step by step: + +1. What I'm trying to do: [Goal] +2. What I expect to happen: [Expected behavior] +3. What actually happens: [Actual behavior] +4. Here's my code: [Code walkthrough] +5. Here's my logic: [Step-by-step reasoning] +6. Here's where I think it might be wrong: [Hypothesis] + +Please help me identify flaws in my reasoning or suggest what I might be missing. +``` + +### 30. Collaborative Problem Solving + +Frame the LLM as a collaborative partner rather than just a tool. + +**Collaboration Template:** +``` +COLLABORATIVE SESSION: +Let's work together on: [Problem statement] + +My current thinking: +- Approach: [How I'm thinking about it] +- Concerns: [What worries me] +- Unknowns: [What I'm not sure about] + +I'd like you to: +- Challenge my assumptions +- Suggest alternative approaches +- Point out potential issues I haven't considered +- Help me think through edge cases + +Let's iterate on this solution together. +``` + +--- + +## Communication Anti-Patterns to Avoid + +### Common Mistakes + +**❌ Vague Requests:** +- "Make this code better" +- "Fix this bug" +- "Optimize this" + +**✅ Specific Requests:** +- "Reduce the time complexity of this sorting algorithm from O(n²) to O(n log n)" +- "Fix the null pointer exception on line 42 when user input is empty" +- "Optimize this database query to reduce execution time from 2s to under 500ms" + +**❌ Missing Context:** +- "This doesn't work" +- "I need help with React" +- "How do I deploy this?" + +**✅ Rich Context:** +- "This authentication middleware returns 401 for valid JWT tokens in production but works in development" +- "I need help implementing infinite scroll in React using hooks with a REST API that returns paginated data" +- "How do I deploy this Node.js app with PostgreSQL to AWS using Docker containers?" + +**❌ Overwhelming Information:** +- Dumping entire codebases without focus +- Providing irrelevant background information +- Mixing multiple unrelated questions + +**✅ Focused Communication:** +- Provide only relevant code sections +- Give necessary context without overwhelming detail +- Ask one clear question at a time + +--- + +## Quick Reference Templates + +### Emergency Debugging Template +``` +🚨 URGENT ISSUE: +Impact: [Production down, users affected, etc.] +Timeline: [When it started, deadline to fix] +Symptoms: [What's happening] +Quick context: [Minimal necessary background] +Immediate need: [What you need right now] +``` + +### Code Review Template +``` +📝 CODE REVIEW: +Purpose: [What this code does] +Key changes: [Main modifications] +Review focus: [What to pay attention to] +Specific concerns: [Your questions] +[CODE BLOCK] +``` + +### Architecture Discussion Template +``` +🏗️ ARCHITECTURE: +Problem: [What we're solving] +Constraints: [Limitations] +Options: [Alternatives considered] +Recommendation: [Preferred approach] +Trade-offs: [Pros and cons] +``` + +### Learning Template +``` +📚 LEARNING REQUEST: +Topic: [What you want to learn] +Current level: [Your experience] +Goal: [What you want to achieve] +Context: [How you'll use this knowledge] +Format: [How you learn best] +``` + +--- + +## Measuring Communication Effectiveness + +### Success Metrics + +**Quality Indicators:** +- First response addresses your actual need +- Minimal back-and-forth clarification needed +- Solutions are implementable without major modifications +- Explanations match your technical level + +**Efficiency Indicators:** +- Faster problem resolution +- Reduced debugging time +- Fewer implementation iterations +- Better code quality outcomes + +**Learning Indicators:** +- Improved understanding of concepts +- Ability to apply solutions to similar problems +- Enhanced problem-solving skills +- Better technical decision-making + +### Continuous Improvement + +**Reflection Questions:** +- Did I provide enough context? +- Was my request specific enough? +- Did I get the level of detail I needed? +- How could I have communicated more effectively? + +**Iteration Strategies:** +- Refine prompts based on response quality +- Build a personal library of effective templates +- Adapt communication style to different types of problems +- Practice structured thinking before engaging with LLMs + +--- + +*This guide provides a foundation for effective LLM communication in software development. Adapt these techniques to your specific needs, technology stack, and communication style. The key is consistent practice and continuous refinement of your communication approach.* \ No newline at end of file From 6e7998c50161d812743d092601fa2f3b16527074 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 26 May 2025 21:47:21 +0800 Subject: [PATCH 07/10] Revise communication techniques section by introducing the PREP framework for structuring technical explanations and requests. Update section headings to reflect the new framework and adjust subsequent sections accordingly. --- ...communication-techniques-for-developers.md | 122 ++++++++++++++---- 1 file changed, 94 insertions(+), 28 deletions(-) diff --git a/llm-communication-techniques-for-developers.md b/llm-communication-techniques-for-developers.md index 9e0e35a..9e9e69f 100644 --- a/llm-communication-techniques-for-developers.md +++ b/llm-communication-techniques-for-developers.md @@ -82,7 +82,64 @@ DETAILS: Using Express.js 4.18, MongoDB with Mongoose, Redis for caching BACKGROUND: Legacy codebase inherited from previous team, limited documentation ``` -### 3. Precision in Technical Language +### 3. The PREP Framework + +**P**oint - **R**eason - **E**xample - **P**oint + +The PREP framework is excellent for structuring technical explanations and requests clearly and persuasively. + +**Point (Main Message):** +``` +Primary statement: [What you want or what the issue is] +Key takeaway: [The most important thing to understand] +``` + +**Reason (Why/Justification):** +``` +Technical rationale: [Why this approach/solution makes sense] +Business justification: [Impact on project/users/performance] +Evidence: [Data, metrics, or technical facts supporting your point] +``` + +**Example (Concrete Illustration):** +``` +Code example: [Specific implementation or demonstration] +Use case: [Real-world scenario where this applies] +Comparison: [How this differs from alternatives] +``` + +**Point (Reinforcement):** +``` +Restatement: [Reiterate the main message with new insight] +Next steps: [What should happen next] +Call to action: [Specific request or decision needed] +``` + +**PREP Template for Technical Requests:** +``` +POINT: I need to implement caching to improve API response times +REASON: Current response times are 800ms average, causing user frustration and potential churn. Caching could reduce this to under 200ms based on our data access patterns. +EXAMPLE: Similar to how we implemented Redis caching for user sessions, we could cache frequently accessed product data. For instance, product catalog queries that currently hit the database every time could be cached for 5 minutes. +POINT: Implementing this caching strategy would significantly improve user experience and reduce database load, making it a high-impact optimization for our current performance issues. +``` + +**PREP for Bug Reports:** +``` +POINT: Authentication middleware is failing in production environment +REASON: Valid JWT tokens are being rejected with 401 errors, but only in production. This suggests an environment-specific configuration issue affecting token validation. +EXAMPLE: User logs in successfully, receives JWT token, but subsequent API calls to /api/user/profile return 401. Same flow works perfectly in development and staging environments. +POINT: This is blocking all authenticated users from accessing the application, making it a critical production issue requiring immediate investigation of environment-specific JWT configuration. +``` + +**PREP for Architecture Proposals:** +``` +POINT: We should adopt microservices architecture for our user management system +REASON: Current monolithic approach is creating deployment bottlenecks and scaling issues. Team velocity is decreasing as the codebase grows, and we need independent scaling of user-facing features. +EXAMPLE: Companies like Netflix and Amazon use microservices to handle similar scale. We could split into UserAuth, UserProfile, and UserPreferences services, each with independent databases and deployment pipelines. +POINT: This architectural change would enable faster development cycles, better fault isolation, and more efficient resource utilization, directly addressing our current scalability challenges. +``` + +### 4. Precision in Technical Language **Instead of vague terms:** - "It's slow" → "Response time increased from 200ms to 2.5s" @@ -98,7 +155,7 @@ BACKGROUND: Legacy codebase inherited from previous team, limited documentation ## Prompt Engineering for Developers -### 4. The STAR Method for Technical Prompts +### 5. The STAR Method for Technical Prompts **S**ituation - **T**ask - **A**ction - **R**esult @@ -118,7 +175,7 @@ ACTION: Design a tracing solution using OpenTelemetry with Jaeger backend RESULT: Complete implementation with code examples, configuration files, and monitoring dashboard setup ``` -### 5. Multi-Layered Prompt Structure +### 6. Multi-Layered Prompt Structure **Layer 1: Core Request** ``` @@ -147,7 +204,7 @@ Detail level: [Implementation-ready, conceptual, reference] Examples: [Include working examples, test cases] ``` -### 6. Progressive Disclosure Technique +### 7. Progressive Disclosure Technique Start with a high-level request, then drill down based on the response. @@ -178,7 +235,7 @@ For the token refresh mechanism you showed: ## Context Management Strategies -### 7. Context Anchoring +### 8. Context Anchoring Establish and maintain context throughout the conversation. @@ -204,7 +261,7 @@ Building on the [previous solution/approach]... Given our [constraint/requirement] from earlier... ``` -### 8. Context Compression +### 9. Context Compression When conversations get long, compress previous context into concise summaries. @@ -220,7 +277,7 @@ NEW REQUEST: [Current specific need] ``` -### 9. Context Switching Signals +### 10. Context Switching Signals Clearly indicate when changing topics or focus areas. @@ -237,7 +294,7 @@ Clearly indicate when changing topics or focus areas. ## Structured Problem-Solving Frameworks -### 10. The 5W1H Technical Framework +### 11. The 5W1H Technical Framework **Who:** Stakeholders and users affected **What:** Specific technical problem or requirement @@ -256,7 +313,7 @@ WHY: [Business value, technical necessity] HOW: [Preferred approach, constraints, alternatives] ``` -### 11. Root Cause Analysis Communication +### 12. Root Cause Analysis Communication **Problem Statement Framework:** ``` @@ -278,7 +335,7 @@ Help me analyze this issue using: 5. Data analysis: [What logs/metrics show?] ``` -### 12. Solution Evaluation Framework +### 13. Solution Evaluation Framework **Criteria-Based Evaluation:** ``` @@ -299,7 +356,7 @@ RECOMMENDATION: [Preferred option with justification] ## Code-Specific Communication Patterns -### 13. Code Review Communication +### 14. Code Review Communication **Review Request Template:** ``` @@ -318,7 +375,7 @@ Specific questions: 3. [Performance/security/maintainability question] ``` -### 14. Implementation Guidance Requests +### 15. Implementation Guidance Requests **Feature Implementation Template:** ``` @@ -336,7 +393,7 @@ IMPLEMENTATION GUIDANCE NEEDED: - Performance considerations: [Scalability requirements] ``` -### 15. Code Optimization Requests +### 16. Code Optimization Requests **Optimization Template:** ``` @@ -360,7 +417,7 @@ ANALYSIS REQUEST: ## Debugging and Troubleshooting Communication -### 16. Bug Report Structure +### 17. Bug Report Structure **Comprehensive Bug Report:** ``` @@ -384,7 +441,7 @@ Additional context: - Workaround: [Temporary solution if any] ``` -### 17. Debugging Session Communication +### 18. Debugging Session Communication **Debugging Request Template:** ``` @@ -404,7 +461,7 @@ DEBUGGING ASSISTANCE NEEDED: 4. Pattern recognition: [Similar issues you've seen] ``` -### 18. Performance Investigation +### 19. Performance Investigation **Performance Analysis Request:** ``` @@ -428,7 +485,7 @@ ANALYSIS REQUEST: ## Architecture and Design Discussions -### 19. Architecture Decision Records (ADR) Communication +### 20. Architecture Decision Records (ADR) Communication **ADR Template for LLM Discussion:** ``` @@ -446,7 +503,7 @@ DISCUSSION NEEDED: - Success metrics: [How to measure success] ``` -### 20. System Design Communication +### 21. System Design Communication **System Design Template:** ``` @@ -468,7 +525,7 @@ SPECIFIC GUIDANCE NEEDED: [Areas where you want detailed advice] ``` -### 21. Technology Selection Framework +### 22. Technology Selection Framework **Technology Evaluation Template:** ``` @@ -499,7 +556,7 @@ DECISION SUPPORT NEEDED: ## Iterative Development Communication -### 22. Sprint Planning Communication +### 23. Sprint Planning Communication **Sprint Planning Template:** ``` @@ -519,7 +576,7 @@ PLANNING ASSISTANCE NEEDED: - Capacity planning: [Realistic sprint scope] ``` -### 23. Progress Review Communication +### 24. Progress Review Communication **Progress Review Template:** ``` @@ -538,7 +595,7 @@ REVIEW ASSISTANCE NEEDED: - Next steps: [Priorities for next period] ``` -### 24. Retrospective Communication +### 25. Retrospective Communication **Retrospective Template:** ``` @@ -564,7 +621,7 @@ IMPROVEMENT PLANNING: ## Documentation and Knowledge Transfer -### 25. Documentation Generation +### 26. Documentation Generation **Documentation Request Template:** ``` @@ -585,7 +642,7 @@ DOCUMENTATION REQUIREMENTS: - Reference: [Complete API/configuration details] ``` -### 26. Knowledge Transfer Communication +### 27. Knowledge Transfer Communication **Knowledge Transfer Template:** ``` @@ -609,7 +666,7 @@ TRANSFER FORMAT: - Q&A sessions: [Interactive discussion] ``` -### 27. Technical Writing Assistance +### 28. Technical Writing Assistance **Technical Writing Template:** ``` @@ -633,7 +690,7 @@ WRITING ASSISTANCE NEEDED: ## Advanced Communication Techniques -### 28. Socratic Method for Problem Solving +### 29. Socratic Method for Problem Solving Use guided questioning to explore problems deeply. @@ -658,7 +715,7 @@ IMPLEMENTATION EXPLORATION: - What would we do if this doesn't work? ``` -### 29. Rubber Duck Debugging with LLMs +### 30. Rubber Duck Debugging with LLMs Structure your thoughts by explaining the problem step-by-step. @@ -677,7 +734,7 @@ I'm going to walk through this problem step by step: Please help me identify flaws in my reasoning or suggest what I might be missing. ``` -### 30. Collaborative Problem Solving +### 31. Collaborative Problem Solving Frame the LLM as a collaborative partner rather than just a tool. @@ -780,6 +837,15 @@ Context: [How you'll use this knowledge] Format: [How you learn best] ``` +### PREP Framework Template +``` +🎯 PREP STRUCTURE: +POINT: [Main message/request/issue] +REASON: [Technical and business justification with evidence] +EXAMPLE: [Concrete code example, use case, or comparison] +POINT: [Reinforcement with next steps and call to action] +``` + --- ## Measuring Communication Effectiveness From a5c217b89b1964389df5a1ab721fbb36b064f886 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 26 May 2025 22:02:30 +0800 Subject: [PATCH 08/10] Add First Principles Thinking section to LLM Communication Techniques guide, including frameworks, templates, and examples for problem-solving and technical decision-making. Update README.md to highlight new content and improve navigation for developers. --- README.md | 393 +++++++++++------- ...communication-techniques-for-developers.md | 184 ++++++++ 2 files changed, 434 insertions(+), 143 deletions(-) diff --git a/README.md b/README.md index 1a00678..2157f7c 100644 --- a/README.md +++ b/README.md @@ -1,180 +1,259 @@ # AI Coding Prompt Guides -This repository contains comprehensive Markdown guides designed to help developers -learn to code using AI and craft effective AI-driven coding prompts tailored to specific job roles and technologies. - -## Guides - -### Core Communication & Learning Guides -- **[LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md)**: Comprehensive guide to effective communication strategies with LLMs for robust software development -- **[LearnToCode.md](LearnToCode.md)**: A curated collection of AI prompts to help you learn programming - concepts, write code, maintain quality, troubleshoot issues, and deepen your - understanding of core software engineering topics. Includes a glossary of terms. -- **[ultimate-coding-prompt-guide.md](ultimate-coding-prompt-guide.md)**: An index to scenario-specific prompt guides: - - [Writing New Code](writing-new-code.md) - - [Modifying Existing Code](modifying-existing-code.md) - - [Troubleshooting](troubleshooting.md) - - [Learning To Code](learning-to-code-guide.md) - -### Job-Specific Prompt Guides -- **[Job-Specific Prompts Index](job-specific-prompts-index.md)**: Complete index of role-based prompt guides -- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)**: Specialized prompts for React and Next.js developers -- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)**: Comprehensive guide for Rust backend development with AI integration -- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)**: Complete guide for Node.js Sails.js framework development -- **[Blockchain Architect](blockchain-architect-prompts.md)**: Complete guide for Blockchain Architects and Web3 developers -- **[UI Designer (Figma)](ui-designer-figma-prompts.md)**: Complete guide for UI Designers using Figma for prototypes and design systems -- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)**: Comprehensive guide for Test Engineers using pytest framework -- **[Product Manager](product-manager-prompts.md)**: Comprehensive guide for Product Managers covering prototypes, research, and strategy -- **[HR Manager (Hiring & Recruitment)](hr-manager-hiring-prompts.md)**: Comprehensive guide for HR Managers covering hiring, recruitment, and talent acquisition - -## Quick Start by Role - -### Learning Effective LLM Communication +A comprehensive collection of AI prompts and communication strategies designed to help developers learn to code, solve problems efficiently, and work effectively with AI assistants across different roles and technologies. + +## 🎯 Quick Start + +### 1. **Master AI Communication First** +Start with **[LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md)** - Essential foundation for effective AI interaction using frameworks like CLEAR, PREP, STAR, and First Principles thinking. + +### 2. **Choose Your Learning Path** +- **New to Coding**: [LearnToCode.md](LearnToCode.md) + [Learning to Code Guide](learning-to-code-guide.md) +- **Specific Role**: Browse [Job-Specific Prompts Index](job-specific-prompts-index.md) +- **General Development**: [Ultimate Coding Prompt Guide](ultimate-coding-prompt-guide.md) + +## 📚 Core Guides + +### Communication & Learning Foundations +- **[LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md)** ⭐ **START HERE** + - 32 advanced communication strategies for robust development + - CLEAR, PREP, STAR, and First Principles frameworks + - Context management, debugging communication, architecture discussions + - Socratic method, rubber duck debugging, collaborative problem solving + +- **[LearnToCode.md](LearnToCode.md)** - Comprehensive learning guide + - Curated AI prompts for programming fundamentals + - Code quality, troubleshooting, and learning strategies + - Extensive glossary of 100+ technical terms + - Best practices for working with AI coding assistants + +### Scenario-Based Development Guides +- **[Ultimate Coding Prompt Guide](ultimate-coding-prompt-guide.md)** - Index to scenario-specific guides: + - **[Writing New Code](writing-new-code.md)** - Feature development and implementation + - **[Modifying Existing Code](modifying-existing-code.md)** - Refactoring and improvements + - **[Troubleshooting](troubleshooting.md)** - Debugging and problem resolution + - **[Learning to Code Guide](learning-to-code-guide.md)** - Structured learning approach + +## 🛠️ Job-Specific Prompt Guides + +### **[Job-Specific Prompts Index](job-specific-prompts-index.md)** - Complete navigation hub + +### Frontend Development +- **[Frontend React/Next.js Engineer](frontend-react-nextjs-prompts.md)** (25 prompts) + - Component development, custom hooks, state management + - Next.js SSR/SSG, dynamic routing, API routes + - Performance optimization, testing, accessibility + - UI/UX implementation with modern design patterns + +### Backend Development +- **[Rust Backend Engineer (RIG + Actix-web)](rust-backend-engineer-prompts.md)** (32 prompts) + - Actix-web server development and middleware + - RIG integration for AI capabilities + - Database integration with SQLx, authentication + - Performance optimization and deployment strategies + +- **[Node.js Sails.js Backend Engineer](nodejs-sailsjs-backend-prompts.md)** (33 prompts) + - Sails.js MVC architecture and conventions + - Waterline ORM and database integration + - Real-time features with Socket.io + - RESTful API development and GraphQL integration + +### Blockchain & Web3 +- **[Blockchain Architect](blockchain-architect-prompts.md)** (30 prompts) + - Blockchain architecture design and technology stack selection + - Smart contract architecture and DeFi protocol design + - Consensus mechanisms, scalability, and security frameworks + - Infrastructure, governance, tokenomics, and interoperability + +### Design & User Experience +- **[UI Designer (Figma)](ui-designer-figma-prompts.md)** (30 prompts) + - Interactive prototype creation and design systems + - Component design and responsive layouts + - Accessibility, usability testing, design handoff + - Performance optimization and conversion rate optimization + +### Quality Assurance & Testing +- **[Test Engineer (Pytest)](test-engineer-pytest-prompts.md)** (33 prompts) + - Pytest framework setup and organization + - Unit, integration, and API testing strategies + - UI/E2E testing with Selenium and Playwright + - Performance testing, CI/CD integration, test data management + +### Product Management +- **[Product Manager](product-manager-prompts.md)** (30 prompts) + - Interactive prototype creation and MVP definition + - User research, personas, and journey mapping + - Feature planning, prioritization frameworks, market research + - Product strategy, roadmapping, go-to-market planning + +### Human Resources & Talent +- **[HR Manager (Hiring & Recruitment)](hr-manager-hiring-prompts.md)** (30 prompts) + - Job description creation and optimization + - Talent sourcing, recruitment strategies, interview design + - Candidate assessment, employer branding, diversity initiatives + - Compensation strategy, onboarding, recruitment analytics + +## 🚀 Getting Started + +### Installation ```bash -# Start with the LLM Communication Techniques guide -open llm-communication-techniques-for-developers.md +git clone https://github.com//.git +cd ``` -Perfect for: Structuring thoughts clearly, crafting precise prompts, maintaining productive AI conversations, debugging communication issues -### Frontend Developers (React/Next.js) -```bash -# Start with the Frontend React/Next.js guide -open frontend-react-nextjs-prompts.md -``` -Perfect for: Component development, state management, Next.js features, performance optimization, testing +### Recommended Learning Path +1. **Foundation**: [LLM Communication Techniques](llm-communication-techniques-for-developers.md) +2. **Role-Specific**: Choose your guide from [Job-Specific Index](job-specific-prompts-index.md) +3. **Scenario-Based**: Use [Ultimate Coding Prompt Guide](ultimate-coding-prompt-guide.md) for specific tasks +4. **Deep Learning**: [LearnToCode.md](LearnToCode.md) for comprehensive understanding -### Backend Developers (Rust) +### Usage Examples ```bash -# Start with the Rust Backend guide -open rust-backend-engineer-prompts.md -``` -Perfect for: Actix-web development, RIG AI integration, database setup, authentication, API design +# For effective AI communication +open llm-communication-techniques-for-developers.md -### Backend Developers (Node.js Sails.js) -```bash -# Start with the Node.js Sails.js guide -open nodejs-sailsjs-backend-prompts.md -``` -Perfect for: Sails.js MVC architecture, Waterline ORM, real-time features, RESTful APIs, Socket.io +# For role-specific prompts +open job-specific-prompts-index.md -### UI Designers (Figma) -```bash -# Start with the UI Designer Figma guide -open ui-designer-figma-prompts.md -``` -Perfect for: Interactive prototypes, design systems, component design, accessibility, design handoff +# For learning fundamentals +open LearnToCode.md -### Test Engineers (Pytest) -```bash -# Start with the Test Engineer Pytest guide -open test-engineer-pytest-prompts.md +# For specific development scenarios +open ultimate-coding-prompt-guide.md ``` -Perfect for: Test automation, unit/integration testing, UI testing, performance testing, CI/CD integration -### Product Managers -```bash -# Start with the Product Manager guide -open product-manager-prompts.md -``` -Perfect for: Prototype creation, user research, feature planning, market analysis, product strategy +## 📊 Guide Statistics -### HR Managers (Hiring & Recruitment) -```bash -# Start with the HR Manager guide -open hr-manager-hiring-prompts.md -``` -Perfect for: Job descriptions, talent sourcing, interview design, candidate assessment, employer branding +| Category | Guides | Total Prompts | Key Features | +|----------|--------|---------------|--------------| +| **Communication** | 1 | 32 | CLEAR, PREP, STAR, First Principles | +| **Learning** | 5 | 50+ | Fundamentals, scenarios, glossary | +| **Frontend** | 1 | 25 | React, Next.js, performance | +| **Backend** | 2 | 65 | Rust, Node.js, databases, APIs | +| **Blockchain** | 1 | 30 | Architecture, DeFi, smart contracts | +| **Design** | 1 | 30 | Figma, prototypes, design systems | +| **Testing** | 1 | 33 | Pytest, automation, CI/CD | +| **Product** | 1 | 30 | Strategy, research, roadmapping | +| **HR** | 1 | 30 | Hiring, recruitment, talent | +| **Total** | **13** | **325+** | **Comprehensive coverage** | -### Blockchain Architects (Web3) -```bash -# Start with the Blockchain Architect guide -open blockchain-architect-prompts.md -``` -Perfect for: Blockchain architecture, smart contracts, DeFi protocols, consensus mechanisms, tokenomics +## 🎯 Quick Reference by Use Case -### General Development +### Learning to Code ```bash -# Start with the general coding guides -open ultimate-coding-prompt-guide.md +# Complete beginner open LearnToCode.md -``` -Perfect for: Learning fundamentals, general coding tasks, troubleshooting - -## Getting Started +open learning-to-code-guide.md -1. **Master LLM Communication First**: - - Start with [LLM Communication Techniques](llm-communication-techniques-for-developers.md) to learn how to structure thoughts and communicate effectively with AI assistants - - This foundational skill will improve your experience with all other guides +# Structured learning with AI communication +open llm-communication-techniques-for-developers.md +``` -2. **Choose your guide based on your role**: - - Browse the [Job-Specific Prompts Index](job-specific-prompts-index.md) to find guides tailored to your technology stack and responsibilities - - Use general guides for learning fundamentals or cross-cutting concerns +### Building Features +```bash +# Planning and implementation +open writing-new-code.md -3. **Clone this repository**: - ```bash - git clone https://github.com//.git - cd - ``` +# Role-specific development +open job-specific-prompts-index.md +``` -4. **Open the relevant guides** in your preferred Markdown viewer or editor +### Debugging & Troubleshooting +```bash +# General troubleshooting +open troubleshooting.md -## Usage +# Advanced debugging communication +open llm-communication-techniques-for-developers.md +``` -Copy and paste the prompts from these guides into your AI coding assistant (e.g., ChatGPT, -Claude Sonnet, GitHub Copilot) to accelerate learning, development, and troubleshooting. +### Code Maintenance +```bash +# Refactoring and improvements +open modifying-existing-code.md -### Example Workflow -1. **Learn effective communication** using the LLM Communication Techniques guide -2. **Identify your role and tech stack** using the job-specific index -3. **Find relevant prompts** for your current task -4. **Customize the prompts** with your specific requirements -5. **Use with your AI assistant** to generate code, solve problems, or learn concepts +# Code review and quality +open llm-communication-techniques-for-developers.md +``` -## What's New +### Architecture & Design +```bash +# System design +open blockchain-architect-prompts.md # For blockchain +open llm-communication-techniques-for-developers.md # General architecture -### Core Communication & Learning -- **NEW**: [LLM Communication Techniques for Developers](llm-communication-techniques-for-developers.md) - Comprehensive guide with 30+ communication strategies including the CLEAR framework, STAR method, context management, structured problem-solving, debugging communication, architecture discussions, and advanced techniques like Socratic method and collaborative problem solving +# UI/UX design +open ui-designer-figma-prompts.md +``` -### Job-Specific Guides -- **NEW**: [HR Manager Hiring Guide](hr-manager-hiring-prompts.md) - 30 comprehensive prompts covering job description creation, talent sourcing, interview design, candidate assessment, employer branding, diversity initiatives, compensation strategy, and legal compliance -- **NEW**: [Blockchain Architect Guide](blockchain-architect-prompts.md) - 30 specialized prompts for blockchain architecture design, smart contract development, DeFi protocols, consensus mechanisms, scalability solutions, security frameworks, and tokenomics design -- **NEW**: [UI Designer Figma Guide](ui-designer-figma-prompts.md) - 30 comprehensive prompts covering interactive prototypes, design systems, component design, responsive layouts, accessibility, and design handoff -- **NEW**: [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) - 33 specialized prompts for pytest framework, test automation, unit/integration testing, UI testing, performance testing, and CI/CD integration -- **NEW**: [Product Manager Guide](product-manager-prompts.md) - 30 comprehensive prompts covering prototype development, user research, feature planning, market analysis, product strategy, and stakeholder communication -- **NEW**: [Node.js Sails.js Backend Engineer Guide](nodejs-sailsjs-backend-prompts.md) - 33 specialized prompts for Sails.js development, Waterline ORM, real-time features, and deployment -- **NEW**: [Rust Backend Engineer Guide](rust-backend-engineer-prompts.md) - 32 comprehensive prompts for Actix-web, RIG integration, database management, and deployment -- **NEW**: [Job-Specific Index](job-specific-prompts-index.md) - Central hub for all role-based guides with selection guidance +## 🔧 Technology Coverage + +### Programming Languages +- **JavaScript/TypeScript**: React, Next.js, Node.js, Sails.js +- **Rust**: Actix-web, RIG, SQLx +- **Python**: Pytest, testing frameworks +- **Solidity**: Smart contracts, blockchain development + +### Frameworks & Tools +- **Frontend**: React, Next.js, Figma +- **Backend**: Actix-web, Sails.js, Express +- **Testing**: Pytest, Selenium, Playwright +- **Blockchain**: Ethereum, DeFi protocols, Web3 +- **Databases**: PostgreSQL, MongoDB, Redis, SQLx + +### Development Areas +- **Web Development**: Full-stack applications +- **Blockchain**: DeFi, smart contracts, tokenomics +- **Testing**: Automation, performance, CI/CD +- **Design**: UI/UX, prototypes, design systems +- **Product**: Strategy, research, management +- **HR**: Hiring, recruitment, talent acquisition + +## 🌟 What's New + +### Latest Additions +- **NEW**: [LLM Communication Techniques](llm-communication-techniques-for-developers.md) - 32 advanced communication strategies including CLEAR framework, PREP method, STAR approach, First Principles thinking, Socratic method, and collaborative problem solving +- **NEW**: [HR Manager Hiring Guide](hr-manager-hiring-prompts.md) - 30 comprehensive prompts for job descriptions, talent sourcing, interview design, candidate assessment, employer branding, and legal compliance +- **NEW**: [Blockchain Architect Guide](blockchain-architect-prompts.md) - 30 specialized prompts for blockchain architecture, smart contracts, DeFi protocols, consensus mechanisms, and tokenomics +- **NEW**: [UI Designer Figma Guide](ui-designer-figma-prompts.md) - 30 prompts for interactive prototypes, design systems, accessibility, and design handoff +- **NEW**: [Test Engineer Pytest Guide](test-engineer-pytest-prompts.md) - 33 prompts for test automation, performance testing, and CI/CD integration +- **NEW**: [Product Manager Guide](product-manager-prompts.md) - 30 prompts for product strategy, user research, and stakeholder communication ### Recent Updates -- ultimate-coding-prompt-guide.md: Updated initial prompt to a robust feature prompt template with clear requirements, best practices, error handling, and unit tests. -- ultimate-coding-prompt-guide.md: Added Next.js-specific frontend prompt template with SSR/SSG, dynamic routing, and testing guidelines. -- ultimate-coding-prompt-guide.md: Split the monolithic guide into four scenario-specific files (`writing-new-code.md`, `modifying-existing-code.md`, `troubleshooting.md`, `learning-to-code-guide.md`), and refactored `ultimate-coding-prompt-guide.md` into an index linking to them. +- Enhanced job-specific index with cross-role collaboration prompts +- Added comprehensive technology coverage across all guides +- Improved navigation and quick reference sections +- Updated learning paths and getting started guidance -## Contributing +## 🤝 Contributing -Contributions, issues, and suggestions are welcome! To contribute: +We welcome contributions! Here's how to help: ### Adding New Communication Techniques -1. Follow the structured format established in the LLM Communication Techniques guide +1. Follow the structured format in [LLM Communication Techniques](llm-communication-techniques-for-developers.md) 2. Include practical templates and real-world examples 3. Focus on developer-specific scenarios and challenges -4. Provide both basic and advanced techniques ### Adding New Job-Specific Guides -1. Follow the format established in existing job-specific guides -2. Include role-specific scenarios and technology-focused prompts -3. Provide both template and example prompts +1. Follow the established format with 25-35 prompts +2. Include role-specific scenarios and technology focus +3. Provide template and example prompts 4. Add best practices and workflow guidance ### General Contributions 1. Fork the repository -2. Create a new branch (`git checkout -b feature-name`) -3. Make your changes and commit them -4. Push to the branch and open a pull request +2. Create a feature branch (`git checkout -b feature-name`) +3. Make your changes and test them +4. Submit a pull request with clear description -Please follow the existing style and guidelines when adding or modifying prompts. +### Contribution Guidelines +- Maintain consistent formatting and structure +- Include practical, actionable prompts +- Provide real-world examples and use cases +- Focus on developer productivity and learning +- Test prompts with high-quality AI models (Claude Sonnet 3.5+) -## Roadmap +## 🗺️ Roadmap ### Upcoming Communication Guides - Advanced Debugging Communication Patterns @@ -183,19 +262,47 @@ Please follow the existing style and guidelines when adding or modifying prompts - Technical Documentation with AI ### Upcoming Job-Specific Guides -- Python Backend Engineer (Django/FastAPI) -- DevOps Engineer (Docker, Kubernetes, CI/CD) -- Mobile Developer (React Native/Flutter) -- Data Engineer (Python, SQL, ETL pipelines) -- Machine Learning Engineer (Python, TensorFlow, PyTorch) -- UX/UI Designer (Design systems, prototyping, user research) +- **Python Backend Engineer** (Django/FastAPI) +- **DevOps Engineer** (Docker, Kubernetes, CI/CD) +- **Mobile Developer** (React Native/Flutter) +- **Data Engineer** (Python, SQL, ETL pipelines) +- **Machine Learning Engineer** (Python, TensorFlow, PyTorch) +- **UX Researcher** (User research, usability testing, analytics) ### Planned Features -- Interactive prompt builder +- Interactive prompt builder tool - Technology-specific prompt collections - Integration examples with popular AI assistants - Video tutorials for complex workflows +- Community-contributed prompt library + +## 📖 Additional Resources + +### User Stories & Use Cases +See [user-story.md](user-story.md) for detailed user personas and their goals when using these guides. + +### Best Practices +- **Use high-quality AI models** (Claude Sonnet 3.5+ recommended) +- **Provide context** in your prompts for better results +- **Start with communication fundamentals** before diving into specific roles +- **Customize prompts** based on your specific needs and constraints +- **Practice iterative refinement** of your communication approach + +### Model Recommendations +- **Primary**: Claude Sonnet 3.5 (best for code generation and explanation) +- **Alternative**: GPT-4 (good for general development tasks) +- **Avoid**: GPT-3.5, basic models (insufficient for complex coding tasks) + +## 📄 License + +This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. + +## 🙏 Acknowledgments + +- Inspired by the AI coding community and best practices +- Built for developers who want to work more effectively with AI +- Continuously updated based on real-world usage and feedback -## License +--- -This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. \ No newline at end of file +**Start your journey**: Begin with [LLM Communication Techniques](llm-communication-techniques-for-developers.md) to master AI communication, then explore role-specific guides based on your needs. Happy coding! 🚀 \ No newline at end of file diff --git a/llm-communication-techniques-for-developers.md b/llm-communication-techniques-for-developers.md index 9e9e69f..2d40ef4 100644 --- a/llm-communication-techniques-for-developers.md +++ b/llm-communication-techniques-for-developers.md @@ -757,6 +757,181 @@ I'd like you to: Let's iterate on this solution together. ``` +### 32. First Principles Thinking + +Break down complex problems to their fundamental truths, then build up solutions from scratch. This approach, famously used by Elon Musk, is powerful for technical innovation and problem-solving. + +**First Principles Framework:** +``` +DECONSTRUCTION: +- What do we know to be absolutely true about this problem? +- What assumptions are we making that might not be necessary? +- What are the fundamental physical/logical constraints? +- What are the core requirements that cannot be compromised? + +RECONSTRUCTION: +- Starting from these fundamentals, what's the simplest solution? +- What would we build if we had no existing constraints? +- How can we combine these basic truths in new ways? +- What innovative approaches become possible? +``` + +**First Principles Template for Technical Problems:** +``` +FIRST PRINCIPLES ANALYSIS: + +Problem: [Complex technical challenge] + +STEP 1 - DECONSTRUCTION: +Fundamental truths: +- [Core constraint #1: e.g., "Data must be consistent across distributed systems"] +- [Core constraint #2: e.g., "Network calls have latency"] +- [Core constraint #3: e.g., "Memory is finite"] + +Assumptions to challenge: +- [Assumption #1: e.g., "We must use a relational database"] +- [Assumption #2: e.g., "All data must be immediately consistent"] +- [Assumption #3: e.g., "We need to support all legacy APIs"] + +STEP 2 - RECONSTRUCTION: +From first principles, the solution would: +- [Fundamental approach based on core truths] +- [Novel combination of basic elements] +- [Innovative solution unconstrained by current implementation] + +STEP 3 - PRACTICAL APPLICATION: +How to bridge from ideal to practical: +- [What constraints are actually necessary] +- [Incremental steps toward first principles solution] +- [Hybrid approaches that capture key benefits] +``` + +**Example - Database Performance Problem:** +``` +FIRST PRINCIPLES ANALYSIS: + +Problem: Database queries are too slow, affecting user experience + +STEP 1 - DECONSTRUCTION: +Fundamental truths: +- Data access speed is limited by storage medium (disk vs memory vs network) +- Frequently accessed data should be closer to the processor +- Query complexity directly affects execution time +- Users only need specific data subsets, not entire datasets + +Assumptions to challenge: +- "We must query the database for every request" +- "All data must be stored in a single normalized database" +- "We need to support complex joins for all queries" +- "Data must always be perfectly up-to-date" + +STEP 2 - RECONSTRUCTION: +From first principles, the solution would: +- Keep frequently accessed data in memory (Redis/in-memory cache) +- Pre-compute common query results (materialized views/denormalization) +- Separate read and write operations (CQRS pattern) +- Accept eventual consistency for non-critical data + +STEP 3 - PRACTICAL APPLICATION: +Incremental implementation: +- Add Redis caching for user sessions and product catalogs +- Create read replicas for query-heavy operations +- Implement background jobs to pre-compute dashboard data +- Use CDN for static content and API responses where appropriate +``` + +**First Principles for Architecture Decisions:** +``` +ARCHITECTURE FIRST PRINCIPLES: + +Challenge: [System design problem] + +FUNDAMENTAL REQUIREMENTS: +- [Core business need #1] +- [Core technical constraint #1] +- [Core user requirement #1] + +ASSUMPTIONS TO QUESTION: +- "We need a microservices architecture" +- "We must use the same technology stack as other teams" +- "We need real-time updates for all features" +- "We must support every possible use case from day one" + +FIRST PRINCIPLES SOLUTION: +- Start with the simplest architecture that meets core requirements +- Add complexity only when fundamental constraints demand it +- Choose technologies based on problem requirements, not popularity +- Build for current needs with clear extension points for future growth + +IMPLEMENTATION STRATEGY: +- [Minimal viable architecture] +- [Clear criteria for when to add complexity] +- [Specific extension points for anticipated growth] +``` + +**First Principles for Code Optimization:** +``` +OPTIMIZATION FIRST PRINCIPLES: + +Performance Problem: [Specific performance issue] + +FUNDAMENTAL CONSTRAINTS: +- [Physical limits: CPU, memory, network, storage] +- [Algorithmic complexity bounds] +- [Business requirements that cannot change] + +ASSUMPTIONS TO CHALLENGE: +- "We need to optimize the existing algorithm" +- "We must maintain backward compatibility" +- "We need to process all data in real-time" +- "We must use the current data structure" + +FIRST PRINCIPLES APPROACH: +- What's the theoretical minimum time/space complexity for this problem? +- What would the solution look like if we could redesign from scratch? +- Which operations are actually necessary vs. convenient? +- How can we eliminate work rather than just doing it faster? + +PRACTICAL OPTIMIZATION: +- [Algorithmic improvements based on first principles] +- [Data structure changes that eliminate unnecessary work] +- [Caching strategies that prevent redundant computation] +- [Architectural changes that avoid the problem entirely] +``` + +**Using First Principles with LLMs:** +``` +FIRST PRINCIPLES LLM PROMPT: + +Help me apply first principles thinking to: [Problem statement] + +Please guide me through: +1. DECONSTRUCTION: What are the fundamental truths and constraints? +2. ASSUMPTION CHALLENGE: What am I assuming that might not be necessary? +3. RECONSTRUCTION: What would an ideal solution look like from scratch? +4. PRACTICAL BRIDGE: How can we move toward the first principles solution? + +Current approach: [Describe current solution/thinking] +Constraints I think are fixed: [List assumptions] +Desired outcome: [What success looks like] +``` + +**Benefits of First Principles Thinking for Developers:** + +1. **Innovation**: Breaks free from conventional solutions and industry assumptions +2. **Clarity**: Forces clear understanding of what's actually required vs. what's traditional +3. **Efficiency**: Often reveals simpler solutions by eliminating unnecessary complexity +4. **Problem-Solving**: Helps tackle novel problems where existing patterns don't apply +5. **Communication**: Provides clear reasoning for technical decisions and trade-offs + +**When to Use First Principles:** +- Facing novel technical challenges with no clear precedent +- Existing solutions are too complex or inefficient +- Need to innovate beyond current industry standards +- Debugging complex systems where assumptions may be wrong +- Making major architectural decisions +- Optimizing performance beyond incremental improvements + --- ## Communication Anti-Patterns to Avoid @@ -846,6 +1021,15 @@ EXAMPLE: [Concrete code example, use case, or comparison] POINT: [Reinforcement with next steps and call to action] ``` +### First Principles Template +``` +🔬 FIRST PRINCIPLES: +DECONSTRUCTION: [Fundamental truths and core constraints] +ASSUMPTIONS: [What we're assuming that might not be necessary] +RECONSTRUCTION: [Ideal solution built from fundamentals] +PRACTICAL: [Bridge from ideal to implementable solution] +``` + --- ## Measuring Communication Effectiveness From ba0cf19a80273bba6aa7badf21759cdda6e99569 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 2 Jun 2025 10:32:53 +0800 Subject: [PATCH 09/10] Revise frontend-react-nextjs-prompts.md to enhance UI/UX and animation sections with advanced design prompts and templates. Update section titles for clarity and introduce new guidelines for complex layouts, responsive design, and accessibility in dynamic theming. --- frontend-react-nextjs-prompts.md | 150 +++++++++++++-- the-alignment-prompts-of-the-frontend.md | 234 +++++++++++++++++++++++ 2 files changed, 367 insertions(+), 17 deletions(-) create mode 100644 the-alignment-prompts-of-the-frontend.md diff --git a/frontend-react-nextjs-prompts.md b/frontend-react-nextjs-prompts.md index d7810d6..0481b15 100644 --- a/frontend-react-nextjs-prompts.md +++ b/frontend-react-nextjs-prompts.md @@ -211,9 +211,9 @@ Use appropriate testing tools and provide optimization recommendations. ## UI/UX Implementation -### 13. Responsive Design Implementation +### 13. Advanced Layout and Responsive Design -**Prompt:** +**Prompt (Mockup to Responsive Component):** ``` Convert this design mockup to a responsive React component: [describe design or paste image] @@ -226,6 +226,53 @@ Requirements: - Include smooth animations and transitions ``` +**Prompt Template (Complex Layout Implementation):** +``` +You are a master of CSS and React. Create a Next.js component that implements a [specific complex layout, e.g., 'responsive masonry grid', 'sidebar layout with collapsible sections', 'dashboard with draggable and resizable widgets']. +Requirements: +- Use [CSS Grid / Flexbox / combination] for the primary layout structure. +- Implement advanced alignment techniques for [specific alignment challenge, e.g., 'vertically centering dynamic height content', 'justifying items in a complex grid']. +- Ensure the layout is fully responsive across [list breakpoints]. +- [Optional: Add a specific feature like 'support for container queries for child elements' or 'integration with a state management solution for layout preferences']. +- Write clean, maintainable TypeScript and [CSS Modules / Tailwind CSS / Styled Components] for styling. +- Explain the rationale behind your layout choices and any trade-offs made. +``` + +**Example (Complex Layout Implementation):** +``` +You are a master of CSS and React. Create a Next.js page component that implements a responsive dashboard layout. +Requirements: +- A fixed sidebar (250px width on desktop, collapsible on tablet/mobile). +- A main content area next to the sidebar. +- The main content area should use CSS Grid to display multiple info cards that automatically adjust their column span based on available width (e.g., 1 column on mobile, 2 on tablet, 3-4 on desktop). +- Cards should have consistent spacing and alignment. +- Implement this using Next.js, TypeScript, and Tailwind CSS. +- Ensure the sidebar collapse mechanism is accessible and clearly indicated. +``` + +**Prompt Template (Container Queries):** +``` +You are a cutting-edge CSS and React developer. Create a Next.js component that demonstrates the use of CSS Container Queries to achieve a truly modular and responsive design. +Requirements: +- The component should adapt its internal layout or styling based on its allocated width, independent of the viewport. +- Provide at least two distinct visual states triggered by different container widths. +- Example scenario: A card component that switches from a vertical layout to a horizontal layout when its container is wide enough. +- Use modern CSS practices and TypeScript. +- Explain the setup for container queries (e.g., `container-type`, `container-name`) and how they are applied. +- Discuss current browser support and any necessary considerations for fallbacks or polyfills. +``` + +**Prompt Template (CSS Subgrid):** +``` +You are a CSS Grid expert. Design a Next.js component that effectively utilizes CSS Subgrid to manage alignment and structure within a nested grid layout. +Requirements: +- The component should feature a parent grid and at least one child element that itself becomes a grid and uses `subgrid` for its rows and/or columns. +- Clearly demonstrate how subgrid helps align items in the nested grid with the main parent grid tracks. +- Provide a comparative explanation or example of how this layout might be more complex or less precise without subgrid. +- Use Next.js, TypeScript, and [CSS Modules / Tailwind CSS / Styled Components]. +- Discuss browser support for subgrid and suggest fallback strategies for older browsers. +``` + ### 14. Form Implementation **Prompt:** @@ -240,22 +287,91 @@ Create a complex form component for [purpose] with: Use React Hook Form and TypeScript. ``` -### 15. Animation Implementation +### 15. Advanced Animation and Micro-interactions -**Prompt:** +**Prompt Template:** +``` +You are a UI animation specialist. Implement [specific advanced animation, e.g., 'a choreographed entrance animation for a list of items', 'a complex SVG path animation', 'physics-based micro-interactions on a button/card', 'a shared layout transition between routes'] in a React/Next.js component using [Framer Motion / GSAP / React Spring / Lottie]. +Requirements: +- The animation should be [describe desired effect, e.g., 'smooth and performant (60fps)', 'triggered on scroll/hover/click/mount/route change', 'sequenced with precise timing and easing']. +- Address accessibility: ensure it respects `prefers-reduced-motion`. +- Optimize for performance, considering bundle size of the animation library and repaint/reflow costs. +- Provide clean, well-structured code with TypeScript, isolating animation logic where possible. +- Explain how to customize parameters (e.g., duration, delay, easing functions) or extend the animation. +``` + +**Example:** +``` +You are a UI animation specialist using Framer Motion. Implement a 'staggered list item entrance' animation for a dynamically loaded list of items in a Next.js component. +Requirements: +- When the list items appear (e.g., on page load or after data fetching), they should animate in one by one with a slight delay between each. +- The entrance animation for each item should combine opacity (from 0 to 1) and a vertical slide (e.g., from 20px below to its final position). +- The animation should be smooth, engaging, and use appropriate easing functions. +- Ensure it respects the `prefers-reduced-motion` media query (e.g., by disabling or simplifying animations). +- The component should accept the list items as props and render them. +- Provide clean, well-structured code with TypeScript and Framer Motion. +- Include comments explaining the key parts of the animation setup (e.g., `staggerChildren`, `variants`). +``` + +**Prompt Template (Advanced Scroll-Triggered Animations):** +``` +You are a web animation specialist. Implement sophisticated scroll-triggered animations for a section in a Next.js page using [Framer Motion / GSAP / Intersection Observer API with custom logic]. +Choose one or combine the following effects: +- Parallax scrolling for background or foreground elements. +- Staggered reveal animations for a list of items as they enter the viewport. +- An element that animates along a path or changes properties (e.g., opacity, scale, rotation) based on scroll progress within its parent container. +Requirements: +- Animations must be smooth, performant (prioritizing `transform` and `opacity`), and avoid jank. +- Implement `prefers-reduced-motion` detection to disable or simplify animations. +- Ensure that the scroll listeners or observers are efficiently managed and cleaned up to prevent memory leaks. +- Provide well-structured TypeScript code, clearly separating animation logic. +- Explain any calculations or concepts used (e.g., normalizing scroll progress, setting up Intersection Observer thresholds). +``` + +### 16. Design System Development and Theming + +**Prompt Template (Design Tokens):** +``` +You are an expert React/Next.js developer specializing in scalable frontend architectures. Outline a strategy for establishing and managing design tokens for a new, large-scale Next.js project using [chosen technology, e.g., CSS Custom Properties, Tailwind CSS theme configuration, Styled System, Vanilla Extract]. +Address the following: +- Token categories (e.g., colors, typography, spacing, radii, shadows, motion). +- Naming conventions and structure (e.g., global, alias, component-specific tokens). +- How to define and consume these tokens within React components. +- Strategy for theming (e.g., light/dark mode, brand themes) using these tokens. +- Tooling recommendations for managing and documenting tokens (e.g., Style Dictionary, Zeroheight). +- How TypeScript can be used to ensure type safety for tokens. +Provide a small code example of defining a few tokens and using them in a simple component. +``` + +**Example (Dynamic Theming):** +``` +You are an expert React/Next.js developer. Implement a dynamic theming system (light and dark modes) for a Next.js application using [Context API and CSS Custom Properties / Styled Components' ThemeProvider / Tailwind CSS dark mode variant]. +Requirements: +- Define a basic set of theme variables for colors (background, text, primary, secondary) for both light and dark themes. +- Create a mechanism to toggle between themes (e.g., a button or a hook `useTheme`). +- The selected theme should persist across page loads (e.g., using localStorage). +- Demonstrate the theming with a sample React component whose appearance changes based on the active theme. +- Ensure the solution is type-safe using TypeScript. +- Explain how new components can subscribe to theme changes. +``` + +**Prompt Template (Accessibility in Dynamic Theming):** ``` -Implement smooth animations for [component/interaction] using [animation library]: -- [Animation 1] -- [Animation 2] -- [Animation 3] -Ensure animations are performant, respect user preferences (prefers-reduced-motion), and enhance UX. +You are an accessibility (a11y) and UI design expert. For a Next.js application that supports dynamic theming (e.g., light, dark, high-contrast modes), provide comprehensive guidelines and a checklist to ensure the theming system is fully accessible. +Address the following critical areas: +- **Color Contrast:** Minimum WCAG AA/AAA contrast ratios for text, interactive elements, icons, and graphics across all themes. How to test and enforce this (e.g., tools, automated checks). +- **Focus Indicators:** Ensuring focus indicators are highly visible and adapt correctly to different themes. +- **Semantic HTML & ARIA:** How theming might impact ARIA attributes or semantic meaning, and how to ensure consistency. +- **User Preferences:** Respecting operating system level theme preferences (e.g., via `prefers-color-scheme`). +- **Testing Strategy:** Specific testing steps for theme-related accessibility, including keyboard navigation and screen reader checks across themes. +- Provide an example of a problematic CSS/style snippet in a multi-theme setup and how to fix it for accessibility. ``` --- ## API Integration -### 16. Data Fetching with React Query +### 17. Data Fetching with React Query **Prompt:** ``` @@ -268,7 +384,7 @@ Set up React Query (TanStack Query) for [API endpoint] with: Include TypeScript types for API responses. ``` -### 17. Real-time Data with WebSockets +### 18. Real-time Data with WebSockets **Prompt:** ``` @@ -284,7 +400,7 @@ Implement WebSocket connection for [real-time feature] that: ## Debugging & Troubleshooting -### 18. Performance Debugging +### 19. Performance Debugging **Prompt:** ``` @@ -299,7 +415,7 @@ Analyze: Provide specific optimization recommendations. ``` -### 19. Build Error Resolution +### 20. Build Error Resolution **Prompt:** ``` @@ -313,7 +429,7 @@ Help me: - Update configuration if needed ``` -### 20. Runtime Error Debugging +### 21. Runtime Error Debugging **Prompt:** ``` @@ -333,7 +449,7 @@ Provide: ## Advanced Patterns -### 21. Compound Component Pattern +### 22. Compound Component Pattern **Prompt:** ``` @@ -345,7 +461,7 @@ Create a compound component for [UI element] that: - Follows accessibility best practices ``` -### 22. Render Props Pattern +### 23. Render Props Pattern **Prompt:** ``` @@ -357,7 +473,7 @@ Implement a render props component for [functionality] that: - Is reusable across different UI implementations ``` -### 23. Higher-Order Component (HOC) +### 24. Higher-Order Component (HOC) **Prompt:** ``` diff --git a/the-alignment-prompts-of-the-frontend.md b/the-alignment-prompts-of-the-frontend.md new file mode 100644 index 0000000..45196a0 --- /dev/null +++ b/the-alignment-prompts-of-the-frontend.md @@ -0,0 +1,234 @@ +# Frontend Alignment Prompts: Mastering Precision in UI Design + +A comprehensive guide with AI prompts for frontend developers to tackle various alignment challenges, ensuring pixel-perfect and responsive user interfaces. + +## Table of Contents +1. [Core CSS Alignment (Flexbox & Grid)](#core-css-alignment) +2. [Text & Typography Alignment](#text--typography-alignment) +3. [Icon & Media Alignment](#icon--media-alignment) +4. [Form Element Alignment](#form-element-alignment) +5. [Responsive Alignment Strategies](#responsive-alignment-strategies) +6. [Alignment in Complex Components](#alignment-in-complex-components) +7. [Debugging Alignment Issues](#debugging-alignment-issues) + +--- + +## 1. Core CSS Alignment (Flexbox & Grid) + +### 1.1 Flexbox Alignment + +**Prompt Template:** +``` +You are a CSS Flexbox expert. I need to align items within a container. +Container selector: `[containerSelector]` +Item selector(s): `[itemSelector]` +Desired alignment: +- Main-axis (justify-content): [e.g., space-between, center, flex-end] +- Cross-axis (align-items): [e.g., center, stretch, flex-start] +- Individual item alignment (align-self on specific items, if any): [e.g., item `.special-item` should be `flex-end`] +- Wrapping behavior: [e.g., wrap, nowrap] +Provide the necessary CSS for the container and any specific items. Explain the key Flexbox properties used. +Using [React/Vue/Angular/Vanilla JS] context if relevant for dynamic classes. +``` + +**Example:** +``` +You are a CSS Flexbox expert. I need to align three `div` elements (`.item`) horizontally within a `nav` element (`.navbar`). +Desired alignment: +- Main-axis (justify-content): `space-around` +- Cross-axis (align-items): `center` +The navbar should have a fixed height of 60px. +Provide the CSS for `.navbar` and `.item`. Explain `display: flex`, `justify-content`, and `align-items`. +``` + +### 1.2 CSS Grid Alignment + +**Prompt Template:** +``` +You are a CSS Grid layout master. I need to align child elements within a grid container. +Container selector: `[containerSelector]` +Child element selector(s): `[childSelector]` +Grid structure: +- Columns: [e.g., `repeat(3, 1fr)`, `100px auto 1fr`] +- Rows: [e.g., `auto 1fr auto`, `minmax(100px, auto)`] +- Gaps: [e.g., `1rem`, `10px 20px`] +Alignment: +- Justify items (inline/row axis for all items): [e.g., start, end, center, stretch] +- Align items (block/column axis for all items): [e.g., start, end, center, stretch] +- Justify self (specific item, inline axis): `[itemSelector]` should be `[value]` +- Align self (specific item, block axis): `[itemSelector]` should be `[value]` +Provide the CSS for the container and any specific child elements. Explain the key Grid properties used. +``` + +**Example:** +``` +You are a CSS Grid layout master. I have a `div` with class `.grid-container` and several `article` elements inside. +Grid structure: +- Columns: `repeat(auto-fit, minmax(250px, 1fr))` +- Rows: `auto` +- Gaps: `1.5rem` +Alignment: +- Align items (block/column axis for all items): `stretch` +I want one specific article with class `.featured-article` to span two columns and be centered within its grid area using `align-self` and `justify-self`. +Provide the CSS. Explain `grid-template-columns`, `gap`, `align-items`, `grid-column`, `justify-self`, `align-self`. +``` + +--- + +## 2. Text & Typography Alignment + +### 2.1 Vertical Rhythm & Baseline Alignment + +**Prompt Template:** +``` +You are a typography and CSS expert. I want to establish consistent vertical rhythm and baseline alignment for text elements in my [React/Vue/Next.js/HTML] project. +Key text elements involved: +- Headers (e.g., `h1`, `h2`, `h3`) +- Paragraphs (`p`) +- Lists (`ul`, `ol`, `li`) +Base font size: `[e.g., 16px]` +Line height multiple: `[e.g., 1.5]` +Desired approach: [e.g., using margins, SASS mixins, CSS custom properties] +Generate the necessary CSS or SASS to ensure all text elements align to a common baseline grid. Explain how to apply this and verify the alignment. +``` + +**Example:** +``` +You are a typography and CSS expert. I want to establish consistent vertical rhythm for my blog content area. +Base font size: `18px` +Line height multiple: `1.6` +Key text elements: `h2`, `h3`, `p`, `blockquote`. +Use CSS custom properties for defining font sizes and line heights based on the rhythm. +Show how to calculate and apply margins (top/bottom) to maintain the rhythm. +Explain how to debug baseline alignment issues using browser developer tools. +``` + +### 2.2 Text Alignment within Constrained Elements + +**Prompt Template:** +``` +You are a CSS expert. I have a text element `[textElementSelector]` inside a container `[containerSelector]` with specific dimensions or constraints (e.g., fixed width, max-lines with ellipsis). +Desired text alignment: +- Horizontal: [e.g., left, right, center, justify] +- Vertical (if applicable, e.g., within a fixed height button): [e.g., top, middle, bottom using flexbox/line-height] +- Handling overflow: [e.g., ellipsis, clip] +Provide the CSS to achieve this alignment. If using Flexbox or Grid for vertical alignment, explain why. +``` + +--- + +## 3. Icon & Media Alignment + +### 3.1 Aligning Icons with Text + +**Prompt Template:** +``` +You are a UI and CSS expert. I need to align an icon (`[iconElementTagOrClass]`, e.g., `svg`, `.icon-font`) with adjacent text (`[textElementTagOrClass]`). +Desired vertical alignment: [e.g., middle of text, baseline of text, top of text cap height] +Icon library/type: [e.g., Font Awesome, SVG inline, Material Icons] +Provide CSS solutions (e.g., using Flexbox, `vertical-align`, adjusting line-height/padding) to achieve precise alignment. Include any necessary HTML structure. Explain trade-offs if multiple solutions exist. +``` + +### 3.2 Aligning Media (Images/Videos) with Captions or Other Elements + +**Prompt Template:** +``` +You are a CSS layout expert. I have an image/video element `[mediaElementSelector]` and a caption/text element `[captionElementSelector]` that need to be aligned. +Desired layout: +- Caption position: [e.g., below the media, overlaying bottom of media, to the side of media] +- Alignment of media and caption relative to each other: [e.g., caption text centered under media, media and caption block left-aligned] +Provide HTML structure and CSS (using Flexbox, Grid, or other techniques) to achieve this. Consider responsive behavior. +``` + +--- + +## 4. Form Element Alignment + +### 4.1 Aligning Labels and Inputs + +**Prompt Template:** +``` +You are a CSS and Forms expert. I need to style a form and align its labels (`label`) with their corresponding input fields (`input`, `textarea`, `select`). +Alignment preference: +- Label position relative to input: [e.g., above, to the left, inline] +- Alignment of labels if they are in a column (e.g., all labels right-aligned for a consistent starting point for inputs). +- Alignment of inputs if they are in a column. +Provide clean CSS to achieve this. Consider using Flexbox or Grid for robust form layouts. Show how to handle different input types and potential for error messages. +``` + +### 4.2 Button Alignment in Forms or UI Groups + +**Prompt Template:** +``` +You are a CSS UI expert. I need to align multiple buttons (`button`, `.btn`) within a form, a modal footer, or a button group. +Desired alignment: [e.g., all buttons right-aligned, buttons spaced evenly, primary button on right and secondary on left] +Container element: `[containerSelector]` +Provide CSS using Flexbox or Grid to achieve the button alignment. Explain how to adjust spacing and order. +``` + +--- + +## 5. Responsive Alignment Strategies + +**Prompt Template:** +``` +You are a responsive design and CSS expert. I have a component `[componentSelector]` with several child elements `[childSelectors]` that need different alignment based on viewport size. +Alignment requirements: +- Mobile (`< [breakpoint1]px`): [Describe mobile alignment, e.g., items stacked vertically, centered] +- Tablet (`[breakpoint1]px` to `[breakpoint2]px`): [Describe tablet alignment, e.g., 2-column layout, items space-between] +- Desktop (`> [breakpoint2]px`): [Describe desktop alignment, e.g., horizontal layout, items aligned to start] +Provide CSS using media queries and appropriate layout techniques (Flexbox/Grid) to implement these responsive alignment changes. +``` + +--- + +## 6. Alignment in Complex Components + +### 6.1 Navigation Bar Item Alignment + +**Prompt Template:** +``` +You are a CSS expert. I'm building a navigation bar `[navSelector]` with a logo `[logoSelector]`, a list of links `[linksListSelector]`, and a user profile section `[userProfileSelector]`. +Desired alignment: +- Logo: [e.g., aligned to the far left] +- Links list: [e.g., centered in the available space, or left-aligned next to logo] +- User profile section: [e.g., aligned to the far right] +- Vertical alignment for all items: [e.g., centered within the navbar height] +Provide HTML structure and CSS (likely Flexbox) to achieve this complex alignment. Ensure it's responsive. +``` + +### 6.2 Card Component Content Alignment + +**Prompt Template:** +``` +You are a CSS component design expert. I'm creating a card component `[cardSelector]` which contains an image `[imageSelector]`, a title `[titleSelector]`, a description `[descriptionSelector]`, and a footer with actions `[footerSelector]`. +Desired internal alignment: +- Image: [e.g., full-width at the top] +- Title and Description: [e.g., left-aligned, with specific spacing] +- Footer: [e.g., always at the bottom of the card, with action buttons right-aligned within it] +The card has a fixed or variable height. Provide robust CSS (Flexbox/Grid) to manage the internal alignment of these elements, especially ensuring the footer stays at the bottom if content is short. +``` + +--- + +## 7. Debugging Alignment Issues + +**Prompt Template:** +``` +You are a CSS debugging expert. I'm having trouble aligning `[problematicElementSelector]` within its parent `[parentElementSelector]`. +Current behavior: [Describe what's happening, e.g., "the element is pushed to the right", "it's not vertically centered"] +Desired behavior: [Describe what you want] +Relevant HTML structure: +\`\`\`html +[Paste relevant HTML snippet] +\`\`\` +Relevant CSS: +\`\`\`css +[Paste relevant CSS snippet for parent and child] +\`\`\` +What are common causes for this type of alignment issue? Suggest debugging steps using browser developer tools (e.g., inspecting box model, computed styles, Flexbox/Grid inspectors). Provide potential CSS fixes or properties to investigate. +``` + +--- + +*This guide provides prompts to generate solutions for common frontend alignment tasks. Customize them with your specific selectors, desired behaviors, and project context.* \ No newline at end of file From e3984e569777577fd14229cc293f817ead6ef6a5 Mon Sep 17 00:00:00 2001 From: tonycai Date: Mon, 2 Jun 2025 21:09:56 +0800 Subject: [PATCH 10/10] Revise frontend-react-nextjs-prompts.md to improve UI/UX and animation sections, incorporating advanced design prompts and templates. Update section titles for better clarity and introduce new guidelines for complex layouts, responsive design, and accessibility in dynamic theming. --- .DS_Store | Bin 0 -> 6148 bytes ...or-google-workspace-prompting-guide-101.md | 3280 +++++++++++++++++ ...r-google-workspace-prompting-guide-101.pdf | Bin 0 -> 5262736 bytes .../prompts-advance-tutorial.md | 156 + .../prompts-tutorial.md | 52 + pdf_to_markdown.py | 64 + utility-tools/pdf_to_markdown.py | 66 + 7 files changed, 3618 insertions(+) create mode 100644 .DS_Store create mode 100644 Google-Prompts-Engineering/gemini-for-google-workspace-prompting-guide-101.md create mode 100644 Google-Prompts-Engineering/gemini-for-google-workspace-prompting-guide-101.pdf create mode 100644 Google-Prompts-Engineering/prompts-advance-tutorial.md create mode 100644 Google-Prompts-Engineering/prompts-tutorial.md create mode 100644 pdf_to_markdown.py create mode 100644 utility-tools/pdf_to_markdown.py diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..b35b58d855c0448efcd9eeebe0a131c2f9ad4e7e GIT binary patch literal 6148 zcmeHK%}(1u5S}FgHlRv5PziCUEcHs&L;(cq#SMvit?H^hlq!vDD_A&Q%XXSW6v+<& zZ@`oA0DS}`9-%MLD}4JC36ye)5TI%&n)zmbW}N-3-SrR=Ymb5^QJsi5RAO}v<{u)* zrOwHc=~)3Xl_RE*-q1(NNX*T)9hL#hz;k0j?%gf=fc+|HK)3hrkWwlr$A0cog0ToT z#4l6cz#r$S9}6Gx7k(N?dC_QGvZYFOd1aNa@^${*I~HTF=oh2B-Os+s)@LDNf9Ci7 zFHtz|)i(}BQuL!F%v3-WgqU*lHA(_8Zi`V88~% zCI>rc>^1hM(;9#I`t7?+=5Z-e3RU4YDoEfMwvnVt`dUUZ;&E znY(pvaq_Nppg*8eoHOTpW>;BMB&E4{x%r7%mX-%chzWT4`1nCQ zAcUzcv5*j0(Zxt09Y9WunB^tKyX2RUViXnkbodq1L%ba z@e#|!%}G`PS&eB*_~{^1)R4=>-J z_VMxX^ZbLx#|Qh7X!9Qaq0D;2(97_R+;6KJgfS-@|AF}*>{D00r0e%62Kkb9Vpge#2 z3()xgj0-Rv|9CDO27~`o9~|;$T;PH{g8!uP3jApwTo3~NlLid=zpp`8q=}8a1rn79 z)PWQLtZ5hzSPg-2MXi1yRv0oEMh!@(maBaV*FBkf>P2v5>hY`1F#Cx!u_vw z!Y2Ua4;NPxr0aFk;2~yVky4iapHu=O=H(Lr!uNN+k^({a;83u%jlHV{5-e?R;%Xsj zVTLfb0Ly_O5MCgMSvXp`T7!V>1qG{vAUqI=h=_|T(!#`nn813j?}@i|oDR(+1_Gw6 z2$=YY5_^Q0(xJFObd;`RF*GlGo^_FBNK*Y!+*ZHltM(-3Pm)q}HeiQK)je7ZJ;}=}0#bdx*xcT(72@MT|COU&Ji#8P2g0Y^6 zEd;>`_P?J!sd~yMfvxBr@UBtv0i{gYVEoTC)>-#LYf9;|N74dz>!vT9bh>&9p;+GT zIK(Px0=y##aRx*F4kzNt*L8BDCxzldY7_>1NoDTdDGrP3%9Ez?M`MLz^Xp$O@g?S8 zf2)E%Wv!*Pf}2AJcB;dC88fGSsZ?~E`k2}6*KLoegmY>gnAMVV@|z*Bz=K-9Nu?yY zcB#)Y`0F5x^b~X)_jlUF>3DbpFQV);DtBybtY@#s2b!hGQc} zR3^8S)Dml*hE17Uk(d%8yCE-eC!~J4t>(zEmv177IcpxXlVdjBR~Dzeox$UGQ$MTW ztCQIfN6_;5^THYEQsXDL1#b0?7whIKQoaqfrqS_7Kd3Ay_n*OGI!jwyO?Pi2+=$3N zGT@WD2_oS`I==FvO#*dO&{ho^*UuNGDVs(g5*AX{MHI55ZsEI`|A2dv8-}I()z*E1 z({SB$lksL>Cfama3VV1@Jm^`GxoU-rN}|HVqUu~Jo!)&1;eM$f9*>{F?+EOMy-*-B?g+90bZL@st^Mr&@ezH)^qmb9- zp)emPsTJ?mGFrx1FI9We@4yt;JwOY$hmMr3Mq3*fb zSIO7|uGR}lc*J8ch4~bPI3*Eo3{#}`BeZ;3=zu?|+UMbG9ijnF=KnYkc{qW>YsX=9K1T+I2Ho1pq; z=UV?(!Sn&~?GfyZ!NZ!JHixA66}}AFmU6^%d+7Ov=8NObnfjrYfr!(b4^2r!3T8tM zPm-=&rk~&1n;H~k7d6aaa#?iOr%1W=u`{6b-VYWAQ{ss1){BJos8l`wSC`dr=BVVp zx#gx;`s&AxU&jiuA0J^zcvrKivo#{$w&RHNd_!k?CC}-~RSVNbT%sP8Ey-OsUA{A( z!HJ%I%$vFE=-64hMF~~AW0bgj$WhS-+jm^2T|t$w=$c3Dd9YGFij|wkc)9Ue*agUk z@c2m=OHm2h5+So;omSk<42r17>W@AsDEK<_nYVUaj^7p_cCMr?)yc)4Qn14lm^u=+ zZ0{2|GX3&lTi8A>60U-_03%ePTnW-==*`@%cw(`k|f<{r02f z;j3^#euf?4yHt8#I=F04wFScrCv0fOKA;tRDs0=qo`Ro^jbt@Wc-WGh=-e8~yDVuY zIc}Cvvu%)-#!@d57AQ6K_~uR<@hs^p4P5&60co{gO88xzqSCd;gZSO8QQ^@mm$$Qi zs$p`0Zlrc>jy&mfa%I=n-L&h|`K}`2%OdoZ#4Nrjx?s;h_Bn;#k-8fRhm9nEynBQF z54Mn^=%)^(dlKijky?-{Kc8d)NY#iuj++S8vu$<1mcfsR7pI2Ljx{c;_DwFUKE^Q@ zx9~z{3_V*7SGrGIHIR&D^Isesknb3NSTN#8gm+BMQ@2xyNloR>#`>KOt6U1^zVwz< zO(>|KAaHS}yvG!GO~1 zYwH7+Z<}w3g;dBH{MkFCPQQOL2+4v3-U5?r6(qZKL~aPW*y+FVoJnR&%(0UA8q)JT zJD!(n0s9RkXXFmGr&EMT0Jmxe7TdF~FHgH(gk{{P4^CRAB7A2d-KFqd%3@$}^!?({ zy^Yuf3CUG)x?oSI?-zA*rUUI1IFzq{q9gYie*NOwK6Jg=X3}`K^#sOToYacifm${q@-b~c&ZI20r`5;MZCq2PWl=#0krO(D*V$)xdT}w4 zkeVIxdQ6VcU@+-NLn8AQ^c6IBV|?*@lGfP{_g?tp8HZ7maWi9q(DY(xjUV#SPAUna zwS1lhU6#rss$OHJB&W!8R*TCndE(!7=??{;Br#)C@Ss9#jZ zXbOV6`KUwLZ{YL$c=j9A{eAK?akOHyaOBcdX9p`;xSE)oxSF7l9)KAEr1#jw!NLXA z1fVt0RCcm(6f<+RK{%pl00akUDkfIfEGR?{G&P<&S%4(~CH4p_@Dm#g4+|uK@+>Wo z7LH~XE&#-ov_V>2s{kwVsfhruzmJW-HU73sQV(bYAR169ZR2VHRtL)d9P&$5di6LFZ5uSQH+`!=rxCD6lfOp_X$<1Q`7Pq&sF#lhBB@m9T z7LKkifKiZZKY?dKu496_xi%AZgF>ikzzyo8`PU5q<^Q_5HVoBuEp7moKq8#}*T=~q z5pGTZv%p^gP_i($G5KGaRZM``qOdyZ%mIW;&B6uYhWsno5(s+)Qr*eK%mRqKggOtv z1-Tws5fQMIr>l&*D}bDVE}6f&{(|>1>bw9S>eK)N1_&$-_>Pk1GeU`@4nU}3*0|Pn z?I+Mc3GiP_0|F{Ygqga9s~#9AIe;}RJb}>zNKO_=SDWh@pd^8kMV*?i^{ZQ(nA*%BA4{%gLc>&@9YaneL{?{;F zPfXNg1*_Otm|37sG=MTWM@b788!JcPRuW<6<^V)ePEttv`V0dTiMLA zdw$@8|MdwGz#s85u)C^LWvp=j69_#Lh5i2O}Mx$>I_<<|d15=Hy% z-ruq)*MYjhb@Z-3QO`i}pe~diRQozizzqKFs-~Qz20{^GW`at2l0Z^ZGI0WC3XdKP z4*Q)%AiyUtOn_SuDhT3-qS6XbW#Q)G1zH09+`Rly5btl!>ptL~4+`T3Dmx&4I1e|3 z&j8G;2LVbef+$JgLh0j!@Nxr(dtd;r*-=>v0{idEAV3b|6=~zCXybxfJUn`TnuB@w@|w?-`+b64yCp7 z#>mUBhOdf8)!^%k9C~7VcY(0VN+hGZ2UfpRymv3jj{)2-@_2XRc!#(XvL6pRpg>#}CCoeT5^&M~-#g8w*4rpIH z-fMDB^>h2x2{N*SY< zY2|N~spqeksqC+uDd8_+Oo9%_Iw4*!n5j42`+O08aedK|!`Zyqz1Uq;Rx-B>)(iT? zVxNBzTg-G-5oANrj)o^g;A}{h)y(eJ*UuSovnyIB*X^AI9?+&m4d7V)m*&|v(cmtH zTews}r3LTdEf;y^Ploc0X5epTA~W*KzxWtFb-iydQ$*Z2eY%=DEtt0~(rmiw5=}OD zyno2WuaA@TWHJ7V!Wa#rME&Z&p%_%z_wSuu+{DEKwNHVSbR>1fr8s2}2rGLFbzm8w z_8%@a3oAE!6C_y55vUOXdkt92#!<}C#pZw7(l$sJR|#tqBv4nn-td53!3=5RqZirOSm4A*8|uOAmZ zJ}6Ku2NDI!^1uHeP++A47pnbNAL<>*L?Bdg5CY=`K><%uMO7$JNCrxzAgF)<2+9iu zLHYl>NAdqlD-@{f!-4Xi!1V?WR9Qg+aDWdeghHWE5Kz?z+WY`N(7uKOP{1ZZetr;) z2LgftH8z237y*T&?oeB_fFNqehocI@fCZ>s7jnHR|MiZt8Vcw_@uCWxz@7ov#|PLA z=m!d!D2cyt96z9u5AZ|~>7Igla8YB0bdpH|9xFs59dQ=xqsy=2ukU1Xef?w18_0`4N*v!8wLbIkkZ{x0Q1@>~30}^x9FkZ z-rvAlP90=vV((%B7FPm4Mr}OyUf3|L*s#KjI^bp%!r zYL)yC7zLXF#}B{~gwtPg|1n^wRr2>E9bIk2>}^b3eyjf%(*0L}z!C@q@_JN(3Gr8m zuD7~>j;kkt?#=a3mR+0oujrsw|Mh?Yc=Q^k{uQqOunLtO{@O@1hXaQoCs_*{ zD{EH}j8_0K>aQ*?Uf_EVRK?oL4>5a2Oxxx)UG+n?LZa3>+{6$Z66h4mS2r z+5SptAXH8Rp^_T=U!6eZo)0yd{=)t!e$<)m|Hy+VHg%vH?rLWJ_i&*|T7Q`ffC;c1 zaDcNh6LSQzC;+V00oeBh$P)j`X#dKOVC~;t0$&>bM_5n?o!?>k-_Za7G2s6W2O6|` zKiq}gnqAYfwgJm)?Zs5hp7hzaM1do#^L|(>R<`c`3W2Z5e*RELY)0MZl;s$#M$oyH z7V2~A)zI)uq-M*CD*e*u>dNz+wZrHU1GuCF-L9mWZWjB8o0i=%BWqHfa^m;Rk$ue{ z7su7h)8ot!eqNn#wH9&Rvtq7&+;b}qq`#MoV73p1y?AJQ9-SK_>J~gvA%e--_Xil*WW>CIm(m;zgksmmw$1P z;#0MLE6p~$E-nt1A8F=E_ab~PXgW3v(iS>ltXROUbtqh~&0+5hPpKX@c+qr|kG#R4 zmcFO-OG*TLtIK{Z+wdX?)BhE|yh^`>jx+eA{e85^@6j-fS$BH^vKphDo8UBcEi zzL_yxu*FoJQ;3Dnhp+|=4Y z?`l4H2MHpDD^8|bB>A+&#)ZS~p;h9eXKhn-cBo&TyO(}E`9-dR;dJi))lm438n=kJ zgu`t{F_Dz>P@4ChK3f}EZ{~_crAV~dE3k^{2-GDibl$=<4!BL%Ju8sj+R3$r>=zi` zY&Wo~^ZY?w>Uq&?uTr0gS6wEP2`Q}6@)*4ItDi^b6TRxr573a|D5}@coDCREl38?C zmmbq2DQjCKTr$K!;-zOqdpxR1+Ixg^dY*lGf_u7nmdW`hv)@})0Y9vDZvjE-@&g@X z(U9ClK$K7wDv6`1^FF0Sgg$A(nfA`UvBev1J|-BR6IHQT-_SQMk|vJavIn}2gh%3+ zc@y<>iz)~B%?d^bP>tPGk1V{!wsJI+)u^ps$DX>KCpA?P>i6H>n<4#Dx3Yg=Rewk6 z4Qn1)ef$JD$A?*(eM{rK*XIXBjkYG1acQHch~bVIaRR7hSVvT?D95{SU)KuFy==XL z-{+13hUwld?mKtf0=>Pl?ze(FLL!4j7cf%4M`5iq7kJ_jya^O*;ShobZ4GB``dEc> zyAkDHw3}hDD=P4()t4C{5eoNeAfpw}E?*c5(B{947fRw4qR%fH6htfK+Qcv4us( zL~|~2=QiFab`8&qKOW&d;Q2)vAWAKf|8^3ChHT^sJSkIKVlLR#h)ikE6Pgtmu64?Q z$C1lDuA3}lP3RR~SuZk0e`;_h6Owp47W%{3OtNJ69cG#F?(1g~^!Ipq+xtYUq=qRF z817tL8eo%=_FG|~{N6DJhE&A+c_}8B?@ts1BJ7M~(%!^;{aPbuDxLm0qx{p5MA?XPt+P5xapX0z( zQ?NpZ_ZIO}B_6WG+a`#m~wDa@syq~+-nnge30$SN}Bh>D9nj};SJUe`_&g4rvuMB@Yu!t=+6UD`MR@#y(!;l&WXE>Gn-kbX?^_V)t&F7EwIDh=w&$ z2!$6`Y#EL1)6%!N(|C1w3I^kC&aL%m!A@-WZ9huUx;7&$qn zQ{0QX?YoP=#H|}x8n)K)5DmVl+iTC5UDlvv=5TvSXeQtcw{g8L=4$YS(|X;ejOj(0 z{|DD{d^eq^$+IQQcVa0--SXb5>wLi@qtajX;l+KylJ-rYlSw=z#u(HVGT7O>&9+Wo zA;wH1&c@qQF0XU-ZbZCEZhNPK*S3b(MgZwftWms*M-u5}ssG@;-WU7NKU~!}+}LTA zcrDdg)j9NjaA-JIDE57h`%uLB{1Z|3EeH1A3T5=f3zcmwXQL6aZPRyIZumBHQCG?I z4>0e*;76=TV=PIM;T#S&!ZKunwaIvH-c6E#B%5zUlrawMZ+In=-n+6o4TARhEhVef%H;_&pV$yk`6^^EGBjql=;f{$ltE`+~L_qz%XY+4jvFp_F1@ zSLA&>^CLXUXoyI{MHd7^_jP99kU0(YHRXg^lH_f1A)_Tl``2wj_{#zayok454Q2k? zq&-uw0){%y%L?IEu_By?BjOg%1b@2Bm{>|hrrlV5au+dxC6R2-h9f>+?L^s2-a7cD zRpRxrydJ^+$hbfrwQ$50jypf{8TG9RY~z}H%3dl<+^hJy(lxyfUm+I+MBA@5?0;4 zn6;ksMI%Z-L~n&T^b-zNEKh!TGv4N6L-CF{9kRO-J@2#(KFP3p`KsX7`PUvvXIMk~ zFRzdw2UnpaokhjnFmLMF?bb@SPK#6O>D%?aZ@Wlv$2Ad%;Hb_i&0S6U>CbeYyHPTe z2F(7(zKwS6gjZJ$KhH04nT8^q-@EqM?)q9a(1+E~8A~|uv!O+u;YCvdC0)7k?Bkt=@xssa8Jv8$ zpU3=Dj*2f6ouM$1mIh8w57_KcC#VE=v}KReWOpV;pP)|yj0 zSkaQaNre@bT#}=Pq|73#P7)7US@g@lDHwqVs>&n~w=+F-9$9IxbBM*obmuCK%yIZ} z+EOAueQsKbzv+pHG!(;8Cb`v0nByQsy>Za#Yl@~l@qOFO+_3&ovq%EoMesT#4uih1 zzl*TNP$!KT>#o6~4BcD@Wo+g9?SwS^B@CVaK=pM`ajWAy4e& z(D)qV&gV_E@1K`UA+7R9sf-?h$LDY2%HO}mqLyWN{TM?c$K?J8 zDDQ)?MVf61f4yFZ40`i~>p8PLR|(`BE85MJ9L{AsCWA~s$jTxT>Frh{Hdoh+Bn!%0 zJ{|t(S!gBCsu)xiam#or=(B5Q`>=~r+m1mYYIb++)#DcM*x|l%&{0iugyQhi&yfKN zuRPH6=)%B>J+jGWb~vRft+CeZ91C`2eiAlq4`X(coX9mFt@a-J!O zNRc|F(n*-;{iaEUaK3_}OD?=#L1G}((`sBOmv;1{X`h3b>wJ51q=9&E&?g}_`do`O zF3U&9r7>0pB5wV``qR1o`Ky~=3c}MrCf7}do+s1n=$oqSiPOcAJonr%-b?=%d5_4@Jaz+7$0XPB3E-*H;h0mM|xoZFS_GC1KJdga_IDuPamqG`NuKu!<9!0%iivw=W)sJC@@*s>1oeXY=(f3`)xM%Gdne6gH0KatbVkx;Vm4NtGgvdiyV4Ol`bQEpp) zDOcAVJ*iLL10J5=~Ts*|SxacEZY5Z;)Ybv4t#8FfPR z4fea(lTg?MY)#`^(zy&xjhk(aoK~}Xa|jyl1}tJN-eybr#amR}bfdRF_V5A@KN>DC zp}%-7Oc`*8x4DlVxheSkhUn0qV9GjKa7Xbb{Gsr%T}JBT72Ub;iNTLAane6_Pbm+4 zc@?kvD`n`{3dZ>EpbAybFR!1ifg2Z;)6zfZAF1#ixB6u^jSZ(Jc1p0n=9bW+ioDHQ z>e(9L&fQpIfLTzPmnKOd#evS#jP)LiK=`P@_mfV`(vAXtcgRUB#!yg^dRw_9T-1(i(RDK*%aUOA#gddD|@We~jY&1rFk8O`27YE)^^v>b((6`(l(QGN{dc@>Ko4ct(O0bFZaVF8}^WWGH=d zkXC#pKiiLpiZJC9c8eXcRK?~Jzvej-?vqy%A=weiQ%f~PPI)UHxT4mdtj~M4sC8?Z z&o^(^e?T-Gc!H6lFv9G0P`~V%sPO1r9nMW6zUDwTYre5hS+C!w zY?7DL1y!U8@$&>qMcC=s4e}G7rug=2lgM+JoF^VqvpjQM8H6vW3O{8X7pTM}QVc2{ z)|dk6+JDt3)c5AOjC0}3`TiIoKGt1aF6{8V*``YW=|(u@_DJSq^2e5jzsQWyw)5BH z{wrcZm301Z!~%Rp`0t3tM@uelM}TPhm--pTAd4#I`$N}Uj)bUwO}?WO=jNfZ<2g@V@sk3IA^14vk0ae2Gzp2%?ChX57sebBn9ozbhd^mNWKo zab^8x-KxRev8kxVrxDJZbqXvgm2g`r?#_v$_gi-!_R6+W;P;4BWih-MZDAd8@(-nqu~!Su&in4gIqZbnv#XTIk*BD~2p{|O4;L?Sp9DA$ z+{Tc3u*&bW4&$Mtjo(%Bdf1|9&dnqfnb1m|Hnf7fda!5YXWHSIdSnhVYra9Ed3J&+ zbNa;^&&8f`WzCPMTfdfF5I2HzNx$@@Dwz67UDmjf-;WE$9JTFzru~XF$sR_DUoGURMR90JNz%h%Z%&k-Ir!SAC|51o;TyR%Q z-NVq+9qon%HZ;juZKwF7)nPMXiW?FUTLHy)ENQnUa^N%)WIl zVJ%y#F5JB2!#AQ{ZT3uF(qL>X4yyOpRuJnNKAhIi;oXgN#n}&O?^2CPt!rAo8B;-O ziL~}xtMnOroS@>nqsUdXrauwxQmr&(ln#!Ftr3WRgrj+|37BjM($Q$dnS z0TrR7maYxW9j3PfWY|HEo-{1`mx?}vJs6f1%C7$W%HD3EDrVBu2IGdou!8;b%!vlO z5yQ=dBgG6(PJ+hX%Bz|5Zjzo2jRe@3XH)hh4?-&c*+4gCk!-Az)!|60+nS4pS2w;? zx<;7_*^`EcnrEaxHRdE-d0WGzmm)Q}`vgA~E5|H%rw4vy9U)s4=^;e8+qRD)g(X|k zf|@=}xs2Su$-w%p9}C@J-Hx1e&WGoKhfk*UQs#y zL4xH`{()eBmm=8q6*RfJ+j9qpPbt6K&RZY@sS)4R&p>TIQsbziO6MP)y^&w@C1q6< zyu9ZBHZOz4sc!0qMRBM8N#n`Fopq7qFoJtJFUj#uj-_`_Ybn4r&d7~lDz2ooQH3z=qbyThJP^<1y<^URHL*MTQD##1iq@v>!<+(VDL zFcHe9=*<)KfyvvS`5Da#OC!np1zZ*`Z-<7=dz=Y`T$zbZl6?H^k7@hvyh1?~)0q)= z+m8s8UgK70xgD7vtU$r&-LGYTmUg`5e(p;5ux>t_)A)#IlKtt2gwNF}QrxLiwZ_Vh zgT#shcCl7CPnq9*Fs8MJ*i||7yz%TlXAV}0QZ^95NcZuC2sL3;?`GW=7V!{qCQ+|% zwArKfrOus5I-pp-+rk?&iX%YJ>FKND8^1inasL#n#nKSEWH-`fF*l&KHcx>3tTzTlY;(>2>+`C22R^O&R&e%<& zWP-(sk^fAam{YTL;TXGj}l)|qJ55-s3)&&vVmCAKmnnZ$y zqtS2iX>B|nMBK#eWN{Sal4^L_m6?joCf}I-;?i~XW%&39M2J~}fsC`8uv6!V=?zh| z2tzCAoe*wV?WN7Y>BeeAv;*7ilG2a#ED#Bvk!p&AI{JC+Qs%>iP*LwqI}9}y*XsA0 znd&;R8wGWW#h!7R0qKQ^<86#GV|KS%_$7N!NJ%?XhiOwP<~v2Quu2M`eM(bra5uDm zcXIUox_okQdRow8Nm{TO>)PVUy^d5KqZ`jfYEJj}JPOym`DB*Rcy7PerCB>14*&j6 zXvi@9?i>8XvbRFMZ-)Z19!g5_x%8g@2q1hj^<-iMjdJ{%=ze_c_u3l^nBOHRwhSG_ z7cC0E^HlQK?yp<_!uLKVONpkZU{C;1z@cKmGXoA56%GnQOrlS>Sj_m*h_a#zru1Jy3pV z_H|}H-8lX$qVU6lT>waQWpB*;eR=bIQRL&Z5j`Ekn#8iT&dS2Z=10xZ=+hTJpUr^c zjU>R0l_eBYTacPfj6!p&NWRz33u(@vSGu@F*}lP)getV*HGOk*lT$jL$A?=SlHs4q z<8zP1{P}vc_SE`gTdRDM;BABR4qw%vM3c|>d0Z}W-rD^~h>huWOzRyjmH+lL zeHO_`LRI)?1HX6<6x+0=#r1LJ0ZGH!!SNj(%n*B>?==Bh4oOKZt#1$9wFC=VX6{S{ z=*5uP3=1};^2bav@1=}7>_2+y(LM_jO32x6O7#%g_g!Zr8x)GPqNq!A!?HK`f56LmmEwUL$B|REg@7 z1xDRcHQ$iXzVaW)d1B{6H|3D^s^0sKRQKoSogMTnUvAa&85e;C@z{gbMS<5?PKOM2=NHLACaKhD#)Iq1&uF@K(kreF~8nPXvJ+q@Q)8b_aioX~_yZTQn)1=dFq*S^e7+<|~^-#+4}#US&kL za4vV2?+VEPsLi&S*+q~4r}MD7wxjHUsS6)%h|%iuL7(CUD{tz4R@67p1%{Yw5gc=?0jb3Mf~o- z=k&dT@a22m`ZMy%hi>w7>CbcnabIyUGYtgCMb0F)QzB(7{|LvQwrWaWwCYzAT?8%AHYeAO{hA!o_`V(&_S^ zK?iJI)5KNc2csqVE)28pG5t2;G^@AP6Zhq#pK1`V|IFLG%_jmy=jkeX?SBLA*d1)< zoju#pT0Ps*IqCSN$R4(MI)Y#-9dQy`8BvPMm_~pgI!A@t`5sMI(ozw(S2kcD&Kn(@ z8A%wuo6!p!GM-7ih%HQihME6d{U}vbS*muC-)`RLK`p~iSFh$D4OokMO=P=24x>F? z*OK=awodV+l9VEEFl$1bS%tnxxda-dXV*JJk3H#!3gREB@@S?Hv$kcH+QugZ^QrnW zefO=|Qec&J$Q9Yew9W49C-`2>Uql_2bt{<8Gx1kb&z&L>?vCRKWG#)#oIv&`$DG1F z_m?tp-adLAJH%uxJsxRxQv(|hZrqpP(~gL?UubGIOL(h50#YwsUTH0N$R{?WRkPH> z*$8mJy@wcG(#bLr!UdJQcFy4R?85K}=#=!<$J*UIAP%f#b|g;az4NO^Dl)`HM&=}? z>b}>mZ;D%t@v+~lJb zHpbYt>Iy-Jy9Tb1N`?b&4I;78<^k@TUX1ZU)?Uri(zQ+2R4=<~t?q-_$*$=0RR+_S z<-r!PtG@m6VB-(gRQVFzKI9w0n%j+G{Z2D;9|R3T0^Wppd~x<8sBcyvAEPYI{9Bj-$o+dT?9F?qzuo3d!4SNP9|i9X&su#%Nh&@XIc zn*6}SKii~Eoc=X_*A&g@f#-MX=oG)h$mD|&9-L{3QinwUX!APlTpQ*U(k04-uT7aveGWRqd7zTbIT5zAwJdD!QL^9la@wrsB@S4|J0XO1GqV>Dk%q>nc0L|l1HpMH(Xxb(S6n4X^G6Ce*4|)W!6f$x#2qdLez8^xo%uh=31sI z;s)BfK^3||pzi#tn0@Vh-yXrSLp`pl@gDM7xR%qs(m)uZWa#nEE%|t7p9YfnLb_>z z*E8S|7g>vX`SI_ko<3gDc&mEW`bW!{pWp8o{>5G5_*jEgL zZ#24xHgb0IDLJ~;>5I#Jx~p;MPg^MOR7+Xkq4xsE_?gXoaaM0`LlEV3dC*Ib1pNox zBTP(YNjov#W3LP!B&n(Ncb(84eC5gJU(s<6-`*x;lY6yFlM@-vU35vyyGNpe@x|4( zh0UhGaM6OoCzW1BTz=Q|Xr6*)_BL8=j-EHMaVNsia5(*Q$@*ZImV2HJ#BJn=vvQ>R z)y0OFkYi_{89Wb^-X$3|TH&8CER9TqNs8y0B*dbJ67NZvOW$-~DX0Q|0CFIolU1qz zm^h51bd)UUj3ONSm*+ii+2I=>hbOoaR*)rcE(w-&-WrL6*^+53*Z zeV<{y^`cyx0689<*57Hqg@L}0e2AN=OTXbZ!{gGNtwcqxoGvvu&)iw6BJaN&ISPG!EABFq4Wx?+u-gCA5;#RfB_wdxX^$ zr~WO1XDgMPeFyXN8Ga&ui-XM!VsOU&5cbr^D(rz55*BbLyl{#X{qUh+N9SmPsC@Lg zQ|ZT`N&I;%u9t$U1Nm(6IHseik>W`!58iY?l_0QgxRdnQS>~i55P8zkM7rs}gI`Q2 z-eN`iyaRJRH}1x1!+K(~2;v2Y*ZSFf6DCI-hn~fn-i~7@VF1DR)JY4$b+AGc-Sh#; zCqg))n+T+7TZ_@h-X7-8@-0XO_kQ%ZL|IRqIc=NZRc#N7NbMQYF%9giEVm&?k;Wz} z6^_rJw@4UQGcPfDc%*`b*H{D0!>e%Bf{V!HNUzW~A!&-{=i6@fq@#PpXVRI0J5eMR z`HvUa1DJ=^K%7VSUCoJT&D*Bp@JD8G9QlO<;3Y@4rCG-vS`+N{~!nAxW|j_vi=7AmXB6b62zvxf}U7USpzbOyPUvZ$3cukCf^^Q}W^$Nnn+ zc?Ol{!5yNf%gHgSk+M*D&NVJ!EQF> z{zZzg=X4q-PM=nUc800_VIf3O{5CNQ_H?vHH(g@!BD!b*<9ASyTC1LRe20pyfZzvH zq0mKR2676{_X|-fxO7>w_K#zlH1|wD&x~}OFe?B#!n><4jtjN z_#sUXe(|7&{iR2Qs!V{8;o?sgJhk0+=xxmHAYdRUs~%KR5|MqPqnRz=Of+@q`JOm6 z8_lS`MP}lkf)Kil&T?09OUD+(%s0e$cK=D6MY8+K@O~&={LoOuS-$w)5vAZOHLH}} z?%G&Ar8Yh3E8LY2J8oOb<|lZUI11Kmu{&W?ojJdLvdNd(9Xv&&C9$`h*p!iBTY8U; zFugnpGc620*65&Ea%XZ8NEYW-{K(S3+;r=}(h3b?Y;6oFNYi8c22X)*o%QFm>Ca z6__5knqsi-5DXIdUYjjQMCTSXf~lqe^k?)hvmGwm3>z#Te5bcWo}d%BIs*Rhp7^> z7`*&=XSAoO?^c3-dYhnhvq;x33?eks2`tWyOCK?}7b1Zbgu& zevR`7Mv$bfud>1HuVxa_qW3)#G9fB9+E_5b)dh{u@wV=&hlkHhZHw!hV%|_pYQw!;1g}#&>S3%2 z_vp}1%L%V|(BH|{M5@NG#pJ(kJHkroTy`&wjGAzur;~E*HaQhWxLUx8rklxZ-xw}&w|y5dH^_M6kK zF*8#g-0ALK%KUi0%Z-rpx!0U26H$(l5U-@gci~bjB~yLfoG&1y2OnSKvDf+Fm)jN% zCcs_=%6^gW5!y>oe8Ik9qd$0bpVneBs5NQKo;<52W;z}ld4BK%^HxCV>kkEe=;~&# z0yiZ#I$DgvEp+N=s19hD7I8u7o7&7zofW5ub1*=w`*=EjAY!psUZArzCOv!)V!ThR zD>oK#%4}tfNj^_#Hj}F5E2tJN6=JCNWy$U32HzJ25!a3vCNWNi#bld^d^9|}6DPOV zK1zMdAg;u+?xqu-x+{PDTj1aEsmx$oL38<-WZk0>XhbO&bOCItG;g|#c`HLl*F4i0 zDJ`kkn_@i}L)LlW$BVdaPhaU>iN{duLpgqKxq#lrnRaAGG-#vORxSj6@4Q)g6c~zs zi$gc|x#(B?XPv_w%0}kFqE@mOSfB zixvD}^z>7HRO6UL|4L2F_|2#ts`AeUJU*spk791cg{c1Io@2mE5nAu*{ppw(ew7+^ zgs0XMdS3+6rV&G*k?|f~2Od+!L57aY)arz_RQ5I#}Rk zTZWu0>$vWgy@V9Jx&v}C3{%s`V^g`i9rU8MODdl&TV&^^J(iUuCpn3Un2t^$7>kbd zDxn~1H+Y53wpujtMREpcL}bv{nR!pVT;_yF>KYM};# zW@ZYKb9Ry$5*4#e$FK2@*J;XIl6#83-~W{yILilX>o}1twvv8p)jLDnwj`>mvEfbl zRI(S8muXwTZ6aRU61Z0oL--s!^qYP7nsux`UIaPtqfG~bV;zeqUwzVjk&-n1?qSo3 z%h&13Rx6Q9mKg~1V5CqnkN+tI(SJMfbvr4=si0-FX%mAzjya(X#$pbcUM~B%q+sq#4sIZ2Nr!ECK;hS`^Me?*| zgSs=eia9UoIl6C?@=E2kjWG7p*=xBm_Z6@pg};n6P?toXUCMs)DrmG*Gkqz`(SH8K zHB%(+Rys?y{0sfKo7NkNfm&xGX7IcB*O$lHoCUt!jlhQZHIob);ZgIHH=L+uQCHux zQ9U^!FRCgyDXk%OV%t`V>VmXZ1voE>FcISu`D)*dZlp!W{X(kS?2XC9BW_sG`DEBp z8#}4KA$I)cJ}|?^*?%SaF-~_Yt}@`!Sr+3Ole`zuS2khqptHPLFB}5nN_0EIjzOao zhSL7{n8UwH{3Um$=Q!&@WmLCY{aniQySB)kyj2rO?h*R0ARW zXw}2+{i7I%J(%fLO#VDaNAOq`%k!zihd>h-YfXSnS{)%RVJ^})OIxP}ZywVg!j(!5ugftz8I+`&@cUl2X#jjUUEp_Q`oF<<&Sc0)$Y zdU~foZdW*7eq}fIZf%Tt`l)F{?5Sw!n`H>QI+wMqLDIrNcG67sYdp4#%37yV9V->r zPU39KV5Rvq8M=8q>hP(xSG9=kUX=+Zx7tI0kD&Gezl?n!;b#%V3=$Lic$%66r$%^4 zd{)M)cbDm%BaJJ!<1*`QG^_9cPYN}*-?68)v`{F1&Ds(f(3t72k4bKlgO5Bksv}s! z=pNb==CBT~+_b|I;dD~qC6$G*K*+!e&#I-8d|{oZ$u`?Idd&*<;9ou1gwjXde-jlZhTlTs+b;a0zyBqxl>e9V zk}~^K${-5;IzsBKzjJD9fX&ElI|D&V%7Ht0& zqxpxW(fy;_{-tQX`~N3IBPk^(tf258c;LU!rvI#I{z)eL_Iv-#tN&Wl{Cl^5z2*OZ zNyEhWpJw4dgZ2Mh8{*(%`_Hu@zTcOWa1%#p{J_I;NcK7E+RXv_4Nr(I+C76AgFgZbSh#-X3AwOA=pu3-F9#zyD{ga#M+}&3>5#{Gzo}ub_x5Q!A z*0B2_1Hy>&_erf3$qE$IKs{sx(w~X$1I*!>Zkf4~>)T!4%11HV5lt5D+wW0o-3Th4 ziK30fdy<=&*QK@FJ242^@rZN94Q%+50+!`HX)21^YpmK17VR@j%^x1`Dm&IUOL2FE zq{~vx$ZD+-B7}I-WbhH8OOIbLhpgriM2!)OHQI!^#E%jGN`fPror3UMwAgQt*-$+(Km0i7{bMmyKB{aH z#DXU|BgTwr=TDI5uOatPzgG=1R~1Iq6iU5-_Itr*a2PTmPD{A*gEMG=f`z3-xPot= zlWTG|V<%_>@wb!Y>T_UX#b!MHjB~R8kl`JiO>dl*Pm&kRg|!o3B|uM zf_}czss07$1;k_v;QS+PpKs=0=PqBrP*Q-AVZEAh1F@95silXJ6K42}8Vi<06mS#J zD#sw(5y7w#r^ufoXc8k2Gk(m_ap9ZLz7ZJ{JE>y@yiJg-==LQ0Q^h=6;XnGDSQ(S1&noVTLU7Q$ z<~_6^c^wMIbMQGuCVL(zBjbz^m1MD=L)KNhlXg#CzLH!AycFF7A0UwBG=^3+&1zeG zM)wBx+76C>52)y8980*pBK$eT4wn#lILyLYn)~{O(ux}1_BE=_bTSv>38dAZgo@EC zEK}XZ#|>P~N|cJezJ^8}V{}?o-gNCP_QxNu{MBM^Bu@eM(bc-pxdW;zxtxsCOnz&~ zVWbnLBlH?_=y$_TiE8x~rvQ*~>Y^16OxwiqKiRCVKYOyYcZT6@qIH9d5?zFzY<76LCL2j$UWM@KMVqbgC0u@S#c-cUPlsiSq5A};?shj6o zxR^}Fn!02%)11ub5CAUgLbjDGs6Xp?fgR3cO>4O>A;mwIU)O&&bwIDVm-LD-@RP_K zEp}!YZlkG)mj!iQOS`-ihmaXB-8dOc`ISj`s&)qu`Q;|J;cEqe($&CzN>DX@dcK6( zP-GN#JYXI|q#WDM4Sbx|fz;_x?+?>BuVY?=WdP~7V5!g7y@x*5uz`qcrXS32wqc_0aMW7W@Lm4Io~L(? z;8KmGC6NcCzqa1hIf@R5g(-0n_2(zN!DXLiQWgN>B{B#hd5Q>t^p5Q>G(eP`C5>co z1T8N+T1k)@YL#5fPBTDqo(+m-03lpKK;Fs{l@!E(6K;rTxD?!>`dE+e*L z(`_K>Vre=*oW(8m5qRwCYvUkn`{dU95VyI%M;35|}K+LN(w*ZBg@)hx_~C5NbkQ4 z*GtUH)X$Ctaq!a{s6x4lQl3C{mA%>4Lm}(1TeddC>$c#vl7QGd;cawp6QKFh)}l5* z-xCHRAsJ9VGP`vHe_G_IY+>caPj{ED0Bb;OzMF&EShv1c3K|dDDOP29J7xhbHTWny ziE=Jav?6)TRLHe@AvdE$-oV^8e~9W~Yey13$FbOlT=mJhOkB?7e6KusIEA`cYBsFDVYmWGjO0f+GPl z-D)lj^VsPDWp>3tfAoxp()V%Sq5GfK)Rnw$3Pc8h)7%8R!Z}aRq_SE7EZ1q3h+HDE z{Hazru~4dTVNLA0=&32kKiS8XB>p{3U8t>&9&|_T#kqQ$Ux-dw9}oBIf-Xx8|})|FR&A0vs=mT;HjjeE1jKs zqyi&Zgwew(@dkxe zlP4PYjp`-@no!3=S&@d<5@#c&%}S*n%Q9z2=jx0(^Jz`Qjdc-o5#{I69mFe21Ji@V z;R``gq6VBn0jv0lrWISUP8HZAODt4g!=jtYq)*7I^kx`_ZQPKM7L9xCl*QPefH#{8{T^4ZIm5;@6hm)H3i%Ss$}R%~l3gHDuV!;-!GM3H(8o(mO0M3R z2kBB}hK=##+8lWqrtgK6@e0U27NECKe~=fw^j2LLb@@~aG=&(nx`gJ^&^A~ThH#AG zwu%w7wE2aeMp4r8Fsr3BKBgSw)hbR7Znd590G&nwU6tKJjMB%zNfHkh36X_i@?cV>@_9-TDF{BYB`7pnrL4b8;AN%wakN=O)cT>l_#wPu zVeH9ozAGXV<3w;`1_tCpX14+19$L{O@wFMXW$Cdx4Uvwr7<5C?sx(evVWI=^>S|I` zsu3TUY@i|cq&pbeVR-=P{77m%%EuJNlZ<8?XtQKDxAe?F9$3c%pHa4fwI5i%;~l(qV&^ zvv4h~je3VX+ZznAzz&PfHyVRo<5W}mc5}np2t&eRnSiUoCoo1oBH0a~mgpMe4ijb| za2sRxaHSifJ63(tp$XIe-$HUjT~fRZ-hRkVse^#;Uk;g}@WUvRS#=2p0HTFsbDs~= ze80eh-cs8|OU;F4u)!Ah3>#ZFrzDY!Y4%|^gQQ<*Sux&?GL;UkazZhBth|~diw0xG zB|=a8qQxy2$i%V8mWL7L*XazfLf7brbq+hmXcW;xz1!|D-Hp_^^`l=B?wP@r61G=F zf91@bQ{ek$1JDDjyBhifQj;6!ThgtyJ*iWoQHAj(g>md`@X0V_gMO!=3}Yd&Ivs=x z>RST{fGzs^b|-MBf|Aou&b6(O7C!lY}KJY~o4z%`wrCL~}0&TdfmgQxx z^(c}SkNY#@#@e`W&4)(vC|eiXu7uV`3mU8C&4bg!MMga#5?j|CgRzFq+NzR*_+-?=}IeKS8fz@IFo z%N~KOc4aQFa_s2ArLZLPUB%ML&>*)Cb_DQzGcWxdTLroz-#!-kKK6TZdvY&xDP%$K zi9aviqabb%=AGZ(qs0L^UqO__fIq<^=`<%fGK(X}=X!1Lh-2ywMqVZZd_R?Fq?vgRd#wR)KpVAD@R5{2>SHs5bI3 zZ|41WR7nM*6A=~m!0N7lIyCHY0A3P$_gE|j+^#G<>^TB=`ls|K{li?tmfn+nFh6&9 z2MeBkfkg>ZYJu7{tJZ08`ba$+7kIF9`RVx|9Nr+a5W{G4B7JZMD@=62BrE~*jY`y< zJ*28#ulY|kyvAwRM$DIwXM{sOui3{Ot%O^FUhi-vygqL`*V7+VeL!8wceDTH;^IFL z)9+vw#_wP*F4pgGE=GFRe{xv9iz4(~T zJ7%ASiS>WwwETOl%YT*C@}DXM|2-=59c9A&Ka#PTh&aB}+yC>;rxaL4GzlF4&ZB~5${71R4G&1T?9-ZSV1X-sO-$Mh7t*iM>rQ@ds3VVgJ=ye z8tZ95el$r&-p`Zr2nOlZ2k)#rrksxE^AFl2m-dd!*RS61mcEtq;raRJk6ubFr6UOe zylfh?0pqDP8xfUdluF|gm%2UFE@QB#_v2^50rq9-p%auQO+Q0sZq94YMXrx0DHb5F23-!f=@csP>Qz*>KtOCQfX*;X2gV zNL~g<5Q>dE{Chd^H(sd3u~^(8aZ+7hV*6X3wPp})WzGX2D{+&lg-I&a4+O1r6uKGxWE?w=YRj!VcOqjHOsBV^v zQ!B4rTFJ6V)+|V;OtVOOD%C8{SEyH?M%SOBnevj7oPsiraF$!Gx&(1XekOP3b2gsS zQ-^A}y)tM0(vsbhnjr-{7udX|70j;XC6ie+IfK%?s`a}?dOc6|S821%noG5+S4s2P z=Dh*m&(;&y?p%Uu#94`B(g%$Xw^yFm&R15SfSh86WscLg`=D3iZY_cQTvm4x<_=u7 zL9^q~&0}*>T$LCT()lr#7A&6VdDkfd1H^{PM+2|2O|vVzxYp8@`3v*&YM++-YUpiL zJ@ikX=V2%rQF~EGQ6bTEA-4 z{G5awrJQX~BR=R0{@mrGGfoU&fD0>9j9}+YFg-xV|M|k5;}f@LAm$kz6J$uiL(ZGe zEk?rIKlhp6yO$o|^gdJz35a@`eAoK~@(UM093st6ol$pJ2}eJK_Csn25zg0PjmkID zXVStW`w>|V5U-cqpe4Yl9M-CrvIYetpwY&}GZ)cXRwp42rAlfSfeOAWm5X!J_&^SA z$J@%-mcxgSijoNp2^WkR+(KX@48@T+n2;dlLJgV6Hnz959# z{ji;b7&4{?xe;0rE<84Pg}|5EI~L{6p2~N!gqSQ?WsN(WH_{S!1G?ck(bJMgoJ(xV z$$3J(GQ$d2Py1U%8~Kp|Z{BOTw+hA{GigFa8{{*TRh5=p4|)z&X-J{T$20v2JjB7m z;YC8KnV{;?#VeFUZ9eAV*z?}513t72e1jSA{HsCRx5B`*iCHtfxC$H~pu`S*qfhOp zdg}iSQ7qMNXv^&Nvq)Z%0`#VF0j*h)P8G3o)c;w9Uoe zIj2#tg`Fktl5L3hX;=!UC9WxLYvfZ{Vv?~G#0=>C}jP>R(UgEnZH zgrlvGx_yB;)cch2ytx}TIPHckz%ziYbZpP<%JUaLIo3FqTOz3Nk3%(xx+MB0^?l@+ z*?zsdHNhb2!9U;1P4r##6&b(1)Q<4{Iu!Vjt6E*W3h{PmmcO(E@JB&&Ziv-$LHEil zFOg8z95$*Rj6yKvfKR?y8!8sL^}gP%B8w8rnB@JB<2@q%!RA82&)`pmy{?wDK`1h3fxaulCSPGaFP_W8-hr8^owo*lEb6>y?YVE2@5~2|81Gh!PBTelo3u?E|;R zAvpxROB#$8LGOd)gsC_%%MUc#ljKB{?r!ga@gkoZ;`zeHjReU$$x6)}36|&ll4dH- z_}%{_(=5$Qa35a#bR1y%>3DTCS&?As1{k@P2WzxNWsePj*MjA#dFzR-9z0|;F136 z&{N=^{*L~^%q!KMrJK+l(+g901pdlBIOoc<2Q}aC%6~TMNWt%NtE0|EX!L`SR%}dl z&T+cA`yinbZDd{RvV*-<$L^*60P?!&>*MM|1rA*^qZZ`Nn_YO%f7#qWc0f)Dal z!>?$~XU2}O{p#hy^tg1Ra?_>8ds$08|5u2>-_9QA3rCxvWVMb+-80?xnvqp5}*>JV)>M z#YF9Ij!%ap2fTkgvM`gEscMb&!n(q{9zAwFE^Y^m0*yh8sYl$6d0*WwN~hiAW~C5m z^-8mb2{48^`APMG_`N;?NRO6rmj@`!Y0PoW(^xjJccT{$a(XWoSBJ4L&Yuc!&!d-c z6z@w^j-aX?v@)Bgur`oFSvSPnZf4wv;-!2Dy{RYfVKlLGHQ<-jkC?QanjOD51!znZ z+;6gQqv=WG+*Dgl^x!DPAXv4q&ai5;dz$N_Wjh3!M=N|FNqD9 zWC)%^HpWDz1BiBM6wwK_tWfdaHGgGXVtD0zmDp~pCi&6#Q2u>FJMueD*4?OdA9AA8 zoKBwmw2u2a!!AuePqd4UHD$@29O^jnS`JKJc(kM$H>A@f#~9<(w&pctiy57;;Wh13 zUU6*s&9#E~`lW;cLWCro9})YaACfWytru1^1L`@j&PecMfGj)+EDgSr7=6wF)Y_DI z!YtpKuX2>{8X7O4&>p8J*t-oP#2%6Wl_<&H==bj;m~!!o#I+)1k96lHc2?!}xmFFN zar1s_x+s&R2cw{7HvEyAdL6wC-M*G{^p@B~BTNqu*Ysi>is;0RapqMIvul_U2RP%& z7`vF-n5#4uC%8a=W%+_A7>YBLaP!tsx?B6)~ipvHzs+A!Z+b;t&F z(jZS516YIogjyaoAa`@?2od_BF9Lc3{RTarkuUo}-J#6KWJD8`hvbB%uv?xik zZz~>wl!~ZNpoGAm8%v@aCEJrOLoc^LX*X3^-wl?GbRSa@D|lLObGNV|JK- zhS)WgcGVb9f>Q^Tc2&5|dAxr8) zl(P_al0mXf;bMqk2@_ESJwX;@h<*Y_BMCM^JV_kl9DGp3S4DkB^C!$`;+YOLj zLh7C==k6GOmQx}w-iiu6=Ux(zhssv8o|)l2OtPQeIxA6<)R1&0L2Yj&WKZ56ec4g1Ax3M`o$f- z)`)m(@XZ}AZV!|P<+v=jHl0(&CUmXOcxVAjgWuF^{w%EW(tiHd5ULV>VmS7Na(Z zXzB7EzSI|IDfb?{G+?cT+d9wP7PK_nJL}n&xHPI@3A!PM3!pvi6Kf*-3}Wx!Y$|Wp zzZ(ahWXR13o6yZLc}(}3_7cv0l*fy?ZPQ z-NLVe5DO}+2(^M{3%lz2C9Sinhk_UjngLONN{YWxFa-r=WFTVk9;;myR8{5SXq#+d zA(?IyoripPJuiLUl!0u;A>oQjnm;jBMOBxHmkpOy&RQEbE3?VVarxB;(! z9>!coT&CzYQ_kwoBDCAbUm;&0-@;xIAL1T5_uQ6MR#k>o7F8xyHs|~1XH>>j)~{M9 zhOW$eC2~B!FC!Th%J@bIe#Ny?te{>fPU2%;B4l=oYON2(4k7&VL1sg5tgG|N4xpHPd~C}%EWB$umIpfxMO zs}8DWtnI|yKi>D8#5_LUK0fvw#N4_*JzgWE`0U$r3CAWC?z5&7?V0}eR_~!G9n;_v zoHr~u9OUFujZH9Sql=xd;uM-na60gA7i8HJeu>R0I&tVYr!XJ?bPUC#JNjeNu0fwL zzVA30U%BtuE?kqO&8lyktjVlxo64inq(i52z}>D^lR$ObwLvz&50OsKvM=5)XPdG; z4$D0Hw~k#avzkt=#ASiI%H!_0i}d`V`&HuP49G#xLR<)0;X@+Dl}&@b#fhfSN;To6H710oqf<+b}3#dMI@$H&OsoAI*=L zR&jyq6ul80K2l9Avp{#2*cp0LIBtf97BvNy1}%F)I$xoUd;^0Y{SwM8WIA{{gdtcp z(saI}q`3go0dy_uY=)l~H{zIAIUkl1BU{+v7!GAdvqMM|G{*xm3D~!jiPZO4cn9PlH6Huihhgx9> zCotUr&O*qZ5`(I%Qx=tv^ZtFFMPJog-t}i4D5q48N2)ATNdLAU?8KXcL z!;VZF`{5Tohtxf`8B*Zw^a2R4pI#h3iRt2%PK(f+@TU4KIbln8;KKtn!XeqnW=OPz z$9Hhvkw3xwLM!d@=ZHb!;>DvZsa*Q$+Te2s@Skzt@%aNf;}PY@LU`*Ma+XE98G-eK zzz|Kr8u~$OuLZdtW`&jIs3UTJCj3yAF>B;+%whe_J%{(PeB3*PFj5nN8@n!d8 zKWXb9c*lq?>3>QI9N!mn0Xk%mV;BvYaEZV6t?oOIDScrO0c`I6zNx;sj}oY!v7e!_ zGl}eo6=z?dL6k0MGW)m$F;{yo>@61<|lC{o*kJ4 zhOMr#n>@%pqcIIU=t36FW$5NsVm5SJ3^s$}CpaA335lc4%sl94M>!_0!51JV!)jG5 z7SM7b!;jP{+Wl$1`NgTX3?ZQU%u5NdB9IIt%tKM20ov@~s!irW`9RWug%s56WU7n#^V zrOyJ7GBP=wwJxG6_tRBJ8eFpR&vY~w4=wy^gNRLa$)E5~7yU=(d_0JC;w*tGE8duwR~?tuJd_;T<1iO_+xVDecor(~hexR8U9& z#YuYAX>$j4w#~jGo{gT7w(vH__)e(7?G(=W>JaIgxIUd0wUW?w4QY%)H6r~Wo(Sk0 zrl|K5%Mvl4kL1pj-*L#T?VU~AyzRcdI#*mC=FV_zJZigVk;$A`>foh|-qmD7N=-OY zUF!%#KyX=4nUou&m0DD%-)^gtuB9tWS0%mB;hIdtArxveV8#ti_;9vHUvy=p}z6AL&vg~b|~V8yT8*H7EH+t)Ss z;rCssQ{5EG%c`nJ+{op8YWY9}M|4c{e>47GnY*ApXGwgIX^b;EE{uc^oyy-^oe2*J zIJ=%oga!1gqjA2VwK7i$+1J& zEkxzg8H_hE=Z03>qpl1+?Nv=5D&GU2Vk}P%=e|Ltfn0BBT!)~cfef4ukhaSmUp#uK zp{CI;ZgPVM2NBVI{A1qj_0i>VwzTzXeY9OkWi$mL(HZrL4AaaEolJtHU89JqDj-@ECNfhLIXPn%9RVvsVguF*HHr@A z#{I1xo?;Hhg(~EPqD^VsTV1?aB^prd22?6-?C$d0N#2)ak13n!_Y~G2=-d2UT6?J6 zeuI4*F4woObFG*k5r}gklb7iH9xB!{)$Js@>b6cr$?GVvp1i8C_=*zu!y|ACo;D#O zSCfmUn>NxiVG;*c840D!nJ&^wHEby+YdFNfhQ@w5z^v&JYvR z{*$Jfm4ki4zoQIbD-k)^?=d-wmU*&WP67bFrhhUpyfqup*-TB@(06H+^~N($Fv9SS z-UT_QthOrVH1I3NCYmsK|B5S2;YWiTdfnZD3?a0{v3`j{|E-qg*4L`e;$=RvZwL&G z2%{xHr8Upkc=ncT@8bMaIzr~$@Bmc@xXig^5mzV6*ZtL8Ic)z!o{#2=4rNRD!Qss8 zi=91$#Er0!KS{WxFXjcxY!SYoS-KRV z##SGSc#xO#sqkqllCJ6B0pxGsirpo1dzZSD?tOB?pIA;pS}4rLCbzeD0-F27rsAnQ zboE!augWh=%StLk6@8~!CTb$cmHVrO(9JRmL$>XpxYOja2k=1cG+>`y+ zhdQlu0;VBzjqEeeNu`ZijF|O(%wZhRzh8A7-?7h4Su!on#izJ4R^o>8V=4Zu9A;id4?68 zuiOxrDUumpe@%03a~-`+3E(XQNiC>ma9%}5F%285Mpm3sW0vAhs}7A3_`Vu!2(Mes zg8RDj<75*aViwp`W+SQO4)iWl3x<15q-3Wh<&-JQ*5f?H)tWg~CJ&ZEBBM+hLdGn* z2M93MXn$}-l7Rk6sE^E-Q19mCdI+h{XJLz}rV$e}qP3xIQJfqHm#q(npK%VfVxX#q zsT4LeNVj2>bL>yU8Y@+}%0i3{xgdxcF})F`*Rd!#YhD~G)8Ay;oRtd`P(g(`?m!Dh zA1v;`TbX~PJp+wgOQsG@){=YSjQ$XbO0SWcwD2q_X<&yHp=sYJ7xrALsyND_4igu# zpEcgSUda_MY+_2&%gBIZdU2A_`t=grOHyVwRiv1av-^Ur)g$7r3T1~nXPFFzPu&Pl zBid}EsUM=n+QQs^qBzfm1$A4b;VbHxmkhjWqZl-Gt)bBd4&0DuwjDZ|#MmkWD7=qk zis&}`8OLUcE3|UXPgt_K(N`l~>xw(;3LvPOAEO=%AS4+Dlvv$uMVu|CE>R?92k!Qq zmJY-j-e$kXc8T7o{z+;oTKnnh`zrX^ivk+`;mGS)s9BV^pSB-Q(5;$}Gib@dQ`5-W z7Lg8-dF@bRMvdSmtKIPX5DXuWlbyUPFr^VM0TIfs(0Em-0ST#R`|%x>(cCI?-5jcg zgH_pSG{ZD>%7f7+Jvui7wI`rtJl%kb^1VoR-F9Wqf1tUxW=Z?#`6XUU-FT2nT36fR(IO*A5S zWHP5_-zaZJzUKmU}ZcI|!aIL}vUI5{ri3hQ4h zb~*F0l$2bQPgkwr(veH1v~(u(=eP6UL)PSJ@%pJ|cAmg&ClfkMviF?3Fq`FB;Y7y5 zXcdF(-G*mywBk-0qu_k!{JmI>RsW$J#oaJqQ7#+a@LF}cCGSU%MwJjN+`u6V(IxLU z4SbQmJA?)9+tx~uN78}-L=6X&BFZKnaVV=ir_nvVX;D+{(e0@nH)1(SXlt;Rs$T=` z_U=rcD2yd7r|7-$kk?QU-;_6ykzsNMN9rZ1)cn)H`L zFI!XWSK}{><{PWKcMlCGly3T}yk&Nd8IF(?Ugo^*K`jSIc1mp6QA+q8AY1pNP6_>Y zz)h>4{k@F3BEx{~1`>OS-$n;G4XZZV>zljV`nL#-|w_iCH6cY04Pz8>jCU1YHLxmf=oR^E$Yh;%gYK!J+QqL0A)#e`7 zU?qXexq=KQu<7)05 z334wh%#H)6^$WN{$K0bd?dGBs04Hh{ZA15Av|B|qodr?TCbB0E`Z)!SmmMr(WFFcZ z>xo&>aIA^5-in2DWa5P(s6hZB(7y^4_>%cRTo?hYX$Jd7`RYjyNf!8AbBZ5E-TwR- zT@Mcr+!+{KD9E9b?1ss1wbZTVVxV|T4&$Wa;v@MKx2NTo^#hXK{KB^-=}21WzMHko zslvmkC+C)%eZoEF7T)z*nk0B&S~b0K(Xr?AiwTY1Z?wV2ZvJP)4yI*V5vat!vcxKr zF2;~9DoG@6$_ls7>sJ3xx(8-Z4tFG#aM5!od{>+RLFAFt;Q6NI$eTduoLXbv?8uqr z9`3)&`7!&uloVX4b9hvy409E_qUK~o9=aF^kFf~taVb)|)m~~nUNzv0F13xF zm^M!(dUeVOv333S&WKuf1nxH=e}A=0cn;TlxxjLK*nKdcFNC1Y_urt8B-}$NPZ-g+ zj`a(IbflAYecjV38?L?f$e{NuMiDWx1#H5;RShcBnRK7)BOR%Ki&dPhVP^ zC6XXHbuuAFA|l_kFNv&EKZZ;d2KFKVe2Zw16a}IrsA3PCAmlct^TXcztMB24KkZJT zt?JO1=fy*!3=JwtIRE#y{;4mX3H^CCoe+rlbRlnllw?%d9m&@FlE|>jut&l^ZD(lV z(S>g>zOU5@g1~c=+u3h`?lYRQ@r?rzlTI|op!w*B2F2EDO!he=E)P9#n6?c&VvQ6t zA5vwLfLZ8=5C={t?K#14&K2pO9$kU^4{!3S(s|N}d zP_shMT827_NHRCCU_I2YM3UAP(doKcs;SENQ@ONF5c@A&UWbPtuTVMbIom&-!_B+d zIAzl8y;G;hbti4zaErI0o~~ef*8^ZwOj-yEo`?qZmx@3F~kV@}b8d z_YIN9pLnSP>t+6(n0o%4di=MtoGQ@JHf;)#;GzLaYy& z!`hET`OKzyvuMAc6iZ8F^3HP^vp*(>Fe3|8*RY!T<1d~zwskexqZSY*oChYtocx~L z2#<2MH}6(97n;1B5~fHnB9t^pbhf?mapt0`8QHccXeTS&exN7!Wa&1gm)cNGxLU8@ z+2}#vVS2DbWB$!Gpt0LOb(tO2ZnaeusJiS>t%bU{s0QRzUORiJyGDq&;UpZG$u^JPeK&ok4j{?zH*8}(L?G&1j! z_Gb!Oi81SdGxou5!R$|d;kl!SeKemefi5aub|#wjbd*#-T$O0HnK+a0Be+OtbP@uK zuVfXU^>2%-^g0yG@}Wi%w!cpn+-%RIE;K3#@xzYX!zq))G@slNbJ|g_Ue~1h+gsel zMJ{h$CHUJJNqmC|EL6@WYC=YaKDK&3zTUPKn`%t-RLrKbWrc>ix|3@oU4eF0)wDH) zgsJUS%;~+ZjtwkSe_o!OR692=vuVb4#$8#H7+g&$MvH=ZFq4w$>_bPyxI22W&cY{i zvUr_D_J#%yALdI176EwpyOFWTk44N9dX~z{mN|tJ9qxmcYdxrhdRmMP`w&!%{pvSE zPmk;kyk~zsyDP6R!QXC(HUx?Ym8XGDyD!;E-WJQhbVgDMN(=mVBn zo%$?_6RdDAg9#m(#Qv6}Jql(e9Y$G|Sid72{+0bpNV`CTQ72c8r=SUJ2}W+vYk7o- zX9Q3FSJUE+1^rd_!8vH&IVbWM?>%qC2|Wu$y~=l*?>N67HOONrWRxnNikR(Td1~k1e7&smfzQ5-7Wp zKvI_w42z~lsf_o_bO?UK6k7iYXh?u^5YxvTA_GFE0+F`P4(~ozI3F1H?Yi!qy1>Z6eU0_b*0FnJws?63YG;At+yptX@`9HODO! zTPW}=V;4?*8r&TZ&J+$~|aT^)nkh~Zjo2hAfsJpD8K(EuDFd3?y+Jmz*p z<5qt@tX7%PU#-02-?7xMH3r@6sDmCcgOtUbe(gd++zecDH>cEFc10)?5vl8jVKQiy zPrkrjA$uO+OCJ5l-8jbEOK;KQwyfetHV;`-aU0aQPHQnactPX+D3NNK?!Mrj{P_;! z>P#)GPKk!P(Q+FzupBOHdA zW0E+$QsOS;mB;hWrBSokR1`o#KC~#<156c&4)XhjQxC7HM+s+&aaHvzCvuAh*SQ6DwwF z2D+<$gB|X^dtKvMUV^PN4e$Hgo=-bOef$6XhDf$9xVFV7*5wWE347oRUNCNx3( z42P>bxe06vz*GaCzQ-rk_=9(-wKSjfN>_dtz_J2kuG}tu1rlwu_$DfR<^G(c#RfMm z(=U@YZ+)Kyx4FS8bvF7sv6ptrMa7{~&I@QCts__?sJ~}xhd4T9v0HdGzxMEU0&c;7 z95cLJXY3!1?Wu<|@3NzSI6JWe_6k>^)LDmDDcMt`a_UQ2w@B;{rC>c7s#D%&yKG9E!}BB*alc3 zz-343-p9(>5!*JfG7nS-1QM>fFQ7i=BMyC9Ym5rWJQ)>u8sCUmuW2fdWgB97(R%{4 zMS~Fr4$}3$83(sHNWRGrLJy+ydc$;eN?W7?=ALD92jUs?8L!JO&3HAvSESeYY45EE z7}{C}$S4>7sD&*c0^<~<-DZ3iLdcQ`cnFApPypW5aYaoeFi(e(fGnu~_^ma>d$uB^ ziJ_+820(xwsnStmn9HTaxihFZ*sl;1Us>f4PWWdn^%HtdySK()|7yUA{~h~{vuDpQ zSi#AFPj7Iy9S-62Nv{oK&}%8+Y0)bbc*!z;_Q)H^XQ>1f=v)a}*)UF_kC-(5E)V{y zAbN7jf4U$28eu(d`$>Dx^Ov^1_7~!HD>m)3H#OMPyWtMjE2DMrl@FA&><*Tf@@Nn* zzIwv4*B<#Onyzs>)0DQ17-{KV+l+w`l_BqmCy~%Hw7DGZ2a9#bxYl6B5ih3KB5KzN zy$mFNocnZm4kugMy?SHDnzQ0@xeFo0xbIr%$70S_Mq{p4jlOI86${jR?+1dnwRhV# z&+B4u?l2K{3nwr_;CzYCYM^j*_j5a{v%k-dkNsh#y}&U0Ys5y3mNA=EmHmFD1FMi4 zQSQWWBdRj-VUch_^`UaV;LMRPYF?sSua0B*Lz1u?rKW7YyOM}Q0eG`1`Pu;*O(Zc* zAM5>B>Rvo9=diHjAIW_nsj-Jj;&xvu|7hT>S~QRvNL)*<<`fk;;RL4Y!^b(m}B!ptULL0U49RkvDEK7s)-=$*=I%F;AnH^(q^aY>QIBqYwsR3JgS zI1Y;OqDjj-!SE!R9c^JM=l)EXIZW21vJt@I?hD7v$5sKpZ<}wMO9O%p_2)9aTu(Vy zTTa_YIhBtN66yEA5zC`wTRiaULLk`4^48F{G`=@gVPd*&Pt;V7F@;SrHQ&%k!?z)!v($??7_A3{_}{9Ae8Tb@)< z5Ah&dWk&Zl+`~O86!{5{I0-%pW(={d`;}VG&1351w7HVc+xN>;vyu!lLwPM=$4AF~ zhGSukf_hT^a&D+^O!9B5PeyK2Lymuz=gFl~Zw@!eeeTKH^)Y4avZ)-nLs?kUR^H(s z@4ThXZ6ulJ=LcvG&N+^{?~$FJ+$oPeLduB*<(7q#|zd&O4OA%j;%@ z4pyY_`m>xqJhNFs5o%Wz@+d5h+(&Vw(j&pnrmx$Ci0FKz53Z8}2FWh10W5d76Yj@# z_7M%iFF%Rg(DfIry~+6fa8D_O?;yBX%U8yJro}%-qgiK+U$+J%qUC%|^MJQ}=OrNQ z{R7zZ0dTKRz+2qs zU9k%884r>L7sStH>~m?;C{y10*ws@5o97-PpdH;^9P#-i>E|xw5JZO$6-4kneuvrE z)1LRq8VnQZHbE`X-7O8#Z^RFw){J#@Vf~5*5M1Iy*v?^)LAtc#S$L=Wv{=xF z>YqZYVUsG%Nu6bA>}BZ6WojsexN75+&1!!asJ#!Y{`T~(Y8jvTY6{%i&ctoic*E1S ztM)FEyxt_hsqm#MK)MBk_afIN_F&6$iQs?e4q?ga7Jd<~#DC2nWhXnMd0amhA*B5jAJ1Ij62h*#sLDtDt|7G;GWqs5nYtH)ZVxdON0_e) zZp9m|OFwx2ZNtrHnB`Avzbc6JGeHMY;YADMQt!57{#d!Xh_Nnp{ z9T(MA1-v6O>&~o#-f`G2r4ogh;zJy8K7LAtjfzvD;GW)~$5(JU0{NN2!>RcN?e_u8 z8Tx^`0sG?vr{_k=+AhJ!j_qaext)Ap#iZa#cOUz+R(LwQ#7{VTur6rjvGSNYLV+J} zSvhiaL8MOyy@mCN%-#)lE8d!Wo7nz#m`I<}vmuAtO&om#jxAWls+gOa7T&CkSC4sG z%z4YTkL3=v&GWmFHHB~9e|qa1+4e>{o6r5(Pz8-2|C6Xz_^0$Y!~ezDIR$4Hbq%`X z?y%!@Y;&_1bLiwwygtRG>9 zKG`Nd?Q?2GFV%yT2$eB)ZGoM$X?MsQV<4k_*z=d_hM0WGw0tw|4+UxX6t#aa^L$ zw|oP{#4?Vu?y=%n1h zKO>?XQ3fzKdCAmbR}Al_f=C0$U|r=4YuDAZstl2Zi#VX;8Je*#^2|l5P{O(M>XWyM zX|?3)-P?-PM{fwI)n8x(u86H1F&KX`!FKmvb^MaU9yh3$PHFuBv*N1-p>dhMZlGJ? zsmjs0sBmiT6IOLVmqzq*DtG8^N&0XJEDp%HfAh?XAVp-~xBJfE_3E~Co_rqvMldNE za;upZzLm*{zM{w<0I=IEW@23NV7SXqz}!)Oa)C5$7cd|HAc++#@h;(x^k(^{zpn4N zC45m73hx4d{L4n15KEwZ1bd1$M-Ouuf=GB;k_|l!x&Q}O+6@jHm=L8hiRW%j3Fc+Y zS3RdIj$Ze|Zoi_&_*{AvQfF4rtkSv~`w}#FxK6sf>Zo_;f4tK%%)O>&ATO^?Kj%a< zm3l=XF^K4;^iVwk!;j<;uc|eCP|^tJ+iFTmr%g~Cm9c(%Xg>tBS#h6UGO3G8L;qE+ zHWASHJf9v}enmL*DSPOzMBv-5K$;oBeYU-yF09glv6cY+k+Zwbcx3anNGd>_%(^j7 zg{kTDWH`PP)%dp|<%Hbj;&~m{%6C#0a&jMaFW3>hPbwN6t#8``%e6B+o}Iky&xPD! zwxG76s^~N7Ry$T70KwKZ{g2nGW8}kBr2o2$R|}7&x~qkcMp^daEj>w2ZR4Y&V43Bc z{U!xVhdM<+3d#dIjPr13!kqrR4>SUP@Ii0ERGIH2uCBjFkbiJy1|yB3M!a#G=J?4R z33vO+kd4bE`TM!fMF=I2YrQJg03FR)MnyCRvs1rS+zzPTRIZ(}*U=YKA)U@1%j{iT zeB0uKcx*A`kx9bes=?A{HIY`L#M2EU+xEiN#b>-zlDvzbl_kaKLFEL)Ib10x-eP;z z8k-wFGBG-ZQzK8HKZ=HTDHugc=GfAMXyXo9bDJOiig>w;8Gro^@qGVr8<0xp`YA+? z4ZimiOcV+V&0W-#ke)E$yBxyiI$MdhxY=0dVxx&2v+^>d>sdOTwp@rzwCjeFQ^k^% z?dS6V*F-^(X%*)<=g8Zo^R<`eXqhY5$2>vKJr8KvIp?}-`)%Wxjk%lNT1UhS;-mkw z=(JPkQF|1$Nyt7q)8>-Df9#Vo&ME&#D$LbPi2&wf?7D`yWQI@F=|Z6u5l2!E4Fqz( zD&~*Vmm_Q;D0(A1<7-R5eNtJ|o+)AGOS!ewnm)cvmza!cMq*T(Vh*_be!-U4A_)K3 zb|4+G5$vLVSkF&)JUr;RCzSZ2TZJh3@dY4WCPp|Q98a;} z#!maABcq3#*l}ShF$8fEb0elr+cg7Ym3$YqvtUpFrZ!`a?i*?5Lw_@MiXz+@O|pfg zd{Z1gOGyBC!VZT&9Bo7ZNxE*A$eC`Oh#rHr3Vy~blx=5A6m5Hp(rA-Zr^eO>B>r3u z>1>!m^xNrC|MJGWV>!qdC!rSxdnJqmMr+@q^#A4iqn|tSC$JlqGmwvB;P{^k3^5qDQ2%NCHUDq$^RLn`S zDM`QceNZ}J`gC>R7kM(aEyzVL52F|a*i-?IB)Yv6#9o^xB(|JTF9Bga>SWu1xCVaR zci5EHtHucy(HeIX0j3R+*HwwNTKyB!f2m!?*J-n!h*E2DeTf`s+nOb{J4q_1{kjxc z?Lf2+#}j$!D*M7`pM*hzIyoj4erm>rV0*G9kD6d^=Wge84hFOg^`UL+nnV%3c!6sK zC83;@O;aY>RT4d`o=mUXH@u^@NPB70W!VBbp8?d#SHr9E!qwn}NjJGZgk6t$)&JBX)v(g6_E50RDK>qFYq1GT+nxrYL!1M2=Q zIjZR1oKP;C%almHvPf!!k9MD)SGSL;gn{kKqc9G-AUa0Hnsef#wm{z|CR!&{HcrfE z%$qK3J>{ngg{rcv7+HdIEM$MVE-mFIq&UV()!3KYzLIx*!biSWk;-8))VI;kXGF>P zYtrp89XsU9N`EiCYw^767$vki4DLw9$L{r+o`|XGQ2uf)ru^mxHeG;dW#Xqg0E+!r z+Zuv(pvfrIb+C@X_PHq!NTd9b9eDXR*p)XbCs|kRSnVfi2g)Wbh}rEzg_-C>;$#3b z6UIlwz6+yoKs%y!ldd+lC)ZnGU>oHsR>tq$%#}#)&a60XuM#VEkTc^_UD2juexVOp zCm0hj&p_j>Xst-;g}9;pWuotoZM1;>%eF@J3%XNKo7v}WlrZQ6(y1 z`LyQh^|*9pgM*b~`oDbA}2gQxD zO58=ph6|VEvf#1{>jysGBnlql4HbVj;hWz5l#lYlLCoM8B!TV*r`Tz;s}EwkD+OBL z7(b|BA*@D9vuW&NoklV6u@Nuo0I;^13>f#P33~$Gf1PXgaZReud4#)bO!+zI6grIz zI;$78cZ9;lAeWq(^1Y=3@o63Kk0Wi1(L)1W9aiX}=#9^L{^Eg12Y4CE}%{ftaDzSzSU`_Brtv& zXDq+J+AB@7cxB#~EXV4#NX6;ydzw&7w0GjsG*079r;8CRb;WZ;Y}zSurS%S6 z@!%3X0B9N+qr%sNOQvI_09oRtq}Ala-<28fZ>~yW?}$IIOSsHQ=Q+Wb$>zIYR^cf~ zm0P}$_Bq$XVhs+m1b9w5f1E`LN1l)(!9_7$-Z%zRRp>-`5wQRV;pewr_aCyHH?OudYi8{2*5*&klMg7n3_>YmT|KC0=a_ z=MDVwmZzxu*k`9Q$4>l0o&n|DpK+pT?`DSYZ}6%D8H|o0uUZ{rk+w;M`XaqRSP;p#!?daA<2~weBL;N}qpg=s42Z!T zNQUnRdfWsI-pOT7b}$Wn;=YosWQ2FZZ-@Mt^g&a3S%3Dx5xGT(Nwd$3e(xCn^wPLq z(z9F}Nqdq48eLFio)qI`64h2~bFLJ~FQ9*5k5oU= zC#dfiFvmVs+fxc(?+w|#p4oX$KS9mmXdC(<>I9I)BGvSz+*Cn^?`oD7R6_v^KnWV> zmJe~GF|i+Q_CPG|=~~R9*wf8MZA0qFyiV{JkE71NeEL163GOYVoLzBb7p?@#;y7=! z8Qd-XZFt@rdHQ6>IFTEO=e+|V%#EzM`mxvd$KPzz&nnW-3h}t#Fr8qRKMSiN2)vZ#eXYLG zbDj(<{(U{&Cf7td*m+hV$N=Zg^+4y~I&Sen8V1J)sa~zdw(ZKej7 zpcK9&$U%}YPW+_3bmKWoz>jLsxh)nDkje7pwCsBs!1_8_dXHh9(@($XyUm|Uzr0gk zPW`RM2iOLJ9$&|)Wh*>H#=nb&BqkzlgOs?zh9VXCi8TmKsT3>jj==?SNJWeKvo;q# zPy?+_$P$i2Do8DN=Nr?U+IR)e!d+;QAasev)oIK0>MpXg;(5;JvsqQwG@o@%*OS)U z#XtvHrK5Z%7uYAxK=vmFmwBS=zi_y=o93(2NiLS&ylkw_H;YStE(gptkF3!c(P>G` z_~P&u=%bXtOt*^vqd70QY&FOISS%fojBkFW+(=Djz7;*G|ED_Nn|Ya}Qe1 zhP$Bn0*q~Bb@83UH5B`b*>&C1v}yyPZ#ZWNa9ff1j1d?QaygDS;X&;b()JbmO3EWe z!DnZ#UHUb8_)i^4Ici5$?~#D)k%|y^SI-vjPLk!&Tf8 zjr@|*sevcYl~qfwYwd8^$5-vsEk^f!Z<8NhixYc8;^KSd;J7)T;<{`2j-Tfl4bVR{qOTon-+&( zQx*>OD}%Hs3et>!KCVnkVMmA{gQb*+}QGSpsPnBs$g6m8&BMFsy4axKm@Tp_HEX|ZI8JvH7ulU)o5m-!{i2q z{W~1QC0Na=->7%tL&2r(C!imB5y@YZjyrv%iFnD=qt?m0J;3Rbc)bq>B*42KCZA63 zcj3QYv`cv7n#K=Ade?abk}6yTrH2Dwj7}R8wbT|ehE}aU`VT^Zi-x{-C}Yqw-?jP` zB>ZQ|f$5A4IOKxPlmYOg{v*#Ln?@^8=Q}yI2;+umkrY=%Cg#H}0WK%G#|m9HQChJk zCe&1Ffj}$bg>{a+ z6tPJRa?v6Khrc_=wA4rqc7JPVZMaBc+bAOOM+<|bmtZkW63HryC$JgpGJ`T^SvQUC z63EBzAhY_As=oxB!hAx&LeRPsv@VNgrK8MR@M^$h?9lWrA-@JV%-!%ckH^APFeGzT zWU4zyI+l=?Us`Lg1<&KR!M00sQy{cq@VgO#u!^PZa#8F3AC$fv%MZDL&5 zE12!fJ7&l}>!yg&DLm8$97JWyR!(lshUC^HZ=C(MjWIK8d+0797{7aYYM&ZX2-{os ze{g1TZ$Uh{SlSJ>#ysuvc%`}P3VmgoN5;hzmY^rOc%ix+WhuX#XC~;3#M_)3mQC@9 zrzKn)UxeHcJ-Wm|e_Z$K5;bG-8NqX+c33NK>Ak=+Zn*5@B4X0$0g=vSdnxQ-%*~ijyN;ncs11&_!8tnF zRgJYgIz&7Ew0J@1Y`JXqwjNJai^rqvqj$g`!L)$^%**vIQA@}QzW!BBYUoSDGO2XB$QfudLbGyrX;O`q5m16Xc4|z}b7%{PGm12Q+kX z=#-KtOLiuxkR{)qwX|#4l`8ctW5M|6sT!5-^9~N8Y`*|HRePAb+?$`{b3h}v%*g9u z!_$G=bJIk=JUz)dWbxG>E}jk7UAG9CMpW?K(fryL=7#oEPQO05S3t+L2z`1NZ-lQ$ zw>IFBA$^fq0W?fEJPbeoHtf}z9QnC6O;X_1H%r_Z2|A+65wO5h5CgyLP0I3s1vbVSkh z45K9_ghMlt7LU9FKCm}W=GlUY#tL>S=IB^Z%B+KUVex}O1_cM?lWZ?z*erl5*C!r_ zs3+{Jt&twVs_pLUq^9h><5#?ih_nn$=O zC&Wj4dvqH7T}Q$zuMAZ14DO%3!t#-+Iy>|4htT)(+%`BdFOgf7_qWco>QuEfC}&|y zR*V5LfTH#>y3TRIoI+x!L7g3_l- zEB4G}os`UgqXJ>fg<$7H#5Q=|;c)ud#axZo`ATA2ORl;QN^%$*`Uab8*2h_N8&R#(NjWnkb7fLrRl*5Ik7X_V zO#*2>^l|c=D1t~r!&FyP1IyTzh=Iaw#t=$G=V;@7me4tgLFk+0{EF8H&-L5Z(_B(B zbEu!UGtevhm~+}=+8KDC$*f-g;6`^7f2c`PuQKCl_F}edz&qqY6lIQ1T7^FFwMeSv7e8G2i7OnbiFXXA zHfiLQ8(H$P|0>k0ERmM$~EtT83K7aZ-Mq4I?%Ydc(4FBF@zu7SzPZd4+QeU{Y4OUl{1_ca6ZF2`_hvh z+o#M&*e!uMo{W5G!qdA(*mQ&)P^p#bY~DM&8rVQaIswo-6Ize#z8CZtHxw;Rm8XK% zA;}*32O<}_hx&%#v?B~J1^OEGLtTwPMr&YtEFCEdk(6Y$UAxQ<4dFj~Sm#;+1YwMmDCS&vmpY3ENpR|qXH(jeO(Q80T#efEc z9HDmfmiq1&_*0-G%JC(VvVJ>TY1_5I0PjrF$$0|Di>>7dskSz~pl!?FQ9sWLU(Y#T z&%w{McK!SVF%>_(D@TWK_!^I+IWB^>zZT=)&*j`9_%nN>(X*@k2JPXnBqI;(PL z)Ffm%i-9OWyF4Sna>e(TfyT_2!|$BVByMuQjDeLh_s5$g>y~^|Z9N>F{8K2;iCG;y zei+3s_tRfRS%=wKtd?#^NOkw;!WSD^X2+e>myN)Z)fdySjF`Z>Em7=q`(OJnCF|VA ziQd?Bd~ZA*!|}&d|G9lxcT^YkR3|TgA$1%@_UWqvJ9jVJi|uvm)xU;oL5~N9m)M8Z z-TCT@_8$&iioLDl^~skd)qHQc@e-5FWR%kA7!CO;Q<6B|Jb?O{T$i{jCIFB|lrg^=6m)(-rs%y@;eh z4@FvuzDEEvCUEu@46)x5Ftp?QXscs3jd#^kd~`#vKjTam)AdiuaMAE>J<&%qGev=0 zW}m?5=Ax#l&bP}%Iq={d`N&K{U>z>Gm2YFIa2Hxbjk3B8p{8h~B$4AvexbU=8*1Uze z3I!+dSCk7MLS_zELBWCSnfLqFi-<1HiL9{Lw=T@w=eZ3qYyrF#=tP?W$SN5ND1Z;A zv$EUof09e3&NgMCC5{UM3d8eQk&CdsmZk9RQL|~AYkhoDdo{uNuL*7L9p_%aip4-R zoB4FEBP>pRZ3kQM>?#6oIN^mveL9BM91&9e))#^b*&}>b}e;a)AL-Vd1QmCb>wQLJ??@zoq>)a zpMoRSV>kPss>xFU0C#(_zs)nd4hLhlfezpubsp0h6ouK77O2Y^FUuRtE3*Zu)W(`> zO(!e`ObM`Ts%kMsGf|{keCY`V{DZgHgBWV-7t3ozvpZ{g2=6ZtV+h><6UPBJ1 zp2=+Rg_cc#_be}7kd%Cp?f0$V%zpUFT~}^ zpHvEtaebyto)Mq;kEc{ijeKH68k@rI*DUv%SZ1TPog)bxuWjV**s^8qmfpwUNx0Me zy)#2jU#UDZM3{u>6Hd+k1*}L!Z#wy!6eX<@iPHhYB}G_o1@GnxUz~M|QAncWClN!pVz8&Hl}-O?FZ8^pR{T`1C9rHd3?q{+`+-rw6%#qoSKzmAKT97`nj{xp*RPCFL= zOb#hvqK<>P#1`-}%IS>858AHNGt{rwtB}Ny(l?^@?C$TRH3)KHC?Qd#z#IGC&RxiN zi+TVmb8HCovxqZl5D34Nd3H-l=Ou*WQTBGi#)bw#23-SMC zl)u}C*`3g}+J)GP33Z*Dvb{%fyL9sqt*ZL7X1s8#JPH&FBO_om>V!tPoodtmRS@&0 z)&>guz^JR;KJ;n$<`|Zx=odYB;fQkYqi@8%AT6`W-Hk+gG#$Kj%RBz^`hGCYcV|NF zG5^g+Na`KzdGTOIv0KyJ#_S4esS81WU&$J$9$y?^6#(C!@3zskj@Hyas%BI&*F(T- zdt!6<05ktk;RPyU`EqstJa^gOCQd0;%|GHgV9ox-2JuXhWq*O-Uqx@j>-7`cO?I+X zJDU*S+U#YwklqR>sI3-B)*gLs-E(dcRO zro|r2^=u|D@#b3y+agouN)3al^Fi1Bw_QB#rYeqlU>@UyTZO^HQu5<`zUM$RYKy*QIQQ zLj9Cx(yOTUQE0bhgwcMbo9;b+~uwzRCYtgM&IdT#3CXrn4tnkF%#CxT$i89Ur) ziHa-n*D#8efQO%RV2zeTj)4v`XW;yVUElvL=kkS9N1YzN&OoVIw={OKea}J?3+9XN z1|avnN`i*6s!>&s)g60l;n^j<4q)Zds_U|nLS{3}cza}HD_D&2J}H&siA{10R(O}k z-3@ZWL9bF8Lf0MfYRIF!ixC=OHTXE^*H%a~)x&+JNM`D;M-bl)e*75XW(3EUjbE6n zza`DcOSh=Lc-*z~8_Oo=0^wIy7s0j4d}!`e)r#Lz%*XKwLES%IaQi8)5%#|n7bX%9 z(p0ay1a*;+ZL_|TVTW*%aVKXt9b6ZAUV@S#Zd~|{Rb&M&17FGHFMWdrZu-yZ&08Zn zRiL}$SDUfh-!+D>0m=wsQE#D8`>hTRkWc+E9``}g0P|?f+Xs=|u$%ixM|Yn34hqlp zl;S@2PMR?^1577{%s>yKoJ|yrLi2hCD6#CN1P(uuYlEa%n4n=~BlY>#0gGTqE75a# zrI%-bil5E$_D76+8BPUKobTE8h$44U$R+ZoeGKst*aLq#{Tlx{^AmgfG+*?qa4CP( zYlG*^C)A_4BESFZv_g(j((_kN;s+CH#in^k&RI;X+|JuQS~tJEgvd}Kf?7FZ8&0@t zflZ*1tAZ3R(~;s7$}GB4pnbU12maD2_W}NG^Y=#j{Fnx1GG>+o3GnVuYTeAEV9xOA zn*|!^-Q^4LC1Q7H>@CE!t<=EV4JNysA)v?W?RE(Lw;u?mA?R+!`)vs&I|3M(#fLRo ze~MYuFph7^G?^kOF#Gksd5hdpmExi$(-zI=b*_kH7l1`wtQLf4=$u!u|f2p6LH61ma+4;`raRUq&`|w*NyNeWC7U zqrCj<3&;s<+9&lLS_TG^y5Uj~`3~K}jl^Q1fDhJ%1wtT_(ozxmumAlkZGbk1@%c?w zd0BO@$8zoDCp>J?+>FKQlB96ef?Z;n@TM4CV`RAMJe%Mz+vUEgZfgpIpH*C!M6&zu zh0~x7FQ4vh5YMq(xc0Iz@&!2b=7hR?IwAA#EXt*79Gpy!<~iq|y$nc%exL2O3CU^4 z)43eHJd8}qS?aD37A=vHe2g}~Jj-zHb$UVE?3Dz#d!Xwn2#20vPyo)2*pm;47L65W zn7qaO7+*(Sor$a4?kB7r2(0uROeMXp?-F(OxT=(ZCIfn8DTnLQ2Q$|j^rb{R;hI*omP1|DQn3h zPNn$DPH*5BRM->r^9urR#+@5uVOy2JR`Q1xrS8gZWcbFWVNCs{L{y16(s5;jYt4J> z+Ge#c23&nSaip{X;h|-T4>sZ1alV29Egyx#uZ&L4viinB58xJgu+J8G%~A^KP-Li0 zFRjVKUGi^=oK%uL;GT!HY|O7_+kZ{5n4ij_Tl)St6c>jUsb0WyvmjP5xi2RHxy z-%+AMWm+u1hsFbFz*xl0499B)P|Oyh$CF%tNp)^v)S60~auAVi!<`P}L0lbrgTP0W z__W#>+jp%cgQ)QCT)CvV&bX3Ay12|YGIWe-%3%qL0R{7{cy-f+v-6{G&zJt$ue)kp^yrb zzD|)p8}@YecO=1q3)K$LUk0}@e3IrYeFl!Fd^-q?b~o1N*jQdkwX>6BACIdMWb-(w zf#sA!Cl@S3PL!(4H(--0=2m2)c5Y;Y5;i+b4St!zn!Ih?Q!g}AE~-+|w)}~^+1>u<+D^jhlAj$v zD!N7dRT?dPt1!QiA0^z2$1#O@A5wP&2wDGqftC}nPEdg`*br=<#V{Zmv6S*h6qsCq zkze;6JF0$=FcB?u6i#w;EP1Lek^w`?n(UF)^j+bi*y$=WN2k>wpShW;zmRbW&EB1+ zcA>q^i=c_-XR$z)V=&m=M& z#rvobjaFSIs_bLHkIi{Xi>p@iUPi+EGC0$GC$E3IcPh^c-&sFE>nm%|6u2r+x_75OmuPy5NLCi&DFlih zw(Ah?+_m|0tb8mIQjwx8*tDg2=?$~WLmSW4@&xGZ4aRGo#2IsGwA~7#!E>XoZSF9w zGoh-hh5NVYCB)g4zv|cLQ*-lWoraiayq^8s{^_l!7f*YUa^1?pTxF!!T%5#OLQ*L! zldgOQ6PxL8`M{_;;siy_2^IkLb+oDG;o?f@WGBLvbg{&p-Mr;6UEvAYQ|6X%VfAV= zYUyRG#Pge1%*8&D7Nln-Z-O3eG)62Y+$aF{yE-8u5&B&`2ydjf_Xt6IpN?3XE@0ja529(+W*0(B{a;^Iymh(%{J zrHtf(oehfyXDftv*=(lkv@NkvmVG<6d*{8bvMWv)W9X&XK*6do8(ICQhZKT)w!tpC>2#x{F{lrRUu2^ zZT?;xCNN`**j5Q(zbJnuL<=1M)3m5(s(FD>{bZlXk&!45+4`b+%BT zw<@1<=*zDxPn$YEm*h=sLcWa$hx36@hI&=cAd$EE)5N{;Zc0x2pmvZhk>ly#&XnL{ z{*Z*$lmkP=GWnlfV3>CX1lI{!>0?zQeud= z9=tF=u z@?q;>>)yUFU4-6s6^=E~4M$I{J;OeuIaf&E z@O^T&3Ug-ISHFFrLwIKE6>qXgdfmLI59%b#$*=})Dp3cF3kc~0fPP|I1s)C zK!2@L2nu&Xcw~)lwlj!XwJ38lFc7tfY`qw%e<=)Lcx3Ho^yhl&_a9*2z9aS{?LuY- zsP7`UqXPTaTXFOQCLGZJ!M=lg`nGp5!176h24$oqpvp+uJhMLj_)fAB`=O)lVG2Xh z44{rt;s#*uFyQ*9?1*yw;168hId;GX_Sx^^JtMsT_yi{yU~NUri6_pd(8@O!U-=jD zL#^CD&^G5dTzq@u;~u4JsJLL{xqYe~S^bVhUCxm z#>+P_GL-_wrJWBqO-4Zu16Hl`Fdp6PJ1xgPG(a3W!S``#<%0a#;aHa2IOB9@8B!}2 zMI$%cHKltwZ#wD%H%b#wR zQz78lI7q$<8T1KBrenrZ+4#TG|os^{-&$;j!DFZFaP?fiG!4Y{AFI#PkzQ zE#aCws@4-iyrKjbsW1hZad$G&wCYOL4MS8Cby2+pBB$KQ*tj{$kO@dmJ-OI2CSkec z7pL&b1nonddeN(RyEgIel6dUOts1^uv2rEW@_|K;#q#9x#WPsfuGjeXWy(nZ;kU?- zD2OQJVF}|%#!U-$uBn=IKU+Q~sr1!tq;2qM8%W^sJU|IQOV*$cb_^3|b&c(YuPI>JnuKNA~b&1spOobshrLA%)I4C-`@=a90U9osb< z!QBWmZ98N8*l~ee`)LPIaLliSz;59cxXe{?H9m%v3+3d)GyekKvIfMy!aVcc*fw0x zy3~!v!)#A+=YH^oX(`ykbbYbB*0L{PUwW$qd0aa!B{x*{t?w-^d+Og*gZNIH+*3U6 zcsa9)r%9*IEbnP>)ng%dB;e2!FOy%R_{0bHoD7wOy35X&4HOu_b?phU_j#{ zcR3sMju$>8@&ezQg6FWod5-iMh;+w|c-JtmadK)9o1N^&){&P_+6c8vgdO$nHz_~U zpP)ciKhs#0+ngPx*VmC)yE4orJL>$A2GArz*L5qP&u@3<3*nwJJgflu+|X?9JhQ_u zZ>lwJj5#Fs`a|?cGiZf0JTgOUi5jzz+YMc5X?*O?DRAo~ZKh9Hm$ zl%o`dg!yeC9&k!&Kpy-DH82nNO#lHgzzX-9GXp%vjzDSuCj-HC2z2Bh3Wa_Yi$O{a z{{chJ^faRmLfj37@9eqo5V_#OX~)O!EIorJJpwS#)|U);1^X_4pXT|FZUwChu1}k> zq=W|piIw0{%NfGa3{ez`g-ya~KJPL~<3-bJLsjDF>Vq`lF=ty5TJ{w;BHtVdKEaUo zh~6PVdxjf9v@78RJJhW|GG5NzsJnw}_HkMv0DBqFUK@eed)&|X-7y5aBhN(my=*)I zIeS0eNwNp0Z=B!3*KcV)fA#cFJR|r<_>E9M_N1@+U-3TbTN&V@r^OL4OPa#IwfC#(Q=+~(rlL9G%shb4TECW+~no3nL zY>u92V4KqAfz+nJ<6bNW8CwMXpr&I0e%@?iE^|*%vlEm?m3s5>sikMI@0eqGSjXOf0?#ncYZ;PJV6VYYNpC;wykgz)gp<7;^UF!zZ{v$>Xk4o zoSW)id)cp!33H z(jxQ6mn5!p74{MHh*c^ix=a%n`7kA44J43bY*l57A6@1Hdzc5 z@41!h)L20Rzxmi?=2~qct-7lGk7qNNyQ%$UNX?giW$U{5 zle;7zTou5f!k8W==TE|~imKF!W~)?>>9k=>fRfB0tBl=G*?#dGs+ptw9kO-$&%g(Vweb z*tfrLqfc!WF_TnHPI}`zKVavLsp(ShvCnuPS;g5+?97iFUMgz*gHY;%7R~OS6N`IQ zjw+hPe|Q}@bW!bvQk-+6pK_Zt(B|0wy3il>{H@LW$V+|`O;u@n-`VUO-wnVQFglX% z@pK$e?$Kzv8$+MKNukxf8{Es`@3t@$_R+PS3V2ymz5jg-OyjLEDsJ!=OB>+pdN7ZX zrKW0@rA;@Yot&P?%1p>gN{h2gV=>Zjm$;E|2?;JtRmvo)Bk99K88@=HkZ^%2ZVhlL zpk^0qN4dAPQuC*!UCb>Xf=)P-Q<=1+vx~kf{*fiwGrIul>1aA#E#n8Q0oWD*3o@BF0Vji%vCUy8v+Q_rCDq?~wWm6pq zgv(afVGX7?*?+x;jC0wh-LDh%5Wt0+^y7NKNFubE?%G_Zefkp7}| ziDINZL%F2m6qZuYT~$dow^q`%VE^^*>Hm+LKQL36uA-^4arS0WdSt8QK@B!$hguB; zQ0$%cqu_jzrRdl;U1CrwU5pKV8Fii+?Q@miq_qM5nRn}d$YLL+JGCr(Ww`942`?Ot zgsVq)g|WxBHXFNTrC)h|BnYgN@(d=j#Z&!Gs?P6LAVh)+%SnMHnj%Nx$WuZQK}G@h z|BiB4hf;_vkyMU?{8P7^*%{Ea)gGq~T4#0!rltL7(@86P6j0M~lRRWmXG%%aacmP3 zhgv$UkF@qN=M=Y+l(wCkdHhYD=OK1#h3L`QPJ=*i3Vr86C_zfv9Cv`d#^&xgpv|<# zEp*92N|mfbMkQgH_tGb+k*Xt3iaAZ@B)Ljfhc?*`4`jt9{voIy-%7{H`oLMdI$>0n zJjyxIUQ(yv{3Cr*+v?7Mv!co6@9pHEeC6cMpvtXO{7lbh$S~oTCjepjpsun7WkDXJ z&U1j(kw#n0zKeG`q7PCTb^L2IhEKz*YHL-kc!~$u) z6rgTGh7&XTfH{VT6sumhFB1&1Z&!N@7YHRqD*>d|WRBv|fh@=1@JCRC<`GP+{hE`{=^# ziRv>HP8Asgi?rR-(jvtc9j6IXhdTYa=nCT8EAODdi2IAuv}wwCUI{WRaqT_Y{ZcHY zPj6G8Gzl;DR`KwgO##BWMQ7>g4{&+~aB{Od1u;-}_$!IbP1clW5+@CD%(2>$%R0~G z;@0j~rXjs<-%aRWuvK4Ii+(1s0{sOLd9~4w#L^48Wt3 z`p>b8zsS`|GjWPCCK||>kH;0}4Na#SW zP(5jLdEQUm)$B&O8h6;9;yhEK;_H$CI_+D+BtYfuHQ)y8=-^EK>vjcP^ZlocS-+P9_O` ziZZlD<^`xqn5A}WTglF>^`h0?-vCxB=7Gx@M+sN_y*IcV*&m31HZ`{4?1MPP^(nM) z3p6{?wcFNLKy_kL90|6Kw$HYD_NTSBIDmY2FrB9bZSQzWFznlT_z>L^@qH}*1caJq zOm|oPxy`Ob*UkA>b3Bw*+udBADeA=j;L+NF2FW1@5tAdAAbLMdTvw4{5A7ZC!!^r}XI!m(%nq?--04G#oj*3cplb%} zk{T-tPSBV`Ro9s%n#pl)5S!1|_tNoh^0}D+5t|2HW>+v(E$6^rm|J0UMt6?4H(uK2 z$LSa}tQ)DDV_2GAqIL7QbD$x(5EO1k~3FN{dw(wQs!ljkmf(n+u}s`3+7XQKCNsu z-WWc)4E6tJaW+n*xz+!1qJBNeW8Li?cGD>o1`V}nj~`nG7Fj5B9}wFn?`t%;JtXwN zYS6>c6ImZyh2ku9;j?`3#BhSE5oLY}VrxT9F1ACiuQAGY{9N7FcnkSA-wtS}aOi`9 zg$DBCKhv{zFJc;>7q3Kmy`6Ho8_~R2_VQi8#H~EuUc#q2xZ=f6Z!4Kt zU%x46=E8*VGpEm&(4{S_{BCd0cxYRgF=tuQr$c&c)o)DiV#qv$eSPv(FSh!q!ujBv zZ&Y?U1n_Grg!Tzs(rgFut!lQX$m za$&}6 z2CpsYCr(eubbN5{3dAUjl`yooC0isYOu;Ix!dVno%d7apH+gXzDfyvqS*%IlYg&pN z^;4296}Z#K?;6~2LSS^Bscceg;4}#_#q@!^ri7h-T$m(~sb^Zfs&BP=BJ+H4kk=ZV z-^Jpa12VQ28%JI+>r~hEZ0@OMDWkj7noQm-ryN#+?=_!M?8Ebz+8!t$YV*9_LOg$u zd(G7Q>)z8UEv+r@iTHO#cLvNJ)w`W}m@`iFZC2S-dr_F*9wJD;RYee=bwYgY#nbCp z?lO>K;ao?xYmdg4v9ToWvkqE=gjET@ec2n*G(@iU{c@OP{{G9Jx$0^1m%$mowvi(l zs11*T8P znLQu46C7VXe!r={JmC#-_JhxHc3>hdaq5tz!)!X!kpAWIFbkfkxq@4>^q*Y%!meF@ zANNA*08w`e|1o@A;`2N*sXumL1}lc~f?mVK=1c+`x$F2GpLycfX}_-cFt^Xa{5v0I zc+BG!Yq?0Qv-JUr7a2)A)KH=prEeb^e#-J0?XSomX^63Uv{&-e>$eL zssAj)mQO~|thRk}(O7%))Y^uc=iVYb)@|!!t~A^@R`)rezuPILJtXgmqRu4Om{m&P z(R0-XekXE`N6^FEmF`bDswcwk7w&7h?t^6!dT)Md$GqhI(M>-7a|tQlU3^*<>eZbR zpEB{okVHSN7EQ@P!_P2|17R%1%-I&r&y(`z$@TgEMYHU(YW+otVs_0%|yXXqP@&1LOT{hn3E{9hwmv_`X{Pl43I-WL9_HVeNcp zb!Y#}2_d^UtB|cp*D%}PKjsTYL|cbEb&=)r7hyl4(YWbU2HoWwyEmyi_e3>@HNMkN zf8BN>Ok&gdAQouro3Qsuwdy`@$LjKn!rz^|ha^L96);P`S`!}|df3SiR@*$N74)`f z+p%V$yXxe4J`TdS2Z3(gxCcVf-s4XqKU{YvUD5pD@RePTYwYFI)-8sLo#Ny&wcMc@ zuAYa7^_sn`*?MHu9M^ameOUkQ!f1_DP>}t*?$<8?&%ONw7q2p(u9b51rkwHV-{n!-vorsEslk$_@ z=f$kR|+qHWc&&Sb`sxhI9!<1n2c?^b)RH47H0M$K&QxB3>A2@RhyXL)~&gH3=% zX#a;eA6DvUQXY0=5Jd1LW&+%_ugxcd4JGhw7z;>>vi^8r@N=} zQ;un2?xm+hIV69n&$LfSIH1utC17SjpqQPh$?4W;7&RJ*x!Vs_R4{egw|%zz(@9YwkVUpKo{Uit&&mA!E1jX8t_E ze1$&E!v3j}jWd+|J+TIQlC~YJN%hw%g1WzX+eX%PxQv9)Y7a)6NSYtH(*L4=lp!&c zJ|L9qV*bsbZlR>x#jhCZHmwtqBYCuq1_d5RZuyesapcLo$013dRMh-req&gk*x61q zd2zq^LMfM=u;RTP?ZvB^=)&Ho=KgAR3wT8JPpe!0`P^#ivDUv_{IcvNF2J$bv_zG) z3?Vi+M=~C&q65_>xj5k*p{mN@>Kc@kloSH0r@#1GPhSTj1vONLP+VN`P(vLY*#U@8 z#6yido$*k04~nKC1xLX{t#IFoNzMzzKOUzI9@R}tT+hWC??NEj3Ts*8i4+3GQv_;& zwR| zK>^@~$2o0c+!GY_*q`ALJJS*ND6XqlP1t#NV%c|}+hQ*@ir3GCw&oLpZ0qK6E*I<|cXKTfxqOZu?{ z+r1sd4f2mJ9S|)2GOAr1<~R7QZ`|D7qIgUWr!}I_g7!-tnxLjjspUtG<{rlbm)=VXn8Arl0K_5aKyLJLo@Oc6B!3 zrNhA0xx37(k`BF5Ak2m<$4NLb_i~Knyg#~WBO;TWqQ;9C8sMKAZ@Sm^tiONlbYPRk ztVsv-)m+7)j`aFSY_{Lsp0O8m;rFxUicIdGob^7KaXoXjRZE;}%h-p3R~tx2-L9Y- zx#nz}2s1jxH*c!D(F0qposPEbEU9Z`7*p^L(Xls=uWgdcdzCqIxQsynU7DNo91~pUBf&$ceHPIu+4L@ zb+EO_b)-zTp{;1F{$p9)H?g)tAA*x>VynGmz~gArkpgGGit%cR>rUb?>TF-dD4-DX zDC~aOnFy8RZ5Ot8PnADA^l1M1mUC0&USKaH6H)ow@SQ0(X7@zN=ErQ_r-jOv#t#Ns z8fjfgWt4ENuwffiT}_V@=6@j`c$<+>*a)G4!$!T-o|`zM#~xT=+fk1)roT^luKd$+$X*le2`pNYmX zXweDzzdUp(Qq%3=h-@sQp=nf9?S@Sl7()m`TTk?b<;zef=XD9m+QCYh%33@3CRW9+ zm2_}6Jv;6EB6eM(Qn=8I+^cWYMowMMkcyZy5-|Og)-|w-bDwguX30#2<(*fSVI%ea z-D(%G={4LAVxQBbxg`h+AK$GO`jG1-eMr~w(OTuWYZFbe95H6YyLvdf`Y_TOpWLmJ zcQ)A`$z-i1?>d;i)5P{2-3gte@kZT&_6JP924bAI3~l%_#HYIL$U9ai&54?Q(2AF$ z&jN+DBi9&5u_rudInx)!@oxCbJ4O3A1!vIHP66=T=tgXtTvNn>Z_%b?Nr2M6RCaeJ+hm47;GbukhL|ot<;{ zwjPi?AmB*fo;(%Bk+RrN`U6N1W+SLCjdg0A@MiEZbwY~DaoIxta;j30=-P7i6WA<7_hF#+GHdfo@mI!MODeUPnU?)1?>MTdE6G zZF4Z+Z{}9Jy=@@#w7tW%edb%r*A1{`hZ2N2!T(^1qs66z~ zJa168pCf!GB10lr_*L+mT8}tK?I$w1?IIudh}_CLYMDZB69`SCcm^wYpv|`CW(M90 z3viOpr6=dO?};+puFfOwrZvqHs_J{_wy`1a&N_8#)71MGyDrRJRg29JWQi8Xu&wD| zQ&8e?1nL^NM^H$6YnSQ;T))^>zOufgJN2!-mbdSps(E$R;cE6_QSs<;qr$37HOw-k zhn0Sw>}pX3sIUS46t>`)NKu`~h1=C4R1+R%ahey%dChFwT=O79h7 ztipjF?J)`Q@h+I2(V-5xEah#8WUH$R zS;1-R*jmnBZ}IJ{BN%cEi{6boih8F14!8cArRAG=HdXr|E&Q7PZ_oImO-x|gaSAZ5 zri1i#*Ms-tAYm%dXyq!$mtWzWZW_Jf;q@C^lN!e8BW|CKbh%Wt`C3-~r?UNy?=kOo z%?fr~-|njrudxoh`lf>z)hJv($VnVKlVCkIZ+Iod*zg-+=Ya&5v5^A;FIMYBcSq%h zbP)`NZi^%(-g>jc?42e@6m)R?9G$i-JzrSq!6%r($Kf(5)%NGICy>s3}2 z=;_$?D2bOuC53)?^0w)Hy&EU7b8Ta*1^n2q%bhiXGNgP3FO>bNL-w^D+LfgyQEi6b ztcGlKrmqVHUzcj`RoCNHz8Fz{6Z7fTjm#Gtog0n~yn<`56A#loc$*7xEAX)-cO<;w z?!3|5F~c+|-x%wncjxroGj<*7JHcj{<(;`^CwKa=(%`=5(%e(!M#S^g(EFHg`{@dT zzZH&X9U+e%vy8Mt1{)m1jBS}zcq_rcNpyE?Ac@H&c4m5KY#Q90(UqcSC$xV@QHsmO zDAjv!n}y3T?*0f$-x1)qC!sN>RX8ek( z^uCvGJ=tyj_P5t>;DkNk*=ix4v7Ue5`#|!Ga-I0>*+J#Da8b@^xx=b1=8epky4E}A z=#Ss`wu*W!-QV%a<%K#TFQ5zQW9|F?3Sy)4YO}{v0kMAhb*>~M=GIqydoomuP-`4PcODC8cYH8Q2o3aTNJc-f(}=^`^J1 zO36rto9O^&d^Eko*7&9XEmfta8yU<-b%*apd3`+YuG?X~sQ@P!IVvP}w0tI}b)?+*J@M#+Z~FhmH53iqJ?Bd ze|fL^72Kdw=jOQ!hxCE2s+d$^Ofqwjmv4HNxEs3wo5Z)MZELua4$*adah8s*7$N{Y zXol=n^4t|7dgo(bW_iiW?#;q=x1FzgIiGjMCv}%%3D>)qI&hUit0xIPHk2>TTP%XT z&Ry&{eIZL-Eah5)B)RQt(FH{gz^M_mXyvI4Pe@FD84<>8vu$u=h%Ep5_Xy$BUTfF0 zvb>a!zjmeh{H0x5+Ly0C(P0bCU~=f;h%(lC$PuX_lHg*n=b@)#vNr{BAhz1@Rao5C z(}>O!pVTa6cE*O5Cne-M=4sz+iwU$oR~7MTW9eQOoQKEmYj?Uwa&BFUhGY;#cVGP$AtkB85~X18-@7C2)4L1n^L#wq2H$5VHVKeQO{&YbJ<5D{pPV|97U0Or zCK}Ogss2^KAf@@MvqVJbG~?U$V#`d2Q}dKCJJjBz^;tFZJ6e4BtJ0Hh)y+riF+RE6 z$#>2?_MS|_h-4_!0hXY>;;HnH4;Dym63@CA6wQq2cFv8*-dlIGqLlHy_eH&wD{&JU zr9y|r?>FrB(qZ|!+Q6YMtG053i}JKLL)^j6_VcWXZVD64*IRA(b_;0;Pa-4kFbK~(rtsok|D9NSy995r`einvck5(Vb(4FcWKcA8KyBuj9Hyih)Z!Jc{N zlj}9{MB9z}#1}P3X03DbvX6@!oM9BxfG34LFMcxV>wVd9&9LU)MAe50aTmugGRVA_ z?6+&!=X5B`zD39|)TUE;e>Rf;!44)j%G##t#}Bbt8y<*n3@f)j8Fgg)04yQz^@u8; z-+?gq*ER{1xb_ByA~h)(he+X*U1O5(k{kMt$i!;b_36G>SgRn-fmT73OjoD4lYF|@ zqmGJ)`K3-57Q{a?_D&(3*sCIN`htaX^COjk^NsfgSudKud25i&!LsXQyt?|v;GT0g z2@IEbH>bpAhu%ALvH8gnKWSk0WkfbY>`K)|ZOI)~@z1>%FTZ`l77gF(QV8JNv4M+zjSF((6%q&U z`tlC!e?w}GAADdGTO7l~DQh8_*6>VQ6m@wI*WSd<0*;rfx`&5vx!vWr=i|#c?Y1tB zFU0TCL0<#ew$)GG@f|L?_3;|MaHK)*?fLae8|0bJxjfv&uVGWK4rLZiPV3M=H-_`H zKQNZ{p(75Ky?;7fc=Qy@-64WuL?goi`%6k;W)eOss(1EUnT2h`@xxaKPb(3Dr}oW$G>M&-`cH8w*(lJJTPx_#vVFMV3V*!C9}& zHvWe)>g?yBQ$v`Ui90;SedXy>ne!POJufHvY`74e+#fe1CZC-@Zd;aqEwd?*@%7Pt z`}SR;sG3Ev*F{_kVoFI^b&@6Me)T3Ne=oV06u&`+SK--Q`$Bt$6CNdHqx|||?jp_} z8CycGR2n`kjm@pRrzFSCFvYtg+SNr`X2%QL)twjL6YIMuSI9v@8Sz&`UVZf&7XNG{ zQ$Lcm(LMi}?v??!G&{N!So~?xOGjdjQ&#ajioa5jdO?zT3%8~J3r&-Ns+R zDS5Mch4jaG_uHqgrpb*TQJ)*XQRNhu_-(JB2IQoB=ACc1&R8;4Hm+_mi8XPnGpMg_ zG26@TQW=ZRmb{+)rL`jDOsYMpSvR)CyQ^=yyfblC|79(am=mo8sUd8?ZUXVK2B*MD z5uczZ;h8#B-ZzV$r4fvaw(aAYm7JV=!qbx}u6VL|4Lqgp6&FDhZT;xvroAPgaD#re2fI&_R0y=>#n9a9fv=V`Rb_PzJr_gxo=b)0F?|dd4zm<0@@H$` z=8(q}skVB)}?Q5HRG8Lj-@zwNye8m}G)9KV5WS9I2+n_hL$gLvc7 z=X@2eWW!RHf{i82#TyLNL_YK1X~?BVF^xT7XhoD5`j4+2kT*Cveejn4;FaFhq0vK3 zJEx01Zg$U!XXz_yj=hBRTsZYYr5bI;#z>;;Iv2c}9=*EwO#XvYIns)&6;>x3yq(`q zv0GDO{JEvX3GrE&(N%uqLuN;|+6TxBe920yh4TbL>2B-C%p`lhBJsR_*m{d`Jo@4) z?`s;WCN&b$hVNBackXmwHBTq!Z!3Ri{&d9IZ}KH~545jOzR`g$IBvLRmr=tua~0*! z#~KyCDN3ye^8K0hP|wZz%?V~1^h4N;?9gpI0MZEvg^i9Bw7=UI8izxfig(u9GOcsaolnltQ$IRpI>)T-Pcwp^bWMg zwQo@f+1luSgR=zZtSlNUUO%#9LZq9grs#4}n{u&|r-B!DN?A$r(5rYJoRbdxpwmUI z)Y1m41G3{Y>p1SBtF`!%_`5lE52V$BWf zr*uCb+*^>pu6Xv+-Lb6nbEhBh=0y)Zy4sU|NyiZ}Bm3+fr$3h0!{TEjEavU*asR>t z@prYJ&2v<)*)UN$6~aFm<15#GZOzu|Z-d-VV{sqp+!XLnPwW=S2>tMA<5llx6Yl^X3UAB(U{kJws|tz08#pVx~{Y2TG%6t><&ZSM!` zaYhBth^rRXo8C6H(M66>3b$QiL);B+_vwj$`A{IPPQ+!mG+*u}p6C(Qm*xS9Z;H0o zc9@n*N4^#uzn<_V+Q2SahJ2-5D>Z_*lTQxsQQ=+Z92qN^UAr#RcUNa(4__l&Hc$O7 z$86@0L@C&HK2O12e*Nw&4edongL^)|o)8Q3*%SJ#{Q8z>bLWkkSQDS|6j#ey&c2k5 z?KM@an_tSr5sG%=+DfA{Nmjo7hY~&G>aZ@gmn^JM2Ba;zVFEedS+Q z53K4rlwgN}%_Q<4+83BoMr7_d6!@yoprib&iO7RZ7HS?X&$^lYrsz@C5?pj0K zi0;%oiOC6t!RdGVs!1O(p=%i~5hTk^F{)F#(Ir3Q-$>h~9 zW5x+~rvl?hm)Q(UHap86T5G?$m8G_o@k%9jX5@pg#{r2;)}FNvSqT+QOs`8#JQ&RA zFDb9Nx?YX3ZdJYaiHDyOu4u(i!MPsp@ZR2M-cR;~b4A_?&AO5#aAMr~q%X_#_EFhO z?Kcv1tp=06WCpqwg|#y1W|kkn{bjA|M&8`ZszuzFw7mt6O!33~=Ref08_o@{^c?HV z3+IR?>!6GhkEVj9m{k7#)OMVjbP4#A{&_pbF=cJ< zKHM(>f1es2{k(6Rm~Pe`wY-m#%^&wyKi$P(Q5t_@Hhw<$44GXhc>3M>%K?KvWlg2h zDgEA}R{S64>Au}PzrTiC1OL(+47DebujxdUW$o7PG&*6QVY%mv z>_^9BO~NaoGJ4jbV-=AEgH>&jsUy$&XKswO?8S=~TzXunZ(msEC%I!_B>BU~HLDut z^euh9hzaOb35ca0xc^q%WX!sz$gDHHBBn5>ed7%=;Nv5=uL90IjXUm3tcisjm<=xM zAD2tIIyv3+>aoiS5!vjf274FI5={oTtFrHoMo268(Lv)nVl%bNIGiz)8Qvd)%%|=Q zcUqLpMxp7xk!DP?W4gbr`)u1qG(0@xXez z@7gYt%iLiWz&0sYd+2knwY|X2Z`2;|e5*S*g%x-C#IO~5ULhz{T`?e3S#ejpw8yIc zRbeOgwJWx7n2_+`V^45>&Mp)%dfdkDxNEVGsXXM{XEC_hz(pC0!3!M2Q7>*doyj-e zX_xNLceu7eWYEUqOJqQuXB)t(P`OnuUi)9+DI9%yrByIUlyJ}`%~#+^JeBg|6w^|*C6>Y-pm7wf)3;JS6IK!;k@WfyJ>;(p5t z;iA<=rF{ixVnXBX1D0K!Md;&aKEghj=JFc^H*R+GJ*sJyzM&si04uW7IHsY0Sh8)C zV`=1twYdVBsnQuvpVL;iJpRJaZ`Xh7g#3B7x93o;eVFk(pN_Ql?O@vxkxzc~NcNG8 zOY4-Y*hs61nHe#G(9(`}bL{PHs;#-Ms3`X+F&{0|(NLR9R5iEK>?ymKdp)deOUf~w zh(|W3T0V}A-Oq8qPmZ2CZ?wW*zfke(Fa;b;Tn=(7jiR*|$ z89ZN((`Z4~=+N}>9r9qF4pa)b^UeF6uGxb-`J%Tc54<0aS17#m z{OyAsUQ<_|$h01A|CBg+omla*;ln$dLjH!g=g8Be@p5_r!&9zg-B@Df5XDM2Zf>T_ zuh2OwiBxT0zcFiSbVgk7xMa)Qk*sM~)!RvZh-p_dn@87WD}d#ia%R!*@7X4ee~O~$ z87Fyq9XytDM{h5iG%*EZ9Of@AEhx$APBfL5@csaeW`(SA~<>q@6pmx(bE&tB#~?# z@rF1eSpt}mb#=tKh%Ce+IO5@8!r-K+0X0Y$=Y)sqn5Z3AQU3)QHHslH1xvBAqs=da zc`;tdFH%Yhszt#$60DSoK!V^5GX?K-5F(9Sm{$g)g5_}`I8#V2&_j#GM8STZ490vH zlM0TE2dVx=mO$}&l7V!zh&Cj!FyNFlAVn=TBa)_;nhwqxN}G^|su@FIz(hE;7~eAj z5`oYd0Q1w96mS9@AO=$fC&S_2vko;jMVP`7a0nWWHG`p1rYHo=42F?5MN7dUC?whp zCXE8`fh*P&g+`dcrKC&|7%Xr_1J6j{iZzA9(PnTs+!Q5+GJ_+eOr2nr1Y?lGn) zEbtBq&|;;{;3yb)g&;6MJQUg#i2?Yb5vB+<5C<&{@B?TtKwKEo41s`~qOmA51X9`* zgG8AD8(5ekkuWo}pXS)57sYA{6c-e+ff-my!Oby%fFJhd_!krK$e%XGIC80lcuI=t z?4W1xkzBUzAM~5|Zb*sYmvnobFHfhV9e`BX*1L{Wd^9Qc{vPG2jN>ht18h1?$$mC- zk2p%#+0=jAyYp(NtW$JDun_a^Ohri{f`Vb0=2SzL2hh3*O8=VSaeFd2@+R_`puWz-&SPosX|N z$u%V^UH-va6HaSASgoB#Y)^c5{d{7M{I&Ia=duG}758E%h#{`buVY74!%c#@&fw49 zKjX#2$~eZIQzStafiGH+_WUjZZMpiDt% z36ase+W1{aWdN|{(8~`h039QH<%JU9BD&~a{tmS!)Q94pO&Z>Aj z!X7UdyrGw_k(HN&71o+pQGrp;L&n3&*$LnV@o;h^l4U&Pd2!%E4jJGc42JSTs8J{m z^1Rd)9*{#i`Vdu;3m$@%gh^OQ0eXSKO5)HsGy;njhrp%aNGPxj1qPRp!pI<{W#9%H-#o9)K z>`A2HJS2!@z6B;UJ~Rad)lxdnt}c$$RIII__=UA9 zWGGA$2K^NsAf6>cB3Y6u97!vZ6VwB+I>1&o|3svt^RLOAoPJ43rWoMAOXQaclBo-L z4De)1t2p7bg5zk^;XW>O2!6U+C@>o0jsG9RyYb!Bq$J74*LDo_ws@9fz?=! zc&dgiReY+dDLYbr4h8vxy5dLxRZzweM+8vukg&$v;9MOkyb79lCjyZmvEWch7?WHa z$bezNOX$0hoSZ2THG&nG8Jvr!gc`w?0Js7Ysw6kOi-duuiX3!-@y`h^g#MflYB~Oz zWjR2&GBnGk2CNNJ0Ii7xOiDruZUjfjprmC`Cs>T4N0gC>Y_kW{T0~R*A;jJ}*T25_B zoN+E>JZNdINh-#~42!Fu?BZaj@B5`;C4~&!q&I*Z>khaESC2Xv4IE)R# z3J@Ds4*ECR?-}~e+WPO10EptzFiW%q-V%nAKw4Q@O5l(-NZ>y!7*g5>hm%48kSuWj zf&5q8NxzNC0{dUk|0)@me*|WM&0pSsXF)^%2V{OQETFLfVBG^OJ|($${_uik-wg4` zeh#I*01O{!rv5#^00BrtZAoQtRI{f*#sQTC6fn@b(!#!Hd4b|P(GPV4)F}d}Q&=m6 zH5?`_fx@D!B#;N*r|V$v=eCtcwcH_UBOAi{-Z%KsN*M;E5D)tWDwXV{>5se~R+G3_zL-e?X~e zQ5J^!7WqKHLB1auEWZ7BEUfSfiz9G~|2Ccp-qDfd{%@nHI0C~;zmByK`g4Yt3jfPO(j;K$jswP*HC;%q z&dZd+e`tjkAL0g-$MHA$bTjeQJh(jPzHz0<6GnFGiu(`Gx-Hk0Jj^ zq)Kum0T%nO2Isr3fT;Z}!lieMg;>CKSp{EWv5<2zRoqk&7~26_v{>dJf`5_!zwmGZ zKGRa5cJishpg#V4Dhk+Q>Ko{(sv8Qb z|DMj$(G?hMSR$i7{v*||bzwH zi2N;0qcwLc5H(HEV*DwpMw8=mAOj|$7mK$n<0wr7dIe&(;KlwKdiGn8VGzFq85}{g zsVfjO6~IIKQ`8JeYh{+BXGmaBo?0cBrDm|jxfM;B6^PkVNAS;3HTZA&jx+^b9&892 z+A9n;c^C?!BM&TKf|$r-r6Bu&+doC?U|3pKm!ozF8qu=wTd7(nF9o0n;ASE(jRL@< zm2JiM+P*hE%fSwf{2h~tqEW3h)dR7UrYhc_g&mSs&6b1RlCmyO?`TP_MC^crz)Yy7 z^G{N|-||&pOH|83Z^_oKMD!4-KhJ8SXzH*W&4Xcnt3$VBY*!k1pu@7{uFwRs@>{$m ze}6gHeIF}Zmf|g?wbHPIgKgfQXf|OqCt_LX!D%DL%R+CdTe8y70~)+P5b?`t{e z!LXR$aW~Plv6z*H9`I4fABo;?4Lrjzv<~;OR1ZT_^OXi3(7gk@=}QjhpVLjJwb08_ zJ>>7H9u4!Ah91yE*O5n1offdGx8xVEc(3KRz>}gW(XvzzMH@t2Y2Yo{P2lDa>gg@b zye&)dq-lsR3p*H$*2P$9-~r<+i*^(FN1;c9VOijzX)3fl@K&zoQNaWI>EOsTO(ZMc zXf92wEe||e*K*KXvVY41Zz-*n3Esk-9vp-ZPHUb2?=+nVnh9JMeoMXkl?ETx-&{cN zkFuOFDcTaCr4th%iYs*BBHZHo-&;urgXsaQB z+dpbG1d6tpYgzcwRCZbTVQH@FN`ns=Afv$t=;0sKWq>a^kjp_2PJ?`T=&e-cTXH#p zS)xA)yWd*RzBD|uEbL%#nuEL2R1a`8bpS^b=rADvDD+@hnnahQd9dFcCtI;=kpR$i z|)#3H)aw4{Yi6Cw2H>u-{U@rLM-Z z@RO#smn#lF(0BsK0q}ud=h6bZ72jW9TGh84?OU2;T^4vtgWD?&JZj4a*w01q{+MBE z7?x(`mjfOQMN`;ip$C&%sY9K>wCv(IHFbXP&zV?!sU3Ez+X=LJiyxmXt$bVY4Ik{cI_#L=nxI{B2UeQy zQPIPIEgv}G3G^ENn6?i~17bO*^Ec;-R;un%`wUd{sFoA+$AGtF&6We+l4)6%;RH7h zqJGS{vQ$q6_&63q>x(YSR{s9>C=_rfF+k6k_SmAzg&O+r_s{sfy<9+iX#gw-YuN7% zjDBD6y8_Xs4ch*Hw84#QX!|39ySKoQG}$auwP|g@%0gS;)de`u{&zmY{o`~Swloa4 zEbU%$GnR?>f6J8dueKojzLnBKWAV>haQ)*}PQSB*6HN(dn~iC@;5^AopDfTqe_@<| zAT$EE%c8X;)P2jSA^%A9&qZ4h0<|3f8+R8|rG5box}cx~3N%l@qd33UI{m)7fwg_f zA6ZV-|G#VBs-K`+8cAGM1NVOdxup*ymxJ6A(XwpT(pEextBLwq>6WI#Ry=Y`1`yBb`6HnoGm6D_-+}bA}e>xg7A|zvr;PVSfU6OJ!U6;4K-6 zWr6p5y>sC3&p$x(XiG&_K6XnBYnO%H64kPrJowVk^MA?NT)|_CD!`dtc9j1&M->;o z;#rv5{$n~@-*=2!R{f{7R?DjXOAFusOSK=I&iQXWabm$|09JF+)+PKo;4PV<<$(A7 z!@K37_un!f@;`(gb*mfT`{O_9JCNVns0a?H`EJVsZ;5K9soq~VD*9t|kCxG8X&(Bw zz+2joaixI=wsnj934_yVG?A=$r*G*C@a2HFv{Bo#6z}``=amK?un6`~#18gbJ8t|g zcr<(k5Rfa8W`fYU0iU9Ipgi-)M{11H@(5-eSS^Rgi@ z46s;B4m`&Dd#uHo{e|RyIL@AW2+~5RftrQ_BapTXu)@m;Pr(5XiXOm`+zxmO1UOq) zp4Wv}QDGBs2b|H4$2oy_Buo2EFgO|pk%EA?a&l1GvDy$ISPBR>P@s}5MudNls48U& ztSN(IkSKs!5`{ubqY=OjRvL+bAYV z`7?uRxDu(y=7NhDAaJNI82VGf0Bc$fsR{ohXKK1w1o#J}hme9{!O}@0&`69F`Zp3r zeot71Ij8-ln7PWk|>tD)=SSmKz6b46PKxuRl~axtnk1YY(OB%g_>so%kP=_ zMaDfSKy@&sxBv?j!T-Kz70eMR1Oup{9nKm!pm71CpK^u%o-0+uA5zy^%-X)it0DBq z^G2Z{Cn)u7y`Q*&f>^ALDk>xoQ=lSBVgae3VJJx$3I#!+fZ73IfW)9AQ5b0;s{}_1 z-UX@wo|dSF2N77{3T7S5ngLWBPqd}jL9kFA9B{~_hbh2-Dvuvz0zR8TX-9aI<>V9; zpukD6;A#=52Fb-qL19sC821FNW}*ZBR{c_!fVx4;{ZF#^Ps;wCRGCO5QOFQ#Re&nH zP(V3=nFW7n7##Q?g9ZLKgQ_^<@z($NRuwqY5;)_L3<2wn0aVq6O;im51pr3M7E(8aL14f^DBuGiTy+nMCU9~u zaLAw>RC6I7wZa1r)OZV(PSX$$a9AV(&&dS2!Yu%{FyIpsYN6m3V0>U%H27o$qrO8e zP#YOh)2F@yk_2q7l_8#D3I(h!)CliEfoeGchhVBMT(r!fhx9D%@m63O8cqP^0uwFp zmRgS#fIp}K3CuJ^3aHBjr+*X?wQhqa;zIQacq_aX(S`(Y)gl6>n_x=>ZfU0jYpKa; zsB36QNnxa=q|j=>6*vhOt`6KIfgg6^icpr4LZE>k5QcyQKOoN14}1nZKsZ2)1_Hrw zG#D4S0mG;?;4{D&xk0)y)P?Ogi*P?A(B0i~rT3tqv}g4qBh1cp(iu_!I7L}+1P zQ5NHX#afai7`9kE8ZB6KG{_S~6}*CJfN{Vd$On9;iV3Kei$y)4rDjCZCRyPqz-hQ@ zI0{Y&=M2;oDN_s<@Cc~7j{vSP3|dke1=v3n)qH{PV89a^DG4gqUrievg^`4T))EUe zTyQfe%oG8~prt`Rzz^gHN5CYdkq`g?@BsxH7X;?l%n*R-0kjdwKgbKzC?M-pn{ES` zNNTxK` zP*v58_7V(RY(kU)c~LEciXo68L*O4(HC2Fi5oj}vA%LF&U3f4B%>-al_ds<4i)KYJ zMMz^L5lA$(;gOa?0}T#b5($VBg~bA{joDK3piLk;EO4co?eBR6Gxa?i3$}9k*`Oi< zmqJLwkyr>q8UPE0h5&&WX=%Wtp|w%}n28@;hF>(4i!CD(gGB$>!o?W35L+s@`!*QA zNZ6ppWGk(@`Gmg`SBvt-`%0XvdTu63XLLWqhHyW+!p(QQ%{Q7;3+u95DgOC~>%J!0 zW6eS>buG+sJ9ApZ?$-K^`+ghan<;#s{+{??)4LWw6VJMma%XO2yqx}Cn>Hr(NkeRO`NxxA0LuL&v#bMWyvoyDo~&v87)&B?Yo zQ_zBQ(ROt?l~Fgxc1pTE5G(L}l$F10=bA`NnqJ!RJ74kJLr$#AFg$E`HeW)V-58@2 zZOSe~i68jzXz<+&wZ7R}hC_`X1$|DLGe!9j0v-lc>lN5d=hw(!R+*e0+_i>7P}gHq z#amV(iel|OK*O3X9*nj|qO}`JhHsl@tqnWeqQ0;9`O%uaZ4VN+JCxk-+c67sPU4A= zc;egHO7V1Xu$_`yvrQ&x)n^m0bnZJ}rq-#RI-@P97UTGMTVl!B^DG zm@v+#-pH>;mwk`eHBRJx5@0-(eCpwG(tL0Q++%|XerLuxhI8w$537HAV)W^3Rn5^< z8InP2eb4qTf_`5>YWm&7Z3m)t?~>}Qx@)H#a*lb7WKZq)JTl5bY=0AS)7>w%%D&S< zlevA~b=`-@Q;N7%YqRFe_aFY+pp-j2o%`{d607~JhVLCT-8Q}H%a6Z$OQgTMA;z6Q zY?>&)(@Kv=^pvbmOQ)BVC-d3Y)$8QWXs5eRn1>C@8(+2cQNoP%dIy-w-Hcr0*$_XD z*?tf=y8+Ao`dMtg(s6H>ljqmleo5W2NiHoef@qhrb}amT>w&dWK3&eoY*Z6;vNpYf z8n$oSG3mS?iyRkjGKQUCtWsacP?L2k1FC|wnaXY6^VOd(U>qfQA}#GpYUsfcnA_?qK^rbKq-T6lrDH>{eYv)LX6z2UfC2X4;@GkEf|f7Ced0AW z$1j+isk&HDBOpk!@ykoNgv9AX9y{C0 zRIF~tr0Copk5OYXZ)z&qXu{1+YKe`z^r@`nVqo4Lq5da&$1rTo0`ikz{rLMo-ixsx z!#vs(*0^PCT0!oZ$nm1Q$bz_|JVM8&^y~X}lE;N3baio7M(!>($dSpV*^mUu2SNH26><;=Dw$)ty6Y+6ig zI#u{KesiA_dk{AiNcYUWfyzUyZX?a3^#7sZ}QJiIN6tu>)Sj(@ej z_kC34ohI?mH=?BbkKR!%%h9{kqrLh~mp??~L$}2M-?iE3t0EzUOXTz+D9r6YtGh_c5@RlSY?I%& zQw(aIQkf;^`Vb>9XnVN6YloATr^(?x^6;mT+>%jor*j~j$Ag$IH}%rLp4`QjY{e?E2hug zQ;CsM%iUwIeiyFNdB(prZLzLtcZ4B!e2*ifO23H8BwONm_7I! z#--q@Eym6IMebP3+onrmpH8`Z>IbxZx$vO1CpDs4-FJsW;oNOM%x&B9BUeoG=Dds! zW~3#T+ux9|Xq+*hQrTeATmyORydg?S*=+hFYW8GpBGkm%YjWN0|gBWoFK zENp~{yD$}RF?v)GoxJ;NYt_>Z*oa*XPjl^#GhAVI_sjR3c)I4W@Z94RA=iACV*@^C zo9$ldK7P?8vUTR{1E=OlKwXgB@s_5Cb|&l)DweCv3(+a5=Xf3#yW^_l>ZFu5(O|L) z(wpD^#C=&C*Vv02FEd__jdhs8yHuX;4nKd@ca6KbrDCF>q0LE8*!}X-&Slkyxk*qBUR^kIK5&=3C|9RYt|KW>xY9hIdsE_YbGLTtyQmGiJc<9 z$P|$=5!_zI9(lNWBc7QT0a+g@(8_LC-USn962F)yFmYK)Exb&@Gct&<`)fANQ*Gnj zR*t5wiC$~BZ_&uJli;=KM_rN~>}6*1j*(?#5mGc)R1fs`=#F7H*j?&l6wgokg_-O93f75eSy$ewWAEu(GEt9DwdU83`F(Lj8H#~Q!& z)b?k77XHoabH2Rn`6N=uW3dfESc%*A)iSG$LqbPl)E)9R2k>F2Iryx+ss^%lP(%f5@z+dc2U1JU_v%pfEXKz|4OzH3fl` zIdcrobc*!@-&3Q4kgV1B*-6)eIQw~;UdRNU{CHpLlw0Dg`B~FT3X#0g@N`x1!!GRRP4n_=wtN`>a+4S06D|Hh{+{TR_x?|tFArsZ zcJ81vsT?*^_Y_UCeL6)++T2%r-L$L8r0dp^VgZGo0JU4_7lJ|N+8tt-*Cua2gX*H# z@wKgg7#OJUno2sKJaubR+x*s{*AfsC*OLbV6JCpZU!`kul=ep zM2LTOBRKf=#U|@*SCe*IpLKz#F`tAr*r?oKe^kGbQ=lSQ=Vo!@iFI|1`d{C^PE3s2R&1+c+g7E5if!AdxMJJ3ZQHKcwyiI9PIupPNB6y>-}~Jj_r=*G z+1YcinLL&MoO7*}=b8Usb@-^Um2J<^^fSX5Rf$`B6CKsikR8n{B0W*73DB0Z9ta$b zS}b3qdzGh1g5%hmtf#;&?A~AHlS|l>fgGx|E;^NR+(nb^P4SW7xqeZr^tT1kD$1lw zu3R6Ehdp~YqBJtu=`l7_4b#LT(%gpSo2xqHUh>Cxg92C>+L_A=jY=CG*)?huUw~bg zd83E|Z@WEvHn3Aq87dohj~jhbD4br5&p%mJHN0&lQ68{~)%bkZvnR{H?g*#X>*x;r zOzELFf%p{)#7Ma`B`wn{t2RDbhA$B{(B_p16?V@r;YYP3U%Bz8YpiI?QB!j9MnT(y zL^3_Z-T@?amO7~RmHXB4&d^25-pZv_~SR-zeL5$!wF()kR!7IJcP%3Rt$)QX}> zrW_FrX>roQI16#arVR~JP{dq_e!w|vBGY!HBz?%^T9?3NJuA3{#U42`@rx(fW0m30 z#3tSH{-Bl7l*+p|$W-bMHM z5Yqbw*2hX(B8gv8pg2k~(;WIK(hF}4!|?^Z;1VSVjmM(Gf-*kYn?c(KSr~H*1D4tP zSHj+kHU()=oGGKQCMOzRp74p|40$2M@!R1IA5_ovURVj&QG3@okB5k%|IA5IWQxim z?y$%*okfX=U@wDGKvtlFenM;S8ZkJgLx}0C?lb1!V@69fm;xHo>H;$)4lrl2Cyyby z;VQ|RE)prvRcwI&dYOx|DY}{^s-C5KV?2;93+UMmBuLutX1){E(H3W=4NncL*Q6yT zxmMTyWG|gTHH|s#mrLblZdR&)6se~guQB7&>O(}k**Z&ab{Gp!je=7s73r!E(wk%m z$$|)lXb-uGSK-^6cCs7=oThvx6cU{fpT?zI1${}HDWId|M-I|0l(@GvEhBWLu>fL? zzTFJvvsT-V1VU)<@)a7f{i1(6iyIeEeV{g3w?iIF1sZjK9h41I+^-lslwcW6{ED!U zB*Df|M)3$NslF^cPL70_5N5H^AVd}17H5af8xyq-ox~j1nHkxR;Enr^pU?%Em7hD| zMlN~tU?5)AVa+zUW8=q#d&OkL3E2a^!o5O@l27xepidW3r{2NnCIGnNZoGll&}vI+hQ$HN<_u@!W7E`8ltKXi9N>E^S5g_LL%oG2D_a~hVXtT-f)KeEFqVfxzVFY& z9Qk=O4!u>c^>I}{n}bxg%tDCv2^se$%judkKypAs#W}16Kr3e==N~~wCNvkT4tiPJ z7dbbEpjMfMouN1VM}Y~gDlU85*6`nZ3d*k-Q&R4Z6*x+Kt=3ps5yI!kLPAurN$TY; z>;N!fY^6+~FARWv$wO^DB$BlklrUw{!KdsEpPAkRg1`M_N^3Ge6i!MpidRi^Mg<6> zqN|%zMXySkzFAo2V$jfWyIB*@7?;C&$OfM@L78hld9T2mAZ`dwYAkySqC(JKNjaTU%S3 zo0}UO8|&-qYinz(tE($3E6dBvOG`_Oi;D{j3-j~yKY#w5o12@Rot>GPnVz1WnwpxN zoSc}L7#|-W8yg!P9UU1N86F-U8X6iL92^)J=+9?7?d|F5>F)0C>gww3?Cj|1 zXm4+CYinz5ZEb03X>M+AYHDh1Y;0&~sIRZDtE;Q6t*xo4sjjZBs;a82tgNW0C@(KB zD=RB4EiEZ2DK0K9Dk>^0EG#G}$j{Hu%gf8n&CSWl$j%*@EhNKa2sOG`^l zO-)HjNls2qN=iyhOiV~fh>wqti;Ihmjg5(kiH?qrii(PijEsng2oDbr3kwSk4Gjqi z2@Vbp3JMAg3=9Ye`0?Y1zrVkqpP#RSWoE#k;9UL6&?d|RC>}+jqZES3;t*x!BtSl`pEi5d|&CSis%uG#9O-xLT zjg5_rj0_D84L*un`uci$db+y0IyySq+S*!LTAG@g8X6kv>gsB0YO1QLDk>_<%F0Sg zN{Wh#-@biQP*9MUmzR^1la-bI`t_@fjLerWU!Tz zOiWB4wPl8n{a+t8MLIfKT3Q+!8ft24Dk>^UO3KflKT}Xpkdu>>k&%&-l9G^+5EBy< z5fKp*5)u#)d~CYI!^6YH#l^wF!N$hM!otGD#KgeBKu1SMLqkJFMMXhDK}JSKLPGlV z=@TL%A_4*eJUl!c92_hxEDQ_`G&D366ci*RBm@KmI5;>M7#JuhC5D*|B z;73vN?-$Hp%c*~>AAY3y|CT8KkE)gbh05)(!r@<%-2x`|c3%x_1+6Tstt@|43fcZp z7W_+n_!sryua#RNL5086ZN&_J?OXmRX3%}q%6^qDKQi$jWnB|TgWt;ACLjA6Y)$n3 zTF<3t`0yywe$lZopjG}`BK)_K-tX!7zm)T6e=8^8voo{);XJYMeg*)?|FHwY06_m& zH5cH089)%=Lq}ks4?Tf_e+l~`@2|%%rNO|!A;3R$|9FD@7=({ufc_W}nBSg0zQX@% zd_3M)0YCtp-#Y=IApl2#+W-L&0p5E7rU8Bp4j?e-Z-IV$f`SAG1Of&D1%rS__!u`} z&|k-(gMRPuaRe2OURE9nSuQH;qtCCHh@Vi)6PXLoP^;PB|; z^6L8L_U``S@#%dD0OHqd;|0jLz;XM*&T$W8>##ULWP}}-YRh6X_~*<2PzU=nh#e;w zTl>=~d%*X}jBB)H3E8AGCO5!jPgJ))xZaqF<(A=l35^)}v2C~rC0hO37r0|edEYDp zQ)_#wvM+G{aYbE|)pcwfsEP&P0>iT#2P&$mIM9D~`9DIJoLo1OkAZYHI!Q>^Lg#L8 z(0{pde7kB(?$B*2dgwcK-~AatMz=J%D7LCP3uD&Yymg{V%CGZu$9r(97-y= zhj-y%x2odR2f59nb@jmZUqCbLciDuyapgYyGNyhR;LDAxR#KER+1#AW4gKef|C>aZ zTE-pIkj9M=To5&^&#jDb<;H_MF6ao=(WEZVr|8{b0e_UUvlrnQM@-cis|(2A4i=GoKgbdBoS zX_08L#9u}K^v3qmi1Y6A$)q@j&RT@%FvXoQ@#z|jy-T@Ix*t0lzl;EONM=D6obaUl zWB}m-#erayJ@O5~U^A2}!j1+gH-s(CpB?|-l7~aIhMzP*wC)aVF(alyv<)tt<|OxI zdW5*fDQD`|s(QV~uBE%cGA|>9C&N+sPD-@Wq~M$sr|tH+YCu~JBmW${_j6B!@V4js zOeds`@9t_4xfAx)z3<7nKDe&4VtR&)t+A6~MYV`(We)DfNMFYHXMz@j+++!l!`-ck zDxBbthF|o3!PFH6Ct>c)!FiRONl%n+?o0q-pLhYBaB$2Q><|>vRCd(Q(rmU=3dzJ5BaS<=+6mDNCG{;NfZ>65R-AcDbmSd>|)78~MqHhj`poH&suvsOHZ zS#(=mKhdCy`T6nkbkS;oi#WZYvJt8B!SQhG?*4tQ^Rsi;kVo|NeY)ss`~PF+ZNppCw>CovYOlhPW}w6;KqatJ9#t6 z1Yb?rh5X6@XLW+qg>W-a@{a=k{vNnkJJO=?#>!gvlgr}Rg=Ir!^?uC=+_mBzs*R)O z15H7G-|b9Qg3tD0g_-C3{C{Uu!H=j(XfxyER=y5x{s|iCTA+$|jBIYS?r8Eex=)7- zBV9H(^K~8Xlm8=8r~XHxPXCWYo%tV$I{QBo_4ft)-?Vc6={fx0x?cb3sDG~4|Kb_( zpH}$K_4=+8Q-;Xkjh|7wN*yuSXc75?*n_+PE?pZCN6YK8y2AO2S> z{OA4fzgpox?}z`@3jep>5C6)o{auy|)%x!5a%;a|U(=$i&biV%pPLp-QraYVI_KcV zKrVjEBx(*8wfxE?ZvPXRMDUZG2v<9vv^zVa0PAmesOpX`WC1oGIXzoPP3h(Rq7&Nk zw$Pk4=O?pey!Yu&40_)vPEu1Rm@A%rN3&;WznZCY?BuA$%o77D;;c1xCfaJeD!-`c z4CjYh?B@k=9osQt&c3s+6;$pT^A@CrOHyOCNhv0bEYpS-xueVCN%b*|f4=>XHBn#t zoaQ$Kp}V~{Y}u3R&;C5nmm$T;{u-Kh2GzEmLes*<9WcUl+cLo7e5bDDH#2*Vy#l(> z&E4+Y*7SSPYmYmywJmH@#8qQ&D2F>aeYnX)Aj0L!7+jy$AU85P!!^md zMv8%~jJ7=-V#ffYCaY~laYG?fppkwERJmo6- zKAZ8tyd!HL_&pgZlrJJb)lf9 zj?B8J&9WkP=Hz5(xfS>5TCSjqp( zt=*;5^x25zaM+${)EUou$Z>>Tdry6h^ct=Ix0HsyEzkG4jQheI`9?kPVNTRL`Y`gI zR`s%lfa+q)u5DVEr>2}LJR?+Bx`Z~(a;X#Gni4rN!H+rmy2Yt3vaL#@b7 z{@8)m)Wb6GRHkgUt?0Hnp^m3P?ylhHk>>2vs^p(t{*Tb5q~3D;W4JWe7i5fdox8b@ z9o&hk8jM(6D^os3AMeC-(Slb8r*Eym>JAOok?q6@^D?D%!ut+oLC92ud+Tm+prLQ- z{b$C#vSyg~REklR&P{*4cq#GA_+= zLk6qHmiySBAO9rdh?_X};qPV+(A`FNX^j{O56_z!3`zcb2y2kHFP{logd z0(JWjsbjyuLw}@${pKPN_#+YQ7Y6J%INFCl zyub0=X!Ue{`%WwC-@o$@5&ytp`gbtA|AM{bHyGPr{UyIm9~K%`Ms{}m4+tF%^Ka9K zg@&E!1JXpp%=Vv7ANt=hbAOpX%>PSJz<>L#KVVY7QS0bGpiCc{{HK$G;VT_LceXu^ z$GtYN|BWsU5+k=A5-1TcG`BpkB&Z$|FgFpXh9Dy_w%Yfj)8X~EfA#z19~)DDY)t>L zG4sd9>>nF*e{B5xV`Ki0jsJJz{G)5tA6%yY=_>mh(DK98_BZq^12gk)P}{%9lK#cs z_D`-m21aIf=D)4H-%r55GcW%Neftl+ZvSo>iUpl0nJ6fTqSCnPncRKLG-2TfQ2_<* zivQ*fFs*A0Dy*P@3W%Zru>}NZU?a&yGceeggCPVP>>7Izs>UP)D+|mY)Y1dg+j>dyy~no(%T)FmsYMXfmMB=;nuM-2Ar9f|uwv1r#Dg^bk37Mnp zTqa3}UQjOZ4Nx7L+mB_JdnlyV(Gs;M5~Se}coFx+113wPh^(%aMN@e|c z^Lo;py~JM+C;~(*gh{aZY_T1YyVzyCAT25re}K+w-*Pk_0Ml)wCCY=0aWH9u!(z`} z!tp!6wZ^o0@0@-OIL2N5+6o*#M7H-0k7_yKKA$d`8Hbx!zsD+yX;kGph3YcFV2@13xwL~IsJSipFltqOVMK*Njp3EX zozdAU=Dt?V&U*D^V=nV1Ui~R&^^`}21@=JL45~{lAu#xhN(& z2SIoUDx;5eDbH0szoWM^GSnmkKL@?QQ_els=;1C$yn*YSS*ShR?KC4~51AW-V5-2% zBVHq2`>O)qNZUr46_2E=!DUO9YamD@kO~w~ zez*8B)6?AisaycHytkXOLFB<49DCq-;08lKuG7I#=F}&RaT9(~PfX`s7IwYT)%Kh6 z-hF`)?KkVlhv$f!d@z}uTjM@>(YGko@pIXY%})91_5G8X_Z28{InSj?a{vfg84HY}jj-R{e}0CTeQ$ z&Y6o^&${3!+E~P&cPy&|L^Q?_SkH|nKyJg(gtJ(6hs-UTwHdQqss&`oAf>jj5)F*z zLG`ltJ$PMYS*6y&0&Iq$wGVNN zdk?y<>2srWTo9h4*0l~7DdD{*%D&y;uN$0+*yZ>ajRYF0ph^rufg!`PP~uXGjn9RV z;{+aen@}7@Q3g!nuxA#;lC3Io0Ma9INyeqH)FM3lJaYBy9$ z7@@ubQzTx%ND$8H$isD;`<-q^F!nH1pFVZNeABD%6Iji#qrjyeo6dDz z7-Nz+9}Uy})S-DS|M)dd+>HYHjnrGq@pZ3a78&qa*Z{5r7)ye{zIL+6)@tqsQHl9 zTgK~I2tSz2TGK|7C@s{BiOVDjOyt5J6h$?hSZm)$F%e2S`Q1Pon;SP>TR!zkvuM@BFBxC*2~_dRjoajPyoW z?B945piatzpZ-EmK$6A2^|_>n@ zeKN(9Nrp2{{EZ`;CSF)`1A)tG98CKC_jIj&luywKP6_0P;xRSu7Vm)EiVmSIQ5Kn{ z`)cIU=j{Yd;29gLpVT2OJke@nf~P~rd?=kUT>>(lS+I2k=787`uQLkZ93mUgP1Cg6 z;c_>pE)+@+jI41!*=}%Y;;)|TbW4~@eo_NRk-g}IN~rHtB;iheWEyc|Z1l_u;9#kZ zPc5#nT97c9p^&&-V(SM8tK~mKCi&6`Yl|Bkn&T=&@E!e;_0xcHQCNMnZx-s{477@0 z2{h4IWWrVl0T1^Zbu|8W@?BXtelc{5!A{jI0c3&4U4SCQk^pQ&(iUlKs+|8j3 zyxqWtEn8@f!skO-h6+7NDi%xDj3tE4@2y@XUSkdC4Ed5zE$}g1-4);IBhsR9u*ATS z-5mjEh~8GDUXYRJI3kKO*bjP18Q3#eh?j5|%-f$pkUDRF;#kXvdfm3d$JXpj63LvL ziB3E-84Tvvd49kefhshwC>H90RPB)~k+oqox~texqo{72Jo@GVj#~M&dOWx>AK+-V zUY4?#2%5V4_UqgV7VS;%~az$=1#cVGdK=3s2F0Z+RntP_fLj@ zzgaj<(W@+$;61DCu#g6WJ}%dsz@|<%D-MikRFpBW%2bUb5lU4m!-nSM!R2LVXZ|Tz zJdlJ}Ow4{pR*)y6MLnygI$};2mI`aWcJ4n@RnF{4B?+5AooMi!sR@Eq2SI(YuLpy$Dpc zC?*3F=@Qt|wW%Oj$QmN!3}LMb+1>52xi#eFy^+z8LLe>iF&d-Nqa?tGXwqG0yZmQ% z7oi4=Lc1w4r*4Oc_Z~4M<_sGc?FW}wMUsKg;}n;a;7j7)t)Yq$c0buXe1pMpzAn_t zMx6upQb+o{!4v=4I3Fk$@6^}qUD72^MA(63^XNx@i+6n$zdj=1RApf%b&C&>1cE*a z#3aO^ZooH0Sy?_}8}%;#AVL~HS>Iq+JawZKY1J>)=Mgvw+|WGy`ktS*7G_GFh#E*wPVq!s4w zGPd=Fd%i8|CEOca_#I5vYu7NQG8K5oVw#%?Zz7abzA>k>BV>+0qojr@Uz5OUO?ti^ zb@H61h{H{({!9|0-CF`)LVLjV*q$uL{=L&tHNCN4b{JHfpWrR_%707$KN z9Mx!eyswqxc+B-dEE(`)xdS%5bfRI`MZF0;?pvykJ^%3I<-=JArY&A_1!o3ryBVq z7=w4cf{6YM*0%Ckr?oWKO@mK${UIy?zPzF@r(;StOO{Tc2|OBzH`Qr|)nQgF?{(Dg zTH-x-lV|A@3Krb}jlp4_*dwT$;uB8j5V6qq(Z)YbI)??!^Ix8D4N>)u@#C^vQ-bj7 zP6j-XE-iXJQe`k1FApEC6YFvAqkfD@DkyA*E1zU%y}{x>jkKUv9v?yTNshV)J>nB@ zP=dCJp(S$pE~GTlZrcj>pli-n422I30lSuxL@@Ie#YXoV!T&+g_@fUV zT!RI?#11E=XAsq88Xj9z;hNjQ(&d=tHB6c*T9kDjU1_}*woRCSq46zH{H!f0r^0gD zpdi9()lzlYytoyy{4ycywt&r$;XpZNw|OL7bDbLZZ9?z~^mNAOY)A4AZ(A`@*HmZe9F`kH~<3l2nv6{iuJ z6q3TkjugAtQS{hD3JMX|be=$0=r6cbF;I}xMn5xv9Hvl!GpcfmTG`wp?62CI{)n~} z|C&}{^9?NECcdTS7JB5y2-|-CA;ejnJ|K+)wB$zj^O%TvP;B|L09om9m(8<%S~dwb z8@lBn60rqiaxJZL86}a&)N$_F+}iZF!{(1b)zT%5DVC<AW9vf>GT zcK;=h<*T`OoE-@Irm(H(UsS*h*>}obm#gk4FOfZn!fUegR4`^tPTwVE0g^x9)0QBr7rV06yj7=EF^Q3MdaNy^xLGfxFIpN-Cj1qBi84#|5zSnmtHcC*&MwVZ@62{` zlyC#+IU4twz{`WU-G)9j8_`j{z3MPyRefBTlUl1Uyyjcrkm@Jic<-=+wjtR_$g3hWPBA}2vLi^wCO~G z(TFe;Q+wn5aW)_U3!A_jwaurerFS4aD&D`WZb;c50}`4`T{zmU_VgKcApLA;^q@%l zq+0iRWzFevy_@}L{gWa>Sj7N?7H1N$9t)@Logd_kg8Rlh4ALS`NCNsLbve2-?!`BT z9|})$lhwm4;QrY8WWH1ZixFBdiTg!gy+KdC2G<<5KP}`!*TtFJP6M__6Qo~JRgur+ zDEX$+Ek%SM?S=agM+2$QLf(V!*Yd#WC0oJLw<`!n_a_?ZQVrdWPBH;4a%9Hr0k0k9 z#dMJ>Nh3awJoHOPSI^jMeG#QJPV7zHmjj`_<^o@C&85tGy{!#--{pBT&k|nU?7CJH zP#@nj>!i0Dx-H^o-IKU~>#1%vSlPK2)_?awK~rCpO`8itnzb|15PQk}9-=a5(9$V# zL_aNkn-ild-y|z6DfFKA2t5Jral@Tw?ISH`o`j@mcDmDj23!~`QKr1sn*mxX+D%vB!d@s-I?t9)xM&E4?V zTjwY&5oL=M5)Ebi@Fk)Ks`*?8g!-wq!x8`+n{=k@<4w306NX*k1RE6+4UU_;7saX|5$U#z)Y0fGcJ^?`H2@%;ImmzG7 z*M!w3hG+&d-UsT`*Hj)uXn?J323AQWgLAfnI;q@#B2_bCD>F;w~qx{DOPS z0_Iu+iIL+qR1UfvvU>GMJJ31M#z#H z>WU&XO{7F@4o-;{qMeG%KFGS)OQtcgls0i4ot;cMBxp!VvAq9ThDDHUy4u!pZ4;iF ztkQAK>E>xxVRc@2*Kp_gu4F^?MuhHGf??D(>PiEC$HCdc;PcJiBzemr+pZ;z)*{ZS zM*~m7{SCaP9(%=wbxd2guIzEb1qC8Huv0Nas9z=xP&j1H3=WLymr;(LX4GbgL;q3> zfMnu;{NS$qdwuURGV7g}zW#6%_fWq1$iqiQ`$=sE@E_LvxuE&sFjtGP!07}RzCv`i z7zX_i2P?(C9x!d6;hbjId*je}36UaHPbTYu(q9WH0zn`e=6v0B+4xWUeCz|nPb;}^xT5k5^(G9M4bbj=oHEUKCF zVG`EJgPZt%$+J!>ea43R(wwwAG+mFHVP+u_DfeW__{iF{iW|Eg^X#T`6SPFb)%VUf zP}ZyK65#|lvap7@!Umq=+ZAw@jK zbP^e92!DnbkjC#sPXm2y@E}LXD$%*mFGDA>DU9Mfy*EK$JCVjq*sYQeZ2uJ1mZ*z3 zCPzaDg=DMmxPdYFlXqh(K&@P=sRuUhMtaEl2VxWz5|A6lDnoj#&ICtIXx9i}sURQa z3WR`LRwCmZta^8By&`sx{;3d#lGXSIFKUS48RDg%M-*`rbG2h=qKY7-zv3pK-TCK) zP0^Y#D96d2H+Lr%HTH!w=>lu6=iG+dH;~oVQ}Zb%{Z&_BQzd%QF8EPN337W-g$YE9 zW$jeCJOwE*+(=B+GA7BATHAFj9hD|^GM9)rU8aMtbcF~hJ&(!7H?P7gzEy5j-fZkU zC^S6b1%Z|eZmBKMtYjN8bov{1NbL#oOk#a-pMdT^#T#r#qz6(#Lq?-{_c?2H73UyO zP<_+k=6`KO9sNq>`bp*qf86y)k=bRJyZiQvpCob)*~NJ=mxj+O@QksS^$a{*^)pr* z!^X&%&*fZgqx=X5o3Z(+@v8?kbB!c9HI6#s2!m)0QPB<`@FucM_+RKD%{HOm1Fj(PZRji1o0i!L|O-c$q?Nin|@i&ZlFV#!+;qSw*jShx5ftt z&^j3GBN@5eY8k3xawBt?AezQt#1lwBA^8~|h)z389+>SqW zj(~N5u0QzPVRi*(Cx#Tpy`6$i6Djy$4BsOv-bxdg0=J3b{|Mzyk9J90_b?{mzWD|g z^SxUG7-zbqY4;LQ%L5BOx@-@XiR3#M?(OOrfBP6G52vTUFw0Cc*xd%FW*OsWcl;2` z#X(&meR=T?Gk)s_o?X;&B{QjpwVdV6Rb>k$4^Q=#F?~!6hnRJr3`Uf_7^~ANZig}I zG8=EB9+quA)|IQ|y)M406gZzD*9~T<-mB)`Z$K=X_&0N281>qms5kmjKw*~vS!gXY z+Q@?&Y25s(h>tdW^3b8Lpc^J&XWz9CM|K|*WpR`u@OitqIU^sg@K+k&r%jtPHyP1^ z27H=Rdrht>#5bk4dxXq3Onldr4|>DpSzC`%2@0|T(u?fadF7}k7m_E8$~;5e66 zt*I}WEI9pfefvd~Wl(c2X4QMTd`|17;*0I+H$Gv}r%q=n+|8RYWoA4))m5WP7oIoP z4FZXI?QmqP2Zwgp;{H$Bs2#l<3@hFJcF3%e{Z&{VPo!J(+OnU1F4XGragS?+!a{{x zE&CEA&>JFZB6NdSLsj@~*opIMfLcQJqanjJ=m|sAyVl{a9yq^{`9}yUJjVfjsv3Q>o#m?zjFbT2 zW#<~HvF-)J3B&*el(P<;L+D+)g^R+Xn8Zuft@FDU@#YXmydr!~d&tBx0FzIv z1G9t0Hze%)I)f~qcnFnlXVPx7m8c)to5G*SZ4;oEME(^Ko<25BMlR2ZQ;DklX-V}h zQ{F{af5!>AQ#v9Ym9~{(=5;`-r)?krvCnVhI4EQ#HiVIDoNDv)MCVvL2g$>eTptPD z)7JN?qw_RL;x_%xL@)yzICoc+1mgE)+4)m=AU=9-4n1nJx;{J-e#PB?-*0E|g5{vl6Hl&H%02 zrdJ-zB?P@YREM{L8+YktW|H~2t}h=%))aRHm^sGwh76T+#w9vFur&mSidD=X23#xNcDKyS5W>nun< zm@wB+%Jw_N`aaKVQzwy1d9u9nb*W<++F>uS6dN%;%oY0N0a^s>xznfHKebzC;#q7+ zxWx0Cmb8d?be1UhPGO4kHYA}UnU&*0SF65C=%qwDlyTWPQ*D##qnTnX?p?!`aKMCg}=L-ZCVGzI|eqZHxs z9UvtqCEmN{0~OY_Z&MQX{zg;|E~*XbQ!?c+S7>H&KZ<3D(EGIQ;N;LzT>e4#)#}@V zzE?|ZK*JJi#kkQ^g{(hzcYgfNCDpDtA*&vSHGL5@HE=prWQG<+T6quSL7?PF1AD^8 za;84f%O8^8aOTA2GN8tTzC3$WyEpXdk*}=UqjEkpWjSrbcW26B(OT3>-_!^a!x+c( zI%8d{>-FNQn+zH60N3hTb2f_Dl(YQR#!WlB6}J`_Hh!C*dkgoknsqWP6&7=x3awk^C9nf8EW+YcRkQC&|3k2M2C*0W8eKo|jgM&U@Wa`% zOrpoSGfo4F(;#@MEmd5B%AF3C#!dF(dlw~CeXnzXI0AUH@Csvd2!!`E!MQGd%Aq&c~PB)K7i$$uH^&T z_1(S>6R5K{J4Jupke(P5wEhvd?iMSgj;^*)?l=YzzQ7r;l$wk0V(@Y;B+eO-Tk545 z4=}t`Y0mt^Qt0Z=M+FCrt5?vh?zG@WdU2} zw(e;I(=LFi7kIfO{=oDONMF-tw%9PN@j|i$Jv-CJ?%$UAMlpvz9Xt(=hgJ!vTSPZR z@x>8*|7*Qsp%=DNirQr0aB z`;e@sIfxssThPNXEYqUGM$0mW=aPu-T1LrsQ)6W`J&oDwl5)q}o?PNhW+6{jha@4E z2p>3qa0_80G}Tu*ewPeQH9CFCEwiehb!v&vTgvjKTFuMJci}q`kwVD&4|t<-_x*%& zsZ}sq49ly*6}sy~w$9<915cc1z$$y;9$LX@TRx62t;kjd_^xljBMsXYc~|U#OwV)M zF1k5WlA}w3ry+;(bkYsu72IF;)1j9<8l7!5ftePB$G=q^#?~THZgXC2J zQ1I&f&g;fC?ynbp;pJ<)q&dxsli32!HT6d>+$B%^wWM;|E_4}lvW+oi5sxjTgMHbj z&A(e`MRgTJgzX50Yk4y#O$|ny_9tK}mqE{sO6PauK)21tlU@;B+fysKn4yhsk1Ded zH}$Hyxm549>Y|{zBs3ZuOz76`HvsHM{^=Y)fsDYxV6<9$JS5n^U~Y-EdTCaorCt;TMXs@j)! z;dLjm1vkFr2Dyo2Afj~EczOUAen#cg@xr?K1m}7wO`GAge7zidc+cv##w}PQFQSzG z=+6;Q%rX_~86Vc6Vf1zCC}BE&*Wc_lp%t_!w1+lB=sSa~PxB*@1O zyZDSBWjqkn-hy1m+3-KE8mALB;T_0SUczoc+Krvf7E0Vk^qx}=7-iR5TrKDGI{Vw{ z7!uzOatreUG+$=R?P9Q6dRT6d>G!W4wAxz>JX!;aK-t~!_B=Z^VDj$Y#2kAo4kbx} zBitGaovvI<2wiCwUlvd_CL36ab0{v{;iXZgJd|EiTnnG|n#Z40kKvUhiXK?~2}s9Q zby{3&0vh(sR${y?Zb(*rcWbIRFT7!(iM31KYu;sJYmn7EJO?gpK@GKW`lv_wnTd#E z<#RSX0u^Y0IFP1P~#KW}cEL#vFqOLIvgyvc*FKE6W2t}awl=lU8bCLwE64s1D`E@ zm<g=%egk3N;;1gc!tD zM*=v8Js@02ZlzFHdYb^20u*U0_~^>~9MYRb^Rp$)1=^kXIaDo$Q}?xp*t<)YjwPy} z0^~L0+!Vfq{&?$Hog+;`iG40gZtC^3y`Y>7gDiP!H$^OYQeu>pes3Ze(GF_1U+e%$ zY~TP1(>#z)czNUCVl1h1q$X=W#BNKavXh@3k(BWqBm`JZmurU+TMNo znhDBheQ!|yk_n=>PQ2htDFEGBO7&{o^3)*9vRMG9ab>>%TGIa0ueP7ykf9S-9LMYvQNuywypPeY4BRH5&0}rG@3b zaaLHE@nGOmo^Et@)?196k!g+1>F|u&+O6}CfKbV-_3aU`H*#5TKCgG-iL_Wy?>QRLeiUk&qn2BKk_C0hYsTYzz6B-xsa}IMUx?Wp> zcfFWsdCiVj0{eqdCw>)+JBiQ0X|=Y2b&Wp=R^sAS>gdE%9izkNHKK(co*=B)RblRi z0hYSZ@$(iHddD9?8P#&#sL=9xHK+Ea!wuv)MGrOyvqFPod z^@ZE&#{1B&4a+SQU!gMG;gr_14`(I_QkIk`QMSU5S?+mds18-j*5ZUF$#74&tGQ*S*Zy^cYMvKdl3{3RKS^BI&nK0`EkxUUeuNW zr4Ypgarzcg$x8lWJ6Lfl_^?|3aFhO7Rurjiu1#4?;+VI^$TwM;$x-O+bgfh&*M7FC z;{Y*E_vieb7jzS@2}C9C*ep;f{|vyB^rk=~w6U@8ls)%S@lb3j9p?o)DCv}I<^bpf z->1dIDqJEywlHv{(K$nY`woE;q_r_BP~O7LIJa*Jzzqg1X;^X}ZQgLrn=C z(cd}QfjrYFkD7+ovfm@YKOr1{ks|MR%Uvynof)|x)`7BHrfY|ABHK(c_NngBp*Y+R zMHl6vys&@)ypc>y2#U5LE^-ax402`AorL9z40A|sD@a(HL11FhUSW+vKGY}q841jE z+&znJuI{I?22Y=sguU;$)sP!cJofzgLZ4yl1~pYHxM`%4IbK_WJzYIw4Cp}6nKA-` z8(xZJ#tw-k31l~->LX>_)hyuc8C0;CuK&v1)Q==Hm06M09(Dy0ptp|s7M+7+9O z!}xf}DXkk!{>rG{B4Q-s9dJrewRFSawvwv;%@_nEEz>H##dsfo;uT5SiFSX$GLL_n z$tg{CN#`k%3f^!MD^VTOJTsz>WFiGL?ulRDMu#t;8LFrQb$`0&nK&_Qo~;r5 z1WW9Eb*=v*5i`qp00r-507~d#8|9@dhk#L8V&1H9fzPrd=lBtVaQ>y=V`%{MTvqswIuzI#VAAGD!sfo1;oe$-E8C88 zofC&UbidtNVaY<%w7HhR4WQ{>$q0xF&m_X&-nSAi>jq`=|55f0(3L&Sz7um|CllMY zCo{2a+qNe*C$^1=ZQHhOC+}pw|9A1$z3Z))wfb~dbyam$?cIG&*6!WEA?LZgC-mP! zXkfhe_B+0{h;ydM{rZJ4IJAf2rj0QM$+t>DfKyZ%q~THbi%y_5(D$=oAzj?=3;u|iAS_?o67i(G zlrw`tTNjgLjE`RoD&Tc3ZzQwsctW|>EFbWVr!2dLlyy-&_HI`Df;J>o35?v2qc`!4 zbvRQdC(b87%qTTn5Jm}p9KTdO(FpseV*i>hxP18PRacJU>8DP-UgtgalJQ#ME2J|X zI58{w?V>G1h?i+SL4D2>@^mJ{gFD8@`lt?9Uyk_3DDPyV?>8~urbhQ_#fycQoMLhbfNbO2`61{#maD zJ5h7--Crvj`Qi1Z*CZ0XcuK@G^u!=UIlxXhSSW@KH7f9!2NPY!Jw+;WH{Q)FW=?Xy zm0p7%C{9Cgyj~0F|4^>&wm%QWQ<{GRd@EER_de#jsQ2U1?tmG}L$?#SF1MOd$GqE@ zVifRKaU3I|0mUtinRb`wp@m}b^Kw;1u2lX}9ZOR_L6r~Pwf#t8EE?^ntrULLM6CTo zqxXtPog9=d%OgT@DA$V^TJbA7kJ5S@YTw%u-ua65`%1aKp|_SgcYx-604KN9T4sG1m)=fo60EYh*|@~P>cde@yInduBSQD`GWz{IS2ZO< zm~-X0B}7b|6C9>7V(tAr@_NV6=v1UmIO(}R5}PLn5;2~=6PJF)wpg?wpiDkIo}4}Q z**>ZKva^yD_!nL2?6zI;N@G9Z%xtq~rFA1y{it9&glOU(5ry=nLi3QBbK6vz&`nZ} z)lDWcv-jD=*C-a0*w(@jle-kZ!P@RaW{mYXIRldiRX2ZmL0Z?pj#7yYl+FxX z)e%;J4~^W8;&@b=M=I-~dfz=Gdi8}B6ltH^ioA1)xaX_iYqMKY(&K7GRgEI-Vc?dk zNz53f^(Y~`2wNkQ*a#yFWOc*C3u z)~xv3{fK7A-o*{s2H>CThkmL;7Q^dWecT1C0ZX$9I8U$9{PzH3Ep@lf6MOC>Wriqm z3jk2dxp^-2)@`Qy{7J?{l!qq4k+dW3{cX^UyM$M%EzMoL#qWm7`llPty^&cqMdf&Qx*dJXxytz9(JJ zGF)&Lp7&ocHcJl=XKGjw;*Y-9UA%OOI$?`Y2Nkr*ZEu^VdvjzUA5bm|_C}?T-}YI= zXC+iU>E9M)#12kO1k`|-cpGe7Y=0MfQuIXKb?%L;Ac!0iSJRGri?CW|DY)Y%!x*6M z@$S{@nXMm}*(=uHZ~{9U=q_u2ci9iKz7pYP`NaldNV?r*qw>-&x3zNQDV;|9uutB9 zb5(t_)ZRN5>q4!@`vWD6E#QtPu8#DIrxM4IHWY8t+Xipi1yq`E>{H+Dd%kX9Z1m^=D;uc)124avbDZU^pli4dxUcm z&PqwfnmGYMR<1N{9ae>5V5wB5w2!#sjEnXvjoZ{Da<#*6;1p!LN1W|_F)p2XDsI!l5%Dez>-a12fa0TG;r$ycM- zyZ`o@V3Lc-G^9`Alt)y6SPokmSEBQ-zA6eHlULi~SGbEN@!FX7Q}csfsa;c2&_QXP z6Kv{(cOS2tQ!$c8K;p0)7EGPNi&Q21Mno>J2rad|$-l9mpr zxqPxry!LCmrufZbn_k6vpj_OawRnW5la7V2Ynb>ASqtxG&ewxne*#I2zsbITgNPTZ z%8gEKmPAnC*)5Q(CVxxpu=q_VqK1|)s}{U^&fvhS-$it`Q9i3b*8g?ej}>rq(}p*~pcy%{1^Q!t+iMu%ji0c_}x zx0^&T0i&3D>*~45d>S_rnjgIFcyoba2^-+}q+)e3ax~~GA`w`gSk6?^b43HgbuRjY zSEaFPWh8Y!MqxBcbjH8iO0X5cW0~#Bv*Wb{iq`EtcIU#(9PdFt08JH} z9=q%{5SdjDM*C{7Y>MIXvNf#CY5jS5cJjMcm@iqW2KvzIldCU{9bE|nLyug(XvNLa z!PWMjY_Aa*4*_e~%UbKW%A)pu#j3~t)_$aPNw3zooI;v)J_JT&DYF1^cBQr{Qlu3t zS$3t=x#c@91jmjIyzqtHN&>P5oEAP@|4-K#hD93xMEa1;j(E?I?8e!e!K)3s zX5-vu2b%6m*>4eSSwvnEh+$5DL#oTK6k$tbRm7-xh}bt6XnWg740!bC;QJE;EB3r$ zWNDpW!CYpadJZnllZ1IQBRu^VM?a9`ZZ0Va@Y2CGYG9;eyeA(G`DiY&hz2AHrVvCB`pjbg!Id0;RMz#6rP z!O>|56WOO3tf&wLI|p<&=@3m%i(o8gyqbtYWccnFBJ=<>}zT4HYjubmJtu-}Km34lY*0-w(r@d1?e&*8+f@vmFI?S{m2JZMePdAIVpjmHVa0QKKHzUV>*q@JaFG=dB||zu)N?qcr}J2B{qcBtagK^ zJVM+yRzBiLkes2FAbUWO*&*Vn5$r+{Y7!=Hq^FhGs)ZhDPPh&umqgk{H4j2fNlhRb zs;navv%Ij~j>{tn`9k0V6r`r(iXq?Nr%P|zl8 z!e8mwEougthLPrGR}^MDtnx@vtus&=b7;i2o_2fh9QX_TY$H*u7W3|QNC%hx^OSv_ zEnm;me%Y+wQj?@x)RL*X&2xTh4%sBJGh-wZH)tOhj7J=XQ6(43MDZe-HR{5iAqd#x z5~0?aMzlkw36JY~#cu~5w*4x6-^60)h3^VP9M;q7D96JD7v{y5=M4r=5gEzv&&F>D zVL+}_7RdAqk2|0aT9d;gYNH-+_qFqz&wh|nhkzjFsRqzQ?iVG`XYRB=#@KJoW`6=v zn$huGsZXSguvcl)iAAtyHypI*ezca1-LW2Ya2IkET#6{8(4Nw2vTm#jr~=-AAfnHE zLjaqfCUY%NrftG&D-}AQ$*jPe^XO{2l*$tP{p3O9b)wktQezp{e6Q1-ezDS)=ty_j zCco`aG4>!|Se+cc#te`7m4iiEp12F6+vsAV5g}b@zktUkm_=ySM^;1}9cq-r#1GS6 zW8TwEf`1y+On(seB|3?~jy^W1ppk%#RY%I;C=LowbT&p26zP#+!Q?!G9c}bLs&>(q zRirG)!9Pjsf!v6zRx?^fnYXkSNnR1H%?J{s0Mc_!C@w&!(YJb(=aK+|E!_I;cVipm zW5Bk_`U~Uxq;Sm(d^!BP0AjwE6TRJeOD%Msx}&pHk*74Q_i76SbZm~}mgS}(d&oeD z_ajgI940ed^qB;v1(B~QghkH<;#dbV5(?*J7SnCH?!YE-!U2QVmmVI8*B7#QzkYs* zdxBN5#Smgikhy7w}JDNH&&~uPYuR z~#LbmZmo(rrob zcaJGsmFsBgdcUot@fNk+lT|K#9kKnMquq}}ZU$4c z@#t`SV28oYD4s76#R z5)cICJDSz**1;kOJ0}4$Qmh@To-W`N#S=dJrq>7)~cczV7FrlCYYnMHk1phw6zE88;aGOl~mM z#cD$+y>`5<4Ck#5*6ZCr^bpnJ1KN|;REBy=o;SlQy3OJ6UyFDu!|N!Mn^OdBrd z9EyC8{WKp9_GC&nW>}aTE_QR+hJB%49A`fqZW+9QLM{;zZ0O3WxqO?t8&w$LI|6me zBJUS7Kuy9`qoOMjI+V0qpc1XNNZ3qC#vQm5Pr;U3UEI74%2rUXX5~Vg8OJvO1&!4{ z9jvIIw62n%Q$7AiI3|38(Ga~?FH?XP2&@oNqCHx@w8xBstRFRi4zZLw@`)9vCOVc^>o=g>fBRqm-u z8@2%j0&g$nt+5sSNiAy|L%;(Mo>#AAlE;M}a7=(s)r;pl%ac54vK{!SPjVe0@+6}C zYg7aAfC<;m@Uo0Y9)=@@P!iT)9w=#r2o8K*NPn06$DQp@)`wpfALSU<3YAxe4)0%{ z%1O^EiR|2KjoM9d5<#!w+LrQ7^6!)Z8`#fVq(B}*-}QooKcI@vNYd<{!`ySJ!0l|u zu9m_spBrxEp2Y;8FA!H2`DB766)zUps!grw%qc5%r=B=ZD?MGAv^L0g?r$&PF4~yf zikvN+FSs?RJsg*^>&PVbTt{)g-x3rJkeWSWprLn*G9HNsuYjl@^n54U%l4ZICy^Zr z5XZ8h0l}47?|?eicqXU`*_yWJy&a_e(&WoLQlYAry%S)wKdnSHzp!wM zG}8=RF?+#+GOn_&m|vfwRDTV&0l%68-*&>OK*RWEGhJYdNnv_YKu1_Jk1)osY7igz1F;@L?p?zk%S8bpRD9`_;X7iKR_*5X-$n zRD<{&$Wep%;dfg;S&!1$hIxM;#EJ#}(4Fa^?9M&6gtl?8#U438fJ8DQfXlGIYZI?5 z)_*v7C7~50h-6He6Z{iCfZR=MO^b4@(6q$envEqhdtvZaNUn*6$Ev}KmV!wZqwajY zVfLjF``YT5 zh01$bIBO|I_j*KW=5P2+K90N=tHJVqGHT%UC061`{V;aT`nk&a?F5*qhw#{Hm5ocr zjtY$Ez>Hc|RM2ngIQg|#p~CpeAlI?B3G->W9a{uvN+Oh~sFzTCSW=T1a@oK@?UZOx zQs>D4stmfo?sxw+;Cb3KC&$$(K|)#Z9PG8>$V`Y`+bPDr+ue;|V|Fod!Ljj(3PV%R z_BMj*Z4cqfW_l$5l_h9TA zz{-U{y?nmFLdU4ky|}*W=UUq!ypIg9&+h^Rl z{%8Vbl$vIp%xhP%)aMQw1IBi0TU=gE{z^l8shui8#}YD<>PNrQ)E@aua<8YGjy3}o z&+U-LdYRa?m|QY~RdUD7J(w6% zatMlc{tVvWu(;@Ge^9qU!UQ{f-gN6~!epv#Onj+jp*%AFL|GB4G0-Q`XiMsCVT{=P zGhlLAZ8GBQov2kPj^W}ATIa(<7R29DuFW{i>NK4taa*2`Dd$J?507X9A;-UQDnv8y z+~APm1AltnF?4|E?ApxVxwecUNWTEXYLDi$rQ_^3*r4U&y-R~!U+9!d9uOV%Mb!uu z^>cT*LiPdI@TuoZDiG{}IHzN~9Yk3%W>#@tc zMD!+}8GJxA;SmTuB-Z5=)O`0O3WFx;G(JT{ac5KO64oqo8rrlfMw6RS3^BVYV^Fng zO6psb3&zt=dCKp`gbglY!mSW?UvmrW1OJ%7-qBy2sNB={%u?h z=&HqlBIST{eNlK+bsFbwZch%ELMFxk=NjCDabr9@-eBzSE$(-pMvNxu{Y_ z2DMr6Bh{5%zQB#=5Ye;XU`v;98zn|WIP1_fE)D&a1P!2Cj3JNiCf%s`zJ2bS>x4e0 z6FRkG8v-sd;CQQeg8T3?rFw;(U*L9Diopazql)0147HE_rSEpS$LC=__(HFunl{#J`RZ@lGK`nDo&G5Wy z)JLr+w5Z}G5s#5K{14kp;w-$REYmp{Sh1cZUJN$#O)L-}#%vZ0_a7|r2VE19cs_Zp zUnifTa473!I=TY|QYbN|x280*<`oz-XfSTLr`;|WC(tYlN zz0+-C2`R0sy~gXdC%@#zc2Wh57hML|x1(`Ir*GAs%SS(99^1Tz9uvPSrM7$9=rPV1= z#t}Kl6HXHTtyM=KEJ0M`fN)LbT&KAoMK8i=^hd##h1R11@tshP3IQ}aK?edW(Qe>d zaD|0Y6OnOQl$UHGP|w%R@tYiVk9=*o@lJyi;j2sY%WwnJu?5^$CIjClL72D9Yf2#V zg#}ll-#NR|ZD$&d!5t4b^apWxjC@c4#Un8aLq53q9>`IMC91MiZ#R3GGb5To!IN4p;9Z0BkwdCgTDr zR3d421V)?W&tqW-`B)};tBOv`@bky_Z2E5D-wHY;r5zKYHqx$PLZLa4rft1*|S_9~W)|!EqcBi>8j$r*o-+h0h9X0LKr-FfIV|$je~QD5r>? z#!U6x3g9aN`@W{e8V^A62N0c*aCC~m|LF%2Ull&GXzEl1&L*iEQ|wYe7xEmCFh{BS zS=}WEvB=#G)_9rBYQwx+DVrEU6o+l@Q$carXYq(~<9Y2LofcSgj=BXuzR2b%HSX5x z@l&}?d_=Rb(n}hTes;gVd`jE7Ql1?N4`=UwElG5xHIn;QebO`dYLAzapp#`{^&!O7 zZt`Y|WCkQ^R}bZumgipO$z?8nJnYtF?>%v6X^FeWI)_1-)8q`&>vCMCJ^=s-z_^0!NXN3fpM|phrDhK`5q|f z&DtRc-4vgg+2eC}OQS)O&VlE%arW4eH{&pN{fu5AH>)~ngU2G~17wsj#Le;$imU}8 z!?3%8bljiQ1mbxgSME~>tqQ2GJ$g5hzWhWyzR)Ki<-OZ}a=)*kk*hz7Q2#lf#wz~I z5x;7ZxDc`jkAYLhBHDy<>Of(Ccy%$hpzZY5+9dL0eb13YzO-U$dqf+jkl7%nrc28{ z0*xa5yD)iNhNtaX5=>A4HukAtik_p?x11K%Qi8Rbc8w(Wb=KpbesfK4x4q*$3)1I{ zbIM3~T+ft>+Rg4!s=Z?Ro7NJu!TyWlV#Tpnx}bWmVBBI>{RI6(nU{b=i-NdntB1mF zopi@3U*ocA)vLRFFN0T-GNLpMIuxz-Ib_ZP9mMN(M+Aj}xRTsqPat!%xGP|}kgg)) zP~@qq)%-*h&s4b!RkSIGo_BlFf5*hrAuyR=oo;L;6RCR-B$&53-Jv?35^K7t>K@CQ z3O0D_!1x%E~A_yrvYcV1{R=~cnf1YCW&+^K1HItGWEY-75|0JX8#UGD~ zQFJ)pmLmE+OKBe;$&&4obw?~T1~*93x0Ro+`Ys*KxHU-qi76#$F9Q2k?^!P02pb0Q z4o!~u=inv3I6V*!VwK={@4O-j5*kU+E}n^=aR*|Vxlev!yi!$&^riv@#~U5!g2=1h zR4Ll3K-Hy@^*yqX=R2N}PHS9*9xnJ&B$(q-{pEIn6Rrtbb7&pGbNluAAXY1EfyA*6BLHt9>@v- zFKz4ywBzu3X0y=Sbw z&uFbx9eJG3?Qf1ZeuCbn$)E5kTp|aKdMod|x7zmtNoWM37QnZxj%QhOdvSr`(Z{<< zI0uou0jr$d)kj#V5umx<{o&B~4lgPl$W&j=ENg?BtW7c3oLMPhISh{< zO|VR4p%u9s*UkEf`_J+_VekEn-L&MFbLx%JboUMzwqEPhlsC{B`Avh~FsGK>DgzE2 z2e)hHQ^wwc?}`|&`FRnm+78i#P9$mJztFDV8w98FD)u+s5qzHn*qM>nSQojkB;!85 zVRS$x_6urG_Ea1aE+&0Z#!10H)pwy}cENqvx-^;MA-k8;I7*R@dL99G@k4Yl?U^?Y zMZkrw|7m3=9q(6eSFN=Ffvh!J)XmaY*f3ldmw=|` z)t}~@n<=nYk(4L97p*n}IgjeL*Lw`N=w01r3%-iUu&vQMOi4Z`>P%6+{-aoIs|*|2 ziB;N%++~(RAw0(d-5v*DU*B!jMjdJ(P*FL|gm*IFfHd+{Kp? z0@%e{uD#~LGg!g;wS191@H#v>NDUVhW`s3!tb?Qe5E8BHV2%=bE5H#dWbghtF+g8{ zPBo@UMW}p1Zs?;9L6KICI!6u{WPC(;AY#1b!3;=SH-}X6!IC%eLX{Wo=Q6y(*G3lohKD_FeZ5j?!<&7usR9HC0FwfFo$%v1%~!OafP^J zp_il8*dNgpRY7wyb(xqa+H_fomsKry2qx7hP!}!M_nM3$G77qq2i=(v%ivYLVq~;Y zXgI6WAt+qMgVJBzX@Jp!J_NVO9{%EBBba>l*OBiF$;9YYGv+7*S zCJpOtrAvXy<>_{{%f5g;tkhtgj6mx3L{El;OX$Ne7rgd?pe26iEkspFss)V3<(J?V z81uUM%WjQ(UTVO5%$Wn4gQY$<5@kz3mPTc3NTY^a1OexpA z-k@9_Vbrx9o!UK=hz8P$v7)T?i_ad=ztyB7naa1hewEF55NEKS9%(~ASdf{_eHI?L z`?}LO)c;;Ty)D;v)6bP#H($m5;D2-f(++W*ElO-|p|xOLYtUt<_gU~f2L3I7+G#`5 zxtWNniJSXrB3|Hb;4;yr);q#59F2MW4W7HDC{W%+M5HJR($*z90I|ldf7j=^qLT!c z6bKD`u!Ic>3_7|O;SN{ii2VwMNS*>oU+|n-AT$H3Ztx4#o`QMsH>4c_UctP0A__0J zo+2HBy8QN(V+nvm_#zxqtRI{ZlcJaKDLKUMzd2TsJNhXn_o}?JX2l=Bhz`TJ$jp$|*xBxvCTtpSF4(f9FYHf}% ztEUcby5akh&0&fSywM&%$Ua)^NwgUDtt)g~SXLU&3X_gYM-7PHJ^wnjOOfMcH`V3d zi_5ksLJ{N@M*rX>f$D_sl>h-eSl|t!rU|GJ4EZ-&8KUSn4@#zpeuS^Zc<^{3h>UM~ zU$(Kcy5u7yku+`v{mAX9JtU!KXb3=?e!}G0TgVjA*+sD+kld5HO}Kap+4FCx_&U_! zU>;{@$6y8GvTI7GnFJPWdvubG;6D$26`3B#j}I^CSuUkjD&n;zyT}YHZt$iGVR~q5 zU-`8gwmj50Q+nN4``l07ft~s-Qt@H5gy<+=c+Qn;KIOM}+#*Fu6xS5=Z+VhmsH3fU zSMed}H&^?xiY(uePG*`6xhoPB ztBK4p;bm+tmU+Y9+wX^MN@{zI)+xyJUb*cPsl7yCYm_C?}YD&E^%ePrjm!3u^0bQg;iXnwEE| zl)BZ0Es-`#N%5{OSh@W{8EOedyj72m9oo@|M9%`HdqpI3a;h$df(TN&K);>*I5#ui zfUp5Opa0a*wOsIm8(O3eEY5XL72UDqXo8#N?M}byE(z3Pq|QCo5Wb@K(=w>6UgBcQ zq-HGgo$p|O=&5GR4WC{)a{8eV8Rt}pltT`3`YYab6aa7lms9}re*hf#M49*pcR|!% zQuiN_2LRfHqMYbwAvbYwu;HYmGd2W(PngmgTU#4j7}DxnTT=WNAc#-Mj{m0-dw>;Z zYddp$8(n?F|6+(v-`dJSSKon-&(XnB+uqvIPT!En*;t?Sle9E6Fm<%#F?9G#>FZkB z=$aZ^@%&U}WTKH}pfR?v*3-41Q5Kh%VPc_iHq-;4V;Iut+tV03+y5u|FZ(n$y2gh8 zG6P^3S~>9iD<&EnJ8MfD2O48XQv*X9C&s@b4u*D?JT(6`#!noGe`5S^U>EXq3U<0y zfS~LQt@Qsv=J*R_@}K!({4dxj0)T^d0q7|7v;ZEUure?LKG`?`pPF=n7KVlf|7-8} ze|c>WKvV&^B1iY#&f4aG6_y0#P4|E8mHBkm0iOYIj{IL!a)$p(yFCE*;=8qlwVnLu zHTopv=>bwqjGs~fSd{+&1^G8T1|!p7v<*PlPk?uy3XIwS4F;xv9b^xn7yuN@XZ!$M z5rx0T{t^I<{|3mSVCdqY31G@uJLozX;?o0?YHInv`u`W9L10d|^$kU>jI04; zi&_a8+5_$mKvT$C-_a5fqNot}&mTX3($llC)6=sG0cv`Bdd44sHZ!1b{HtaXpr>bI z1rz{}34rLr1d#cU@<}rQbO5@n0Olv3^-~tm_~iZ7`J@4cKW+Y%1IYj7f64;%|H^%i z^=S*>$EWV!aX$4v=}-C3zEApZ%}XbtYwsXwZD49-YH09J2+W`EeY*N7^6BDd{mJ`O z|D-?bf0uuo`lML^1wgY1@X|>+TIw0vNgI9UPSnBB(q7c+vx(36PmlHA9(w>XjI^Dp zv8k1=#s7CE|7Hmg?cZTP>(6LE-2i0hllM0p|77cLM*hwF4CNo0&#?X@lb^hQ!uz-G zXXvb-Hb1ZGXZ<-O%vcY`zKUIQ6U9u32S{_2UBY+AzcSuz+wluQ|Q&% zIN1J~j7)%wS_Wp8PavGX)Any4pv}m_M$5ni=;r`{ z95HIrF{m>!vazy%Y68lqJw_%5T6Si9zy(X0R8?tG2`DF4<4g#2$&d`31F4(5MsDw`TOnEXf2 z-zDf1;O6u1^BdxGmHWHK{IlHs4@gb_pzAO*u>x$`JJ=cOT7HEV3F%cfw_asMd*ki! z!~2ni6^23~8^-VRZNkCX7g*E5M<)giX23Sh;?(xo_IP*W!t;ti)hQPEh%i_ql5DqQHu_~Ge?{*tFwF4wbWg`YRfw12D{;NU4y`yR@r))lvAmZ%6)$yF|-xDbXYvFaO&d|8hZzc=i8R0ybJKO}k(o^8gFB_U*DbFkK%}!QUM(Lc6u;|$ zh+uj7;rVE?Eh0H-MhVmtZ^lP{d%NDU_&8mfx_Vk0s4ZRVD{L`d8FPY3!tA$IAS;}h z3r)}|e+9J`H`JLghe&T(_;vP0SD(Aae2kbe2^3O?OsYPOX0U{sFy#c8oU|`D(#PtD zOqg-tYh3~kSpv3~l%C`|&r&QEBJ&F)cZdiU_0jJHw`>B-pNb7w@QN4AgjvlqKtjss z#}fYE+DhP#*RbzY{S%cG*|2)M52BjSFLx^E)y{xTfEjr3xDQi=JUX=>ZL%5O<}h)= z94`!?(hKMn-4R`j&u_oz7F#K-V)3mV!g-%FwGK2utB9Z zBB2RYDUGQ3O6?uHgLi2EC!H9_213n4=HRd(M6luqWE#*yrHo)u5LUQQD7H$7@Sqf1 z7=}p4Y`p2?`PCh5N@=Lemu;&2CN!VGbO_vYjD#w<%O8PO++JbQ4<(6~LjA!T#}TaH zsQP2RO(NBoAYu$ZA_eOge&N#hM4O|#+a$j>b@Cw4^H2;GHVaACfkVEH|>8j1iehS^E~= zLRP0{%js8aTheLrWEiig2L9LHp@le!kk)vjbUZY{dzDIF76xitsKE5<1S9hy6}%;S zC&Ei+9s`JAi9F-{YTuT^tHNAU{Z4$4R9E_fLW!x9pd|u91*$iPS_6JW9O9GqUMeZ{ ztGuXWFO0OL7sgR>w5%o1VgK6=#^fd6schS}I{g)~Y~cQ&9HI#~VR@U;iRO@9X#@1j z19*HE!bdcyGnN?RC7ECm$^Bk?NhM`#<6kXNI771~rrZ3-^)%(^g!;(%&1Ygr3!w3{ zR$60&*o8S{D(4h-C$_-ZgwJ6^5!b6w1qet@Mec#e;j0E0-LN-cc0Egyq!=Mxe9Eg_8757*HYOt=Q%bGWK<-f)H?aqoC3@MjczL{-AH}8Y&Bjeb zR4rN|;uRHdvfR1nW9EkJGgUotQfHF<1EJKk)K*oeX zD84c_1;&`^ufL|01sF@4d1>Ozkqzf9^~ydV3fgnPrZF$C*xpcKSi>?tXV#EKV3uDp zWKr)5L8d192Gi_1NS)DAUR9f;Xe`CXR7;=_BnJQw&?2?F`@Zld$f$-plpYVuc}}wG zeh`tMUj$d{*c>Ql*MkkeHe zF!40yH+!;&ahI(`mzGXEijD3nwAMTywyr+w9m>DS7LMCbmnlm_bq{Px86^yQ{H(Aq zqDH#yzKqj79h}20<>{@J%TQ>7@2?1yzssMp#HHQVQx&AWPj2`foHr7zx~;}$T>FGE zgH~~1J(b9KD?Oee6dd4bDpGHcF*6z0tcLsRayy|gLvPgee$WGrNrO0jdgpbvnBusb zyY}>(OGxb@N*V`rlM8e!t&iFvGEQnYLe$+%LUylvb3t{tOab_dBa}S@3rTk+-nz*3 zv6F@BSBbfPv0{kgTVRi^iG|}o9!B3N>kVoz>vZM^xplQViU}rk&WK9#n(YTO9fa^h z6LuD6!Y6(97f9|l5#?~rb-L+k9VPcKjt0K~eT4dqvWp{NfYRPzr_Zj=n5Z>3aLcN% z4`7UkGA~@_JxxGsULv#RO6M9#tS!{mxcVg|pSC-CV7$j(`NFUeKS~_9=SWboG(|js z*e&%D;6J3%-q`!fJ#4}n@{#fPL)moiE9r#C-z9b<%+B<<(GfEgw}^tH^>gMy99> zo3QH%7UhqEwe|>a#J%4Uy4aEhfA60%7yQ^X5pA{GxtxiVMLWuU$R`ZBDWIHOgME^r zNS#nu=XbE%8@9;c0&*_3Ci#*@vC?aP{PFS5Pk{X>rkF@`ufW^E5+a^-Z&;TX`zr}5 zAqi@2I%{!&(8?~6u(^Wfqn7i8>MZPcGhBU2ysKC->p*EA$=PjW9#SU1_UjYtF6j%wBK^E$yDP0L|8+q2Cuc;d zbwD!fT5u>C1yp!Sz6ue`BmcIn#UD%|N(Z%u-*JKuXQYyGHOG{$4x1j5&1A!eEZiW> z&#@S))KD%Q175pQCIZJ@0g*lMJv(!Ak__S3C^X=a#BYgto<4!oC&}-cO6F(eg$Vo) zcP>LiS;?i%)6CrdO$#Z(?gY;e9N(+%c3tp3YT7}boC-CO)`Wu|DAcdV+ePhkws8G@ zxU3YI*}zTF_*xCVbc3k>=(PACriZ#a8Q83y($!4Kcq`=Yb0`Wn0o=tgAYq#iwL;oi z){xCe>enXOB?{Dvv{SCx88L6}qMauS2w)=jhYc~5qz1dka7^ynqVp5Kg2$)y9Fq35|^~^2|s$b=M=K~#HBaK zHUJgT+={_dIAM}9LLTiD)s40+)P`e7EE&C#Wu*`4@+2Afh*H)OW+-w*=6^-(+wr#E>(LJH| zrv8Ao<<|4lL!pu-`}^s7SaxT)(uyy^hf)2usP<=3;Ptg!x2%<1~z*hr}!N?WC58(&}dmvODS0!@8-ZzYp#H2t$0SenyweLss z)di5R`sMExG;s_E_bT*JFwrGzZJZVz>4E(SK8 z?N{j5T#noC<4@xCQKMKwqSgpcLC~c5>GWH*%6R$>t#iL8vpZE(7cp0J%H?CAY*h9O zj0!;ePmny|!I#r@UYQ|OtKy-3Ee(gh7+4rSiFr>^G?&1(u6B`?Q&$5IzPxE@bu13g znJx!db94(w`28Gj@MJx>Tz@p1khIUje2r z(cR4xcvh>Gv*;U^D*!5+rJVbrBxHJ0|hR#MAD*GL|=76R2-y38QMDCoxBSfyM0X`VrwlkL^^+mAsW) zg)h5M%nD0 z#HBx268tSRQF49Af(AGN>_<9A_kUimxIGXn$P`F}^VH`64)ZT#ggEdg>k{q^rZ66H z2N@u{K^Fhw1fzxnzZr$d2in?%^Wyt|*n8`+x{_sY7zrBO0tDH(+r~AxyF(yh<1QQ5 zV1eK+!Cis`w*&&gA-F?um*9{PeHSE?$(%FyzVptV`#s+uXC)7NueH0os%ur(>aME( zE%>k5<%mZTlN-&K$dXnhWK4PKFYp`S3<4-Hn;uRDn(6gr6RI#E20f1P`JyS+cE2P% zaAO#I&?|%zV^e^w^hsLQOj%f5tx#{=r-!01qYgB=9SV29M1=TJ1|DJ;tW3jOP>?1E zDJ9jZ;V+)R|25uftPpW=b1s#)ay53SW7Lv^*$?){) zJcA4M+88{dh|$~hkonlgfTnFC!*8F)Z2Lqai+Zy#6sqUP?GD#5k@cn36J+&qKXj1T zpoT>?EOTo4X9;vd5>%QY{5_h{SSlKEkaK><3?9*kQ8`w+c#ra6TuZ{`)T`?cn+9GT z?|GK7h#Jz`eJI6J|D-)XC7H9?Qfzl@)Iv{rY0pdT`AL+}1Dly7p=$Ax2ex|^wveb$ zr-{5Ln-!Rpr}gKfEuy^rP&R&6yYk$=_-U8Wppa(JsDCXll#VrwHHKB^!o}`|JQ)+h zw0<+%AU=tngS#|(gF-1q8yjtXdthqYa)~PhIz#SgFr7`*>48E&yz+XbIO6F}jf?a? z=ouE|K(W;u`2ifPbuL$oeOU=S_yT2UQMqWmJ!fK-!2v%E3roeCbdOU48H(%OV6n2Z zsQGFtrRw$yn)m!^iG78gLx4_Tqc*!g*%%(Y0qhIN=FyXP@5>aSNMmNkV>>i z$HA136%+GM%6!<)UUV=oWy^cyNYlU7s@a{qs_sm}!GgjVyS->JZ4>s*9W%kJGu+`6 zF9QWc6|R?a(}xg*}| za)fIjMh!L_WT|43o;#6)cav-&2<*{WeW*71&3gK?*;)HmUZ22Qa<7L<#9{4p=4eg) zI}!qFOw|pL{5z~*(@#Tb^UI%4UICu=Z`+Q8|L$oAUprBMcvQsf?HybINACAm75@V+ zVZa6TAD1xT4F()$|8WTezRzo)=ntRie_X=fv$W%xqnR+2&c)iDYL1Y znYi5N<^ufUJbc{1i{!x|ZtiRMJP!|;m7fFf*#GvfWkoA{o9`{&80TL+;n&^#$phC- zkN!3fTmbFgc>r^>a{VZ2e*d-{z`yFlbpY(I>BEgh`JIOw z;l`Z(&cpYK*x$StoPV$noPXIq+}P6JdH5gMNnpP4i#~w=vVFKQ z0SrjxFY3b|>?HU9$WC4dZhs#aK&HfBv=29ru;1nIKeCe? z{J@jzMh@((y!=3Hn&Ynu;uk~tUx#lwczAe!4d2%3EZ8qdWBJ}0eY8S#CF*5ybPElx zO|~@$7EaQ^O05ZOQc`a!ksN=1B*^(fLA_B|4(~2jf9spWEPiLVEiZwVCQrJWIR!+$ zOYr?@R==K+(3G)m7se{PkB|+{fNvt4(pm!_6+g-ggc(MtRYvUI%Rh0sMfBx4nY6Tp za?>*&FsHbMyr%dk+o@;~)s%|;fjpGG_!_WpC|6P_dvB_IpI`Jzn|k$a1G5lAX_s2J z7ow!;g_-<33T62=R!%M~W-*n88)NkwC(d&3Vuo=ps`XY@R?7ExWi>(jXpiu}O>UG% z+`ZB{cMN;*Iz^8lE87wNz}YAEo>;zNS>Ngr+vDSwQmIX_PishzR{WBEC2_YMNHb`? z^xZVF1zv+9F^n~#w>=i`OjHFIW)@cnQc%fVc6@Xo7e4lLIBnI#qxTW)a>{Ay#9Ijx!<|SBX6BV))J67?HQYe&zoO+4zSqP*-RweQ1QqlvKg^5Y7uIv{! zVjF!a2=S6;S1mAsybtlwJiZ3g#wA?&=I%IiuEX*E0M5k{#9VkZmzRajU%bcfP$w&Hwf_Mvtthcm4)Wi7v zSz+%t!bJRu1cf7ti?<$z>-8T)B2zJ1^U8N`AyeMMqv+^!!W>;M!S!{0Jq9tdUze>( zbr?l;*19E7&5G0XxfR45_lN~Y8OhlCb#faG=cP%o>x1L%^2MO3k_pJg>n!}~&Wy<< z=a2ZxaARmz;|hWDZ#7AIhcI}13A04CMG{o_L@f>q1z?7{4A*Z5g?F&IKKVM%@eJ*m zaQo2nC)PqFAIK@ngj2%|a`J2RZ#B@B%2PiURhMnT2`bouNur(OKv6}wAjrXON#WYf zjI2YOPTud$JD&^&d0|*6Jg%&p56!oG?9x9-GPN5b%dTaU0Ru$L3YBU&sQ|cCJGdeDuRC~P~Y!+&d;P8sQ z(&{U=vX7>tj{6s$oPik47y?B2?HFeGlqT?;d%++wT+ZhYVB)#TSTo1H(w{pxCevi- z=7&i!6_MzFY*fm)kL#)jc5+;)q+=#`%hh;@dqM0cJNh20C=!{E>h)`_R4@NrCAH@g z9=pMm>v5%y{g}@pTE)X)>+ky;Lyt(b@Q`Y}?(9A3w=4I$3=h#|zv}5defHeXCpE&3 zags6$EeTbdDpw@e6O2z4MK-NeO3Sa$BI|vc_n9r>LYtkE^#+c zEZcIStP_@{r(eSU)eG;)r&$OxBj@t^I z+D?xQAgYcR`slgTt8?$b1U9KtVY*WY*pH%j4QFDR-Jw|ov#qe*yHf}cMh@?iyxiwO zBx&3weR;^!{rY3Kf{NAbNqQI|wj_4H*7GR?NlAk&_^KE?F>sf4uO(;dI}GcWU?fVB zTVDfv(!19>sL5nt!@4MqIU{o?y5YI*_aG6f?aq^feWRQ9d}<7{AR#uBq7eCnLm2!+ zn5jkBCu#2-)Meen95ave-{sDKj`osz!)#ju_FtUnIXHD{qpnf{!4fYEg>FCUvcxZw z7*Ns9{lc$ophh38sP2joO*;bRX)f}Pq};bQ+=XzQimp-vzGWGi9Dhq(xU`OmxS|PHNzkkiqEs?#?4vL>LR`Sl_>U&2H9w zKc1$N^s185EHXD4s34h}d{h=7i4e%$1W8(%T&G7tpq?OYFpDIRy5<701!oq?+? zJV44GHw%=519*L>si^?)4CUtI7vSLIU;tK;G7g#!zpwUg)_4C4^!Paddf-2ycRfe> z-=N0{(Bu3QdcSxf|4DiBa|86a{)FCdUISpw{*Th*1?X}A3B6xD2LC9%YklGQ6MDaR z2mV2NJnYx{!uu!mewpF^qx7!zh3`-3{j%!+N9kSb3;&4*q z|L5p|`T4Ht{fRtp)rK$c-R4Ye=;7p|5xk_V6b@v!0dlw zKe>OgFF&Fx+}~X?|3FlQ`@2))|La71AnX1nYyQTS0C+Y3lXZU`%lJ>${eQQA;XhgT z|G&(-=L9BUe?7!^#8k z24KSh7ay<*iG!7g_bO=>Rr_`p7izx9i6{ZeK5>qjw- zOgd%Lby7$2n~D{T8mTQBF*9X%eJ1N%$MpP67hWfw?wGy+Kdwk**lRG6kSX4L)fGe% zIV)}FF3;LlQbYTE1qrjxvc7aQKf=9d(yh-b~oE{g+-FuRqnHxs%)vh8d zHS}YBEul^FEqWbVofyZBU*=S`R~L*ts^agNAolSULxV~WcX2X%(zm(-rG&6>^-l3` zAvp;&+49^KDY6UIW_Itm$BzyMk@?SsVEU_1nnE&?-hO=2XFDMfN%G3y{*1f#g)YYd z81M^pL>t{y?Fm_eKh!RL4ufc{%&i9MogrX^CT>{Hpa5eAm`_nb7dEt zeZ&EA))|jY>D>T&{in1|G$!3L8M;Rt?r0Xtl?$rlgfP;?Aq{J?Dmw^wr8`c}2>qC4 zJosF2A5CkPExqSNLQgi_sWSUE=f_#Q{E5Yt-5?k;`vWZc9OApIlOUS#DxR{H^uuN$~NLFFTA`%c2U1)l(%T5lyZ7hNcz* zjmT4T0=wq{7uN;$_N^l$4U1P+#K{M!%PUmlJ8azOs%|ma z9YJLt1g|`cQI#ZZ3hKU`pEApA8NW4&gW!_>v`Z>W( zj&|z7XFr@rW6EpEMIom9c9C~ZN4sh(r!Zcz_OsT2UaE-QE48u1UafhaX3pdtdkY#H zLo68LJoO>{Hn!-3nY;>Lr?c0%JH(Oksi3;2jIiaKD^ha18I02Lw=X?(# zO(~`QCR*Z3Lx}9cXz3A?SRIC}m?~5Xs5M>VL4C5L0>@8x2`j8$zt?|>(;5Kk$08DC z%BFhH_fj?%TL9iqrG(08tz9TolYsj*_^Y?MFjdxG!eiC4wDKe2Tfp~Sq-0nl8+{ag;l0=f`8GgsF)(e^wu~N{^m4sR`#XG81 zWus3WxZ_nnp=zhQs11O%O-=A0lp8aRBu?#@Zpcwp7xyiIHAku=LDCsNKA zuxR^vlUDR1`p(c_?V+qr@hV+)A0dZ|P_#_JB4C@GVB~I*2ZoY!Q^wHb7SU%XD`{1gscye4o(t^;tq`lh{Dut*&j-f8*wwAkz;`DVD5DUs>Z+e6pjOi2eA5BJF)i@yF!t&c?wT2`GA}x*#)0f&#p8Z(vY}Y8A~9ZHhW#F%g96J3W%yKf z69fj(1{p#|&v5y^xz*+oq<65wGRNvQwMpGUi7C2JC8BY<)M2s8eu@4b3g_i*{yVsG z6%+L{o-FKBG9|?=P3IrkOcovGZdYJw21HdN9Ny7`lMfh#@{AHjZ2C<-ur0t*G&@z2wJRzl&ef zd8__t>gm=rD$|~_vj)wlC*fFIPt#y`^HGJK<-N4TX_*c-&G!6){WL#}D0`gS1rk?t z%kW``pVae&`;M2GZ0)Xsbji;A^zrRa!lkf0m$HIRDCq6)&j>X00KJvg5{VCT)P+j(jiv9i1^i?!(Evr6+8HkewCL+zN zAed2AC{Z%;flh%zk^?V?)LsLmeu2y29H=6c0EyzNcn0d+~g;Ig~xZ)ij%lXwEbkVTpG9F2W<-DSs+Q z7D5O-v0#%&HX2=%E|l7#qOec z>l`7x2^ei}<3JN7q5M&Zg2rr(&haCuZx?$f$@D#ZYlO`o^U8A*R*{AkFx&e4#*1<` z^oP+nWcwE(Vet3X*`~0UI{QeazRKO^Tw7$*z5TIaHQK5vPgp1YU~!q%jE;RRfJ=)M zZ`Zr96vgV9g_ZnuD;?&$QrJsS(UkY2P53=C6J86aUJ4cPsDb*YIO_iKTc=9ZyoaCa z`)aG{kRF;Ak78>J_#=gy1h(aPQ0S+^6MGOBEZaNf$+@T_uEY|AB0cP)o3t;q)QIl` zvG!{!=dH6meYW_mR3Scyt;RVrX~kc1HWPD#&U~Cc9&;OT*{mqt_|?a1`I-;ymNUFD-wi zAV_!WWRSigq!~9gUxqx6@wzl8Q9UzJm8+Cxb=F?Esp&F&HWK=rG>o%}{bgWu{apNp zSj&+*>}$q}LAAkWbm6fj{kpYzSXE-kmuhrRu#7nbG@g~-&x=;^73vVKn+Rr;wm$WL z#zWzbv~FmbQKC~sYO;64J8eg}Z!I$2-*IPd*-=#AE2@pS0jl%efQ!ldv5Wh$I5Do z3|aYQjOU1h&qIWQy7<|o0x|*z?R_m2S@{L4nP@MzJ22m_YU1ZT>2i3C)mjKYb0!x@ zTG@Ecep7<73VwPRUn@{m(S|~UJ71uN=j*nuv^vWQ7Z>aw$AK~^z?~Dlmg^gaGQ{R$ zP)CAa)#u2b`!GQNKsAEJ+9@ulhTxG^o@wCQ#J++IQwDU?RZa%j0E|+;^3NejV&vEf zBVNbigvNW%YxcFUxKT*Q8kMz);OSxzB2I8by7P+15%l%zOhi4CXt5XsL_bJYxQOA0 ziwKa^BlqHVyE4@E9kdphuMx%yB7C!rwhQxQ;*TbJrBI9fbw(7fq$S$rE8fr}#(750 zjwmK89~*n07yLedEy9oaGefrZ=3?vcvND3^6i6XFK@ir3(Y4ANFT3-!TVdV#C3NJUbMjUM>8N@*^h>$QUoxjLx|tYLVQ zT^u-~V+e{?J<^cn*X)QuYSvL0Z(Vq-op@dk}X)dgYZ(dyW zz>XzT#6dphK4w17z<+A^ro&fUQHwlft{=VV_T|}@j7tPa33OKsR}e;T1PX_mn#?b6 z$(A5R8SGl?7YboAEvIh7mt0$CaYzeB^s}BfH?rWiQ$jR2&HuI^C_7Z2*C?t8BU(%Y zccE9o6WElUc3M)B5L?fgE80O9z+gR6SWMTAcpD%8ThCWM*5SDx^4 z2cP%F8}Hg}#ba*9x8mq)AM80Ou299ITtYH?&GxTUto?`{QuoFcu_1E!84d zU-J~Nr@tI4h&`H{(ZZ8NN6py1PIn3x2Xj*10ryI^zqJ_ArUqo=E&)X%bT8XOSawyoXRR)***>{e`QMBoE zk#uz_HZJ|`o^la%r{EM7DS^H|(TppMWUo|>#ht%xEcQk?fXmV94N)XgXpPPR?K%Ev zAyOXE$K?JAI?5%o{Cs6h%FpRIv>g1hyz7NTiBu3&G~&P!m<{pjco63VJKBAOz-%H! zvIwIxJ~I3cF&A6R7<_Ths*8#yPBN_mh#34MEq-Fs&IzuU+Cnh4@|_*Q6K1qVn@cfw;_*V;SNJFLO0=f$aaF9i)>j@)^$v22`sY@$V7F8*j=FpT^%t zzySaweunXWb3=d6!uki?&^+JsnEqQg^bO(+kmCxlq0aVK!C$^}_&)`IVUq#e)jT(O zPJpZHAHacOld}Wz_$3V4bXAP4f&5({bSP~Hr0jn8>&sn#y>ZN6<5m0zFy)El71-yds zwHkw}?kudVg6Jme0>rLf`NuPYx-n`Fn`LE!GnV{y=SvgMh(hk-t8@C;Ywf&oao$-2 z$%%-IL}Zg@hR-&040la%Nl=dhg&6J8S}shF(FC6-2pGcqOj8t1Pdp;c66AM&HDJi1WM@=0 z_WAZRcq)=Q*&`BJhn-82&qk5=j#3)z&oO(_B9;c&4N`f$OnfKYU00-@^1t&Xb?Px( zkwcQG4L5s{E9LCB#0#Y0J$?+Ig?Y@HVw&Pw?3-s;vJi$}dY}Tz?~HTUDd0a+rC|vq zg{X>3>te%hoxdvord*{Pg0L2^>PYlBm6pC>wAZ*PQq(?`FnSOEuH5|nIsAxAJ~()t zwE1`iLkDxhpe)q!lKQ8+(S|*#z+~2G`RTo zL2p)?{S^G2t1C)L4ke-|hD=qt7N+kRmL^CZ^l=#2vT8H)`E#;%I&SbFz{j>%dN>st zEb8A2?9`^WnTu=3Jz)iEE7YHX!?wec~j$gq;$Pu1YQ zS{=R6LilL&CBKO>+MokFR0Jlq2{$NF80Xd{{sX!JW<Bf8Cd3P;G|~?G=1q z>B`LLj+m$!+HbSj<(3iUoBEM1>bI@0H{XVIs)bO{a|Kpg%j0a&W8w~bGQd9J^ckiw zuwwIq^OL`uQzTqvE_<$slVB;#Ld_x)g<^6LfxFk#PK}u;yDO0$wf-Ttr;2Ib%BPQXSO_== z;s~5Kw{CMk88s(3xGOK~Tly{WoSt8jqB|YhB8DZw2G5WqhNI{sAWb%e zeM)cD(q*#D7k2wj`*f)Ot8GPw&k{aP!egUC3M%nt?Nlu07iLnAS&H+%>IM^DV)x(m zk!dshtj3QP(4o+YCgX%`^|fouZ)-7-m_RS}V{~~I^btyn2$Zy+6efi0xfuN%-|g4A z`pF`l+grP`S<(AG(J%EfW%Ldms~z?X63go(;>j80c023c@b+<$Xg;!mDPm1Zo8)WM za9$XASkk*2_CMBLq1Q4LmAF0oWqg99YC$s)@7-HBp&&H+QxohE_V{G&9C9B;&f|x2 z9=K_#{$4K)IW6ubN248N@xV@egk@#3TcY1;S&xd}KGcD+(qU@YPZbVC_!uh>JHVVA zv{7|C{Fv*QKe96}$F5iPRS4Tc$_HrA5mG<9*6469nNEy}OZHh+L1%$8i#@a*U#560 z>3x|0S^3Ib{F2g2ktqG#m13158AuVI^o@(L_GI&_E#@Wl+*#g2!ghzdOTqY#*cXtr zUs|0;~?R@zBM#-aWU1G5HsVrU$7Dv@#UC6K0y$>O6}t##?Z7L z;|C|K6v%DGFCIPRXe(nEe)#a|iUq!#_Cbu0YsYZcM&@An$U6m8-vL*u1jUq3Sd6nn zsnZ5=F$f;|Y@+MXk|Y0m(jBS2;kr-moKP}8%i%is5tV_^?CL_Z7xxhnj*2vrP1dq=Ak!n z@~Yt@sw-!1mIRw*6N4OI_lyHSufBSd3(_lKE3k{WB(1!#7>snp8RqW4)v=K zI99Qn$%;A>trW=tcF7Mg%s+qa4|TY`ZZbsAC6D-46VyO!50lJsjC4=LzoEdes^0Ey z@r~bo_MsO@}9k9 zh%Bna_VRH9!P;mnabz{Ssmgu#2|3#pV;=Q2+|!{H-&V} z6MY#?hfX`TNVe#BMedPNvc5cnXw4k~zRrV$wmT$eit*DItY^$5Hn$HHWE^3{R;RFN zR`6LKzdi;91wHA7%VcuMaq}0OOJ&6FCQMcICmeQ9l0oUDb~B-`3SfCXBP*>sE8v`($lqwM8VA5qh~tA+bI!DFdO zwv#(13gq2*UyYolQa=QEnKr5A$5ebQ_nY=^Z|CM4yCNV6dw`SizQTQl|E;QGk5nD{ zxxft3^4^eg=4U&L^F8g>pjY2e*ukm*uEeH%jZtXJ zCLsnO5CUkEz+9Y7MfJzeDym8Vq@;!z$OY-7f+R=FQ!6n=dE1xVJL#pI7}h+pH3vH;tj0BA-a69U*&#sj{_Y2@Gn zcBL7z{Yj$3kJa|~{f9rW5IMNOY~SG-|4Ud#U^nXTIIBN<4J>bEzQe5Ew0ETnvjQphn=Gxa2@1fXKU{);2}&20gx!o1c2|? zm)R&mH$_}*gek?Ye*oz!se&XNpk^R`Rt^@E>uplJ{Hzcj2oEPe4>JhJ7UW`M=Vapm zv#|3DaPbKMU<*GEN)c3$5Y*IMKwVP$2Q}bKnDPhGvAerFt2-yF1Jr_zgP)(DjUCJe z2D1PqSe!ippkfaeduOWaCcd`;K+c*#tsJkj&q3F1LW~_;U4$tqf!{$t8h5mGaB*<9 zba4Dh!rqznrgPUg%4|P>W&<|8vHe<6&e6q$3lPh7FMrkrXqntF=j>w2_G^io>Nmps zLnAU~E-s!o9u;R9Icd$G?EvkvT3r8Tb?t3&zG20}%G~AOxBv>OTUl7TIRC8r2lhQ6 zjyF{RyjY;jA4r>;{H)^W3bnoA+SG*2%+|~fz~*%Zs&V|GyrZq_ABea*n_XYJsb_0y z&IWMuJ9j_DCZO>hGMds#!^OeG=H~j16n`%v=IUbU0CiS%0N|m48zoG6jin5=GIn)w zfc{HS2?s~do32RPLM((SuMO6}m2d?rdkRx(0jSSrCN~hh|55~imo<|BKv7-HOob@{ zO=M?b=LFPHlbv1Q=0DTT-+!qDR4}yyROjY~fxh1{w*R_MvStudTPu4&F}_2Xk{PlYi}#mb&8iTXh4{4GaJP zVfHs!UTem`uqtN{V7|KEY`Fk#7=Tl3W($JYn}UGd7>;I87f+BnaE~F*W~Lx|C3RW= zv|CVBodI;y$gdhJAOSE8h*AP*01&6L#!ZQTQCI;Fwa zV^LqL>VGR6Hd`|b;K64LNY&oij0Iu=HM^;F17~jc9lsnfCJ=iolN(X|f^z;HP5tN9 zpYZ0_V;mSTH&zBDWNISdV&!6Mc5QQhSRFB2m+xoajgYO?wW$%Xh1dfs>%n4bW)5++ zb)gjby>mir*T%`#>PH(lXTLQf#P$aY*Yr%TmDd6K3q=hxr$15@0X*B5u25MkQ&Thh zKWqNC8aK`V+Tb+-)8EbJFGPOh=tnRAt8PiV+S-Bu)ObMPF3=lXWDvyVM$cJ6e{nEe zYb&7FcCNr(0a^fthr6W}FjxQsadQT=_xoT00o>YvTpR#%X=w%pxm&qd0+nq66}NCT zbN;iw|JIS4zW-}qg|3a7fZ~n5{P!}xx#1wtAIksVhU)j{$xn5(u=`yJSpET(WcyWv ze!sqim*8v+KP;jaPzf%%s$aI@XaZZPhx zfN2HP%7pF5Oa*`e2c{~&%}hWya~X9uWr&>_o9@pU%#B_7K8N`coM5{F(+2#J0F=sa zK-k}Aza7G0+{{v7Okscn_S*tXHw@g*10MJWe+wQsZXw*dJ`jE$NXW>@NC+sXz=4AH z{lNV32@6yMsvsdCAfewzxs8T~4jk9NVPat16v4dyz`(%3#X!UUvjgsb+Q7F(m|HNC z-`ZiYkzt>}k-@`Y!@y$0!ePUG>w?XLx$Yo5EG+DGkFO786htHhRG_15mX}{pSX5k6`mDCDzM-+H zxuvtKyQjCWe_&#AYIbJXLs-P?EK>L{fDcM*f4Malkm3?ft%%d(6w_M-Z{lTr~ zAGvk@!EVsM^816`n&0?+{TsvM|HkpjPnN&U!=M4;hsB1&hPemheGx)lh9+X`6;*~N zaEB-qDQlL$oV{yc;+WbrImE~NOMNk6Z6QA;xyQtA@SIb936-F~l5x<=&{0vXjG*K_ zXYRS}bkt#ASBg&4DEj%Tv5~~-yNvJjIo$5~-TkB=*qDaW=^4)|B`WLG4XN|lEVqz3 zH27$ffcZ9Eo6wDhEPN`e$Svgk`LyoP`s7;%43oIWWg;lt;{{7kwzSmOO!H@19kRic zuVoa2W>yei=z7+M85>0&_~JsH-C- zJG+LSQtP@LkS@nYM!y`UxrepXqNcXuxXnPWw4f+PZp4$4G;zR%?_=F@q zcI{*-PNqg+j($7^BOHdbS!t;0RyDp$Rl_~CQ*z2RL4PdH-v*YeBy}Hks~X!C+MQN^ zIImI0zX#iXiKac}Oh(ot7tx8ao-~#%S2-m)Ov)1(PV*R}8L53nUIv5C!xyQo(U}?g z4tqUqEEKM8n$U3zKXP8?P59JMCQDq>dQUTtn|W2|CL{!B9sP37X82JP7=!sP^3=tX0NJ(5kr;m-XtF93dV+yah_vCWEMBuGhqeb;8L8)IAdOGz*CF^OXRb++AO zVzu804aR5fb(Uq((RlGx5PHneSmcyf*A5qxYInBP^pNoi&pwb>jn&_vk*D5Hr-H%M zGK&-;cpz-UY%T*&`k-Y(dO{$HS*J4~)mhm)`;=F}?`Y~Yz zp-XZi6eqsi!$Hr4HTp46`8t_& zkkF(0a`rE}kWYn>(7jGH(l0O_dcD5(0;$G%4PZaa_!jfXSS3j4nlOF{zI_$p3(Qx@ zS6ULrLZiy$Z{j%Ba58*dLq_s9$_4mg4Qerrv~@clJrNCJ-Z0xTkKO&?jcYt23Th;N((!$GJgtDU4gTv3q$&M4NcZA>y?jL(^_3R>Bu4(&bL(qMxw7 zaGMRy9${Jl1BqAJx5x&q`h7Zg2sM=Gq#IIO(f3Y>eGRU5r-Cc8c@w*!hw5$R9b%$S z2r?-|J@OdHNY)ce+?Je^VWk=YjRZvx4kdzaeUaPogV$>ta+W=!kvz;(DXM-uFT2Ng z1Sn=wffo~+faV^OFJ#)H^NEgr^_uA7{tcGmf$vfsTl5uOeNNk=9>7ns;d~`{iE+3vu7~S2(&$oD;)@hX~FYR5XL`vpP zc*|u-dTOYY@I7VJNt}T^lC?~ftY_^OefV~bjE(D_pW-eH>8X=$nVhxNSj6Z>y+_Xg z%{_E?5^??{L{r`7n0yhpFV<3O*e&LUVVk;VwQ27-LvNWb_{#UpRp!lgY73X>2}`+{ z2vZnx>O!5j&b0}Bfj~ zR|r(!~9Kj4Gb+Y<+1PP--v3|t+ zwAS0p(5#Qs(&Vjug6}JMAn)In99IyFct3@2soLcXfK==AWR7I|3uCF2Xjj@ENVQ44 z@>pxC-jVw_^@8*MiGhl^tq%S=)->$N!e;qmiddzaFddYuVn|9#&gx}mP34g?lXXU< z$CJ2E6%DJ_O?91nkR5d@hOVYLp&ifLFu8gQx0ooKO9`STo)sC->{Tj{fNS-6qLbik z%tyenl_q=SHu~&4>gbT#H+3Glm?m@&9~)$ueQ&(LTzE+k$rG1B4l5-s z-yR>-9B03Y{T9-muv;;^aZxzQv{XW_1qtmgY{XHodtC6I9!^A{6OFnIAx~K@@~+<1 zRt&|5h6=tSmuGTLRHrWC?i@7P;)X;YdZ#N5spUu{)*^4EBaE}FC-zzgZzS=EhX~&% z-t5Seorz$#CS9CDncLKN*07Xz+SxFh~0Kgdd;o1=5(lql~=m89!0G z`hB%q)Tq4##__@&8w1fY?AvfHQF8fDH6p{P1t;z!;i&ppTN-1d9Umk}XLRP^F%ze8 zDu$?94m8w}=vZawUckijRHV7{Lusq#KHTyMpQsK64NTVIaTUT~N~UerV#OX_NnIhu72275nbV2(q^Z@E z%+!4dkEq|?ptYb01Jb&d1=kx_Zy89Cr7fsZAsQhbcfc!dCeOxao_n}AKDC>1m~p?(hx`Wg=-Ppi-3Cpo2)zPo37^GLb$A zwo~1;K-g1=d;iRitN^o~wtl#_(wHt_aB4{JO?TuM6qGBN3WvTuE+gZ`PYB>8KN$_q>N7zyzcsx8Ei|rQG5Q%?^P)K!_fWKmhqhk2kWEt! zo-Fk{Jrm5kDO~QgJM#%HGNC*~rV>FV5_u4@%It?Z)k@^H-LwFxYq5(Z&$$ zFXwG>VYw~WK@!>?i`gS(RZAK3ZNh8l&68u&#G;H5sCK;X(;>4+VZL(qPr8uPs?G~Y z2>9fE&QXVd4~<&V!H$dSdJ zPLtGpMdv9RO#)%z2)5#B`B!=@*1z_qu7N$lub6c3%tDysS2pRtZ_&w}>`VJTMQq(S z;-w~om4`rLSO-dlQ zI+xH|Xiv#@mlRdX$;1MqFUvn|Xo5Fh5ZgZS{Sy5l{{;hWwR(zJbln}?rJkf#xz`B} zPW(r@n^!jV;wk~X$)KjE=5;iSM$RD%=lJF=x^B=DHQ}Arg#jWz4Y`x{dn^tEr5RVQ z=VZZ_HkuCnpZcT)R^?RYw;D;P)run%R=g%~6~qalmxaOa5iB-PE8h|B4YR2mVAL;j zX_~~iyu2cvbtWgLuMn6_!S&Or{6G>?G2VIf0Oa_E2Wdb{w@lqf@w8RbtyoV~_7mJ) z`VTVm)Y?~lX{Rrv8K+sxNVAOt_UJab+nk8ra1OVsu{_F&%`S!UEwstteM5@cCi`F@ zd6it#hIi|9WUw2hT z1stCTNW7D>9v4sxo19urX>J!Et;4~?$6j7 zZydJaG#RkCsJ|qzC=@M}orhmcRnghCzTQ(eHy*I&bkcS)7&jiU>I!@*=5i^m?b?VH z+)q)R&l`as?}hqzTTKaS63vk9rM5m(bfZSXAHE$$VSVd@NL{YSy>fRQPb;k%-{4lk z5s~hEqsip6#+h!B%PYqcl^s7z zE~&oq)jZx$U~z4TkF)vCt`!v<*Uqt1O~O0zw(-UnxO!O~C0FX2=cXmprk4s=aPdt1 zZF6OrxX(umst=(HQ5EAbTRp-#Y2Bm~+|SLK8kinR zmYvUJKe2v;S+4g9sd}9%d=9b}NLtplBOQHc%+>HPjtD$wyQxIKLXRDzWJ(-aX(rn& z-ItQ72b=q(fmZFp;FV=s`XJU0=(PMp?eJD(lTqQ5v01X+Z=6R)kdifG z9(xFAis)~tr%mp0gx)4I^ITMN_ReIEp$gmAx87DWr&M52<;TZcQ9!BTU=)appP$TD zE1^-UKw0IwU@uE|jP{w44=rlmwx*RW)rdQYc@#_NT*oNCps&&nMR!NLzxZa&gS$2E zX{ZO=Iv7Ue*5qV0s)4NaYK8}n<#5u<nF-(7nISdQOI+i=d=F_ZL%9?C z=R_(xTZ>20&0J6l5&V#`N#75$^6E>x>S2T;gecraL$l|f!VJP(mFoy~LCiS0Lou-X z6=j@ZO2sC#MtZOD7ZxW62GnD5W_THU_UI5qgGP7B3-5rR^>GHpak<_ zj8_sMDhv3Sh9c1AkyY=zzjJqHK+katk6s?VQ54*M1M{l}b{ z1x=}f3D9>j&zPt05SJ6AH&gC9_ z=2lh2zaNjAWr35e2bY({li?a~IBxANQcxFhM3{0^HI`*nUQEVHw?A6XvxQ1L75?6A z9i_PH1UjDa;!T%u={w62?vCsL(a%qF_Mx?A68d9D%af>u{dT#)`&Cb#cS*P z|9;Dhw&QNW^7U*_RPow19FfVi80SMe`rf96VuZ%5!ZU4l?rVw?CW zSK$+iq^-Az;iND>d?)wAm<6t?E9*ftf}XO6yzvZz&l8o#l3EWnUwc+1VU5tsPYPan zCME22YqzOSB^;lp@coZ^Sb`X#Und_O(xv&oN-r;e@z>{Vj!Ub*>LFKC8N1~;t}qZXL(v`7bdLe4Vwm1y8jUo))2v*wy_uh0(4>-Lal)M|c>7ta8gPUa7H$j1z ze%7c}PM*Q)B?XmFx{}Z0!XN)1vfeT%&b4b6CINy4m*6(I1$PM!LvYPtA-D`KL4#Xx z7~Em-!QB$veQ*oz?vP}Ev!CaEPt|wMAD{{fs&4MpSFi5A*2<6ML;4-?#q(B2D~iFw zqY0l8H|*5`!>f~h#J%EAIihigTQ|Z~vzY3U)l{#Q7Dbu|CPMB%sj<%l+e4=M#&b+@ zr3B2yFck_InD;FrB0fT!$a7Pf35!DLDX6IF z<@f02Cc>Zh`J6xjWkJ`OiB7k8qfo~FhZg7s@VJ*Sk2rc`H_rRnx?EJ@P%*dJ@KN~% zxG4Zgiw+t;q7TXtQXr#d2#U8Qj>`gN8GJvCCrtGhpz-!81ei#DX_O);W81EU|6W(B zZcYo$%%QYY=K-p>{#FoK78icJ<6{nmg7CD8woqp48B}sq|>i@0;DGjyxVDl6Z~KRV#64?j4m8_%C_0H`lWZ{3~!hl(jZj0a{{6o)Ht zYLX^L;xnK^8zv;g>cc;5RVMVJFMi<1dBq(nAbzl*WoxqYFL}zehhIADd!BIr<@c|# zpu1Xse&BD!$EKIIK9z<0Pgyl9UW!+lS-RZ8OYG1Jao)INmw_xg++uiZ?AWZYZu}s$*N;{@cQHgT@F!by@_C z2gd2N3|>NtMXm-x;)Y%6yRoje$kZE{V{uwwbI-M``Bp&(rt$q|XjBI;;srV9l|)UD zu*TVla)EM&|`Or^FtcG^O=OV=MvSoJO z?#Hje(;rBwARbgWCdFOIc7ryj19peYsBqhfpZ-tkD{#_ye*B0V2KT~3M&bK_=sq0r zTm-6y5r@;XvA_Knvs`vhHVw>fl4|=7m(t6!iTvImnAu~7nRGQ~~1K%8{My_q&5+hp=ZS;i){ssS+ z0tFS->*CMIO%8+S79#A}#HqDvTr4lwlG++yJfsaI$Y>gb%ybq}|EMtuS>MxG;b2}% z+zTCPYOZaZMpcSNOGGjAezhdsl{E^(B@(WB(P4A4T$DzwQ!m~hc#wm^>ySTIsEkS4 z$=Z(A{qTvku+wxLgY)XRU>N`ScYIJ=LHs(yObROP?^A zS-LRmmJvjO`R=d*PB#1k;F?c13C7rA;Z9=RM{36=Tvy~0TX;Km%;{#Ts9Vh|Xbg#q z$uml8HG6|gy$MFQ4Df=q%t@Qy>a(`eL;=0~XSm-rLv1x?ftJNCsf^8|`a9Wt#;nP{GILFU1rRipG33P$N|Gw{hO|Lx+3iTF|R zH*i-2Z&T035tz>~R^*^RvCfRu*Hm_bx(J!MCd=4d`BKL$d_#Wk)NDOcZ<3&9do9tZ ze-{5Qt&afS$3hb@Z*VJGTE1J$e4dAVFlpiP0lKWvTf0Cx;1qsoH#aie}qU?giv`1Vw z9c}x|r5B&RmnrLsXej{$uY{>={=~*Y)rs3!tr;zJ!Rt}cuwaOfOQ%_uKkWTctfR*N zHh<}11O+TBq1cMREEvDptmY5k%&h1b0<5hy?P~kV5DrQamZ5x6(nO3$!q#uWsG|K3 zSJVzEZ4a^Ev;u%7FJrq$(lY@mGJvQ`axg$G;)m5MfcK1$<{39OGBlL8e(uTzEMCl*J1b4nFlhMeg@^=$vGMIX|&ry}KDx z8+6<$&G@6Q;hrLs&a7^Z-sDrZ+r)~7o}(L9e+h0ZpBQF;ZmkQ*xA-0>W>DhoVKbh| z6PGMI2qqA&@w&B9DVMQ75zdzF_{joU8JB9v=A{^(6T503z?-IDz2a~UGHI*?d|9rB zEb<_ud)`D2t=^p~zagZ*lRRU7Pg2}k{}QGqKSY0eP-|3JcRm4}se+#i`~|=Wha_ap2>GO3qq;$?qMB?CWJwWKNqAvG*|?@-g?r> z+}mz@rLwAhu9~rDVyJWf;`OBy4R=_vN9m&Y+h#zY|DEKzf zQUwJ14cC7wZFha^O+{NaMmLri05|4ARAALcu4-xNy#dO&WO)SNSna$!^>=5lsF