super easy dfs

1038-231204-pass/main.cpp

@@ -0,0 +1,125 @@
+#include<stdcpp.h>
+using namespace std;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+
+class Solution {
+public:
+    priority_queue<int, vector<int>, greater<int> > vals;
+    int cnt = 0;
+    void traverse(TreeNode * node){
+        vals.push(node->val);
+        cnt++;
+        if(node->left!=nullptr)  traverse(node->left);
+        if(node->right!=nullptr)  traverse(node->right);
+    }
+    TreeNode* bstToGst(TreeNode* root) {
+        traverse(root);
+        int val[110];
+        int idx[110];
+        int pref[110],sum=0;
+        for(int i = 0 ; i < cnt ; i++){
+            val[i] = vals.top();
+            vals.pop();
+            if(i==0)
+                pref[i] = val[i];
+            else{
+                pref[i] = pref[i-1] + val[i];
+            }
+        }
+        sum = pref[cnt-1];
+        for(int i = 0 ; i < cnt ; i++){
+            idx[val[i]] = sum - pref[i];
+        }
+        stack<TreeNode*> sta;
+        sta.push(root);
+        while(sta.empty() == false){
+            TreeNode* top_node = sta.top();
+            cout<<"top_node is "<<top_node->val<<endl;
+            sta.pop();
+            if(top_node->left!=nullptr) sta.push(top_node->left);
+            if(top_node->right!=nullptr) sta.push(top_node->right);
+            top_node->val+=idx[top_node->val];
+        }
+        cnt = 0;
+        std::priority_queue<int, std::vector<int>, std::greater<int>> empty;
+        vals.swap(empty);
+        return root;
+    }
+};
+
+void create(int * val, int cnt, TreeNode *cur,int idx){
+    int left_idx = (idx + 1) * 2 - 1;
+    int right_idx = (idx + 1) * 2 ;
+    if(left_idx > cnt){
+        cur->left = nullptr;
+        cur->right = nullptr;
+        return;
+    }
+    if(right_idx > cnt){
+        cur->right = nullptr;
+        return;
+    }
+    if(val[left_idx] == -1){
+        cur -> left = nullptr;
+    }else{
+        TreeNode * left_child = new TreeNode(val[left_idx]);
+        cur->left = left_child;
+        create(val,cnt,left_child,left_idx);
+    }
+    if(val[right_idx] == -1){
+        cur -> right = nullptr;
+    }else{
+        TreeNode * right_child = new TreeNode(val[right_idx]);
+        cur->right = right_child;
+        create(val, cnt, right_child, right_idx);
+    }
+    return;
+}
+void traverse(TreeNode* node){
+    cout<<node->val<<' ';
+    if(node->left != nullptr){
+        traverse(node->left);
+    }
+    if(node->right != nullptr){
+        traverse(node->right);
+    }
+    return;
+}
+TreeNode* createTree(int * val, int cnt){
+    TreeNode * root = new TreeNode(val[0]);
+    cout<<"create a tree"<<endl;
+    create(val,cnt,root, 0);
+    traverse(root);
+    cout<<"\ndone"<<endl;
+    // cout<<endl;
+    return root;
+}
+int main(){
+    Solution sol;
+
+    //create example 1
+    const int ex1_length = 15;
+    int ex1_data[ex1_length] = {4,1,6,0,2,5,7,-1,-1,-1,3,-1,-1,-1,8};
+    TreeNode * ex1 = createTree(ex1_data, ex1_length);
+    sol.bstToGst(ex1);
+    traverse(ex1);
+    cout<<endl;
+
+    const int ex2_length = 3;
+    int ex2_data[ex2_length] = {0,-1,1};
+    TreeNode * ex2 = createTree(ex2_data,ex2_length);
+    sol.bstToGst(ex2);
+    traverse(ex2);
+    cout<<endl;
+
+
+    return 0;
+}

104-240525-pass/main.py

@@ -0,0 +1,10 @@
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        cnt = 0
+        if head == None: return False
+        while cnt < 1e4+10:
+            if head.next == None:
+                return False
+            head = head.next
+            cnt += 1
+        return True

108-240525-pass/main.py

@@ -0,0 +1,20 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def sortedArrayToBST(self, nums: List[int]) -> Optional[TreeNode]:
+        print(nums)
+        if len(nums) == 0: return None
+        mid = len(nums) // 2
+        # if mid == 0 : return TreeNode(nums[mid], None, None)
+        node = TreeNode(nums[mid], None, None)
+        if mid != 0:
+            left_nums = nums[:mid]
+            node.left = self.sortedArrayToBST(left_nums)
+        if mid + 1 < len(nums): 
+            right_nums = nums[mid + 1: ]
+            node.right = self.sortedArrayToBST(right_nums)
+        return node

1094-20231203-pass/main.cpp

@@ -0,0 +1,47 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution {
+public:
+    bool carPooling(vector<vector<int>>& trips, int capacity) {
+        int len = trips.size();
+        struct op{
+            bool tp;
+            int people;
+            int station;
+        };
+        vector<op> ops(trips.size()*2+10);
+        for(int i = 0 ; i < trips.size() ;i++){
+            op in = {true,trips[i][0],trips[i][1]};
+            op out = {false,trips[i][0],trips[i][2]};
+            ops[i*2] = in;
+            ops[i*2+1] = out;
+        }
+        sort(ops.begin(), ops.end(), [](const op a, const op& b){
+            return a.station<b.station||(a.station == b.station && a.tp < b.tp);
+        });
+        int peo = 0;
+        for(int i = 0 ; i < ops.size() ; i++){
+            if(!ops[i].tp){
+                peo-=ops[i].people;
+            }
+            if(ops[i].tp){
+                peo+=ops[i].people;
+                if(peo>capacity)
+                    return false;
+            }
+        }
+        return true;
+    }
+};
+
+int main(){
+    Solution sol;
+    vector<int> sta1 = {2,1,5};
+    vector<int> sta2 = {3,3,7};
+    vector<vector<int> >ex1 = {sta1,sta2};
+    cout<<sol.carPooling(ex1, 4)<<endl;
+    cout<<sol.carPooling(ex1, 5)<<endl;
+    
+    
+    return 0;
+}

125-240524-pass/main.py

@@ -0,0 +1,25 @@
+def isPalindrome(s: str) -> bool:
+    tmp = s
+    tmp = tmp.lower()
+    def is_char(ch):
+        if (ch >= 'a' and ch <= 'z') or (ch >= '0' and ch <= '9'):
+            return True
+        return False
+    exp = []
+    for lt in tmp:
+        if is_char(lt):
+            exp.append(lt)
+    length = len(exp)
+    for index, ele in enumerate(exp):
+        if(exp[index] != exp[length - index - 1]):
+            return False
+    return True
+
+s = 'A man, a plan a canal: Panama'
+print(isPalindrome(s))
+s = " "
+print(isPalindrome(s))
+s = "race a car"
+print(isPalindrome(s))
+s = "0P"
+print(isPalindrome(s))

130-240602-pass/main.py

@@ -0,0 +1,63 @@
+class Solution:
+    def solve(self, board: List[List[str]]) -> None:
+        """
+        Do not return anything, modify board in-place instead.
+        """
+        que = []
+        front = -1
+        tail = -1
+
+        def push_back(que, front, tail, ele):
+            lq = len(que)
+            tail += 1
+            if lq <= tail:
+                que.append(ele)
+            else:
+                que[tail] = ele
+            return tail
+        def pop(que, front, tail):
+            front += 1
+            return (que[front], front)
+        d = [(1,0),(-1,0),(0,1),(0,-1)]
+        height = len(board)
+        width = len(board[0])
+        def is_valid(x, y):
+            if x<0 or y < 0 or x >= height or y >= width:
+                return False
+            return True
+        is_visited = []
+        for x, l in enumerate(board):
+            is_visited.append([])
+            for y in l:
+                is_visited[x].append(0)
+        if height < 3 or width < 3:
+            return board
+        def is_edge(x, y):
+            if x == 0 or y == 0 or x == height - 1 or y == width - 1:
+                return True
+            return False
+        for x in range(1,height - 1):
+            for y in range(1,width - 1):
+                if board[x][y] == 'X' or is_visited[x][y] == 1: continue
+                tail = push_back(que,front, tail,(x,y))
+                flag = 0
+                last_front = front
+                while front != tail:
+                    (top_ele, front) = pop(que, front, tail)
+                    for (cx, cy) in d:
+                        nx = cx + top_ele[0]
+                        ny = cy + top_ele[1]
+                        if is_edge(nx, ny):
+                            if board[nx][ny] == 'O': 
+                                flag = 1
+                            continue
+                        if board[nx][ny] == 'O' and is_visited[nx][ny]==0:
+                            tail = push_back(que,front,tail,(nx,ny))
+                            is_visited[nx][ny]=1
+                if flag == 0:
+                    for idx in range(last_front + 1, front + 1):
+                        xx = que[idx][0]
+                        yy = que[idx][1]
+                        board[xx][yy]='X'
+        return board
+        

138-240617-pass/main.py

@@ -0,0 +1,48 @@
+class Solution:
+    def copy RandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        l = []
+        cur = head
+        while cur != None:
+            l.append(cur)
+            cur = cur.next
+        n_l = []
+        for i in range(len(l)):
+            tmp = Node()
+            tmp.val = l[i].val
+            n_l.append(tmp)
+        for i in range(len(l)):
+            if l[i].random == None: continue
+            n_l[i].random = n_l[l[i].random.val]
+            if i == len(l) - 1: continue
+            n_l[i].next = n_l[i+1]
+        return n_l[0]
+"""
+class Node:
+    def __init__(self, x: int, next: 'Node' = None, random: 'Node' = None):
+        self.val = int(x)
+        self.next = next
+        self.random = random
+"""
+
+class Solution:
+    def copyRandomList(self, head: 'Optional[Node]') -> 'Optional[Node]':
+        if head == None: 
+            return None
+        l = []
+        cur = head
+        cnt = 0
+        m = {}
+        while cur != None:
+            l.append(cur)
+            m[cur] = cnt
+            cur = cur.next
+            cnt += 1
+        n_l = []
+        for i in range(len(l)):
+            tmp = Node(l[i].val)
+            n_l.append(tmp)
+        for i in range(len(l)):
+            if i != len(l) - 1: n_l[i].next = n_l[i+1]
+            if l[i].random == None: continue
+            n_l[i].random = n_l[m[l[i].random]]
+        return n_l[0]

141-240525-pass/main.py

@@ -0,0 +1,21 @@
+# Definition for singly-linked list.
+class ListNode:
+    def __init__(self, x):
+        self.val = x
+        self.next = None
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+class Solution:
+    def hasCycle(self, head: Optional[ListNode]) -> bool:
+        cnt = 0
+        if head == None: return False
+        while cnt < 1e4+10:
+            if head.next == None:
+                return False
+            head = head.next
+            cnt += 1
+        return True

1423-231205-pass/main.cpp

@@ -0,0 +1,69 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution {
+public:
+    int maxScore1(vector<int>& cardPoints, int k) {
+        const int len = 1e5+10;
+        const int siz = cardPoints.size();
+        int h2t_state[len][2]= {}, t2h_state[len][2] = {};
+        h2t_state[0][1] = cardPoints[0];
+        t2h_state[siz-1][1] = cardPoints[siz - 1];
+        for(int i = 2 ; i <= k ; i++){
+            int idx = i%2;
+            for(int j = 0 ; j < i ; j++){
+                // h2t_state[j][idx] = t2h_state[siz-j-1][1-idx] + cardPoints[j];
+                // t2h_state[siz-j-1][idx] = h2t_state[j][1-idx] + cardPoints[siz-j-1];
+                if(j == 0){
+                    h2t_state[j][idx] = t2h_state[siz - i + 1][1-idx] + cardPoints[j];
+                    t2h_state[siz-j-1][idx] = h2t_state[ i - 2 ][1-idx] + cardPoints[siz-j-1];
+                }else{
+                    h2t_state[j][idx] = h2t_state[j-1][1-idx] + cardPoints[j];
+                    t2h_state[siz-j-1][idx] = t2h_state[siz-j][1-idx] + cardPoints[siz-j-1];
+                }
+            }
+            // cout<<"i: "<<i<<endl;
+            // for(int j = 0 ; j < siz ; j++){
+            //     cout<<h2t_state[j][idx]<<' '<<t2h_state[j][idx]<<' ';
+            //     cout<<h2t_state[j][1-idx]<<' '<<t2h_state[j][1-idx]<<endl;
+            // }
+            // cout<<"======"<<endl;
+        }
+        // cout<<"++++++++"<<endl;
+        int rlt = -1;
+        for(int i = 0 ; i < siz ; i++){
+            rlt = max(rlt,h2t_state[i][k%2]);
+            rlt = max(rlt,t2h_state[i][k%2]);
+            // cout<<h2t_state[i][k%2]<<' '<<t2h_state[i][k%2]<<endl;
+        }
+        // cout<<"done"<<endl;
+        return rlt;
+    }
+    int maxScore(vector<int>& cardPoints, int k){
+        int sum = 0;
+        int ans = 0;
+        int sz = cardPoints.size();
+        for(int i = 0 ; i < k ; i++) sum+=cardPoints[i];
+        ans = sum;
+        for(int i = 0 ; i < k ; i++){
+            sum-=cardPoints[k - i - 1];
+            sum+=cardPoints[sz - 1 - i];
+            ans = max(ans, sum);
+            cout<<sum<<endl;
+        }
+        return ans;
+    }
+};
+int main(){
+    Solution sol;
+    vector<int> ex1 = {1,2,3,4,5,6,1};
+    int k1 = 3;
+    cout<<sol.maxScore(ex1,k1)<<endl;
+
+    vector<int> ex2 = {2,2,2};
+    int k2 = 2;
+    cout<<sol.maxScore(ex2,k2)<<endl;
+
+    vector<int> ex3 = {9,7,7,9,7,7,9};
+    int k3 = 7;
+    cout<<sol.maxScore(ex3,k3)<<endl;
+}

155-240605-pass/main.py

@@ -0,0 +1,43 @@
+class MinStack:
+    def __init__(self):
+        self.sta = []
+        self.minn = 2 ** 31
+        self.tops = -1
+        self.sorted = []
+    
+    def push(self, val: int) -> None:
+        self.tops += 1
+        if len(self.sta) <= self.tops:
+            self.sta.append(val)
+        else:
+            self.sta[self.tops] = val
+        flag = False
+        for ind, num in enumerate(self.sorted):
+            if val < num:
+                self.sorted.insert(ind,val)
+                flag = True
+                break
+        if flag == False:
+            self.sorted.append(val)
+        self.minn = min(self.minn, val)
+
+    def pop(self) -> None:
+        val = self.sta[self.tops]
+        self.sorted.remove(val)
+        self.tops -= 1
+
+    def top(self) -> int:
+        return self.sta[self.tops]
+
+    def getMin(self) -> int:
+        return self.sorted[0]
+
+    
+mins = MinStack()
+mins.push(-2)
+mins.push(0)
+mins.push(-3)
+print(mins.getMin())
+print(mins.pop())
+print(mins.top())
+print(mins.getMin())

155-240605/main.py

@@ -0,0 +1,43 @@
+class MinStack:
+    def __init__(self):
+        self.sta = []
+        self.minn = 2 ** 31
+        self.tops = -1
+        self.sorted = []
+    
+    def push(self, val: int) -> None:
+        self.tops += 1
+        if len(self.sta) <= self.tops:
+            self.sta.append(val)
+        else:
+            self.sta[self.tops] = val
+        flag = False
+        for ind, num in enumerate(self.sorted):
+            if val < num:
+                self.sorted.insert(ind,val)
+                flag = True
+                break
+        if flag == False:
+            self.sorted.append(val)
+        self.minn = min(self.minn, val)
+
+    def pop(self) -> None:
+        val = self.sta[self.tops]
+        self.sorted.remove(val)
+        self.tops -= 1
+
+    def top(self) -> int:
+        return self.sta[self.tops]
+
+    def getMin(self) -> int:
+        return self.sorted[0]
+
+    
+mins = MinStack()
+mins.push(-2)
+mins.push(0)
+mins.push(-3)
+print(mins.getMin())
+print(mins.pop())
+print(mins.top())
+print(mins.getMin())

1599-240101-pass/main.cpp

@@ -0,0 +1,77 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution {
+public:
+    int minOperationsMaxProfit(vector<int>& customers, int boardingCost, int runningCost) {
+        if(boardingCost * 4 < runningCost) return -1;
+        int waiting = 0;
+        int profit = 0;
+        int max_profit= -1;
+        int wheel = 0;
+        int ans = wheel;
+        for(int i = 0 ; i < customers.size();i++){
+            waiting += customers[i];
+            if(waiting <= 4){
+                profit += waiting * boardingCost - runningCost;
+                waiting = 0;
+            }else{
+                profit += 4 * boardingCost - runningCost;
+                waiting -= 4;
+            }
+            cout<<waiting<<' '<<profit<<endl;
+            wheel++;
+            if(max_profit < profit){
+                ans = wheel;
+                max_profit = profit;
+            }
+        }
+        profit += waiting / 4 * ( 4 * boardingCost - runningCost);
+        wheel += waiting / 4;
+        if(max_profit < profit){
+            ans = wheel;
+            max_profit = profit;
+        }
+        cout<<wheel<<' '<<profit<<endl;
+        profit += waiting % 4 * boardingCost - runningCost;
+        wheel++;
+        if(max_profit < profit){
+            ans = wheel;
+            max_profit = profit;
+        }
+        cout<<wheel<<' '<<profit<<endl;
+        // while(waiting){
+        //     if(waiting <= 4){
+        //         profit += waiting * boardingCost - runningCost;
+        //         waiting = 0;
+        //     }else{
+        //         profit += 4 * boardingCost - runningCost;
+        //         waiting -= 4;
+        //     }
+        //     wheel++;
+        //     cout<<waiting<<' '<<profit<<endl;
+        //     if(max_profit < profit){
+        //         ans = wheel;
+        //         max_profit = profit;
+        //     }
+        // }
+        if(max_profit <= 0 ) return -1;
+        return ans;
+    }
+};
+
+int main(){
+    Solution sol;
+    vector<int> customer_ex1 = {8,3};
+    int boardingCost = 5, runningCost = 6;
+    cout<<sol.minOperationsMaxProfit(customer_ex1,boardingCost,runningCost)<<endl;
+    vector<int> customer_ex2 = {10,9,6};
+    boardingCost = 6, runningCost = 4;
+    cout<<sol.minOperationsMaxProfit(customer_ex2,boardingCost,runningCost)<<endl;
+    vector<int> customer_ex3 = {3,4,0,5,1};
+    boardingCost = 1, runningCost = 92;
+    cout<<sol.minOperationsMaxProfit(customer_ex3,boardingCost,runningCost)<<endl;
+    vector<int> customer_ex4 = {2};
+    boardingCost = 2, runningCost = 4;
+    cout<<sol.minOperationsMaxProfit(customer_ex4,boardingCost,runningCost)<<endl;
+    return 0;
+}

167-240604-pass/main.py

@@ -0,0 +1,19 @@
+class Solution:
+    def twoSum(self, numbers: list[int], target: int) -> list[int]:
+        for idx, num in enumerate(numbers):
+            finding = target - num
+            left = idx
+            right  = len(numbers) - 1
+            while left <=  right:
+                mid = (left + right) // 2
+                if numbers[mid] == finding:
+                    return [idx + 1, mid + 1]
+                if numbers[mid] > finding:
+                    right = mid - 1
+                    continue
+                if numbers[mid] < finding:
+                    left = mid + 1
+sol = Solution()
+print(sol.twoSum([2, 7 ,11, 15], 26))
+print(sol.twoSum([-1, 9], 8))
+print(sol.twoSum([2,3,4], 6))

1688-20231205-pass/main.cpp

@@ -0,0 +1,24 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+    public:
+    int numberOfMatches(int n){
+        int sum = 0;
+        while(n!=1){
+            sum+=n/2;
+            if(n%2) n+=1;
+            n/=2;
+        }
+        return sum;
+    }
+};
+
+int main(){
+    Solution sol;
+    int n;
+    n = 7;
+    cout<<sol.numberOfMatches(n)<<endl;
+    n = 14;
+    cout<<sol.numberOfMatches(n)<<endl;
+    return 0;
+}

17-240525-pass/main.py

@@ -0,0 +1,30 @@
+class Solution:
+    def letterCombinations(self, digits: str) -> List[str]:
+        m = {
+            1: '',
+            2: 'abc',
+            3: 'def',
+            4: 'ghi',
+            5: 'jkl',
+            6: 'mno',
+            7: 'pqrs',
+            8: 'tuv',
+            9: 'wxyz',
+        }
+        rlt = []
+        for ch in digits:
+            num = int(ch)
+            if len(rlt) == 0:
+                for l in m[num]:
+                    rlt.append(l)
+            else:
+                tmp_rlt = rlt.copy()
+                for length in range(len(m[num])):
+                    ch = m[num][length]
+                    if length == 0:
+                        for index, s in enumerate(rlt):
+                            rlt[index] = tmp_rlt[index] + ch
+                    else:
+                        for index, s in enumerate(tmp_rlt):
+                            rlt.append(tmp_rlt[index] + ch)                            
+        return rlt

1716-20231206-pass/main.cpp

@@ -0,0 +1,31 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+    public:
+    int totalMoney(int n){
+        int monday = 0;
+        int rlt = 0;
+        for(int i = 1 ; i<=n ;i++){
+            if(i%7==1){
+                monday = monday + 1;
+                rlt += monday;
+                cout<<monday<<endl;
+            }else{
+                int amount = i%7;
+                if(!amount) amount = 7;
+                cout<< monday + amount - 1 <<endl;
+                rlt += monday + amount - 1 ;
+
+            }
+        }
+        cout<<endl;
+        return rlt;
+    }
+};
+int main(){
+    int n;
+    Solution sol;
+    cout<<sol.totalMoney(4)<<endl;
+    cout<<sol.totalMoney(10)<<endl;
+    cout<<sol.totalMoney(20)<<endl;
+}

190-240603-pass/main.py

@@ -0,0 +1,20 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        num = n
+        l = []
+        while num != 0:
+            l.append(num % 2)
+            num //= 2
+        rlt = 0
+        length = len(l)
+        while len(l) < 32:
+            l.append(0)
+        print(l)
+        l.reverse()
+        for i, n in enumerate(l):
+            rlt += n * pow(2, i)
+        return rlt
+
+
+sol = Solution()
+print(sol.reverseBits(43261596))

1903-20231207-pass/main.cpp

@@ -0,0 +1,22 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+public:
+    string largestOddNumber(string num){
+        string rlt = "";
+        for(int i = num.size() - 1 ; i >= 0 ; i--){
+            if(num[i]=='1' || num[i] == '3' || num[i] == '5' || num[i] == '7' || num[i] == '9'){
+                rlt = num.substr(0,i+1);
+                break;
+            }
+        }
+        return rlt;
+    }
+};
+int main(){
+    Solution sol;
+    cout<<sol.largestOddNumber("52")<<endl;
+    cout<<sol.largestOddNumber("2480")<<endl;
+    cout<<sol.largestOddNumber("35247")<<endl;
+    return 0; 
+}

198-240603-pass/main.py

@@ -0,0 +1,16 @@
+class Solution:
+    def rob(self, nums: list[int]) -> int:
+        s = []
+        rlt = -1e6
+        for i, num in enumerate(nums):
+            maxi = num
+            for j in range(0, i - 1, 1):
+                maxi = max(s[j] + num, maxi)
+            s.append(maxi)
+            rlt = max(maxi, rlt)
+        return rlt
+
+sol = Solution()
+print(sol.rob([1, 2, 3, 1]))
+print(sol.rob([2, 7, 9, 3, 1]))
+print(sol.rob([2, 7, 9, 9, 3, 1]))

199-240525-pass/main.cpp

@@ -0,0 +1,45 @@
+#include<iostream>
+#include<vector>
+#include<queue>
+
+using namespace std;
+
+ struct TreeNode {
+     int val;
+    TreeNode *left;
+     TreeNode *right;
+     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ };
+
+class Solution {
+public:
+    vector<int> rightSideView(TreeNode* root) {
+        queue<TreeNode *> que;
+        vector<int> rlt;
+        if(root == nullptr) return rlt;
+        que.push(root);
+        while(!que.empty()){
+            queue< TreeNode *> tmp_que;
+            TreeNode * node;
+            while(!que.empty()){
+                node = que.front();
+                tmp_que.push(node);
+                que.pop();
+            }
+            rlt.push_back(node->val);
+            while(!tmp_que.empty()){
+                node = tmp_que.front();
+                if(node->left != nullptr){
+                    que.push(node->left);
+                }
+                if(node->right != nullptr){
+                    que.push(node->right);
+                }
+                tmp_que.pop();
+            }
+        }
+        return rlt;
+    }
+};

20-240526-pass/main.py

@@ -0,0 +1,42 @@
+class Solution:
+    def isValid(self, s: str) -> bool:
+        def rcg_type(ch) -> int:
+            if ch[0] =='(':
+                return 1
+            if ch[0] ==')':
+                return 2
+            if ch[0] =='{':
+                return 3
+            if ch[0] =='}':
+                return 4
+            if ch[0] =='[':
+                return 5
+            if ch[0] ==']':
+                return 6
+        stack = []
+        top_idx = -1
+        def is_empty():
+            return top_idx == -1
+        def set_ele(stack: list, idx: int, ele: int):
+            if len(stack) <= idx:
+                stack.append(ele)
+            else:
+                stack[idx] = ele
+        for ch in s:
+            tp = rcg_type(ch)
+            if tp % 2 == 1:
+                top_idx += 1
+                set_ele(stack, top_idx, tp)
+            else:
+                if is_empty(): return False
+                top_ele = stack[top_idx]
+                if tp - top_ele != 1: return False
+                top_idx -= 1
+        if not is_empty(): return False
+        return True
+    
+sol = Solution()
+print(sol.isValid("()"))
+print(sol.isValid("(){}[]"))
+print(sol.isValid("(]"))
+print(sol.isValid("[(])"))

200-240525-pass/main.py

@@ -0,0 +1,58 @@
+class Solution:
+    def numIslands(self, grid: List[List[str]]) -> int:
+        searched_cell = set()
+        def va(s):
+            return int(s)
+        # bfs
+        ans = 0
+        row = len(grid)
+        column = len(grid[0])
+        def add_node(que, idx, node):
+            if len(que) <= idx:
+                que.append(node)
+            else:
+                que[idx] = node
+        def is_valid_node(node):
+            i = node[0]
+            j = node[1]
+            return i >= 0 and j >= 0 and i < row and j <column
+        flag = []
+        for i, l in enumerate(grid):
+            flag.append([])
+            for j, lee in enumerate(l):
+                flag[i].append(0)
+        for i, l in enumerate(grid):
+            for j, ele in enumerate(l):
+                val = va(grid[i][j])
+                if val == 0 : continue
+                # if (i,j) in searched_cell: continue
+                if flag[i][j] == 1: continue
+                que = [(i, j)]
+                idx = 0
+                while idx >= 0:
+                    node = que[idx]
+                    # if node in searched_cell: continue
+                    idx -= 1
+                    if flag[node[0]][node[1]] == 1: continue
+                    flag[node[0]][node[1]] = 1
+                    if va(grid[node[0]][node[1]]) == 0: continue                    
+                    up = (node[0] - 1, node[1])
+                    down = (node[0] + 1, node[1])
+                    left = (node[0], node[1] - 1)
+                    right = (node[0], node[1] + 1)
+                    if is_valid_node(up):
+                        idx += 1
+                        add_node(que, idx, up)
+                    if is_valid_node(down):
+                        idx += 1
+                        add_node(que,idx, down)
+                    if is_valid_node(left):
+                        idx += 1
+                        add_node(que, idx, left)
+                    if is_valid_node(right):
+                        idx += 1
+                        add_node(que,idx, right)
+                ans += 1
+        return ans
+
+                    

208-240525-pass/main.py

@@ -0,0 +1,26 @@
+class Trie:
+
+    def __init__(self):
+        self.l = []
+
+    def insert(self, word: str) -> None:
+        self.l.append(word)
+
+    def search(self, word: str) -> bool:
+        for s in self.l:
+            if s == word:
+                return True
+        return False
+
+    def startsWith(self, prefix: str) -> bool:
+        for s in self.l:
+            if s.startswith(prefix):
+                return True
+        return False
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)

208-240525-pass/main1.py

@@ -0,0 +1,42 @@
+class TrieNode:
+    def __init__(self, val = ''):
+        self.child = []
+        self.is_word = False
+        self.val = val
+        self.child_map = {}
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        parent_node = self.root
+        for idx, letter in enumerate(word):
+            if letter not in parent_node.child_map:
+                new_node = TrieNode(letter)
+                parent_node.child.append(new_node)
+                parent_node.child_map[letter] = len(parent_node.child) - 1
+                parent_node = new_node
+            else:
+                idx = parent_node.child_map[letter]
+                parent_node = parent_node.child[idx]
+        parent_node.is_word = True
+
+    def search(self, word: str) -> bool:
+        parent_node = self.root
+        for idx, letter in enumerate(word):
+            if letter not in parent_node.child_map:
+                return False
+            idx = parent_node.child_map[letter]
+            parent_node = parent_node.child[idx]
+        if parent_node.is_word == False:
+            return False
+        return True
+
+    def startsWith(self, prefix: str) -> bool:
+        parent_node = self.root
+        for idx, letter in enumerate(prefix):
+            if letter not in parent_node.child_map:
+                return False
+            idx = parent_node.child_map[letter]
+            parent_node = parent_node.child[idx]
+        return True

209-240524-pass/main.cpp

@@ -0,0 +1,36 @@
+#include<iostream>
+#include<vector>
+
+using namespace std;
+
+class Solution {
+public:
+    int minSubArrayLen(int target, vector<int>& nums) {
+        vector<int> sub;
+        sub.push_back(0);
+        int num_sum = 0;
+        for(int i = 0 ; i < nums.size() ; i++){
+            int num = nums[i];
+            sub.push_back(num_sum + num);
+            num_sum += num;
+        }
+        if(num_sum < target){
+            return 0;
+        }
+        for(int length = 1 ; length < nums.size() + 1 ; length ++){
+            for(int i = 0 ; i <= nums.size() - length;i++){
+                int rlt = sub[i+length] - sub[i];
+                if(rlt >= target){
+                    return length;
+                }
+            }
+        }
+        return 0;
+    }
+};
+
+int main(){
+    Solution *sol = new Solution();
+    vector<int>tmp = {2, 3, 1 ,4, 2 ,3};
+    cout<<sol->minSubArrayLen(7,tmp)<<endl;
+}

209-240524-pass/main.py

@@ -0,0 +1,42 @@
+class Solution1(object):
+    def minSubArrayLen(self, target, nums):
+        """
+        :type target: int
+        :type nums: List[int]
+        :rtype: int
+        """
+        sub = []
+        sub.append(0)
+        num_sum = 0
+        for ind, num in enumerate(nums):
+            sub.append(num_sum + num)
+            num_sum += num
+        print(nums)
+        for length in range(1, len(nums) + 1):
+            print(length)
+            for i in range(0, len(nums) - length + 1):
+                rlt = sub[ i + length ] - sub[i]
+                print(rlt, length, i)
+                if rlt >= target:
+                    return length
+        return 0
+class Solution:
+    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
+        if sum(nums) < target:
+            return 0
+        left_idx = 0
+        s = 0 # sum
+        ans = len(nums)
+
+        for right_idx, val in enumerate(nums):
+            s += val
+            while s >= target:
+                s -= nums[left_idx]
+                ans = min(ans, right_idx - left_idx + 1)
+                left_idx += 1
+        return ans
+
+print(Solution().minSubArrayLen(7, [2,3,1,2,4,3]))
+print(Solution().minSubArrayLen(4, [1, 1, 4]))
+print(Solution().minSubArrayLen(11, [1, 1, 1, 1]))
+print(Solution().minSubArrayLen(15, [1, 2, 3, 4, 5]))

211-240602-pass/main.py

@@ -0,0 +1,71 @@
+class TrieNode:
+    def __init__(self, val = ''):
+        self.child = []
+        self.is_word = False
+        self.val = val
+        self.child_map = {}
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+
+    def insert(self, word: str) -> None:
+        parent_node = self.root
+        for idx, letter in enumerate(word):
+            if letter not in parent_node.child_map:
+                new_node = TrieNode(letter)
+                parent_node.child.append(new_node)
+                parent_node.child_map[letter] = len(parent_node.child) - 1
+                parent_node = new_node
+            else:
+                idx = parent_node.child_map[letter]
+                parent_node = parent_node.child[idx]
+        parent_node.is_word = True
+
+    def search(self, word: str) -> bool:
+        def subsearch(node, word) -> bool:
+            parent_node = node
+            if len(word) == 0:
+                return parent_node.is_word
+            ch = word[0]
+            rlt = False
+            if ch == '.':
+                flag = 0
+                for child in parent_node.child_map:
+                    idx = parent_node.child_map[child]
+                    r = subsearch(parent_node.child[idx], word[1:])
+                    if r == True: flag = 1
+                if flag == 1:
+                    return True
+                else:
+                    return False
+            else:
+                if ch not in parent_node.child_map:
+                    return False
+                else:
+                    idx = parent_node.child_map[ch]
+                    return subsearch(parent_node.child[idx], word[1:])
+        return subsearch(self.root, word)
+
+    def startsWith(self, prefix: str) -> bool:
+        parent_node = self.root
+        for idx, letter in enumerate(prefix):
+            if letter not in parent_node.child_map:
+                return False
+            idx = parent_node.child_map[letter]
+            parent_node = parent_node.child[idx]
+        return True
+class WordDictionary:
+    def __init__(self):
+        self.tree = Trie()
+
+    def addWord(self, word: str) -> None:
+        self.tree.insert(word)
+
+    def search(self, word: str) -> bool:
+        return self.tree.search(word)
+
+
+# Your WordDictionary object will be instantiated and called as such:
+# obj = WordDictionary()
+# obj.addWord(word)
+# param_2 = obj.search(word)

2125-20240103-pass/main.cpp

@@ -0,0 +1,43 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+    public:
+    int numberOfBeams(vector<string> & bank){
+        int len = bank.size();
+        vector<string> null_bank;
+        for(string row_plan: bank){
+            bool flag = 1;
+            for(char ch: row_plan){
+                if(ch == '1'){
+                    flag = 0;
+                    break;
+                }
+            }
+            if(!flag) null_bank.push_back(row_plan);
+        }
+        long long ans = 0;
+        int last = 0;
+        for(string row_plan: null_bank){
+            int num = 0;
+            for(char ch : row_plan){
+                if(ch == '1')   num++;
+            }
+            ans += num*last;
+            last = num;
+        }
+        return ans;
+    }
+    
+};
+
+int main(){
+    Solution sol;
+    vector<string> ex1 = {"011001","000000","010100","001000"};
+    cout<<"ex1"<<endl;
+    cout<<sol.numberOfBeams(ex1)<<endl;
+
+    vector<string> ex2 = {"000","000","000"};
+    cout<<"ex2"<<endl;
+    cout<<sol.numberOfBeams(ex2)<<endl;
+    return 0;
+}

228-240525-pass/main.py

@@ -0,0 +1,29 @@
+class Solution:
+    def summaryRanges(self, nums: list[int]) -> list[str]:
+        if len(nums) == 0:
+            return []
+        rlt = []
+        start = nums[0]
+        end = start
+        last = start
+        for idx, ele in enumerate(nums[1:]):
+            if ele == last + 1:
+                end = ele
+            else:
+                rlt.append((start, end))
+                start = ele
+                end = ele
+            last = ele
+        rlt.append((start,end))
+        str_rlt = []
+        for ele in rlt:
+            if ele[0] == ele[1]:
+                str_rlt.append(f"{ele[0]}")
+            else:
+                str_rlt.append(f"{ele[0]}->{ele[1]}")
+        return str_rlt
+
+sol = Solution()
+print(sol.summaryRanges([0,1,2,4,5,7]))
+print(sol.summaryRanges([0,2,3,4,6,8,9]))
+                

2477-20231205-pass/main.cpp

@@ -0,0 +1,55 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+public:
+    int people_counter(
+        vector<vector<int> > nodes, int k, int prev, long long & ans, int seats
+    ){
+        int people = 1;
+        for(int node : nodes[k]){
+            if(node == prev){continue;}
+            people+=people_counter(nodes,node,k, ans, seats);
+        }
+        if(k > 0)
+            ans += (people+seats - 1)/seats;
+        return people;
+    }
+    long long minimumFuelCost(vector<vector<int> >& roads, int seats){
+        vector<vector<int> >nodes(roads.size() + 1); 
+        for(vector<int> edge: roads){
+            const int u = edge[0], v = edge[1];
+            nodes[u].push_back(v);
+            nodes[v].push_back(u);
+        }
+        long long ans = 0;
+        people_counter(nodes,0, -1, ans, seats);
+        cout<<ans<<endl;
+        return ans;
+    }
+};
+
+int main(){
+    Solution sol;
+    vector<int> rd1 = {3,1};
+    vector<int> rd2 = {3,2};
+    vector<int> rd3 = {1,0};
+    vector<int> rd4 = {0,4};
+    vector<int> rd5 = {0,5};
+    vector<int> rd6 = {4,6};
+    vector<vector<int> >ex1 = {rd1,rd2,rd3,rd4,rd5,rd6};
+    sol.minimumFuelCost(ex1, 2);
+
+    rd1[0]=0; rd1[1] = 1;
+    rd2[0]=0; rd2[1] = 2;
+    rd3[0]=0; rd3[1] = 3;
+    vector<vector<int> >ex2 = {rd1,rd2,rd3};
+
+    sol.minimumFuelCost(ex2, 5);
+
+    vector<vector<int> >ex3 ;
+    sol.minimumFuelCost(ex3,1);
+
+
+
+    
+}

2482-20231215/main.cpp

@@ -0,0 +1,52 @@
+#include<vector>
+#include<iostream>
+using namespace std;
+class Solution {
+public:
+    vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {
+        int cols[100010] = {};
+        int rows[100010] = {};
+        for(int i = 0 ; i < grid.size(); i++){
+            for(int j = 0 ; j < grid[i].size(); j++){
+                if(grid[i][j]){
+                    cols[j]++;
+                    rows[i]++;
+                }
+            }
+        }
+        int colszero[100010] = {};
+        int rowszero[100010] = {};
+        int cols_size = grid.size();
+        int rows_size = grid[0].size();
+        for(int i = 0 ; i <grid.size();i++){
+            colszero[i] = cols_size - cols[i];
+            rowszero[i] = rows_size - rows[i];
+        }
+        
+
+        vector<vector<int> >rlt;
+        for(int i = 0 ; i < cols_size ; i++){
+            vector<int> tmp ;
+            for(int j = 0 ; j <rows_size ;j++){
+                tmp.push_back(rows[i]+cols[j]-colszero[j]-rowszero[i]);
+            }
+            rlt.push_back(tmp);
+        }
+        return rlt;
+    }
+};
+int main(){
+    Solution sol;
+    vector<int> ex1row1 = {0,1,1};
+    vector<int> ex1row2 = {1,0,1};
+    vector<int> ex1row3 = {0,0,1};
+    vector<vector<int> >ex1 = {ex1row1, ex1row2, ex1row3};
+    auto sol1 = sol.onesMinusZeros(ex1);
+    for(int i = 0 ; i < sol1.size();i++){
+        for(int j = 0 ; j < sol1[i].size(); j++){
+            cout<<sol1[i][j]<<' ';
+        }
+        cout<<endl;
+    }
+    return 0;
+}

2487-240103/main.cpp

@@ -0,0 +1,25 @@
+#include<stdcpp.h>
+using namespace std;
+struct ListNode{
+    int val;
+    ListNode *next;
+    ListNode() : val(0), next(nullptr){}
+    ListNode(int x): val(x), next(nullptr) {}
+    ListNode(int x, ListNode *next) : val(x), next(next) {}
+};
+class Solution{
+public:
+    ListNode* removeNodes(ListNode* head){
+        ListNode * now = head;
+        while(now->next != NULL){
+            if(now->val < now->next->val){
+                while   
+            }
+        }
+    }
+};
+int main(){
+    Solution sol;
+    ListNode * ex1 = new ListNode(5);
+
+}

26-240604-pass/main.py

@@ -0,0 +1,10 @@
+class Solution:
+    def removeDuplicates(self, nums: List[int]) -> int:
+        k = {}
+        cnt = 0
+        for num in nums:
+            if num not in k:
+                nums[cnt] = num
+                cnt += 1
+                k[num] = 1
+        return cnt

2610-20240102-pass/main.cpp

@@ -0,0 +1,59 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution{
+    public:
+    vector<vector<int> > findMatrix(vector<int>& nums){
+        sort(nums.begin(),nums.end(),greater<int>());
+        int max_cate = 1;
+        int cate = 1;
+        for(int i = 1 ; i < nums.size();i++){
+            if(nums[i]==nums[i-1])
+                cate++;
+            else{
+                max_cate = max(max_cate,cate);
+                cate = 1;
+            }
+        }
+        max_cate = max(max_cate,cate);
+        vector<vector<int> > rlt(max_cate);
+        int cnt = 0;
+        while(cnt < nums.size() - 1){
+            int cnt_in = 0;
+            rlt[cnt_in++].push_back(nums[cnt++]);
+            while(cnt<nums.size() - 1&&nums[cnt]==nums[cnt-1]){
+                rlt[cnt_in++].push_back(nums[cnt++]);
+            }
+        }
+        for(int i = 0 ; i < rlt.size() ;i++){
+            int end = rlt[i].size() - 1;
+            if(rlt[i].size() == 0||rlt[i][end]!=nums[nums.size()-1]) {
+                rlt[i].push_back(nums[nums.size() - 1]);
+                break;
+            }
+        }
+        return rlt;
+    }
+};
+int main(){
+    Solution sol;
+    cout<<"ex1"<<endl;
+    vector<int> ex1_nums = {1,3,4,1,2,3,1};
+    vector<vector<int> >rlt1 = sol.findMatrix(ex1_nums);
+    for(int i = 0 ; i < rlt1.size();i++){
+        for(int j = 0 ; j <rlt1[i].size();j++){
+            cout<<rlt1[i][j]<<' ';
+        }
+        cout<<endl;
+    }
+    cout<<endl;
+    cout<<"ex2"<<endl;
+    vector<int> ex2_nums = {4,4,3};
+    vector<vector<int> >rlt2 = sol.findMatrix(ex2_nums);
+    for(int i = 0 ; i < rlt2.size();i++){
+        for(int j = 0 ; j <rlt2[i].size();j++){
+            cout<<rlt2[i][j]<<' ';
+        }
+        cout<<endl;
+    }
+
+}

2661-231201/main.cpp

@@ -0,0 +1,26 @@
+#include<stdcpp.h>
+using namespace std;
+
+class Solution{
+    public:
+    int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
+        
+    }
+};
+
+int main(){
+    Solution sol;
+
+    vector<int> ex1_arr = {1,3,4,2};
+    vector<int> ex1_row1 = {1,4};
+    vector<int> ex1_row2 = {2,3};
+    vector<vector<int> > ex1_mat = {ex1_row1,ex1_row2};
+    sol.firstCompleteIndex(ex1_arr, ex1_mat);
+
+    vector<int> ex2_arr = {2,8,7,4,1,3,5,6,9};
+    vector<int> ex2_row1 = {3,2,5};
+    vector<int> ex2_row2 = {1,4,6};
+    vector<int> ex2_row3 = {8,7,9};
+    vector<vector<int> > ex2_mat = {ex2_row1,ex2_row2,ex2_row3};
+    sol.firstCompleteIndex(ex2_arr, ex2_mat);
+}

27-240525-pass/main.py

@@ -0,0 +1,18 @@
+class Solution:
+    def removeElement(self, nums: list[int], val: int) -> int:
+        cnt = 0
+        for num in nums:
+            if num == val: cnt+=1
+        for i in range(len(nums) - cnt):
+            if nums[i] == val:
+                for j in range(len(nums) - 1, 0, -1):
+                    if nums[j] != val:
+                        nums[i], nums[j] = (nums[j], nums[i])
+        print(nums)
+        return len(nums) - cnt
+
+nums = [3, 2, 2, 3]
+val = 3
+sol = Solution()
+print(sol.removeElement(nums, val))
+

3-240603-pass/main.py

@@ -0,0 +1,36 @@
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        dic = {}
+        def encode(ch) -> int:
+            if ch not in dic:
+                dic[ch] = len(dic)
+            return dic[ch]
+
+        l = [0 for i in range(108)]
+        rlt = 0
+        start = 0
+        
+        for i, ch in enumerate(s):
+            idx = encode(ch)
+            if(l[idx] >= 1):
+                rlt = max(rlt, i - start )
+                # print("now", start, rlt)
+                while start < i and l[idx] >= 1:
+                    tmp = encode(s[start])
+                    start = start + 1
+                    l[tmp] -= 1
+            l[idx] += 1
+            # print(ch, start, l )
+        rlt = max(rlt, len(s) - start )
+        if rlt == 0: return len(s)
+        return rlt
+
+sol = Solution()
+print(sol.lengthOfLongestSubstring("abcabcbb"))
+print(sol.lengthOfLongestSubstring("bbbbb"))
+print(sol.lengthOfLongestSubstring("pwwkew"))
+print(sol.lengthOfLongestSubstring("abcde"))
+print(sol.lengthOfLongestSubstring("abcdbej"))
+print(sol.lengthOfLongestSubstring("bbcdjeb"))
+print(sol.lengthOfLongestSubstring(" "))
+print(sol.lengthOfLongestSubstring("1 b 234aac 2"))

30-240604/main.py

@@ -0,0 +1,146 @@
+class TrieNode:
+    def __init__(self, val = ''):
+        self.child = []
+        self.is_word = 0
+        self.val = val
+        self.t = 1
+        self.child_map = {}
+class Trie:
+    def __init__(self):
+        self.root = TrieNode()
+        self.cnt = 0
+
+    def insert(self, word: str) -> None:
+        parent_node = self.root
+        for idx, letter in enumerate(word):
+            if letter not in parent_node.child_map:
+                new_node = TrieNode(letter)
+                parent_node.child.append(new_node)
+                parent_node.child_map[letter] = len(parent_node.child) - 1
+                parent_node = new_node
+            else:
+                idx = parent_node.child_map[letter]
+                parent_node = parent_node.child[idx]
+        if parent_node.is_word != 0:
+            parent_node.t += 1
+        parent_node.is_word = self.cnt + 1
+        self.cnt += 1
+
+    def search(self, word: str) :
+        parent_node = self.root
+        for idx, letter in enumerate(word):
+            if letter not in parent_node.child_map:
+                return None
+            idx = parent_node.child_map[letter]
+            parent_node = parent_node.child[idx]
+        if parent_node.is_word != 0:
+            return parent_node
+        return None
+
+    def startsWith(self, prefix: str) -> bool:
+        parent_node = self.root
+        for idx, letter in enumerate(prefix):
+            if letter not in parent_node.child_map:
+                return False
+            idx = parent_node.child_map[letter]
+            parent_node = parent_node.child[idx]
+        return True
+
+class Solution:
+    def findSubstring(self, s: str, words: list[str]) -> list[int]:
+        len_word = len(words[0])
+        tree = Trie()
+        is_word = []
+
+        rlt = []
+        state = []
+        word_cnt = {}
+
+        if len_word > len(s): return []
+
+        for word in words:
+            tree.insert(word)
+            r = tree.search(word)
+            if r != None:
+                word_cnt[r.is_word] = r.t
+        # print(word_cnt)
+
+        for idx, ch in enumerate(s):
+            if idx + len_word > len(s): break
+            waiting = s[idx:idx+len_word]
+            r = tree.search(waiting)
+            if r != None:
+                is_word.append(r.is_word)
+            else:
+                is_word.append(0)
+        for i in range(len_word - 1) : is_word.append(0)
+        for i in range(len_word):
+            if is_word[i] != 0:
+                tmp_dic = {is_word[i]: [i]}
+                state.append((tmp_dic,i,i))
+            else:
+                state.append(({},i,i))
+        
+        if len(words) == 1 and words[0] == s:
+            return [0]
+        # is_word[idx] = value words index / 0 if it is not a word
+        # state[dic_idx][0]
+        for i in range(len(is_word[len_word:])):
+            idx = i + len_word
+            dic_idx = idx % len_word
+            # print(f"current index: {idx}, {idx % len_word}")
+            # print(f"current dic: {state[dic_idx]}")
+            # print(f"is_word[idx]: {is_word[idx]}")
+            if is_word[idx] in state[dic_idx][0] and len(state[dic_idx][0][is_word[idx]]) >= word_cnt[is_word[idx]]:
+                # print("condition 1")
+                tmp = state[dic_idx][0][is_word[idx]][0]
+                tmp_l = []
+                for key in state[dic_idx][0]:
+                    for i, v in enumerate(state[dic_idx][0][key]):
+                        if v <= tmp:
+                            tmp_l.append((key, i))
+
+                for (key, i) in tmp_l:
+                    state[dic_idx][0][key].pop(i)
+                    if len(state[dic_idx][0][key]) == 0:
+                        del state[dic_idx][0][key]
+                
+                if is_word[idx] not in state[dic_idx][0]:
+                    state[dic_idx][0][is_word[idx]] = [idx] 
+                else:
+                    state[dic_idx][0][is_word[idx]].append(idx)
+                state[dic_idx] = (state[dic_idx][0], tmp + len_word, state[dic_idx][2])
+            elif is_word[idx] != 0:
+                # print("condition 2")
+                if len(state[dic_idx][0]) == 0:
+                    state[dic_idx] = ({}, idx, idx)
+                if is_word[idx] in state[dic_idx][0]:
+                    state[dic_idx][0][is_word[idx]].append(idx)
+                else:
+                    state[dic_idx][0][is_word[idx]]=[idx]
+            elif is_word[idx] == 0:
+                # print("condition 3")
+                state[dic_idx] = ({}, idx, idx)
+
+            state[dic_idx] = (state[dic_idx][0],state[dic_idx][1], idx)
+            s = 0
+            for k in state[dic_idx][0]:
+                s += len(state[dic_idx][0][k])
+            # if len(state[dic_idx][0]) == len(words):
+            if s == len(words):
+                # print(f"win, {idx}")
+                rlt.append(state[dic_idx][1])
+                del state[dic_idx][0][is_word[state[dic_idx][1]]]
+                state[dic_idx] = (state[dic_idx][0], state[dic_idx][1] + len_word, state[dic_idx][2])
+            # print(f"after fixed: {state[dic_idx]}")
+            # print()
+        return rlt
+
+sol = Solution()
+print(sol.findSubstring("barfoothefoobarman", words=["foo", "bar"]))
+print(sol.findSubstring("barfoofoobarthefoobarman", words=["foo", "bar", "the"]))
+print(sol.findSubstring("barbarbbar", words=["arb", "bar"]))
+print(sol.findSubstring("wordgoodgoodgoodbestword", words=["word", "good", "good", "best"]))
+print(sol.findSubstring("aaa", words=["a"]))
+print(sol.findSubstring("word", words=["word"]))
+

35-240525-pass/main.py

@@ -0,0 +1,17 @@
+class Solution:
+    def searchInsert(self, nums: List[int], target: int) -> int:
+        left = 0
+        right = len(nums)
+        while left < right:
+            mid = (left + right) // 2
+            print(mid, nums[mid])
+            if nums[mid] == target: return mid
+            elif nums[mid] < target:
+                left = mid
+            elif nums[mid] > target:
+                right = mid
+            if right - left == 1: 
+                if target > nums[left]: return right
+                else: return left
+            print(left, right, mid)
+        return 0

36-240525-pass/main.py

@@ -0,0 +1,74 @@
+class Solution:
+    def isValidSudoku(self, board: list[list[str]]) -> bool:
+        plates = []
+        for l in board:
+            plates.append([])
+            for ch_num in l:
+                if ch_num.isalnum():
+                    num = int(ch_num[0])
+                else:
+                    num = -1
+                plates[-1].append(num)
+        def judge_1(plates, i, j):
+            t = plates[i][j]
+            for idx, num in enumerate(plates[i]):
+                if idx == j: continue
+                if num == t: return False
+            return True
+        
+        def judge_2(plates, i, j):
+            t = plates[i][j]
+            l = []
+            for idx in range(0, 9):
+                l.append(plates[idx][j])
+            for idx, num in enumerate(l):
+                if idx == i: continue
+                if num == t: return False
+            return True
+
+        def judge_3(plates, i, j):
+            row = i // 3 * 3
+            col = j // 3 * 3
+            l = []
+            for idx1 in range(row, row + 3):
+                for idx2 in range(col, col + 3):
+                    if idx1 == i and idx2 ==j: continue
+                    l.append(plates[idx1][idx2])
+            for idx,num in enumerate(l):
+                if num == plates[i][j]:
+                    return False 
+            return True
+
+        for i in range(0, 9):
+            for j in range(0, 9):
+                if plates[i][j] == -1: continue
+                if not judge_1(plates, i, j):
+                    return False
+                if not judge_2(plates, i, j):
+                    return False
+                if not judge_3(plates, i, j):
+                    return False
+        return True
+                
+board = [["5","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+
+sol = Solution()
+print(sol.isValidSudoku(board=board))
+board = [["8","3",".",".","7",".",".",".","."]
+,["6",".",".","1","9","5",".",".","."]
+,[".","9","8",".",".",".",".","6","."]
+,["8",".",".",".","6",".",".",".","3"]
+,["4",".",".","8",".","3",".",".","1"]
+,["7",".",".",".","2",".",".",".","6"]
+,[".","6",".",".",".",".","2","8","."]
+,[".",".",".","4","1","9",".",".","5"]
+,[".",".",".",".","8",".",".","7","9"]]
+print(sol.isValidSudoku(board=board))

383-240524-pass/main.py

@@ -0,0 +1,27 @@
+class Solution:
+    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
+        ran_dic = {}
+        mag_dic = {}
+        for l in ransomNote:
+            if l not in ran_dic:
+                ran_dic[l] = 1
+            else:
+                ran_dic[l] += 1
+        for l in magazine:
+            if l not in mag_dic:
+                mag_dic[l] = 1
+            else:
+                mag_dic[l] += 1
+        print(ran_dic)
+        print(mag_dic)
+        for key in ran_dic:
+            if key not in mag_dic:
+                return False
+            if ran_dic[key] > mag_dic[key]:
+                return False
+        return True
+
+sol = Solution()
+print(sol.canConstruct("a", "b"))
+print(sol.canConstruct("aa", "ab"))
+print(sol.canConstruct("aa", "aab"))

39-240619-pass/main.py

@@ -0,0 +1,16 @@
+class Solution:
+    def combinationSum(self, candidates: list[int], target: int) -> list[list[int]]:
+        candidates.sort()
+        rlt = []
+        def dfs(cur, l, cur_num):
+            if cur == 0:
+                rlt.append(l)
+            for candidate in candidates:
+                if cur - candidate >= 0 and candidate >= cur_num:
+                    dfs(cur - candidate, l + [candidate], candidate)
+        dfs(target, [], candidates[0])
+        return rlt
+
+
+sol = Solution()
+print(sol.combinationSum([2,3,6,7], 7))

392-240527-pass/main.py

@@ -0,0 +1,17 @@
+class Solution:
+    def isSubsequence(self, s: str, t: str) -> bool:
+        cnt = 0
+        idt_m = 0
+        for idx, chs in enumerate(s):
+            for idt, cht in enumerate(t[idt_m:]):
+                if cht == chs:
+                    idt_m = idt + idt_m + 1
+                    cnt += 1
+                    break
+        if cnt == len(s): return True
+        return False
+        
+sol = Solution()
+s = "axc"
+t = "ahbgdc"
+print(sol.isSubsequence(s,t))

399-240619-pass/main.py

@@ -0,0 +1,55 @@
+class Solution:
+    def calcEquation(self, equations: list[list[str]], values: list[float], queries: list[list[str]]) -> list[float]:
+        vs = []
+        for equation in equations:
+            first_var = equation[0]
+            second_var = equation[1]
+            if first_var not in vs:
+                vs.append(first_var)
+            if second_var not in vs:
+                vs.append(second_var)
+        index_map = {}
+        for ind, var in enumerate(vs):
+            index_map[var] = ind
+        ls = []
+        vs_len = len(vs)
+        for ind, var in enumerate(vs):
+            ls.append([])
+            for i in range(vs_len):
+                if i == ind:
+                    ls[ind].append(1)
+                else:
+                    ls[ind].append(-1)
+        for ind, equation in enumerate(equations):
+            first_ind = index_map[equation[0]]
+            second_ind = index_map[equation[1]]
+            ls[first_ind][second_ind] = values[ind]
+            ls[second_ind][first_ind] = 1.0 / values[ind]
+        flag = 1
+        while flag == 1:
+            flag = 0
+            for i in range(vs_len):
+                for j in range(vs_len):
+                    for k in range(vs_len):
+                        if ls[i][j] != -1 : continue
+                        if ls[i][k] == -1 or ls[k][j] == -1: continue
+                        flag = 1
+                        ls[i][j] = ls[i][k] * ls[k][j]
+                        ls[j][i] = 1.0/ls[i][j]
+        output = []
+        for query in queries:
+            if query[0] not in vs or query[1] not in vs:
+                output.append(-1)
+                continue
+            first_ind = index_map[query[0]]
+            second_ind = index_map[query[1]]
+            output.append(ls[first_ind][second_ind])
+        return output
+
+
+
+
+sol = Solution()
+print(sol.calcEquation([["a", "b"], ["b", "c"]], [2.0, 3.0], [["a", "c"], ["b", "a"], ["a", "e"], ["a", "a"], ["x", "x"]]))
+print(sol.calcEquation([["a", "c"], ["b", "e"],["c", "d"], ["e", "d"]], [2.0, 3.0,0.5,5.0], [["a", "b"]]))
+

427-240611-pass/main.py

@@ -0,0 +1,41 @@
+"""
+# Definition for a QuadTree node.
+class Node:
+    def __init__(self, val, isLeaf, topLeft, topRight, bottomLeft, bottomRight):
+        self.val = val
+        self.isLeaf = isLeaf
+        self.topLeft = topLeft
+        self.topRight = topRight
+        self.bottomLeft = bottomLeft
+        self.bottomRight = bottomRight
+"""
+
+class Solution:
+    def construct(self, grid: List[List[int]]) -> 'Node':
+        n = len(grid)
+        def check_is_leaf(row_start,row_end,column_start,column_end):
+            x = grid[row_start][column_start]
+            for i in range(row_start, row_end + 1):
+                for j in range(column_start, column_end + 1):
+                    if grid[i][j] != x:
+                        return 0
+            return 1
+        def dfs(dim, row, column,node):
+            isLeaf = check_is_leaf(row,row+dim -1 , column, column + dim - 1)
+            node.isLeaf= isLeaf
+            if isLeaf==1:
+                node.val=grid[row][column]
+            else:
+                node.val = 1
+                top_left = Node()
+                node.topLeft = dfs(dim // 2, row, column, top_left)
+                top_right = Node()
+                node.topRight = dfs(dim // 2, row, column + dim // 2, top_right)
+                bottom_left = Node()
+                node.bottomLeft = dfs(dim // 2, row + dim // 2, column, bottom_left)
+                bottom_right = Node()
+                node.bottomRight = dfs(dim // 2, row + dim // 2, column + dim // 2, bottom_right)
+            return node
+        root = Node()
+        root = dfs(n,0,0,root)
+        return root

433-240602-pass/main.py

@@ -0,0 +1,38 @@
+class Solution:
+    def minMutation(self, startGene: str, endGene: str, bank: list[str]) -> int:
+        if endGene not in bank: return -1
+        que = []
+        front = -1
+        tail = -1
+        def push_back(que, front, tail, ele):
+            tail += 1
+            if tail >= len(que):
+                que.append(ele)
+            else:
+                que[tail] = ele
+            return tail
+        def pop(que, front ,tail):
+            front += 1
+            return (front , que[front])
+        tail = push_back(que,front,tail,(startGene,0))
+        def diff(str1, str2) -> int:
+            rlt = 0
+            for idx, ch in enumerate(str1):
+                if(str1[idx] != str2[idx]): rlt += 1
+            return rlt
+        rlt = 1e5
+        while front != tail:
+            (front, top_ele) = pop(que, front, tail)            
+            step = top_ele[1]
+            string = top_ele[0]
+            if diff(string, endGene) == 0: return step
+            for s in bank:
+                diff_num = diff(s, string)
+                # print(diff_num)
+                if diff_num == 1:
+                    tail = push_back(que, front, tail, (s, step + 1))
+        return -1
+
+sol = Solution()
+print(sol.minMutation("AACCGGTT","AACCGGTA",["AACCGGTA"]))
+print(sol.minMutation("AACCGGTT","AAACGGTA",["AACCGGTA","AACCGCTA","AAACGGTA"]))

447-240108/mai.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.mai</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

447-240108/mai.dSYM/Contents/Resources/Relocations/aarch64/mai.yml

@@ -0,0 +1,281 @@
+---
+triple:          'arm64-apple-darwin'
+binary-path:     mai
+relocations:
+  - { offsetInCU: 0x54EA, offset: 0x54EA, size: 0x8, addend: 0x0, symName: __ZNSt3__124__put_character_sequenceB7v160006IcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_PKS4_m, symObjAddr: 0x135C, symBinAddr: 0x100003948, symSize: 0x1EC }
+  - { offsetInCU: 0x796D, offset: 0x796D, size: 0x8, addend: 0x0, symName: __ZNSt3__14endlB7v160006IcNS_11char_traitsIcEEEERNS_13basic_ostreamIT_T0_EES7_, symObjAddr: 0xE78, symBinAddr: 0x100003464, symSize: 0x58 }
+  - { offsetInCU: 0x79AD, offset: 0x79AD, size: 0x8, addend: 0x0, symName: __ZNSt3__1neB7v160006IPNS_6vectorIiNS_9allocatorIiEEEEEEbRKNS_11__wrap_iterIT_EESA_, symObjAddr: 0xF84, symBinAddr: 0x100003570, symSize: 0x34 }
+  - { offsetInCU: 0x79F0, offset: 0x79F0, size: 0x8, addend: 0x0, symName: __ZNSt3__1lsB7v160006INS_11char_traitsIcEEEERNS_13basic_ostreamIcT_EES6_c, symObjAddr: 0x11F0, symBinAddr: 0x1000037DC, symSize: 0x34 }
+  - { offsetInCU: 0x7A36, offset: 0x7A36, size: 0x8, addend: 0x0, symName: __ZNSt3__1eqB7v160006IPNS_6vectorIiNS_9allocatorIiEEEEEEbRKNS_11__wrap_iterIT_EESA_, symObjAddr: 0x12FC, symBinAddr: 0x1000038E8, symSize: 0x48 }
+  - { offsetInCU: 0x7A79, offset: 0x7A79, size: 0x8, addend: 0x0, symName: __ZNSt3__116__pad_and_outputB7v160006IcNS_11char_traitsIcEEEENS_19ostreambuf_iteratorIT_T0_EES6_PKS4_S8_S8_RNS_8ios_baseES4_, symObjAddr: 0x1564, symBinAddr: 0x100003B50, symSize: 0x240 }
+  - { offsetInCU: 0x7B48, offset: 0x7B48, size: 0x8, addend: 0x0, symName: __ZNSt3__119__debug_db_insert_cB7v160006INS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEEEEvPT_, symObjAddr: 0x1A24, symBinAddr: 0x100004010, symSize: 0x10 }
+  - { offsetInCU: 0x7B79, offset: 0x7B79, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006IcEEPT_S2_, symObjAddr: 0x1AF0, symBinAddr: 0x1000040DC, symSize: 0x14 }
+  - { offsetInCU: 0x7BE1, offset: 0x7BE1, size: 0x8, addend: 0x0, symName: __ZNSt3__19use_facetB7v160006INS_5ctypeIcEEEERKT_RKNS_6localeE, symObjAddr: 0x1DA8, symBinAddr: 0x100004394, symSize: 0x2C }
+  - { offsetInCU: 0x80B0, offset: 0x80B0, size: 0x8, addend: 0x0, symName: __ZNSt3__122__make_exception_guardB7v160006INS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEEENS_28__exception_guard_exceptionsIT_EES7_, symObjAddr: 0x1FC8, symBinAddr: 0x1000045B4, symSize: 0x40 }
+  - { offsetInCU: 0x80E5, offset: 0x80E5, size: 0x8, addend: 0x0, symName: __ZNSt3__119__debug_db_insert_cB7v160006INS_6vectorIiNS_9allocatorIiEEEEEEvPT_, symObjAddr: 0x203C, symBinAddr: 0x100004628, symSize: 0x10 }
+  - { offsetInCU: 0x8116, offset: 0x8116, size: 0x8, addend: 0x0, symName: __ZNSt3__119__allocate_at_leastB7v160006INS_9allocatorIiEEEENS_19__allocation_resultINS_16allocator_traitsIT_E7pointerEEERS5_m, symObjAddr: 0x2398, symBinAddr: 0x100004984, symSize: 0x40 }
+  - { offsetInCU: 0x8159, offset: 0x8159, size: 0x8, addend: 0x0, symName: __ZNSt3__13minB7v160006ImEERKT_S3_S3_, symObjAddr: 0x24D4, symBinAddr: 0x100004AC0, symSize: 0x2C }
+  - { offsetInCU: 0x8386, offset: 0x8386, size: 0x8, addend: 0x0, symName: __ZNSt3__13minB7v160006ImNS_6__lessImmEEEERKT_S5_S5_T0_, symObjAddr: 0x2538, symBinAddr: 0x100004B24, symSize: 0x54 }
+  - { offsetInCU: 0x841B, offset: 0x841B, size: 0x8, addend: 0x0, symName: __ZNSt3__120__throw_length_errorB7v160006EPKc, symObjAddr: 0x25DC, symBinAddr: 0x100004BC8, symSize: 0x64 }
+  - { offsetInCU: 0x8443, offset: 0x8443, size: 0x8, addend: 0x0, symName: __ZNSt3__117__libcpp_allocateB7v160006Emm, symObjAddr: 0x274C, symBinAddr: 0x100004D38, symSize: 0x60 }
+  - { offsetInCU: 0x849D, offset: 0x849D, size: 0x8, addend: 0x0, symName: __ZNSt3__124__is_overaligned_for_newB7v160006Em, symObjAddr: 0x27AC, symBinAddr: 0x100004D98, symSize: 0x20 }
+  - { offsetInCU: 0x84CB, offset: 0x84CB, size: 0x8, addend: 0x0, symName: __ZNSt3__121__libcpp_operator_newB7v160006IJmSt11align_val_tEEEPvDpT_, symObjAddr: 0x27CC, symBinAddr: 0x100004DB8, symSize: 0x2C }
+  - { offsetInCU: 0x8518, offset: 0x8518, size: 0x8, addend: 0x0, symName: __ZNSt3__121__libcpp_operator_newB7v160006IJmEEEPvDpT_, symObjAddr: 0x27F8, symBinAddr: 0x100004DE4, symSize: 0x24 }
+  - { offsetInCU: 0x8551, offset: 0x8551, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006IiEEPT_S2_, symObjAddr: 0x2914, symBinAddr: 0x100004F00, symSize: 0x14 }
+  - { offsetInCU: 0x8586, offset: 0x8586, size: 0x8, addend: 0x0, symName: __ZNSt3__130__uninitialized_allocator_copyB7v160006INS_9allocatorIiEEPiS3_S3_EET2_RT_T0_T1_S4_, symObjAddr: 0x29C4, symBinAddr: 0x100004FB0, symSize: 0xF4 }
+  - { offsetInCU: 0x8624, offset: 0x8624, size: 0x8, addend: 0x0, symName: __ZNSt3__122__make_exception_guardB7v160006INS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEEENS_28__exception_guard_exceptionsIT_EES7_, symObjAddr: 0x2B28, symBinAddr: 0x100005114, symSize: 0x4C }
+  - { offsetInCU: 0x865A, offset: 0x865A, size: 0x8, addend: 0x0, symName: __ZNSt3__119__allocator_destroyB7v160006INS_9allocatorIiEENS_16reverse_iteratorIPiEES5_EEvRT_T0_T1_, symObjAddr: 0x2DB0, symBinAddr: 0x10000539C, symSize: 0x70 }
+  - { offsetInCU: 0x86BD, offset: 0x86BD, size: 0x8, addend: 0x0, symName: __ZNSt3__1neB7v160006IPiS1_EEbRKNS_16reverse_iteratorIT_EERKNS2_IT0_EE, symObjAddr: 0x2E54, symBinAddr: 0x100005440, symSize: 0x48 }
+  - { offsetInCU: 0x8709, offset: 0x8709, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006INS_16reverse_iteratorIPiEEvEENS_5decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS5_EEEEE4typeES7_, symObjAddr: 0x2EC8, symBinAddr: 0x1000054B4, symSize: 0x24 }
+  - { offsetInCU: 0x8768, offset: 0x8768, size: 0x8, addend: 0x0, symName: __ZNSt3__118__debug_db_erase_cB7v160006INS_6vectorIiNS_9allocatorIiEEEEEEvPT_, symObjAddr: 0x31A8, symBinAddr: 0x100005794, symSize: 0x10 }
+  - { offsetInCU: 0x8799, offset: 0x8799, size: 0x8, addend: 0x0, symName: __ZNSt3__119__libcpp_deallocateB7v160006EPvmm, symObjAddr: 0x32E0, symBinAddr: 0x1000058CC, symSize: 0x60 }
+  - { offsetInCU: 0x87FE, offset: 0x87FE, size: 0x8, addend: 0x0, symName: __ZNSt3__127__do_deallocate_handle_sizeB7v160006IJSt11align_val_tEEEvPvmDpT_, symObjAddr: 0x3340, symBinAddr: 0x10000592C, symSize: 0x30 }
+  - { offsetInCU: 0x8851, offset: 0x8851, size: 0x8, addend: 0x0, symName: __ZNSt3__127__do_deallocate_handle_sizeB7v160006IJEEEvPvmDpT_, symObjAddr: 0x3370, symBinAddr: 0x10000595C, symSize: 0x28 }
+  - { offsetInCU: 0x888F, offset: 0x888F, size: 0x8, addend: 0x0, symName: __ZNSt3__124__libcpp_operator_deleteB7v160006IJPvSt11align_val_tEEEvDpT_, symObjAddr: 0x3398, symBinAddr: 0x100005984, symSize: 0x2C }
+  - { offsetInCU: 0x88D8, offset: 0x88D8, size: 0x8, addend: 0x0, symName: __ZNSt3__124__libcpp_operator_deleteB7v160006IJPvEEEvDpT_, symObjAddr: 0x33C4, symBinAddr: 0x1000059B0, symSize: 0x24 }
+  - { offsetInCU: 0x890D, offset: 0x890D, size: 0x8, addend: 0x0, symName: __ZNSt3__130__uninitialized_allocator_copyB7v160006INS_9allocatorIiEEiiLPv0EEEPT0_RT_PKS4_S9_S5_, symObjAddr: 0x3718, symBinAddr: 0x100005D04, symSize: 0x38 }
+  - { offsetInCU: 0x8985, offset: 0x8985, size: 0x8, addend: 0x0, symName: __ZNSt3__14copyB7v160006IPKiPiEET0_T_S5_S4_, symObjAddr: 0x3750, symBinAddr: 0x100005D3C, symSize: 0x40 }
+  - { offsetInCU: 0x89DF, offset: 0x89DF, size: 0x8, addend: 0x0, symName: __ZNSt3__16__copyB7v160006INS_17_ClassicAlgPolicyEPKiS3_PiEENS_4pairIT0_T2_EES6_T1_S7_, symObjAddr: 0x3790, symBinAddr: 0x100005D7C, symSize: 0x44 }
+  - { offsetInCU: 0x8A4B, offset: 0x8A4B, size: 0x8, addend: 0x0, symName: __ZNSt3__123__dispatch_copy_or_moveB7v160006INS_17_ClassicAlgPolicyENS_11__copy_loopIS1_EENS_14__copy_trivialEPKiS6_PiEENS_4pairIT2_T4_EES9_T3_SA_, symObjAddr: 0x37D4, symBinAddr: 0x100005DC0, symSize: 0x44 }
+  - { offsetInCU: 0x8AC9, offset: 0x8AC9, size: 0x8, addend: 0x0, symName: __ZNSt3__121__unwrap_and_dispatchB7v160006INS_10__overloadINS_11__copy_loopINS_17_ClassicAlgPolicyEEENS_14__copy_trivialEEEPKiS8_PiLi0EEENS_4pairIT0_T2_EESB_T1_SC_, symObjAddr: 0x3818, symBinAddr: 0x100005E04, symSize: 0xB4 }
+  - { offsetInCU: 0x8B57, offset: 0x8B57, size: 0x8, addend: 0x0, symName: __ZNSt3__114__unwrap_rangeB7v160006IPKiS2_EENS_4pairIT0_S4_EET_S6_, symObjAddr: 0x38CC, symBinAddr: 0x100005EB8, symSize: 0x60 }
+  - { offsetInCU: 0x8CEC, offset: 0x8CEC, size: 0x8, addend: 0x0, symName: __ZNSt3__113__unwrap_iterB7v160006IPiNS_18__unwrap_iter_implIS1_Lb1EEELi0EEEDTclsrT0_8__unwrapclsr3stdE7declvalIT_EEEES5_, symObjAddr: 0x3974, symBinAddr: 0x100005F60, symSize: 0x24 }
+  - { offsetInCU: 0x8D30, offset: 0x8D30, size: 0x8, addend: 0x0, symName: __ZNSt3__19make_pairB7v160006IPKiPiEENS_4pairINS_18__unwrap_ref_decayIT_E4typeENS5_IT0_E4typeEEEOS6_OS9_, symObjAddr: 0x3998, symBinAddr: 0x100005F84, symSize: 0x38 }
+  - { offsetInCU: 0x8D7F, offset: 0x8D7F, size: 0x8, addend: 0x0, symName: __ZNSt3__114__rewrap_rangeB7v160006IPKiS2_EET_S3_T0_, symObjAddr: 0x39D0, symBinAddr: 0x100005FBC, symSize: 0x2C }
+  - { offsetInCU: 0x8DCB, offset: 0x8DCB, size: 0x8, addend: 0x0, symName: __ZNSt3__113__rewrap_iterB7v160006IPiS1_NS_18__unwrap_iter_implIS1_Lb1EEEEET_S4_T0_, symObjAddr: 0x39FC, symBinAddr: 0x100005FE8, symSize: 0x3C }
+  - { offsetInCU: 0x8E20, offset: 0x8E20, size: 0x8, addend: 0x0, symName: __ZNSt3__19make_pairB7v160006IPKiS2_EENS_4pairINS_18__unwrap_ref_decayIT_E4typeENS4_IT0_E4typeEEEOS5_OS8_, symObjAddr: 0x3A38, symBinAddr: 0x100006024, symSize: 0x38 }
+  - { offsetInCU: 0x8E6F, offset: 0x8E6F, size: 0x8, addend: 0x0, symName: __ZNSt3__113__unwrap_iterB7v160006IPKiNS_18__unwrap_iter_implIS2_Lb1EEELi0EEEDTclsrT0_8__unwrapclsr3stdE7declvalIT_EEEES6_, symObjAddr: 0x3A70, symBinAddr: 0x10000605C, symSize: 0x24 }
+  - { offsetInCU: 0x8FDA, offset: 0x8FDA, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006IKiEEPT_S3_, symObjAddr: 0x3B28, symBinAddr: 0x100006114, symSize: 0x14 }
+  - { offsetInCU: 0x900F, offset: 0x900F, size: 0x8, addend: 0x0, symName: __ZNSt3__119__copy_trivial_implB7v160006IKiiEENS_4pairIPT_PT0_EES4_S4_S6_, symObjAddr: 0x3B3C, symBinAddr: 0x100006128, symSize: 0x84 }
+  - { offsetInCU: 0x9077, offset: 0x9077, size: 0x8, addend: 0x0, symName: __ZNSt3__19make_pairB7v160006IRPKiPiEENS_4pairINS_18__unwrap_ref_decayIT_E4typeENS6_IT0_E4typeEEEOS7_OSA_, symObjAddr: 0x3BC0, symBinAddr: 0x1000061AC, symSize: 0x38 }
+  - { offsetInCU: 0x9119, offset: 0x9119, size: 0x8, addend: 0x0, symName: __ZNSt3__113__rewrap_iterB7v160006IPKiS2_NS_18__unwrap_iter_implIS2_Lb1EEEEET_S5_T0_, symObjAddr: 0x3CFC, symBinAddr: 0x1000062E8, symSize: 0x3C }
+  - { offsetInCU: 0x916E, offset: 0x916E, size: 0x8, addend: 0x0, symName: __ZNSt3__122__make_exception_guardB7v160006INS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEEENS_28__exception_guard_exceptionsIT_EES9_, symObjAddr: 0x3F38, symBinAddr: 0x100006524, symSize: 0x40 }
+  - { offsetInCU: 0x91A3, offset: 0x91A3, size: 0x8, addend: 0x0, symName: __ZNSt3__119__debug_db_insert_cB7v160006INS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEEEEEvPT_, symObjAddr: 0x3FAC, symBinAddr: 0x100006598, symSize: 0x10 }
+  - { offsetInCU: 0x91D4, offset: 0x91D4, size: 0x8, addend: 0x0, symName: __ZNSt3__119__allocate_at_leastB7v160006INS_9allocatorINS_6vectorIiNS1_IiEEEEEEEENS_19__allocation_resultINS_16allocator_traitsIT_E7pointerEEERS8_m, symObjAddr: 0x4358, symBinAddr: 0x100006944, symSize: 0x40 }
+  - { offsetInCU: 0x9217, offset: 0x9217, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006INS_6vectorIiNS_9allocatorIiEEEEEEPT_S6_, symObjAddr: 0x46A0, symBinAddr: 0x100006C8C, symSize: 0x14 }
+  - { offsetInCU: 0x924C, offset: 0x924C, size: 0x8, addend: 0x0, symName: __ZNSt3__130__uninitialized_allocator_copyB7v160006INS_9allocatorINS_6vectorIiNS1_IiEEEEEEPKS4_S7_PS4_EET2_RT_T0_T1_S9_, symObjAddr: 0x4750, symBinAddr: 0x100006D3C, symSize: 0xF4 }
+  - { offsetInCU: 0x92EA, offset: 0x92EA, size: 0x8, addend: 0x0, symName: __ZNSt3__122__make_exception_guardB7v160006INS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEEENS_28__exception_guard_exceptionsIT_EESA_, symObjAddr: 0x48BC, symBinAddr: 0x100006EA8, symSize: 0x4C }
+  - { offsetInCU: 0x9320, offset: 0x9320, size: 0x8, addend: 0x0, symName: __ZNSt3__119__allocator_destroyB7v160006INS_9allocatorINS_6vectorIiNS1_IiEEEEEENS_16reverse_iteratorIPS4_EES8_EEvRT_T0_T1_, symObjAddr: 0x4B4C, symBinAddr: 0x100007138, symSize: 0x70 }
+  - { offsetInCU: 0x9383, offset: 0x9383, size: 0x8, addend: 0x0, symName: __ZNSt3__1neB7v160006IPNS_6vectorIiNS_9allocatorIiEEEES5_EEbRKNS_16reverse_iteratorIT_EERKNS6_IT0_EE, symObjAddr: 0x4BF0, symBinAddr: 0x1000071DC, symSize: 0x48 }
+  - { offsetInCU: 0x93CF, offset: 0x93CF, size: 0x8, addend: 0x0, symName: __ZNSt3__112__to_addressB7v160006INS_16reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEEvEENS_5decayIDTclsr19__to_address_helperIT_EE6__callclsr3stdE7declvalIRKS9_EEEEE4typeESB_, symObjAddr: 0x4C64, symBinAddr: 0x100007250, symSize: 0x24 }
+  - { offsetInCU: 0x942E, offset: 0x942E, size: 0x8, addend: 0x0, symName: __ZNSt3__118__debug_db_erase_cB7v160006INS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEEEEEvPT_, symObjAddr: 0x4F74, symBinAddr: 0x100007560, symSize: 0x10 }
+  - { offsetInCU: 0x9836, offset: 0x9836, size: 0x8, addend: 0x0, symName: __ZSt28__throw_bad_array_new_lengthB7v160006v, symObjAddr: 0x2718, symBinAddr: 0x100004D04, symSize: 0x34 }
+  - { offsetInCU: 0xC232, offset: 0xC232, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0x0, symBinAddr: 0x1000025EC, symSize: 0x690 }
+  - { offsetInCU: 0xC2F2, offset: 0xC2F2, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEEC1B7v160006ESt16initializer_listIiE, symObjAddr: 0x690, symBinAddr: 0x100002C7C, symSize: 0x3C }
+  - { offsetInCU: 0xC32D, offset: 0xC32D, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEEC1ERKS3_, symObjAddr: 0x6CC, symBinAddr: 0x100002CB8, symSize: 0x34 }
+  - { offsetInCU: 0xC368, offset: 0xC368, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEED1B7v160006Ev, symObjAddr: 0x700, symBinAddr: 0x100002CEC, symSize: 0x2C }
+  - { offsetInCU: 0xC392, offset: 0xC392, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEEC1B7v160006ESt16initializer_listIS3_E, symObjAddr: 0x72C, symBinAddr: 0x100002D18, symSize: 0x3C }
+  - { offsetInCU: 0xC435, offset: 0xC435, size: 0x8, addend: 0x0, symName: __ZN8Solution18numberOfBoomerangsERNSt3__16vectorINS1_IiNS0_9allocatorIiEEEENS2_IS4_EEEE, symObjAddr: 0x768, symBinAddr: 0x100002D54, symSize: 0x6E4 }
+  - { offsetInCU: 0xC579, offset: 0xC579, size: 0x8, addend: 0x0, symName: __ZNSt3__113basic_ostreamIcNS_11char_traitsIcEEElsB7v160006EPFRS3_S4_E, symObjAddr: 0xE4C, symBinAddr: 0x100003438, symSize: 0x2C }
+  - { offsetInCU: 0xC5AD, offset: 0xC5AD, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEED1B7v160006Ev, symObjAddr: 0xED0, symBinAddr: 0x1000034BC, symSize: 0x2C }
+  - { offsetInCU: 0xC5D7, offset: 0xC5D7, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE4sizeB7v160006Ev, symObjAddr: 0xEFC, symBinAddr: 0x1000034E8, symSize: 0x28 }
+  - { offsetInCU: 0xC5FD, offset: 0xC5FD, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE5beginB7v160006Ev, symObjAddr: 0xF24, symBinAddr: 0x100003510, symSize: 0x30 }
+  - { offsetInCU: 0xC625, offset: 0xC625, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE3endB7v160006Ev, symObjAddr: 0xF54, symBinAddr: 0x100003540, symSize: 0x30 }
+  - { offsetInCU: 0xC64D, offset: 0xC64D, size: 0x8, addend: 0x0, symName: __ZNKSt3__111__wrap_iterIPNS_6vectorIiNS_9allocatorIiEEEEEdeB7v160006Ev, symObjAddr: 0xFB8, symBinAddr: 0x1000035A4, symSize: 0x18 }
+  - { offsetInCU: 0xC673, offset: 0xC673, size: 0x8, addend: 0x0, symName: __ZN8Solution9samePointENSt3__16vectorIiNS0_9allocatorIiEEEES4_, symObjAddr: 0xFD0, symBinAddr: 0x1000035BC, symSize: 0xE4 }
+  - { offsetInCU: 0xC6B7, offset: 0xC6B7, size: 0x8, addend: 0x0, symName: __ZN8Solution8distanceENSt3__16vectorIiNS0_9allocatorIiEEEES4_, symObjAddr: 0x10B4, symBinAddr: 0x1000036A0, symSize: 0x13C }
+  - { offsetInCU: 0xC709, offset: 0xC709, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEEixB7v160006Em, symObjAddr: 0x1224, symBinAddr: 0x100003810, symSize: 0x24 }
+  - { offsetInCU: 0xC740, offset: 0xC740, size: 0x8, addend: 0x0, symName: __ZNSt3__111__wrap_iterIPNS_6vectorIiNS_9allocatorIiEEEEEppB7v160006Ev, symObjAddr: 0x1248, symBinAddr: 0x100003834, symSize: 0x20 }
+  - { offsetInCU: 0xC766, offset: 0xC766, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE11__make_iterB7v160006EPS3_, symObjAddr: 0x1268, symBinAddr: 0x100003854, symSize: 0x34 }
+  - { offsetInCU: 0xC79B, offset: 0xC79B, size: 0x8, addend: 0x0, symName: __ZNSt3__111__wrap_iterIPNS_6vectorIiNS_9allocatorIiEEEEEC1B7v160006EPKvS5_, symObjAddr: 0x129C, symBinAddr: 0x100003888, symSize: 0x3C }
+  - { offsetInCU: 0xC7E1, offset: 0xC7E1, size: 0x8, addend: 0x0, symName: __ZNSt3__111__wrap_iterIPNS_6vectorIiNS_9allocatorIiEEEEEC2B7v160006EPKvS5_, symObjAddr: 0x12D8, symBinAddr: 0x1000038C4, symSize: 0x24 }
+  - { offsetInCU: 0xC827, offset: 0xC827, size: 0x8, addend: 0x0, symName: __ZNKSt3__111__wrap_iterIPNS_6vectorIiNS_9allocatorIiEEEEE4baseB7v160006Ev, symObjAddr: 0x1344, symBinAddr: 0x100003930, symSize: 0x18 }
+  - { offsetInCU: 0xC86B, offset: 0xC86B, size: 0x8, addend: 0x0, symName: __ZNKSt3__113basic_ostreamIcNS_11char_traitsIcEEE6sentrycvbB7v160006Ev, symObjAddr: 0x1548, symBinAddr: 0x100003B34, symSize: 0x1C }
+  - { offsetInCU: 0xC891, offset: 0xC891, size: 0x8, addend: 0x0, symName: __ZNSt3__119ostreambuf_iteratorIcNS_11char_traitsIcEEEC1B7v160006ERNS_13basic_ostreamIcS2_EE, symObjAddr: 0x17A4, symBinAddr: 0x100003D90, symSize: 0x34 }
+  - { offsetInCU: 0xC8C9, offset: 0xC8C9, size: 0x8, addend: 0x0, symName: __ZNKSt3__18ios_base5flagsB7v160006Ev, symObjAddr: 0x17D8, symBinAddr: 0x100003DC4, symSize: 0x18 }
+  - { offsetInCU: 0xC8F1, offset: 0xC8F1, size: 0x8, addend: 0x0, symName: __ZNKSt3__19basic_iosIcNS_11char_traitsIcEEE4fillB7v160006Ev, symObjAddr: 0x17F0, symBinAddr: 0x100003DDC, symSize: 0x64 }
+  - { offsetInCU: 0xC919, offset: 0xC919, size: 0x8, addend: 0x0, symName: __ZNKSt3__119ostreambuf_iteratorIcNS_11char_traitsIcEEE6failedB7v160006Ev, symObjAddr: 0x1854, symBinAddr: 0x100003E40, symSize: 0x24 }
+  - { offsetInCU: 0xC93F, offset: 0xC93F, size: 0x8, addend: 0x0, symName: __ZNSt3__19basic_iosIcNS_11char_traitsIcEEE8setstateB7v160006Ej, symObjAddr: 0x1878, symBinAddr: 0x100003E64, symSize: 0x2C }
+  - { offsetInCU: 0xC974, offset: 0xC974, size: 0x8, addend: 0x0, symName: __ZNKSt3__18ios_base5widthB7v160006Ev, symObjAddr: 0x18B0, symBinAddr: 0x100003E9C, symSize: 0x18 }
+  - { offsetInCU: 0xC99C, offset: 0xC99C, size: 0x8, addend: 0x0, symName: __ZNSt3__115basic_streambufIcNS_11char_traitsIcEEE5sputnB7v160006EPKcl, symObjAddr: 0x18C8, symBinAddr: 0x100003EB4, symSize: 0x3C }
+  - { offsetInCU: 0xC9DE, offset: 0xC9DE, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC1B7v160006Emc, symObjAddr: 0x1904, symBinAddr: 0x100003EF0, symSize: 0x3C }
+  - { offsetInCU: 0xCA26, offset: 0xCA26, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE4dataB7v160006Ev, symObjAddr: 0x1940, symBinAddr: 0x100003F2C, symSize: 0x28 }
+  - { offsetInCU: 0xCA4C, offset: 0xCA4C, size: 0x8, addend: 0x0, symName: __ZNSt3__18ios_base5widthB7v160006El, symObjAddr: 0x1968, symBinAddr: 0x100003F54, symSize: 0x2C }
+  - { offsetInCU: 0xCA92, offset: 0xCA92, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEC2B7v160006Emc, symObjAddr: 0x1994, symBinAddr: 0x100003F80, symSize: 0x54 }
+  - { offsetInCU: 0xCADF, offset: 0xCADF, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repES5_EC1B7v160006INS_18__default_init_tagESA_EEOT_OT0_, symObjAddr: 0x19E8, symBinAddr: 0x100003FD4, symSize: 0x3C }
+  - { offsetInCU: 0xCB37, offset: 0xCB37, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repES5_EC2B7v160006INS_18__default_init_tagESA_EEOT_OT0_, symObjAddr: 0x1A34, symBinAddr: 0x100004020, symSize: 0x3C }
+  - { offsetInCU: 0xCB8F, offset: 0xCB8F, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repELi0ELb0EEC2B7v160006ENS_18__default_init_tagE, symObjAddr: 0x1A70, symBinAddr: 0x10000405C, symSize: 0x14 }
+  - { offsetInCU: 0xCBC4, offset: 0xCBC4, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorIcEELi1ELb1EEC2B7v160006ENS_18__default_init_tagE, symObjAddr: 0x1A84, symBinAddr: 0x100004070, symSize: 0x2C }
+  - { offsetInCU: 0xCBF9, offset: 0xCBF9, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIcEC2B7v160006Ev, symObjAddr: 0x1AB0, symBinAddr: 0x10000409C, symSize: 0x2C }
+  - { offsetInCU: 0xCC23, offset: 0xCC23, size: 0x8, addend: 0x0, symName: __ZNSt3__116__non_trivial_ifILb1ENS_9allocatorIcEEEC2B7v160006Ev, symObjAddr: 0x1ADC, symBinAddr: 0x1000040C8, symSize: 0x14 }
+  - { offsetInCU: 0xCC4D, offset: 0xCC4D, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE13__get_pointerB7v160006Ev, symObjAddr: 0x1B04, symBinAddr: 0x1000040F0, symSize: 0x54 }
+  - { offsetInCU: 0xCC73, offset: 0xCC73, size: 0x8, addend: 0x0, symName: __ZNKSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE9__is_longB7v160006Ev, symObjAddr: 0x1B58, symBinAddr: 0x100004144, symSize: 0x38 }
+  - { offsetInCU: 0xCC99, offset: 0xCC99, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE18__get_long_pointerB7v160006Ev, symObjAddr: 0x1B90, symBinAddr: 0x10000417C, symSize: 0x28 }
+  - { offsetInCU: 0xCCBF, offset: 0xCCBF, size: 0x8, addend: 0x0, symName: __ZNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE19__get_short_pointerB7v160006Ev, symObjAddr: 0x1BB8, symBinAddr: 0x1000041A4, symSize: 0x28 }
+  - { offsetInCU: 0xCCE5, offset: 0xCCE5, size: 0x8, addend: 0x0, symName: __ZNKSt3__117__compressed_pairINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repES5_E5firstB7v160006Ev, symObjAddr: 0x1BE0, symBinAddr: 0x1000041CC, symSize: 0x24 }
+  - { offsetInCU: 0xCD0B, offset: 0xCD0B, size: 0x8, addend: 0x0, symName: __ZNKSt3__122__compressed_pair_elemINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repELi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x1C04, symBinAddr: 0x1000041F0, symSize: 0x14 }
+  - { offsetInCU: 0xCD31, offset: 0xCD31, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repES5_E5firstB7v160006Ev, symObjAddr: 0x1C18, symBinAddr: 0x100004204, symSize: 0x24 }
+  - { offsetInCU: 0xCD57, offset: 0xCD57, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_12basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEE5__repELi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x1C3C, symBinAddr: 0x100004228, symSize: 0x14 }
+  - { offsetInCU: 0xCD7D, offset: 0xCD7D, size: 0x8, addend: 0x0, symName: __ZNSt3__114pointer_traitsIPcE10pointer_toB7v160006ERc, symObjAddr: 0x1C50, symBinAddr: 0x10000423C, symSize: 0x14 }
+  - { offsetInCU: 0xCDA0, offset: 0xCDA0, size: 0x8, addend: 0x0, symName: __ZNSt3__119ostreambuf_iteratorIcNS_11char_traitsIcEEEC2B7v160006ERNS_13basic_ostreamIcS2_EE, symObjAddr: 0x1C64, symBinAddr: 0x100004250, symSize: 0x54 }
+  - { offsetInCU: 0xCDD8, offset: 0xCDD8, size: 0x8, addend: 0x0, symName: __ZNKSt3__19basic_iosIcNS_11char_traitsIcEEE5rdbufB7v160006Ev, symObjAddr: 0x1CB8, symBinAddr: 0x1000042A4, symSize: 0x24 }
+  - { offsetInCU: 0xCE00, offset: 0xCE00, size: 0x8, addend: 0x0, symName: __ZNKSt3__18ios_base5rdbufB7v160006Ev, symObjAddr: 0x1CDC, symBinAddr: 0x1000042C8, symSize: 0x18 }
+  - { offsetInCU: 0xCE26, offset: 0xCE26, size: 0x8, addend: 0x0, symName: __ZNSt3__111char_traitsIcE11eq_int_typeEii, symObjAddr: 0x1CF4, symBinAddr: 0x1000042E0, symSize: 0x28 }
+  - { offsetInCU: 0xCE57, offset: 0xCE57, size: 0x8, addend: 0x0, symName: __ZNSt3__111char_traitsIcE3eofEv, symObjAddr: 0x1D1C, symBinAddr: 0x100004308, symSize: 0x8 }
+  - { offsetInCU: 0xCE6B, offset: 0xCE6B, size: 0x8, addend: 0x0, symName: __ZNKSt3__19basic_iosIcNS_11char_traitsIcEEE5widenB7v160006Ec, symObjAddr: 0x1D24, symBinAddr: 0x100004310, symSize: 0x84 }
+  - { offsetInCU: 0xCED9, offset: 0xCED9, size: 0x8, addend: 0x0, symName: __ZNKSt3__15ctypeIcE5widenB7v160006Ec, symObjAddr: 0x1DD4, symBinAddr: 0x1000043C0, symSize: 0x38 }
+  - { offsetInCU: 0xCF0E, offset: 0xCF0E, size: 0x8, addend: 0x0, symName: __ZNSt3__18ios_base8setstateB7v160006Ej, symObjAddr: 0x1E0C, symBinAddr: 0x1000043F8, symSize: 0x34 }
+  - { offsetInCU: 0xCF45, offset: 0xCF45, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEEC2ERKS3_, symObjAddr: 0x1E40, symBinAddr: 0x10000442C, symSize: 0x114 }
+  - { offsetInCU: 0xCFAE, offset: 0xCFAE, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorIiEEE37select_on_container_copy_constructionB7v160006IS2_vvEES2_RKS2_, symObjAddr: 0x1F54, symBinAddr: 0x100004540, symSize: 0x10 }
+  - { offsetInCU: 0xCFDD, offset: 0xCFDD, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE7__allocB7v160006Ev, symObjAddr: 0x1F64, symBinAddr: 0x100004550, symSize: 0x28 }
+  - { offsetInCU: 0xD00D, offset: 0xD00D, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEEC1B7v160006IDnS3_EEOT_OT0_, symObjAddr: 0x1F8C, symBinAddr: 0x100004578, symSize: 0x3C }
+  - { offsetInCU: 0xD065, offset: 0xD065, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE16__destroy_vectorC1ERS3_, symObjAddr: 0x2008, symBinAddr: 0x1000045F4, symSize: 0x34 }
+  - { offsetInCU: 0xD09E, offset: 0xD09E, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE4sizeB7v160006Ev, symObjAddr: 0x204C, symBinAddr: 0x100004638, symSize: 0x28 }
+  - { offsetInCU: 0xD0C4, offset: 0xD0C4, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE11__vallocateB7v160006Em, symObjAddr: 0x2074, symBinAddr: 0x100004660, symSize: 0xAC }
+  - { offsetInCU: 0xD108, offset: 0xD108, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE18__construct_at_endIPiLi0EEEvT_S6_m, symObjAddr: 0x2120, symBinAddr: 0x10000470C, symSize: 0x8C }
+  - { offsetInCU: 0xD17B, offset: 0xD17B, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEE10__completeB7v160006Ev, symObjAddr: 0x21AC, symBinAddr: 0x100004798, symSize: 0x1C }
+  - { offsetInCU: 0xD1A1, offset: 0xD1A1, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEED1B7v160006Ev, symObjAddr: 0x21C8, symBinAddr: 0x1000047B4, symSize: 0x2C }
+  - { offsetInCU: 0xD1CB, offset: 0xD1CB, size: 0x8, addend: 0x0, symName: __ZNKSt3__117__compressed_pairIPiNS_9allocatorIiEEE6secondB7v160006Ev, symObjAddr: 0x21F4, symBinAddr: 0x1000047E0, symSize: 0x24 }
+  - { offsetInCU: 0xD1F1, offset: 0xD1F1, size: 0x8, addend: 0x0, symName: __ZNKSt3__122__compressed_pair_elemINS_9allocatorIiEELi1ELb1EE5__getB7v160006Ev, symObjAddr: 0x2218, symBinAddr: 0x100004804, symSize: 0x14 }
+  - { offsetInCU: 0xD217, offset: 0xD217, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEEC2B7v160006IDnS3_EEOT_OT0_, symObjAddr: 0x222C, symBinAddr: 0x100004818, symSize: 0x44 }
+  - { offsetInCU: 0xD26F, offset: 0xD26F, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemIPiLi0ELb0EEC2B7v160006IDnvEEOT_, symObjAddr: 0x2270, symBinAddr: 0x10000485C, symSize: 0x1C }
+  - { offsetInCU: 0xD2B1, offset: 0xD2B1, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorIiEELi1ELb1EEC2B7v160006IS2_vEEOT_, symObjAddr: 0x228C, symBinAddr: 0x100004878, symSize: 0x18 }
+  - { offsetInCU: 0xD2F3, offset: 0xD2F3, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEEC1B7v160006ES5_, symObjAddr: 0x22A4, symBinAddr: 0x100004890, symSize: 0x34 }
+  - { offsetInCU: 0xD32B, offset: 0xD32B, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEEC2B7v160006ES5_, symObjAddr: 0x22D8, symBinAddr: 0x1000048C4, symSize: 0x24 }
+  - { offsetInCU: 0xD363, offset: 0xD363, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE16__destroy_vectorC2ERS3_, symObjAddr: 0x22FC, symBinAddr: 0x1000048E8, symSize: 0x20 }
+  - { offsetInCU: 0xD39C, offset: 0xD39C, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE8max_sizeEv, symObjAddr: 0x231C, symBinAddr: 0x100004908, symSize: 0x60 }
+  - { offsetInCU: 0xD3C4, offset: 0xD3C4, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE20__throw_length_errorB7v160006Ev, symObjAddr: 0x237C, symBinAddr: 0x100004968, symSize: 0x1C }
+  - { offsetInCU: 0xD3EA, offset: 0xD3EA, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE7__allocB7v160006Ev, symObjAddr: 0x23D8, symBinAddr: 0x1000049C4, symSize: 0x28 }
+  - { offsetInCU: 0xD410, offset: 0xD410, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE9__end_capB7v160006Ev, symObjAddr: 0x2400, symBinAddr: 0x1000049EC, symSize: 0x28 }
+  - { offsetInCU: 0xD436, offset: 0xD436, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE14__annotate_newB7v160006Em, symObjAddr: 0x2428, symBinAddr: 0x100004A14, symSize: 0xAC }
+  - { offsetInCU: 0xD46B, offset: 0xD46B, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorIiEEE8max_sizeB7v160006IS2_vEEmRKS2_, symObjAddr: 0x2500, symBinAddr: 0x100004AEC, symSize: 0x24 }
+  - { offsetInCU: 0xD499, offset: 0xD499, size: 0x8, addend: 0x0, symName: __ZNSt3__114numeric_limitsIlE3maxB7v160006Ev, symObjAddr: 0x2524, symBinAddr: 0x100004B10, symSize: 0x14 }
+  - { offsetInCU: 0xD4C1, offset: 0xD4C1, size: 0x8, addend: 0x0, symName: __ZNKSt3__16__lessImmEclB7v160006ERKmS3_, symObjAddr: 0x258C, symBinAddr: 0x100004B78, symSize: 0x34 }
+  - { offsetInCU: 0xD503, offset: 0xD503, size: 0x8, addend: 0x0, symName: __ZNKSt3__19allocatorIiE8max_sizeB7v160006Ev, symObjAddr: 0x25C0, symBinAddr: 0x100004BAC, symSize: 0x14 }
+  - { offsetInCU: 0xD529, offset: 0xD529, size: 0x8, addend: 0x0, symName: __ZNSt3__123__libcpp_numeric_limitsIlLb1EE3maxB7v160006Ev, symObjAddr: 0x25D4, symBinAddr: 0x100004BC0, symSize: 0x8 }
+  - { offsetInCU: 0xD53D, offset: 0xD53D, size: 0x8, addend: 0x0, symName: __ZNSt12length_errorC1B7v160006EPKc, symObjAddr: 0x2640, symBinAddr: 0x100004C2C, symSize: 0x34 }
+  - { offsetInCU: 0xD575, offset: 0xD575, size: 0x8, addend: 0x0, symName: __ZNSt12length_errorC2B7v160006EPKc, symObjAddr: 0x2674, symBinAddr: 0x100004C60, symSize: 0x4C }
+  - { offsetInCU: 0xD5AD, offset: 0xD5AD, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIiE8allocateB7v160006Em, symObjAddr: 0x26C0, symBinAddr: 0x100004CAC, symSize: 0x58 }
+  - { offsetInCU: 0xD5E1, offset: 0xD5E1, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEE6secondB7v160006Ev, symObjAddr: 0x281C, symBinAddr: 0x100004E08, symSize: 0x24 }
+  - { offsetInCU: 0xD607, offset: 0xD607, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorIiEELi1ELb1EE5__getB7v160006Ev, symObjAddr: 0x2840, symBinAddr: 0x100004E2C, symSize: 0x14 }
+  - { offsetInCU: 0xD62D, offset: 0xD62D, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEE5firstB7v160006Ev, symObjAddr: 0x2854, symBinAddr: 0x100004E40, symSize: 0x24 }
+  - { offsetInCU: 0xD653, offset: 0xD653, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemIPiLi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x2878, symBinAddr: 0x100004E64, symSize: 0x14 }
+  - { offsetInCU: 0xD679, offset: 0xD679, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE31__annotate_contiguous_containerB7v160006EPKvS5_S5_S5_, symObjAddr: 0x288C, symBinAddr: 0x100004E78, symSize: 0x20 }
+  - { offsetInCU: 0xD6CB, offset: 0xD6CB, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE4dataB7v160006Ev, symObjAddr: 0x28AC, symBinAddr: 0x100004E98, symSize: 0x28 }
+  - { offsetInCU: 0xD6F1, offset: 0xD6F1, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE8capacityB7v160006Ev, symObjAddr: 0x28D4, symBinAddr: 0x100004EC0, symSize: 0x40 }
+  - { offsetInCU: 0xD717, offset: 0xD717, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE9__end_capB7v160006Ev, symObjAddr: 0x2928, symBinAddr: 0x100004F14, symSize: 0x28 }
+  - { offsetInCU: 0xD73D, offset: 0xD73D, size: 0x8, addend: 0x0, symName: __ZNKSt3__117__compressed_pairIPiNS_9allocatorIiEEE5firstB7v160006Ev, symObjAddr: 0x2950, symBinAddr: 0x100004F3C, symSize: 0x24 }
+  - { offsetInCU: 0xD763, offset: 0xD763, size: 0x8, addend: 0x0, symName: __ZNKSt3__122__compressed_pair_elemIPiLi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x2974, symBinAddr: 0x100004F60, symSize: 0x14 }
+  - { offsetInCU: 0xD7A2, offset: 0xD7A2, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE21_ConstructTransactionC1B7v160006ERS3_m, symObjAddr: 0x2988, symBinAddr: 0x100004F74, symSize: 0x3C }
+  - { offsetInCU: 0xD7EA, offset: 0xD7EA, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE21_ConstructTransactionD1B7v160006Ev, symObjAddr: 0x2AB8, symBinAddr: 0x1000050A4, symSize: 0x2C }
+  - { offsetInCU: 0xD814, offset: 0xD814, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE21_ConstructTransactionC2B7v160006ERS3_m, symObjAddr: 0x2AE4, symBinAddr: 0x1000050D0, symSize: 0x44 }
+  - { offsetInCU: 0xD85C, offset: 0xD85C, size: 0x8, addend: 0x0, symName: __ZNSt3__129_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEC1B7v160006ERS2_RS3_S6_, symObjAddr: 0x2B74, symBinAddr: 0x100005160, symSize: 0x44 }
+  - { offsetInCU: 0xD8B3, offset: 0xD8B3, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorIiEEE9constructB7v160006IiJRiEvEEvRS2_PT_DpOT0_, symObjAddr: 0x2BB8, symBinAddr: 0x1000051A4, symSize: 0x34 }
+  - { offsetInCU: 0xD90A, offset: 0xD90A, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEE10__completeB7v160006Ev, symObjAddr: 0x2BEC, symBinAddr: 0x1000051D8, symSize: 0x1C }
+  - { offsetInCU: 0xD930, offset: 0xD930, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEED1B7v160006Ev, symObjAddr: 0x2C08, symBinAddr: 0x1000051F4, symSize: 0x2C }
+  - { offsetInCU: 0xD95A, offset: 0xD95A, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEEC1B7v160006ES5_, symObjAddr: 0x2C34, symBinAddr: 0x100005220, symSize: 0x34 }
+  - { offsetInCU: 0xD993, offset: 0xD993, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEEC2B7v160006ES5_, symObjAddr: 0x2C68, symBinAddr: 0x100005254, symSize: 0x30 }
+  - { offsetInCU: 0xD9CC, offset: 0xD9CC, size: 0x8, addend: 0x0, symName: __ZNSt3__129_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEC2B7v160006ERS2_RS3_S6_, symObjAddr: 0x2C98, symBinAddr: 0x100005284, symSize: 0x38 }
+  - { offsetInCU: 0xDA23, offset: 0xDA23, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIiE9constructB7v160006IiJRiEEEvPT_DpOT0_, symObjAddr: 0x2CD0, symBinAddr: 0x1000052BC, symSize: 0x28 }
+  - { offsetInCU: 0xDA79, offset: 0xDA79, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEEED2B7v160006Ev, symObjAddr: 0x2CF8, symBinAddr: 0x1000052E4, symSize: 0x50 }
+  - { offsetInCU: 0xDAA3, offset: 0xDAA3, size: 0x8, addend: 0x0, symName: __ZNKSt3__129_AllocatorDestroyRangeReverseINS_9allocatorIiEEPiEclB7v160006Ev, symObjAddr: 0x2D48, symBinAddr: 0x100005334, symSize: 0x68 }
+  - { offsetInCU: 0xDAC9, offset: 0xDAC9, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPiEC1B7v160006ES1_, symObjAddr: 0x2E20, symBinAddr: 0x10000540C, symSize: 0x34 }
+  - { offsetInCU: 0xDB01, offset: 0xDB01, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorIiEEE7destroyB7v160006IivEEvRS2_PT_, symObjAddr: 0x2E9C, symBinAddr: 0x100005488, symSize: 0x2C }
+  - { offsetInCU: 0xDB3E, offset: 0xDB3E, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPiEppB7v160006Ev, symObjAddr: 0x2EEC, symBinAddr: 0x1000054D8, symSize: 0x20 }
+  - { offsetInCU: 0xDB64, offset: 0xDB64, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPiE4baseB7v160006Ev, symObjAddr: 0x2F0C, symBinAddr: 0x1000054F8, symSize: 0x18 }
+  - { offsetInCU: 0xDB8A, offset: 0xDB8A, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIiE7destroyB7v160006EPi, symObjAddr: 0x2F24, symBinAddr: 0x100005510, symSize: 0x14 }
+  - { offsetInCU: 0xDBC3, offset: 0xDBC3, size: 0x8, addend: 0x0, symName: __ZNSt3__119__to_address_helperINS_16reverse_iteratorIPiEEvE6__callB7v160006ERKS3_, symObjAddr: 0x2F38, symBinAddr: 0x100005524, symSize: 0x38 }
+  - { offsetInCU: 0xDBE6, offset: 0xDBE6, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPiEptB7v160006Ev, symObjAddr: 0x2F70, symBinAddr: 0x10000555C, symSize: 0x24 }
+  - { offsetInCU: 0xDC0C, offset: 0xDC0C, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPiEdeB7v160006Ev, symObjAddr: 0x2F94, symBinAddr: 0x100005580, symSize: 0x28 }
+  - { offsetInCU: 0xDC40, offset: 0xDC40, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPiEC2B7v160006ES1_, symObjAddr: 0x2FBC, symBinAddr: 0x1000055A8, symSize: 0x28 }
+  - { offsetInCU: 0xDC78, offset: 0xDC78, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE21_ConstructTransactionD2B7v160006Ev, symObjAddr: 0x2FE4, symBinAddr: 0x1000055D0, symSize: 0x20 }
+  - { offsetInCU: 0xDCA2, offset: 0xDCA2, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorIiNS_9allocatorIiEEE16__destroy_vectorEED2B7v160006Ev, symObjAddr: 0x3004, symBinAddr: 0x1000055F0, symSize: 0x50 }
+  - { offsetInCU: 0xDCCC, offset: 0xDCCC, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE16__destroy_vectorclB7v160006Ev, symObjAddr: 0x3054, symBinAddr: 0x100005640, symSize: 0x9C }
+  - { offsetInCU: 0xDCF2, offset: 0xDCF2, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorIiNS_9allocatorIiEEE17__annotate_deleteB7v160006Ev, symObjAddr: 0x30F0, symBinAddr: 0x1000056DC, symSize: 0xB8 }
+  - { offsetInCU: 0xDD18, offset: 0xDD18, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE7__clearB7v160006Ev, symObjAddr: 0x31B8, symBinAddr: 0x1000057A4, symSize: 0x28 }
+  - { offsetInCU: 0xDD3E, offset: 0xDD3E, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorIiEEE10deallocateB7v160006ERS2_Pim, symObjAddr: 0x31E0, symBinAddr: 0x1000057CC, symSize: 0x34 }
+  - { offsetInCU: 0xDD80, offset: 0xDD80, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE22__base_destruct_at_endB7v160006EPi, symObjAddr: 0x3214, symBinAddr: 0x100005800, symSize: 0x8C }
+  - { offsetInCU: 0xDDC4, offset: 0xDDC4, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIiE10deallocateB7v160006EPim, symObjAddr: 0x32A0, symBinAddr: 0x10000588C, symSize: 0x40 }
+  - { offsetInCU: 0xDE06, offset: 0xDE06, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEED2B7v160006Ev, symObjAddr: 0x33E8, symBinAddr: 0x1000059D4, symSize: 0x44 }
+  - { offsetInCU: 0xDE30, offset: 0xDE30, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEEC2B7v160006ESt16initializer_listIiE, symObjAddr: 0x342C, symBinAddr: 0x100005A18, symSize: 0x128 }
+  - { offsetInCU: 0xDE80, offset: 0xDE80, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEEC1B7v160006IDnNS_18__default_init_tagEEEOT_OT0_, symObjAddr: 0x3554, symBinAddr: 0x100005B40, symSize: 0x3C }
+  - { offsetInCU: 0xDED8, offset: 0xDED8, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listIiE4sizeB7v160006Ev, symObjAddr: 0x3590, symBinAddr: 0x100005B7C, symSize: 0x18 }
+  - { offsetInCU: 0xDEFE, offset: 0xDEFE, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorIiNS_9allocatorIiEEE18__construct_at_endIPKiLi0EEEvT_S7_m, symObjAddr: 0x35A8, symBinAddr: 0x100005B94, symSize: 0x8C }
+  - { offsetInCU: 0xDF71, offset: 0xDF71, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listIiE5beginB7v160006Ev, symObjAddr: 0x3634, symBinAddr: 0x100005C20, symSize: 0x18 }
+  - { offsetInCU: 0xDF97, offset: 0xDF97, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listIiE3endB7v160006Ev, symObjAddr: 0x364C, symBinAddr: 0x100005C38, symSize: 0x20 }
+  - { offsetInCU: 0xDFBD, offset: 0xDFBD, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPiNS_9allocatorIiEEEC2B7v160006IDnNS_18__default_init_tagEEEOT_OT0_, symObjAddr: 0x366C, symBinAddr: 0x100005C58, symSize: 0x40 }
+  - { offsetInCU: 0xE015, offset: 0xE015, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorIiEELi1ELb1EEC2B7v160006ENS_18__default_init_tagE, symObjAddr: 0x36AC, symBinAddr: 0x100005C98, symSize: 0x2C }
+  - { offsetInCU: 0xE04A, offset: 0xE04A, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorIiEC2B7v160006Ev, symObjAddr: 0x36D8, symBinAddr: 0x100005CC4, symSize: 0x2C }
+  - { offsetInCU: 0xE074, offset: 0xE074, size: 0x8, addend: 0x0, symName: __ZNSt3__116__non_trivial_ifILb1ENS_9allocatorIiEEEC2B7v160006Ev, symObjAddr: 0x3704, symBinAddr: 0x100005CF0, symSize: 0x14 }
+  - { offsetInCU: 0xE0C1, offset: 0xE0C1, size: 0x8, addend: 0x0, symName: __ZNKSt3__114__copy_trivialclB7v160006IKiiLi0EEENS_4pairIPT_PT0_EES5_S5_S7_, symObjAddr: 0x392C, symBinAddr: 0x100005F18, symSize: 0x48 }
+  - { offsetInCU: 0xE147, offset: 0xE147, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiS2_EC1B7v160006IS2_S2_LPv0EEEOT_OT0_, symObjAddr: 0x3A94, symBinAddr: 0x100006080, symSize: 0x3C }
+  - { offsetInCU: 0xE1A5, offset: 0xE1A5, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiS2_EC2B7v160006IS2_S2_LPv0EEEOT_OT0_, symObjAddr: 0x3AD0, symBinAddr: 0x1000060BC, symSize: 0x34 }
+  - { offsetInCU: 0xE203, offset: 0xE203, size: 0x8, addend: 0x0, symName: __ZNSt3__118__unwrap_iter_implIPKiLb1EE8__unwrapB7v160006ES2_, symObjAddr: 0x3B04, symBinAddr: 0x1000060F0, symSize: 0x24 }
+  - { offsetInCU: 0xE230, offset: 0xE230, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiPiEC1B7v160006IRS2_S3_LPv0EEEOT_OT0_, symObjAddr: 0x3BF8, symBinAddr: 0x1000061E4, symSize: 0x3C }
+  - { offsetInCU: 0xE28E, offset: 0xE28E, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiPiEC2B7v160006IRS2_S3_LPv0EEEOT_OT0_, symObjAddr: 0x3C34, symBinAddr: 0x100006220, symSize: 0x34 }
+  - { offsetInCU: 0xE2EC, offset: 0xE2EC, size: 0x8, addend: 0x0, symName: __ZNSt3__118__unwrap_iter_implIPiLb1EE8__unwrapB7v160006ES1_, symObjAddr: 0x3C68, symBinAddr: 0x100006254, symSize: 0x24 }
+  - { offsetInCU: 0xE30F, offset: 0xE30F, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiPiEC1B7v160006IS2_S3_LPv0EEEOT_OT0_, symObjAddr: 0x3C8C, symBinAddr: 0x100006278, symSize: 0x3C }
+  - { offsetInCU: 0xE36D, offset: 0xE36D, size: 0x8, addend: 0x0, symName: __ZNSt3__14pairIPKiPiEC2B7v160006IS2_S3_LPv0EEEOT_OT0_, symObjAddr: 0x3CC8, symBinAddr: 0x1000062B4, symSize: 0x34 }
+  - { offsetInCU: 0xE3CB, offset: 0xE3CB, size: 0x8, addend: 0x0, symName: __ZNSt3__118__unwrap_iter_implIPKiLb1EE8__rewrapB7v160006ES2_S2_, symObjAddr: 0x3D38, symBinAddr: 0x100006324, symSize: 0x50 }
+  - { offsetInCU: 0xE3FC, offset: 0xE3FC, size: 0x8, addend: 0x0, symName: __ZNSt3__118__unwrap_iter_implIPiLb1EE8__rewrapB7v160006ES1_S1_, symObjAddr: 0x3D88, symBinAddr: 0x100006374, symSize: 0x50 }
+  - { offsetInCU: 0xE42D, offset: 0xE42D, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEEC2B7v160006ESt16initializer_listIS3_E, symObjAddr: 0x3DD8, symBinAddr: 0x1000063C4, symSize: 0x124 }
+  - { offsetInCU: 0xE47E, offset: 0xE47E, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEEC1B7v160006IDnNS_18__default_init_tagEEEOT_OT0_, symObjAddr: 0x3EFC, symBinAddr: 0x1000064E8, symSize: 0x3C }
+  - { offsetInCU: 0xE4D6, offset: 0xE4D6, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE16__destroy_vectorC1ERS5_, symObjAddr: 0x3F78, symBinAddr: 0x100006564, symSize: 0x34 }
+  - { offsetInCU: 0xE50F, offset: 0xE50F, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listINSt3__16vectorIiNS0_9allocatorIiEEEEE4sizeB7v160006Ev, symObjAddr: 0x3FBC, symBinAddr: 0x1000065A8, symSize: 0x18 }
+  - { offsetInCU: 0xE535, offset: 0xE535, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE11__vallocateB7v160006Em, symObjAddr: 0x3FD4, symBinAddr: 0x1000065C0, symSize: 0xB4 }
+  - { offsetInCU: 0xE579, offset: 0xE579, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE18__construct_at_endIPKS3_Li0EEEvT_S9_m, symObjAddr: 0x4088, symBinAddr: 0x100006674, symSize: 0x8C }
+  - { offsetInCU: 0xE5EC, offset: 0xE5EC, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listINSt3__16vectorIiNS0_9allocatorIiEEEEE5beginB7v160006Ev, symObjAddr: 0x4114, symBinAddr: 0x100006700, symSize: 0x18 }
+  - { offsetInCU: 0xE612, offset: 0xE612, size: 0x8, addend: 0x0, symName: __ZNKSt16initializer_listINSt3__16vectorIiNS0_9allocatorIiEEEEE3endB7v160006Ev, symObjAddr: 0x412C, symBinAddr: 0x100006718, symSize: 0x28 }
+  - { offsetInCU: 0xE638, offset: 0xE638, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEE10__completeB7v160006Ev, symObjAddr: 0x4154, symBinAddr: 0x100006740, symSize: 0x1C }
+  - { offsetInCU: 0xE65E, offset: 0xE65E, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEED1B7v160006Ev, symObjAddr: 0x4170, symBinAddr: 0x10000675C, symSize: 0x2C }
+  - { offsetInCU: 0xE688, offset: 0xE688, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEEC2B7v160006IDnNS_18__default_init_tagEEEOT_OT0_, symObjAddr: 0x419C, symBinAddr: 0x100006788, symSize: 0x40 }
+  - { offsetInCU: 0xE6E0, offset: 0xE6E0, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemIPNS_6vectorIiNS_9allocatorIiEEEELi0ELb0EEC2B7v160006IDnvEEOT_, symObjAddr: 0x41DC, symBinAddr: 0x1000067C8, symSize: 0x1C }
+  - { offsetInCU: 0xE722, offset: 0xE722, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorINS_6vectorIiNS1_IiEEEEEELi1ELb1EEC2B7v160006ENS_18__default_init_tagE, symObjAddr: 0x41F8, symBinAddr: 0x1000067E4, symSize: 0x2C }
+  - { offsetInCU: 0xE757, offset: 0xE757, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorINS_6vectorIiNS0_IiEEEEEC2B7v160006Ev, symObjAddr: 0x4224, symBinAddr: 0x100006810, symSize: 0x2C }
+  - { offsetInCU: 0xE781, offset: 0xE781, size: 0x8, addend: 0x0, symName: __ZNSt3__116__non_trivial_ifILb1ENS_9allocatorINS_6vectorIiNS1_IiEEEEEEEC2B7v160006Ev, symObjAddr: 0x4250, symBinAddr: 0x10000683C, symSize: 0x14 }
+  - { offsetInCU: 0xE7AB, offset: 0xE7AB, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEEC1B7v160006ES7_, symObjAddr: 0x4264, symBinAddr: 0x100006850, symSize: 0x34 }
+  - { offsetInCU: 0xE7E3, offset: 0xE7E3, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEEC2B7v160006ES7_, symObjAddr: 0x4298, symBinAddr: 0x100006884, symSize: 0x24 }
+  - { offsetInCU: 0xE81B, offset: 0xE81B, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE16__destroy_vectorC2ERS5_, symObjAddr: 0x42BC, symBinAddr: 0x1000068A8, symSize: 0x20 }
+  - { offsetInCU: 0xE854, offset: 0xE854, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE8max_sizeEv, symObjAddr: 0x42DC, symBinAddr: 0x1000068C8, symSize: 0x60 }
+  - { offsetInCU: 0xE87C, offset: 0xE87C, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE20__throw_length_errorB7v160006Ev, symObjAddr: 0x433C, symBinAddr: 0x100006928, symSize: 0x1C }
+  - { offsetInCU: 0xE8A2, offset: 0xE8A2, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE7__allocB7v160006Ev, symObjAddr: 0x4398, symBinAddr: 0x100006984, symSize: 0x28 }
+  - { offsetInCU: 0xE8C8, offset: 0xE8C8, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE9__end_capB7v160006Ev, symObjAddr: 0x43C0, symBinAddr: 0x1000069AC, symSize: 0x28 }
+  - { offsetInCU: 0xE8EE, offset: 0xE8EE, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE14__annotate_newB7v160006Em, symObjAddr: 0x43E8, symBinAddr: 0x1000069D4, symSize: 0xC8 }
+  - { offsetInCU: 0xE92D, offset: 0xE92D, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorINS_6vectorIiNS1_IiEEEEEEE8max_sizeB7v160006IS5_vEEmRKS5_, symObjAddr: 0x44B0, symBinAddr: 0x100006A9C, symSize: 0x24 }
+  - { offsetInCU: 0xE95B, offset: 0xE95B, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE7__allocB7v160006Ev, symObjAddr: 0x44D4, symBinAddr: 0x100006AC0, symSize: 0x28 }
+  - { offsetInCU: 0xE981, offset: 0xE981, size: 0x8, addend: 0x0, symName: __ZNKSt3__19allocatorINS_6vectorIiNS0_IiEEEEE8max_sizeB7v160006Ev, symObjAddr: 0x44FC, symBinAddr: 0x100006AE8, symSize: 0x18 }
+  - { offsetInCU: 0xE9A7, offset: 0xE9A7, size: 0x8, addend: 0x0, symName: __ZNKSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEE6secondB7v160006Ev, symObjAddr: 0x4514, symBinAddr: 0x100006B00, symSize: 0x24 }
+  - { offsetInCU: 0xE9CD, offset: 0xE9CD, size: 0x8, addend: 0x0, symName: __ZNKSt3__122__compressed_pair_elemINS_9allocatorINS_6vectorIiNS1_IiEEEEEELi1ELb1EE5__getB7v160006Ev, symObjAddr: 0x4538, symBinAddr: 0x100006B24, symSize: 0x14 }
+  - { offsetInCU: 0xE9F3, offset: 0xE9F3, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorINS_6vectorIiNS0_IiEEEEE8allocateB7v160006Em, symObjAddr: 0x454C, symBinAddr: 0x100006B38, symSize: 0x5C }
+  - { offsetInCU: 0xEA27, offset: 0xEA27, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEE6secondB7v160006Ev, symObjAddr: 0x45A8, symBinAddr: 0x100006B94, symSize: 0x24 }
+  - { offsetInCU: 0xEA4D, offset: 0xEA4D, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemINS_9allocatorINS_6vectorIiNS1_IiEEEEEELi1ELb1EE5__getB7v160006Ev, symObjAddr: 0x45CC, symBinAddr: 0x100006BB8, symSize: 0x14 }
+  - { offsetInCU: 0xEA73, offset: 0xEA73, size: 0x8, addend: 0x0, symName: __ZNSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEE5firstB7v160006Ev, symObjAddr: 0x45E0, symBinAddr: 0x100006BCC, symSize: 0x24 }
+  - { offsetInCU: 0xEA99, offset: 0xEA99, size: 0x8, addend: 0x0, symName: __ZNSt3__122__compressed_pair_elemIPNS_6vectorIiNS_9allocatorIiEEEELi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x4604, symBinAddr: 0x100006BF0, symSize: 0x14 }
+  - { offsetInCU: 0xEABF, offset: 0xEABF, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE31__annotate_contiguous_containerB7v160006EPKvS7_S7_S7_, symObjAddr: 0x4618, symBinAddr: 0x100006C04, symSize: 0x20 }
+  - { offsetInCU: 0xEB11, offset: 0xEB11, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE4dataB7v160006Ev, symObjAddr: 0x4638, symBinAddr: 0x100006C24, symSize: 0x28 }
+  - { offsetInCU: 0xEB37, offset: 0xEB37, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE8capacityB7v160006Ev, symObjAddr: 0x4660, symBinAddr: 0x100006C4C, symSize: 0x40 }
+  - { offsetInCU: 0xEB5D, offset: 0xEB5D, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE9__end_capB7v160006Ev, symObjAddr: 0x46B4, symBinAddr: 0x100006CA0, symSize: 0x28 }
+  - { offsetInCU: 0xEB83, offset: 0xEB83, size: 0x8, addend: 0x0, symName: __ZNKSt3__117__compressed_pairIPNS_6vectorIiNS_9allocatorIiEEEENS2_IS4_EEE5firstB7v160006Ev, symObjAddr: 0x46DC, symBinAddr: 0x100006CC8, symSize: 0x24 }
+  - { offsetInCU: 0xEBA9, offset: 0xEBA9, size: 0x8, addend: 0x0, symName: __ZNKSt3__122__compressed_pair_elemIPNS_6vectorIiNS_9allocatorIiEEEELi0ELb0EE5__getB7v160006Ev, symObjAddr: 0x4700, symBinAddr: 0x100006CEC, symSize: 0x14 }
+  - { offsetInCU: 0xEBE8, offset: 0xEBE8, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE21_ConstructTransactionC1B7v160006ERS5_m, symObjAddr: 0x4714, symBinAddr: 0x100006D00, symSize: 0x3C }
+  - { offsetInCU: 0xEC30, offset: 0xEC30, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE21_ConstructTransactionD1B7v160006Ev, symObjAddr: 0x4844, symBinAddr: 0x100006E30, symSize: 0x2C }
+  - { offsetInCU: 0xEC5A, offset: 0xEC5A, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE21_ConstructTransactionC2B7v160006ERS5_m, symObjAddr: 0x4870, symBinAddr: 0x100006E5C, symSize: 0x4C }
+  - { offsetInCU: 0xECA2, offset: 0xECA2, size: 0x8, addend: 0x0, symName: __ZNSt3__129_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS1_IiEEEEEEPS4_EC1B7v160006ERS5_RS6_S9_, symObjAddr: 0x4908, symBinAddr: 0x100006EF4, symSize: 0x44 }
+  - { offsetInCU: 0xECF9, offset: 0xECF9, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorINS_6vectorIiNS1_IiEEEEEEE9constructB7v160006IS4_JRKS4_EvEEvRS5_PT_DpOT0_, symObjAddr: 0x494C, symBinAddr: 0x100006F38, symSize: 0x34 }
+  - { offsetInCU: 0xED50, offset: 0xED50, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEE10__completeB7v160006Ev, symObjAddr: 0x4980, symBinAddr: 0x100006F6C, symSize: 0x1C }
+  - { offsetInCU: 0xED76, offset: 0xED76, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEED1B7v160006Ev, symObjAddr: 0x499C, symBinAddr: 0x100006F88, symSize: 0x2C }
+  - { offsetInCU: 0xEDA0, offset: 0xEDA0, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEEC1B7v160006ES8_, symObjAddr: 0x49C8, symBinAddr: 0x100006FB4, symSize: 0x34 }
+  - { offsetInCU: 0xEDD9, offset: 0xEDD9, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEEC2B7v160006ES8_, symObjAddr: 0x49FC, symBinAddr: 0x100006FE8, symSize: 0x30 }
+  - { offsetInCU: 0xEE12, offset: 0xEE12, size: 0x8, addend: 0x0, symName: __ZNSt3__129_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS1_IiEEEEEEPS4_EC2B7v160006ERS5_RS6_S9_, symObjAddr: 0x4A2C, symBinAddr: 0x100007018, symSize: 0x38 }
+  - { offsetInCU: 0xEE69, offset: 0xEE69, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorINS_6vectorIiNS0_IiEEEEE9constructB7v160006IS3_JRKS3_EEEvPT_DpOT0_, symObjAddr: 0x4A64, symBinAddr: 0x100007050, symSize: 0x30 }
+  - { offsetInCU: 0xEEBF, offset: 0xEEBF, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_29_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS2_IiEEEEEEPS5_EEED2B7v160006Ev, symObjAddr: 0x4A94, symBinAddr: 0x100007080, symSize: 0x50 }
+  - { offsetInCU: 0xEEE9, offset: 0xEEE9, size: 0x8, addend: 0x0, symName: __ZNKSt3__129_AllocatorDestroyRangeReverseINS_9allocatorINS_6vectorIiNS1_IiEEEEEEPS4_EclB7v160006Ev, symObjAddr: 0x4AE4, symBinAddr: 0x1000070D0, symSize: 0x68 }
+  - { offsetInCU: 0xEF0F, offset: 0xEF0F, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEC1B7v160006ES5_, symObjAddr: 0x4BBC, symBinAddr: 0x1000071A8, symSize: 0x34 }
+  - { offsetInCU: 0xEF47, offset: 0xEF47, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorINS_6vectorIiNS1_IiEEEEEEE7destroyB7v160006IS4_vEEvRS5_PT_, symObjAddr: 0x4C38, symBinAddr: 0x100007224, symSize: 0x2C }
+  - { offsetInCU: 0xEF84, offset: 0xEF84, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEppB7v160006Ev, symObjAddr: 0x4C88, symBinAddr: 0x100007274, symSize: 0x20 }
+  - { offsetInCU: 0xEFAA, offset: 0xEFAA, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEE4baseB7v160006Ev, symObjAddr: 0x4CA8, symBinAddr: 0x100007294, symSize: 0x18 }
+  - { offsetInCU: 0xEFD0, offset: 0xEFD0, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorINS_6vectorIiNS0_IiEEEEE7destroyB7v160006EPS3_, symObjAddr: 0x4CC0, symBinAddr: 0x1000072AC, symSize: 0x28 }
+  - { offsetInCU: 0xF009, offset: 0xF009, size: 0x8, addend: 0x0, symName: __ZNSt3__119__to_address_helperINS_16reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEEvE6__callB7v160006ERKS7_, symObjAddr: 0x4CE8, symBinAddr: 0x1000072D4, symSize: 0x38 }
+  - { offsetInCU: 0xF02C, offset: 0xF02C, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEptB7v160006Ev, symObjAddr: 0x4D20, symBinAddr: 0x10000730C, symSize: 0x24 }
+  - { offsetInCU: 0xF052, offset: 0xF052, size: 0x8, addend: 0x0, symName: __ZNKSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEdeB7v160006Ev, symObjAddr: 0x4D44, symBinAddr: 0x100007330, symSize: 0x28 }
+  - { offsetInCU: 0xF086, offset: 0xF086, size: 0x8, addend: 0x0, symName: __ZNSt3__116reverse_iteratorIPNS_6vectorIiNS_9allocatorIiEEEEEC2B7v160006ES5_, symObjAddr: 0x4D6C, symBinAddr: 0x100007358, symSize: 0x28 }
+  - { offsetInCU: 0xF0BE, offset: 0xF0BE, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE21_ConstructTransactionD2B7v160006Ev, symObjAddr: 0x4D94, symBinAddr: 0x100007380, symSize: 0x20 }
+  - { offsetInCU: 0xF0E8, offset: 0xF0E8, size: 0x8, addend: 0x0, symName: __ZNSt3__128__exception_guard_exceptionsINS_6vectorINS1_IiNS_9allocatorIiEEEENS2_IS4_EEE16__destroy_vectorEED2B7v160006Ev, symObjAddr: 0x4DB4, symBinAddr: 0x1000073A0, symSize: 0x50 }
+  - { offsetInCU: 0xF112, offset: 0xF112, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE16__destroy_vectorclB7v160006Ev, symObjAddr: 0x4E04, symBinAddr: 0x1000073F0, symSize: 0x9C }
+  - { offsetInCU: 0xF138, offset: 0xF138, size: 0x8, addend: 0x0, symName: __ZNKSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE17__annotate_deleteB7v160006Ev, symObjAddr: 0x4EA0, symBinAddr: 0x10000748C, symSize: 0xD4 }
+  - { offsetInCU: 0xF15E, offset: 0xF15E, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE7__clearB7v160006Ev, symObjAddr: 0x4F84, symBinAddr: 0x100007570, symSize: 0x28 }
+  - { offsetInCU: 0xF184, offset: 0xF184, size: 0x8, addend: 0x0, symName: __ZNSt3__116allocator_traitsINS_9allocatorINS_6vectorIiNS1_IiEEEEEEE10deallocateB7v160006ERS5_PS4_m, symObjAddr: 0x4FAC, symBinAddr: 0x100007598, symSize: 0x34 }
+  - { offsetInCU: 0xF1C6, offset: 0xF1C6, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEE22__base_destruct_at_endB7v160006EPS3_, symObjAddr: 0x4FE0, symBinAddr: 0x1000075CC, symSize: 0x8C }
+  - { offsetInCU: 0xF20A, offset: 0xF20A, size: 0x8, addend: 0x0, symName: __ZNSt3__19allocatorINS_6vectorIiNS0_IiEEEEE10deallocateB7v160006EPS3_m, symObjAddr: 0x506C, symBinAddr: 0x100007658, symSize: 0x44 }
+  - { offsetInCU: 0xF24C, offset: 0xF24C, size: 0x8, addend: 0x0, symName: __ZNSt3__16vectorINS0_IiNS_9allocatorIiEEEENS1_IS3_EEED2B7v160006Ev, symObjAddr: 0x50B0, symBinAddr: 0x10000769C, symSize: 0x44 }
+...

447-240108/main.cpp

@@ -0,0 +1,107 @@
+#include<iostream>
+#include<vector>
+using namespace std;
+class Solution{
+public:
+  int numberOfBoomerangs1(vector<vector <int>>& points){
+    int points_size = points.size();
+    int ans = 0;
+    for(vector<int> firstpoint: points){
+      for(vector<int> secondpoint: points){
+	  if(samePoint(firstpoint, secondpoint))continue;
+	  for(vector<int> thirdpoint: points){
+	      if(samePoint(secondpoint, thirdpoint) || samePoint(firstpoint, thirdpoint)) continue;
+	      if(distance(firstpoint, secondpoint) == distance(firstpoint, thirdpoint)){
+		ans++;
+		cout<<firstpoint[0]<<' '<<firstpoint[1]<<' '<<secondpoint[0]<<' '<<secondpoint[1]<<' '<<thirdpoint[0]<<' '<<thirdpoint[1]<<endl;
+	      }
+	  }
+      }
+    }
+    return ans;
+  }
+  int numberOfBoomerangs(vector<vector<int>>& points){
+    int point_size = points.size();
+    int ans =0;
+    double dist[510][510];
+    for(int i = 0 ; i < point_size ;i++){
+      for(int j = 0 ; j < point_size ;j++){
+	dist[i][j] = distance(points[i],points[j]);
+      }
+    }
+
+    for(int i = 0 ; i < point_size ; i++){
+      for(int j = 0 ; j < point_size ; j++){
+	cout<<dist[i][j]<<' ';
+      }
+      cout<<endl;
+    }
+    /*
+    for(int i = 0 ; i < point_size;i++){
+      for(int j = i + 1 ; j < point_size ; j++){
+	if(i == j) continue;
+	for(int k = j + 1 ; k < point_size ; k++) {
+	  if(i == k || j == k) continue;
+	  if(dist[i][j] == dist[i][k]){
+	    ans += 2;
+	    cout<<points[i][0]<<' ' <<points[i][1]<<' '<<points[j][0]<<' '<<points[j][1]<<' '<<points[k][0]<<' '<<points[k][1]<<' '<<dist[i][j]<<' '<<dist[i][k]<<endl;
+	  }
+	}
+      }
+    }
+    */
+    for(int i = 0 ; i < point_size ; i++){
+      sort(dist[i],dist[i]+point_size);
+      int tmp = 1;
+      for(int j = 0 ; j < point_size ; j++)
+	cout<<dist[i][j]<<' ';
+      cout<<endl;
+      for(int j = 1 ; j < point_size ; j++){
+	if(dist[i][j]  == dist[i][j-1]){
+	  tmp++;
+	}
+	else{
+	  ans += tmp * (tmp-1);
+	  tmp = 1;
+	  cout<<i<<' '<<j<<' '<<tmp<<endl;
+	}
+      }
+      ans += tmp * (tmp - 1);
+    }
+    return ans;
+  }
+    private:
+      bool samePoint(vector<int> a, vector<int> b){
+	  if(a[0] == b[0] && a[1] == b[1])
+	    return true;
+	  return false;
+      }
+      double distance(vector<int> a, vector<int> b){
+	double rlt = (a[0]-b[0])*(a[0]-b[0]) +(a[1]-b[1])*(a[1]-b[1]);
+	
+	return sqrt(rlt);
+      }
+};
+int main(){
+  Solution sol;
+  vector<int> point1 = {0,0};
+  vector<int> point2 = {1,0};
+  vector<int> point3 = {-1,0};
+  vector<int> point4 = {0,1};
+  vector<int> point5 = {0,-1};
+  vector<vector<int>> ex1 = {point1, point2, point3,point4,point5};
+  cout<<sol.numberOfBoomerangs(ex1)<<endl;
+  //  vector<int> ex2_point1 = {1,1};
+  //  vector<int> ex2_point2 = {2,2};
+  //  vector<int> ex2_point3 = {3,3};
+  //  vecotr<int> ex2_point4 = {
+  vector<int> ex2_point1 = {0,0};
+  vector<int> ex2_point2 = {0,1};
+  vector<int> ex2_point3 = {5,0};
+  vector<int> ex2_point4 = {5,1};
+  vector<vector<int>> ex2 = {ex2_point1, ex2_point2, ex2_point3,ex2_point4};
+  cout<<sol.numberOfBoomerangs(ex2)<<endl;
+  
+  
+  return 0;
+}

452-240616-pass/main.py

@@ -0,0 +1,18 @@
+class Solution:
+    def findMinArrowShots(self, points: list[list[int]]) -> int:
+        def rule(l):
+            return (l[0], l[1])
+        sorted_points = sorted(points, key=rule)
+        rlt = 0
+        end = -inf
+        for point in sorted_points:
+            st = point[0]
+            ed = point[1]
+            if st > end:
+                rlt += 1
+                end = ed
+            else:
+                end = min(end, ed)
+        return rlt
+sol = Solution()
+print(sol.findMinArrowShots([[10, 16],[2, 8],[1, 6], [7, 12]]))

46-240610-pass/main.py

@@ -0,0 +1,26 @@
+class Solution:
+    def permute(self,nums: list[int]) -> list[list[int]]:
+        length = len(nums)
+        l = [i for i in range(length)]
+        permute = []
+        s = set()
+        def get_permute(l, num, length, s, cur):
+            if num == length: 
+                permute.append(cur)
+                return
+            for i in range(length):
+                if i not in s:
+                    s.add(i)
+                    cur.append(i)
+                    get_permute(l, num+1, length, s, cur.copy())
+                    cur.pop()
+                    s.remove(i)
+        get_permute(l,0,length, s, cur=[])
+        rlt = []
+        for li in permute:
+            rlt.append([nums[i] for i in li])
+        return rlt
+
+sol = Solution()
+print(sol.permute([1, 2, 3]))
+

53-240525-pass/main.py

@@ -0,0 +1,10 @@
+class Solution:
+    def maxSubArray(self, nums: List[int]) -> int:
+        s = [-1e5]
+        for index, num in enumerate(nums):
+            val = max(s[index] + num, num)
+            s.append(val)
+        ans = -1e5
+        for num in s:
+            ans = max(num,ans)
+        return ans

530-240525-pass/main.py

@@ -0,0 +1,32 @@
+class Solution {
+public:
+    vector<int> rightSideView(TreeNode* root) {
+        queue<TreeNode *> que;
+        vector<int> rlt;
+        if(root->left == nullptr && root->right == nullptr){
+            return rlt;
+        }
+        que.push(root);
+        while(!que.empty()){
+            queue< TreeNode *> tmp_que;
+            TreeNode * node;
+            while(!que.empty()){
+                node = que.front();
+                tmp_que.push(node);
+                que.pop();
+            }
+            rlt.push_back(node->val);
+            while(!tmp_que.empty()){
+                node = tmp_que.front();
+                if(node->left != nullptr){
+                    que.push(node->left);
+                }
+                if(node->right != nullptr){
+                    que.push(node->right);
+                }
+                tmp_que.pop();
+            }
+        }
+        return rlt;
+    }
+};

54-240608-pass/main.py

@@ -0,0 +1,32 @@
+class Solution:
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        d = [(0,1),(1,0),(0,-1),(-1,0)]
+        cur_d = 0
+        width = len(matrix[0])
+        height = len(matrix)
+        m, n = width, height - 1
+        cur_m, cur_n = 0,0
+        cur_p = (0,0)
+        rlt = []
+        for i in range(width * height):
+            # print(cur_p, m, n, cur_m, cur_n)
+            row = cur_p[0]
+            col = cur_p[1]
+            rlt.append(matrix[row][col])
+            if cur_d % 2 == 0:
+                cur_m += 1
+                if cur_m == m:
+                    m -= 1
+                    cur_d += 1
+                    cur_d %= 4    
+                    cur_m = 0           
+            else:
+                cur_n += 1
+                if cur_n == n:
+                    n -= 1
+                    cur_d += 1
+                    cur_d %= 4
+                    cur_n = 0
+            cur_p = (row + d[cur_d][0], col+d[cur_d][1])
+            
+        return rlt

56-240602-pass/main.py

@@ -0,0 +1,18 @@
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        sorted_intervals = sorted(intervals, key=lambda x:x[0])
+        cur_l = [sorted_intervals[0][0], sorted_intervals[0][1]]
+        rlt = []
+        for ind, l in enumerate(sorted_intervals[1:]):
+          
+            if cur_l[1] >= l[1] and cur_l[0]<=l[0]:pass
+            elif cur_l[1] >= l[0]:
+                cur_l[1] = l[1]
+            else:
+                r = cur_l.copy()
+                rlt.append(r)
+                cur_l[0]=l[0]
+                cur_l[1]=l[1]
+            # print(cur_l,rlt)
+        rlt.append(cur_l)
+        return rlt

57-240605-pass/main.py

@@ -0,0 +1,81 @@
+class Solution:
+    def insert(self, intervals: list[list[int]], newInterval: list[int]) -> list[list[int]]:
+        l = newInterval[0]
+        r = newInterval[1]
+        if r < intervals[0][0]:
+            intervals.insert(0, newInterval)
+            return intervals
+        if l > intervals[-1][1]:
+            intervals.append(newInterval)
+            return intervals
+        nl = 0
+        nl_f = False
+        nl_ff = False
+        nr = len(intervals) 
+        nr_f = False
+        nr_ff = False
+        for ind, interval in enumerate(intervals):
+            left = interval[0]
+            right = interval[1]
+            if l >= left and l <= right:
+                nl_f = True
+                nl = ind
+            if r >= left and r <= right:
+                nr_f = True
+                nr = ind + 1
+
+        if nl_f == False:
+            for i in range(1, len(intervals)):
+                if l > intervals[i - 1][1] and l < intervals[i][0]:
+                    nl = i
+                    nl_ff = True
+                    break
+
+        if nr_f == False:
+             for i in range(1, len(intervals)):
+                if r > intervals[i - 1][1] and r < intervals[i][0]:
+                    nr = i
+                    nr_ff = True
+                    break
+
+        print(nl, nr, nl_f, nr_f)
+
+        rlt = []
+        for i in range(nl):
+            rlt.append(intervals[i])
+        nl_l = intervals[nl][0]
+        if nl_f == False:
+            nl_l = l
+        if nr_ff == True or nr_f == True:
+            nr = nr - 1
+            nr_r = intervals[nr][1]
+            nr = nr + 1
+
+        if nr_f == False:
+            nr_r = r
+        
+        rlt.append([nl_l, nr_r])
+
+        print(rlt)
+        for i in range(nr, len(intervals)):
+            rlt.append(intervals[i])
+        return rlt
+
+intervals = [[1,3], [6,9]]
+newInterval = [2,5]
+sol = Solution()
+print(sol.insert(intervals=intervals, newInterval=newInterval))
+intervals = [[1,2], [3,5], [6,7], [8,10],[12, 16]]
+newInterval = [4, 8]
+print(sol.insert(intervals=intervals, newInterval=newInterval))
+
+intervals = [[1,2], [3,5], [6,7], [8,10],[12, 16]]
+newInterval = [0, 16]
+print(sol.insert(intervals=intervals, newInterval=newInterval))
+print()
+intervals = [[1,5]]
+newInterval = [6, 18]
+print(sol.insert(intervals=intervals, newInterval=newInterval))
+
+
+

606-20231208-pass/main.cpp

@@ -0,0 +1,94 @@
+#include<stdcpp.h>
+using namespace std;
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+void create(int * val, int cnt, TreeNode *cur,int idx){
+    int left_idx = (idx + 1) * 2 - 1;
+    int right_idx = (idx + 1) * 2 ;
+    if(left_idx >= cnt && right_idx >= cnt) {
+        cur->left = nullptr;
+        cur->right = nullptr;
+        return;
+    }
+    if(val[left_idx] == -1 || left_idx >= cnt){
+        cur -> left = nullptr;
+    }else{
+        TreeNode * left_child = new TreeNode(val[left_idx]);
+        cur->left = left_child;
+        create(val,cnt,left_child,left_idx);
+    }
+    if(val[right_idx] == -1 || right_idx >= cnt){
+        cur -> right = nullptr;
+    }else{
+        TreeNode * right_child = new TreeNode(val[right_idx]);
+        cur->right = right_child;
+        create(val, cnt, right_child, right_idx);
+    }
+    return;
+}
+void traverse(TreeNode* node){
+    cout<<node->val<<' ';
+    if(node->left != nullptr){
+        traverse(node->left);
+    }
+    if(node->right != nullptr){
+        traverse(node->right);
+    }
+    return;
+}
+TreeNode* createTree(int * val, int cnt){
+    TreeNode * root = new TreeNode(val[0]);
+    cout<<"create a tree"<<endl;
+    create(val,cnt,root, 0);
+    traverse(root);
+    cout<<"\ndone"<<endl;
+    return root;
+}
+
+class Solution{
+    public:
+    string traverse(TreeNode * node, string &str){
+        str.push_back((char)('0'+node->val));
+        if(node -> left == nullptr && node -> right == nullptr) return str;
+        if(node -> left == nullptr){
+            str.push_back('(');
+            str.push_back(')');
+        }else{
+            str.push_back('(');
+            traverse(node->left, str);
+            str.push_back(')');
+        }
+        if(node -> right == nullptr){
+            return str;
+        }else{
+            str.push_back('(');
+            traverse(node->right, str);
+            str.push_back(')');
+            return str;
+        }
+        
+    }
+    string tree2str(TreeNode * root){
+        string rlt = "";
+        return traverse(root,rlt);
+    }
+
+};
+
+int main(){
+    Solution sol;
+    int ex1_val[4] = {1,2,3,4};
+    TreeNode * ex1 = createTree(ex1_val,4);
+    cout<<sol.tree2str(ex1)<<endl;
+    int ex2_val[5] = {1,2,3,-1,4};
+    TreeNode * ex2 = createTree(ex2_val, 5);
+    cout<<sol.tree2str(ex2)<<endl;
+
+    return 0;
+}

64-240603-pass/main.py

@@ -0,0 +1,21 @@
+class Solution:
+    def minPathSum(self, grid: List[List[int]]) -> int:
+        r = []
+        for i in range(len(grid)):
+            r.append([])
+        for i , l in enumerate(grid):
+            for j, num in enumerate(l):
+                if i == 0 and j == 0:
+                    r[i].append(num)
+                    continue
+                if i == 0:
+                    r[i].append(num + r[i][j - 1])
+                    continue
+                if j == 0:
+                    r[i].append(num + r[i - 1][0])
+                    continue
+                r[i].append(min(r[i - 1][j], r[i][j - 1]) + num)
+        width = len(grid[0])
+        height = len(grid)
+        return r[height - 1][width - 1]
+

66-240603-pass/main.py

@@ -0,0 +1,25 @@
+class Solution:
+    def plusOne(self, digits: list[int]) -> list[int]:
+        flag = 1
+        # x = digits[-1] + 1
+        # if x == 10: 
+        #     flag = 1
+        #     digits[-1] = 0
+        # else:
+        #     digits[-1] = x
+        for i in range(len(digits) - 1, -1, -1):
+            x = digits[i] + flag
+            digits[i] = x
+            if x == 10:
+                flag = 1
+                digits[i] = 0
+            else:
+                flag = 0
+        if digits[0] == 0:
+            digits.insert(0, 1)
+        return digits
+
+sol = Solution()
+print(sol.plusOne([1, 2, 3]))
+print(sol.plusOne([1, 2, 3, 4]))
+print(sol.plusOne([9]))

67-240525-pass/main.py

@@ -0,0 +1,33 @@
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        tmpa = a
+        tmpb = b
+        if len(a)>len(b):
+            a = tmpb
+            b = tmpa
+        while len(a) < len(b): a = '0' + a
+        print(a, b)
+        flag = 0
+        indb = len(b) - 1
+        rlt = ""
+        for inda in range(len(a)-1, -1, -1):
+            numa = int(a[inda])
+            numb = int(b[indb])
+            s = numa + numb + flag
+            print(s)
+            if s == 3:
+                rlt = '1' + rlt
+                flag = 1
+            if s == 2:
+                flag = 1
+                rlt = '0' + rlt
+            if s == 1: 
+                flag = 0
+                rlt = '1' + rlt
+            if s == 0: 
+                flag = 0
+                rlt = '0' + rlt
+            indb -= 1
+            print(f'rlt: {rlt}')
+        if flag == 1: rlt = '1' + rlt
+        return rlt

74-240602-pass/main.py

@@ -0,0 +1,13 @@
+class Solution:
+    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
+        ind = len(matrix) - 1
+        for x, l in enumerate(matrix):
+            if l[0] < target: continue
+            if l[0] == target: return True
+            if x != 0: ind = x - 1
+            break
+        l = matrix[ind]
+        print(l)
+        if target in l:
+            return True
+        return False

77-240602-pass/main.py

@@ -0,0 +1,13 @@
+class Solution:
+    def combine(self, n: int, k: int) -> List[List[int]]:
+        rlt = []
+        def comb(l, cur, k):
+            if k == 0: 
+                rlt.append(l) 
+                return
+            for i in range(cur, n + 1):
+                tmp_l = l.copy()
+                tmp_l.append(i)
+                comb(tmp_l, i + 1, k - 1)
+        comb([], 1, k)
+        return rlt

88-231127-pass/main.py

@@ -0,0 +1,42 @@
+def merge(self, nums1: list[int], m: int, nums2: list[int], n: int) -> None:
+        """
+        Do not return anything, modify nums1 in-place instead.
+        """
+        tmp = []
+        for i in range(m):
+            tmp.append(nums1[i])
+        for num in nums2:
+            tmp.append(num)
+        
+        ind1 = 0
+        ind2 = 0
+        rlt = []
+        if(m == 0 or n == 0):
+            rlt += tmp
+        else:
+            for i in range(m + n):
+                if(nums1[ind1]<= nums2[ind2]):
+                    rlt.append(nums1[ind1])
+                    ind1 += 1
+                    if(ind1 == m):
+                        rlt += nums2[ind2:]
+                        print(i, rlt)
+                        break
+                else:
+                    rlt.append(nums2[ind2])
+                    ind2 += 1
+                    if(ind2 == n):
+                        rlt += nums1[ind1:]
+                        print(i, rlt)
+                        break;
+                print(i, rlt)
+        for i in range(len(rlt)):
+            nums1[i] = rlt[i]
+
+nums1 = [2,0]
+m = 1
+nums2 = [1]
+n = 1
+print(merge(0, nums1, m, nums2, n))
+
+    

9-240525-pass/main.py

@@ -0,0 +1,15 @@
+class Solution:
+    def isPalindrome(self, x: int) -> bool:
+        s = str(x)
+        if len(s) % 2 == 0: 
+            mid = len(s) // 2 - 1
+            for i in range(mid):
+                if s[i] != s[len(s) - i - 1]:
+                    return False
+            return True
+        else:
+            mid = len(s) // 2
+            for i in range(mid):
+                if s[i] != s[len(s) - i - 1]:
+                    return False
+            return True

909-240525-pass/main.py

@@ -0,0 +1,46 @@
+class Solution:
+    def snakesAndLadders(self, board: List[List[int]]) -> int:
+        ans = 0
+        n = len(board)
+        n = n - 1
+        length = n + 1
+        que = [(1,0)]
+        idx = 0
+        flag = [0 for i in range((n+1)*(n+1))]
+        def add_node(que, idx, node):
+            if len(que) <= idx:
+                que.append(node)
+            else:
+                que[idx] = node
+        def move(idx):
+            row = 0
+            column = idx % (n + 1)
+            if idx % (n + 1) == 0: row -= 1
+            row += idx // (n + 1)
+            row = n - row
+            oe = idx // (n + 1) % 2
+            if idx % (n + 1) == 0: oe = 1 - oe
+            if column == 0: column = n + 1
+            column -= 1
+            if oe == 1: column = n - column
+            return (row, column)
+        front = 0
+        while idx - front >= 0:
+            node = que[front]
+            front += 1
+            step = node[1]
+            cur_loc = node[0]
+            if flag[cur_loc] == 1: continue
+            flag[cur_loc] = 1
+            if cur_loc + 6 >=  length * length:
+                return step + 1
+            for i in range(1, 7):
+                (row, column) = move(i + cur_loc)
+                if board[row][column]!= -1:
+                    if board[row][column] == length * length: return step + 1
+                    idx += 1
+                    add_node(que, idx, (board[row][column], step + 1))
+                else:
+                    idx += 1
+                    add_node(que, idx, (i + cur_loc, step + 1))
+        return -1

918-240623/main.cpp

@@ -0,0 +1,14 @@
+class Solution {
+public:
+    int maxSubarraySumCircular(vector<int>& A) {
+        int sum = 0, mn = INT_MAX, mx = INT_MIN, curMax = 0, curMin = 0;
+		for (int num : A) {
+			curMin = min(curMin + num, num);
+            mn = min(mn, curMin);
+            curMax = max(curMax + num, num);
+            mx = max(mx, curMax);
+            sum += num;
+		}
+        return (sum - mn == 0) ? mx : max(mx, sum - mn);
+    }
+};

92-240616-pass/main.py

@@ -0,0 +1,25 @@
+class ListNode:
+    def __init__(self, val = 0, next = None):
+        self.val = val
+        self.next = next
+class Solution:
+    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
+        cnt = 0
+        l = []
+        true_head = ListNode()
+        true_head.next = head
+        true_end = ListNode()
+        cur = head
+        while cur.next != None:
+            cur = cur.next
+        cur.next = true_end
+        cur = true_head
+
+        while cur != None:
+            if cnt >= left - 1 and cnt <= right + 1:
+                l.append(cur)
+            cur = cur.next
+            cnt += 1
+        for ind in range(len(l), 0, -1):
+            l[ind].next = l[ind-1]
+        

94-231209/main.cpp

@@ -0,0 +1,89 @@
+#include<stdcpp.h>
+using namespace std;
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+
+void create(int * val, int cnt, TreeNode *cur,int idx){
+    int left_idx = (idx + 1) * 2 - 1;
+    int right_idx = (idx + 1) * 2 ;
+    if(left_idx > cnt){
+        cur->left = nullptr;
+        cur->right = nullptr;
+        return;
+    }
+    if(right_idx > cnt){
+        cur->right = nullptr;
+        return;
+    }
+    if(val[left_idx] == -1){
+        cur -> left = nullptr;
+    }else{
+        TreeNode * left_child = new TreeNode(val[left_idx]);
+        cur->left = left_child;
+        create(val,cnt,left_child,left_idx);
+    }
+    if(val[right_idx] == -1){
+        cur -> right = nullptr;
+    }else{
+        TreeNode * right_child = new TreeNode(val[right_idx]);
+        cur->right = right_child;
+        create(val, cnt, right_child, right_idx);
+    }
+    return;
+}
+void traverse(TreeNode* node){
+    cout<<node->val<<' ';
+    if(node->left != nullptr){
+        traverse(node->left);
+    }
+    if(node->right != nullptr){
+        traverse(node->right);
+    }
+    return;
+}
+TreeNode* createTree(int * val, int cnt){
+    TreeNode * root = new TreeNode(val[0]);
+    cout<<"create a tree"<<endl;
+    create(val,cnt,root, 0);
+    traverse(root);
+    cout<<"\ndone"<<endl;
+    // cout<<endl;
+    return root;
+}
+class Solution{
+    public:
+    vector<int> traversal(TreeNode * node, vector<int> & rlt){
+        if(node -> left != nullptr){
+            traversal(node->left,rlt);
+        }
+        rlt.push_back(node->val);
+        if(node -> right != nullptr){
+            traversal(node->right, rlt);
+        }
+        return rlt;
+    }
+    vector<int> inorderTraversal(TreeNode* root){
+        vector<int> rlt;
+        traversal(root, rlt);
+        return rlt;
+    }
+};
+int main(){
+    Solution sol;
+    int ex1_data[7] = {1,-1,2,-1,-1,3,-1};
+    TreeNode * ex1 = createTree(ex1_data, 7);
+    vector<int> rltex1 = sol.inorderTraversal(ex1);
+    for(int i = 0 ; i < rltex1.size(); i++){
+        cout<<rltex1[i]<<' ';
+    }
+    cout<<endl;
+
+    return 0;
+}

contest-20231203/2951/main.cpp

@@ -0,0 +1,32 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution {
+public:
+    vector<int> findPeaks(vector<int>& mountain) {
+        vector<int>rlt;
+        const int len = mountain.size();
+        for(int i = 1 ; i < mountain.size() - 1; i++){
+            if(mountain[i] > mountain[i-1] && mountain[i] > mountain[i+1])
+            rlt.push_back(i);
+        }
+
+        return rlt;
+    }
+};
+int main(){
+    Solution sol;
+
+    vector<int> ex1 = {2,4,4};
+    vector<int>rlt1 = sol.findPeaks(ex1);
+    for(int i = 0 ; i <rlt1.size();i++)
+        cout<<rlt1[i]<<' ';
+    cout<<endl;
+
+    vector<int> ex2 = {1,4,3,8,5};
+    vector<int>rlt2 = sol.findPeaks(ex2);
+    for(int i = 0 ; i <rlt2.size();i++)
+        cout<<rlt2[i]<<' ';
+    cout<<endl;
+
+    return 0;
+}

contest-20231203/2952/main.cpp

@@ -0,0 +1,42 @@
+#include<stdcpp.h>
+using namespace std;
+class Solution {
+public:
+    int minimumAddedCoins(vector<int>& coins, int target) {
+        const int len = coins.size(); 
+        sort(coins.begin(), coins.end());
+        int express = 0;
+        int idx = 0;
+        int ans = 0;
+        while(express < target){
+            if(idx < len && express+1 >= coins[idx]){
+                express += coins[idx++];
+            }else{
+                ans++;
+                express += express + 1;
+            }
+        }
+        cout<<ans<<endl;
+        return ans;
+    }
+};
+int main(){
+    Solution sol;
+
+    vector<int> ex1 = {1,4,10};
+    int target1 = 19;
+    sol.minimumAddedCoins(ex1,target1);
+
+    vector<int> ex2 = {1,4,10,5,7,19};
+    int target2 = 19;
+    sol.minimumAddedCoins(ex2,target2);
+
+    vector<int> ex3 = {1,1,1};
+    int target3 = 20;
+    sol.minimumAddedCoins(ex3,target3);
+
+    vector<int> ex4 = {1};
+    int target4 = 100000;
+    sol.minimumAddedCoins(ex4,target4);
+    return 0;
+}

example.cpp

@@ -0,0 +1,12 @@
+#include<stdcpp.h>
+using namespace std;
+int plus(int a, int b){
+  return a+b;
+}
+int main(){
+  int first_add_number = 5;
+  int second_add_number = 10;
+  int result = plus(first_add_number, second_add_number);
+  cout<< result <<endl;
+  return 0;
+}

example.cpp~

@@ -0,0 +1,135 @@
+#include<stdio.h>
+#include<cstring>
+struct People{
+	char name[20];
+    unsigned long long phone;
+} ;	
+People list[200];
+void Input();
+void Inquiry();
+void Revise();
+void Delete();
+int main(){
+	while(1){
+    printf("ƒ˙“—Ω¯»ÎÕ®—∂¬º£¨«Î—°‘Òƒ˙µƒ—°œÓ\n");
+    printf("1.Ã̺”¡™œµ»Àº∞∆‰µÁª∞∫≈¬Î\n");
+	printf("2.≤È—Ø¡™œµ»ÀµÁª∞∫≈¬Î\n");
+	printf("3.–fi∏ƒ¡™œµ»ÀµƒµÁª∞∫≈¬Î\n");
+	printf("4.…æ≥˝¡™œµ»Àº∞∆‰µÁª∞∫≈¬Î\n");
+	int a;
+	scanf("%d",&a);
+	switch(a){
+	case 1:Input(); break;
+    case 2:Inquiry(); break;
+	case 3:Revise(); break; 
+	case 4:Delete(); break;
+	case 5:return 0;
+	}
+	}
+}
+void Input(){
+	char name[20];
+ unsigned long long phone;
+	 FILE* fole=fopen("people.txt","r");
+	 for(int k=0;k<200;k++){
+       fscanf(fole,"%s\n%ld\n",list[k].name,&list[k].phone);	
+	}
+    printf("«Î ‰»Îƒ„“™Ã̺”µƒ¡™œµ»À–’√˚\n");
+    scanf("%s",name);
+	printf("«Î ‰»Îƒ„“™Ã̺”µƒ¡™œµ»ÀµƒµÁª∞∫≈¬Î\n");
+	scanf("%lld",&phone);
+    for(int i=0;i<200;i++){
+		if(list[i].name[0]=='\0'){
+            strcpy(list[i].name,name);
+			list[i].phone=phone;
+			printf("Ã̺”¡™œµ»À≥…𶣨∑µªÿ÷˜ΩÁ√Ê\n");
+		    break;
+		}
+	}
+	FILE* file=fopen("people.txt","w");
+	for(int j=0;j<200;j++){
+       fprintf(file,"%s\n%lld\n",list[j].name,list[j].phone);	
+	}
+  fclose(file);
+} 
+
+void Inquiry(){
+    char name[20];
+	printf("«Î ‰»Îƒ„“™≤ȗصƒµÁª∞∫≈¬Îµƒ¡™œµ»À√˚◊÷\n");
+		scanf("%s",name);
+     FILE* fole=fopen("people.txt","r");
+	 for(int k=0;k<200;k++){
+       fscanf(fole,"%s\n%ld\n",list[k].name,&list[k].phone);	
+	}
+	 fclose(fole);
+	 int a=0;
+	 for(int g=0;g<200;g++){
+		 if(strcmp(list[g].name,name)==0){
+			 printf("name:%s\n phone:%lld\n",list[g].name,list[g].phone);
+			 a=1;
+			 printf("≤È—Ø≥…𶣨∑µªÿ÷˜ΩÁ√Ê\n");
+			 break;
+		 }
+	 }
+	 if(a==0){
+	 printf("≤È—Ø ß∞‹£¨«Î÷ÿ–¬≥¢ ‘\n");
+	 }
+   FILE* file=fopen("people.txt","w");
+	for(int j=0;j<200;j++){
+       fprintf(file,"%s\n%lld\n",list[j].name,list[j].phone);	
+	}
+  fclose(file);
+}  
+
+void Revise(){
+    char name[20];
+   unsigned long long phone;
+	printf("«Î ‰»Îƒ„“™–fi∏ƒ–≈œ¢µƒ¡™œµ»À√˚◊÷\n");
+		scanf("%s",name);
+	FILE* fole=fopen("people.txt","r");
+	 for(int k=0;k<200;k++){
+       fscanf(fole,"%s\n%lld\n",list[k].name,&list[k].phone);	
+	}
+	 fclose(fole);
+	 printf("«Î ‰»Î–¬µƒ¡™œµ»À√˚◊÷\n");
+	 char Name[20];
+      scanf("%s",Name);
+	  printf("«Î ‰»Î–¬µƒ¡™œµ»ÀµÁª∞∫≈¬Î\n");
+      scanf("%lld",&phone);
+	 for(int g=0;g<200;g++){
+		 if(strcmp(list[g].name,name)==0){
+			 strcpy(list[g].name,Name);
+			 list[g].phone=phone;
+			 printf("–fi∏ƒ¡™œµ»À–≈œ¢≥…π¶,∑µªÿ÷˜ΩÁ√Ê\n");
+			 break;
+		 }
+	 }
+    FILE* file=fopen("people.txt","w");
+	for(int j=0;j<200;j++){
+       fprintf(file,"%s\n%lld\n",list[j].name,list[j].phone);	
+	}
+  fclose(file);
+
+}
+
+void Delete(){
+	char name[20];
+   unsigned long long phone;
+	printf("«Î ‰»Îƒ„“™…æ≥˝–≈œ¢µƒ¡™œµ»À√˚◊÷");
+		scanf("%s",name);
+	FILE* fole=fopen("people.txt","r");
+	 for(int k=0;k<200;k++){
+       fscanf(fole,"%s\n%ld\n",list[k].name,&list[k].phone);	
+	}
+	 for(int i=0;i<200;i++){
+		 if(strcmp(list[i].name,name)==0){
+		 strcpy(list[i].name,"");
+		 list[i].phone=0;
+		 }
+	 }
+      FILE* file=fopen("people.txt","w");
+	for(int j=0;j<200;j++){
+       fprintf(file,"%s\n%lld\n",list[j].name,list[j].phone);	
+	}
+  fclose(file);
+}

example.dSYM/Contents/Info.plist

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+	<dict>
+		<key>CFBundleDevelopmentRegion</key>
+		<string>English</string>
+		<key>CFBundleIdentifier</key>
+		<string>com.apple.xcode.dsym.example</string>
+		<key>CFBundleInfoDictionaryVersion</key>
+		<string>6.0</string>
+		<key>CFBundlePackageType</key>
+		<string>dSYM</string>
+		<key>CFBundleSignature</key>
+		<string>????</string>
+		<key>CFBundleShortVersionString</key>
+		<string>1.0</string>
+		<key>CFBundleVersion</key>
+		<string>1</string>
+	</dict>
+</plist>

example.dSYM/Contents/Resources/Relocations/aarch64/example.yml

@@ -0,0 +1,12 @@
+---
+triple:          'arm64-apple-darwin'
+binary-path:     '/Users/hanzhangma/Document/leetcode/example'
+relocations:
+  - { offsetInCU: 0x26, offset: 0x26, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0x0, symBinAddr: 0x100003138, symSize: 0xD0 }
+  - { offsetInCU: 0x3F, offset: 0x3F, size: 0x8, addend: 0x0, symName: _list, symObjAddr: 0x2A58, symBinAddr: 0x100008000, symSize: 0x0 }
+  - { offsetInCU: 0x39D, offset: 0x39D, size: 0x8, addend: 0x0, symName: _main, symObjAddr: 0x0, symBinAddr: 0x100003138, symSize: 0xD0 }
+  - { offsetInCU: 0x3D3, offset: 0x3D3, size: 0x8, addend: 0x0, symName: __Z5Inputv, symObjAddr: 0xE4, symBinAddr: 0x10000321C, symSize: 0x238 }
+  - { offsetInCU: 0x479, offset: 0x479, size: 0x8, addend: 0x0, symName: __Z7Inquiryv, symObjAddr: 0x31C, symBinAddr: 0x100003454, symSize: 0x258 }
+  - { offsetInCU: 0x51F, offset: 0x51F, size: 0x8, addend: 0x0, symName: __Z6Revisev, symObjAddr: 0x574, symBinAddr: 0x1000036AC, symSize: 0x268 }
+  - { offsetInCU: 0x5D3, offset: 0x5D3, size: 0x8, addend: 0x0, symName: __Z6Deletev, symObjAddr: 0x7DC, symBinAddr: 0x100003914, symSize: 0x20C }
+...