puzzle_bg.eps

It uses latex to give question papers

        /setseparationgray
        {
            AGMCORE_&setgray
        }ndf
    }ifelse
    /findcmykcustomcolor
    {
        5 makereadonlyarray
    }ndf
    /setcustomcolor
    {
        exch aload pop pop
        4 {4 index mul 4 1 roll} repeat
        setcmykcolor pop
    }ndf
    /has_color
        /colorimage where{
            AGMCORE_producing_seps{
                pop true
            }{
                systemdict eq
            }ifelse
        }{
            false
        }ifelse
    def
    /map_index
    {
        1 index mul exch getinterval {255 div} forall
    } bdf
    /map_indexed_devn
    {
        Lookup Names length 3 -1 roll cvi map_index
    } bdf
    /n_color_components
    {
        base_colorspace_type
        dup /DeviceGray eq{
            pop 1
        }{
            /DeviceCMYK eq{
                4
            }{
                3
            }ifelse
        }ifelse
    }bdf
    level2{
        /mo /moveto ldf
        /li /lineto ldf
        /cv /curveto ldf
        /knockout_unitsq
        {
            1 setgray
            0 0 1 1 rectfill
        }def
        level2 /setcolorspace AGMCORE_key_known not and{
            /AGMCORE_&&&setcolorspace /setcolorspace ldf
            /AGMCORE_ReplaceMappedColor
            {
                dup type dup /arraytype eq exch /packedarraytype eq or
                {
                    /AGMCORE_SpotAliasAry2 where {
                        begin
                        dup 0 get dup /Separation eq
                        {
                            pop
                            dup length array copy
                            dup dup 1 get
                            current_spot_alias
                            {
                                dup map_alias
                                {
                                    false set_spot_alias
                                    dup 1 exch setsepcolorspace
                                    true set_spot_alias
                                    begin
                                    /sep_colorspace_dict currentdict AGMCORE_gput
                                    pop pop pop
                                    [ 
                                        /Separation Name 
                                        CSA map_csa
                                        MappedCSA 
                                        /sep_colorspace_proc load
                                    ]
                                    dup Name
                                    end
                                }if
                            }if
                            map_reserved_ink_name 1 xpt
                        }{
                            /DeviceN eq 
                            {
                                dup length array copy
                                dup dup 1 get [ 
                                    exch {
                                        current_spot_alias{
                                            dup map_alias{
                                                /Name get exch pop
                                            }if
                                        }if
                                        map_reserved_ink_name
                                    } forall 
                                ] 1 xpt
                            }if
                        }ifelse
                        end
                    } if
                }if
            }def
            /setcolorspace
            {
                dup type dup /arraytype eq exch /packedarraytype eq or
                {
                    dup 0 get /Indexed eq
                    {
                        AGMCORE_distilling
                        {
                            /PhotoshopDuotoneList where
                            {
                                pop false
                            }{
                                true
                            }ifelse
                        }{
                            true
                        }ifelse
                        {
                            aload pop 3 -1 roll
                            AGMCORE_ReplaceMappedColor
                            3 1 roll 4 array astore
                        }if
                    }{
                        AGMCORE_ReplaceMappedColor
                    }ifelse
                }if
                DeviceN_PS2_inRip_seps {AGMCORE_&&&setcolorspace} if
            }def
        }if 
    }{
        /adj
        {
            currentstrokeadjust{
                transform
                0.25 sub round 0.25 add exch
                0.25 sub round 0.25 add exch
                itransform
            }if
        }def
        /mo{
            adj moveto
        }def
        /li{
            adj lineto
        }def
        /cv{
            6 2 roll adj
            6 2 roll adj
            6 2 roll adj curveto
        }def
        /knockout_unitsq
        {
            1 setgray
            8 8 1 [8 0 0 8 0 0] {<ffffffffffffffff>} image
        }def
        /currentstrokeadjust{
            /currentstrokeadjust AGMCORE_gget
        }def
        /setstrokeadjust{
            /currentstrokeadjust exch AGMCORE_gput
        }def
        /setcolorspace
        {
            /currentcolorspace exch AGMCORE_gput
        } def
        /currentcolorspace
        {
            /currentcolorspace AGMCORE_gget
        } def
        /setcolor_devicecolor
        {
            base_colorspace_type
            dup /DeviceGray eq{
                pop setgray
            }{
                /DeviceCMYK eq{
                    setcmykcolor
                }{
                    setrgbcolor
                }ifelse
            }ifelse
        }def
        /setcolor
        {
            currentcolorspace 0 get
            dup /DeviceGray ne{
                dup /DeviceCMYK ne{
                    dup /DeviceRGB ne{
                        dup /Separation eq{
                            pop
                            currentcolorspace 3 get exec
                            currentcolorspace 2 get
                        }{
                            dup /Indexed eq{
                                pop
                                currentcolorspace 3 get dup type /stringtype eq{
                                    currentcolorspace 1 get n_color_components
                                    3 -1 roll map_index
                                }{
                                    exec
                                }ifelse
                                currentcolorspace 1 get
                            }{
                                /AGMCORE_cur_err /AGMCORE_invalid_color_space def
                                AGMCORE_invalid_color_space
                            }ifelse
                        }ifelse
                    }if
                }if
            }if
            setcolor_devicecolor
        } def
    }ifelse
    /sop /setoverprint ldf
    /lw /setlinewidth ldf
    /lc /setlinecap ldf
    /lj /setlinejoin ldf
    /ml /setmiterlimit ldf
    /dsh /setdash ldf
    /sadj /setstrokeadjust ldf
    /gry /setgray ldf
    /rgb /setrgbcolor ldf
    /cmyk /setcmykcolor ldf
    /sep /setsepcolor ldf
    /devn /setdevicencolor ldf
    /idx /setindexedcolor ldf
    /colr /setcolor ldf
    /csacrd /set_csa_crd ldf
    /sepcs /setsepcolorspace ldf
    /devncs /setdevicencolorspace ldf
    /idxcs /setindexedcolorspace ldf
    /cp /closepath ldf
    /clp /clp_npth ldf
    /eclp /eoclp_npth ldf
    /f /fill ldf
    /ef /eofill ldf
    /@ /stroke ldf
    /nclp /npth_clp ldf
    /gset /graphic_setup ldf
    /gcln /graphic_cleanup ldf
    /AGMCORE_def_ht currenthalftone def
    /clonedict Adobe_AGM_Utils begin /clonedict load end def
    /clonearray Adobe_AGM_Utils begin /clonearray load end def
    currentdict{
        dup xcheck 1 index type dup /arraytype eq exch /packedarraytype eq or and {
            bind
        }if
        def
    }forall
    /getrampcolor
    { 
        /indx exch def
        0 1 NumComp 1 sub
        {
            dup
            Samples exch get
            dup type /stringtype eq {indx get} if
            exch
            Scaling exch get aload pop
            3 1 roll
            mul add
        } for
        ColorSpaceFamily /Separation eq 
        {sep}
        {
            ColorSpaceFamily /DeviceN eq
            {devn} {setcolor}ifelse
        }ifelse
    } bdf
    /sssetbackground {aload pop setcolor} bdf
    /RadialShade
    {
        40 dict begin
        /ColorSpaceFamily xdf
        /background xdf
        /ext1 xdf
        /ext0 xdf
        /BBox xdf
        /r2 xdf
        /c2y xdf
        /c2x xdf
        /r1 xdf
        /c1y xdf
        /c1x xdf
        /rampdict xdf
        /setinkoverprint where {pop /setinkoverprint{pop}def}if
        gsave
        BBox length 0 gt
        {
            newpath
            BBox 0 get BBox 1 get moveto
            BBox 2 get BBox 0 get sub 0 rlineto
            0 BBox 3 get BBox 1 get sub rlineto
            BBox 2 get BBox 0 get sub neg 0 rlineto
            closepath
            clip
            newpath
        } if
        c1x c2x eq
        {
            c1y c2y lt {/theta 90 def}{/theta 270 def} ifelse
        }
        {
            /slope c2y c1y sub c2x c1x sub div def
            /theta slope 1 atan def
            c2x c1x lt c2y c1y ge and { /theta theta 180 sub def} if
            c2x c1x lt c2y c1y lt and { /theta theta 180 add def} if
        } ifelse
        gsave
        clippath
        c1x c1y translate
        theta rotate
        -90 rotate
        { pathbbox } stopped
        { 0 0 0 0 } if
        /yMax xdf
        /xMax xdf
        /yMin xdf
        /xMin xdf
        grestore
        xMax xMin eq yMax yMin eq or
        {
            grestore
            end
        }
        {
            /max { 2 copy gt { pop } {exch pop} ifelse } bdf
            /min { 2 copy lt { pop } {exch pop} ifelse } bdf
            rampdict begin
            40 dict begin
            background length 0 gt { background sssetbackground gsave clippath fill grestore } if
            gsave
            c1x c1y translate
            theta rotate
            -90 rotate
            /c2y c1x c2x sub dup mul c1y c2y sub dup mul add sqrt def
            /c1y 0 def
            /c1x 0 def
            /c2x 0 def
            ext0
            {
                0 getrampcolor
                c2y r2 add r1 sub 0.0001 lt
                {
                    c1x c1y r1 360 0 arcn
                    pathbbox
                    /aymax exch def
                    /axmax exch def
                    /aymin exch def
                    /axmin exch def
                    /bxMin xMin axmin min def
                    /byMin yMin aymin min def
                    /bxMax xMax axmax max def
                    /byMax yMax aymax max def
                    bxMin byMin moveto
                    bxMax byMin lineto
                    bxMax byMax lineto
                    bxMin byMax lineto
                    bxMin byMin lineto
                    eofill
                }
                {
                    c2y r1 add r2 le
                    {
                        c1x c1y r1 0 360 arc
                        fill
                    }
                    {
                        c2x c2y r2 0 360 arc fill
                        r1 r2 eq
                        {
                            /p1x r1 neg def
                            /p1y c1y def
                            /p2x r1 def
                            /p2y c1y def
                            p1x p1y moveto p2x p2y lineto p2x yMin lineto p1x yMin lineto
                            fill
                        }
                        {
                            /AA r2 r1 sub c2y div def
                            AA -1 eq
                            { /theta 89.99 def}
                            { /theta AA 1 AA dup mul sub sqrt div 1 atan def}
                            ifelse
                            /SS1 90 theta add dup sin exch cos div def
                            /p1x r1 SS1 SS1 mul SS1 SS1 mul 1 add div sqrt mul neg def
                            /p1y p1x SS1 div neg def
                            /SS2 90 theta sub dup sin exch cos div def
                            /p2x r1 SS2 SS2 mul SS2 SS2 mul 1 add div sqrt mul def
                            /p2y p2x SS2 div neg def
                            r1 r2 gt
                            {
                                /L1maxX p1x yMin p1y sub SS1 div add def