
                  An Analysis of Alpha-Beta Pruning
                              ( - 祭)
                       Donald E. Knuth and Ronald W. Moor
                     Artificial Intelligence, 6 (1975), 293-326

      0. 

 ᪥ 室  ⠪ ,  嬠, ணࠬ  
室 ந ᬮ 讣 ॢ  த.
⮡ ᪮      ଠ, 筮 ᯮ
⮤, 뢠 - 祭ﬨ ( ᮢ᪮  
뢠 ⮤ ࠭  業 -- ਬ. ॢ稪).   
뢠 १  ⮩ 楤, ஢  ⮣,
⮡   - ᫥ 業 ⢠  ࠡ.

 ࠧ. 1 । ᭮ , 易  ॢ . 
ࠧ. 2 뢠 楤, 뢠 - 祭ﬨ
(alpha-beta pruning),  ᭮ 易   ⮤, , ,
 ⮫ 䥪⨢, ᪮   ந " 祭";
   ४⭮  ⮤. ਬ ࠡ ⬮
  ஡  ।⠢ ᮤঠ  ࠧ. 3.  ࠧ. 4
  ᯮᮡ ࠪ᪮ ਬ ⮤,  ࠧ. 5
饭 ਨ - 祭.

 ࠧ. 6 稭  ࠡ ⮤ -- 祭  業
㤮 ᪠, 室 楤   㣮
,  蠥   .  業 㤮
祭  ࠧ. 7  ᭮  ࠡ  砩묨 ॢﬨ,
  ந  祭. ,    
᫮   祭 ࠧ㬭 १.  ࠧ. 8  
祭  祭,   ࠧ. 9 ,  䥪⨢
⠥, ᫨  ᫥⥫묨 室  . 
ࠡ  ⥫쭮 ⥯ ,   ᫥ ࠧ
  ⥬⨪.


1.   業 権

  ,  ⮫쪮       , 筮 뢠
⢮ "権"  ᮢ㯭 ࠢ 室   樨 
, 祬 ।,  ப 室  ।. 㤥
,  ࠢ ࠧ襭   ᫥⥫쭮
権     樨   筮 ᫮ ࠧ襭
室.    樨 p  ᫮ N(p) ⠪, 
 , 砢  p,   த  N(p) 室 --
 ᫥  "  ᪮筮" (. [11, . 2.3.4.3]).

ନ묨 뢠 樨,    ࠧ襭 室. 
   । 楫᫥ 㭪 f(p),  먣
⮣  ப, ஬ ਭ 室  ⮩ 樨; 먣
ண ப ⠥ ࠢ -f(p).

᫨  樨 p  d ࠧ襭 室 p[1],...,p[d], 
஡ 롮 襣  . 㤥 뢠 室 訬, ᫨ 
砭   ਭ 訩  먣  ᫮,
 ⨢ 롨ࠥ 室, 訥   ( ⮬  ᫥).
 F(p)  訩 먣, ⨦  樨 p ப,
஬ ਭ । 室, ⨢ ⨬쭮 . ..
᫥ 室   p[i] 먣 ⮣ ப ࠢ -F(p[i]), 

                  /  f(p)                             d = 0,
   (1)  F(p) =   |
                  \  max {-F(p[1]),...,-F(p[d]), ᫨ d > 0.

  樨 p  㫠  ⨢ । F(p).

 設⢥ ࠡ  ⥮ਨ  ᯮ   㫨஢;
  ப 뢠 Max  Min     "窨 ७"
ப Max.  ࠧ, ᫨ p  ନ쭠   室
Max,  먣 ࠢ,   ࠭ f(p), ᫨   ନ쭮
樨 p 室  Min,   먣 ࠢ

   (2)   g(p) = -f(p).

Max ⠥ ᨬ஢ ᢮  먣,  Min ࠥ
஢ . ⭮襭 (1)  ⮬ ᮮ⢥  㭪樨,
,

                   /  f(p)                           d = 0,
   (1)  F(p)V =   |
                   \  max {G(p[1]),...,G(p[d]), ᫨ d > 0,

  ᨬ ࠭஢ 먣 ப Max 
樨 p, 

                  /  g(p)                           d = 0,
   (1)  G(p) =   |
                  \  min {F(p[1]),...,F(p[d]), ᫨ d > 0,

 ࠢ ⨬, ⨦  ப Min.   ࠭, 
।,  p[1],...,p[d]  ࠧ襭  樨 p 室.
樥   室  ,  㭪樨, ।塞
ᮮ⭮襭ﬨ (1)  (3), ᮢ     p

   (5)  G(p) = -F(p).

 ࠧ,  室 .

..  筮  業 樨  窨 ७  -
ப,  㤮 ᯮ짮 "" 室 (3)  (4), 
 㦤  "--ᨬ" ନ ᮮ⭮襭 (1). 
㣮 ஭, ᮮ⭮襭 (1) ।⥫쭥,   ⨬
 -, --  ⮬   室 ᫥  (
 --   ப) ࠧ .

㭪 F(p) ࠢ ⮬ ᨬ,  ࠭஢, ᫨ 
ப  ⨬쭮. , , ,  
ࠦ १ 쬠 ஦ ⥣,   易⥫쭮
 ⨢  ப  ப,  ᮣ᭮ 㣮
ਭ樯 ⨬쭮. , ਬ,   室  樨 p1
 p2, 祬 p1 ࠭  (먣 0)    
먣,   ६,  p2   먣, ᫨ ⨢
ᬮ 祭 ⮭ 먣뢠騩 室.  ⠪ 樨  
। ᪮ 室  p2, ᫨ ⮫쪮   㢥७  ⮬, 
 ⨢ ᥬ  ᥧ. 祭 ,   먣뢠
 嬠 ணࠬ ⠪  ࠧ.


2. ࠡ⪠ ⬠

᫥騩  ( ᯥ樠쭮 ਤ㬠 
몥), 祢,  F(p)  ᮮ⢥⢨  । (1):

      integer procedure F(position p):
         begin integer m,i,t,d;
         । 樨 p[1],...,p[d], 稭 p;
         if d = 0 then F := f(p) else
         begin  m := -INFINITY;
            for i:= 1 step 1 until d do
               begin t := -F(p[i]);
                  if( t > m then m:= t;
               end;
            F := m;
         end;
      end.

 +INFINITY 砥 ᫮, ஥   abs(f(p))  
ନ쭮 樨 p; ⮬ -INFINITY   F(p)  -F(p) 
 p.    F(p)  ᭮ "㡮 ᨫ" -- 
 樨  業   த; " 
᪮筮" ࠭ 砭 ᫥  筮 ᫮
室.

ॡ,  ⢫  ,  㬥, ᯮ  ⮤ "⢥  ࠭" [14].  ⮨  ⮬,    ᪠
 業 室,   ⠫ ⭮,     
, 祬   室, ᬮ७ ࠭. , ਬ,  ⭮,      F(p1) = -10.   F(p) >= 10,  ⮬   㦭  筮 祭 F(p2), ᫨ - ࠧ    㧭,  F(p2) >= -1 ( ⠪
ࠧ,  -F(p2) <= 10). ⠪, ᫨ p21 -- ⨬ 室  p2 
F(p21) <= 10,    ᫥ 㣨 室  p2.  ନ
⥮ਨ  室   p2 "஢࣠" (⭮⥫쭮 室  p1),
᫨  ⨢  樨 p2  ⢥,  ࠩ  ⮫ 
訩,   訩 ⢥  樨 p1. ᭮,  ᫨ 室 
஢࣭,    ᪠ 襥 ஢থ.

 㦤 ਢ  , ࠧ  , 祬
 F. । F1  楤   ࠬࠬ p  bound;
 楫 -- 㤮⢮ ᫥騬 ᫮:

          F1(p, bound) = F(p),    ᫨ F(p) < bound,
   (6)
          F1(p, bound) >= bound,  ᫨ F(p) >= bound.

 ᫮  । F1 , ,  ᫨
F(p)   砫쭮 樨 p, ᪮   ᫥, 

   (7)    F1(p,+INFINITY) = F(p).

 ⮤ ⢥  ࠭ ॠ ᫥騩 :

      integer procedure F1(position p, integer bound):
         begin integer m,i,t,d;
         । 樨 p[1],...,p[d], 稭 p;
         if d = 0 then F1 := f(p) else
         begin  m := -INFINITY;
            for i:= 1 step 1 until d do
               begin t := -F1(p[i], -m);
                  if( t > m then m := t;
                  if m >= bound then goto done;
               end;
      done: F1 := m;
         end;
      end.

ࠢ쭮 ࠡ ⮩ 楤  ,  १ 㤮⢮
ᮮ⭮襭 (6),   ᫥騬 㦤ﬨ.  砫
i- ⪠ for- 믮 "ਠ⭮" ᫮

   (8)    m = max { -F(p[1]), ..., -F(p[i-1])}.

(।,  ᨬ  ⮬   -INFINITY.)
⮬, ᫨ -F(p[i]) > m, , ᯮ ᫮ (6)   
 , 稭饩  p, 砥 F1(p[i],-m) = F(p[i]).
⥫쭮,  砫 ᫥饣 ⪠ (8) ⠪ 㤥 믮.
᫨  max {-F(p[1],...,-F(p[i])} >= bound   i,  F(p) >=
bound.  ᫥,  (6) 믮   p.

 楤   , ᫨   ⮫쪮 ,  
 ࠭.   --  뢠 ᭮ -
楤ன   - 祭ﬨ --  ⥫
த  ࠢ  ஭ ⮤ ⢥  ࠭. (
ᮦ,  ਬ    ,  ᯮ ⮤
⢥  ࠭;  ࠡ⠥ ⮫쪮  ᫥ ஢
ॢ쥢.) । 楤 F2  ६ ࠬࠬ p, alpha  beta
(祬 ᥣ 㤥 믮 alpha < beta),  㤮⢮
᫥騬 ᫮,  (6):

          F2(p,alpha,beta) <= alpha,    ᫨ F(p) < alpha,
   (9)    F2(p,alpha,beta) = F(p),      ᫨ alpha < F(p) < beta,
          F2(p,alpha,beta) >= beta,     ᫨ F(p) >= beta.

 ᭮  ᫮  । F2 , ,   ᫥,


   (10)   F2(p,-INFINITY,+INFINITY) = F(p).

뢠, ।⠢ ⮣ 襭 ⬠  몥
ணࠬ஢  - ⫨砥  ⬮ F  F1:

      integer procedure F2(position p, integer alpha, integer beta):
         begin integer m,i,t,d;
         । 樨 p[1],...,p[d], 稭 p;
         if d = 0 then F2 := f(p) else
         begin  m := alpha;
            for i:= 1 step 1 until d do
               begin t := -F2(p[i], -beta, -m);
                  if( t > m then m := t;
                  if m >= beta then goto done;
               end;
      done: F2 := m;
         end;
      end.


3. ਬ  筥

  楤 ந㥬  ਬ ॢ (. 1), 
୥  樨  ६ 稭묨 ﬨ,    
⠪   稭 樨,  ..   ,   
稬 3**4 = 81 権, ⨦  4 室. ⨬ ନ
 ਯᠭ "砩" 業,  ࠢ  81 ࠬ
筮 ࠧ ᫠ pi.  ࠧ, ७ ॢ
(ᯮ )  業 2, ࠢ 먣 ࢮ ப,
᫨  ப  ⨬ 室.



   .1.  業 ॢ .


 . 2 ।⠢ , ᮮ⢥ ॡ, 
ந 楤 F1. ⨬,   81 ନ 権 
"頥" ⮫쪮 36. ஬ ⮣,   設 2- ஢ 
"ਡ" 業 3  ⨭ 祭 7; 
ਡ⥫쭮, 筮,     業 .


   .2. ॢ , ।⠢  . 1, ᫥ 業
          楤ன F1 (⮤ ⢥  ࠭).


 . 3 ।⠢   , 蠥 - 楤ன.
F2(p,-INFINITY,+INFINITY) ᥣ ᫥   㧫,  
F1(p,+INFINITY),   ⨣ 設 ⢥⮣ ஢;  
᫥⢨ ࠧ  ⥮ਨ.  ஢ 4, 5, ..., ,
楤 F2 ᯮᮡ ந " 祭",  
ᯮᮡ F1. ࠢ . 3  . 2 뢠,   ⮬ ਬ
ᤥ 5  祭.

   3. ॢ , ।⠢  . 1, ᫥ 業
         楤ன F2 (- ⥣).

 樨 ।⠢  ନ "⥫쭮-ᨬ쭮"
, ᬮ७  ࠧ. 1; ⥬,  ।⠥ ""
ନ, 筮 ஢  . 1-3 . 楤
ࠧ. 2  ।⠢  ᭮ , , ਬ, F2
᫥騬  楤ࠬ:

      integer procedure F2(position p, integer alpha, integer beta):
         begin integer m,i,t,d;
         । 樨 p[1],...,p[d], 稭 p;
         if d = 0 then F2 := f(p) else
         begin  m := alpha;
            for i:= 1 step 1 until d do
               begin t := G2(p[i], m, beta);
                  if( t > m then m := t;
                  if m >= beta then goto done;
               end;
      done: F2 := m;
         end;
      end;

      integer procedure G2(position p, integer alpha, integer beta):
         begin integer m,i,t,d;
         । 樨 p[1],...,p[d], 稭 p;
         if d = 0 then G2 := g(p) else
         begin  m := alpha;
            for i:= 1 step 1 until d do
               begin t := F2(p[i], alpha, m);
                  if( t > m then m := t;
                  if m >= beta then goto done;
               end;
      done: F2 := m;
         end;
      end.

 ⢥ ,  ⥫쭮 ࠦ । ,
 G2(p,alpha,beta) ᥣ ࠢ -F2(p,-beta,-alhpa).

 ਢ 楤 ᯮ 襡 ணࠬ, 
। 樨 p[1],...,p[d], 稭 樨 p. ᫨ 
⨬  筮  ᯮᮡ ।⠢ 権, 
⢥ ᯮ짮 ᯨ᪮ .  p  뫪 
, ᮮ⢥ 室 樨, ⮣ first(p)  뫪 
 稭   NULL ( 뫪), ᫨  p
ନ쭠. 筮, ᫨ q  뫪  , ᮮ⢥
p[i],  next(q)  뫪  ᫥ 稭  p[i+1]
 NULL, ᫨ i = d. , १ generate(p) 稬 楤,
 ᮧ , ᮮ⢥騥  p[1],...,p[d],
⠭     next   ⠪,  first(p)
㪠뢠  p[1]  ࠢ NULL, ᫨ d = 0.  -
楤  ।⠢  ᫥饩  筮 ଥ:

      integer procedure F2(ref(position) p,integer alpha,integer beta):
         begin integer m,t; ref(position) q;
         generate(p);
         q := first(p);
         if q = NULL then F2 := f(p) else
         begin  m := alpha;
            while q <> NULL and m < beta do
               begin t := -F2(q, -beta, -m);
                  if t > m then m := t;
                  q := next(q);
               end;
            F2 := m;
         end;
      end.

᭮ ।⠢  ४७ 楤  ⨢
(४७⭮)   ஡  ⨬騥
८ࠧ,  ࠭ ४⭮ ணࠬ (. [13]).
 楤 㤨⥫쭮 ,  ⥫⢮ 
ࠢ쭮  ⮫ 祢,   ४७⭮ ।⠢:

   integer procedure alphabeta(ref(position p);
      begin integer l; comment level of recursion;
         integer array a[-2:L];
            comment stack for recursion where a[l-2], a[l-1], a[l]
                denote respectively alpha, beta, m, -t in procedure F2;
         ref (position) array r[0:L+1];
            comment another stack for recursion where r[l] and r[l+1]
                denote respectively p and q in F2;
         l := 0; a[-2] := a[-1] := -INFINITY; r[0] := p;
     F2: generate(r[l]);
         r[l+1] := first(r[l]);
         if r[l+1] = NIL then a[l] := f(r[l]) else
         begin a[l] := a[l-2];
          loop: l := l+1; goto F2;
          resume: if -a[l+1] > a[l] then
            begin a[l] := -a[l+1];
              if a[l+1] <= a[l-1] then go to done;
            end;
         r[l+1] := next(r[l+1]);
         if r[l+1] <> NIL then goto loop;
      end;
   done: l := l-1; if l >= 0 then goto resume;
      alphabeta := a[0];
   end.


 楤    祭,   F2(p,-INFINITY,INFINITY);
祭 L 㦭  ⮫쪮 訬, ⮡ ஢ ४ᨨ
  ॢ室 L.



4. ਫ

ࠡ뢠 ஢ ணࠬ,  ।  ,  
業 । 室  ᬮ   ନ 㧫 --
 - 祭 筮 , ⮡  
"⨬" 嬠!   , ᠭ 楤 ਬ
, ᫨ ணࠬ,  । 樨 (室)
 ⠪, ⮡ 筮 㡮 樨  﫠
ନ묨. , ਬ,  ⨬  ॡ  㡨  6
室 ( 3   ப).  ⮬ 砥  
⢮,   , 室  6- ஢  業,
 ⨬ 室 (..  ନ).  ᫥ 業
⠪ "⢥ ନ" 権  㦭, 筮,
ᯮ짮   ,   ,  
⮬,  筮 㡮   ᫥⢨ 饭
訡. (  ६ ࠡ ணࠬ 㤥 祭 
᫥ ⠪ , ⮬ 室 ᯮ짮 
᫨ 業. 㣠  ⮨  ࠧࠡ⪥ 
⨬ 室, ,   १砩 㤭.)

 ᪠  䨪஢ 㡨  ᫥ 
⢨ (᫥⥫쭮 -室) ॢ ஡, ᪠,
᫥   ࠧ.  室 ।  1965 .
. [6],  -   ᫥ 筮 ப.
 室  奬  ᢠ  "ࠢ"
ᮣ᭮ ᫥饬 饬 . "ࠢ" 㦤 室
ࠢ 1,   ६   室 (⠪,  ⢠
  嬠) ᢠ "ࠢ", ࠢ, ᪠, 0.01
  ⮣.  嬠 ⢥⭮ ⨥  ࠢ, 襥
0.5,  訥 室 -- , ᪠, 0.02.  ந
ࠢ 室,    , ⠭ 
࠭ ண (ਬ,  10**(-8)),  
ᬠਢ  ନ쭠,      
 業.  ⮩ 奬 " "  ॢ 㤥
襥 .

  ⮤  ᯮ짮  祭 ॢ ਥ
ࠧ஢, ᠬ - 楤 ᪠ 襭, ᫨ 
।⠢塞 ᥡ, 祬   ࠢ 業 室 樨. ᫨
 㬠,  業 樨  a   b,   F2(p,
-INFINITY, +INFINITY)   ஡ F2(p, a, b). , 
ਬ  . 3   F2(p,-10,+10) ᯮ짮 F2(p,0,4) --
 ⮬ "-4"  ஢ 3  稭 樨  祭. ᫨
 । ୮,  祬   ॢ;  㣮
஭, ᫨ 祭 業  ᫨誮 , ᪠
F2(p,a,b) = v,  v <= a,     
F2(p,-INFINITY,v), ⮡   業.   ᯮ짮
   嬠⭮ ணࠬ ਭ [8].




5. 

० 祬  㯨  ⢥  䥪⨢
- 楤, ⪮ ᬮਬ ᭮ ⠯  ࠧ. 
࠭  筮 㬠, ⮬   ᭮뢠 
㬥஢ ᯮ,  ⠪ ⮬,   
楤 F1   魮 楤ன F2. ⮬ ᫥饥
 ᯮ   ଠ, 㯭 ࠬ.

- 㬠   ⮤  1965 .  ६ ᪮ ⭥
᫥⥫᪮ ७樨  ⢥ ⥫, 
⠩ ᪠    ᠬ ࠭ 嬠 ணࠬ [3], 
ன  ᯮ짮  祭. - "⨪ 
 ணࠬ,   㡥 ⠩.   ६ ᯥ䨪樨
⬠ ⮢  뫨". 祭 ⭮,  砭
-, ᤥ  ⮩ ७樨, ਢ  ⮬,   
50- . - 祭 ⠫ ᯮ짮  嬠
ணࠬ.

ࢮ 㡫樥,  ன ᮤঠ 㦤 祭  ॢ
, 뫠  ,    [16]  ᠭ  ࠭
嬠⭮ ணࠬ. ,  ਢ ਬ ࠡ 
"஭" ⮤, ॠ  楤 F1, ⠪  ᭮,
ᯮ짮    "" 祭.

-  䨪 alpha  beta  ᢮ ࢮ ணࠬ 
LISP', ॠ饩  ⮤.  ணࠬ ࠡ⠫  
७, 祬 襮ᠭ ⮤, ᪮  ।
⢮  㭪権 "⨬᪠ 業 (p)" 
"ᨬ᪠ 業 (p)",  ⠢﫨   
࠭ 業 樨. ணࠬ -, 믮  
⢨,  ਢ  楤 F2,  ।⠢ 
᫥饬 :

      if optimistic value(p) <= alpha then F2 := alpha
      else if pessimistic value(p) >= beta then F2 := beta
      else begin <the above body of procedure F2> end.

-   - ⠫ - 祭 (,
騬 訡) ᪨ ਥ,  ᮧ,  筮 祭
業 砥,    p

      optimistic value(p) = +INFINITY

      pessimistic value(p) = -INFINITY.

 ਫ ⨥ ⮣ 䠪   ,   1961 
⮢  ⮬   [10].  ⮬ 㡫 
 ਢ ਬ ࠡ 饣 ⮤,  ⮬ ᫥, 
祭.  (  뫮 ਭ  1961 .),    
᭮ ⮤,  㪠 ᫮,    ࠡ⠥.

ࢠ 㡫  ᠭ - 祭   ᪮
몥  1963 . ᮢ襭 ᨬ  ࠡ ਪ楢. 㤭 [4]
  ࠧࠡ稪  ᨩ ᪮ 嬠⭮ ணࠬ
(   ணࠬ,    ஬᪨ 
    嬠 -- ਬ. ॢ.), । ,
ᮢ騩  - ⮤,   -- 쭮-⠪ ᫮ --
⥫⢮  ࠢ쭮.

 ᠭ - 祭   "" 
 ᫥  ࠬ  1968 .     ᪮ [24]
 ⥣ ⥫⢠ ⥮६, ,  ᠭ ࠤ
⪮   ᮤঠ 㦤  祭.  ࠧ,
 ⢥ত,  ࢮ ⪮  ⮤  ᪮
몥   1969 .     ᮭ [25]  
[22];     㯮   祭 
㦤  砥 室 ⠫.

ࠪ⨪ 뢠,  祭 㤭 ᭨ ⮤ ஥
- 祭 " ᫮"   筮 ⥬᪮ 몥,
⮬  ஢  ࠡ 뫨 㦤 ਡ 
  ᫮ ᠭ.  ⮣,  ࢮ ⢥  ⮤
祭 㤭 ⠢ ᥡ   ,   ⢨⥫쭮
ࠡ⠥, ᮡ ⮣,  ⮤ 뢠  "筮" 몥 
 ᭮   祭.  , 
⮬ ᠭ ⮤     ᫥ ⮣,  
 ⥭. ,  ࠧ. 2  ,  ⮤   
᭮, ᫨ ࠧ   ⬨᪮ 몥;  
訬 ਬ஬ ,  ஬ "᪨" 室  ᠭ
 뢠 ⥫쭮  ।⥫, 祬 
⥬᪨.

祭  ⮤ ᠭ    ᮭ [18, ࠧ.4] 
 [23, pp.16-24], ,  ।⠢ ⮤ " ஧",  
     ⬨᪮ ଥ. -
祭 ⠫ "ப 묨", , ᪮쪮 ⭮
ࠬ,    㡫 楤 ᠭ  ⬨᪮
몥.  ᠬ ,  ࢮ   [27, ࠧ. 4.3.3],  ਢ
  - 楤,     ᫠, 祬
楤 F1. (   ⮫쪮  ந  祭,
  孨 祭 ந   믮 ண
ࠢ⢠.) 㣠  ⬠, ਭ   ᭨
[5, ࠧ. 8.1],    襤襬  ࢥ᪮ 몥
祡  ࠬ ; , - ⮤ ।⠢ 
  ᯮ짮 ࠬ஢-⮪, ⠪  ⥫⢮
ࠢ쭮 ⠭ 筮 㤭.  㣮  祡
[17, ࠧ. 3.3.1] ᮤন ଠ쭮 ᠭ ⮣,  ⠬
 "- 祭ﬨ",  ᭮ ਢ  ⮤,
ॠ㥬 楤ன F1; -,   ,  -
楤 ᯮᮡ ந  祭. (   ஢
 (..)  5   த  ᫥,
ᠭ  ࠧ. 7,  ,   祭 . ,
楤 F1  ਭ  "- 祭",   
 , ⠪    F2. -- ਬ. ஢.) - ᥣ ⮣
   㢥७  ⮬,    ⮤ 
, --   ᬮ  ,  - 祭 ᯮ
㦥  15 !




3



