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

int pos[8][8][6];

#define TM 0
#define TL 1
#define BL 2
#define BM 3
#define BR 4
#define TR 5



#define COLUMNS 450

void generate_SVG(const char *fn);
void generate_SVG_round(const char *fn);

int main(int argc, char *argv[])
{
    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++)
            for (int s = 0; s < 6; s++)
                pos[i][j][s] = -1;
    
    int nr = 128;
    for (int i = 0; i < 8; i++)
        for (int j = 0; j+1 < 8; j++)
        {
            pos[i  ][j  ][BM] = nr;
            pos[i  ][j+1][TM] = nr;
            nr += 2;
        }
    
    for (int i = 0; i+1 < 8; i += 2)
        for (int j = 0; j < 8; j++)
        {
            pos[i  ][j  ][BR] = nr;
            pos[i+1][j  ][TL] = nr;
            nr += 2;
        }
    for (int i = 1; i+1 < 8; i += 2)
        for (int j = 0; j+1 < 8; j++)
        {
            pos[i  ][j  ][BR] = nr; 
            pos[i+1][j+1][TL] = nr;
            nr += 2;
        }
        
    for (int i = 0; i < 8; i += 2)
        for (int j = 1; j < 8; j++)
        {
            pos[i  ][j  ][TR] = nr;
            pos[i+1][j-1][BL] = nr;
            nr += 2;
        }
    for (int i = 1; i+1 < 8; i += 2)
        for (int j = 0; j < 8; j++)
        {
            pos[i  ][j  ][TR] = nr; 
            pos[i+1][j  ][BL] = nr;
            nr += 2;
        }
    if (nr != COLUMNS)
    {
        printf("ERROR %d != 444\n", nr);
        return -1;
    }
    
    if (argc > 1)
    {
        generate_SVG_round(argv[1]);
        return 0;
    }
    
    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++)
        {
            int count = 0;
            for (int p = 0; p < 64; p++)
            {
                bool okay = true;
                for (int b = 0; b < 6; b++)
                    if (pos[i][j][b] == -1 && ((p >> b) & 1) == 1)
                    {
                        okay = false;
                        break;
                    }
                if (okay)
                {
                    count++;
                    printf("%d,%d", i + 8*j, 64 + p);
                    char line[444];
                    for (int k = 0; k < COLUMNS; k++)
                        line[k] = 0;
                    for (int b = 0; b < 6; b++)
                        if (pos[i][j][b] != -1)
                        {
                            bool bit = ((p >> b) & 1) == (b < 3);
                            line[pos[i][j][b] + bit] = 1;
                        }
                    for (int k = 0; k < COLUMNS; k++)
                        if (line[k] == 1)
                            printf(",%d", k);
                    printf(" %d,%d,%d\n", i, j, p);
                }
            }
            // printf("A %03d\n", count);
        }
    return 0;
}

void generate_SVG(const char *fn)
{
    FILE *f = fopen(fn, "r");
    if (f == NULL)
    {
        fprintf(stderr, "Cannot open file %s\n", fn);
        return;
    }
    
    int matrix[8][8];
    
    char buffer[501];
    fgets(buffer, 500, f);
    for (char *s = buffer; *s > ' ';)
    {
        int x,y,p;
        sscanf(s, "%d,%d,%d", &x, &y, &p);
        while (('0' <= *s && *s <= '9') || *s == ',')
            s++;
        if (*s == '|')
            s++;
        if (0 <= x && x < 8 && 0 <= y && y < 8 && 0 <= p && p < 64)
            matrix[x][y] = p;
        else
            fprintf(stderr, "%d,%d,%d is incorrect\n", x, y, p);
    }
    
    int dd[6];
    dd[0] = 1 << TL;
    dd[1] = 1 << TM;
    dd[2] = 1 << TR;
    dd[3] = 1 << BR;
    dd[4] = 1 << BM;
    dd[5] = 1 << BL;



    FILE *fout = stdout;
    fprintf(fout, "<svg width=\"%d\" height=\"%d\" xmlns=\"http://www.w3.org/2000/svg\">\n",
                1000, 1000);

    int g = 30;
    int g02 = (int)round(g*0.2);
    int g05 = (int)round(g*0.5);
    int g12 = (int)round(g*1.2);
    int g14 = (int)round(g*1.4);
    int g16 = (int)round(g*1.6);
    int g18 = (int)round(g*1.8);
    double sqrt3 = sqrt(3);
    int h = (int)round(g*sqrt3);
    int h02 = (int)round(0.2*g*sqrt3);
    int h04 = (int)round(0.4*g*sqrt3);
    int h06 = (int)round(0.6*g*sqrt3);
    int h07 = (int)round(0.7*g*sqrt3);
    int h08 = (int)round(0.8*g*sqrt3);
    int h13 = (int)round(1.3*g*sqrt3);
    int h018 = (int)round(0.18*g*sqrt3);
    int h012 = (int)round(0.13*g*sqrt3);
    fprintf(stderr, "%d %d\n", h018, h012);

    int extra = 0;
    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++)
        {
            int x = (g + extra) * (3*i + 2);
            int y = (h + extra) * (2*j + 1 + (i % 2 == 1 ? 1 : 0));
            int d = matrix[i][j];
            fprintf(fout, "<polyline points=\"");
            
            if (pos[i][j][TL] == -1 && pos[i][j][TM] == -1)
            {
                fprintf(fout, " %d,%d", x-g*2,y);
                if (d & (1 << TL))
                {
                    fprintf(fout, " %d,%d", x-g16,y-h04);
                    fprintf(fout, " %d,%d", x-g18,y-h08);
                    fprintf(fout, " %d,%d", x-g12,y-h08);
                }
            }
            if (pos[i][j][TM] == -1)
            {
                fprintf(fout, " %d,%d", x-g, y-h);
                if (d & (1 << TM))
                {
                    fprintf(fout, " %d,%d", x-g05, y-h);
                    fprintf(fout, " %d,%d", x, y-h13);
                    fprintf(fout, " %d,%d", x+g05, y-h);
                }
            }
            fprintf(fout, " %d,%d", x+g,y-h);
            if (d & (1 << TR))
            {
                fprintf(fout, " %d,%d", x+g12,y-h08);
                fprintf(fout, " %d,%d", x+g18,y-h08);
                fprintf(fout, " %d,%d", x+g16,y-h04);
            }
            fprintf(fout, " %d,%d", x+g*2,y);
            if (d & (1 << BR))
            {
                fprintf(fout, " %d,%d", x+g18,y+h02);
                fprintf(fout, " %d,%d", x+g12,y+h02);
                fprintf(fout, " %d,%d", x+g14,y+h06);
            }
            fprintf(fout, " %d,%d", x+g,y+h);
            if (d & (1 << BM))
            {
                fprintf(fout, " %d,%d", x+g05, y+h);
                fprintf(fout, " %d,%d", x, y+h07);
                fprintf(fout, " %d,%d", x-g05, y+h);
            }
            fprintf(fout, " %d,%d", x-g,y+h);
            if (pos[i][j][BL] == -1)
            {
                if (d & (1 << BL))
                {
                    fprintf(fout, " %d,%d", x-g14,y+h06);
                    fprintf(fout, " %d,%d", x-g12,y+h02);
                    fprintf(fout, " %d,%d", x-g18,y+h02);
                }
                fprintf(fout, " %d,%d", x-g*2,y);
                if (pos[i][j][TL] == -1)
                    fprintf(fout, " %d,%d", x-g, y-h);
            }
            fprintf(fout, "\" fill=\"none\" stroke=\"black\"/>\n");
            
            int ys = y - 2*h018 - h012;
            for (int l = 0; l < 6; l++)
            {
                if (d & dd[l])
                {
                    fprintf(fout, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke=\"red\"/>\n", x-g, ys, x-g02, ys);
                    fprintf(fout, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke=\"red\"/>\n", x+g02, ys, x+g, ys);
                }
                else
                    fprintf(fout, "<line x1=\"%d\" y1=\"%d\" x2=\"%d\" y2=\"%d\" stroke=\"red\"/>\n", x-g, ys, x+g, ys);
                ys += l == 2 ? 2*h012 : h018;
            }
        }
                
    fprintf(fout, "</svg>\n");
        
#define SIDE(S,V) ((matrix[x][y] >> V) & 1) ? S : ' '
    for (int y = 0; y < 8; y++)
    {
        for (int x = 0; x < 8; x++)
            fprintf(stderr, " %c%c%c", SIDE('/', TL), SIDE('-', TM), SIDE('\\', TR));
        fprintf(stderr, "\n");
        for (int x = 0; x < 8; x++)
            fprintf(stderr, " %c%c%c", SIDE('\\', BL), SIDE('-', BM), SIDE('/', BR));
        fprintf(stderr, "\n\n");
    }
    fclose(f);
}

struct Point
{
    double x, y;
};
Point horz_points[5] = {
    { 0,     0     },
    { 0.30,  0.01  },
    { 0.5,  -0.20  },
    { 0.70,  0.01  },
    { 1,     0     }
};
double horz_radius = 0.20;

Point side_points[5] = {
    { 0,     0     },
//    { 0.25, -0.01  },
//    { 0.5,  -0.12  },
//    { 0.75, -0.01  },
    { 0.25, -0.05  },
    { 0.56, -0.21  },
    { 0.68,  0.06  },
    { 1,     0     }
};
double side_radius = 0.20;


struct Arc
{
    double x, y, r;
    int la, sw;
};

Arc top_arcs[5];
Arc bot_arcs[5];
Arc tr_arcs[5];
Arc bl_arcs[5];
Arc tl_arcs[5];
Arc br_arcs[5];

double distance(Point &p1, Point &p2)
{
    double dx = p1.x - p2.x;
    double dy = p1.y - p2.y;
    return sqrt(dx*dx + dy*dy);
}

void calc_points(Point *s_points, bool reverse, double radius, double gap, Arc *arcs)
{
    radius += gap;
    Point points[5];
    for (int i = 1; i < 4; i++)
    {
        points[i].x = reverse ? 1.0 - s_points[4 - i].x : s_points[i].x;
        points[i].y = s_points[reverse ? 4 - i : i].y + gap;
    }
        
    double dist12 = distance(points[1], points[2]);
    double dist23 = distance(points[2], points[3]);
    double radius3 = dist23 - radius;
    double radius1 = dist12 - radius;
    double angle12 = atan2(points[1].y - points[2].y, points[1].x - points[2].x);
    double angle32 = atan2(points[3].y - points[2].y, points[3].x - points[2].x);
    fprintf(stderr, "angle12 = %lf\n", angle12);
    fprintf(stderr, "angle32 = %lf\n", angle32);
    
    double a3 = 1.0 - points[3].x;
    fprintf(stderr, "a3 = %lf\n", a3);
    double b3 =  - points[3].y;
    fprintf(stderr, "b3 = %lf 0.0 %lf\n", b3, points[3].y);
    double d3 = 2*(b3 - radius3);
    fprintf(stderr, "d3 = %lf\n", d3);

    double dy4 = (radius3 * radius3 - a3 * a3 - b3 * b3)/d3;
    fprintf(stderr, "dy4 = %lf\n", dy4);
    double angle43 = atan2(dy4 - points[3].y, 1.0 - points[3].x);
    fprintf(stderr, "%lf %lf ", dy4 - points[3].y, 1.0 - points[3].x);
    fprintf(stderr, "angle43 = %lf\n", angle43);

    double a1 = - points[1].x;
    double b1 = - points[1].y;
    double d1 = 2*(b1 - radius1);

    double dy0 = (radius1 * radius1 - a1 * a1 - b1 * b1)/d1;
    double angle01 = atan2(dy0 - points[1].y, - points[1].x);

    arcs[0].x = points[1].x + radius1 * cos(angle01);
    arcs[0].y = points[1].y + radius1 * sin(angle01);
    arcs[0].r = dy0;
    arcs[0].la = 0;
    arcs[0].sw = 1;

    arcs[1].x = points[1].x - radius1 * cos(angle12);
    arcs[1].y = points[1].y - radius1 * sin(angle12);
    arcs[1].r = radius1;
    arcs[1].la = 0;
    arcs[1].sw = 0;
    
    arcs[2].x = points[3].x - radius3 * cos(angle32);
    arcs[2].y = points[3].y - radius3 * sin(angle32);
    arcs[2].r = radius;
    arcs[2].la = 1;
    arcs[2].sw = 1;

    arcs[3].x = points[3].x + radius3 * cos(angle43);
    arcs[3].y = points[3].y + radius3 * sin(angle43);
    arcs[3].r = radius3;
    arcs[3].la = 0;
    arcs[3].sw = 0;

    arcs[4].x = 1;
    arcs[4].y = 0;
    arcs[4].r = dy4;
    arcs[4].la = 0;
    arcs[4].sw = 1;
}

void generate_SVG_round(const char *fn)
{
    FILE *f = fopen(fn, "r");
    if (f == NULL)
    {
        fprintf(stderr, "Cannot open file %s\n", fn);
        return;
    }

    double extra = 0;
    double g = 30;
    double gap = 0.5 * extra / g;
    calc_points(horz_points, false, horz_radius, -gap, top_arcs);
    calc_points(horz_points, false, horz_radius,  gap, bot_arcs);
    calc_points(side_points, true,  side_radius, -gap, tr_arcs); tr_arcs[1].la = true;
    calc_points(side_points, false, side_radius,  gap, bl_arcs); bl_arcs[3].la = true;
    calc_points(side_points, true,  side_radius, -gap, tl_arcs); tl_arcs[1].la = true;
    calc_points(side_points, false, side_radius,  gap, br_arcs); br_arcs[3].la = true;
    
    for (int i = 0; i < 4; i++)
        fprintf(stderr, "%d: %lf %lf %lf\n", i, top_arcs[i].x, top_arcs[i].y, top_arcs[i].r);

    int matrix[8][8];
    
    char buffer[501];
    fgets(buffer, 500, f);
    for (char *s = buffer; *s > ' ';)
    {
        int x,y,p;
        sscanf(s, "%d,%d,%d", &x, &y, &p);
        while (('0' <= *s && *s <= '9') || *s == ',')
            s++;
        if (*s == '|')
            s++;
        if (0 <= x && x < 8 && 0 <= y && y < 8 && 0 <= p && p < 64)
            matrix[x][y] = p;
        else
            fprintf(stderr, "%d,%d,%d is incorrect\n", x, y, p);
    }

    int dd[6];
    dd[0] = 1 << TL;
    dd[1] = 1 << TM;
    dd[2] = 1 << TR;
    dd[3] = 1 << BR;
    dd[4] = 1 << BM;
    dd[5] = 1 << BL;
    
    FILE *fout = stdout;
    fprintf(fout, "<svg width=\"%d\" height=\"%d\" xmlns=\"http://www.w3.org/2000/svg\">\n",
                1000, 1000);

    double g02 = g*0.2;

    //int g05 = g*0.5;
    //double g12 = g*1.2;
    //double g14 = g*1.4;
    //double g16 = g*1.6;
    //double g18 = g*1.8;
    double sqrt3 = sqrt(3);
    double h = g*sqrt3;
    //double h02 = 0.2*g*sqrt3;
    //double h04 = 0.4*g*sqrt3;
    //double h06 = 0.6*g*sqrt3;
    //int h07 = 0.7*g*sqrt3);
    //double h08 = 0.8*g*sqrt3;
    //int h13 = 1.3*g*sqrt3);
    double h018 = 0.18*g*sqrt3;
    double h012 = 0.13*g*sqrt3;
    fprintf(stderr, "%.2lf %.2lf\n", h018, h012);

    for (int i = 0; i < 8; i++)
        for (int j = 0; j < 8; j++)
        {
            double x = (g + extra/sqrt3) * (3*i + 2);
            double y = (h + extra) * (2*j + 1 + (i % 2 == 1 ? 1 : 0));
            int d = matrix[i][j];
            fprintf(fout, "<path d=\"");

            bool move = true;
            if (pos[i][j][TL] == -1 && pos[i][j][TM] == -1)
            {
                fprintf(fout, "M %.2lf %.2lf", x-g*2,y);
                move = false;
                if (d & (1 << TL))
                {
                    double dr = 2*g;
                    double dx = g;
                    double dy = -h;
                    for (int i = 0; i < 5; i++)
                        fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                            dr * tl_arcs[i].r,
                            dr * tl_arcs[i].r,
                            tl_arcs[i].la,
                            tl_arcs[i].sw,
                            x-g*2 + dx * tl_arcs[i].x - dy * tl_arcs[i].y,
                            y     + dy * tl_arcs[i].x + dx * tl_arcs[i].y);
                }
                else
                    fprintf(fout, " L %.2lf %.2lf", x-g, y-h);
            }
            if (pos[i][j][TM] == -1)
            {
                if (move)
                    fprintf(fout, "M %.2lf %.2lf", x-g,y-h);
                move = false;
                if (d & (1 << TM))
                {
                    double dx = 2*g;
                    for (int i = 0; i < 5; i++)
                        fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                            dx * top_arcs[i].r,
                            dx * top_arcs[i].r,
                            top_arcs[i].la,
                            top_arcs[i].sw,
                            x-g + dx * top_arcs[i].x,
                            y-h + dx * top_arcs[i].y);
                }
                else
                    fprintf(fout, " L %.2lf %.2lf", x+g,y-h);
            }
            if (move)
                fprintf(fout, "M %.2lf %.2lf", x+g,y-h);
            if (d & (1 << TR))
            {
                move = false;
                double dr = 2*g;
                double dx = g;
                double dy = h;
                for (int i = 0; i < 5; i++)
                    fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                        dr * tr_arcs[i].r,
                        dr * tr_arcs[i].r,
                        tr_arcs[i].la,
                        tr_arcs[i].sw,
                        x+g + dx * tr_arcs[i].x - dy * tr_arcs[i].y,
                        y-h + dy * tr_arcs[i].x + dx * tr_arcs[i].y);
                }
                else
                    fprintf(fout, " L %.2lf %.2lf", x+g*2,y);
            move = false;
            if (d & (1 << BR))
            {
                double dr = 2*g;
                double dx = -g;
                double dy = h;
                for (int i = 0; i < 5; i++)
                    fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                        dr * br_arcs[i].r,
                        dr * br_arcs[i].r,
                        br_arcs[i].la,
                        !br_arcs[i].sw,
                        x+g*2 + dx * br_arcs[i].x + dy * br_arcs[i].y,
                        y     + dy * br_arcs[i].x - dx * br_arcs[i].y);
            }
            else
                fprintf(fout, " L %.2lf %.2lf", x+g,y+h);
            if (d & (1 << BM))
            {
                double dx = 2*g;
                for (int i = 0; i < 5; i++)
                    fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                        dx * bot_arcs[i].r,
                        dx * bot_arcs[i].r,
                        bot_arcs[i].la,
                        !bot_arcs[i].sw,
                        x+g - dx * bot_arcs[i].x,
                        y+h + dx * bot_arcs[i].y);
            }
            else
                fprintf(fout, " L %.2lf %.2lf", x-g,y+h);
            if (pos[i][j][BL] == -1)
            {
                if (d & (1 << BL))
                {
                    double dr = 2*g;
                    double dx = -g;
                    double dy = -h;
                    for (int i = 0; i < 5; i++)
                        fprintf(fout, " A %.2lf %.2lf 0 %d %d %.2lf %.2lf",
                            dr * bl_arcs[i].r,
                            dr * bl_arcs[i].r,
                            bl_arcs[i].la,
                            !bl_arcs[i].sw,
                            x-g + dx * bl_arcs[i].x + dy * bl_arcs[i].y,
                            y+h + dy * bl_arcs[i].x - dx * bl_arcs[i].y);
                }
                else
                    fprintf(fout, " L %.2lf %.2lf", x-g*2,y);
            }
            if (pos[i][j][TL] == -1 && pos[i][j][TM] != -1)
                fprintf(fout, " L %.2lf %.2lf", x-g,y-h);

            fprintf(fout, "\" fill=\"none\" stroke=\"black\"/>\n");
            double ys = y - 0.7*h;
            double gl = g * 0.75;
            for (int l = 0; l < 6; l++)
            {
                if (d & dd[l])
                {
                    fprintf(fout, "<line x1=\"%.2lf\" y1=\"%.2lf\" x2=\"%.2lf\" y2=\"%.2lf\" stroke=\"black\"/>\n", x-gl, ys, x-g02, ys);
                    fprintf(fout, "<line x1=\"%.2lf\" y1=\"%.2lf\" x2=\"%.2lf\" y2=\"%.2lf\" stroke=\"black\"/>\n", x+g02, ys, x+gl, ys);
                }
                else
                    fprintf(fout, "<line x1=\"%2lf\" y1=\"%.2lf\" x2=\"%.2lf\" y2=\"%.2lf\" stroke=\"black\"/>\n", x-gl, ys, x+gl, ys);
                ys += (l == 2 ? 2 : 1) * h * 0.1;
            }
        }
                
    fprintf(fout, "</svg>\n");
        
#define SIDE(S,V) ((matrix[x][y] >> V) & 1) ? S : ' '
    for (int y = 0; y < 8; y++)
    {
        for (int x = 0; x < 8; x++)
            fprintf(stderr, " %c%c%c", SIDE('/', TL), SIDE('-', TM), SIDE('\\', TR));
        fprintf(stderr, "\n");
        for (int x = 0; x < 8; x++)
            fprintf(stderr, " %c%c%c", SIDE('\\', BL), SIDE('-', BM), SIDE('/', BR));
        fprintf(stderr, "\n\n");
    }
    fclose(f);
}