puzzle_bg.eps

It uses latex to give question papers

    def
    /AGMCORE_is_cmyk_sep
        AGMCORE_cyan_plate AGMCORE_magenta_plate or AGMCORE_yellow_plate or AGMCORE_black_plate or
    def
    /AGM_avoid_0_cmyk where{
        pop AGM_avoid_0_cmyk
    }{
        AGM_preserve_spots 
        userdict/Adobe_AGM_OnHost_Seps known 
        userdict/Adobe_AGM_InRip_Seps known or
        not and
    }ifelse
    {
        /setcmykcolor[
            {
                4 copy add add add 0 eq currentoverprint and{
                    pop 0.0005
                }if
            }/exec cvx
            /AGMCORE_&setcmykcolor load dup type/operatortype ne{
                /exec cvx
            }if
        ]cvx def
    }if
    /AGMCORE_IsSeparationAProcessColor
        {
        dup (Cyan) eq exch dup (Magenta) eq exch dup (Yellow) eq exch (Black) eq or or or
        }def
    AGMCORE_host_sep{
        /setcolortransfer
        { 
            AGMCORE_cyan_plate{
                pop pop pop
            }{
                AGMCORE_magenta_plate{
                    4 3 roll pop pop pop
                }{
                    AGMCORE_yellow_plate{
                        4 2 roll pop pop pop
                    }{
                        4 1 roll pop pop pop
                    }ifelse
                }ifelse
            }ifelse
            settransfer  
        }   
        def
        /AGMCORE_get_ink_data
            AGMCORE_cyan_plate{
                {pop pop pop}
            }{
                AGMCORE_magenta_plate{
                    {4 3 roll pop pop pop}
                }{
                    AGMCORE_yellow_plate{
                        {4 2 roll pop pop pop}
                    }{
                        {4 1 roll pop pop pop}
                    }ifelse
                }ifelse
            }ifelse
        def
        /AGMCORE_RemoveProcessColorNames
            {
            1 dict begin
            /filtername
                {
                dup /Cyan eq 1 index (Cyan) eq or
                    {pop (_cyan_)}if
                dup /Magenta eq 1 index (Magenta) eq or
                    {pop (_magenta_)}if
                dup /Yellow eq 1 index (Yellow) eq or
                    {pop (_yellow_)}if
                dup /Black eq 1 index (Black) eq or
                    {pop (_black_)}if
                }def
            dup type /arraytype eq
                {[exch {filtername}forall]}
                {filtername}ifelse
            end
            }def
        level3 {
            /AGMCORE_IsCurrentColor
                {
                dup AGMCORE_IsSeparationAProcessColor
                    {
                    AGMCORE_plate_ndx 0 eq
                        {dup (Cyan) eq exch /Cyan eq or}if
                    AGMCORE_plate_ndx 1 eq
                        {dup (Magenta) eq exch /Magenta eq or}if
                    AGMCORE_plate_ndx 2 eq
                        {dup (Yellow) eq exch /Yellow eq or}if
                    AGMCORE_plate_ndx 3 eq
                        {dup (Black) eq exch /Black eq or}if
                    AGMCORE_plate_ndx 4 eq
                        {pop false}if
                    }{
                    gsave
                    false setoverprint
                    current_spot_alias false set_spot_alias
                    1 1 1 1 6 -1 roll findcmykcustomcolor 1 setcustomcolor
                    set_spot_alias
                    currentgray 1 ne
                    grestore
                    }ifelse
                }def
            /AGMCORE_filter_functiondatasource
                {   
                5 dict begin
                /data_in xdf
                data_in type /stringtype eq
                    {
                    /ncomp xdf
                    /comp xdf
                    /string_out data_in length ncomp idiv string def
                    0 ncomp data_in length 1 sub
                        {
                        string_out exch dup ncomp idiv exch data_in exch ncomp getinterval comp get 255 exch sub put
                        }for
                    string_out
                    }{
                    string /string_in xdf
                    /string_out 1 string def
                    /component xdf
                    [
                    data_in string_in /readstring cvx
                        [component /get cvx 255 /exch cvx /sub cvx string_out /exch cvx 0 /exch cvx /put cvx string_out]cvx
                        [/pop cvx ()]cvx /ifelse cvx
                    ]cvx /ReusableStreamDecode filter
                }ifelse
                end
                }def
            /AGMCORE_separateShadingFunction
                {
                2 dict begin
                /paint? xdf
                /channel xdf
                dup type /dicttype eq
                    {
                    begin
                    FunctionType 0 eq
                        {
                        /DataSource channel Range length 2 idiv DataSource AGMCORE_filter_functiondatasource def
                        currentdict /Decode known
                            {/Decode Decode channel 2 mul 2 getinterval def}if
                        paint? not
                            {/Decode [1 1]def}if
                        }if
                    FunctionType 2 eq
                        {
                        paint?
                            {
                            /C0 [C0 channel get 1 exch sub] def
                            /C1 [C1 channel get 1 exch sub] def
                            }{
                            /C0 [1] def
                            /C1 [1] def
                            }ifelse         
                        }if
                    FunctionType 3 eq
                        {
                        /Functions [Functions {channel paint? AGMCORE_separateShadingFunction} forall] def          
                        }if
                    currentdict /Range known
                        {/Range [0 1] def}if
                    currentdict
                    end}{
                    channel get 0 paint? AGMCORE_separateShadingFunction
                    }ifelse
                end
                }def
            /AGMCORE_separateShading
                {
                3 -1 roll begin
                currentdict /Function known
                    {
                    currentdict /Background known
                        {[1 index{Background 3 index get 1 exch sub}{1}ifelse]/Background xdf}if
                    Function 3 1 roll AGMCORE_separateShadingFunction /Function xdf
                    /ColorSpace [/DeviceGray] def
                    }{
                    ColorSpace dup type /arraytype eq {0 get}if /DeviceCMYK eq
                        {
                        /ColorSpace [/DeviceN [/_cyan_ /_magenta_ /_yellow_ /_black_] /DeviceCMYK {}] def
                        }{
                        ColorSpace dup 1 get AGMCORE_RemoveProcessColorNames 1 exch put
                        }ifelse
                    ColorSpace 0 get /Separation eq
                        {
                            {
                                [1 /exch cvx /sub cvx]cvx
                            }{
                                [/pop cvx 1]cvx
                            }ifelse
                            ColorSpace 3 3 -1 roll put
                            pop
                        }{
                            {
                                [exch ColorSpace 1 get length 1 sub exch sub /index cvx 1 /exch cvx /sub cvx ColorSpace 1 get length 1 add 1 /roll cvx ColorSpace 1 get length{/pop cvx} repeat]cvx
                            }{
                                pop [ColorSpace 1 get length {/pop cvx} repeat cvx 1]cvx
                            }ifelse
                            ColorSpace 3 3 -1 roll bind put
                        }ifelse
                    ColorSpace 2 /DeviceGray put                                                                        
                    }ifelse
                end
                }def
            /AGMCORE_separateShadingDict
                {
                dup /ColorSpace get
                dup type /arraytype ne
                    {[exch]}if
                dup 0 get /DeviceCMYK eq
                    {
                    exch begin 
                    currentdict
                    AGMCORE_cyan_plate
                        {0 true}if
                    AGMCORE_magenta_plate
                        {1 true}if
                    AGMCORE_yellow_plate
                        {2 true}if
                    AGMCORE_black_plate
                        {3 true}if
                    AGMCORE_plate_ndx 4 eq
                        {0 false}if     
                    dup not currentoverprint and
                        {/AGMCORE_ignoreshade true def}if
                    AGMCORE_separateShading
                    currentdict
                    end exch
                    }if
                dup 0 get /Separation eq
                    {
                    exch begin
                    ColorSpace 1 get dup /None ne exch /All ne and
                        {
                        ColorSpace 1 get AGMCORE_IsCurrentColor AGMCORE_plate_ndx 4 lt and ColorSpace 1 get AGMCORE_IsSeparationAProcessColor not and
                            {
                            ColorSpace 2 get dup type /arraytype eq {0 get}if /DeviceCMYK eq 
                                {
                                /ColorSpace
                                    [
                                    /Separation
                                    ColorSpace 1 get
                                    /DeviceGray
                                        [
                                        ColorSpace 3 get /exec cvx
                                        4 AGMCORE_plate_ndx sub -1 /roll cvx
                                        4 1 /roll cvx
                                        3 [/pop cvx]cvx /repeat cvx
                                        1 /exch cvx /sub cvx
                                        ]cvx                                    
                                    ]def
                                }{
                                AGMCORE_report_unsupported_color_space
                                AGMCORE_black_plate not
                                    {
                                    currentdict 0 false AGMCORE_separateShading
                                    }if
                                }ifelse
                            }{
                            currentdict ColorSpace 1 get AGMCORE_IsCurrentColor
                            0 exch 
                            dup not currentoverprint and
                                {/AGMCORE_ignoreshade true def}if
                            AGMCORE_separateShading
                            }ifelse 
                        }if         
                    currentdict
                    end exch
                    }if
                dup 0 get /DeviceN eq
                    {
                    exch begin
                    ColorSpace 1 get convert_to_process
                        {
                        ColorSpace 2 get dup type /arraytype eq {0 get}if /DeviceCMYK eq 
                            {
                            /ColorSpace
                                [
                                /DeviceN
                                ColorSpace 1 get
                                /DeviceGray
                                    [
                                    ColorSpace 3 get /exec cvx
                                    4 AGMCORE_plate_ndx sub -1 /roll cvx
                                    4 1 /roll cvx
                                    3 [/pop cvx]cvx /repeat cvx
                                    1 /exch cvx /sub cvx
                                    ]cvx                                    
                                ]def
                            }{
                            AGMCORE_report_unsupported_color_space
                            AGMCORE_black_plate not
                                {
                                currentdict 0 false AGMCORE_separateShading
                                /ColorSpace [/DeviceGray] def
                                }if
                            }ifelse
                        }{
                        currentdict
                        false -1 ColorSpace 1 get
                            {
                            AGMCORE_IsCurrentColor
                                {
                                1 add
                                exch pop true exch exit
                                }if
                            1 add
                            }forall
                        exch 
                        dup not currentoverprint and
                            {/AGMCORE_ignoreshade true def}if
                        AGMCORE_separateShading
                        }ifelse
                    currentdict
                    end exch
                    }if
                dup 0 get dup /DeviceCMYK eq exch dup /Separation eq exch /DeviceN eq or or not
                    {
                    exch begin
                    ColorSpace dup type /arraytype eq
                        {0 get}if
                    /DeviceGray ne
                        {
                        AGMCORE_report_unsupported_color_space
                        AGMCORE_black_plate not
                            {
                            ColorSpace 0 get /CIEBasedA eq
                                {
                                /ColorSpace [/Separation /_ciebaseda_ /DeviceGray {}] def
                                }if
                            ColorSpace 0 get dup /CIEBasedABC eq exch dup /CIEBasedDEF eq exch /DeviceRGB eq or or
                                {
                                /ColorSpace [/DeviceN [/_red_ /_green_ /_blue_] /DeviceRGB {}] def
                                }if
                            ColorSpace 0 get /CIEBasedDEFG eq
                                {
                                /ColorSpace [/DeviceN [/_cyan_ /_magenta_ /_yellow_ /_black_] /DeviceCMYK {}] def
                                }if
                            currentdict 0 false AGMCORE_separateShading
                            }if
                        }if
                    currentdict
                    end exch
                    }if
                pop
                dup /AGMCORE_ignoreshade known
                    {
                    begin
                    /ColorSpace [/Separation (None) /DeviceGray {}] def
                    currentdict end
                    }if
                }def
            /shfill
                {
                AGMCORE_separateShadingDict 
                dup /AGMCORE_ignoreshade known
                    {pop}
                    {AGMCORE_&sysshfill}ifelse
                }def
            /makepattern
                {
                exch
                dup /PatternType get 2 eq
                    {
                    clonedict
                    begin
                    /Shading Shading AGMCORE_separateShadingDict def
                    Shading /AGMCORE_ignoreshade known
                    currentdict end exch
                    {pop <</PatternType 1/PaintProc{pop}/BBox[0 0 1 1]/XStep 1/YStep 1/PaintType 1/TilingType 3>>}if
                    exch AGMCORE_&sysmakepattern
                    }{
                    exch AGMCORE_&usrmakepattern
                    }ifelse
                }def
        }if
    }if
    AGMCORE_in_rip_sep{
        /setcustomcolor
        {
            exch aload pop
            dup 7 1 roll inRip_spot_has_ink not { 
                4 {4 index mul 4 1 roll}
                repeat
                /DeviceCMYK setcolorspace
                6 -2 roll pop pop
            }{ 
                //Adobe_AGM_Core begin
                    /AGMCORE_k xdf /AGMCORE_y xdf /AGMCORE_m xdf /AGMCORE_c xdf
                end
                [/Separation 4 -1 roll /DeviceCMYK
                {dup AGMCORE_c mul exch dup AGMCORE_m mul exch dup AGMCORE_y mul exch AGMCORE_k mul}
                ]
                setcolorspace
            }ifelse
            setcolor
        }ndf
        /setseparationgray
        {
            [/Separation (All) /DeviceGray {}] setcolorspace_opt
            1 exch sub setcolor
        }ndf
    }{