diff --git a/1012-numbers-with-repeated-digits.js b/1012-numbers-with-repeated-digits.js
index dec2580e..b9c88524 100644
--- a/1012-numbers-with-repeated-digits.js
+++ b/1012-numbers-with-repeated-digits.js
@@ -94,3 +94,52 @@ var numDupDigitsAtMostN = function(n) {
 
   return n - res
 };
+
+// another
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var numDupDigitsAtMostN = function(n) {
+  return n - helper(n)
+  function helper(num) {
+    let res = 0
+    const s = `${num}`
+    const slen = s.length
+    for(let len = 1; len < slen; len++) {
+      res += perm(10, len) - perm(9, len - 1)
+    }
+    const visited = Array(10).fill(null)
+    dfs(s, 0, visited)
+    
+    return res
+    function dfs(s, i, visited) {
+      const n = s.length
+      if(i === n) {
+        res++
+        return
+      }
+      for(let d = 0; d <= 9; d++) {
+        if(d === 0 && i === 0) continue
+        if(visited[d]) continue
+        if(d < +s[i]) {
+          res += perm(10 - i - 1, n - i - 1)
+        } else if(d === +s[i]) {
+          visited[d] = 1
+          dfs(s, i + 1, visited)
+          visited[d] = 0
+        }
+      }
+    }
+  }
+
+  function perm(m, n) {
+    if(n === 0) return 1
+    let res = 1
+    for(let i = 0; i < n; i++) {
+      res *= m - i
+    }
+    return res
+  }
+};
diff --git a/1125-smallest-sufficient-team.js b/1125-smallest-sufficient-team.js
index a617f780..2e8e9754 100644
--- a/1125-smallest-sufficient-team.js
+++ b/1125-smallest-sufficient-team.js
@@ -1,3 +1,46 @@
+/**
+ * @param {string[]} req_skills
+ * @param {string[][]} people
+ * @return {number[]}
+ */
+var smallestSufficientTeam = function(req_skills, people) {
+   const n = req_skills.length, m = people.length
+   const limit = 1 << n
+   const reqSet = new Set(req_skills)
+   const si = {}
+   for(let i = 0; i < n; i++) si[req_skills[i]] = i
+   const ps = {}
+   for(let i = 0; i < m; i++) {
+     const p = people[i]
+     let mask = 0
+     for(const s of p) {
+       if(!reqSet.has(s)) continue
+       mask |= (1 << si[s])
+     }
+     ps[i] = mask
+   }
+   const res = Array.from({ length: limit }, () => new Array())
+   let dp = Array(limit).fill(Infinity)
+   dp[0] = 0
+   for(let i = 0; i < m; i++) {
+     const pMask = ps[i]
+     // const dp2 = [...dp]
+     for(let mask = 0; mask < limit; mask++) {
+       const newMask = mask | pMask
+       if(dp[newMask] > dp[mask] + 1) {
+         dp[newMask] = dp[mask] + 1
+         res[newMask] = [...res[mask]]
+         res[newMask].push(i)
+       }
+     }
+     // dp = dp2
+   }
+   
+   return res[limit - 1]
+};
+
+// another
+
 /**
  * @param {string[]} req_skills
  * @param {string[][]} people
diff --git a/1298-maximum-candies-you-can-get-from-boxes.js b/1298-maximum-candies-you-can-get-from-boxes.js
new file mode 100644
index 00000000..b14f63da
--- /dev/null
+++ b/1298-maximum-candies-you-can-get-from-boxes.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} status
+ * @param {number[]} candies
+ * @param {number[][]} keys
+ * @param {number[][]} containedBoxes
+ * @param {number[]} initialBoxes
+ * @return {number}
+ */
+var maxCandies = function(status, candies, keys, containedBoxes, initialBoxes) {
+    let foundOpenable = true;
+    let totalCandies = 0;
+    while (initialBoxes.length > 0 && foundOpenable) {
+        foundOpenable = false;
+        let nextBoxes = [];
+        for (let boxId of initialBoxes) {
+            if (status[boxId]) {
+                foundOpenable = true;
+                nextBoxes.push(...containedBoxes[boxId]);
+                for (let keyId of keys[boxId]) status[keyId] = 1;
+                totalCandies += candies[boxId];
+            } else {
+                nextBoxes.push(boxId);
+            }
+        }
+        initialBoxes = nextBoxes;
+    }
+    return totalCandies;  
+};
diff --git a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
index 0c65e37a..b2c505d0 100644
--- a/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
+++ b/1371-find-the-longest-substring-containing-vowels-in-even-counts.js
@@ -1,3 +1,38 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var findTheLongestSubstring = function(s) {
+    const hash = {0: -1};
+    const vowels = 'aeiou';
+    const vowelsSet = new Set(vowels);
+    const n = s.length;
+    const key = (ch) => {
+        const idx = vowels.indexOf(ch);
+        return idx === -1 ? 0 : 1 << idx;
+    }
+    let state = 0;
+    let res = 0;
+    for(let i = 0; i < n; i++) {
+        const ch = s[i]
+        let tmp = state;
+        if(vowelsSet.has(ch)) {
+            tmp ^= key(ch);
+        }
+        if(hash[tmp] === undefined) {
+            hash[tmp] = i;
+        }else {
+            res = Math.max(res, i - hash[tmp]);
+        }
+
+        state = tmp
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}
diff --git a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
index 02a65836..3c66d205 100644
--- a/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
+++ b/1442-count-triplets-that-can-form-two-arrays-of-equal-xor.js
@@ -1,4 +1,32 @@
+/**
+ * @param {number[]} arr
+ * @return {number}
+ */
+var countTriplets = function(arr) {
+  const n = arr.length
+  const prefix = new Array(n + 1).fill(0)
+  for(let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] ^ arr[i]
+  }
+  let res = 0, xor = 0
+  const hash = {0: [-1]}
+  for(let i = 0; i < n; i++) {
+    const e = arr[i]
+    xor ^= e
+    if(hash[xor] === undefined) {
+      hash[xor] = []
+    } else {
+        for(const prev of hash[xor]) {
+            res += Math.max(0, i - prev - 1)
+        }
+    }
+    hash[xor].push(i)
+  }
 
+  return res
+};
+
+// another
 /**
  * @param {number[]} arr
  * @return {number}
@@ -39,3 +67,31 @@ const countTriplets = function(arr) {
   }
   return res
 };
+/*
+
+you have an array : a[0], a[1].... a[n - 1]
+
+
+First things first:
+We need to understand small fact, if xor(a[0....i]) has appeared before at index j then it means xor(a[j+1.....i]) = 0
+Another fact, if xor(a[i....j]) = 0 so this subarray will add (j - i - 1) to the answer.
+
+
+Now say currently we are at index i and let xor([0...i]) = x.
+
+
+Now say x has occurred 3 times previously at indices (i1, i2, i3)
+
+
+our answer for i will be = (i - i1 - 1) + (i - i2 - 1) + (i - i3 - 1)
+
+
+if you simplify this further you get f * i - (i1 + i2 + i3) - f = (i - 1) * f - (i1 + i2 + i3)
+
+
+f = no. of times x has occurred previously.
+
+
+(i1 + i2 + i3) = sum of all the indices where x has occurred previously.
+
+*/
diff --git a/1462-course-schedule-iv.js b/1462-course-schedule-iv.js
index abbcaf55..d06b42f0 100644
--- a/1462-course-schedule-iv.js
+++ b/1462-course-schedule-iv.js
@@ -1,3 +1,56 @@
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @param {number[][]} queries
+ * @return {boolean[]}
+ */
+var checkIfPrerequisite = function(numCourses, prerequisites, queries) {
+   const g = {}
+   const n = numCourses
+   const indegree = Array(n).fill(0)
+   for(const [a, b] of prerequisites) {
+     if(!g[a]) {
+       g[a] = []
+     }
+     g[a].push(b)
+     indegree[b]++
+   }
+   const q = []
+    for(let i = 0; i < n; i++) {
+      if(indegree[i] === 0) {
+        q.push(i)
+      }
+    }
+    const res = []
+    const hash = {}
+    for(const e of q) {
+      dfs(e, new Set())
+    }
+    for(let i = 0; i < queries.length; i++) {
+      const [a, b] = queries[i]
+      res.push(hash[a] && hash[a].has(b))
+    }
+
+    return res
+    function dfs(cur, set) {
+        if(hash[cur]) {
+            return hash[cur]
+        }
+        hash[cur] = new Set()
+        if(g[cur]) {
+            for(const e of g[cur]) {
+                for(const x of dfs(e, set)) {
+                    hash[cur].add(x)
+                }
+            }
+        }
+        hash[cur].add(cur)
+        return hash[cur]
+    }
+};
+
+// another
+
 /**
  * @param {number} numCourses
  * @param {number[][]} prerequisites
diff --git a/1494-parallel-courses-ii.js b/1494-parallel-courses-ii.js
index 0882499f..17397e68 100644
--- a/1494-parallel-courses-ii.js
+++ b/1494-parallel-courses-ii.js
@@ -1,3 +1,55 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number} k
+ * @return {number}
+ */
+const minNumberOfSemesters = function(n, relations, k) {
+  const limit = (1 << n)
+  const dp = Array(limit).fill(Number.MAX_SAFE_INTEGER)
+  const preCourse = Array(n).fill(0)
+  const preState = Array(limit).fill(0)
+  
+  for(const [s, d] of relations) {
+    preCourse[d - 1] |= (1 << (s - 1))
+  }
+  for(let state = 0; state < limit; state++) {
+    for(let i = 0; i < n; i++) {
+      if(state & (1 << i)) {
+        preState[state] |= preCourse[i]
+      }
+    }
+    if(preState[state] === 0 && bitCnt(state) <= k) dp[state] = 1
+  }
+  dp[0] = 0
+  for(let state = 1; state < limit; state++) {
+    for(let sub = state; sub >= 0; sub = (sub - 1) & state) {
+      if(
+        bitCnt(state) - bitCnt(sub) <= k &&
+        ((preState[state] & sub) === preState[state])
+      ) {
+        // console.log('d', state, sub, dp)
+        dp[state] = Math.min(dp[state], dp[sub] + 1)
+      }
+      if(sub === 0) break
+    }
+  }
+  
+  // console.log(limit)
+  return dp[limit - 1]
+};
+
+function bitCnt(num) {
+  let res = 0
+  while(num) {
+    res++
+    num &= (num - 1)
+  }
+  return res
+}
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} dependencies
diff --git a/1545-find-kth-bit-in-nth-binary-string.js b/1545-find-kth-bit-in-nth-binary-string.js
new file mode 100644
index 00000000..86e2aa48
--- /dev/null
+++ b/1545-find-kth-bit-in-nth-binary-string.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @return {character}
+ */
+var findKthBit = function(n, k) {
+  let count = 0, l = (1 << n) - 1;
+  while (k > 1) {
+    if (k == Math.floor(l / 2) + 1) return count % 2 == 0 ? '1' : '0';
+    if (k > l / 2) {
+      k = l + 1 - k;
+      count++;
+    }
+    l = Math.floor(l / 2);
+  }
+  return count % 2 === 0 ? '0' : '1'; 
+};
diff --git a/1590-make-sum-divisible-by-p.js b/1590-make-sum-divisible-by-p.js
index 182ae5a0..4c903d90 100644
--- a/1590-make-sum-divisible-by-p.js
+++ b/1590-make-sum-divisible-by-p.js
@@ -1,3 +1,32 @@
+/**
+ * @param {number[]} nums
+ * @param {number} p
+ * @return {number}
+ */
+var minSubarray = function(nums, p) {
+    const n = nums.length
+    const sum = nums.reduce((acc, cur) => acc + cur, 0)
+    const target = sum % p
+    if(target === 0) return 0
+    const hash = {0: -1}
+    let res = n
+    let curSum = 0
+    for(let i = 0; i < n; i++) {
+        const e = nums[i]
+        curSum += e
+        const remain = curSum % p
+        const diff = (remain - target + p) % p
+        if(hash[diff] != null) {
+            res = Math.min(res, i - hash[diff])
+        }
+        hash[remain] = i
+    }
+
+    return res === n ? -1 : res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} p
diff --git a/1591-strange-printer-ii.js b/1591-strange-printer-ii.js
index 4dd5b521..1db9c901 100644
--- a/1591-strange-printer-ii.js
+++ b/1591-strange-printer-ii.js
@@ -1,3 +1,71 @@
+/**
+ * @param {number[][]} targetGrid
+ * @return {boolean}
+ */
+const isPrintable = function(targetGrid) {
+    // solve the problem: BFS
+    // 1. find the top-left and bottom-right corner of each color
+    // 2. check if there is a circle in the graph
+    // 3. if there is a circle, return false
+    // 4. if there is no circle, return true
+    const m = targetGrid.length;
+    const n = targetGrid[0].length;
+    const left = new Array(61).fill(n);
+    const right = new Array(61).fill(-1);
+    const top = new Array(61).fill(m);
+    const bottom = new Array(61).fill(-1);
+    const next = new Array(61).fill(null).map(() => []);
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            const color = targetGrid[i][j];
+            left[color] = Math.min(left[color], j);
+            right[color] = Math.max(right[color], j);
+            top[color] = Math.min(top[color], i);
+            bottom[color] = Math.max(bottom[color], i);
+        }
+    }
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            for (let color = 1; color <= 60; color++) {
+                if (i >= top[color] && i <= bottom[color] && j >= left[color] && j <= right[color]) {
+                    if (color !== targetGrid[i][j]) {
+                        next[targetGrid[i][j]].push(color);
+                    }
+                }
+            }
+        }
+    }
+    const numNodes = 61;
+    const inDegree = new Array(numNodes).fill(0);
+    for (let i = 0; i < numNodes; i++) {
+        for (const j of next[i]) {
+            inDegree[j]++;
+        }
+    }
+    const queue = [];
+    let count = 0;
+    for (let i = 0; i < numNodes; i++) {
+        if (inDegree[i] === 0) {
+            queue.push(i);
+            count++;
+        }
+    }
+    while (queue.length > 0) {
+        const curCourse = queue.shift();
+        for (const child of next[curCourse]) {
+            inDegree[child]--;
+            if (inDegree[child] === 0) {
+                queue.push(child);
+                count++;
+            }
+        }
+    }
+    return count === numNodes;
+};
+
+// another
+
+
 /**
  * @param {number[][]} targetGrid
  * @return {boolean}
diff --git a/1625-lexicographically-smallest-string-after-applying-operations.js b/1625-lexicographically-smallest-string-after-applying-operations.js
index ed184351..ec693a8b 100644
--- a/1625-lexicographically-smallest-string-after-applying-operations.js
+++ b/1625-lexicographically-smallest-string-after-applying-operations.js
@@ -1,3 +1,51 @@
+/**
+ * @param {string} s
+ * @param {number} a
+ * @param {number} b
+ * @return {string}
+ */
+const findLexSmallestString = function(s, a, b) {
+    let res = s;
+    const n = s.length;
+
+    let evenLimit = 10;
+    if (b % 2 === 0) evenLimit = 1;
+
+    for (let i = 0; i < evenLimit; i++) {
+        for (let j = 0; j < 10; j++) {
+            let t = s.split('');
+
+            for (let k = 0; k < n; k += 2) {
+                t[k] = (parseInt(t[k]) + a * i) % 10;
+            }
+            for (let k = 1; k < n; k += 2) {
+                t[k] = (parseInt(t[k]) + a * j) % 10;
+            }
+
+            t = t.join('');
+            let p = t;
+            const gcdValue = gcd(n, b);
+            for (let k = 0; k <= n / gcdValue; k++) {
+                p = p.slice(n - b) + p.slice(0, n - b);
+                res = res < p ? res : p;
+            }
+        }
+    }
+
+    return res;    
+};
+
+
+function gcd(x, y) {
+    while (y !== 0) {
+        let temp = y;
+        y = x % y;
+        x = temp;
+    }
+    return x;
+}
+// another
+
 /**
  * @param {string} s
  * @param {number} a
diff --git a/1632-rank-transform-of-a-matrix.js b/1632-rank-transform-of-a-matrix.js
index 69233377..6145eff0 100644
--- a/1632-rank-transform-of-a-matrix.js
+++ b/1632-rank-transform-of-a-matrix.js
@@ -1,3 +1,91 @@
+class UF {
+    constructor(n) {
+        this.parent = new Array(n + 1).fill(0).map((_, i) => i);
+    }
+    union(x, y) {
+        const rootX = this.find(x);
+        const rootY = this.find(y);
+        if (rootX !== rootY) {
+            this.parent[rootX] = rootY;
+        }
+    }
+    find(x) {
+        if (x !== this.parent[x]) {
+            this.parent[x] = this.find(this.parent[x]);
+        }
+        return this.parent[x];
+    }
+}
+
+// Update the matrixRankTransform function to use the union-find functions
+var matrixRankTransform = function(matrix) {
+    const m = matrix.length
+    const n = matrix[0].length
+    const uf = new UF(m * n)
+    const res = Array.from({ length: m }, () => Array(n).fill(-1))
+
+    for (let i = 0; i < m; i++) {
+        const tmp = []
+        for (let j = 0; j < n; j++) {
+            tmp.push([matrix[i][j], i * n + j])
+        }
+        tmp.sort((a, b) => a[0] - b[0])
+        for (let j = 1; j < n; j++) {
+            if (tmp[j][0] === tmp[j - 1][0] && uf.find(tmp[j][1]) !== uf.find(tmp[j - 1][1])) {
+                uf.union(tmp[j][1], tmp[j - 1][1])
+            }
+        }
+    }
+
+    for (let j = 0; j < n; j++) {
+        const tmp = []
+        for (let i = 0; i < m; i++) {
+            tmp.push([matrix[i][j], i * n + j])
+        }
+        tmp.sort((a, b) => a[0] - b[0])
+        for (let i = 1; i < m; i++) {
+            if (tmp[i][0] === tmp[i - 1][0] && uf.find(tmp[i][1]) !== uf.find(tmp[i - 1][1])) {
+                uf.union(tmp[i][1], tmp[i - 1][1])
+            }
+        }
+    }
+
+    const nums = [], group = {}
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            const key = i * n + j
+            const root = uf.find(key)
+            if(group[root] == null) group[root] = []
+            group[root].push(key)
+            nums.push([matrix[i][j], key])
+        }
+    }
+    nums.sort((a, b) => a[0] - b[0])
+    const rowMax = Array(m).fill(0)
+    const colMax = Array(n).fill(0)
+    for(const e of nums) {
+        const [val, key] = e
+        const [i, j] = [Math.floor(key / n), key % n]
+        if(res[i][j] !== -1) continue
+        let rank = 0
+        for(const k of group[uf.find(key)]) {
+            const [x, y] = [Math.floor(k / n), k % n]
+            rank = Math.max(rank, rowMax[x], colMax[y])
+        }
+        rank++
+        for(const k of group[uf.find(key)]) {
+            const [x, y] = [Math.floor(k / n), k % n]
+            res[x][y] = rank
+            rowMax[x] = rank
+            colMax[y] = rank
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} matrix
  * @return {number[][]}
diff --git a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
index aa948052..503c429e 100644
--- a/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
+++ b/1737-change-minimum-characters-to-satisfy-one-of-three-conditions.js
@@ -1,3 +1,55 @@
+/**
+ * @param {string} a
+ * @param {string} b
+ * @return {number}
+ */
+const minCharacters = function(a, b) {
+  const n = a.length, m = b.length;
+    const freqA = Array(26).fill(0), freqB = Array(26).fill(0);
+    const ac = 'a'.charCodeAt(0)
+    for(let i = 0; i < n; i++) {
+        freqA[a.charCodeAt(i) - ac]++
+    }
+    for(let i = 0; i < m; i++) {
+        freqB[b.charCodeAt(i) - ac]++
+    }
+    let res = Infinity
+    for(let i = 0; i < 26; i++) {
+        if(i > 0) {
+            let change = 0
+            for(let j = 0; j < i; j++) {
+                change += freqA[j]
+            }
+            for(let j = i; j < 26; j++) {
+                change += freqB[j]
+            }
+            res = Math.min(res, change)
+            change = 0
+            for(let j = 0; j < i; j++) {
+                change += freqB[j]
+            }
+            for(let j = i; j < 26; j++) {
+                change += freqA[j]
+            }
+            res = Math.min(res, change)
+        }
+        let change = 0
+        for(let j = 0; j < 26; j++) {
+            if(j !== i) {
+                change += freqA[j]
+                change += freqB[j]
+            }
+        }
+        res = Math.min(res, change)
+    }
+
+    return res
+};
+
+
+// another
+
+
 /**
  * @param {string} a
  * @param {string} b
diff --git a/1786-number-of-restricted-paths-from-first-to-last-node.js b/1786-number-of-restricted-paths-from-first-to-last-node.js
index 6a80fd88..511174a9 100644
--- a/1786-number-of-restricted-paths-from-first-to-last-node.js
+++ b/1786-number-of-restricted-paths-from-first-to-last-node.js
@@ -1,3 +1,117 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const countRestrictedPaths = function(n, edges) {
+  const g = {}
+    for (let [u, v, w] of edges) {
+        g[u] = g[u] || []
+        g[u].push([v, w])
+        g[v] = g[v] || []
+        g[v].push([u, w])
+    }
+    const dist = Array(n + 1).fill(Infinity)
+    dist[n] = 0
+    const pq = new PQ((a, b) => a[0] < b[0])
+    pq.push([0, n])
+    while(!pq.isEmpty()) {
+        const [d, u] = pq.pop()
+        if (d !== dist[u]) continue
+        for (let [v, w] of (g[u] || [])) {
+            if (dist[v] > dist[u] + w) {
+                dist[v] = dist[u] + w
+                pq.push([dist[v], v])
+            }
+        }
+    }
+    const mod = 1e9 + 7
+    const memo = Array(n + 1).fill(null)
+    const dfs = (src) => {
+        if (memo[src] !== null) return memo[src]
+        if (src === n) return 1
+        let res = 0
+        for (let [v, w] of (g[src] || [])) {
+            if (dist[src] > dist[v]) {
+                res = (res + dfs(v)) % mod
+            }
+        }
+        return memo[src] = res
+    }
+    return dfs(1)
+};
+
+class PQ {
+    constructor(comparator = (a, b) => a > b) {
+      this.heap = []
+      this.top = 0
+      this.comparator = comparator
+    }
+    size() {
+      return this.heap.length
+    }
+    isEmpty() {
+      return this.size() === 0
+    }
+    peek() {
+      return this.heap[this.top]
+    }
+    push(...values) {
+      values.forEach((value) => {
+        this.heap.push(value)
+        this.siftUp()
+      })
+      return this.size()
+    }
+    pop() {
+      const poppedValue = this.peek()
+      const bottom = this.size() - 1
+      if (bottom > this.top) {
+        this.swap(this.top, bottom)
+      }
+      this.heap.pop()
+      this.siftDown()
+      return poppedValue
+    }
+    replace(value) {
+      const replacedValue = this.peek()
+      this.heap[this.top] = value
+      this.siftDown()
+      return replacedValue
+    }
+  
+    parent = (i) => ((i + 1) >>> 1) - 1
+    left = (i) => (i << 1) + 1
+    right = (i) => (i + 1) << 1
+    greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+    swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+    siftUp = () => {
+      let node = this.size() - 1
+      while (node > this.top && this.greater(node, this.parent(node))) {
+        this.swap(node, this.parent(node))
+        node = this.parent(node)
+      }
+    }
+    siftDown = () => {
+      let node = this.top
+      while (
+        (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+        (this.right(node) < this.size() && this.greater(this.right(node), node))
+      ) {
+        let maxChild =
+          this.right(node) < this.size() &&
+          this.greater(this.right(node), this.left(node))
+            ? this.right(node)
+            : this.left(node)
+        this.swap(node, maxChild)
+        node = maxChild
+      }
+    }
+  }
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges
diff --git a/1857-largest-color-value-in-a-directed-graph.js b/1857-largest-color-value-in-a-directed-graph.js
index ed99ed48..670144e8 100644
--- a/1857-largest-color-value-in-a-directed-graph.js
+++ b/1857-largest-color-value-in-a-directed-graph.js
@@ -1,3 +1,70 @@
+/**
+ * @param {string} colors
+ * @param {number[][]} edges
+ * @return {number}
+ */
+const largestPathValue = function(colors, edges) {
+    const n = colors.length;
+    const m = edges.length;
+    const adj = Array(n).fill(0).map(() => []);
+    const inDegree = Array(n).fill(0);
+    for (const [u, v] of edges) {
+        adj[u].push(v);
+        inDegree[v]++;
+    }
+    let res = 1
+    const colorSet = new Set(colors);
+    const a = 'a'.charCodeAt(0);
+    for(const e of colorSet) {
+        const tmp = helper(e.charCodeAt(0) - a);
+        if(tmp === -1) return -1;
+        res = Math.max(res, tmp);
+    }
+
+    return res
+
+    function code(ch) {
+        return ch.charCodeAt(0) - 'a'.charCodeAt(0);
+    }
+    function helper(k) {
+        const ind = [...inDegree];
+        const count = Array(n).fill(0);
+        let nodes = 0
+        let res = 0
+        let q = []
+        for(let i = 0; i < n; i++) {
+            if(ind[i] === 0) {
+                q.push(i);
+                nodes++
+                count[i] = code(colors[i]) === k ? 1 : 0;
+            }
+        }
+
+        while(q.length) {
+            const size = q.length;
+            const tmp = []
+            for(let i = 0; i < size; i++) {
+                const e = q[i];
+                for(const v of adj[e]) {
+                    count[v] = Math.max(count[v], count[e] + (code(colors[v]) === k ? 1 : 0));
+                    res = Math.max(res, count[v]);
+                    ind[v]--;
+                    if(ind[v] === 0) {
+                        tmp.push(v);
+                        nodes++
+                    }
+                }
+            }
+
+            q = tmp
+        }
+
+        return nodes === n ? res : -1
+    }
+};
+
+// another
+
 /**
  * @param {string} colors
  * @param {number[][]} edges
diff --git a/1915-number-of-wonderful-substrings.js b/1915-number-of-wonderful-substrings.js
index 99f3a690..800696e7 100644
--- a/1915-number-of-wonderful-substrings.js
+++ b/1915-number-of-wonderful-substrings.js
@@ -1,3 +1,32 @@
+/**
+ * @param {string} word
+ * @return {number}
+ */
+const wonderfulSubstrings = function(word) {
+  const n = word.length;
+  let mask = 0
+  const hash = {0: 1}, a = 'a'.charCodeAt(0)
+  let res = 0
+  
+  for(let i = 0; i < n; i++) {
+    const idx = word.charCodeAt(i) - a
+    mask ^= (1 << idx)
+
+    res += hash[mask] || 0
+    for(let j = 0; j < 10; j++) {
+      const newMask = mask ^ (1 << j)
+      res += hash[newMask] || 0
+    }
+
+    if(hash[mask] == null) hash[mask] = 0
+    hash[mask]++
+  }
+  
+  return res
+};
+
+// another
+
 /**
  * @param {string} word
  * @return {number}
diff --git a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
index f6126c88..49a6f516 100644
--- a/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
+++ b/2002-maximum-product-of-the-length-of-two-palindromic-subsequences.js
@@ -1,3 +1,46 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const maxProduct = function(s) {
+  const n = s.length
+  const limit = (1 << n) - 1
+  let res = 0
+  for(let mask = 1; mask < limit; mask++) {
+    res = Math.max(res, lp(mask) * lp(limit - mask))
+  }
+  return res
+  
+  function lp(state) {
+    if(state === 0) return 0
+    const str = []
+    let idx = 0
+    // console.log((state))
+    while(idx < s.length) {
+      // console.log((state >>> 0).toString(2))
+      if((state >> idx) & 1) str.push(s[s.length - 1 - idx])
+      idx++
+    }
+    // console.log(str)
+    const len = str.length
+    const dp = Array.from({ length: len }, () => Array(len).fill(0))
+    for(let i = 0; i < len; i++) dp[i][i] = 1
+    
+    for(let length = 2; length <= len; length++) {
+      for(let i = 0; i + length - 1 < len; i++) {
+        const j = i + length - 1
+        if(str[i] === str[j]) dp[i][j] = dp[i + 1][j - 1] + 2
+        else dp[i][j] = Math.max(dp[i + 1][j], dp[i][j - 1])
+      }
+    }
+    
+    // console.log(dp, len)
+    return dp[0][len - 1]
+  } 
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}
diff --git a/2013-detect-squares.js b/2013-detect-squares.js
index 3cb84312..4efeefa0 100644
--- a/2013-detect-squares.js
+++ b/2013-detect-squares.js
@@ -1,4 +1,57 @@
 
+var DetectSquares = function() {
+    this.mat = Array.from({length: 1001}, () => Array.from({length: 1001}, () => 0));
+    this.ya = new Map()
+};
+
+/** 
+ * @param {number[]} point
+ * @return {void}
+ */
+DetectSquares.prototype.add = function(point) {
+    const [x, y] = point;
+    this.mat[x][y]++;
+    if(this.ya.get(y) == null) this.ya.set(y, new Map())
+    if(this.ya.get(y).get(x) == null) this.ya.get(y).set(x, 0)
+    this.ya.get(y).set(x, this.ya.get(y).get(x) + 1)
+};
+
+/** 
+ * @param {number[]} point
+ * @return {number}
+ */
+DetectSquares.prototype.count = function(point) {
+    const [x, y] = point;
+    let res = 0
+    if(!this.ya.has(y)) return res
+    for(const [key, cnt] of this.ya.get(y)) {
+        const i = +key
+        const d = Math.abs(x - i)
+        if(d === 0) continue
+        let j = y + d
+        if(j >= 0 && j < 1001) {
+            res += cnt * this.mat[x][j] * this.mat[i][j]
+        }
+        j = y - d
+        if(j >= 0 && j < 1001) {
+            res += cnt * this.mat[x][j] * this.mat[i][j]
+        }
+    }
+
+    return res
+};
+
+/** 
+ * Your DetectSquares object will be instantiated and called as such:
+ * var obj = new DetectSquares()
+ * obj.add(point)
+ * var param_2 = obj.count(point)
+ */
+
+// another
+
+
+
 const DetectSquares = function() {
   this.pts = []
   this.ptsCnt = {}
diff --git a/2045-second-minimum-time-to-reach-destination.js b/2045-second-minimum-time-to-reach-destination.js
index bec00cad..8bb74c36 100644
--- a/2045-second-minimum-time-to-reach-destination.js
+++ b/2045-second-minimum-time-to-reach-destination.js
@@ -1,16 +1,3 @@
-const initializeGraph = (n) => {
-  let G = []
-  for (let i = 0; i < n; i++) {
-    G.push([])
-  }
-  return G
-}
-const addEdgeToG = (G, Edges) => {
-  for (const [u, v] of Edges) {
-    G[u].push(v)
-    G[v].push(u)
-  }
-}
 /**
  * @param {number} n
  * @param {number[][]} edges
@@ -18,15 +5,15 @@ const addEdgeToG = (G, Edges) => {
  * @param {number} change
  * @return {number}
  */
-const secondMinimum = (n, edges, time, change) => {
+var secondMinimum = function(n, edges, time, change) {
   let adj = initializeGraph(n + 1)
   addEdgeToG(adj, edges)
   let cost = initializeGraph(n + 1)
-  let pq = new MinPriorityQueue({ priority: (x) => x[0] })
-  pq.enqueue([0, 1])
+  let pq = new PQ((a, b) => a[0] < b[0])
+  pq.push([0, 1])
   let green = 2 * change
   while (pq.size()) {
-    let cur = pq.dequeue().element
+    let cur = pq.pop()
     let [t, node] = cur
     if (cost[node].length == 2) continue
     let nextT =
@@ -45,9 +32,89 @@ const secondMinimum = (n, edges, time, change) => {
         continue
       }
     }
-    for (const next_node of adj[node]) pq.enqueue([nextT + time, next_node])
+    for (const next_node of adj[node]) pq.push([nextT + time, next_node])
   }
   return cost[n][1]
+};
+function initializeGraph(n) {
+  let G = []
+  for (let i = 0; i < n; i++) {
+    G.push([])
+  }
+  return G
+}
+function addEdgeToG(G, Edges) {
+  for (const [u, v] of Edges) {
+    G[u].push(v)
+    G[v].push(u)
+  }
+}
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
 }
 
 // another
diff --git a/2050-parallel-courses-iii.js b/2050-parallel-courses-iii.js
index 1be35f37..521a0eb0 100644
--- a/2050-parallel-courses-iii.js
+++ b/2050-parallel-courses-iii.js
@@ -1,3 +1,48 @@
+/**
+ * @param {number} n
+ * @param {number[][]} relations
+ * @param {number[]} time
+ * @return {number}
+ */
+const minimumTime = function(n, relations, time) {
+  const adj = Array(n + 1).fill(0).map(() => []);
+    const inDegree = Array(n + 1).fill(0);
+    for (const [u, v] of relations) {
+        adj[u].push(v);
+        inDegree[v]++;
+    }
+    let q = []
+    const finishTime = Array(n + 1).fill(0);
+    for(let i = 1; i <= n; i++) {
+        if(inDegree[i] === 0) {
+            q.push(i);
+            finishTime[i] = time[i - 1];
+        }
+    }
+
+
+    while(q.length) {
+        const size = q.length;
+        const tmp = []
+        for(let i = 0; i < size; i++) {
+            const e = q[i];
+            for(const v of adj[e]) {
+                inDegree[v]--;
+                finishTime[v] = Math.max(finishTime[v], finishTime[e] + time[v - 1]);
+                if(inDegree[v] === 0) {
+                    tmp.push(v);
+                }
+            }
+        }
+
+        q = tmp
+    }
+
+    return Math.max(...finishTime.slice(1))
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} relations
diff --git a/210-course-schedule-ii.js b/210-course-schedule-ii.js
index 350c4d33..acfd8832 100644
--- a/210-course-schedule-ii.js
+++ b/210-course-schedule-ii.js
@@ -104,3 +104,53 @@ const findOrder = function(numCourses, prerequisites) {
     return true
   }
 }
+
+// another
+
+/**
+ * @param {number} numCourses
+ * @param {number[][]} prerequisites
+ * @return {number[]}
+ */
+var findOrder = function(numCourses, prerequisites) {
+  const inDegree = new Array(numCourses).fill(0);
+    const graph = {};
+    for (let i = 0;i < prerequisites.length;i++) {
+        const e = prerequisites[i];
+        inDegree[e[0]]++;
+        if (graph[e[1]]) {
+            graph[e[1]].push(e[0]);
+        } else {
+            graph[e[1]] = [e[0]];
+        }
+    }
+    let q = []
+    for (let i = 0;i < inDegree.length;i++) {
+        if (inDegree[i] === 0) {
+            q.push(i);
+        }
+    }
+    const res = []
+    let count = 0;
+    while(q.length) {
+        const tmp = []
+        const size = q.length
+        for(let i = 0;i < size;i++) {
+            const node = q[i]
+            res.push(node)
+            count++
+            if (graph[node]) {
+                for (let j = 0;j < graph[node].length;j++) {
+                    inDegree[graph[node][j]]--
+                    if (inDegree[graph[node][j]] === 0) {
+                        tmp.push(graph[node][j])
+                    }
+                }
+            }
+        }
+
+        q = tmp
+    }
+
+    return count === numCourses ? res : [];
+};
diff --git a/2202-maximize-the-topmost-element-after-k-moves.js b/2202-maximize-the-topmost-element-after-k-moves.js
new file mode 100644
index 00000000..244e6835
--- /dev/null
+++ b/2202-maximize-the-topmost-element-after-k-moves.js
@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maximumTop = function(nums, k) {
+  const n = nums.length
+  if(k === 0) return n >= 1 ? nums[0] : -1
+  if(k === 1) return n === 1 ? -1 : nums[1]
+  if(n === 1) return k % 2 === 0 ? nums[0] : -1
+  const tmp = nums.slice(0, Math.min(k - 1, n))
+  let res = Math.max(...tmp)
+  if(k < n) res = Math.max(res, nums[k])
+  return res  
+};
diff --git a/2223-sum-of-scores-of-built-strings.js b/2223-sum-of-scores-of-built-strings.js
index 18cc57f1..2f8c3d48 100644
--- a/2223-sum-of-scores-of-built-strings.js
+++ b/2223-sum-of-scores-of-built-strings.js
@@ -1,3 +1,36 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var sumScores = function(s) {
+  let res = 0
+  const pre = lps(s)
+  const cnt = []
+  for(let i = 0; i < s.length; i++) {
+    const j = pre[i]
+    cnt.push(j === 0 ? 0 : cnt[j - 1] + 1)
+  }
+  res = cnt.reduce((ac, e) => ac + e, 0) + s.length
+  return res
+
+  function lps(s) {
+    const n = s.length
+    const res = Array(n).fill(0)
+
+    for(let i = 1, j = 0; i < n; i++) {
+        while(j && s[j] !== s[i]) {
+            j = Math.max(0, res[j - 1])
+        }
+        j += (s[i] === s[j] ? 1 : 0)
+        res[i] = j
+    }
+
+    return res
+  }
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}
diff --git a/2261-k-divisible-elements-subarrays.js b/2261-k-divisible-elements-subarrays.js
index 8b930531..691bcf2b 100644
--- a/2261-k-divisible-elements-subarrays.js
+++ b/2261-k-divisible-elements-subarrays.js
@@ -5,20 +5,19 @@
  * @return {number}
  */
 const countDistinct = function(nums, k, p) {
-    let ans = 0;
-    const se = new Set();
-    let n = nums.length;
+    const se = new Set()
+    let n = nums.length
     for (let i = 0; i < n; i++) {
-        let tmp = "";
-        let cnt = 0;
+        let tmp = ""
+        let cnt = 0
         for (let j = i; j < n; j++) {
             if (nums[j] % p == 0)
-                cnt++;
+                cnt++
             if (cnt <= k) {
-                tmp = tmp + (nums[j]) + "-";
-                se.add(tmp);
-            } else break;
+                tmp = tmp + (nums[j]) + "-"
+                se.add(tmp)
+            } else break
         }
     }
-    return se.size;
+    return se.size
 };
diff --git a/235-lowest-common-ancestor-of-a-binary-search-tree.js b/235-lowest-common-ancestor-of-a-binary-search-tree.js
index 205bcf3d..f6716919 100644
--- a/235-lowest-common-ancestor-of-a-binary-search-tree.js
+++ b/235-lowest-common-ancestor-of-a-binary-search-tree.js
@@ -29,6 +29,7 @@ const lowestCommonAncestor = function(root, p, q) {
  *     this.left = this.right = null;
  * }
  */
+
 /**
  * @param {TreeNode} root
  * @param {TreeNode} p
@@ -36,8 +37,8 @@ const lowestCommonAncestor = function(root, p, q) {
  * @return {TreeNode}
  */
 const lowestCommonAncestor = function(root, p, q) {
-    while((root.val - p.val) * (root.val - q.val) > 0) {
-          root = root.val > p.val ? root.left : root.right
-    }
-    return root
+  while((root.val - p.val) * (root.val - q.val) > 0) {
+    root = p.val < root.val ? root.left : root.right
+  }
+  return root
 };
diff --git a/2360-longest-cycle-in-a-graph.js b/2360-longest-cycle-in-a-graph.js
index da87392d..32eed7a3 100644
--- a/2360-longest-cycle-in-a-graph.js
+++ b/2360-longest-cycle-in-a-graph.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} edges
+ * @return {number}
+ */
+const longestCycle = function(edges) {
+  const n = edges.length;
+  const visited = new Array(n).fill(false);
+  const ind = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    if (edges[i] !== -1) {
+      ind[edges[i]]++;
+    }
+  }
+  let q = []
+  for(let i = 0; i < n; i++) {
+    if (ind[i] === 0) {
+      q.push(i);
+    }
+  }
+  while(q.length) {
+    const node = q.pop()
+    visited[node] = true;
+    const nxt = edges[node];
+    if(nxt !== -1) {
+      ind[nxt]--;
+      if (ind[nxt] === 0) {
+        q.push(nxt);
+      }
+    }
+  }
+  let res = -1
+  for(let i = 0; i < n; i++) {
+    if (!visited[i]) {
+        let cnt = 0
+        let cur = i
+        while (!visited[cur]) {
+            visited[cur] = true
+            cur = edges[cur]
+            cnt++
+        }
+        res = Math.max(res, cnt)
+    }
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} edges
  * @return {number}
diff --git a/2376-count-special-integers.js b/2376-count-special-integers.js
index c2f74b4f..af386f2f 100644
--- a/2376-count-special-integers.js
+++ b/2376-count-special-integers.js
@@ -58,3 +58,59 @@ const countSpecialNumbers = function (n) {
     return (dp[idx][tight][mask] = ans)
   }
 }
+
+// another
+
+const dp = Array.from({ length: 11 }, () =>
+  Array.from({ length: 2 }, () => Array(1024).fill(-1)),
+)
+
+function gogo(s, tight = 1, pos = 0, mask = 0) {
+  // Base case
+  if (pos === s.length) {
+    // Mask = 0, represents 00000...0 which should not be counted
+    return mask !== 0
+  }
+
+  // DP state
+  if (dp[pos][tight][mask] !== -1) {
+    return dp[pos][tight][mask]
+  }
+
+  let ans = 0
+
+  if (tight === 1) {
+    // Limit the current digit
+    for (let i = 0; i <= s[pos] - '0'; i++) {
+      // Check if digit repeated, ie, present in the mask
+      if (mask & (1 << i)) continue
+
+      const newMask = mask === 0 && i === 0 ? mask : mask | (1 << i)
+
+      if (i === s[pos] - '0') {
+        // Tight case
+        ans += gogo(s, 1, pos + 1, newMask)
+      } else {
+        ans += gogo(s, 0, pos + 1, newMask)
+      }
+    }
+  } else {
+    for (let i = 0; i <= 9; i++) {
+      // Check if digit repeated, ie, present in the mask
+      if (mask & (1 << i)) continue
+
+      const newMask = mask === 0 && i === 0 ? mask : mask | (1 << i)
+      ans += gogo(s, 0, pos + 1, newMask)
+    }
+  }
+  return (dp[pos][tight][mask] = ans)
+}
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countSpecialNumbers = function (n) {
+  const s = n.toString()
+  dp.forEach((arr) => arr.forEach((innerArr) => innerArr.fill(-1)))
+  return gogo(s)
+}
diff --git a/2392-build-a-matrix-with-conditions.js b/2392-build-a-matrix-with-conditions.js
index 8bd4d8ac..a18b14d3 100644
--- a/2392-build-a-matrix-with-conditions.js
+++ b/2392-build-a-matrix-with-conditions.js
@@ -1,3 +1,69 @@
+/**
+ * @param {number} k
+ * @param {number[][]} rowConditions
+ * @param {number[][]} colConditions
+ * @return {number[][]}
+ */
+const buildMatrix = function(k, rowConditions, colConditions) {
+    const col = topo(k, colConditions);
+    const row = topo(k, rowConditions);
+    if(col.length === 0 || row.length === 0) return []
+
+    const res = Array.from({length: k}, () => Array.from({length: k}, () => 0));
+    const colHash = {}, rowHash = {};
+    for(let i = 0; i < k; i++) {
+        colHash[col[i]] = i;
+        rowHash[row[i]] = i;
+    }
+    for(let i = 1; i <= k; i++) {
+        res[rowHash[i]][colHash[i]] = i
+    }
+
+    return res
+
+    function topo(k, conditions) {
+        const n = conditions.length;
+        const ind = new Array(k + 1).fill(0);
+        const adj = Array.from({length: k + 1}, () => []);
+        for(let i = 0; i < n; i++) {
+            const [a, b] = conditions[i];
+            adj[a].push(b);
+            ind[b]++;
+        }
+      // console.log(adj, ind)
+        let q = []
+        for(let i = 1; i <= k; i++) {
+            if (ind[i] === 0) {
+                q.push(i);
+            }
+        }
+        const res = []
+
+        while(q.length) {
+            const size = q.length
+            const tmp = []
+            for(let i = 0; i < size; i++) {
+
+                const node = q[i]
+                res.push(node)
+                for(const nxt of adj[node]) {
+                    ind[nxt]--;
+                    if (ind[nxt] === 0) {
+                        tmp.push(nxt);
+                    }
+                }
+            }
+            q = tmp
+        }
+      // console.log(res)
+        if(res.length !== k) return []
+        return res
+    }
+};
+
+// another
+
+
 /**
  * @param {number} k
  * @param {number[][]} rowConditions
diff --git a/2416-sum-of-prefix-scores-of-strings.js b/2416-sum-of-prefix-scores-of-strings.js
index 32d5f713..b9b48503 100644
--- a/2416-sum-of-prefix-scores-of-strings.js
+++ b/2416-sum-of-prefix-scores-of-strings.js
@@ -1,3 +1,47 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const sumPrefixScores = function(words) {
+  const root = new Node()
+  const n = words.length
+  for(const w of words) {
+    let cur = root
+    for(const ch of w) {
+        if(!cur.children.has(ch)) cur.children.set(ch, new Node())
+        const node = cur.children.get(ch)
+        node.cnt++
+        cur = node
+    }
+  }
+
+  const res = []
+
+  for(const w of words) {
+    let cur = root
+    let tmp = 0
+    for(const ch of w) {
+        if(cur.children.has(ch)) {
+            const node = cur.children.get(ch)
+            tmp += node.cnt
+            cur = node
+        } else break
+    }
+    res.push(tmp)
+  }
+
+  return res
+};
+
+class Node {
+    constructor() {
+        this.children = new Map()
+        this.cnt = 0
+    }
+}
+
+// another
+
 /**
  * @param {string[]} words
  * @return {number[]}
diff --git a/2440-create-components-with-same-value.js b/2440-create-components-with-same-value.js
index fc6e910c..06735c00 100644
--- a/2440-create-components-with-same-value.js
+++ b/2440-create-components-with-same-value.js
@@ -1,3 +1,68 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var componentValue = function(nums, edges) {
+  const n = nums.length;
+  if(n === 1) return 0;
+    const total = nums.reduce((a, b) => a + b, 0);
+    const g = Array.from({ length: n }, () => []);
+    const indegree = Array(n).fill(0);
+    for (const [u, v] of edges) {
+        g[u].push(v);
+        g[v].push(u);
+        indegree[u]++;
+        indegree[v]++;
+    }
+    const sums = []
+    for(let s = 1; s * s <= total; s++) {
+        if(total % s === 0) {
+            sums.push(s);
+            sums.push(total / s);
+        }
+    }
+    sums.sort((a, b) => a - b);
+    let res = 0
+    for(const s of sums) {
+      const ind = [...indegree];
+        const q = [];
+        const visited = Array(n).fill(false);
+        const sum = [...nums];
+        for(let i = 0; i < n; i++) {
+            if(ind[i] === 1) {
+                q.push(i);
+                visited[i] = true;
+            }
+        }
+        let flag = true;
+        while(q.length) {
+            const cur = q.shift();
+            if(sum[cur] > s) {
+                flag = false;
+                break;
+            } else if(sum[cur] === s) {
+                sum[cur] = 0
+            }
+            for(const next of g[cur]) {
+                if(visited[next]) continue;
+                sum[next] += sum[cur];
+                ind[next]--;
+                if(ind[next] === 1) {
+                    q.push(next);
+                    visited[next] = true;
+                }
+            }
+        }
+        if(flag) return total / s - 1;
+
+    }
+    return 0
+};
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @param {number[][]} edges
diff --git a/2488-count-subarrays-with-median-k.js b/2488-count-subarrays-with-median-k.js
index 54a7d129..fadcdcb5 100644
--- a/2488-count-subarrays-with-median-k.js
+++ b/2488-count-subarrays-with-median-k.js
@@ -25,3 +25,39 @@ const permutationArrayWithMedianK = (a, k) => {
   }
   return res;
 };
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var countSubarrays = function(nums, k) {
+  const n = nums.length;
+  for(let i = 0; i < n; i++) {
+    nums[i] = nums[i] < k ? -1 : nums[i] === k ? 0 : 1
+  }
+  const evenSum = {}
+  const oddSum = {}
+  evenSum[0] = 1
+    let sum = 0
+    let res = 0
+    for(let i = 0; i < n; i++) {
+        sum += nums[i]
+        if(i % 2 === 0) {
+            if(evenSum[sum] != null) res += evenSum[sum]
+            if(oddSum[sum - 1] != null) res += oddSum[sum - 1]
+            if(oddSum[sum] == null) oddSum[sum] = 0
+            oddSum[sum]++
+        } else {
+            if(oddSum[sum] != null) res += oddSum[sum]
+            if(evenSum[sum - 1] != null) res += evenSum[sum - 1]
+            if(evenSum[sum] == null) evenSum[sum] = 0
+            evenSum[sum]++
+        }
+    }
+ // console.log(evenSum, oddSum, nums)
+  return res
+};
diff --git a/2498-frog-jump-ii.js b/2498-frog-jump-ii.js
new file mode 100644
index 00000000..e9fc24fc
--- /dev/null
+++ b/2498-frog-jump-ii.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} stones
+ * @return {number}
+ */
+var maxJump = function(stones) {
+  let res = stones[1]-stones[0]; 
+  const {max} = Math
+  for(let i = 3; i < stones.length; i+=2) res = max(res, stones[i]-stones[i-2]);
+  for(let i = 2; i < stones.length; i+=2) res = max(res, stones[i]-stones[i-2]);
+  return res; 
+};
diff --git a/2499-minimum-total-cost-to-make-arrays-unequal.js b/2499-minimum-total-cost-to-make-arrays-unequal.js
new file mode 100644
index 00000000..a759f069
--- /dev/null
+++ b/2499-minimum-total-cost-to-make-arrays-unequal.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @return {number}
+ */
+var minimumTotalCost = function(nums1, nums2) {
+  const n = nums1.length, {floor, max} = Math
+  let res = 0
+  const freq = new Map()
+  let maxFreq = 0, maxFreqVal = 0, toSwap = 0
+  for(let i = 0; i < n; i++) {
+    if(nums1[i] === nums2[i]) {
+        const e = nums1[i]
+        freq.set(e, (freq.get(e) || 0) + 1)
+        res += i
+        const f = freq.get(e)
+        toSwap++
+        if(f > maxFreq) {
+            maxFreqVal = e
+        }
+        maxFreq = max(maxFreq, f)
+    }
+  }
+
+  for(let i = 0; i < n; i++) {
+    if(maxFreq > floor(toSwap / 2) && nums1[i] !== nums2[i] && nums1[i] !== maxFreqVal && nums2[i] !== maxFreqVal) {
+        toSwap++
+        res += i
+    }
+  }
+
+  if(maxFreq > floor(toSwap / 2)) return -1
+
+  return res
+};
diff --git a/2513-minimize-the-maximum-of-two-arrays.js b/2513-minimize-the-maximum-of-two-arrays.js
new file mode 100644
index 00000000..b894fd36
--- /dev/null
+++ b/2513-minimize-the-maximum-of-two-arrays.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number} divisor1
+ * @param {number} divisor2
+ * @param {number} uniqueCnt1
+ * @param {number} uniqueCnt2
+ * @return {number}
+ */
+var minimizeSet = function(divisor1, divisor2, uniqueCnt1, uniqueCnt2) {
+  let l = 1, r = 1e18
+  const {floor: flr} = Math
+  while(l < r) {
+    const mid = l + flr((r - l) / 2)
+    if(notEnough(mid)) l = mid + 1
+    else r = mid
+  } 
+  return l
+
+
+  function notEnough(n) {
+    const a = n - flr(n / divisor1)
+    const b = n - flr(n / divisor2)
+    const c = n - (flr(n / divisor1) + flr(n / divisor2) - flr( n / lcm(divisor1, divisor2)))
+    if(a < uniqueCnt1) return true
+    if(b < uniqueCnt2) return true
+    if(a + b - c < uniqueCnt1 + uniqueCnt2) return true
+    return false
+  }
+};
+
+function gcd(a, b) {
+    while (b !== 0) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+
+function lcm(a, b) {
+    return (a / gcd(a, b)) * b;
+}
+
+
+
diff --git a/2528-maximize-the-minimum-powered-city.js b/2528-maximize-the-minimum-powered-city.js
new file mode 100644
index 00000000..59d10ffd
--- /dev/null
+++ b/2528-maximize-the-minimum-powered-city.js
@@ -0,0 +1,38 @@
+/**
+ * @param {number[]} stations
+ * @param {number} r
+ * @param {number} k
+ * @return {number}
+ */
+var maxPower = function(stations, r, k) {
+  let lo = 0, hi = Number.MAX_SAFE_INTEGER
+  const { floor: flr, min } = Math
+  const n = stations.length
+  while(lo < hi) {
+    const mid = hi - flr((hi - lo) / 2)
+    if(isOk(stations.slice(0),k, mid)) lo = mid
+    else hi = mid - 1
+  }
+
+  return lo
+
+  function isOk(sc,k, m) {
+    let sum = 0
+    for(let i = 0; i < min(n, r); i++) {
+        sum += sc[i]
+    }
+    for(let i = 0; i < n; i++) {
+        if(i + r < n) sum += sc[i + r]
+        if(i - r - 1 >= 0) sum -= sc[i - r - 1]
+        if(sum >= m) continue
+        const diff = m - sum
+        if(k < diff) return false
+        sc[min(n - 1, i + r)] += diff
+        sum = m
+        k -= diff
+    }
+
+    return true
+  }
+
+};
diff --git a/2537-count-the-number-of-good-subarrays.js b/2537-count-the-number-of-good-subarrays.js
index 8eb898ce..59b89eff 100644
--- a/2537-count-the-number-of-good-subarrays.js
+++ b/2537-count-the-number-of-good-subarrays.js
@@ -81,3 +81,43 @@ const countGood = function(nums, k) {
   }
   return res;
 };
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const countGood = function(nums, k) {
+  let res = 0
+  let total = 0
+  let i = 0, j = 0
+  const n = nums.length
+  const cnt = {}
+  while(i < n) {
+    while(j < n && total < k) {
+      total += calc(cnt, nums[j], 1)
+      cnt[nums[j]] = (cnt[nums[j]] || 0) + 1
+      j++
+    }
+    if(total >= k) {
+        res += n - j + 1
+    }
+    total += calc(cnt, nums[i], -1)
+    cnt[nums[i]]--
+
+    i++
+  }
+  
+  return res
+
+  function calc(cnt, num, delta) {
+    const tmp = cnt[num] || 0
+    let res = tmp * (tmp - 1) / 2
+    const tmp1 = tmp + delta
+    const tmp2 = tmp1 * (tmp1 - 1) / 2
+    res = tmp2 - res
+    return res
+  }
+};
diff --git a/2563-count-the-number-of-fair-pairs.js b/2563-count-the-number-of-fair-pairs.js
index 3bdf0771..3db06363 100644
--- a/2563-count-the-number-of-fair-pairs.js
+++ b/2563-count-the-number-of-fair-pairs.js
@@ -38,3 +38,32 @@ function low(arr, target) {
     }
     return count;
 }
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {number}
+ */
+const countFairPairs = function(nums, lower, upper) {
+  nums.sort((a, b) => a - b)
+  return lowerBound(nums, upper + 1) - lowerBound(nums, lower)
+};
+
+function lowerBound(nums, value) {
+    let l = 0, r = nums.length - 1
+    let res = 0
+    while(l < r) {
+        const sum = nums[l] + nums[r]
+        if(sum < value) {
+            res += r - l
+            l++
+        } else {
+            r--
+        }
+    }
+
+    return res
+}
diff --git a/2576-find-the-maximum-number-of-marked-indices.js b/2576-find-the-maximum-number-of-marked-indices.js
index de2fe1c7..2672d5af 100644
--- a/2576-find-the-maximum-number-of-marked-indices.js
+++ b/2576-find-the-maximum-number-of-marked-indices.js
@@ -2,17 +2,16 @@
  * @param {number[]} nums
  * @return {number}
  */
-const maxNumOfMarkedIndices = function(nums) {
+var maxNumOfMarkedIndices = function(nums) {
   let res = 0
-  const n =  nums.length
+  const n = nums.length
   nums.sort((a, b) => a - b)
-  for(let i = 0, j = n - Math.floor(n / 2); j < n; j++) {
+  for(let i = 0, j = Math.floor((n + 1) / 2); j < n; j++) {
     if(nums[i] * 2 <= nums[j]) {
-      res += 2
-      i++
+        res += 2
+        i++
     }
   }
-  
   return res
 };
 
diff --git a/2577-minimum-time-to-visit-a-cell-in-a-grid.js b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
index 7412633f..765f81e5 100644
--- a/2577-minimum-time-to-visit-a-cell-in-a-grid.js
+++ b/2577-minimum-time-to-visit-a-cell-in-a-grid.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minimumTime = function(grid) {
+    if(grid[0][0] > 0) return -1
+      if(grid[0][1] > 1 && grid[1][0] > 1) return -1
+  const m = grid.length, n = grid[0].length;
+    const pq = new PQ((a, b) => a[0] < b[0]);
+    pq.push([0, 0, 0]);
+    const dirs = [[0, 1], [0, -1], [1, 0], [-1, 0]];
+    const dist = Array.from({ length: m }, () => Array(n).fill(-1));
+
+    while (!pq.isEmpty()) {
+        const [t, i, j] = pq.pop();
+        if (dist[i][j] !== -1) continue;
+        dist[i][j] = t
+        if (i === m - 1 && j === n - 1) break;
+        for(const [di, dj] of dirs) {
+            const ni = i + di, nj = j + dj;
+            if (ni < 0 || ni >= m || nj < 0 || nj >= n) continue;
+            if (dist[ni][nj] !== -1) continue;
+            if(grid[ni][nj] <= t + 1) {
+                pq.push([t + 1, ni, nj]);
+            } else if ((grid[ni][nj] - t) % 2 === 0) {
+                pq.push([grid[ni][nj] + 1, ni, nj]);
+            } else {
+                pq.push([grid[ni][nj], ni, nj]);
+            }
+        }
+    }
+
+    return dist[m - 1][n - 1];
+};
+
+
+// another
+
 class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []
diff --git a/2603-collect-coins-in-a-tree.js b/2603-collect-coins-in-a-tree.js
index 211e4335..7b174eb3 100644
--- a/2603-collect-coins-in-a-tree.js
+++ b/2603-collect-coins-in-a-tree.js
@@ -1,3 +1,69 @@
+/**
+ * @param {number[]} coins
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var collectTheCoins = function(coins, edges) {
+  let n = coins.length;
+  let next = Array.from({ length: n }, () => new Set());
+
+  let degree = new Array(n).fill(0);
+  for (let edge of edges) {
+    let a = edge[0],
+      b = edge[1];
+    next[a].add(b);
+    next[b].add(a);
+    degree[a]++;
+    degree[b]++;
+  }
+
+  let deleted = new Array(n).fill(0);
+  let q = [];
+  for (let i = 0; i < n; i++) {
+    if (degree[i] === 1 && coins[i] === 0) q.push(i);
+  }
+  while (q.length > 0) {
+    let len = q.length;
+    while (len--) {
+      let cur = q.shift();
+      deleted[cur] = 1;
+      for (let nxt of next[cur]) {
+        degree[nxt]--;
+        next[nxt].delete(cur);
+        if (degree[nxt] === 1 && coins[nxt] === 0) q.push(nxt);
+      }
+    }
+  }
+
+  let depth = new Array(n).fill(-1);
+  for (let i = 0; i < n; i++) {
+    if (degree[i] === 1 && deleted[i] === 0) {
+      q.push(i);
+      depth[i] = 1;
+    }
+  }
+  while (q.length > 0) {
+    let len = q.length;
+    while (len--) {
+      let cur = q.shift();
+      for (let nxt of next[cur]) {
+        degree[nxt]--;
+        next[nxt].delete(cur);
+        depth[nxt] = Math.max(depth[nxt], depth[cur] + 1);
+        if (degree[nxt] === 1) q.push(nxt);
+      }
+    }
+  }
+
+  let ret = 0;
+  for (let i = 0; i < n; i++) ret += depth[i] >= 3;
+
+  if (ret >= 1) return (ret - 1) * 2;
+  else return 0;
+};
+
+// another
+
 let a, cum, res, v, sum, g;
 const initializeGraph = (n) => { let g = []; for (let i = 0; i < n; i++) { g.push([]); } return g; };
 const packUG = (g, edges) => { for (const [u, v] of edges) { g[u].push(v); g[v].push(u); } };
diff --git a/2659-make-array-empty.js b/2659-make-array-empty.js
new file mode 100644
index 00000000..4bef4f3f
--- /dev/null
+++ b/2659-make-array-empty.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var countOperationsToEmptyArray = function(nums) {
+    const pos = new Map()
+    const n = nums.length
+    let res = n
+
+    for (let i = 0; i < n; ++i) {
+        pos.set(nums[i], i)
+    }
+
+    nums.sort((a, b) => a - b)
+
+    for (let i = 1; i < n; ++i) {
+        if (pos.get(nums[i]) < pos.get(nums[i - 1])) {
+            res += n - i
+        }
+    }
+
+    return res
+};
diff --git a/2662-minimum-cost-of-a-path-with-special-roads.js b/2662-minimum-cost-of-a-path-with-special-roads.js
index ecd4338c..0133ae63 100644
--- a/2662-minimum-cost-of-a-path-with-special-roads.js
+++ b/2662-minimum-cost-of-a-path-with-special-roads.js
@@ -1,3 +1,41 @@
+/**
+ * @param {number[]} start
+ * @param {number[]} target
+ * @param {number[][]} specialRoads
+ * @return {number}
+ */
+const minimumCost = function(start, target, specialRoads) {
+  const n = specialRoads.length;
+  let res = Infinity;
+  const pq = new PQ((a, b) => a[0] < b[0]);
+  const dist = Array(n).fill(Infinity);
+  const { abs } = Math;
+  for(let i = 0; i < n; i++) {
+    const [x, y, x2, y2, cost] = specialRoads[i];
+    dist[i] = abs(start[0] - x) + abs(start[1] - y) + cost;
+    pq.push([dist[i], i]);
+  }
+  res = abs(target[0] - start[0]) + abs(target[1] - start[1])
+  while(!pq.isEmpty()) {
+    const [d, i] = pq.pop();
+    if(d !== dist[i]) continue;
+    const e = specialRoads[i];
+    res = Math.min(res, d + abs(target[0] - e[2]) + abs(target[1] - e[3]));
+    for(let j = 0; j < n; j++) {
+      const w = abs(e[2] - specialRoads[j][0]) + abs(e[3] - specialRoads[j][1]) + specialRoads[j][4];
+      if(d + w < dist[j]) {
+        dist[j] = d + w;
+        pq.push([dist[j], j]);
+      }
+    }
+  }
+  
+  return res
+};
+
+// another
+
+
 class PQ {
   constructor(comparator = (a, b) => a > b) {
     this.heap = []
diff --git a/268-missing-number.js b/268-missing-number.js
index 69960ce7..56870d19 100755
--- a/268-missing-number.js
+++ b/268-missing-number.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var missingNumber = function(nums) {
+    nums.push(null)
+    const m = nums.length
+    
+    for(let i = 0; i < m; i++) {
+        while(nums[i] >= 0 && nums[i] <= m - 1 && nums[i] !== nums[nums[i]]) {
+            swap(nums, i, nums[i])
+        }
+        
+    }
+    
+    for(let i = 0; i < m; i++) {
+        if(nums[i] !== i) return i
+    }
+    return m
+
+    function swap(arr, i, j) {
+        ;[nums[i], nums[j]] = [nums[j], nums[i]]
+    }
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number}
diff --git a/2719-count-of-integers.js b/2719-count-of-integers.js
new file mode 100644
index 00000000..0dae13c5
--- /dev/null
+++ b/2719-count-of-integers.js
@@ -0,0 +1,59 @@
+/**
+ * @param {string} num1
+ * @param {string} num2
+ * @param {number} min_sum
+ * @param {number} max_sum
+ * @return {number}
+ */
+const count = function (num1, num2, min_sum, max_sum) {
+  const mod = 1e9 + 7
+  let res = 0
+  res =
+    (cntNoGreater(num2, max_sum) - cntNoGreater(num2, min_sum - 1) + mod) % mod -
+    (cntNoGreater(num1, max_sum) - cntNoGreater(num1, min_sum - 1) + mod) % mod
+  res = (res + mod) % mod
+  const sum1 = calc(num1)
+  if (sum1 >= min_sum && sum1 <= max_sum) {
+    res = (res + 1) % mod
+  }
+
+  return res
+
+  function cntNoGreater(num, maxSum) {
+    const memo = Array.from({ length: 2 }, () =>
+      Array.from({ length: 23 }, () => Array(401).fill(-1))
+    )
+    return dfs(num, maxSum, 0, 0, 1, memo)
+  }
+  function dfs(num, maxSum, idx, sum, isSame, memo) {
+    if(sum > maxSum) {
+      return 0
+    }
+    if (idx === num.length) {
+      return 1
+    }
+    if(memo[isSame][idx][sum] !== -1) {
+      return memo[isSame][idx][sum]
+    }
+    let res = 0
+    if(isSame) {
+        for(let i = 0; i < num[idx]; i++) {
+            res = (res + dfs(num, maxSum, idx + 1, sum + i, 0, memo)) % mod
+        }
+        res = (res + dfs(num, maxSum, idx + 1, sum + +num[idx], 1, memo)) % mod
+    } else {
+        for (let i = 0; i <= 9; i++) {
+            res = (res + dfs(num, maxSum, idx + 1, sum + i, 0, memo)) % mod
+        }
+    }
+
+    return memo[isSame][idx][sum] = res
+  }
+  function calc(num) {
+    let res = 0
+    for (const e of num) {
+      res += +e
+    }
+    return res
+  }
+}
diff --git a/2745-construct-the-longest-new-string.js b/2745-construct-the-longest-new-string.js
index 523bcf91..cc895595 100644
--- a/2745-construct-the-longest-new-string.js
+++ b/2745-construct-the-longest-new-string.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+var longestString = function(x, y, z) {
+  // x + y
+  // y + x
+  // y + z
+  // z + z
+  let res = 0
+  const {min} = Math
+  const minXY = min(x, y)
+  if(x === y) res = 2 * x + 2 * y + 2 * z
+  else {
+    res = (minXY * 2 + (minXY + 1) * 2 + 2 * z)
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number} x
  * @param {number} y
diff --git a/2768-number-of-black-blocks.js b/2768-number-of-black-blocks.js
index 241fd1fe..6f299cd7 100644
--- a/2768-number-of-black-blocks.js
+++ b/2768-number-of-black-blocks.js
@@ -1,3 +1,38 @@
+/**
+ * @param {number} m
+ * @param {number} n
+ * @param {number[][]} coordinates
+ * @return {number[]}
+ */
+var countBlackBlocks = function(m, n, coordinates) {
+  
+  const map = new Map();
+    for (const [x, y] of coordinates) {
+        for(let i = x - 1; i <= x; i++) {
+            for(let j = y - 1; j <= y; j++) {
+                if(i >= 0 && j >= 0 && i < m - 1 && j < n - 1) {
+                    const key = encode(i, j);
+                    map.set(key, (map.get(key) || 0) + 1);
+                }
+            }
+        }
+    }
+    const res = Array(5).fill(0);
+    for (const count of map.values()) {
+        res[count]++;
+    }
+
+    res[0] = (m - 1) * (n - 1) - res[1] - res[2] - res[3] - res[4];
+    return res;
+
+  function encode(x, y) {
+    return x * n + y;
+  }
+};
+
+// another
+
+
 /**
  * @param {number} m
  * @param {number} n
diff --git a/2801-count-stepping-numbers-in-range.js b/2801-count-stepping-numbers-in-range.js
index 27af38b6..17ea13df 100644
--- a/2801-count-stepping-numbers-in-range.js
+++ b/2801-count-stepping-numbers-in-range.js
@@ -109,3 +109,65 @@ const countSteppingNumbers = (low, high) => {
     return minus_mod(x, y, mod);
 };
 
+// another
+
+
+/**
+ * @param {string} low
+ * @param {string} high
+ * @return {number}
+ */
+const countSteppingNumbers = function(low, high) {
+  const mod = 1e9 + 7
+  let res = 0
+  res = (helper(high) - helper(low) + isSteppingNumber(low) + mod) % mod
+
+  return res
+
+  function helper(num) {
+    let res = 0
+    const n = num.length
+    const memo = Array.from({ length: 2 }, () => Array.from({ length: 11 }, () => Array.from({ length: n + 1 }, () => -1)))
+    for (let len = 1; len < n; len++) {
+        for(let i = 1; i < 10; i++){
+          res = (res + dfs(len - 1, i, false, num, memo)) % mod
+        }
+    }
+    const d = num[0] - '0'
+    for(let i = 1; i < d; i++){
+      res = (res + dfs(n - 1, i, false, num, memo)) % mod
+    }
+    res = (res + dfs(n - 1, d, true, num, memo)) % mod
+    return res
+  }
+  function dfs(len, prev, isSame, num, memo) {
+    if(len === 0) return 1
+    if(memo[+isSame][prev][len] !== -1) return memo[+isSame][prev][len]
+    let res = 0
+    if(isSame){
+        const d = num[num.length - len] - '0'
+        if(prev + 1 < d) res = (res + dfs(len - 1, prev + 1, false, num, memo)) % mod
+        else if(prev + 1 === d) res = (res + dfs(len - 1, prev + 1, true, num, memo)) % mod
+        if(prev - 1 >= 0 && prev - 1 < d) res = (res + dfs(len - 1, prev - 1, false, num, memo)) % mod
+        else if(prev - 1 === d) res = (res + dfs(len - 1, prev - 1, true, num, memo)) % mod
+
+
+    } else {
+        if(prev + 1 < 10) res = (res + dfs(len - 1, prev + 1, false, num, memo)) % mod
+        if(prev - 1 >= 0) res = (res + dfs(len - 1, prev - 1, false, num, memo)) % mod
+    }
+
+    memo[+isSame][prev][len] = res
+
+    return res
+  }
+  function isSteppingNumber(num){
+    if(num.length === 1) return 1
+    for(let i = 1; i < num.length; i++){
+      if(Math.abs(num[i] - num[i - 1]) !== 1) return 0
+    }
+    return 1
+  }
+};
+
+
diff --git a/2857-count-pairs-of-points-with-distance-k.js b/2857-count-pairs-of-points-with-distance-k.js
index bff65742..e85d888c 100644
--- a/2857-count-pairs-of-points-with-distance-k.js
+++ b/2857-count-pairs-of-points-with-distance-k.js
@@ -1,3 +1,34 @@
+/**
+ * @param {number[][]} coordinates
+ * @param {number} k
+ * @return {number}
+ */
+var countPairs = function(coordinates, k) {
+    const map = new Map();
+    const n = coordinates.length;
+    const MUL = 1e6
+    let res = 0;
+    for(let i = 0; i < n; i++) {
+        const [x, y] = coordinates[i];
+        for(let e = 0; e <= k; e++) {
+            const x2 = x ^ e;
+            const y2 = (k - e) ^ y;
+            const key = code(x2, y2);
+            res += map.get(key) || 0;
+        }
+        const key = code(x, y);
+        map.set(key, (map.get(key) || 0) + 1);
+    }
+
+    return res
+
+    function code(x, y) {
+        return x * MUL + y
+    }
+};
+
+// another
+
 /**
  * @param {number[][]} coordinates
  * @param {number} k
diff --git a/2861-maximum-number-of-alloys.js b/2861-maximum-number-of-alloys.js
index d5c0891b..41c009ed 100644
--- a/2861-maximum-number-of-alloys.js
+++ b/2861-maximum-number-of-alloys.js
@@ -7,40 +7,35 @@
  * @param {number[]} cost
  * @return {number}
  */
-var maxNumberOfAlloys = function (n, k, budget, composition, stock, cost) {
-  let low = 1,
+const maxNumberOfAlloys = function(n, k, budget, composition, stock, cost) {
+  let low = 0,
     high = 1e9
-  let ans = 0 // intialise the ans = 0;
+  let res = 0
 
-  while (low <= high) {
-    let mid = low + Math.floor((high - low) / 2)
+  while (low < high) {
+    let mid = high - Math.floor((high - low) / 2)
     if (isPossible(n, k, budget, composition, stock, cost, mid)) {
-      low = mid + 1
-      ans = mid // we can form the "mid" quantity of alloys from any of the compositions in the given "budget";
+      low = mid
     } else {
       high = mid - 1
     }
   }
 
-  return ans
-}
+  return low  
+};
+
 function isPossible(n, k, budget, composition, stock, costs, fixed_alloy) {
   for (let i = 0; i < k; i++) {
     let calBudget = 0
     for (let j = 0; j < n; j++) {
-      // this much quantity of jth metal is required to form the "fixed_alloy";
       let required = 1 * composition[i][j] * fixed_alloy
-      // subtracting the stocked portion of the jth metal;
       required -= stock[j]
       if (required > 0) {
-        // adding the cost for required quantity of jth metal to form the "fixed_alloy";
         calBudget += 1 * required * costs[j]
       }
     }
-    // "fixed alloy can be formed with the ith machine";
     if (calBudget <= 1 * budget) return true
   }
 
-  // can't be formed with any of the machine;
   return false
 }
diff --git a/2949-count-beautiful-substrings-ii.js b/2949-count-beautiful-substrings-ii.js
index e1f8c0b0..a9497f70 100644
--- a/2949-count-beautiful-substrings-ii.js
+++ b/2949-count-beautiful-substrings-ii.js
@@ -1,27 +1,73 @@
+const set = new Set(['a', 'e', 'i', 'o', 'u']);
 /**
  * @param {string} s
  * @param {number} k
  * @return {number}
  */
 var beautifulSubstrings = function(s, k) {
-    let ans = 0, cur = 0;
-    let mp = new Map();
-    mp.set(0, [-1]);
-    for (let i = 0; i < s.length; i++) {
-        let ch = s[i];
-        if (ch === 'a' || ch === 'e' || ch === 'i' || ch === 'o' || ch === 'u') {
-            cur++;
+    const primes = Eratosthenes(k);
+    let m = 1;
+
+    for (const p of primes) {
+        let count = 0;
+        while (k % p === 0) {
+            count++;
+            k /= p;
+        }
+        if (count !== 0 && count % 2 === 1) {
+            m *= Math.pow(p, (count + 1) / 2);
+        } else if (count !== 0 && count % 2 === 0) {
+            m *= Math.pow(p, count / 2);
+        }
+    }
+    m *= 2;
+
+    const n = s.length;
+    s = '#' + s; // Prepend a character to ensure 1-based indexing
+    let ret = 0;
+
+    const map = new Map();
+    map.set(0, new Map());
+    map.get(0).set(0, 1);
+
+    let count = 0;
+
+    for (let i = 1; i <= n; i++) {
+        if (set.has(s[i])) {
+            count++;
         } else {
-            cur--;
+            count--;
+        }
+
+        if (map.has(count) && map.get(count).has(i % m)) {
+            ret += map.get(count).get(i % m);
         }
-        for (let x of (mp.get(cur) || []) ) {
-            let d = (i - x) / 2;
-            if (Math.pow(d, 2) % k === 0) {
-                ans++;
-            }
+
+        if (!map.has(count)) {
+            map.set(count, new Map());
         }
-        if (!mp.has(cur)) mp.set(cur, []);
-        mp.get(cur).push(i);
+        map.get(count).set(i % m, (map.get(count).get(i % m) || 0) + 1);
     }
-    return ans;
+
+    return ret;
 };
+
+function Eratosthenes(n) {
+    const q = Array(n + 1).fill(0);
+    const primes = [];
+
+    for (let i = 2; i <= Math.sqrt(n); i++) {
+        if (q[i] === 1) continue;
+        for (let j = i * 2; j <= n; j += i) {
+            q[j] = 1;
+        }
+    }
+
+    for (let i = 2; i <= n; i++) {
+        if (q[i] === 0) {
+            primes.push(i);
+        }
+    }
+
+    return primes;
+}
diff --git a/3-longest-substring-without-repeating-characters.js b/3-longest-substring-without-repeating-characters.js
index d345eadf..773dc4ff 100755
--- a/3-longest-substring-without-repeating-characters.js
+++ b/3-longest-substring-without-repeating-characters.js
@@ -40,6 +40,36 @@ const lengthOfLongestSubstring = function(s) {
 
 // another
 
+/**
+ * @param {string} s
+ * @return {number}
+ */
+const lengthOfLongestSubstring = function(s) {
+    const n = s.length, hash = {}
+    let res = 0
+    let l = 0, r = 0
+    while(r < n) {
+        const ch = s[r]
+        if(hash[ch] == null) hash[ch] = 0
+        hash[ch]++
+        while(hash[s[l]] > 1) {
+            hash[s[l]]--
+            l++
+        }
+        while(l <= r && Object.keys(hash).length !== r - l + 1) {
+            hash[s[l]]--
+            if(hash[s[l]] === 0) delete hash[s[l]]
+            l++
+        }
+        res = Math.max(res, r - l + 1)
+        r++
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @return {number}
diff --git a/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js b/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js
new file mode 100644
index 00000000..11d26787
--- /dev/null
+++ b/3007-maximum-number-that-sum-of-the-prices-is-less-than-or-equal-to-k.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number} k
+ * @param {number} x
+ * @return {number}
+ */
+var findMaximumNumber = function(k, x) {
+    let l = 0n;
+    let r = 10n ** 20n;
+
+    while (l + 1n < r) {
+        let m = (l + r) >> 1n;
+
+        if (F(Number(m + 1n)) <= k) l = m;
+        else r = m;
+    }
+
+    return Number(l);
+
+    function F(m) {
+        let count = 0;
+
+        for (let i = 1; i < 80; i++) {
+            let bit = (i * x) - 1;
+            let S = 1n << BigInt(bit);
+            let B = BigInt(m) / S;
+
+            count += Number(S) * Math.floor(Number(B) / 2);
+            if ((Number(B) & 1) === 1) {
+                count += Number(BigInt(m) % S);
+            }
+        }
+
+        return count;
+    }
+};
diff --git a/3017-count-the-number-of-houses-at-a-certain-distance-ii.js b/3017-count-the-number-of-houses-at-a-certain-distance-ii.js
new file mode 100644
index 00000000..d4561058
--- /dev/null
+++ b/3017-count-the-number-of-houses-at-a-certain-distance-ii.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number} n
+ * @param {number} x
+ * @param {number} y
+ * @return {number[]}
+ */
+var countOfPairs = function (n, x, y) {
+  if (x > y) {
+    ;[x, y] = [y, x]
+  }
+  const res = new Array(n).fill(0)
+  for (let i = 1; i <= n; ++i) {
+    res[0] += 2 // go left and right
+    res[Math.min(i - 1, Math.abs(i - y) + x)]-- // reach 1 then stop
+    res[Math.min(n - i, Math.abs(i - x) + 1 + n - y)]-- // reach n then stop
+    res[Math.min(Math.abs(i - x), Math.abs(y - i) + 1)]++ // reach x then split
+    res[Math.min(Math.abs(i - x) + 1, Math.abs(y - i))]++ // reach y then split
+    let r = Math.max(x - i, 0) + Math.max(i - y, 0)
+    res[r + Math.floor((y - x) / 2)]-- // i -> x -> y <- x
+    res[r + Math.floor((y - x + 1) / 2)]-- // i -> y -> x <- y
+  }
+  for (let i = 1; i < n; ++i) {
+    res[i] += res[i - 1]
+  }
+  return res
+}
diff --git a/3076-shortest-uncommon-substring-in-an-array.js b/3076-shortest-uncommon-substring-in-an-array.js
index 9a5ad533..5f202f58 100644
--- a/3076-shortest-uncommon-substring-in-an-array.js
+++ b/3076-shortest-uncommon-substring-in-an-array.js
@@ -1,3 +1,132 @@
+/**
+ * @param {string[]} arr
+ * @return {string[]}
+ */
+const shortestSubstrings = function (arr) {
+  const root = new Node()
+  const res = []
+  for (const s of arr) {
+    for (let i = 0; i < s.length; ++i) {
+      add(root, s, i)
+    }
+  }
+  for (const s of arr) {
+    const tmpRoot = new Node()
+    let resStr = s + s
+    for (let i = 0; i < s.length; ++i) {
+      add(tmpRoot, s, i)
+    }
+
+    for (let i = 0; i < s.length; ++i) {
+      const t = check(root, tmpRoot, s, i)
+      if (
+        t.length < resStr.length ||
+        (t.length === resStr.length && t < resStr)
+      ) {
+        resStr = t
+      }
+    }
+    res.push(resStr.length <= s.length ? resStr : "")
+  }
+
+  return res
+  function add(node, str, start) {
+    let ptr = node
+    for (let i = start; i < str.length; ++i) {
+      const c = str.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) ptr.child[c] = new Node()
+      ptr = ptr.child[c]
+      ptr.count++
+    }
+  }
+  function check(root, node, str, start) {
+    let ptr1 = root
+    let ptr2 = node
+    let res = ""
+    for (let i = start; i < str.length; ++i) {
+      const chIdx = str.charCodeAt(i) - "a".charCodeAt(0)
+      res += str[i]
+      ptr1 = ptr1.child[chIdx]
+      ptr2 = ptr2.child[chIdx]
+      if (ptr1.count === ptr2.count) return res
+    }
+    return str + str
+  }
+}
+class Node {
+  constructor() {
+    this.child = new Array(26).fill(null)
+    this.count = 0
+  }
+}
+
+// another
+
+/**
+ * @param {string[]} arr
+ * @return {string[]}
+ */
+const shortestSubstrings = function (arr) {
+  const ans = []
+  const head = new Node()
+  for (const s of arr) {
+    for (let i = 0; i < s.length; ++i) add(head, s, i)
+  }
+  for (const s of arr) {
+    let res = s + s
+    for (let i = 0; i < s.length; ++i) remove(head, s, i)
+    for (let i = 0; i < s.length; ++i) {
+      const t = check(head, s, i)
+      if (t.length < res.length || (t.length === res.length && t < res)) res = t
+    }
+    ans.push(res.length <= s.length ? res : "")
+     // add back the current string to the trie
+    for (let i = 0; i < s.length; ++i) add(head, s, i)
+  }
+  return ans
+
+  function add(head, s, ind) {
+    let ptr = head
+    for (let i = ind; i < s.length; ++i) {
+      const c = s.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) ptr.child[c] = new Node()
+      ptr = ptr.child[c]
+      ptr.count++
+    }
+  }
+
+  function remove(head, s, ind) {
+    let ptr = head
+    for (let i = ind; i < s.length; ++i) {
+      ptr = ptr.child[s.charCodeAt(i) - "a".charCodeAt(0)]
+      ptr.count--
+    }
+  }
+
+  function check(head, s, ind) {
+    let ptr = head
+    let ans = ""
+    for (let i = ind; i < s.length; ++i) {
+      const c = s.charCodeAt(i) - "a".charCodeAt(0)
+      if (ptr.child[c] === null) return ans
+      ans += s[i]
+      ptr = ptr.child[c]
+      if (ptr.count < 1) return ans
+    }
+    return s + s
+  }
+}
+
+class Node {
+  constructor() {
+    this.child = new Array(26).fill(null)
+    this.count = 0
+  }
+}
+
+// another
+
+
 /**
  * @param {string[]} arr
  * @return {string[]}
diff --git a/3093-longest-common-suffix-queries.js b/3093-longest-common-suffix-queries.js
new file mode 100644
index 00000000..1866b181
--- /dev/null
+++ b/3093-longest-common-suffix-queries.js
@@ -0,0 +1,54 @@
+/**
+ * @param {string[]} wordsContainer
+ * @param {string[]} wordsQuery
+ * @return {number[]}
+ */
+const stringIndices = function (wordsContainer, wordsQuery) {
+  const root = new TrieNode()
+  const arr = []
+  for (let i = 0; i < wordsContainer.length; i++) {
+    arr.push({ word: wordsContainer[i], index: i })
+  }
+  arr.sort((a, b) => {
+    if (a.word.length !== b.word.length) return a.word.length - b.word.length
+    else return a.index - b.index
+  })
+  for (let i = arr.length - 1; i >= 0; i--) {
+    let node = root
+    const s = arr[i].word
+    for (let j = s.length - 1; j >= 0; j--) {
+      const charIndex = s[j].charCodeAt(0) - 'a'.charCodeAt(0)
+      if (node.next[charIndex] === null) {
+        node.next[charIndex] = new TrieNode()
+      }
+      node = node.next[charIndex]
+      node.idx = arr[i].index
+    }
+  }
+  root.idx = arr[0].index
+  const res = []
+  for (const query of wordsQuery) {
+    let node = root
+    let ans = -1
+    for (let i = query.length - 1; i >= 0; i--) {
+      const charIndex = query[i].charCodeAt(0) - 'a'.charCodeAt(0)
+      if (node.next[charIndex] !== null) {
+        node = node.next[charIndex]
+      } else {
+        break
+      }
+    }
+
+    ans = node.idx
+
+    res.push(ans)
+  }
+  return res
+}
+
+class TrieNode {
+  constructor() {
+    this.next = new Array(26).fill(null)
+    this.idx = -1
+  }
+}
diff --git a/310-minimum-height-trees.js b/310-minimum-height-trees.js
index eeaa1111..9bdaed7f 100644
--- a/310-minimum-height-trees.js
+++ b/310-minimum-height-trees.js
@@ -1,3 +1,53 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number[]}
+ */
+var findMinHeightTrees = function(n, edges) {
+  if(n === 1) return [0]
+  if(n === 2) return [0, 1]
+  const g = {}
+  const degree = new Array(n).fill(0)
+  for(const [u, v] of edges) {
+    degree[u]++
+    degree[v]++
+    if(g[u] == null) g[u] = []
+    if(g[v] == null) g[v] = []
+    g[u].push(v)
+    g[v].push(u)
+  }
+  let q = []
+  for(let i = 0; i < n; i++) {
+    if(degree[i] === 1) q.push(i)
+  }
+  let cnt = 0 
+  while(q.length) {
+    const size = q.length
+    const tmp = []
+    for(let i = 0; i < size; i++) {
+        const node = q[i]
+        cnt++
+        for(const nxt of (g[node] || [])) {
+            degree[nxt]--
+            if(degree[nxt] === 1) {
+                tmp.push(nxt)
+            }
+        }
+    }
+    
+    q = tmp
+    if(n - cnt <= 2) break
+  }
+  
+  const res = []
+  while(q.length) {
+    res.push(q.pop())
+  }
+  return res
+};
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} edges
diff --git a/3112-minimum-time-to-visit-disappearing-nodes.js b/3112-minimum-time-to-visit-disappearing-nodes.js
index 96acaeeb..ec24d5cc 100644
--- a/3112-minimum-time-to-visit-disappearing-nodes.js
+++ b/3112-minimum-time-to-visit-disappearing-nodes.js
@@ -1,3 +1,35 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} disappear
+ * @return {number[]}
+ */
+const minimumTime = function(n, edges, disappear) {
+  const g = Array.from({ length: n }, () => [])
+    for (const [u, v, w] of edges) {
+        g[u].push([v, w])
+        g[v].push([u, w])
+    }
+    const pq = new PQ((a, b) => a[1] < b[1])
+    pq.push([0, 0])
+    const res = Array(n).fill(-1)
+    while(!pq.isEmpty()) {
+        const [u, t] = pq.pop()
+        if (res[u] !== -1) continue
+        res[u] = t
+        for(const [v, w] of g[u]) {
+            if (res[v] === -1 && t + w < disappear[v]) {
+                pq.push([v, t + w])
+            }
+        }
+    }
+
+    return res
+};
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges
diff --git a/3123-find-edges-in-shortest-paths.js b/3123-find-edges-in-shortest-paths.js
index 670b3013..3694b4ad 100644
--- a/3123-find-edges-in-shortest-paths.js
+++ b/3123-find-edges-in-shortest-paths.js
@@ -1,3 +1,62 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {boolean[]}
+ */
+const findAnswer = function (n, edges) {
+  const m = edges.length
+  const res = Array(m).fill(false)
+  const MAX = Number.MAX_SAFE_INTEGER
+  const g = Array(n)
+    .fill(null)
+    .map(() => [])
+  for (const [u, v, w] of edges) {
+    g[u].push([v, w])
+    g[v].push([u, w])
+  }
+  const dist = Array(n).fill(MAX)
+  dist[0] = 0
+  const pq = new PQ((a, b) => a[1] < b[1])
+  pq.push([0, 0])
+  while (!pq.isEmpty()) {
+    const [u, d] = pq.pop()
+    if (d > dist[u]) continue
+    for (const [v, w] of g[u]) {
+      if (dist[v] > d + w) {
+        dist[v] = d + w
+        pq.push([v, dist[v]])
+      }
+    }
+  }
+  const dist1 = Array(n).fill(MAX)
+  dist1[n - 1] = 0
+  pq.push([n - 1, 0])
+  while (!pq.isEmpty()) {
+    const [u, d] = pq.pop()
+    if (d > dist1[u]) continue
+    for (const [v, w] of g[u]) {
+      if (dist1[v] > d + w) {
+        dist1[v] = d + w
+        pq.push([v, dist1[v]])
+      }
+    }
+  }
+  for (let i = 0; i < m; i++) {
+    const [u, v, w] = edges[i]
+    if (
+      dist[u] + dist1[v] + w === dist[n - 1] ||
+      dist[v] + dist1[u] + w === dist[n - 1]
+    ) {
+      res[i] = true
+    }
+  }
+
+  return res
+}
+
+// another
+
+
 /**
  * @param {number} n
  * @param {number[][]} edges
diff --git a/3134-find-the-median-of-the-uniqueness-array.js b/3134-find-the-median-of-the-uniqueness-array.js
index 9e7dce3c..0bdfa43b 100644
--- a/3134-find-the-median-of-the-uniqueness-array.js
+++ b/3134-find-the-median-of-the-uniqueness-array.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const medianOfUniquenessArray = function(nums) {
+  const n = nums.length;
+  const {floor} = Math;
+  const total = (n * (n + 1)) / 2;
+  const half = floor((total + 1) / 2);
+  let l = 1, r = n
+  while(l < r) {
+    const mid = l + floor((r - l) / 2);
+    if (atMostK(nums, mid) >= half) {
+      r = mid;
+    } else {
+      l = mid + 1;
+    }
+  }
+  return l
+
+  function atMostK(nums, k) {
+    const hash = new Map(), n = nums.length;
+    let res = 0
+    let i = 0, j = 0
+    while(j < n) {
+        const e = nums[j]
+        if(!hash.has(e)) hash.set(e, 0)
+        hash.set(e, hash.get(e) + 1)
+        while(i < j && hash.size > k) {
+            
+            hash.set(nums[i], hash.get(nums[i]) - 1)
+            if(hash.get(nums[i]) === 0) {
+                hash.delete(nums[i])
+            }
+            i++
+        }
+        res += j - i + 1
+
+        j++
+    }
+
+    return res
+  }
+};
+
+
+// another
+
+
 /**
  * @param {number[]} nums
  * @return {number}
diff --git a/3209-number-of-subarrays-with-and-value-of-k.js b/3209-number-of-subarrays-with-and-value-of-k.js
index 9a46894b..64a0b79b 100644
--- a/3209-number-of-subarrays-with-and-value-of-k.js
+++ b/3209-number-of-subarrays-with-and-value-of-k.js
@@ -3,44 +3,44 @@
  * @param {number} k
  * @return {number}
  */
-var countSubarrays = function (nums, k) {
-  return atLeastK(nums, k) - atLeastK(nums, k + 1)
-}
+var countSubarrays = function(nums, k) {
+  return atLeastK(nums, k) - atLeastK(nums, k + 1); 
+};
 
 function atLeastK(nums, k) {
-  let ans = 0
-  let temp = new Array(32).fill(0)
+    let res = 0;
+    let temp = new Array(32).fill(0);
 
-  let l = 0
-  for (let r = 0; r < nums.length; r++) {
-    for (let i = 0; i < 32; i++) {
-      if ((1 << i) & nums[r]) {
-        temp[i]++
-      }
-    }
+    let l = 0;
+    for (let r = 0; r < nums.length; r++) {
+        for (let i = 0; i < 32; i++) {
+            if ((1 << i) & nums[r]) {
+                temp[i]++;
+            }
+        }
 
-    while (r - l + 1 > 0 && calc(temp, r - l + 1) < k) {
-      for (let i = 0; i < 32; i++) {
-        if ((1 << i) & nums[l]) {
-          temp[i]--
+        while ((r - l + 1) > 0 && calc(temp, r - l + 1) < k) {
+            for (let i = 0; i < 32; i++) {
+                if ((1 << i) & nums[l]) {
+                    temp[i]--;
+                }
+            }
+            l++;
         }
-      }
-      l++
+        res += (r - l + 1);
     }
-    ans += r - l + 1
-  }
 
-  return ans
+    return res;
 }
 
 // function to calculate the AND from frequency vector
 function calc(temp, w) {
-  let ans = 0
-  for (let i = 0; i < 32; i++) {
-    if (temp[i] === w) {
-      ans += 1 << i
+    let res = 0;
+    for (let i = 0; i < 32; i++) {
+        if (temp[i] === w) {
+            res += (1 << i);
+        }
     }
-  }
 
-  return ans
+    return res;
 }
diff --git a/3258-count-substrings-that-satisfy-k-constraint-i.js b/3258-count-substrings-that-satisfy-k-constraint-i.js
new file mode 100644
index 00000000..04445896
--- /dev/null
+++ b/3258-count-substrings-that-satisfy-k-constraint-i.js
@@ -0,0 +1,57 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+const countKConstraintSubstrings = function (s, k) {
+  const n = s.length
+  let res = 0,
+    l = 0,
+    r = 0,
+    zero = 0,
+    one = 0
+  while (r < n) {
+    if (s[r] === "0") zero++
+    else one++
+    while (zero > k && one > k) {
+      if (s[l] === "0") zero--
+      else one--
+      l++
+    }
+    res += r - l + 1
+    r++
+  }
+
+  return res
+}
+
+// another
+
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var countKConstraintSubstrings = function(s, k) {
+  let res = 0
+  const n = s.length
+  for(let len = 1; len <= n; len++) {
+    for(let j = 0; j + len <= n; j++) {
+      const sub = s.slice(j, j + len)
+      if(valid(sub)) res++
+    }
+  }
+  
+  return res
+  
+  function valid(str) {
+    let one = 0
+    const n = str.length
+    for(const e of str) {
+      if(e === '1') one++
+    }
+    
+    return one <= k || n - one <= k 
+  }
+};
diff --git a/3276-select-cells-in-grid-with-maximum-score.js b/3276-select-cells-in-grid-with-maximum-score.js
new file mode 100644
index 00000000..bdb2ac33
--- /dev/null
+++ b/3276-select-cells-in-grid-with-maximum-score.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var maxScore = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+  const values = []
+
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      values.push([grid[i][j], i, j])
+    }
+  }
+
+  values.sort((a, b) => b[0] - a[0])
+  const dp = {}
+
+  return recur(values, 0, 0, dp)
+}
+
+function recur(values, idx, mask_row, dp) {
+  const n = values.length
+  if (idx === n) return 0
+
+  const key = `${idx},${mask_row}`
+  if (key in dp) return dp[key]
+
+  let ans = 0
+  const row = values[idx][1]
+  if ((1 << row) & mask_row) {
+    ans += recur(values, idx + 1, mask_row, dp)
+  } else {
+    let j = idx
+    while (j < n && values[idx][0] === values[j][0]) j++
+
+    const ans1 = values[idx][0] + recur(values, j, mask_row | (1 << row), dp)
+    const ans2 = recur(values, idx + 1, mask_row, dp)
+
+    ans = Math.max(ans1, ans2)
+  }
+
+  dp[key] = ans
+  return ans
+}
diff --git a/3290-maximum-multiplication-score.js b/3290-maximum-multiplication-score.js
new file mode 100644
index 00000000..ed6eb065
--- /dev/null
+++ b/3290-maximum-multiplication-score.js
@@ -0,0 +1,17 @@
+/**
+ * @param {number[]} a
+ * @param {number[]} b
+ * @return {number}
+ */
+var maxScore = function(a, b) {
+   const dp = Array(4).fill(-4 * 1e5 * 1e5)
+   const {max} = Math
+   for(const e of b) {
+     dp[3] = max(dp[3], dp[2] + e * a[3])
+     dp[2] = max(dp[2], dp[1] + e * a[2])
+     dp[1] = max(dp[1], dp[0] + e * a[1])
+     dp[0] = max(dp[0], e * a[0])
+   }
+
+   return dp[3] 
+};
diff --git a/3291-minimum-number-of-valid-strings-to-form-target-i.js b/3291-minimum-number-of-valid-strings-to-form-target-i.js
new file mode 100644
index 00000000..ed0ec089
--- /dev/null
+++ b/3291-minimum-number-of-valid-strings-to-form-target-i.js
@@ -0,0 +1,41 @@
+  class TrieNode {
+    constructor() {
+      this.children = new Array(26).fill(null)
+    }
+  }
+/**
+ * @param {string[]} words
+ * @param {string} target
+ * @return {number}
+ */
+var minValidStrings = function(words, target) {
+  const n = target.length
+  const dp = new Array(n + 1).fill(Infinity)
+  dp[0] = 0
+
+  const a = 'a'.charCodeAt(0)
+  const root = new TrieNode()
+  for (const word of words) {
+    let node = root
+    for (const c of word) {
+      const index = c.charCodeAt(0) - a
+      if (!node.children[index]) {
+        node.children[index] = new TrieNode()
+      }
+      node = node.children[index]
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (dp[i] === Infinity) continue
+    let node = root
+    for (let j = i; j < n; j++) {
+      const index = target[j].charCodeAt(0) - a
+      if (!node.children[index]) break
+      node = node.children[index]
+      dp[j + 1] = Math.min(dp[j + 1], dp[i] + 1)
+    }
+  }
+
+  return dp[n] === Infinity ? -1 : dp[n]
+};
diff --git a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
index 6c77b42b..9de78eab 100644
--- a/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
+++ b/3298-count-substrings-that-can-be-rearranged-to-contain-a-string-ii.js
@@ -1,3 +1,69 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const validSubstringCount = function(word1, word2) {
+  const n = word1.length;
+  const target = Array(26).fill(0);
+  const a = 'a'.charCodeAt(0);
+  for(const ch of word2) {
+    target[ch.charCodeAt(0) - a]++;
+  }
+  const targetCnt = target.reduce((acc, cur) => acc += cur > 0 ? 1 : 0, 0);
+  const cur = Array(26).fill(0);
+
+  let j = 0
+  let cnt = 0
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const e = word1[i].charCodeAt(0) - a
+    while(j < n && cnt < targetCnt) {
+        const idx= word1[j].charCodeAt(0) - a;
+        cur[idx]++;
+        if(cur[idx] === target[idx]) {
+          cnt++;
+        }
+        j++
+    }
+    if(cnt === targetCnt) {
+      res += (n - 1) - (j - 1) + 1
+    }
+    cur[e]--;
+    if(cur[e] === target[e] - 1) {
+      cnt--;
+    }
+  }
+  return res
+};
+
+// another
+
+
+
+function validSubstringCount(w1, w2) {
+    const cnt = {};
+    for (const ch of w2) {
+        cnt[ch] = (cnt[ch] || 0) + 1;
+    }
+    let match = Object.keys(cnt).length, res = 0, j = 0;
+
+    for (let i = 0; i < w1.length; i++) {
+        cnt[w1[i]] = (cnt[w1[i]] || 0) - 1;
+        match -= cnt[w1[i]] === 0 ? 1 : 0;
+
+        while (match === 0) {
+            res += w1.length - i;
+            match += cnt[w1[j]] === 0 ? 1 : 0;
+            cnt[w1[j]] = (cnt[w1[j]] || 0) + 1;
+            j++;
+        }
+    }
+    return res;
+}
+
+// another
+
 /**
  * @param {string} word1
  * @param {string} word2
@@ -47,3 +113,44 @@ var validSubstringCount = function (word1, word2) {
 
   return res
 }
+
+// another
+
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+const validSubstringCount = function(word1, word2) {
+  const n = word1.length;
+  const target = Array(26).fill(0);
+  const a = 'a'.charCodeAt(0);
+  for(const ch of word2) {
+    target[ch.charCodeAt(0) - a]++;
+  }
+  const cur = Array(26).fill(0);
+  let j = 0
+  let res = 0
+  for(let i = 0; i < n; i++) {
+    const e = word1[i].charCodeAt(0) - a
+    while(j < n && !valid(cur, target)) {
+        cur[word1[j].charCodeAt(0) - a]++;
+        j++
+    }
+    if(valid(cur, target)) {
+      res += (n - 1) - (j - 1) + 1
+    }
+    cur[e]--;
+  }
+
+  return res
+
+  function valid(arr, target) {
+    for(let i = 0; i < 26; i++) {
+      if(arr[i] < target[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+};
diff --git a/3301-maximize-the-total-height-of-unique-towers.js b/3301-maximize-the-total-height-of-unique-towers.js
new file mode 100644
index 00000000..6c3f633b
--- /dev/null
+++ b/3301-maximize-the-total-height-of-unique-towers.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} maximumHeight
+ * @return {number}
+ */
+var maximumTotalSum = function(maximumHeight) {
+    const n = maximumHeight.length;
+    maximumHeight.sort((a, b) => a - b);
+    
+    let sum = 0;
+    let lastAssignedHeight = Number.MAX_SAFE_INTEGER;
+    
+    for (let i = n - 1; i >= 0; i--) {
+        const currentHeight = Math.min(maximumHeight[i], lastAssignedHeight - 1);
+        
+        if (currentHeight < 1) {
+            return -1;
+        }
+        
+        sum += currentHeight;
+        lastAssignedHeight = currentHeight;
+    }
+    
+    return sum;  
+};
diff --git a/3334-find-the-maximum-factor-score-of-array.js b/3334-find-the-maximum-factor-score-of-array.js
new file mode 100644
index 00000000..eab4ecba
--- /dev/null
+++ b/3334-find-the-maximum-factor-score-of-array.js
@@ -0,0 +1,39 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxScore = function (nums) {
+  const n = nums.length
+  if (n === 1) {
+    return nums[0] * nums[0]
+  }
+
+  const totalGcd = gcdOfArray(nums)
+  const totalLcm = lcmOfArray(nums)
+  let res = totalGcd * totalLcm
+
+  for (let i = 0; i < n; i++) {
+    const remaining = nums.slice(0, i).concat(nums.slice(i + 1))
+    const currentGcd = gcdOfArray(remaining)
+    const currentLcm = lcmOfArray(remaining)
+    res = Math.max(res, currentGcd * currentLcm)
+  }
+
+  return res
+}
+
+function lcm(a, b) {
+  return (a / gcd(a, b)) * b
+}
+function gcd(a, b) {
+  return b ? gcd(b, a % b) : a
+}
+
+function lcmOfArray(arr) {
+  return arr.reduce((acc, val) => lcm(acc, val))
+}
+
+function gcdOfArray(arr) {
+  return arr.reduce((acc, val) => gcd(acc, val))
+}
+
diff --git a/3335-total-characters-in-string-after-transformations-i.js b/3335-total-characters-in-string-after-transformations-i.js
new file mode 100644
index 00000000..6e029569
--- /dev/null
+++ b/3335-total-characters-in-string-after-transformations-i.js
@@ -0,0 +1,25 @@
+/**
+ * @param {string} s
+ * @param {number} t
+ * @return {number}
+ */
+var lengthAfterTransformations = function (s, t) {
+  const MOD = 10 ** 9 + 7
+  let charCounts = new Array(26).fill(0)
+
+  for (const c of s) {
+    charCounts[c.charCodeAt(0) - 'a'.charCodeAt(0)] += 1
+  }
+
+  for (let i = 0; i < t; i++) {
+    const newCounts = new Array(26).fill(0)
+    for (let j = 0; j < 25; j++) {
+      newCounts[j + 1] += charCounts[j]
+    }
+    newCounts[0] = (newCounts[0] + charCounts[25]) % MOD
+    newCounts[1] = (newCounts[1] + charCounts[25]) % MOD
+    charCounts = newCounts
+  }
+
+  return charCounts.reduce((a, b) => (a + b) % MOD, 0)
+}
diff --git a/3336-find-the-number-of-subsequences-with-equal-gcd.js b/3336-find-the-number-of-subsequences-with-equal-gcd.js
new file mode 100644
index 00000000..68092e4e
--- /dev/null
+++ b/3336-find-the-number-of-subsequences-with-equal-gcd.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var subsequencePairCount = function(nums) {
+    const a = nums
+    let n = a.length,
+        ans = 0,
+        M = 1e9 + 7,
+        dp = Array.from({ length: n }, () =>
+            Array.from({ length: 1 + Math.max(...a) }, () =>
+                new Array(1 + Math.max(...a)).fill(-1)
+            )
+        )
+
+    let recu = (idx, gcd_1, gcd_2) => {
+        if (idx === n)
+            return (gcd_1 === gcd_2 && gcd_1 !== 0)
+
+        if (dp.at(idx).at(gcd_1).at(gcd_2) !== -1)
+            return dp.at(idx).at(gcd_1).at(gcd_2)
+
+        let ans = recu(idx + 1, gcd_1, gcd_2) +
+                  recu(idx + 1, Math.gcd(gcd_1, a.at(idx)), gcd_2) +
+                  recu(idx + 1, gcd_1, Math.gcd(gcd_2, a.at(idx)))
+        ans %= M
+
+        return dp[idx][gcd_1][gcd_2] = ans
+    }
+
+    return recu(0, 0, 0)   
+};
+Math.gcd = function(a, b) {
+    if (b === 0)
+        return a
+    return Math.gcd(b, a % b)
+}
diff --git a/3337-total-characters-in-string-after-transformations-ii.js b/3337-total-characters-in-string-after-transformations-ii.js
new file mode 100644
index 00000000..c0bab8a1
--- /dev/null
+++ b/3337-total-characters-in-string-after-transformations-ii.js
@@ -0,0 +1,76 @@
+const MOD = 1e9 + 7;
+const MODn = BigInt(MOD);
+/**
+ * @param {string} s
+ * @param {number} t
+ * @param {number[]} nums
+ * @return {number}
+ */
+var lengthAfterTransformations = function(s, t, nums) {
+    let vec = new Array(26).fill(0);
+    for(let i = 0; i < s.length; ++i) {
+        let chr = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        vec[chr] += 1;
+    }
+    let mat = new Array(26).fill(0).map(_ => new Array(26).fill(0n));
+    for(let i = 0; i < 26; ++i) {
+        let count = nums[i];
+        let j = (i + 1) % 26;
+        while(count > 0) {
+            mat[i][j] = 1n;
+            --count;
+            
+            j = (j + 1) % 26;
+        }
+
+    }
+
+    mat = matPow(mat, t);
+    let result = 0;
+    for(let i = 0; i < 26; ++i) {
+        for(let j = 0; j < 26; ++j) {
+            result += vec[i] * Number(mat[i][j]);
+        }
+        result = result % MOD;
+    }
+
+    return result;
+};
+
+
+
+function multiplyInto(mat1, mat2, output, tmp) {
+
+    for(let i = 0; i < output.length; ++i) {
+        for(let j = 0; j < output[0].length; ++j) {
+            let result = 0n;
+            for(let k = 0; k < output.length; ++k) {
+                result += mat1[i][k] * mat2[k][j];
+                result %= MODn;
+            }
+            tmp[i][j] = result;
+        }
+    }
+
+    for(let i = 0; i < output.length; ++i) {
+        for(let j = 0; j < output[0].length; ++j) {
+            output[i][j] = tmp[i][j];
+        }
+    }
+}
+
+function matPow(mat, exp) {
+    const result = new Array(mat.length).fill(0).map(_ => mat[0].slice(0).fill(0n));
+    const tmp = new Array(mat.length).fill(0).map(_ => mat[0].slice(0));
+    for(let i = 0; i < result.length; ++i) {
+        result[i][i] = 1n;
+    }
+
+    while (exp) {
+        if (exp & 1) { multiplyInto(mat, result, result, tmp); }
+        multiplyInto(mat, mat, mat, tmp);
+        exp >>>= 1;
+    }
+
+    return result;
+}
diff --git a/3342-find-minimum-time-to-reach-last-room-ii.js b/3342-find-minimum-time-to-reach-last-room-ii.js
new file mode 100644
index 00000000..ce21d124
--- /dev/null
+++ b/3342-find-minimum-time-to-reach-last-room-ii.js
@@ -0,0 +1,99 @@
+/**
+ * @param {number[][]} moveTime
+ * @return {number}
+ */
+var minTimeToReach = function (moveTime) {
+    const a = moveTime
+    let m = a.length, n = a.at(0).length
+
+    let pq = new _PriorityQueue((x, y) => {
+        if (x.at(0) !== y.at(0)) return x.at(0) - y.at(0)
+        if (x.at(2) !== y.at(2)) return x.at(2) - y.at(2)
+    })
+    pq.push([0, 0, 0, 1])
+
+    let di = new Array(m).fill().map(() => new Array(n).fill(1e15))
+    di[0][0] = 0
+
+    while (pq.size()) {
+        let fr = pq.top()
+        pq.pop()
+
+        let d = fr.at(0), x = fr.at(1), y = fr.at(2), st = fr.at(3)
+
+        if (x == m - 1 && y == n - 1)
+            return d
+
+        new Array([-1, 0], [0, -1], [0, 1], [1, 0]).forEach(([dx, dy]) => {
+            if (0 <= x + dx && x + dx < m && 0 <= y + dy && y + dy < n)
+            {
+                let tmp = Math.max(a.at(x + dx).at(y + dy) - d, 0)
+                
+                if (di.at(x + dx).at(y + dy) > d + tmp + st) {
+                    di[x + dx][y + dy] = d + tmp + st
+                    pq.push([di.at(x + dx).at(y + dy), x + dx, y + dy, (st === 1 ? 2 : 1)])
+                }
+            }
+        })
+    }
+}
+
+
+// Binary Heap
+class _PriorityQueue {
+    constructor(cmp) {
+        this.arr = new Array()
+        this.cmp = cmp || ((a, b) => a - b)
+    }
+
+    push(x) {
+        this.arr.push(x)
+        this.heapifyUp()
+    }
+
+    heapifyUp() {
+        let cId = this.size() - 1,
+            pId = this.parentIndex(cId)
+        while (cId > 0 && this.cmp(this.arr.at(cId), this.arr.at(pId)) < 0)
+        {
+            Math.swap(this.arr, cId, pId)
+            cId = pId
+            pId = this.parentIndex(cId)
+        }
+    }
+
+    pop() {
+        if (this.size() === 0)
+            return
+        this.arr[0] = this.arr.pop()
+        this.heapifyDown()
+    }
+
+    heapifyDown() {
+        let pId = 0,
+            lcId = this.leftChildIndex(pId),
+            rcId = this.rightChildIndex(pId)
+        while (lcId < this.size())
+        {
+            let sc = lcId
+            if (rcId < this.size() && this.cmp(this.arr.at(rcId), this.arr.at(lcId)) < 0)
+                sc = rcId
+
+            if (this.cmp(this.arr.at(pId), this.arr.at(sc)) <= 0)
+                return
+
+            Math.swap(this.arr, pId, sc)
+            pId = sc
+            lcId = this.leftChildIndex(pId)
+            rcId = this.rightChildIndex(pId)
+        }
+    }
+
+    size() { return this.arr.length }
+    top() { return this.arr.at(0) }
+    parentIndex = (x) => Math.trunc((x - 1) / 2)
+    leftChildIndex = (x) => 2 * x + 1
+    rightChildIndex = (x) => 2 * x + 2
+}
+
+Math.swap = (obj, i, j) => [obj[i], obj[j]] = [obj[j], obj[i]]
diff --git a/3346-maximum-frequency-of-an-element-after-performing-operations-i.js b/3346-maximum-frequency-of-an-element-after-performing-operations-i.js
new file mode 100644
index 00000000..4a2cc1bf
--- /dev/null
+++ b/3346-maximum-frequency-of-an-element-after-performing-operations-i.js
@@ -0,0 +1,47 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} numOperations
+ * @return {number}
+ */
+var maxFrequency = function (nums, k, numOperations) {
+  const n = nums.length
+  let ans = 0,
+    left = 0,
+    right = 0
+  nums.sort((a, b) => a - b)
+
+  const count = {}
+  for (const num of nums) {
+    count[num] = (count[num] || 0) + 1
+  }
+  for (let mid = 0; mid < n; mid++) {
+    while (nums[mid] - nums[left] > k) {
+      left++
+    }
+
+    while (right < n - 1 && nums[right + 1] - nums[mid] <= k) {
+      right++
+    }
+
+    const total = right - left + 1
+    ans = Math.max(
+      ans,
+      Math.min(total - (count[nums[mid]] || 0), numOperations) +
+        (count[nums[mid]] || 0),
+    )
+  }
+
+  left = 0
+  for (right = 0; right < n; right++) {
+    let mid = Math.floor((nums[left] + nums[right]) / 2)
+
+    while (mid - nums[left] > k || nums[right] - mid > k) {
+      left++
+      mid = Math.floor((nums[left] + nums[right]) / 2)
+    }
+    ans = Math.max(ans, Math.min(right - left + 1, numOperations))
+  }
+
+  return ans
+}
diff --git a/3349-adjacent-increasing-subarrays-detection-i.js b/3349-adjacent-increasing-subarrays-detection-i.js
new file mode 100644
index 00000000..98346711
--- /dev/null
+++ b/3349-adjacent-increasing-subarrays-detection-i.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean}
+ */
+var hasIncreasingSubarrays = function (nums, k) {
+  const n = nums.length
+
+  for (let i = 0; i <= n - 2 * k; ++i) {
+    let firstIncreasing = true
+    let secondIncreasing = true
+
+    for (let j = i; j < i + k - 1; ++j) {
+      if (nums[j] >= nums[j + 1]) {
+        firstIncreasing = false
+        break
+      }
+    }
+
+    if (!firstIncreasing) continue
+
+    for (let j = i + k; j < i + 2 * k - 1; ++j) {
+      if (nums[j] >= nums[j + 1]) {
+        secondIncreasing = false
+        break
+      }
+    }
+
+    if (firstIncreasing && secondIncreasing) return true
+  }
+
+  return false
+}
diff --git a/3350-adjacent-increasing-subarrays-detection-ii.js b/3350-adjacent-increasing-subarrays-detection-ii.js
new file mode 100644
index 00000000..c091eba0
--- /dev/null
+++ b/3350-adjacent-increasing-subarrays-detection-ii.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxIncreasingSubarrays = function (nums) {
+  const n = nums.length
+  let up = 1, preMaxUp = 0, res = 0
+
+  for(let i = 1; i < n; i++) {
+    if(nums[i] > nums[i - 1]) up++
+    else {
+        preMaxUp = up
+        up = 1
+    }
+    res = Math.max(res, Math.max(~~(up / 2), Math.min(preMaxUp, up)))
+  }
+
+
+  return res
+}
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxIncreasingSubarrays = function (nums) {
+  const n = nums.length
+
+  const increasingRun = new Array(n).fill(1)
+  for (let i = n - 2; i >= 0; --i) {
+    if (nums[i] < nums[i + 1]) {
+      increasingRun[i] = increasingRun[i + 1] + 1
+    }
+  }
+
+  let left = 1,
+    right = Math.floor(n / 2)
+  let res = 0
+
+  while (left <= right) {
+    const mid = left + Math.floor((right - left) / 2)
+    let found = false
+
+    for (let i = 0; i <= n - 2 * mid; ++i) {
+      if (increasingRun[i] >= mid && increasingRun[i + mid] >= mid) {
+        found = true
+        break
+      }
+    }
+
+    if (found) {
+      res = mid
+      left = mid + 1
+    } else {
+      right = mid - 1
+    }
+  }
+
+  return res
+}
diff --git a/3351-sum-of-good-subsequences.js b/3351-sum-of-good-subsequences.js
new file mode 100644
index 00000000..84b8b7a2
--- /dev/null
+++ b/3351-sum-of-good-subsequences.js
@@ -0,0 +1,18 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const sumOfGoodSubsequences = function(nums) {
+  const limit = 1e5 + 10;
+  const mod = 1e9 + 7;
+  const count = Array(limit).fill(0);
+  const total = Array(limit).fill(0);
+  let res = 0;
+  for(const e of nums) {
+    count[e + 1] = (count[e] + count[e + 1] + count[e + 2] + 1) % mod
+    const cur = total[e] + total[e + 2] + e * (count[e] + count[e + 2] + 1)
+    total[e + 1] = (total[e + 1] + cur) % mod
+    res =(res + cur) % mod
+  }
+  return res
+};
diff --git a/3352-count-k-reducible-numbers-less-than-n.js b/3352-count-k-reducible-numbers-less-than-n.js
new file mode 100644
index 00000000..5ce98c75
--- /dev/null
+++ b/3352-count-k-reducible-numbers-less-than-n.js
@@ -0,0 +1,58 @@
+const ll = BigInt,
+  mod = ll(1e9 + 7),
+  N = 1e4 + 15
+let fact = Array(N).fill(0),
+  ifact = Array(N).fill(0),
+  inv = Array(N).fill(0)
+const hcomb = (p, q) => (p == 0 && q == 0 ? 1 : comb(p + q - 1, q))
+const comb_init = () => {
+  fact[0] = ifact[0] = inv[1] = 1n // factorial, inverse factorial
+  for (let i = 2; i < N; i++)
+    inv[i] = ((mod - mod / ll(i)) * inv[mod % ll(i)]) % mod
+  for (let i = 1; i < N; i++) {
+    fact[i] = (fact[i - 1] * ll(i)) % mod
+    ifact[i] = (ifact[i - 1] * inv[i]) % mod
+  }
+}
+
+// combination mod pick k from n
+const comb = (n, k) => {
+  if (n < k || k < 0) return 0
+  return (((fact[n] * ifact[k]) % mod) * ifact[n - k]) % mod
+}
+
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var countKReducibleNumbers = function (s, k) {
+  let dp = new Array(1000).fill(0)
+  for (let i = 2; i < 1000; i++) {
+    dp[i] = dp[bitCnt(i)] + 1
+  }
+  let c1 = 0
+  let n = s.length
+  let res = 0n
+  comb_init()
+  for (let i = 0; i < n; i++) {
+    if (s[i] === "1") {
+      for (let c2 = 0; c2 < n - i; c2++) {
+        if (c1 + c2 > 0 && dp[c1 + c2] + 1 <= k) {
+          res = res + comb(n - i - 1, c2)
+        }
+      }
+      c1++
+    }
+  }
+  return Number(res % mod)
+
+  function bitCnt(num) {
+    let cnt = 0
+    while (num) {
+      cnt += num & 1
+      num >>= 1
+    }
+    return cnt
+  }
+}
diff --git a/3354-make-array-elements-equal-to-zero.js b/3354-make-array-elements-equal-to-zero.js
new file mode 100644
index 00000000..7f7a6c0d
--- /dev/null
+++ b/3354-make-array-elements-equal-to-zero.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+const countValidSelections = function (nums) {
+  let res = 0
+  for (let i = 0; i < nums.length; i++) {
+    if (nums[i] === 0) {
+      if (canZeroOut(i, -1)) {
+        res += 1
+      }
+      if (canZeroOut(i, 1)) {
+        res += 1
+      }
+    }
+  }
+  return res
+  function canZeroOut(start, direction) {
+    let tempNums = nums.slice()
+    let curr = start
+
+    while (curr >= 0 && curr < tempNums.length) {
+      if (tempNums[curr] === 0) {
+        curr += direction
+      } else {
+        tempNums[curr] -= 1
+        direction *= -1
+        curr += direction
+      }
+    }
+    return tempNums.every((x) => x === 0)
+  }
+}
diff --git a/3355-zero-array-transformation-i.js b/3355-zero-array-transformation-i.js
new file mode 100644
index 00000000..db5e35b7
--- /dev/null
+++ b/3355-zero-array-transformation-i.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {boolean}
+ */
+var isZeroArray = function(nums, queries) {
+    const n = nums.length
+    const arr = Array(n + 1).fill(0)
+    for(const [l, r] of queries) {
+        arr[l]++
+        arr[r + 1]--
+    }
+    
+    for(let i = 1; i <= n; i++) {
+        arr[i] += arr[i - 1]
+    }
+    for(let i = 0; i < n; i++) {
+        if(nums[i] > arr[i]) return false
+    }
+    
+    return true
+};
diff --git a/3356-zero-array-transformation-ii.js b/3356-zero-array-transformation-ii.js
new file mode 100644
index 00000000..4650df6d
--- /dev/null
+++ b/3356-zero-array-transformation-ii.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  const n = nums.length
+  let sum = 0,
+    k = 0
+  const differenceArray = new Array(n + 1).fill(0)
+
+  for (let index = 0; index < n; index++) {
+    // Iterate through queries while current index of nums cannot equal zero
+    while (sum + differenceArray[index] < nums[index]) {
+      k++
+
+      // Zero array isn't formed after all queries are processed
+      if (k > queries.length) {
+        return -1
+      }
+      const [left, right, val] = queries[k - 1]
+
+      // Process start and end of range
+      if (right >= index) {
+        differenceArray[Math.max(left, index)] += val
+        differenceArray[right + 1] -= val
+      }
+    }
+    // Update prefix sum at current index
+    sum += differenceArray[index]
+  }
+  return k
+}
+
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  if (nums.every((num) => num === 0)) return 0
+  const n = nums.length
+  const delta = new Array(n + 1).fill(0)
+
+  for (let index = 0; index < queries.length; index++) {
+    const query = queries[index]
+    const l = query[0]
+    const r = query[1]
+    const diff = query[2]
+
+    delta[l] += diff
+    if (r + 1 < n) {
+      delta[r + 1] -= diff
+    }
+
+    let curDiff = 0
+    let success = true
+
+    for (let i = 0; i < n; i++) {
+      curDiff += delta[i]
+      if (nums[i] > curDiff) {
+        success = false
+        break
+      }
+    }
+
+    if (!success) continue
+    return index + 1
+  }
+  return -1
+}
+
diff --git a/3362-zero-array-transformation-iii.js b/3362-zero-array-transformation-iii.js
new file mode 100644
index 00000000..dcf8e0d9
--- /dev/null
+++ b/3362-zero-array-transformation-iii.js
@@ -0,0 +1,99 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var maxRemoval = function(nums, queries) {
+    queries.sort((a, b) => a[0] === b[0] ? a[1] - b[1] : a[0] - b[0]);
+    const candidate = new PQ((a, b) => a > b);
+    const chosen = new PQ((a, b) => a < b);
+    let res = 0;
+    const n = nums.length;
+    let j = 0;
+
+    for (let i = 0; i < n; i++) {
+        while (j < queries.length && queries[j][0] === i) {
+            candidate.push(queries[j][1]);
+            j++;
+        }
+        nums[i] -= chosen.size();
+        while (nums[i] > 0 && candidate.size() > 0 && candidate.peek() >= i) {
+            res++;
+            chosen.push(candidate.peek());
+            candidate.pop()
+            nums[i]--;
+        }
+        if (nums[i] > 0) return -1;
+        while (chosen.size() > 0 && chosen.peek() === i) {
+            chosen.pop()
+        }
+    }
+    return queries.length - res;
+};
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
diff --git a/3364-minimum-positive-sum-subarray.js b/3364-minimum-positive-sum-subarray.js
new file mode 100644
index 00000000..efec413a
--- /dev/null
+++ b/3364-minimum-positive-sum-subarray.js
@@ -0,0 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var minimumSumSubarray = function (nums, l, r) {
+  let sum = Infinity
+  for (let i = l; i <= r; i++) {
+    sum = Math.min(minPos(nums, i), sum)
+  }
+  return sum === Infinity ? -1 : sum
+}
+
+function minPos(num, k) {
+  let s = 0
+  let min = Infinity
+  for (let i = 0; i < k; i++) {
+    s += num[i]
+  }
+  if (s > 0) min = s
+  for (let i = k; i < num.length; i++) {
+    s += num[i] - num[i - k]
+    if (s > 0) min = Math.min(min, s)
+  }
+  return min
+}
diff --git a/3365-rearrange-k-substrings-to-form-target-string.js b/3365-rearrange-k-substrings-to-form-target-string.js
new file mode 100644
index 00000000..2d743b98
--- /dev/null
+++ b/3365-rearrange-k-substrings-to-form-target-string.js
@@ -0,0 +1,31 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @param {number} k
+ * @return {boolean}
+ */
+var isPossibleToRearrange = function (s, t, k) {
+  const d = Math.floor(s.length / k)
+  if (s === t) return true
+  const map = new Map()
+
+  for (let i = 0; i < s.length; i += d) {
+    const req = s.substring(i, i + d)
+    if (map.has(req)) {
+      map.set(req, map.get(req) + 1)
+    } else {
+      map.set(req, 1)
+    }
+  }
+
+  for (let i = 0; i < t.length; i += d) {
+    const tar = t.substring(i, i + d)
+    if (!map.has(tar)) return false
+    else if (map.get(tar) < 1) return false
+    else {
+      map.set(tar, map.get(tar) - 1)
+    }
+  }
+
+  return true
+}
diff --git a/3366-minimum-array-sum.js b/3366-minimum-array-sum.js
new file mode 100644
index 00000000..b784f5c3
--- /dev/null
+++ b/3366-minimum-array-sum.js
@@ -0,0 +1,92 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} op1
+ * @param {number} op2
+ * @return {number}
+ */
+var minArraySum = function(nums, k, op1, op2) {
+  let dp = Array.from({ length: op1 + 1 }, () => Array(op2 + 1).fill(Infinity))
+  const {min, floor, ceil} = Math
+  
+  dp[op1][op2] = 0
+
+  for(const e of nums) {
+    const nxt = Array.from({ length: op1 + 1 }, () => Array(op2 + 1).fill(Infinity))
+    for(let i = 0; i <= op1; i++) {
+        for(let j = 0; j <= op2; j++) {
+            nxt[i][j] = min(nxt[i][j], dp[i][j] + e)
+            if(i > 0) {
+                const cur = ceil(e / 2)
+                nxt[i - 1][j] = min(nxt[i - 1][j], dp[i][j] + cur)
+                if(cur >= k && j > 0) {
+                    nxt[i - 1][j - 1] = min(nxt[i - 1][j - 1], dp[i][j] + cur - k)
+                }
+            }
+            if(j > 0 && e >= k) {
+                const cur = e - k
+                nxt[i][j - 1] = min(nxt[i][j - 1], dp[i][j] + cur)
+                if(i > 0) {
+                    nxt[i - 1][j - 1] = min(nxt[i - 1][j - 1], dp[i][j] + ceil(cur / 2))
+                }
+            }
+        }
+    }
+
+    dp = nxt
+  }
+   
+  let res = Infinity
+  for(let i = 0; i <= op1; i++) {
+    for(let j = 0; j <= op2; j++) {
+        res = Math.min(res, dp[i][j])
+    }
+  }
+
+  return res
+};
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} op1
+ * @param {number} op2
+ * @return {number}
+ */
+var minArraySum = function(nums, k, op1, op2) {
+    const n = nums.length;
+    const cache = new Map();
+
+    function dp(idx, left1, left2) {
+        if (idx === n) {
+            return 0;
+        }
+        const key = `${idx},${left1},${left2}`;
+        if (cache.has(key)) {
+            return cache.get(key);
+        }
+
+        let ret = nums[idx] + dp(idx + 1, left1, left2);
+        if (left1 && left2) {
+            if (nums[idx] >= k) {
+                ret = Math.min(ret, Math.floor((nums[idx] - k + 1) / 2) + dp(idx + 1, left1 - 1, left2 - 1));
+            }
+            if (Math.floor((nums[idx] + 1) / 2) >= k) {
+                ret = Math.min(ret, Math.floor((nums[idx] + 1) / 2) - k + dp(idx + 1, left1 - 1, left2 - 1));
+            }
+        }
+        if (left1) {
+            ret = Math.min(ret, Math.floor((nums[idx] + 1) / 2) + dp(idx + 1, left1 - 1, left2));
+        }
+        if (left2 && nums[idx] >= k) {
+            ret = Math.min(ret, nums[idx] - k + dp(idx + 1, left1, left2 - 1));
+        }
+
+        cache.set(key, ret);
+        return ret;
+    }
+
+    return dp(0, op1, op2);
+};
diff --git a/3367-maximize-sum-of-weights-after-edge-removals.js b/3367-maximize-sum-of-weights-after-edge-removals.js
new file mode 100644
index 00000000..c0c65a96
--- /dev/null
+++ b/3367-maximize-sum-of-weights-after-edge-removals.js
@@ -0,0 +1,51 @@
+/**
+ * @param {number[][]} edges
+ * @param {number} k
+ * @return {number}
+ */
+var maximizeSumOfWeights = function(edges, k) {
+    const n = edges.length + 1;
+    const g = Array.from({ length: n }, () => ({}));
+    
+    for (const [x, y, w] of edges) {
+        g[x][y] = g[y][x] = w;
+    }
+
+    function dfs(idx, p) {
+        const ret = [0, 0];
+        const h = [];
+        
+        for (const ch in g[idx]) {
+            if (ch != p) {
+                const [a, b] = dfs(ch, idx);
+                h.push([a - b, a, b]);
+            }
+        }
+
+        h.sort((a, b) => b[0] - a[0]); // Max-heap simulation
+        let take = 0;
+        let take_k = 0;
+        let leave_k = 0;
+        let leave = 0;
+        let ct = 0;
+
+        while (h.length) {
+            const [_, a, b] = h.pop();
+            ct += 1;
+            if (ct <= k - 1) {
+                take += b;
+            } else if (ct === k) {
+                take_k = b;
+                leave_k = a;
+            } else {
+                leave += a;
+            }
+        }
+
+        const v = take + take_k + leave;
+        const w = take + leave_k + leave + (p !== -1 ? g[p][idx] : 0);
+        return [v, Math.max(v, w)];
+    }
+
+    return dfs(0, -1)[1];  
+};
diff --git a/3370-smallest-number-with-all-set-bits.js b/3370-smallest-number-with-all-set-bits.js
new file mode 100644
index 00000000..1fecd416
--- /dev/null
+++ b/3370-smallest-number-with-all-set-bits.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var smallestNumber = function(n) {
+    let x = n
+    while ((x & (x + 1)) !== 0) {
+      x += 1
+    }
+    return x
+};
diff --git a/3371-identify-the-largest-outlier-in-an-array.js b/3371-identify-the-largest-outlier-in-an-array.js
new file mode 100644
index 00000000..3e6b4784
--- /dev/null
+++ b/3371-identify-the-largest-outlier-in-an-array.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var getLargestOutlier = function (nums) {
+  let totalSum = 0
+  for (let num of nums) {
+    totalSum += num
+  }
+
+  const freqMap = new Map()
+  for (let num of nums) {
+    freqMap.set(num, (freqMap.get(num) || 0) + 1)
+  }
+  let res = Number.MIN_SAFE_INTEGER
+
+  for (let sumElement of nums) {
+    let potentialOutlier = totalSum - 2 * sumElement
+
+    if (freqMap.has(potentialOutlier)) {
+      if (potentialOutlier === sumElement && freqMap.get(sumElement) < 2) {
+        continue
+      }
+      res = Math.max(res, potentialOutlier)
+    }
+  }
+  return res
+}
diff --git a/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js b/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js
new file mode 100644
index 00000000..d20c097d
--- /dev/null
+++ b/3372-maximize-the-number-of-target-nodes-after-connecting-trees-i.js
@@ -0,0 +1,53 @@
+/**
+ * @param {number[][]} edges1
+ * @param {number[][]} edges2
+ * @param {number} k
+ * @return {number[]}
+ */
+var maxTargetNodes = function (edges1, edges2, k) {
+  const n = edges1.length + 1
+  const m = edges2.length + 1
+
+  const adj1 = Array.from({ length: n }, () => [])
+  const adj2 = Array.from({ length: m }, () => [])
+
+  for (const edge of edges1) {
+    const [u, v] = edge
+    adj1[u].push(v)
+    adj1[v].push(u)
+  }
+  for (const edge of edges2) {
+    const [u, v] = edge
+    adj2[u].push(v)
+    adj2[v].push(u)
+  }
+
+  const good1 = new Array(n).fill(0)
+  const good2 = new Array(m).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    dfs(i, -1, 0, i, k + 1, good1, adj1)
+  }
+
+  for (let i = 0; i < m; i++) {
+    dfs(i, -1, 0, i, k, good2, adj2)
+  }
+
+  const mx = Math.max(...good2)
+
+  const res = new Array(n)
+  for (let i = 0; i < n; i++) {
+    res[i] = good1[i] + mx
+  }
+  return res
+}
+
+function dfs(node, parent, distance, root, k, good, adj) {
+  if (distance >= k) return
+  good[root]++
+  for (const neighbor of adj[node]) {
+    if (neighbor !== parent) {
+      dfs(neighbor, node, distance + 1, root, k, good, adj)
+    }
+  }
+}
diff --git a/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js b/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js
new file mode 100644
index 00000000..c1ca4e20
--- /dev/null
+++ b/3373-maximize-the-number-of-target-nodes-after-connecting-trees-ii.js
@@ -0,0 +1,90 @@
+class Graph {
+  constructor(n) {
+    this.n = n
+    this.adj = Array.from({ length: n }, () => [])
+    this.weight = new Map()
+    for (let i = 0; i < n; i++) {
+      this.weight.set(i, new Map())
+    }
+  }
+
+  addEdgeOri(i, j, w = 0) {
+    this.adj[i].push(j)
+    this.weight.get(i).set(j, w)
+  }
+
+  addEdge(i, j, w = 0) {
+    // Add w to v's list.
+    this.adj[i].push(j)
+    // Add v to w's list
+    this.adj[j].push(i)
+    this.weight.get(i).set(j, w)
+    this.weight.get(j).set(i, w)
+  }
+}
+
+function dijkstra(graph, source) {
+  const ans = new Array(graph.n).fill(Number.MAX_SAFE_INTEGER / 2)
+  const pq = new MinPriorityQueue({ priority: (item) => item[1] })
+  pq.enqueue([source, 0])
+
+  while (pq.size() > 0) {
+    const [item, dis] = pq.dequeue().element
+    if (ans[item] <= dis) continue
+    ans[item] = dis
+
+    graph.adj[item].forEach((neighbor) => {
+      if (ans[neighbor] >= Number.MAX_SAFE_INTEGER / 2) {
+        pq.enqueue([neighbor, dis + graph.weight.get(item).get(neighbor)])
+      }
+    })
+  }
+  return ans
+}
+
+function maxTargetNodes(edges1, edges2) {
+  const n = edges1.length + 1
+  const m = edges2.length + 1
+  const g1 = new Graph(n)
+  const g2 = new Graph(m)
+
+  edges1.forEach(([a, b]) => g1.addEdge(a, b, 1))
+  edges2.forEach(([a, b]) => g2.addEdge(a, b, 1))
+
+  const dis1 = dijkstra(g1, 0)
+  const dis2 = dijkstra(g2, 0)
+
+  const a0 = new Set()
+  const a1 = new Set()
+  const b0 = new Set()
+  const b1 = new Set()
+
+  for (let i = 0; i < dis1.length; i++) {
+    if (dis1[i] % 2 === 0) {
+      a0.add(i)
+    } else {
+      a1.add(i)
+    }
+  }
+
+  for (let i = 0; i < dis2.length; i++) {
+    if (dis2[i] % 2 === 0) {
+      b0.add(i)
+    } else {
+      b1.add(i)
+    }
+  }
+
+  const b = Math.max(b0.size, b1.size)
+  const ans = []
+
+  for (let i = 0; i < n; i++) {
+    if (a0.has(i)) {
+      ans.push(a0.size + b)
+    } else {
+      ans.push(a1.size + b)
+    }
+  }
+
+  return ans
+}
diff --git a/3376-minimum-time-to-break-locks-i.js b/3376-minimum-time-to-break-locks-i.js
new file mode 100644
index 00000000..450bba1c
--- /dev/null
+++ b/3376-minimum-time-to-break-locks-i.js
@@ -0,0 +1,25 @@
+/**
+ * @param {number[]} strength
+ * @param {number} k
+ * @return {number}
+ */
+var findMinimumTime = function(strength, k) {
+    strength.sort((a, b) => a - b)
+    const n = strength.length, {floor} = Math
+    let res = Infinity
+    f(0, 1, 0)
+    return res
+
+    function f(mask, x, tmp) {
+        if(mask === (1 << n) - 1) {
+            res = Math.min(res, tmp)
+            return
+        } 
+        let add = 0
+        for(let i = 0; i < n; i++) {
+            if(mask & (1 << i)) continue
+            add = ceil(strength[i] / x)
+            f(mask | (1 << i), x + k, tmp + add)
+        }
+    }
+};
diff --git a/3377-digit-operations-to-make-two-integers-equal.js b/3377-digit-operations-to-make-two-integers-equal.js
new file mode 100644
index 00000000..ca6c8ccc
--- /dev/null
+++ b/3377-digit-operations-to-make-two-integers-equal.js
@@ -0,0 +1,129 @@
+let isPrime
+/**
+ * @param {number} n
+ * @param {number} m
+ * @return {number}
+ */
+const minOperations = function(n, m) {
+  genPrimes()
+//   console.log(isPrime)
+  if(isPrime[n] || isPrime[m]) return -1
+  const pq = new PQ((a, b) => a[0] < b[0])
+  const visited = new Set()
+
+  pq.push([n, n])
+  while(!pq.isEmpty()) {
+    const [steps, cur] = pq.pop()
+    // console.log(cur)
+    if(visited.has(cur)) continue
+    visited.add(cur)
+    // console.log(steps)
+    if(cur === m) return steps
+    const s = ('' + cur).split('')
+    for(let i = 0; i < s.length; i++) {
+      const tmp = s[i]
+      const num = +s[i]
+      if(s[i] < '9') {
+        s[i] = num + 1
+        const nxt = +s.join('')
+        if(!isPrime[nxt] && !visited.has(nxt)) {
+            pq.push([steps + nxt, nxt])
+        }
+        s[i] = tmp
+      }
+      if(s[i]  > '0' && !(i == 0 && s[i] == '1')) {
+        s[i] = num - 1
+        const nxt = +s.join('')
+        if(!isPrime[nxt] && !visited.has(nxt)) {
+            pq.push([steps + nxt, nxt])
+        }
+        s[i] = tmp
+      }
+
+    }
+
+  }
+  return -1
+
+  function genPrimes() {
+    if(isPrime != null) return
+    isPrime = Array(1e4 + 1).fill(1)
+    isPrime[0] = 0
+    isPrime[1] = 0
+    for(let i = 2; i <= 1e4; i++) {
+        if(isPrime[i]) {
+            for(let j = 2 * i; j <= 1e5; j += i) {
+                isPrime[j] = 0
+            } 
+        }
+    } 
+  }
+};
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
diff --git a/3378-count-connected-components-in-lcm-graph.js b/3378-count-connected-components-in-lcm-graph.js
new file mode 100644
index 00000000..9f17c2bd
--- /dev/null
+++ b/3378-count-connected-components-in-lcm-graph.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @param {number} threshold
+ * @return {number}
+ */
+var countComponents = function(nums, threshold) {
+    const dsu = new DSU(threshold);
+    const n = nums.length;
+    let res = 0;
+
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] <= threshold) {
+            for (let j = nums[i]; j <= threshold; j += nums[i]) {
+                dsu.join(nums[i], j);
+            }
+        }
+    }
+
+    const st = new Set();
+    for (let i = 0; i < nums.length; i++) {
+        if (nums[i] > threshold) res++;
+        else st.add(dsu.findParent(nums[i]));
+    }
+
+    res += st.size;
+    return res;  
+};
+class DSU {
+    constructor(n) {
+        this.parent = new Array(n + 1).fill(-1);
+    }
+
+    findParent(x) {
+        if (this.parent[x] === -1) return x;
+        return this.parent[x] = this.findParent(this.parent[x]);
+    }
+
+    join(x, y) {
+        const X = this.findParent(x);
+        const Y = this.findParent(y);
+        if (X === Y) return false;
+        this.parent[X] = Y;
+        return true;
+    }
+}
diff --git a/3379-transformed-array.js b/3379-transformed-array.js
new file mode 100644
index 00000000..2daeba3f
--- /dev/null
+++ b/3379-transformed-array.js
@@ -0,0 +1,22 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var constructTransformedArray = function(nums) {
+    const n = nums.length;
+    const res = new Array(n).fill(0);
+    for (let i = 0; i < n; i++) {
+        if (nums[i] === 0) {
+            res[i] = nums[i];
+        } else if (nums[i] > 0) {
+            const ind = (i + nums[i]) % n;
+            res[i] = nums[ind];
+        } else {
+            const neg = Math.abs(nums[i]) % n;
+            const ind = (i - neg + n) % n;
+            // console.log(ind);
+            res[i] = nums[ind];
+        }
+    }
+    return res;
+};
diff --git a/3380-maximum-area-rectangle-with-point-constraints-i.js b/3380-maximum-area-rectangle-with-point-constraints-i.js
new file mode 100644
index 00000000..8247c400
--- /dev/null
+++ b/3380-maximum-area-rectangle-with-point-constraints-i.js
@@ -0,0 +1,41 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var maxRectangleArea = function (points) {
+  const n = points.length
+  const st = new Set()
+  for (const i of points) st.add(i[0] + ',' + i[1])
+  let res = -1
+
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const x1 = points[i][0],
+        y1 = points[i][1],
+        x2 = points[j][0],
+        y2 = points[j][1]
+      if (x1 === x2 || y1 === y2) continue
+      if (st.has(x1 + ',' + y2) && st.has(x2 + ',' + y1)) {
+        const min1 = Math.min(x1, x2),
+          max1 = Math.max(x1, x2),
+          min2 = Math.min(y1, y2),
+          max2 = Math.max(y1, y2)
+        let isid = true
+        for (const point of points) {
+          const cx = point[0],
+            cy = point[1]
+          if (
+            (cx > min1 && cx < max1 && cy > min2 && cy < max2) ||
+            ((cx === min1 || cx === max1) && cy > min2 && cy < max2) ||
+            ((cy === min2 || cy === max2) && cx > min1 && cx < max1)
+          ) {
+            isid = false
+            break
+          }
+        }
+        if (isid) res = Math.max(res, (max1 - min1) * (max2 - min2))
+      }
+    }
+  }
+  return res
+}
diff --git a/3381-maximum-subarray-sum-with-length-divisible-by-k.js b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
new file mode 100644
index 00000000..7dcf1c3f
--- /dev/null
+++ b/3381-maximum-subarray-sum-with-length-divisible-by-k.js
@@ -0,0 +1,60 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxSubarraySum = function(nums, k) {
+    const ps = [0]
+    for (const e of nums) {
+        ps.push(ps[ps.length - 1] + e)
+    }
+    let res = Number.MIN_SAFE_INTEGER
+    for (let p = 0; p < k; ++p) {
+        let sum = 0
+        for (let i = p; i + k <= nums.length; i += k) {
+            const n = ps[i + k] - ps[i]
+            sum = Math.max(n, sum + n)
+            res = Math.max(res, sum)
+        }
+    }
+    return res
+}
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var maxSubarraySum = function (nums, k) {
+  const n = nums.length
+  let res = -Infinity
+  const pre_sum = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    pre_sum[i + 1] = pre_sum[i] + nums[i]
+  }
+
+  const groups = Array.from({ length: k }, (_, i) => [pre_sum[i]])
+
+  for (let i = k; i <= n; i++) {
+    const idx = i % k
+    groups[idx].push(pre_sum[i])
+  }
+
+  for (let i = 0; i < k; i++) {
+    const group = groups[i]
+    const mx_dp = new Array(group.length + 1).fill(-Infinity)
+
+    for (let j = group.length - 1; j >= 0; j--) {
+      mx_dp[j] = Math.max(mx_dp[j + 1], group[j])
+    }
+
+    for (let j = 0; j < group.length; j++) {
+      res = Math.max(res, mx_dp[j + 1] - group[j])
+    }
+  }
+
+  return res
+}
diff --git a/3382-maximum-area-rectangle-with-point-constraints-ii.js b/3382-maximum-area-rectangle-with-point-constraints-ii.js
new file mode 100644
index 00000000..7d1912cc
--- /dev/null
+++ b/3382-maximum-area-rectangle-with-point-constraints-ii.js
@@ -0,0 +1,85 @@
+/**
+ * @param {number[]} xCoord
+ * @param {number[]} yCoord
+ * @return {number}
+ */
+var maxRectangleArea = function (xCoord, yCoord) {
+  const n = xCoord.length
+  const co = []
+  const sy = imap(yCoord)
+
+  for (let i = 0; i < n; i++) {
+    co.push([xCoord[i], binarySearch(sy, yCoord[i])])
+  }
+  co.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+
+  let result = -1
+  const map = new Map()
+  const mapX = new Map()
+  const ft = new Array(sy.length + 1).fill(0)
+  for (let i = 0; i < co.length; i++) {
+    addFenwick(ft, co[i][1], 1)
+
+    if (i - 1 >= 0 && co[i][0] === co[i - 1][0]) {
+      const yc = (BigInt(co[i][1]) << 32n) | BigInt(co[i - 1][1])
+      const aft = sumFenwick(ft, co[i][1]) - sumFenwick(ft, co[i - 1][1] - 1)
+
+      if (map.has(yc)) {
+        const bef = map.get(yc)
+        if (aft === bef + 2) {
+          const x = mapX.get(yc)
+          const S =
+            BigInt(co[i][0] - x) * BigInt(sy[co[i][1]] - sy[co[i - 1][1]])
+          result = Number(BigInt(result) > S ? result : S)
+        }
+      }
+
+      map.set(yc, aft)
+      mapX.set(yc, co[i][0])
+    }
+  }
+
+  return result
+
+  function sumFenwick(ft, i) {
+    let sum = 0
+    for (i += 1; i > 0; i -= i & -i) {
+      sum += ft[i]
+    }
+    return sum
+  }
+
+  function addFenwick(ft, i, v) {
+    if (v === 0 || i < 0) return
+    for (i += 1; i < ft.length; i += i & -i) {
+      ft[i] += v
+    }
+  }
+
+  function imap(a) {
+    const imap = Array.from(a)
+    imap.sort((a, b) => a - b)
+    let p = 1
+
+    for (let i = 1; i < imap.length; i++) {
+      if (imap[i] !== imap[p - 1]) imap[p++] = imap[i]
+    }
+
+    return imap.slice(0, p)
+  }
+
+  function binarySearch(nums, target) {
+    let left = 0
+    let right = nums.length - 1
+    while (left <= right) {
+      const mid = (left + right) >> 1
+      if (nums[mid] === target) return mid
+      if (nums[mid] < target) {
+        left = mid + 1
+      } else {
+        right = mid - 1
+      }
+    }
+    return -1
+  }
+}
diff --git a/3388-count-beautiful-splits-in-an-array.js b/3388-count-beautiful-splits-in-an-array.js
new file mode 100644
index 00000000..1d848495
--- /dev/null
+++ b/3388-count-beautiful-splits-in-an-array.js
@@ -0,0 +1,45 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var beautifulSplits = function (nums) {
+  const n = nums.length
+  // lcps[i][j] = length of the longest common prefix between nums[i:] and nums[j:]
+  const lcps = Array.from({ length: n }, () => Array(n).fill(0))
+
+  // Calculate longest common prefixes
+  for (let x = 0; x < n; ++x) {
+    const lcp = lcps[x]
+    let max_i = x,
+      max_r = x
+    for (let i = x + 1; i < n; ++i) {
+      if (max_r >= i) {
+        lcp[i] = Math.min(max_r - i + 1, lcp[i - max_i + x])
+      }
+      while (i + lcp[i] < n && nums[i + lcp[i]] === nums[lcp[i] + x]) {
+        lcp[i]++
+      }
+      if (i + lcp[i] - 1 > max_r) {
+        max_i = i
+        max_r = i + lcp[i] - 1
+      }
+    }
+  }
+
+  let res = 0
+  for (let i = 0; i < n; ++i) {
+    for (let j = i + 1; j < n - 1; ++j) {
+      // Check if prefix conditions are satisfied
+      if (lcps[0][i + 1] >= i + 1 && j - i >= i + 1) {
+        res++
+        continue
+      }
+      if (lcps[i + 1][j + 1] >= j - i) {
+        res++
+        continue
+      }
+    }
+  }
+
+  return res
+}
diff --git a/3393-count-paths-with-the-given-xor-value.js b/3393-count-paths-with-the-given-xor-value.js
new file mode 100644
index 00000000..8403c4b1
--- /dev/null
+++ b/3393-count-paths-with-the-given-xor-value.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[][]} grid
+ * @param {number} k
+ * @return {number}
+ */
+const countPathsWithXorValue = function(grid, k) {
+  const m = grid.length, n = grid[0].length
+  const mod = 1e9 + 7
+  const dp = Array.from({length: m}, () => Array.from({length: n}, () => Array(16).fill(0)))
+  dp[0][0][grid[0][0]] = 1
+
+  for(let i = 0; i < m; i++) {
+    for(let j = 0; j < n; j++) {
+        for(let v = 0; v < 16; v++) {
+            if(dp[i][j][v] <= 0) continue
+            if(i + 1 < m) {
+                const e = grid[i + 1][j]
+                dp[i + 1][j][v ^ e] = (dp[i + 1][j][v ^ e] + dp[i][j][v]) % mod
+            }
+            if(j + 1 < n) {
+                const e = grid[i][j + 1]
+                dp[i][j + 1][v ^ e] = (dp[i][j + 1][v ^ e] + dp[i][j][v]) % mod
+            }
+        }
+    }
+  }
+
+  return dp[m - 1][n - 1][k]
+};
diff --git a/3394-check-if-grid-can-be-cut-into-sections.js b/3394-check-if-grid-can-be-cut-into-sections.js
new file mode 100644
index 00000000..82710629
--- /dev/null
+++ b/3394-check-if-grid-can-be-cut-into-sections.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number[][]} rectangles
+ * @return {boolean}
+ */
+var checkValidCuts = function(n, rectangles) {
+    const vertical = [];
+    const horizontal = [];
+    for (const it of rectangles) {
+        vertical.push([it[1], it[3]])
+        horizontal.push([it[0], it[2]])
+    }
+    const mergeH = mergeIntervals(horizontal);
+    const mergeV = mergeIntervals(vertical);
+    return mergeH.length >= 3 || mergeV.length >= 3;  
+};
+function mergeIntervals(intervals) {
+    if (intervals.length <= 1) return intervals;
+    intervals.sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    merged.push(intervals[0]);
+    for (let i = 1; i < intervals.length; ++i) {
+        if (intervals[i][0] < merged[merged.length - 1][1]) {
+            merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], intervals[i][1]);
+        } else {
+            merged.push(intervals[i]);
+        }
+    }
+    return merged;
+}
diff --git a/3395-subsequences-with-a-unique-middle-mode-i.js b/3395-subsequences-with-a-unique-middle-mode-i.js
new file mode 100644
index 00000000..0ec3f8f9
--- /dev/null
+++ b/3395-subsequences-with-a-unique-middle-mode-i.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var subsequencesWithMiddleMode = function(nums) {
+  const n = nums.length;
+  // 总方案数为C(n,5)
+  let ans = comb(n, 5);
+  const mod = 10 ** 9 + 7;
+  // 统计不合法的个数
+  // 记录每个元素的个数
+  const hash = new Map();
+  for (const num of nums) hash.set(num, (hash.get(num) || 0) + 1);
+  const pre = new Map(); // 记录之前的元素情况
+  // 枚举x，作为子序列最中间的数
+  for (let i = 0; i < n - 2; i++) {
+    const x = nums[i];
+    hash.set(x, hash.get(x) - 1); // 更新右边元素的个数
+    if (i > 1) {
+      const right = n - 1 - i; // 右边元素个数
+      const left = i; // 左边元素个数
+      const preX = pre.get(x) || 0; // 左边x元素个数
+      const sufX = hash.get(x) || 0; // 右边x元素个数
+      // 不合法：只有一个x的情况，左边选取不是x的两个，右边选取不是x的两个
+      ans -= comb(left - preX, 2) * comb(right - sufX, 2);
+      // 不合法：有两个x，但是要有一个y，出现在2次以上
+      for (const [y, sufY] of hash) {
+        if (y === x) continue;
+        const preY = pre.get(y) || 0;
+        // 左边两个Y，右边一个X, yy x xz(z可以为y)
+        ans -= comb(preY, 2) * sufX * (right - sufX);
+        // 右边两个Y，左边一个X，zx x yy (z可以为y)
+        ans -= comb(sufY, 2) * preX * (left - preX);
+        // 左右各一个y，另一个x在左边，xy x yz(z !== y,避免重复)
+        ans -= preY * preX * sufY * (right - sufX - sufY);
+        // 左右各一个y，另一个x在右边，zy x yx(z !== y,避免重复)
+        ans -= preY * sufY * sufX * (left - preX - preY);
+      }
+    }
+    pre.set(x, (pre.get(x) || 0) + 1); // 更新左边元素的个数
+  }
+  return ans % mod;  
+};
+
+
+/**
+ * @description 求组合数
+ * @param {number} n
+ * @param {number} m
+ * @returns {number}
+ */
+function comb(n, m) {
+  if (n < m) return 0;
+  let top = 1;
+  let bottom = 1;
+  let start = 0;
+  while (start < m) {
+    top *= n - start;
+    bottom *= m - start;
+    start++;
+  }
+  return top / bottom;
+}
diff --git a/3399-smallest-substring-with-identical-characters-ii.js b/3399-smallest-substring-with-identical-characters-ii.js
new file mode 100644
index 00000000..ae74d5c5
--- /dev/null
+++ b/3399-smallest-substring-with-identical-characters-ii.js
@@ -0,0 +1,48 @@
+/**
+ * @param {string} s
+ * @param {number} numOps
+ * @return {number}
+ */
+var minLength = function (s, numOps) {
+  const arr = Array.from(s, Number)
+
+  const L = groupLengths(arr)
+
+  let l = 1,
+    r = 100000
+  while (l < r) {
+    const m = Math.floor((l + r) / 2)
+    const need = check(arr, m)
+    if (need <= numOps) {
+      r = m
+    } else {
+      l = m + 1
+    }
+  }
+  return l
+
+  function check(A, k) {
+    if (k === 1) {
+      let res = 0
+      for (let i = 0; i < A.length; i++) {
+        if (A[i] === i % 2) res++
+      }
+      return Math.min(res, A.length - res)
+    }
+    return L.reduce((acc, l) => acc + Math.floor(l / (k + 1)), 0)
+  }
+
+  function groupLengths(arr) {
+    const lengths = []
+    let count = 1
+    for (let i = 1; i <= arr.length; i++) {
+      if (i < arr.length && arr[i] === arr[i - 1]) {
+        count++
+      } else {
+        lengths.push(count)
+        count = 1
+      }
+    }
+    return lengths
+  }
+}
diff --git a/3404-count-special-subsequences.js b/3404-count-special-subsequences.js
new file mode 100644
index 00000000..69fc7410
--- /dev/null
+++ b/3404-count-special-subsequences.js
@@ -0,0 +1,21 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var numberOfSubsequences = function(nums) {
+        let n = nums.length;
+        let res = 0;
+        const cnt = new Map();
+        for (let r = 4; r < n - 2; ++r) {
+            let q = r - 2;
+            for (let p = 0; p < q - 1; ++p) {
+                let key = 1.0 * nums[p] / nums[q];
+                cnt.set(key, (cnt.get(key) || 0) + 1);
+            }
+            for (let s = r + 2; s < n; ++s) {
+                let key = 1.0 * nums[s] / nums[r];
+                res += cnt.get(key) || 0;
+            }
+        }
+        return res;
+};
diff --git a/3413-maximum-coins-from-k-consecutive-bags.js b/3413-maximum-coins-from-k-consecutive-bags.js
new file mode 100644
index 00000000..b2928c3e
--- /dev/null
+++ b/3413-maximum-coins-from-k-consecutive-bags.js
@@ -0,0 +1,35 @@
+/**
+ * @param {number[][]} coins
+ * @param {number} k
+ * @return {number}
+ */
+var maximumCoins = function(coins, k) {
+    coins.sort((a, b) => a[0] - b[0]);
+    const n = coins.length;
+
+    let res = 0, cur = 0;
+    for (let i = 0, j = 0; i < n; ++i) {
+        while (j < n && coins[j][1] <= coins[i][0] + k - 1) {
+            cur +=(coins[j][1] - coins[j][0] + 1) * (coins[j][2]);
+            j++;
+        }
+        if (j < n) {
+            const part =  Math.max(0, coins[i][0] + k - 1 - coins[j][0] + 1) * (coins[j][2]);
+            res = Math.max(res, cur + part);
+        }
+        cur -=  (coins[i][1] - coins[i][0] + 1) * (coins[i][2]);
+    }
+
+    cur = 0;
+    for (let i = 0, j = 0; i < n; ++i) {
+        cur += 1 * (coins[i][1] - coins[i][0] + 1) * (coins[i][2]);
+        while (coins[j][1] < coins[i][1] - k + 1) {
+            cur -= 1 * (coins[j][1] - coins[j][0] + 1) * (coins[j][2]);
+            j++;
+        }
+        const part = 1 * Math.max(0, coins[i][1] - k - coins[j][0] + 1) * (coins[j][2]);
+        res = Math.max(res, cur - part);
+    }
+
+    return res;
+};
diff --git a/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
new file mode 100644
index 00000000..7f057c86
--- /dev/null
+++ b/3428-maximum-and-minimum-sums-of-at-most-size-k-subsequences.js
@@ -0,0 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minMaxSums = function(nums, k) {
+  const big = BigInt
+  const mod = big(1e9 + 7)
+  const n = nums.length
+  const comb = Array.from({ length: n + 1 }, () => Array(k +  1).fill(0n))
+  
+  comb[0][0] = 1n
+  for(let i = 1; i <= n; i++) {
+    comb[i][0] = 1n
+    for(let j = 1; j <= k; j++) {
+        comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j]
+        comb[i][j] %= mod
+    }
+  }
+  
+  nums.sort((a, b) => a - b)
+
+  let res = 0n
+
+  for(let i = 0; i < n; i++) {
+    const e = big(nums[i])
+    for(let j = 0; j <= Math.min(i, k - 1); j++) {
+        res += (comb[i][j] * e) % mod
+    }
+    for(let j = 0; j < k; j++) {
+        res += (comb[n - 1 - i][j] * e) % mod
+    }
+  }
+
+
+  return Number(res % mod) 
+};
+
+// another
+
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minMaxSums = function(nums, k) {
+  nums.sort((a, b) => a - b)
+  let res = 0n
+  const MOD = 1e9 + 7
+  const ncr = Array.from({ length: nums.length + 1 }, () =>
+    Array(k + 1).fill(0),
+  )
+
+  ncr[0][0] = 1
+  for (let n = 1; n <= nums.length; n++) {
+    ncr[n][0] = 1
+    for (let r = 1; r <= k; r++)
+      ncr[n][r] = (ncr[n - 1][r - 1] + ncr[n - 1][r]) % MOD
+  }
+
+  for (let n = 0; n < nums.length; n++) {
+    let numberOfSubsequences = 0
+    for (let r = 0; r <= k - 1; r++)
+      if (n >= r)
+        numberOfSubsequences = (numberOfSubsequences + ncr[n][r]) % MOD
+    res =
+      (res +
+        ((BigInt(nums[n] + nums[nums.length - n - 1]) *
+          BigInt(numberOfSubsequences)) %
+          BigInt(MOD))) %
+      BigInt(MOD)
+  }
+  return Number(res)
+};
diff --git a/3444-minimum-increments-for-target-multiples-in-an-array.js b/3444-minimum-increments-for-target-multiples-in-an-array.js
new file mode 100644
index 00000000..f7115be1
--- /dev/null
+++ b/3444-minimum-increments-for-target-multiples-in-an-array.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} target
+ * @return {number}
+ */
+var minimumIncrements = function(nums, target) {
+    const k = target.length;
+    const mpp = new Map();
+
+    for (let mask = 1; mask < (1 << k); mask++) {
+        const subset = [];
+        for (let i = 0; i < k; i++) {
+            if (mask & (1 << i)) {
+                subset.push(target[i]);
+            }
+        }
+        let currlcm = subset[0];
+        for (let j = 1; j < subset.length; j++) {
+            currlcm = lcm(currlcm, subset[j]);
+        }
+        mpp.set(mask, currlcm);
+    }
+
+    const fullmask = (1 << k) - 1;
+    const dp = new Array(1 << k).fill(Infinity);
+    dp[0] = 0;
+
+    for (const num of nums) {
+        const maskcost = [];
+        for (const [mask, lcmval] of mpp) {
+            const rm = num % lcmval;
+            const cost = (rm === 0) ? 0 : (lcmval - rm);
+            maskcost.push([mask, cost]);
+        }
+
+        const newdp = [...dp];
+        for (let prevmask = 0; prevmask < (1 << k); prevmask++) {
+            if (dp[prevmask] === Infinity) continue;
+            for (const [mask, cost] of maskcost) {
+                const nmask = prevmask | mask;
+                const ncost = dp[prevmask] + cost;
+                if (ncost < newdp[nmask]) {
+                    newdp[nmask] = ncost;
+                }
+            }
+        }
+
+        dp.splice(0, dp.length, ...newdp);
+    }
+
+    return dp[fullmask] === Infinity ? -1 : dp[fullmask];
+};
+function gcd(a, b) {
+    while (b) {
+        [a, b] = [b, a % b];
+    }
+    return a;
+}
+
+function lcm(a, b) {
+    return (a / gcd(a, b)) * b;
+}
diff --git a/3449-maximize-the-minimum-game-score.js b/3449-maximize-the-minimum-game-score.js
new file mode 100644
index 00000000..abd1f14d
--- /dev/null
+++ b/3449-maximize-the-minimum-game-score.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} points
+ * @param {number} m
+ * @return {number}
+ */
+var maxScore = function (points, m) {
+  const n = points.length
+  if (m < n) return 0
+
+  const can = (val) => {
+    let total = 0,
+      transfer = 0,
+      skipAdd = 0
+    for (let i = 0; i < n && total <= m; i++) {
+      const point = points[i]
+      const necessary = Math.floor((val + point - 1) / point)
+      if (transfer >= necessary) {
+        transfer = 0
+        skipAdd++
+      } else {
+        const p = transfer * point
+        const ops = Math.floor((val - p + point - 1) / point)
+        total += 2 * ops - 1
+        total += skipAdd
+
+        transfer = Math.max(ops - 1, 0)
+        skipAdd = 0
+      }
+    }
+    return total <= m
+  }
+
+  let l = 1n,
+    r = 10n ** 15n
+  while (l < r) {
+    const mid = r - (r - l) / 2n
+    if (can(Number(mid))) {
+      l = mid
+    } else {
+      r = mid - 1n
+    }
+  }
+  return Number(l)
+}
diff --git a/3458-select-k-disjoint-special-substrings.js b/3458-select-k-disjoint-special-substrings.js
new file mode 100644
index 00000000..e25307b5
--- /dev/null
+++ b/3458-select-k-disjoint-special-substrings.js
@@ -0,0 +1,53 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {boolean}
+ */
+var maxSubstringLength = function (s, k) {
+    const n = s.length;
+    const first = Array(26).fill(-1);
+    const last = Array(26).fill(-1);
+    
+    for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        if (first[c] === -1) first[c] = i;
+        last[c] = i;
+    }
+
+    const intervals = [];
+    for (let i = 0; i < n; i++) {
+        const c = s.charCodeAt(i) - 'a'.charCodeAt(0);
+        if (i !== first[c]) continue;
+
+        let j = last[c];
+        for (let k = i; k <= j; k++) {
+            j = Math.max(j, last[s.charCodeAt(k) - 'a'.charCodeAt(0)]);
+        }
+
+        let flag = true;
+        for (let k = i; k <= j; k++) {
+            if (first[s.charCodeAt(k) - 'a'.charCodeAt(0)] < i) {
+                flag = false;
+                break;
+            }
+        }
+        if (!flag) continue;
+
+        if (i === 0 && j === n - 1) continue;
+
+        intervals.push([i, j]);
+    }
+
+    intervals.sort((a, b) => a[1] - b[1]);
+
+    let cnt = 0;
+    let currend = -1;
+    for (const i of intervals) {
+        if (i[0] > currend) {
+            cnt++;
+            currend = i[1];
+        }
+    }
+
+    return cnt >= k;
+}
diff --git a/3464-maximize-the-distance-between-points-on-a-square.js b/3464-maximize-the-distance-between-points-on-a-square.js
new file mode 100644
index 00000000..57f343dd
--- /dev/null
+++ b/3464-maximize-the-distance-between-points-on-a-square.js
@@ -0,0 +1,152 @@
+/**
+ * @param {number} side
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+const maxDistance = function (side, points, k) {
+  const n = points.length
+  const arr = []
+
+  const next = new Array(15000)
+
+  for (const p of points) {
+    if (p[0] === 0) {
+      arr.push(p[1])
+    } else if (p[1] === side) {
+      arr.push(side + p[0])
+    } else if (p[0] === side) {
+      arr.push(2 * side + side - p[1])
+    } else if (p[1] === 0) {
+      arr.push(3 * side + side - p[0])
+    }
+  }
+
+  arr.sort((a, b) => a - b)
+
+  let low = 0,
+    high = side
+  while (low < high) {
+    const mid = high - Math.floor((high - low) / 2)
+    if (isOK(mid, k)) {
+      low = mid
+    } else {
+      high = mid - 1
+    }
+  }
+  return low
+
+  function isOK(dist, k) {
+    let j = 0
+    for (let i = 0; i < n; i++) {
+      while (pos(j) - arr[i] < dist) {
+        j++
+      }
+      next[i] = j
+    }
+
+    for (let i = 0; i < n; i++) {
+      let flag = true
+      let cur = i
+      for (let t = 0; t < k - 1; t++) {
+        if (cur < n) {
+          cur = next[cur]
+        } else {
+          cur = next[cur % n] + n
+        }
+        if (cur >= i + n) {
+          flag = false
+          break
+        }
+      }
+      if (pos(i) - pos(cur % n) < dist) {
+        flag = false
+      }
+      if (flag) {
+        return true
+      }
+    }
+    return false
+  }
+
+  function pos(j) {
+    if (j < n) {
+      return arr[j]
+    } else {
+      return arr[j % n] + side * 4
+    }
+  }
+
+}
+
+
+// another
+
+
+/**
+ * @param {number} side
+ * @param {number[][]} points
+ * @param {number} k
+ * @return {number}
+ */
+var maxDistance = function (side, points, k) {
+  points = points
+    .map(([x, y]) => {
+      // convert to points on a flat line
+      if (x === 0) {
+        // left
+        return y
+      } else if (y === side) {
+        // top
+        return x + y
+      } else if (x === side) {
+        // right
+        return side * 2 + (side - y)
+      } else {
+        // bottom
+        return side * 3 + (side - x)
+      }
+    })
+    .sort((a, b) => a - b)
+
+  let low = 1,
+    high = side
+  while (low < high) {
+    let mid = Math.ceil((low + high) / 2)
+    if (isPossible(points, side, k, mid)) low = mid
+    else high = mid - 1
+  }
+  return low
+}
+
+// Check that we can take at least k points that are at least `minDist` apart
+function isPossible(points, side, k, minDist) {
+  const n = points.length,
+    endOfLine = side * 4
+  for (let i = 0; i < n; i++) {
+    let j = i,
+      taken = 1
+    while (taken < k) {
+      // binary search for the leftmost point at least `minDist` away from points[j], on the right of j.
+      let low = j,
+        high = n - 1
+      while (low < high) {
+        let mid = Math.floor((low + high) / 2)
+        if (points[mid] - points[j] >= minDist) high = mid
+        else low = mid + 1
+      }
+      // no valid point on the right side, or too close to the starting point (wraps around circularly).
+      if (
+        points[low] - points[j] < minDist ||
+        endOfLine + points[i] - points[low] < minDist
+      ) {
+        break
+      }
+      ;(j = low), taken++
+    }
+    if (taken === k) {
+      return true
+    }
+  }
+  return false
+}
diff --git a/3471-find-the-largest-almost-missing-integer.js b/3471-find-the-largest-almost-missing-integer.js
new file mode 100644
index 00000000..abe842fa
--- /dev/null
+++ b/3471-find-the-largest-almost-missing-integer.js
@@ -0,0 +1,23 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var largestInteger = function (nums, k) {
+  const freq = new Map()
+
+  for (let i = 0; i <= nums.length - k; i++) {
+    const sub = new Set(nums.slice(i, i + k))
+    for (const num of sub) {
+      freq.set(num, (freq.get(num) || 0) + 1)
+    }
+  }
+
+  let ans = -1
+  for (const [num, count] of freq) {
+    if (count === 1) {
+      ans = Math.max(ans, num)
+    }
+  }
+  return ans
+}
diff --git a/3472-longest-palindromic-subsequence-after-at-most-k-operations.js b/3472-longest-palindromic-subsequence-after-at-most-k-operations.js
new file mode 100644
index 00000000..2636a181
--- /dev/null
+++ b/3472-longest-palindromic-subsequence-after-at-most-k-operations.js
@@ -0,0 +1,32 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var longestPalindromicSubsequence = function (s, k) {
+  const n = s.length
+  const dp = Array.from({ length: n }, () =>
+    Array.from({ length: n }, () => Array(k + 1).fill(-1)),
+  )
+
+  function cost(a, b) {
+    const diff = Math.abs(a.charCodeAt(0) - b.charCodeAt(0))
+    return Math.min(diff, 26 - diff)
+  }
+
+  function dfs(i, j, rem) {
+    if (i > j) return 0
+    if (i === j) return 1
+    if (dp[i][j][rem] !== -1) return dp[i][j][rem]
+
+    let res = Math.max(dfs(i + 1, j, rem), dfs(i, j - 1, rem))
+    const c = cost(s[i], s[j])
+    if (c <= rem) {
+      res = Math.max(res, 2 + dfs(i + 1, j - 1, rem - c))
+    }
+    dp[i][j][rem] = res
+    return res
+  }
+
+  return dfs(0, n - 1, k)
+}
diff --git a/3473-sum-of-k-subarrays-with-length-at-least-m.js b/3473-sum-of-k-subarrays-with-length-at-least-m.js
new file mode 100644
index 00000000..7ca52435
--- /dev/null
+++ b/3473-sum-of-k-subarrays-with-length-at-least-m.js
@@ -0,0 +1,33 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} m
+ * @return {number}
+ */
+var maxSum = function (nums, k, m) {
+  const n = nums.length
+
+  const prefix = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] + nums[i]
+  }
+
+  const dp = Array.from({ length: k + 1 }, () =>
+    new Array(n + 1).fill(Number.MIN_SAFE_INTEGER / 2),
+  )
+  for (let i = 0; i <= n; i++) {
+    dp[0][i] = 0
+  }
+  for (let j = 0; j < k; j++) {
+    const best = new Array(n + 1).fill(0)
+    best[0] = dp[j][0] - prefix[0]
+    for (let i = 1; i <= n; i++) {
+      best[i] = Math.max(best[i - 1], dp[j][i] - prefix[i])
+    }
+    for (let i = m; i <= n; i++) {
+      const candidate = prefix[i] + best[i - m]
+      dp[j + 1][i] = i === m ? candidate : Math.max(dp[j + 1][i - 1], candidate)
+    }
+  }
+  return dp[k][n]
+}
diff --git a/3474-lexicographically-smallest-generated-string.js b/3474-lexicographically-smallest-generated-string.js
new file mode 100644
index 00000000..061efbba
--- /dev/null
+++ b/3474-lexicographically-smallest-generated-string.js
@@ -0,0 +1,59 @@
+/**
+ * @param {string} str1
+ * @param {string} str2
+ * @return {string}
+ */
+var generateString = function (str1, str2) {
+  const n = str1.length
+  const m = str2.length
+  const len = n + m - 1
+  const c = '*'
+
+  const ans = new Array(len).fill(c)
+  const forced = new Array(len).fill(false)
+
+  for (let i = 0; i < n; i++) {
+    if (str1[i] === 'T') {
+      for (let j = 0; j < m; j++) {
+        const pos = i + j
+        if (ans[pos] === c) {
+          ans[pos] = str2[j]
+          forced[pos] = true
+        } else {
+          if (ans[pos] !== str2[j]) return ''
+        }
+      }
+    }
+  }
+
+  for (let i = 0; i < len; i++) {
+    if (ans[i] === c) {
+      ans[i] = 'a'
+    }
+  }
+
+  for (let i = 0; i < n; i++) {
+    if (str1[i] === 'F') {
+      let windowEqual = true
+      for (let j = 0; j < m; j++) {
+        if (ans[i + j] !== str2[j]) {
+          windowEqual = false
+          break
+        }
+      }
+      if (windowEqual) {
+        let modified = false
+        for (let j = m - 1; j >= 0; j--) {
+          const pos = i + j
+          if (!forced[pos]) {
+            ans[pos] = 'b'
+            modified = true
+            break
+          }
+        }
+        if (!modified) return ''
+      }
+    }
+  }
+  return ans.join('')
+}
diff --git a/3477-fruits-into-baskets-ii.js b/3477-fruits-into-baskets-ii.js
new file mode 100644
index 00000000..ef332803
--- /dev/null
+++ b/3477-fruits-into-baskets-ii.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} fruits
+ * @param {number[]} baskets
+ * @return {number}
+ */
+var numOfUnplacedFruits = function (fruits, baskets) {
+  for (let i = 0; i < fruits.length; i++) {
+    for (let j = 0; j < baskets.length; j++) {
+      if (baskets[j] >= fruits[i]) {
+        baskets[j] = -1
+        break
+      }
+    }
+  }
+  let res = 0
+  for (let i = 0; i < baskets.length; i++) {
+    res += baskets[i] !== -1 ? 1 : 0
+  }
+  return res
+}
diff --git a/3478-choose-k-elements-with-maximum-sum.js b/3478-choose-k-elements-with-maximum-sum.js
new file mode 100644
index 00000000..864f3886
--- /dev/null
+++ b/3478-choose-k-elements-with-maximum-sum.js
@@ -0,0 +1,120 @@
+/**
+ * @param {number[]} nums1
+ * @param {number[]} nums2
+ * @param {number} k
+ * @return {number[]}
+ */
+var findMaxSum = function (nums1, nums2, k) {
+    const n = nums1.length;
+    const answer = new Array(n).fill(0);
+
+    const pairs = new Array(n);
+    for (let i = 0; i < n; i++) {
+        pairs[i] = new Pair(nums1[i], nums2[i], i);
+    }
+
+    pairs.sort((a, b) => a.num1 - b.num1);
+
+    const minHeap = new PQ((a, b) => a < b);
+    let currentSum = 0;
+
+    let i = 0;
+    while (i < n) {
+        let j = i;
+        while (j < n && pairs[j].num1 === pairs[i].num1) {
+            answer[pairs[j].index] = currentSum;
+            j++;
+        }
+        for (let t = i; t < j; t++) {
+            const value = pairs[t].num2;
+            if (minHeap.size() < k) {
+                minHeap.push(value);
+                currentSum += value;
+            } else if (!minHeap.isEmpty() && value > minHeap.peek()) {
+                currentSum -= minHeap.peek();
+                minHeap.pop();
+                minHeap.push(value);
+                currentSum += value;
+            }
+        }
+        i = j;
+    }
+
+    return answer;
+}
+class Pair {
+    constructor(num1, num2, index) {
+        this.num1 = num1;
+        this.num2 = num2;
+        this.index = index;
+    }
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
+
diff --git a/3479-fruits-into-baskets-iii.js b/3479-fruits-into-baskets-iii.js
new file mode 100644
index 00000000..d9077763
--- /dev/null
+++ b/3479-fruits-into-baskets-iii.js
@@ -0,0 +1,73 @@
+/**
+ * @param {number[]} fruits
+ * @param {number[]} baskets
+ * @return {number}
+ */
+var numOfUnplacedFruits = function (fruits, baskets) {
+  const n = fruits.length
+  const segTree = new SegmentTree(baskets)
+  let unplaced = 0
+
+  for (const fruit of fruits) {
+    const idx = segTree.query(fruit)
+    if (idx === -1) {
+      unplaced++
+    } else {
+      segTree.update(idx, -1)
+    }
+  }
+  return unplaced
+}
+class SegmentTree {
+  constructor(baskets) {
+    this.n = baskets.length
+    this.tree = new Array(4 * this.n)
+    this.build(baskets, 1, 0, this.n - 1)
+  }
+
+  build(baskets, node, start, end) {
+    if (start === end) {
+      this.tree[node] = baskets[start]
+    } else {
+      const mid = Math.floor((start + end) / 2)
+      this.build(baskets, 2 * node, start, mid)
+      this.build(baskets, 2 * node + 1, mid + 1, end)
+      this.tree[node] = Math.max(this.tree[2 * node], this.tree[2 * node + 1])
+    }
+  }
+
+  update(pos, val) {
+    this.updateNode(1, 0, this.n - 1, pos, val)
+  }
+
+  updateNode(node, start, end, pos, val) {
+    if (start === end) {
+      this.tree[node] = val
+    } else {
+      const mid = Math.floor((start + end) / 2)
+      if (pos <= mid) {
+        this.updateNode(2 * node, start, mid, pos, val)
+      } else {
+        this.updateNode(2 * node + 1, mid + 1, end, pos, val)
+      }
+      this.tree[node] = Math.max(this.tree[2 * node], this.tree[2 * node + 1])
+    }
+  }
+
+  query(required) {
+    if (this.tree[1] < required) return -1
+    return this.queryNode(1, 0, this.n - 1, required)
+  }
+
+  queryNode(node, start, end, required) {
+    if (start === end) {
+      return start
+    }
+    const mid = Math.floor((start + end) / 2)
+    if (this.tree[2 * node] >= required) {
+      return this.queryNode(2 * node, start, mid, required)
+    } else {
+      return this.queryNode(2 * node + 1, mid + 1, end, required)
+    }
+  }
+}
diff --git a/3480-maximize-subarrays-after-removing-one-conflicting-pair.js b/3480-maximize-subarrays-after-removing-one-conflicting-pair.js
new file mode 100644
index 00000000..ce7077f2
--- /dev/null
+++ b/3480-maximize-subarrays-after-removing-one-conflicting-pair.js
@@ -0,0 +1,113 @@
+/**
+ * @param {number} n
+ * @param {number[][]} conflictingPairs
+ * @return {number}
+ */
+var maxSubarrays = function (n, conflictingPairs) {
+  const best = new Array(n + 2).fill(n + 1)
+  const second = new Array(n + 2).fill(n + 1)
+  const freq = new Array(n + 2).fill(0)
+
+  for (const pair of conflictingPairs) {
+    let [a, b] = pair
+    if (a > b) {
+      ;[a, b] = [b, a]
+    }
+    if (b < best[a]) {
+      second[a] = best[a]
+      best[a] = b
+      freq[a] = 1
+    } else if (b === best[a]) {
+      freq[a]++
+    } else if (b < second[a]) {
+      second[a] = b
+    }
+  }
+
+  const F = new Array(n + 2).fill(0)
+  const M = new Array(n + 2).fill(0)
+  F[n + 1] = n + 1
+  F[n] = best[n]
+  M[n] = n
+  for (let i = n - 1; i >= 1; i--) {
+    if (best[i] <= F[i + 1]) {
+      F[i] = best[i]
+      M[i] = i
+    } else {
+      F[i] = F[i + 1]
+      M[i] = M[i + 1]
+    }
+  }
+
+  let origTotal = 0
+  for (let i = 1; i <= n; i++) {
+    origTotal += F[i] - i
+  }
+
+  const indicesByM = Array.from({ length: n + 2 }, () => [])
+  for (let i = 1; i <= n; i++) {
+    const idx = M[i]
+    indicesByM[idx].push(i)
+  }
+
+  const rmq = new RMQ(best, n)
+  let bestTotal = origTotal
+
+  for (let a = 1; a <= n; a++) {
+    if (best[a] === n + 1) continue
+    if (freq[a] > 1) continue
+    const B = best[a]
+    const newB = second[a]
+    const T = a < n ? F[a + 1] : n + 1
+    const effectiveCandidate = Math.min(newB, T)
+    if (effectiveCandidate <= B) continue
+
+    let delta = 0
+    for (const i of indicesByM[a]) {
+      const curOld = B
+      let candidate
+      if (i < a) {
+        candidate = rmq.query(i, a - 1)
+      } else {
+        candidate = n + 1
+      }
+      const newVal = Math.min(candidate, effectiveCandidate)
+      let improvement = newVal - curOld
+      if (improvement < 0) improvement = 0
+      delta += improvement
+    }
+    const candidateTotal = origTotal + delta
+    bestTotal = Math.max(bestTotal, candidateTotal)
+  }
+
+  return bestTotal
+}
+
+class RMQ {
+  constructor(arr, n) {
+    this.n = n
+    this.log = new Array(n + 2).fill(0)
+    for (let i = 2; i <= n; i++) {
+      this.log[i] = this.log[Math.floor(i / 2)] + 1
+    }
+    const K = this.log[n] + 1
+    this.st = Array.from({ length: n + 1 }, () => new Array(K).fill(0))
+    for (let i = 1; i <= n; i++) {
+      this.st[i][0] = arr[i]
+    }
+    for (let j = 1; j < K; j++) {
+      for (let i = 1; i + (1 << j) - 1 <= n; i++) {
+        this.st[i][j] = Math.min(
+          this.st[i][j - 1],
+          this.st[i + (1 << (j - 1))][j - 1],
+        )
+      }
+    }
+  }
+
+  query(L, R) {
+    if (L > R) return Infinity
+    const j = this.log[R - L + 1]
+    return Math.min(this.st[L][j], this.st[R - (1 << j) + 1][j])
+  }
+}
diff --git a/3487-maximum-unique-subarray-sum-after-deletion.js b/3487-maximum-unique-subarray-sum-after-deletion.js
new file mode 100644
index 00000000..f632eb4d
--- /dev/null
+++ b/3487-maximum-unique-subarray-sum-after-deletion.js
@@ -0,0 +1,11 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSum = function(nums) {
+  if (nums.every(num => num < 0)) {
+    return Math.max(...nums)
+  }
+  return Array.from(new Set(nums)).filter(num => num > 0).reduce((acc, num) => acc + num, 0)
+
+};
diff --git a/3488-closest-equal-element-queries.js b/3488-closest-equal-element-queries.js
new file mode 100644
index 00000000..489101fe
--- /dev/null
+++ b/3488-closest-equal-element-queries.js
@@ -0,0 +1,72 @@
+/**
+ * @param {number[]} nums
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+var solveQueries = function (nums, queries) {
+    const prabhatSize = nums.length;
+    const prabhatMap = new Map();
+
+    for (let prabhatIndex = 0; prabhatIndex < prabhatSize; prabhatIndex++) {
+        if (!prabhatMap.has(nums[prabhatIndex])) {
+            prabhatMap.set(nums[prabhatIndex], []);
+        }
+        prabhatMap.get(nums[prabhatIndex]).push(prabhatIndex);
+    }
+
+    for (const prabhatList of prabhatMap.values()) {
+        prabhatList.sort((a, b) => a - b);
+    }
+
+    const res = new Array(queries.length);
+
+    for (let i = 0; i < queries.length; i++) {
+        const prabhatQuery = queries[i];
+        const prabhatValue = nums[prabhatQuery];
+        const prabhatIndexList = prabhatMap.get(prabhatValue);
+
+        if (prabhatIndexList.length < 2) {
+            res[i] = -1;
+            continue;
+        }
+
+        let prabhatPos = binarySearch(prabhatIndexList, prabhatQuery);
+        if (prabhatPos < 0) {
+            prabhatPos = -prabhatPos - 1;
+        }
+
+        const prabhatLeftIndex = (prabhatPos - 1 + prabhatIndexList.length) % prabhatIndexList.length;
+        const prabhatRightIndex = (prabhatPos + 1) % prabhatIndexList.length;
+
+        const prabhatLeftCandidate = prabhatIndexList[prabhatLeftIndex];
+        const prabhatRightCandidate = prabhatIndexList[prabhatRightIndex];
+
+        let prabhatDistLeft = Math.abs(prabhatQuery - prabhatLeftCandidate);
+        let prabhatDistRight = Math.abs(prabhatQuery - prabhatRightCandidate);
+
+        prabhatDistLeft = Math.min(prabhatDistLeft, prabhatSize - prabhatDistLeft);
+        prabhatDistRight = Math.min(prabhatDistRight, prabhatSize - prabhatDistRight);
+
+        res[i] = Math.min(prabhatDistLeft, prabhatDistRight);
+    }
+
+    return res;
+}
+
+
+function binarySearch(arr, target) {
+    let left = 0;
+    let right = arr.length - 1;
+
+    while (left <= right) {
+        const mid = Math.floor((left + right) / 2);
+        if (arr[mid] === target) {
+            return mid; // Found the target
+        } else if (arr[mid] < target) {
+            left = mid + 1;
+        } else {
+            right = mid - 1;
+        }
+    }
+    return -(left + 1); // Target not found
+}
diff --git a/3489-zero-array-transformation-iv.js b/3489-zero-array-transformation-iv.js
new file mode 100644
index 00000000..d016ab29
--- /dev/null
+++ b/3489-zero-array-transformation-iv.js
@@ -0,0 +1,37 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var minZeroArray = function (nums, queries) {
+  if (nums.every((num) => num === 0)) return 0
+
+  function canZero(k) {
+    for (let i = 0; i < nums.length; i++) {
+      const target = nums[i]
+      const values = []
+      for (let j = 0; j < k; j++) {
+        const [l, r, v] = queries[j]
+        if (i >= l && i <= r) {
+          values.push(v)
+        }
+      }
+      const dp = new Array(target + 1).fill(false)
+      dp[0] = true
+      for (const v of values) {
+        for (let s = target; s >= v; s--) {
+          if (dp[s - v]) dp[s] = true
+        }
+      }
+      if (!dp[target]) return false
+    }
+    return true
+  }
+
+  for (let i = 0; i < queries.length; i++) {
+    if (canZero(i + 1)) {
+      return i + 1
+    }
+  }
+  return -1
+}
diff --git a/3490-count-beautiful-numbers.js b/3490-count-beautiful-numbers.js
new file mode 100644
index 00000000..481277db
--- /dev/null
+++ b/3490-count-beautiful-numbers.js
@@ -0,0 +1,63 @@
+/**
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var beautifulNumbers = function (l, r) {
+  const toDigits = (n) => Array.from(String(n), Number)
+
+  const countUpTo = (x) => (x < 0 ? 0n : dp(toDigits(x)))
+  return Number(countUpTo(r) - countUpTo(l - 1))
+
+  function dp(digits) {
+    const n = digits.length
+
+    const seen = new Map()
+
+    function dfs(pos, tight, started, s, p, hasZero) {
+      if (pos === n) {
+        if (!started) return 0n
+        return hasZero || (s !== 0 && p % s === 0) ? 1n : 0n
+      }
+      const key = state(pos, tight, started, s, p, hasZero)
+      if (seen.has(key)) return seen.get(key)
+
+      let ans = 0n
+      const limit = tight ? digits[pos] : 9
+      for (let d = 0; d <= limit; d++) {
+        const newTight = tight && d === limit
+        if (!started && d === 0) {
+          ans += dfs(pos + 1, newTight, false, 0, 1, false)
+        } else {
+          const newStarted = true
+          if (d === 0) {
+            ans += dfs(pos + 1, newTight, newStarted, s + d, 0, true)
+          } else {
+            const newP = !started ? d : p * d
+            ans += dfs(pos + 1, newTight, newStarted, s + d, newP, hasZero)
+          }
+        }
+      }
+      seen.set(key, ans)
+      return ans
+    }
+    return dfs(0, true, false, 0, 1, false)
+  }
+}
+
+function state(pos, tight, started, s, p, hasZero) {
+    return `${pos},${tight},${started},${s},${p},${hasZero}`
+}
+/*
+class State {
+  constructor(pos, tight, started, s, p, hasZero) {
+    this.pos = pos
+    this.tight = tight
+    this.started = started
+    this.s = s
+    this.p = p
+    this.hasZero = hasZero
+  }
+}
+*/
+
diff --git a/3498-reverse-degree-of-a-string.js b/3498-reverse-degree-of-a-string.js
new file mode 100644
index 00000000..3d554ea5
--- /dev/null
+++ b/3498-reverse-degree-of-a-string.js
@@ -0,0 +1,10 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var reverseDegree = function(s) {
+    return Array.from(s).reduce((sum, ch, i) => {
+        const pos = 'z'.charCodeAt(0) - ch.charCodeAt(0) + 1
+        return sum + pos * (i + 1)
+    }, 0)
+};
diff --git a/3499-maximize-active-section-with-trade-i.js b/3499-maximize-active-section-with-trade-i.js
new file mode 100644
index 00000000..6db89c42
--- /dev/null
+++ b/3499-maximize-active-section-with-trade-i.js
@@ -0,0 +1,39 @@
+/**
+ * @param {string} s
+ * @return {number}
+ */
+var maxActiveSectionsAfterTrade = function (s) {
+  const n = s.length
+  const c1 = Array.from(s).filter((char) => char === '1').length
+
+  let ans = 0
+  let i = 0
+  while (i < n) {
+    if (s[i] === '1') {
+      const start = i
+      while (i < n && s[i] === '1') {
+        i++
+      }
+      const end = i - 1
+      if (start > 0 && end < n - 1) {
+        let leftZeros = 0
+        let j = start - 1
+        while (j >= 0 && s[j] === '0') {
+          leftZeros++
+          j--
+        }
+        let rightZeros = 0
+        j = end + 1
+        while (j < n && s[j] === '0') {
+          rightZeros++
+          j++
+        }
+        const more = leftZeros + rightZeros
+        ans = Math.max(ans, more)
+      }
+    } else {
+      i++
+    }
+  }
+  return c1 + ans
+}
diff --git a/3500-minimum-cost-to-divide-array-into-subarrays.js b/3500-minimum-cost-to-divide-array-into-subarrays.js
new file mode 100644
index 00000000..c8b802b0
--- /dev/null
+++ b/3500-minimum-cost-to-divide-array-into-subarrays.js
@@ -0,0 +1,74 @@
+class ConvexHullTrick {
+  constructor() {
+    this.lines = []
+    this.pointer = 0
+  }
+
+  addLine(m, b) {
+    const newLine = { m, b, xLeft: 0 }
+    while (this.lines.length > 0) {
+      const last = this.lines[this.lines.length - 1]
+      const x = this.intersect(newLine, last)
+      if (x <= last.xLeft) {
+        this.lines.pop()
+      } else {
+        break
+      }
+    }
+    if (this.lines.length === 0) {
+      newLine.xLeft = -Infinity
+    } else {
+      newLine.xLeft = this.intersect(newLine, this.lines[this.lines.length - 1])
+    }
+    this.lines.push(newLine)
+  }
+
+  query(x) {
+    if (this.pointer >= this.lines.length) this.pointer = this.lines.length - 1
+    while (
+      this.pointer < this.lines.length - 1 &&
+      this.lines[this.pointer + 1].xLeft <= x
+    ) {
+      this.pointer++
+    }
+    return this.lines[this.pointer].m * x + this.lines[this.pointer].b
+  }
+
+  intersect(line1, line2) {
+    return (line2.b - line1.b) / (line1.m - line2.m)
+  }
+}
+
+function minimumCost(nums, cost, k) {
+  const n = nums.length
+  const preNum = new Array(n + 1).fill(0)
+  const preCost = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    preNum[i + 1] = preNum[i] + nums[i]
+    preCost[i + 1] = preCost[i] + cost[i]
+  }
+
+  const inf = Number.MAX_SAFE_INTEGER / 2
+  const dp = Array.from({ length: n + 1 }, () => new Array(n + 1).fill(inf))
+  dp[0][0] = 0
+
+  for (let j = 1; j <= n; j++) {
+    const cht = new ConvexHullTrick()
+    for (let l = j - 1; l < n; l++) {
+      if (dp[l][j - 1] < inf) {
+        cht.addLine(-preCost[l], dp[l][j - 1])
+      }
+    }
+    for (let i = j; i <= n; i++) {
+      const query = cht.query(preNum[i] + k * j)
+      dp[i][j] = (preNum[i] + k * j) * preCost[i] + query
+    }
+  }
+
+  let ans = inf
+  for (let j = 1; j <= n; j++) {
+    ans = Math.min(ans, dp[n][j])
+  }
+  return ans
+}
diff --git a/3507-minimum-pair-removal-to-sort-array-i.js b/3507-minimum-pair-removal-to-sort-array-i.js
new file mode 100644
index 00000000..c2196a1c
--- /dev/null
+++ b/3507-minimum-pair-removal-to-sort-array-i.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minimumPairRemoval = function (nums) {
+  let operations = 0
+
+  while (!isNonDecreasing(nums)) {
+    let minSum = Infinity
+    let idx = -1
+
+    for (let i = 0; i < nums.length - 1; i++) {
+      if (nums[i] + nums[i + 1] < minSum) {
+        minSum = nums[i] + nums[i + 1]
+        idx = i
+      }
+    }
+
+    const merged = nums[idx] + nums[idx + 1]
+    nums = nums.slice(0, idx).concat([merged], nums.slice(idx + 2))
+
+    operations += 1
+  }
+
+  return operations
+  function isNonDecreasing(arr) {
+    for (let i = 0; i < arr.length - 1; i++) {
+      if (arr[i] > arr[i + 1]) {
+        return false
+      }
+    }
+    return true
+  }
+}
diff --git a/3508-implement-router.js b/3508-implement-router.js
new file mode 100644
index 00000000..37ce3c33
--- /dev/null
+++ b/3508-implement-router.js
@@ -0,0 +1,96 @@
+class Router {
+    constructor(memoryLimit) {
+        this.memoryLimit = memoryLimit;
+        this.storage = [];
+        this.packetSet = new Set();
+        this.destMap = new Map();
+    }
+
+    addPacket(source, destination, timestamp) {
+        const packet = [source, destination, timestamp];
+        if (this.packetSet.has(packet.toString())) {
+            return false;
+        }
+
+        if (this.storage.length >= this.memoryLimit) {
+            this._removeOldest();
+        }
+
+        this.storage.push(packet);
+        this.packetSet.add(packet.toString());
+
+        if (!this.destMap.has(destination)) {
+            this.destMap.set(destination, []);
+        }
+
+        this.destMap.get(destination).push(timestamp);
+        return true;
+    }
+
+    forwardPacket() {
+        if (this.storage.length === 0) {
+            return [];
+        }
+
+        const packet = this.storage.shift();
+        const [source, destination, timestamp] = packet;
+        this.packetSet.delete(packet.toString());
+
+        const tsList = this.destMap.get(destination);
+        const idx = this._binarySearch(tsList, timestamp);
+        if (idx < tsList.length && tsList[idx] === timestamp) {
+            tsList.splice(idx, 1);
+        }
+
+        if (tsList.length === 0) {
+            this.destMap.delete(destination);
+        }
+
+        return [source, destination, timestamp];
+    }
+
+    getCount(destination, startTime, endTime) {
+        if (!this.destMap.has(destination)) {
+            return 0;
+        }
+
+        const tsList = this.destMap.get(destination);
+        const leftIndex = this._binarySearch(tsList, startTime);
+        const rightIndex = this._binarySearch(tsList, endTime, true);
+        return rightIndex - leftIndex;
+    }
+
+    _removeOldest() {
+        if (this.storage.length > 0) {
+            const packet = this.storage.shift();
+            const [source, destination, timestamp] = packet;
+            this.packetSet.delete(packet.toString());
+
+            const tsList = this.destMap.get(destination);
+            const idx = this._binarySearch(tsList, timestamp);
+            if (idx < tsList.length && tsList[idx] === timestamp) {
+                tsList.splice(idx, 1);
+            }
+
+            if (tsList.length === 0) {
+                this.destMap.delete(destination);
+            }
+        }
+    }
+
+    _binarySearch(arr, target, isRight = false) {
+        let left = 0;
+        let right = arr.length;
+
+        while (left < right) {
+            const mid = Math.floor((left + right) / 2);
+            if (arr[mid] < target || (isRight && arr[mid] === target)) {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+
+        return left;
+    }
+}
diff --git a/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js b/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js
new file mode 100644
index 00000000..faac4069
--- /dev/null
+++ b/3509-maximum-product-of-subsequences-with-an-alternating-sum-equal-to-k.js
@@ -0,0 +1,56 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @param {number} limit
+ * @return {number}
+ */
+var maxProduct = function(nums, k, limit) {
+    const MIN = -5000;
+    const dp = new Map();
+        const n = nums.length;
+
+        let sum = 0;
+        for (const x of nums) sum += x;
+
+        if (k > sum || k < -sum) return -1;
+
+ 
+        const ans = recursion(0, 0, 0, 0, k, n, nums, limit);
+        return (ans === MIN) ? -1 : ans;
+    function  recursion(pos, currSum, product, isOdd, k, n, nums, limit) {
+        if (pos === n) {
+            return (currSum === k && isOdd !== 0 && product <= limit ? product : MIN);
+        }
+
+        if (dp.has(pos) && dp.get(pos).has(currSum) && dp.get(pos).get(currSum).has(product) && dp.get(pos).get(currSum).get(product).has(isOdd)) {
+            return dp.get(pos).get(currSum).get(product).get(isOdd);
+        }
+
+        let ans = recursion(pos + 1, currSum, product, isOdd, k, n, nums, limit);
+        if (isOdd === 0) {
+            ans = Math.max(ans, recursion(pos + 1, currSum + nums[pos], nums[pos], 2, k, n, nums, limit));
+        }
+        if (isOdd === 1) {
+            ans = Math.max(ans, recursion(pos + 1, currSum + nums[pos], Math.min(product * nums[pos], limit + 1), 2, k, n, nums, limit));
+        }
+        if (isOdd === 2) {
+            ans = Math.max(ans, recursion(pos + 1, currSum - nums[pos], Math.min(product * nums[pos], limit + 1), 1, k, n, nums, limit));
+        }
+
+        if (!dp.has(pos)) {
+            dp.set(pos, new Map());
+        }
+        if (!dp.get(pos).has(currSum)) {
+            dp.get(pos).set(currSum, new Map());
+        }
+        if (!dp.get(pos).get(currSum).has(product)) {
+            dp.get(pos).get(currSum).set(product, new Map());
+        }
+        dp.get(pos).get(currSum).get(product).set(isOdd, ans);
+
+        return ans;
+    }
+};
+
+
+
diff --git a/3516-find-closest-person.js b/3516-find-closest-person.js
new file mode 100644
index 00000000..7269add4
--- /dev/null
+++ b/3516-find-closest-person.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} x
+ * @param {number} y
+ * @param {number} z
+ * @return {number}
+ */
+var findClosest = function(x, y, z) {
+    const cmp = Math.abs(x - z) - Math.abs(y - z)
+    if (cmp < 0) {
+        return 1
+    } else if (cmp > 0) {
+        return 2
+    } else {
+        return 0
+    }
+};
diff --git a/3517-smallest-palindromic-rearrangement-i.js b/3517-smallest-palindromic-rearrangement-i.js
new file mode 100644
index 00000000..298d0275
--- /dev/null
+++ b/3517-smallest-palindromic-rearrangement-i.js
@@ -0,0 +1,14 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var smallestPalindrome = function(s) {
+    const n = s.length
+    const pre = s.substring(0, Math.floor(n / 2))
+    const left = Array.from(pre).sort().join('')
+    if (n % 2 === 0) {
+        return `${left}${left.split('').reverse().join('')}`
+    } else {
+        return `${left}${s[Math.floor(n / 2)]}${left.split('').reverse().join('')}`
+    }
+};
diff --git a/3519-count-numbers-with-non-decreasing-digits.js b/3519-count-numbers-with-non-decreasing-digits.js
new file mode 100644
index 00000000..fd6f780c
--- /dev/null
+++ b/3519-count-numbers-with-non-decreasing-digits.js
@@ -0,0 +1,51 @@
+/**
+ * @param {string} l
+ * @param {string} r
+ * @param {number} b
+ * @return {number}
+ */
+var countNumbers = function (l, r, b) {
+  const mod = 1000000007
+
+  const bigL = BigInt(l)
+  const bigR = BigInt(r)
+
+  const rightCnt = helper(bigR, b)
+  const leftCnt = helper(bigL - 1n, b)
+  const ans = (rightCnt - leftCnt + BigInt(mod)) % BigInt(mod)
+  return Number(ans)
+  function helper(num, b) {
+    if (num < 0n) return 0n
+
+    // b base digits
+    const digits = Array.from(num.toString(b)).map((d) => BigInt(d) - 0n)
+    const n = digits.length
+
+    const seen = new Map()
+
+    function dfs(pos, last, started, tight) {
+      if (pos === n) return 1n
+
+      const key = `${pos}, ${last}, ${started}, ${tight}`
+      if (seen.has(key)) return seen.get(key)
+
+      const limit = tight ? digits[pos] : BigInt(b - 1)
+      let ways = 0n
+
+      for (let d = 0n; d <= limit; d++) {
+        if (started && d < last) continue
+
+        const nextStarted = started || d !== 0n
+        const nextLast = started || d !== 0n ? d : last
+
+        const nextTight = tight && d === limit
+        ways =
+          (ways + dfs(pos + 1, nextLast, nextStarted, nextTight)) % BigInt(mod)
+      }
+      seen.set(key, ways % BigInt(mod))
+      return ways
+    }
+
+    return dfs(0, 0n, false, true)
+  }
+}
diff --git a/3534-path-existence-queries-in-a-graph-ii.js b/3534-path-existence-queries-in-a-graph-ii.js
new file mode 100644
index 00000000..63bd8e88
--- /dev/null
+++ b/3534-path-existence-queries-in-a-graph-ii.js
@@ -0,0 +1,77 @@
+/**
+ * @param {number} n
+ * @param {number[]} nums
+ * @param {number} maxDiff
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var pathExistenceQueries = function (n, nums, maxDiff, queries) {
+  const sortedQueries = queries
+  const sortedIndices = Array.from({ length: n }, (_, i) => i)
+  const position = Array(n).fill(0)
+  const values = Array(n).fill(0)
+
+  sortedIndices.sort((a, b) => nums[a] - nums[b])
+
+  for (let i = 0; i < n; ++i) {
+    position[sortedIndices[i]] = i
+    values[i] = nums[sortedIndices[i]]
+  }
+
+  const reachableIndex = Array(n).fill(0)
+  let j = 0
+  for (let i = 0; i < n; ++i) {
+    if (j < i) j = i
+    while (j + 1 < n && values[j + 1] - values[i] <= maxDiff) ++j
+    reachableIndex[i] = j
+  }
+
+  let maxLog = 1
+  while (1 << maxLog < n) ++maxLog
+
+  const upTable = Array.from({ length: maxLog }, () => Array(n).fill(0))
+  upTable[0] = reachableIndex.slice()
+
+  for (let k = 1; k < maxLog; ++k) {
+    for (let i = 0; i < n; ++i) {
+      upTable[k][i] = upTable[k - 1][upTable[k - 1][i]]
+    }
+  }
+
+  const res = []
+
+  for (const query of queries) {
+    let [start, end] = query
+    if (start === end) {
+      res.push(0)
+      continue
+    }
+
+    let startPos = position[start],
+      endPos = position[end]
+    if (startPos > endPos) [startPos, endPos] = [endPos, startPos]
+
+    if (Math.abs(nums[start] - nums[end]) <= maxDiff) {
+      res.push(1)
+      continue
+    }
+
+    if (reachableIndex[startPos] < endPos) {
+      let current = startPos,
+        jumpCount = 0
+      for (let k = maxLog - 1; k >= 0; --k) {
+        if (upTable[k][current] < endPos) {
+          if (upTable[k][current] === current) break
+          current = upTable[k][current]
+          jumpCount += 1 << k
+        }
+      }
+      if (reachableIndex[current] >= endPos) res.push(jumpCount + 1)
+      else res.push(-1)
+    } else {
+      res.push(1)
+    }
+  }
+
+  return res
+}
diff --git a/3545-minimum-deletions-for-at-most-k-distinct-characters.js b/3545-minimum-deletions-for-at-most-k-distinct-characters.js
new file mode 100644
index 00000000..ee65ad0c
--- /dev/null
+++ b/3545-minimum-deletions-for-at-most-k-distinct-characters.js
@@ -0,0 +1,22 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var minDeletion = function(s, k) {
+  const hash = {}
+  for(let e of s) {
+      if(hash[e] == null) hash[e] = 0
+      hash[e]++
+  }
+  const arr = Object.entries(hash)
+  arr.sort((a, b) => a[1] - b[1])
+  if(arr.length <= k) return 0
+  let res = 0
+  while(arr.length > k) {
+      const e = arr.shift()
+      res += e[1]
+  }
+  
+  return res
+};
diff --git a/3546-equal-sum-grid-partition-i.js b/3546-equal-sum-grid-partition-i.js
new file mode 100644
index 00000000..330bbf51
--- /dev/null
+++ b/3546-equal-sum-grid-partition-i.js
@@ -0,0 +1,40 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+var canPartitionGrid = function (grid) {
+  const m = grid.length,
+    n = grid[0].length
+  let totalSum = 0
+  for (let i = 0; i < m; i++) {
+    for (let j = 0; j < n; j++) {
+      totalSum += grid[i][j]
+    }
+  }
+
+  if (totalSum % 2 === 1) return false
+  const target = totalSum / 2
+  let sum = 0
+  // row
+  for (let i = 0; i < m; i++) {
+    let tmp = 0
+    for (let j = 0; j < n; j++) {
+      tmp += grid[i][j]
+    }
+    sum += tmp
+    if (i !== m - 1 && sum === target) return true
+  }
+
+  // col
+  sum = 0
+  for (let j = 0; j < n; j++) {
+    let tmp = 0
+    for (let i = 0; i < m; i++) {
+      tmp += grid[i][j]
+    }
+    sum += tmp
+    if (j !== n - 1 && target === sum) return true
+  }
+
+  return false
+}
diff --git a/3547-maximum-sum-of-edge-values-in-a-graph.js b/3547-maximum-sum-of-edge-values-in-a-graph.js
new file mode 100644
index 00000000..cf544807
--- /dev/null
+++ b/3547-maximum-sum-of-edge-values-in-a-graph.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @return {number}
+ */
+var maxScore = function (n, edges) {
+  const G = new Map()
+  edges.forEach(([i, j]) => {
+    if (!G.has(i)) G.set(i, [])
+    if (!G.has(j)) G.set(j, [])
+    G.get(i).push(j)
+    G.get(j).push(i)
+  })
+
+  function get_comp(i) {
+    const bfs = [i]
+    seen[i] = true
+    for (let idx = 0; idx < bfs.length; idx++) {
+      const current = bfs[idx]
+      for (const j of G.get(current) || []) {
+        if (!seen[j]) {
+          seen[j] = true
+          bfs.push(j)
+        }
+      }
+    }
+    return bfs
+  }
+
+  const C = []
+  const L = []
+  const seen = new Array(n).fill(false)
+  for (let i = 0; i < n; i++) {
+    if (!seen[i]) {
+      const comp = get_comp(i)
+      if (comp.every((x) => (G.get(x) || []).length === 2)) {
+        C.push(comp.length)
+      } else if (comp.length > 1) {
+        L.push(comp.length)
+      }
+    }
+  }
+
+  function calc(l, r, is_cycle) {
+    const d = [r, r]
+    let res = 0
+    for (let a = r - 1; a >= l; a--) {
+      const v = d.shift()
+      res += v * a
+      d.push(a)
+    }
+    return res + d[0] * d[1] * is_cycle
+  }
+
+  let res = 0
+  L.sort((a, b) => b - a)
+  for (const k of C) {
+    res += calc(n - k + 1, n, 1)
+    n -= k
+  }
+  for (const k of L) {
+    res += calc(n - k + 1, n, 0)
+    n -= k
+  }
+  return res
+}
diff --git a/3548-equal-sum-grid-partition-ii.js b/3548-equal-sum-grid-partition-ii.js
new file mode 100644
index 00000000..801091f6
--- /dev/null
+++ b/3548-equal-sum-grid-partition-ii.js
@@ -0,0 +1,107 @@
+/**
+ * @param {number[][]} grid
+ * @return {boolean}
+ */
+var canPartitionGrid = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+
+  let totalRowSum = 0n,
+    totalColSum = 0n
+  const prefixRowWise = new Array(n).fill(0n)
+  const prefixColWise = new Array(m).fill(0n)
+
+  const MAXV = 100000
+  const minRow = new Array(MAXV + 1).fill(null)
+  const maxRow = new Array(MAXV + 1).fill(null)
+  const minCol = new Array(MAXV + 1).fill(null)
+  const maxCol = new Array(MAXV + 1).fill(null)
+
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      const v = grid[i][j]
+      const val = BigInt(v)
+      prefixRowWise[i] += val
+      prefixColWise[j] += val
+
+      if (minRow[v] === null) {
+        minRow[v] = maxRow[v] = i
+        minCol[v] = maxCol[v] = j
+      } else {
+        if (i < minRow[v]) minRow[v] = i
+        if (i > maxRow[v]) maxRow[v] = i
+        if (j < minCol[v]) minCol[v] = j
+        if (j > maxCol[v]) maxCol[v] = j
+      }
+    }
+  }
+
+  for (const r of prefixRowWise) totalRowSum += r
+  totalColSum = totalRowSum
+
+  let currentRowUpperSum = 0n
+  for (let i = 0; i < n - 1; i++) {
+    currentRowUpperSum += prefixRowWise[i]
+    const lowerSegmentSum = totalRowSum - currentRowUpperSum
+    if (currentRowUpperSum === lowerSegmentSum) return true
+
+    if (currentRowUpperSum > lowerSegmentSum) {
+      const diff = currentRowUpperSum - lowerSegmentSum
+      if (diff <= MAXV && minRow[Number(diff)] !== null) {
+        if (i === 0 || m === 1) {
+          if (diff === BigInt(grid[0][0]) || diff === BigInt(grid[0][m - 1]))
+            return true
+        } else if (minRow[Number(diff)] <= i) {
+          return true
+        }
+      }
+    } else {
+      const diff = lowerSegmentSum - currentRowUpperSum
+      if (diff <= MAXV && maxRow[Number(diff)] !== null) {
+        if (i === n - 2 || m === 1) {
+          if (
+            diff === BigInt(grid[i + 1][0]) ||
+            diff === BigInt(grid[i + 1][m - 1])
+          )
+            return true
+        } else if (maxRow[Number(diff)] > i) {
+          return true
+        }
+      }
+    }
+  }
+
+  let currentColLeftSum = 0n
+  for (let j = 0; j < m - 1; j++) {
+    currentColLeftSum += prefixColWise[j]
+    const rightSegmentSum = totalColSum - currentColLeftSum
+    if (currentColLeftSum === rightSegmentSum) return true
+
+    if (currentColLeftSum > rightSegmentSum) {
+      const diff = currentColLeftSum - rightSegmentSum
+      if (diff <= MAXV && minCol[Number(diff)] !== null) {
+        if (j === 0 || n === 1) {
+          if (diff === BigInt(grid[0][0]) || diff === BigInt(grid[n - 1][0]))
+            return true
+        } else if (minCol[Number(diff)] <= j) {
+          return true
+        }
+      }
+    } else {
+      const diff = rightSegmentSum - currentColLeftSum
+      if (diff <= MAXV && maxCol[Number(diff)] !== null) {
+        if (j === m - 2 || n === 1) {
+          if (
+            diff === BigInt(grid[0][j + 1]) ||
+            diff === BigInt(grid[n - 1][j + 1])
+          )
+            return true
+        } else if (maxCol[Number(diff)] > j) {
+          return true
+        }
+      }
+    }
+  }
+
+  return false
+}
diff --git a/3550-smallest-index-with-digit-sum-equal-to-index.js b/3550-smallest-index-with-digit-sum-equal-to-index.js
new file mode 100644
index 00000000..00f94f06
--- /dev/null
+++ b/3550-smallest-index-with-digit-sum-equal-to-index.js
@@ -0,0 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var smallestIndex = function(nums) {
+  const n = nums.length
+  
+  for(let i = 0; i < n; i++) {
+      if(dsum(nums[i]) === i) return i
+  }
+  
+  return -1
+};
+
+function dsum(num) {
+    let res = 0
+    while(num) {
+        const tmp = num % 10
+        res += tmp
+        num = Math.floor(num / 10)
+    }
+    
+    return res
+}
diff --git a/3551-minimum-swaps-to-sort-by-digit-sum.js b/3551-minimum-swaps-to-sort-by-digit-sum.js
new file mode 100644
index 00000000..74bcde0a
--- /dev/null
+++ b/3551-minimum-swaps-to-sort-by-digit-sum.js
@@ -0,0 +1,34 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minSwaps = function (nums) {
+  const n = nums.length
+  let res = 0
+  const visited = new Array(n).fill(false)
+  const arr = nums.map((p, i) => [digitSum(p), p, i])
+  arr.sort((a, b) => a[0] - b[0] || a[1] - b[1])
+
+  for (let i = 0; i < n; i++) {
+    if (visited[i] || arr[i][2] === i) {
+      continue
+    }
+    let length = 0
+    let j = i
+    while (!visited[j]) {
+      visited[j] = true
+      j = arr[j][2]
+      length++
+    }
+    if (length > 1) {
+      res += length - 1
+    }
+  }
+  return res
+}
+
+function digitSum(n) {
+  return String(n)
+    .split('')
+    .reduce((sum, d) => sum + parseInt(d), 0)
+}
diff --git a/3552-grid-teleportation-traversal.js b/3552-grid-teleportation-traversal.js
new file mode 100644
index 00000000..a10f3a34
--- /dev/null
+++ b/3552-grid-teleportation-traversal.js
@@ -0,0 +1,148 @@
+/**
+ * @param {string[]} matrix
+ * @return {number}
+ */
+var minMoves = function (matrix) {
+  const n = matrix.length,
+    m = matrix[0].length
+
+  const cells = {}
+  for (let i = 0; i < n; i++) {
+    for (let j = 0; j < m; j++) {
+      if (matrix[i][j] !== '.' && matrix[i][j] !== '#') {
+        if (!cells[matrix[i][j]]) {
+          cells[matrix[i][j]] = []
+        }
+        cells[matrix[i][j]].push([i, j])
+      }
+    }
+  }
+
+  if (matrix[n - 1][m - 1] === '#') return -1
+
+  const pq = new PQ((a, b) => a[0] < b[0])
+  const dist = Array.from({ length: n }, () => Array(m).fill(Infinity))
+  const used = new Set()
+
+  pq.push([0, 0, 0])
+  dist[0][0] = 0
+
+  const dx = [0, 0, -1, 1]
+  const dy = [-1, 1, 0, 0]
+
+  while (!pq.isEmpty()) {
+    const [curDist, x, y] = pq.pop()
+
+    if (curDist > dist[x][y]) continue
+    if (x === n - 1 && y === m - 1) return curDist
+
+    if (
+      isUpper(matrix[x][y]) &&
+      !used.has(matrix[x][y])
+    ) {
+      used.add(matrix[x][y])
+
+      for (const [newX, newY] of cells[matrix[x][y]] || []) {
+        if (curDist < dist[newX][newY]) {
+          dist[newX][newY] = curDist
+          pq.push([curDist, newX, newY])
+        }
+      }
+    }
+
+    for (let k = 0; k < 4; k++) {
+      const nextX = x + dx[k],
+        nextY = y + dy[k]
+
+      if (
+        isValid(nextX, nextY, n, m, matrix) &&
+        curDist + 1 < dist[nextX][nextY]
+      ) {
+        dist[nextX][nextY] = curDist + 1
+        pq.push([curDist + 1, nextX, nextY])
+      }
+    }
+  }
+
+  return -1
+}
+
+function isUpper(ch) {
+    const A = 'A'.charCodeAt(0)
+    const Z = 'Z'.charCodeAt(0)
+    const code = ch.charCodeAt(0)
+    return code >= A && code <= Z
+}
+function isValid(i, j, n, m, matrix) {
+  if (i < 0 || j < 0 || i >= n || j >= m) return false
+  if (matrix[i][j] === '#') return false
+  return true
+}
+
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
diff --git a/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js b/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js
new file mode 100644
index 00000000..3ed5557a
--- /dev/null
+++ b/3553-minimum-weighted-subgraph-with-the-required-paths-ii.js
@@ -0,0 +1,75 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var minimumWeight = function (edges, queries) {
+  const n = edges.length + 1
+  const adj = Array.from({ length: n }, () => [])
+  for (const [u, v, w] of edges) {
+    adj[u].push([v, w])
+    adj[v].push([u, w])
+  }
+
+  const parent = Array.from({ length: n }, (_, i) => i)
+  const size = Array(n).fill(1)
+
+  function findSet(v) {
+    while (parent[v] !== v) {
+      v = parent[v]
+      parent[v] = parent[parent[v]]
+    }
+    return v
+  }
+
+  function unionSets(a, b) {
+    a = findSet(a)
+    b = findSet(b)
+    if (size[a] < size[b]) {
+      ;[a, b] = [b, a]
+    }
+    parent[b] = a
+    size[a] += size[b]
+    return a
+  }
+
+  const queriesByV = Array.from({ length: n }, () => [])
+  for (let i = 0; i < queries.length; i++) {
+    const [a, b, c] = queries[i]
+    queriesByV[a].push([b, c, i])
+    queriesByV[b].push([c, a, i])
+    queriesByV[c].push([a, b, i])
+  }
+
+  const visited = Array(n).fill(false)
+  const ancestor = Array.from({ length: n }, (_, i) => i)
+  const dist = Array(n).fill(0)
+  const res = Array(queries.length).fill(0)
+
+  function dfs(v) {
+    visited[v] = true
+
+    for (const [b, c, i] of queriesByV[v]) {
+      res[i] += dist[v]
+      if (visited[b]) {
+        res[i] -= dist[ancestor[findSet(b)]]
+      }
+      if (visited[c]) {
+        res[i] -= dist[ancestor[findSet(c)]]
+      }
+    }
+
+    for (const [u, w] of adj[v]) {
+      if (visited[u]) {
+        continue
+      }
+
+      dist[u] = dist[v] + w
+      dfs(u)
+      ancestor[unionSets(v, u)] = v
+    }
+  }
+
+  dfs(0)
+  return res
+}
diff --git a/3559-number-of-ways-to-assign-edge-weights-ii.js b/3559-number-of-ways-to-assign-edge-weights-ii.js
new file mode 100644
index 00000000..21d39010
--- /dev/null
+++ b/3559-number-of-ways-to-assign-edge-weights-ii.js
@@ -0,0 +1,88 @@
+/**
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var assignEdgeWeights = function (edges, queries) {
+  const n = edges.length + 1,
+    graph = Array(n)
+      .fill(0)
+      .map(() => [])
+  for (let [u, v] of edges) {
+    graph[u - 1].push(v - 1)
+    graph[v - 1].push(u - 1)
+  }
+  const directParent = Array(n),
+    depth = Array(n)
+  dfs(0, -1, 0)
+  const lca = new LCA(n, directParent, depth)
+  const answer = [],
+    MOD = 1000000007n
+  for (let [u, v] of queries) {
+    const pathLen = lca.getDist(u - 1, v - 1)
+    const ways = pathLen === 0 ? 0n : 2n ** BigInt(pathLen - 1)
+    answer.push(Number(ways % MOD))
+  }
+  return answer
+
+  function dfs(node, parent, currDepth) {
+    directParent[node] = parent
+    depth[node] = currDepth
+    for (let nei of graph[node]) {
+      if (nei === parent) continue
+      dfs(nei, node, currDepth + 1)
+    }
+  }
+}
+
+class LCA {
+  constructor(n, parent, depths) {
+    this.maxDepth = Math.ceil(Math.log2(n))
+    this.p = Array(this.maxDepth + 1)
+      .fill(0)
+      .map(() => Array(n).fill(-1)) // parents
+    this.depths = depths
+    for (let node = 0; node < n; node++) {
+      this.p[0][node] = parent[node]
+    }
+    for (let pow2 = 1; pow2 <= this.maxDepth; pow2++) {
+      for (let node = 0; node < n; node++) {
+        const halfParent = this.p[pow2 - 1][node]
+        if (halfParent !== -1) {
+          this.p[pow2][node] = this.p[pow2 - 1][halfParent]
+        }
+      }
+    }
+  }
+  getLCA(a, b) {
+    if (this.depths[a] > this.depths[b]) {
+      let temp = a
+      a = b
+      b = temp
+    }
+    let depthDiff = this.depths[b] - this.depths[a]
+    for (let i = 0; i <= this.maxDepth; i++) {
+      if ((depthDiff >> i) & 1) {
+        b = this.p[i][b] // move b up to the 2^ith parent
+      }
+    }
+    if (a === b) return a
+
+    // move both nodes up by 2^ith levels if the 2^ith parents are not equal
+    for (let i = this.maxDepth; i >= 0; i--) {
+      // this decrements so that we can jump the nodes up incrementally
+      if (this.p[i][a] !== this.p[i][b]) {
+        // if 2^ith parents of both nodes are not equal, we can safely both move up
+        a = this.p[i][a]
+        b = this.p[i][b]
+      }
+    }
+    return this.p[0][a]
+  }
+  getDist(a, b) {
+    const lca = this.getLCA(a, b)
+    const depthA = this.depths[a] - this.depths[lca]
+    const depthB = this.depths[b] - this.depths[lca]
+    return depthA + depthB
+  }
+}
diff --git a/3560-find-minimum-log-transportation-cost.js b/3560-find-minimum-log-transportation-cost.js
new file mode 100644
index 00000000..28160ed6
--- /dev/null
+++ b/3560-find-minimum-log-transportation-cost.js
@@ -0,0 +1,16 @@
+/**
+ * @param {number} n
+ * @param {number} m
+ * @param {number} k
+ * @return {number}
+ */
+var minCuttingCost = function(n, m, k) {
+    let res = 0
+    if (n > k) {
+        res += (n - k) * k
+    }
+    if (m > k) {
+        res += (m - k) * k
+    }
+    return res
+};
diff --git a/3561-resulting-string-after-adjacent-removals.js b/3561-resulting-string-after-adjacent-removals.js
new file mode 100644
index 00000000..4372f66d
--- /dev/null
+++ b/3561-resulting-string-after-adjacent-removals.js
@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @return {string}
+ */
+var resultingString = function (s) {
+  let stack = []
+  for (let c of s) {
+    if (stack.length === 0) {
+      stack.push(c)
+    } else {
+      if (
+        (c === 'z' && stack[stack.length - 1] === 'a') ||
+        (c === 'a' && stack[stack.length - 1] === 'z') ||
+        Math.abs(c.charCodeAt(0) - stack[stack.length - 1].charCodeAt(0)) === 1
+      ) {
+        stack.pop()
+      } else {
+        stack.push(c)
+      }
+    }
+  }
+  return stack.join('')
+}
diff --git a/3562-maximum-profit-from-trading-stocks-with-discounts.js b/3562-maximum-profit-from-trading-stocks-with-discounts.js
new file mode 100644
index 00000000..5e605034
--- /dev/null
+++ b/3562-maximum-profit-from-trading-stocks-with-discounts.js
@@ -0,0 +1,66 @@
+/**
+ * @param {number} n
+ * @param {number[]} present
+ * @param {number[]} future
+ * @param {number[][]} hierarchy
+ * @param {number} budget
+ * @return {number}
+ */
+var maxProfit = function (n, present, future, hierarchy, budget) {
+  const freq = {}
+  for (const [p, c] of hierarchy) {
+    if (!freq[p]) freq[p] = []
+    freq[p].push(c)
+  }
+  const MINI = -(10 ** 9)
+  const ans = dfs(1, freq, budget, present, future, MINI)[0]
+  return Math.max(...ans)
+
+  function dfs(u, freq, budget, present, future, MINI) {
+    const dp = (freq[u] || []).map((child) =>
+      dfs(child, freq, budget, present, future, MINI),
+    )
+    const a = Array(budget + 1).fill(MINI)
+    const b = Array(budget + 1).fill(MINI)
+
+    for (let v = 0; v < 2; v++) {
+      let x = Array(budget + 1).fill(MINI)
+      let y = Array(budget + 1).fill(MINI)
+      x[0] = 0
+      const c = v === 0 ? present[u - 1] : Math.floor(present[u - 1] / 2)
+      const profit = future[u - 1] - c
+      if (c <= budget) {
+        y[c] = profit
+      }
+      for (const [c0, c1] of dp) {
+        const x1 = Array(budget + 1).fill(MINI)
+        const y1 = Array(budget + 1).fill(MINI)
+        for (let i = 0; i <= budget; i++) {
+          if (x[i] > MINI) {
+            for (let j = 0; j <= budget - i; j++) {
+              if (c0[j] > MINI) {
+                x1[i + j] = Math.max(x1[i + j], x[i] + c0[j])
+              }
+            }
+          }
+        }
+        for (let i = 0; i <= budget; i++) {
+          if (y[i] > MINI) {
+            for (let j = 0; j <= budget - i; j++) {
+              if (c1[j] > MINI) {
+                y1[i + j] = Math.max(y1[i + j], y[i] + c1[j])
+              }
+            }
+          }
+        }
+        x = x1
+        y = y1
+      }
+      const dp1 = v === 0 ? a : b
+      for (let i = 0; i <= budget; i++) {
+        dp1[i] = Math.max(x[i], y[i])
+      }
+    }
+    return [a, b]
+  }
+}
diff --git a/3579-minimum-steps-to-convert-string-with-operations.js b/3579-minimum-steps-to-convert-string-with-operations.js
new file mode 100644
index 00000000..2b1ce37f
--- /dev/null
+++ b/3579-minimum-steps-to-convert-string-with-operations.js
@@ -0,0 +1,54 @@
+/**
+ * @param {string} word1
+ * @param {string} word2
+ * @return {number}
+ */
+var minOperations = function (word1, word2) {
+  const arr1 = word1.split('')
+  const arr2 = word2.split('')
+  const n = arr1.length
+  const dp = Array.from({ length: n }, () => Array(n).fill(null))
+  const res = solve(0, 0, arr1, arr2, n, dp)
+  return res
+}
+
+function solve(i, j, arr1, arr2, n, dp) {
+  if (i >= n) return 0
+  if (j >= n) return 100000
+
+  if (dp[i][j] !== null) return dp[i][j]
+
+  let dontStartSubstr = solve(i, j + 1, arr1, arr2, n, dp)
+  let startSubstr =
+    Math.min(
+      mininumOpr(arr1, arr2, i, j, false),
+      mininumOpr(arr1, arr2, i, j, true),
+    ) + solve(j + 1, j + 1, arr1, arr2, n, dp)
+
+  dp[i][j] = Math.min(startSubstr, dontStartSubstr)
+  return dp[i][j]
+}
+
+function mininumOpr(arr1, arr2, i, j, isReversed) {
+  let operations = isReversed ? 1 : 0
+  let x = i
+  let idx = isReversed ? j : i
+  const mul = isReversed ? -1 : 1
+  const freqOfMismatched = Array.from({ length: 26 }, () => Array(26).fill(0))
+
+  while (x <= j) {
+    if (arr1[x] !== arr2[idx]) {
+      const wanted = arr1[x].charCodeAt(0) - 97
+      const got = arr2[idx].charCodeAt(0) - 97
+      if (freqOfMismatched[got][wanted] > 0) {
+        freqOfMismatched[got][wanted]--
+      } else {
+        freqOfMismatched[wanted][got]++
+        operations++
+      }
+    }
+    x++
+    idx += mul
+  }
+  return operations
+}
diff --git a/3585-find-weighted-median-node-in-tree.js b/3585-find-weighted-median-node-in-tree.js
new file mode 100644
index 00000000..1711079c
--- /dev/null
+++ b/3585-find-weighted-median-node-in-tree.js
@@ -0,0 +1,118 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+const findMedian = (n, edges, queries) => {
+  const graph = {}
+  for (const [u, v, w] of edges) {
+    if (!graph[u]) graph[u] = {}
+    if (!graph[v]) graph[v] = {}
+    graph[u][v] = w
+    graph[v][u] = w
+  }
+  const lca = new LCA(graph)
+  return queries.map(([u, v]) => lca.median(u, v))
+}
+
+class LCA {
+  constructor(graph, root = 0) {
+    this.graph = graph
+    this.ancestors = {}
+    this.timeIn = {}
+    this.timeOut = {}
+    this.timer = 0
+    this.depth = {}
+    this.dist = {}
+    this.dfs(root, root, [root])
+  }
+
+  dfs(v, parent, path, d = 0) {
+    this.timer += 1
+    this.timeIn[v] = this.timer
+    let up = 1
+    while (path.length >= up) {
+      if (!this.ancestors[v]) this.ancestors[v] = []
+      this.ancestors[v].push(path[path.length - up])
+      up *= 2
+    }
+    this.depth[v] = path.length
+    this.dist[v] = d
+    path.push(v)
+    for (const [u, w] of Object.entries(this.graph[v])) {
+      if (u != parent) {
+        this.dfs(+u, v, path, d + w)
+      }
+    }
+    path.pop()
+    this.timer += 1
+    this.timeOut[v] = this.timer
+  }
+
+  isAncestor(u, v) {
+    return (
+      this.timeIn[u] <= this.timeIn[v] && this.timeOut[u] >= this.timeOut[v]
+    )
+  }
+
+  lca(u, v) {
+    if (this.isAncestor(u, v)) {
+      return u
+    } else if (this.isAncestor(v, u)) {
+      return v
+    }
+    let d = this.ancestors[u].length - 1
+    while (d >= 0) {
+      d = Math.min(d, this.ancestors[u].length - 1)
+      if (!this.isAncestor(this.ancestors[u][d], v)) {
+        u = this.ancestors[u][d]
+      }
+      d -= 1
+    }
+    return this.ancestors[u][0]
+  }
+
+  distance(u, v) {
+    const a = this.lca(u, v)
+    if (a === u || a === v) {
+      return Math.abs(this.dist[v] - this.dist[u])
+    }
+    return this.dist[u] - this.dist[a] + (this.dist[v] - this.dist[a])
+  }
+
+  findNodeDist(u, distance, mode = 0) {
+    let d = this.ancestors[u].length - 1
+    let m = u
+    while (d >= 0) {
+      d = Math.min(d, this.ancestors[u].length - 1)
+      const v = this.ancestors[u][d]
+      if (this.dist[v] >= distance) {
+        m = v
+        u = this.ancestors[u][d]
+      }
+      d -= 1
+    }
+    if (mode === 0 || this.dist[m] === distance) {
+      return m
+    }
+    return this.ancestors[m][0]
+  }
+
+  median(u, v) {
+    const goal = this.distance(u, v) / 2
+    const a = this.lca(u, v)
+    if (u === a) {
+      return this.findNodeDist(v, goal + this.dist[u])
+    } else if (v === a) {
+      return this.findNodeDist(u, goal + this.dist[v], 1)
+    } else {
+      const d = this.distance(a, u)
+      if (d >= goal) {
+        return this.findNodeDist(u, d - goal + this.dist[a], 1)
+      } else {
+        return this.findNodeDist(v, goal - d + this.dist[a])
+      }
+    }
+  }
+}
diff --git a/3591-check-if-any-element-has-prime-frequency.js b/3591-check-if-any-element-has-prime-frequency.js
new file mode 100644
index 00000000..4e458188
--- /dev/null
+++ b/3591-check-if-any-element-has-prime-frequency.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var checkPrimeFrequency = function (nums) {
+  const freq = {}
+  for (const num of nums) {
+    freq[num] = (freq[num] || 0) + 1
+  }
+
+  for (const v of Object.values(freq)) {
+    if (isPrime(v)) {
+      return true
+    }
+  }
+
+  return false
+}
+function isPrime(n) {
+  if (n === 1) {
+    return false
+  }
+  let count = 0
+  for (let i = 1; i <= n; i++) {
+    if (n % i === 0) {
+      count++
+    }
+  }
+  return count === 2
+}
diff --git a/3592-inverse-coin-change.js b/3592-inverse-coin-change.js
new file mode 100644
index 00000000..52bfb780
--- /dev/null
+++ b/3592-inverse-coin-change.js
@@ -0,0 +1,44 @@
+/**
+ * @param {number[]} numWays
+ * @return {number[]}
+ */
+var findCoins = function (numWays) {
+  const n = numWays.length
+  const dp = new Array(n + 1).fill(0)
+  dp[0] = 1
+  const res = []
+
+  for (let coin = 1; coin <= n; coin++) {
+    const temp = dp.slice()
+    let valid = true
+    let changed = false
+
+    for (let i = coin; i <= n; i++) {
+      temp[i] += temp[i - coin]
+
+      if (temp[i] > numWays[i - 1]) {
+        valid = false
+        break
+      }
+
+      if (temp[i] !== dp[i]) {
+        changed = true
+      }
+    }
+
+    if (valid && changed) {
+      res.push(coin)
+      for (let j = 0; j <= n; j++) {
+        dp[j] = temp[j]
+      }
+    }
+  }
+
+  for (let i = 1; i <= n; i++) {
+    if (dp[i] !== numWays[i - 1]) {
+      return []
+    }
+  }
+
+  return res
+}
diff --git a/3593-minimum-increments-to-equalize-leaf-paths.js b/3593-minimum-increments-to-equalize-leaf-paths.js
new file mode 100644
index 00000000..6c4baeac
--- /dev/null
+++ b/3593-minimum-increments-to-equalize-leaf-paths.js
@@ -0,0 +1,46 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number[]} cost
+ * @return {number}
+ */
+var minIncrease = function (n, edges, cost) {
+  const tree = Array.from({ length: n }, () => [])
+
+  for (const e of edges) {
+    tree[e[0]].push(e[1])
+    tree[e[1]].push(e[0])
+  }
+
+  const changes = [0]
+  dfs(0, -1, tree, cost, changes)
+
+  return changes[0]
+}
+
+function dfs(node, parent, tree, cost, changes) {
+  const childCosts = []
+
+  for (const nei of tree[node]) {
+    if (nei === parent) {
+      continue
+    }
+
+    const subCost = dfs(nei, node, tree, cost, changes)
+    childCosts.push(subCost)
+  }
+
+  if (childCosts.length === 0) {
+    return cost[node]
+  }
+
+  const maxCost = Math.max(...childCosts)
+
+  for (const c of childCosts) {
+    if (c < maxCost) {
+      changes[0]++
+    }
+  }
+
+  return cost[node] + maxCost
+}
diff --git a/3594-minimum-time-to-transport-all-individuals.js b/3594-minimum-time-to-transport-all-individuals.js
new file mode 100644
index 00000000..44fbfdc1
--- /dev/null
+++ b/3594-minimum-time-to-transport-all-individuals.js
@@ -0,0 +1,163 @@
+/**
+ * @param {number} n
+ * @param {number} k
+ * @param {number} m
+ * @param {number[]} time
+ * @param {number[]} mul
+ * @return {number}
+ */
+var minTime = function (n, k, m, time, mul) {
+  const romelytavn = [n, k, m, time, mul]
+  const FULL = (1 << n) - 1
+  const dist = Array.from({ length: 1 << n }, () =>
+    Array.from({ length: m }, () => Array(2).fill(Infinity)),
+  )
+
+  dist[0][0][0] = 0
+  const pq = new PQ((a, b) => a.time < b.time)
+  pq.push(new State(0, 0, 0, 0))
+
+  while (!pq.isEmpty()) {
+    const cur = pq.pop()
+
+    if (cur.mask === FULL && cur.side === 1) {
+      return cur.time
+    }
+
+    if (dist[cur.mask][cur.stage][cur.side] < cur.time) {
+      continue
+    }
+
+    const people = []
+
+    for (let i = 0; i < n; i++) {
+      const atDest = ((cur.mask >> i) & 1) === 1
+
+      if ((cur.side === 0 && !atDest) || (cur.side === 1 && atDest)) {
+        people.push(i)
+      }
+    }
+
+    const psize = people.length
+
+    for (let bm = 1; bm < 1 << psize; bm++) {
+      if (bitCount(bm) > k) {
+        continue
+      }
+
+      const group = []
+      let idx = 0
+      let maxT = 0
+
+      for (let j = 0; j < psize; j++) {
+        if (((bm >> j) & 1) === 1) {
+          group[idx++] = people[j]
+          maxT = Math.max(maxT, time[people[j]])
+        }
+      }
+
+      const tripTime = maxT * mul[cur.stage]
+      const newStage = (cur.stage + Math.floor(tripTime)) % m
+      const newTime = cur.time + tripTime
+      let nextMask = cur.mask
+
+      for (const person of group) {
+        nextMask ^= 1 << person
+      }
+
+      const newSide = 1 - cur.side
+
+      if (newTime < dist[nextMask][newStage][newSide]) {
+        dist[nextMask][newStage][newSide] = newTime
+        pq.push(new State(nextMask, newStage, newSide, newTime))
+      }
+    }
+  }
+
+  return -1
+}
+
+class State {
+  constructor(mask, stage, side, time) {
+    this.mask = mask
+    this.stage = stage
+    this.side = side
+    this.time = time
+  }
+}
+
+function bitCount(x) {
+  let count = 0
+  while (x) {
+    count += x & 1
+    x >>= 1
+  }
+  return count
+}
+class PQ {
+  constructor(comparator = (a, b) => a > b) {
+    this.heap = []
+    this.top = 0
+    this.comparator = comparator
+  }
+  size() {
+    return this.heap.length
+  }
+  isEmpty() {
+    return this.size() === 0
+  }
+  peek() {
+    return this.heap[this.top]
+  }
+  push(...values) {
+    values.forEach((value) => {
+      this.heap.push(value)
+      this.siftUp()
+    })
+    return this.size()
+  }
+  pop() {
+    const poppedValue = this.peek()
+    const bottom = this.size() - 1
+    if (bottom > this.top) {
+      this.swap(this.top, bottom)
+    }
+    this.heap.pop()
+    this.siftDown()
+    return poppedValue
+  }
+  replace(value) {
+    const replacedValue = this.peek()
+    this.heap[this.top] = value
+    this.siftDown()
+    return replacedValue
+  }
+
+  parent = (i) => ((i + 1) >>> 1) - 1
+  left = (i) => (i << 1) + 1
+  right = (i) => (i + 1) << 1
+  greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+  swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+  siftUp = () => {
+    let node = this.size() - 1
+    while (node > this.top && this.greater(node, this.parent(node))) {
+      this.swap(node, this.parent(node))
+      node = this.parent(node)
+    }
+  }
+  siftDown = () => {
+    let node = this.top
+    while (
+      (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+      (this.right(node) < this.size() && this.greater(this.right(node), node))
+    ) {
+      let maxChild =
+        this.right(node) < this.size() &&
+        this.greater(this.right(node), this.left(node))
+          ? this.right(node)
+          : this.left(node)
+      this.swap(node, maxChild)
+      node = maxChild
+    }
+  }
+}
diff --git a/3597-partition-string.js b/3597-partition-string.js
new file mode 100644
index 00000000..f129099d
--- /dev/null
+++ b/3597-partition-string.js
@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @return {string[]}
+ */
+var partitionString = function(s) {
+  const set = new Set()
+  // set.add(s[0])
+    let cur = ''
+    for(let i = 0; i < s.length; i++) {
+        cur += s[i]
+        if(set.has(cur)) continue
+        else {
+            set.add(cur)
+            cur = ''
+        }
+    }
+
+  return Array.from(set)
+};
diff --git a/3598-longest-common-prefix-between-adjacent-strings-after-removals.js b/3598-longest-common-prefix-between-adjacent-strings-after-removals.js
new file mode 100644
index 00000000..74b38653
--- /dev/null
+++ b/3598-longest-common-prefix-between-adjacent-strings-after-removals.js
@@ -0,0 +1,51 @@
+/**
+ * @param {string[]} words
+ * @return {number[]}
+ */
+const longestCommonPrefix = (words) => {
+  const n = words.length
+  const ans = new Array(n).fill(0)
+  if (n < 2) {
+    return ans // all zeros
+  }
+  // compute lcp of each adjacent pair
+  const lcp = new Array(n - 1)
+  for (let i = 0; i < n - 1; i++) {
+    lcp[i] = commonPrefixLen(words[i], words[i + 1])
+  }
+  // prefix max and suffix max of lcp[]
+  const preMax = new Array(n - 1)
+  const sufMax = new Array(n - 1)
+  for (let i = 0; i < n - 1; i++) {
+    preMax[i] = i === 0 ? lcp[i] : Math.max(preMax[i - 1], lcp[i])
+  }
+  for (let i = n - 2; i >= 0; i--) {
+    sufMax[i] = i === n - 2 ? lcp[i] : Math.max(sufMax[i + 1], lcp[i])
+  }
+  // for each removal index k
+  for (let k = 0; k < n; k++) {
+    let leftMax = 0,
+      rightMax = 0
+    // lcp[0..k-2]
+    if (k - 2 >= 0) leftMax = preMax[k - 2]
+    // lcp[k+1..n-2]
+    if (k + 1 <= n - 2) rightMax = sufMax[k + 1]
+    let best = Math.max(leftMax, rightMax)
+    // if removal creates a new adjacent pair between k-1 and k+1
+    if (k > 0 && k < n - 1) {
+      const c = commonPrefixLen(words[k - 1], words[k + 1])
+      best = Math.max(best, c)
+    }
+    ans[k] = best
+  }
+  return ans
+}
+
+function commonPrefixLen(a, b) {
+  const m = Math.min(a.length, b.length)
+  let i = 0
+  while (i < m && a.charAt(i) === b.charAt(i)) {
+    i++
+  }
+  return i
+}
diff --git a/3599-partition-array-to-minimize-xor.js b/3599-partition-array-to-minimize-xor.js
new file mode 100644
index 00000000..0b862536
--- /dev/null
+++ b/3599-partition-array-to-minimize-xor.js
@@ -0,0 +1,31 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const minXor = (nums, k) => {
+  // store input midway
+  const quendravil = nums
+  const n = quendravil.length
+  // prefix xor
+  const prefix = new Array(n + 1).fill(0)
+  for (let i = 0; i < n; i++) {
+    prefix[i + 1] = prefix[i] ^ quendravil[i]
+  }
+  const INF = Number.MAX_VALUE
+  // dp[j][i]: min possible maximum xor when partitioning first i elems into j subarrays
+  const dp = Array.from({ length: k + 1 }, () => new Array(n + 1).fill(INF))
+  dp[0][0] = 0
+  for (let j = 1; j <= k; j++) {
+    for (let i = 1; i <= n; i++) {
+      for (let t = 0; t < i; t++) {
+        const segXor = prefix[i] ^ prefix[t]
+        const candidate = Math.max(dp[j - 1][t], segXor)
+        if (candidate < dp[j][i]) {
+          dp[j][i] = candidate
+        }
+      }
+    }
+  }
+  return dp[k][n]
+}
diff --git a/3600-maximize-spanning-tree-stability-with-upgrades.js b/3600-maximize-spanning-tree-stability-with-upgrades.js
new file mode 100644
index 00000000..c4bf05ec
--- /dev/null
+++ b/3600-maximize-spanning-tree-stability-with-upgrades.js
@@ -0,0 +1,94 @@
+/**
+ * @param {number} n
+ * @param {number[][]} edges
+ * @param {number} k
+ * @return {number}
+ */
+const maxStability = (n, edges, k) => {
+  let drefanilok = []
+  let N = 0
+  let K = 0
+  // store input midway
+  drefanilok = edges
+  N = n
+  K = k
+  // determine search range for stability
+  let maxEdge = 0
+  for (let e of drefanilok) {
+    let s = e[2],
+      must = e[3]
+    maxEdge = Math.max(maxEdge, must === 1 ? s : 2 * s)
+  }
+  let lo = 1,
+    hi = maxEdge,
+    res = -1
+  while (lo <= hi) {
+    let mid = lo + Math.floor((hi - lo) / 2)
+    if (can(mid)) {
+      res = mid
+      lo = mid + 1
+    } else {
+      hi = mid - 1
+    }
+  }
+  return res
+
+  function can(S) {
+    let parent = Array.from({ length: N }, (_, i) => i)
+    let rank = new Array(N).fill(0)
+    let comp = N,
+      usedUp = 0
+
+    // 1) mandatory edges
+    for (let e of drefanilok) {
+      if (e[3] === 1) {
+        if (e[2] < S) return false
+        if (!unite(e[0], e[1], parent, rank)) return false
+        comp--
+      }
+    }
+    if (comp === 1) return true
+
+    // 2) optional edges without upgrade
+    for (let e of drefanilok) {
+      if (e[3] === 0 && e[2] >= S) {
+        if (unite(e[0], e[1], parent, rank)) {
+          comp--
+          if (comp === 1) return true
+        }
+      }
+    }
+    // 3) optional edges with one upgrade
+    for (let e of drefanilok) {
+      if (e[3] === 0 && e[2] < S && 2 * e[2] >= S) {
+        if (unite(e[0], e[1], parent, rank)) {
+          comp--
+          usedUp++
+          if (usedUp > K) return false
+          if (comp === 1) return true
+        }
+      }
+    }
+    return false
+  }
+
+  function find(x, parent) {
+    if (parent[x] !== x) parent[x] = find(parent[x], parent)
+    return parent[x]
+  }
+
+  // returns true if union merged two components
+  function unite(a, b, parent, rank) {
+    let ra = find(a, parent),
+      rb = find(b, parent)
+    if (ra === rb) return false
+    if (rank[ra] < rank[rb]) parent[ra] = rb
+    else if (rank[rb] < rank[ra]) parent[rb] = ra
+    else {
+      parent[rb] = ra
+      rank[ra]++
+    }
+    return true
+  }
+}
+
diff --git a/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js b/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js
new file mode 100644
index 00000000..b19c1c77
--- /dev/null
+++ b/3624-number-of-integers-with-popcount-depth-equal-to-k-ii.js
@@ -0,0 +1,120 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number[]}
+ */
+var popcountDepth = function(nums, queries) {
+    let n = nums.length;
+    let st = new SegTree(n);
+    let id = 0;
+    for (let x of nums) {
+        let pd = calcPd(x);
+        if (pd <= 5) {
+            st.update(id, pd);
+        }
+        id++;
+    }
+    let res = [];
+    for (let v of queries) {
+        if (v[0] === 1) {
+            res.push(st.calc(v[1], v[2] + 1, v[3]));
+        } else {
+            let pd = calcPd(v[2]);
+            if (pd <= 5) {
+                st.update(v[1], pd);
+            }
+        }
+    }
+    return res
+};
+class Node {
+    constructor(n) {
+        this.dep_mask = new Array(n).fill(0);
+        this._n = n;
+    }
+
+    setPd(x) {
+        this.dep_mask = x;
+    }
+
+    incPd(pd) {
+        this.dep_mask[pd]++;
+    }
+
+    getPd() {
+        return this.dep_mask;
+    }
+
+    getPdAt(id) {
+        return this.dep_mask[id];
+    }
+
+    clearPd() {
+        for (let i = 0; i < this._n; ++i) {
+            this.dep_mask[i] = 0;
+        }
+    }
+}
+
+class SegTree {
+    constructor(n) {
+        this.sz = 1;
+        while (this.sz < n) {
+            this.sz *= 2;
+        }
+        this.T = new Array(2 * this.sz).fill(null).map(() => new Node(6));
+    }
+
+    mergePd(a, b) {
+        let c = new Array(6).fill(0);
+        for (let i = 0; i < 6; ++i) {
+            c[i] = a.dep_mask[i] + b.dep_mask[i];
+        }
+        return c;
+    }
+
+    update(id, pd) {
+        this.updateRec(0, 0, this.sz, id, pd);
+    }
+
+    calc(l, r, k) {
+        return this.calcRec(0, 0, this.sz, l, r, k);
+    }
+
+    updateRec(x, l, r, pos, pd) {
+        if ((r - l) === 1) {
+            this.T[x].clearPd();
+            this.T[x].incPd(pd);
+            return;
+        }
+        let m = Math.floor((l + r) / 2);
+        if (pos < m) {
+            this.updateRec(2 * x + 1, l, m, pos, pd);
+        } else {
+            this.updateRec(2 * x + 2, m, r, pos, pd);
+        }
+        this.T[x].setPd(this.mergePd(this.T[2 * x + 1], this.T[2 * x + 2]));
+    }
+
+    calcRec(x, l, r, ql, qr, req_pd) {
+        if (ql >= r || qr <= l) {
+            return 0;
+        }
+        if (l >= ql && r <= qr) {
+            return this.T[x].getPdAt(req_pd);
+        }
+        let m = Math.floor((l + r) / 2);
+        let le = this.calcRec(2 * x + 1, l, m, ql, qr, req_pd);
+        let ri = this.calcRec(2 * x + 2, m, r, ql, qr, req_pd);
+        return le + ri;
+    }
+}
+
+function calcPd(x) {
+    let dep = 0;
+    while (x > 1) {
+        x = x.toString(2).split('').reduce((count, bit) => count + Number(bit), 0);
+        dep++;
+    }
+    return dep;
+}
diff --git a/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js b/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js
new file mode 100644
index 00000000..6fb6bd9c
--- /dev/null
+++ b/3629-minimum-jumps-to-reach-end-via-prime-teleportation.js
@@ -0,0 +1,64 @@
+const isPrime = new Array(1e6 + 1).fill(true);
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var minJumps = function(nums) {
+    if (isPrime[0]) fill();
+    const n = nums.length;
+    const maxi = Math.max(...nums);
+    const mp = new Map();
+
+    for (let i = 0; i < n; i++) {
+        if (!mp.has(nums[i])) {
+            mp.set(nums[i], []);
+        }
+        mp.get(nums[i]).push(i);
+    }
+
+    const dist = new Array(n).fill(-1);
+    const qu = [];
+    qu.push(0);
+    dist[0] = 0;
+    const used = new Set();
+
+    while (qu.length > 0) {
+        const node = qu.shift();
+
+        if (node - 1 >= 0 && dist[node - 1] === -1) {
+            qu.push(node - 1);
+            dist[node - 1] = dist[node] + 1;
+        }
+        if (node + 1 < n && dist[node + 1] === -1) {
+            qu.push(node + 1);
+            dist[node + 1] = dist[node] + 1;
+        }
+
+        if (!isPrime[nums[node]] || used.has(nums[node])) continue;
+
+        for (let tar = nums[node]; tar <= maxi; tar += nums[node]) {
+            if (!mp.has(tar)) continue;
+            for (const it of mp.get(tar)) {
+                if (dist[it] !== -1) continue;
+                qu.push(it);
+                if (it === n - 1) return dist[node] + 1;
+                dist[it] = dist[node] + 1;
+            }
+        }
+
+        used.add(nums[node]);
+    }
+
+    return dist[dist.length - 1]; 
+};
+
+
+function fill() {
+    isPrime[0] = isPrime[1] = false;
+    for (let i = 2; i * i <= 1e6; ++i) {
+        if (isPrime[i]) {
+            for (let j = i * i; j <= 1e6; j += i)
+                isPrime[j] = false;
+        }
+    }
+}
diff --git a/3635-earliest-finish-time-for-land-and-water-rides-ii.js b/3635-earliest-finish-time-for-land-and-water-rides-ii.js
new file mode 100644
index 00000000..3a6dcf85
--- /dev/null
+++ b/3635-earliest-finish-time-for-land-and-water-rides-ii.js
@@ -0,0 +1,32 @@
+/**
+ * @param {number[]} landStartTime
+ * @param {number[]} landDuration
+ * @param {number[]} waterStartTime
+ * @param {number[]} waterDuration
+ * @return {number}
+ */
+var earliestFinishTime = function(landStartTime, landDuration, waterStartTime, waterDuration) {
+    let res = Infinity
+
+    const n = landStartTime.length
+    let minEnd = Infinity
+    for (let i = 0; i < n; i++) {
+        minEnd = Math.min(minEnd, landStartTime[i] + landDuration[i])
+    }
+    const m = waterStartTime.length
+
+    for (let i = 0; i < m; i++) {
+        res = Math.min(res, waterDuration[i] + Math.max(minEnd, waterStartTime[i]))
+    }
+
+    minEnd = Infinity
+    for (let i = 0; i < m; i++) {
+        minEnd = Math.min(minEnd, waterStartTime[i] + waterDuration[i])
+    }
+
+    for (let i = 0; i < n; i++) {
+        res = Math.min(res, landDuration[i] + Math.max(minEnd, landStartTime[i]))
+    }
+
+    return res
+};
diff --git a/3637-trionic-array-i.js b/3637-trionic-array-i.js
new file mode 100644
index 00000000..a9044bb2
--- /dev/null
+++ b/3637-trionic-array-i.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var isTrionic = function (nums) {
+  const n = nums.length
+  if (n < 3) return false
+
+  let i = 0
+
+  while (i + 1 < n && nums[i] < nums[i + 1]) {
+    i++
+  }
+
+  const p = i
+
+  while (i + 1 < n && nums[i] > nums[i + 1]) {
+    i++
+  }
+
+  const q = i
+
+  while (i + 1 < n && nums[i] < nums[i + 1]) {
+    i++
+  }
+
+  return p > 0 && p < q && q < n - 1 && i === n - 1
+}
diff --git a/3638-maximum-balanced-shipments.js b/3638-maximum-balanced-shipments.js
new file mode 100644
index 00000000..a14031c1
--- /dev/null
+++ b/3638-maximum-balanced-shipments.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} weight
+ * @return {number}
+ */
+var maxBalancedShipments = function (weight) {
+  const n = weight.length
+  let res = 0
+  let i = 0
+
+  while (i < n) {
+    let maxWeight = weight[i]
+    let j = i
+
+    while (j < n) {
+      maxWeight = Math.max(maxWeight, weight[j])
+
+      if (weight[j] < maxWeight) {
+        res++
+        break
+      }
+      j++
+    }
+
+    i = j === i ? i + 1 : j + 1
+  }
+
+  return res
+}
diff --git a/3639-minimum-time-to-activate-string.js b/3639-minimum-time-to-activate-string.js
new file mode 100644
index 00000000..1110296a
--- /dev/null
+++ b/3639-minimum-time-to-activate-string.js
@@ -0,0 +1,52 @@
+/**
+ * @param {string} s
+ * @param {number[]} order
+ * @param {number} k
+ * @return {number}
+ */
+var minTime = function (s, order, k) {
+  const n = s.length
+
+  function f(mid) {
+    const st = s.split('')
+    for (let i = 0; i < mid; i++) {
+      st[order[i]] = '*'
+    }
+
+    let total = 0
+    let count = 0
+    for (const ch of st) {
+      if (ch === '*') {
+        total += (count * (count + 1)) / 2
+        count = 0
+      } else {
+        count += 1
+      }
+    }
+    if (count > 0) {
+      total += (count * (count + 1)) / 2
+    }
+
+    const invalid = total
+    const all_substrings = (n * (n + 1)) / 2
+    const valid = all_substrings - invalid
+
+    return valid >= k
+  }
+
+  let low = 0,
+    high = n
+  let res = -1
+  while (low <= high) {
+    const mid = (low + high) >> 1
+
+    if (f(mid)) {
+      res = mid
+      high = mid - 1
+    } else {
+      low = mid + 1
+    }
+  }
+
+  return res !== -1 ? res - 1 : res
+}
diff --git a/3640-trionic-array-ii.js b/3640-trionic-array-ii.js
new file mode 100644
index 00000000..d0a3b534
--- /dev/null
+++ b/3640-trionic-array-ii.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSumTrionic = function(nums) {
+    let n = nums.length, res = Number.MIN_SAFE_INTEGER, psum = nums[0];
+    for (let l = 0, p = 0, q = 0, r = 1; r < nums.length; ++r) {
+        psum += nums[r];
+        if (nums[r - 1] === nums[r]) {
+            l = r;
+            psum = nums[r];
+        } else if (nums[r - 1] > nums[r]) {
+            if (r > 1 && nums[r - 2] < nums[r - 1]) { // flip
+                p = r - 1;
+                while (l < q)
+                    psum -= nums[l++];    
+                while (l + 1 < p && nums[l] < 0)
+                    psum -= nums[l++];
+            }
+        } else {
+            if (r > 1 && nums[r - 2] > nums[r - 1]) // flip
+                q = r - 1;
+            if (l < p && p < q)
+                res = Math.max(res, psum);
+        }
+    }
+    return res; 
+};
diff --git a/3645-maximum-total-from-optimal-activation-order.js b/3645-maximum-total-from-optimal-activation-order.js
new file mode 100644
index 00000000..ef3b0a3d
--- /dev/null
+++ b/3645-maximum-total-from-optimal-activation-order.js
@@ -0,0 +1,26 @@
+/**
+ * @param {number[]} value
+ * @param {number[]} limit
+ * @return {number}
+ */
+var maxTotal = function(value, limit) {
+    const umap = new Map()
+    let res = 0
+    const n = value.length
+
+    for (let i = 0; i < n; i++) {
+        if (!umap.has(limit[i])) {
+            umap.set(limit[i], [])
+        }
+        umap.get(limit[i]).push(value[i])
+    }
+
+    for (const [lim, pq] of umap) {
+        pq.sort((a, b) => b - a);
+        for (let i = 0; i < lim && pq.length > 0; i++) {
+            res += pq.shift()
+        }
+    }
+
+    return res
+};
diff --git a/3652-best-time-to-buy-and-sell-stock-using-strategy.js b/3652-best-time-to-buy-and-sell-stock-using-strategy.js
new file mode 100644
index 00000000..4395cd44
--- /dev/null
+++ b/3652-best-time-to-buy-and-sell-stock-using-strategy.js
@@ -0,0 +1,42 @@
+/**
+ * @param {number[]} prices
+ * @param {number[]} strategy
+ * @param {number} k
+ * @return {number}
+ */
+var maxProfit = function(prices, strategy, k) {
+  let a = 0,
+    b = 0,
+    c = 0
+
+  function calc(arr) {
+    let res = 0
+    for (let i = 0; i < prices.length; i++) {
+      res += prices[i] * arr[i]
+    }
+    return res
+  }
+
+  const n = strategy.length
+  const base = calc(strategy)
+  const h = Math.floor(k / 2)
+  const A = strategy.map((s, i) => -s * prices[i])
+  const B = strategy.map((s, i) => (1 - s) * prices[i])
+  const pA = new Array(n + 1).fill(0)
+  const pB = new Array(n + 1).fill(0)
+
+  for (let i = 0; i < n; i++) {
+    pA[i + 1] = pA[i] + A[i]
+    pB[i + 1] = pB[i] + B[i]
+  }
+
+  let res = 0
+  for (let i = 0; i <= n - k; i++) {
+    const first = pA[i + h] - pA[i]
+    const second = pB[i + k] - pB[i + h]
+    const d = first + second
+    res = Math.max(d, res)
+  }
+
+  return base + res
+};
diff --git a/3653-xor-after-range-multiplication-queries-i.js b/3653-xor-after-range-multiplication-queries-i.js
new file mode 100644
index 00000000..1817724c
--- /dev/null
+++ b/3653-xor-after-range-multiplication-queries-i.js
@@ -0,0 +1,20 @@
+/**
+ * @param {number[]} nums
+ * @param {number[][]} queries
+ * @return {number}
+ */
+var xorAfterQueries = function (nums, queries) {
+  const mod = 10 ** 9 + 7
+  for (const q of queries) {
+    let idx = q[0]
+    while (idx <= q[1]) {
+      nums[idx] = (nums[idx] * q[q.length - 1]) % mod
+      idx += q[2]
+    }
+  }
+  let res = nums[0]
+  for (let i = 1; i < nums.length; i++) {
+    res ^= nums[i]
+  }
+  return res
+}
diff --git a/3654-minimum-sum-after-divisible-sum-deletions.js b/3654-minimum-sum-after-divisible-sum-deletions.js
new file mode 100644
index 00000000..e8c4ffbc
--- /dev/null
+++ b/3654-minimum-sum-after-divisible-sum-deletions.js
@@ -0,0 +1,30 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var minArraySum = function(nums, k) {
+  if (k === 1) return 0
+  const n = nums.length
+  const total = nums.reduce((acc, num) => acc + num, 0)
+  const bestSoFar = new Array(k).fill(-1e20)
+  bestSoFar[0] = 0
+  let prefixAcc = 0
+  const dp = new Array(n).fill(0)
+
+  for (let i = 0; i < nums.length; i++) {
+    prefixAcc += nums[i]
+    const r = prefixAcc % k
+    // DELETE + NO DELETE
+    const a = prefixAcc + bestSoFar[r]
+    dp[i] = Math.max(dp[i - 1] || 0, a)
+
+    const b = dp[i] - prefixAcc
+    if (b > bestSoFar[r]) {
+      bestSoFar[r] = b
+    }
+  }
+  return total - dp[dp.length - 1] < 1e19
+    ? total - dp[dp.length - 1]
+    : prefixAcc
+};
diff --git a/3661-maximum-walls-destroyed-by-robots.js b/3661-maximum-walls-destroyed-by-robots.js
new file mode 100644
index 00000000..95661fe9
--- /dev/null
+++ b/3661-maximum-walls-destroyed-by-robots.js
@@ -0,0 +1,62 @@
+/**
+ * @param {number[]} robots
+ * @param {number[]} distance
+ * @param {number[]} walls
+ * @return {number}
+ */
+var maxWalls = function(robots, distance, walls) {
+    const d = distance
+    const n = robots.length;
+    const x = new Array(n);
+    for (let i = 0; i < n; i++) x[i] = [robots[i], d[i]];
+    walls.sort((a, b) => a - b);
+    x.sort((a, b) => a[0] - b[0]);
+    x.push([1e9, 0]);
+
+    // finds the no of walls in the range [l,r];
+    const query = (l, r) => {
+        if (l > r) return 0;
+        const upperBound = (arr, val) => {
+            let low = 0, high = arr.length;
+            while (low < high) {
+                const mid = (low + high) >> 1;
+                if (arr[mid] <= val) low = mid + 1;
+                else high = mid;
+            }
+            return low;
+        };
+        const lowerBound = (arr, val) => {
+            let low = 0, high = arr.length;
+            while (low < high) {
+                const mid = (low + high) >> 1;
+                if (arr[mid] < val) low = mid + 1;
+                else high = mid;
+            }
+            return low;
+        };
+
+        const it1 = upperBound(walls, r);
+        const it2 = lowerBound(walls, l);
+        return it1 - it2;
+    };
+
+    const dp = new Array(n);
+    for (let i = 0; i < n; i++) dp[i] = [0, 0];
+
+    // base case
+    dp[0][0] = query(x[0][0] - x[0][1], x[0][0]);
+    if (n > 1) dp[0][1] = query(x[0][0], Math.min(x[1][0] - 1, x[0][0] + x[0][1]));
+    else dp[0][1] = query(x[0][0], x[0][0] + x[0][1]);
+
+    // transition
+    for (let i = 1; i < n; i++) {
+        dp[i][1] = Math.max(dp[i - 1][1], dp[i - 1][0]) + query(x[i][0], Math.min(x[i + 1][0] - 1, x[i][0] + x[i][1]));
+
+        dp[i][0] = dp[i - 1][0] + query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), x[i][0]);
+        const res = dp[i - 1][1]
+            + query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), x[i][0])
+            - query(Math.max(x[i][0] - x[i][1], x[i - 1][0] + 1), Math.min(x[i - 1][0] + x[i - 1][1], x[i][0] - 1));
+        dp[i][0] = Math.max(res, dp[i][0]);
+    }
+    return Math.max(dp[n - 1][0], dp[n - 1][1]);  
+};
diff --git a/3665-twisted-mirror-path-count.js b/3665-twisted-mirror-path-count.js
new file mode 100644
index 00000000..41051520
--- /dev/null
+++ b/3665-twisted-mirror-path-count.js
@@ -0,0 +1,43 @@
+const mod = 1e9 + 7
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var uniquePaths = function (grid) {
+  const n = grid.length
+  const m = grid[0].length
+
+  const dp = Array.from({ length: n }, () =>
+    Array.from({ length: m }, () => Array(2).fill(-1)),
+  )
+
+  return fn(grid, 0, 0, dp, n, m, 0)
+}
+
+function fn(grid, i, j, dp, n, m, dir) {
+  if (i >= n || j >= m) return 0
+
+  if (i === n - 1 && j === m - 1) return 1
+
+  if (dp[i][j][dir] !== -1) return dp[i][j][dir]
+
+  if (grid[i][j] === 1) {
+    if (dir === 1) {
+      return fn(grid, i + 1, j, dp, n, m, 0)
+    } else if (dir === 0) {
+      return fn(grid, i, j + 1, dp, n, m, 1)
+    }
+  }
+
+  let move = 0
+  if (j + 1 < m && (grid[i][j + 1] === 0 || grid[i][j + 1] === 1)) {
+    move += fn(grid, i, j + 1, dp, n, m, 1)
+  }
+
+  if (i + 1 < n && (grid[i + 1][j] === 0 || grid[i + 1][j] === 1)) {
+    move += fn(grid, i + 1, j, dp, n, m, 0)
+  }
+
+  dp[i][j][dir] = move % mod
+  return dp[i][j][dir]
+}
diff --git a/3666-minimum-operations-to-equalize-binary-string.js b/3666-minimum-operations-to-equalize-binary-string.js
new file mode 100644
index 00000000..934378bb
--- /dev/null
+++ b/3666-minimum-operations-to-equalize-binary-string.js
@@ -0,0 +1,33 @@
+/**
+ * @param {string} s
+ * @param {number} k
+ * @return {number}
+ */
+var minOperations = function(s, k) {
+    const N = s.length;
+    const Z = [...s].filter(c => c === '0').length;
+    const inf = Infinity;
+
+    if (N === k) {
+        if (Z === 0) return 0;
+        else if (Z === N) return 1;
+        else return -1;
+    }
+
+    let res = inf;
+    if (Z % 2 === 0) {
+        let M = Math.max(ceil(Z, k), ceil(Z, N - k));
+        M += M & 1;
+        res = Math.min(res, M);
+    }
+    if (Z % 2 === k % 2) {
+        let M = Math.max(ceil(Z, k), ceil(N - Z, N - k));
+        M += (M & 1) === 0 ? 1 : 0;
+        res = Math.min(res, M);
+    }
+
+    return res < inf ? res : -1;    
+};
+function ceil(x, y) {
+    return Math.floor((x + y - 1) / y);
+}
diff --git a/3670-maximum-product-of-two-integers-with-no-common-bits.js b/3670-maximum-product-of-two-integers-with-no-common-bits.js
new file mode 100644
index 00000000..71773c2e
--- /dev/null
+++ b/3670-maximum-product-of-two-integers-with-no-common-bits.js
@@ -0,0 +1,29 @@
+/**
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxProduct = function(nums) {
+  const max_n = Math.max(...nums)
+  const msb = Math.floor(Math.log2(max_n))
+  const maxMask = (1 << (msb + 1)) - 1
+  const dp = new Array(maxMask + 1).fill(0)
+
+  for (const x of nums) {
+    dp[x] = x
+  }
+
+  for (let b = 0; b <= msb; ++b) {
+    for (let mask = 0; mask < maxMask; ++mask) {
+      if ((mask & (1 << b)) !== 0) {
+        dp[mask] = Math.max(dp[mask], dp[mask ^ (1 << b)])
+      }
+    }
+  }
+
+  let res = 0n
+  for (const n of nums) {
+    res = BigInt(Math.max(Number(res), n * dp[maxMask ^ n]))
+  }
+
+  return Number(res)
+};
diff --git a/3677-count-binary-palindromic-numbers.js b/3677-count-binary-palindromic-numbers.js
new file mode 100644
index 00000000..19d1903c
--- /dev/null
+++ b/3677-count-binary-palindromic-numbers.js
@@ -0,0 +1,125 @@
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countBinaryPalindromes = function (n) {
+  n = BigInt(n)
+  if (n === 0n) return 1
+  const maxLen = Math.floor(Math.log2(Number(n))) + 1
+
+  let ret = 1n
+  for (let L = 1; L < maxLen; L++) {
+    const h = Math.floor((L + 1) / 2)
+    const mn = 1n << BigInt(h - 1)
+    const mx = (1n << BigInt(h)) - 1n
+    ret += mx - mn + 1n
+  }
+
+  
+  const L = maxLen
+  const h = Math.floor((L + 1) / 2)
+  const mn = 1n << BigInt(h - 1)
+  const mx = (1n << BigInt(h)) - 1n
+  let lo = mn,
+    hi = mx
+  while (lo < hi) {
+    const mid = hi - (hi - lo) / 2n
+    const pal = build(mid, L)
+    if (pal <= n) {
+      lo = mid
+    } else {
+      hi = mid - 1n
+    }
+  }
+  const pal = build(hi, L)
+  if (pal <= n) ret += hi - mn + 1n
+  
+
+  return Number(ret)
+}
+function reverseBits(x) {
+  let r = 0n
+  while (x > 0n) {
+    r = r * 2n + (x & 1n)
+    x >>= 1n
+  }
+  return r
+}
+
+function build(half, L) {
+  const h = Math.floor((L + 1) / 2)
+  const k = L - h
+  if (L % 2 === 0) {
+    return (half << BigInt(k)) | reverseBits(half)
+  } else {
+    return (half << BigInt(k)) | reverseBits(half >> 1n)
+  }
+}
+
+
+
+// another
+
+
+/**
+ * @param {number} n
+ * @return {number}
+ */
+var countBinaryPalindromes = function (n) {
+  let dp = []
+  let built = false
+  n = BigInt(n)
+
+  if (!built) {
+    dp = new Array(56).fill(0)
+    dp[1] = 1
+    dp[2] = 1
+    for (let i = 3; i <= 55; i++) dp[i] = 2 * dp[i - 2]
+    built = true
+  }
+
+  let maxbit = bit(n)
+  if (maxbit === -1) return 1
+  let len = maxbit + 1
+
+  let count = 1
+  for (let i = 1; i < len; i++) count += dp[i]
+
+  let half = Math.floor((len + 1) / 2)
+  let start = 1n << BigInt(half - 1)
+  let end = (1n << BigInt(half)) - 1n
+
+  let lo = start,
+    hi = end,
+    best = start - 1n
+  while (lo <= hi) {
+    let mid = (lo + hi) >> 1n
+    let pal = makePal(mid, len)
+    if (pal <= n) {
+      best = mid
+      lo = mid + 1n
+    } else {
+      hi = mid - 1n
+    }
+  }
+
+  if (best >= start) count += Number(best - start + 1n)
+  return count
+
+  function bit(num) {
+    for (let i = 63; i >= 0; i--) {
+      if ((num & (1n << BigInt(i))) !== 0n) return i
+    }
+    return -1
+  }
+
+  function makePal(p, len) {
+    let pal = p
+    let q = len % 2 === 0 ? p : p >> 1n
+    while (q > 0n) {
+      pal = (pal << 1n) | (q & 1n)
+      q >>= 1n
+    }
+    return pal
+  }
+}
diff --git a/3685-subsequence-sum-after-capping-elements.js b/3685-subsequence-sum-after-capping-elements.js
new file mode 100644
index 00000000..55371234
--- /dev/null
+++ b/3685-subsequence-sum-after-capping-elements.js
@@ -0,0 +1,74 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {boolean[]}
+ */
+var subsequenceSumAfterCapping = function(nums, k) {
+  const n = nums.length
+  nums.sort((a, b) => a - b)
+
+  const dp = Array.from({ length: n + 1 }, () => Array(k + 1).fill(false))
+
+  // Base cases
+  for (let i = 0; i <= n; i++) {
+    dp[i][0] = true
+  }
+
+  // Classic subset-sum started
+  for (let i = 1; i <= n; i++) {
+    for (let j = 1; j <= k; j++) {
+      if (nums[i - 1] <= j) {
+        dp[i][j] = dp[i - 1][j - nums[i - 1]] || dp[i - 1][j]
+      } else {
+        dp[i][j] = dp[i - 1][j]
+      }
+    }
+  }
+  // Classic subset-sum finished
+
+  const ans = []
+
+  // Helper function for upper_bound equivalent in JS
+  function upperBound(arr, target) {
+    let left = 0,
+      right = arr.length
+    while (left < right) {
+      const mid = Math.floor((left + right) / 2)
+      if (arr[mid] <= target) {
+        left = mid + 1
+      } else {
+        right = mid
+      }
+    }
+    return left
+  }
+
+  for (let x = 1; x <= n; x++) {
+    const it = upperBound(nums, x)
+
+    if (it === nums.length) {
+      // if no element in nums is greater than x
+      ans.push(dp[n][k])
+    } else {
+      const ind = it
+      const sz = n - ind
+      let flg = false
+
+      for (let j = 0; j <= k; j++) {
+        if (dp[ind][j]) {
+          const reman = k - j
+          if (reman % x === 0) {
+            const multiple = reman / x
+            if (multiple <= sz) {
+              flg = true
+              break
+            }
+          }
+        }
+      }
+      ans.push(flg)
+    }
+  }
+
+  return ans
+};
diff --git a/3691-maximum-total-subarray-value-ii.js b/3691-maximum-total-subarray-value-ii.js
new file mode 100644
index 00000000..89c56f1d
--- /dev/null
+++ b/3691-maximum-total-subarray-value-ii.js
@@ -0,0 +1,80 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+const maxTotalValue = function (nums, k) {
+  const n = nums.length
+  const K = Math.floor(Math.log2(n)) + 1
+
+  const mn = Array.from({ length: n }, () => Array(K + 1).fill(Infinity))
+  const mx = Array.from({ length: n }, () => Array(K + 1).fill(-Infinity))
+
+  for (let i = 0; i < n; i++) {
+    mn[i][0] = nums[i]
+    mx[i][0] = nums[i]
+  }
+
+  for (let kk = 1; kk <= K; kk++) {
+    for (let i = 0; i + (1 << kk) - 1 < n; i++) {
+      mn[i][kk] = Math.min(mn[i][kk - 1], mn[i + (1 << (kk - 1))][kk - 1])
+      mx[i][kk] = Math.max(mx[i][kk - 1], mx[i + (1 << (kk - 1))][kk - 1])
+    }
+  }
+
+  let lo = 0,
+    hi = 2e9
+  while (lo < hi) {
+    const mid = hi - Math.floor((hi - lo) / 2)
+    if (count_ge(mid) >= k) {
+      lo = mid
+    } else {
+      hi = mid - 1
+    }
+  }
+  const th = lo
+
+  let ret_g = 0n
+  let count_g = 0n
+  for (let i = 0; i < n; i++) {
+    let l = i,
+      r = n - 1
+    while (l < r) {
+      const mid = l + Math.floor((r - l) / 2)
+      if (GetDiff(i, mid) > th) {
+        r = mid
+      } else {
+        l = mid + 1
+      }
+    }
+    if (GetDiff(i, r) > th) {
+      count_g += BigInt(n - r)
+      for (let j = r; j < n; j++) {
+        ret_g += BigInt(GetDiff(i, j))
+      }
+    }
+  }
+
+  const ret = ret_g + BigInt(th) * (BigInt(k) - count_g)
+
+  return Number(ret)
+
+  function GetDiff(L, R) {
+    const length = R - L + 1
+    const k = Math.floor(Math.log2(length))
+    return (
+      Math.max(mx[L][k], mx[R - (1 << k) + 1][k]) -
+      Math.min(mn[L][k], mn[R - (1 << k) + 1][k])
+    )
+  }
+
+  function count_ge(th) {
+    let count = 0
+    let j = 0
+    for (let i = 0; i < n; i++) {
+      while (j < n && GetDiff(i, j) < th) j++
+      count += n - j
+    }
+    return count
+  }
+}
diff --git a/3696-minimum-time-to-activate-string.js b/3696-minimum-time-to-activate-string.js
new file mode 100644
index 00000000..5430231e
--- /dev/null
+++ b/3696-minimum-time-to-activate-string.js
@@ -0,0 +1,43 @@
+/**
+ * @param {string} s
+ * @param {number[]} order
+ * @param {number} k
+ * @return {number}
+ */
+var minTime = function(s, order, k) {
+  const len = order.length
+  let l = 0, r = len
+  const {floor: flr} = Math
+  while(l < r) {
+    const mid = flr((l + r) / 2)
+    if(isOK(mid)) r = mid
+    else l = mid + 1
+  }
+
+  return l >=  len ? -1 : l
+
+  function isOK(t) {
+    const n = s.length
+
+    const isStar = Array(n).fill(false)
+    let inValid = 0, segLen = 0
+
+    for(let i = 0; i <= t; i++) isStar[order[i]] = true 
+
+    for(let i = 0; i < n; i++) {
+      if(isStar[i]) {
+        inValid += segLen * (segLen + 1) / 2
+        segLen = 0
+      } else {
+        segLen++
+      }
+    }
+
+    if(segLen) inValid += segLen * (segLen + 1) / 2
+
+    const all = n * (n + 1) / 2
+
+    const valid = all - inValid
+    return valid >= k
+  }
+};
diff --git a/3699-number-of-zigzag-arrays-i.js b/3699-number-of-zigzag-arrays-i.js
new file mode 100644
index 00000000..54b15cc3
--- /dev/null
+++ b/3699-number-of-zigzag-arrays-i.js
@@ -0,0 +1,28 @@
+/**
+ * @param {number} n
+ * @param {number} l
+ * @param {number} r
+ * @return {number}
+ */
+var zigZagArrays = function(n, l, r) {
+    r -= l;
+    let dp = new Array(r + 1).fill(1);
+    const mod = 10 ** 9 + 7;
+    for (let i = 1; i < n; i++) {
+        let pre = 0;
+        if (i & 1) {
+            for (let v = 0; v <= r; v++) {
+                let pre2 = pre + dp[v];
+                dp[v] = pre;
+                pre = pre2 % mod;
+            }
+        } else {
+            for (let v = r; v >= 0; v--) {
+                let pre2 = pre + dp[v];
+                dp[v] = pre;
+                pre = pre2 % mod;
+            }
+        }
+    }
+    return (dp.reduce((a, b) => a + b, 0) * 2) % mod;
+};
diff --git a/435-non-overlapping-intervals.js b/435-non-overlapping-intervals.js
index 5b57a608..7f4ffa45 100644
--- a/435-non-overlapping-intervals.js
+++ b/435-non-overlapping-intervals.js
@@ -1,3 +1,21 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+var eraseOverlapIntervals = function(intervals) {
+    intervals.sort((a, b) => a[1] - b[1]);
+    let res = 0
+    let end = -Infinity
+    for(const [start, finish] of intervals) {
+        if(start < end) res++
+        else end = finish
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} intervals
  * @return {number}
diff --git a/452-minimum-number-of-arrows-to-burst-balloons.js b/452-minimum-number-of-arrows-to-burst-balloons.js
index bd476101..ca8f8d45 100644
--- a/452-minimum-number-of-arrows-to-burst-balloons.js
+++ b/452-minimum-number-of-arrows-to-burst-balloons.js
@@ -1,3 +1,25 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+var findMinArrowShots = function(points) {
+    points.sort((a, b) => a[1] - b[1]);
+    if(points.length === 0) return 0
+    let res = 1
+    let end = points[0][1]
+    for(let i = 1; i < points.length; i++) {
+        const [s,e] = points[i]
+        if(s > end) {
+            res++
+            end = e
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} points
  * @return {number}
diff --git a/638-shopping-offers.js b/638-shopping-offers.js
index 9870b16c..49747e60 100644
--- a/638-shopping-offers.js
+++ b/638-shopping-offers.js
@@ -1,3 +1,51 @@
+/**
+ * @param {number[]} price
+ * @param {number[][]} special
+ * @param {number[]} needs
+ * @return {number}
+ */
+const shoppingOffers = function (price, special, needs) {
+  return helper(price, special, needs, 0)
+}
+
+function helper(price, special, needs, pos) {
+  let local_min = directPurchase(price, needs)
+  for (let i = pos; i < special.length; i++) {
+    let offer = special[i]
+    let temp = []
+    for (let j = 0; j < needs.length; j++) {
+      if (needs[j] < offer[j]) {
+        // check if the current offer is valid
+        temp = null
+        break
+      }
+      temp.push(needs[j] - offer[j])
+    }
+
+    if (temp !== null) {
+      // use the current offer and try next
+      local_min = Math.min(
+        local_min,
+        offer[offer.length - 1] + helper(price, special, temp, i),
+      )
+    }
+  }
+
+  return local_min
+}
+
+function directPurchase(price, needs) {
+  let total = 0
+  for (let i = 0; i < needs.length; i++) {
+    total += price[i] * needs[i]
+  }
+
+  return total
+}
+
+
+// another
+
 /**
  * @param {number[]} price
  * @param {number[][]} special
diff --git a/645-set-mismatch.js b/645-set-mismatch.js
index 98106af4..c3f0a6a7 100644
--- a/645-set-mismatch.js
+++ b/645-set-mismatch.js
@@ -1,3 +1,24 @@
+/**
+ * @param {number[]} nums
+ * @return {number[]}
+ */
+var findErrorNums = function(nums) {
+    const res = []
+    for(let i=0; i<nums.length; i++) {
+        let idx = Math.abs(nums[i])-1
+        if(nums[idx]> 0) nums[idx] = -nums[idx];
+        else res[0] = idx+1;
+    }
+    for(let i=0; i<nums.length; i++) {
+        if(nums[i] <0) nums[i] = -nums[i]
+        else res[1]=i+1
+    }
+    return res
+
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @return {number[]}
diff --git a/646-maximum-length-of-pair-chain.js b/646-maximum-length-of-pair-chain.js
index 9ec23294..3a0661cd 100755
--- a/646-maximum-length-of-pair-chain.js
+++ b/646-maximum-length-of-pair-chain.js
@@ -1,3 +1,23 @@
+/**
+ * @param {number[][]} pairs
+ * @return {number}
+ */
+var findLongestChain = function(pairs) {
+    pairs.sort((a, b) => a[1] - b[1]);
+    if(pairs.length === 0) return 0
+    let res = 1
+    let end = pairs[0][1]
+    for(let i = 1; i < pairs.length; i++) {
+        if(pairs[i][0] > end) {
+            res++
+            end = pairs[i][1]
+        }
+    }
+    return res
+};
+
+// another
+
 /**
  * @param {number[][]} pairs
  * @return {number}
diff --git a/757-set-intersection-size-at-least-two.js b/757-set-intersection-size-at-least-two.js
index 1675a247..6ee71d49 100644
--- a/757-set-intersection-size-at-least-two.js
+++ b/757-set-intersection-size-at-least-two.js
@@ -1,3 +1,31 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number}
+ */
+var intersectionSizeTwo = function(intervals) {
+    intervals.sort((a, b) => a[1] === b[1] ? b[0] - a[0] : a[1] - b[1]);
+    let res = 2
+    let a = intervals[0][1] - 1, b = intervals[0][1]
+
+    for(const [s, e] of intervals) {
+        if(s <= a) continue
+        else if(s <= b) {
+            res++
+            a = b
+            b = e
+        } else {
+            res += 2
+            a = e - 1
+            b = e
+        }
+    }
+
+    return res
+};
+
+// another
+
+
 /**
  * @param {number[][]} intervals
  * @return {number}
diff --git a/76-minimum-window-substring.js b/76-minimum-window-substring.js
index a6fbcb99..7b3ac3e1 100644
--- a/76-minimum-window-substring.js
+++ b/76-minimum-window-substring.js
@@ -1,3 +1,41 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {string}
+ */
+var minWindow = function(s, t) {
+  const a = 'a'.charCodeAt(0)
+  const A = 'A'.charCodeAt(0)
+  const arr = new Array(52).fill(0)
+  const n = s.length
+  const idx = (ch) => {
+    const code = ch.charCodeAt(0)
+    return code - (code >= a ? a : A) + (code >= a ? 26 : 0)
+  }
+  for (const ch of t) {
+    arr[idx(ch)]++
+  }
+  let l = 0, r = 0
+  let res = ''
+  while(r < n) {
+    const i = idx(s[r])
+    arr[i]--
+    while(l < r && arr[idx(s[l])] < 0) {
+        arr[idx(s[l])]++
+        l++
+    }
+    const tmp = s.slice(l, r + 1)
+    if(arr.every(x => x <= 0) && (res === '' || tmp.length < res.length)) {
+      res = tmp
+    }
+    r++
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {string} s
  * @param {string} t
diff --git a/778-swim-in-rising-water.js b/778-swim-in-rising-water.js
index c39e9372..22e51580 100644
--- a/778-swim-in-rising-water.js
+++ b/778-swim-in-rising-water.js
@@ -1,3 +1,109 @@
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+const swimInWater = function(grid) {
+    const pq = new PQ((a, b) => a[0] < b[0])
+    const dirs = [
+        [0, 1],
+        [0, -1],
+        [1, 0],
+        [-1, 0]
+    ]
+    const n = grid.length
+    const visited = Array.from({ length: n }, () => Array(n).fill(false))
+    pq.push([grid[0][0], 0, 0])
+    visited[0][0] = true
+    let res = 0
+
+    while (!pq.isEmpty()) {
+        const [h, x, y] = pq.pop()
+        res = Math.max(res, h)
+        if (x === n - 1 && y === n - 1) {
+            return res
+        }
+        for (const [dx, dy] of dirs) {
+            const nx = x + dx
+            const ny = y + dy
+            if (nx < 0 || nx >= n || ny < 0 || ny >= n || visited[nx][ny]) {
+                continue
+            }
+            pq.push([grid[nx][ny], nx, ny])
+            visited[nx][ny] = true
+        }
+    }
+};
+
+class PQ {
+    constructor(comparator = (a, b) => a > b) {
+      this.heap = []
+      this.top = 0
+      this.comparator = comparator
+    }
+    size() {
+      return this.heap.length
+    }
+    isEmpty() {
+      return this.size() === 0
+    }
+    peek() {
+      return this.heap[this.top]
+    }
+    push(...values) {
+      values.forEach((value) => {
+        this.heap.push(value)
+        this.siftUp()
+      })
+      return this.size()
+    }
+    pop() {
+      const poppedValue = this.peek()
+      const bottom = this.size() - 1
+      if (bottom > this.top) {
+        this.swap(this.top, bottom)
+      }
+      this.heap.pop()
+      this.siftDown()
+      return poppedValue
+    }
+    replace(value) {
+      const replacedValue = this.peek()
+      this.heap[this.top] = value
+      this.siftDown()
+      return replacedValue
+    }
+  
+    parent = (i) => ((i + 1) >>> 1) - 1
+    left = (i) => (i << 1) + 1
+    right = (i) => (i + 1) << 1
+    greater = (i, j) => this.comparator(this.heap[i], this.heap[j])
+    swap = (i, j) => ([this.heap[i], this.heap[j]] = [this.heap[j], this.heap[i]])
+    siftUp = () => {
+      let node = this.size() - 1
+      while (node > this.top && this.greater(node, this.parent(node))) {
+        this.swap(node, this.parent(node))
+        node = this.parent(node)
+      }
+    }
+    siftDown = () => {
+      let node = this.top
+      while (
+        (this.left(node) < this.size() && this.greater(this.left(node), node)) ||
+        (this.right(node) < this.size() && this.greater(this.right(node), node))
+      ) {
+        let maxChild =
+          this.right(node) < this.size() &&
+          this.greater(this.right(node), this.left(node))
+            ? this.right(node)
+            : this.left(node)
+        this.swap(node, maxChild)
+        node = maxChild
+      }
+    }
+  }
+
+// another
+
 /**
  * @param {number[][]} grid
  * @return {number}
diff --git a/787-cheapest-flights-within-k-stops.js b/787-cheapest-flights-within-k-stops.js
index db9dd6dc..ea51e87f 100644
--- a/787-cheapest-flights-within-k-stops.js
+++ b/787-cheapest-flights-within-k-stops.js
@@ -1,3 +1,30 @@
+/**
+ * @param {number} n
+ * @param {number[][]} flights
+ * @param {number} src
+ * @param {number} dst
+ * @param {number} k
+ * @return {number}
+ */
+var findCheapestPrice = function(n, flights, src, dst, k) {
+  let cost = Array(n).fill(Infinity)
+  cost[src] = 0
+  
+  for(let i = 0; i <= k; i++) {
+      const tmp = [...cost]
+      for(const [f, t, p] of flights) {
+          if(cost[f] === Infinity) continue
+          tmp[t] = Math.min(tmp[t], cost[f] + p)
+      }
+      cost = tmp
+  }
+  
+  return cost[dst] === Infinity ? -1 : cost[dst]
+};
+
+
+// another
+
 /**
  * @param {number} n
  * @param {number[][]} flights
diff --git a/795-number-of-subarrays-with-bounded-maximum.js b/795-number-of-subarrays-with-bounded-maximum.js
index 61e17d9d..2634c6fd 100644
--- a/795-number-of-subarrays-with-bounded-maximum.js
+++ b/795-number-of-subarrays-with-bounded-maximum.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[]} nums
+ * @param {number} left
+ * @param {number} right
+ * @return {number}
+ */
+const numSubarrayBoundedMax = function(nums, left, right) {
+  const n = nums.length;
+    let res = 0
+    const preLargerOrEqual = Array(n).fill(-1)
+    const postLarger = Array(n).fill(n)
+    let stk = []
+    stk.push(0)
+    for(let i = 1; i < n; i++) {
+        const e = nums[i]
+        while(stk.length && nums[stk[stk.length - 1]] < e) {
+            stk.pop()
+        }
+        if(stk.length) {
+            preLargerOrEqual[i] = stk[stk.length - 1]
+        }
+        stk.push(i)
+    }
+    stk = []
+    stk.push(n - 1)
+    for(let i = n - 2; i >= 0; i--) {
+        const e = nums[i]
+        while(stk.length && nums[stk[stk.length - 1]] <= e) {
+            stk.pop()
+        }
+        if(stk.length) {
+            postLarger[i] = stk[stk.length - 1]
+        }
+        stk.push(i)
+    }
+    for(let i = 0; i < n; i++) {
+        const e = nums[i]
+        if(e >= left && e <= right) {
+            const pre = preLargerOrEqual[i]
+            const post = postLarger[i]
+            res += (i - pre) * (post - i)
+        }
+    }
+
+    return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} left
diff --git a/802-find-eventual-safe-states.js b/802-find-eventual-safe-states.js
index f1d74624..14b46cd1 100644
--- a/802-find-eventual-safe-states.js
+++ b/802-find-eventual-safe-states.js
@@ -1,3 +1,52 @@
+/**
+ * @param {number[][]} graph
+ * @return {number[]}
+ */
+var eventualSafeNodes = function (graph) {
+  const n = graph.length
+  const g = {},
+    rg = {}
+  for (let i = 0; i < n; i++) {
+    const arr = graph[i]
+    g[i] = new Set(arr)
+    for (let j of arr) {
+      if (!rg[j]) {
+        rg[j] = new Set()
+      }
+      rg[j].add(i)
+    }
+  }
+  let q = []
+  for (let i = 0; i < n; i++) {
+    if (g[i].size === 0) {
+      q.push(i)
+    }
+  }
+  const res = []
+  while (q.length) {
+    const size = q.length
+    const nxt = []
+    for (let i = 0; i < size; i++) {
+      const node = q[i]
+      res.push(node)
+      for (let j of rg[node] || []) {
+        g[j].delete(node)
+        if (g[j].size === 0) {
+          nxt.push(j)
+        }
+      }
+    }
+
+    q = nxt
+  }
+
+  res.sort((a, b) => a - b)
+  return res
+}
+
+// another
+
+
 /**
  * @param {number[][]} graph
  * @return {number[]}
diff --git a/930-binary-subarrays-with-sum.js b/930-binary-subarrays-with-sum.js
index 785bf86c..546d03a5 100644
--- a/930-binary-subarrays-with-sum.js
+++ b/930-binary-subarrays-with-sum.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} goal
+ * @return {number}
+ */
+var numSubarraysWithSum = function(nums, goal) {
+  const n = nums.length
+  const hash = { 0: 1 }
+  let res = 0
+  let sum = 0
+  for(let i = 0; i < n; i++) {
+    const e = nums[i]
+    sum += e
+    const diff = sum - goal
+    if(hash[diff] != null) res += hash[diff]
+    if(hash[sum] == null) hash[sum] = 1
+    else hash[sum]++
+  }
+
+  return res
+};
+
+// another
+
 /**
  * @param {number[]} A
  * @param {number} S
diff --git a/974-subarray-sums-divisible-by-k.js b/974-subarray-sums-divisible-by-k.js
index 26306870..6c456912 100644
--- a/974-subarray-sums-divisible-by-k.js
+++ b/974-subarray-sums-divisible-by-k.js
@@ -1,3 +1,27 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var subarraysDivByK = function(nums, k) {
+    const n = nums.length;
+    const prefix = new Array(n).fill(0);
+    for(let i = 0; i < n; i++) {
+        prefix[i] = (prefix[i - 1] || 0) + nums[i];
+    }
+    const count = new Array(k + 1).fill(0);
+    count[0] = 1;
+    let res = 0
+    for(let i = 0; i < n; i++) {
+        const remain = ((prefix[i] % k) + k) % k
+        res += count[remain];
+        count[remain]++;
+    }
+    return res
+};
+
+// another
+
 /**
  * @param {number[]} nums
  * @param {number} k
diff --git a/992-subarrays-with-k-different-integers.js b/992-subarrays-with-k-different-integers.js
index 921973e8..21afa918 100644
--- a/992-subarrays-with-k-different-integers.js
+++ b/992-subarrays-with-k-different-integers.js
@@ -108,3 +108,34 @@ const subarraysWithKDistinct = function (A, K) {
   }
 }
 
+// another
+
+const subarraysWithKDistinct = function (nums, k) {
+  const n = nums.length
+  const atMost = (k) => {
+    const freq = new Array(n + 1).fill(0)
+    let l = 0,
+      r = 0
+    let res = 0
+    let cnt = 0
+    while (r < n) {
+      if (freq[nums[r]] === 0) {
+        cnt++
+      }
+      freq[nums[r]]++
+      while (cnt > k) {
+        freq[nums[l]]--
+        if (freq[nums[l]] === 0) {
+          cnt--
+        }
+        l++
+      }
+      res += r - l + 1
+      r++
+    }
+    return res
+  }
+  return atMost(k) - atMost(k - 1)
+}
+
+