— Dark mode

Putka Open 2020 – 4/5

Ruudukko

  • Start: 2020-11-06 18:00:00
  • End: 2020-11-08 23:00:00
CSES - Putka Open 2020 – 4/5 - Results
Submission details
Task:Ruudukko
Sender:Mahtimursu
Submission time:2023-05-30 00:36:17 +0300
Language:C++ (C++17)
Status:READY
Result:44
Feedback
groupverdictscore
#1ACCEPTED5
#2ACCEPTED12
#3ACCEPTED27
#40
#50
Test results
testverdicttimegroup
#1ACCEPTED0.00 s1, 5details
#2ACCEPTED0.00 s2, 5details
#3ACCEPTED0.00 s3, 5details
#4--4, 5details
#5ACCEPTED0.01 s5details
#6ACCEPTED0.01 s5details
#7ACCEPTED0.00 s2, 5details
#8ACCEPTED0.00 s2, 5details
#9ACCEPTED0.00 s3, 5details
#10ACCEPTED0.00 s3, 5details
#11ACCEPTED0.00 s3, 5details
#12ACCEPTED0.00 s3, 5details
#13ACCEPTED0.00 s4, 5details
#14--5details
#15ACCEPTED0.00 s3, 5details
#16ACCEPTED0.01 s5details

Compiler report

input/code.cpp: In function 'void solver_all::solve_mid_rev(int, int, int, int, std::pair<int, int>)':
input/code.cpp:631:9: warning: unused variable 'on' [-Wunused-variable]
  631 |     int on = n;
      |         ^~
input/code.cpp: In function 'void solve_mid_rev(int, int, int, int, std::pair<int, int>)':
input/code.cpp:1195:9: warning: unused variable 'on' [-Wunused-variable]
 1195 |     int on = n;
      |         ^~
input/code.cpp: In function 'void solver_all::solve_strip_hor(bool, int, int, std::pair<int, int>)':
input/code.cpp:367:5: warning: 'up' may be used uninitialized [-Wmaybe-uninitialized]
  367 |     if (up) {
      |     ^~
input/code.cpp: In function 'void solver_all::solve_strip_ver(bool, int, int, std::pair<int, int>)':
input/code.cpp:470:5: warning: 'left' may be used uninitialized [-Wmaybe-uninitialized]
  470 |     if (left) {
      |     ^~
input/code.cpp: In function 'void solve_strip_ver(bool, int, int, std::pair<int, int>)':
input/code.cpp:1104:5: warning: 'l...

Code

#include <bits/stdc++.h>

typedef long long ll;

#define y first
#define x second

using namespace std;

namespace solver_all {
    int s2 = 0;

const int MAX_N = 10000;

char result[MAX_N + 1][MAX_N + 1];

inline void st(char c, pair<int, int> pos, pair<int, int> offset) {
    result[pos.y + offset.y][pos.x + offset.x] = c;
}

inline char gt(pair<int, int> pos, pair<int, int> offset) {
    return result[pos.y + offset.y][pos.x + offset.x];
}

inline pair<int, int> step(char c, pair<int, int> pos) {
    if (c == 'U') return {pos.y - 1, pos.x};
    if (c == 'D') return {pos.y + 1, pos.x};
    if (c == 'R') return {pos.y, pos.x + 1};
    if (c == 'L') return {pos.y, pos.x - 1};
    return {0, 0};
}

inline char gt_rev(char c) {
    if (c == 'U') return 'D';
    if (c == 'D') return 'U';
    if (c == 'R') return 'L';
    if (c == 'L') return 'R';
    return '?';
}

void rev_from(pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    // s = start in the wrong order

    // means that pos[t] will be empty
    // but pos[s] should be empty

    char c = gt(s, offset);
    s = step(gt(s, offset), s);

    while (s != t) {
        char nxt = gt(s, offset);
        st(gt_rev(c), s, offset);
        c = nxt;
        s = step(nxt, s);
    }

    st(gt_rev(c), s, offset);
}

namespace mango {
    void solveSmall(int h, int w, int y0, int x0, int y1, int x1, pair<int, int> offset) {
        bool swp = 0;
        if (x0 > x1 || (x0 == x1 && y0 > y1)) {
            swp = 1;
            swap(x0, x1);
            swap(y0, y1);
        }
    
        if (h == 1) {
            if (x0 == 1 && x1 == w) {
                for (int i = 0; i < w - 1; ++i) {
                    if (!swp) {
                        st('R', {y0, x0}, offset);
                        offset.x++;
                    } else {
                        offset.x++;
                        st('L', {y0, x0}, offset);
                    }
                }
                return;
            }
            if (x0 == w && x1 == 1) {
                for (int i = 0; i < w - 1; ++i) {
                    if (!swp) {
                        st('L', {y0, x0}, offset);
                        offset.x--;
                    } else {
                        offset.x--;
                        st('R', {y0, x0}, offset);
                    }
                }
                return;
            }
        } else {    
            string res;
            if (x0 == x1 && x0 == 1) {
                for (int i = 0; i < w-1; ++i) {
                    if (!swp)
                        st('R', {y0, x0}, offset);
                    offset.x++;
                    if (swp)
                        st('L', {y0, x0}, offset);
                }
    
                if (y0 == 1) {
                    if (!swp)
                        st('D', {y0, x0}, offset);
                    offset.y++;
                    if (swp)
                        st('U', {y0, x0}, offset);
                }
                else {
                    if (!swp)
                        st('U', {y0, x0}, offset);
                    offset.y--;
                    if (swp)
                        st('D', {y0, x0}, offset);
                }
    
                for (int i = 0; i < w-1; ++i) {
                    if (!swp)
                        st('L', {y0, x0}, offset);
                    offset.x--;
                    if (swp)
                        st('R', {y0, x0}, offset);
                }
            } else {
                for (int i = 1; i < x0; ++i) {
                    if (!swp)
                        st('L', {y0, x0}, offset);
                    offset.x--;
                    if (swp)
                        st('R', {y0, x0}, offset);
                }
    
                if (y0 == 1) {
                    if (!swp)
                        st('D', {y0, x0}, offset);
                    offset.y++;
                    if (swp)
                        st('U', {y0, x0}, offset);
                }
                else {
                    if (!swp)
                        st('U', {y0, x0}, offset);
                    offset.y--;
                    if (swp)
                        st('D', {y0, x0}, offset);
                }
    
                for (int i = 1; i < x0; ++i) {
                    if (!swp)
                        st('R', {y0, x0}, offset);
                    offset.x++;
                    if (swp)
                        st('L', {y0, x0}, offset);
                }
    
                if (x0 == x1) return;
    
                for (int i = 1; i < x1 - x0; ++i) {
                    if (!swp)
                        st('R', {y0, x0}, offset);
                    offset.x++;
                    if (swp)
                        st('L', {y0, x0}, offset);

                    if (((i - 1) ^ (y0 - 1)) & 1) {
                        if (!swp)
                            st('D', {y0, x0}, offset);
                        offset.y++;
                        if (swp)
                            st('U', {y0, x0}, offset);
                    }
                    else {
                        if (!swp)
                            st('U', {y0, x0}, offset);
                        offset.y--;
                        if (swp)
                            st('D', {y0, x0}, offset);
                    }
                }
                if (!swp)
                    st('R', {y0, x0}, offset);
                offset.x++;
                if (swp)
                    st('L', {y0, x0}, offset);
    
                for (int i = 0; i < w - x1; ++i) {
                    if (!swp)
                        st('R', {y0, x0}, offset);
                    offset.x++;
                    if (swp)
                        st('L', {y0, x0}, offset);
                }
    
                if (y1 == 1) {
                    if (!swp)
                        st('U', {y0, x0}, offset);
                    offset.y--;
                    if (swp)
                        st('D', {y0, x0}, offset);
                }
                else {
                    if (!swp)
                        st('D', {y0, x0}, offset);
                    offset.y++;
                    if (swp)
                        st('U', {y0, x0}, offset);
                }
    
                for (int i = 0; i < w - x1; ++i) {
                    if (!swp)
                        st('L', {y0, x0}, offset);
                    offset.x--;
                    if (swp)
                        st('R', {y0, x0}, offset);
                }
            }    
        }
    }

    void solve2(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
        s2++;
        solveSmall(n, m, s.y, s.x, t.y, t.x, offset);
    }
};

bool check_small(int h, int w, int y0, int x0, int y1, int x1) {
	if (x0 > x1 || (x0 == x1 && y0 > y1)) return check_small(h, w, y1, x1, y0, x0);
 
	if (h == 1) {
		if (x0 == 0 && x1 == w-1) return true;
		if (x0 == w-1 && x1 == 0) return true;
		return false;
	} else {
		if (x0 == x1 && 0 < x0 && x0 < w-1) return false;
		return true;
	}
}

bool works(int h, int w, int y0, int x0, int y1, int x1) {
	if (y0 == y1 && x0 == x1) return false;
	if (w < h) return works(w, h, x0, y0, x1, y1);
	if (! ((h*w ^ abs(x0 - x1) ^ abs(y0 - y1)) & 1)) return false;
	if ((h*w & 1) && ((x0 + y0) & 1)) return false;
 
	if (h <= 2) return check_small(h, w, y0, x0, y1, x1);
	if (h == 3 && (!(w & 1))) {
		if (y0 == 1) {
			if ((x0 & 1) && x1 < x0) return false;
			if (!(x0 & 1) && x1 > x0) return false;
		} else {
			if (!(x0 & 1) && (x1 < x0 - 1)) return false;
			if ((x0 & 1) && (x1 > x0 + 1)) return false;
		}
	}   
	return true;
}

bool inside(int n, int m, pair<int, int> p) {
    return p.x <= m && p.y <= n && p.x > 0 && p.y > 0;
}

bool ok(int h, int w, pair<int, int> s, pair<int, int> t) {
    if (h == 0) return s.x == t.x;
    if (!inside(h, w, s) || !inside(h, w, t)) return false;
    return works(h, w, s.y - 1, s.x - 1, t.y - 1, t.x - 1);
}

pair<int, int> ot(pair<int, int> p, pair<int, int> off) {
    return {p.y + off.y, p.x + off.x};
}

const int cutoff = 20;

bool vis[MAX_N + 1][MAX_N + 1];

bool run_brute(int n, int m, pair<int, int> c, pair<int, int> t, int left, pair<int, int> offset) {
    if (c.x < 1 || c.x > m || c.y < 1 || c.y > n) return false;
    if (vis[c.y][c.x]) return false;
    if (left == 0) {
        if (c != t) return false;
        st('E', c, offset);
        return true;
    }

    vis[c.y][c.x] = 1;

    if (run_brute(n, m, {c.y - 1, c.x}, t, left - 1, offset)) {
        st('U', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y + 1, c.x}, t, left - 1, offset)) {
        st('D', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y, c.x - 1}, t, left - 1, offset)) {
        st('L', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y, c.x + 1}, t, left - 1, offset)) {
        st('R', c, offset);
        return true;
    }

    vis[c.y][c.x] = 0;
    return false;
}

int c = 0;

void brute(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    c++;

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) vis[i][j] = 0;
    }

    run_brute(n, m, s, t, n * m - 1, offset);
}

void solve_strip_hor(bool left, int n, int m, pair<int, int> offset) {
    int s_idx = 0;
    bool up;
    pair<int, int> cp;

    // cout << "here hor " << left << " " << n << " "  << m << " " << offset.y << " " << offset.x << endl; 

    if (left) {
        for (int i = 1; i <= n; ++i) {
            char c = gt({i, m + 1}, offset);
            if (c == 'D') {
                up = 1;
                s_idx = i;
                break;
            } else if (c == 'U') {
                up = 0;
                s_idx = i;
                break;
            }
        }

        st('L', {s_idx, m + 1}, offset);
        cp = {s_idx, m};
    } else {
        for (int i = 1; i <= n; ++i) {
            char c = gt({i, 0}, offset);
            if (c == 'D') {
                up = 1;
                s_idx = i;
                break;
            } else if (c == 'U') {
                up = 0;
                s_idx = i;
                break;
            }
        }

        st('R', {s_idx, 0}, offset);
        cp = {s_idx, 1};
    }

    if (up) {
        while (cp.y != 1) {
            st('U', cp, offset);
            cp.y--;
        }
    } else {
        while (cp.y != n) {
            st('D', cp, offset);
            cp.y++;
        }
    }

    if (left) {
        st('L', cp, offset);
        cp.x--;
    } else {
        st('R', cp, offset);
        cp.x++;
    }
    

    if (up) {
        while (cp.y != n) {
            st('D', cp, offset);
            cp.y++;
        }
    } else {
        while (cp.y != 1) {
            st('U', cp, offset);
            cp.y--;
        }
    }

    if (left) {
        st('R', cp, offset);
        cp.x++;
    } else {
        st('L', cp, offset);
        cp.x--;
    }

    if (up) {
        while (cp.y != s_idx + 1) {
            st('U', cp, offset);
            cp.y--;
        }
    } else {
        while (cp.y != s_idx - 1) {
            st('D', cp, offset);
            cp.y++;
        }
    }

    if (left) {
        st('R', cp, offset);
        cp.x++;
    } else {
        st('L', cp, offset);
        cp.x--;
    }
}

void solve_strip_ver(bool up, int n, int m, pair<int, int> offset) {
    int s_idx = 0;
    bool left;
    pair<int, int> cp;

    // cout << "here hor " << left << " " << n << " "  << m << " " << offset.y << " " << offset.x << endl; 

    if (up) {
        for (int i = 1; i <= m; ++i) {
            char c = gt({n + 1, i}, offset);
            if (c == 'R') {
                left = 1;
                s_idx = i;
                break;
            } else if (c == 'L') {
                left = 0;
                s_idx = i;
                break;
            }
        }

        st('U', {n + 1, s_idx}, offset);
        cp = {n, s_idx};
    } else {
        for (int i = 1; i <= m; ++i) {
            char c = gt({0, i}, offset);
            if (c == 'R') {
                left = 1;
                s_idx = i;
                break;
            } else if (c == 'L') {
                left = 0;
                s_idx = i;
                break;
            }
        }

        st('D', {0, s_idx}, offset);
        cp = {1, s_idx};
    }

    if (left) {
        while (cp.x != 1) {
            st('L', cp, offset);
            cp.x--;
        }
    } else {
        while (cp.x != m) {
            st('R', cp, offset);
            cp.x++;
        }
    }

    if (up) {
        st('U', cp, offset);
        cp.y--;
    } else {
        st('D', cp, offset);
        cp.y++;
    }
    

    if (left) {
        while (cp.x != m) {
            st('R', cp, offset);
            cp.x++;
        }
    } else {
        while (cp.x != 1) {
            st('L', cp, offset);
            cp.x--;
        }
    }

    if (up) {
        st('D', cp, offset);
        cp.y++;
    } else {
        st('U', cp, offset);
        cp.y--;
    }

    if (left) {
        while (cp.x != s_idx + 1) {
            st('L', cp, offset);
            cp.x--;
        }
    } else {
        while (cp.x != s_idx - 1) {
            st('R', cp, offset);
            cp.x++;
        }
    }

    if (up) {
        st('D', cp, offset);
        cp.y++;
    } else {
        st('U', cp, offset);
        cp.y--;
    }
}

void solve_m(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {  
    // cout << "here: " << n << " " << m << " " << s.y << " " << s.x << " " << t.y << " " << t.x << endl;
    int min_j = min(s.x, t.x);
    int max_j = max(s.x, t.x);

    /*for (int j = min_j - min_j % 2; j > 0; j -= 2) {*/
    for (int j = 2; j > 0; j -= 2) {
        if (min_j > j) {
            if (ok(n, m - j, ot(s, {0, -j}), ot(t, {0, -j}))) {
                solve_m(n, m - j, ot(s, {0, -j}), ot(t, {0, -j}), ot(offset, {0, j}));

                solve_strip_hor(true, n, j, offset);
                return;
            }
        }
    }
    
    /*for (int j = (m - max_j) / 2 * 2; j > 0; j -= 2) {*/
    for (int j = 2; j > 0; j -= 2) {
        if (max_j <= m - j) {
            if (ok(n, m - j, s, t)) {
                solve_m(n, m - j, s, t, offset);

                solve_strip_hor(false, n, j, ot(offset, {0, m - j}));
                return;
            }
        }
    }

    if (s.x > t.x) {
        // cout << "reversed: " << s.y << " " << s.x << " " << t.y << " " << t.x << endl;
        char c = gt(t, offset);
        solve_m(n, m, t, s, offset);
        rev_from(t, s, offset);
        st(c, t, offset);
        return;
    }
    

    vector<int> st_i;
    st_i.push_back(1);
    st_i.push_back(2);
    
    if (n % 2 == 0) st_i.push_back(n);
    else st_i.push_back(n - 1);
    for (int i : st_i) {
        int first_m = 2;
        int second_m = m - 2;

        pair<int, int> first_e = {i, first_m};
        pair<int, int> second_e = {i, first_m + 1};

        if (inside(n, first_m, s) 
            && inside(n, second_m, ot(t, {0, -first_m}))
            && ok(n, first_m, s, first_e) 
            && ok(n, second_m, ot(t, {0, -first_m}), ot(second_e, {0, -first_m}))
        ) { 
            solve_m(n, first_m, s, first_e, offset);
            st('R', first_e, offset);
            solve_m(n, second_m, ot(second_e, {0, -first_m}), ot(t, {0, -first_m}), ot(offset, {0, first_m}));
            return;
        }
    }

    brute(n, m, s, t, offset);
}

int ckmid = 0;
int ckmidloop = 0;

void solve_mid(int n, int m, int j1, int j2, pair<int, int> offset) {
    while (n > 2) {
        ckmidloop++;
        if (n * m <= cutoff) {
            brute(n, m, {1, j1}, {n, j2}, offset);
            return;
        }
        for (int j = 2 - (j1 % 2); j <= m; j += 2) {
            ckmid++;
            if (j == j1 && j1 != 1 && j1 != m) continue;
            if (ok(n - 2, m, {1, j}, {n - 2, j2})) {
                mango::solve2(2, m, {1, j1}, {2, j}, offset);
                offset.y += 2;
                j1 = j; 
                break;
            }
        }

        st('D', {0, j1}, offset);
        n -= 2;
    }

    mango::solve2(2, m, {1, j1}, {2, j2}, offset);
}

void solve_mid_rev(int n, int m, int j1, int j2, pair<int, int> offset) {
    // {n, j2} -> {1, j1}
    //cout << "called: " << n << " " << m << " " << j1 << " " << j2 << " " << offset.y << " " << offset.x << endl;

    int on = n;

    while (n > 2) {
        ckmidloop++;
        if (n * m <= cutoff) {
            brute(n, m, {n, j2}, {1, j1}, offset);
            return;
        }
        for (int j = 2 - (j2 % 2); j <= m; j += 2) {
            ckmid++;
            if (j == j2 && j2 != 1 && j2 != m) continue;
            if (ok(n - 2, m, {n - 2, j}, {1, j1})) {
                mango::solve2(2, m, {2, j2}, {1, j}, ot(offset, {n - 2, 0}));
                st('U', {1, j}, ot(offset, {n - 2, 0}));
                j2 = j; 
                break;
            }
        }

        n -= 2;
    }

    mango::solve2(2, m, {2, j2}, {1, j1}, offset);

    /*for (int i = 1; i <= on + 1; ++i) {
        for (int j = 1; j <= m; ++j) {
            cout << gt({i, j}, offset);
        }
        cout << endl;
    }
    cout << "END\n";*/
}

int scc = 0;
int chc = 0;

void solve(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    scc++;
    if (n <= 2) {
        mango::solve2(n, m, s, t, offset);
        return;
    }

    int min_i = min(s.y, t.y);
    int max_i = max(s.y, t.y);

    /*for (int i = min_i - min_i % 2; i > 0; i -= 2) {*/
    for (int i = 2; i > 0; i -= 2) {
        if (min_i > i) {
            if (ok(n - i, m, ot(s, {-i, 0}), ot(t, {-i, 0}))) {
                solve(n - i, m, ot(s, {-i, 0}), ot(t, {-i, 0}), ot(offset, {i, 0}));

                solve_strip_ver(true, i, m, offset);
                return;
            }
        }
    }

    /*for (int i = (n - max_i) / 2 * 2; i > 0; i -= 2) {*/
    for (int i = 2; i > 0; i -= 2) {
        if (max_i <= n - i) {
            if (ok(n - i, m, s, t)) {
                solve(n - i, m, s, t, offset);

                solve_strip_ver(false, i, m, ot(offset, {n - i, 0}));
                return;
            }
        }
    }

    if (n <= 3 || max_i <= 2 || min_i > 2) {
        solve_m(n, m, s, t, offset);
        return;
    }

    if (s > t) {
        int left_n = 2;
        int right_n = 2 + (n % 2);

        int mid = n - left_n - right_n;

        int color = (t.x + t.y) % 2;

        for (int j1 = 1 + color; j1 <= m; j1 += 2) {
            for (int j2 = 1 + color; j2 <= m; j2 += 2) {
                chc++;
                pair<int, int> first_e = {left_n, j1};
                pair<int, int> second_e = {1, j2};

                if (mid == 0 && j1 != j2) continue;
                if (mid == 2 && j1 == j2 && j1 != 1 && j1 != m) continue;

                if (ok(left_n, m, first_e, t) 
                    && ok(right_n, m, ot(s, {-(left_n + mid), 0}), second_e)
                ) {
                    solve_m(right_n, m, ot(s, {-(left_n + mid), 0}), second_e, ot(offset, {left_n + mid, 0})); 
                    st('U', second_e, ot(offset, {left_n + mid, 0}));
                    if (mid != 0) {
                        solve_mid_rev(mid, m, j1, j2, ot(offset, {2, 0}));
                        st('U', {1, j1}, ot(offset, {2, 0}));
                    }
                    mango::solve2(left_n, m, first_e, t, offset);                           
                    return;
                }
            }
        }

        solve_m(n, m, s, t, offset);
        return;
    }

    int left_n = 2;
    int right_n = 2 + (n % 2);

    int mid = n - left_n - right_n;

    int color =  (s.x + s.y) % 2;

    for (int j1 = 1 + color; j1 <= m; j1 += 2) {
        for (int j2 = 1 + color; j2 <= m; j2 += 2) {
            chc++;
            pair<int, int> first_e = {left_n, j1};
            pair<int, int> second_e = {1, j2};

            if (mid == 0 && j1 != j2) continue;
            if (mid == 2 && j1 == j2 && j1 != 1 && j1 != m) continue;

            if (ok(left_n, m, s, first_e) 
                && ok(right_n, m, second_e, ot(t, {-(left_n + mid), 0}))
            ) {
                mango::solve2(left_n, m, s, first_e, offset);
                st('D', first_e, offset);
                if (mid != 0) {
                    solve_mid(mid, m, j1, j2, ot(offset, {2, 0}));
                    st('D', {mid, j2}, ot(offset, {2, 0}));
                }
                solve_m(right_n, m, second_e, ot(t, {-(left_n + mid), 0}), ot(offset, {left_n + mid, 0}));        
                return;
            }
        }
    }

    solve_m(n, m, s, t, offset);
}
}

int s2 = 0;

const int MAX_N = 10000;

char result[MAX_N + 1][MAX_N + 1];

inline void st(char c, pair<int, int> pos, pair<int, int> offset) {
    result[pos.y + offset.y][pos.x + offset.x] = c;
}

inline char gt(pair<int, int> pos, pair<int, int> offset) {
    return result[pos.y + offset.y][pos.x + offset.x];
}

inline pair<int, int> step(char c, pair<int, int> pos) {
    if (c == 'U') return {pos.y - 1, pos.x};
    if (c == 'D') return {pos.y + 1, pos.x};
    if (c == 'R') return {pos.y, pos.x + 1};
    if (c == 'L') return {pos.y, pos.x - 1};
    return {0, 0};
}

inline char gt_rev(char c) {
    if (c == 'U') return 'D';
    if (c == 'D') return 'U';
    if (c == 'R') return 'L';
    if (c == 'L') return 'R';
    return '?';
}

void rev_from(pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    // s = start in the wrong order

    // means that pos[t] will be empty
    // but pos[s] should be empty

    char c = gt(s, offset);
    s = step(gt(s, offset), s);

    while (s != t) {
        char nxt = gt(s, offset);
        st(gt_rev(c), s, offset);
        c = nxt;
        s = step(nxt, s);
    }

    st(gt_rev(c), s, offset);
}

namespace mango {
    void solveSmall(int h, int w, int y0, int x0, int y1, int x1, pair<int, int> offset) {
        bool swp = 0;
        if (x0 > x1 || (x0 == x1 && y0 > y1)) {
            swp = 1;
            swap(x0, x1);
            swap(y0, y1);
        }
      
        string res;
        if (x0 == x1 && x0 == 1) {
            for (int i = 0; i < w-1; ++i) {
                if (!swp)
                    st('R', {y0, x0}, offset);
                offset.x++;
                if (swp)
                    st('L', {y0, x0}, offset);
            }

            if (y0 == 1) {
                if (!swp)
                    st('D', {y0, x0}, offset);
                offset.y++;
                if (swp)
                    st('U', {y0, x0}, offset);
            }
            else {
                if (!swp)
                    st('U', {y0, x0}, offset);
                offset.y--;
                if (swp)
                    st('D', {y0, x0}, offset);
            }

            for (int i = 0; i < w-1; ++i) {
                if (!swp)
                    st('L', {y0, x0}, offset);
                offset.x--;
                if (swp)
                    st('R', {y0, x0}, offset);
            }
        } else {
            for (int i = 1; i < x0; ++i) {
                if (!swp)
                    st('L', {y0, x0}, offset);
                offset.x--;
                if (swp)
                    st('R', {y0, x0}, offset);
            }

            if (y0 == 1) {
                if (!swp)
                    st('D', {y0, x0}, offset);
                offset.y++;
                if (swp)
                    st('U', {y0, x0}, offset);
            }
            else {
                if (!swp)
                    st('U', {y0, x0}, offset);
                offset.y--;
                if (swp)
                    st('D', {y0, x0}, offset);
            }

            for (int i = 1; i < x0; ++i) {
                if (!swp)
                    st('R', {y0, x0}, offset);
                offset.x++;
                if (swp)
                    st('L', {y0, x0}, offset);
            }

            if (x0 == x1) return;

            for (int i = 1; i < x1 - x0; ++i) {
                if (!swp)
                    st('R', {y0, x0}, offset);
                offset.x++;
                if (swp)
                    st('L', {y0, x0}, offset);

                if (((i - 1) ^ (y0 - 1)) & 1) {
                    if (!swp)
                        st('D', {y0, x0}, offset);
                    offset.y++;
                    if (swp)
                        st('U', {y0, x0}, offset);
                }
                else {
                    if (!swp)
                        st('U', {y0, x0}, offset);
                    offset.y--;
                    if (swp)
                        st('D', {y0, x0}, offset);
                }
            }
            if (!swp)
                st('R', {y0, x0}, offset);
            offset.x++;
            if (swp)
                st('L', {y0, x0}, offset);

            for (int i = 0; i < w - x1; ++i) {
                if (!swp)
                    st('R', {y0, x0}, offset);
                offset.x++;
                if (swp)
                    st('L', {y0, x0}, offset);
            }

            if (y1 == 1) {
                if (!swp)
                    st('U', {y0, x0}, offset);
                offset.y--;
                if (swp)
                    st('D', {y0, x0}, offset);
            }
            else {
                if (!swp)
                    st('D', {y0, x0}, offset);
                offset.y++;
                if (swp)
                    st('U', {y0, x0}, offset);
            }

            for (int i = 0; i < w - x1; ++i) {
                if (!swp)
                    st('L', {y0, x0}, offset);
                offset.x--;
                if (swp)
                    st('R', {y0, x0}, offset);
            }
        }    
    }

    void solve2(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
        s2++;
        solveSmall(n, m, s.y, s.x, t.y, t.x, offset);
    }
};

bool check_small(int h, int w, int y0, int x0, int y1, int x1) {
	if (x0 > x1 || (x0 == x1 && y0 > y1)) return check_small(h, w, y1, x1, y0, x0);
 
	if (h == 1) {
		if (x0 == 0 && x1 == w-1) return true;
		if (x0 == w-1 && x1 == 0) return true;
		return false;
	} else {
		if (x0 == x1 && 0 < x0 && x0 < w-1) return false;
		return true;
	}
}

bool works(int h, int w, int y0, int x0, int y1, int x1) {
	if (y0 == y1 && x0 == x1) return false;
	if (w < h) return works(w, h, x0, y0, x1, y1);
	if (! ((h*w ^ abs(x0 - x1) ^ abs(y0 - y1)) & 1)) return false;
	if ((h*w & 1) && ((x0 + y0) & 1)) return false;
 
	if (h <= 2) return check_small(h, w, y0, x0, y1, x1);
	if (h == 3 && (!(w & 1))) {
		if (y0 == 1) {
			if ((x0 & 1) && x1 < x0) return false;
			if (!(x0 & 1) && x1 > x0) return false;
		} else {
			if (!(x0 & 1) && (x1 < x0 - 1)) return false;
			if ((x0 & 1) && (x1 > x0 + 1)) return false;
		}
	}   
	return true;
}

bool inside(int n, int m, pair<int, int> p) {
    return p.x <= m && p.y <= n && p.x > 0 && p.y > 0;
}

bool ok(int h, int w, pair<int, int> s, pair<int, int> t) {
    if (h == 0) return s.x == t.x;
    if (!inside(h, w, s) || !inside(h, w, t)) return false;
    return works(h, w, s.y - 1, s.x - 1, t.y - 1, t.x - 1);
}

pair<int, int> ot(pair<int, int> p, pair<int, int> off) {
    return {p.y + off.y, p.x + off.x};
}

const int cutoff = 20;

bool vis[MAX_N + 1][MAX_N + 1];

bool run_brute(int n, int m, pair<int, int> c, pair<int, int> t, int left, pair<int, int> offset) {
    if (c.x < 1 || c.x > m || c.y < 1 || c.y > n) return false;
    if (vis[c.y][c.x]) return false;
    if (left == 0) {
        if (c != t) return false;
        st('E', c, offset);
        return true;
    }

    vis[c.y][c.x] = 1;

    if (run_brute(n, m, {c.y - 1, c.x}, t, left - 1, offset)) {
        st('U', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y + 1, c.x}, t, left - 1, offset)) {
        st('D', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y, c.x - 1}, t, left - 1, offset)) {
        st('L', c, offset);
        return true;
    }

    if (run_brute(n, m, {c.y, c.x + 1}, t, left - 1, offset)) {
        st('R', c, offset);
        return true;
    }

    vis[c.y][c.x] = 0;
    return false;
}

int c = 0;

void brute(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    c++;

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) vis[i][j] = 0;
    }

    run_brute(n, m, s, t, n * m - 1, offset);
}

void solve_strip_ver(bool up, int n, int m, pair<int, int> offset) {
    int s_idx = 0;
    bool left;
    pair<int, int> cp;

    if (up) {
        for (int i = 1; i <= m; ++i) {
            char c = gt({n + 1, i}, offset);
            if (c == 'R') {
                left = 1;
                s_idx = i;
                break;
            } else if (c == 'L') {
                left = 0;
                s_idx = i;
                break;
            }
        }

        st('U', {n + 1, s_idx}, offset);
        cp = {n, s_idx};
    } else {
        for (int i = 1; i <= m; ++i) {
            char c = gt({0, i}, offset);
            if (c == 'R') {
                left = 1;
                s_idx = i;
                break;
            } else if (c == 'L') {
                left = 0;
                s_idx = i;
                break;
            }
        }

        st('D', {0, s_idx}, offset);
        cp = {1, s_idx};
    }

    if (left) {
        while (cp.x != 1) {
            st('L', cp, offset);
            cp.x--;
        }
    } else {
        while (cp.x != m) {
            st('R', cp, offset);
            cp.x++;
        }
    }

    if (up) {
        st('U', cp, offset);
        cp.y--;
    } else {
        st('D', cp, offset);
        cp.y++;
    }
    

    if (left) {
        while (cp.x != m) {
            st('R', cp, offset);
            cp.x++;
        }
    } else {
        while (cp.x != 1) {
            st('L', cp, offset);
            cp.x--;
        }
    }

    if (up) {
        st('D', cp, offset);
        cp.y++;
    } else {
        st('U', cp, offset);
        cp.y--;
    }

    if (left) {
        while (cp.x != s_idx + 1) {
            st('L', cp, offset);
            cp.x--;
        }
    } else {
        while (cp.x != s_idx - 1) {
            st('R', cp, offset);
            cp.x++;
        }
    }

    if (up) {
        st('D', cp, offset);
        cp.y++;
    } else {
        st('U', cp, offset);
        cp.y--;
    }
}

int ckmid = 0;
int ckmidloop = 0;

void solve_mid(int n, int m, int j1, int j2, pair<int, int> offset) {
    while (n > 2) {
        ckmidloop++;
        if (n * m <= cutoff) {
            brute(n, m, {1, j1}, {n, j2}, offset);
            return;
        }
        for (int j = 2 - (j1 % 2); j <= m; j += 2) {
            ckmid++;
            if (j == j1 && j1 != 1 && j1 != m) continue;
            if (ok(n - 2, m, {1, j}, {n - 2, j2})) {
                mango::solve2(2, m, {1, j1}, {2, j}, offset);
                offset.y += 2;
                j1 = j; 
                break;
            }
        }

        st('D', {0, j1}, offset);
        n -= 2;
    }

    mango::solve2(2, m, {1, j1}, {2, j2}, offset);
}

void solve_mid_rev(int n, int m, int j1, int j2, pair<int, int> offset) {
    int on = n;

    while (n > 2) {
        ckmidloop++;
        if (n * m <= cutoff) {
            brute(n, m, {n, j2}, {1, j1}, offset);
            return;
        }
        for (int j = 2 - (j2 % 2); j <= m; j += 2) {
            ckmid++;
            if (j == j2 && j2 != 1 && j2 != m) continue;
            if (ok(n - 2, m, {n - 2, j}, {1, j1})) {
                mango::solve2(2, m, {2, j2}, {1, j}, ot(offset, {n - 2, 0}));
                st('U', {1, j}, ot(offset, {n - 2, 0}));
                j2 = j; 
                break;
            }
        }

        n -= 2;
    }

    mango::solve2(2, m, {2, j2}, {1, j1}, offset);
}

int scc = 0;
int chc = 0;

void solve(int n, int m, pair<int, int> s, pair<int, int> t, pair<int, int> offset) {
    scc++;
    if (n <= 2) {
        mango::solve2(n, m, s, t, offset);
        return;
    }

    int min_i = min(s.y, t.y);
    int max_i = max(s.y, t.y);

    /*for (int i = min_i - min_i % 2; i > 0; i -= 2) {*/
    for (int i = 2; i > 0; i -= 2) {
        if (min_i > i) {
            if (ok(n - i, m, ot(s, {-i, 0}), ot(t, {-i, 0}))) {
                solve(n - i, m, ot(s, {-i, 0}), ot(t, {-i, 0}), ot(offset, {i, 0}));

                solve_strip_ver(true, i, m, offset);
                return;
            }
        }
    }

    /*for (int i = (n - max_i) / 2 * 2; i > 0; i -= 2) {*/
    for (int i = 2; i > 0; i -= 2) {
        if (max_i <= n - i) {
            if (ok(n - i, m, s, t)) {
                solve(n - i, m, s, t, offset);

                solve_strip_ver(false, i, m, ot(offset, {n - i, 0}));
                return;
            }
        }
    }

    if (n <= 3 || max_i <= 2 || min_i > 2) {
        brute(n, m, s, t, offset);
        return;
    }

    if (s > t) {
        int left_n = 2;
        int right_n = 2;

        int mid = n - left_n - right_n;

        int color = (t.x + t.y) % 2;

        for (int j1 = 1 + color; j1 <= m; j1 += 2) {
            for (int j2 = 1 + color; j2 <= m; j2 += 2) {
                chc++;
                pair<int, int> first_e = {left_n, j1};
                pair<int, int> second_e = {1, j2};

                if (mid == 0 && j1 != j2) continue;
                if (mid == 2 && j1 == j2 && j1 != 1 && j1 != m) continue;

                if (ok(left_n, m, first_e, t) 
                    && ok(right_n, m, ot(s, {-(left_n + mid), 0}), second_e)
                ) {
                    mango::solve2(right_n, m, ot(s, {-(left_n + mid), 0}), second_e, ot(offset, {left_n + mid, 0})); 
                    st('U', second_e, ot(offset, {left_n + mid, 0}));
                    if (mid != 0) {
                        solve_mid_rev(mid, m, j1, j2, ot(offset, {2, 0}));
                        st('U', {1, j1}, ot(offset, {2, 0}));
                    }
                    mango::solve2(left_n, m, first_e, t, offset);                           
                    return;
                }
            }
        }
        return;
    }

    int left_n = 2;
    int right_n = 2;

    int mid = n - left_n - right_n;

    int color =  (s.x + s.y) % 2;

    for (int j1 = 1 + color; j1 <= m; j1 += 2) {
        for (int j2 = 1 + color; j2 <= m; j2 += 2) {
            chc++;
            pair<int, int> first_e = {left_n, j1};
            pair<int, int> second_e = {1, j2};

            if (mid == 0 && j1 != j2) continue;
            if (mid == 2 && j1 == j2 && j1 != 1 && j1 != m) continue;

            if (ok(left_n, m, s, first_e) 
                && ok(right_n, m, second_e, ot(t, {-(left_n + mid), 0}))
            ) {
                mango::solve2(left_n, m, s, first_e, offset);
                st('D', first_e, offset);
                if (mid != 0) {
                    solve_mid(mid, m, j1, j2, ot(offset, {2, 0}));
                    st('D', {mid, j2}, ot(offset, {2, 0}));
                }
                mango::solve2(right_n, m, second_e, ot(t, {-(left_n + mid), 0}), ot(offset, {left_n + mid, 0}));        
                return;
            }
        }
    }
}

void test_case() {
    int n, m;
    pair<int, int> s, t;

    cin >> n >> m >> s.y >> s.x >> t.y >> t.x;

    if (!ok(n, m, s, t)) {
        cout << "NO" << "\n";
        return;
    }

    cout << "YES" << "\n";

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j <= m; ++j) {
            result[i][j] = '?';
        }
    }

    // ignore odd
    if (n & 1) {
        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= m; ++j) {
                solver_all::result[i][j] = '?';
            }
        }
        solver_all::solve(n, m, s, t, {0, 0});
        for (int i = 1; i < n * m; ++i) {
            char c = solver_all::result[s.y][s.x];
            cout << c;
            s = step(c, s);
        }
        cout << "\n";
        return;
    }

    solve(n, m, s, t, {0, 0});

    for (int i = 1; i < n * m; ++i) {
        char c = result[s.y][s.x];
        cout << c;
        s = step(c, s);
    }
    cout << "\n";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
    cin >> t;
    for (int i = 0; i < t; ++i) {
        test_case();
    }

    return 0;
}

Test details

Test 1

Group: 1, 5

Verdict: ACCEPTED

input
100
1 45 1 45 1 1
1 18 1 1 1 10
1 47 1 17 1 30
1 33 1 28 1 20
...
view save

correct output
YES
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL...
view save

user output
YES
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLL...
Truncated

Test 2

Group: 2, 5

Verdict: ACCEPTED

input
100
2 43 1 33 1 21
2 2 1 1 2 2
2 32 1 1 2 8
2 14 1 12 1 14
...
view save

correct output
NO
NO
NO
NO
YES
...
view save

user output
NO
NO
NO
NO
YES
...
Truncated

Test 3

Group: 3, 5

Verdict: ACCEPTED

input
100
3 4 2 1 2 4
3 38 2 24 1 22
3 29 2 23 2 3
3 8 3 1 1 2
...
view save

correct output
NO
NO
NO
YES
RRRRRRRUULDLULDLULDLLUR
...
view save

user output
NO
NO
NO
YES
RRRURDRURDRUULLLLLDLLUR
...
Truncated

Test 4

Group: 4, 5

Verdict:

input
100
4 25 2 19 1 5
4 13 3 10 4 12
4 7 3 1 4 2
4 23 1 19 2 5
...
view save

correct output
YES
DDRRRRRRULLLLLURRRRRULLLLLLLDD...
view save

user output
(empty)

Test 5

Group: 5

Verdict: ACCEPTED

input
100
16 8 13 1 14 8
41 21 19 11 32 12
46 17 13 7 6 11
8 41 4 32 4 12
...
view save

correct output
NO
YES
LURULURULURULURULURRDDDDDDDDDR...
view save

user output
NO
YES
RRRRRRRRRRDLLLLLLLLLLLULDLULDL...
Truncated

Test 6

Group: 5

Verdict: ACCEPTED

input
100
31 38 18 35 31 37
35 48 7 13 21 21
46 21 25 2 4 19
35 2 13 2 35 1
...
view save

correct output
YES
LLLLLLLLLLLLDRRRRRRRRRRRRDLLLL...
view save

user output
YES
RRRULLLLDLULDLULDLULDLULDLULDL...
Truncated

Test 7

Group: 2, 5

Verdict: ACCEPTED

input
100
2 4 1 3 1 4
2 4 2 2 1 1
2 4 2 3 1 2
2 4 2 3 1 4
...
view save

correct output
YES
LLDRRRU
NO
NO
NO
...
view save

user output
YES
LLDRRRU
NO
NO
NO
...
Truncated

Test 8

Group: 2, 5

Verdict: ACCEPTED

input
100
2 5 1 2 2 4
2 5 1 2 1 1
2 5 2 1 1 2
2 5 1 1 1 5
...
view save

correct output
YES
LDRRURRDL
YES
RRRDLLLLU
NO
...
view save

user output
YES
LDRRURRDL
YES
RRRDLLLLU
NO
...
Truncated

Test 9

Group: 3, 5

Verdict: ACCEPTED

input
100
3 4 1 1 2 3
3 4 2 4 3 2
3 4 2 1 3 1
3 4 1 4 3 4
...
view save

correct output
YES
DDRRRUULLDR
NO
YES
URRRDDLULDL
...
view save

user output
YES
DDRUURRDDLU
NO
YES
URRRDDLULDL
...
Truncated

Test 10

Group: 3, 5

Verdict: ACCEPTED

input
100
3 5 3 4 3 2
3 5 3 5 2 3
3 5 3 1 2 2
3 5 3 1 3 2
...
view save

correct output
NO
NO
YES
UURRRRDDLULDLU
NO
...
view save

user output
NO
NO
YES
UURRRRDDLULDLU
NO
...
Truncated

Test 11

Group: 3, 5

Verdict: ACCEPTED

input
100
3 8 2 8 1 2
3 8 2 4 1 7
3 8 3 4 2 7
3 8 2 5 3 1
...
view save

correct output
NO
NO
NO
YES
LLLDRRRRURDRUULLLLLLLDD
...
view save

user output
NO
NO
NO
YES
DRURDRUULLLLDDLUULLDRDL
...
Truncated

Test 12

Group: 3, 5

Verdict: ACCEPTED

input
100
3 9 1 3 2 9
3 9 1 6 1 5
3 9 3 6 2 8
3 9 3 2 3 4
...
view save

correct output
NO
NO
NO
NO
NO
...
view save

user output
NO
NO
NO
NO
NO
...
Truncated

Test 13

Group: 4, 5

Verdict: ACCEPTED

input
100
4 4 2 2 1 4
4 4 4 1 2 2
4 4 2 1 4 3
4 4 3 1 3 3
...
view save

correct output
YES
DDLUUURRDDDRUUU
YES
UUURRRDLDRDLLUU
NO
...
view save

user output
YES
DRRDLLLUUURRDRU
YES
RRRULLLUURRRDLL
NO
...
Truncated

Test 14

Group: 5

Verdict:

input
100
12 27 6 22 1 8
6 25 3 2 4 4
6 16 4 6 5 2
36 33 8 6 1 6
...
view save

correct output
YES
DLDDDDDRUUUURDDDDRUURDDRRULURU...
view save

user output
(empty)

Test 15

Group: 3, 5

Verdict: ACCEPTED

input
100
3 12 3 5 1 4
3 20 3 19 2 19
3 34 3 9 2 9
3 38 2 15 3 15
...
view save

correct output
YES
RRRRRRRUULDLULDLULDLULDLDLULDL...
view save

user output
YES
RURDRURDRURDRUULLLLLLLDLDLULDL...
Truncated

Test 16

Group: 5

Verdict: ACCEPTED

input
100
50 50 29 1 16 21
50 50 37 5 23 48
50 50 32 22 45 24
50 50 6 28 12 37
...
view save

correct output
YES
DDDDDDDDDDDDDDDDDDDDDRUUUUUUUU...
view save

user output
YES
DDDDDDDDDDDDDDDDDDDDDRRRRRRRRR...
Truncated

Tasks

A Neliöt-B Peli-C Tekijät-D Ruudukko-

Submissions (Mahtimursu)

2023-05-30 00:38:05 1002023-05-30 00:36:17 442023-05-30 00:34:00 1002023-05-30 00:32:46 1002023-05-30 00:31:42 452023-05-15 00:48:24 1002023-05-15 00:33:39 722023-05-15 00:31:16 722023-05-15 00:30:40 442023-05-15 00:29:30 2023-05-14 21:31:15 1002023-05-14 21:30:33 722023-05-14 21:29:47 722023-05-14 21:23:52 1002023-05-14 21:08:19 1002023-05-14 20:59:45 442023-05-14 20:59:13 1002023-05-14 20:43:01 1002023-05-14 18:55:04 1002023-05-09 02:07:35 1002023-05-09 01:46:50 1002023-05-09 01:46:21 02023-05-09 01:40:51 1002023-05-09 00:57:19 172023-05-09 00:54:07 52023-05-09 00:34:49 52023-05-04 23:52:48 1002023-05-04 23:52:02 1002023-05-04 23:51:22 442023-05-04 23:50:35 442023-05-04 23:49:30 442023-05-04 23:46:44 1002023-05-04 23:44:09 442023-05-04 23:41:34 1002023-04-26 21:27:02 1002023-04-26 21:22:19 1002023-04-25 16:55:53 1002023-04-25 16:52:52 1002023-04-25 16:51:57 1002023-04-12 20:32:48 1002023-04-12 20:23:49 1002023-04-12 20:20:21 1002023-04-12 02:32:30 1002023-04-12 02:29:58 1002023-04-12 02:27:58 1002023-04-12 02:27:16 1002023-04-12 02:26:20 722023-04-12 02:25:21 722023-04-12 02:11:27 722023-04-07 14:18:25 1002023-04-07 14:17:16 1002023-04-07 14:15:49 1002023-04-07 14:13:50 1002023-04-05 18:32:52 1002023-04-05 18:31:13 1002023-04-05 18:28:50 722023-04-05 18:28:38 172023-04-05 18:18:57 722023-04-05 18:17:14 722023-04-05 18:16:24 722023-04-05 18:14:57 172023-04-05 18:09:14 722023-04-05 18:08:52 1002023-04-05 18:07:02 1002023-04-05 18:06:17 52023-04-05 18:04:25 52023-03-23 18:50:28 1002023-03-23 18:50:02 722023-03-21 18:36:36 1002023-03-21 18:35:07 722023-03-21 18:34:32 1002023-03-21 18:32:15 1002023-03-21 18:21:28 1002023-03-21 18:21:11 442023-03-21 18:20:08 722023-03-21 18:19:40 1002023-03-21 18:19:21 1002023-03-21 18:10:59 442023-03-21 17:59:57 442023-03-21 17:52:46 442023-03-21 00:46:49 02023-03-21 00:44:46 02023-03-21 00:44:33 02023-03-21 00:44:00 02023-03-21 00:43:00 02023-03-21 00:41:06 02023-03-21 00:40:14 02023-03-21 00:14:25 1002023-03-21 00:14:06 1002023-03-21 00:09:45 1002023-03-21 00:09:30 02023-03-21 00:06:28 722023-03-21 00:03:45 1002023-03-21 00:02:41 172023-03-21 00:02:13 172023-03-20 23:59:01 1002023-03-20 23:46:38 1002023-03-20 23:37:32 1002023-03-20 23:37:05 722023-03-20 23:29:42 1002023-03-17 23:56:27 1002023-03-17 23:21:38 1002023-03-17 23:14:29 52023-03-17 23:14:14 322023-03-17 23:13:20 52023-03-17 23:12:51 02023-03-17 23:11:51 02023-03-17 23:09:25 52023-03-17 23:08:53 52023-03-17 23:04:27 322023-03-17 00:14:08 1002023-03-17 00:12:07 1002023-03-17 00:11:35 52023-03-17 00:06:20 52023-03-17 00:03:32 02023-03-16 23:56:49 1002023-03-16 23:53:34 1002023-03-16 23:40:59 1002023-03-16 23:40:29 1002023-03-16 23:32:36 1002023-03-16 23:15:46 1002023-03-16 23:12:05 1002023-03-16 23:08:53 1002023-03-16 23:06:44 722023-03-16 23:05:33 1002023-03-16 22:50:31 452023-03-16 22:50:00 722023-03-11 14:57:05 1002023-03-11 14:54:27 1002023-03-11 14:52:10 722023-03-11 14:45:42 52023-03-11 14:33:10 172023-03-11 03:50:23 172023-03-11 03:50:09 52023-03-11 03:42:21 172023-03-11 03:37:38 172023-03-11 02:58:50 172023-03-11 02:57:20 172023-03-11 01:01:08 172023-03-11 00:53:52 52023-03-11 00:53:37 52023-03-11 00:46:39 02023-03-11 00:43:24 52023-03-11 00:37:20 52023-03-11 00:30:32 52023-03-11 00:25:39 02023-03-11 00:24:52 02023-03-11 00:05:37 02023-03-11 00:01:20 02023-03-10 23:52:27 02023-03-10 23:45:01 02023-03-10 23:42:31 02023-03-10 23:41:30 02023-03-10 23:41:14 02023-03-10 23:40:05 02023-03-10 23:38:13 02023-03-10 23:14:28 02023-03-10 23:13:56 02023-03-10 23:08:25 02023-03-10 21:42:30 02023-03-10 21:42:05 2023-03-10 19:56:09 02023-03-10 19:44:49 02023-03-10 19:24:35 02023-03-10 19:23:13 02023-03-10 19:16:42 02023-03-10 19:15:03 02023-03-10 19:14:37 02023-03-10 19:14:25 02023-03-10 19:09:01 02023-03-10 01:49:06 02023-03-10 01:45:17 02020-11-07 19:55:55 52020-11-07 19:03:45 52020-11-07 19:03:06 52020-11-06 19:31:36 52020-11-06 19:00:39 52020-11-06 18:59:56 0