// 革命 // Etuden Op.10-5 ///////////////////////////////////////////////////////////////////////////////////////// // 各種設定らしきもの Int MSGS=0 Int TWM2=0 Int TIMIDITY=0 Int BRIGHT=0 Int LOOP=2 Int LONGPEDAL=1 Int KEY=0 Int TEMPORATIO=120 Int TEMPODIFF=0 // Base Tempo=120 (楽譜は160) Int IGNORETEMPO=0 Int TINY=0 Int GAKUHU=0 //Int DEBUG=1 //Mute(1,2,3) // ↑上2行のコメント外すと、メトロノームだけが鳴るなの。どうやって使うかは秘密なの。ぐすぐす;; //////////////////////////////////////////////////////////////////////////////////////////////// 拍子 4,4 Tempo 160 曲名{"革命 Etuden Op.10-12"} 作者{"Fryderyk Franciszek Chopin MML by ななこっち★"} IF(MSGS=1 || TWM2=1) { ResetGS } #METORONOMEMML={M4m4m4m4} IF(TINY=1 || GAKUHU=1 || TWM2=1) { Expression.Frequency(2); Modulation.Frequency(8); System.TimeBase=96 } ELSE { Expression.Frequency(1); Modulation.Frequency(1); System.TimeBase=3072 } #PEDALON={Sub {r64y64,127}} #PEDALOFF={r-36 y64,0 r36} /////////////////////////////////////////////////////////////////////////////// // title: "rchord.h" ver 1.01 // description: 和音を下からランダムなタイミングで演奏するインクルードファイル(2015/05/24) // keywords: SAKURA Function by ななこっち★ @nanakochi123456 // HP: http://nano.daiba.cx/ /////////////////////////////////////////////////////////////////////////////// // rchord.h 和音をランダムなタイミングで演奏する /////////////////////////////////////////////////////////////////////////////// // Function RCDINIT(min, value) // 乱数値の最小値、最大値を設定する。両方0にすると、同一タイミングで演奏します。 // // Function RCD(mml) // ランダムに演奏したい和音のMMLを入力する /////////////////////////////////////////////////////////////////////////////// // Example // Include(rchord.h) // RCDINIT(53,513) // l4 RCD(ceg) // l8 RCD(fg) // l8 RCD(ceg) /////////////////////////////////////////////////////////////////////////////// // テストする場合、コメントアウトを消して下さい。 //Int TEST=1 /////////////////////////////////////////////////////////////////////////////// Int RCD_MIN=192 Int RCD_MAX=768 Function RCDINIT(Int MIN, Int MAX) { RCD_MIN=MIN RCD_MAX=MAX } Function RCD(Str MML) { Str BUF="" Str FIRST="" Str ML="" Str M Str R Str FM Int C=0 BUF="" R="" For(Int i=1; MID(MML, i, 1)!=""; i++) { M=MID(MML, i, 1) IF(DEBUG=1||TEST=1) { Print("Count "+ C + " Str="+M) } IF(M="a"||M="b"||M="c"||M="d"||M="e"||M="f"||M="g") { C++ IF(C<2) { FIRST=ML ML=FM+M FM="" } ELSE { BUF=BUF+"Sub" + CHR(123)+R+ML+CHR(125) IF(RCD_MAX>0) { R=R+"r"+Random(RCD_MIN, RCD_MAX) } ML=M } } ELSE { IF(C>0) { ML=ML+M } ELSE { FM=FM+M } } } BUF=BUF+"Sub"+CHR(123)+R+ML+CHR(125)+FIRST+"r" IF(DEBUG=1 || TEST=1) { Print(BUF) } BUF } IF(TEST=1) { TR(1) Tempo 50 l4 RCDINIT(32,40) l4 RCD(ceg) l8 RCD(fg) l8 RCD(ceg) RCDINIT(96,425) l4 RCD(ceg) l8 RCD(fg) l8 RCD(ceg) RCDINIT(193,765) l4 RCD(ceg) l8 RCD(fg) l8 RCD(ceg) RCDINIT(0,0) l4 RCD(ceg) l8 RCD(fg) l8 RCD(ceg) } /////////////////////////////////////////////////////////////////////////////// // title: "rmelody.h" ver 0.25 // description: 単音をランダムな音量とタイミングで演奏するインクルードファイル(2015/05/25) // keywords: SAKURA Function by ななこっち★ @nanakochi123456 // HP: http://nano.daiba.cx/ /////////////////////////////////////////////////////////////////////////////// // rmelody.h メロディー等をランダムなタイミングで演奏する /////////////////////////////////////////////////////////////////////////////// // Function RMDINIT(rmin, rmax, vmin, vmax) // 休符乱数値の最小値、最大値、最小、最大音量設定する。両方0にすると、同一タイミングで演奏します。 // // Function RMDR(rmin, rmax) // 休符乱数値の最小値、最大値の設定のみする // // Function RNDV(rmin, rmax) // 音量乱数値の最小値、最大値の設定のみする。 // 同一の値を設定を両方に行うと、固定音量となる。 // rmaxを省略すると、rmin、rmax共に加算、または減算を行なう // // rmin, rmaxは与える休符値、vmin, vmaxは与える音量値 // Function RMD(mml) // ランダムに演奏したいメロディーのMMLを入力する /////////////////////////////////////////////////////////////////////////////// // Example // Include(rchord.h) // RMDINIT(53,513,90,110) // l4 RMD(ceg) // RMDV(5) // l8 RMD(fg) // RMDV(-5) // l8 RMD(ceg) /////////////////////////////////////////////////////////////////////////////// // テストする場合、コメントアウトを消してください。 //Int TEST=1 /////////////////////////////////////////////////////////////////////////////// Int RMD_RMIN=192 Int RMD_RMAX=768 Int RMD_VMIN=95 Int RMD_VMAX=100 Int RMD_CRESC=0 Function RMDINIT(Int RMIN, Int RMAX, Int VMIN, Int VMAX) { RMD_RMIN=RMIN RMD_RMAX=RMAX RMD_VMIN=VMIN RMD_VMAX=VMAX RMD_CRESC=0 } Function RMDCresc(Str STEP) { RMD_CRESC=STEP } Function RMDR(Int RMIN, Int RMAX) { RMD_RMIN=RMIN RMD_RMAX=RMAX } Function RMDV(Int VMIN, Int VMAX) { IF(VMAX=0) { Int TMPMIN=RMD_VMIN Int TMPMAX=RMD_VMAX TMPMIN=TMPMIN+VMIN TMPMAX=TMPMAX+VMIN IF(TMPMIN < 0) { TMPMIN=0 } IF(TMPMIN > 127) { TMPMAX=127 } IF(TMPMAX < 0) { TMPMAX=0 } IF(TMPMAX > 127) { TMPMAX=127 } RMD_VMIN=TMPMIN RMD_VMAX=TMPMAX } ELSE { RMD_VMIN=VMIN RMD_VMAX=VMAX } } Function RMD(Str MML) { Str BUF="" Str FIRST="" Str ML="" Str M Str R Str VL Str RRMML Str RMML Str FM="" Int C=0 Str LenStr Int TOKEN=0 Int TO=0 BUF="" R="" For(Int i=1; MID(MML, i, 1)!=""; i++) { M=MID(MML, i, 1) // Print("Start Str="+M) IF((ASC(M)>=48 && ASC(M)<=57) || M="r"||M="."||M="^") { IF(TO>=1) { LenStr=LenStr+M //Print("LenADD:"+LenStr) } ML=ML+M } ELSE { IF((ASC(M)>=97 && ASC(M)<=103)) { //Print("Note:"+M) TOKEN++ TO=1 FM=RRMML+VL+ML+RMML IF(TOKEN>1) { C++ IF(FM!="") { BUF=BUF+"Sub{"+FM+"}r"+LenStr } // TO=0 TOKEN=0 } ELSE { BUF=BUF+ML } LenStr="" ML=M IF(RMD_RMAX>0) { R=Random(RMD_RMIN, RMD_RMAX) IF(Random(0,10)<5) { RRMML="r-"+R RMML="r"+R } ELSE { RRMML="r"+R RMML="r-"+R } } VL="v"+Random(RMD_VMIN, RMD_VMAX) RMDV(RMD_CRESC,0) } ELSE { //Print("Other:"+M) ML=ML+M IF(TO=1) { TO=2 } IF((ASC(M)>=97 && ASC(M)<=103) || M="r" || (ASC(M)>=48 && ASC(M)<=57) || M="." ||M="^"|| M="-"||M="#") { } ELSE { TO=0 } } } IF(DEBUG=1||TEST=1) { Print("Token "+ TOKEN + " Count "+ C + " Str="+M+" ML="+ML+" Len="+LenStr+" TO="+TO+" BUF="+BUF) } } FM=RRMML+VL+ML+RMML IF(FM!="") { BUF=BUF+"Sub{"+FM+"}r"+LenStr } IF(DEBUG=1 || TEST=1) { Print(BUF) } BUF } IF(TEST=1) { #basemml={ l8 [4 RMD(cdefgfed) RMDV(-5)] RMDV(15) RMD(c4g4f4d4) } TR(1) Tempo 120 o6 // 下手過ぎあひゃひゃ RMDINIT(32,40,70,110) #basemml // まぁまぁ RMDINIT(96,425,70,110) #basemml // 上手 RMDINIT(193,765,100,110) #basemml // DTM RMDINIT(0,0,110,110) #basemml TR(2) Tempo 120 o4 // 下手過ぎあひゃひゃ RMDINIT(32,40,70,110) #basemml // まぁまぁ RMDINIT(96,425,70,110) #basemml // 上手 RMDINIT(193,765,100,110) #basemml // DTM RMDINIT(0,0,110,110) #basemml TR(10) $M{n(MetronomeBell),} $m{n(MetronomeClick),} [40 Rythm{M4m4m4m4} ] } /////////////////////////////////////////////////////////////////////////////// // title: "tempo.h" ver 1.1 // description: TempoChange非互換高機能テンポチェンジ機能インクルードファイル(2015/05/28) // keywords: SAKURA Function by ななこっち★ @nanakochi123456 // HP: http://nano.daiba.cx/ /////////////////////////////////////////////////////////////////////////////// // tempo.h デバッグ機能付きテンポチェンジ // (サクラに TempoChange がありますが、その高機能版です) // // Include前に、以下の変数を定義して下さい。 // // ・Int DEBUG=0 // 1 でメトロノームがなります、2 でテンポチェンジ時にうるさい雑音が鳴ります //  (メトロノームは10000小節で終了します、4/4 を前提に作成されています。) // // ・Int TEMPORATIO //  ベーステンポの割合を%で設定します。(100がデフォルト。) // // ・Int TEMPODIFF //  ベーステンポを設定して、外部よりテンポを制御したい場合、TEMPODIFF に 整数値 (-〜+)を設定します。 // // ・Int IGNORETEMPO //  IGNORETEMPO=1 にすると、テンポチェンジを無効にします。 // // #METORONOMEMML //  メトロノームのリズムMMLを設定できます。3拍子にする時等使用します。 //  (M=表拍、m=裏拍) // // ※テンポチェンジは、専用のトラックを作成することをお勧めします。 /////////////////////////////////////////////////////////////////////////////// // Function TmpChange(tempo, len) // テンポをチェンジします。 // 前のテンポは自動的に読み込まれます // 即時チェンジする場合には、lenを 0 にします。 // それ以外は、!2 !4. 等を指定します。 // // Function TmpChangeR(tempo, len) // テンポをチェンジして、len分の休符を置きます。 /////////////////////////////////////////////////////////////////////////////// // テストするときは、以下のコメントを全て外してください。 //Int TEST=1 //Int DEBUG //Int TEMPORATIO=100 //Int IGNORETEMPO=0 //Int TEMPODIFF=0 /////////////////////////////////////////////////////////////////////////////// //#METORONOMEMML={M4m4m4} IF(#METORONOMEMML="") { #METORONOMEMML={M4m4m4m4} } IF(TEST=1) { DEBUG=2 Tempo 200 } IF(DEBUG>=1) { IF(DEBUG=2) { #DEBUGMML1={Sub{@1v90V(127)'v90o5do6fo7a#o8d'}} #DEBUGMML2={Sub{@1v90V(127)'v90o5co6eo7g#o8c'}} #DEBUGMML3={Sub{@1v127V(127)'v127o4cdefgabo6cdefgab'}} } TR(10) $M{n(MetronomeBell),} $m{n(MetronomeClick),} [10000 Rythm{#METORONOMEMML} ] } Function TmpChangeR(tempo, len) { TmpChange(tempo, len) r%(len) } Function TmpChange(tempo, len) { IF(len=0) { IF(DEBUG=2) { #DEBUGMML1 } } ELSE { IF(DEBUG=2) { #DEBUGMML2 } } IF(len=0) { IF(!(IGNORETEMPO<>1)) { IF(TEMPORATIO=0) { Tempo=tempo+TEMPODIFF } ELSE { Tempo=(tempo*TEMPORATIO)/100+TEMPODIFF } } } ELSE { IF(!(IGNORETEMPO<>1)) { Int TT1=Tempo Int TT2 IF(TEMPORATIO=0) { TT2=tempo+TEMPODIFF } ELSE { TT2=(tempo*TEMPORATIO)/100+TEMPODIFF } Int TTDIFF=(TT2 - TT1) Int TTSTEP=TTDIFF IF(TTSTEP < 0) { TTSTEP=-TTDIFF } Int TTR=len / TTSTEP For(Int I=1; I < TTSTEP; I++) { Sub { r%(I*TTR) IF(TTDIFF < 0) { TT1 = TT1 - 1; } ELSE { TT1 = TT1 + 1; } Tempo = TT1; } } Sub{ r%(len) IF(TEMPORATIO=0) { Tempo=tempo+TEMPODIFF } ELSE { Tempo=tempo*TEMPORATIO/100+TEMPODIFF } } } } } IF(TEST=1) { TR(1) TmpChange(100,0) o5l8cdefgfed TmpChange(120,!2) o5l8cdefgfed TmpChange(160,!2) o5l8cdefgfed TmpChange(80,!2) o5l8cdefgfed TmpChange(50,!2) o5l8cdefgfed TmpChange(160,!4) o5l8cdefgfed TmpChange(50,!2) o5l8cdefgfedc1 } /////////////////////////////////////////////////////////////////////////////// // title: "loop.h" ver 1.0 // description: Loopインクルードファイル(2015/06/02) // keywords: SAKURA Function by ななこっち★ @nanakochi123456 // HP: http://nano.daiba.cx/ /////////////////////////////////////////////////////////////////////////////// // loop.h 可変回数のループ /////////////////////////////////////////////////////////////////////////////// // Function LoopPlay // LoopPlay(mml string value[, loop count offset]) max 5 parms. // // Example // Int LOOP=4 // Include(loop.h) // #mml={ // cde // } // LoopPlay(#mml) // LoopPlay(#mml,0) /////////////////////////////////////////////////////////////////////////////// // テストする時は、以下のコメントを外してください。 //Int TEST=1 //Int LOOP=5 /////////////////////////////////////////////////////////////////////////////// Function LoopPlay(Str Mml, Int count) { Str _MML For (Int i = 1; i <= LOOP + count; i++) { _MML=_MML + Mml } _MML } IF(TEST=1) { 曲名{"かえるの歌(test)"} 作者{"ドイツ民謡"} #mmla={ l4 cdef edc4.r8 } #mmlb={ l4 efga gfe4.r8 } #mmlc={ crcr crcr l8ccddeeff l4 edc2 } TR(1) o5 @(Clarinet) q95 #mmla LoopPlay(#mmlb,3) #mmlc TR(2) o6 @(Violin) q95 [2 r1] #mmla LoopPlay(#mmlb,2) #mmlc TR(3) o4 q95 @(FrenchHorn) [4 r1] #mmla LoopPlay(#mmlb,1) #mmlc TR(4) o3 q95 @(Contrabass) [6 r1] #mmla LoopPlay(#mmlb,0) #mmlc TR(5) o3 q95 @(Timpani) [8 r1] #mmla LoopPlay(#mmlb,-1) #mmlc } #LN={RMDCresc(0)} #LFF={v127 RMDV(120,127) #LN} #LF={v120 RMDV(95,110) #LN} #LMF={v105 RMDV(85,95) #LN} #LMP={v95 RMDV(75,85) #LN} #LP={v80 RMDV(65,75) #LN} #LPP={v70 RMDV(50,60) #LN} #L5={RMDV(-20)} #LC={RMDCresc(1)} #LC2={RMDCresc(2)} #LD={RMDCresc(-1)} #LD2={RMDCresc(-2)} IF(GAKUHU=1) { RCDINIT(0,0) } ELSE { RCDINIT(370,856) } Key(KEY) Int QTemp Function QSet(value) { QTemp=value } Function Q(value) { Str MML="q" IF(GAKUHU=1) { MML=MML+"100" } ELSE { MML=MML+(value * QTemp / 100) } MML } #V_PIANO={ #REV V(100) M(0) IF(BRIGHT=1) { @(BrightPiano) } ELSE { @(GrandPiano) } QSet(100) } // Tempo TR(16) // intro #introtempo={ [ TmpChangeR(80,0) r8 TmpChangeR(100,0) TmpChangeR(130,!4.) TmpChangeR(150,!2) TmpChangeR(130,!2) TmpChangeR(90,!2) ] TmpChangeR(65,0) r8 TmpChangeR(80,0) TmpChangeR(120,!4.) TmpChangeR(130,!2) TmpChangeR(120,!1) TmpChangeR(125,!1) TmpChangeR(85,!0) TmpChangeR(120,!2) TmpChangeR(95,!2) } #m1tempo={ TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) // [3 TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) ] TmpChangeR(130,!2) TmpChangeR(125,!2) [ TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) ] TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(100,!2) [3 TmpChangeR(130,!2) TmpChangeR(125,!2) ] TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(120,!8) TmpChangeR(110,!8) TmpChangeR(100,0) TmpChangeR(130,!1) TmpChangeR(142,!2) TmpChangeR(100,!2) TmpChangeR(130,!4.) TmpChangeR(75,0) r16 TmpChangeR(150,0) r16 TmpChangeR(130,0) TmpChangeR(90,!2) TmpChangeR(120,0) TmpChangeR(100,!1) } #m2tempo={ [ TmpChangeR(128,!2) TmpChangeR(126,!4) TmpChangeR(80,0) TmpChangeR(130,!8) TmpChangeR(110,!8) TmpChangeR(128,!2) TmpChangeR(126,!4) TmpChangeR(120,0) TmpChangeR(90,!8) TmpChangeR(110,!8) ] TmpChangeR(128,!2) TmpChangeR(126,!4) TmpChangeR(80,0) TmpChangeR(130,!8) TmpChangeR(110,!8) TmpChangeR(130,!2) TmpChangeR(128,!4) TmpChangeR(85,0) TmpChangeR(134,!8) TmpChangeR(115,!8) TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(120,!2) TmpChangeR(90,!2) [3 TmpChangeR(130,!2) TmpChangeR(125,!2) ] TmpChangeR(130,!2) TmpChangeR(110,!8) TmpChangeR(90,!4.) } #intro2tempo={ [ TmpChangeR(70,0) r8 TmpChangeR(95,0) TmpChangeR(130,!4.) TmpChangeR(150,!2) TmpChangeR(130,!2) TmpChangeR(90,!2) ] TmpChangeR(55,0) r8 TmpChangeR(65,0) TmpChangeR(110,!4.) TmpChangeR(130,!2) TmpChangeR(120,!1) TmpChangeR(125,!1) TmpChangeR(85,!0) TmpChangeR(120,!2) TmpChangeR(90,!2) } #m3tempo={ TmpChangeR(128,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(125,!8) TmpChangeR(90,0) TmpChangeR(100,!4^8) TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) TmpChangeR(120,!2) TmpChangeR(80,0) TmpChangeR(110,!2) TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(110,!4.) TmpChangeR(70,!8) TmpChangeR(100,!8) TmpChangeR(115,!4.) TmpChangeR(90,!2) TmpChangeR(90,0) TmpChangeR(100,!4) TmpChangeR(95,!4) TmpChangeR(85,0) TmpChangeR(55,!4.) TmpChangeR(160,!8) TmpChangeR(100,0) TmpChangeR(115,!2) TmpChangeR(105,!2) TmpChangeR(130,!2) TmpChangeR(115,!2) TmpChangeR(130,!2) TmpChangeR(125,!2) // TmpChangeR(130,!2) TmpChangeR(125,!8) TmpChangeR(90,0) TmpChangeR(100,!4^8) TmpChangeR(130,!2) TmpChangeR(125,!4) TmpChangeR(90,0) TmpChangeR(125,!4) TmpChangeR(120,!2) TmpChangeR(75,0) TmpChangeR(70,!4.) TmpChangeR(120,!8) TmpChangeR(120,0) TmpChangeR(130,!2) TmpChangeR(125,!2) TmpChangeR(130,!2) TmpChangeR(115,!2) [ TmpChangeR(130,!2) TmpChangeR(125,!2) ] [ TmpChangeR(130,!2) TmpChangeR(115,!2) ] [ TmpChangeR(125,!2) TmpChangeR(115,!2) ] TmpChangeR(105,!1) TmpChangeR(90,!1) TmpChangeR(110,0) TmpChangeR(125,!1^1) TmpChangeR(105,!1^1) TmpChangeR(125,!1^1) TmpChangeR(105,!1) TmpChangeR(70,!1) TmpChangeR(50,0) r8 TmpChangeR(123,!4) r2. TmpChangeR(100,!1) TmpChangeR(80,!1) } #introtempo #tempotr={ #m1tempo #m2tempo #intro2tempo } LoopPlay(#tempotr,0) #m3tempo // pedal IF(LONGPEDAL=1) { #p1={ [ #PEDALON r4 #PEDALOFF r2. r2 #PEDALON r4 r8. #PEDALOFF #PEDALON r16 #PEDALOFF ] #PEDALON r4. #PEDALOFF r8r2 r1 [4 r1] } #p2={ [ [3 #PEDALON r2^16 #PEDALOFF r2 r-16 [#PEDALON r8 #PEDALOFF r4.] ] [4 #PEDALON r2 #PEDALOFF ] : #PEDALON r4 #PEDALOFF r2. r1 ] #PEDALON r2 #PEDALOFF r2 #PEDALON r8 #PEDALOFF r8^2. } #p3={ [4 #PEDALON r2 #PEDALOFF r2 ] [3 #PEDALON r2 #PEDALOFF r2 ] r1 // #PEDALON r2^8 #PEDALOFF r4. #PEDALON r2. #PEDALOFF #PEDALON r4 #PEDALOFF #PEDALON r2.^8 #PEDALOFF r8 // #PEDALON r2 #PEDALOFF r2 #PEDALON r2. #PEDALOFF #PEDALON r4 #PEDALOFF #PEDALON r2. #PEDALOFF #PEDALON r8. #PEDALOFF r16 } #p4={ [2 #PEDALON r4 #PEDALOFF r2. r2 #PEDALON r4 r8. #PEDALOFF #PEDALON r16 #PEDALOFF ] #PEDALON r4. #PEDALOFF r8^r2 [3 r1] } #p5={ [ [3 #PEDALON r2^16 #PEDALOFF r2 r-16 r2 #PEDALON r4 r8. #PEDALOFF #PEDALON r16 #PEDALOFF ] : [4 #PEDALON r2 #PEDALOFF ] #PEDALON r4 #PEDALOFF r2. r1 ] [#PEDALON r2 #PEDALOFF] #PEDALON r4. #PEDALOFF r8^2 [#PEDALON r2 #PEDALOFF] #PEDALON r4^16 #PEDALOFF r8.^2 [#PEDALON r2 #PEDALOFF] #PEDALON r1 #PEDALOFF #PEDALON r2 #PEDALOFF r2 #PEDALON r4^16 #PEDALOFF r8.^2 [4 r1] #PEDALON r4 #PEDALOFF r2. #PEDALON r1 #PEDALOFF #PEDALON r4 #PEDALOFF r2. #PEDALON r2 #PEDALOFF [#PEDALON r4 #PEDALOFF] #PEDALON r4. #PEDALOFF r8^2 r1 [#PEDALON r2 #PEDALOFF] } } ELSE { #p1={ [2 r1] #PEDALON r4. #PEDALOFF r8r2 r1 #PEDALON r4. #PEDALOFF r8r2 [4 r1] } #p2={ [ [3 #PEDALON r2^16 #PEDALOFF r2 r-16 r1 ] [4 #PEDALON r2 #PEDALOFF ] : #PEDALON r4 #PEDALOFF r2. r1 ] #PEDALON r2 #PEDALOFF r2 #PEDALON r8 #PEDALOFF r8^2. } #p3={ [4 #PEDALON r4.#PEDALOFF r8^2 ] [3 #PEDALON r4 #PEDALOFF r2. ] r1 #PEDALON r2^8 #PEDALOFF r4. #PEDALON r2.^8 #PEDALOFF r8 #PEDALON r2 #PEDALOFF r2 #PEDALON r2. #PEDALOFF #PEDALON r8. #PEDALOFF r16 } #p4={ [2 #PEDALON r4. #PEDALOFF r8^r2 r1 ] #PEDALON r4. #PEDALOFF r8^r2 [3 r1] } #p5={ [ [3 #PEDALON r2^16 #PEDALOFF r2 r-16 r1 ] : [4 #PEDALON r2 #PEDALOFF ] #PEDALON r4 #PEDALOFF r2. r1 ] [#PEDALON r2 #PEDALOFF] #PEDALON r4. #PEDALOFF r8^2 [#PEDALON r2 #PEDALOFF] #PEDALON r4^16 #PEDALOFF r8.^2 [#PEDALON r2 #PEDALOFF] #PEDALON r1 #PEDALOFF #PEDALON r2 #PEDALOFF r2 #PEDALON r4^16 #PEDALOFF r8.^2 [4 r1] #PEDALON r4 #PEDALOFF r2. #PEDALON r1 #PEDALOFF #PEDALON r4 #PEDALOFF r2. #PEDALON r2 #PEDALOFF [#PEDALON r4 #PEDALOFF] #PEDALON r4. #PEDALOFF r8^2 r1 [#PEDALON r2 #PEDALOFF] } } // parts #up1={ #LF l2RCD(b>dfgb<) r2 r2. l8.RCD(a->e-fa-<) l16 RCD(g>g<) l2RCD(>dfg>d<<) r2 r2. l8.RCD(a->e-fa-<) l16 RCD(g>g<) l8 RCD(>fg>df<<) } #up2={ c8r8r2. } #up3={ r2 r8 #LF r16l16RCD(c>c<) l8.RCD(d>d<) l16RCD(e->e-<) l2RCD(e->e-<) < #LP r8.l16RCD(g>ce-g<) l8.RCD(g>ce-g<) l16RCD(g>ce-g<) #LMP l2RCD(a->ce-a-<) l8 #LP RCD(g>ce-g<) > #LF r16l16RCD(c>c<) l8.RCD(d>d<) l16RCD(e->e-<) l2RCD(e->e-<) < #LP r8.l16RCD(g>ce-g<) #LMP l8.RCD(g>ce-g<) #LMF l16RCD(g>ce-g<) #LF l1RCD(a>ce-a<) l8 RCD(>da>d<<) r8 l4RCD(g>dg<) r8.l16RCD(g>d-g<) l8.RCD(a->d-a-<) l16 RCD(g>d-g<) l8 RCD(g>cg<) l16 RCD(>c>c<<) r16 l4 RCD(f>cf<) r8.l16RCD(f>cf<) l8.RCD(g>cg<) l16RCD(f>cf<) #LMF l2.^8.RCD(e>ce<) l16RCD(e->e-<) Sub{b2}l4RCD(e->e-<) #LMP RCD(d>d<) r2 } #up4={ r2 r8 #LP r16l16RCD(c>c<) #LMP l8.RCD(d>d<) #LMF l16RCD(e->e-<) #LF l2RCD(e->e-<) ce-g<) l8.RCD(g>ce-g<) l16RCD(g>ce-g<) #LMP l2RCD(a->ce-a-<) l8 #LP RCD(g>ce-g<) > #LMP r16l16RCD(c>c<) #LMF l8.RCD(d>d<) #LMF l16RCD(e->e-<) #LF l2RCD(e->e-<) ce-g<) l8.#LMP RCD(g>ce-g<) #LMF l16RCD(g>ce-g<) #LF l1RCD(a>e-fa<) #LP l4.RCD(b->fb-<) l4RCD(b->fb-<) RCD(b>g-b<) RCD(b>gb<) > #LMP RCD(cgb->c<) RCD(c#b>c#<) #LMF l8 RCD(db>d<) RCD(e-b->e-<) RCD(eb->e<) #LF l2RCD(fb->df<) l4 RCD(dfb->d<) #LMF Sub{RCD(e-fa) } RMD(>d8.c16<) l8 RCD(dfb-) r8r2. } #lo1={ l16 [ #LF #LC RMD(a-g fde-d )] RMDV(20) : >> ] RMD(b8)>> } #co2={ l16 RMD(a-g fde-d) < RMDCresc(-1)[3 RMD(bga-g fde-d<)]> RMDCresc(1) RMD(cgf) [RMD(e-d)] RMD(cb-a-) [RMD(gf)] RMDCresc(3) RMD(e-d>e-d) RMDCresc(-1) [RMD(c)]<[RMD(a-g)][RMD(fe-)] } #loc1={ #LF RMD(c) #L5 #LC RMD(g>cde-g>cd) #LD RMD(e-dccd) #LD RMD(e-dccd) #LD RMD(e-dccd) #LD RMD(e-dc) #L5 #LC RMD(b>dg>) #LD RMD(d) #L5 #LC RMD(b->d-g>) #LD RMD(d-) #L5 #LC RMD(a>cf>) #LD RMD(c) #L5 #LC RMD(a->cf>) #LD RMD(cg>c d-cdc# e-ded# feg-f) #LD RMD(gf#a-g b-a-gf e-dcc-b-c-c-b-c-cb-cb-b-dfb->dg16.f32 fddfb->dgf) #LD2 RMD(fd>d-cc- cc-c-d-g-a-) #LD RMD(b-a-g-d-<)] #LF RMD(d-)> #L5 #LC2 RMD(d-gb->d-) #LD RMD(cc-f-g-) #LD RMD(a-g-f-c-<)] #LF RMD(c-)> #L5 #LC2 RMD(c-fa->c-<) #LD RMD(b-a-g- fe-dc-) #L5 #LC RMD(b->e-f) #LD RMD(gfe-) #L5 #LC RMD(b>dg>) #LD RMD(dcde-g>cd) #LD RMD(e-dcd-fg a->d-fg a-gfd- l16 RMD(ed#feg-f gf#a-g ag#b-a) RMD(>c-c d-cdc# e-ded# feg-f) RMD(gf#a-g b-a-gf e-dfe- gfe-d) RMD(cdc > RMD(d-c Q(40)RMD(c8) Q(95) } #coend={ #LFF l16 RMD(a-g ecd-c) [3 RMD(f<)] Q(60)l4 [RCD(c>c<)] } #lo3={ [3 #loc1 : #loc2 ] #locfp2 #lobb [3 #loc1 : #loc2 ] #locf2 #lobc } #lo7={ [ [3 #loc1 : #loc2 ] #locfp2 : #lobb ] } // #up5={ #LF l2.RCD(b>d#g#b<) l8.RCD(d#g#b>d#<) l16 RCD(e#>e#<) l2.RCD(f#a#>d#f#<) l8. RCD(f#>f#<) l16 RCD(g#>g#<) l2.RCD(a>c#f#a<) l8.RCD(c#f#a>c#<) l16 RCD(d#>d#<) l2.RCD(eg#>c#e<) l8.RCD(e>e<) l16 RCD(f#>f#<) l2.RCD(g#>d#f#g#<) l8.RCD(g#>d#f#g#<) l16 RCD(a#>a#<) l4 RCD(>c-fa->c-<<) l2 RCD(b->fa-b-<) l8.RCD(b->fa-b-<) l16 RCD(>c>c<<) > l4 RCD(d-gb->d-<) l4 RCD(cgb->c<) r2 r1 #LFF [ l2 RCD(a->cfa-<) l4 RCD(f>cf<) RCD(cf>c<) : l2 RCD(fb-) l4 RCD(fa-) r4 ] l2.RCD(cf>c<) l8.RCD(fb) l16RCD(cf>c<) } #up6={ l2 RCD(dfb>d<) r2 r2.l8.RCD(e-fa-) l16RCD(g) l2 RCD(fg>df<) r2 r2.l8.RCD(e-fa-) l16RCD(g) l8 RCD(fg>dg<) } #lo5={ l8 RMD(g#8)l16 RMD(>gg# b>d# d#g#dd# g#bgg#) RMD(<>>d#d# d#f#) l16 RMD(e#f# a>c#c#f#c# f#ae#f#) RMD(>c#c#<c# eg#c#e>>d#>fc->gc d-ccd-c ccfg a->cfg) #LC RMD(a->cfg) #LD RMD(a-gfc) #LN : RMD(d-fd-d-f)]< ] RMD(dfdc cda-) } #lo6={ l8 RCD(g8) } #up11={ r2r16 #LF l16 RCD(c>c<) l8 RCD(c#>c#<) l8.RCD(d>d<) l16 RCD(e->e-<) l2 RCD(e->e-<) r8.l16 #LP RCD(ce-g) l8.RCD(ce-g) l16 RCD(ce-g) #LMP l2 RCD(ce-a-) #LP l12 RCD(ce-g) #LF RCD(b) RCD(c>c<) l16 RCD(d->d-<) RCD(d>d<) r16. l32 RCD(e->e-<) l2 RCD(e->e-<) r8.#LP l16 RCD(ce-g) l8.#LMP RCD(ce-g) l16 #LMF RCD(ce-g) #LF l1 RCD(ce-a) Sub { r-40 RCDINIT(35,50) l8 RCD(da>d<) r8 } r4 RCDINIT(400,856) l4 RCD(dg) l12 r [RCD(d-g)] l16 RCD(d-g) RCD(d-a-) r RCD(d-g) RCD(g) RCD(c>c<) r8 l4 RCD(cf) l12 r [RCD(cf)]Sub{l20 RCD(ce)RCD(cf)RCD(cg)rRCD(cf)}r4 l4 RCD(ce) Sub{l2. RMD(c2.)} l2^8. RCD(e-) l16 RCD(e-) Sub{l2 RMD()} l4 RCD(e-) RCD(d)r2 r1. #LF l12 r RCD(b) RCD(c>c<) l16 RCD(d->d-<) RCD(d>d<) r RCD(e->e-<) l2 RCD(e->e-<) r8.l16 #LP RCD(ce-g) l8.RCD(ce-g) l16 RCD(ce-g) #LMP l2 RCD(ce-a-) #LP l12 RCD(ce-g) #LF RCD(b) RCD(c>c<) Sub{l20 RCD(c#>c#<) RCD(d>d<) RCD(f>f<) r RCD(e->e-<)} r4 l2 RCD(e->e-<) r8.l16 #LP RCD(ce-g) l8.#LMP RCD(ce-g) l16 #LMF RCD(ce-g) l1 #LF RCD(e-a) #LFF l2 RCD(d-b-) l4 RCD(d-a-) l8.RCD(d-g-) l16 #LF RCD(d-f) #LF l2 RCD(d-f) #LMF l4 RCD(e) r4 #LFF l2 RCD(c-f-a-) l4 RCD(c-g-) l8.RCD(c-f-) l16 #LF RCD(c-e-) #LFF l2 RCD(c-e-) #LMF l4 RCD(d) r4 #LFF l1 RCD(e-g) #LF Sub{l1 RMD(d1)}Sub{l2 RMD() #LMP RMD()} #LMF RMD(g2^4.) #LMP RMD(f8) #LP Sub{l1 RCD(c)}l2 RMD(f2e-2) Sub{l1 RCD()} l8 RMD(e-8f16e-16 d-8.e-16 f4) l1^1 RCD(c) Sub{l2. RCD()} RMD(c4.d4)r4 r1 Sub{} RMD(c1.)#LMP RMD(d2) #LMF l1RCD(e) #LP Sub{l1 RCD()} Sub{RMD()} RMD(c2.)l4 #LF RCD(d) #LFF l8 RCD(ce) } #upend2={ l2 #FF RCD(cfa>c<) RCD(cfa->c<) l4Q(60) RCD(cfg>c<) RCD(ceg>c<) } TR(1) #V_PIANO RCDINIT(400,856) RMDINIT(250,370,110,115) v110 Q(98) o5 Sub{#p1} #up1 o7 #co2 #tr1={ Sub{#p2} #up2 o6 #up3 r1 o6 #up4 o5 Sub{#p3} #up5 o6 Sub{#p4} #up6 o7 #co2 } LoopPlay(#tr1,0) Sub{#p5} #up2 o6 #up11 o7 #coend #upend2 IF(GAKUHU=0) {r1r1 v0 c1} TR(2) #V_PIANO RMDINIT(250,370,110,115) Q(95) o5 Sub{#p1} r8 #lo1 o6 #co2 #tr2={ Sub{#p2} #lo3 Sub{#p3} o2 #lo5 #lo6 o5 Sub{r-8 #p4} #lo1 o6 #co2 } LoopPlay(#tr2,0) Sub{#p5} #lo7 #loend o6 #coend #loend2