Repository: cpinitiative/usaco-guide
Pull request #5176: reorg Silver sorting and searching modules, move some modules to Gold
Author: login: bqi343
Created: 2025-03-05T23:44:33Z | Merged: 2025-03-06T04:35:36Z

TODO: read through Silver and Gold sorting / ds sections again to check that ordering of topics makes sense.

_Place an "x" in the corresponding checkbox if it is done or does not apply to this pull request._

- [ ] I have tested my code.
- [ ] I have added my solution according to the steps [here](https://usaco.guide/general/adding-solution#steps).
- [ ] I have followed the code conventions mentioned [here](https://usaco.guide/general/adding-solution/#code-conventions).
  - I understand that if it is clear that I have not attempted to follow these conventions, my PR will be closed.
  - If changes are requested, I will re-request a review after addressing them.
- [ ] I have linked this PR to any issues that it closes.



Diff:
diff --git a/content/3_Silver/Binary_Search.mdx b/content/3_Silver/Binary_Search.mdx
index 5909e234061..58c531a612b 100644
--- a/content/3_Silver/Binary_Search.mdx
+++ b/content/3_Silver/Binary_Search.mdx
@@ -6,15 +6,12 @@ redirects:
 title: 'Binary Search'
 author: Darren Yao, Abutalib Namazov, Andrew Wang, Qi Wang, Dustin Miao
 prerequisites:
-  - greedy-sorting
+  - binary-search-sorted-array
 description:
-  'Binary searching on arbitrary monotonic functions and built-in functions for
-  binary search.'
+  'Binary searching on arbitrary monotonic functions.'
 frequency: 3
 ---
 
-<!-- process numbers from left to right, keep track of the last element of each block and use binary search of lower_bound to find which block the current numbers belongs -->
-
 ## Introduction
 
 <Resources>
@@ -57,13 +54,14 @@ frequency: 3
 
 <YouTube id="GU7DpgHINWQ" />
 
-When we binary search on an answer, we start with a search space of size $N$
+When we binary search, we start with a search space of size $N$
 which we know the answer lies in. Then each iteration of the binary search cuts
 the search space in half, so the algorithm tests $\mathcal{O}(\log N)$ values.
 This is efficient and much better than testing each possible value in the search
 space.
 
-## Binary Searching on Monotonic Functions
+
+## Binary Search on Monotonic Functions
 
 Let's say we have a boolean function `f(x)`. Usually, in such problems, we want
 to find the maximum or minimum value of $x$ such that `f(x)` is true. Similarly
@@ -812,311 +810,6 @@ The first version of `firstTrue` won't work if `hi-lo` initially exceeds
 `INT_MAX` at any point during execution. If this is an issue, use `long long`s
 instead of `int`s.
 
-## Library Functions For Binary Search
-
-<LanguageSection>
-
-<CPPSection>
-
-<Resources>
-	<Resource
-		source="CPP"
-		url="http://www.cplusplus.com/reference/algorithm/lower_bound/"
-		title="lower_bound, upper_bound"
-		starred
-	>
-		with examples
-	</Resource>
-</Resources>
-
-</CPPSection>
-
-<JavaSection>
-
-<Resources>
-	<Resource
-		source="JAVA"
-		url="https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch(int[],%20int)"
-		title="Arrays.binarySearch"
-	/>
-	<Resource
-		source="JAVA"
-		url="https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#binarySearch(java.util.List,%20T)"
-		title="Collections.binarySearch"
-	/>
-</Resources>
-
-</JavaSection>
-
-<PySection>
-
-<Resources>
-	<Resource
-		source="Python"
-		url="https://docs.python.org/3/library/bisect.html"
-		title="Array bisection algorithm"
-	/>
-	<Resource
-		source="GFG"
-		url="https://www.geeksforgeeks.org/binary-search-bisect-in-python/"
-		title="Binary Search (bisect) in Python"
-	/>
-</Resources>
-
-</PySection>
-
-</LanguageSection>
-
-### Example - Counting Haybales
-
-<FocusProblem problem="count" />
-
-As each of the points are in the range $0 \ldots 1\,000\,000\,000$, storing
-locations of haybales in a boolean array and then taking prefix sums of that
-would take too much time and memory.
-
-Instead, let's place all of the locations of the haybales into a list and sort
-it. Now we can use binary search to count the number of cows in any range
-$[A,B]$ in $\mathcal{O}(\log N)$ time.
-
-### With Built-in Function
-
-<LanguageSection>
-
-<CPPSection>
-
-We can use the the built-in
-[`lower_bound`](https://en.cppreference.com/w/cpp/algorithm/lower_bound) and
-[`upper_bound`](https://en.cppreference.com/w/cpp/algorithm/upper_bound)
-functions.
-
-```cpp
-#include <bits/stdc++.h>
-using namespace std;
-
-void setIO(string name = "") {  // name is nonempty for USACO file I/O
-	ios_base::sync_with_stdio(0);
-	cin.tie(0);  // see Fast Input & Output
-	// alternatively, cin.tie(0)->sync_with_stdio(0);
-	if (!name.empty()) {
-		freopen((name + ".in").c_str(), "r", stdin);  // see Input & Output
-		freopen((name + ".out").c_str(), "w", stdout);
-	}
-}
-
-int main() {
-	setIO("haybales");
-	int bale_num;
-	int query_num;
-	cin >> bale_num >> query_num;
-	vector<int> bales(bale_num);
-	for (int i = 0; i < bale_num; i++) { cin >> bales[i]; }
-
-	sort(begin(bales), end(bales));
-	for (int i = 0; i < query_num; i++) {
-		int q_start;
-		int q_end;
-		cin >> q_start >> q_end;
-		cout << upper_bound(begin(bales), end(bales), q_end) -
-		            lower_bound(begin(bales), end(bales), q_start)
-		     << "\n";
-	}
-}
-```
-
-</CPPSection>
-<JavaSection>
-
-We can use the builtin
-[`Arrays.binarySearch`](<https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch(int[],%20int)>)
-function.
-
-```java
-import java.io.*;
-import java.util.*;
-
-public class Haybales {
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new FileReader(new File("haybales.in")));
-		PrintWriter out = new PrintWriter("haybales.out");
-		StringTokenizer st = new StringTokenizer(br.readLine());
-
-		int baleNum = Integer.parseInt(st.nextToken());
-		int queryNum = Integer.parseInt(st.nextToken());
-		int[] bales = new int[baleNum];
-		st = new StringTokenizer(br.readLine());
-		for (int i = 0; i < baleNum; i++) {
-			bales[i] = Integer.parseInt(st.nextToken());
-		}
-
-		Arrays.sort(bales);
-		for (int i = 0; i < queryNum; i++) {
-			st = new StringTokenizer(br.readLine());
-			int start = Integer.parseInt(st.nextToken());
-			int end = Integer.parseInt(st.nextToken());
-
-			// Get the left-est bale that's still in the interval
-			int bi = Arrays.binarySearch(bales, start);
-			if (bi < 0) { bi = Math.abs(bi + 1); }
-
-			// And also get the right-est bale that's still in the interval
-			int ti = Arrays.binarySearch(bales, end);
-			if (ti < 0) { ti = Math.abs(ti + 2); }
-			out.println(ti - bi + 1);
-		}
-		out.close();
-	}
-}
-```
-
-</JavaSection>
-<PySection>
-
-We can use the builtin
-[`bisect.bisect`](https://docs.python.org/3/library/bisect.html#bisect.bisect)
-function.
-
-```py
-from bisect import bisect
-
-inp = open("haybales.in", "r")
-out = open("haybales.out", "w")
-
-bale_num, query_num = map(int, inp.readline().split())
-bales = sorted(list(map(int, inp.readline().split())))
-for _ in range(query_num):
-	start, end = map(int, inp.readline().split())
-	print(bisect(bales, end) - bisect(bales, start - 1), file=out)
-```
-
-</PySection>
-</LanguageSection>
-
-### Without Using Built-in Functions
-
-<LanguageSection>
-<CPPSection>
-
-```cpp
-#include <bits/stdc++.h>
-using namespace std;
-
-void setIO(string name = "") {  // name is nonempty for USACO file I/O
-	ios_base::sync_with_stdio(0);
-	cin.tie(0);  // see Fast Input & Output
-	// alternatively, cin.tie(0)->sync_with_stdio(0);
-	if (!name.empty()) {
-		freopen((name + ".in").c_str(), "r", stdin);  // see Input & Output
-		freopen((name + ".out").c_str(), "w", stdout);
-	}
-}
-
-int main() {
-	setIO("haybales");
-	int bale_num;
-	int query_num;
-	cin >> bale_num >> query_num;
-	vector<int> bales(bale_num);
-	for (int &i : bales) { cin >> i; }
-
-	sort(begin(bales), end(bales));
-	// Returns the number of elements that are at most x
-	auto atMost = [&](int x) {
-		int lo = 0;
-		int hi = bales.size();
-		while (lo < hi) {
-			int mid = (lo + hi) / 2;
-			if (bales[mid] <= x) {
-				lo = mid + 1;
-			} else {
-				hi = mid;
-			}
-		}
-		return lo;
-	};
-
-	for (int i = 0; i < query_num; ++i) {
-		int q_start;
-		int q_end;
-		cin >> q_start >> q_end;
-		cout << atMost(q_end) - atMost(q_start - 1) << "\n";
-	}
-}
-```
-
-</CPPSection>
-<JavaSection>
-
-```java
-import java.io.*;
-import java.util.*;
-
-public class Haybales {
-	static int[] bales;
-	public static void main(String[] args) throws IOException {
-		Kattio io = new Kattio("haybales");
-		int baleNum = io.nextInt();
-		int queryNum = io.nextInt();
-		bales = new int[baleNum];
-		for (int i = 0; i < baleNum; i++) { bales[i] = io.nextInt(); }
-		Arrays.sort(bales);
-
-		for (int i = 0; i < queryNum; ++i) {
-			int start = io.nextInt();
-			int end = io.nextInt();
-			io.println(atMost(end) - atMost(start - 1));
-		}
-		io.close();
-	}
-
-	// Returns the number of elements that are at most x
-	public static int atMost(int x) {
-		int lo = 0;
-		int hi = bales.length;
-		while (lo < hi) {
-			int mid = (lo + hi) / 2;
-			if (bales[mid] <= x) {
-				lo = mid + 1;
-			} else {
-				hi = mid;
-			}
-		}
-		return lo;
-	}
-
-	// CodeSnip{Kattio}
-}
-```
-
-</JavaSection>
-<PySection>
-
-```py
-def at_most(x: int) -> int:
-	lo = 0
-	hi = len(bales)
-	while lo < hi:
-		mid = (lo + hi) // 2
-		if bales[mid] <= x:
-			lo = mid + 1
-		else:
-			hi = mid
-	return lo
-
-
-inp = open("haybales.in", "r")
-out = open("haybales.out", "w")
-
-bale_num, query_num = map(int, inp.readline().split())
-bales = sorted(list(map(int, inp.readline().split())))
-for _ in range(query_num):
-	start, end = map(int, inp.readline().split())
-	print(at_most(end) - at_most(start - 1), file=out)
-```
-
-</PySection>
-
-</LanguageSection>
 
 ## Problems
 
diff --git a/content/3_Silver/Binary_Search.problems.json b/content/3_Silver/Binary_Search.problems.json
index 54a46e252c5..fb837ec9b03 100644
--- a/content/3_Silver/Binary_Search.problems.json
+++ b/content/3_Silver/Binary_Search.problems.json
@@ -116,33 +116,7 @@
       }
     }
   ],
-  "count": [
-    {
-      "uniqueId": "usaco-666",
-      "name": "Counting Haybales",
-      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=666",
-      "source": "Silver",
-      "difficulty": "Easy",
-      "isStarred": false,
-      "tags": ["Binary Search"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    }
-  ],
   "general": [
-    {
-      "uniqueId": "cf-702C",
-      "name": "Cellular Network",
-      "url": "https://codeforces.com/contest/702/problem/C",
-      "source": "CF",
-      "difficulty": "Easy",
-      "isStarred": false,
-      "tags": ["Binary Search"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
     {
       "uniqueId": "cses-1620",
       "name": "Factory Machines",
@@ -179,6 +153,18 @@
         "kind": "internal"
       }
     },
+    {
+      "uniqueId": "cf-862E",
+      "name": "Mahmoud & Ehab & Function",
+      "url": "https://codeforces.com/contest/862/problem/E",
+      "source": "CF",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Binary Search"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
     {
       "uniqueId": "cc-TRPTSTIC",
       "name": "TripTastic",
diff --git a/content/3_Silver/Binary_Search_Sorted_Array.mdx b/content/3_Silver/Binary_Search_Sorted_Array.mdx
new file mode 100644
index 00000000000..abd263cd124
--- /dev/null
+++ b/content/3_Silver/Binary_Search_Sorted_Array.mdx
@@ -0,0 +1,321 @@
+---
+id: binary-search-sorted-array
+title: 'Binary Search on a Sorted Array'
+author: Darren Yao, Abutalib Namazov, Andrew Wang, Qi Wang, Dustin Miao
+prerequisites:
+  - intro-sorting
+description:
+  'Efficiently searching for a value in a sorted array.'
+frequency: 3
+---
+
+## Binary Search on a Sorted Array
+
+<LanguageSection>
+
+<CPPSection>
+
+<Resources>
+	<Resource
+		source="CPP"
+		url="http://www.cplusplus.com/reference/algorithm/lower_bound/"
+		title="lower_bound, upper_bound"
+		starred
+	>
+		with examples
+	</Resource>
+</Resources>
+
+</CPPSection>
+
+<JavaSection>
+
+<Resources>
+	<Resource
+		source="JAVA"
+		url="https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch(int[],%20int)"
+		title="Arrays.binarySearch"
+	/>
+	<Resource
+		source="JAVA"
+		url="https://docs.oracle.com/javase/7/docs/api/java/util/Collections.html#binarySearch(java.util.List,%20T)"
+		title="Collections.binarySearch"
+	/>
+</Resources>
+
+</JavaSection>
+
+<PySection>
+
+<Resources>
+	<Resource
+		source="Python"
+		url="https://docs.python.org/3/library/bisect.html"
+		title="Array bisection algorithm"
+	/>
+	<Resource
+		source="GFG"
+		url="https://www.geeksforgeeks.org/binary-search-bisect-in-python/"
+		title="Binary Search (bisect) in Python"
+	/>
+</Resources>
+
+</PySection>
+
+</LanguageSection>
+
+Please check the [Binary Search](/silver/binary-search) module for additional resources (though they cover additional material not part of this module).
+
+### Example - Counting Haybales
+
+<FocusProblem problem="count" />
+
+As each of the points are in the range $0 \ldots 1\,000\,000\,000$, storing
+locations of haybales in a boolean array and then taking prefix sums of that
+would take too much time and memory.
+
+Instead, let's place all of the locations of the haybales into a list and sort
+it. Now we can use binary search to count both the number of haybales with position at most $B$ and the number of haybales with position less than $A$ in $\mathcal{O}(\log N)$ time, and then subtract these two quantities to get the final answer.
+
+### Without Built-in Functions
+
+<LanguageSection>
+<CPPSection>
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+void setIO(string name = "") {  // name is nonempty for USACO file I/O
+	ios_base::sync_with_stdio(0);
+	cin.tie(0);  // see Fast Input & Output
+	// alternatively, cin.tie(0)->sync_with_stdio(0);
+	if (!name.empty()) {
+		freopen((name + ".in").c_str(), "r", stdin);  // see Input & Output
+		freopen((name + ".out").c_str(), "w", stdout);
+	}
+}
+
+int main() {
+	setIO("haybales");
+	int bale_num;
+	int query_num;
+	cin >> bale_num >> query_num;
+	vector<int> bales(bale_num);
+	for (int &i : bales) { cin >> i; }
+
+	sort(begin(bales), end(bales));
+	// Returns the number of elements that are at most x
+	auto atMost = [&](int x) {
+		int lo = 0;
+		int hi = bales.size();
+		while (lo < hi) {
+			int mid = (lo + hi) / 2;
+			if (bales[mid] <= x) {
+				lo = mid + 1;
+			} else {
+				hi = mid;
+			}
+		}
+		return lo;
+	};
+
+	for (int i = 0; i < query_num; ++i) {
+		int q_start;
+		int q_end;
+		cin >> q_start >> q_end;
+		cout << atMost(q_end) - atMost(q_start - 1) << "\n";
+	}
+}
+```
+
+</CPPSection>
+<JavaSection>
+
+```java
+import java.io.*;
+import java.util.*;
+
+public class Haybales {
+	static int[] bales;
+	public static void main(String[] args) throws IOException {
+		Kattio io = new Kattio("haybales");
+		int baleNum = io.nextInt();
+		int queryNum = io.nextInt();
+		bales = new int[baleNum];
+		for (int i = 0; i < baleNum; i++) { bales[i] = io.nextInt(); }
+		Arrays.sort(bales);
+
+		for (int i = 0; i < queryNum; ++i) {
+			int start = io.nextInt();
+			int end = io.nextInt();
+			io.println(atMost(end) - atMost(start - 1));
+		}
+		io.close();
+	}
+
+	// Returns the number of elements that are at most x
+	public static int atMost(int x) {
+		int lo = 0;
+		int hi = bales.length;
+		while (lo < hi) {
+			int mid = (lo + hi) / 2;
+			if (bales[mid] <= x) {
+				lo = mid + 1;
+			} else {
+				hi = mid;
+			}
+		}
+		return lo;
+	}
+
+	// CodeSnip{Kattio}
+}
+```
+
+</JavaSection>
+<PySection>
+
+```py
+def at_most(x: int) -> int:
+	lo = 0
+	hi = len(bales)
+	while lo < hi:
+		mid = (lo + hi) // 2
+		if bales[mid] <= x:
+			lo = mid + 1
+		else:
+			hi = mid
+	return lo
+
+
+inp = open("haybales.in", "r")
+out = open("haybales.out", "w")
+
+bale_num, query_num = map(int, inp.readline().split())
+bales = sorted(list(map(int, inp.readline().split())))
+for _ in range(query_num):
+	start, end = map(int, inp.readline().split())
+	print(at_most(end) - at_most(start - 1), file=out)
+```
+
+</PySection>
+
+</LanguageSection>
+
+### With Built-in Functions
+
+<LanguageSection>
+
+<CPPSection>
+
+We can use the the built-in
+[`lower_bound`](https://en.cppreference.com/w/cpp/algorithm/lower_bound) and
+[`upper_bound`](https://en.cppreference.com/w/cpp/algorithm/upper_bound)
+functions.
+
+```cpp
+#include <bits/stdc++.h>
+using namespace std;
+
+void setIO(string name = "") {  // name is nonempty for USACO file I/O
+	ios_base::sync_with_stdio(0);
+	cin.tie(0);  // see Fast Input & Output
+	// alternatively, cin.tie(0)->sync_with_stdio(0);
+	if (!name.empty()) {
+		freopen((name + ".in").c_str(), "r", stdin);  // see Input & Output
+		freopen((name + ".out").c_str(), "w", stdout);
+	}
+}
+
+int main() {
+	setIO("haybales");
+	int bale_num;
+	int query_num;
+	cin >> bale_num >> query_num;
+	vector<int> bales(bale_num);
+	for (int i = 0; i < bale_num; i++) { cin >> bales[i]; }
+
+	sort(begin(bales), end(bales));
+	for (int i = 0; i < query_num; i++) {
+		int q_start;
+		int q_end;
+		cin >> q_start >> q_end;
+		cout << upper_bound(begin(bales), end(bales), q_end) -
+		            lower_bound(begin(bales), end(bales), q_start)
+		     << "\n";
+	}
+}
+```
+
+</CPPSection>
+<JavaSection>
+
+We can use the builtin
+[`Arrays.binarySearch`](<https://docs.oracle.com/javase/7/docs/api/java/util/Arrays.html#binarySearch(int[],%20int)>)
+function.
+
+```java
+import java.io.*;
+import java.util.*;
+
+public class Haybales {
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new FileReader(new File("haybales.in")));
+		PrintWriter out = new PrintWriter("haybales.out");
+		StringTokenizer st = new StringTokenizer(br.readLine());
+
+		int baleNum = Integer.parseInt(st.nextToken());
+		int queryNum = Integer.parseInt(st.nextToken());
+		int[] bales = new int[baleNum];
+		st = new StringTokenizer(br.readLine());
+		for (int i = 0; i < baleNum; i++) {
+			bales[i] = Integer.parseInt(st.nextToken());
+		}
+
+		Arrays.sort(bales);
+		for (int i = 0; i < queryNum; i++) {
+			st = new StringTokenizer(br.readLine());
+			int start = Integer.parseInt(st.nextToken());
+			int end = Integer.parseInt(st.nextToken());
+
+			// Get the left-est bale that's still in the interval
+			int bi = Arrays.binarySearch(bales, start);
+			if (bi < 0) { bi = Math.abs(bi + 1); }
+
+			// And also get the right-est bale that's still in the interval
+			int ti = Arrays.binarySearch(bales, end);
+			if (ti < 0) { ti = Math.abs(ti + 2); }
+			out.println(ti - bi + 1);
+		}
+		out.close();
+	}
+}
+```
+
+</JavaSection>
+<PySection>
+
+We can use the builtin
+[`bisect.bisect`](https://docs.python.org/3/library/bisect.html#bisect.bisect)
+function.
+
+```py
+from bisect import bisect
+
+inp = open("haybales.in", "r")
+out = open("haybales.out", "w")
+
+bale_num, query_num = map(int, inp.readline().split())
+bales = sorted(list(map(int, inp.readline().split())))
+for _ in range(query_num):
+	start, end = map(int, inp.readline().split())
+	print(bisect(bales, end) - bisect(bales, start - 1), file=out)
+```
+
+</PySection>
+</LanguageSection>
+
+## Problems
+
+<Problems problems="general" />
diff --git a/content/3_Silver/Binary_Search_Sorted_Array.problems.json b/content/3_Silver/Binary_Search_Sorted_Array.problems.json
new file mode 100644
index 00000000000..d8afe7c139e
--- /dev/null
+++ b/content/3_Silver/Binary_Search_Sorted_Array.problems.json
@@ -0,0 +1,44 @@
+{
+  "MODULE_ID": "binary-search-sorted-array",
+  "count": [
+    {
+      "uniqueId": "usaco-666",
+      "name": "Counting Haybales",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=666",
+      "source": "Silver",
+      "difficulty": "Easy",
+      "isStarred": false,
+      "tags": ["Binary Search"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    }
+  ],
+  "general": [
+    {
+      "uniqueId": "cf-702C",
+      "name": "Cellular Network",
+      "url": "https://codeforces.com/contest/702/problem/C",
+      "source": "CF",
+      "difficulty": "Easy",
+      "isStarred": false,
+      "tags": ["2P", "Binary Search"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "usaco-1303",
+      "name": "Cow-libi",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=1303",
+      "source": "Silver",
+      "difficulty": "Easy",
+      "isStarred": false,
+      "tags": ["Binary Search"],
+      "solutionMetadata": {
+        "kind": "USACO",
+        "usacoId": "1303"
+      }
+    }
+  ]
+}
diff --git a/content/3_Silver/Greedy_Sorting.mdx b/content/3_Silver/Greedy_Sorting.mdx
index f7b414c452a..71abc18a473 100644
--- a/content/3_Silver/Greedy_Sorting.mdx
+++ b/content/3_Silver/Greedy_Sorting.mdx
@@ -7,7 +7,6 @@ redirects:
 prerequisites:
   - intro-greedy
   - two-pointers
-  - intro-sorted-sets
 description: 'Solving greedy problems by sorting the input.'
 frequency: 3
 ---
diff --git a/content/3_Silver/Greedy_Sorting.problems.json b/content/3_Silver/Greedy_Sorting.problems.json
index 119abaec5d9..0af4534f3fc 100644
--- a/content/3_Silver/Greedy_Sorting.problems.json
+++ b/content/3_Silver/Greedy_Sorting.problems.json
@@ -76,42 +76,6 @@
       "solutionMetadata": {
         "kind": "internal"
       }
-    },
-    {
-      "uniqueId": "cses-1073",
-      "name": "Towers",
-      "url": "https://cses.fi/problemset/task/1073",
-      "source": "CSES",
-      "difficulty": "Easy",
-      "isStarred": true,
-      "tags": ["Sorted Set", "Greedy", "LIS", "Binary Search"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1632",
-      "name": "Movie Festival II",
-      "url": "https://cses.fi/problemset/task/1632",
-      "source": "CSES",
-      "difficulty": "Normal",
-      "isStarred": true,
-      "tags": ["Sorting", "Sorted Set", "Greedy"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1161",
-      "name": "Stick Division",
-      "url": "https://cses.fi/problemset/task/1161",
-      "source": "CSES",
-      "difficulty": "Hard",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorted Set"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
     }
   ],
   "other": [
@@ -146,7 +110,7 @@
       "source": "Silver",
       "difficulty": "Easy",
       "isStarred": false,
-      "tags": ["Greedy", "Sorting", "Sorted Set"],
+      "tags": ["Greedy", "Sorting"],
       "solutionMetadata": {
         "kind": "internal"
       }
@@ -158,7 +122,7 @@
       "source": "Gold",
       "difficulty": "Easy",
       "isStarred": true,
-      "tags": ["Greedy", "Sorting", "Sorted Set"],
+      "tags": ["Greedy", "Sorting"],
       "solutionMetadata": {
         "kind": "internal"
       }
@@ -187,30 +151,6 @@
         "kind": "internal"
       }
     },
-    {
-      "uniqueId": "usaco-714",
-      "name": "Why Did the Cow Cross the Road",
-      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=714",
-      "source": "Silver",
-      "difficulty": "Normal",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorted Set"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "leetcode-502",
-      "name": "IPO",
-      "url": "https://leetcode.com/problems/ipo",
-      "source": "LC",
-      "difficulty": "Normal",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorting", "Priority Queue"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
     {
       "uniqueId": "usaco-990",
       "name": "Berry Picking",
@@ -260,31 +200,6 @@
         "kind": "USACO",
         "usacoId": "1158"
       }
-    },
-    {
-      "uniqueId": "cf-1802D",
-      "name": "Buying Gifts",
-      "url": "https://codeforces.com/contest/1802/problem/D",
-      "source": "CF",
-      "difficulty": "Hard",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorting", "Sorted Set"],
-      "solutionMetadata": {
-        "kind": "autogen-label-from-site",
-        "site": "CF"
-      }
-    },
-    {
-      "uniqueId": "usaco-1233",
-      "name": "Apple Catching",
-      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=1233",
-      "source": "Gold",
-      "difficulty": "Very Hard",
-      "isStarred": false,
-      "tags": ["Sorting", "Greedy", "Set"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
     }
   ]
 }
diff --git a/solutions/silver/cses-1164.mdx b/content/3_Silver/Priority_Queues.mdx
similarity index 58%
rename from solutions/silver/cses-1164.mdx
rename to content/3_Silver/Priority_Queues.mdx
index e93d2e657ea..5ee4899ac80 100644
--- a/solutions/silver/cses-1164.mdx
+++ b/content/3_Silver/Priority_Queues.mdx
@@ -1,11 +1,112 @@
 ---
-id: cses-1164
-source: CSES
-title: Room Allocation
-author: Shreyas Thumathy, Nathan Gong
+id: priority-queues
+title: 'Priority Queues'
+author: Darren Yao, Benjamin Qi, Jeffrey Hu, Shreyas Thumathy, Nathan Gong
+prerequisites:
+  - greedy-sorting
+  - sorting-custom
+description: 'A data structure that supports insert, query max, and pop max.'
+frequency: 2
 ---
 
-## Explanation
+## Introduction
+
+<Resources>
+	<Resource source="CSA" url="heaps" title="Heaps" />
+</Resources>
+
+A **priority queue** (or **heap**) supports the following operations: insertion
+of elements, deletion of the element considered highest priority, and retrieval
+of the highest priority element, all in $\mathcal{O}(\log N)$ time according to
+the number of elements in the priority queue. Priority queues are simpler and
+faster than sets, so you should use them instead whenever possible.
+
+<LanguageSection>
+<CPPSection>
+
+### [C++](http://www.cplusplus.com/reference/queue/priority_queue/)
+
+```cpp
+priority_queue<int> pq;
+pq.push(7);                // [7]
+pq.push(2);                // [2, 7]
+pq.push(1);                // [1, 2, 7]
+pq.push(5);                // [1, 2, 5, 7]
+cout << pq.top() << endl;  // 7
+pq.pop();                  // [1, 2, 5]
+pq.pop();                  // [1, 2]
+pq.push(6);                // [1, 2, 6]
+```
+
+</CPPSection>
+<JavaSection>
+
+### Java
+
+In Java (unlike in C++), we delete and retrieve the **lowest** element.
+
+```java
+PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
+pq.add(7);                      // [7]
+pq.add(2);                      // [7, 2]
+pq.add(1);                      // [7, 2, 1]
+pq.add(5);                      // [7, 5, 2, 1]
+System.out.println(pq.peek());  // 1
+pq.poll();                      // [7, 5, 2]
+pq.poll();                      // [7, 5]
+pq.add(6);                      // [7, 6, 5]
+```
+
+</JavaSection>
+<PySection>
+
+### [Python](https://docs.python.org/3/library/heapq.html)
+
+In Python (unlike in C++), we delete and retrieve the **lowest** element.
+
+Note that Python's priority queue is not encapsulated; `heapq` operates on a
+provided list directly by turning it into a heap, then doing operations on the
+heap.
+
+<Warning>
+
+Because of a heap's structure, printing out `pq` will **not** print out the
+elements in sorted order in Python; instead, it will print out the list. The
+comments below are a **representation** of what the heap contains, **not** what
+the contents of `pq` actually are.
+
+</Warning>
+
+```py
+import heapq
+
+pq = []
+
+"""
+The following line is not necessary since pq starts as an empty list. However,
+for lists of length greater than 1, heapify is required to turn the list into a
+heap.
+"""
+heapq.heapify(pq)
+
+heapq.heappush(pq, 7)  # [7]
+heapq.heappush(pq, 2)  # [7, 2]
+heapq.heappush(pq, 1)  # [7, 2, 1]
+heapq.heappush(pq, 5)  # [7, 5, 2, 1]
+print(pq[0])  # 1
+heapq.heappop(pq)  # [7, 5, 2]
+heapq.heappop(pq)  # [7, 5]
+heapq.heappush(pq, 6)  # [7, 6, 5]
+```
+
+</PySection>
+</LanguageSection>
+
+## Example
+
+<FocusProblem problem="sample" />
+
+### Solution
 
 In this problem, we're asked the minimum number of rooms needed to accommodate
 $n$ customers, who arrive and leave on set days. Let's sort each customer by
@@ -27,7 +128,7 @@ less than the arrival time of the new customer.
 We can determine $k$ by finding the maximum size the priority queue reaches as
 we iterate through the customers.
 
-## Implementation
+### Implementation
 
 **Time Complexity:** $\mathcal{O}(n\log n)$
 
@@ -35,20 +136,21 @@ we iterate through the customers.
 
 <CPPSection>
 
+Implementation Note: Similarly to what was done in an [earlier module](/silver/sorting-custom?lang=cpp#sorting-in-descending-order), we can use `greater<>()` to create a min-heap instead of a max-heap.
+
 ```cpp
 #include <algorithm>
 #include <iostream>
 #include <queue>
 using namespace std;
 
-const int MAX_N = 2e5;
-
-int N;
-int ans[MAX_N];
-vector<pair<pair<int, int>, int>> v(MAX_N);
-
 int main() {
+	int N;
 	cin >> N;
+
+	vector<int> ans(N);
+	vector<pair<pair<int, int>, int>> v(N);
+
 	v.resize(N);
 	for (int i = 0; i < N; i++) {
 		cin >> v[i].first.first >> v[i].first.second;
@@ -57,19 +159,19 @@ int main() {
 	sort(v.begin(), v.end());
 
 	int last_room = 0;
-	priority_queue<pair<int, int>> pq;  // min heap to store departure times.
+	using Room = pair<int, int>;
+	priority_queue<Room, vector<Room>, greater<Room>>
+	    pq;  // min heap to store departure times.
 	for (int i = 0; i < N; i++) {
-		if (pq.empty() || -pq.top().first >= v[i].first.first) {
+		if (pq.empty() || pq.top().first >= v[i].first.first) {
 			last_room++;
-			// make the departure time negative so that we create a min heap
-			// (cleanest way to do a min heap... default is max in c++)
-			pq.push(make_pair(-v[i].first.second, last_room));
+			pq.push(make_pair(v[i].first.second, last_room));
 			ans[v[i].second] = last_room;
 		} else {
 			// accessing the minimum departure time
-			pair<int, int> minimum = pq.top();
+			Room minimum = pq.top();
 			pq.pop();
-			pq.push(make_pair(-v[i].first.second, minimum.second));
+			pq.push(make_pair(v[i].first.second, minimum.second));
 			ans[v[i].second] = minimum.second;
 		}
 	}
@@ -85,7 +187,7 @@ int main() {
 
 <Warning>
 Input classes like `Scanner` and `BufferedReader` are too slow for this problem,
-so we have to use [`FastIO`](/general/fast-io?lang=java#method-5---inputstream) (which reads bytes directly from an input stream) instead.
+so we have to use [`FastIO`](/general/fast-io?lang=java#even-faster-methods-1) (which reads bytes directly from an input stream) instead.
 </Warning>
 
 ```java
@@ -234,3 +336,14 @@ public class RoomAllocation {
 </JavaSection>
 
 </LanguageSection>
+
+
+## Problems
+
+<Info title="Sorted Sets">
+
+[Sorted sets](/gold/intro-sorted-sets) support all the operations of priority queues and more; however, they are rarely required for Silver and their constant factor is worse. Only one practice problem from the sorted sets module (Milk Measurement) comes from USACO Silver.
+
+</Info>
+
+<Problems problems="general" />
diff --git a/content/3_Silver/Priority_Queues.problems.json b/content/3_Silver/Priority_Queues.problems.json
new file mode 100644
index 00000000000..03308468550
--- /dev/null
+++ b/content/3_Silver/Priority_Queues.problems.json
@@ -0,0 +1,105 @@
+{
+  "MODULE_ID": "priority-queues",
+  "sample": [
+    {
+      "uniqueId": "cses-1164",
+      "name": "Room Allocation",
+      "url": "https://cses.fi/problemset/task/1164",
+      "source": "CSES",
+      "difficulty": "Normal",
+      "isStarred": true,
+      "tags": ["Priority Queue", "Sorting"],
+      "solutionMetadata": {
+        "kind": "in-module",
+        "moduleId": "priority-queues"
+      }
+    }
+  ],
+  "general": [
+    {
+      "uniqueId": "usaco-859",
+      "name": "Convention II",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=859",
+      "source": "Silver",
+      "difficulty": "Normal",
+      "isStarred": true,
+      "tags": ["Priority Queue", "Sorting"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "cf-104002E",
+      "name": "William and Robot",
+      "url": "https://codeforces.com/gym/104002/problem/E",
+      "source": "CF",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Priority Queue"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "ac-packing",
+      "name": "Packing Under Range Regulations",
+      "url": "https://atcoder.jp/contests/abc214/tasks/abc214_e",
+      "source": "AC",
+      "difficulty": "Normal",
+      "isStarred": true,
+      "tags": ["Sorting", "Priority Queue"],
+      "solutionMetadata": {
+        "kind": "none"
+      }
+    },
+    {
+      "uniqueId": "usaco-714",
+      "name": "Why Did the Cow Cross the Road",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=714",
+      "source": "Silver",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Sorting", "Priority Queue"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "leetcode-502",
+      "name": "IPO",
+      "url": "https://leetcode.com/problems/ipo",
+      "source": "LC",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Greedy", "Sorting", "Priority Queue"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "cses-1161",
+      "name": "Stick Division",
+      "url": "https://cses.fi/problemset/task/1161",
+      "source": "CSES",
+      "difficulty": "Hard",
+      "isStarred": false,
+      "tags": ["Greedy", "Priority Queue"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
+    {
+      "uniqueId": "cf-1805F1",
+      "name": "Survival of the Weakest (easy version)",
+      "url": "https://codeforces.com/problemset/problem/1805/F1",
+      "source": "CF",
+      "difficulty": "Hard",
+      "isStarred": true,
+      "tags": ["Priority Queue", "Sorting"],
+      "solutionMetadata": {
+        "kind": "autogen-label-from-site",
+        "site": "CF"
+      }
+    }
+  ]
+}
diff --git a/content/3_Silver/Sorting_Custom.mdx b/content/3_Silver/Sorting_Custom.mdx
index 45463a78144..f1a43464558 100644
--- a/content/3_Silver/Sorting_Custom.mdx
+++ b/content/3_Silver/Sorting_Custom.mdx
@@ -5,7 +5,7 @@ frequency: 3
 author: Darren Yao, Siyong Huang, Michael Cao, Benjamin Qi, Nathan Chen
 prerequisites:
   - intro-sorting
-  - intro-graphs
+  - binary-search-sorted-array
 description: 'Using a custom comparator to sort custom objects or values in a non-default order, and compressing values from a large range to a smaller one.'
 ---
 
@@ -46,10 +46,15 @@ After sorting, it should look like
 2 3 10
 ```
 
+We will describe several ways to do this below.
+
 <LanguageSection>
 <CPPSection>
 
-There's multiple ways we can do this.
+## Built-In Data Structures
+
+### Pairs
+
 The most straightforward method is to use a `pair<int, pair<int, int>>`.
 When comparing these, C++ looks at the first element and only uses
 the second element as a tiebreaker.
@@ -74,12 +79,13 @@ int main() {
 }
 ```
 
-If you don't like all the accesses to `.first` and `.second`,
-an alternative is to use an `std::vector` or maybe even an
-[`std::array`](https://en.cppreference.com/w/cpp/container/array):
+### Arrays
+
+An alternative is to use [`std::array`](https://en.cppreference.com/w/cpp/container/array) or `std::vector`:
 
 ```cpp
 #include <algorithm>
+#include <array>
 #include <iostream>
 #include <vector>
 
@@ -88,8 +94,8 @@ using namespace std;
 int main() {
 	constexpr int edge_num = 4;
 
-	// array<int, 3> is also usable and probably faster
-	vector<vector<int>> edges;
+	vector<array<int, 3>> edges;
+	// vector<vector<int>> edges;  // also works, but is slower
 	for (int e = 0; e < edge_num; e++) {
 		int a, b;
 		int width;
@@ -98,7 +104,7 @@ int main() {
 	}
 	sort(edges.begin(), edges.end());
 
-	for (const vector<int> &e : edges) { printf("(%i, %i): %i\n", e[1], e[2], e[0]); }
+	for (const auto &e : edges) { printf("(%i, %i): %i\n", e[1], e[2], e[0]); }
 }
 ```
 
@@ -427,11 +433,51 @@ for an explanation of how `cmp_to_key` works.
 
 ### Sorting in Descending Order
 
-We can replace all occurrences of `x.w < y.w` with `x.w > y.w` in our C++ code.
-Similarly, we can replace all occurrences of `Integer.compare(x, y)` with
-`-Integer.compare(x, y)` in our Java code. In Python, we can pass the parameter
+<LanguageSection>
+
+<CPPSection>
+
+There are many ways to do this.
+
+Sorting and then reversing:
+
+```
+sort(begin(edges), end(edges));
+reverse(begin(edges), end(edges));
+```
+
+Sorting using reverse iterators:
+
+```
+sort(rbegin(edges), rend(edges));
+```
+
+For data structures (such as pairs and arrays) where `operator>` is defined:
+
+```
+sort(edges.begin(), edges.end(), greater<>());
+```
+
+If overloading `operator<` yourself, you can replace all occurrences of `x.w < y.w` with `x.w > y.w`.
+
+</CPPSection>
+
+<JavaSection>
+
+We can replace all occurrences of `Integer.compare(x, y)` with
+`-Integer.compare(x, y)` in our Java code.
+
+</JavaSection>
+
+<PySection>
+
+In Python, we can pass the parameter
 `reverse=True` to the `sort` or `sorted` function.
 
+</PySection>
+
+</LanguageSection>
+
 ### Sorting by Multiple Criteria
 
 Now, suppose we wanted to sort a list of `Edge`s in ascending order, primarily
@@ -770,7 +816,7 @@ implementation of coordinate compression and how it can switch between
 compressed indices and original values, see the contracted code below. `indices`
 is a list of values that need to be compressed. After it gets sorted and has
 duplicate values removed, it is ready to use. The method `getCompressedIndex`
-takes in an original value, and [binary searches](/silver/binary-search) for its
+takes in an original value, and [binary searches](/silver/binary-search-sorted-array) for its
 position in `indices` to get its corresponding compressed index. To go from a
 compressed index to an original value, the code can just access that index in
 `indices`.
@@ -821,7 +867,7 @@ conveniently use them as array indices for the difference array. We perform this
 coordinate compression by keeping a sorted list of all special indices, and
 using each special index's position in that list as its compressed index. To
 find a special index's position in the sorted list (a.k.a. its compressed
-index), we can [binary search](/silver/binary-search) on the list. The next part
+index), we can [binary search](/silver/binary-search-sorted-array) on the list. The next part
 of the solution will show why it was important for us to store the original
 indices.
 
diff --git a/content/3_Silver/Sorting_Custom.problems.json b/content/3_Silver/Sorting_Custom.problems.json
index 19ce162d2fa..4870b87a8a8 100644
--- a/content/3_Silver/Sorting_Custom.problems.json
+++ b/content/3_Silver/Sorting_Custom.problems.json
@@ -42,6 +42,18 @@
         "kind": "internal"
       }
     },
+    {
+      "uniqueId": "cf-1000C",
+      "name": "Covered Points Count",
+      "url": "https://codeforces.com/problemset/problem/1000/C",
+      "source": "CF",
+      "difficulty": "Normal",
+      "isStarred": false,
+      "tags": ["Sorting", "Prefix Sums", "Coordinate Compression"],
+      "solutionMetadata": {
+        "kind": "internal"
+      }
+    },
     {
       "uniqueId": "usaco-786",
       "name": "Lifeguards",
diff --git a/content/3_Silver/Two_Pointers.mdx b/content/3_Silver/Two_Pointers.mdx
index a67d76a150c..762fbd381f2 100644
--- a/content/3_Silver/Two_Pointers.mdx
+++ b/content/3_Silver/Two_Pointers.mdx
@@ -6,7 +6,7 @@ title: 'Two Pointers'
 author: Darren Yao, Qi Wang, Ryan Chou
 contributors: Aadit Ambadkar, Juheon Rhee
 prerequisites:
-  - sorting-custom
+  - intro-sorting
 description:
   'Iterating two monotonic pointers across an array to search for a pair of
   indices satisfying some condition in linear time.'
diff --git a/content/3_Silver/Two_Pointers.problems.json b/content/3_Silver/Two_Pointers.problems.json
index de42c2348b6..2c2c0b9d2bc 100644
--- a/content/3_Silver/Two_Pointers.problems.json
+++ b/content/3_Silver/Two_Pointers.problems.json
@@ -70,7 +70,7 @@
       "source": "CF",
       "difficulty": "Easy",
       "isStarred": false,
-      "tags": ["2P"],
+      "tags": ["2P", "Binary Search"],
       "solutionMetadata": {
         "kind": "internal"
       }
@@ -125,7 +125,7 @@
     },
     {
       "uniqueId": "cf-814C",
-      "name": "Garland",
+      "name": "An impassioned circulation of affection",
       "url": "https://codeforces.com/problemset/problem/814/C",
       "source": "CF",
       "difficulty": "Normal",
diff --git a/content/3_Silver/Custom_Cpp_STL.mdx b/content/4_Gold/Custom_Cpp_STL.mdx
similarity index 98%
rename from content/3_Silver/Custom_Cpp_STL.mdx
rename to content/4_Gold/Custom_Cpp_STL.mdx
index 0873fd75dac..2873da343c1 100644
--- a/content/3_Silver/Custom_Cpp_STL.mdx
+++ b/content/4_Gold/Custom_Cpp_STL.mdx
@@ -1,6 +1,6 @@
 ---
 id: custom-cpp-stl
-title: '(Optional) C++ Sets with Custom Comparators'
+title: '(Optional) Sorted Sets with Custom Comparators'
 author: Benjamin Qi, Siyong Huang
 prerequisites:
   - sorting-custom
diff --git a/content/3_Silver/Custom_Cpp_STL.problems.json b/content/4_Gold/Custom_Cpp_STL.problems.json
similarity index 100%
rename from content/3_Silver/Custom_Cpp_STL.problems.json
rename to content/4_Gold/Custom_Cpp_STL.problems.json
diff --git a/content/3_Silver/Intro_Sorted_Sets.mdx b/content/4_Gold/Intro_Sorted_Sets.mdx
similarity index 87%
rename from content/3_Silver/Intro_Sorted_Sets.mdx
rename to content/4_Gold/Intro_Sorted_Sets.mdx
index 11a625732e3..7687c30225b 100644
--- a/content/3_Silver/Intro_Sorted_Sets.mdx
+++ b/content/4_Gold/Intro_Sorted_Sets.mdx
@@ -5,12 +5,14 @@ author: Darren Yao, Benjamin Qi, Andrew Wang
 contributors: Aadit Ambadkar, Jeffrey Hu, Jason Sun
 prerequisites:
   - intro-sets
+  - binary-search-sorted-array
+  - priority-queues
+  - greedy-sorting
 description:
-  'Finding the next element smaller or larger than a specified key in a set, and
-  using iterators with sets.'
+  'Finding the next element smaller or larger than a specified key in a sorted set, and using iterators with sorted sets.'
 frequency: 2
 redirects:
-  - intro-ordered
+  - /silver/intro-sorted-sets
 ---
 
 <LanguageSection>
@@ -50,8 +52,8 @@ or removing the next key higher or lower than some input key `k` is supported.
 
 Keep in mind that insertion and deletion will take $\mathcal{O}(\log N)$ time
 for sorted sets, which is more than the average $\mathcal{O}(1)$ insertion and
-deletion for unordered sets, but less than the worst case $\mathcal{O}(N)$
-insertion and deletion for unordered sets.
+deletion for hashsets, but less than the worst case $\mathcal{O}(N)$
+insertion and deletion for hashsets.
 
 ## Using Iterators
 
@@ -463,120 +465,12 @@ static void remove(int x) {
 </JavaSection>
 </LanguageSection>
 
-## Priority Queues
-
-<Warning>
-
-Priority queues are **not** implemented in the same way as sets and multisets,
-but they are included in this section because the operations that they perform
-can also be performed with sets.
-
-</Warning>
-
-<Resources>
-	<Resource source="CSA" url="heaps" title="Heaps" />
-</Resources>
-
-A **priority queue** (or **heap**) supports the following operations: insertion
-of elements, deletion of the element considered highest priority, and retrieval
-of the highest priority element, all in $\mathcal{O}(\log N)$ time according to
-the number of elements in the priority queue. Priority queues are simpler and
-faster than sets, so you should use them instead whenever possible.
-
-<LanguageSection>
-<CPPSection>
-
-### [C++](http://www.cplusplus.com/reference/queue/priority_queue/)
-
-```cpp
-priority_queue<int> pq;
-pq.push(7);                // [7]
-pq.push(2);                // [2, 7]
-pq.push(1);                // [1, 2, 7]
-pq.push(5);                // [1, 2, 5, 7]
-cout << pq.top() << endl;  // 7
-pq.pop();                  // [1, 2, 5]
-pq.pop();                  // [1, 2]
-pq.push(6);                // [1, 2, 6]
-```
-
-</CPPSection>
-<JavaSection>
-
-### Java
-
-In Java (unlike in C++), we delete and retrieve the **lowest** element.
-
-```java
-PriorityQueue<Integer> pq = new PriorityQueue<Integer>();
-pq.add(7);                      // [7]
-pq.add(2);                      // [7, 2]
-pq.add(1);                      // [7, 2, 1]
-pq.add(5);                      // [7, 5, 2, 1]
-System.out.println(pq.peek());  // 1
-pq.poll();                      // [7, 5, 2]
-pq.poll();                      // [7, 5]
-pq.add(6);                      // [7, 6, 5]
-```
-
-</JavaSection>
-<PySection>
-
-### [Python](https://docs.python.org/3/library/heapq.html)
-
-In Python (unlike in C++), we delete and retrieve the **lowest** element.
-
-Note that Python's priority queue is not encapsulated; `heapq` operates on a
-provided list directly by turning it into a heap, then doing operations on the
-heap.
-
-<Warning>
-
-Because of a heap's structure, printing out `pq` will **not** print out the
-elements in sorted order in Python; instead, it will print out the list. The
-comments below are a **representation** of what the heap contains, **not** what
-the contents of `pq` actually are.
-
-</Warning>
-
-```py
-import heapq
-
-pq = []
-
-"""
-The following line is not necessary since pq starts as an empty list. However,
-for lists of length greater than 1, heapify is required to turn the list into a
-heap.
-"""
-heapq.heapify(pq)
-
-heapq.heappush(pq, 7)  # [7]
-heapq.heappush(pq, 2)  # [7, 2]
-heapq.heappush(pq, 1)  # [7, 2, 1]
-heapq.heappush(pq, 5)  # [7, 5, 2, 1]
-print(pq[0])  # 1
-heapq.heappop(pq)  # [7, 5, 2]
-heapq.heappop(pq)  # [7, 5]
-heapq.heappush(pq, 6)  # [7, 6, 5]
-```
-
-</PySection>
-</LanguageSection>
-
 ## Introductory Problems
 
 <Problems problems="standard" />
 
 ## Harder Example - Bit Inversions
 
-<Warning>
-
-Problems marked as "Hard" or beyond in this module would likely be too difficult
-to appear on a USACO Silver contest.
-
-</Warning>
-
 <FocusProblem problem="sample" />
 
 ### Solution
diff --git a/content/3_Silver/Intro_Sorted_Sets.problems.json b/content/4_Gold/Intro_Sorted_Sets.problems.json
similarity index 63%
rename from content/3_Silver/Intro_Sorted_Sets.problems.json
rename to content/4_Gold/Intro_Sorted_Sets.problems.json
index b089b2a1d09..af6ce2f853d 100644
--- a/content/3_Silver/Intro_Sorted_Sets.problems.json
+++ b/content/4_Gold/Intro_Sorted_Sets.problems.json
@@ -14,15 +14,15 @@
       }
     },
     {
-      "uniqueId": "cf-702C",
-      "name": "Cellular Network",
-      "url": "https://codeforces.com/contest/702/problem/C",
-      "source": "CF",
+      "uniqueId": "ys-DEPQ",
+      "name": "Double-Ended Priority Queue",
+      "url": "https://judge.yosupo.jp/problem/double_ended_priority_queue",
+      "source": "YS",
       "difficulty": "Easy",
       "isStarred": false,
       "tags": ["Sorted Set"],
       "solutionMetadata": {
-        "kind": "internal"
+        "kind": "none"
       }
     },
     {
@@ -30,7 +30,7 @@
       "name": "Traffic Lights",
       "url": "https://cses.fi/problemset/task/1163",
       "source": "CSES",
-      "difficulty": "Normal",
+      "difficulty": "Easy",
       "isStarred": true,
       "tags": ["Sorted Set"],
       "solutionMetadata": {
@@ -38,13 +38,13 @@
       }
     },
     {
-      "uniqueId": "cses-1164",
-      "name": "Room Allocation",
-      "url": "https://cses.fi/problemset/task/1164",
+      "uniqueId": "cses-1073",
+      "name": "Towers",
+      "url": "https://cses.fi/problemset/task/1073",
       "source": "CSES",
-      "difficulty": "Normal",
+      "difficulty": "Easy",
       "isStarred": true,
-      "tags": ["Sorted Set"],
+      "tags": ["Sorted Set", "Greedy", "LIS", "Binary Search"],
       "solutionMetadata": {
         "kind": "internal"
       }
@@ -77,30 +77,6 @@
         "kind": "internal"
       }
     },
-    {
-      "uniqueId": "usaco-859",
-      "name": "Convention II",
-      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=859",
-      "source": "Silver",
-      "difficulty": "Normal",
-      "isStarred": true,
-      "tags": ["Sorted Set"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cf-104002E",
-      "name": "William and Robot",
-      "url": "https://codeforces.com/gym/104002/problem/E",
-      "source": "CF",
-      "difficulty": "Normal",
-      "isStarred": false,
-      "tags": ["Sorted Set", "Sorting", "Greedy"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
     {
       "uniqueId": "cf-1474C",
       "name": "Array Destruction",
@@ -114,18 +90,13 @@
       }
     },
     {
-      "uniqueId": "cf-1000C",
-      "name": "Covered Points Count",
-      "url": "https://codeforces.com/problemset/problem/1000/C",
-      "source": "CF",
+      "uniqueId": "cses-1632",
+      "name": "Movie Festival II",
+      "url": "https://cses.fi/problemset/task/1632",
+      "source": "CSES",
       "difficulty": "Normal",
-      "isStarred": false,
-      "tags": [
-        "Sorted Set",
-        "Sorting",
-        "Prefix Sums",
-        "Coordinate Compression"
-      ],
+      "isStarred": true,
+      "tags": ["Sorting", "Sorted Set", "Greedy"],
       "solutionMetadata": {
         "kind": "internal"
       }
@@ -135,7 +106,7 @@
       "name": "Snow Boots",
       "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=813",
       "source": "Gold",
-      "difficulty": "Hard",
+      "difficulty": "Normal",
       "isStarred": true,
       "tags": ["Linked List", "Sorted Set"],
       "solutionMetadata": {
@@ -143,53 +114,54 @@
       }
     },
     {
-      "uniqueId": "ac-packing",
-      "name": "Packing Under Range Regulations",
-      "url": "https://atcoder.jp/contests/abc214/tasks/abc214_e",
-      "source": "AC",
+      "uniqueId": "cf-1802D",
+      "name": "Buying Gifts",
+      "url": "https://codeforces.com/contest/1802/problem/D",
+      "source": "CF",
       "difficulty": "Hard",
-      "isStarred": true,
-      "tags": ["Sorted Set", "Greedy"],
+      "isStarred": false,
+      "tags": ["Greedy", "Sorting", "Sorted Set"],
       "solutionMetadata": {
-        "kind": "none"
+        "kind": "autogen-label-from-site",
+        "site": "CF"
       }
     },
     {
-      "uniqueId": "cf-1805F1",
-      "name": "Survival of the Weakest (easy version)",
-      "url": "https://codeforces.com/problemset/problem/1805/F1",
+      "uniqueId": "cf-878C",
+      "name": "Tournament",
+      "url": "https://codeforces.com/contest/878/problem/C",
       "source": "CF",
       "difficulty": "Hard",
-      "isStarred": true,
-      "tags": ["Sorted Set", "Binary Search"],
+      "isStarred": false,
+      "tags": ["Sorted Set"],
       "solutionMetadata": {
         "kind": "autogen-label-from-site",
         "site": "CF"
       }
     },
     {
-      "uniqueId": "cf-862E",
-      "name": "Mahmoud & Ehab & Function",
-      "url": "https://codeforces.com/contest/862/problem/E",
-      "source": "CF",
-      "difficulty": "Very Hard",
+      "uniqueId": "usaco-1475",
+      "name": "Photo Op",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=1475",
+      "source": "Gold",
+      "difficulty": "Hard",
       "isStarred": false,
       "tags": ["Sorted Set"],
       "solutionMetadata": {
-        "kind": "internal"
+        "kind": "USACO",
+        "usacoId": "1475"
       }
     },
     {
-      "uniqueId": "cf-878C",
-      "name": "Tournament",
-      "url": "https://codeforces.com/contest/878/problem/C",
-      "source": "CF",
-      "difficulty": "Insane",
+      "uniqueId": "usaco-1233",
+      "name": "Apple Catching",
+      "url": "http://www.usaco.org/index.php?page=viewproblem2&cpid=1233",
+      "source": "Gold",
+      "difficulty": "Hard",
       "isStarred": false,
-      "tags": ["Sorted Set"],
+      "tags": ["Sorting", "Greedy", "Sorted Set"],
       "solutionMetadata": {
-        "kind": "autogen-label-from-site",
-        "site": "CF"
+        "kind": "internal"
       }
     }
   ]
diff --git a/content/4_Gold/PURS.mdx b/content/4_Gold/PURS.mdx
index 7ca5758fe26..530fcc136a6 100644
--- a/content/4_Gold/PURS.mdx
+++ b/content/4_Gold/PURS.mdx
@@ -5,6 +5,7 @@ author: Benjamin Qi, Dong Liu, Nathan Gong
 contributors: Andrew Wang, Pramana Saldin
 prerequisites:
   - prefix-sums
+  - intro-sorted-sets
 description:
   'Segment Tree, Binary Indexed Tree, and Order Statistic Tree (in C++).'
 frequency: 3
diff --git a/content/extraProblems.json b/content/extraProblems.json
index 2456a9456ec..16d333b3917 100644
--- a/content/extraProblems.json
+++ b/content/extraProblems.json
@@ -1370,19 +1370,6 @@
         "usacoId": "1280"
       }
     },
-    {
-      "uniqueId": "usaco-1303",
-      "name": "Cow-libi",
-      "url": "http://usaco.org/index.php?page=viewproblem2&cpid=1303",
-      "source": "Silver",
-      "difficulty": "N/A",
-      "isStarred": false,
-      "tags": ["Sorting", "Binary Search"],
-      "solutionMetadata": {
-        "kind": "USACO",
-        "usacoId": "1303"
-      }
-    },
     {
       "uniqueId": "usaco-1304",
       "name": "Moo Route II",
@@ -2631,19 +2618,6 @@
         "usacoId": "1474"
       }
     },
-    {
-      "uniqueId": "usaco-1475",
-      "name": "Photo Op",
-      "url": "https://usaco.org/index.php?page=viewproblem2&cpid=1475",
-      "source": "Gold",
-      "difficulty": "N/A",
-      "isStarred": false,
-      "tags": [],
-      "solutionMetadata": {
-        "kind": "USACO",
-        "usacoId": "1475"
-      }
-    },
     {
       "uniqueId": "usaco-1476",
       "name": "DFS Order",
diff --git a/content/ordering.ts b/content/ordering.ts
index fb266e01223..e05f8dbc0d7 100644
--- a/content/ordering.ts
+++ b/content/ordering.ts
@@ -99,12 +99,12 @@ const MODULE_ORDERING: { [key in SectionID]: Chapter[] } = {
     {
       name: 'Sorting & Searching',
       items: [
-        'sorting-custom',
         'two-pointers',
-        'intro-sorted-sets',
-        'custom-cpp-stl',
-        'greedy-sorting',
+        'binary-search-sorted-array',
         'binary-search',
+        'sorting-custom',
+        'greedy-sorting',
+        'priority-queues',
       ],
     },
     {
@@ -156,7 +156,13 @@ const MODULE_ORDERING: { [key in SectionID]: Chapter[] } = {
     },
     {
       name: 'Data Structures',
-      items: ['stacks', 'sliding-window', 'PURS'],
+      items: [
+        'intro-sorted-sets',
+        'custom-cpp-stl',
+        'stacks',
+        'sliding-window',
+        'PURS',
+      ],
     },
     {
       name: 'Trees',
diff --git a/solutions/silver/cf-104002E.mdx b/solutions/silver/cf-104002E.mdx
index 4846a2295ce..99a57ca1d79 100644
--- a/solutions/silver/cf-104002E.mdx
+++ b/solutions/silver/cf-104002E.mdx
@@ -2,7 +2,7 @@
 id: cf-104002E
 source: CF
 title: William and Robot
-author: Alex Du
+author: Alex Du, Benjamin Qi
 ---
 
 ## Explanation
@@ -15,18 +15,7 @@ For example, if we had array of size $4$, we could select either of the first tw
 Alternatively, we could select both of the last two elements, selecting 0 integers for $k = 2$ and $2$ integers for $k = 4$.
 Note that we cannot take both the first and second element, since the Robot will take the one we don't pick.
 
-To solve this problem, we can use a greedy algorithm.
-
-For any even $k$, if we know the $\frac{k}{2}$ integers that make the highest sum, we can use this to find the $\frac{k}{2}+1$ integers for $k+2$.
-
-The base case is $k = 2$, where the highest sum is simply the maximum of the first two integers.
-
-Similarly, to gain the highest sum for our current $k$, we will always select the maximum of the $k-1$ and $k-2$ elements, since we now have another turn and this will build directly off of our previous solution.
-
-However, it is sometimes optimal to take both integers, rather than just the maximum of the two.
-After $k=2$, we can choose to remove any previous integer we selected and replace it with the minimum of the two integers we are currently considering.
-Since we can remove any integer, we will remove the minimum. Therefore, this is only worth it if the minimum of the two integers is greater than the minimum of all the integers we already selected.
-To quickly access and remove the smallest integer, we can use either a priority queue or a multiset.
+To solve this problem, we can iterate $k$ from $1$ to $n$ and maintain a priority queue of the numbers tentatively selected by William so far. For each $k$ we push $a_k$ to the priority queue, and then if $k$ is even, pop the smallest element of the priority queue while the number of taken integers is greater than $k/2$.
 
 ## Implementation
 
@@ -47,35 +36,18 @@ int main() {
 	for (int &i : a) { cin >> i; }
 
 	// stores currently selected numbers
-	multiset<int> taken;
+	priority_queue<int, vector<int>, greater<int>> taken;
 
-	// cannot take both the first and second number
-	taken.insert(max(a[0], a[1]));
-
-	for (int i = 2; i < n; i += 2) {
-		int smallest_taken = *taken.begin();
-
-		/*
-		 * if it is worth it to give up a previous number
-		 * to select both, give up the smallest
-		 */
-		if (smallest_taken < min(a[i], a[i + 1])) {
-			/*
-			 * erase using pointer, not value, since multiset will erase
-			 * all elements of the same value if value is passed in
-			 */
-			taken.erase(taken.begin());
-			taken.insert(a[i]);
-			taken.insert(a[i + 1]);
-		} else {
-			taken.insert(max(a[i], a[i + 1]));
-		}
+	for (int i = 0; i < n; ++i) {
+		taken.push(a[i]);
+		if (i & 1) taken.pop();
 	}
 
 	long long ans = 0;
-
-	// sum up the answer
-	for (int t : taken) { ans += t; }
+	while (!taken.empty()) {
+		ans += taken.top();
+		taken.pop();
+	}
 
 	cout << ans << endl;
 }
diff --git a/solutions/silver/cses-1632.mdx b/solutions/silver/cses-1632.mdx
index fd73ad0b6b1..328ab8a33be 100644
--- a/solutions/silver/cses-1632.mdx
+++ b/solutions/silver/cses-1632.mdx
@@ -73,7 +73,7 @@ int main() {
 
 <Warning>
 Input classes like `Scanner` and `BufferedReader` are too slow for this problem,
-so we have to use [`FastIO`](/general/fast-io?lang=java#method-5---inputstream) (which reads bytes directly from an input stream) instead.
+so we have to use [`FastIO`](/general/fast-io?lang=java#even-faster-methods-1) (which reads bytes directly from an input stream) instead.
 </Warning>
 
 ```java
diff --git a/solutions/silver/usaco-859.mdx b/solutions/silver/usaco-859.mdx
index 6e03215ae6a..c91b3a28a8b 100644
--- a/solutions/silver/usaco-859.mdx
+++ b/solutions/silver/usaco-859.mdx
@@ -2,12 +2,12 @@
 id: usaco-859
 source: USACO Silver 2018 December
 title: Convention II
-author: Ryan Chou, Kevin Sheng
+author: Ryan Chou, Kevin Sheng, Benjamin Qi
 ---
 
 [Official Analysis (C++)](http://www.usaco.org/current/data/sol_convention2_silver_dec18.html)
 
-Due to the low bounds on $N$, we can naively simulate the events. We'll sort by arrival time to process the cows in order.
+Due to the low bounds on $N$, we can naively simulate the events. We'll sort by arrival time to process the cows in order and store the cows that are waiting in a priority queue.
 
 ## Implementation
 
@@ -18,9 +18,10 @@ Due to the low bounds on $N$, we can naively simulate the events. We'll sort by
 
 ```cpp
 #include <algorithm>
+#include <array>
 #include <cstdio>
 #include <iostream>
-#include <set>
+#include <queue>
 #include <vector>
 
 using namespace std;
@@ -29,8 +30,10 @@ int main() {
 	freopen("convention2.in", "r", stdin);
 	freopen("convention2.out", "w", stdout);
 
+	using Cow = array<int, 3>;
+
 	int cow_num;
-	vector<vector<int>> cows;
+	vector<Cow> cows;
 	cin >> cow_num;
 	for (int c = 0; c < cow_num; c++) {
 		int start, duration;
@@ -39,20 +42,20 @@ int main() {
 	}
 
 	// sort by arrival time
-	auto cmp = [](const vector<int> &a, const vector<int> &b) { return a[1] < b[1]; };
-	sort(cows.begin(), cows.end(), cmp);
+	sort(cows.begin(), cows.end(),
+	     [](const Cow &a, const Cow &b) { return a[1] < b[1]; });
 
 	int time = 0;
 	int curr = 0;
 	int longest_wait = 0;
 
 	// sorted by priority so that the highest seniority starts eating first
-	set<vector<int>> waiting;
+	priority_queue<Cow, vector<Cow>, greater<Cow>> waiting;
 	// as long as we haven't processed all cows or there are still cows waiting
 	while (curr < cow_num || !waiting.empty()) {
 		// this cow can be processed.
 		if (curr < cow_num && cows[curr][1] <= time) {
-			waiting.insert(cows[curr]);
+			waiting.push(cows[curr]);
 			curr++;
 			// no cow waiting, skip to the next cow.
 		} else if (waiting.empty()) {
@@ -61,12 +64,12 @@ int main() {
 			curr++;
 		} else {
 			// process the next cow
-			vector<int> next = *waiting.begin();
+			Cow next = waiting.top();
 			longest_wait = max(longest_wait, time - next[1]);
 
 			// set the time to when this cow finishes
 			time += next[2];
-			waiting.erase(waiting.begin());
+			waiting.pop();
 		}
 	}
 
@@ -77,6 +80,12 @@ int main() {
 </CPPSection>
 <JavaSection>
 
+<IncompleteSection>
+
+TODO: use priority queue instead of sorted set
+
+</IncompleteSection>
+
 ```java
 import java.io.*;
 import java.util.*;
@@ -151,9 +160,6 @@ public class Convention2 {
 </JavaSection>
 <PySection>
 
-Even though Python doesn't have a sorted set for these operations, it's possible
-to simulate the operations needed with a [priority queue](https://docs.python.org/3/library/heapq.html).
-
 ```py
 import heapq
 


Reviews:
user: login: SansPapyrus683
state: COMMENTED
author_association: CONTRIBUTOR
submitted_at: 2025-03-06T04:22:02Z
user: login: bqi343
state: COMMENTED
author_association: MEMBER
submitted_at: 2025-03-06T04:24:56Z
user: login: SansPapyrus683
body: eh, i suppose i'll get used to this with time
state: APPROVED
author_association: CONTRIBUTOR
submitted_at: 2025-03-06T04:29:48Z

Review comments:
diff_hunk: @@ -76,42 +76,6 @@
       "solutionMetadata": {
         "kind": "internal"
       }
-    },
-    {
-      "uniqueId": "cses-1073",
-      "name": "Towers",
-      "url": "https://cses.fi/problemset/task/1073",
-      "source": "CSES",
-      "difficulty": "Easy",
-      "isStarred": true,
-      "tags": ["Sorted Set", "Greedy", "LIS", "Binary Search"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1632",
-      "name": "Movie Festival II",
-      "url": "https://cses.fi/problemset/task/1632",
-      "source": "CSES",
-      "difficulty": "Normal",
-      "isStarred": true,
-      "tags": ["Sorting", "Sorted Set", "Greedy"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1161",
-      "name": "Stick Division",
-      "url": "https://cses.fi/problemset/task/1161",
-      "source": "CSES",
-      "difficulty": "Hard",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorted Set"],
path: content/3_Silver/Greedy_Sorting.problems.json
user: login: SansPapyrus683
body: what's w/ these problems
created_at: 2025-03-06T04:22:02Z
author_association: CONTRIBUTOR
diff_hunk: @@ -76,42 +76,6 @@
       "solutionMetadata": {
         "kind": "internal"
       }
-    },
-    {
-      "uniqueId": "cses-1073",
-      "name": "Towers",
-      "url": "https://cses.fi/problemset/task/1073",
-      "source": "CSES",
-      "difficulty": "Easy",
-      "isStarred": true,
-      "tags": ["Sorted Set", "Greedy", "LIS", "Binary Search"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1632",
-      "name": "Movie Festival II",
-      "url": "https://cses.fi/problemset/task/1632",
-      "source": "CSES",
-      "difficulty": "Normal",
-      "isStarred": true,
-      "tags": ["Sorting", "Sorted Set", "Greedy"],
-      "solutionMetadata": {
-        "kind": "internal"
-      }
-    },
-    {
-      "uniqueId": "cses-1161",
-      "name": "Stick Division",
-      "url": "https://cses.fi/problemset/task/1161",
-      "source": "CSES",
-      "difficulty": "Hard",
-      "isStarred": false,
-      "tags": ["Greedy", "Sorted Set"],
path: content/3_Silver/Greedy_Sorting.problems.json
user: login: bqi343
body: they got moved to sorted set or pq modules
created_at: 2025-03-06T04:24:56Z
author_association: MEMBER

PR comments:
user: login: SansPapyrus683
created_at: 2025-03-06T00:45:34Z
body: most of the problems in the pq module use sets
author_association: CONTRIBUTOR
user: login: bqi343
created_at: 2025-03-06T00:47:32Z
body: I am rewriting some of the internal sols to remove the sets (William and Robots, Convention II). There is no reason to use sets here.

I don't think any other internal sols use sets.
author_association: MEMBER
user: login: SansPapyrus683
created_at: 2025-03-06T01:09:34Z
body: can i ask for proof of ac?
author_association: CONTRIBUTOR
user: login: bqi343
created_at: 2025-03-06T01:11:06Z
body: I have resubmitted all the code I modified.
author_association: MEMBER
user: login: bqi343
created_at: 2025-03-06T01:18:55Z
body: > most of the problems in the pq module use sets

@SansPapyrus683 does it look good now?
author_association: MEMBER
user: login: SansPapyrus683
created_at: 2025-03-06T01:40:24Z
body: should difficulty be updated
author_association: CONTRIBUTOR
user: login: bqi343
created_at: 2025-03-06T01:41:04Z
body: difficulty of what?
author_association: MEMBER
user: login: bqi343
created_at: 2025-03-06T01:45:00Z
body: feel free to change them if you want (or not)
author_association: MEMBER