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

char *lena =
    "	{k/;	y{ q ; }	c {	@;	={ 	S}	c}	W;"
    ";	{4}	k |; w{	+9;{;	8; 9{	S;	/}	y{ K}	{"
    ";}	l{	{ ~{ ;	V}k}g< t{	E	v;M{ B}y}	<{7;"
    "/;	Y} t}kp; Y} $Ha{e} w};} R} /{>}a	;} "
    ";	`	$W-}	D}B; e;f;*;	~;A;s O{	o;>{1; m{ `} "
    "R}]{ T} v}={ I} ; }a?&; A}$;W;R{u} `; j}W;s{e}	A;"
    "[	R;	X  P; 4 ,F;({<8{#;%}@J{)}	}o^*{u/{'}"
    "]{	*}	
}	;{ r}	f	/;}e} }w{ ${{;,; @ "
    "d	$}];>(}	I{ d}	&;	U}	{	y;Y}	{ P{	R} T}"
    "_{ }R } l	{ T}"
    "';	|; ${=}	H} (}}8{cp{ s} #}+}	3}kF}<H	 .{ }"
    "G}x;	r	D c{; W; {	b;6; k{}B;*};	]} ~	{ ;"
    ";} !}}	x}v}n;^;	6V}Y{ h; ~	%*}! H; G{ r{ f;Y{ i}z} N "
    " %}.{;	( 	v} _}	h; 7;<}	^;Z;0; ;	<;<; M; N{"
    "	}	_{O} !{f{]{M{;A{}	0;S}${	@;x}y}"
    "@	L;1	t{ 3{c{s{_{	`{	D{ ]}!;	${	_J;v+ "
    "}	3{B; ]{	}	E6	.x{?+; {x; }v{$};6}T; O; "
    "; (}X7}	j; @} :}#	c{ !{ }x	KXt} >; ?{ c; ;	"
    "W;	; l;} h}p}	i{ %	}P}	/{	*}	%L; ;	!{ S{ n} "
    "x;  { 1	J;v{	U}({	@ X{ k} H;4;e J	6;;v; G{{"
    "]	&{A d{ lM{;K;;	4-{}} p h{;	{	rW;	v{;	"
    "f}	}1{^&{9{{ ;~;n;q{	9 R	6{	{ u;a;	;	"
    "U;	;Y}	+}}2sk; 8	{	JK;'i;	;$;	W{	P!{"
    "{{P	} [;	(;Q; Un;+}g{C;
{{	; <{	vS} b;6`"
    "} ?{+	%;	}n;q{ r}k; ;{c{ S} 2}~{	4;RW v} "
    "R;	kI}|; 
d; [ O}5; ;;}Z d	{ {&;h	o{ V	v "
    ";	_{{/}  F{f{r{4{{?{ 4;S}	:;];E}	;	&} #e "
    "!{>{H; {O{ 0;} H;	p; w}
>{1}{	-} 4;"
    "S}}	u L{ y} %;2  |{(}	/;,{ )}Y;g}	G}v;"
    "T}	};}i {{};[{ E{q} g;T{ ={}R;	k{ j;_;h}gPc;({	F;"
    "6}	}} 3	,}<; 0	 P;{'t}u};		}U}s{8{ E} >{}"
    "E	{G{H :{  Yog}	}F  D{ R{	 -;M?;= q}_ U	{ "
    ";	 I	{ |{{}	 	1{,}{ x{{ U{ s;J}}
	6{>7"
    ";,{ D{	{{ ;]}	;M; &}{ V}	n{&	T~;({	}[;	r{"
    "#	u{X 9;L; Uf})}   {T}		p{	N;	>{	"
    ">	
}}D} m{1{	{}X; o}	w}$}	^v} K  f	"
    ",}	^3; { @{_} _{	o;	4}	h}H;#.{	{}	"
    ";	<{ {G{ $;{ "
    "z {a{{D;	?|}{{ ;	`} }	Q}j;4} 	3{Q}	"
    "{	* ;}r{a}	} R{p @;  N{ {f; A;8}L	$}{ }}J{ "
    "}	k{r} { [; -;p{	I{ {	&}J;	T}	?{Z{>;	5>; "
    "];  wz ^}	u;);	H}	; L	&;	V	E{1{g;C} "
    "V} ~;U; ^{	J; { /}	{;(}y} aK /}	.};K;N{w{ "
    "`{	}T{l`; #;N{lX;	?; +}{ 	w{	;	q;	z;_;"
    "y} 8} 	&{X}	V{ WG}	,; [}U{	v{	Q;	w{	["
    "	Y}N	Yu i{ {!A{}{ b0;	X~} ;-; 8{	E }	;F{	y{}"
    "{	";

int image[ 3 ][ 1 << 20 ];
int buffer[ 2048 ];
int models[ 166 ];
int fraction;
int range = 1;
int width;
int radix;
int luma;
int chroma;

void renormalize_and_read()
{
    range *= radix;
    fraction *= radix;
    if ( radix >> 9 )
    {
        int byte;
        if ( byte = *lena )
        {
            fraction += byte - 1 -
                ( byte > 10 ) - ( byte > 13 ) -
                ( byte > 34 ) - ( byte > 92 ) << 4;
            byte = lena[ 1 ];
            lena += 2;
            fraction += byte < 33 ? ( byte ^ 8 ) * 2 % 5 :
                ( byte ^ 6 ) % 3 * 4 + ( *lena++ ^ 8 ) * 2 % 5 + 4;
        }
    }
    else
    {
        int byte = getchar();
        fraction += byte < 0 ? 0 : byte;
    }
}

int decode_bit( int context )
{
    if ( range < radix )
        renormalize_and_read();
    int *counts = models + context * 2;
    int observations = *counts + counts[ 1 ] + 2;
    int split = range * ( *counts + 1 ) / observations;
    int bit = fraction >= split;
    if ( bit )
    {
        fraction -= split;
        range -= split;
    }
    else
        range = split;
    counts[ bit ]++;
    if ( observations > 63 )
    {
        *counts /= 2;
        counts[ 1 ] /= 2;
    }
    return bit;
}

int decode_unsigned( int context )
{
    int length = 0;
    while ( !decode_bit( context + length ) )
        length++;
    int value = 1;
    while ( length-- )
        value = value << 1 | decode_bit( 4 );
    return value - 1;
}

void compute_idct( int *samples, int point_stride,
                   int *coefficients, int frequency_stride,
                   int sequence_stride, int size, int scale )
{
    for ( int sequence = 0; sequence < size; sequence++ )
        for ( int point = 0; point < size; point++ )
        {
            int sum = 0;
            for ( int frequency = 0; frequency < size; frequency++ )
                sum += coefficients[ frequency * frequency_stride +
                                     sequence * sequence_stride ] *
                    lrint( cos( acos( -1 ) / size *
                                ( point + 0.5 ) * frequency ) *
                           sqrt( 2 - !frequency ) * 1024 );
            samples[ point * point_stride +
                     sequence * sequence_stride ] =
                sum + ( 1 << scale - 1 ) >> scale;
        }
}

void extract_block( int left, int top, int level )
{
    if ( level > 5 || level > 2 && decode_bit( level - 3 ) )
    {
        int size = 1 << --level;
        for ( int corner = 0; corner < 4; corner++ )
            extract_block( left + corner % 2 * size,
                           top  + corner / 2 * size,
                           level );
    }
    else
    {
        int size = 1 << level;
        int area = size * size;
        int predictor = decode_unsigned( 73 );
        for ( int channel = 0; channel < 3; channel++ )
        {
            int *output = image[ channel ] + top * width + left;
            int is_chroma = channel > 0;
            for ( int coefficient = 0; coefficient < area; coefficient++ )
                buffer[ coefficient ] = 0;
            for ( int coefficient = 0; coefficient < area; coefficient++ )
            {
                if ( decode_bit( 61 + level * 2 + is_chroma ) )
                    break;
                coefficient += decode_unsigned( 5 + is_chroma * 10 );
                int sign = 1 - 2 * decode_bit( 3 );
                buffer[ coefficient ] =
                    sign *
                    ( decode_unsigned( 25 + ( is_chroma + (
                        coefficient < area / 8 ) * 2 ) * 10 ) + 1 ) *
                    ( channel ? chroma : luma );
            }
            if ( !predictor )
            {
                int dc = 0;
                for ( int pixel = 0; pixel < size; pixel++ )
                {
                    dc += top ? output[ -width + pixel ] : 0;
                    dc += left ? output[ pixel * width - 1 ] : 0;
                }
                *buffer += left && top ? dc / 2 : dc;
            }
            compute_idct( buffer + area, 1, buffer, 1, size,
                          size, 10 );
            compute_idct( output, width, buffer + area, size, 1,
                          size, 10 + level );
            if ( predictor )
            {
                int is_leftward = predictor < 17;
                int slope = is_leftward ? 9 - predictor : predictor - 25;
                for ( int y = 0; y < size; y++ )
                    for ( int x = 0; x < size; x++ )
                    {
                        int weight;
                        for ( int neighbor = 0; neighbor < 2; neighbor++ )
                        {
                            int reference = y * slope + slope;
                            weight = reference & 7;
                            reference = ( reference >> 3 ) + x + neighbor;
                            int is_clipped = reference < 0;
                            if ( is_clipped )
                                reference = (
                                    reference * 8 + slope / 2 ) / slope - 2;
                            reference = reference < size ?
                                reference : size - 1;
                            buffer[ neighbor ] = is_clipped ^ is_leftward ?
                                output[ reference * width - 1 ] :
                                output[ -width + reference ];
                        }
                        output[ is_leftward ? x * width + y :
                                              y * width + x ] +=
                            *buffer * ( 8 - weight ) +
                            buffer[ 1 ] * weight + 4 >> 3;
                    }
            }
        }
    }
}

int write_byte_clamped( int byte )
{
    putchar( byte < 0 ? 0 : byte > 255 ? 255 : byte );
}

int main( int argc )
{
    radix = argc > 1 ? 256 : 1968;
    renormalize_and_read();
    int level = decode_unsigned( 5 );
    width = 1 << level;
    int height = width - decode_unsigned( 5 );
    luma = decode_unsigned( 5 );
    chroma = decode_unsigned( 5 );
    extract_block( 0, 0, level );
    printf( "P6 %d %d 255 ", width, height );
    for ( int pixel = 0; pixel < height * width; pixel++ )
    {
        int Y  = image[ 0 ][ pixel ];
        int Cg = image[ 1 ][ pixel ];
        int Co = image[ 2 ][ pixel ];
        int temporary = Y - Cg;
        write_byte_clamped( temporary + Co );
        write_byte_clamped( Y         + Cg );
        write_byte_clamped( temporary - Co );
    }
    return 0;
}