From 816f9d826107d3df83780f52530ed40d5365a130 Mon Sep 17 00:00:00 2001
From: codecademydev <dev@codecademy.com>
Date: Sun, 29 Dec 2024 13:05:53 +0000
Subject: [PATCH 01/31] =?UTF-8?q?=F0=9F=A4=96=20update=20concept=20of=20th?=
 =?UTF-8?q?e=20week?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bin/concept-of-the-week.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/concept-of-the-week.txt b/bin/concept-of-the-week.txt
index d1c5b89855e..310bf96da85 100644
--- a/bin/concept-of-the-week.txt
+++ b/bin/concept-of-the-week.txt
@@ -1 +1 @@
-content/c/concepts/user-input/user-input.md
\ No newline at end of file
+content/general/concepts/jit-compilation/jit-compilation.md
\ No newline at end of file

From 37bb0d5e7fade8b2077f7f3d3e9d108a9f79edbb Mon Sep 17 00:00:00 2001
From: Pragati Verma <itispragativerma@gmail.com>
Date: Thu, 2 Jan 2025 16:13:57 +0530
Subject: [PATCH 02/31] [Concept Entry] Python: Packages (#5831)

* Add package entry

* Update content/python/concepts/packages/packages.md

---------
---
 content/python/concepts/packages/packages.md | 104 +++++++++++++++++++
 1 file changed, 104 insertions(+)
 create mode 100644 content/python/concepts/packages/packages.md

diff --git a/content/python/concepts/packages/packages.md b/content/python/concepts/packages/packages.md
new file mode 100644
index 00000000000..dd80476b349
--- /dev/null
+++ b/content/python/concepts/packages/packages.md
@@ -0,0 +1,104 @@
+---
+Title: 'Packages'
+Description: 'Packages are a way to organize related modules into a directory hierarchy in Python.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Command Line'
+  - 'Packages'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+In Python, **packages** are a way to organize related modules into a directory hierarchy. Packages allow for modular code organization, making projects more readable, reusable, and maintainable. A package is essentially a directory that contains a special `__init__.py` file and one or more modules (Python files).
+
+Packages are particularly useful for:
+
+- Grouping related functionality.
+- Avoiding module name conflicts in larger codebases.
+- Providing a clear project structure.
+
+## Syntax
+
+The structure of a Python package typically looks like this:
+
+```pseudo
+project_name/
+    package_name/
+        __init__.py       # Marks the directory as a package (can be empty or include initialization code)
+        module1.py        # First module in the package
+        module2.py        # Second module in the package
+    main.py               # Main program
+```
+
+- The `__init__.py` file is required to make Python treat the directory as a package.
+- Modules (`.py` files) inside the package can be imported and used in other parts of the project.
+
+### Importing a Package
+
+To use a package or its modules, the syntax is:
+
+```pseudo
+import package_name.module_name
+
+# OR
+from package_name import module_name
+
+# OR (import specific functions or classes)
+from package_name.module_name import function_name, class_name
+```
+
+## Example
+
+Here’s an example that creates and uses a Python package:
+
+### Creating a Python Package
+
+Create a directory with following files:
+
+```shell
+mypackage/
+    __init__.py
+    module1.py
+    module2.py
+```
+
+- `__init__.py`: This file is used to indicate that the directory `mypackage` is a package. It can be empty or contain initialization code for the package.
+
+- `module1.py`: A module within the package that could contain functions or classes.
+
+```py
+# module1.py
+def greet(name):
+    return f"Hello, {name}!"
+```
+
+- `module2.py`: Another module within the package.
+
+```py
+# module2.py
+def farewell(name):
+    return f"Goodbye, {name}!"
+```
+
+### Using the Package
+
+The package and its modules can then be used in another Python script like this:
+
+```py
+# test_package.py
+import mypackage.module1 as m1
+import mypackage.module2 as m2
+
+print(m1.greet("Alice"))
+print(m2.farewell("Alice"))
+```
+
+The output of the above code will be as follows:
+
+```shell
+Hello, Alice!
+Goodbye, Alice!
+```

From a6ff03d2c951270bbe34a6df4d6a253ef780e4ad Mon Sep 17 00:00:00 2001
From: Pragati Verma <itispragativerma@gmail.com>
Date: Thu, 2 Jan 2025 16:44:37 +0530
Subject: [PATCH 03/31] [Concept Entry] Pandas: Pivot Tables (#5830)

* Add pandas pivot table entry

* Minor edits

* Add codebyte example

* Update content/pandas/concepts/pivot-tables/pivot-tables.md

* Update content/pandas/concepts/pivot-tables/pivot-tables.md

* Update content/pandas/concepts/pivot-tables/pivot-tables.md

* Update content/pandas/concepts/pivot-tables/pivot-tables.md

---------
---
 .../concepts/pivot-tables/pivot-tables.md     | 153 ++++++++++++++++++
 1 file changed, 153 insertions(+)
 create mode 100644 content/pandas/concepts/pivot-tables/pivot-tables.md

diff --git a/content/pandas/concepts/pivot-tables/pivot-tables.md b/content/pandas/concepts/pivot-tables/pivot-tables.md
new file mode 100644
index 00000000000..65baedcf1ca
--- /dev/null
+++ b/content/pandas/concepts/pivot-tables/pivot-tables.md
@@ -0,0 +1,153 @@
+---
+Title: 'Pivot Tables'
+Description: 'Pivot tables are a data summarization tool in Pandas that allow reshaping and aggregating tabular data for analysis.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Data Structures'
+  - 'Pandas'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+**Pivot tables** in [Pandas](https://www.codecademy.com/resources/docs/pandas) are a data summarization tool that perform operations such as aggregation, grouping, and reshaping of tabular data based on specific criteria, making it easier to derive meaningful insights.
+
+## Syntax
+
+The general syntax for creating a pivot table in Pandas is:
+
+```pseudo
+pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
+```
+
+- `data`: The input DataFrame.
+- `values`: The column(s) to aggregate.
+- `index`: Column(s) to group data by (rows).
+- `columns`: Column(s) to group data by (columns).
+- `aggfunc`: The aggregation function(s) (default is `mean`).
+- `fill_value`: Value to replace `NaN`s.
+- `margins`: Add subtotals (row/column totals).
+- `margins_name`: Name for row/column totals.
+- `dropna`: Whether to drop columns with `NaN` values.
+
+## Example
+
+Consider the following DataFrame:
+
+```py
+import pandas as pd
+
+data = {
+    'Region': ['North', 'South', 'East', 'West', 'North', 'South'],
+    'Category': ['A', 'A', 'B', 'B', 'A', 'B'],
+    'Sales': [100, 150, 200, 130, 120, 180]
+}
+
+df = pd.DataFrame(data)
+print(df)
+```
+
+The output for the above code will be as follows:
+
+| Region | Category | Sales |
+| ------ | -------- | ----- |
+| North  | A        | 100   |
+| South  | A        | 150   |
+| East   | B        | 200   |
+| West   | B        | 130   |
+| North  | A        | 120   |
+| South  | B        | 180   |
+
+### Pivoting Data
+
+To summarize total sales by **Region** and **Category**:
+
+```py
+pivot = pd.pivot_table(df, values='Sales', index='Region', columns='Category', aggfunc='sum', fill_value=0)
+print(pivot)
+```
+
+The output of the above code will be as follows:
+
+| Category | A   | B   |
+| -------- | --- | --- |
+| East     | 0   | 200 |
+| North    | 220 | 0   |
+| South    | 150 | 180 |
+| West     | 0   | 130 |
+
+### Adding Margins for Totals
+
+To include row and column totals in the pivot table, set `margins=True`:
+
+```py
+pivot = pd.pivot_table(df, values='Sales', index='Region', columns='Category', aggfunc='sum', fill_value=0, margins=True)
+print(pivot)
+```
+
+The output of the above code will be as follows:
+
+| Category | A   | B   | All |
+| -------- | --- | --- | --- |
+| East     | 0   | 200 | 200 |
+| North    | 220 | 0   | 220 |
+| South    | 150 | 180 | 330 |
+| West     | 0   | 130 | 130 |
+| All      | 370 | 510 | 880 |
+
+### Aggregating with Multiple Functions
+
+Multiple aggregation functions can be applied using a list:
+
+```py
+pivot = pd.pivot_table(df, values='Sales', index='Region', columns='Category', aggfunc=['sum', 'mean'], fill_value=0)
+print(pivot)
+```
+
+The output of the above code will be as follows:
+
+|        | sum |     | mean  |       |
+| ------ | --- | --- | ----- | ----- |
+| Region | A   | B   | A     | B     |
+| East   | 0   | 200 | 0.0   | 200.0 |
+| North  | 220 | 0   | 110.0 | 0.0   |
+| South  | 150 | 180 | 150.0 | 180.0 |
+| West   | 0   | 130 | 0.0   | 130.0 |
+
+## Codebyte Example
+
+Run the following example to see how pivot tables can be used to aggregate `Quantity` by `Category` and `Region`:
+
+```codebyte/python
+import pandas as pd
+
+# Sample data
+data = {
+    'Category': ['Electronics', 'Electronics', 'Clothing', 'Clothing', 'Electronics', 'Clothing'],
+    'Sub-Category': ['Phones', 'Laptops', 'Shirts', 'Shirts', 'Phones', 'Pants'],
+    'Region': ['North', 'South', 'North', 'East', 'East', 'South'],
+    'Quantity': [2, 3, 4, 1, 3, 2],
+    'Discount': [0.1, 0.2, 0.15, 0.1, 0.25, 0.05]
+}
+
+# Create a DataFrame
+df = pd.DataFrame(data)
+
+print("Original DataFrame:")
+print(df)
+
+# Create a pivot table to aggregate 'Quantity' by 'Category' and 'Region'
+pivot_table = pd.pivot_table(
+    df,
+    values='Quantity',         # Column to aggregate
+    index='Category',          # Rows
+    columns='Region',          # Columns
+    aggfunc=['sum', 'mean'],   # Aggregation functions
+    fill_value=0               # Replace NaN with 0
+)
+
+print("\nPivot Table Aggregating 'Quantity' with Sum and Mean:")
+print(pivot_table)
+```

From 87f6b861add93c74e162f26435ad47dd47e2cc1f Mon Sep 17 00:00:00 2001
From: Dani Tellini <dani.tellini1223@gmail.com>
Date: Thu, 2 Jan 2025 13:45:57 -0300
Subject: [PATCH 04/31] Concept Entry: Git - Amend (#5834)

* metadata entered

* draft amend entry - ready for pr

* check fail fix

* Update amend.md

* Update amend.md

minor fixes

* Update amend.md

---------
---
 content/git/concepts/amend/amend.md | 91 +++++++++++++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 content/git/concepts/amend/amend.md

diff --git a/content/git/concepts/amend/amend.md b/content/git/concepts/amend/amend.md
new file mode 100644
index 00000000000..95b45f397b0
--- /dev/null
+++ b/content/git/concepts/amend/amend.md
@@ -0,0 +1,91 @@
+---
+Title: 'Amend'
+Description: 'Modifies the most recent Git commit without creating a new one.'
+Subjects:
+  - 'Bash/Shell'
+  - 'Developer Tools'
+Tags:
+  - 'Command Line'
+  - 'Documentation'
+  - 'Error Handling'
+  - 'Git'
+CatalogContent:
+  - 'learn-git'
+  - 'paths/computer-science'
+---
+
+**Amend** is a Git feature that allows developers to modify the most recent commit. It is commonly used to correct mistakes such as adding a missing file, fixing an incorrect commit message, or making minor adjustments without creating an entirely new commit.
+
+This feature is particularly helpful for maintaining a clean and concise commit history, ensuring that changes are logically grouped and easy to understand.
+
+## Syntax
+
+The syntax for using the amend feature in Git is:
+
+```pseudo
+git commit --amend
+```
+
+To amend both the content of the commit and the commit message, the following would be used:
+
+```pseudo
+git commit --amend -m "Your new commit message"
+```
+
+## Example 1
+
+Suppose, the developer created and committed a feature, but forgot to include a file:
+
+```shell
+# Original commit
+echo "Initial code" > feature.txt
+echo "Forgotten content" > forgotten-file.txt
+git add feature.txt # Dev forgot to add forgotten-file.txt
+git commit -m "Add initial code for the feature"
+```
+
+Here's the original commit history:
+
+```shell
+git log --oneline
+abc1234 Add initial code for the feature
+```
+
+The developer realized that he hasn't included a file in the original commit. So, he performs the amend operation to both include the file in that commit and change the commit message:
+
+```shell
+# Amending the original commit
+git add forgotten-file.txt
+git commit --amend -m "Add initial code for the feature and forgotten file"
+```
+
+Here's the amended commit history:
+
+```shell
+git log --oneline
+def5678 Add initial code for the feature and forgotten file # Commit abc1234 has been replaced by def5678
+```
+
+## Example 2
+
+Suppose, the developer is going through another commit history:
+
+```shell
+git log --oneline
+abc1234 Original commit message
+```
+
+While going through it, the developer didn't like the above commit message. So, he decides to use the amend operation to only change the commit message without touching the contents of the commit:
+
+```shell
+git commit --amend -m "Corrected commit message"
+```
+
+Here's the amended commit history:
+
+```shell
+git log --oneline
+abc1234 Corrected commit message
+```
+
+> **Note:** Use `git commit --amend` carefully if the commit has already been shared with others, as it rewrites history.

From e7eed0b33b81e5e0d67c20510deb3167a4c878f3 Mon Sep 17 00:00:00 2001
From: codecademydev <dev@codecademy.com>
Date: Sun, 5 Jan 2025 13:06:17 +0000
Subject: [PATCH 05/31] =?UTF-8?q?=F0=9F=A4=96=20update=20concept=20of=20th?=
 =?UTF-8?q?e=20week?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bin/concept-of-the-week.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/concept-of-the-week.txt b/bin/concept-of-the-week.txt
index 310bf96da85..4829c2f3c48 100644
--- a/bin/concept-of-the-week.txt
+++ b/bin/concept-of-the-week.txt
@@ -1 +1 @@
-content/general/concepts/jit-compilation/jit-compilation.md
\ No newline at end of file
+content/r/concepts/built-in-functions/built-in-functions.md
\ No newline at end of file

From b7624d0e5404cfa093c248769bf7ee904bb50302 Mon Sep 17 00:00:00 2001
From: John Rood <john.rood@skillsoft.com>
Date: Mon, 6 Jan 2025 16:24:44 -0600
Subject: [PATCH 06/31] Check to verify that there are not missing md files
 (#5553)

* Github check to verify that there are not missing md files

* linebreaks
---
 .github/scripts/validate-content-tree.js | 22 ++++++++++++++++++++++
 .github/workflows/push.yml               |  2 +-
 package.json                             |  3 ++-
 3 files changed, 25 insertions(+), 2 deletions(-)
 create mode 100644 .github/scripts/validate-content-tree.js

diff --git a/.github/scripts/validate-content-tree.js b/.github/scripts/validate-content-tree.js
new file mode 100644
index 00000000000..98386de582a
--- /dev/null
+++ b/.github/scripts/validate-content-tree.js
@@ -0,0 +1,22 @@
+const { readdirSync } = require('node:fs');
+
+let exitCode = 0;
+
+const next = ['concepts', 'terms'];
+
+function checkPath(path, i) {
+  for (const entry of readdirSync(path)) {
+    const entryDir = readdirSync(`${path}/${entry}`);
+    if (!entryDir.includes(`${entry}.md`)) {
+      console.error(`\n${path}/${entry} should contain a ${entry}.md file\n`);
+      exitCode = 1;
+    }
+    if (i < 2 && entryDir.includes(next[i])) {
+      checkPath(`${path}/${entry}/${next[i]}`, i + 1);
+    }
+  }
+}
+
+checkPath('content', 0);
+
+process.exit(exitCode);
diff --git a/.github/workflows/push.yml b/.github/workflows/push.yml
index c666a7e3c87..10609797248 100644
--- a/.github/workflows/push.yml
+++ b/.github/workflows/push.yml
@@ -11,7 +11,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        command: ["compile", "format:verify", "lint:js", "lint:md", "test"]
+        command: ["compile", "format:verify", "lint:js", "lint:md", "test", "validate-content-tree"]
 
 on:
   push:
diff --git a/package.json b/package.json
index d1c0b64275a..25ccb7da153 100644
--- a/package.json
+++ b/package.json
@@ -36,7 +36,8 @@
     "lint:md": "markdownlint \"./content/**/*.md\"",
     "lint": "yarn lint:md && yarn lint:js",
     "test": "jest",
-    "prepare": "husky install"
+    "prepare": "husky install",
+    "validate-content-tree": "node .github/scripts/validate-content-tree.js"
   },
   "license": "UNLICENSED",
   "version": "1.0.0"

From f5d5c1b80b8aa327efe46ea9cf76e5934ff1888a Mon Sep 17 00:00:00 2001
From: Nil-Morah <172632764+Nil-Morah@users.noreply.github.com>
Date: Tue, 7 Jan 2025 07:14:29 +0100
Subject: [PATCH 07/31] Volatile variables (#5721)

* volatile-variables file created and filled, examples pending

* Created volatile variable term for cpp variables

* File has been added.

* File has been modified.

* minor changes

* Fixes

---------
---
 .../volatile-variables/volatile-variables.md  | 59 +++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 content/cpp/concepts/variables/terms/volatile-variables/volatile-variables.md

diff --git a/content/cpp/concepts/variables/terms/volatile-variables/volatile-variables.md b/content/cpp/concepts/variables/terms/volatile-variables/volatile-variables.md
new file mode 100644
index 00000000000..7501d2e6819
--- /dev/null
+++ b/content/cpp/concepts/variables/terms/volatile-variables/volatile-variables.md
@@ -0,0 +1,59 @@
+---
+Title: 'Volatile Variables'
+Description: 'Ensures variables avoid compiler optimization, allowing correct access when their values may change due to external factors.'
+Subjects:
+  - 'Computer Science'
+  - 'Code Foundations'
+Tags:
+  - 'Memory'
+  - 'Variables'
+  - 'Variable Types'
+CatalogContent:
+  - 'learn-c-plus-plus'
+  - 'paths/computer-science'
+---
+
+**Volatile variables** in C++ are not optimized or cached by the compiler. Marking a variable as volatile is appropriate when its value may be altered by external factors beyond the program's control. This instructs the compiler to read the most recent value from memory instead of a potentially outdated cached version. However, it's important to note that declaring a variable as volatile does not ensure atomicity or synchronize memory between threads; it solely prevents compiler optimization, which is particularly crucial in multithreaded environments.
+
+## Syntax
+
+To declare a variable as volatile, the `volatile` keyword needs to be placed before the variable type:
+
+```pseudo
+volatile data_type variable_name;
+```
+
+## Example
+
+A volatile variable signals a worker thread to stop running and performing tasks in the following example. The `volatile` keyword prevents the compiler from optimizing away, continuously checking the variable while in the loop. The worker thread will continue until the `isRunning` variable is false.
+
+```cpp
+#include <iostream>
+#include <thread>
+#include <chrono>
+class VolatileExample {
+private:
+    // 'volatile' tells the compiler not to optimize this variable, ensuring that each iteration of the following loop fetches the latest value.
+    volatile bool isRunning = true;
+public:
+    void runTask() {
+        while (isRunning) {
+            std::cout << "Task is running..." << std::endl;
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+        std::cout << "Task has stopped." << std::endl;
+    }
+    void stopTask() {
+        isRunning = false; // Changing 'isRunning' to false to stop the task.
+    }
+};
+int main() {
+    VolatileExample example;
+    std::thread workerThread(&VolatileExample::runTask, &example);
+    // The task runs for a while before stopping it.
+    std::this_thread::sleep_for(std::chrono::seconds(5));
+    example.stopTask(); // Stop the task
+    workerThread.join(); // Waits for the thread to finish.
+    return 0;
+}
+```

From 70c3df1c02f260bf46dbd62d6524a6629980331f Mon Sep 17 00:00:00 2001
From: Tommaso Berti <152935267+tommaso-berti@users.noreply.github.com>
Date: Tue, 7 Jan 2025 07:39:00 +0100
Subject: [PATCH 08/31] feat: [Concept Entry] Git Checkout (#5748) (#5769)

* feat: [Concept Entry] Git Checkout (#5748)

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Update content/git/concepts/checkout/checkout.md

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* Apply suggestions from code review

Co-authored-by: Pragati Verma <itispragativerma@gmail.com>

* feat: [Concept Entry] Git Checkout (#5748): added optional flags

* Update options syntax

* Update checkout.md

* fix: [Bug/Error] Java Map: .replaceAll() (Codecademy#5748)

* revert wrong commit on feat branch

* Minor fixes

* Formatting fixes

---------
---
 content/git/concepts/checkout/checkout.md | 76 +++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 content/git/concepts/checkout/checkout.md

diff --git a/content/git/concepts/checkout/checkout.md b/content/git/concepts/checkout/checkout.md
new file mode 100644
index 00000000000..b023674d34d
--- /dev/null
+++ b/content/git/concepts/checkout/checkout.md
@@ -0,0 +1,76 @@
+---
+Title: 'Checkout'
+Description: 'The git checkout command switches, creates and restores branches in the working directory to a specific state.'
+Subjects:
+  - 'Bash/Shell'
+  - 'Developer Tools'
+Tags:
+  - 'Git'
+  - 'GitHub'
+CatalogContent:
+  - 'learn-git'
+  - 'learn-the-command-line'
+  - 'paths/computer-science'
+---
+
+The **`git checkout`** command switches, creates and restores branches in the working directory to a specific state. The `git checkout` command also allows switching to a specific commit without changing branches.
+
+## Syntax
+
+Checkout with branches:
+
+```pseudo
+git checkout [options] <branch-name>
+```
+
+- `<branch-name>` specifies the name of the branch to switch to or create.
+- `[options]` optional flags that can be used with the checkout command. Here are some of the most commonly used options:
+  - `-b` creates a new branch with the specified name and switches to it immediately.
+  - `-` returns to the previously checked-out branch. This flag does not need the `<branch-name>`.
+  - `-f` (--force) forces the checkout, discarding any local changes in the working directory.
+
+Checkout to a specific commit:
+
+```pseudo
+git checkout <commit-hash>
+```
+
+## Switch to an existing branch
+
+The following command will switch to an already existing branch, created previously with the [git branch](https://www.codecademy.com/resources/docs/git/branch) command:
+
+```pseudo
+git checkout existing-branch
+```
+
+> **Note**: From Git 2.23, the new specific `git switch` command has been introduced to switch branches, making it clearer and safer than `git checkout` because it avoids the ambiguity of the latter's multi-purpose nature.
+
+## Create and switch to a new branch
+
+It is possible to create and switch to a new branch with a single command using the `-b` option:
+
+```pseudo
+git checkout -b new-branch
+```
+
+## Restore a file from a specific commit
+
+`git checkout` also allows to restore a file from a specific commit using its hash:
+
+```pseudo
+git checkout <commit-hash> -- example.txt
+```
+
+## Examine a Previous Commit
+
+`git checkout` also allows temporarily moving to a specific commit without changing branches. This state is called **detached `HEAD` state**:
+
+```pseudo
+git checkout <commit-hash>
+```
+
+The detached `HEAD` state allows to:
+
+- Examine the state of the repository at that specified commit.
+- Create new branches if the developer needs to start from that point.
+- Any code changes made in this state will not be associated with any existing branch unless a new branch is created.

From 934f2b9f4ebe989f733d7063ee047f16530c6e00 Mon Sep 17 00:00:00 2001
From: John Rood <john.rood@skillsoft.com>
Date: Tue, 7 Jan 2025 09:26:26 -0600
Subject: [PATCH 09/31] Update post-merge copy (#5922)

---
 .github/workflows/post-merge-messages.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/post-merge-messages.yml b/.github/workflows/post-merge-messages.yml
index 3355c834b32..202ee23781a 100644
--- a/.github/workflows/post-merge-messages.yml
+++ b/.github/workflows/post-merge-messages.yml
@@ -43,7 +43,6 @@ jobs:
             ${{ env.urls }}
             
             Please note it may take a little while for changes to become visible.
-            If you're appearing as anonymous and want to be credited, see [here](https://discuss.codecademy.com/t/my-contribution-is-live-but-im-not-being-shown-as-a-contributor-why-is-this/758036).
+            If you're appearing as anonymous and want to be credited, visit the [linked accounts](https://www.codecademy.com/account/linked_accts) page and ensure that your GitHub account is linked.
           issuesClosed: |
             🌸 Thanks for closing this Issue!
-            Please head over to the [Docs Forum](https://discuss.codecademy.com/c/community/community-docs/2205) if you have any questions about Docs, or reply to the thread on [Possible Content Discussion](https://discuss.codecademy.com/t/find-a-starting-point-possible-content-discussion/745868) to share ideas and collaborate with other contributors, maintainers, or super users to determine good future issues that will help expand Docs!

From 6cf99d185e3cf39fe032c19b7f531fc9ee74b73f Mon Sep 17 00:00:00 2001
From: Valeriy Anysenko <168164564+vlrnsnk@users.noreply.github.com>
Date: Tue, 7 Jan 2025 12:56:41 -0500
Subject: [PATCH 10/31] Update json.md (#5891)

Remove trailing commas on pseudocode JSON
---
 content/general/concepts/json/json.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/general/concepts/json/json.md b/content/general/concepts/json/json.md
index 6758ebe3c9c..f05f1e055da 100644
--- a/content/general/concepts/json/json.md
+++ b/content/general/concepts/json/json.md
@@ -36,7 +36,7 @@ More can be learned about JSON by visiting [json.org](https://www.json.org/).
 {
   "propertyOne": "valueOne",
   "propertyTwo": "valueTwo",
-  "propertyThree": "valueThree",
+  "propertyThree": "valueThree"
 }
 ```
 
@@ -60,12 +60,12 @@ Multiple JSON objects can be collected in an array-like sequence:
   {
     "propertyOne": "valueOne",
     "propertyTwo": "valueTwo",
-    "propertyThree": "valueThree",
+    "propertyThree": "valueThree"
   },
   {
     "propertyA": "valueA",
     "propertyB": "valueB",
-    "propertyC": "valueC",
+    "propertyC": "valueC"
   }
 ]
 ```

From 6d2f3d2d517053f323334cda23b445985dfafd32 Mon Sep 17 00:00:00 2001
From: Savi Dahegaonkar <124272050+SaviDahegaonkar@users.noreply.github.com>
Date: Wed, 8 Jan 2025 12:00:00 +0530
Subject: [PATCH 11/31] [Term Entry] Python statsmodels: anova_lm() (#5907)

* New file has been added.

* Update user-input.md

* Update user-input.md

* File has been modified.

* Update anova-lm.md

major fixes in meta data and some content

* Update anova-lm.md

---------
---
 .../statsmodels/terms/anova-lm/anova-lm.md    | 63 +++++++++++++++++++
 1 file changed, 63 insertions(+)
 create mode 100644 content/python/concepts/statsmodels/terms/anova-lm/anova-lm.md

diff --git a/content/python/concepts/statsmodels/terms/anova-lm/anova-lm.md b/content/python/concepts/statsmodels/terms/anova-lm/anova-lm.md
new file mode 100644
index 00000000000..e63d6e6bc7f
--- /dev/null
+++ b/content/python/concepts/statsmodels/terms/anova-lm/anova-lm.md
@@ -0,0 +1,63 @@
+---
+Title: 'anova_lm'
+Description: 'Performs an analysis of variance (ANOVA) on one or more fitted linear models to assess their goodness-of-fit and compare their explanatory power.'
+Subjects:
+  - 'Data Science'
+  - 'Machine Learning'
+Tags:
+  - 'Python'
+  - 'Statsmodels'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/data-science'
+---
+
+**`anova_lm()`** is the function in Python's [`statsmodels`](https://www.codecademy.com/resources/docs/python/statsmodels) library that produces an ANOVA table for one or more fitted linear models. ANOVA (Analysis of Variance) is a statistical method used to determine whether there are significant differences between the means of three or more groups. Researchers and analysts can use `anova_lm()` to evaluate the effects of categorical variables on a continuous outcome and compare nested linear models to assess their relative explanatory power.
+
+## Syntax
+
+```pseudo
+statsmodels.stats.anova.anova_lm(*args, **kwargs)
+```
+
+- `*args`: One or more fitted model results (e.g., instances of `OLS` model results) to perform ANOVA on.
+- `**kwargs`: Optional keyword arguments to customize the ANOVA test, such as:
+  - `scale`: Specifies the scale parameter.
+  - `test`: Type of test (e.g., 'F' for F-test).
+  - `typ`: Specifies the type of sum of squares to calculate (e.g., Type I, II, or III).
+  - `robust`: If `True`, performs a robust ANOVA.
+
+## Example
+
+This example demonstrates how to use the `anova_lm()` function in the `statsmodels` library to perform analysis of variance on a fitted linear model:
+
+```py
+import statsmodels.api as sm
+from statsmodels.formula.api import ols
+from statsmodels.stats.anova import anova_lm
+import pandas as pd
+
+# Load example data
+data = sm.datasets.get_rdataset('iris').data
+
+# Rename columns to make them Python-friendly
+data.rename(columns=lambda x: x.replace('.', '_'), inplace=True)
+
+# Fit a linear regression model using Ordinary Least Squares (OLS)
+model = ols('Sepal_Length ~ Petal_Length + Petal_Width', data=data).fit()
+
+# Perform ANOVA on the fitted model
+anova_results = anova_lm(model, typ=2)
+
+# Print the ANOVA table
+print(anova_results)
+```
+
+The ANOVA table produced shows the sum of squares, degrees of freedom, F-statistics, and p-values, helping to evaluate the significance of each predictor in the model:
+
+```shell
+                 sum_sq     df          F        PR(>F)
+Petal_Length   9.934196    1.0  61.150938  9.414477e-13
+Petal_Width    0.644340    1.0   3.966300  4.827246e-02
+Residual      23.880694  147.0        NaN           NaN
+```

From 583a11f3030c1c5c02d50f1beff6290993090574 Mon Sep 17 00:00:00 2001
From: Sudharshanan <71761488+Maverick073@users.noreply.github.com>
Date: Wed, 8 Jan 2025 12:38:22 +0530
Subject: [PATCH 12/31] Added docs for javascript spread operator - #5802 
 (#5827)

* Added docs for javascript spread operator

* Update spread-operator.md

fixes done

* Update spread-operator.md

* Update content/javascript/concepts/spread-operator/spread-operator.md

* Update content/javascript/concepts/spread-operator/spread-operator.md

* Update content/javascript/concepts/spread-operator/spread-operator.md

---------
---
 .../spread-operator/spread-operator.md        | 91 +++++++++++++++++++
 1 file changed, 91 insertions(+)
 create mode 100644 content/javascript/concepts/spread-operator/spread-operator.md

diff --git a/content/javascript/concepts/spread-operator/spread-operator.md b/content/javascript/concepts/spread-operator/spread-operator.md
new file mode 100644
index 00000000000..d69bfef4d62
--- /dev/null
+++ b/content/javascript/concepts/spread-operator/spread-operator.md
@@ -0,0 +1,91 @@
+---
+Title: 'Spread Operator'
+Description: 'Expands elements of an array, object, or iterable in JavaScript.'
+Subjects:
+  - 'Computer Science'
+  - 'Web Development'
+Tags:
+  - 'Arrays'
+  - 'Functions'
+  - 'Objects'
+  - 'Spread Operator'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+The **Spread Operator** in JavaScript, represented by three dots (`...`), is used to expand or unpack elements of arrays, objects, or other iterables into individual elements.
+
+The spread operator performs a shallow copy, meaning that for nested objects or arrays, changes in the copied object/array might reflect in the original.
+
+## Syntax
+
+The syntax of spread operator for arrays is as follows:
+
+```pseudo
+const nums = [...nums1 , ...nums2]   // arrays
+```
+
+The syntax of spread operator for objects is as follows:
+
+```pseudo
+const obj = {...obj1, ...obj2}      // objects
+```
+
+- `nums1` and `nums2` are arrays. They represent any two arrays that need to be merged into a single array.
+- `obj1` and `obj2` are objects. They represent two objects that should be combined into one.
+
+## Example
+
+The following example demonstrates how to use the spread operator:
+
+```js
+const nums1 = [1, 2, 3];
+const nums2 = [4, 5, 6];
+const nums = [...nums1, ...nums2];
+console.log(nums);
+
+const obj1 = { name: 'Subro' };
+const obj2 = { age: 22 };
+const obj = { ...obj1, ...obj2 };
+console.log(obj);
+```
+
+This example results in the following output:
+
+```shell
+[1, 2, 3, 4, 5, 6]
+{ name: 'Subro', age: 22 }
+```
+
+## Codebyte Example
+
+Run the codebyte example below to understand how the spread operator works:
+
+```codebyte/javascript
+function sum(a, b, c) {
+  return a + b + c;
+}
+
+const numbers = [1, 2, 3];
+console.log(sum(...numbers));
+
+// Original object with nested data
+const originalObj = {
+  name: 'Subro',
+  address: {
+    city: 'Lalaland',
+    zip: '12345'
+  }
+};
+
+// Creating a shallow copy using the spread operator
+const shallowCopyObj = { ...originalObj };
+
+// Modifying the nested object in the copy
+shallowCopyObj.address.city = 'Wonderland';
+
+console.log('Shallow Copy:', shallowCopyObj);
+console.log('Original Object:', originalObj);
+// The nested 'address' object is shared between the original and the shallow copy, so modifying it affects both objects.
+```

From 7340800a504df225c17b7c2abc59c00ccc242f19 Mon Sep 17 00:00:00 2001
From: ebikatsudon <99709771+ebikatsudon@users.noreply.github.com>
Date: Tue, 7 Jan 2025 23:44:29 -0800
Subject: [PATCH 13/31] [Edit] Combine Duplicate Focus Group Entries (#5829)

* merged conflicting focus group entries into one

* updated to fix formatting errors

* Revert yarn.lock changes

* Revert yarn.lock changes

* Revert yarn.lock changes

* Revert yarn.lock changes

* Update focus-group.md

* Update focus-group.md

* Update focus-group.md

* Update focus-group.md

---------
---
 .../uiux/concepts/focus-group/focus-group.md  | 57 +++++++++++--------
 .../concepts/focus-groups/focus-groups.md     | 29 ----------
 2 files changed, 34 insertions(+), 52 deletions(-)
 delete mode 100644 content/uiux/concepts/focus-groups/focus-groups.md

diff --git a/content/uiux/concepts/focus-group/focus-group.md b/content/uiux/concepts/focus-group/focus-group.md
index eb4139d180a..9569f48dad8 100644
--- a/content/uiux/concepts/focus-group/focus-group.md
+++ b/content/uiux/concepts/focus-group/focus-group.md
@@ -1,10 +1,10 @@
 ---
 Title: 'Focus Group'
-Description: 'A qualitative attitudinal research method used to anticipate user needs and wants through direct interaction with possible users.'
+Description: 'A qualitative research method that involves asking questions to a small group of users to obtain feedback on a topic, product, or design.'
 Subjects:
   - 'Web Design'
 Tags:
-  - 'Methods'
+  - 'Design'
   - 'UI'
   - 'UX'
 CatalogContent:
@@ -12,32 +12,43 @@ CatalogContent:
   - 'paths/front-end-engineer-career-path'
 ---
 
-The **Focus Group** is a powerful method used in Human-Computer Interaction (HCI) and User Experience (UX) design for User Research. It serves as a means to gather insights from users before and after the development of the product. As focus groups are a self-reported method of user research, they only help gauge users' perspectives of their wants, needs, and actions. So, they are an inaccurate representation of users' actions and thoughts. Focus groups follow the following pattern:
+**Focus groups** are a [user research method](https://www.codecademy.com/resources/docs/uiux/user-research) in which a moderator guides a group of participants (typically 4-12 users) through a series of questions about a topic, product, or design. These questions help researchers understand the in-depth motivations and thought processes behind the user experience. Because the data is self-reported by users, focus groups are also considered an [attitudinal research method](https://www.codecademy.com/resources/docs/uiux/attitudinal-research). Some fields of study that utilize focus groups are market research, Human-Computer Interaction (HCI), and [User Experience (UX) Design](https://www.codecademy.com/resources/docs/uiux/ux-design).
 
-## Steps in Focus Groups
+Focus groups can be more cost- and time-efficient compared to one-on-one [interviews](https://www.codecademy.com/resources/docs/uiux/interviews), as researchers can gather feedback from a diverse group of participants all at once. The real-time group dynamic of focus groups may also encourage participants to open up and share their thoughts more than they would with other methodologies, such as [surveys](https://www.codecademy.com/resources/docs/uiux/surveys).
 
-A typical focus group involves:
+The following are some examples of qualitative data that can be obtained through focus groups:
 
-- **Selection of Participants:** Carefully select a diverse group of participants representing the target user demographic.
-- **Preparation of Materials:** Prepare prototypes, wireframes, or design concepts for participants to evaluate.
-- **Facilitation:** A skilled facilitator guides the discussion, encouraging participants to express their thoughts, opinions, and concerns.
-- **Observation:** Designers and stakeholders observe the session, taking notes on participant reactions and comments.
-- **Post-Session Analysis:** Analyze the collected data to derive actionable insights for design improvements.
+- **User Perspectives:** How users interact with or think about a product or service.
+- **User Feedback:** Direct feedback on design elements, usability, and overall user experience.
+- **Pain Points:** Any challenges or difficulties users may face when using a product.
+- **Design Improvements:** User-driven suggestions on how a product or concept could be improved.
 
-## About Focus Groups
+## Focus Group Methodology
 
-The purpose of focus groups is given below:
+A typical focus group involves the following steps:
 
-- **Understand User Perspectives:** Gain a deeper understanding of how users interact with a product or service.
-- **Collect Feedback:** Obtain direct feedback on design elements, usability, and overall user experience.
-- **Identify Pain Points:** Identify pain points and challenges users may face during interaction.
-- **Generate Ideas:** Stimulate creative thinking and generate new design ideas.
-- **Validate Design Decisions:** Validate design decisions through user opinions and preferences.
+1. **Participant Selection:** Researchers select a diverse group of users representing the target demographic, usually through a screening process.
+2. **Preparation of Materials:** Researchers prepare materials such as prototypes, wireframes, or design concepts for evaluation.
+3. **Facilitation:** During the focus group, a moderator guides the discussion and encourages participants to express their thoughts, opinions, and concerns.
+4. **Observation:** Researchers observe the session, noting participants' reactions and feedback.
+5. **Post-Session Analysis:** Researchers analyze the collected data to derive actionable insights for design improvements.
 
-The best practices to follow while conducting focus groups are:
+A focus group may also integrate activities like collaging, drawing, brainstorming with sticky notes, card-sorting, or role-playing to increase participant engagement and break away from the standard question-and-answer format.
 
-- **Diversity Matters:** Ensure participants represent diverse demographics, including age, gender, and technological proficiency.
-- **Clear Objectives:** Define clear objectives for the focus group to guide discussions effectively.
-- **Neutral Facilitation:** The facilitator should remain neutral, encouraging open and honest feedback.
-- **Use of Prototypes:** Whenever possible, utilize prototypes or interactive elements to simulate the user experience.
-- **Incorporate User Stories:** Use real-life scenarios or user stories to contextualize discussions.
+## Best Practices for Focus Groups
+
+Some principles to keep in mind when conducting a focus group are:
+
+- **Diversity:** Select participants who represent a range of demographics, including age, gender, and technological proficiency.
+- **Clear Objectives:** Clearly define the goals of the focus group for effective discussions.
+- **Neutral Facilitation:** Emphasize neutral moderation and encourage honest feedback.
+- **User Interactivity:** Incorporate prototypes or interactive elements to enhance user engagement.
+- **User-centric Storytelling:** Contextualize discussions with real-life scenarios or user stories.
+
+## Additional Focus Group Resources
+
+- [User Interviews: Focus Groups](https://www.userinterviews.com/ux-research-field-guide-chapter/focus-groups)
+- [Interaction Design Foundation: How to Conduct Focus Groups](https://www.interaction-design.org/literature/article/how-to-conduct-focus-groups)
+- [Nielsen Norman Group: The Use and Misuse of Focus Groups](https://www.nngroup.com/articles/focus-groups/)
+- [UX Matters: Do’s and Don’ts for Focus Groups](https://www.uxmatters.com/mt/archives/2011/07/dos-and-donts-for-focus-groups.php)
+- [Adobe XD: Why Focus Groups Benefit the Web Design Process](https://xd.adobe.com/ideas/process/user-research/why-focus-groups-benefit-web-design-process/)
diff --git a/content/uiux/concepts/focus-groups/focus-groups.md b/content/uiux/concepts/focus-groups/focus-groups.md
deleted file mode 100644
index aa39eee5885..00000000000
--- a/content/uiux/concepts/focus-groups/focus-groups.md
+++ /dev/null
@@ -1,29 +0,0 @@
----
-Title: 'Focus Groups'
-Description: 'Focus groups are a user research method where a researcher guides a group of 3 to 10 participants through a series of questions about a topic, product, or design.'
-Subjects:
-  - 'Web Design'
-Tags:
-  - 'UI'
-  - 'UX'
-  - 'Design'
-CatalogContent:
-  - 'intro-to-ui-ux'
-  - 'paths/front-end-engineer-career-path'
----
-
-**Focus groups** are a [user research](https://www.codecademy.com/resources/docs/uiux/user-research) method where a researcher guides a group of 3 &ndash; 10 participants through a series of questions about a topic, product, or design. Focus groups can be conducted either remotely or in-person.
-
-Because focus groups rely on self-reported user data, they are considered an [attitudinal research method](https://www.codecademy.com/resources/docs/uiux/attitudinal-research). Focus groups are considered a [qualitative research method](https://www.codecademy.com/resources/docs/uiux/qualitative-research) since they focus on the in-depth motivations and thought processes behind the user experience. [Interviews](https://www.codecademy.com/resources/docs/uiux/interviews) are typically one-on-one, while focus groups collect qualitative feedback from a group of participants.
-
-Focus groups are commonly used in market research to collect feedback about a product or brand. In UX research, they can be used to collect data or feedback that may be difficult to collect in a typical interview or [survey](https://www.codecademy.com/resources/docs/uiux/surveys). Unlike a survey or one-on-one interview, a focus group has a social dynamic that may facilitate participants opening up and sharing their thoughts.
-
-Before conducting a focus group, the moderator will need to prepare a discussion guide to focus the conversation. Adding activities like collaging, drawing, brainstorming with sticky notes, card sorting, or role-playing can help engage participants and break away from a standard question-and-answer format.
-
-## Focus Resources
-
-- [User Interviews: Focus Groups](https://www.userinterviews.com/ux-research-field-guide-chapter/focus-groups)
-- [Interaction Design Foundation: How to Conduct Focus Groups](https://www.interaction-design.org/literature/article/how-to-conduct-focus-groups)
-- [Nielsen Norman Group: The Use and Misuse of Focus Groups](https://www.nngroup.com/articles/focus-groups/)
-- [UX Matters: Do’s and Don’ts for Focus Groups](https://www.uxmatters.com/mt/archives/2011/07/dos-and-donts-for-focus-groups.php)
-- [Adobe XD: Why Focus Groups Benefit the Web Design Process](https://xd.adobe.com/ideas/process/user-research/why-focus-groups-benefit-web-design-process/)

From 148c7d5627aca565777ae595a2ad7884782e2374 Mon Sep 17 00:00:00 2001
From: Savi Dahegaonkar <124272050+SaviDahegaonkar@users.noreply.github.com>
Date: Wed, 8 Jan 2025 17:09:25 +0530
Subject: [PATCH 14/31] [Concept Entry] Rust: Ownership (#5880)

* New file has been added.

* Update user-input.md

* Update user-input.md

* File has been modified.

* Update content/rust/concepts/ownership/ownwership.md

* Update content/rust/concepts/ownership/ownwership.md

* Update content/rust/concepts/ownership/ownwership.md

* Rename ownwership.md to ownership.md

fixed minor issues and corrected file name spelling

* Update content/rust/concepts/ownership/ownership.md

* Update ownership.md

* Update ownership.md

---------
---
 content/rust/concepts/ownership/ownership.md | 78 ++++++++++++++++++++
 1 file changed, 78 insertions(+)
 create mode 100644 content/rust/concepts/ownership/ownership.md

diff --git a/content/rust/concepts/ownership/ownership.md b/content/rust/concepts/ownership/ownership.md
new file mode 100644
index 00000000000..ca691a6b799
--- /dev/null
+++ b/content/rust/concepts/ownership/ownership.md
@@ -0,0 +1,78 @@
+---
+Title: 'Ownership'
+Description: 'A compile-time system enforcing strict memory safety rules.'
+Subjects:
+  - 'Code Foundations'
+  - 'Computer Science'
+  - 'Developer Tools'
+Tags:
+  - 'Alias'
+  - 'Const'
+  - 'Memory'
+CatalogContent:
+  - 'rust-for-programmers'
+  - 'paths/computer-science'
+---
+
+**Ownership** in Rust is one of the core memory management concepts that ensures every value has a single owner responsible for it. This system avoids memory leaks and data races without needing a garbage collector. Ownership features include move semantics, where the ownership is transferred between variables, borrowing, and the borrow checker, by which these rules are checked at compile time to keep memory safe.
+
+## Syntax
+
+Here's the syntax for the ownership concept in Rust:
+
+```pseudo
+let variable1 = value;
+let variable2 = variable1;
+// 'variable1' is no longer valid and cannot be accessed.
+```
+
+- `variable1`: First owner of the value.
+- `value`: The value or data to be owned initially.
+- `variable2`: New owner of `value` after the ownership transfer.
+
+## Example
+
+This example demonstrates how ownership works, ensuring that only one variable owns the data at a time:
+
+```rust
+fn main() {
+    let s1 = String::from("Hello, Welcome to Codecademy!");
+    println!("s1: {}", s1);
+    let s2 = take_ownership(s1);
+    // println!("s1: {}", s1);  // Uncommenting this line would result in a compile-time error because 's1' no longer owns the value.
+    println!("s2: {}", s2);  // Prints: s2: Hello, Welcome to Codecademy!
+}
+
+fn take_ownership(s: String) -> String {  // Function takes ownership of the passed value
+    println!("Taking ownership: {}", s);  // Prints: Taking ownership: Hello, Welcome to Codecademy!
+    s  // Ownership is returned to the caller, moving it back to the caller.
+}
+```
+
+In this example, the ownership of the string s1 is moved to s2, and s1 is no longer valid. After moving, s2 holds the ownership of the string "Hello, Welcome to Codecademy!":
+
+The example will result in the following output:
+
+```shell
+s1: Hello, Welcome to Codecademy!
+Taking ownership: Hello, Welcome to Codecademy!
+s2: Hello, Welcome to Codecademy!
+```
+
+### Unsafe Code Example
+
+Rust’s ownership system prevents operations that could lead to unsafe memory access, like accessing data after ownership is moved, at compile time :
+
+```rust
+fn main() {
+    let s1 = String::from("Hello");
+    let s2 = take_ownership(s1);
+    // println!("{}", s1);  // Uncommenting this line would cause a compile-time error: use of moved value
+}
+
+fn take_ownership(s: String) -> String {
+    s
+}
+```
+
+In this unsafe scenario, the ownership of `s1` is moved to `s2`, and attempting to access `s1` after the move results in a compile-time error.

From acf7d5bc3dd503c58b85cb647d078768a983f899 Mon Sep 17 00:00:00 2001
From: hitomiyamamoto <hitomi0727pupil@gmail.com>
Date: Wed, 8 Jan 2025 16:49:35 +0100
Subject: [PATCH 15/31] [Concept Entry] JavaScript: Nullish Coalescing

* Initial commit

* removed extra information and modified grammar mistakes

* Update nullish-coalescing.md

minor fixes

* Minor changes

---------
---
 .../nullish-coalescing/nullish-coalescing.md  | 53 +++++++++++++++++++
 1 file changed, 53 insertions(+)
 create mode 100644 content/javascript/concepts/nullish-coalescing/nullish-coalescing.md

diff --git a/content/javascript/concepts/nullish-coalescing/nullish-coalescing.md b/content/javascript/concepts/nullish-coalescing/nullish-coalescing.md
new file mode 100644
index 00000000000..d7523d3c534
--- /dev/null
+++ b/content/javascript/concepts/nullish-coalescing/nullish-coalescing.md
@@ -0,0 +1,53 @@
+---
+Title: 'Nullish Coalescing'
+Description: 'Returns the right-hand operand in case the left-hand operand is null or undefined. Otherwise, it returns the left-hand operand.'
+Subjects:
+  - 'Web Development'
+  - 'Computer Science'
+Tags:
+  - 'Comparison'
+  - 'Logical'
+  - 'Operators'
+CatalogContent:
+  - 'introduction-to-javascript'
+  - 'paths/front-end-engineer-career-path'
+---
+
+In JavaScript, the **nullish coalescing** (`??`) operator is a logical operator that evaluates the left-hand operand and returns it if it is not nullish (i.e., not `null` or `undefined`). Otherwise, it returns the right-hand operand.
+
+## Syntax
+
+```pseudo
+value1 ?? value2
+```
+
+- `value1`: The first operand to check if it is nullish (`null` or `undefined`).
+- `value2`: The second operand that acts as the default value, returned only if `value1` is nullish.
+
+## Example
+
+The following example demonstrates the use of the nullish coalescing operator to return `18` as a default or fallback value when the variable `age` is `null` or `undefined`:
+
+```js
+const age = undefined;
+const defaultAge = 18;
+
+console.log(age ?? defaultAge);
+```
+
+The above code produces the following output:
+
+```shell
+18
+```
+
+## Codebyte Example
+
+The following codebyte example uses the nullish coalescing operator (`??`) to return `"Guest"` as a fallback value when `name` is `null`:
+
+```codebyte/javascript
+const name = null;
+const defaultName = "Guest";
+
+console.log(name ?? defaultName);
+```

From aeba50536608a2198563ef759a35f109f6a63267 Mon Sep 17 00:00:00 2001
From: Savi Dahegaonkar <124272050+SaviDahegaonkar@users.noreply.github.com>
Date: Thu, 9 Jan 2025 12:16:39 +0530
Subject: [PATCH 16/31] [Concept Entry] Sklearn: Ensembles

* New file has been added.

* Update user-input.md

* Update user-input.md

* File has been added.

* Minor changes

---------
---
 .../sklearn/concepts/ensembles/ensembles.md   | 134 ++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 content/sklearn/concepts/ensembles/ensembles.md

diff --git a/content/sklearn/concepts/ensembles/ensembles.md b/content/sklearn/concepts/ensembles/ensembles.md
new file mode 100644
index 00000000000..0880b40f7e9
--- /dev/null
+++ b/content/sklearn/concepts/ensembles/ensembles.md
@@ -0,0 +1,134 @@
+---
+Title: 'Ensembles'
+Description: 'A machine learning technique that incorporates predictions from multiple models to enhance accuracy and reliability.'
+Subjects:
+  - 'AI'
+  - 'Data Science'
+Tags:
+  - 'Classification'
+  - 'Data'
+  - 'Machine Learning'
+  - 'Scikit-learn'
+CatalogContent:
+  - 'paths/intermediate-machine-learning-skill-path'
+  - 'paths/data-science'
+---
+
+**Ensembles** are machine learning techniques that combine the predictions from multiple models in order to increase accuracy, robustness, and reliability in classification and regression tasks. Scikit-learn provides tools to build these sophisticated predictive systems effectively.
+Some of the ensemble techniques include _Bagging_ and _Boosting_.
+
+## Bagging (Bootstrap Aggregating)
+
+Bagging refers to training multiple models in parallel on different subsets of the data generated using bootstrapping or random sampling with replacement. The predictions from the models are combined.
+
+This approach reduces the variance and prevents overfitting. Some popular algorithms that can be classified under bagging are `Random Forest` and `Bagging Classifier`.
+
+## Boosting
+
+Boosting creates models sequentially, where each new model corrects the mistakes of the previous one by focusing on the harder instances that the former model failed to predict. Well-known boosting algorithms include `AdaBoost`, `Gradient Boosting`, and `XGBoost`.
+
+## Syntax
+
+Sklearn offers the `BaggingClassifier` for performing classification tasks:
+
+```pseudo
+BaggingClassifier(estimator=None, n_estimators=10, max_samples=1.0, max_features=1.0, bootstrap=True, bootstrap_features=False, oob_score=False, warm_start=False, n_jobs=None, random_state=None, verbose=0)
+```
+
+- `estimator` (`None`, default=`None`): The base estimator to fit on random subsets of the dataset. If `None`, the algorithm uses a decision tree as the default estimator.
+- `n_estimators` (int, default=`10`): Number of estimators in the ensemble.
+- `max_samples` (float, default=`1.0`): The fraction of samples for fitting each estimator, must be between `0` and `1`.
+- `max_features` (float, default=`1.0`): The fraction of features for fitting each estimator, must be between `0` and `1`.
+- `bootstrap` (bool, default=`True`): Whether to use bootstrap sampling (sampling with replacement) for creating datasets for each estimator.
+- `bootstrap_features` (bool, default=`False`): Determines whether to sample features with replacement for each estimator.
+- `oob_score` (bool, default=`False`): Determines whether to use out-of-bag samples for estimating the generalization error.
+- `warm_start` (bool, default=`False`): If `True`, the fit method adds more estimators to the existing ensemble instead of starting from scratch.
+- `n_jobs` (int, default=`None`): The number of jobs to run in parallel for fitting the base estimators. `None` means using `1` core, `-1` uses all available cores.
+- `random_state` (int, default=`None`): Controls the randomness of the estimator fitting process, ensuring reproducibility.
+- `verbose` (int, default=`0`): Controls the verbosity level of the fitting process, with higher values producing more detailed output.
+
+## Example
+
+This example code demonstrates the use of the `BaggingClassifier` to build an ensemble of `Decision Trees` and examine its performance on the Iris dataset:
+
+```py
+# Import all the necessary libraries
+from sklearn.ensemble import BaggingClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# Load the Iris dataset
+data = load_iris()
+X = data.data
+y = data.target
+
+# Split the dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Initialize a BaggingClassifier with a DecisionTreeClassifier as the base estimator
+bagging_clf = BaggingClassifier(estimator=DecisionTreeClassifier(),
+                               n_estimators=50,
+                               max_samples=0.8,
+                               max_features=0.8,
+                               bootstrap=True,
+                               random_state=42)
+
+# Train the BaggingClassifier
+bagging_clf.fit(X_train, y_train)
+
+# Predict on the test set
+y_pred = bagging_clf.predict(X_test)
+
+# Evaluate accuracy
+accuracy = accuracy_score(y_test, y_pred)
+print(f"Accuracy: {accuracy:.2f}")
+```
+
+The code results in the following output:
+
+```shell
+Accuracy: 1.00
+```
+
+## Codebyte Example
+
+This is an example that demonstrates the use of a `VotingClassifier` to combine multiple classifiers (`Decision Tree`, `Support Vector Classifier`, and `K-Nearest Neighbors`) for a classification task on the Iris dataset:
+
+```codebyte/python
+# Import all the necessary libraries
+from sklearn.ensemble import VotingClassifier
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.svm import SVC
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.datasets import load_iris
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# Load the Iris dataset
+data = load_iris()
+X = data.data
+y = data.target
+
+# Split the dataset into training and testing sets
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
+
+# Initialize individual classifiers
+dt_clf = DecisionTreeClassifier(random_state=42)
+svc_clf = SVC(probability=True, random_state=42)
+knn_clf = KNeighborsClassifier()
+
+# Create a VotingClassifier that combines the classifiers
+voting_clf = VotingClassifier(estimators=[('dt', dt_clf), ('svc', svc_clf), ('knn', knn_clf)], voting='soft')
+
+# Train the VotingClassifier
+voting_clf.fit(X_train, y_train)
+
+# Predict on the test set
+y_pred = voting_clf.predict(X_test)
+
+# Evaluate accuracy
+accuracy = accuracy_score(y_test, y_pred)
+print(f"VotingClassifier Accuracy: {accuracy:.2f}")
+```

From 28ca408ca0d5cb4f155fa1656834ca15aa3d2cd6 Mon Sep 17 00:00:00 2001
From: Jonathan Hill <jonathan@jh.codes>
Date: Thu, 9 Jan 2025 07:15:58 -0800
Subject: [PATCH 17/31] [Edit] Fix typo in CSS Overflow entry (#5917)

* Add colon for consistancy in formatting

* Update overflow.md

Fixed the description. It was too long.

* Update overflow.md

fixed lint issue

* Update overflow.md

fixing issues

---------
---
 content/css/concepts/overflow/overflow.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/css/concepts/overflow/overflow.md b/content/css/concepts/overflow/overflow.md
index 140e9411c5e..aea41c7c0ea 100644
--- a/content/css/concepts/overflow/overflow.md
+++ b/content/css/concepts/overflow/overflow.md
@@ -1,6 +1,6 @@
 ---
 Title: 'Overflow'
-Description: 'The overflow property controls what happens to content that spills, or overflows, outside its box. The most commonly used values are: - hidden When set to this value, any content that overflows will be hidden from view. - scroll: When set to this value, a scrollbar will be added to the element’s box so that the rest of the content can be viewed by scrolling. - visible: When set to this value, the overflow content will be displayed outside of the containing element. Note, this is the default value. css p {'
+Description: 'The overflow property controls what happens to content that spills, or overflows, outside its box.'
 Subjects:
   - 'Web Development'
   - 'Web Design'
@@ -16,7 +16,7 @@ The `overflow` property controls what happens to content that spills, or overflo
 
 The most commonly used values are:
 
-- `hidden` When set to this value, any content that overflows will be hidden from view.
+- `hidden`: When set to this value, any content that overflows will be hidden from view.
 - `scroll`: When set to this value, a scrollbar will be added to the element’s box so that the rest of the content can be viewed by scrolling.
 - `visible`: When set to this value, the overflow content will be displayed outside of the containing element. Note, this is the default value.
 

From 2fd341e99d5fcc50ff4c48f960d76c2331b2bb6f Mon Sep 17 00:00:00 2001
From: Melek Nur <meleknurbacakli@gmail.com>
Date: Thu, 9 Jan 2025 19:56:05 +0300
Subject: [PATCH 18/31] Updated doc for python strftime module (#5835)

* Add documentation for python strftime() method

* Updated doc for python strftime module

* New term entries for Python: Dates

* Updated doc for python strftime module

* Update content/python/concepts/dates/terms/strftime/strftime.md

* Update content/python/concepts/dates/terms/strftime/strftime.md

* Update content/python/concepts/dates/terms/strftime/strftime.md

* Update content/python/concepts/dates/terms/strftime/strftime.md

* Changes implemented on the file.

* Update content/python/concepts/dates/terms/strftime/strftime.md

---------
---
 .../concepts/dates/terms/strftime/strftime.md | 60 +++++++++++++++++++
 1 file changed, 60 insertions(+)
 create mode 100644 content/python/concepts/dates/terms/strftime/strftime.md

diff --git a/content/python/concepts/dates/terms/strftime/strftime.md b/content/python/concepts/dates/terms/strftime/strftime.md
new file mode 100644
index 00000000000..248030c7364
--- /dev/null
+++ b/content/python/concepts/dates/terms/strftime/strftime.md
@@ -0,0 +1,60 @@
+---
+Title: '.strftime()'
+Description: 'Format time and date objects into readable strings based on specified patterns.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Date'
+  - 'Time'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`datetime.strftime()`** method formats time and `datetime` objects into readable strings on specified format codes.
+
+## Syntax
+
+```pseudo
+datetime.strftime(format)
+```
+
+Here are some commonly used format codes:
+
+| Directive | Meaning                                | Example                                  |
+| --------- | -------------------------------------- | ---------------------------------------- |
+| `%a`      | Abbreviated name of days               | Sun, Mon, …, Sat                         |
+| `%d`      | Day of the month                       | 01, 02, …, 31                            |
+| `%b`      | Abbreviated name of months             | Jan, Feb, …, Dec                         |
+| `%Y`      | Year                                   | 0001, 0002, …, 2013, 2014, …, 9998, 9999 |
+| `%m`      | Month                                  | 01, 02, …, 12                            |
+| `%I`      | Hour (12-hour clock)                   | 01, 02, …, 12                            |
+| `%M`      | Minute                                 | 00, 01, …, 59                            |
+| `%p`      | Locale’s equivalent of either AM or PM | AM, PM                                   |
+
+For a complete list, refer to the [Python documentation](https://docs.python.org/3/library/datetime.html#strftime-strptime-behavior).
+
+## Example
+
+The formatted time can be retrieved and stored in a variable as shown in this example:
+
+```py
+import datetime
+
+#Assign current time
+now = datetime.datetime.now()
+
+#Format the current date and time
+formatted_date = now.strftime('%a %d %b %Y, %I:%M%p')
+
+print(formatted_date)
+```
+
+This example results in the following output which displays the current date and time in specific format:
+
+```shell
+Mon 06 Jan 2025, 09:01PM
+```
+
+> **Note:** The actual output will vary depending on the current date and time when the script is executed.

From 46df91d59f79c392f53e81bc92e6fbd03ce97ebb Mon Sep 17 00:00:00 2001
From: Goodluck Somadina Chukwuemeka
 <105865699+Good-Soma@users.noreply.github.com>
Date: Fri, 10 Jan 2025 12:39:07 +0100
Subject: [PATCH 19/31] The document for Mixedlm entry. (#5794)

* Create deg2rad.md

* statsmodel

* Delete content/python/concepts/statsmodel

* terms

* Delete content/python/concepts/statsmodel directory

* Create mixedlm.md

* Update and rename deg2rad.md to deg2rad.md

format

* Delete content/numpy/concepts/math-methods/terms/deg2rad/deg2rad.md

* Update mixedlm.md

fixes

* Update mixedlm.md

Please, I have done the correction and also added the note as you specified.

I will still need to exemplify that the three models can be combined in an operation, but that will be later.  I just want you to work on the aspect that is important to you and that I have already completed, then later I will do that.

Review the changes, and if you think I didn't still get some things right, always feel free to reach out. Thanks

* Update mixedlm.md

* Fix file path

---------
---
 .../statsmodels/terms/mixedlm/mixedlm.md      | 156 ++++++++++++++++++
 1 file changed, 156 insertions(+)
 create mode 100644 content/python/concepts/statsmodels/terms/mixedlm/mixedlm.md

diff --git a/content/python/concepts/statsmodels/terms/mixedlm/mixedlm.md b/content/python/concepts/statsmodels/terms/mixedlm/mixedlm.md
new file mode 100644
index 00000000000..6ba7e764488
--- /dev/null
+++ b/content/python/concepts/statsmodels/terms/mixedlm/mixedlm.md
@@ -0,0 +1,156 @@
+---
+Title: 'MixedLM'
+Description: 'MixedLM in Statsmodels is a class for fitting linear mixed-effects models, which account for both fixed and random effects in data.'
+Subjects:
+  - 'Data Science'
+  - 'Machine Learning'
+Tags:
+  - 'Linear Regression'
+  - 'Machine Learning'
+  - 'Python'
+  - 'Statistics'
+  - 'Supervised Learning'
+CatalogContent:
+  - 'learn-python-3'
+  - paths/data-science
+---
+
+**MixedLM** in Python's [Statsmodels](https://www.codecademy.com/resources/docs/python/statsmodels) library is a tool for fitting mixed-effects models, combining fixed and random effects to analyze data. It captures fixed effects (predictable factors) and random effects (unpredictable factors), defining mixed-effect modeling. Fixed effects explain the trend, while random effects account for variability across groups.
+
+## Application of mixedlm model
+
+- **Random Intercept Model**: Captures group-level variability in the intercept while keeping the slope fixed.
+- **Random Slope Model**: Allows the slope to vary across groups to account for differences in trends.
+- **Variance Components Model**: Decomposes variance into different components to understand variability sources.
+
+## Syntax
+
+### Using Formula API (`from_formula`)
+
+The formula API is the recommended approach for specifying mixed-effects models. It simplifies model definition using a string formula.
+
+```pseudo
+from statsmodels.api import MixedLM
+
+model = MixedLM.from_formula(formula, data, groups, re_formula=None)
+result = model.fit()
+```
+
+**Parameters**:
+
+- `formula`: A string specifying the fixed-effects model (e.g., "Y ~ X1 + X2").
+- `data`: A Pandas DataFrame containing the dataset.
+- `groups`: A column in the DataFrame that defines the grouping for random effects.
+- `re_formula` (Optional): A string specifying the random-effects model. Defaults to a random intercept model.
+
+> **Note**: The Formula API (`from_formula`) is typically easier to use and more intuitive for specifying models, especially for developers familiar with R-style formulas.
+
+### Using Direct API
+
+```pseudo
+from statsmodels.api import MixedLM
+
+model = MixedLM(endog, exog, groups, exog_re=None)
+result = model.fit()
+```
+
+**Parameters**:
+
+- `endog`: Dependent variable (response variable as a NumPy array or Pandas Series).
+- `exog`: Design matrix for fixed effects (NumPy array or Pandas DataFrame).
+- `groups`: A grouping variable for random effects (e.g., a column name or array-like object).
+- `exog_re` (Optional): Design matrix for random effects. Defaults to a random intercept model.
+
+> **Note**: The Direct API provides greater flexibility and control but requires manually constructing the design matrices, which can be cumbersome for complex models.
+
+## Examples
+
+In this example, a mixed-effects model is fitted to NBA team performance data, with `'Minutes'` as a fixed effect and `'Team'` as a random effect to analyze points scored:
+
+### Using Formula API
+
+```
+import pandas as pd
+from statsmodels.api import MixedLM
+
+# Sample data
+data = pd.DataFrame({
+    'Points': [10, 25, 35, 30, 22, 14, 24, 28, 32, 27],
+    'Minutes': [35, 40, 30, 38, 33, 32, 34, 39, 41, 36],
+    'Team': ['TeamG', 'TeamG', 'TeamR', 'TeamR', 'TeamG', 'TeamG', 'TeamR', 'TeamR', 'TeamG', 'TeamR']
+})
+
+# Fit the model using formula API
+model = MixedLM.from_formula("Points ~ Minutes", data, groups="Team")
+result = model.fit()
+
+# Display the results
+print(result.summary())
+```
+
+The code generates the output as follows:
+
+```shell
+        Mixed Linear Model Regression Results
+======================================================
+Model:            MixedLM Dependent Variable: Points
+No. Observations: 10      Method:             REML
+No. Groups:       2       Scale:              45.7191
+Min. group size:  5       Log-Likelihood:     -30.8931
+Max. group size:  5       Converged:          Yes
+Mean group size:  5.0
+------------------------------------------------------
+            Coef.  Std.Err.   z   P>|z|  [0.025 0.975]
+------------------------------------------------------
+Intercept    1.759   22.753 0.077 0.938 -42.835 46.353
+Minutes      0.641    0.624 1.027 0.304  -0.582  1.863
+Team Var    28.935    8.542
+======================================================
+```
+
+### Using Direct API
+
+```py
+import pandas as pd
+import numpy as np
+from statsmodels.api import MixedLM
+
+# Sample data
+data = pd.DataFrame({
+    'Points': [10, 25, 35, 30, 22, 14, 24, 28, 32, 27],
+    'Minutes': [35, 40, 30, 38, 33, 32, 34, 39, 41, 36],
+    'Team': ['TeamG', 'TeamG', 'TeamR', 'TeamR', 'TeamG', 'TeamG', 'TeamR', 'TeamR', 'TeamG', 'TeamR']
+})
+
+# Define variables
+endog = data['Points']
+exog = sm.add_constant(data['Minutes'])  # Adding constant for intercept
+groups = data['Team']
+
+# Fit the model using direct API
+model = MixedLM(endog, exog, groups)
+result = model.fit()
+
+# Display the results
+print(result.summary())
+```
+
+The code generates the output as follows:
+
+```shell
+        Mixed Linear Model Regression Results
+======================================================
+Model:            MixedLM Dependent Variable: Points
+No. Observations: 10      Method:             REML
+No. Groups:       2       Scale:              45.7191
+Min. group size:  5       Log-Likelihood:     -30.8931
+Max. group size:  5       Converged:          Yes
+Mean group size:  5.0
+------------------------------------------------------
+            Coef.  Std.Err.   z   P>|z|  [0.025 0.975]
+------------------------------------------------------
+Intercept    1.759   22.753 0.077 0.938 -42.835 46.353
+Minutes      0.641    0.624 1.027 0.304  -0.582  1.863
+Team Var    28.935    8.542
+======================================================
+```

From 38d8bbc9523a276cbeb583c2d99f3461a5840253 Mon Sep 17 00:00:00 2001
From: Timothy Charteris <tim.charterii@gmail.com>
Date: Sun, 12 Jan 2025 07:34:15 +0000
Subject: [PATCH 20/31] [Edit] Python: Errors

* add custom exceptions

* Update content/python/concepts/errors/errors.md

* Update content/python/concepts/errors/errors.md

* Update content/python/concepts/errors/errors.md

* Minor changes

---------
---
 content/python/concepts/errors/errors.md | 58 ++++++++++++++++++++++++
 1 file changed, 58 insertions(+)

diff --git a/content/python/concepts/errors/errors.md b/content/python/concepts/errors/errors.md
index 59e031d28d4..eae58060dc9 100644
--- a/content/python/concepts/errors/errors.md
+++ b/content/python/concepts/errors/errors.md
@@ -100,3 +100,61 @@ File "script.py", line 1, in <module>
 ratio = 100 / 0
 ZeroDivisionError: division by zero
 ```
+
+## Custom Exceptions
+
+Custom exceptions can be used to define and handle application-specific errors. This can be done by creating a sub-class of the built-in `Exception` class.
+
+Custom exceptions help provide clear feedback to users about unexpected behavior, aid in debugging, and can be used throughout the program.
+
+### Defining Custom Exceptions
+
+To define a custom exception, a new class can be created by inheriting `Exception` and the constructor can be optionally overridden to provide additional information:
+
+```pseudo
+# Custom exception for invalid age input
+class InvalidAgeError(Exception):
+  def __init__(self, message, age=None):
+    super().__init__(message)
+    self.age = age
+```
+
+### Using Custom Exceptions
+
+Once a custom exception has been created, it can raise custom error messages for invalid inputs. For example, the following function raises an error if the user inputs an age not between 0 and 130:
+
+```pseudo
+def validate_age(age):
+  if not isinstance(age, int):
+    raise InvalidAgeError("Age must be an integer.", age)
+  if age < 0 or age > 130:
+    raise InvalidAgeError(f"{age} is not a valid age. Please choose an age between 0 and 130.", age)
+```
+
+### Example
+
+Once the custom exception is defined, it can be used to handle errors in a `try-except` block. The following example demonstrates how to raise the custom exception when an invalid age is provided:
+
+```py
+class InvalidAgeError(Exception):
+  def __init__(self, message, age=None):
+    super().__init__(message)
+    self.age = age
+
+def validate_age(age):
+  if not isinstance(age, int):
+    raise InvalidAgeError("Age must be an integer.", age)
+  if age < 0 or age > 130:
+    raise InvalidAgeError(f"{age} is not a valid age. Please choose an age between 0 and 130.", age)
+
+try:
+  validate_age(-5)
+except InvalidAgeError as e:
+  print(f"Error: {e}")
+```
+
+Here is the output:
+
+```shell
+Error: -5 is not a valid age. Please choose an age between 0 and 130.
+```

From 75fe50ff14263ff6a35cc7e57bd75bde2d615a67 Mon Sep 17 00:00:00 2001
From: EduardoGallego94 <e.gallegogar@gmail.com>
Date: Sun, 12 Jan 2025 08:50:53 +0100
Subject: [PATCH 21/31] [Term Entry] Python Dates: .strptime()

* Add strptime.md file

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update content/python/concepts/dates/terms/strptime/strptime.md

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* strptime updated

* Update strptime.md

minor fixes

* Minor changes

---------
---
 .../concepts/dates/terms/strptime/strptime.md | 69 +++++++++++++++++++
 1 file changed, 69 insertions(+)
 create mode 100644 content/python/concepts/dates/terms/strptime/strptime.md

diff --git a/content/python/concepts/dates/terms/strptime/strptime.md b/content/python/concepts/dates/terms/strptime/strptime.md
new file mode 100644
index 00000000000..2cef73d78e8
--- /dev/null
+++ b/content/python/concepts/dates/terms/strptime/strptime.md
@@ -0,0 +1,69 @@
+---
+Title: '.strptime()'
+Description: 'Returns a datetime object that represents the parsed date and time from the given string, based on the specified format.'
+Subjects:
+  - 'Python'
+  - 'Computer Science'
+Tags:
+  - 'Date'
+  - 'Time'
+  - 'Strings'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`.strptime()`** is a method included in the [`datetime`](https://www.codecademy.com/resources/docs/python/dates) module. It is used to parse a string representing a date and/or time and convert it into a `datetime` object using a specified format.
+
+## Syntax
+
+```pseudo
+from datetime import datetime
+
+datetime.strptime(date_string, format)
+```
+
+- `date_string`: The string representing the date and/or time to be parsed.
+- `format`: A string that defines the structure of `date_string` using format codes from the `datetime` module (e.g., `%Y` for a four-digit year, `%m` for a two-digit month).
+
+It returns a `datetime` object, which represents the parsed date and time from the provided `date_string` according to the specified `format`.
+
+## Example
+
+In the following example, the `.strptime()` method is used to parse a date-time string into a `datetime` object based on the specified format:
+
+```py
+from datetime import datetime
+
+# Define the date-time string and format
+datetime_string = "27/12/2024 15:30:00"
+datetime_format = "%d/%m/%Y %H:%M:%S"
+
+# Parse the string into a datetime object
+dt_object = datetime.strptime(datetime_string, datetime_format)
+
+print(dt_object)
+```
+
+The code above produces an output as:
+
+```shell
+2024-12-27 15:30:00
+```
+
+## Codebyte Example
+
+Run the following codebyte example to understand the use of the `.strptime()` method:
+
+```codebyte/python
+from datetime import datetime
+
+# Define the date string and format
+date_string = "2025-01-08"
+date_format = "%Y-%m-%d"
+
+# Parse the string into a datetime object
+dt_object = datetime.strptime(date_string, date_format)
+
+print(dt_object)
+```

From 48cf7eb89a95062cca78971a3bb3c76f10659074 Mon Sep 17 00:00:00 2001
From: DenisFlorin66 <62358650+DenisFlorin66@users.noreply.github.com>
Date: Sun, 12 Jan 2025 09:56:52 +0200
Subject: [PATCH 22/31] [Term Entry] PyTorch Tensor Operations: .swapaxes()

* [Term Entry] PyTorch Tensor Operations: .swapaxes()

* Update swapaxes.md

minor fixes

* Minor changes

---------
---
 .../terms/swapaxes/swapaxes.md                | 66 +++++++++++++++++++
 1 file changed, 66 insertions(+)
 create mode 100644 content/pytorch/concepts/tensor-operations/terms/swapaxes/swapaxes.md

diff --git a/content/pytorch/concepts/tensor-operations/terms/swapaxes/swapaxes.md b/content/pytorch/concepts/tensor-operations/terms/swapaxes/swapaxes.md
new file mode 100644
index 00000000000..ff495f2b4ea
--- /dev/null
+++ b/content/pytorch/concepts/tensor-operations/terms/swapaxes/swapaxes.md
@@ -0,0 +1,66 @@
+---
+Title: '.swapaxes()'
+Description: 'Swaps two specified axes (dimensions) of a tensor, effectively rearranging its shape.'
+Subjects:
+  - 'Computer Science'
+  - 'Machine Learning'
+Tags:
+  - 'AI'
+  - 'Data Types'
+  - 'Deep Learning'
+  - 'Functions'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/data-science'
+---
+
+In PyTorch, the **`.swapaxes()`** function swaps two specified axes (dimensions) of a tensor.
+
+## Syntax
+
+```pseudo
+torch.swapaxes(input, axis0, axis1)
+```
+
+- `input`: The input tensor.
+- `axis0`: The first axis to be swapped.
+- `axis1`: The second axis to be swapped.
+
+## Example
+
+The following example demonstrates the usage of the `.swapaxes()` function:
+
+```py
+import torch
+
+# Create a tensor
+x = torch.tensor([[[0, 1], [2, 3]], [[4, 5], [6, 7]]])
+
+# Swap the axes (0 and 1)
+swapped1 = torch.swapaxes(x, 0, 1)
+print("After swapping axes 0 and 1:")
+print(swapped1)
+
+# Swap the axes (0 and 2)
+swapped2 = torch.swapaxes(x, 0, 2)
+print("\nAfter swapping axes 0 and 2:")
+print(swapped2)
+```
+
+The output of the above code is as follows:
+
+```shell
+After swapping axes 0 and 1:
+tensor([[[0, 1],
+         [4, 5]],
+
+        [[2, 3],
+         [6, 7]]])
+
+After swapping axes 0 and 2:
+tensor([[[0, 4],
+         [2, 6]],
+
+        [[1, 5],
+         [3, 7]]])
+```

From 5adc9fcb18fcaf6451df4e15140db3b3f3ce54b1 Mon Sep 17 00:00:00 2001
From: codecademydev <dev@codecademy.com>
Date: Sun, 12 Jan 2025 13:06:10 +0000
Subject: [PATCH 23/31] =?UTF-8?q?=F0=9F=A4=96=20update=20concept=20of=20th?=
 =?UTF-8?q?e=20week?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 bin/concept-of-the-week.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/bin/concept-of-the-week.txt b/bin/concept-of-the-week.txt
index 4829c2f3c48..ba6b63ae17c 100644
--- a/bin/concept-of-the-week.txt
+++ b/bin/concept-of-the-week.txt
@@ -1 +1 @@
-content/r/concepts/built-in-functions/built-in-functions.md
\ No newline at end of file
+content/ruby/concepts/sets/sets.md
\ No newline at end of file

From e77b33609e7cd028b9826fc4c40ea91a12c267f0 Mon Sep 17 00:00:00 2001
From: Pragati Verma <itispragativerma@gmail.com>
Date: Mon, 13 Jan 2025 09:07:42 +0530
Subject: [PATCH 24/31] [Concept Entry] How to use loops in SQL (#5836)

* Add loops concept entry

* Update loops.md

* Update loops.md

* Update loops.md

---------
---
 content/sql/concepts/loops/loops.md | 114 ++++++++++++++++++++++++++++
 1 file changed, 114 insertions(+)
 create mode 100644 content/sql/concepts/loops/loops.md

diff --git a/content/sql/concepts/loops/loops.md b/content/sql/concepts/loops/loops.md
new file mode 100644
index 00000000000..aad6d9fa72c
--- /dev/null
+++ b/content/sql/concepts/loops/loops.md
@@ -0,0 +1,114 @@
+---
+Title: 'Loops'
+Description: 'Loops are used to repeatedly execute a block of code as long as a certain condition is met.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Loops'
+  - 'Database'
+  - 'Queries'
+  - 'Tables'
+CatalogContent:
+  - 'learn-sql'
+  - 'paths/analyze-data-with-sql'
+---
+
+In SQL, **loops** are used to repeatedly execute a block of code as long as a certain condition is met. These loops can be useful when performing operations that require repetition, such as processing a set of rows or performing iterative calculations.
+
+## Types of Loops
+
+### 1. WHILE Loop
+
+The `WHILE` loop is the most common loop in SQL and is used to execute a block of SQL statements as long as a given condition remains true.
+
+The syntax for `WHILE` loop is as follows:
+
+```pseudo
+WHILE condition
+BEGIN
+    -- SQL statements to execute
+END
+```
+
+Here's an example to print the value of `@counter` from 1 to 5 using a `WHILE` loop:
+
+```sql
+DECLARE @counter INT = 1;
+
+WHILE @counter <= 5
+BEGIN
+    PRINT 'Counter: ' + CAST(@counter AS VARCHAR);
+    SET @counter = @counter + 1;
+END
+```
+
+### 2. FOR Loop
+
+In SQL, a `FOR` loop is often used for iterating over a specific range of values. It is more common in Oracle databases than other SQL variants.
+
+The syntax for `FOR` loop is as follows:
+
+```pseudo
+FOR counter IN lower_bound..upper_bound
+LOOP
+    -- SQL statements to execute
+END LOOP;
+```
+
+Here's an example to print the value of `counter` from 1 to 5 using a `FOR` loop:
+
+```sql
+BEGIN
+    FOR counter IN 1..5 LOOP
+        DBMS_OUTPUT.PUT_LINE('Counter: ' || counter);
+    END LOOP;
+END;
+```
+
+### 3. LOOP
+
+The `LOOP` structure in SQL is a powerful tool for executing a block of statements repeatedly until a specific condition is met. Unlike other loop types, a `LOOP` does not inherently depend on an initial condition. Instead, it runs unconditionally and requires an explicit exit condition within the loop body to stop execution. This flexibility makes it highly versatile but demands careful implementation to avoid infinite loops.
+
+The syntax for using `LOOP` is as follows:
+
+```pseudo
+LOOP
+    -- SQL statements
+    IF condition THEN
+        EXIT;
+    END IF;
+END LOOP;
+```
+
+Here's an example to print the value of `counter` from 1 to 5 using a `LOOP`:
+
+```sql
+DECLARE
+    counter INT := 1;
+BEGIN
+    LOOP
+        EXIT WHEN counter > 5;
+        DBMS_OUTPUT.PUT_LINE('Counter: ' || counter);
+        counter := counter + 1;
+    END LOOP;
+END;
+```
+
+## Infinite Loops
+
+Loops without a properly defined exit condition can lead to infinite loops, where the code continues executing indefinitely. This often occurs when the condition in a `WHILE` or `LOOP` structure is never met or incorrectly updated.
+
+Here is an example of an infinite loop in SQL:
+
+```sql
+DECLARE @counter INT = 1;
+
+WHILE @counter > 0
+BEGIN
+    PRINT 'This loop will run indefinitely';
+    -- No exit condition or update to @counter
+END
+```
+
+> **Note**: Be cautious of creating infinite loops, especially if the exit condition is not correctly defined, as it can lead to system performance degradation.

From 978e922b3cc966dfc9e22b1bd3b357e315a4b99c Mon Sep 17 00:00:00 2001
From: Pragati Verma <itispragativerma@gmail.com>
Date: Mon, 13 Jan 2025 09:12:11 +0530
Subject: [PATCH 25/31] [Concept Entry] Optimizing SQL queries (#5837)

* Add optimizing SQL queries entry

* Update optimizing-queries.md

* Fix lint errors

* Updating

---------
---
 .../optimizing-queries/optimizing-queries.md  | 178 ++++++++++++++++++
 1 file changed, 178 insertions(+)
 create mode 100644 content/sql/concepts/optimizing-queries/optimizing-queries.md

diff --git a/content/sql/concepts/optimizing-queries/optimizing-queries.md b/content/sql/concepts/optimizing-queries/optimizing-queries.md
new file mode 100644
index 00000000000..e68656210e1
--- /dev/null
+++ b/content/sql/concepts/optimizing-queries/optimizing-queries.md
@@ -0,0 +1,178 @@
+---
+Title: 'Optimizing Queries'
+Description: 'Optimizing SQL queries is the process of improving the efficiency of SQL statements to reduce execution time, minimize resource consumption, and enhance overall database performance.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Database'
+  - 'Queries'
+  - 'MySQL'
+  - 'PostgreSQL'
+  - 'SQLite'
+CatalogContent:
+  - 'learn-sql'
+  - 'paths/analyze-data-with-sql'
+---
+
+**Optimizing SQL queries** is the process of improving the efficiency of SQL statements to reduce execution time, minimize resource consumption, and enhance overall database performance.
+
+This involves using techniques such as indexing, query restructuring, execution plan analysis, and proper use of SQL constructs to ensure that queries retrieve or manipulate data most effectively. Optimisation aims to handle large datasets, complex joins, or frequent transactions efficiently while maintaining accuracy and scalability.
+
+## Common Techniques for Query Optimization
+
+### **Use Indexes Effectively**
+
+Indexes are essential for speeding up data retrieval. They act as pointers to the rows in a table, allowing the database to locate data without scanning the entire table.
+
+#### Tips
+
+- Create indexes on columns frequently used in `WHERE`, `JOIN`, `GROUP BY`, or `ORDER BY` clauses.
+- Avoid over-indexing, as it can slow down `INSERT`, `UPDATE`, and `DELETE` operations.
+- Use composite indexes for queries that filter on multiple columns.
+
+To add an index on `last_name` in a SQL query:
+
+Without an index:
+
+```sql
+SELECT *
+FROM employees
+WHERE last_name = 'Smith';
+```
+
+With an index:
+
+```sql
+CREATE INDEX idx_last_name ON employees(last_name);
+
+SELECT *
+FROM employees
+WHERE last_name = 'Smith';
+```
+
+### Avoid `SELECT *`
+
+Fetching all columns from a table increases data transfer time and memory usage. Specify only the columns needed for your query.
+
+Instead of:
+
+```sql
+SELECT *
+FROM employees;
+```
+
+Use:
+
+```sql
+SELECT first_name, last_name
+FROM employees;
+```
+
+### Filter Early with `WHERE`
+
+Reduce the number of rows processed by filtering data as early as possible in the query using the `WHERE` clause.
+
+Instead of:
+
+```sql
+SELECT first_name, last_name
+FROM employees
+ORDER BY last_name;
+```
+
+Use:
+
+```sql
+SELECT first_name, last_name
+FROM employees
+WHERE department = 'Sales'
+ORDER BY last_name;
+```
+
+### Avoid Functions on Indexed Columns in `WHERE` Clauses
+
+When using functions on columns in the `WHERE` clause, the database cannot use an index on that column effectively, leading to a full table scan. Rewrite queries to avoid applying functions directly to indexed columns.
+
+Inefficient (function on indexed column):
+
+```sql
+SELECT *
+FROM employees
+WHERE YEAR(hire_date) = 2023;
+```
+
+This query applies the `YEAR()` function to every row's `hire_date`, preventing the use of an index on the `hire_date` column.
+
+Efficient:
+
+```sql
+SELECT *
+FROM employees
+WHERE hire_date BETWEEN '2023-01-01' AND '2023-12-31';
+```
+
+By transforming the query, the index on `hire_date` can be used effectively, improving performance.
+
+### Use Joins Instead of Subqueries
+
+In many cases, joins perform better than subqueries because the database can optimize them more efficiently.
+
+Subquery:
+
+```sql
+SELECT first_name, last_name
+FROM employees
+WHERE department_id = (SELECT id FROM departments WHERE name = 'Sales');
+```
+
+Join:
+
+```sql
+SELECT e.first_name, e.last_name
+FROM employees e
+JOIN departments d ON e.department_id = d.id
+WHERE d.name = 'Sales';
+```
+
+### Optimize `JOIN`
+
+- Ensure the joined columns are indexed.
+- Use the appropriate join type (e.g., INNER `JOIN`, `LEFT JOIN`) for the specific use case.
+
+### Limit the Use of `DISTINCT`
+
+Using `DISTINCT` can be costly for performance, requiring sorting and deduplication. Use it only when absolutely necessary.
+
+Instead of:
+
+```sql
+SELECT DISTINCT department
+FROM employees;
+```
+
+Use:
+
+```sql
+SELECT department
+FROM employees
+GROUP BY department;
+```
+
+### Partition Large Tables
+
+Partitioning divides a table into smaller, more manageable pieces based on column values, improving query performance for specific subsets of data.
+
+To partition a `sales` table by year:
+
+```sql
+CREATE TABLE sales_2023 PARTITION OF sales FOR VALUES IN (2023);
+```
+
+### Use Caching
+
+Cache frequently executed queries to reduce database load. This can be done using a caching layer like Redis or in-memory caching.
+
+### Optimize Data Types
+
+Use appropriate data types for columns to minimize storage and processing overhead. For example, use `INT` instead of `BIGINT` when possible or `CHAR` instead of `VARCHAR` for fixed-length data.

From 3a2392b81c2e80b979b45bc25f182228122cba9b Mon Sep 17 00:00:00 2001
From: Savi Dahegaonkar <124272050+SaviDahegaonkar@users.noreply.github.com>
Date: Mon, 13 Jan 2025 09:23:05 +0530
Subject: [PATCH 26/31] [Concept Entry] Subject: performance tuning in sql
 (#5899)

* New file has been added.

* Update user-input.md

* Update user-input.md

* File has been added.

---------
---
 .../performance-tuning/performance-tuning.md  | 49 +++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 content/sql/concepts/performance-tuning/performance-tuning.md

diff --git a/content/sql/concepts/performance-tuning/performance-tuning.md b/content/sql/concepts/performance-tuning/performance-tuning.md
new file mode 100644
index 00000000000..0e7139f90fe
--- /dev/null
+++ b/content/sql/concepts/performance-tuning/performance-tuning.md
@@ -0,0 +1,49 @@
+---
+Title: 'Performance Tuning'
+Description: 'Optimizes queries and database configurations to improve speed and resource efficiency.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+  - 'Developer Tools'
+Tags:
+  - 'Algorithms'
+  - 'Collations'
+  - 'Database'
+  - 'MySQL'
+  - 'Queries'
+CatalogContent:
+  - 'learn-sql'
+  - 'paths/analyze-data-with-sql'
+---
+
+**Performance Tuning** in SQL involves optimizing queries and database configurations to improve speed and resource efficiency. This process is essential for improving overall database performance.
+
+## Factors Affecting SQL Speed
+
+The execution speed of SQL queries is affected by several factors as follows:
+
+- `Query Complexity`: Queries with multiple joins or subqueries may take longer to execute.
+- `Indexing`: Missing or lack of proper indexing can slow down query performance.
+- `Data Volume`: Larger datasets generally require more time to process.
+- `Server performance`: The CPU, memory, and disk I/O all impact query execution times.
+- `Database Schema Design`: Poorly designed schema can lead to inefficient queries and slow performance.
+
+## Ways to Improve SQL Speed
+
+To improve the SQL speed, consider the following techniques:
+
+- `Optimize Queries`: Make complex queries and eliminate any unnecessary subqueries or joins.
+- `Indexing`: Proper indexes should be built on frequently queried columns to improve data retrieval speed.
+- `Use the EXPLAIN command`: Make use of the EXPLAIN command to analyze query execution plans and identify inefficiencies.
+- `Partitioning`: Breaking up very large tables into smaller ones to speed up queries.
+- `Caching`: Implement cache mechanisms to avoid redundant data retrieval operations.
+
+## Tools for SQL Performance Tuning
+
+Several tools that can help optimize SQL Performance Tuning are as follows:
+
+- `MySQL Query Profiler`: This tool monitors activity and tracks slow queries, helping to identify known performance bottlenecks across SQL databases.
+- `EXPLAIN Command`: Visualizes the execution of SQL queries, which helps in performance analysis.
+- `SQL Server Profiler`: This tool monitors activity and tracks slow queries and known performance bottlenecks across SQL Server.
+- `pgAdmin (PostgreSQL)`: Tools for database management and analysis of database performance in PostgreSQL.
+- `Database indexing tools`: Tools that help in automatically generate and maintain the indexes in order to ensure performance.

From 5fbedfffabe451a0b83ddbf03c90f765ea708c26 Mon Sep 17 00:00:00 2001
From: arisdelacruz <115809819+arisdelacruz@users.noreply.github.com>
Date: Mon, 13 Jan 2025 13:26:40 +0800
Subject: [PATCH 27/31] Create narrow copy entry for pytorch (#5904)

* Create narrow copy entry for pytorch

* Update narrow-copy.md

* Update narrow-copy.md

minor fixes

* format fixes

---------
---
 .../terms/narrow-copy/narrow-copy.md          | 61 +++++++++++++++++++
 1 file changed, 61 insertions(+)
 create mode 100644 content/pytorch/concepts/tensor-operations/terms/narrow-copy/narrow-copy.md

diff --git a/content/pytorch/concepts/tensor-operations/terms/narrow-copy/narrow-copy.md b/content/pytorch/concepts/tensor-operations/terms/narrow-copy/narrow-copy.md
new file mode 100644
index 00000000000..fa2c87188b9
--- /dev/null
+++ b/content/pytorch/concepts/tensor-operations/terms/narrow-copy/narrow-copy.md
@@ -0,0 +1,61 @@
+---
+Title: '.narrow_copy()'
+Description: 'Creates a new tensor containing a narrowed subsection of data from the input tensor along a specified dimension.'
+Subjects:
+  - 'Computer Science'
+  - 'Machine Learning'
+Tags:
+  - 'Functions'
+  - 'Machine Learning'
+  - 'Methods'
+  - 'Python'
+CatalogContent:
+  - 'intro-to-py-torch-and-neural-networks'
+  - 'paths/computer-science'
+---
+
+In Pytorch, **`.narrow_copy()`** is a function that creates a new tensor containing the same data as the input tensor but with a narrowed dimension. Unlike [`.narrow()`](https://www.codecademy.com/resources/docs/pytorch/tensor-operations/narrow), which returns a view of the original tensor, `.narrow_copy()` returns a new tensor.
+
+## Syntax
+
+```pseudo
+torch.narrow_copy(input, dim, start, length)
+```
+
+- `input`: The input tensor to be narrowed.
+- `dim`: The dimension along which the narrowing is applied.
+- `start`: The index where the narrowing begins. This can be a positive integer, a negative integer (to index from the end of `dim`), or a 0-dimensional integer tensor.
+- `length`: The number of elements to include from the starting position.
+
+## Example
+
+The following example demonstrates the usage of the `.narrow_copy()` function:
+
+```py
+import torch
+
+# Create a 2D tensor
+tensor_2d = torch.arange(1, 13).reshape(3, 4)
+print(f"Original 2D Tensor:\n{tensor_2d}")
+
+# Narrow the tensor along rows and create a new tensor
+narrowed_tensor = torch.narrow_copy(tensor_2d, 0, 1, 2)
+print(f"Narrowed 2D Tensor:\n{narrowed_tensor}")
+```
+
+The above code produces the following output:
+
+```shell
+Original 2D Tensor:
+tensor([[ 1,  2,  3,  4],
+        [ 5,  6,  7,  8],
+        [ 9, 10, 11, 12]])
+
+Narrowed 2D Tensor:
+tensor([[ 5,  6,  7,  8],
+        [ 9, 10, 11, 12]])
+```
+
+In this example, the `.narrow_copy()` function creates a new tensor by narrowing an input tensor along a specific dimension. In the given code, the input tensor is narrowed along rows (dimension 0), starting from index _1_ and including _2_ rows.
+
+The `.narrow_copy()` function is used to create a new tensor containing a subset of data from an existing tensor without modifying the original tensor.

From d4a8fba09db6ce15ee75b918ac2c0db0a4eed77c Mon Sep 17 00:00:00 2001
From: guobyti <guobyteigne@gmail.com>
Date: Mon, 13 Jan 2025 08:58:09 +0200
Subject: [PATCH 28/31] Adding Squash Documentation (#5883)

* Create squash.md and squash directory

* Update squash.md

* Added title, description to squash.md

* Implemented the changes.

* Update content/git/concepts/squash/squash.md

Co-authored-by: Savi Dahegaonkar <124272050+SaviDahegaonkar@users.noreply.github.com>

* Update squash.md

* Fix lint errors

---------
---
 content/git/concepts/squash/squash.md | 108 ++++++++++++++++++++++++++
 1 file changed, 108 insertions(+)
 create mode 100644 content/git/concepts/squash/squash.md

diff --git a/content/git/concepts/squash/squash.md b/content/git/concepts/squash/squash.md
new file mode 100644
index 00000000000..fb79ffa8cc0
--- /dev/null
+++ b/content/git/concepts/squash/squash.md
@@ -0,0 +1,108 @@
+---
+Title: 'Squash'
+Description: 'Squashing in Git combines multiple commits into one to simplify and clean up the commit history.'
+Subjects:
+  - 'Bash/Shell'
+  - 'Computer Science'
+  - 'Developer Tools'
+Tags:
+  - 'Git'
+  - 'Command Line'
+  - 'Version Control'
+CatalogContent:
+  - 'learn-the-command-line'
+  - 'learn-git'
+---
+
+Merging a series of smaller commits into a cohesive one can significantly clean up a project’s commit history. This practice, commonly known as "**squashing**", is particularly helpful when previous commits contain minor changes that clutter the commit history.
+
+Though Git doesn’t offer a straightforward `squash` command, it can be achieved through an **interactive rebase**. Below, we explore how to squash your commits for a tidier project history.
+
+## Syntax
+
+To squash commits using an _interactive rebase_, the following command can be used:
+
+```pseudo
+git rebase -i HEAD~<number_of_commits>
+```
+
+- `HEAD` refers to the latest commit on the current branch.
+- `<number_of_commits>` specifies how many recent commits to include in the rebase.
+
+## Example
+
+Imagine working on a feature branch and generating several incremental commits. Before integrating these changes into the main branch, it’s best to `squash` your commits to maintain a clean history.
+
+The current commit log might look something like this:
+
+```shell
+12345678 Initial commit
+23456789 Added Santa's new address
+87654321 Corrected grammar in the address
+98765544 Updated house number for Santa
+```
+
+These last three commits relate to updates and corrections to the same component, and squashing them into a single commit will make the commit history more concise and meaningful.
+
+### Interactive Rebase: The path to squashing
+
+To squash the last three commits, initiate an interactive rebase with the following command:
+
+```shell
+git rebase -i HEAD~3
+```
+
+Executing the command will launch an editor displaying something similar to this:
+
+```shell
+pick 23456789 Added Santa's new address
+pick 87654321 Corrected grammar in the address
+pick 98765544 Updated house number for Santa
+
+# Rebase
+#
+# Commands:
+#  p, pick = use commit
+#  r, reword = use commit, but edit the commit message
+#  e, edit = use commit, but stop for amending
+#  s, squash = use commit, but meld into previous commit
+#  f, fixup = like "squash", but discard this commit's log message
+#  x, exec = run command (the rest of the line) using shell
+#
+# These lines can be re-ordered; they are executed from top to bottom.
+#
+# If you remove a line here THAT COMMIT WILL BE LOST.
+#
+# However, if you remove everything, the rebase will be aborted.
+#
+# Note that empty commits are commented out
+```
+
+The goal is to combine the commits by replacing `pick` with `squash` (or `s`) for all but the first commit:
+
+```shell
+pick 23456789 Added Santa`s new address
+squash 87654321 Corrected grammar in the address
+squash 98765544 Updated house number for Santa
+```
+
+After saving and closing the editor, `Git` will prompt the user to draft a new commit message:
+
+```shell
+# This is a combination of 3 commits.
+# The first commit's message is:
+Added Santa's new address
+# This is the 2nd commit message:
+Corrected grammar in the address
+# This is the 3rd commit message:
+Updated house number for Santa
+# Lines starting with '#' are ignored, and an empty message cancels the commit.
+```
+
+Now, create a clear, comprehensive message reflecting the changes these combined commits introduced.
+
+> **Note**: Remember, lines with `#` are comments and will be excluded.
+
+Squashing commits via an interactive rebase keeps the project history clean, concise, and easier to navigate.
+
+> **Note**: Caution is advised when squashing commits in a branch that has already been pushed to a remote repository, as it rewrites history and may cause conflicts. To avoid such issues, perform squashing locally before pushing changes.

From ef344c1804460c20aa6f49e7817bee07383df5a5 Mon Sep 17 00:00:00 2001
From: Maria <155121699+MariaRoDigital@users.noreply.github.com>
Date: Mon, 13 Jan 2025 07:42:09 -0700
Subject: [PATCH 29/31] fix grammar in Javascript iterator.md (#5941)

---
 content/javascript/concepts/iterators/iterators.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/javascript/concepts/iterators/iterators.md b/content/javascript/concepts/iterators/iterators.md
index 56e4ad25bae..2a287502c84 100644
--- a/content/javascript/concepts/iterators/iterators.md
+++ b/content/javascript/concepts/iterators/iterators.md
@@ -26,7 +26,7 @@ The **iterator protocol**, by definition, implements the `next()` method and ret
 
 ## Example
 
-This range-based iterator, loops through a collection of integers and satisfies the iteration protocols.
+This range-based iterator loops through a collection of integers and satisfies the iteration protocols.
 
 ```js
 function createRangeIterator(min = 0, max = Infinity, step = 1) {
@@ -76,7 +76,7 @@ This will output:
 
 ## Codebyte Example
 
-Run the below codebyte example to see how an iterator works with a string:
+Run the codebyte example below to see how an iterator works with a string:
 
 ```codebyte/javascript
 const str = "Hello";

From 30f61d724ed7e475b96c6b9332e5acaa74a0eca7 Mon Sep 17 00:00:00 2001
From: Virachai Wongsena <virachai@users.noreply.github.com>
Date: Mon, 13 Jan 2025 22:25:26 +0700
Subject: [PATCH 30/31] [Term Entry] Python scipy integrate odeint (#5910)

* Explanation for using scipy.integrate.odeint() to solve ODEs

* Add documentation for odeint() function in SciPy for solving ODEs

* Enhance .odeint() function description

Refined the description of the .odeint() function to emphasize its role in solving ordinary differential equations using the LSODA method. The updated description highlights its capability to automatically handle both stiff and non-stiff problems. A big thank you to @mamtawardhani for the valuable suggestions!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Add hyperlink to .odeint() function description

Included a hyperlink in the description of the .odeint() function to provide direct access to the SciPy integrate module documentation. This update improves the usability of the documentation. A big thank you to @mamtawardhani for the valuable suggestion!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update code block language to pseudo for .odeint()

Changed the code block language from python to pseudo in the .odeint() function documentation to accurately reflect the content. Thank you so much to @mamtawardhani for the helpful suggestion!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Clarify parameter descriptions for .odeint() documentation

Improved the parameter descriptions for the .odeint() function documentation by adding detailed explanations and clarifications. This update enhances the overall clarity and usability of the documentation. Thank you so much to @mamtawardhani for the insightful suggestions!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Enhance return description for .odeint() documentation

Updated the return description for the .odeint() function documentation to specify that it returns a 2D NumPy array, with each row corresponding to the solution at a specific time point in t. Thanks to @mamtawardhani for the helpful suggestion!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update plotting code for .odeint() documentation

Modified the plotting code in the .odeint() function documentation to correctly index the solution array and retrieve the actual y values. A big thank you to @mamtawardhani for the valuable suggestion!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Update code block language to py for .odeint() documentation

Changed the code block language from python to py in the .odeint() function documentation for improved readability and consistency. Many thanks to @mamtawardhani for the suggestion!

Co-authored-by: Mamta Wardhani <mamta.wardhani@gmail.com>

* Add explanation for odeint usage and output image

Added a brief explanation of the code and the usage of odeint, emphasizing its role in solving differential equations numerically. Included an output visualization as an image stored under the media folder in the docs directory for better understanding.

* Attach the image of the output

* explanation of the code and how is odeint used in it

moved explanation

* Update odeint.md

minor fixes

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md

* Update odeint.md

* Update odeint.md

* fix lint errors

---------
---
 .../scipy-integrate/terms/odeint/odeint.md    |  76 ++++++++++++++++++
 media/odeint_solution_plot.png                | Bin 0 -> 21936 bytes
 2 files changed, 76 insertions(+)
 create mode 100644 content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md
 create mode 100644 media/odeint_solution_plot.png

diff --git a/content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md b/content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md
new file mode 100644
index 00000000000..121057fec77
--- /dev/null
+++ b/content/scipy/concepts/scipy-integrate/terms/odeint/odeint.md
@@ -0,0 +1,76 @@
+---
+Title: '.odeint()'
+Description: 'Solves ordinary differential equations in SciPy using the LSODA method, automatically handling stiff and non-stiff problems.'
+Subjects:
+  - 'Computer Science'
+  - 'Data Science'
+Tags:
+  - 'Data'
+  - 'Math'
+  - 'Python'
+CatalogContent:
+  - 'learn-python-3'
+  - 'paths/computer-science'
+---
+
+The **`odeint()`** function from SciPy's [`integrate`](https://www.codecademy.com/resources/docs/scipy/scipy-integrate) module is a powerful tool for solving initial value problems for _Ordinary Differential Equations (ODEs)_.
+
+It integrates a system of ordinary differential equations using the LSODA method from the FORTRAN library `odepack`, which automatically switches between stiff and non-stiff methods based on the problem's characteristics.
+
+## Syntax
+
+The general syntax for using `odeint()` is as follows:
+
+```pseudo
+from scipy.integrate import odeint
+
+solution = odeint(func, y0, t, args=(), Dfun=None, col_deriv=0, full_output=0, ml=None, mu=None, rtol=None, atol=None, tcrit=None, h0=0.0, hmax=0.0, hmin=0.0, ixpr=0, mxstep=500, mxhnil=10, mxordn=12, mxords=5)
+```
+
+- `func`: A callable that defines the derivative of the system, ({dy}/{dt} = f(y, t, ...)).
+- `y0`: Initial condition(s) (array-like). Represents the initial state of the system.
+- `t`: Array of time points at which the solution is to be computed (1D array-like).
+- `args` (Optional): Tuple of extra arguments to pass to `func`.
+
+Other parameters are optional and control solver behavior, precision, and output verbosity.
+
+It returns a 2D [NumPy](https://www.codecademy.com/resources/docs/numpy) array, where each row corresponds to the solution at a specific time point in `t`.
+
+## Example
+
+The code below numerically solves a first-order ordinary differential equation using `odeint`. The model function defines the ODE, and `odeint` integrates it over specified time points starting from the initial condition, and the results are plotted to visualize the solution:
+
+```py
+import numpy as np
+from scipy.integrate import odeint
+import matplotlib.pyplot as plt
+
+def model(y, t):
+    dydt = -2 * y + 3
+    return dydt
+
+# Initial condition
+y0 = 5
+
+# Time points
+t = np.linspace(0, 5, 100)
+
+# Solve ODE
+solution = odeint(model, y0, t)
+
+# Plot results (indexing the solution to get the actual y values)
+plt.plot(t, solution[:, 0])  Since solution is a 2D array, we index its first column to extract the solution values.
+plt.title('Solution of dy/dt = -2y + 3')
+plt.xlabel('Time (t)')
+plt.ylabel('y(t)')
+plt.grid()
+plt.show()
+```
+
+The output plot shows the numerical solution of the ODE, illustrating how `y(t)` evolves over time:
+
+![A plot showing the solution of an ODE using odeint, with time on the x-axis and y(t) on the y-axis.](https://raw.githubusercontent.com/Codecademy/docs/main/media/odeint_solution_plot.png)
+
+`odeint()` is ideal for many scientific and engineering applications due to its robustness and flexibility.
+
+> For more advanced control or alternative solvers, consider using `scipy.integrate.solve_ivp()`, which offers a more modern API.
diff --git a/media/odeint_solution_plot.png b/media/odeint_solution_plot.png
new file mode 100644
index 0000000000000000000000000000000000000000..80457bb94e7a67fa697176512a383364d75c9ca0
GIT binary patch
literal 21936
zcmdqJbzD{5wm!aS1O*I0L_j2@QAtrk0g>*M5R{fKX-rf^6h)Bk4iUC=C?ZPN25AuK
z7B;=%Hx{0I&bjw{?l1oRy`OX57Zz*HHRoJ&K4Xk$JYzo7P*XTUaf$*#kRysW<g^fk
zFbF{iM#)Lxib%)cZ}`t8cX<PMZ6_;tFLPH*MAh8g`L2`uU0aJYo|dj|woZ;h0^$Pa
z`Oet5yF0r{2nss<^9BJYS8G9$LQD=ca>)6Hp&Nowo1_0H$dt~oMG##kMY*dw_hJ`@
zy!~`=Rr@O&&38UJ$y_^jhCSC@Xx{Dvg+S1ajy1iz9Un_Qh;l4&ran8`uPBUgXLaXH
zlXNMrQDPeDUZ>q{JWIhvPJT%F82Kwn_BZcWci7lz-pB;Kzx1PdZtGq%+xsQIw)bs*
z$Lj``E=~FJJuyE?h#)~DAEHg5V@PEPLXIG#*5pC(OTd%=AN?XDBy#6F%@Kx+U-NdZ
zxKF?0qYIgAem~xWFCX|b(S*%VXCWaYYqBWhl9t{N|CAu%kqviPKNlMFM@F@dA_Rhc
zWo{XZm8)tT930%@;sy=_pRnyovbaA@g1%MnyjLe@(jra&Z10rU{djZEqu0cXo1I;*
zpn5xdZ@r|3n~$$~&g07Z&)c&dDGeM>Vz<8?<~RKK6;EQ4UKdPl-(PH7zCD|RO_ryu
z|N7PD`zzM%-*42L1@f*oykzQX3s@IQOHJiEd-hsKM+bVNh}WVq!xM8)Z<!*RTb=|#
z(mzXGQXDH+u49}=OsS<d6Mv15du%S7I}BGE7FoCT$WlxG#`;XQ#AKLMc+R|5V9vtE
zzkQqf@#Dq51<!&WH||e&`;wEB&#ER!nUoB=hS+-e?XEPO60z(4+t(rQsW>Hdb+16p
z$T741?Z|lF#Y<@!8TPxIE7`fZ-Ec|&2$O_P;8v5F`%=|Lw21|ix3{;1>+h%NjG>*P
z3YKMHV2D0%{$PD^D2GAFD$3++`)_n!?@hk9K0!;H#((n@mxM%lk9|WJi&#dcj{zSY
ze32NFZzQ^5y&DZ3G1WVZmluXA^b2bC%56nTn?l8gGjntKV8XhK@qZ#~bP}Ze*I?Rw
zgb^x+i*i4H{D|~xylQ8c-IHsmo#W7%st5ymySJ7hZM(fT^Re&lBJYXitEUM`D@SYZ
z6V3J&Syv^cdCc`-;`R0P?BJH!?yNTt9z1v(8=E_VU-aS;6s#HbZGJDLKo=q(OvRLq
zt+r}8Wytp~I`Dk(VTR-|={<w@@85qk;Di4usj0o|UcMBR5U`z<U$f`)`0-<I2?-;w
zL6_j_t;rZ8|LiuefttV?PL-&{>1i8zdHI=P-z8mJ+Zp+W8{u>U#+iHg9bQ;M7cN}b
z?rRH3Pf-Z#sg!~x9LgeX8ZPWSDr3k;ry6yB?7@z4O+XbX)#=R9(OVv~-HJ}I4&tO9
zl2Pj|4Oh(#NpWz<!x}5VuCFw(@bd5|NpF6p7MSse<*lToB<!^~7+qLnfRFEig<>?O
z9u6aRA8;s{`Tm-XhleMey=rH%0tU4GD@1U1{`R*Q3@~$;06nW4YHE76wpnnGN*<97
zRTKen<r!{n#TZeC&U}-K?i~FB%60$I`(*G2V|4xa%ojGS^;sv_!nWI<jBzTyxAKcO
ze<E;yBT!dEBauzvr44+j@YLnyWzwC%KR?c$x?u50!gD?|OFIJ=nTlY|?#KL!MG1$I
z>MG7FdKGi|72Qd)WG%6mv<FI@dIy|p@_O=a&XrBYSKKmjn{4i=+8EBcPef)1?`v#n
z!Or&;Va)4D{a5PgpTB(Bv%j~r&jVBARK1lRAFyrfG2MPOPQt^^IpMO`V)qC0x)Y3y
zIq0iDe$-Nz#J&CX>z5sl@v>(wv)}S(3F!n_uG8>N>{8(VjuAdmz$80KHkjwknbGj!
zDW|}l80LGU1SbAC?Dke$pnxKMu35IkVBg83M~_laP}u2=eEa_6ho+59<~3Pa4n?nF
z?+i}0*vyTQKr{cH^*rnbeq*Hf6{~FbCx@FQRe`tPMnq(#rpndV*Be!M<_-IAn53np
z0l<9C@jzO_32Mjn@{MhO-W9F0Dq^s;wf%Nn{fc?6LE)E7_y_9*81jUD{5~0TCU$RN
zWUuGd9l!0F3=s!dBBG?!%*Ly`LtY~y><nbo%(<9_S!~V`#c%L$`~K@MPusF{aA31m
zM?XJ=Cg8R_+qtfcu#R#M`|;mD-iSDu1#G36V~j#w#=l{UC2`%_a2ssY984Pvep=yr
zj$YoWQ>W_AA5KY5{$ev!j_JtJ7fi{`%}vLrgh^dwXHb{gx)aw{X4&+Pa<S|DVKzz0
zA#y4z(ThSt_Wjj++xF;)ruMg*+S<e(JbW06ezklI-YH;}kqt1FOF$ssmY19R0{qQB
zRP**o12h5GPf7>u%G(!kW@(14&XsBHtS<<mPZ!>9=&@rFvU<^xuF6<9<K9yYiwXa6
zByf53bEGich!`vzqub7_En<v@hK7+<(zOZB<R_OOz?Ze_N>?q%uMglRBF$#Q0(VoM
zP_yKJau}Gcqn6H{DRH0CQtX5Yv3J=2c{@xoTVicmwXd(QzwmZ2y2Ib`-|Q*QNKdz$
zZch@y#V<wH>{{kc^_m4%sl{K(`ts!q>4^1QPo6};ZfO91&a790%;op@*Rwr&1D5`d
z8C_Ylyn0-ck|qlSB?Y#yseR*Q%QZDM%g0|{UfZbIubSl1f}2Pv>ENcS9^G#!=rlGp
ziCBDnsvMBe^!oMdj?Cc8!^+`G%E}@>Yc`J`J(`A{n1|~xbs2Y`|9K(Lw5mLP0T!M9
zjT=t`cE?%FoNEBF0mCuO@ZX7v36Fjg0sRy^CYZd77cUAs4PP1Z-xvzdwjv=gJ{=rH
zAjlx@oVW*TJv%x18oDUx1Wj`di>zi^FE4e!WV+m)qCjnFWz}eh$#$D+#e5143)6RZ
zFNW`2W#oq20rS@Fo#(r;XjEwN7+}ecBz0Bx6+6bJ<65};_L{By_3Ng8cHHNBROfmN
zYJT^t$BHL`_41hMOl!60=H~YJG6zE`zV(?9KPA22aYSq|5muI5Sy|bs%bs`h0$2if
z3rP>3)Ns4Ep*1q4RW_$Ib^M&#cUS^fsHv$7+@?on+-EbS@mc7agRQON&|jQ|+Xe$4
z@#<9~x-Z2>{ECbPBKP(-YUW;EUeu72`${qrSoh>e`N}uOxnifmQq9$=wgRjttR;yI
zy6$s;h44>!_LtGNz&*Di*Czh{3NOLn`}af6AcUrLCr@Ug-~^^;wjYzTShZowZ(OPY
zNTZ{g&}4X}G|8cLUtxstRQYzN&9AwlBP>$JE-o%UU|rqoj)+YIxM}<O`NbihVCfYI
zgoeL))0G(ji-P{JBoP@^E>4;TMXhwTIHR1lhtyJ;VN%;SmTLB^9m{9ZC3Zga-7N=P
z$MxKFnt|>WiQfIGQN%e?zqUAZ6YMmmpV@c*LVZKS9N3HkEHevBU<V#Mg?`JMPF1Lp
zEOWSiVp*41rdE!K^zbVkk4)X{=nm&H<Ngw-gmSMX(=I_VG5xKrEs-K7Tvoj8&YsDI
z*%*<#cWZM4YN~uUdb}Ol;w7Iyd*;$~wt1?iZR24BENj8dGR9*7yRTl+pi8~g9_JrF
z>nvp5dRlU0(9P)Moo6Wc8r}Eo%{OUmZ0rORCAi}+AToH4on1J4q++Ss_cQPFk-&Yt
zQLw^g&v}D6Tmws>@ly3pzNya)M<|0(`e*zLMlm(P>doXm{8FHO-$%>mp`i{sKkYh_
z<>Sr|fdj_D&R**9u4sFe_QZ)&%fKK(Huzj0d~kN)JEpcu?_q<<a;W`>JqH}Nhn4~|
zB29g=dM=&?E4F`55%Zv7L)T2T+;K<(H`Aq{g`FRXajG`Va56A3NZEU>a^r>uI4P(_
zRDFLj&59ug+%emU#)#19E!!6aM5LK8vp#rSug8f02G+Qx{BGYxe?TK2u!e%(38FEo
zV90yJIh4U3=(^c#L)#tCX?bUdtmc0fMvK_L3s?y;%PcJ|ZJoMV?w*C3tOq+2mFflt
zKRJfV7k7%Rj?DBGO_7+@ESArm@>|%NO6a8&tV~3`8=uXwV8POa?rxp5^z_+<l93*8
z7exYgH=}csswTcZI}Y=d*R=;r;JZa(rddsZX&#x)OY)!~`YUVgvON6!*sy>#Ht4@9
zEiEnJN(vpHLE`V<zoTWJqu+aTWgG`apGR8S49rf?R6<~WncEZ(;MK5OW;SlVPrKLD
zH!oe~eX@3jS{9gtXz9Re9$wzLwS|$I8ni8NtL<U8P*77lE$7p<N$*!)e{nLYxL9}y
zzPCtIt(?3(_R^z!W%HgDsCzo(yHs`R%DoTZuxJ+@R&jOx$n3w?(bT_GY}-}rx8-UQ
zh{tW?3Ig*Q8<nbd|1^RBmr)I_wFDllMUH8ekL}o($FnHbo>_rSVE^^$QI7|^X_e~x
zdwATBa|zR^De4A0f;tYp#%`()6Fzr&T{f(|R~Ucq*C9YA`JoE0Ug(AX91aXfk729T
zV5!UYf>R)`qT^0Nkn&2iP@4@3Ag~Lu)&9QVeJJg3Hb@s+HqlAKoO-k-k!VmC3Cfc0
ze*S3L^aA#4+jLJ}%u!}$M`BXaQ*oEQM45f2S=q$IO7zTv>&#VRL|eeXJTxyE2>tq1
z?snr_?r-mftnF|+dl%0`phre^`n+S=1RWa}*Y~F(AwmHg6(g|O89d(I=N1qUU98@5
zWRsBSf2C8zuHxTRd-937A1u6Y5X@LVdi3Zdn2~Rpnkg?(|64C%*7BBGthi=QRnmm*
zY!Lu&iqlB-bq$SI9Um=~$KeZHczODg*3#aoqQfuDPk!si*oT5g%Xt6({p;Y5grc@D
zy=QxOB`i>w9m0X;Ol*8Yf)g<@@ktig<Fr)(556xL9ZNrxA3Ah_-K66p*P@2WZP~EZ
zK&Na=YimZ)n3m~&%p7gi#)JS-k?Vxgc(C+t(t%-jEMWvc>!9D2FlkSkCd!kekwEhc
zFE|6NM3H+P;0ofVQ^IBe-ZA+$d!rAj-P<HLxC8~&0YEwRY^p0OuK)~8!)NZ^-wE7r
zn|DQwNqY#0gNhE<wO?MUO!@qftk<xW6FmCB?XHAfsa-`~F9#QiIFEPV3EKUfsm>rZ
z`dV7a)Y7{e;0X7$#$AS`hR;z;Ft2;^Uc<2K&rC+b>|8-jk5Jo{l(n_B>v>qRMB869
z=aCw(>2_9hO+l!4us*Hhy}!+eN2jvNKCv197FrHlcMU=XZ~Sl#G8p_fLKi2aL6F)u
z8iW8rb`KLA{NhZzObdVv9(2^%vu6di_Tu4|(@)I7CA<OF?KO5b!Ofhwme(2VKL;mg
zv<a{rrH6y5S@bGA7n%j?PQc%2jvi&rnx*Huc(F5Y$5Z^YQJHJnlOv3r6+??X{^O^=
z^<6$`y>u(K>Y>XzmHJCJbMvHQ$B*0ZF>NTo!y5iS#o$3Ug7d<{I<R<l@2{NsZ%;VA
zD3VU7o=708M!S9TZ@2&382+Drd7(~R3qE?IMPauOI0p+42Kc~;4wZXoJ3D{KFQ4V%
zH!1H{#sb3;)pU+9ksZYuaLYu(aC5z4KfPc&Pk}?TShF91h6NDe>ihVVdoJ`()IWzV
zHIE4qoIi6$W@TkXBrGZ_igc$nUh-ziuul$i;I50u(y&QahPr-D0Di5Jx8Po(1yCk#
z#8D<e74rin>M+Hc(235@PGPr66$pW=hpW-p2z3%Ms5Mu9$5%G$`!+H%r?Rqg(i`S3
zHJefI^68hnJIIt_;br|MPfOnI7xJ=0rDol_csIAHHfoOxt;3(ieaXh>nc`1d2Y5;y
zLkh|!Pqjcy3QkaCYikdnn>!c~d$5qtpFYj(l0J7%0sIC`KNy3zZ{E0l-gtk>Ej?W|
zMlZu33=hSTBUK-%UE(c+`Hcd;rrY1V`S$heu}}D9^A|;4=l}JxlT)3YS|v+GWh>7R
zad0c6m$bFDJz7M1xxmeV4SOG*!;-4Dx7^xxEvM<|=y)z%&;)GLzH=vaV7Ot$^3yxP
z{;WzNI+P~xtQd0Gx$f|n5_nM*{O^OBnq|AU*L;p}bVFW2AqR%hUlSNuRnXATz>C7%
zO-ILk;5GzHM-mgykdTmIZA%6g9PtzL-Q{*Yf4(woEHUD4|6PxNm)i1I@m06gq!5`_
zePiQX@Qk=vS(Ao)yE;3I?XcNK4gi1P6t7<QrjHopQ3==4FxNDE-1XZIII#j4>n6lY
zde93jAb7FM_;rYBq{CaRx}q-JW><ve(}fOrTY7i7&Zye2%+zm1exa{O0ZbScVo?#>
zPWB?HYyA9Q2x)1xL@xPm3QuvvBH8%!47vCF`%&;muES?5M<dy6U0#%|DJ(1uPX$r~
z5UzKPMcC#Q%GrSHsg2suWciTdJ3o%$X0c7VVHyfrP1zwz7uDarH$H?Q%OX-PRHM6F
ztAd-`;0eqYhcZhV0cWtTA+MkB-=yL1QLOPk1A=q}S)4d76jaTXrHeg0n)HTP2KYWx
z;#$t^Z5n4fp&$T>7V;of9o*qtod5bwtBFQY%X5q&&gH|2!wBNcLU`*q_9CCgRZ-a|
ztW4(IC!vw+&<N~AF45B29a-;#cBSAFpXkq5>`W4d7Oou7b|eiF^C7B8D9D%`cIDtR
z<maRM^F+WoUI~I9UC5!KdxQiZ4&_J@`>naZ=ixD#q$5HQKT^0BQmmYGU$o4C0!6B$
zaG}T`b)CPA4W4!ugbwNZE6}tOp(DJ8-2GL0?mS!<gX@v*>on&N#$o~^JALre5d36}
zlRp!z9+BPoLkn&lZ9Iy^l$Jh)Wo4i{bJ1P6rWs%#38FrOh`Q+Iq)nb*W~Cy6zKFpE
zq91u**cIRZ9R&3JFnfazNv*7RGeU?2@hTv9Nn1@0H6K0$9d#wHwMyKkId4w@1NK6n
z#R>(%Yk$mKRLO^t2z$W|XIOdU?u+K|#0oIoMkmwxF?mo+P>Y?Ws|uEH)XV!cDcq_5
z1o^4r{`^QJJCnHSU35AV%h(Xn<01sh#3*<gGZ5Yq>d5lIM%1FS@0<p0d@W;;X+^*K
z--oX-BI+k1auS=(T}9yWOX%ZcR|%en9e&5|-(Y?Vo+5##zL%{cmkz^+7GNRxz%X;N
zE~54y6ZBfG(ApX?q(omw0I%!J5<%y4v~lYW;<w&sZCPlr_MI(E_@{Mi>?NR$FwCDn
ze;(%jb5Tc-<c;@79jc5bbaTnL(E@L|_z7H{Du|zyR8^~NM!tW)0sLOcWLdq%${kyM
zKB<ca@Vz7S#3MYii#cgv`iv<Oq6zo}1bQGINC6;L<~J%XwFwNVPu|?zj8-r<j-}78
z^wZ0cXSzg<_K+2Bj}>=G1|lQtrem3W;AS0*Kz~hXsR4v$u4Trvy#)zY%~46<Yl!}=
zsjM`HNLQqdl9G}`5zvV$*q7cqe|ThLV<1U4)02t6yX4a2@<MywlIjd;JDb=s(|>|w
z@VSQf331dUwOgxG_TWJFgA<gpospV4Ef}~JqNS~kQe5<=_pUx9J<_>2RDlJG%%|l4
zfa2tB#_-p#HRsA!i{-;r=RD_iEmp*sz10KP@GeiR{}Ub;f|nL$@-;%jZ}S5LxQQ=b
zyoh$&e*$!*l>hcLP||kYQm3hcAtcMcaQmALu$s8_EGN?Q0M8KJKY#I}@>kmm-Up58
z-KRDB7S^NJEh}8tVo1!g)Ggl9?d_iWkAp4y@IeEZNgggP=bf67mdEPNh~vN~RiJKB
zduZ1mtCj%(n4xd#Ee}%)j3NDC@Q|baNVPvEaDR_<hnR$fn~N)R*g+DfFuJp|7)`^W
zxV<R%jF6BpdiODJ%j0u_PsD@4tN3>me~sLOV90)|H4f8{2Fz%%v5z0w_wQIfr%Un;
z{NdS81CFaY?;T$QmeYmk+)LN;uBUw-n#p(r%(=kVbA-3#<R1CpW_5G;`S?`wj4;`@
zEMkta{hu6iz)@BTM~Ofa-v!L<U|G?h)m7Z?Y8$VRkT&&|<)GfVniHQrV~*W?#51Rp
zMHS1%iEee}$>RhcE`0p>@eU^bCT?<VrpssfGg-u&Hz{=dMwu{FG!pVzn>M$I2<_q)
z&E-T)2VV2uCqQb`R{D@qtCna=sRRhz;D?E-2ZNc~cT4q_B$J35l$!-e02^ebFf_$A
zqw(nWQv&ErdU?TmiS!x*8#?knz>aPk!rUUL{ST8R<0gyTePZ;Ogoo#=K;0{<Nf+ib
zfIz|kFlf-G%@>Tmd4d%Y)sC|$qk%?@nPCs>`ZJI2jUPaUEo^=rdP4Lm6?iJ!-uO{!
zwruS`cP#*GdjIucF1~io;I2`nTYwje@W@-Noo4T5wqb46C3#MLz{u$1(C$0e_4CUm
zWoX0g_n@`h?JF`?;G)*10SeycUO50uWdO@>+17{<0C910=U;HR3fC;y9(42YX*~Jt
z69h=L0&h7z1rQpfERWos6hGMBJn#~IA)=@zR_I8(IJ`n2&FaGRwKu%*xm!pGKD?hh
zMK7S($j_%AVEgz77SMbWz`9wUcmOLZAs4>Jk4}gT8x7(wgX0@D6(EM^LS>LO0+XBq
zVk;Dg+sTP#SlapHG0<<B@uP@;ZCTo_=XXv%IcP2YB{EGUQU9dL?lnc@X$eyuN6$;p
z*=KCXcF?T~)gKqk!^IC^6z*fw`c=wt8bNGM6DEe;7`q1e)P4gRf9*Q__zZ#|^w*HJ
zqayYMlXO2OexWnlejdHijv>1i$!Qfgmhda@Mh%k8@#}CSfoM*7aeg_+pjhAIzcYT3
zFp+xZH4V37zyAv~DmVqVu}Ti0E_7`@bo@r!C(ZEGf<r;DlnDJUB2qi^MF7w~zh5f|
z{B%NtU5G7#CH27S>e~XZHq6~FTYgTi(c-l$Mcee93nh=>yW&>MkkWqx?OQdWjAC}p
zQ5VYh_jYjg^kyhcIWsc@;a+4Uk4MdNBEnIUUCwd(V4`LHcn~^z`Z<UWJ5U}8_K5L^
zC5Xm6=JHBrA<EX@SR4}Z-*yN0T)m+3&-2J^+zaMdG8m1(+1h!+LEB$npPjnonu<oT
z_%Z6h(pw{{F`~AAe*eJqql7Gn@;l*DRd4UI#-=tVBYwVI3c~{&AOAyHpn%&G@TeIY
z|AH$_HBtC8Wco(1e9+}vn)yH7#VeOucjx`Mkk$lgGc=_DtnDf6|8StYMn!>->IOG^
zwz$B!Oe-lVDN@gw&GOD2W3ByPej)5JpXS?oI@1)cXhHkkF5f2pt^EtFX=#J!KZAEW
zRu_z0uA}B<W0M8@$n2ZIt)1Q-EyBmgr(<D}3?WuJ7{ik4$ht9&>(`$=p<?2x7#f~l
z$mbU5og2x;K64Er9l4@nepPCPZ9S@q$=dkTKO?KUH{-_s#BB*%auPp3ImEnVk<Jgm
zZ)1xu#i`}pEKx(J6}Vx`qCPu^<18!%gM))c4#1N>4-0cz_J`!pi4!MuGKL&WeCNYz
z(-tpRKQ?iBeHFG)?_TA_BR3ppUYGlY{zr5Uk#VfvvRW7{(+27-)BEtr^D@BNg?Y~Z
z)I7JVsAXgnt(Rv6$O~hJ9K|rt!0l4hbt|Pwh$49L^r=RHX_XxY@?=@MIeH=s;9P4D
zd~y(h;7PF)CD|e5o`VI}4Wyq);GUnuP`NIeyXl?tDv5VUF7{bEv>>H-%M%>z#6y3c
zG1Pwh-q@(+>FL?B3P#s<xYFAPj0d*D%L#mj8xVYD9cPb8nZ5bNKduG!(=waRSs`;p
z2Z$V*+L5AQzc$@5%>6yY=TjDJvyw~ouHq&i2X;B9h>)P`XBajUzrJIAPEMuqxGT-S
ztllaTMZJ@-2VqZ5nUH_+hJBVO3OhJk>TvUc`?NzIB$YjRjRr;6O=kGZY~T7|M6E#N
zUtf%y71_>ID;%RZ{2{xvQp+%-bcz*0#DkIPlzGt{tzT!^570a_6q&BeZX^1A0KQW2
z!pro?d(^|50vIzW_@t}+d0xWkOx-AoFdC2HZgdwr7ERw#eEc$2K&S#Rs9g@d_rp;7
zqV*E_pNZFgZXtkts-y(%4LC=7e#PxS&ed5S0GH_xk?C=tbJvx_Jr97y5CE(9T;c4s
zS8)oIIy3I?jgJ7LQNYOZZ>yAkc}VE~ZLG88zor9$K^7VDD>>+kP<}^2PUbAK{djg2
zIj}tdel_jElvg1t@FoumNR&VVVs55(K36*EOgdob{nGEZ>J><vEN@i2bTzvLBmoma
zyZV|`#p%PSDS+k^G7V{>QG2@VODrSZF*VOW=6Po##)u3-&a<HR+R<}_$V)_<r5~4{
zIQT{?a>&~8*PlH-P(Rwg-W+Z96hV8~nw0O!D6})nPS8^4)O<wk<(DU-(AetyarEzs
zcUiOSNZZdJev<=pWd&dB_1jHy5>f+QjY*BkA6i9CaG4Xm40!GH>DgO$f0xZ-)Jz~n
zGzea0e_c2DehKqga2rMoV7yi`uDZzJJ4LYNwPr`r8&cner&g88^Kf}Yq0@Svh@idg
z>viHRS(T{6vi<S(d@zH1Pm$?hQg&S?(qY%>w?87Fbs=cIz4mu@T`d}p1O-BLx!G@D
zz%3%83#<#ccsj84&<xbA{Y!3>;0Sd45R;Ml7FxLJnvs7Tzfs-D8+TwrD)~{2O#)8Z
z2RwOfnle4ZlO$kiXCdFwPH*Oiy2(8isu0pc4*%xrphe-m9OEvJr-!t2KFGxJWwqz0
zkciMffiCTj9w%__&eX)jORqKy`7B_1i$NhlN|ab{q3P#WDb{H33h8H3_LBDJLuLK0
z)52)@B0YYbVA)SCLz|LbKu1yW8Biyu=FzA<HI=>0SOB#Nz!Tb>=hNdA6x0XrwPp3o
zmurgQbz`sU#)dg`vp1#|@p^MHCv|BN>iBN_!+zi2lF>x!VM5ve<~gIZNqGJF!*%m#
z2hG8igy_Eue7_US%=xH@102Ylk|p3rik(KJfC<k|Oq3C<Tz-Ihv%u%(z~mgMZs^X^
z76F1sVqtZ%MH{lX15zPkr+LDy7AQ0ff|8^UJ2%csE7TGo0r|znI$k6GC6M$z!N6ea
zc`1GQJz}7#nFKLD<QHrp>)^AqP=fJXFv3lDj3*CBoTfsFCCIaPfHTQBuRn757FdKo
zfBp>aQT}!o2YMz6xQIr_k_wNJa2?GVt$l`s*%x(bmefbIrh3L41H&e3yT)Je{CjBf
z4{tqy3Gtt#alUmcQNnAHPjMEAbyW8O!iPD~Qj|`A@~kj{^fMNCTEU-!TwFJ<UcHKQ
zT*{IrjPEZQ62K|G=$Twnvu)@&>)|x;Wnrl!_TC@sr*8j70lpBD7Gp6aO_vgg%;~v1
z^jJJj4Ydb{4jp37&$i7nrG7<{1bbCb>H?9tW#fs^lNYW*qDNm-^EJwIh}ieo)IX;U
zPlaT17U*lDfvIAj0j9JE(`%Xo94aql4^ZMCvWB=?BI>BE3zd!t<uxK?G}7-Z!YmzN
zj9Lv(&rhIbc^e&_4QW#wAjA(C6~nwK&dcfvQh8)7ej1l9U4n$q<L!;50`Ol%XZ^04
zbr$#+=hAV5Z|_Rk#wE}hNLNRS)Pfa7{HEf(1P)jgJIVj@)jvOv4t{#8qP$*Vc5eQf
zgQU9=n>K!qMjSS1qjejB+_=sNoufS`ic+J3u-P3E`Ul{5dBKm1vqc2UbGIM!aNV|a
z2k;?)U0$z1l5<-n%J|9J)>SJ4m?1J^8Lm8SUd7HQcyCU9fV#^22>FrO6Ksn8?xU#(
z+urF6l59ol?Bw`b?S#nUB5L=x&LY?N>j<%uNwZczV`^^G!LBm1p1sx%G1&HeQQO=1
z@3Vl%tN->b8~8||zaPH0+)BF|XEYN7gSg_XmEu!!0ksdKSJR1Wk1&ebtk3stLx!0@
zxGpI(lMBro!_o&Kj6QJqxYdMx<C@(GLE587&96TTu-3@X^RdQXb+}TCV*RE>0SjR@
znlgWru#2j3Q1bZs^XKk=ek(Fva+L!G1DY%h*xwnk$7buISx|^VD@~Hk%FAVy`*P_l
z<N2_!yV4F&`^xt@p&*cmbW888P(zgJW483OFa=eItc*9z0g<i;Up<m{P5tO+&$Le=
zo%DuV=tNzoCKst-hw-qQCJ^k_3kG!D+T5vTmh_p1T-3U=e5UC1JhqmP3{1L{5RPXQ
z64kT6f0UcE!9ruY>?xddc3-cGdGs66Im^EuKcap?1YwqNzoC{<q~;5b=1XQtyKC}$
zd4XD#B>lOK+*eW_dUO2k^4GUHK`1jAy`-OO0MnNlJq6$fiU=)8MjeXSDuD<AAD)ca
zs?hFt9!-___9VvS7}y^~oA4IU(Cj}f3T;4Og)uD}SO7UuPl#Z(%{9x?eC-#afnG{6
zRKIQKF^Yd*Rr?m1b}eI9WRh@i2c$o7{P^wb44Dmyt$Aw}*RhY!2t=~xU@bfqQF2d3
zk_=MR4<FTVa$-!1uMs&&n9R1v$DTc~U(BO8L_BbB_xgq;5DJhL9{p^$?C%+)tM6q4
zk;R9E3UnEVR5BxGz6&BKQU!uq0M{Zm((PRZP^la#fJIdzsK;5Ma`?&|SzL~lWp9A*
zm)}a@PMo_Zi2(DV2icZb_}Cy45`@ftHat~6o1N30Z*m!9hgI4b@=AcEQ2<ywvp(Ro
z;rT3J>6>F7hhhTDm9+3bN(Tmb(W+7YOvy+<g<}og6V|saejC@=+^l10_};?8qPxV&
z47V_#ua}dRac&#)@`Ab2U54bkjK<=XTE!y^N39R$B2?v25EjjJ|4ku&Nwoc7z;~(>
zgW3CZN!xy%`5bDiZ>z*v@p5ss^Op=J3z(GKKtd7Csl1;Uy&|h+!J%ls9zXiY8P@wr
zZK6@g&AP8mYvO11YdRm0P`(9`-BGsdD9pQxpSF58xzQ<s(Yh6+tFYQsynnB-Zvu>^
z*hRct#m}Dxs_|D0QRM^#W<nl|gNC;oUg|=|U=1==c0in1MNUUvBO-Ed>6^IKGe2Q>
z3s})-GXx)uVCBPHf?;5dX-OY&tWX63lTH}3q_BMtUs2PlvaD8iKB?*Ig3Cczym-eB
zaTh<m-5|Y}#Im;>3}TDUFOMm4K-x|JEW90k*(+aa>-TYgpfP+vCDg*#<)oWH_TBY7
zjF3*dfKctmjaN+*oj`!ELHalc5Y=OQ@ZNYRXsXtI95Ril(t&NZjN`!qa-HfC8lDe_
z@6H${K_m{{fjy-Hnn=4U(3vHtq<AckUR|OiRkV(Lm{ol$>R@dNsT>JHM-I7@_Z*{V
zvx!EH-aUj6)>`;|h)lb1n#T+COAwd)L6(dD#4(#L4AV`;aJ{9!^FaU?MN;R=(3XNG
z!;q&T*;3TbO-b535_L>Q;HfT>2bE^NEF7CX$p{2SyB!L)HtS$Ks@MDNfrZos=jJRM
zTg1C}>5zjqagKRRNuPbQ#F2uEsz+BJR9DK8K3V;fwwrw-i2i)*g)-Q%&S~)cC;MKt
zHmRLlkOZYem^GUo<JigMHJF6vfCmEq_e9e~V@%jA5J7D&aW3MjC?9NmD1kgE<$7qR
zL&;D&EVxWaKlq>;N$^lwV#J^|0A)01jN2R!%K^zuw3L7OHf|0j+v=Ml#8|Q%Qckci
z<c3pZh|aeixckl|Dpj<x=fE1H8WRw(g42^z(gt3Ru=k(eMh^c_6$q3r{rTe>5gFNg
zMUap0t&WHK?clm9dIg=OwxOM>V<qlkSl<Muo{w>T<w<VJMNKXt>Ef-`PyfZz{T5#>
zT1`Sq-KNw4-Df~53EBGIU-cna$VB+;O#c3j3byoa0#EDeD&Q9|0C)WLqj>f6b!=>=
zC+GtSAS1)vw>0sT@8gY+wte~v!d&OIMML^%%ha_`S(|<PoBaas=AK2Yva<3}b=%}O
zYr<PfO3xwCOnUHu5Do9f8^U^lf?zy+KN8J?W2~rv(~XFV%7pYQH{>K8me_RhBZ~hF
zts$FfmY<{+IUML1O3}!JEpNb-r^~J;klcMfJ|FUL4$ezA+|et6laLoYe_jI!$9L?w
zr4h56pY9&yl)o`Lb<Z&V_n;aiqyHc~)hdP@H-54Zs4wnl^(}O^42`d~Ehu2@oZ<u8
zMHYWCiX2z9jrC`M+}>Z`ZS0xL<kTb^{r&ES30JIy*^(cG%|;kI-Mml0@{+bOe7%I#
zCn^|><E=Y?kV!D6f=D{{qUCc`7_q)EkOP@sa8SD-A5?5nPodZe5-C(sh)O2I*MNSo
z2SeZkiBA#N-#1!-^nitq1x<<VWP=Tz<MgqdTNMXDwPTRvg9*Ke8dB$Heio$5Am%s)
zw5gVsmODzwHofCVWm_mqp$M`ZH0V~{|Ib0UCItD-+vF|RZzQTdY#U~bk_Ug#CLV1x
z&TF`Abk4pfH>*n&G-{B)>X)V6`gGH`-oAd(IPYg%O2d=1C=)7R4CKInBws4$=1?Qh
z3#o45@A+JL?7)0QK1H4?)6v@L8)fK)r%qI$<Qqzgezh#a=wq?9EdCzNs3EFNJB$4K
z_+mOD5y_FS2&1*zU$OYxKoIh@sS^@gy<X2=v-@vy6a@hbdyZJf_|xU>;s|#C(s8a3
za5&pv&>${-Pu8Dme;CS^J*SLWwYiUidC+yV;m0H-)9)5_H;DFnsnC>ByD{7?pG{2^
zxQ4xO$plU2Bwjj${CYmvE^__#X9AR6u_jZGMh9m@On4^$hDMNTiAls6#qC#hwa@`d
z=s@9sZ^>(R{(*>;KS~(~>|+QkG-1+J7-6J9oR!#|<S{b&{$PH{p^2y#yN=AFqM-eL
zmu{3)t*xg)#^|uY_ocTu_3I}h4kA8*M+kYz4F~!(Fpv`C&NJf$r6-9Y>IVX`1T}?{
zXEei$Z#9`8SX>||9}Vo52HphU%%QEZcW+$&!238Q1J{dRlJ|si=W$%1Bu8YluOp9c
z;_uwTnvVuLN@qV;iahA=HuOMGEd6V?hukZ*cRJHul4S=C%wC1tNq**TyX<?0r*0ig
zkK$S6%fh0BugG$_lR8&LV)MZmHjW}=o=g^B+&zNdxiWMn=P5J`K&bCWO+drE(p5zN
z(C@>-2V;S{gPXU=gO;BjtvYt%=!rzs@^4kVIe1;GEb>U<5pln}Z$kDC(SBSA1pPKz
zaC1~efvupT(I=ssWsj{7c9aeq^5r(f@}0H6>9XA!eD;gLqC%K&4gJtOPU`WBy=8|_
zdm=*ZV1kZ8FGO>#V~-_2h|o7q3ae=pMV;w0glDcaI~L7a_i`$R4-Yxtc=9<MtZ7sz
zLLRm=Q!57)0=j%YSx>~EUoRjGuG`Zxr(X8a=RYLmHO_j#hY-u$YuLQ{BRn;Y?-01F
zGtl4XrVed4k6F2;qbqN;7p_Fla+nYA^M!Dj1AXus#1W|c2SigK1<(L}X+(T{J|vP&
zon!u;2*|S7*QsJ}{t-^WKOAsCF)!bgI*NdTAm`cfb9R6rjo-gRh}{mNXdNvr*Ut;6
zg^Y_cS^eJpyFK+>pM&0zmkFdP8Rx3sbk!e>jTL1Q%(wnbVB*_AoB$TF2P`A1Tof*i
z`%403G}U=8R;O2)8djN+ttu7Y)&CR_)elk^aDgww`)dlopA7E?<rC#PuYiD_mR30E
zFHu7Wa-mG?w)i9Kg8wHE;4C{abzrYVZYJuU@^VNvHO0r7;@xYWc!a#Jx44kUY{oQ|
z{^Y;gtT%j5!iJ(hPq?D)rhY&`bx(oW$gLWbS_a1pbqlUuy>EJNj07c6E4-Fag$#)9
zpgtg4)WIlj9f$*NVc~9vgwMSZ;;C5!4%yCzYaxzmIGZu;ng>V_=YOC9%8<<*GrSUD
zXBUi#@vtk-Mf^1A%__jZOquD*=pD$YW~c=j7x=bic>3>S&Rjs8$_7(K3^{tuRmVJd
z-?Tm}$S5RohTAAGaMZ4Ab{Xg5$n)Q96=+Jp7v7aXw!2wJ72j~qfabch++$9Fdsi|1
ze@n;JzS$A&Y9sUNL2Z3cv)_WaQR@94^isx4w$&1?sz?5(ebOgje3Ar>+pheo-(Krd
zN2L<V!@*rM-4L;ZdUo_a#ftxm=4aU5pTbk63mnDWfhyft1tE#cFFDY$`bLX6#e+l%
z<S8k!v8N*<BCu-=U|v8BsI|I_hX0Kbyf}y|Y$36FPz%xAtRlHwOJwCoT(cI!DDlJY
zHJUUl2%|kf(11E1*zF6d(!m)3&88f%4<cb8j_zLj@n4KE=yv8lld<SPy1@f#9kL*s
z$tdQCI?c_S<N@55I91r%1c+8=PaOo~bP3{QA1?G3f}T0OXB9-vwos_RoJ}5zn`4bz
zTM`Td-25owawEy7c%|))3xw~SV2I^bv68G1QR}x5R+s+yQnCc2UIe6@VXjIGxvLkV
zw{R)n;eEydfF&rvbqE0M-S@LCefLWJoKmP}V3#*3AaZY(V`3_}&evwQQN?!#u1_35
zyi_Rilru@y{pmN;7<NUU020(r-2(tp{Z<g{u4Ry@dO3{Frhf4>3RkrNR~>hXDX2T~
z(wXHUO_aPf5nTstV!RBr|EKl{6D^Y+;Ca1KDel7on7knmve7#Ga3R|LwzXm>CGSS|
z@{79P&tYpy63Yl*8t)9pUJzA*<f@N1R_fp#z&>~UCMGq&{ie=Y{IR?EL{`E%`RBnS
z{P2jPtd`MSx?>(FE7pR;st<tCj{^GJv!vh|Ib_u_TXnA3r_JSWf1#~A9xsmcR`u%g
zQwrfz3UoDRE|#4Iq$h$$`ensD^i=M>s&3-#7z_>mJA>#*=#Jj)JzkQ2BiwZR_f4iI
zK_T>!XlcST(Uq5XFxva6bUazkv-|vg_5KeCkkV_=FK-YFwC(lkQWP6v?Al!LJ2`iY
zlnIeULpCJYaQYa1(lhHNnu`l{LlP!h=C1N!i_PFE#+p-|iYDV<JU*sg3*6jfM0=gs
zcNR(RBR~AXZZa?pvSxdQ_@{eCOON_E2#|I@_yW0W>UK#hwgBPW`-531&rJz0VnCnT
zT39}T38m_I-DMeF<{pNAg7$fsg!xBgB-4E?W{?~om{iHz=Ili$)W#IP&b$1jV>vs4
z8XhsF=ji;?fZpcRCq`seuOf0qxXtAg9wA}v0O^v|)5>&D!QXfd&wP5YAd0tDF+(km
z)zTrnhj#kk-odMKJwij;m#(|NVQ(?m4h5&`V7{ZJVDhR~9)^pQ+UGX%nryd>)M!Aq
z8AWNEPH1u+cwEzyLpLvs-S2;+ow{#Q`DPVjs#1jTjNi4pa<5F8yVON<<o9=fW$t}?
zkN(MqoPb7(4ahBgTb}L|kraNZ0K>of_6IFYlQ7s-ZRXPIhu70NGdnG(^_LuaSCWOS
zB4K22z-+4*LLt(4m^M~Kz_=l#QDg=$_}jU>S%4BS_Ax@9aGdT$VsBuN+0m;6+q>=D
zsyiEw0u%(u=oMm_%~S~cwrdjBUe}+kD!HWWgrB;6@TGs8LB3c6C6F-^HqWXUUFaSr
zwZ}7XFwdtTumc&3Hps?wKsaDj;+VI#<_;Q_jpP9|lKLM)LrUzIn8gYK!{ekJ%HhoT
zTV(pAM93MILqVv33>4HD?^P>E6atjn{QO|f!_95$9P_`YPw9DsGoZu^U&FHA&ObB`
zRBtDdTgj}3X<ZFH#NtE{B{oG0_C7jvyt~L+9S4j&RIh02>AeF(+cPSPmi^_G3}>SP
zcr*wFHW^!BCSCQXk=Hc$^zf}BqqU3+{%`vQlrof=qL&w^_^64HWqSfE`q4umtP4*C
z9!d14HI%(XU-5R$`ve(F`yb&PM;x_HP4j_{j-G;4T{wGi9cyr%3khwnZk4pxQm<Jb
ze<$O{TF11QR9DiQwC%o|2{TR`M>OOT<&TZe+wMvoXcy7w%{6wbPm!*!p{D^vs%T|R
zL_$Krfh<!HLMx~d!2-o#*T1(rC5@IxLIqczR}5%9?cf)W{wbh~+uPfD1(}&6y{>O}
z3B*vGro&JQ2^R)yCrNG9Tt$MOynXj>cClhf4{SF$EG+^JC!{viN6_y8--Gf=O_PXa
z<6EPmCom2r6&1AP>pxKJdmy(}cHg+1Fn8mb>}nXMd&oiEwma`d(YckKe+FtlT=JzJ
zOtnFFTP<2xk;Q-QHJUB}9jVC&C$vc8ef8j=F;r8Cm8yb38gi_&#RChTVfdrVzpL@O
zC88ZZ`}gf}U1DN$O(~CgxIfx{b<VlQU>!ET@m~Vly5r-`Z7m7{gclCWzTs5ugqRu!
zmN6Ur0s0|MetuP;6|=GLAUObnc=d>9oT<LoQujRfu@ux4?R(ck0``VIX(RQcP3REB
zbPSR+kVr>sNzg(bc{w>QP>BL34to2X86n3(akM&NatqD6PBcXxWL+WkBkVD&gJxaf
z{TIjCYKgNJl5y)lt0_J*^!qIr2duAKHwxyRuiyhMU+e#^1zs<^eD&}t;e*%|!p$rY
z+1mp{hSqn0HplXtLXhJ2IZXRkW;OZXpO|sy>VWM@t9MTckj*OxmYDux0a#+Sf$5GE
zw3>-p=g}lPw{f)BzKm*Ag{rUXbNAl4n6+V|-b@q9{CQGj6E(-g`8tuM&ivaGXE;6`
z?tryfzKT)Z=8VbtiXhd`5b{`TwQeTep2aJP5-NSQF@~Y7{_A<eZiDk5A?m$Mc*Z$?
zGxHXHJo4e&p27$vp4jrhMY@(g=k|lY^Aes}mefr0Y^hqZ!{3ofHhv<E8!?;v5xAh0
z)@A8w3o$DR0Zpa?Fn?`(n>_for;Z;DQfnL=yB~R#Oy6<Ysuu%@2H6PV5eU1sCq~tL
z7UK6P3I~b<0^<WV|M)mGU2#C0F+K`CIa;#*yf^$=Z`SR*Q6DK=r_VXv?W|y=61Cf6
z1#@?n@Ju^7_sY?2=T2(jiy~Je1Z2DR@EA@!o{~1+CCcO!NQWT46V|$?5oF5HrLP`3
zn*>oXOJGFaQ9-;y3{|Xfg)j&%4iV6l5<{iyhH39rmfef0ih0*Oglkm1YN`y|{B|*|
z;;~kdWQa@(4RXJ!y}+N6AK!vI<>ukb@MNtgkZSg&zNk%a2Vs#iWM`7egK8})C@I>T
z_sf-*Ua%xaEz2yl@OLs5IJP&ZjbwuEXZ{Zu6dHKtH8HQSuICDl?GF0&P2eniD_;`6
z+ar<J*W~aUQq;!@Xq+GFja}VdmBiy(Hwo+*nUdKunuN!O_@jlLDqJaAqfD3)1OwS>
zvGOwCSUoA9hs>K-$qe~B70fK>zR~wgr>R%#8j{dIgSjFlJTq!#4#omc?K@qkDBT_e
zE`pmluJhcE`#7b2@n#5{Yng$}Ddd&_+{s$if8BOWuxqVx$RE`YU3zT2HvK@*qalZ}
z*lNjTk)04Ze}sT$`3&e0S<*jsWH*q`t&DL~P!`)xbr7oF^9ot?^M51C{9UL*4hdp`
zOt2}<-4fehp>de?XN<U7Y6&i`+HCL%JvMG8*fz(+U|a&3g@DQ|V1-*x9A{1)+5ZsS
zBk7XzEsf)cW06gl*Ex@kfrOct`eHUSt#>b7QlLRb&531diCtcQ_St@EYP7l;ddk-!
z`~hL^_Uw)O0r)-7q1|7n@D6V2N{xmpr;t$wxLeL4MOIj{DpGW>O?A7a#pDDygD7|h
zDtpfKGvo;4!21DTZvG+xA_YeR2ovOec_{2{qwlb}6tmWy$*kl^o1Oeesip7U4Y8V1
zz1t&OD#~6~IhElU&{OFPKq!dBqL$gWU@j5-pY682D|nA_R{!#i(!C-<_5Hrc47w!G
zp^l8a#rY96nB?~+0!ZR}m><<wSi6qV{K8X%B6=X1wHux?+@4xzL-~@}&|qQfaaPpL
zVe;>v4bD0Q48NV{4<yJ6NDX0^XZ*6bkrK}?r{FZ3q3YvC#S2d_dQRD?tG!<58%ddZ
zx1^cy)dqiF<SJXflE%O^O_4GwBJ4sellcCFA%FRWG>oH)ZQgDt1^-AyN?@Re3hayS
zmvvkHF5+gW$A`OnJj-12mq@WfEXXS$sUBq_0XrBzREvhYO=5tLhcA9@c3r~M{d$wv
z#B_>a5k_S7ttSg__u}ox(YPNa=)z^?E-X*7&n5M+OM_%$Um6h-4SrL5GX}_%(&9Uz
z%E~=Ie!1rLyBRZ>P0dR0s7>1hyodN+c`5K+8thqoxY6`>>jkB`ZY2O?+LN`{fCmVJ
znk;Ht;14QD*=O?!p7G>3+jV()8*Mnm_XPM}gHU^I>$CRu?kG36EFg^VnX<?E3qO^J
z!i_S$EQ-NHERrTfYAK<WFp5LPGwF^l<ykjl*}3QLWc4gwPEsZN15ApxgszrmQRNGE
z5(EC(KGB1xopx+MJd)?he@#4?2JwT<ynKA&=3~3NIqacTqKX2MN&XEXm>HRPsmu42
zZVIW-$!V5VUx_Ucq@L=%+XbAPJ|<La$y0N-gHuUzK<*d?K`j|<W9d5>qqoOcl0a;s
zTAKe53UI(n?tkZP1Wn8|)scYPnW@b|YqYa)C=b6b*YXLRzu93<t)X$YZVrKKCgW$j
z!CUM|y3ZMK_CR___zDOJizW@Q1G+vV5R(c~Wvu@`F_Xi#g>I7S9|GMapu*rOxZ))+
z=8bY|pvr{cENi^4AkN|omQ&*Ai!kB?7dOa<WWZte&B;8eXB{FAv=IVK;+nY-huT3_
z7F_7g>Ol*p7QwESWLG9Zp5F8&wVr<UAZ)T|$7c!;BV5@kBS*ud9Fq_ljQ!DUm^avX
zQ?D)}_ZSFhWKzIMM+3;A<7e$L^l>gWBP$mEUdeJJaa<_fiT+5Y{w_1QGc8x!GCa3`
zb!$vw=kSqYZdM+HLz=9*W+^$<-{eWNJmfz7I{Od{N=iLm)}zQExXGi>Q2``CHqL$|
zS+AnWlB;C;1=Vl5*%Xlk?s5}rCSI;yNW4n8LQTbo;xAc5=ak$><rE+8lo;~c(b8o`
zEuX2st|Mvmm@He@AQ9xISrdIrHy@E^%NrzqA#`ZwA*?0YR6&eO9OL2x_q-vKkJdsP
zL1kQL7f2dv;M9a6$QXI_7ZnxJval?DRwCGk8uGU^w8>HJNZjtXb_dyt?~c-5V&U*<
zz`}7|uF0LXzxw_qZLFr_XNC#7I88_MvOmw8CfpfBf}<k*S2m6m8$t}LAJQ%(|M({@
zgN43(X4UM@t%|d<gslM>-m~H|V^;~L{4qr`qDaD&5Wxp1r$=ilpolqRf4gAcZp{-?
zDY|!lm(>{p%d;-$jm#dsTY_qDB)&cp`I*r<qh;#y7~biTJUyRMYJ4t)*ZpIvafT9)
zUA45ytcHA=GOb!~S?xWBdC`zB4+u}t8PHPHJ-7>IPs1irHR(Rq%mKFBiDM@dX)1J+
z?h{aayh&?O!u``x8@TY#1fnE;c^=iI{kf+*NpJBa913E){-XWqQ8oeZ3UDTQp)L<k
zLf{;N#OMN-@;t136Z;ivxthniXS9OVB6YZGx|1G!%vK06d<;rd9=;r%4u)WgHl6Gb
z%}HN`sAv<ibX>gClz3yoW$)4m$dcVkqYCpEsAx$}L}CbuvI)&^1!2}VtZVum=z!4c
zYx@K{`y-iwWr@*=TSa<RRz+O3b`iP)3zzLQ7r&{Hkdc13!f@3Z;f#V>v{nbLF!6XJ
z+y^5*iVwQ}7(@P#hOO{OcKVQyX+{0nK0aLsh_m%V?6za~qwCL7H4v%3Y9p>aICcf{
zO;93d8Vx6|!0`^{q&x4>lBnIm7uSHkV*fGb4Dr&E^a<>a+eUyUBd|}yr>!gG?U?8i
zd(0#Ert;v!C_dKan26xv_R20zp0&4?Piy3fg-AcU_}9E!u(BnsTEwMTfWhqUF`cry
zETIU2xGeD<?3j*sn(~BojTghzaMPIZZ)ZKFNHIlk0#W}cOz+U;s<U*;x=)Mak38%t
zYRehm@ANh=EO*lN^$5zH)yCes<diV7bi42dUEENl-A2Jq|3-YydVss>K;Pm=1NJ)0
z={4J&Ny|Wi9IR1MLAKz#Xot3i)k^=Y^$_~mRXo0%S-WW?zPD@Y?0|6P($a>lT#(b(
zo!*K*5{WY7C$6r!o%#*#H|=7s&*!ad#w;}uoM&adidJ5tB7exzRYAmb>f)WJXtEfh
zrh;JytJc^o+pcu1tr_Sn;8+PsEo;bcDXfR|11D(HI(|3ug#Wr`o#%ST(=@6hvaYAJ
z(pYuNvze)Sz1xmtby{Y5FJ37avb_O|cp;~{L<f_w@2n^ghxhrEH(AD>(R4O4+cXEa
z88Fc2Gq*ErsUs=I&JenNu6nzOF+18!M4+>x?1R$dEi3vlvfSrGYiaIxf^TjZ85zy?
z;6)VZ>dyO3)O<Td7c!9y2`y_#JV8#o3OySKyW`_86!h%bGf<`GcrYhj7C%h|Q8Fsr
z!Kg(C`~IyC3odEsJO836spD0X$MD7z)(qu~Yxs4y0i7z(z20o8C+4w~vDP(Wce)>`
z_4YZn;-r^wOSrs%{OGA~-V3^IIc9I{oCM=~GkWH<EG^SK7YDOU^-VZpTJ&-Pac@>P
z42$r6Jx2JNUWFrTS(1ymrGiD%*}my({<AZBfh^<6{-;*f=_lMJFi_e)<k2N_Wd5Yv
z%;nM`5TL>NGnt8rwF~<JV)Ox*i3}2Q3aX9Zi#RRg{;fuhdFS@rkAEwflx%{99gmN2
zoEv!QvVI2iHEHs`!XIwG7=S{On6E};Q+;rD#Ia+?ngxJ2tWEK=BK-hmD?6ZA@(zHs
z`NGdaSvaRa2PjbpV^1(i`sf70$q^iif>mqb67JK95U|ZcdKFcdp^>5;6#H5E6C>bE
zf&#4+N+*mcFRO#%AY3?L_a0h62oMd)yKL_&IKUxHay<%^E!pku8fZ268+EBHFBcnl
z*zA`OfioOW<e{b_ITCxx%}z4#*RykLUyrNbE9HUoS9-7;=*|CGgNkZK|6l*|qHXZd
z*TYyZW;iX$eW#j<Dj3q#x&{VZP;I)7PoelH@eCD^P;XPVJ+eSKbhWwnC{iE;3Nm)?
z3l}>6Cimb>8Z8~2w|$mTUo1A=cB`%lL@I+|NgFsEpsQ|fm>3vj0<+E}<!1m2Nyj0v
z)_;k#VY4j%76(cjjzhxOc3p=B5`U!O@F?vEqddFb{5XXXwu=|TrO%tz{xcH|>cX)s
zm-XKFHFkRpzUYYmS<4y&OXCcBED8t!FIJpL_*eS+uOyL<{yxm=CIea)@xM(}OrpM-
zzb*)<P!WPiuW<@U;0EWz{aS&^7q;u>LVF2u8c3QiRIn$Y)uu;Ii)%myv>lwc0u~ot
zvqepRE)`U*M?)o&JzcXZXdWT2(k#$4CHb!^fM$XE43#(uUAmC8o)kz0TSZQ|L6uxH
z=vY7|a0eYlf3<&w&&FaNkU?{h1h$Ht)CT=XH;AgMpmg3U@>f^S|B^Mb@U)dm`-id=
z<1iqK5(#2M?r#=L$Eg;Es|Myf{d$0LT7wiimxu^<UdvAlD!>o2Oa^egQ6I<F>38>S
zE%Kq-6&)R_Vo%N9IdYDZb2cfMxpRNFZ9mF5&I!cV|L`+f1nQ^a#9gkTsV9&EctGkY
z%H*XwocNH2Iwh#$2m0&wJR}6A#qe-)Ne{?j$k1aO&@I$wx%C2Nn}G5{4{_;B+Z47!
zVqQIePJy~Ja7LE0Y7Ev6i;99EP4wP?VU!tV&9c87x&jBw*zN6Z0l%jS!rQ)y%~Ujv
z2Isk8_VntiATOUG>d>DF8kh2^cwacl!O~Mv>Kp_~&T6Kn@lZI09@~IvsIRw$3E<Qv
zDGdg>4O`fiWGE9=tMb8JtT>%e^q&+K)aXZsGe~;j6&R?|C{kWAgo6n};ryeNw{K5C
zN$J5kV|&|kK!6DV>l0-X-v(!qEI&v42kE}prg2uNM@7dA%eC01<1BjC6p&>c#N{3T
zy<)*Ca=Zvs2AZq>aK0A$Q9x8O1ILVvz9khqi-@v9Z5R}Np`;x)J|-q-bMxMtY{LA(
zRK+)I9SSVAK%Am`37wnTS{YRA6y6PWz7BmK<x$>}(Ww$n*Q>q_`hWCD9LSI9cTEEL
z!m%1Ce+l}-$QCQ1!fPWZn3(cFPi6;aGQh{whBVEgLx&IRz^|Yq%Z?U}Y)XS-0v7@5
zXpXw`!cdOOZ(3=9o{j?udCOBVpl-r7tFm%%{-R$aNZ4{g&|wESArb~haZIB{Dxe1>
z4`kN*XXWr`SeFz+uqU938_veKcLZu2U~^*7(?ufQzMY1;e31&_1bD!BZl9By`AQ}z
zo-#p6gc`eN5nJ!jnTAq??cSQbw5LzWCw~9F5e{P26UUBOxO!BhS{3xvD^&aj@B?Ze
zb<jhgM|?C3v}DN1$#q`}gc=dFaP3#6o)~(TM2=<(T0^V|-R{y>mjsKJ4t0J}Cei9p
z<#j=N>xa7gudjzBw|>8AgafDG@DVus;*SLVlhMYz=nfpdce`a3PS#Kk{}#ql09oNE
zorooG&}*|R%04-qh1~-J)$YrqL&JjK6`1}veXUg_sqshj{4S^ilJNeMYH|BE?jg&r
zOpKV5-rc*oeQ8@K;Oqp*9SOyvmA?PqPZzA6Qi(c$70QaztM);oCIaec%5_61xQ22@
zw#cT5v}|PbG~t;bt9pw<<K+v$Q?|rQ4iw+q_TQR_G=h^*0#;*2x{Eo^otuM-$ZYHq
z9D4(4)ZU$?nxzQ}f*@Z4A{(oZMMd`2W*=_dkN5kdh}NN|^Iy4QJT^9F^_El72O0vd
zar!#;y!jVm{ET{FCv>Drg8_-HI}9)8kdmsNJW5N;5mK*}1J6~qvW~)m4bvz#p?eo9
zok04e=2V4y2Y`v5k;en4`N4YY0UWlgg3VVUZ1I)+ad0rCy46tqo2jYkLk!gHpmHWq
zgJt7};cPh{*gf`E+&Q7AM3hjm4xAt~C?<1Iq=p2TFAkQ$i8>wV*($-zJ~wK%u?51w
zj~@BI8acn0rou3ezZoI^xah8FFdYS3$!a4vb07{Ya=|405jwDW(;03DCGuQ!L>q<H
zO$8&`MI9WII@xq9#?hrUQVefIGoeM88U#_RSrDs^#ri(`3%WcvFP!&0=li}q&-eR5
ztCiwRXmD49i34xjsQ|)_!m6`o3^w4m(?aC-VRsZQ>UThWz}=3DzDKiDjVW~h>qzd8
z4E>blkwF)(2nuJyTCqgpD1nx~uN4;hMV#`#hS0=K6N_rP?^76ICIb+O5CKX<QjmZO
zkV*rD6_}c<Vo$@#fo(5F-4r@g0bC&;vFn+rkYQNd*oV+1XgARAXg4V~Z@q&7v6nlr
zoC0wL94Rq#Wv9Ik*bBeA(dnG{z0SocHbgE`FQE?hI}k+;whHD2fXvc$!7U>E;WeZz
zs8PfXur2nRbvm6TeuHgdKFJ1Wd!|xi&*OHl(sp(7^SKTj48R{62s|WYF~&Z<)jyA$
z9{l{^+Z30U@~xe6lhn-f{HR*spTQo4w6LJAl0g}TR#h1~f9c>h>eHdB>6kAWB&DmB
zmTZ5Q@79iDqVxcJpD~oN^6R)Vg|xs?!CEa>bBh|1L9kk0;=iX#dA%3yZL9SRtqv*l
zDSEx$2L-j^+fGET)%329<B|cx-Nheq_8b-&tcGyH3Q}Yr`fL{djj0ovKFaw)E{zf8
zeZ7Q0t6h2_K?%EI8Eyo5=An@I36$MT=E+Cx(D1PM<pQ%05FM1;vx6nW;O{|YT#veD
zcX_gy{@e-#!uUEge>gk7n-N!Fs<^0V#hp`AC5JRd2l$AuP&%Hu3f7X(_iuXg@PThf
jC=SZ%kFmTU{O3ci!qRZ^rqNkR^i<|J(R4i8&~^DA4F6gk

literal 0
HcmV?d00001


From e50335bcf105cbba7e09da3cc48f5c090cd2d944 Mon Sep 17 00:00:00 2001
From: Sachiko Ponpon <150808503+sachyko@users.noreply.github.com>
Date: Tue, 14 Jan 2025 00:49:33 +0900
Subject: [PATCH 31/31] Specifying data types (#5893)

* add documentation for specifying data types in Pytorch tensors

* Updated tags.md and added new directory for specifying data types

* add main file to the branch

* Update specifying-data-types.md

minor fixes

* Update yarn.lock

* Update content/pytorch/concepts/tensor-operations/terms/specifiying-data-types/specifying-data-types.md

* Update content/pytorch/concepts/tensor-operations/terms/specifiying-data-types/specifying-data-types.md

* Update content/pytorch/concepts/tensor-operations/terms/specifiying-data-types/specifying-data-types.md

* Update content/pytorch/concepts/tensor-operations/terms/specifiying-data-types/specifying-data-types.md

* Fix file path

---------
---
 .../specifying-data-types.md                  | 69 +++++++++++++++++++
 documentation/tags.md                         |  1 +
 2 files changed, 70 insertions(+)
 create mode 100644 content/pytorch/concepts/tensor-operations/terms/specifying-data-types/specifying-data-types.md

diff --git a/content/pytorch/concepts/tensor-operations/terms/specifying-data-types/specifying-data-types.md b/content/pytorch/concepts/tensor-operations/terms/specifying-data-types/specifying-data-types.md
new file mode 100644
index 00000000000..7d77c8f1ff3
--- /dev/null
+++ b/content/pytorch/concepts/tensor-operations/terms/specifying-data-types/specifying-data-types.md
@@ -0,0 +1,69 @@
+---
+Title: 'Specifying Data Types'
+Description: 'Determines how tensors are stored and processed, impacting precision, memory usage, and computation speed.'
+Subjects:
+  - 'Data Science'
+  - 'Machine Learning'
+  - 'Deep Learning'
+Tags:
+  - 'Pytorch'
+  - 'Tensor'
+  - 'Data Types'
+CatalogContent:
+  - 'learn-Intro-to-PyTorch-and-Neural-Networks'
+  - 'paths/data-science'
+---
+
+In PyTorch, specifying the data types for [`tensors`](https://www.codecademy.com/resources/docs/pytorch/tensors) is crucial as they are the core data structures used to store and process data. Each tensor's data type (`dtype`) defines the kind of values it holds (e.g., `integer`, `float`, `boolean`), ensuring precision, improving performance, and maintaining compatibility during computations.
+
+## Syntax
+
+To specify a data type in a PyTorch tensor, use the `dtype` parameter when creating a tensor or the `.to()` method for converting an existing one.
+
+### For specifying `dtype` when creating a tensor
+
+```pseudo
+torch.tensor(data, dtype=torch.<data_type>)
+```
+
+- `data`: The input data used to create the tensor. This can be a list, NumPy array, or another tensor.
+- `dtype`: Specifies the data type of the tensor. Common data types include:
+  - `torch.float32` (default): 32-bit floating-point
+  - `torch.float64`: 64-bit floating-point
+  - `torch.int32`: 32-bit integer
+  - `torch.int64`: 64-bit integer
+  - `torch.bool`: Boolean
+
+### For converting an existing tensor to a different data type
+
+```pseudo
+tensor.to(torch.<data_type>)
+```
+
+## Example
+
+In the example below a tensor is created with a specified data type, another with a different type, and one tensor is converted to a new data type:
+
+```py
+import torch
+
+# Creating a float32 tensor
+float_tensor = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32)
+print(float_tensor)
+
+# Creating an int64 tensor
+int_tensor = torch.tensor([1, 2, 3], dtype=torch.int64)
+print(int_tensor)
+
+# Converting a tensor to a different data type
+converted_tensor = float_tensor.to(torch.int64)
+print(converted_tensor)
+```
+
+The code above generates the output as:
+
+```shell
+tensor([1., 2., 3.])
+tensor([1, 2, 3])
+tensor([1, 2, 3])
+```
diff --git a/documentation/tags.md b/documentation/tags.md
index 3a68d0a5742..9d798b7ca7c 100644
--- a/documentation/tags.md
+++ b/documentation/tags.md
@@ -336,6 +336,7 @@ Tags
 Target
 Technical Interviews
 Templates
+Tensor
 TensorFlow
 Text-To-Image
 Text Processing