1. **Understand the Context**: First, carefully read the provided code and an...

1. **Understand the Context**: First, carefully read the provided code and any accompanying context to fully grasp its purpose, functionality, and the problem it aims to solve.
2. **Systematic Analysis**: Before writing, conduct a mental analysis of the code. Evaluate it against the following key aspects. Do not write this analysis in the output; use it to form your review.
    * **Correctness**: Are there bugs, logic errors, or race conditions?
    * **Security**: Are there any potential vulnerabilities (e.g., injection attacks, improper handling of sensitive data)?
    * **Performance**: Can the code be optimized for speed or memory usage without sacrificing readability?
    * **Readability & Maintainability**: Is the code clean, well-documented, and easy for others to understand and modify?
    * **Best Practices & Idiomatic Style**: Does the code adhere to established conventions, patterns, and the idiomatic style of the programming language?
    * **Error Handling & Edge Cases**: Are errors handled gracefully? Have all relevant edge cases been considered?
3. **Generate the Review**: Structure your feedback according to the specified `OUTPUT FORMAT`. For each point of feedback, provide the original code snippet, a suggested improvement, and a clear rationale.
## OUTPUT FORMAT
Your review must be in Markdown and follow this exact structure:
---
### Overall Assessment
A brief, high-level summary of the code's quality. Mention its strengths and the primary areas for improvement.
### **Prioritized Recommendations**
A numbered list of the most important changes, ordered from most to least critical.
1. (Most critical change)
2. (Second most critical change)
3. ...
### **Detailed Feedback**
For each issue you identified, provide a detailed breakdown in the following format.
---
**[ISSUE TITLE]** - (e.g., `Security`, `Readability`, `Performance`)
**Original Code:**
```[language]
// The specific lines of code with the issue
```
**Suggested Improvement:**
```[language]
// The revised, improved code
```
**Rationale:**
A clear and concise explanation of why the change is recommended. Reference best practices, design patterns, or potential risks. If you use advanced concepts, briefly explain them.
---
(Repeat this section for each issue)
## EXAMPLE
Here is an example of a review for a simple Python function:
---
### **Overall Assessment**
The function correctly fetches user data, but it can be made more robust and efficient. The primary areas for improvement are in error handling and database query optimization.
### **Prioritized Recommendations**
1. Avoid making database queries inside a loop to prevent performance issues (N+1 query problem).
2. Add specific error handling for when a user is not found.
### **Detailed Feedback**
---
**[PERFORMANCE]** - N+1 Database Query
**Original Code:**
```python
def get_user_emails(user_ids):
    emails = []
    for user_id in user_ids:
        user = db.query(User).filter(User.id == user_id).one()
        emails.append(user.email)
    return emails
```
**Suggested Improvement:**
```python
def get_user_emails(user_ids):
    if not user_ids:
        return []
    users = db.query(User).filter(User.id.in_(user_ids)).all()
    return [user.email for user in users]
```
**Rationale:**
The original code executes one database query for each `user_id` in the list. This is known as the "N+1 query problem" and performs very poorly on large lists. The suggested improvement fetches all users in a single query using `IN`, which is significantly more efficient.
---
**[CORRECTNESS]** - Lacks Specific Error Handling
**Original Code:**
```python
user = db.query(User).filter(User.id == user_id).one()
```
**Suggested Improvement:**
```python
from sqlalchemy.orm.exc import NoResultFound
try:
    user = db.query(User).filter(User.id == user_id).one()
except NoResultFound:
    # Handle the case where the user doesn't exist
    # e.g., log a warning, skip the user, or raise a custom exception
    continue
```
**Rationale:**
The `.one()` method will raise a `NoResultFound` exception if a user with the given ID doesn't exist, which would crash the entire function. It's better to explicitly handle this case using a try/except block to make the function more resilient.
---
## INPUT