using System;

using System.Collections.Generic;

public class IMyTextPanel {

    public IMyTextPanel() {}

    public void WritePublicText(string s) {

        s = s.Replace("\u2014\u0060", "█");

        Console.WriteLine();

    }

    public void ShowTextureOnScreen() {

    }

    public void ShowPublicTextOnScreen() {

    }

}

public class SEFix {

    public static T[] arr<T>(params T[] arg) {

        return arg; //becuse SE is stupid

    }

}

public class ColorUtils {

    private static double oo64 = 1.0/64.0;

    private static double[][] map = new double[][] {

        new double[] { 0*oo64, 48*oo64, 12*oo64, 60*oo64,  3*oo64, 51*oo64, 15*oo64, 63*oo64},

        new double[] {32*oo64, 16*oo64, 44*oo64, 28*oo64, 35*oo64, 19*oo64, 47*oo64, 31*oo64},

        new double[] { 8*oo64, 56*oo64,  4*oo64, 52*oo64, 11*oo64, 59*oo64,  7*oo64, 55*oo64},

        new double[] {40*oo64, 24*oo64, 36*oo64, 20*oo64, 43*oo64, 27*oo64, 39*oo64, 23*oo64},

        new double[] { 2*oo64, 50*oo64, 14*oo64, 62*oo64,  1*oo64, 49*oo64, 13*oo64, 61*oo64},

        new double[] {34*oo64, 18*oo64, 46*oo64, 30*oo64, 33*oo64, 17*oo64, 45*oo64, 29*oo64},

        new double[] {10*oo64, 58*oo64,  6*oo64, 54*oo64,  9*oo64, 57*oo64,  5*oo64, 53*oo64},

        new double[] {42*oo64, 26*oo64, 38*oo64, 22*oo64, 41*oo64, 25*oo64, 37*oo64, 21*oo64}

    };

    private static int[][] palette = new int[][] {

        SEFix.arr( 0, 0, 0),

        SEFix.arr( 97, 97, 97),

        SEFix.arr( 255, 255, 255),

        SEFix.arr( 255, 0, 0),

        SEFix.arr( 255, 255, 0),

        SEFix.arr( 0, 255, 0),

        SEFix.arr( 0, 0, 255)

    };

    private static string[] colorStrings = new string[] {

        "\u2014\u0060",

        "\uE00D",

        "\uE007\u0458",

        "\uE003",

        "\uE004",

        "\uE001",

        "\uE002"

    };

    private static int redC = 300;

    private static int greenC = 540;

    private static int blueC = 150;

    private static double compareColors(int r1, int g1, int b1, int r2, int g2, int b2) {

        double dl = ((r1*redC + g1*greenC + b1*blueC)-(r2*redC + g2*greenC + b2*blueC))/255000.0;

        double dr = (r1-r2)/255.0, dg = (g1-g2)/255.0, db = (b1-b2)/255.0;

        return ((dr*dr*redC + dg*dg*greenC + db*db*blueC)*0.0075 + dl*dl);

    }

    private static double calcError(int r, int g, int b, int r0, int g0, int b0, int[] color1, int[] color2, double ratio) {

        return compareColors(r, g, b, r0,g0,b0) +

            compareColors(color1[0], color1[1], color1[2], color2[0], color2[1], color2[2]) *0.03*(Math.Abs(ratio-0.5)+0.5)* 

            (1+ (color1[0]==color1[1] && color1[0]==color1[2] && color1[0]==color2[0] && 

             color1[0] == color2[1] && color1[0]==color2[2] ? 0.03 : 0));

    }

    private static int makeRatio(int r, int g, int b, int[] c1, int[] c2) {

        int ratio = 32;

        if (c1[0] != c2[0] || c1[1] != c2[1] || c1[2] != c2[2]) {

            ratio =

                ((c2[0] != c1[0] ? redC  *64 * (r - c1[0]) / (c2[0]-c1[0]) : 0) +

                 (c2[1] != c1[1] ? greenC*64 * (g - c1[1]) / (c2[1]-c1[1]) : 0) +

                 (c1[2] != c2[2] ? blueC *64 * (b - c1[2]) / (c2[2]-c1[2]) : 0))/

                ((c2[0] != c1[0] ? redC   : 0)+

                 (c2[1] != c1[1] ? greenC : 0)+

                 (c2[2] != c1[2] ? blueC  : 0));

            if (ratio < 0)

                ratio = 0;

            else if (ratio > 63)

                ratio = 63;

        }

        return ratio;

    }

    private static int[] createMix(int r, int g, int b) {

        int[] result = SEFix.arr(0,0,32);

        double minPenalty = Single.MaxValue;

        for (int i = 0; i < palette.Length; i++) {

            for (int j = i; j < palette.Length; j++) {

                int ratio = makeRatio(r,g,b, palette[i], palette[j]);

                double penalty = calcError(

                    r,g,b,

                    palette[i][0] + ratio * (palette[j][0]-palette[i][0]) / 64,

                    palette[i][1] + ratio * (palette[j][1]-palette[i][1]) / 64,

                    palette[i][2] + ratio * (palette[j][2]-palette[i][2]) / 64,

                    palette[i], palette[j],

                    (double)ratio/64.0);

                if (penalty < minPenalty) {

                    minPenalty = penalty;

                    result[0] = i;

                    result[1] = j;

                    result[2] = ratio;

                }

            }

        }

        return result;

    }

    public static string[][] genDitherPattern(int r, int g, int b) {

        int[] mix = createMix(r,g,b);

        string[][] dithered = new string[8][];

        for (int x = 0; x < 8; x++) {

            dithered[x] = new string[8];

            for (int y = 0; y < 8; y++) {

                double mapValue = map[y&7][x&7];

                double ratio = mix[2]/64.0;

                dithered[x][y] = colorStrings[mix[ mapValue < ratio ? 1 : 0 ]];

            }

        }

        return dithered;

    }

}

public class Ascii {

    private static int offset = 0x21;

    // binary numbers represent bitmap glyphs, three bits to a line

    // eg 9346 == 010 010 010 000 010 == !

    //    5265 == 001 010 010 010 001 == (

    private static short[] glyphs = SEFix.arr<short>(

        9346, 23040, 24445, 15602,

        17057, 10923, 9216, 5265,

        17556, 21824, 1488, 20,

        448, 2, 672, 31599,

        11415, 25255, 29326, 23497,

        31118, 10666, 29370, 10922,

        10954, 1040, 1044, 5393,

        3640, 17492, 25218, 15203,

        11245, 27566, 14627, 27502,

        31143, 31140, 14827, 23533,

        29847, 12906, 23469, 18727,

        24557, 27501, 11114, 27556,

        11131, 27565, 14478, 29842,

        23403, 23378, 23549, 23213,

        23186, 29351, 13459, 2184,

        25750, 10752, 7, 17408,

        239, 18862, 227, 4843,

        1395, 14756, 1886, 18861,

        8595, 4302, 18805, 25745,

        509, 429, 170, 1396,

        1369, 228, 1934, 18851,

        363, 362, 383, 341,

        2766, 3671, 5521, 9234,

        17620, 1920

    );

    public static short getGlyph(char code) {

        return glyphs[code-offset];

    }

}

​

public class Canvas {

    public readonly int width, height;

    public string[] data;

    public Canvas(int w, int h) {

        width = w; height = h;

        data = new string[width*height];

    }

    public void clear() {

        Array.Clear(data, 0, width*height);

    }

}

public class Graphics {

    public readonly int width, height;

    private int cwidth, cheight;

    private IMyTextPanel console;

    private string[] screen;

    private string[] currentSurface;

    private string[] screenLines;

    private string[][] fgDither, bgDither;

    private int[] clip = new int[4];

    private Dictionary<string, string[][]> oldPatterns = new Dictionary<string, string[][]>();

    public Graphics(int w, int h, IMyTextPanel c) {

        width = w;

        height = h;

        screen = new string[height*width];

        screenLines = new string[width*height+height-1];

        console = c;

        setCanvas();

        mask();

        setFG(255,255,255);

        setBG(0,0,0);

    }

    public void setCanvas(Canvas c) {

        currentSurface = c.data;

        cwidth = c.width;

        cheight = c.height;

        mask();

    }

    public void setCanvas() {

        currentSurface = screen;

        cwidth = width;

        cheight = height;

        mask();

    }

    public void setFG(int r, int g, int b) {

        string k = r+":"+g+":"+b;

        if (!oldPatterns.TryGetValue(k, out fgDither)) {

            fgDither = ColorUtils.genDitherPattern(r,g,b);

            oldPatterns[k] = fgDither;

        }

    }

    public void setBG(int r, int g, int b) {

        string k = r+":"+g+":"+b;

        if (!oldPatterns.TryGetValue(k, out bgDither)) {

            bgDither = ColorUtils.genDitherPattern(r,g,b);

            oldPatterns[k] = bgDither;

        }

    }

    public void mask(int x1, int y1, int x2, int y2) {

        clip[0] = x1;

        clip[1] = y1;

        clip[2] = x2;

        clip[3] = y2;

    }

    public void mask() {

        clip[0] = 0;

        clip[1] = 0;

        clip[2] = cwidth-1;

        clip[3] = cheight-1;

    }

    public void draw(int x1, int y1, Canvas canvas) {

        if (canvas.data == currentSurface) return;

        x1 = Math.Max(x1, clip[0]);

        y1 = Math.Max(y1, clip[1]);

        int w = Math.Min(canvas.width, clip[2]-x1+1);

        int h = Math.Min(canvas.height, clip[3]-y1+1);

        for (int x=0; x < w; x++) {

            for (int y=0; y < h; y++) {

                string px = canvas.data[canvas.width*y + x];

                if (px != null)

                    currentSurface[cwidth*(y1+y)+(x1+x)] = px;

            }

        }

    }

    public void paint() {

        if (currentSurface != screen) return;

        for (int i=0; i < height; i++) {

            screenLines[i] = string.Join(null, screen, i*width, width)+"\n";

        }

        console.WritePublicText(string.Concat(screenLines));

        console.ShowTextureOnScreen();

        console.ShowPublicTextOnScreen();

    }

    public void clear() {

        for (int i=0; i < 8; i++) {

            for (int j=0; j < cwidth; j+=8) {

                Array.Copy(bgDither[i], 0, currentSurface, i*cwidth+j, 8);

            }

        }

        int size = cwidth*cheight;

        int half = cwidth*cheight >> 1;

        for (int i = cwidth*8; i < size; i *= 2) {

            int copyLength = i;

            if (i > half) {

                copyLength = size - i;

            }

            Array.Copy(currentSurface, 0, currentSurface, i, copyLength);

        }

    }

    public void pixel(int x, int y) {

        if (x >= clip[0] && x <= clip[2] && y >= clip[1] && y <= clip[3]) {

            currentSurface[cwidth*y + x] = fgDither[y&7][x&7];

        }

    }

    private void horizontal(int x1, int x2, int y) {

        x1 = Math.Max(Math.Min(x1, x2), clip[0]);

        x2 = Math.Min(Math.Max(x1, x2), clip[2]);

        int length = x2-x1+1;

        string[] ditherRow = fgDither[y&7];

        if (length >= 8) {

            int start = x1&7;

            int x1index = cwidth*y + x1;

            Array.Copy(ditherRow,start, currentSurface, x1index, 8-start);

            Array.Copy(ditherRow,0, currentSurface, x1index+8-start, start);

            int after = x1index+length;

            int half = x1index+(length>>1);

            int begin = x1index+8;

            for (int i = begin; i < after; i *= 2) {

                int copyLength = i;

                if (i > half) {

                    copyLength = after - i;

                }

                Array.Copy(currentSurface, begin, currentSurface, i, copyLength);

            }

        } else {

            for (int x = x1; x <= x2; x++) {

                currentSurface[cwidth*y + x] = ditherRow[x&7];

            }

        }

    }

    public void line(int x0, int y0, int x1, int y1) {

        if (x0 == x1) {

            rect("fill", x0, y0, 1, y1-y0+1);

        } else if (y0 == y1) {

            rect("fill", x0, y0, x1-x0+1, 1);

        } else {

            bool yLonger=false;

            int incrementVal, endVal;

            int shortLen=y1-y0;

            int longLen=x1-x0;

            if (Math.Abs(shortLen)>Math.Abs(longLen)) {

                int swap=shortLen;

                shortLen=longLen;

                longLen=swap;

                yLonger=true;

            }

            endVal=longLen;

            if (longLen<0) {

                incrementVal=-1;

                longLen=-longLen;

            } else incrementVal=1;

            int decInc;

            if (longLen==0) decInc=0;

            else decInc = (shortLen << 16) / longLen;

            int j=0;

            if (yLonger) {

                for (int i=0;i-incrementVal!=endVal;i+=incrementVal) {

                    pixel(x0+(j >> 16),y0+i);     

                    j+=decInc;

                }

            } else {

                for (int i=0;i-incrementVal!=endVal;i+=incrementVal) {

                    pixel(x0+i,y0+(j >> 16));

                    j+=decInc;

                }

            }

        }

    }

    private void flatBottom(int x1, int y1, int x2, int y2, int x3, int y3, bool rotated) {

        float invslope1 = (float)(x2 - x1) / (y2 - y1);

        float invslope2 = (float)(x3 - x1) / (y3 - y1);

        float curx1 = x1;

        float curx2 = x1;

        for (int scanlineY = y1; scanlineY <= y2; scanlineY++) {

            if (rotated) line(scanlineY, (int)curx1, scanlineY, (int)curx2);

            else line((int)curx1, scanlineY, (int)curx2, scanlineY);

            curx1 += invslope1;

            curx2 += invslope2;

        }

    }

    private void flatTop(int x1, int y1, int x2, int y2, int x3, int y3, bool rotated) {

        float invslope1 = (float)(x3 - x1) / (y3 - y1);

        float invslope2 = (float)(x3 - x2) / (y3 - y2);

        float curx1 = x3;

        float curx2 = x3;

        for (int scanlineY = y3; scanlineY > y1; scanlineY--) {

            curx1 -= invslope1;

            curx2 -= invslope2;

            if (rotated) line(scanlineY, (int)curx1, scanlineY, (int)curx2);

            else line((int)curx1, scanlineY, (int)curx2, scanlineY);

        }

    }

    private void swap(ref int a, ref int b) {

        int c = a;

        a = b;

        b = c;

    }

    public void tri(string m, int x1, int y1, int x2, int y2, int x3, int y3) {

        if (m == "line") {

            line(x1,y1,x2,y2);

            line(x2,y2,x3,y3);

            line(x3,y3,x1,y1);

        } else if (m == "fill") {

            if (x1 == x2 || x2 == x3 || x3 == x1) {

                if (x1 > x3) {

                    swap(ref y1, ref y3);

                    swap(ref x1, ref x3);

                }

                if (x1 > x2) {

                    swap(ref y1, ref y2);

                    swap(ref x1, ref x2);

                }

                if (x2 > x3) {

                    swap(ref y2, ref y3);

                    swap(ref x2, ref x3);

                }

                if (x2 == x3) flatBottom(y1,x1, y2,x2, y3,x3, true);

                else if (x1 == x2) flatTop(y1,x1, y2,x2, y3,x3, true);

            } else {

                if (y1 > y3) {

                   swap(ref y1, ref y3);

                   swap(ref x1, ref x3);

                }

                if (y1 > y2) {

                   swap(ref y1, ref y2);

                   swap(ref x1, ref x2);

                }

                if (y2 > y3) {

                   swap(ref y2, ref y3);

                   swap(ref x2, ref x3);

                }

                if (y2 == y3) {

                    flatBottom(x1,y1, x2,y2, x3,y3, false);

                } else if (y1 == y2) {

                    flatTop(x1,y1, x2,y2, x3,y3, false);

                } else {

                    int x4 = (int)(x1 + ((float)(y2 - y1) / (float)(y3 - y1)) * (x3 - x1));

                    flatBottom(x1,y1, x2,y2, x4,y2, false);

                    flatTop(x2,y2, x4,y2, x3,y3, false);

                }

            }

        }

    }

    public void rect(string m, int xb, int yb, int w, int h) {

        if (m == "line") {

            line(xb, yb, xb, yb+h-1);

            line(xb, yb, xb+w-1, yb);

            line(xb+w-1, yb, xb+w-1, yb+h-1);

            line(xb, yb+h-1, xb+w-1, yb+h-1);

        } else if (m == "fill") {

            for (int x = xb; x < xb+w; x++) {

                for (int y = yb; y < yb+h; y++) {

                    pixel(x,y);

                }

            }

        }

    }

    public void ellipse(string m, int cx, int cy, int rx, int ry) {

        int rx2 = rx*rx;

        int ry2 = ry*ry;

        if (m == "fill") {

            int rxsys = rx2*ry2;

            pixel(cx, cy);

            for (int i=1; i < rx*ry; i++) {

                int x = i % rx;

                int y = i / rx;

                if (ry2*x*x+rx2*y*y <= rxsys) {

                    pixel(cx+x, cy+y);

                    pixel(cx-x, cy-y);

                    //if (x && y) { //unnecessary (prevents overdrawing pixels)

                    pixel(cx+x, cy-y);

                    pixel(cx-x, cy+y);

                    //}

                }

            }

        } else if (m == "line") {

            int frx2 = 4 * rx2;

            int fry2 = 4 * ry2;

            int s = 2*ry2+rx2*(1-2*ry);

            int y = ry;

            for (int x = 0; ry2*x <= rx2*y; x++) {

                pixel(cx + x, cy + y);

                pixel(cx - x, cy + y);

                pixel(cx + x, cy - y);

                pixel(cx - x, cy - y);

                if (s >= 0) {

                    s += frx2 * (1 - y);

                    y--;

                }

                s += ry2 * ((4 * x) + 6);

            }

            y = 0;

            s = 2*rx2+ry2*(1-2*rx);

            for (int x = rx; rx2*y <= ry2*x; y++) {

                pixel(cx + x, cy + y);

                pixel(cx - x, cy + y);

                pixel(cx + x, cy - y);

                pixel(cx - x, cy - y);

                if (s >= 0) {

                    s += fry2 * (1 - x);

                    x--;

                }

                s += rx2 * ((4 * y) + 6);

            }

        }

    }

    public void circle(string m, int cx, int cy, int r) {

        if (m == "fill") {

            int rr = r*r;

            pixel(cx, cy);

            for (int i=1; i < r*r; i++) {

                int x = i % r;

                int y = i / r;

                if (x*x+y*y < rr) {

                    pixel(cx+x, cy+y);

                    pixel(cx-x, cy-y);

                    if (x>0 && y>0) {

                        pixel(cx+x, cy-y);

                        pixel(cx-x, cy+y);

                    }

                }

            }

        } else if (m == "line") {

            int x = r;

            int y = 0;

            int do2 = 1 - x;

            while (y <= x) {

                pixel(cx+x, cy+y);

                pixel(cx+y, cy+x);

                pixel(cx-x, cy+y);

                pixel(cx-y, cy+x);

                pixel(cx-x, cy-y);

                pixel(cx-y, cy-x);

                pixel(cx+x, cy-y);

                pixel(cx+y, cy-x);

                y++;

                if (do2 <= 0) {

                    do2 += 2 * y + 1;

                } else {

                    do2 += 2 * (y - --x) + 1;

                }

            }

        }

    }

    public void print(int x, int y, string text) {

        int x1 = x;

        int y1 = y;

        for (int i = 0; i < text.Length; i++) {

            switch(text[i]) {

                case '\n':

                    y1 += 6;

                    x1 = x;

                    break;

                case ' ':

                    x1 += 4;

                    break;

                default:

                    short glyph = Ascii.getGlyph(text[i]);

                    int j = 14;

                    do {

                        if ((glyph & 1) != 0) {

                            pixel(x1+j%3, y1-4+j/3);

                        }

                        glyph >>= 1;

                        j--;

                    } while (glyph > 0);

                    x1 += 4;

                    break;

            }

        }

    }

}

public class Program

{

    static Graphics g = new Graphics(20, 13, new IMyTextPanel());

    public static void Main()

    {

        g.clear();

        g.print(5, 7, "yo");

        g.paint();

    }

}