#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#define CHARS_MAX 64
#define MAX_ROBOTS 1024
#define MAX_ITERATIONS 10650

typedef struct robot {
    int p[2];
    int v[2];
} robot_t;

void reposition(int p[2], int v[2], int max_x, int max_y, int i);

int main() {
    char *p, *buf, c;

    buf = calloc(CHARS_MAX, sizeof(char));
    p = buf;

    robot_t *robots = calloc(MAX_ROBOTS, sizeof(robots[0]));
    int robot_count = 0;

    while ((c = getchar()) != EOF) {
        *p++ = c;
        if (c != '\n') {
            continue;
        }
        p = buf;

        while(*p != '=') p++;
        p++;

        sscanf(p, "%i", &robots[robot_count].p[0]);

        while(*p != ',') p++;
        p++;

        sscanf(p, "%i", &robots[robot_count].p[1]);

        while(*p != '=') p++;
        p++;

        sscanf(p, "%i", &robots[robot_count].v[0]);

        while(*p != ',') p++;
        p++;

        sscanf(p, "%i", &robots[robot_count].v[1]);

        robot_count++;
        memset(buf, 0, CHARS_MAX);
        p = buf;
    }

    free(buf);

    int max_y = 103, max_x = 101;

    for (int i = 0; i < robot_count; i++) {
        reposition(robots[i].p, robots[i].v, max_x, max_y, 100);
    }
    
    int quadrants[4] = { 0 };
    for (int i = 0; i < max_y / 2; i++) {
        for (int j = 0; j < max_x / 2; j++) {
            for (int k = 0; k < robot_count; k++) {
                quadrants[0] += robots[k].p[0] == j && robots[k].p[1] == i;
            }
        }
    }
    for (int i = (max_y / 2) + (max_y % 2); i < max_y; i++) {
        for (int j = 0; j < max_x / 2; j++) {
            for (int k = 0; k < robot_count; k++) {
                quadrants[1] += robots[k].p[0] == j && robots[k].p[1] == i;
            }
        }
    }
    for (int i = (max_y / 2) + (max_y % 2); i < max_y; i++) {
        for (int j = (max_x / 2) + (max_x % 2); j < max_x; j++) {
            for (int k = 0; k < robot_count; k++) {
                quadrants[2] += robots[k].p[0] == j && robots[k].p[1] == i;
            }
        }
    }
    for (int i = 0; i < max_y / 2; i++) {
        for (int j = (max_x / 2) + (max_x % 2); j < max_x; j++) {
            for (int k = 0; k < robot_count; k++) {
                quadrants[3] += robots[k].p[0] == j && robots[k].p[1] == i;
            }
        }
    }

    // RESET
    for (int i = 0; i < robot_count; i++) {
        reposition(robots[i].p, robots[i].v, max_x, max_y, -100);
    }

    int **map = calloc(max_x, sizeof(map[0]));
    for (int i = 0; i < max_x; i++) {
        map[i] = calloc(max_y, sizeof(map[0][0]));
    }

    for (int i = 0; i < MAX_ITERATIONS; i++) {
        for (int j = 0; j < robot_count; j++) {
            reposition(robots[j].p, robots[j].v, max_x, max_y, 1);
        }

        for (int j = 0; j < max_y; j++) {
            for (int k = 0; k < max_x; k++) {
                int occupied = 0;
                for (int l = 0; l < robot_count; l++) {
                    if (robots[l].p[0] == k && robots[l].p[1] == j) {
                        occupied = 1;
                        break;
                    }
                }
                map[k][j] = occupied;
            }
        }

        int display = 0;
        for (int j = 0; j < max_y; j++) {
            int consecutive = 0;
            for (int k = 0; k < max_x; k++) {
                if (map[k][j]) {
                    consecutive++;
                } else {
                    consecutive = 0;
                }

                if (consecutive >= 30) {
                    display = 1;
                }
            }
        }

        if (!display) {
            continue;
        }

        for (int i = 0; i < max_y; i++) {
            for (int j = 0; j < max_x; j++) {
                int r = 0;
                for (int k = 0; k < robot_count; k++) {
                    if (robots[k].p[0] == j && robots[k].p[1] == i) {
                        printf("1");
                        r = 1;
                        break;
                    }
                }
                if (!r) {
                    printf(".");
                }
            }
            printf("\n");
        }
        printf("Part2: %i\n", i + 1);
        break;
    }


    free(robots);

    for (int i = 0; i < max_x; i++) {
        free(map[i]);
    }
    free(map);

    int safety = 1;
    for (int i = 0; i < 4; i++) {
        safety *= quadrants[i];
    }

    printf("Part1: %i\n", safety);
}

void reposition(int p[2], int v[2], int max_x, int max_y, int i) {
    p[0] = (p[0] + v[0] * i) % max_x;
    p[1] = (p[1] + v[1] * i) % max_y;

    if (p[0] < 0) {
        p[0] = max_x + p[0];
    }

    if (p[1] < 0) {
        p[1] = max_y + p[1];
    }

    if (p[0] >= max_x) {
        p[0] = p[0] - max_x;
    }

    if (p[1] >= max_y) {
        p[1] = p[1] - max_y;
    }
}