# ruby
l=92.chr;eval s="s=s.dump[r=1..-2].gsub(/("+l*4+"){4,}(?!¥")/){|t|'¥"+l*%d+¥"'%(t
.size/2)};5.times{s=s.dump[r]};puts¥"# python¥¥nprint(¥¥¥"# perl¥¥¥¥nprint(¥¥¥¥¥¥
¥"# lua"+l*4+"nprint("+l*7+"¥"(* ocaml *)"+l*8+"nprint_endline"+l*15+"¥"-- haskel
l"+l*16+"nimport Data.List;import Data.Bits;import Data.Char;main=putStrLn("+l*31
+"¥"/* C */"+l*32+"n#include<stdio.h>"+l*32+"nint main(void){char*s[501]={"+l*31+
"¥"++intercalate"+l*31+"¥","+l*31+"¥"(c(tail(init(show("+l*31+"¥"/* Java */"+l*32
+"npublic class QuineRelay{public static void main(String[]a){String[]s={"+l*31+"
¥"++intercalate"+l*31+"¥","+l*31+"¥"(c("+l*31+"¥"brainfuck"+l*64+"n++++++++[>++++
<-]+++++++++>>++++++++++"+l*31+"¥"++(concat(snd(mapAccumL h 2("+l*31+"¥"110"+l*31
+"¥"++g(length s)++"+l*31+"¥"22111211100111112021111102011112120012"+l*31+"¥"++co
ncatMap("+l*32+"c->let d=ord c in if d<11then"+l*31+"¥"21002"+l*31+"¥"else"+l*31+
"¥"111"+l*31+"¥"++g d++"+l*31+"¥"22102"+l*31+"¥")s++"+l*31+"¥"2100211101012021122
2211211101000120211021120221102111000110120211202"+l*31+"¥"))))))++"+l*31+"¥","+l
*63+"¥""+l*64+"n"+l*63+"¥"};int i=0;for(;i<94;i++)System.out.print(s[i]);}}"+l*31
+"¥")))))++"+l*31+"¥",0};int i=0;for(;s[i];i++)printf("+l*63+"¥"%s"+l*63+"¥",s[i]
);puts("+l*63+"¥""+l*63+"¥");return 0;}"+l*31+"¥");c s=map("+l*32+"s->"+l*31+"¥""
+l*63+"¥""+l*31+"¥"++s++"+l*31+"¥""+l*63+"¥""+l*31+"¥")(unfoldr t s);t[]=Nothing;
t s=Just(splitAt(if length s>w&&s!!w=='"+l*31+"¥"'then 501else w)s);w=500;f 0=Not
hing;f x=Just((if x`mod`2>0then '0'else '1'),x`div`2);g x= reverse (unfoldr f x);
h p c=let d=ord c-48in(d,replicate(abs(p-d))(if d<p then '<'else '>')++"+l*31+"¥"
."+l*31+"¥");s="+l*31+"¥"# ruby"+l*32+"n"+l*31+"¥"++"+l*31+"¥"l=92.chr;eval s=¥"+
(z=l*31)+¥"¥¥¥"¥"+s+z+¥"¥¥¥""+l*31+"¥"++"+l*31+"¥""+l*32+"n"+l*31+"¥""+l*15+"¥""+
l*7+"¥")"+l*4+"n¥¥¥¥¥¥¥")¥¥¥")¥"########### (c) Yusuke Endoh, 2009 ###########¥n"

начало
  "начало",
  "вывод начала (1 строка)",
  "вывод строк с кавычками",
  "вывод конца (3-5 строки)"
  "конец"
вывод начала (1 строка)
вывод строк с кавычками
вывод конца (3-5 строки)
конец

начало
  "начало",             "nachalo"
  "вывод nachala",      "vyvod начала"
  "вывод s kavychkami", "vyvod с кавычками"
  "вывод konca",        "vyvod конца"
  "конец",              "konec"
вывод nachala (стр.1б)
вывод s kavychkami (с учётом экранирования на втором языке)
вывод konca (стр.3б,4б,5б)
конец

c = [
    '#include <iostream>',
    'using namespace std;',
    'const char* const c[14] = {',
    '};',
    'const char* const p[9] = {',
    '};',
    'int main()',
    '{',
    '    for(int i=0; i!= 1; ++i) cout << p[i] << endl;',
    '    for(int i=0; i!=14; ++i) cout << char(9) << char(39) << c[i] << char(39) << char(44) << endl;',
    '    for(int i=1; i!= 3; ++i) cout << p[i] << endl;',
    '    for(int i=0; i!= 9; ++i) cout << char(9) << char(39) << p[i] << char(39) << char(44) << endl;',
    '    for(int i=3; i!= 9; ++i) cout << p[i] << endl;',
    '}',
    ]
p = [
    'c = [',
    '    ]',
    'p = [',
    '    ]',
    'for i in range(0, 3) : print c[i]',
    'for i in range(0,14) : print chr(9)+chr(34)+c[i]+chr(34)+chr(44)',
    'for i in range(3, 5) : print c[i]',
    'for i in range(0, 9) : print chr(9)+chr(34)+p[i]+chr(34)+chr(44)',
    'for i in range(5,14) : print c[i]',
    ]
for i in range(0, 3) : print c[i]
for i in range(0,14) : print chr(9)+chr(34)+c[i]+chr(34)+chr(44)
for i in range(3, 5) : print c[i]
for i in range(0, 9) : print chr(9)+chr(34)+p[i]+chr(34)+chr(44)
for i in range(5,14) : print c[i]

#include <iostream>
using namespace std;
const char* const c[14] = {
    "#include <iostream>",
    "using namespace std;",
    "const char* const c[14] = {",
    "};",
    "const char* const p[9] = {",
    "};",
    "int main()",
    "{",
    "    for(int i=0; i!= 1; ++i) cout << p[i] << endl;",
    "    for(int i=0; i!=14; ++i) cout << char(9) << char(39) << c[i] << char(39) << char(44) << endl;",
    "    for(int i=1; i!= 3; ++i) cout << p[i] << endl;",
    "    for(int i=0; i!= 9; ++i) cout << char(9) << char(39) << p[i] << char(39) << char(44) << endl;",
    "    for(int i=3; i!= 9; ++i) cout << p[i] << endl;",
    "}",
};
const char* const p[9] = {
    "c = [",
    "    ]",
    "p = [",
    "    ]",
    "for i in range(0, 3) : print c[i]",
    "for i in range(0,14) : print chr(9)+chr(34)+c[i]+chr(34)+chr(44)",
    "for i in range(3, 5) : print c[i]",
    "for i in range(0, 9) : print chr(9)+chr(34)+p[i]+chr(34)+chr(44)",
    "for i in range(5,14) : print c[i]",
};
int main()
{
    for(int i=0; i!= 1; ++i) cout << p[i] << endl;
    for(int i=0; i!=14; ++i) cout << char(9) << char(39) << c[i] << char(39) << char(44) << endl;
    for(int i=1; i!= 3; ++i) cout << p[i] << endl;
    for(int i=0; i!= 9; ++i) cout << char(9) << char(39) << p[i] << char(39) << char(44) << endl;
    for(int i=3; i!= 9; ++i) cout << p[i] << endl;
}

/* prog1 */
#include <stdio.h>
int main() {
    puts("prog2");
}

/* prog2 */
#include <stdio.h>
int main() {
    puts("prog3");
}

/* prog3 */
#include <stdio.h>
int main() {
    puts("prog4");
}

/* prog4 */
#include <stdio.h>
define_magic();
int main() {
    magic_puts("prog1");
}

// подставляем prog1
/* prog4 */
#include <stdio.h>
define_magic();
int main() {
    magic_puts(
        "/* prog1 */\n"
        "#include <stdio.h>\n"
        "int main() {\n"
        "puts(\"prog2\");\n" // появились экранированные кавычки!
        "}\n"
    );
}

// подставляем prog2
/* prog4 */
#include <stdio.h>
define_magic();
int main() {
    magic_puts(
        "/* prog1 */\n"
        "#include <stdio.h>\n"
        "int main() {\n"
        "puts(\""
            "/* prog2 */\n"
            "#include <stdio.h>\n"
            "int main() {\n"
            "    puts(\"prog3\");\n" // в недрах - кавычки экранированы ровно один раз
            "}\n"
        "\");\n"
        "}\n"
    );
}

// подставляем prog3
/* prog4 */
#include <stdio.h>
define_magic();
int main() {
    magic_puts(
        "/* prog1 */\n"
        "#include <stdio.h>\n"
        "int main() {\n"
        "puts(\""
            "/* prog2 */\n"
            "#include <stdio.h>\n"
            "int main() {\n"
            "    puts(\""
                "/* prog3 */\n"
                "#include <stdio.h>\n"
                "int main() {\n"
                "puts(\"prog4\");\n"
                "}\n"
            "\");\n"
            "}\n"
        "\");\n"
        "}\n"
    );
}

/* prog4 */
#include <stdio.h>

void putqs(const char* s)
{
    for(;*s;++s)
    {
        switch(*s)
        {
        case '\n': puts("\\n"); break;
        case '\"': puts("\\\""); break;
        case '\\': puts("\\\\"); break;
        default: putc(*s);
        }
    }
}

const char* s[] = {
    STRINGIZE( /* prog1 */ ..... const char* s [] = { ), // сами руками сделаете
    "    \"", // начало строки кода, образующей элемент этого массива
    "\",\n", // соответственно, конец
    STRINGIZE( }; int main() { ..... } ) // сами руками сделаете
};

int main()
{
    int k;

    // выводим первую часть prog1...
    puts(
        "/* prog1 */\n"
        "#include <stdio.h>\n"
        "int main() {\n"
        "puts(\""
            "/* prog2 */\n"
            "#include <stdio.h>\n"
            "int main() {\n"
            "    puts(\""
                "/* prog3 */\n"
                "#include <stdio.h>\n"
                "int main() {\n"
                "puts(\""
    );
    
    // а вот здесь надо вывести текст prog4!
    puts(s[0]);
    for(k=0; k!=4; ++k) puts(s[1]), putqs(s[k]), puts(s[2]);
    puts(s[3]);
    
    // выводим последнюю часть prog1...
    puts(
                "\");\n"
                "}\n"
            "\");\n"
            "}\n"
        "\");\n"
        "}\n"
    );
}

/* COMMENT */ // сюда мы будем подвёрстывать какой-нибудь комментарий
#include <stdio.h>
int main()
{
    printf("%s", "CHILD"); // ну а здесь окажется строка, которую надо вывести
}

// начало строки Q1
    //всякие полезности, относящиеся к голове программы
    show(const char* s) {.....} // вывод строки как есть
    escape(const char* s, int n) {.....} // многократное наложение escape
    
    const char* s[6] = // набор литеральных текстов (на самом деле, можно и поштучно, но будет больше писанины ниже)
    {
// конец строки Q1
        "SH", // начало префикса литерального текста, т.е. "\t\""
        "ST", // конец префикса литерального текста, т.е. "\",\n"
        "P1", // первая половина принтера (P1)
        "Q1", // первая половина квайна (Q1)
        "Q2", // вторая половина квайна (Q2)
        "P2", // вторая половина принтера (P1)
// начало строки Q2
    };
    
    int main()
    {
        show(s[2]); // выводим первую половину принтера - совершая однократный unescape c "P1", т.е. получая P1
        
        // помним, что принтер обернул /*QUINE*/ в escape^n - поэтому мы сейчас сделаем то же самое
        escape(s[3],n);
            // и напедалим строк
            for(k=0;k!=6;++k) escape(s[0],n-1), escape(s[k],n), escape(s[1],n-1); // у обрамления, естественно, одним уровнем меньше
        escape(s[4],n);
        
        show(s[5]); // выводим вторую половину принтера
    }
// конец строки Q2

-- принтеры на языках 1..n

e1(s) -- эскейпит строку по правилам языка 1
p1(s) -- рожает программу на языке 1, выводящую данную строку (естественно, эскейпя эту строку на входе)

...

en(s)
pn(s)

pk(s)() = s -- инвариант любого принтера

-- итоговый принтер
eall(s) = e1(e2(...(en(s))...))
pall(s) = p1(p2(...(pn(s))...))

pall(s)()()...() = s -- инвариант мега-принтера

-- решаем уравнение
pall(s) = phead,eall(s),ptail
phead,"TAG",ptail = pall("TAG") -- вот так оно решается (при условии, что eall("TAG")=="TAG")

-- фиксированная точка на языке 0

e0(s) -- эскейпит строку по правилам языка 0
qhead,qprefix,qsuffix,qtail = -- детали программы

quine =
    -- голова
    qhead,
    -- строки
        -- эскейпнутый префикс и суффикс строк
        qprefix,e0( qprefix ),qsuffix,
        qprefix,e0( qsuffix ),qsuffix,
        -- эскейпнутые голова и хвост квайна
        qprefix,e0( qhead ),qsuffix,
        qprefix,e0( qtail ),qsuffix,
        -- эскейпнутые голова и хвост принтера
        qprefix,e0( phead ),qsuffix,
        qprefix,e0( ptail ),qsuffix,
    -- хвост квайна
    qtail

-- 
qhead = <<<
|    ...
|    define e0(s)...
|    define eall(s)...
|    ...
|    strings = {
>>>

qtail = <<<
|    }
|    ...
|    print strings[4]             -- phead
|    print eall(strings[2])       -- eall(qhead)
|    foreach s in strings
|        print eall(strings[0])   --\
|        print eall(e0(s))        -- eall(qprefix,e0(s),qsuffix)
|        print eall(strings[1])   --/
|    print eall(strings[3])       -- eall(qtail)
|    print strings[5]             -- ptail
|    ...
>>>

-- результат работы:
quine()
    = phead, eall(qhead), { eall(qprefix,e0(s),qsuffix) }, eall(qtail), ptail
-- eall() дистрибутивна, поэтому
    = phead, eall( qhead,{qprefix,e0(s),qsuffix},qtail} ), ptail
-- внутри eall получился квайн
    = phead, eall(quine), ptail
-- а снаружи получился принтер на языке 1
    = pall(quine)
    = printer
printer()()...() = pall(quine)()()...() = quine
-- ЧТД

| >++++++++[-<+++++++++++++>]< . | plus(ord('h')), print
| --- .                          | minus(ord('h')-ord('e')), print
| +++++++ .                      | plus(ord('l')-ord('e')), print
| .                              | print
| +++ .                          | plus(ord('o')-ord('l')), print

| >                             | shift
| >++++++++[-<+++++++++++++>]   | plusShift(ord('h')) - оказалось, plusShift даёт более короткий код, чем plus (и тем более plus,print)
| +>++++++++++[-<++++++++++>]   | plusShift(ord('e'))
| +>++++++++++[-<++++++++++>]   | plusShift(ord('l'))
| >+++++++++[-<++++++++++++>]   | plusShift(ord('l'))
| +>++++++++++[-<+++++++++++>]  | plusShift(ord('o'))
| <[<]>                         | shift_left_all - поэтому удобнее сначала всё сконструировать, а потом напечатать
| [.>]                          | print_all

format=".......";
printf(format,escape(format))