// 子犬のワルツ by ななこっち★
// Fryderyk Franciszek Chopin Valse op.64-1
/////////////////////////////////////////////////////////////////////////////////////////
// 各種設定らしきもの
Int MSGS=0
Int TWM2=0
Int TIMIDITY=0
Int LOOP=2

Int KEY=0
Int TEMPORATIO=100
Int TEMPODIFF=0
Int IGNORETEMPO=0
Int BRIGHT=0
Int TINY=0
Int GAKUHU=0
//Int DEBUG=1
//Mute(1,2,3)
// ↑上2行のコメント外すと、メトロノームだけが鳴るなの。どうやって使うかは秘密なの。ぐすぐす；；
////////////////////////////////////////////////////////////////////////////////////////////////
拍子 3,4

曲名{"子犬のワルツ Valse op.64-1"}
作者{"Fryderyk Franciszek Chopin MML by ななこっち★"}

IF(MSGS=1 || TWM2=1) {
	ResetGS
}
#METORONOMEMML={M4m4m4}

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 {r32y64,127}}
#PEDALOFF={r-34 y64,0 r34}

///////////////////////////////////////////////////////////////////////////////
// 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

}

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(110)
	M(0)
	IF(BRIGHT=1) {
		IF(MSGS=1 || TWM2=1) {
			@(BrightPiano,16)	// for MSGS
		} ELSE {
			@(BrightPiano)
		}
	} ELSE {
		IF(MSGS=1 || TWM2=1) {
			@(GrandPiano,16)	// for MSGS
		} ELSE {
			@(GrandPiano)
		}
	}
	QSet(100)
}

// Tempo

TR(16)
	// intro
	TmpChange(200,0)
	TmpChange(90,!8)
	TmpChangeR(200,!4.)
	TmpChangeR(240,!2)
	TmpChangeR(260,!2.)
	TmpChangeR(230,!2.^2.)

// Loop Start
	#tempoloop={
		// 1
		TmpChangeR(215,!8)
		TmpChangeR(240,!2^8)
		TmpChangeR(255,!2.^2.)
		TmpChangeR(230,!2^8)
		TmpChangeR(200,!8)

		TmpChangeR(195,0)
		TmpChangeR(200,!4)
		TmpChangeR(220,!2)
		TmpChangeR(230,!2.)
		TmpChangeR(200,0)
		TmpChangeR(220,!4)
		TmpChangeR(230,!2)
		TmpChangeR(225,!2.)

		TmpChangeR(240,!8)
		TmpChangeR(260,!2^8)
		TmpChangeR(270,!2.^2.)
		TmpChangeR(250,!2^8)
		TmpChangeR(220,!8)

		TmpChangeR(200,0)
		TmpChangeR(220,!4)
		TmpChangeR(230,!2)
		TmpChangeR(240,!2.)
		TmpChangeR(210,0)
		TmpChangeR(230,!4)
		TmpChangeR(240,!2)
		TmpChangeR(210,!2.)

		// 2
		[
			TmpChangeR(200,0)
			TmpChangeR(270,!2.)
			TmpChangeR(280,!2.^2.)
			TmpChangeR(260,!2.)
			TmpChangeR(280,!2.^2.)
			TmpChangeR(270,!2.)
			TmpChangeR(230,!2.)

			TmpChangeR(270,!2.)
			TmpChangeR(285,!2.^2.)
			TmpChangeR(230,!2.)
			:
			TmpChangeR(270,!2.^2.^2)
			TmpChangeR(250,!4)
			TmpChangeR(190,0)
			r2.
		]
		TmpChangeR(260,!2.^2.)
		TmpChangeR(240,!2.)
		TmpChangeR(170,0)
		r2
		// 3
		TmpChangeR(140,0)
		r4
		TmpChangeR(210,!2.^2.)
		TmpChangeR(200,!2.^2.)
		TmpChangeR(210,!2.^2.)
		TmpChangeR(200,!2.)
		TmpChangeR(180,0)
		TmpChangeR(155,!2.)

		TmpChangeR(195,0)
		TmpChangeR(230,!2.^2.)
		TmpChangeR(197,!2.)
		TmpChangeR(165,!2.)
		TmpChangeR(205,!2)
		TmpChangeR(155,!4^2.^2.^2.)

		TmpChangeR(230,!2.)
		TmpChangeR(260,!2.^2.^2.)
		TmpChangeR(240,!2.^2.^2.)
		TmpChangeR(220,!2.)

		TmpChangeR(270,!2.^2.)
		TmpChangeR(230,0)
		TmpChangeR(200,!2)r4
		TmpChangeR(170,!2.)
		TmpChangeR(180,!2.)
		TmpChangeR(160,!2.)
		TmpChangeR(80,!2.^2.)

		// 4 intro
		TmpChangeR(135,0)
		TmpChangeR(145,!2.)
		TmpChangeR(125,!2.^2.)
		TmpChangeR(140,!2)

		TmpChangeR(150,!4)
		r4
		TmpChangeR(145,0)
		TmpChangeR(130,!8)
		TmpChangeR(218,0)
		TmpChangeR(210,!8)
		TmpChangeR(250,!2)
		TmpChangeR(270,!2)
		TmpChangeR(280,!2.)
		TmpChangeR(250,!2.)
	}
// loop end
	LoopPlay(#tempoloop,0)
	// 4
	TmpChangeR(240,!8)
	TmpChangeR(260,!2^8)
	TmpChangeR(270,!2.^2.)
	TmpChangeR(250,!2)
	TmpChangeR(230,!4)

	TmpChangeR(220,0)
	TmpChangeR(240,!4)
	TmpChangeR(260,!2)
	TmpChangeR(270,!2.)
	TmpChangeR(220,0)
	TmpChangeR(250,!4)
	TmpChangeR(260,!2)
	TmpChangeR(240,!2.)

	TmpChangeR(245,!8)
	TmpChangeR(265,!2^8)
	TmpChangeR(275,!2.^2.)
	TmpChangeR(255,!2)
	TmpChangeR(240,!4)

	TmpChangeR(235,0)
	TmpChangeR(245,!4)
	TmpChangeR(270,!2)
	TmpChangeR(275,!2.)
	TmpChangeR(225,0)
	TmpChangeR(270,!4)
	TmpChangeR(270,!2)
	TmpChangeR(235,!2.)

	// 5
	TmpChangeR(220,0)
	[
		TmpChangeR(280,!2.)
		TmpChangeR(290,!2.^2.)
		TmpChangeR(270,!2.)
		TmpChangeR(290,!2.^2.)
		TmpChangeR(280,!2.)
		TmpChangeR(240,!2.)
		:
		TmpChangeR(280,!2.)
		TmpChangeR(295,!2.^2.)
		TmpChangeR(240,!2.)
		TmpChangeR(270,!2.^2.^2)
		TmpChangeR(250,!4)
		TmpChangeR(160,0)
		r2.
		TmpChangeR(210,0)
	]
	TmpChangeR(300,!2.^2.)
	TmpChangeR(250,!2.)
	TmpChangeR(200,0)
	TmpChangeR(150,!2.)

	TmpChangeR(190,!4)
	TmpChangeR(210,!4)
	TmpChangeR(220,!4)
	TmpChangeR(245,!2)
	TmpChangeR(210,!4)
	TmpChangeR(180,!2.)
	TmpChangeR(140,0)

// pedal part
#p1={
	//
	[
		[4 #PEDALON r4 #PEDALOFF r2]
		[1 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4 #PEDALOFF r2]
		[1 #PEDALON r2 #PEDALOFF r4]
		[1 #PEDALON r4 #PEDALOFF r2]
	]
}
	//
#p2={
	[
		[3 #PEDALON r4 #PEDALOFF r2]
		[3 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4 #PEDALOFF r2]

		[6 #PEDALON r4 #PEDALOFF r2]
		[2 #PEDALON r2 #PEDALOFF r4]
	]
}
#p3={
	//
	[1 #PEDALON r2. r2. #PEDALOFF]
	[5 #PEDALON r2. #PEDALOFF]
	Sub{[#PEDALON r5 r5 r5 #PEDALOFF #PEDALON r5 #PEDALOFF]} r2.
	[5 #PEDALON r2. #PEDALOFF]
	[1 #PEDALON r2 #PEDALOFF r4]
	[1 #PEDALON r2. #PEDALOFF r2.]

	[10 #PEDALON r2 #PEDALOFF r4]
	[3 #PEDALON r2. #PEDALOFF]
	[1 r2.]
	[1 #PEDALON r2. #PEDALOFF]
	[1 r2.]
}
#p4={
	#PEDALON [4 r2.] #PEDALOFF
	[4 r2.]
}
#p5={
	//
	[
		[4 #PEDALON r4 #PEDALOFF r2]
		[1 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4 #PEDALOFF r2]
		[1 #PEDALON r2 #PEDALOFF r4]
		[1 #PEDALON r4 #PEDALOFF r2]
	]
	//
}
#p6={
	[
		[3 #PEDALON r4. #PEDALOFF r4.]
		[3 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4. #PEDALOFF r4.]
		[1 #PEDALON r4 #PEDALOFF r2]
		:
		[6 #PEDALON r4 #PEDALOFF r2]
		[2 #PEDALON r2 #PEDALOFF r4]
	]
	[4 #PEDALON r4 #PEDALOFF r2]
	#PEDALON r2 #PEDALOFF r4
	r2.
	#PEDALON r2. #PEDALOFF
	#PEDALON r2 #PEDALOFF r4
}


//

#intro={
	v100
	l8
	IF(GAKUHU=1) {
		RMDINIT(0,0,110,110)
	} ELSE {
		RMDINIT(192,384,90,110)
	}
	RMDV(55,60)
	RMD(r32a-32b-32)
	RMDV(65,75)
	RMD(a-8^32  ga->c<b-)
	RMDV(65,75)
	RMD(ga-b-a->c<b-)
	RMDV(70,80)
	RMD(ga->c<b-ga-)
	RMDV(75,85)
	RMD(>c<b-ga->c<b-)
	RMDV(80,90)
}

#melody1={
	[
		[
			RMD(ga->c<b-ga-)
			:
			RMD(>c<b-ga->c<b-)
		]
		RMD(b->cd-e-fg-)
		:

		[
			RMD(b-4.a-g-f)
			:
			RMD(fe-)
			RMDV(-5)
			RMD(e-32f32)
			RMDV(5)
			RMD(e-16d) Q(60) RMD(e-4) Q(99)
		]
		RMD(fe-32f32e-16de-f<b-)
	]
	[
		RMD(b-4.a-g-f)
		:
		RMD(fe-)
		RMDV(-5)
		RMD(e-32f32)
		RMDV(5)
		RMD(e-16d) Q(60) RMD(e-4) Q(99)
	]
	RMD(e-fe-de-e)
}

Int M2FLG=0
#melody2={
	[
		[
			IF(M2FLG=0) {
				RMDV(90,95)
				RMDV(-3)
				RMD(f12g-12f12)
				RMDV(3)
				RMD(efa-g-)
			}
			M2FLG=0
			RMD(fg-fefb-)
			RMDV(-3)
			RMD(a-12b-12a-12)
			RMDV(3)
			RMD(ga->c<b-)
			:
			RMD(a-b-a-ga->d-)
			RMD(c<b-a-g-fe-)
			RMD(d-c<b-a-g-f)
			RMD(e-d-ce-b-a-)
			RMD(ga-b->cd-e-)
		]
		RMD(a-b-a-ga->f)
		RMD(e-d-c<b-a-g-)
		RMD(fe-d-c<b-a-)
		RMDV(85,95)
		RMD(a>c<b-fg-c)
		:
		M2FLG=1
		RMDV(85,87)
		RMD(d-4r4>)
		RMDV(90,90)
		RMD(f4^12)
		RMDV(-3)
		RMD(g-12) RMD(f12)
		RMDV(3)
		RMD(efa-g-)
	]
	RMDV(85,85)
	RMD(d-)r8r4
}

#melody3={
	l4v105
	RMDV(75,85)
	RMD(a-2.e-)
	RMD(a-2e)
	RMD(a-2f>)
	RMD(f2)
	RMD(f2.<b->)
	RMD(f2c	e-2d-)
	Sub{RMD(c5e-5d-5<b-5)}r2.

	RMD(a-2e-)
	RMD(a-2e)
	RMD(a-2f>)
	RMD(f2.)
	RMDV(-3)
	RMD(c32d-32)
	RMDV(3)
	RMD(c8.<b>c)
	RMD(a-<b->g<)
	RMD(a>g-<a-)
	RMD(>f<)
	RMDV(-3)
	RMD(fb-)

	RMDV(5)
	RMD(a-2e-)
	RMD(a-2e)
	RMD(a-2f>)
	RMD(f2)
	RMD(f2.<b->)
	RMD(f2c)
	RMD(e-d-c)
	RMD(e-d-.<b-8)

	RMDV(3)
	RMD(a-2e-)
	RMD(a-2e)
	RMD(a-2f>)
	RMD(f2.)
	RMD(f2<b->)
	RMD(e-2<a>)
	RMDV(-1)
	RMD(e-<a->d)
	RMDV(-1)
	RMD(fe-) Q(80)
	RMDV(60,60)
	RMD(a-) Q(99)<
}

#submelody3={
	r4
	[17 r2.]
	r-16..
	>
	RMDV(55,55)
	[10 RMD(a-2)r4]
	<
}

#melody4={
	RMDV(45,45)
	g16
	RMDV(50,60)
	[25 RMD(a-16b-16)]
	l8
	RMD(a-16)
	RMDV(55,65)
	RMD(g16)
	RMD(a-16>c16<b-16)
	RMD(ga->c<b-)
	RMDV(60,70)
	RMD(ga->c<b-)
	RMDV(8)
	RMD(ga->c<b-)
	RMDV(8)
	RMD(ga->c<b-)
	RMDV(8)
	RMD(ga->c<b-)
	RMDV(80,90)
}

#melody5={#melody1}

#melody6={
	[
		[
			IF(M2FLG=0) {
				RMDV(95,100)
				RMDV(-2)
				RMD(f12g-12f12)
				RMDV(2)
				RMD(efa-g-)
			}
			M2FLG=0
			RMD(fg-fefb-)
			RMDV(-2)
			RMD(a-12b-12a-12)
			RMDV(2)
			RMD(ga->c<b-)
			:
			RMD(a-b-a-ga->d-)
			RMD(c<b-a-g-fe-)
			RMD(d-c<b-a-g-f)
			RMD(e-d-ce-b-a-)
			RMD(ga-b->cd-e-)
		]
		:
		RMD(a-b-a-ga->f)
		RMD(e-d-c<b-a-g-)
		RMD(fe-d-c<b-a-)
		RMDV(85,100)
		RMD(a>c<b-fg-c)
		M2FLG=1
		RMD(d-4r4>) f4^12 RMDV(95,100) RMD(g-12) RMD(f12) RMD(efa-g-)
	]
	v++
	RMD(a-b-a-g) Q(60)RMD(a-)Q(99)>>
	RMDV(105,110)
	RMD(f)
	RMDV(98,100)
	l12
	RMD(e-d-c<b-a-g-fe-d-)
	RMD(c<b-a-g-fe-d-c<b-)
	l8
	RMDV(101,105)
	RMD(a>c<b-fg-c)
	RMD(d-4f4)r2v0 IF(GAKUHU=0) { f4 }
}

#adf={RCD(a->d-f<)}
#acg={RCD(a->cg-<)}
#cg={RCD(>cg-<)}
#fce={RCD(f>ce-<)}
#fd={RCD(f>d-<)}
#aeg={RCD(a->e-g-<)}
#af={RCD(a->f<)}
#be={RCD(b->e-<)}
#fad={RCD(fa->d-<)}
#ga={RCD(g-a-)}
#gac={RCD(g-a->c<)}
#ef={RCD(>e-f<)}
#df={RCD(>d-f<)}
#ga={RCD(>g-a-<)}
#fa={RCD(>fa-<)}
#deb={RCD(>d-e-b-<)}
#ad={RCD(a->d-<)}
#acf={RCD(a->cf<)}
#gce={RCD(g>ce<)}
#fc={RCD(f>c<)}
#fae={RCD(fa->e-<)}
#fadm={RCD(fa->d<)}
#dg1={RCD(>d-g<)}
#dg2={RCD(>d-g-<)}
#faf={RCD(fa->f<)}

#chord2={
	l4
	[4 r4 #adf #adf]
	[2 r4 #acg #acg]
	[2 r4 #cg #cg]
	[4 r4 #adf #adf]
	[3 r4 #acg #acg]
	[1 r4 #cg r4]
}

#chord3={
	[
		r4 #fce #fce
		r4 #fd #fd
		r4 #aeg #aeg
		r4 #af r4
		r4 #be r4
		r4 #fad r4
		r4 <#ga> #gac
		r4 #adf r4

		r4 #ef #ef
		r4 #df #df
		r4 #ga #ga
		r4 #fa r4
		r4 #deb r4
		r4 #fad r4
		r4 <#ga #ga>
		r4 #af r4
	]
}

#chord4={
	r4 [5 #gac]
	r4 #ad #ad
	r4 #adf #adf
	r4 #acg #acg
	r4 #aeg #aeg
	[r4 #adf #adf]

	r4 <#ga #ga>
	r4 #gac #gac
	r4 #ad #ad
	r4 #adf #adf

	r4 #acf #acf
	r4 #gce r4
	r2 #fc
	r2.

	//--
	r4 <#ga #ga>
	r4 #gac #gac
	r4 #ad #ad
	r4 #adf #adf

	r4 #acg #acg
	r4 #aeg #aeg
	[r4 #adf #adf]

	r4 <#ga #ga>
	r4 #gac #gac
	r4 #fae #fae
	r4 #fadm #fadm

	Q(30)
	r4 #dg1 #dg1
	r4 #dg2 #dg2
	Q(17)
	r4 #cg r4
	r2.
}

#chord5={#chord2}

#chord6={
	[
		r4 #fce #fce
		r4 #fd #fd
		r4 #aeg #aeg
		r4 #af r4
		r4 #be r4
		r4 #fad r4
		r4 <#ga> #gac
		r4 #adf r4

		r4 #ef #ef
		r4 #df #df
		r4 #ga #ga
		r4 #fa r4
		:
		r4 #deb r4
		r4 #fad r4
		r4 <#ga #ga>
		r4 #af r4
	]
	r4 #deb r4
	r2.
	r4 <#ga #ga>
	r4 <#fa> r4
	
}


#bass2={
		l4
	[
		[
			RMD(d-rr)
			RMD(frr)
		]
		<RMD(a-rr)>
		RMD(e-rr)
		<RMD(a-rr)>
		:
		RMD(a-rr)
	]
	RMD(a-r<a-)
}

#bass3={
	[
		l4
		RMD(arr)
		RMD(b-rr)>
		RMD(crr)
		RMD(d-rr)
		RMD(g-rr)<
		RMD(a-rr)
		RMD(a-rr)>
		RMD(d-rr)

		RMD(a2.)
		RMD(b-2.)>
		RMD(c2.)
		RMD(d-rr)<
		RMD(g-rr)<
		RMD(a-rr)
		RMD(a-rr)
		RMD(d-rr)
	]
}

#bass4={
	l4
	RMD(a-)>rrrrr
	RMD(d-rr)
	<RMD(a-)>rr
	RMD(e-)rr
	<RMD(a-)>rr
	RMD(d-)rr
	RMD(f)rr
	RMD(c)rr
	<RMD(a-)>rr
	RMD(d-)rr
	<RMD(b)>rr
	RMD(c)rr
	<RMD(c)>rr
	<RMD(f)>rr
	rrr

	RMD(c)rr
	<RMD(a-)>rr
	RMD(d-)rr
	<RMD(a-)>rr
	RMD(e-)rr
	<RMD(a-)>rr
	RMD(d-)rr
	RMD(f)rr
	RMD(c2.)
	<RMD(a-)>rr
	RMD(c-)rr
	<RMD(b-)>rr
	RMD(e-)rr
	rrr
	RMD(a-2.)
	r2.
}

#bass5={#bass2}

#bass6={
	[
		l4
		RMD(a)rr
		RMD(b-)rr>
		RMD(c)rr
		RMD(d-)rr
		RMD(g-)rr<
		RMD(a-)rr
		RMD(a-)rr>
		RMD(d-)rr

		RMD(a2.)
		RMD(b-2.)>
		RMD(c2.)
		RMD(d-)rr<
		:
		RMD(g-)rr<
		RMD(a-)rr
		RMD(a-)rr
		RMD(d-)rr
	]
	<RMD(g-)rrrrr
	RMD(a-)rr
	RMD(d-)rr
	v0d-
}

TR(1)
	#V_PIANO
	o5
	QSet(100)
	Q(99)
	#intro
	#tr1={
		Sub{#p1 #p2}
		#melody1
		#melody2

		Sub{#p3}
		Sub{#submelody3}
		#melody3
		Sub{#p4}
		#melody4
	}
	LoopPlay(#tr1,0)
	Sub{#p5}
	#melody5
	Sub{#p6}
	#melody6

TR(2)
	#V_PIANO
	q100
	QSet(100)
	Q(17)v65
	[4 r2.]
	#tr2={
		o4
		Sub{#p1 #p2}
		#chord1
		#chord2
		#chord3
		v55
		Sub{#p3}
		#chord4
		[8 r2.]
		v65
	}
	LoopPlay(#tr2,0)
	Sub{#p5}
	#chord5
	Sub{#p6}
	#chord6

TR(3)
	#V_PIANO
	q100
	QSet(100)
	Q(95)v95
	IF(GAKUHU=1) {
		RMDINIT(0,0,110,110)
	} ELSE {
		RMDINIT(270,856,85,95)
	}
	[4 r2.]
	#tr3={
		o4
		Sub{#p1 #p2}
		#bass2
		#bass3
		RMDV(75,90)
		Sub{#p3}
		#bass4
		[8 r2.]
		RMDV(85,95)
	}
	LoopPlay(#tr3,0)
	Sub{#p1 #p2}
	#bass5
	#bass6