// 革命
// 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(<b>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(<b>fg)
		l8 RCD(ceg)

		RCDINIT(96,425)
		l4 RCD(ceg)
		l8 RCD(<b>fg)
		l8 RCD(ceg)

		RCDINIT(193,765)
		l4 RCD(ceg)
		l8 RCD(<b>fg)
		l8 RCD(ceg)

		RCDINIT(0,0)
		l4 RCD(ceg)
		l8 RCD(<b>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(<b>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-<) <r8.#LP l16RCD(g>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-<) <r8.#LP l16RCD(g>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 <bga-g fde-d<)
		#LD
		RMD(bga-g fde-d) [4 RMD(c<g>)]
		RMDV(20)
		:
		<RMD(b8)>>>
	]
	RMD(b8)>>
}
#co2={
	l16
	RMD(a-g fde-d) < RMDCresc(-1)[3 RMD(bga-g fde-d<)]>
	RMDCresc(1) RMD(c<b>gf) [RMD(e-d)] RMD(c<b>b-a-) [RMD(gf)]
	RMDCresc(3) RMD(e-d>e-d) RMDCresc(-1) [RMD(c<b>)]<[RMD(a-g)][RMD(fe-)]
}


#loc1={
	#LF
	RMD(c) #L5 #LC RMD(g>cde-g>cd) #LD RMD(e-dc<ge-dc<g)
}
#loc2={
	[#LF RMD(c) #L5 #LC RMD(g>cd) #LD RMD(e-dc<g)]
}
#locfp2={
	[#LF RMD(c) #L5 #LC RMD(f#>cd) #LD RMD(e-dc<f#)]
}
#locf2={
	[#LF RMD(c) #L5 #LC RMD(f>cd) #LD RMD(e-dc<f)]
}
#lobb={
	#LF RMD(<b>) #L5 #LC RMD(b>dg>) #LD RMD(d<gd<b)
	#LF RMD(<b->) #L5 #LC RMD(b->d-g>) #LD RMD(d-<gd-<b-)
	#LF RMD(<a>) #L5 #LC RMD(a>cf>) #LD RMD(c<fc<a)
	#LF RMD(<a->) #L5 #LC RMD(a->cf>) #LD RMD(c<fc<a-)

	#LC
	RMD(<g>g>c<b> d-cdc# e-ded# feg-f)
	#LD
	RMD(gf#a-g b-a-gf e-dc<b a-gfd)
}

#lobc={
	#LN
	RMD(d-b->c-<b->b-<b->c-<b- e-b->c-<b->b-<b->c-<b-)
	RMD(e-b->c<b->b-<b->c<b- fb->b-<b- g-b->b-<b-)
//	RMD(fb->dfb->dg16.f32 fd<b-g fe-c<f)
	#LC RMD(fb->dfb->dgf) #LD2 RMD(fd<b-g) #LN RMD(fe-c<f)
	RMD(<b->>d-cc- <b->cc-<b- a>c-<b-a g#b-ag#)
}

#loend={
	[#LF RMD(d-) #L5 #LC RMD(>d-g-a-) #LD RMD(b-a-g-d-<)]
	#LF RMD(d-)> #L5 #LC2 RMD(d-gb->d-) #LD RMD(c<b-a- gfed-c<b-a-g)
	[#LF RMD(c-) #L5 #LC RMD(>c-f-g-) #LD RMD(a-g-f-c-<)]
	#LF RMD(c-)> #L5 #LC2 RMD(c-fa->c-<) #LD RMD(b-a-g- fe-dc-<b-a-g-f)
	[#LMF RMD(<b->) #L5 #LC RMD(b->e-f) #LD RMD(gfe-<b-)]
	[#LMP RMD(<b>) #L5 #LC RMD(b>dg>) #LD RMD(d<gd<b)]
	#LP RMD(c) #L5 #LC RMD(g>cde-g>cd) #LD RMD(e-dc<ge-dc<g) #LN
	#LP RMD(<f>d-fg a->d-fg a-gfd- <a-fd-<a-)

	Q(40)l8 RMD(g) Q(95)>l16 RMD(ed#feg-f gf#a-g ag#b-a)
	RMD(>c-<b->c<b> d-cdc# e-ded# feg-f)
	RMD(gf#a-g b-a-gf e-dfe- gfe-d)
	RMD(c<b>dc <b-a-gf# ga-fg e-fde-)

	[
		Q(40)l8 RMD(c) Q(95)l16>> RMD(d-c <b-ga-g ecd-c <b-ga-g)
		#LPP [8 fc]
	]
	#LFF >Q(40)RMD(c8) Q(95)
}

#coend={
	#LFF
	l16
	RMD(a-g ecd-c) [3 RMD(<b-ga-g ecd-c)]
}

#loend2={
	<
	v120
	l2 [RCD(f>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(<b->fb-) l4 RCD(<a->fa-) r4
	]
	l2.RCD(cf>c<) l8.RCD(<b>fb) l16RCD(cf>c<) 
}
#up6={
	l2 RCD(dfb>d<) r2
	r2.l8.RCD(<a->e-fa-) l16RCD(<g>g) 
	l2 RCD(fg>df<) r2
	r2.l8.RCD(<a->e-fa-) l16RCD(<g>g) 
	l8 RCD(fg>dg<) 
}

#lo5={
	l8 RMD(g#8)l16 RMD(>gg# b>d#<a#b> d#g#dd# g#bgg#)
	RMD(<<d#>>>d#<e#f# a#>d#<dd# f#a#<aa#> d#f#<e#f#)
	l8 RMD(<f#8>) l16 RMD(e#f# a>c#<g#a >c#f#<b#>c# f#ae#f#)
	RMD(<c#>>c#<d#e g#>c#<<b#>c# eg#<gg# >c#e<d#e)
	RMD(<b#>>>d#<gg# ag#f#e d#c#<b#a gg#d#g#)
	RMD(d>>f<ab- >c-<b-a-g- fe-dc- <ab-fb-)
	RMD(e>>g<b>c d-c<b-a- gfeg fed-c)
	#LC
	RMD(<b>cd-c <b-a-gf ed-c<b >c<b-a-g)

	#LN
	[
		RMD(f>cfg a->cfg) #LC RMD(a->cfg) #LD RMD(a-gfc) #LN
		:
		RMD(d-fd-<a- fd-<a-f) [RMD(d-<a->d-f)]<
	]
	RMD(dfdc <a-fdc <a-fdc <a->cda-)
}

#lo6={
	l8 RCD(<g8>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(<g>ce-g) l8.RCD(<g>ce-g) l16 RCD(<g>ce-g)
	#LMP l2 RCD(<a->ce-a-) #LP l12 RCD(<g>ce-g) #LF RCD(<b>b) RCD(c>c<) l16 RCD(d->d-<) RCD(d>d<) r16. l32 RCD(e->e-<)
	l2 RCD(e->e-<) r8.#LP l16 RCD(<g>ce-g) l8.#LMP RCD(<g>ce-g) l16 #LMF RCD(<g>ce-g)
	#LF l1 RCD(<a>ce-a)
	Sub { r-40 
		RCDINIT(35,50)
		l8 RCD(<a>da>d<) r8
	} r4
	RCDINIT(400,856)
	l4 RCD(<g>dg) l12 r [RCD(<g>d-g)] l16 RCD(<g>d-g) RCD(<a->d-a-) r RCD(<g>d-g)
	RCD(<g>g) RCD(c>c<) r8 l4 RCD(<f>cf)
		l12 r [RCD(<f>cf)]Sub{l20 RCD(<e>ce)RCD(<f>cf)RCD(<g>cg)rRCD(<f>cf)}r4
	l4 RCD(<e>ce) Sub{l2. RMD(c2.)} l2^8. RCD(<e->e-) l16 RCD(<e->e-)
	Sub{l2 RMD(<b2>)} l4 RCD(<e->e-) RCD(<d>d)r2
	r1.


	#LF
	l12 r RCD(<b>b) RCD(c>c<) l16 RCD(d->d-<) RCD(d>d<) r RCD(e->e-<)
	l2 RCD(e->e-<) r8.l16 #LP RCD(<g>ce-g) l8.RCD(<g>ce-g) l16 RCD(<g>ce-g)
	#LMP l2 RCD(<a->ce-a-) #LP l12 RCD(<g>ce-g) #LF RCD(<b>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(<g>ce-g) l8.#LMP RCD(<g>ce-g) l16 #LMF RCD(<g>ce-g)
	l1 #LF RCD(<a>e-a)

	#LFF l2 RCD(<b->d-b-) l4 RCD(<a-b->d-a-) l8.RCD(<g-b->d-g-) l16 #LF RCD(<fb->d-f)
	#LF l2 RCD(<fb->d-f) #LMF l4 RCD(<eb->e) r4
	#LFF l2 RCD(<a->c-f-a-) l4 RCD(<g-a->c-g-) l8.RCD(<f-a->c-f-) l16 #LF RCD(<e-a->c-e-)
	#LFF l2 RCD(<e-a->c-e-) #LMF l4 RCD(<da->d) r4
	#LFF l1 RCD(<g>e-g)
	#LF Sub{l1 RMD(d1)}Sub{l2 RMD(<g2>) #LMP RMD(<g2>)} #LMF RMD(g2^4.) #LMP RMD(f8)
	#LP Sub{l1 RCD(<g>c)}l2 RMD(f2e-2)
	Sub{l1 RCD(<fa->)} l8 RMD(e-8f16e-16 d-8.e-16 f4<a-4>)
	l1^1 RCD(<e->c)
	Sub{l2. RCD(<df>)} RMD(c4.<b8>d4)r4
	r1
	Sub{<l8 RMD(c8) r8 r2. l1 RCD(fa-)>}
	RMD(c1.)#LMP RMD(d2)
	#LMF l1RCD(<eg>e)
	#LP
	Sub{l1 RCD(<ca->)}
	Sub{RMD(<g2f2>)}
	RMD(c2.)l4 #LF RCD(<b>d)
	#LFF l8 RCD(<eg>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