// リスト：超絶技巧練習曲 第4番「マゼッパ」 ループ版 v1.1
/////////////////////////////////////////////////////////
Int DY=1			// 奨励音源ならこのまま、それ以外なら0
Int DEBUG=0			// 1=メトロノーム 2=雑音付き、途中で拍子2回変わるので非奨励
Int KEY=0			// 移調
Int TEMPORATIO=100	// 100がデフォルト
Int TINY=0			// MIDIを軽くする TWM2時必須
Int IGNORETEMPO=0		// テンポ変化を無効にする
// Tempo 60
Int TEMPODIFF=0		// テンポ差分 -5以下にしてはならない
Int LOOP=2			// ループ回数 30 with TEMPORATIO=101

System.RandomSeed=1

IF(TINY=1) {
	Expression.Frequency(2);
	Modulation.Frequency(8);
	System.TimeBase=96
} ELSE {
	Expression.Frequency(1);
	Modulation.Frequency(1);
	System.TimeBase=96
}


///////////////////////////////////////////////////////////////////////////////
// title:        "tempo.h" ver 1.2
// description:  TempoChange非互換高機能テンポチェンジ機能インクルードファイル(2025/09/20)
// keywords:     SAKURA Function     by ななこっち★ @nanakochi123456
// HP:           https://773.moe/
///////////////////////////////////////////////////////////////////////////////
// tempo.h デバッグ機能付きテンポチェンジ
// （サクラに TempoChange がありますが、その高機能版です）
//
// Include前に、以下の変数を定義して下さい。
//
// ・Int DEBUG=0 // 1 でメトロノームがなります、2 でテンポチェンジ時にうるさい雑音が鳴ります
// 　（メトロノームは10000小節で終了します、4/4 を前提に作成されています。）
//
// ・Int RTEMPO
//  値%の範囲内でランダムにする
// ・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={M8m8m8 m8m8m8}

IF(#METORONOMEMML="") {
	#METORONOMEMML={M4m4m4m4}
}

IF(TEST=1) {
	DEBUG=2
	Tempo 200
}

IF(DEBUG>=1) {
	IF(DEBUG=2) {
		#DEBUGMML1={Sub{@1v90V(127)'v50o5do6fo7a#o8d'}}
		#DEBUGMML2={Sub{@1v90V(127)'v50o5co6eo7g#o8c'}}
		#DEBUGMML3={Sub{@1v127V(127)'v80o4cdefgabo6cdefgab'}}
	}
	TR(10)
		$M{n(MetronomeBell),}
		$m{n(MetronomeClick),}
		[10000
			Rythm{#METORONOMEMML}
		]
}
Function TmpChangeR(tempo, len) {
	TmpChange(tempo, len)
	r%(len)
}

Function TmpChange(Atempo, len) {
	Int Rtempo

	IF(len=0) {
		IF(DEBUG=2) {
			#DEBUGMML1
		}
	} ELSE {
		IF(DEBUG=2) {
			#DEBUGMML2
		}
	}

	IF(RTEMPO>0) {
		Int Ztempo = Atempo * RTEMPO / 100
		Rtempo=Random(Atempo - Ztempo, Atempo + Ztempo)
		//Print("RTEMPO="+RTEMPO+" A="+Atempo+" Z="+Ztempo+" R="+Rtempo)
	} ELSE {
		Rtempo=Atempo
	}

	IF(len=0) {
		IF(!(IGNORETEMPO<>1)) {
			IF(TEMPORATIO=0) {
				Tempo=Rtempo+TEMPODIFF
			} ELSE {
				Tempo=(Rtempo*TEMPORATIO)/100+TEMPODIFF
			}
		}
	} ELSE {
		IF(!(IGNORETEMPO<>1)) {
			Int TT1=Tempo
			Int TT2
			IF(TEMPORATIO=0) {
				TT2=Rtempo+TEMPODIFF
			} ELSE {
				TT2=(Rtempo*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:           https://773.moe/
///////////////////////////////////////////////////////////////////////////////
// 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,#mml2,0)
///////////////////////////////////////////////////////////////////////////////
// テストする時は、以下のコメントを外してください。
//Int TEST=1
//Int LOOP=5
///////////////////////////////////////////////////////////////////////////////

Function LoopPlay(Str Mml1, Str Mml2, Int count) {
	Str _MML
	For (Int i = 1; i < LOOP + count; i++) {
		_MML=_MML + Mml1 + Mml2
	}
	_MML=_MML + Mml1
	_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

}

///////////////////////////////////////////////////////////////////////////////
// title:        "rnd.h" ver 1.12
// description:  単音、和音、ドラムをランダムな音量とタイミングで演奏するインクルードファイル(2025/09/23)
// keywords:     SAKURA Function     by ななこっち★ @nanonano773
// License:      GPL3
///////////////////////////////////////////////////////////////////////////////
// rnd.h メロディー、和音、ドラムをランダムなタイミングで演奏する
///////////////////////////////////////////////////////////////////////////////
// 詳細の取扱説明書は、ファイル下部へ
//
// Function RMDINIT(rmin, rmax, vmin, vmax)
// 休符乱数値の最小値、最大値、最小、最大音量設定する。両方0にすると、同一タイミングで演奏します。
// 
// Function RMDR(rmin, rmax)
// 休符乱数値の最小値、最大値の設定のみする
//
// Function RMDV(rmin, rmax)
// 音量乱数値の最小値、最大値の設定のみする。
// 同一の値を設定を両方に行うと、固定音量となる。
// rmaxを省略すると、rmin、rmax共に加算、または減算を行なう
//
// rmin, rmaxは与える休符値、vmin, vmaxは与える音量値
//
// Function RMDAV(vmin, vmax)
// MMLの音文字の前に ! を指定することで、アクセントと認識する
// そのアクセントの音量を設定する
//
// Function RMDQ(qmin, qmax)
//
// Function RMD(mml)
// ランダムに演奏したいメロディーのMMLを入力する
// Function RMDENABLE(1 or 0)
// メロディーランダム演奏機能を有効/無効にする
///////////////////////////////////////////////////////////////////////////////
// Function RCDINIT(rmin,rmax,vmin,vmax,vdif)
// 乱数値の最小値、最大値を設定する。両方0にすると、同一タイミングで演奏します。
// vmin,vmaxは音量の最小値、最大値
// vdifは音量増加値(マイナス値を指定すると減少値)
//
// Function RCD(mml)
// ランダムに演奏したい和音のMMLを入力する
// Function RCOT(mml)
// ランダムに演奏したい単音のMMLを入力すると、オクターブで演奏する。
// Function RCDENABLE(1 or 0)
// 和音ランダム演奏機能を有効/無効にする
// Function RCDQ(qmin, qmax)
// Function RCDR(rmin, rmax)
// Function RCDV(vmin, vmax)
// Function RCDAV(vmin, vmax)
// MMLの音文字の前に ! を指定することで、アクセントと認識する
// そのアクセントの音量を設定する
//
// RCDをSRCDに置き換えた同名関数があります。ケースバイケースで使い分けられます。
//
// RDINIT(ドラム音量,randvフラグ,randrフラグ,BDロテートフラグ,SDロテートフラグ,シンバルロテートフラグ)
// RDV(Int V)
// RDCresc(Int V)
// RandV(Int MIN, Int MAX)
// RandR(Int MIN, Int MAX)
// SyncR()
// #RDRUMSET1
///////////////////////////////////////////////////////////////////////////////
// Example
// Include(rnd.h)
// TR(1)
//   RMDINIT(53,513,90,110)
//   l4 RMD(ceg)
//   RMDV(5)
//   l8 RMD(<b>fg)
//   RMDV(-5)
//   l8 RMD(ceg)
// TR(2)
//   RCDINIT(53,513)
//   l4 RCD(ceg)
//   l8 RCD(<b>fg)
//   RCDINIT(53,513,90,100)
//   l8 RCD(ceg)
// TR(10)
//   RDINIT(110,1,1,1,1,1)
//   #RDRUMSET1
//   l8 [4 Rythm {'bh'h'sh''bh''bh'h'sh'h}]
///////////////////////////////////////////////////////////////////////////////

Int RMD_RMIN=192
Int RMD_RMAX=768
Int RMD_VMIN=95
Int RMD_VMAX=100
Int RMD_AMIN=95
Int RMD_AMAX=100
Int RMD_AFLG=0
Int RMD_CRESC=0
Int RMD_ENABLE=1
Int RMD_QMIN=0
Int RMD_QMAX=0

Int RCD_MIN=192
Int RCD_MAX=768
Int RCD_VMIN=-1
Int RCD_VMAX=-1
Int RCD_AMIN=-1
Int RCD_AMAX=-1
Int RCD_CRESC=0
Int RCD_TMIN=-1
Int RCD_TMAX=-1
Int RCD_ENABLE=1
Int RCD_QMIN=0
Int RCD_QMAX=0

Int SRCD_MIN=192
Int SRCD_MAX=768
Int SRCD_VMIN=-1
Int SRCD_VMAX=-1
Int SRCD_CRESC=0
Int SRCD_TMIN=-1
Int SRCD_TMAX=-1
Int SRCD_ENABLE=1
Int SRCD_QMIN=0
Int SRCD_QMAX=0

Int BDROTATE=0
Int SDROTATE=0
Int CYMROTATE=0

Int BDINIT=0
Int CYMINIT=0
Int SDINIT=0

Int RANDV=0
Int RANDR=0

Int RDVOL=127

Function RMDENABLE(Int FLG) {
	RMD_ENABLE=FLG
}

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 RMDQ(Int QMIN, Int QMAX) {
	RMD_QMIN=QMIN
	RMD_QMAX=QMAX
}

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 RMDAV(Int VMIN, Int VMAX) {
//	RMD_CRESC=0
	IF(VMAX=0) {
		Int TMPMIN=RMD_AMIN
		Int TMPMAX=RMD_AMAX
		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_AMIN=TMPMIN
		RMD_AMAX=TMPMAX
	} ELSE {
		RMD_AMIN=VMIN
		RMD_AMAX=VMAX
	}
}

Function RMD(Str MML) {
	Str BUF=""
	Str FIRST=""
	Str ML=""
	Str M
	Str R
	Str VL
	Str RRMML
	Str RMML
	Str QRMML=""
	Str Q=""
	Str FM=""
	Int C=0
	Str LenStr
	Int TOKEN=0
	Int TO=0
	Int ACT=0

	BUF=""
	R=""
	IF(RMD_ENABLE=0) {
		BUF=MML
	} ELSE {
		For(Int i=1; MID(MML, i, 1)!=""; i++) {
			M=MID(MML, i, 1)
			IF(M=="!") {
				RMD_AFLG=1
			} ELSE {
				IF((ASC(M)>=48 && ASC(M)<=57) || M="r"||M="."||M="^") {
					IF(TO>=1) {
						LenStr=LenStr+M
					}
					ML=ML+M
				} ELSE {
					IF((ASC(M)>=97 && ASC(M)<=103)) {
						TOKEN++
						TO=1
						IF(RMD_QMAX>0) {
							Q=Random(RMD_QMIN, RMD_QMAX)
							QRMML="q"+Q
						}
						FM=QRMML+RRMML+VL+ML+RMML
						IF(TOKEN>1) {
							C++
							IF(FM!="") {
								BUF=BUF+"Sub{"+FM+"}r"+LenStr
							}
							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
							}
						}
						IF(RMD_AFLG == 0) {
							VL="v"+Random(RMD_VMIN, RMD_VMAX)
							RMDV(RMD_CRESC,0)
							RMDAV(RMD_CRESC,0)
							RMD_AFLG=0
						} ELSE {
							VL="v"+Random(RMD_AMIN, RMD_AMAX)
							RMDV(RMD_CRESC,0)
							RMDAV(RMD_CRESC,0)
							RMD_AFLG=0
						}
					} ELSE {
						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
						}
					}
				}
			}
		}
		FM=QRMML+RRMML+VL+ML+RMML
		IF(FM!="") {
			BUF=BUF+"Sub{"+FM+"}r"+LenStr
		}
	}
	IF(DEBUG=1 || TEST=1) {
//		Print(RMD_QMIN)
//		Print(RMD_QMAX)
//		Print(BUF)
	}
	BUF
}

Function RCDENABLE(Int FLG) {
	RCD_ENABLE=FLG
}

Function SRCDENABLE(Int FLG) {
	SRCD_ENABLE=FLG
}

Function RCDCresc(Int C) {
	RCD_CRESC=C
}

Function SRCDCresc(Int C) {
	SRCD_CRESC=C
}

Function RCDINIT(Int MIN, Int MAX, Int VMIN, Int VMAX, Int VDIF) {
	RCD_MIN=MIN
	RCD_MAX=MAX
	IF(VMIN<>0 && VMAX<>0) {
		RCD_VMIN=VMIN
		RCD_VMAX=VMAX
		RCD_CRESC=VDIF
	} ELSE {
		RCD_VMIN=-1
		RCD_VMAX=-1
		RCD_CRESC=0
	}
}

Function RCDR(Int RMIN, Int RMAX) {
	RCD_RMIN=RMIN
	RCD_RMAX=RMAX
}

Function RCDV(Int VMIN, Int VMAX) {
	RCD_CRESC=0
	IF(VMAX=0) {
		Int TMPMIN=RCD_VMIN
		Int TMPMAX=RCD_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
		}
		RCD_VMIN=TMPMIN
		RCD_VMAX=TMPMAX
	} ELSE {
		RCD_VMIN=VMIN
		RCD_VMAX=VMAX
	}
}

Function RCDQ(Int QMIN, Int QMAX) {
	RCD_QMIN=QMIN
	RCD_QMAX=QMAX
}

Function SRCDQ(Int QMIN, Int QMAX) {
	SRCD_QMIN=QMIN
	SRCD_QMAX=QMAX
}


Function RCDAV(Int VMIN, Int VMAX) {
	RCD_CRESC=0
	IF(VMAX=0) {
		Int TMPMIN=RCD_AMIN
		Int TMPMAX=RCD_AMAX
		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
		}
		RCD_AMIN=TMPMIN
		RCD_AMAX=TMPMAX
	} ELSE {
		RCD_AMIN=VMIN
		RCD_AMAX=VMAX
	}
}

Function RCD(Str MML) {
	Str BUF=""
	Str FIRST=""
	Str ML=""
	Str M
	Str R
	Str FM
	Int C=0
	Str VL
	Int ACT=0
	Str Q
	Str QRMML

	IF(RCD_ENABLE=0) {
		BUF="'" + MML + "'"
	} ELSE {
		RCD_TMIN=RCD_VMIN
		RCD_TMAX=RCD_VMAX

		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="!") {
				ACT=1
				C++
			} ELSE {
				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=""
						IF(RCD_TMIN>=0 && RCD_TMAX>=0) {
							VL="v"+Random(RCD_TMIN, RCD_TMAX)
							RCD_TMIN=RCD_TMIN+RCD_CRESC
							RCD_TMAX=RCD_TMAX+RCD_CRESC
							IF(RCD_TMIN<0) { RCD_TMIN=0 }
							IF(RCD_TMIN>127) { RCD_TMIN=127 }
							IF(RCD_TMAX<0) { RCD_TMAX=0 }
							IF(RCD_TMAX>127) { RCD_TMAX=127 }
						} ELSE {
							VL=""
						}
						ML=VL+ML
					} ELSE {
						BUF=BUF+"Sub" + CHR(123)+R+ML+CHR(125)
						IF(RCD_MAX>0) {
							R=R+"r"+Random(RCD_MIN, RCD_MAX)
						}
						IF(RCD_TMIN>=0 && RCD_TMAX>=0) {
							IF(ACT == 0) {
								VL="v"+Random(RCD_TMIN, RCD_TMAX)
							} ELSE {
								VL="v"+Random(RCD_AMIN, RCD_AMAX)
							}
							ACT=0
							RCD_TMIN=RCD_TMIN+RCD_CRESC
							RCD_TMAX=RCD_TMAX+RCD_CRESC
							IF(RCD_TMIN<0) { RCD_TMIN=0 }
							IF(RCD_TMIN>127) { RCD_TMIN=127 }
							IF(RCD_TMAX<0) { RCD_TMAX=0 }
							IF(RCD_TMAX>127) { RCD_TMAX=127 }
						} ELSE {
							VL=""
						}
						ML=VL+M
					}
					ACT=0
				} ELSE {
					IF(M="#"||M="+"||M="-") {
						ML=ML+M
					} ELSE {
						IF(C>0) {
							ML=ML+VL+M
						} ELSE {
							FM=FM+VL+M
						}
					}
				}
			}
		}
		IF(RCD_QMAX>0) {
			Q=Random(RCD_QMIN, RCD_QMAX)
			QRMML="q"+Q
		}
		VL="Sub{r-96" + "v"+Random(RMD_VMIN, RMD_VMAX)+"}"
		BUF=QRMML+BUF+"Sub"+CHR(123)+R+ML+CHR(125)+FIRST+"r"
		IF(DEBUG=1 || TEST=1) {
//			Print(RCD_QMIN)
//			Print(RCD_QMAX)
//			Print(BUF)
		}
	}
	BUF
}

Function ROCT(Str MML) {
	Str BUF=""
	Str FIRST=""
	Str ML=""
	Str M
	Str R
	Str FM
	Int C=0
	Str VL

	MML=MML + ">" + MML + "<"

	IF(RCD_ENABLE=0) {
		BUF="'" + MML + "'"
	} ELSE {
		RCD_TMIN=RCD_VMIN
		RCD_TMAX=RCD_VMAX

		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=""
					IF(RCD_TMIN>=0 && RCD_TMAX>=0) {
						VL="v"+Random(RCD_TMIN, RCD_TMAX)
						RCD_TMIN=RCD_TMIN+RCD_CRESC
						RCD_TMAX=RCD_TMAX+RCD_CRESC
						IF(RCD_TMIN<0) { RCD_TMIN=0 }
						IF(RCD_TMIN>127) { RCD_TMIN=127 }
						IF(RCD_TMAX<0) { RCD_TMAX=0 }
						IF(RCD_TMAX>127) { RCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+ML
				} ELSE {
					BUF=BUF+"Sub" + CHR(123)+R+ML+CHR(125)
					IF(RCD_MAX>0) {
						R=R+"r"+Random(RCD_MIN, RCD_MAX)
					}
					IF(RCD_TMIN>=0 && RCD_TMAX>=0) {
						VL="v"+Random(RCD_TMIN, RCD_TMAX)
						RCD_TMIN=RCD_TMIN+RCD_CRESC
						RCD_TMAX=RCD_TMAX+RCD_CRESC
						IF(RCD_TMIN<0) { RCD_TMIN=0 }
						IF(RCD_TMIN>127) { RCD_TMIN=127 }
						IF(RCD_TMAX<0) { RCD_TMAX=0 }
						IF(RCD_TMAX>127) { RCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+M
				}
			} ELSE {
				IF(M="#"||M="+"||M="-") {
					ML=ML+M
				} ELSE {
					IF(C>0) {
						ML=ML+VL+M
					} ELSE {
						FM=FM+VL+M
					}
				}
			}
		}
		BUF=BUF+"Sub"+CHR(123)+R+ML+CHR(125)+FIRST+"r"
		IF(DEBUG=1 || TEST=1) {
			Print(BUF)
		}
	}
	BUF
}

Function SRCDINIT(Int MIN, Int MAX, Int VMIN, Int VMAX, Int VDIF) {
	SRCD_MIN=MIN
	SRCD_MAX=MAX
	IF(VMIN<>0 && VMAX<>0) {
		SRCD_VMIN=VMIN
		SRCD_VMAX=VMAX
		SRCD_CRESC=VDIF
	} ELSE {
		SRCD_VMIN=-1
		SRCD_VMAX=-1
		SRCD_CRESC=0
	}
}

Function SRCDR(Int RMIN, Int RMAX) {
	SRCD_RMIN=RMIN
	SRCD_RMAX=RMAX
}

Function SRCDV(Int VMIN, Int VMAX) {
	SRCD_CRESC=0
	IF(VMAX=0) {
		Int TMPMIN=SRCD_VMIN
		Int TMPMAX=SRCD_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
		}
		SRCD_VMIN=TMPMIN
		SRCD_VMAX=TMPMAX
	} ELSE {
		SRCD_VMIN=VMIN
		SRCD_VMAX=VMAX
	}
}

Function SRCD(Str MML) {
	Str BUF=""
	Str FIRST=""
	Str ML=""
	Str M
	Str R
	Str FM
	Int C=0
	Str VL

	SRCD_TMIN=SRCD_VMIN
	SRCD_TMAX=SRCD_VMAX

	IF(SRCD_ENABLE=0) {
		BUF="'" + MML + "'"
	} ELSE {
		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=""
					IF(SRCD_TMIN>=0 && SRCD_TMAX>=0) {
						VL="v"+Random(SRCD_TMIN, SRCD_TMAX)
						SRCD_TMIN=SRCD_TMIN+SRCD_CRESC
						SRCD_TMAX=SRCD_TMAX+SRCD_CRESC
						IF(SRCD_TMIN<0) { SRCD_TMIN=0 }
						IF(SRCD_TMIN>127) { SRCD_TMIN=127 }
						IF(SRCD_TMAX<0) { SRCD_TMAX=0 }
						IF(SRCD_TMAX>127) { SRCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+ML
				} ELSE {
					BUF=BUF+"Sub" + CHR(123)+R+ML+CHR(125)
					IF(SRCD_MAX>0) {
						R=R+"r"+Random(SRCD_MIN, SRCD_MAX)
					}
					IF(SRCD_TMIN>=0 && SRCD_TMAX>=0) {
						VL="v"+Random(SRCD_TMIN, SRCD_TMAX)
						SRCD_TMIN=SRCD_TMIN+SRCD_CRESC
						SRCD_TMAX=SRCD_TMAX+SRCD_CRESC
						IF(SRCD_TMIN<0) { SRCD_TMIN=0 }
						IF(SRCD_TMIN>127) { SRCD_TMIN=127 }
						IF(SRCD_TMAX<0) { SRCD_TMAX=0 }
						IF(SRCD_TMAX>127) { SRCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+M
				}
			} ELSE {
				IF(M="#"||M="+"||M="-") {
					ML=ML+M
				} ELSE {
					IF(C>0) {
						ML=ML+VL+M
					} ELSE {
						FM=FM+VL+M
					}
				}
			}
		}
		BUF=BUF+"Sub"+CHR(123)+R+ML+CHR(125)+FIRST+"r"
		IF(DEBUG=1 || TEST=1) {
			Print(BUF)
		}
	}
	BUF
}

Function SROCT(Str MML) {
	Str BUF=""
	Str FIRST=""
	Str ML=""
	Str M
	Str R
	Str FM
	Int C=0
	Str VL

	MML=MML + ">" + MML + "<"
	IF(SRCD_ENABLE=0) {
		BUF="'" + MML + "'"
	} ELSE {
		SRCD_TMIN=SRCD_VMIN
		SRCD_TMAX=SRCD_VMAX

		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=""
					IF(SRCD_TMIN>=0 && SRCD_TMAX>=0) {
						VL="v"+Random(SRCD_TMIN, SRCD_TMAX)
						SRCD_TMIN=SRCD_TMIN+SRCD_CRESC
						SRCD_TMAX=SRCD_TMAX+SRCD_CRESC
						IF(SRCD_TMIN<0) { SRCD_TMIN=0 }
						IF(SRCD_TMIN>127) { SRCD_TMIN=127 }
						IF(SRCD_TMAX<0) { SRCD_TMAX=0 }
						IF(SRCD_TMAX>127) { SRCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+ML
				} ELSE {
					BUF=BUF+"Sub" + CHR(123)+R+ML+CHR(125)
					IF(SRCD_MAX>0) {
						R=R+"r"+Random(SRCD_MIN, SRCD_MAX)
					}
					IF(SRCD_TMIN>=0 && SRCD_TMAX>=0) {
						VL="v"+Random(SRCD_TMIN, SRCD_TMAX)
						SRCD_TMIN=SRCD_TMIN+SRCD_CRESC
						SRCD_TMAX=SRCD_TMAX+SRCD_CRESC
						IF(SRCD_TMIN<0) { SRCD_TMIN=0 }
						IF(SRCD_TMIN>127) { SRCD_TMIN=127 }
						IF(SRCD_TMAX<0) { SRCD_TMAX=0 }
						IF(SRCD_TMAX>127) { SRCD_TMAX=127 }
					} ELSE {
						VL=""
					}
					ML=VL+M
				}
			} ELSE {
				IF(M="#"||M="+"||M="-") {
					ML=ML+M
				} ELSE {
					IF(C>0) {
						ML=ML+VL+M
					} ELSE {
						FM=FM+VL+M
					}
				}
			}
		}
		BUF=BUF+"Sub"+CHR(123)+R+ML+CHR(125)+FIRST+"r"
		IF(DEBUG=1 || TEST=1) {
			Print(BUF)
		}
	}
	BUF
}

Function RDINIT(Int _RDVOL, Int _RANDV, Int _RANDR, Int _BDROTATE, Int _SDROTATE, Int _CYMROTATE) {
	RDVOL=_RDVOL
	RANDV=_RANDV
	RANDR=_RANDR
	BDROTATE=_BDROTATE
	SDROTATE=_SDROTATE
	CYMROTATE=_CYMROTATE
}

Function BassDrum(Int VO) {
	Int CC
	IF(BDROTATE=0) {
		CC=VO
	} ELSE {
		IF(BDINIT=0) {
			CC=BassDrum1
			BDINIT=1
		} ELSE {
				CC=BassDrum2
			BDINIT=0
		}
	}
	Result=CC
}

Function Snare(Int VO) {
	Int CC
	IF(SDROTATE=0) {
		CC=VO
	} ELSE {
		IF(SDINIT=0) {
			CC=Snare1
			SDINIT=1
		} ELSE {
				CC=Snare2
			SDINIT=0
		}
	}
	Result=CC
}

Function Cymbal(Int VO) {
	Int CC
	IF(CYMROTATE=0) {
		CC=VO
	} ELSE {
		IF(CYMINIT=0) {
			CC=CrashCymbal1
			CYMINIT=1
		} ELSE {
			CC=CrashCymbal2
			CYMINIT=0
		}
	}
	Result=CC
}

Function RDV(Int V) {
	RDVOL=V
}

Function RDCresc(Int V) {
	RDVOL=RDVOL+V
	IF(RDVOL>127) {
		RDVOL=127
	}
	IF(RDVOL<0) {
		RDVOL=0
	}
}

Function _RDV(Int V) {
	Int R=V
	R=R-(127-RDVOL)
	IF(R<0) {
		R=0
	}
	Result=R
}

Function RandV(Int MIN, Int MAX) {
	Str MML="v"
	IF(RANDV=0) {
		MML=MML+#STR(_RDV(MAX)
	} ELSE {
		MML=MML+Random(_RDV(MIN), _RDV(MAX))
	}
	MML
}

Str RMML
Function RandR(Int MIN, Int MAX) {
	Str MML
	IF(RANDR=1) {
		MML=MML+"r"
		RMML=RMML+"r"
		Int VALUE=Random(0,10)
		IF(VALUE<5) {
			MML=MML+"-"
		} ELSE {
			RMML=RMML+"-"
		}
		Str RAND=Random(MIN,MAX)
		MML=MML+RAND
		RMML=RMML+RAND
		MML
	}
}

Function SyncR() {
	Str MML=RMML
	RMML=""
	MML
}


#RDRUMSET1={
	// stick
	$k{Sub{RandR(800,1536) RandV(124,127) n(Sticks),16}r} //37

	// Bass Drum
	$B{Sub{RandR(800,1536) RandV(124,127) n(BassDrum(Kick2)),16}r}//35
	$b{Sub{RandR(800,1536) RandV(124,127) n(BassDrum(Kick1)),16}r}//36

	// Snare Drum
	$s{Sub{RandR(800,1536) RandV(120,127) n(Snare(Snare1)),16}r}//38
	$S{Sub{RandR(800,1536) RandV(120,127) n(Snare(Snare2)),16}r}//40

	// Toms
	$L{Sub{RandR(800,1536) RandV(123,127) n(LowTom2),16}r}//41
	$l{Sub{RandR(800,1536) RandV(123,127) n(LowTom1),16}r}//43
	$M{Sub{RandR(800,1536) RandV(123,127) n(MidTom2),16}r}//45
	$m{Sub{RandR(800,1536) RandV(123,127) n(MidTom1),16}r}//47
	$T{Sub{RandR(800,1536) RandV(123,127) n(HighTom2),16}r}//48
	$t{Sub{RandR(800,1536) RandV(123,127) n(HighTom1),16}r}//50

	// Hihat
	$p{Sub{RandR(800,1536) RandV(110,127) n(PedalHiHat),16}r}//44
	$h{Sub{RandR(800,1536) RandV( 65, 80) n(ClosedHiHat),16}r}//42
	$o{Sub{RandR(800,1536) RandV( 90,110) n(OpenHiHat),16}r}//46

	// Ride
	$r{Sub{RandR(800,1536) RandV(100,110) n(RideCymbal1),16}r}//51
	$R{Sub{RandR(800,1536) RandV(120,127) n(RideCymbal2),16}r}//59
	$P{Sub{RandR(800,1536) RandV(120,127) n(RideBell),16}r}//53

	// Cymbal
	$c{Sub{RandR(800,1536) RandV(120,127) n(Cymbal(CrashCymbal1)),16}r}//49
	$C{Sub{RandR(800,1536) RandV(120,127) n(Cymbal(CrashCymbal2)),16}r}//57

	// Splash
	$a{Sub{RandR(800,1536) RandV(120,127) n(SplashCymbal),16}r}//55
	$A{Sub{RandR(800,1536) RandV(120,127) n(ChineseCymbal),16}r}//52
}

/*
　■ rnd.h

	名目上、CCライセンスは、表示-継承としましたが、
	コード部がメインなのでGPLライセンスを適用して下さい

	Includeフォルダに入れて使います
	rnd.hとリネーム後、サクラやTWのIncludeフォルダに入れて下さい

	-- 拡張子"h"が、何らかのソフトにより登録されている場合、
	"rnd.h.mml"等とリネームされることがあります

 	この場合、フォルダオプションの"登録されている拡張子は表示しない"
	のチェックを一時外し、リネームしてみて下さい --

　■ 概要

	メロディーラインにごくわずかな休符を＋／−につけたり、音量（ベロシティー）を
　　範囲内でランダムに演奏させることで、リアルな演奏感をつけるものです。

　■ 基本雛型
	Include(rnd.h)
	TR(1)
	  RMDINIT(53,513,90,110)
	  l4 RMD(ceg)
	  RMDV(5)
	  l8 RMD(<b>fg)
	  RMDV(-5)
	  l8 RMD(ceg)
	TR(2)
	  RCDINIT(53,513)
	  l4 RCD(ceg)
	  l8 RCD(<b>fg)
	  RCDINIT(53,513,90,100)
	  l8 RCD(ceg)

　■ 関数 RMDINIT(rmin, rmax, vmin, vmax)
　　RMD機能の初期化を行います。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)

　■ 関数 RMD(mml)
　　MMLを生演奏に近くなるように演奏をします。
　　（ストトンは使えません）
　　サポートしているMMLリスト
		c- c c# d- d d# e- e e# f- f f# g- g g# a- a a# b- b b#
		r . ^
		1 2 3 4 5 6 7 8 9 0
	※数値は一応サポートしていますが、長さがうまくいかない場合、
　　　前に l8 等をつけて対応して下さい。

　　※和音はサポートしていません。RCD系の関数を使用して下さい。

　■ 関数 RMDR(rmin, rmax)
　　RMD機能の休符値のみ設定します。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)

　■ 関数 RMDV(vmin, vmax)
　　RMD機能の音量値のみ設定します。
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)

　■ 関数 RMDCresc(cresc)
　　ノートごとにcresc値の乱数音量値分を増量します。
　　マイナス値を設定すると、減量します。
	cresc : 音量増減分 (-127〜127)

　■ 関数 RMDEnable(enabled)
　　RMD機能を有効にします。初期値は1です。
　　enabled : 1=有効、0=無効

　■ 関数 RCDINIT(rmin,rmax,vmin,vmax,vdif)
　　RCD機能の乱数値を設定する。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)
	vdif : 音量増加値（マイナスを設定すると減少値） (-127〜127)

　■ 関数 RCD(mml)
	和音のMMLを生演奏に近くなるように演奏をします。
	すでに「'〜'」で囲まれているのと同等です。

　　（ストトンは使えません）
　　サポートしているMMLリスト
		c- c c# d- d d# e- e e# f- f f# g- g g# a- a a# b- b b#
		r . ^
		1 2 3 4 5 6 7 8 9 0
	※数値は一応サポートしていますが、長さがうまくいかない場合、
　　　前に l8 等をつけて対応して下さい。

　　※単音はサポートしていません。RMD系の関数を使用して下さい。

　■ RCOT(mml)
　　単音のMMLを入れると自動的に１オクターブ上の音と一緒に和音で生演奏に
　　近くなるように演奏をします。

　　（ストトンは使えません）
　　サポートしているMMLリスト
		c- c c# d- d d# e- e e# f- f f# g- g g# a- a a# b- b b#
		r . ^
		1 2 3 4 5 6 7 8 9 0
	※数値は一応サポートしていますが、長さがうまくいかない場合、
　　　前に l8 等をつけて対応して下さい。

　■ 関数 RCDR(rmin, rmax)
　　RCD機能の休符値のみ設定します。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)

　■ 関数 RCDV(vmin, vmax)
　　RCD機能の音量値のみ設定します。
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)

　■ 関数 RCDEnable(enabled)
　　RCD機能を有効にします。初期値は1です。
　　enabled : 1=有効、0=無効

　■ 関数 SRCDINIT(rmin,rmax,vmin,vmax,vdif)
　　RCD機能（サブ）の乱数値を設定する。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)
	vdif : 音量増加値（マイナスを設定すると減少値） (-127〜127)

　■ 関数 SRCD(mml)
	和音のMMLを生演奏に近くなるように演奏をします。
	すでに「'〜'」で囲まれているのと同等です。

　　（ストトンは使えません）
　　サポートしているMMLリスト
		c- c c# d- d d# e- e e# f- f f# g- g g# a- a a# b- b b#
		r . ^
		1 2 3 4 5 6 7 8 9 0
	※数値は一応サポートしていますが、長さがうまくいかない場合、
　　　前に l8 等をつけて対応して下さい。

　　※単音はサポートしていません。RMD系の関数を使用して下さい。

　■ SRCOT(mml)
　　単音のMMLを入れると自動的に１オクターブ上の音と一緒に和音で生演奏に
　　近くなるように演奏をします。

　　（ストトンは使えません）
　　サポートしているMMLリスト
		c- c c# d- d d# e- e e# f- f f# g- g g# a- a a# b- b b#
		r . ^
		1 2 3 4 5 6 7 8 9 0
	※数値は一応サポートしていますが、長さがうまくいかない場合、
　　　前に l8 等をつけて対応して下さい。

　■ 関数 SRCDR(rmin, rmax)
　　RCD機能（サブ）の休符値のみ設定します。
	rmin : 休符の最小値 (1〜System.TimeBaseの値)
	rmax : 休符の最大値 (1〜System.TimeBaseの値)

　■ 関数 SRCDV(vmin, vmax)
　　RCD機能（サブ）の音量値のみ設定します。
	vmin : 音量の最小値 (0〜127)
	vmax : 音量の最大値 (0〜127)

　■ 関数 SRCDEnable(enabled)
　　RCD機能（サブ）を有効にします。初期値は1です。
　　enabled : 1=有効、0=無効

　■ RDINIT(rdvol,randv_flag,randr_flag,bdrotate,sdrotate,cymrotate)
	RD機能を初期化します。
	rdvol : ドラムの基本音量(0〜127)
	randv_flag : ランダム音量フラグ 1=有効、0=無効
	randr_flag : ランダム休符フラグ 1=有効、0=無効
	bdrotate   : バスドラムロテートフラグ  1=有効、0=無効
　　sdrotate   : スネアドラムロテートフラグ  1=有効、0=無効
　　cymrotate  : シンバルロテートフラグ  1=有効、0=無効

　■ RDV(vol)
　　RD機能の基本音量を設定します(0〜127)

　■ RDCresc(vol)
　　ノートごとに音量増をします。マイナス値を設定すると、減をします。 (0〜127)

　■ RandV(Int MIN, Int MAX)
	ドラム定義マクロ内で使用する音量乱数範囲設定関数
	MIN : 最小音量 (0〜127)
	MAX : 最大音量 (0〜127)

　■ RandR(Int MIN, Int MAX)
	ドラム定義マクロ内で使用する休符乱数範囲設定関数
	MIN : 休符の最小値 (1〜System.TimeBaseの値)
	MAX : 休符の最大値 (1〜System.TimeBaseの値)

　■ SyncR()
	通常使用することはありませんが、ドラムの乱数休符を強制的にクリアする関数

　■ #RDRUMSET1
	既にRDVで定義してあるサンプルドラムセット
　　以下に対応します。
		k : Sticks
		B : Kick2 / b : Kick1
		s : Snare1 / S : Snare2
		L : LowTom2 / l : LowTom1
		M : MidTom2 / m : MidTom2
		T : HighTom2 / t : HighTom1
		p : PedalHihat / h : ClosedHihat / o : OPenHihat
		r : RideCymbal1 / R : RideCymbal2 / P : RideBell
		c : CrashCYmbal1 / C : CrashCymbal2
		a : SplashCymbal / A : ChineseCymbal

　■ ドラムセットの指定方法のサンプル
	$p{Sub{RandR(800,1536) RandV(110,127) n(PedalHiHat),16}r}
	$h{Sub{RandR(800,1536) RandV( 65, 80) n(ClosedHiHat),16}r}
	$o{Sub{RandR(800,1536) RandV( 90,110) n(OpenHiHat),16}r}

　　このマクロで指定することで、通常通りのドラムマクロで演奏感をつけることができます。
　　※ただし、ドラムノート音の長さに依存するものは、16の数字を適時変更するか、
	　通常の方法でマクロを指定して下さい。

　■ よりリアリティーある演奏にさせるためのコツ
　　より細かいシステムクォンタイズ(System.TimeBase)にすることをおすすめします。
	最低でも System.TimeBase=192に設定するようにしましょう。

　■ 現在わかってる問題
	MMLに数字を入れて長さを設定してもうまくいかないことがあります。
	その場合は、事前に、l8 等を設定して、長さを設定して下さい。

*/

Function Q(Int qmin, Int qmax) {
	RMDQ(qmin,qmax)
	RCDQ(qmin,qmax)
	SRCDQ(qmin,qmax)
}

#REV={
	IF(TWM2=1) {
		REV(50)
	}ELSE{
		REV(100)
	}
}

#R={
	RCDINIT(384,800)
	RMDINIT(384,800,90,110)
}

IF(DY=0) {
	#SP={
		RMDCresc(0)
		RMDV(33,36)
		RCDV(33,36)
		RCDAV(36,48)
		Sub {RMD(r96)}
	}

	#SPA={
		RMDCresc(0)
		RMDV(33,36)
		RCDV(33,36)
		RCDAV(48,56)
		Sub {RMD(r96)}
	}

	#PP={
		RMDCresc(0)
		RMDV(33,48)
		RCDV(33,48)
		RCDAV(48,56)
		Sub {RMD(r96)}
	}

	#PPA={
		RMDCresc(0)
		RMDV(33,48)
		RCDV(33,48)
		RCDAV(56,64)
		Sub {RMD(r96)}
	}

	#PPS={
		RMDCresc(0)
		RMDV(40,56)
		RCDV(40,56)
		RCDAV(56,64)
		Sub {RMD(r96)}
	}

	#PPSA={
		RMDCresc(0)
		RMDV(40,56)
		RCDV(40,56)
		RCDAV(64,72)
		Sub {RMD(r96)}
	}

	#P={
		RMDCresc(0)
		RMDV(48,64)
		RCDV(48,64)
		RCDAV(64,72)
		Sub {RMD(r96)}
	}

	#PA={
		RMDCresc(0)
		RMDV(48,64)
		RCDV(48,64)
		RCDAV(72,80)
		Sub {RMD(r96)}
	}

	#PS={
		RMDCresc(0)
		RMDV(56,72)
		RCDV(56,72)
		RCDAV(72,80)
		Sub {RMD(r96)}
	}

	#PSA={
		RMDCresc(0)
		RMDV(56,72)
		RCDV(56,72)
		RCDAV(80,88)
		Sub {RMD(r96)}
	}

	#M={
		RMDCresc(0)
		RMDV(64,80)
		RCDV(64,80)
		RCDAV(80,88)
		Sub {RMD(r96)}
	}

	#MA={
		RMDCresc(0)
		RMDV(64,80)
		RCDV(64,80)
		RCDAV(88,96)
		Sub {RMD(r96)}
	}

	#MS={
		RMDCresc(0)
		RMDV(72,88)
		RCDV(72,88)
		RCDAV(88,96)
		Sub {RMD(r96)}
	}

	#MSA={
		RMDCresc(0)
		RMDV(72,88)
		RCDV(72,88)
		RCDAV(96,104)
		Sub {RMD(r96)}
	}

	#F={
		RMDCresc(0)
		RMDV(80,96)
		RCDV(80,96)
		RCDAV(96,104)
		Sub {RMD(r96)}
	}

	#FA={
		RMDCresc(0)
		RMDV(80,96)
		RCDV(80,96)
		RCDAV(104,112)
		Sub {RMD(r96)}
	}

	#FS={
		RMDCresc(0)
		RMDV(88,104)
		RCDV(88,104)
		RCDAV(104,112)
		Sub {RMD(r96)}
	}

	#FSA={
		RMDCresc(0)
		RMDV(88,104)
		RCDV(88,104)
		RCDAV(112,120)
		Sub {RMD(r96)}
	}

	#FF={
		RMDCresc(0)
		RMDV(96,112)
		RCDV(96,112)
		RCDAV(112,120)
		Sub {RMD(r96)}
	}

	#FFA={
		RMDCresc(0)
		RMDV(96,112)
		RCDV(96,112)
		RCDAV(120,127)
		Sub {RMD(r96)}
	}

	#FFS={
		RMDCresc(0)
		RMDV(104,120)
		RCDV(104,120)
		RCDAV(120,127)
		Sub {RMD(r96)}
	}

	#FFSA={
		RMDCresc(0)
		RMDV(104,120)
		RCDV(104,120)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SF={
		RMDCresc(0)
		RMDV(112,127)
		RCDV(112,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SFA={
		RMDCresc(0)
		RMDV(112,127)
		RCDV(112,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SSF={
		RMDCresc(0)
		RMDV(127,127)
		RCDV(127,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SSFA={
		RMDCresc(0)
		RMDV(127,127)
		RCDV(127,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

} ELSE {
	#SP={
		RMDCresc(0)
		RMDV(36,52)
		RCDV(36,52)
		RCDAV(52,64)
		Sub {RMD(r96)}
	}

	#SPA={
		RMDCresc(0)
		RMDV(36,52)
		RCDV(36,52)
		RCDAV(64,72)
		Sub {RMD(r96)}
	}

	#PP={
		RMDCresc(0)
		RMDV(52,64)
		RCDV(52,64)
		RCDAV(64,72)
		Sub {RMD(r96)}
	}

	#PPA={
		RMDCresc(0)
		RMDV(52,64)
		RCDV(52,64)
		RCDAV(72,80)
		Sub {RMD(r96)}
	}

	#PPS={
		RMDCresc(0)
		RMDV(56,72)
		RCDV(56,72)
		RCDAV(72,80)
		Sub {RMD(r96)}
	}

	#PPSA={
		RMDCresc(0)
		RMDV(56,72)
		RCDV(56,72)
		RCDAV(80,84)
		Sub {RMD(r96)}
	}

	#P={
		RMDCresc(0)
		RMDV(64,80)
		RCDV(64,80)
		RCDAV(80,84)
		Sub {RMD(r96)}
	}

	#PA={
		RMDCresc(0)
		RMDV(64,80)
		RCDV(64,80)
		RCDAV(84,92)
		Sub {RMD(r96)}
	}

	#PS={
		RMDCresc(0)
		RMDV(72,84)
		RCDV(72,84)
		RCDAV(84,92)
		Sub {RMD(r96)}
	}

	#PSA={
		RMDCresc(0)
		RMDV(72,84)
		RCDV(72,84)
		RCDAV(92,96)
		Sub {RMD(r96)}
	}

	#M={
		RMDCresc(0)
		RMDV(80,92)
		RCDV(80,92)
		RCDAV(92,96)
		Sub {RMD(r96)}
	}

	#MA={
		RMDCresc(0)
		RMDV(80,92)
		RCDV(80,92)
		RCDAV(96,108)
		Sub {RMD(r96)}
	}

	#MS={
		RMDCresc(0)
		RMDV(84,96)
		RCDV(84,96)
		RCDAV(96,108)
		Sub {RMD(r96)}
	}

	#MSA={
		RMDCresc(0)
		RMDV(84,96)
		RCDV(84,96)
		RCDAV(108,112)
		Sub {RMD(r96)}
	}

	#F={
		RMDCresc(0)
		RMDV(92,108)
		RCDV(92,108)
		RCDAV(108,112)
		Sub {RMD(r96)}
	}

	#FA={
		RMDCresc(0)
		RMDV(92,108)
		RCDV(92,108)
		RCDAV(112,120)
		Sub {RMD(r96)}
	}

	#FS={
		RMDCresc(0)
		RMDV(96,112)
		RCDV(96,112)
		RCDAV(112,120)
		Sub {RMD(r96)}
	}

	#FSA={
		RMDCresc(0)
		RMDV(96,112)
		RCDV(96,112)
		RCDAV(120,124)
		Sub {RMD(r96)}
	}

	#FF={
		RMDCresc(0)
		RMDV(108,120)
		RCDV(108,120)
		RCDAV(120,124)
		Sub {RMD(r96)}
	}

	#FFA={
		RMDCresc(0)
		RMDV(108,120)
		RCDV(108,120)
		RCDAV(124,127)
		Sub {RMD(r96)}
	}

	#FFS={
		RMDCresc(0)
		RMDV(112,124)
		RCDV(112,124)
		RCDAV(124,127)
		Sub {RMD(r96)}
	}

	#FFSA={
		RMDCresc(0)
		RMDV(112,124)
		RCDV(112,124)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SF={
		RMDCresc(0)
		RMDV(120,127)
		RCDV(120,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}

	#SSF={
		RMDCresc(0)
		RMDV(127,127)
		RCDV(127,127)
		RCDAV(127,127)
		Sub {RMD(r96)}
	}
}

Key(KEY)

TR(1)
	#REV

TR(2)
	#REV

TR(3)
	#REV

TR(4)
	#REV


曲名={"超絶技巧練習曲第4番 ニ短調 S.139-4「マゼッパ」 (打ち込み版)"}
作者={"ななこっち★ based by Franz Liszt"}

拍子 4,4

#PEDALON={Sub {y23,64 r56y64,127}}
#PEDALOFF={Sub{r-48 RandR(50,72) y64,0}}
#FPEDALOFF={y64,0}
#PEDALOFF2={Sub{r-48 RandR(48,52) y64,0}}
//#PEDALOFF={Sub{r-32 y64,0 y64,0}}

/////
//Part1
//拍子 4,4

#M01_16={
	TR(16)
		TmpChangeR(80,0)
		TmpChangeR(125,!1)
		TmpChangeR(210,!1)
		TmpChangeR(140,!1)
		TmpChangeR(100,!1)
		r1
}

#M01_01={
	TR(1)
		#R #MSA l8
		RCDINIT(56,72)
		Sub {
			r4
			o5 #F #PEDALON Sub{RCD(!c#gb->eg>c#e!b-)}r8r8 #PEDALOFF r4
			o4 #F #PEDALON Sub{RCD(!g#>dfb>!dg#b>!f)}r8r8 #PEDALOFF r8

			o4 #PPS #PEDALON Sub{RCD(e-a>c!f#a>e-f#>!c)}r8..#PEDALOFF r32
			o3 #P #PEDALON Sub{RCD(b->eg>!c#eb->c#!g)}r8..#PEDALOFF r32
			o3 #PS #PEDALON Sub{RCD(!fb>dg#!b>fg#>!d)}r8..#PEDALOFF r32

			o3 #M #PEDALON Sub{RCD(!cf#a>e-!f#>ce-!a)}r8..#PEDALOFF r32
			o3 #MS #PEDALON Sub{RCD(!c#gb->e!g>c#e!b-)}r8..#PEDALOFF r32
			o3 #F #PEDALON Sub{RCD(!dg#b>f!g#b>!f)}r8..#PEDALOFF r32
			o2 #FS #PEDALON Sub{RCD(!b->fg>d!fg>!d)}r8..#PEDALOFF r32

			o2 #FF  #PEDALON Sub{RCD(!a>dfa>!a>df!a)}r4.. #PEDALOFF r16
			#R o3 #F  #PEDALON Sub{RCD(a>df!a>a>df!a)}r4.. #PEDALOFF r16
			o4 #FF  #PEDALON Sub{RCD(!a>c#ea>ga>c#e!a)}r2.#PEDALOFF r4
		}[5 r1]
}

#M01_02={
	TR(2)
		[5 r1]
}

#M01_03={
	TR(3)
		[5 r1]
}

#M01_04={
	TR(4)
		[5 r1]
}

//Part2
#M02_16={
	TR(16)
		Sub {
			TmpChangeR(37,0)TmpChangeR(98,!2)
			TmpChangeR(150,!2)
			TmpChangeR(130,!1^1)
			r2
			Sub{r-24 TmpChangeR(50,!4)}r4^16TmpChangeR(20,0)TmpChangeR(50,!4)
			TmpChangeR(50,0)TmpChangeR(30,!4)TmpChangeR(12,!9.)TmpChangeR(999,0)
		}[5 r1]
}

#M02_PART2_1={
	#SPA
	#PEDALON l16 RMDCresc(2)RMD(rab->c#) l20 RMDCresc(-2)RMD(fedc#<b-) #PEDALOFF #PEDALON l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-2)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(2)RMD(c#defgab->c#) l20 RMDCresc(-1)RMD(fedc#<b-)l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-1)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(2)RMD(c#defgab->c#) l20 RMDCresc(-1)RMD(fedc#<b-)l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-1)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(3)RMD(c#defgab->c#) l20 RMD(fedc#<b-)Sub{l36 RMD(ab->c#defgab->c#)}r4 #PEDALOFF
	Sub{#PEDALON l50 RMDCresc(-1)RMD(!fedc#<b-agfedc#<b- agfedc#<b-agfed)RMDCresc(1)RMD(c#<b-agfe dc#<b-)#SSF RMD(a)l48 #PEDALOFF q120 #PEDALON RMD(!g!f!e) #PEDALOFF}r2
	#PEDALOFF
}

#M02_PART2_2={
	#SPA
	#PEDALON l16 RMDCresc(2)RMD(rab->c#) l20 RMDCresc(-2)RMD(fedc#<b-) #PEDALOFF #PEDALON l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-2)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(2)RMD(c#defgab->c#) l20 RMDCresc(-1)RMD(fedc#<b-)l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-1)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(2)RMD(c#defgab->c#) l20 RMDCresc(-1)RMD(fedc#<b-)l24 RMDCresc(2)RMD(ab->c#def) RMDCresc(-1)RMD(b-agfed)
	#PEDALOFF #PEDALON l28 RMDCresc(3)RMD(c#defgab->c#) l20 RMDCresc(-1)RMD(fedc#<b-)Sub{l36 RMD(ab->c#defgab->c#)}r4 #PEDALOFF
	Sub{#PEDALON #SSF RMDCresc(-2)l50 RMD(!fedc#<b-agfedc#<b-)RMDCresc(-1)RMD(agfedc#<b-agfed)RMDCresc(3)RMD(c#<b-agfe dc#<b-)#SSF RMD(arrr) #PEDALOFF}r2
	#PEDALOFF
}

#M02_01={
	TR(1)
		#R q125
		o3 Sub{#M02_PART2_1}[5 r1]
}

#M02_02={
	TR(2)
		#R q125
		o2 Sub{#M02_PART2_2}[5 r1]
}

#M02_03={
	TR(3)
		[5 r1]
}

#M02_04={
	TR(4)
		[5 r1]
}

//Part3
#M03_16={
	TR(16)
		[1  TmpChangeR(150,0)r8TmpChangeR(140,0)TmpChangeR(135,!4.)]
		[3  TmpChangeR(170,0)r8TmpChangeR(140,0)TmpChangeR(135,!4.)]
		[1 [TmpChangeR(160,0)r8TmpChangeR(135,0)TmpChangeR(125,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(110,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(140,0)TmpChangeR(135,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(110,!4.)]]
		[2 [TmpChangeR(170,0)r8TmpChangeR(140,0)TmpChangeR(135,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(110,!4.)]]
		[1 [TmpChangeR(160,0)r8TmpChangeR(130,0)TmpChangeR(110,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(110,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(120,0)TmpChangeR(110,!4.)]]

		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(115,!4.)]]
		[1 [TmpChangeR(160,0)r8TmpChangeR(130,0)TmpChangeR(115,!4.)]]
		[1 [TmpChangeR(170,0)r8TmpChangeR(130,0)TmpChangeR(125,!4.)]]
}

#M03PEDAL={
	Sub {
		[2 #PEDALON r1 #PEDALOFF]
		[#PEDALON r2 #PEDALOFF]
		[1 #PEDALON r1 #PEDALOFF]
		[4 #PEDALON r1 #PEDALOFF]

		[2 [#PEDALON r2 #PEDALOFF]]
		[2 #PEDALON r1 #PEDALOFF]

		[3 [#PEDALON r2 #PEDALOFF]]
	}
}

#M03_01={
	TR(1)
		#R #M03PEDAL o6 #FF q90
		#SSF l2 RCD(df>d<) #SF l4...RCD(!df>d<)#F l32 RCD(c>c<)
		#SF l2 RCD(!<b->gb-) l4...RCD(!<b->gb-) #MS l32 RCD(<b->b-)
		#F l4... RCD(!<a>ea) #MS l32 RCD(<a>a) #SSF l4...RCD(!eg>e<)#MS l32 RCD(<g>g)
		#F l4... RCD(!<fa>f) #M l32 RCD(<a>a) #MS l2RCD(!<df>d)

		#FS l2 RCD(ce>c<) #F l4...RCD(cg>c<)#MS l32RCD(<b->b-)
		#F l4...RCD(!<a>fa)#M l32RCD(c>c<)#MS l2RCD(!<fa>f)
		#SSF l2 RCD(eg#>e<) #SF l4...RCD(eb>e<)#MS l32RCD(d>d<)
		#F l4...RCD(!c#a>c#<)#M l32RCD(e>e<) #F l4...RCD(!<a>c#a)l32RCD(<a>a)

		#FFS l2 RCD(!g>c#g<) #F l4...RCD(<a>a) #M l32RCD(<a>a)
		#FFS l2 RCD(!f#>cf#<) #F l4...RCD(<a>a) #M l32RCD(<a>a)
		#FFS l4...RCD(!fg#>f<) #M l32RCD(f>f<) #FF l4...RCD(!eg#>e<) #M l32RCD(d>d<)
		#FF  l4...RCD(!c#a>c#<) #M l32RCD(e>e<) #F l2 RCD(<a>c#a)

		#FFS l2 RCD(<g>c#g) #MS l4...RCD(<<a>a>) #M l32RCD(<<a>a>)
		#FF l2 RCD(<f#>cf#) #M l4...RCD(<<a>a>) #PS l32RCD(<<a>a>)
		#FFS l4...RCD(<fg#>f) #M l32RCD(<f>f) #FF l4...RCD(<eg#>e) #M l32RCD(<d>d)
}

#M03_02={
	TR(2)
		#R #M03PEDAL o4l16 #M q90
		[r8[RCD(eg#)RCD(fa):RCD(>c#e)RCD(df)]<]
		[r8[RCD(f#a)RCD(gb-):RCD(>d#f#)RCD(eg)]<]
		[r8[RCD(d#f#)RCD(eg):RCD(>cd#)RCD(c#e)]<]
		[r8[RCD(eg#)RCD(fa):RCD(>c#e)RCD(df)]<]

		[r8[RCD(f#b)RCD(g>c):RCD(<b>d#)RCD(ce)]<<]
		[r8[RCD(g#b)RCD(a>c):RCD(<b>e)RCD(cf)]<<]
		[r8[RCD(ga#)RCD(g#b):RCD(>d#g)RCD(eg#)]<]
		[r8[RCD(cd#)RCD(c#e):RCD(g#>c)RCD(<a>c#)]<]

		[r8[RCD(d#f#)RCD(eg):RCD(>cd#)RCD(c#e)]<]
		[r8[RCD(df)RCD(e-f#):RCD(b>d)RCD(ce-)]<]
		r8[RCD(c#e)RCD(df):RCD(ga#)RCD(g#b)>]  r8[RCD(<ga#)RCD(g#b)>:RCD(d#g)RCD(eg#)>]<<
		r8[RCD(cd#)RCD(c#e):RCD(g#>c)RCD(<a>c#)] r8RCD(<g#>c)RCD(<a>c#) RCD(cd#)RCD(c#e) RCD(d#g#)RCD(ea)<

		[r8[RCD(d#f#)RCD(eg):RCD(>cd#)RCD(c#e)]<]
		[r8[RCD(df)RCD(e-f#):RCD(b>d)RCD(ce-)]<]
		r8RCD(c#e)RCD(df)RCD(ga#)RCD(g#b)RCD(>c#e)RCD(df)< r8RCD(c#e)RCD(df)RCD(a>c#)RCD(<b->d)RCD(<g>d#)RCD(<g#>e)
}

#M03_03={
	TR(3)
		#R #M03PEDAL o6 #F q90
		o3 l2 [RCD(da>d<)]
		[RCD(dg>d<)]
		RCD(c#>c#<)RCD(<a>a)
		RCD(d>d<)RCD(df>d<)

		RCD(c>c<)RCD(e>e<)
		[RCD(f>f<)]
		RCD(e>e<)RCD(g#>g#<)
		[RCD(a>ea<)]

		RCD(b->eb-<)RCD(a>a<)
		RCD(b->e-b-<)RCD(a>a<)
		RCD(b>db<)RCD(eb>e<)
		[RCD(a>ea<)]<

		RCD(b->eb-<)RCD(a>a<)
		RCD(b->e-b-<)RCD(a>a<)
		RCD(b>db<)RCD(b->db-<)
}

#M03_04={
	TR(4)
		[15 r1]
}

//Part4
#M04_16={
	TR(16)
		TmpChangeR(135,0)TmpChangeR(145,!1)
		TmpChangeR(150,!1)
		TmpChangeR(120,!1)
}

#M04PEDAL={
	Sub {
		[2 l6 r [5 #PEDALON r #PEDALOFF]]
		[1 l12 [6 r #PEDALON r #PEDALOFF]]
	}
}

#M04_01={
	TR(1)
		#R #F o4 #M04PEDAL
		l12 RCD(a>c#a)r l6RMD(>c#egb-b)
		l12 RCD(ea>c#e)r l6RMD(c#egb-b)
		[3 l12 RCD(ea>c#e)r<b6]
}

#M04_02={
	TR(2)
		#R #PP o5 #M04PEDAL
		#P RMDCresc(1)Sub{r6 l18 RMD(eff# gg#a b-b>c c#de <b>fg#)}r1
		#P RMDCresc(1)Sub{r6 l18 RMD(eff# gg#a b-b>c c#de <b>fg#)}r1
		[3 r6 l18 #M RMDCresc(-1)RMD(<b>fg#)]
}

#M04_03={
	TR(3)
		#R #P o4 #M04PEDAL
		Sub{r6 l18 RMD(gg#a b-b>c c#dd# edc#)r6}r1
		Sub{r6 l18 RMD(gg#a b-b>c c#dd# edc#)r6}r1
		r1
}

#M04_04={
	TR(4)
		#R #F o3 #M04PEDAL
		l12 RCD(<a>ea)r l6RMD(b>c#eg)RCD(dg#b>f<)
		l12 RCD(<a>ea)r l6RMD(b>c#eg)RCD(dg#b>f<)
		l12 RCD(a>c#ea<)r < RCD(dfg#>d<)r RCD(<a>c#ea)r RCD(<dfg#>d)r RCD(<<a>c#ea>)r RCD(<dfg#>d)r
}

//Part5
#M05_16={
	TR(16)
		Sub{TmpChangeR(20,0)r9TmpChangeR(40,0)TmpChangeR(100,!2)TmpChangeR(50,!4..)}r1
		Sub{TmpChangeR(20,0)r9TmpChangeR(30,0)TmpChangeR(105,!2)TmpChangeR(50,!4..)}r1
		Sub{TmpChangeR(25,!9)TmpChangeR(40,0)TmpChangeR(105,!2)TmpChangeR(95,!4..)}r1
		Sub{TmpChangeR(66,0)TmpChangeR(55,!27^27^27^27)TmpChangeR(30,0)r27r27TmpChangeR(70,!4)}r1
		Sub{TmpChangeR(106,0)TmpChangeR(115,!1)}r1
		Sub{TmpChangeR(80,!2)TmpChangeR(140,0)TmpChangeR(55,!4)TmpChangeR(60,!8)}r1
}

#M05PART={
	Sub {
		#PEDALOFF q40 l6 #PEDALON ROCT(b-) #PEDALOFF l18ROCT(a) ROCT(g)ROCT(f)ROCT(e) ROCT(d)ROCT(c#)ROCT(e)ROCT(c)ROCT(e)<ROCT(b)>ROCT(e)<ROCT(b-)>ROCT(e)
		<ROCT(a)#PEDALOFF r>> #PEDALON l6ROCT(c#) #PEDALOFF l18<ROCT(b-)ROCT(a)ROCT(g)ROCT(f) ROCT(e)ROCT(g)ROCT(e-)ROCT(g)ROCT(d)ROCT(g)ROCT(c#)ROCT(g)<ROCT(b-)
		>ROCT(g)<ROCT(a)l6>>#PEDALOFF q100 #PEDALON ROCT(e)l18ROCT(d)ROCT(c#)<ROCT(b-)ROCT(a)>ROCT(g)ROCT(f)ROCT(e)ROCT(d)ROCT(c#)ROCT(b-)ROCT(a)ROCT(g)ROCT(f)
		#PEDALON Sub{l27ROCT(e)>ROCT(e)ROCT(d)ROCT(c#)<ROCT(b-)ROCT(a)>#PEDALOFF #PEDALON ROCT(b-)ROCT(a)ROCT(g)ROCT(f)ROCT(e)ROCT(d)ROCT(c#)ROCT(e)<ROCT(b-)>ROCT(c#)<ROCT(a)	ROCT(b-) ROCT(f)ROCT(g)ROCT(e)ROCT(g)ROCT(d)ROCT(e)ROCT(c#)ROCT(e)<ROCT(b-)}r1
		l18>ROCT(c#)<ROCT(a)ROCT(b-)ROCT(g)ROCT(b-)ROCT(f)ROCT(g)ROCT(e)ROCT(g)ROCT(d)ROCT(e)ROCT(c#)ROCT(e)<ROCT(b-)>ROCT(c#)<ROCT(a)ROCT(b-)ROCT(g#)
		ROCT(a)ROCT(g)ROCT(a) ROCT(f#)ROCT(a)ROCT(f) ROCT(a)ROCT(e)ROCT(a) l12 ROCT(e-)ROCT(a) ROCT(c)ROCT(a) #PEDALOFF #PEDALON #SSF ROCT(c#) #FS ROCT(a)r16#PEDALOFF
	}[6 r1]
	#PEDALOFF
}

#M05_01={
	TR(1)
		Sub{l18 RCD(ea>c#e)<<< r #M05PART}[6 r1]
}

#M05_02={
	TR(2)
		[6 r1]
}

#M05_03={
	TR(3)
		[6 r1]
}

#M05_04={
	TR(4)
		Sub{l18 <RCD(a>c#ea<) r #M05PART}[6 r1]
}

//Part6
#M06_16={
	TR(16)
		[2  TmpChangeR(155,0)r8TmpChangeR(168,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(175,0)r8TmpChangeR(168,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(165,0)r8TmpChangeR(133,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(175,0)r8TmpChangeR(168,0)TmpChangeR(150,!4.)]

		[2  TmpChangeR(170,0)r8TmpChangeR(153,0)TmpChangeR(120,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(153,0)TmpChangeR(135,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(163,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(162,0)TmpChangeR(140,!4.)]

		[2  TmpChangeR(170,0)r8TmpChangeR(164,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(163,0)TmpChangeR(140,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(160,0)TmpChangeR(150,!4.)]
		[2  TmpChangeR(170,0)r8TmpChangeR(160,0)TmpChangeR(110,!4.)]

		TmpChangeR(140,0)TmpChangeR(180,!2)TmpChangeR(155,!1^1^4)
		TmpChangeR(120,!0)r4TmpChangeR(155,!2)
		TmpChangeR(125,!2)

		TmpChangeR(110,0)r12r12TmpChangeR(200,!12^4.)TmpChangeR(130,!4.)
		TmpChangeR(120,0)r12r12TmpChangeR(205,!12^4.)TmpChangeR(130,!4.)
		TmpChangeR(120,0)r12r12TmpChangeR(210,!12^4.)TmpChangeR(120,!4.)
		[TmpChangeR(130,0)TmpChangeR(160,!4)TmpChangeR(145,!4)]

		TmpChangeR(110,0)r12r12TmpChangeR(205,!12^4.)TmpChangeR(130,!4.)
		TmpChangeR(120,0)r12r12TmpChangeR(205,!12^4.)TmpChangeR(130,!4.)
		TmpChangeR(120,0)r12r12TmpChangeR(200,!12^4.)TmpChangeR(120,!4.)
		[TmpChangeR(130,0)TmpChangeR(160,!4)TmpChangeR(137,!4)]
}

#M06PEDAL={
	Sub {
		#PEDALOFF [24 #PEDALON r2 #PEDALOFF]Sub{r-16 #PEDALOFF #PEDALON r16}
		#PEDALOFF [8 #PEDALON r2 #PEDALOFF]
		[
			[3 #PEDALON r2.r8.#PEDALON r16 #PEDALOFF]
			[#PEDALON r2 #PEDALOFF]
		]
		#PEDALOFF
	}
}

#M06_01={
	TR(1)
		#R #M06PEDAL o6 #FF q90
		#SSF l2 RCD(df>d<) #SF l4..RCD(!df>d<)#F l16 RCD(c>c<)
		#SF l2 RCD(!<b->gb-) l4..RCD(!<b->gb-) #MS l16 RCD(<b->b-)
		#F l4.. RCD(!<a>ea) #MS l16 RCD(<a>a) #SSF l4..RCD(!eg>e<)#MS l16 RCD(<g>g)
		#F l4.. RCD(!<fa>f) #M l16 RCD(<a>a) #MS l2RCD(!<df>d)

		#FS l2 RCD(ce>c<) #F l4..RCD(cg>c<)#MS l16RCD(<b->b-)
		#F l4..RCD(!<a->fa-)#M l16RCD(c>c<)#MS l2RCD(!<fa->f)
		#SSF l2 RCD(e-g>e-<) #SF l4..RCD(e-b->e-<)#MS l16RCD(d->d-<)
		#F l4..RCD(!ca->c<)#M l16RCD(e->e-<) #F l2RCD(!<a->ca-)

		#MS l2 RCD(f>d!f<) #M l4..RCD(f>d!f<) #P l16RCD(f>f<)
		#MS l2 RCD(a->c!a-<) #M l2RCD(e-a->!e-<)
		#PS l2 RCD(f>d!f<) #MS l4..RCD(f>d!f<) #M l16RCD(f>f<)
		#PS l2 RCD(a->c!a-<) l4..RCD(g#>g#<) #FFS l16RCD(g#>g#<)

		#SSF l2 ROCT(a)ROCT(f)
		ROCT(d)<ROCT(a)
		ROCT(b-)ROCT(g)
		ROCT(e)ROCT(a) Sub{r-12<l12 #SSF ROCT(a12)}

		>
		o5l2.ROCT(d)   r8.l16RCD(d)>
		l2.RCD(cf#>c<)<r8.l16RCD(d)
		l2.RCD(b>fb<)  r8.l16RCD(d)
		l4..ROCT(b-)l16ROCT(b-) l4..ROCT(a)l16ROCT(g)

		o5l2.RCD(df#>d<)   r8.l16RCD(d)>
		l2.RCD(cf#>c<)<r8.l16RCD(d)
		l2.RCD(b>fb<)  r8.l16RCD(d)
		l4..ROCT(b-)l16ROCT(b-) l4..ROCT(a)l16ROCT(g)
}

#M06_02={
	TR(2)
		#R #M06PEDAL o4l12 #M q90
		[rRCD(eg#)RCD(fa) RCD(>c#e)RCD(df)<r]
		[rRCD(f#a)RCD(gb-) RCD(>d#f#)RCD(eg)<r]
		[rRCD(d#f#)RCD(eg) RCD(>cd#)RCD(c#e)<r]
		[rRCD(eg#)RCD(fa) RCD(>c#e)RCD(df)<r]

		rRCD(d#f#)RCD(eg) RCD(b>d#)RCD(ce)r< rRCD(f#b)RCD(g>c<) RCD(>d#f#)RCD(eg)r<
		[rRCD(gb)RCD(a->c) RCD(eg)RCD(fa-)r<]		
		[rRCD(f#a)RCD(gb-) >RCD(df#)RCD(e-g)r<]
		[rRCD(b>d)RCD(ce-) RCD(gb)RCD(a->c<)r<]

		#PS
		[rRCD(>c#e)RCD(df) RCD(a#>c#<)RCD(b>d<)r<]
		[rRCD(b>d)RCD(ce-) RCD(gb)RCD(a->c<)r<]
		[rRCD(>c#e)RCD(df) RCD(a#>c#<)RCD(b>d<)r<]
		[rRCD(b>d)RCD(ce-) RCD(gb)RCD(a->c<)r< #F]>

		rRCD(eg#)RCD(fa)> RCD(c#e)RCD(df) r< rRCD(c#e)RCD(df) RCD(g#>c#<)RCD(a>d<) r <
		rRCD(g#>c#<)RCD(a>d<)> RCD(eg#)RCD(fa) r< rRCD(eg#)RCD(fa) >RCD(c#e)RCD(df) r <
		rRCD(f#a)RCD(gb-)> RCD(df#)RCD(e-g) r < rRCD(df#)RCD(e-g) RCD(a>d<)RCD(b->e-<) r <
		rRCD(a>c#<)RCD(b->d) RCD(f#a)RCD(gb-) r rRCD(d#f#)RCD(eg) >RCD(cd#)RCD(c#e) r

		#FS
		o4rr[4 RCD(eg#)RCD(fa)>]rr<<<<
		rr[4 RCD(g#b)RCD(a>c)]rr<<<<
		rr[4 RCD(ga#)RCD(g#b)>]rr<<<<
		[rRCD(d#f#)RCD(eg)>RCD(cd#)RCD(c#e)r<]

		o4rr[4 RCD(e#g#)RCD(f#a)>]rr<<<<
		rr[4 RCD(g#b)RCD(a>c)]rr<<<<
		rr[4 RCD(ga#)RCD(g#b)>]rr<<<<
		[rRCD(d#f#)RCD(eg)>RCD(cd#)RCD(c#e)r<]
}

#M06_03={
	TR(3)
		#R #M06PEDAL o6 #F q90
		o3 l2 RCD(da>d<)Sub{r-12RMD(d12^2)}RCD(a>d<)
		[Sub{r-12RMD(d12^2)}RCD(g>d<)]
		Sub{r-12RMD(c#12^2)}RCD(a>c#<)Sub{r-12RMD(<a12^2>)}RCD(c#a)
		Sub{r-12RMD(d12^2)}RCD(a>d<)Sub{r-12RMD(d12^2)}RCD(f>d<)

		Sub{r-12RMD(c12^2)}RCD(g>c<)Sub{r-12RMD(e12^2)}RCD(>ce<)
		[Sub{r-12RMD(f12^2)}RCD(>cf<)]
		Sub{r-12RMD(e-12^2)}RCD(b->e-<)Sub{r-12RMD(g12^2)}RCD(>e-g<)
		[Sub{r-12RMD(a-12^2)}RCD(>e-a-<)]

		#M
		[Sub{r-12RMD(a-12^2)}RCD(>da-<)]
		[Sub{r-12RMD(a-12^2)}RCD(>e-a-<)]
		[Sub{r-12RMD(a-12^2)}RCD(>da-<)]
		Sub{r-12RMD(a-12^2)}RCD(>e-a-<) #FF Sub{r-12RMD(g#12^2)}RCD(>g#<)Sub{#SSF r-16l16 ROCT(g#)}

		l2ROCT(a)Sub{r-12 RMD(f12^2)}RMD(>f2<)
		Sub{r-12 RMD(d12^2)}RMD(>d2<) < Sub{r-12 RMD(a12^2)}RMD(>a2<)
		Sub{r-12 RMD(b-12^2)}RMD(>b-2<) Sub{r-12 RMD(g12^2)}RMD(>g2<)
		#SSF Sub{r-12 RMD(e12^2)}RMD(>e2<) #FS Sub{r-12 RMD(a12^2)}RMD(>a2<)Sub{r-12 l12 ROCT(a12)}

		>
		l2.ROCT(d)r8.l16ROCT(d)
		l2.RCD(da>d<)r8.l16ROCT(d)
		l2.RCD(dg#>d<)r8.l16ROCT(d)<
		l4..ROCT(b-)l16ROCT(b-) l4..ROCT(a)l16ROCT(g)>

		l2.RCD(da>d<)r8.l16ROCT(d)
		l2.RCD(e-a>e-<)r8.l16ROCT(d)
		l2.RCD(e-g#>e-<)r8.l16ROCT(d)<
		l4..ROCT(b-)l16ROCT(b-) l4..ROCT(a)l16ROCT(g)>
}

#M06_04={
	TR(4)
		[24 r1]
}

//Part7
#M07_16={
	TR(16)
		Sub{
			TmpChangeR(135,0)
			TmpChangeR(140,!1)
			TmpChangeR(135,!1^1^2)TmpChangeR(115,!2)
			TmpChangeR(155,0)TmpChangeR(130,!1)
			TmpChangeR(140,0)TmpChangeR(170,!1)
			TmpChangeR(80,0)TmpChangeR(130,!2)TmpChangeR(70,!2)
			TmpChangeR(40,!12)TmpChangeR(80,!12^12^4)TmpChangeR(60,!4)TmpChangeR(30,0)TmpChangeR(5,!4)
		}[8 r1]
}

#M07PEDAL={
	Sub{
		[4
			[6 #PEDALON r6 Sub{r-20 #PEDALOFF}]
		]
		Sub{r-21 #FPEDALOFF #PEDALON} r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 r6r6r6r6r6 Sub{r-8 #PEDALOFF} #PEDALON r4 #PEDALOFF
	}
}

#M07PART1={
	l16 #SP
	Sub{r32 RMDCresc(4)RMD(e-fga b>c#e-f gab>c# e-fga32)}r1
	l25
	Sub{r48 RMD(b>c#c#<b)RMDCresc(-6)RMD(agfe- c#<bag fe-c#<b agfe-)}r1
	r4
}

#M07PART2={
	l16 #PPS
	Sub{RMDCresc(3)RMD(def#g# b->cde f#g#b->c def#g#)}r1
	l25
	Sub{RMD(b->cdc)RMDCresc(-5)RMD(<b-g#f#e dc<b-g# f#edc <b-g#f#e)}r2.
	l12
	Sub{#PEDALON #P RMDCresc(-2)RMD(d>d>d)}r4 #PEDALOFF
}

#M07_01={
	TR(1)
		#R o5 #MS l18 #M07PEDAL
		Sub{
			Sub{l12RCD(df#>d<)r>>#FF l6RMD(b-gec#12)r12RMD(<b-)}r1
			Sub{l12RCD(df#>d<)rl6RMD(b-gec#12)r12RMD(<b-)}r1

			#F l12RCD(df#>d<)r >[2 RMD(e6) RCD(<f#a>f#)r RMD(b-6) RCD(f#a>f#<)r:>]RMD(b-6) RCD(f#a>f#<)r RMD(b-6)

			o7l12
			#FS o7RCD(df#>d<)#F RCD(<b->b-) rr o6 #MS RCD(df#>d<)#M RCD(<b->b-) rr o5#PS RCD(df#>d<)#P RCD(<b->b-)rr
			#M[6 l6 o3RCD(b->b-<)#MS]
		}[6 r1]
		o4 Sub{#M07PART1}r1r1
}

#M07_02={
	TR(2)
		#R o7 #PS l18 #M07PEDAL
		Sub{
			Sub{l18rrr RMD(c#c<b b-ag# gf#f) l12RMD(e12)r12l18RMD(<b->c#e)}r1
			Sub{l18rrr RMD(c#c<b b-ag# gf#f) l12RMD(e12)r12l18RMD(<b->c#e)}r1

			Sub{l18rrr [2 RMD(eb->c#) rrr RMD(<b->c#e) rrr] [RMD(<b->c#e) rrr]}r1
		}[6 r1]

		o3 Sub{#M07PART1}r1r1
}

#M07_03={
	TR(3)
		#R o6 #PS l18 #M07PEDAL
		Sub{
			Sub{l18rrr RMD(ed#d c#c<b b-ag# g12)r12rrr}r1
			Sub{l18rrr RMD(ed#d c#c<b b-ag# g12)r12rrr}r1
		}[6 r1]

		o3 Sub{#M07PART2}r1r1
}

#M07_04={
	TR(4)
		#R o3 #MS l18 #M07PEDAL
		Sub{
			Sub{l12RCD(da>d<)r>>#FF l6RMD(gec#<b-#12r12)l18 RCD(<g>c#ea)rr}r1
			Sub{l12RCD(df#a>d<)r>#FF l6RMD(gec#<b-#12r12)l18 RCD(<g>c#ea)rr}r1

			l12
			o3RCD(df#a>d<)r RCD(gb->c#e<)r RCD(>df#a>d<<)r RCD(gb->c#e<)r [4 RCD(df#a>d<)r RCD(<gb->c#e)r]

			RCD(df#a>d<)r #MS o5RCD(a>a<)#M RCD(f#>f#<) rr #PS o4RCD(a>a<)#P RCD(f#>f#<) #PS o3RCD(a>a<) #M RCD(f#>f#<)
			Sub{r12l6o3#FF RCD(c>c<)<RCD(b>b<)#FFS RCD(b->b-<)RCD(g>g<)RCD(g#>g#<)l12RCD(a>a<)}r1
		}[6 r1]
		o2 Sub{#M07PART2}r1r1
}

//Part8
#M08_16={
	TR(16)
		Sub{
			TmpChangeR(92,0)TmpChangeR(108,!1)
			TmpChangeR(98,!1)
			TmpChangeR(95,!2)TmpChangeR(110,0)TmpChangeR(105,!2)
			TmpChangeR(110,0)TmpChangeR(105,!1)

			TmpChangeR(105,!4.)TmpChangeR(95,0)TmpChangeR(105,!8^2)
			TmpChangeR(100,!1)
			TmpChangeR(85,!2)TmpChangeR(95,!2)
			TmpChangeR(105,!2)TmpChangeR(110,0)TmpChangeR(105,!2)

			TmpChangeR(95,0)TmpChangeR(102,!1)
			TmpChangeR(95,!1)
			TmpChangeR(105,0)TmpChangeR(102,!1)
			TmpChangeR(90,!1)

			TmpChangeR(103,!2)TmpChangeR(110,0)TmpChangeR(105,!2)
			TmpChangeR(105,!2)TmpChangeR(110,0)TmpChangeR(105,!2)
			TmpChangeR(95,0)TmpChangeR(103,!4) TmpChangeR(93,0)TmpChangeR(100,!4) TmpChangeR(90,0)TmpChangeR(98,!4) TmpChangeR(85,0)TmpChangeR(95,!4)
			TmpChangeR(135,!1)
			TmpChangeR(95,!1)
			TmpChangeR(50,!2) TmpChangeR(5,0)TmpChangeR(90,!4)TmpChangeR(50,!4)
		}[18 r1]
}

#M08PEDAL={
	Sub{
		#PEDALON r2 r4.#PEDALOFF #PEDALON r8 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF

		#PEDALON r2 r4.#PEDALOFF #PEDALON r8 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF

		#PEDALON r1 #PEDALOFF
		[#PEDALON r2 #PEDALOFF]
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF

		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		[4 #PEDALON r4 #PEDALOFF]
		#PEDALON r1r1r1 #PEDALOFF
	}
}

#M08_01={
	TR(1)
		#R o5 #M08PEDAL #SP l12
		r[3 RCD(df)RCD(b->d)]<[3 RCD(df):RCD(<b->d)<]
		r[3 RCD(df)RCD(b->d)]<[3 RCD(df):RCD(<b->d)<]
		r[3 RCD(e-g-)RCD(>ce-)]<[3 RCD(e-g-):RCD(ce-)<]
		r[3 RCD(df)RCD(b->d)]<[3 RCD(df):RCD(<b->d)<]

		r[3 RCD(dg)RCD(b->d)]<[3 RCD(dg):RCD(<b->d)<]
		r[3 RCD(dg)RCD(b->d)]<[3 RCD(dg):RCD(<b->d)<]
		r[3 RCD(eg)RCD(g>c)]<[3 RCD(eg):RCD(<g>c)<]
		r[3 RCD(fa)RCD(>cf)]<[3 RCD(fa):RCD(cf)<]

		r[3 RCD(fa-)RCD(>d-f)]<[3 RCD(fa-):RCD(d-f)<]
		r[3 RCD(e-a-):RCD(>d-e-)][3 RCD(>ce-<)RCD(e-a-)<]
		r[3 RCD(e-g)RCD(>ce-)][3 RCD(e-g):RCD(ce-)<]
		r[3 RCD(dg):RCD(>cd)][3 RCD(b>d<)RCD(dg)<]

		o5r[3 RCD(df)RCD(b->d)]<[3 RCD(df):RCD(<b->d)<]
		r[3 RCD(dg)RCD(b->d)]<[3 RCD(dg):RCD(<b->d)<]
		rRCD(e-g)>RCD(d) rRCD(ce-)RCD(g>c)< rRCD(b->e-)RCD(gb-) rRCD(ce-)RCD(g>c)<<
		Sub{
			o5r[3 RCD(df#):RCD(a>d)]RCD(a>d<)RCD(df#)< RCD(a>d<)RCD(df#) RCD(a>d<)RCD(df#)< RCD(a>d<)RCD(df#) RCD(a>d<)RCD(df#)< RCD(a>d<)RCD(df#) RCD(a>d<)RCD(df#)
			ro2RMD(d>d>d >d>d>d>d)
			rrr
			#SP o6 #PEDALON [5 ROCT(d) RCDV(4)] #PEDALOFF
		}r1r1r1
}

#M08_02={
	TR(2)
		#R o3 #M08PEDAL RCDINIT(28,38) #PPA
		l2 RCD(b->fb->!d<<) l4^6RCD(<b->b->fb->!d)l12RCD(!c)<<
		l2 RCD(b->df!b-<) l4^6RCD(<b->b->df!b-)l12RCD(!b-)<
		l4^6 RCD(b->e-g-!a) l12 RCD(!a) l4^6RCD(g-a>!g-<)l12RCD(!a)<
		l2 RCD(b->f>!c)<#SP RCD(!b-)

		#PPA l2RCD(dgb->!d)<<<l4^6RCD(g>g>dgb->!d)l12RCD(!c)<<
		l2RCD(g>d!b-)<<l4^6RCD(g>g>dg!b-)#SP l12RCD(!b-)
		#PPA l4^6RCD(ceb->!d-)l12RCD(!c)<#PA l4^6RCD(g>c!b-)#PPA l12RCD(!e)<<
		l1RCD(f>ca>!f)<

		l2RCD(d-a->d-!f)<<l4^6RCD(d->d-a->d-!f)l12RCD(!f)<
		l2RCD(a->d-e-!a-)<<#SP l2RCD(a->e-a->c!e-)<
		#PPA l2RCD(cg>c!e-)<<l4^6RCD(c>cg>c!e-)l12RCD(e-)<
		#PPSA l2RCD(g>cd!g)<<#SP RCD(g>dgb>!d)<<

		#PPA l2 RCD(b->fb->!d<<) l4^6RCD(<b->b->fb->!d)l12RCD(!c)<<
		l2 RCD(g>d!b-<) l4^6RCD(<g>g>dg!b-)#SP l12RCD(!b-)
		#R #PPA l4 RCD(e-g>!d<)RCD(<e->>!c<)RCD(e-g!b-)RCD(<e->>!c)<<
		RCDINIT(28,38) #PPA l1 RCD(da>f#>!d)
		[2 r1]
}

#M08_03={
	TR(3)
		[18 r1]
}

#M08_04={
	TR(4)
		[18 r1]
}

//Part9
#M09_16={
	TR(16)
		Sub{
			TmpChangeR(70,0)TmpChangeR(120,!2)TmpChangeR(90,!2)
			TmpChangeR(90,0)TmpChangeR(120,!2)TmpChangeR(90,!2)
			TmpChangeR(75,0)TmpChangeR(115,!2)TmpChangeR(90,!2)
			TmpChangeR(90,0)TmpChangeR(120,!2)TmpChangeR(90,!2)

			TmpChangeR(90,0)TmpChangeR(120,!2)TmpChangeR(90,!2)
			TmpChangeR(90,0)TmpChangeR(120,!2)TmpChangeR(90,!2)
			TmpChangeR(93,0)TmpChangeR(110,!2)TmpChangeR(80,!2)
			TmpChangeR(80,0)TmpChangeR(110,!2)TmpChangeR(90,!2)

			TmpChangeR(100,0)TmpChangeR(130,!2)TmpChangeR(100,!2)
			TmpChangeR(105,0)TmpChangeR(120,!2)TmpChangeR(100,!2)
			TmpChangeR(105,0)TmpChangeR(130,!2)TmpChangeR(100,!2)
			TmpChangeR(105,0)TmpChangeR(120,!2)TmpChangeR(90,!2)
		}[12 r1]
}

#M09PEDAL={
	Sub{
		[12 #PEDALON r1 #PEDALOFF]
	}
}

#M09_01={
	TR(1)
		#R o6 #M09PEDAL #M
		Sub{
			l2ROCT(d)l4^6ROCT(d)l12ROCT(c)<
			l2ROCT(b-)l4^6ROCT(b-)l12ROCT(b-)
			l4^6ROCT(a)l12ROCT(a)>l4^6ROCT(g-)<l12ROCT(a)>
			l2ROCT(c)<#PS ROCT(b-)>

			#M l2ROCT(d)l4^6ROCT(d)l12ROCT(c)<
			l2^4^6ROCT(b-)l12ROCT(b-)>
			l4^6ROCT(d-)l12ROCT(c)l4^6ROCT(b-)l12ROCT(e)
			l1ROCT(f)

			#MS
			l2ROCT(f)l4^6ROCT(f)l12ROCT(f)
			l2ROCT(a-)#M ROCT(e-)
			#F l2ROCT(g#)l4^6ROCT(g#)l12ROCT(g#)
			l2ROCT(b)#MS ROCT(f#)
		}[12 r1]
}

#M09_02={
	TR(2)
		#R o6 #M09PEDAL #SP
		Sub{
			#SP l12r[5RCD(fb-) RCDV(2)] r[4RCD(fb-) RCDV(-2)]r
			#SP r[5RCD(df) RCDV(2)] r[4RCD(df) RCDV(-2)]r
			#SP r[4RCD(ce-)]r r[4RCD(a>c<) RCDV(-2)]r
			#SP r[5RCD(df) RCDV(2)] r[5RCD(df) RCDV(-2)]

			#SP r[5RCD(gb-) RCDV(2)] r[4RCD(gb-) RCDV(-2)]r
			#SP r[5RCD(dg) RCDV(2)][5RCD(dg) RCDV(-2)]r
			#SP r[5RCD(eb-) RCDV(2)] r[4RCD(>d-e<) RCDV(-2)]r
			#SP r[5RCD(a>c<) RCDV(2)][6RCD(a>c<) RCDV(-2)]

			#SP r[5RCD(a->d-<) RCDV(2)] r[4RCD(a->d-<) RCDV(-2)]r
			#SP r[5RCD(>d-e-<) RCDV(2)] r[5RCD(a->c<) RCDV(-2)]
			#SP r[5RCD(b>e<) RCDV(2)] r[4RCD(b>e<) RCDV(-2)]r
			#SP r[5RCD(>ef#<) RCDV(2)] r[5RCD(b>d#<) RCDV(-2)]
		}[12 r1]
}

#M09_03={
	TR(3)
		#R o5 #M09PEDAL
		Sub{
			rSub{#SP[9RCD(df)][1RCD(f)]}#SP RMDCresc(3)<RMD(ff# ga-a b-b>c c#d)r
			rSub{#SP[9RCD(df)][1RCD(f)]}#SP RMDCresc(3)<RMD(ff# ga-a b-b>c c#d)r
			rSub{#SP[9RCD(e-g-)][1RCD(g-)]}#SP RMDCresc(3)<RMD(g-g a-ab- b>cd- de-)r
			rSub{#SP[9RCD(df)][1RCD(f)]}#SP RMDCresc(3)<RMD(ff# ga-a b-b>c c#d)r

			rSub{#SP[9RCD(gb-)][1RCD(b-)]}#SP RMDCresc(4)<RMD(b-b >cc#d e-ef f#g)r
			rSub{#SP[6RCD(dg)][3RCD(g)]}#SP RMDCresc(4)<RMD(gg# ab-b >cc#d <b-)rr>
			rSub{#SP[9RCD(gb-)][1RCD(b-)]}#SP RMDCresc(4)<RMD(b-b >cc#d e-ef f#g)r
			rSub{#SP[8RCD(fa)][1RCD(a)]}#SP RMDCresc(4)<RMD(ab- b>cd- de-e f)rr

			rSub{#SP[8RCD(d-f)][1RCD(f)]}#SP RMDCresc(5)<RMD(fg- ga-a b-b>c d-)rr
			rSub{#SP[8RCD(e-a-)][2RCD(a-)]}#SP RMDCresc(6)<RMD(a-a b-b>c <b>cd- de-)r
			rSub{#SP[9RCD(eg#)][1RCD(g#)]}#SP RMDCresc(7)<RMD(g#a a#b>c c#dd# e)rr
			rSub{#SP[5RCD(f#b)]r[3RCD(f#b)][2RCD(b)]}#SP RMDCresc(8)<RMD(b>c c#dd# rdd# eff#)
		}[12 r1]
}

#M09_04={
	TR(4)
		#R o3 #M09PEDAL #P
		Sub{
			l1RMD(b-)
			RMD(b-)
			RMD(b-)
			RMD(b-)

			#PS
			RMD(g)
			RMD(g)
			RCD(c>c<)
			RMD(f)

			#M RCD(d->d-<)
			#MS RCD(<a->a-)
			#F RCD(e>e<)
			#MS RCD(<b>b)
		}[12 r1]
}

//Part10
#M10_16={
	TR(16)
		Sub{
			TmpChangeR(110,0)TmpChangeR(140,!1^1)
			TmpChangeR(155,!1^1)
			TmpChangeR(124,!1)
			TmpChangeR(70,0)TmpChangeR(140,!2)TmpChangeR(135,!2)TmpChangeR(120,0)TmpChangeR(120,!1)
			TmpChangeR(100,0)TmpChangeR(135,!2)TmpChangeR(125,!2)TmpChangeR(110,0)TmpChangeR(120,!1)
			TmpChangeR(220,!1^2^4)TmpChangeR(140,!4^1^1)
		}[13 r1]
}

#M10PEDAL={
	Sub{
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF

		#PEDALON r1 #PEDALOFF
		#PEDALON r1 #PEDALOFF
		[#PEDALON r2 #PEDALOFF]
		#PEDALON r1 #PEDALOFF
		#PEDALON r1 r1 r1 r1 r2. #PEDALOFF r4
	}
}

#M10_01={
	TR(1)
		#R o5 #M10PEDAL #PP l12
		Sub{
			rrSub{[10RMD(b)]}RMD(c#dd#e ff#gg#aa#)
			Sub{[12 #PP RMDCresc(1)RMD(b)]}>r #PP RMDCresc(1)RMD(cc#dd#e ff#gg#aa#)
			Sub{[12 #P RMDCresc(1)RMD(b)]}r #P RMDCresc(1)RMD(cc#dd#e ff#gg#aa#)
			Sub{[12 #MS RMDCresc(1)RMD(b)]}>r #MS RMDCresc(1)RMD(cc#dd#e ff#gg#aa#)
			Sub{[6 #F RMDCresc(1)RMD(b)]r[5RMD(b)]}Sub{r2r[5 #M RMDCresc(1)RMD(d)]}r #M RMDCresc(1)RMD(cc#dd#e)rRMD(eff#ga-)

			rSub{#SF RMDCresc(-1)RMD(>ed#dc#c<ba#ag#gf#)}Sub{#M RMD(>c<bb-aa-gf#fee-d)}RMD(gf#fee-dc#c<bb-a)
			Sub{RMD(>fed#dc#c)rRMD(<ba#aa-g)}Sub{RMD(>d-c<bb-aa-)rRMD(gf#fdd)}RMD(a-gf#fee-)rRMD(dc#c<bb-)
			>rSub{#FFS RMDCresc(-1)RMD(>ed#dc#c<ba#ag#gf#)}#M Sub{RMD(>c<bb-aa-gf#fee-d)}RMD(gf#fee-dc#c<bb-a)
			>Sub{RMD(fee-dd-c <bb-aa-gg-)}Sub{RMD(>d-c<bb-aa- gg-fee-d)}RMD(a-)rrrRMD(ee-dd-c<bb-a)
			>Sub{RMD(fee-dd-c <bb-aa-gg-)}Sub{RMD(>d-c<bb-aa- gg-fee-d)}RMD(a-gg-fee- dd-c<bb-a)
			>Sub{RMD(fee-dd-c <bb-aa-gg-)}Sub{RMD(>d-c<bb-aa- gg-fee-d)}RMD(a-gg-fee- dd-c<bb-a)

			[3 >Sub{#M RMD(fg-g)#SF RMD(a-)#M RMD(gg-)}Sub{RMD(d-de-ee-d)}RMD(<a-ab-bb-a)]
			>Sub{RMD(de-e)}Sub{RMD(<b-b>c)}RMD(<a-ab-)
				Sub{#MS RMD(a-6g12^16)}#M RMD(e12f6)
		}[13 r1]
}

#M10_02={
	TR(2)
		#R o4 #M10PEDAL l12
		Sub{
			RCDINIT(32,48) #MA l2 RCD(g#>df!b<) l4^6<RCD(g#>df!b<) RMD(>b12<)
			l2 RCD(g#>d#b<)<Sub{r-12 l12[#R #SP RCD(g#>d#<)]}r2>>

			RCDINIT(32,48) #FA l2 RCD(g#>df!b<) l4^6<RCD(g#>df!b<) RMD(>b12<)
			l2 RCD(g#>d#b<)<Sub{r-12 l12[#R #MS RCD(g#>d#<)]}r2>>

			RCDINIT(32,48) #FFSA l2 RCD(g#>df!b<) l4^6<RCD(g#>df!b<) RMD(>b12<)<
			#F o3l48RMD(g>ce) #R >l12^12^4RCD(ce)<<<l4ROCT(g)>>RCD(g>ce<)
			l2RCD(a->d-f<) RCDINIT(32,48)<l4^6RCD(g>dfb)l12#R RCD(dfb)
			#R l2RCD(g>ce)<<<l4ROCT(g)>>RCD(g>ce<)
			l2RCD(a->d-!f<)
			[3 r1]
			r2.o2RMD(b12e-6)
		}[13 r1]
}

#M10_03={
	TR(3)
		[13 r1]
}

#M10_04={
	TR(4)
		[13 r1]
}

//Part11
#M11_16={
	TR(16)
		Sub{
			TmpChangeR(50,0)r4TmpChangeR(80,0)TmpChangeR(210,!1.)TmpChangeR(100,!1.)
		}[3 r1]r2
}

#M11PEDAL={
	Sub{
		r4[12#PEDALON r4 #PEDALOFF]
	}
}

#M11_01={
	TR(1)
		#R o3 #M11PEDAL l4
		Sub{
			RMD(e16)r8.>>RMD(cd-d)
			RMD(e-eff#)
			RMD(gg#ab-)
			RMD(b>c)
		}[3 r1]r2
}

#M11_02={
	TR(2)
		#R o4 #M11PEDAL l12
		Sub{
			r4 RMD(c)RCD(eg)r RMD(d-)RCD(fa-)r RMD(d)RCD(fa)r
			RMD(e-)RCD(gb-)r RMD(e)RCD(g#b)r RMD(f)RCD(g#b)r RMD(f#)RCD(a#>c#<)r
			RMD(g)RCD(b>d<)r RMD(g#)RCD(b>d<)r RMD(a)RCD(>c#e<)r RMD(b-)RCD(>df<)r
			RMD(b)RCD(>d#f#<)r RMD(>c<)RCD(eg)r
		}[3 r1]r2
}

#M11_03={
	TR(3)
		#R o2 #M11PEDAL l12
		Sub{
			l16ROCT(c)r8.>l12 rrROCT(c) <rrROCT(b) rrROCT(b-)
			rrROCT(e)> rrROCT(d) rrROCT(c#)< rrROCT(f#)
			rrROCT(f) rrROCT(e) [4 rrROCT(a)]
		}[3 r1]r2
}

#M11_04={
	TR(4)
		[3 r1] r2
}

//Part12 (from Part5)
#M12_16={
	TR(16)
		r8
		Sub{TmpChangeR(50,0)r9TmpChangeR(37,0)TmpChangeR(110,!2)TmpChangeR(50,!4..)}r1
		Sub{TmpChangeR(20,0)r9TmpChangeR(35,0)TmpChangeR(103,!2)TmpChangeR(52,!4..)}r1
		Sub{TmpChangeR(25,!9)TmpChangeR(40,0)TmpChangeR(105,!2)TmpChangeR(95,!4..)}r1
		Sub{TmpChangeR(66,0)TmpChangeR(55,!27^27^27^27)TmpChangeR(25,0)r27r27TmpChangeR(70,!4)}r1
		Sub{TmpChangeR(106,0)TmpChangeR(115,!1)}r1
		Sub{TmpChangeR(88,!2)TmpChangeR(140,0)TmpChangeR(53,!4)TmpChangeR(60,!8)}r1
		TmpChangeR(999,0)r4.
}

#PART12={
	Sub {
		#PEDALOFF q40 l6 #PEDALON ROCT(b-) #PEDALOFF l18ROCT(a) ROCT(g)ROCT(f)ROCT(e) ROCT(d)ROCT(c#)ROCT(e)ROCT(c)ROCT(e)<ROCT(b)>ROCT(e)<ROCT(b-)>ROCT(e)
		<ROCT(a)#PEDALOFF r>> #PEDALON l6ROCT(c#) #PEDALOFF l18<ROCT(b-)ROCT(a)ROCT(g)ROCT(f) ROCT(e)ROCT(g)ROCT(e-)ROCT(g)ROCT(d)ROCT(g)ROCT(c#)ROCT(g)<ROCT(b-)
		>ROCT(g)<ROCT(a)l6>>#PEDALOFF q100 #PEDALON ROCT(e)l18ROCT(d)ROCT(c#)<ROCT(b-)ROCT(a)>ROCT(g)ROCT(f)ROCT(e)ROCT(d)ROCT(c#)ROCT(b-)ROCT(a)ROCT(g)ROCT(f)
		#PEDALON Sub{l27ROCT(e)>ROCT(e)ROCT(d)ROCT(c#)<ROCT(b-)ROCT(a)>#PEDALOFF #PEDALON ROCT(b-)ROCT(a)ROCT(g)ROCT(f)ROCT(e)ROCT(d)ROCT(c#)ROCT(e)<ROCT(b-)>ROCT(c#)<ROCT(a)	ROCT(b-) ROCT(f)ROCT(g)ROCT(e)ROCT(g)ROCT(d)ROCT(e)ROCT(c#)ROCT(e)<ROCT(b-)}r1
		l18>ROCT(c#)<ROCT(a)ROCT(b-)ROCT(g)ROCT(b-)ROCT(f)ROCT(g)ROCT(e)ROCT(g)ROCT(d)ROCT(e)ROCT(c#)ROCT(e)<ROCT(b-)>ROCT(c#)<ROCT(a)ROCT(b-)ROCT(g#)
		ROCT(a)ROCT(g)ROCT(a) ROCT(f#)ROCT(a)ROCT(f) ROCT(a)ROCT(e)ROCT(a) l12 ROCT(e-)ROCT(a) ROCT(c)ROCT(a) #PEDALOFF #PEDALON #SSF ROCT(c#) #FS ROCT(a)r16#PEDALOFF
		r4
	}[6 r1]r2
	#PEDALOFF
}

#M12_01={
	TR(1)
		o5Sub{l8 ROCT(c#) r #PART12}[6 r1]r2
}

#M12_02={
	TR(2)
		[6 r1]r2
}

#M12_03={
	TR(3)
		[6 r1]r2
}

#M12_04={
	TR(4)
		o3Sub{l8 RCD(a>eg<) r #PART12}[6 r1]r2
}

//Part13
//拍子 6,8
#M13_16={
	TR(16)
		Sub{
			TmpChangeR(110,0)TmpChangeR(135,!2.)
			TmpChangeR(130,!2.^2.^2)

			TmpChangeR(125,!2.^2.^2.^2)TmpChangeR(115,!4)

			TmpChangeR(135,!4)TmpChangeR(130,!2)
			TmpChangeR(135,!4)TmpChangeR(120,!2)
			TmpChangeR(135,!2.)TmpChangeR(130,!2.)

			TmpChangeR(130,!4)TmpChangeR(125,!2)
			TmpChangeR(130,!4)TmpChangeR(120,!2)
		}[15 r2.]
}

#M13PEDAL={
	Sub{
		[15 [#PEDALON r8. #PEDALOFF r8.]]
	}
}

#M13_01={
	TR(1)
		#R o6 #M13PEDAL l8 #MSA q10
		l4RCD(df>!d<)r8 l4RCD(df>!d<)l16rRCD(c>c<)<
		l4RCD(b->e!b-<)r8 l4RCD(b->e!b-<)l16rRCD(b->b-<)
		l4RCD(a>e!a<)l16rRCD(a>a<) >l4RCD(eg>!e<)<l16rRCD(g>g<)
		l4RCD(fa>!f<)l16rRCD(a>a<) l4RCD(df>!d<)r8

		>l4RCD(ce>!c<)r8 l4RCD(ce>!c<)< l16rRCD(b->b-<)
		l4RCD(a>g!a<)l16r>RCD(c>c<)< l4RCD(fa>!f<)r8
		>l4RCD(eg#>!e<)r8 l4RCD(eb>!e<) l16rRCD(d>d<)
		l4RCD(c#>!c#<)l16rRCD(e>e<)< l4RCD(a>c#!a<)l16rRCD(a>a<)

		>#FFS l4RCD(!g>!c#!g<)r8< #MSA l4RCD(!a>a<)l16rRCD(a>a<)
		>l4RCD(!f#>!c!f#<)r8< l4RCD(!a>a<)l16rRCD(a>a<)
		>#FF l4RCD(!fg#>f<)#MSA l16rRCD(f>f<) l4RCD(!eg#>e<)l16rRCD(d>d<)
		l4RCD(!c#a>c#<)l16rRCD(e>e<)< l4RCD(!a>c#a<)<l16rRCD(a>a<)

		>#FFS l4RCD(!g>!c#!g<)r8< #MSA l4RCD(!a>a<)l16rRCD(a>a<)
		>l4RCD(!f#>!c!f#<)r8< l4RCD(!a>a<)l16rRCD(a>a<)
		>l4RCD(!fg#>f<)l16rRCD(f>f<) l4RCD(!eg#>e<)l16rRCD(d>d<)
}

#M13_02={
	TR(2)
		#R o4 #M13PEDAL #PPA q20
		Sub{
			r8 Sub{l16r-16RCD(eg#)}l8RCD(!f!a)Sub{l16r-16RCD(>c#e)}l8RCD(!d!f)< r8 Sub{l16r-16RCD(g#>c#<)}l8RCD(!a!>d<)Sub{l16r-16RCD(>eg#)}l8RCD(!f!a)<
			[r8 Sub{l16r-16RCD(f#a)}l8RCD(!g!b-)Sub{l16r-16RCD(>d#f#)}l8RCD(!e!g)<]
			[r8 Sub{l16r-16RCD(d#f#)}l8RCD(!e!g)Sub{l16r-16RCD(>cd#)}l8RCD(!c#!e)<]
			[r8 Sub{l16r-16RCD(eg#)}l8RCD(!f!a)Sub{l16r-16RCD(>c#e)}l8RCD(!d!f)<]

			r8 Sub{l16r-16RCD(d#f#)}l8RCD(!e!g)Sub{l16r-16RCD(f#b)}l8RCD(!g!>c)< r8 Sub{l16r-16RCD(f#b)}l8RCD(!g!>c<)Sub{l16r-16RCD(>d#f#)}l8RCD(!e!g)<
			[r8 Sub{l16r-16RCD(g#b)}l8RCD(!a!>c<)Sub{l16r-16RCD(>eg#)}l8RCD(!f!a)<]
			r8 Sub{l16r-16RCD(ga#)}l8RCD(!g#!b)Sub{l16r-16RCD(>d#g)}l8RCD(!e!g#)< r8 Sub{l16r-16RCD(a#>d#<)}l8RCD(!b!>e<)Sub{l16r-16RCD(>ga#)}l8RCD(!g#!b)<
			[r8 Sub{l16r-16RCD(>cd#)}l8RCD(!c#!e)Sub{l16r-16RCD(g#>c<)}l8RCD(!a>!c#<)<]

			[r8 Sub{l16r-16RCD(>d#f#)}l8RCD(!e!g)Sub{l16r-16RCD(>cd#)}l8RCD(!c#!e)<<]
			[r8 Sub{l16r-16RCD(>df)}l8RCD(!e-!f#)Sub{l16r-16RCD(b>d)}l8RCD(!c!e-)<<]
			r8 Sub{l16r-16RCD(>c#e)}l8RCD(!d!f)Sub{l16r-16RCD(ga#)}l8RCD(!g#!b)< r8 Sub{l16r-16RCD(ga#)}l8RCD(!g#!b)Sub{l16r-16RCD(>d#g)}l8RCD(!e!g#)<
			[r8 Sub{l16r-16RCD(>cd#)}l8RCD(!c#!e)Sub{l16r-16RCD(g#>c<)}l8RCD(!a!>c#)<<]<

			[r8 Sub{l16r-16RCD(>d#f#)}l8RCD(!e!g)Sub{l16r-16RCD(>cd#)}l8RCD(!c#!e)<<]
			[r8 Sub{l16r-16RCD(>df)}l8RCD(!e-!f#)Sub{l16r-16RCD(b>d)}l8RCD(!c!e-)<<]
			r8 Sub{l16r-16RCD(>eg)}l8RCD(!f!g#)Sub{l16r-16RCD(>c#e)}l8RCD(!d!f)< r8 Sub{l16r-16RCD(d#)}l8RCD(!e)Sub{l16r-16RCD(g)}l8RCD(g#)<
		}[15 r2.]
}

#M13_03={
	TR(3)
		#R o3 #M13PEDAL l4. #PSA q10
		[RCD(da>d<)]
		[RCD(dg>d<)]
		RCD(c#>c#<)<RCD(a>a)
		RCD(d>d<)RCD(da>d<)

		RCD(c>c<)RCD(e>e<)
		RCD(f>cf<)RCD(f>f<)
		RCD(e>e<)RCD(g#>g#<)
		RCD(a>ea<)l4^16RCD(a>ea<)l16RCD(a>a<)

		l4.RCD(!b->!e!b-<)l4^16RCD(a>a<)l16RCD(a>a<)
		l4.RCD(b->e-b-<)l4^16RCD(a>a<)l16RCD(a>a<)
		l4.RCD(!b>!d!b<)RCD(eb>e<)
		RCD(a>ea<)l4^16RCD(a>ea<)<l16RCD(a>a<)

		l4.RCD(!b->!e!b-<)l4^16RCD(a>a<)l16RCD(a>a<)
		l4.RCD(b->e-b-<)l4^16RCD(a>a<)l16RCD(a>a<)
		l4.RCD(b>db<)RCD(b->db-<)
}

#M13_04={
	TR(4)
		[15 r2.]
}

//Part14
#M14_16={
	TR(16)
		TmpChangeR(115,0)TmpChangeR(130,!2.)
		TmpChangeR(137,!2.^2.^2.)
		TmpChangeR(140,!2.^2.)
		TmpChangeR(100,!2.)
}

#M14PEDAL={
	Sub{
		[#PEDALON r2r8#PEDALOFF #PEDALON r8#PEDALOFF]
		[#PEDALON r2.#PEDALOFF]
		#PEDALON r8 #PEDALOFF
		[8 #PEDALON r4 #PEDALOFF]
		#PEDALON r8 #PEDALOFF
	}
}

#M14_01={
	TR(1)
		#R o4 #M14PEDAL #M q60
		l8 RCD(a>c#a) l16 #M rRCD(e>c#<)r#MS RCD(g>e<)r#F RCD(b->g<)r#FS RCD(>c#b-<) l8 #FF RCD(b>fg#b<)
		#M l8 RCD(ea>c#a) l16 #MS rRCD(e>c#<)r#F RCD(g>e<)r#FS RCD(b->g<)r#FF RCD(>c#b-<) #SF l8 RCD(b>fg#b<)>
		[l8RCD(ea>c#e<)r16l16RCD(<b>fg#b)l8[RCD(ea>c#e<)RCD(<b>fg#b)]]

		l8 RCD(ea>c#e) o5 #MS l16ROCT(g#)ROCT(a)l8ROCT(b) #F l16ROCT(a)ROCT(b-)l8ROCT(b) #FS l16ROCT(b-)ROCT(b)>
		l8 ROCT(c)< #F l16ROCT(a)ROCT(b-)l8ROCT(b) #FS l16ROCT(b-)ROCT(b)l8>ROCT(c) <#FF l16ROCT(b)>ROCT(c)
		l8 ROCT(c#) <#FFS l16ROCT(b-)ROCT(b)l8>ROCT(c) <l16ROCT(b)>ROCT(c)l8ROCT(c#) l16ROCT(c)ROCT(c#)
}

#M14_02={
	TR(2)
		[7 r2.]
}

#M14_03={
	TR(3)
		#R o2 #M14PEDAL #M q80
		l8 RCD(a>ea) #PS l16 RCD(b->g)r #M RCD(c#b-)r #MS RCD(e>c#<)r #F RCD(g>e<)r l8 #FS RCD(d>d<)
		#M l8 <RCD(a>a) #M l16 RCD(b->g)r #MS RCD(c#b-)r #F RCD(e>c#<)r #FS RCD(g>e<)r l8 #FF RCD(d>d<)
		o4 l8RCD(a>a<)r16l16o4RCD(d>d<)<l8RCD(a>a<)RCD(d>d<)<#SF RCD(a>a<)>#FF RCD(d>d<)
		o2 l8RCD(a>a<)r16l16o4RCD(d>d<)<l8RCD(a>a<)RCD(d>d<)<#SF RCD(a>a<)>#FF RCD(d>d<)
		o2 l8RCD(a>a<) o3 #MS l16ROCT(g#)ROCT(a)l8ROCT(b) #F l16ROCT(a)ROCT(b-)l8ROCT(b) #FS l16ROCT(b-)ROCT(b)>
		l8 ROCT(c)< #F l16ROCT(a)ROCT(b-)l8ROCT(b) #FS l16ROCT(b-)ROCT(b)l8>ROCT(c) <#FF l16ROCT(b)>ROCT(c)
		l8 ROCT(c#) <#FFS l16ROCT(b-)ROCT(b)l8>ROCT(c) <l16ROCT(b)>ROCT(c)l8ROCT(c#) l16ROCT(c)ROCT(c#)
}

#M14_04={
	TR(4)
		[7 r2.]
}

//Part15
//拍子 2,4

#M15_16={
	TR(16)
		TmpChangeR(125,0)TmpChangeR(142,!2)
		r2
		r2
		TmpChangeR(130,!2)

		TmpChangeR(143,!2)
		r2
		r2
		TmpChangeR(133,!2)

		TmpChangeR(143)r2
		r2
		r2
		r2
		TmpChangeR(146,!1)
		r2
		r2

		r2
		r2
		TmpChangeR(153,!1)

		r2
		TmpChangeR(120,!1)
}

#M15PEDAL={
	Sub{
		r2
		r2
		r2
		r2

		r2
		r2
		r2
		r2

		r2
		r2
		r2
		r2
		r1
		r2	
		r2

		r2
		r2
		r1

		r2
		#PEDALON r2 #PEDALOFF
		#PEDALON r2 #PEDALOFF
	}
}

#M15_01={
	TR(1)
		#R o6 #M15PEDAL #FF q80
		l8RCD(d>!d<)rl8.#FS RCD(d>!d<)#FF l16RCD(c>c<)<
		l8RCD(b->!b-<)rl8.RCD(b->!b-<)#M l16RCD(b->b-<)
		l8.RCD(a>!a<)l16RCD(a>a<)>#FF l8.RCD(e>!e<)< #M l16RCD(g>g<)
		l8.RCD(f#>!f#<)l16RCD(a>a<)l8RCD(d>!d<)r

		>#FS l8RCD(c#>!c#<)rl8.RCD(c#>c#<)<#F l16RCD(b>b<)
		l8RCD(a>a<)rl8.RCD(f#>f#<)l16RCD(a>a<)>
		#FS l8RCD(e>e<)rl8.RCD(e>e<)#F l16RCD(d>d<)
		l8RCD(c#>c#<)rl8.<RCD(a>a<)#P l16RCD(a>a<)>

		#M l8RCD(f#>cf#<)rl8.RCD(f#>cf#<)l16RCD(f#>cf#<)
		l8RCD(a>c#a<)rRCD(ea>e<)r
		l8RCD(g->cg-<)rl8.RCD(g->cg-<)l16RCD(g->cg-<)
		l8RCD(b->db-<)rRCD(fb->f<)r
		l8RCD(g>c#g<)rl8.#MS RCD(g>c#g<)#M l16RCD(g>c#g<)
		#FS l8RCD(b>d#b<)rl8.RCD(b>b<)l16RCD(b>b<)
		l8RCD(>c>c<<)rl8.RCD(>c#>c#<<)l16RCD(>c#>c#<<)

		#FF l8RCD(>d>d<<)rRCD(a>a<)r
		RCD(f>f<)rRCD(d>d<)r
		RCD(b->b-<)rRCD(f>f<)r
		RCD(d>d<)rRCD(<b->b-)r
		RCD(e->e-<)rRCD(<b->b-)r
		#FFS RCD(e->e-<)rRCD(<b->b-)r
		RCD(<a>a)rRCD(<f>f)r
		RCD(<e>e)rRCD(<a>a)r
}

#M15_02={
	TR(2)
		#R o5 #M15PEDAL #FF
		[r8Sub{r-48l48 q80 #PS RCD(fg#)}q45 #MS l8RCD(f#a)]
		[r8Sub{r-48l48 q80 #PS RCD(d#f#)}q45 #MS l8RCD(eg)]
		[r8Sub{r-48l48 q80 #PS RCD(cd#)}q45 #MS l8RCD(c#e)]
		r8Sub{r-48l48 q80 #PS RCD(fg#)}q45 #MS l8RCD(f#a) r8Sub{r-48l48 q80 #PS RCD(c#f)}q45 #MS l8RCD(df#)

		[r8Sub{r-48l48 q80 #PS RCD(eg)}q45 #MS l8RCD(fg#)]
		[r8Sub{r-48l48 q80 #PS RCD(fg#)}q45 #MS l8RCD(f#a)]
		[r8Sub{r-48l48 q80 #PS RCD(ga#)}q45 #MS l8RCD(g#b)]
		[r8Sub{r-48l48 q80 #PS RCD(g#>c<)}q45 #MS l8RCD(a>c#<)]

		[r8Sub{r-48l48 q80 #PS RCD(b>d<)}q45 #MS l8RCD(>cd#<)]
		r8Sub{r-48l48 q80 #PS RCD(>cd#<)}q45 #MS l8RCD(>c#e<) r8Sub{r-48l48 q80 #PS RCD(g#>c<)}q45 #MS l8RCD(a>c#<)
		[r8Sub{r-48l48 q80 #PS RCD(b>d<)}q45 #MS l8RCD(>ce-<)]
		r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<) r8Sub{r-48l48 q80 #PS RCD(a>c#<)}q45 #MS l8RCD(b->d<)
		[r8Sub{r-48l48 q80 #PS RCD(>cd#<)}q45 #MS l8RCD(>c#e<)]
		r8Sub{r-48l48 q80 #PS RCD(a#>d<)}q45 #MS l8RCD(b>d#<) r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<)
		r8Sub{r-48l48 q80 #PS RCD(b>d#<)}q45 #MS l8RCD(>ce<) r8Sub{r-48l48 q80 #PS RCD(>d#f#<)}q45 #MS l8RCD(>eg<)

		r8Sub{r-48l48 q80 #PS RCD(>eg#<)}q45 #MS l8RCD(>fa<) r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<)
		r8Sub{r-48l48 q80 #PS RCD(g#>c#<)}q45 #MS l8RCD(a>d<) r8Sub{r-48l48 q80 #PS RCD(eg#)}q45 #MS l8RCD(fa)
		r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<) r8Sub{r-48l48 q80 #PS RCD(a>c#<)}q45 #MS l8RCD(b->d<)
		r8Sub{r-48l48 q80 #PS RCD(ea)}q45 #MS l8RCD(fb-) r8Sub{r-48l48 q80 #PS RCD(c#e)}q45 #MS l8RCD(df)
		[r8Sub{r-48l48 q80 #PS RCD(df#)}q45 #MS l8RCD(e-g)]
		[r8Sub{r-48l48 q80 #PS RCD(df#)}q45 #MS l8RCD(e-g)]
		r8Sub{r-48l48 q80 #PS RCD(c#e)}q45 #MS l8RCD(df) r8Sub{r-48l48 q80 #PS RCD(<g#>c#)}q45 #MS l8RCD(<a>d)
		r8l8RCD(<gb->d)r8RCD(<a>c#ea)
}

#M15_03={
	TR(3)
		#R o4 #M15PEDAL #FF
		[r8Sub{r-48l48 q80 #PS RCD(fg#>d<)}q45 #MS l8RCD(f#a)]
		[r8Sub{r-48l48 q80 #PS RCD(f#a)}q45 #MS l8RCD(gb-)]
		[r8Sub{r-48l48 q80 #PS RCD(d#f#)}q45 #MS l8RCD(eg)]
		r8Sub{r-48l48 q80 #PS RCD(fg#>d<)}q45 #MS l8RCD(f#a) r8Sub{r-48l48 q80 #PS RCD(fg#)}q45 #MS l8RCD(f#a)

		r8Sub{r-48l48 q80 #PS RCD(eg>c#<)}q45 #MS l8RCD(fg#) r8Sub{r-48l48 q80 #PS RCD(g>c#<)}q45 #MS l8RCD(g#)
		[r8Sub{r-48l48 q80 #PS RCD(g#>c#<)}q45 #MS l8RCD(a)]
		r8Sub{r-48l48 q80 #PS RCD(ga#>e<)}q45 #MS l8RCD(g#b) r8Sub{r-48l48 q80 #PS RCD(a#>e<)}q45 #MS l8RCD(b)
		[r8Sub{r-48l48 q80 #PS RCD(>ce<)}q45 #MS l8RCD(>c#<)]

		[r8Sub{r-48l48 q80 #PS RCD(>df<)}q45 #MS l8RCD(>d#f#<)]
		[r8Sub{r-48l48 q80 #PS RCD(>cd#<)}q45 #MS l8RCD(>c#e<)]
		[r8Sub{r-48l48 q80 #PS RCD(>df<)}q45 #MS l8RCD(>e-g-<)]
		[r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<)]
		[r8Sub{r-48l48 q80 #PS RCD(>d#f#<)}q45 #MS l8RCD(>#eg<)]
		r8Sub{r-48l48 q80 #PS RCD(>df<)}q45 #MS l8RCD(>d#f#<) r8Sub{r-48l48 q80 #PS RCD(>eg<)}q45 #MS l8RCD(>fa-<)
		r8Sub{r-48l48 q80 #PS RCD(>d#f#<)}q45 #MS l8RCD(>eg<) r8Sub{r-48l48 q80 #PS RCD(>f#a<)}q45 #MS l8RCD(>gb-<)

		r8Sub{r-48l48 q80 #PS RCD(>eg#<)}q45 #MS l8RCD(>fa<) r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<)
		r8Sub{r-48l48 q80 #PS RCD(g#>c#<)}q45 #MS l8RCD(a>d<) r8Sub{r-48l48 q80 #PS RCD(eg#)}q45 #MS l8RCD(fa)
		r8Sub{r-48l48 q80 #PS RCD(>c#e<)}q45 #MS l8RCD(>df<) r8Sub{r-48l48 q80 #PS RCD(a>c#<)}q45 #MS l8RCD(b->d<)
		r8Sub{r-48l48 q80 #PS RCD(ea)}q45 #MS l8RCD(fb-) r8Sub{r-48l48 q80 #PS RCD(c#e)}q45 #MS l8RCD(df)
		[r8Sub{r-48l48 q80 #PS RCD(f#a)}q45 #MS l8RCD(gb-)]
		[r8Sub{r-48l48 q80 #PS RCD(f#a)}q45 #MS l8RCD(gb-)]
		r8Sub{r-48l48 q80 #PS RCD(eg#)}q45 #MS l8RCD(fa) r8Sub{r-48l48 q80 #PS RCD(e)}q45 #MS l8RCD(f)
		r8l8RCD(<b->de)r8RCD(<a>c#eg)
}

#M15_04={
	TR(4)
		#R o3 #M15PEDAL #FF q80
		l8RCD(d>!d<)rRCD(d>!d<)r
		#FS RCD(d>!d<)r #F RCD(d>!d<)r
		#MS RCD(c#>!c#<)r<#M RCD(a>!a<)r>
		RCD(d>!d<)rRCD(d>!d<)r
		RCD(c#>!c#<)rRCD(f>!f<)r
		RCD(f#>!f#<)rRCD(a>!a<)r
		RCD(e>!e<)rRCD(g#>!g#<)r
		RCD(a>!a<)rl8.RCD(>c#>!c#<<)l16RCD(a>a<)
		l8RCD(a>d#a<)rl8.RCD(a>d#a<)l16RCD(a>d#a<)
		l8RCD(a>ea<)rRCD(a>c#a<)r
		#M RCD(a>e-a<)rl8.RCD(a>e-a<)l16RCD(a>e-a<)
		l8RCD(b->fb-<)rRCD(b->db-<)r
		RCD(a#>ea#<)rl8.RCD(a#>ea#<)l16RCD(a#>ea#<)
		l8RCD(b>f#b<)rl8.RCD(b>b<)l16RCD(b>b<)
		#MS l8RCD(>c>c<<)rl8.RCD(>c#>c#<<)l16RCD(>c#>c#<<)
		l8RCD(>d>d<<)rRCD(a>a<)r
		RCD(f>f<)rRCD(d>d<)r
		#M RCD(b->b-<)rRCD(f>f<)r
		RCD(d>d<)rRCD(<b->b-)r
		RCD(e->e-<)rRCD(<b->b-)r
		#FFS RCD(e->e-<)rRCD(<b->b-)r
		RCD(<a>a)rRCD(<f>f)r
		RCD(<e>e)rRCD(<a>a)r
}

//Part16
#M16_16={
	TR(16)
		TmpChangeR(62,0)TmpChangeR(76,!2)
		TmpChangeR(72,!1)
		[TmpChangeR(68,0)TmpChangeR(65,!4)]

		TmpChangeR(70,0)TmpChangeR(75,!2)
		TmpChangeR(73,!1)
		[TmpChangeR(71,0)TmpChangeR(68,!4)]
}

#M16PEDAL={
	Sub{
		[
			[3
				#PEDALON [11 r12] #PEDALOFF #PEDALON r12 #PEDALOFF
			]
			#PEDALON r2 #PEDALOFF #PEDALON r2 #PEDALOFF
		]
	}
}

#M16_01={
	TR(1)
		#R o4 #M16PEDAL #P q80 l24
		RCD(f#a>d)RCD(d)>[RCD(d)]>[RCD(d)]> RCD(d)<[RCD(d)]<[RCD(d)]<RCD(d)
		rRCD(df#)>RCD(cd)RCD(df#)>RCD(cd)RCD(df#)> RCD(cd)<RCD(df#)RCD(cd)<RCD(df#)RCD(cd)<RCD(df#)
		rRCD(df)>RCD(<b>d)RCD(df)>RCD(<b>d)RCD(df)> RCD(<b>d)<RCD(df)RCD(<b>d)<RCD(df)RCD(<b>d)<RCD(df)
		rRCD(de)>RCD(<b->d)RCD(de)>RCD(<b->d)RCD(de)> RCD(<b->d)<RCD(de)RCD(<b->d)<RCD(de)RCD(<b->d)<RCD(de)

		rRCD(df#)>RCD(<a>d)RCD(df#)>RCD(<a>d)RCD(df#)> RCD(<a>d)<RCD(df#)RCD(<a>d)<RCD(df#)RCD(<a>d)<RCD(df#)
		rRCD(ce-)>RCD(<f#>c)RCD(ce-)>RCD(<f#>c)RCD(ce-)> RCD(<f#>c)<RCD(ce-)RCD(<f#>c)<RCD(ce-)RCD(<f#>c)<RCD(ce-)
		rRCD(<b>d)>RCD(<fb>)RCD(<b>d)>RCD(<fb>)RCD(<b>d)> RCD(<fb>)<RCD(<b>d)RCD(<fb>)<RCD(<b>d)RCD(<fb>)<RCD(<b>d)
		RCD(<b->c#)>RCD(<eb->)RCD(<b->c#)>RCD(<eb->)RCD(<b->c#)> RCD(<eb->)o4RCD(gb-)RCD(>c#g)RCD(gb-)RCD(>c#g)RCD(gb-)RCD(>c#g)
}

#M16_02={
	TR(2)
		#R o3 #M16PEDAL #F q80 l24
		RCDINIT(48,56)l4RCD(da>d<)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l4RCD(e-f#a>e-<)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l4RCD(fg#b>f<)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l24^24^24^24^24RCD(b->dgb-<)l24 #R #M RCD(b->b-<) l24^24^24^24^24 #F RCD(a>a<)l24 #M RCD(g>g<)

		RCDINIT(48,56)l4RCD(df#a>d<)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l4RCD(e-f#a>e-<)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l4RCD(<b>fg#b)l24rrrrr #R #F RCD(d>d<)
		RCDINIT(48,56)l24^24^24^24^24RCD(<b->c#eb-)l24 #R #M RCD(<b->b-) l24^24^24^24^24 #F RCD(<g>c#eg)l24 #M RCD(<g>g)
}

#M16_03={
	TR(3)
		[8 r2]
}

#M16_04={
	TR(4)
		[8 r2]
}

//Part17
#M17_16={
	TR(16)
		TmpChangeR(100,0)r8TmpChangeR(125,!4.)
		TmpChangeR(150,0)TmpChangeR(90,!2)
		TmpChangeR(110,0)r8TmpChangeR(127,!4.)
		TmpChangeR(147,0)TmpChangeR(100,!2)
}

#M17PEDAL={
	Sub{
		#PEDALOFF
		[4
			r8
			[3 #PEDALON r8 #PEDALOFF]
		]
	}
}

#M17_01={
	TR(1)
		#M17PEDAL
		o4l8q50
		RCD(df#a>d<)
		#R o7 #F q80 l8
		[
			RMD(b-ge)
			RMD(c#)<l16RMD(b-eaegc#)
			:
			l8RCD(df#>d<) #MS
		]
}

#M17_02={
	TR(2)
		#M17PEDAL
		o3l8q50 RCD(da>d<)
		#R o7 #M q80 l24
		[
			RMDCresc(-2)l24RMD(c#c<b b-ag# gf#f)
			l8RMD(e)#F RMDCresc(-2)l16RMD(<b->c#<a>c#<gb-)>
			:
			r8
		]
}

#M17_03={
	TR(3)
		r8r8//ずれてる
		#M17PEDAL
		r8
		#R o6 #M q80 l24
		[
			RMDCresc(-2)l24RMD(ed#d c#c<b b-ag#)
			l8RMD(g)<#F RMDCresc(-2)l16RMD(geaeb-g)>
			:
			r8
		]
}

#M17_04={
	TR(4)
		#M17PEDAL
		r8
		#R o5 #F q80 l8
		[
			l8RMD(gec#)
			RMD(<b-)l16RMD(<g>c#<a>c#<b-e)>
			:
			r8
		]
}

//Part18
#M18_16={
	TR(16)
		Sub {
			TmpChangeR(100,0)TmpChangeR(120,!2)
			TmpChangeR(115,!2)
			TmpChangeR(100,!2)

			TmpChangeR(80,!2)
			TmpChangeR(110,!4)TmpChangeR(80,!2)
			TmpChangeR(70,!2)

			TmpChangeR(20,0)TmpChangeR(40,!2)
			TmpChangeR(50,!2)
			TmpChangeR(60,!2)
			TmpChangeR(70,!2)
			TmpChangeR(60,!4)TmpChangeR(40,!4)
		}[11 r2]
}

#M18PEDAL={
}

#M18_01={
	TR(1)
		#R o5 #M18PEDAL #FS q80
		Sub{
			l8RCD(!df#>d<)l16[RCD(eb->c#e<)] l8RCD(f#a>d!f#<)l16[RCD(b->c#eb-<)]>
			l8RCD(!df#a>d<)l16[RCD(eb->c#e<)] l8RCD(f#a>d!f#<)l16[RCD(b->c#eb-<)]>
			[l8RCD(df#>!d<)l16[RCD(<b->c#eb-)]]

				l8RCD(df#>d<)#SF RCD(<b->c#eb-) r RCD(<b->c#eb-)
			rRCD(<b->c#eb-) RCD(<fg#b>f)RCD(<ce-f#>c)<<
			RCD(gb->c#g<)RCD(dfg#>d<)RCD(<a>ce-a)RCD(<b->c#eb-)

			// 拍子 2,4 1小節を5小節に展開
			q100 #F r4 l4Sub{o4RMD(f)}Sub{RMD(b)}
			>#FF RMD(f4.)#P RMD(c#8d8.e16)
			#SP RMD(e32) #P l16.^4RMDCresc(-3)RMD(g)l8RMD(f)
			l6RMD(edc#)
			l6RMD(c<b)#PPS o3RCD(db->fa-b-)
		}[11 r2]
}

#M18_02={
	TR(2)
		#R o3 #M18PEDAL #FS q80
		Sub{
			o3l8RCD(!df#a>d<)l16[RCD(gb->c#g<)] o4l8RCD(df#a>d!<)<o3l16[RCD(gb->c#g<)]>
			o3l8RCD(!df#a>d<)l16[RCD(gb->c#g<)] o4l8RCD(df#a>d!<)<o3l16[RCD(gb->c#g<)]>
			<[l8RCD(df#>!d<)l16[RCD(<g>c#eg)]]

			l8RCD(df#a>d<)#SF RCD(<g>c#eg) r RCD(<g>c#eg)
			rRCD(<g>c#eg) RCD(dfg#>d<)RCD(df#a>e-<)
			RCD(dgb->e<)RCD(dg#b>f<)RCD(da>cf#<)RCD(db->c#g<)

			q100#F l4ro3RCD(db>g#)
		}[11 r2]
}

#M18_03={
	TR(3)
		[11 r2]
}

#M18_04={
	TR(4)
		[11 r2]
}

//Part19
#M19_16={
	TR(16)
		TmpChangeR(60,0)TmpChangeR(70,!1)
		TmpChangeR(40,!1)
}

#M19PEDAL={
	Sub{
		[4
			#PEDALON r2 #PEDALOFF
		]
	}
}

#M19_01={
	TR(1)
		#R o4 #M19PEDAL #PA q80 l2
		RCD(g-b-)
		RCD(fb-)
		RCD(e-b->e-<)
		l4..RCD(e-a->e-<)l16RCD(fa->df<)
}

#M19_02={
	TR(2)
		#R o3 #M19PEDAL #SP q80 l2
		RMD(b-)
		l4..RMD(b-)l16RMD(b-)
		l2RMD(b-)
		l4..RMD(a-)l16RMD(a-)
}

#M19_03={
	TR(3)
		#R o3 #M19PEDAL #P q80 l2
		RMD(e-)
		RMD(d-)<
		RMD(b)
		l4..RMD(b)l16RMD(b)
}

#M19_04={
	TR(4)
		[4 r2]
}

//Part20
//拍子 4,4
#M20_16={
	TR(16)
		TmpChangeR(60,0)TmpChangeR(40,!1)
		TmpChangeR(50,0)TmpChangeR(45,!1)
		TmpChangeR(50,0)TmpChangeR(40,!1)
		TmpChangeR(45,0)TmpChangeR(40,!1)
		TmpChangeR(65,0)TmpChangeR(45,!1)
		TmpChangeR(55,0)TmpChangeR(45,!1)
		TmpChangeR(50,0)TmpChangeR(35,!1)
		TmpChangeR(60,0)r1
}

#M20PEDAL={
}

#M20_01={
	TR(1)
		#R o4 #M20PEDAL #PP q80 l2
		l8RCD(fa->df)r r2.
		r2o4l8RCD(fa->d-f<)rr.#SP l16RCD(fa->df<)
		l8RCD(fa->df<)r4.r2
		#SP r2o4l8RCD(fa->d-f<)rr.l16RCD(fa->df<)
		l8RCD(fa->df<)r4.r2
		[3 r1]
}

#M20_02={
	TR(2)
		#R o3 #M20PEDAL #SP q80 l2
		l8RMD(a-)r r2.
		r2l8RMD(a-)rr.#SP l16RMD(a-)
		l8RMD(a-)r4.r2
		#SP r2l8RMD(a-)rr.l16RMD(a-)
		l8RMD(a-)r4.r2
		[3 r1]
}

#M20_03={
	TR(3)
		#R o2 #M20PEDAL #PP q80 l2
		l8RMD(a-)r r2.	
		r2l8RMD(b-)rr.#SP l16RMD(b)
		l8RMD(b)r4.r2
		#SP r2l8RMD(b-)rr.l16RMD(b)
		l8RMD(b)r4.r2
		[3 r1]
}

#M20_04={
	TR(4)
		#R o4 #M20PEDAL #PP q100 l2
		#SP r4.RMDCresc(-3)RMD(f8>d4.<f8)
		r1
		#SP r4.RMDCresc(-3)RMD(f8>d4.<f8)
		r1
		#PP r4.RMDCresc(2)RMD(>d8b4.d8<)
		#PP r4.RMDCresc(3)RMD(g#8>f4.<g#8)
		#PP r4.RMDCresc(-4)RMD(d8b4.<g#8)
		RMD(>f1)
}

//Part21
#M21_16={
	TR(16)
		TmpChangeR(120,0)r2TmpChangeR(65,0)TmpChangeR(120,!4.)TmpChangeR(80,!8)
		TmpChangeR(130,0)TmpChangeR(80,!2)TmpChangeR(110,0)TmpChangeR(90,!2)
		TmpChangeR(160,0)TmpChangeR(80,!2)TmpChangeR(110,0)TmpChangeR(90,!2)
		TmpChangeR(120,0)TmpChangeR(70,!2)TmpChangeR(110,0)TmpChangeR(70,!2)
		TmpChangeR(150,0)r4.TmpChangeR(80,0)TmpChangeR(170,!16^2)
		TmpChangeR(195,!1)
		TmpChangeR(200,!1)
		TmpChangeR(185,!1^1^1)
		TmpChangeR(85,!1)
}

#M21PEDAL={
	Sub{
		r1
		[2 #PEDALON r1 #PEDALOFF]
		#PEDALON r2 #PEDALOFF #PEDALON r4.. #PEDALOFF r32
		#PEDALON r1r1r1r1r2
	}
}

#TENUKI={
	r2 #PP l16r RMDCresc(10) #PEDALON RMD(fedc#c<bb-) #PEDALOFF
}
#TENUKI2={
	q50
	r4r8.l16#P RCD(>a>df#a<<)l8#FS RCD(>a>df#a<<)r16 l16#P RCD(>>df#a>d<<<) l8#FS RCD(>>df#a>d<<<)r16 l16#P RCD(>f#>df#<<)
	l8#FS RCD(>f#>df#<<)r16 l16#P RCD(>a>df#a<<)l8#FS RCD(>a>df#a<<)r16 l16#P RCD(>df#a>d<<)l8#FS RCD(>df#a>d<<)r16 l16#P RCD(>f#>df#<<)l8#FS RCD(>f#>df#<<)r16 l16#P RCD(a>df#a<)
	l8#FS RCD(a>df#a<)r16 l16#P RCD(>df#a>d<<)l8#FS RCD(>df#a>d<<)r16 l16#P RCD(f#>df#<)l8#FS RCD(f#>df#<)r16 l16#P RCD(a>df#a<)l8#FS RCD(a>df#a<)r16 l16#P RCD(df#a>d<)
	l8#FS RCD(df#a>d<)r16 l16#P RCD(f#>df#<)l8#FS RCD(f#>df#<)r16 l16#P RCD(<a>df#a)l8#FS RCD(<a>df#a)r16 l16#P RCD(df#a>d<)l8#FS RCD(df#a>d<)r16 l16#P RCD(<f#>df#)
	l8#FS RCD(<f#>df#)r16 l16#P RCD(<a>df#a)l8#FS RCD(<a>df#a)r16
}

#M21_01={
	TR(1)
		#R o5 #M21PEDAL q90
		#TENUKI

		#R o5
		r4r8.#PP[l32RCD(a>df#a<) #M]#FF l2RCD(a>df#a<)
		r4r8.#PP[l32RCD(>df#b>d<<) #M]#FF l2RCD(>df#b>d<<)
		r8.#PP[l32RCD(>f#a#>c#f#<<) #M]#FF l8RCD(>f#a#>c#f#<<)r8 r8.#PP[l32RCD(>a>c#ea<<) #M]#FF l8RCD(>a>c#ea<<)r8

		#PEDALON
		#TENUKI2

		o4q70
		l16RCD(df#a>d<) #PEDALOFF [6 #PEDALON l8 RCD(df#a>d<)RCD(dgb->d<) #PEDALOFF]
		#PEDALON
		o4[4 l4RCD(df#a>d<)>]
		o5RMD(d1)
		r1
		#PEDALOFF
}

#M21_02={
	TR(2)
		#R o4 #M21PEDAL q90
		#TENUKI
		
		#R o4
		#SF l2.^8.RMD(a)l16 #F RMD(a)
		#SF l2.^8.RMD(b)l16 #F RMD(b)
		#SF l2 ROCT(f#) l4..ROCT(a) #M l16RCD(a>df#a<)

		#SF l1 RCD(a>df#a<)
		[7 r1]
}

#M21_03={
	TR(3)
		#R o3 #M21PEDAL q90
		#TENUKI

		#R o4
		r4r8.#PP[l32RCD(a>df#<) #M]#FF l2RCD(a>df#<)
		r4r8.#PP[l32RCD(f#b>df#<) #M]#FF l2RCD(f#b>df#<)
		r8.#PP[l32RCD(f#a#>c#f#<) #M]#FF l8RCD(f#a#>c#f#<)r8 r8.#PP[l32RCD(a>c#ea<) #M]#FF l8RCD(a>c#ea<)r8

		#PEDALON
		o3#TENUKI2

		o2q70
		l16RCD(da) #PEDALOFF[6 #PEDALON l8 RCD(da)RCD(db-) #PEDALOFF]
		#PEDALON
		o2l4RCD(da>d<)>[3 l4RCD(df#a>d<)>]
		o2l1RCD(d>d>d)
		r1
		#PEDALOFF
}

#M21_04={
	TR(4)
		#R o3 #M21PEDAL q90
		r1
		#R o2
		#SF l2.^8.ROCT(a)l16 #F ROCT(a)
		#SF l2.^8.ROCT(b)l16 #F ROCT(b)
		#SF l2 ROCT(f#) l4..ROCT(a) #M l16RCD(da>d<)

		#SF l1 RCD(da>d<)
		[7 r1]
}
///////////////////////////////////////////
Int C=0

TR(16)
	拍子 4,4
	C=0
	#M01_16
	#M02_16

	#tr16={
		Time(11+109*C:1:1)
		C=C+1
		#M03_16
		#M04_16
		#M05_16
		#M06_16
		#M07_16
		#M08_16
		#M09_16
		#M10_16
		#M11_16
		#M12_16
	}
	LoopPlay(#tr16,,0)

	拍子 6,8
	#M13_16
	#M14_16
	拍子 2,4
	#M15_16
	#M16_16
	#M17_16
	#M18_16
	#M19_16
	拍子 4,4
	#M20_16
	#M21_16

TR(1)
	C=0
	拍子 4,4
	#M01_01
	#M02_01

	#tr01={
		Time(11+109*C:1:1)
		C=C+1
		#M03_01
		#M04_01
		#M05_01
		#M06_01
		#M07_01
		#M08_01
		#M09_01
		#M10_01
		#M11_01
		#M12_01
	}
	LoopPlay(#tr01,,0)

	拍子 6,8
	#M13_01
	#M14_01
	拍子 2,4
	#M15_01
	#M16_01
	#M17_01
	#M18_01
	#M19_01
	拍子 4,4
	#M20_01
	#M21_01

TR(2)
	C=0
	拍子 4,4
	#M01_02
	#M02_02

	#tr02={
		Time(11+109*C:1:1)
		C=C+1
		#M03_02
		#M04_02
		#M05_02
		#M06_02
		#M07_02
		#M08_02
		#M09_02
		#M10_02
		#M11_02
		#M12_02
	}
	LoopPlay(#tr02,,0)

	拍子 6,8
	#M13_02
	#M14_02
	拍子 2,4
	#M15_02
	#M16_02
	#M17_02
	#M18_02
	#M19_02
	拍子 4,4
	#M20_02
	#M21_02

TR(3)
	C=0
	拍子 4,4
	#M01_03
	#M02_03

	#tr03={
		Time(11+109*C:1:1)
		C=C+1
		#M03_03
		#M04_03
		#M05_03
		#M06_03
		#M07_03
		#M08_03
		#M09_03
		#M10_03
		#M11_03
		#M12_03
	}
	LoopPlay(#tr03,,0)

	拍子 6,8
	#M13_03
	#M14_03
	拍子 2,4
	#M15_03
	#M16_03
	#M17_03
	#M18_03
	#M19_03
	拍子 4,4
	#M20_03
	#M21_03

TR(4)
	C=0
	拍子 4,4
	#M01_04
	#M02_04

	#tr04={
		Time(11+109*C:1:1)
		C=C+1
		#M03_04
		#M04_04
		#M05_04
		#M06_04
		#M07_04
		#M08_04
		#M09_04
		#M10_04
		#M11_04
		#M12_04
	}
	LoopPlay(#tr04,,0)

	拍子 6,8
	#M13_04
	#M14_04
	拍子 2,4
	#M15_04
	#M16_04
	#M17_04
	#M18_04
	#M19_04
	拍子 4,4
	#M20_04
	#M21_04