%!PS-Adobe-3.0 Resource-Font
%%Creator: Taiji Yamada <taiji@aihara.co.jp> and gs-cjk project
%%BeginResource: Font (Ryumin-Light-V)
%%Copyright:	--------------------------------------------------------
%%Copyright:	Copyright (C) 2002 gs-cjk project. All rights reserved.
%%Copyright:	
%%Copyright:	This file is provided under "BSD" license.
%%Copyright:	For the detail of "BSD" license, please refer
%%Copyright:	http://www.gyve.org/gs-cjk/license.html
%%Copyright:	--------------------------------------------------------
/Ryumin-Light-V
30 dict begin
/basecidfont /Ryumin-Light def

/concat2strings { % str1 str2 concat2strings str
  2 { dup type /stringtype ne { dup length string cvs } if exch } repeat
  exch dup length 3 2 roll dup length 2 index add string 0 5 1 roll
  2 { dup 4 2 roll putinterval } repeat
} bind def

/concats { % [str ...] concats string
  () exch dup length 1 sub -1 0 {
    1 index exch get 3 -1 roll concat2strings exch
  } for pop
} bind def

/strcmp { % s1 s2 strcmp integer
  1 index length 1 index length 2 copy gt { exch } if pop	% s1 s2 lmin
  0 exch 1 sub 0 1 3 -1 roll {	% s1 s2 0 0 1 lmin-1 {} for
				% s1 s2 0 i s1[i]-s2[i] s1[i]-s2[i]=0
    3 index 1 index get 3 index 2 index get sub dup 0 eq {
      pop pop			% s1 s2 0
    } {
      3 1 roll pop pop exit	% s1 s2 s1[i]-s2[i]
    } ifelse
  } for 3 1 roll pop pop	% s1[i]-s2[i]
} bind def

/stringsub { % s1 s2 stringsub string bool
  true 3 1 roll				% true s1 s2
  1 index length 1 index length 2 copy ne {
    2 copy gt {				% true s1 s2 l1 l2 l1>l2
      %sub string exch concat2strings	% true s1 str(l1-l2)+s2
      sub string concat2strings		% true s1 s2+str(l1-l2)
    } {					% true s1 s2 l1 l2 l1<l2
      exch sub string 3 -1 roll		% true s2 str(l2-l1) s1
      %concat2strings exch		% true str(l2-l1)+s1 s2
      exch concat2strings exch		% true s1+str(l2-l1) s2
    } ifelse dup length			% true s1 s2 L
  } { pop } ifelse			% true s1 s2 L
  dup string 4 1 roll 1 sub -1 0 {	% true s s1 s2 L-1 -1 0 {} for
    2 index 1 index get
    2 index 2 index get sub		% true s s1 s2 i s1[i]-s2[i]
    4 index 2 index get sub		% true s s1 s2 i s1[i]-s2[i]-s[i]
    dup 0 lt {				% true s s1 s2 i d
      16#0100 add			% true s s1 s2 i d'
      4 index 2 index 3 -1 roll put	% true s s1 s2 i (s i d' put)
      1 sub				% true s s1 s2 i-1
      dup 0 lt { pop
        4 -1 roll pop false 4 1 roll	% false s s1 s2
        2 index length 1 sub -1 0 {	% false s s1 s2 i
          3 index 1 index get		% false s s1 s2 i s[i]
          16#ff exch sub		% false s s1 s2 i s'[i]
          4 index 3 1 roll put		% false s s1 s2 (s i s'[i] put)
        } for
      } {
        1 4 index 3 1 roll put		% true s s1 s2 (s i-1 1 put)
      } ifelse
    } {
      4 index 3 1 roll put		% true s s1 s2 (s i s1[i]-s2[i] put)
    } ifelse
  } for pop pop				% bool s
  exch					% s bool
} bind def

/strsub { % s1 s2 strsub integer
  stringsub exch			% (s1 s2 stringsub exch)bool string
  0 exch { exch 8 bitshift add } forall	% bool value
  exch not { not } if			% value|co-value
} bind def

/stringadd { % s1 s2 stringadd string bool
  true 3 1 roll				% true s1 s2
  1 index length 1 index length 2 copy ne {
    2 copy gt {				% true s1 s2 l1 l2 l1>l2
      %sub string exch concat2strings	% true s1 str(l1-l2)+s2
      sub string concat2strings		% true s1 s2+str(l1-l2)
    } {					% true s1 s2 l1 l2 l1<l2
      exch sub string 3 -1 roll		% true s2 str(l2-l1) s1
      %concat2strings exch		% true str(l2-l1)+s1 s2
      exch concat2strings exch		% true s1+str(l2-l1) s2
    } ifelse dup length			% true s1 s2 L
  } { pop } ifelse			% true s1 s2 L
  dup string 4 1 roll 1 sub -1 0 {	% true s s1 s2 L-1 -1 0 {} for
    2 index 1 index get
    2 index 2 index get add		% true s s1 s2 i s1[i]+s2[i]
    4 index 2 index get add		% true s s1 s2 i s1[i]+s2[i]+s[i]
    dup 16#ff gt {			% true s s1 s2 i d
      16#0100 sub			% true s s1 s2 i d'
      4 index 2 index 3 -1 roll put	% true s s1 s2 i (s i d' put)
      1 sub				% true s s1 s2 i-1
      dup 0 lt { pop
        4 -1 roll pop false 4 1 roll	% false s s1 s2
      } {
        1 4 index 3 1 roll put		% true s s1 s2 (s i-1 1 put)
      } ifelse
    } {
      4 index 3 1 roll put		% true s s1 s2 (s i s1[i]-s2[i] put)
    } ifelse
  } for pop pop				% bool s
  exch					% s bool
} bind def

/stradd { % s1 s2 stradd integer
  stringadd				% (s1 s2 stringadd)string bool
  not { <01> exch concat2strings } if	% !bool { <01>+string } if
  0 exch { exch 8 bitshift add } forall	% value
} bind def

/markstacktoarray { % mark d11..d1n ... n markstacktoarray
  % mark d11..d1n ... n array[N/n] N/n-1 -1 0 {} for 
  counttomark 1 sub 1 index idiv array dup length 1 sub -1 0 {
    % mark d11..d1n ... dN1...dNn n array[N/n] (array[N/n] i [5+n -n roll] put)
    1 index exch [ 5 5 index add 5 index neg roll ] put
  } for 3 1 roll pop pop	% mark n array[N/n]
} bind def

/stacktoarray { % d11..d1n ... dN1..dNn N n stacktoarray
  % d11..d1n ... n array[N] N-1 -1 0 {} for 
  exch array dup length 1 sub -1 0 {
    % d11..d1n ... dN1...dNn n array[N] (array[N] i [5+n -n roll] put)
    1 index exch [ 5 5 index add 5 index neg roll ] put
  } for exch pop		% n array[N]
} bind def

/putmorearray { % dict key arr putmorearray -
  2 index 2 index get dup null eq { pop put } {
    dup length 0 eq { pop put } {
      dup length dup 3 index length add array dup 0 5 -1 roll putinterval dup
      3 -1 roll 4 -1 roll putinterval put
    } ifelse
  } ifelse
} bind def

/bsort { % array cmpproc bsort array
  1 index length 1 sub -1 1 {	% arr proc i
	% arr proc arr i arr[i] arr i arr[i]
    2 index exch 2 copy get 3 copy
    0 1 3 index 1 sub {		% arr proc arr i arr[i] arr i arr[i] j(0..i-1)
      3 index 1 index get	% arr proc arr i arr[i] arr i arr[i] j arr[j]
	% arr proc arr i arr[i] arr i arr[i] j arr[j] (arr[i] arr[j] proc)cmp<0
      2 index 1 index 10 index exec 0 lt {
	4 2 roll		% arr proc arr i arr[i] arr j arr[j] i arr[i]
      } if pop pop		% arr proc arr i arr[i] arr j arr[j]
    } for			% arr proc arr i arr[i] arr ~i ~arr[j]
	% arr proc (arr i ~arr[j] put) (arr ~i arr[i] put)
    4 -1 roll exch 4 1 roll put put
  } for pop			% arr
} bind def

% array value cmpproc bsearch index true
% array value cmpproc bsearch false
/bsearch {
  0 3 index length 1 sub {				% arr v proc l r
    2 copy gt { 5 { pop } repeat false exit } if	% false exit
    2 copy add 2 idiv					% arr v proc l r i
    dup 6 index exch get 5 index 5 index exec neg	% arr v proc l r i -cmp
    dup 0 eq {
      pop 6 1 roll 5 { pop } repeat true exit		% i true exit
    } {
      0 lt {						% arr v proc l r i -cmp
        1 sub exch pop					% arr v proc l i-1
      } {
	1 add exch 3 -1 roll pop			% arr v proc i+1 r
      } ifelse
    } ifelse
  } loop
} bind def

% array value cmpproc bfind [value ...]
/bfind {
  3 copy bsearch {					% arr v proc
    dup dup -1 0 {					% arr v proc i i j--
      5 index 1 index get 5 index 5 index exec		% arr v proc i l l cmp
      0 eq { exch pop } { pop exit } ifelse		% arr v proc i l
    } for
    exch dup 1 6 index length 1 sub {			% arr v proc l i j++
      5 index 1 index get 5 index 5 index exec		% arr v proc l u u cmp
      0 eq { exch pop } { pop exit } ifelse		% arr v proc l u
    } for
    4 2 roll pop pop 1 index sub 1 add getinterval	% subarr
  } {							% arr v proc
    pop pop 0 0 getinterval				% []
  } ifelse
} bind def

/CodeMapProcSet <<
  % [ <> id ] <> charcmp integer
  /charcmp {
    exch 0 get exch strcmp			% <> <> strsub
  } bind
  % [ <> <> id ] <> rangecmp integer
  /rangecmp {
    1 index 0 get 1 index strcmp 0 le {		% [ l u id ] m l<=m
      1 index 1 get 1 index strcmp 0 ge {	% [ l u id ] m u>=m
        pop pop 0
      } { pop pop -1 } ifelse
    } { pop pop 1 } ifelse
  } bind
  % [ <> id ] [ <> <> ] cmpcharcodespace integer
  /cmpcharcodespace {
    1 index 0 get 1 index 0 get strcmp 0 ge {	% [ <> id ] [ L U ] c>=L
      1 index 0 get 1 index 1 get strcmp 0 le {	% [ <> id ] [ L U ] c<=U
        pop pop 0
      } { pop pop 1 } ifelse
    } { pop pop -1 } ifelse
  } bind
  % [ <> <> id ] [ <> <> ] cmprangecodespace integer
  /cmprangecodespace {
    1 index 0 get 1 index 0 get strcmp 0 ge {	% [ l u id ] [ L U ] l>=L
      1 index 1 get 1 index 1 get strcmp 0 le {	% [ l u id ] [ L U ] u<=U
        pop pop 0
      } { pop pop 1 } ifelse
    } { pop pop -1 } ifelse
  } bind
>> def

/makesuffix { % size vlabel makesuffix string
  [
    { pop <> } bind
    {} bind
    { 0 2 index 1 sub getinterval } bind
  ] 2 index 1 index length 1 sub 2 copy gt { exch } if pop get exec
  [
    (N) % size 0: sub CMap naming with supplement suffix for notdef data
    (S) % size 1: sub CMap naming with supplement suffix for single-byte data
    ()  % size n: sub CMap naming with supplement suffix for multi-byte data
  ] 3 -1 roll 1 index length 1 sub 2 copy gt { exch } if pop get
  exch				% suffix[size] vlabel
  () exch {			% suffix[size] vLabel () vlabel[i]
    16 2 string cvrs dup length 2 lt { (0) exch concat2strings } if
    concat2strings
  } forall [ 3 1 roll ] concats	% suffix[size]+suffix
} bind def

/cvsuffix { % value basename cvsuffix basevaluename
  [ 1 index (XX) ] concats exch length 3 -1 roll 16 2 string cvrs
  dup length 2 lt { [ (0) 3 -1 roll ] concats } if
  2 index 3 -2 roll putinterval
} bind def

%/OCFMapSet <<>> def
/OCFCIDSet 2 dict def

/OCFMapInitProcSet <<
  /usecmap		{
    codemap begin
      /usedcmap exch def
      OCFCIDSet usedcmap known { OCFCIDSet usedcmap get } {
	usedcmap /CMap /findresource load exec	% under OCFCIDInitProcSet only!
      } ifelse
      dup /codemap get /codespacerange get /codespacerange exch def
      dup /codemap get /notdefchar get /notdefchar exch def
      dup /codemap get /notdefrange get /notdefrange exch def
      pop
    end
  } bind
  /usefont		{ pop } bind	% !
  /beginusematrix	{ pop } bind	% !
  /endusematrix		{ pop } bind	% !
  /begincodespacerange	{ begincodemapdata } bind
  /endcodespacerange	{			% mark <> <> ...
    2 endcodemapdata
    codemap /codespacerange 3 -1 roll putmorearray
  } bind
  /begincmap		{
    /begincodemapdata { % size|null begincodemapdata -|mark
      /ndata exch def ndata null eq { mark } if
    } bind def
    /endcodemapdata { % n endcodemapdata array
      ndata null eq { markstacktoarray } { ndata exch stacktoarray } ifelse
    } bind def
    /codemap <<
      /usedcmap null
      /codespacerange []
      /bfchar []
      /bfrange []
      /cidchar []
      /cidrange []
      /notdefchar []
      /notdefrange []
    >> def
    /modifydataprocs <<
      /chartosinglebyte { % [<>id]
	dup length array copy			% [<>id]
	0 1 0 {					% [<>id] i
	  2 copy get				% [<>id] i <>
	  dup length 1 sub 1 getinterval	% [<>id] i <>'
	  2 index 2 index 3 -1 roll put pop	% [<>id]
	} for
      } bind
      /rangetosinglebyte { % [<><>id]
        dup length array copy			% [<><>id]
        0 1 1 {					% [<><>id] i
          2 copy get				% [<><>id] i <>
          dup length 1 sub 1 getinterval	% [<><>id] i <>'
          2 index 2 index 3 -1 roll put pop	% [<><>id]
        } for
      } bind
    >> def
    /makesubcmap { % size label [<><>] makesubcmap -
      /subcodemap <<
        /suffix ()
        /usedcmap null
        /codespacerange []
        /bfchar []
        /bfrange []
        /cidchar []
        /cidrange []
        /notdefchar []
        /notdefrange []
        /count 0
      >> def
	% s l [<><>] subcodemap /suffix s l makesuffix put
      subcodemap /suffix 4 index 4 index makesuffix put
      subcodemap /usedcmap codemap 1 index get dup null ne {
        [ exch subcodemap /suffix get ] concats cvn
      } if put
      subcodemap /codespacerange [ 3 index ] put
      <<
        /bfchar		CodeMapProcSet /cmpcharcodespace get
        /bfrange	CodeMapProcSet /cmprangecodespace get
        /cidchar	CodeMapProcSet /cmpcharcodespace get
        /cidrange	CodeMapProcSet /cmprangecodespace get
        /notdefchar	CodeMapProcSet /cmpcharcodespace get
        /notdefrange	CodeMapProcSet /cmprangecodespace get
      >> {
	% s l [<><>] subcodemap key (codemap[key] [<><>] cmp bfind)[] put
        subcodemap 3 1 roll codemap 2 index get 4 index 3 -1 roll bfind put
      } forall
      [
        /bfchar
        /bfrange
        /cidchar
        /cidrange
        /notdefchar
        /notdefrange
      ] {
        subcodemap exch get length subcodemap /count get add
        subcodemap /count 3 -1 roll put
      } forall
      subcodemap /count get 0 gt {
        %
        % SubCMap definition	----------------------------------------
        %
        /CIDInit /ProcSet findresource begin
        12 dict begin
        begincmap
        codemap /usedcmap get null ne {
          subcodemap /usedcmap get usecmap
        } if
        /CIDSystemInfo CIDSystemInfo def
        /CMapName [ CMapName subcodemap /suffix get ] concats cvn def
        /CMapType CMapType def
        /WMode WMode def
        subcodemap /codespacerange get length 0 gt {
          subcodemap /codespacerange get length begincodespacerange
            subcodemap /codespacerange get {
	      modifydataprocs /rangetosinglebyte get exec cvx exec
            } forall
          endcodespacerange
        } if
        subcodemap /bfchar get length 0 gt {
          subcodemap /bfchar get length beginbfchar
            subcodemap /bfchar get {
	      modifydataprocs /chartosinglebyte get exec cvx exec
            } forall
          endbfchar
        } if
        subcodemap /bfrange get length 0 gt {
          subcodemap /bfrange get length beginbfrange
            subcodemap /bfrange get {
	      modifydataprocs /rangetosinglebyte get exec cvx exec
            } forall
          endbfrange
        } if
        subcodemap /cidchar get length 0 gt {
          subcodemap /cidchar get length begincidchar
            subcodemap /cidchar get {
	      modifydataprocs /chartosinglebyte get exec cvx exec
            } forall
          endcidchar
        } if
        subcodemap /cidrange get length 0 gt {
          subcodemap /cidrange get length begincidrange
            subcodemap /cidrange get {
	      modifydataprocs /rangetosinglebyte get exec cvx exec
            } forall
          endcidrange
        } if
        subcodemap /notdefchar get length 0 gt {
          subcodemap /notdefchar get length beginnotdefchar
            subcodemap /notdefchar get {
	      modifydataprocs /chartosinglebyte get exec cvx exec
            } forall
          endnotdefchar
        } if
        subcodemap /notdefrange get length 0 gt {
          subcodemap /notdefrange get length beginnotdefrange
            subcodemap /notdefrange get {
	      modifydataprocs /rangetosinglebyte get exec cvx exec
            } forall
          endnotdefrange
        } if
        endcmap
        CMapName currentdict /CMap defineresource pop
        %CMapName currentdict OCFMapSet begin def end
        end
        end
      } if
	% size label [<><>]
      pop pop pop
    } bind def
  } bind
  /endcmap		{
    /cidrange	% special extension for OCFMap not CMap
    0 0 1 codemap 4 index get length 1 sub {	% key I i
      codemap 3 index get 1 index get		% key I i codemap[key][i]
      cvx exec 3 1 roll				% key I i id <> <>
      exch strsub 1 add exch			% key I i d+1 id
      dup null eq {
			% key I i d+1 (codemap[key][i] 2 I put) I
        pop codemap 4 index get 2 index get 2 4 index put 2 index
      } if add 3 1 roll pop pop			% key d+1+id|I
    } for pop pop
    % making nilset of CMap	----------------------------------------
    /CIDInit /ProcSet findresource begin
    12 dict begin
    begincmap
    codemap /usedcmap get null ne {
      [ codemap /usedcmap get 0 <> makesuffix ] concats cvn usecmap
    } if
    /CIDSystemInfo CIDSystemInfo def
    /CMapName [ CMapName 0 <> makesuffix ] concats cvn def
    /CMapType CMapType def
    /WMode WMode def
    codemap /usedcmap get null eq {
      1 begincodespacerange
        <00> <FF>
      endcodespacerange
      1 beginnotdefrange
        <00> <ff> 0
      endnotdefrange
    } if
    endcmap
    CMapName currentdict /CMap defineresource pop
    %CMapName currentdict OCFMapSet begin def end
    end
    end
    % making subset of CMap	----------------------------------------
    codemap /codespacerange get {
      dup 0 get dup length exch {			% [ L U ] s L
        dup 0 3 index 1 sub getinterval			% [ L U ] s L l
        3 index 1 get 3 index 1 sub 1 getinterval	% [ L U ] s L l u'
        [ 3 1 roll ] concats				% [ L U ] s L u
        1 index exch [ 3 1 roll ] 			% [ L U ] s L [ L u ]
        3 copy makesubcmap pop				% [ L U ] s L
							% [ L U ] s L
        <0100> stringadd not {				% [ L U ] s L' bool
          exit
        } {
          dup length 2 index gt {			% [ L U ] s L' s'>s
            exit
          } {
            dup 3 index 1 get strsub 0 ge {		% [ L U ] s L' L'>=U
              exit
            } if
          } ifelse
        } ifelse					% [ L U ] s L
      } loop pop pop pop
    } forall
  } bind
  /beginbfchar		{ begincodemapdata } bind
  /endbfchar		{			% mark <> <> ...
    2 endcodemapdata codemap /bfchar 3 -1 roll putmorearray
  } bind
  /beginbfrange		{ begincodemapdata } bind
  /endbfrange		{			% mark <> <> id ...
    3 endcodemapdata codemap /bfrange 3 -1 roll putmorearray
  } bind
  /begincidchar		{ begincodemapdata } bind
  /endcidchar		{			% mark <> id ...
    2 endcodemapdata codemap /cidchar 3 -1 roll putmorearray
  } bind
  /begincidrange	{ begincodemapdata } bind
  /endcidrange		{			% mark <> <> id ...
    3 endcodemapdata codemap /cidrange 3 -1 roll putmorearray
  } bind
  /beginnotdefchar	{ begincodemapdata } bind
  /endnotdefchar	{			% mark <> id ...
    2 endcodemapdata codemap /notdefchar 3 -1 roll putmorearray
  } bind
  /beginnotdefrange	{ begincodemapdata } bind
  /endnotdefrange	{			% mark <> <> id ...
    3 endcodemapdata codemap /notdefrange 3 -1 roll putmorearray
  } bind
>> def

/OCFCIDInitProcSet <<
  /findresource		{			% name /ProcSet
    1 index /CIDInit eq 1 index /ProcSet eq and { pop pop 0 dict } {
      dup /CMap ne { findresource } {		% name /CMap
        /CMap /Category findresource begin	% name /CMap
          1 index 256 string ResourceFileName	% name /CMap filename
        end dup status not {			% name /CMap filename status
          pop findresource			% name /CMap findresource
        } {					% name /CMap filename
		% name /CMap filename pages bytes referenced created
          4 { pop } repeat exch pop		% name filename
          OCFMapInitProcSet begin
	    run OCFCIDSet exch get		% (filename run) dict
	  end
        } ifelse
      } ifelse
    } ifelse
  } bind
  /defineresource	{
    dup /CMap ne { defineresource } {
      OCFCIDSet begin pop dup 3 1 roll def end
    } ifelse
  } bind
>> def

OCFMapInitProcSet begin
12 dict begin
begincmap
/CIDSystemInfo 3 dict begin
  /Registry (Adobe) def
  /Ordering (Japan1) def
  /Supplement 1 def
currentdict end def
/CMapName /H def
/CMapType 1 def
/WMode 0 def
null begincodespacerange
  <2121> <7E7E>
endcodespacerange
null begincidrange
<2121> <217e> 633
<2221> <222e> null
<223a> <2241> null
<224a> <2250> null
<225c> <226a> null
<2272> <2279> null
<227e> <227e> null
<2330> <2339> null
<2341> <235a> null
<2361> <237a> null
<2421> <2473> null
<2521> <2576> null
<2621> <2638> null
<2641> <2658> null
<2721> <2741> null
<2751> <2771> null
<2821> <2821> 7479
<2822> <2822> 7481
<2823> <2823> 7491
<2824> <2824> 7495
<2825> <2825> 7503
<2826> <2826> 7499
<2827> <2827> 7507
<2828> <2828> 7523
<2829> <2829> 7515
<282a> <282a> 7531
<282b> <282b> 7539
<282c> <282c> 7480
<282d> <282d> 7482
<282e> <282e> 7494
<282f> <282f> 7498
<2830> <2830> 7506
<2831> <2831> 7502
<2832> <2832> 7514
<2833> <2833> 7530
<2834> <2834> 7522
<2835> <2835> 7538
<2836> <2836> 7554
<2837> <2837> 7511
<2838> <2838> 7526
<2839> <2839> 7519
<283a> <283a> 7534
<283b> <283b> 7542
<283c> <283c> 7508
<283d> <283d> 7527
<283e> <283e> 7516
<283f> <283f> 7535
<2840> <2840> 7545
<3021> <307e> 1125
<3121> <317e> null
<3221> <327e> null
<3321> <337e> null
<3421> <347e> null
<3521> <357e> null
<3621> <367e> null
<3721> <377e> null
<3821> <387e> null
<3921> <397e> null
<3a21> <3a7e> null
<3b21> <3b7e> null
<3c21> <3c7e> null
<3d21> <3d7e> null
<3e21> <3e7e> null
<3f21> <3f7e> null
<4021> <407e> null
<4121> <417e> null
<4221> <427e> null
<4321> <437e> null
<4421> <447e> null
<4521> <457e> null
<4621> <467e> null
<4721> <477e> null
<4821> <487e> null
<4921> <497e> null
<4a21> <4a7e> null
<4b21> <4b7e> null
<4c21> <4c7e> null
<4d21> <4d7e> null
<4e21> <4e7e> null
<4f21> <4f53> null
<5021> <507e> null
<5121> <517e> null
<5221> <527e> null
<5321> <537e> null
<5421> <547e> null
<5521> <557e> null
<5621> <567e> null
<5721> <577e> null
<5821> <587e> null
<5921> <597e> null
<5a21> <5a7e> null
<5b21> <5b7e> null
<5c21> <5c7e> null
<5d21> <5d7e> null
<5e21> <5e7e> null
<5f21> <5f7e> null
<6021> <607e> null
<6121> <617e> null
<6221> <627e> null
<6321> <637e> null
<6421> <647e> null
<6521> <657e> null
<6621> <667e> null
<6721> <677e> null
<6821> <687e> null
<6921> <697e> null
<6a21> <6a7e> null
<6b21> <6b7e> null
<6c21> <6c7e> null
<6d21> <6d7e> null
<6e21> <6e7e> null
<6f21> <6f7e> null
<7021> <707e> null
<7121> <717e> null
<7221> <727e> null
<7321> <737e> null
<7421> <7424> null
<7425> <7426> 8284
endcidrange
endcmap
CMapName currentdict OCFCIDSet begin def end
end
end

OCFMapInitProcSet begin
12 dict begin
begincmap
/H usecmap
/CIDSystemInfo 3 dict begin
  /Registry (Adobe) def
  /Ordering (Japan1) def
  /Supplement 1 def
currentdict end def
/CMapName /V def
/CMapType 1 def
/WMode 1 def
null begincidrange
<2122> <2123> 7887
<2131> <2132> null
<213c> <213e> null
<2141> <2145> null
<214a> <215b> null
<2161> <2161> null
<2421> <2421> null
<2423> <2423> null
<2425> <2425> null
<2427> <2427> null
<2429> <2429> null
<2443> <2443> null
<2463> <2463> null
<2465> <2465> null
<2467> <2467> null
<246e> <246e> null
<2521> <2521> null
<2523> <2523> null
<2525> <2525> null
<2527> <2527> null
<2529> <2529> null
<2543> <2543> null
<2563> <2563> null
<2565> <2565> null
<2567> <2567> null
<256e> <256e> null
<2575> <2576> null
endcidrange
endcmap
CMapName currentdict OCFCIDSet begin def end
end
end

/FontName /Ryumin-Light-V def
/FontType 0 def
/Encoding [
  16#00 1 16#20 { pop 0 } for
  16#21 1 16#28 { 16#20 sub } for
  16#29 1 16#2F { pop 0 } for
  16#30 1 16#74 { 16#27 sub } for
  16#75 1 16#FF { pop 0 } for
] def
/FontMatrix matrix def
/WMode 1 def
/FMapType 2 def
/FDepVector
[
  /.notdeffont
  (HN) cvn /CMap findresource
  [ basecidfont /CIDFont findresource ] composefont
  [
    16#21 1 16#21 { (V) cvsuffix cvn } for
    16#22 1 16#23 { (H) cvsuffix cvn } for
    16#24 1 16#25 { (V) cvsuffix cvn } for
    16#26 1 16#28 { (H) cvsuffix cvn } for
    16#30 1 16#74 { (H) cvsuffix cvn } for
  ] {
    [ basecidfont (-) 3 index ] concats cvn exch /CMap findresource
    [ basecidfont /CIDFont findresource ] composefont
  } forall
  % /.notdeffont findfont
  % /Ryumin-Light-V21 findfont
  % /Ryumin-Light-H22 findfont
  % /Ryumin-Light-H23 findfont
  % /Ryumin-Light-V24 findfont
  % /Ryumin-Light-V25 findfont
  % /Ryumin-Light-H26 findfont
  %	:
  % /Ryumin-Light-H28 findfont
  % /Ryumin-Light-H30 findfont
  %	:
  % /Ryumin-Light-H74 findfont
] def
currentdict
end
definefont pop
%%EndResource
%%EOF
