diff --git a/stepmania/src/GameState.cpp b/stepmania/src/GameState.cpp
index 129c585372..c9805877dd 100644
--- a/stepmania/src/GameState.cpp
+++ b/stepmania/src/GameState.cpp
@@ -618,7 +618,7 @@ bool GameState::HasEarnedExtraStage()
 			if( PREFSMAN->m_bPickExtraStage && GAMESTATE->IsExtraStage() && !GAMESTATE->m_bAllow2ndExtraStage )
 				continue;
 
-			if( g_CurStageStats.GetGrade((PlayerNumber)p) >= GRADE_AA )
+			if( g_CurStageStats.GetGrade((PlayerNumber)p) >= GRADE_TIER_2 )
 				return true;
 		}
 	}
diff --git a/stepmania/src/Grade.cpp b/stepmania/src/Grade.cpp
index 0758db787e..f94be74ac6 100644
--- a/stepmania/src/Grade.cpp
+++ b/stepmania/src/Grade.cpp
@@ -11,21 +11,17 @@
 */
 
 #include "Grade.h"
+#include "RageUtil.h"
 
 CString GradeToString( Grade g )
 {
+	// string is meant to be human readable
 	switch( g )
 	{
-	case GRADE_AAAA:	return "AAAA";
-	case GRADE_AAA:		return "AAA";
-	case GRADE_AA:		return "AA";
-	case GRADE_A:		return "A";
-	case GRADE_B:		return "B";
-	case GRADE_C:		return "C";
-	case GRADE_D:		return "D";
-	case GRADE_E:		return "E";
-	case GRADE_NO_DATA:	return "N";
-	default:			ASSERT( false );	return "N";
+	case GRADE_NO_DATA:	return "NoData";
+	case GRADE_FAILED:	return "Failed";
+	default:
+		return ssprintf("%02d",g);
 	}
 };
 
@@ -33,14 +29,28 @@ Grade StringToGrade( const CString &sGrade )
 {
 	CString s = sGrade;
 	s.MakeUpper();
-	if	   ( s == "AAAA" )	return GRADE_AAAA;
-	else if( s == "AAA" )	return GRADE_AAA;
-	else if( s == "AA" )	return GRADE_AA;
-	else if( s == "A" )		return GRADE_A;
-	else if( s == "B" )		return GRADE_B;
-	else if( s == "C" )		return GRADE_C;
-	else if( s == "D" )		return GRADE_D;
-	else if( s == "E" )		return GRADE_E;
-	else if( s == "N" )		return GRADE_NO_DATA;
-	else	ASSERT( false );	return GRADE_NO_DATA;	// invalid grade string
+
+	// letters for backward compatibility
+	if	   ( s == "AAAA" )		return GRADE_TIER_1;
+	else if( s == "AAA" )		return GRADE_TIER_2;
+	else if( s == "AA" )		return GRADE_TIER_3;
+	else if( s == "A" )			return GRADE_TIER_4;
+	else if( s == "B" )			return GRADE_TIER_5;
+	else if( s == "C" )			return GRADE_TIER_6;
+	else if( s == "D" )			return GRADE_TIER_7;
+	else if( s == "E" )			return GRADE_FAILED;
+	else if( s == "FAILED" )	return GRADE_FAILED;
+	else if( s == "NODATA" )	return GRADE_NO_DATA;
+
+#define MY_IS_DIGIT( c ) (c>='0'&&c<='9')
+
+	// If the string is a two digit number...
+	if( s.length()==2 && MY_IS_DIGIT(s[0]) && MY_IS_DIGIT(s[1]) )
+	{
+		return (Grade)atoi(s);
+	}
+
+	ASSERT(0);
+	return GRADE_NO_DATA;
 };
+
diff --git a/stepmania/src/Grade.h b/stepmania/src/Grade.h
index 43f0102115..a02e39704f 100644
--- a/stepmania/src/Grade.h
+++ b/stepmania/src/Grade.h
@@ -13,9 +13,33 @@
 #ifndef GRADE_H
 #define GRADE_H
 
-enum Grade { GRADE_NO_DATA=0,
-			GRADE_E, GRADE_D, GRADE_C, GRADE_B, GRADE_A,
-			GRADE_AA,GRADE_AAA,GRADE_AAAA, NUM_GRADES };
+#define NUM_GRADE_TIERS 20
+enum Grade 
+{ 
+	GRADE_NO_DATA=0,
+	GRADE_TIER_1,	// = AAAA
+	GRADE_TIER_2,	// = AAA
+	GRADE_TIER_3,	// = AA
+	GRADE_TIER_4,	// = A
+	GRADE_TIER_5,	// = B
+	GRADE_TIER_6,	// = C
+	GRADE_TIER_7,	// = D
+	GRADE_TIER_8,
+	GRADE_TIER_9,
+	GRADE_TIER_10,
+	GRADE_TIER_11,
+	GRADE_TIER_12,
+	GRADE_TIER_13,
+	GRADE_TIER_14,
+	GRADE_TIER_15,
+	GRADE_TIER_16,
+	GRADE_TIER_17,
+	GRADE_TIER_18,
+	GRADE_TIER_19,
+	GRADE_TIER_20,
+	GRADE_FAILED,	// = E
+	NUM_GRADES 
+};
 
 CString GradeToString( Grade g );
 Grade StringToGrade( const CString &s );
diff --git a/stepmania/src/GradeDisplay.cpp b/stepmania/src/GradeDisplay.cpp
index ec2cb35ee7..0074de04a3 100644
--- a/stepmania/src/GradeDisplay.cpp
+++ b/stepmania/src/GradeDisplay.cpp
@@ -96,17 +96,15 @@ int GradeDisplay::GetFrameNo( PlayerNumber pn, Grade g )
 	int iFrame;
 	switch( g )
 	{
-	case GRADE_AAAA:	iFrame = 0;	break;
-	case GRADE_AAA:		iFrame = 1;	break;
-	case GRADE_AA:		iFrame = 2;	break;
-	case GRADE_A:		iFrame = 3;	break;
-	case GRADE_B:		iFrame = 4;	break;
-	case GRADE_C:		iFrame = 5;	break;
-	case GRADE_D:		iFrame = 6;	break;
-	case GRADE_E:		iFrame = 7;	break;
-	default:
-		ASSERT(0);
-	case GRADE_NO_DATA:	iFrame = 0;	break;
+	case GRADE_TIER_1:	iFrame = 0;	break;
+	case GRADE_TIER_2:	iFrame = 1;	break;
+	case GRADE_TIER_3:	iFrame = 2;	break;
+	case GRADE_TIER_4:	iFrame = 3;	break;
+	case GRADE_TIER_5:	iFrame = 4;	break;
+	case GRADE_TIER_6:	iFrame = 5;	break;
+	case GRADE_TIER_7:	iFrame = 6;	break;
+	case GRADE_FAILED:	iFrame = 7;	break;
+	default:			iFrame = 7;	break;
 	}
 	iFrame *= iNumCols;
 	if( iNumCols==2 )
diff --git a/stepmania/src/MeterDisplay.cpp b/stepmania/src/MeterDisplay.cpp
index caace5c566..70db7d0601 100644
--- a/stepmania/src/MeterDisplay.cpp
+++ b/stepmania/src/MeterDisplay.cpp
@@ -14,8 +14,6 @@
 
 MeterDisplay::MeterDisplay()
 {
-	this->AddChild( &m_sprStream );
-	this->AddChild( &m_sprTip );
 }
 
 void MeterDisplay::Load( CString sStreamPath, float fStreamWidth, CString sTipPath )
@@ -27,6 +25,9 @@ void MeterDisplay::Load( CString sStreamPath, float fStreamWidth, CString sTipPa
 
 	m_sprTip.Load( sTipPath );
 
+	this->AddChild( &m_sprStream );
+	this->AddChild( m_sprTip );
+
 	SetPercent( 0.5f );
 }
 
@@ -36,5 +37,5 @@ void MeterDisplay::SetPercent( float fPercent )
 
 	m_sprStream.SetCropRight( 1-fPercent );
 
-	m_sprTip.SetX( SCALE(fPercent, 0.f, 1.f, -m_fStreamWidth/2, m_fStreamWidth/2) );
+	m_sprTip->SetX( SCALE(fPercent, 0.f, 1.f, -m_fStreamWidth/2, m_fStreamWidth/2) );
 }
diff --git a/stepmania/src/MeterDisplay.h b/stepmania/src/MeterDisplay.h
index a31ce28c73..367e80e6d3 100644
--- a/stepmania/src/MeterDisplay.h
+++ b/stepmania/src/MeterDisplay.h
@@ -13,7 +13,7 @@
 
 #include "ActorFrame.h"
 #include "Sprite.h"
-#include "Quad.h"
+#include "ActorUtil.h"
 
 
 class MeterDisplay : public ActorFrame
@@ -28,7 +28,7 @@ private:
 	float	m_fStreamWidth;
 	float	m_fPercent;
 	Sprite  m_sprStream;
-	Sprite  m_sprTip;
+	AutoActor  m_sprTip;
 };
 
 #endif
diff --git a/stepmania/src/NoteField.cpp b/stepmania/src/NoteField.cpp
index 267c8f1af4..da8de6ab10 100644
--- a/stepmania/src/NoteField.cpp
+++ b/stepmania/src/NoteField.cpp
@@ -332,7 +332,9 @@ NoteField::NoteDisplayCols *NoteField::SearchForBeat( float Beat )
 {
 	NDMap::iterator it = m_BeatToNoteDisplays.lower_bound( Beat );
 	/* The first entry should always be lower than any Beat we might receive. */
-	RAGE_ASSERT_M( it != m_BeatToNoteDisplays.begin(), ssprintf("%f",Beat) );
+	// This assert is firing with Beat = -7408. -Chris
+	// Again with -4976.
+ 	RAGE_ASSERT_M( it != m_BeatToNoteDisplays.begin(), ssprintf("%f",Beat) );
 	--it;
 	RAGE_ASSERT_M( it != m_BeatToNoteDisplays.end(), ssprintf("%f",Beat) );
 
diff --git a/stepmania/src/PrefsManager.cpp b/stepmania/src/PrefsManager.cpp
index b402331b5e..b95a34f7b4 100644
--- a/stepmania/src/PrefsManager.cpp
+++ b/stepmania/src/PrefsManager.cpp
@@ -115,11 +115,16 @@ PrefsManager::PrefsManager()
 	m_iGradeHitMineWeight = -8;
 	m_iGradeOKWeight = 6;
 	m_iGradeNGWeight = 0;
-	m_fGradePercentAA = 0.93f;
-	m_fGradePercentA = 0.80f;
-	m_fGradePercentB = 0.65f;
-	m_fGradePercentC = 0.45f;
-	m_fGradePercentD = 0;
+	m_bGradeTier1IsAllMarvelouses = true;
+	m_bGradeTier2IsAllPerfects = true;
+	for( int i=0; i<NUM_GRADE_TIERS; i++ )
+		m_fGradePercentTier[i] = 0;
+	m_fGradePercentTier[GRADE_TIER_1] = 1.0f;
+	m_fGradePercentTier[GRADE_TIER_2] = 1.0f;
+	m_fGradePercentTier[GRADE_TIER_3] = 0.93f;	// AA
+	m_fGradePercentTier[GRADE_TIER_4] = 0.80f;	// A
+	m_fGradePercentTier[GRADE_TIER_5] = 0.65f;	// B
+	m_fGradePercentTier[GRADE_TIER_6] = 0.45f;	// C
 	
 	m_fSuperMeterMarvelousPercentChange =	+0.05f;
 	m_fSuperMeterPerfectPercentChange =		+0.04f;
@@ -364,11 +369,12 @@ void PrefsManager::ReadGlobalPrefsFromDisk()
 	ini.GetValue( "Options", "GradeHitMineWeight",				m_iGradeHitMineWeight );
 	ini.GetValue( "Options", "GradeOKWeight",					m_iGradeOKWeight );
 	ini.GetValue( "Options", "GradeNGWeight",					m_iGradeNGWeight );
-	ini.GetValue( "Options", "GradePercentAA",					m_fGradePercentAA );
-	ini.GetValue( "Options", "GradePercentA",					m_fGradePercentA );
-	ini.GetValue( "Options", "GradePercentB",					m_fGradePercentB );
-	ini.GetValue( "Options", "GradePercentC",					m_fGradePercentC );
-	ini.GetValue( "Options", "GradePercentD",					m_fGradePercentD );
+	for( int g=0; g<NUM_GRADE_TIERS; g++ )
+	{
+		Grade grade = (Grade)g;
+		CString s = GradeToString( grade );
+		ini.GetValue( "Options", "GradePercentTier"+s,			m_fGradePercentTier[g] );
+	}
 
 	ini.GetValue( "Options", "SuperMeterMarvelousPercentChange",m_fSuperMeterMarvelousPercentChange );
 	ini.GetValue( "Options", "SuperMeterPerfectPercentChange",	m_fSuperMeterPerfectPercentChange );
@@ -569,11 +575,12 @@ void PrefsManager::SaveGlobalPrefsToDisk() const
 	ini.SetValue( "Options", "GradeHitMineWeight",				m_iGradeHitMineWeight );
 	ini.SetValue( "Options", "GradeOKWeight",					m_iGradeOKWeight );
 	ini.SetValue( "Options", "GradeNGWeight",					m_iGradeNGWeight );
-	ini.SetValue( "Options", "GradePercentAA",					m_fGradePercentAA );
-	ini.SetValue( "Options", "GradePercentA",					m_fGradePercentA );
-	ini.SetValue( "Options", "GradePercentB",					m_fGradePercentB );
-	ini.SetValue( "Options", "GradePercentC",					m_fGradePercentC );
-	ini.SetValue( "Options", "GradePercentD",					m_fGradePercentD );
+	for( int g=0; g<NUM_GRADE_TIERS; g++ )
+	{
+		Grade grade = (Grade)g;
+		CString s = GradeToString( grade );
+		ini.SetValue( "Options", "GradePercentTier"+s,			m_fGradePercentTier[g] );
+	}
 
 	ini.SetValue( "Options", "SuperMeterMarvelousPercentChange",m_fSuperMeterMarvelousPercentChange );
 	ini.SetValue( "Options", "SuperMeterPerfectPercentChange",	m_fSuperMeterPerfectPercentChange );
diff --git a/stepmania/src/PrefsManager.h b/stepmania/src/PrefsManager.h
index 3db8228fe0..3cbd7e8591 100644
--- a/stepmania/src/PrefsManager.h
+++ b/stepmania/src/PrefsManager.h
@@ -12,6 +12,7 @@
 -----------------------------------------------------------------------------
 */
 #include "PlayerNumber.h"
+#include "Grade.h"	// for NUM_GRADE_TIERS
 
 class PrefsManager
 {
@@ -111,11 +112,9 @@ public:
 	int				m_iGradeHitMineWeight;
 	int				m_iGradeOKWeight;
 	int				m_iGradeNGWeight;
-	float			m_fGradePercentAA;
-	float			m_fGradePercentA;
-	float			m_fGradePercentB;
-	float			m_fGradePercentC;
-	float			m_fGradePercentD;
+	bool			m_bGradeTier1IsAllMarvelouses;
+	bool			m_bGradeTier2IsAllPerfects;
+	float			m_fGradePercentTier[NUM_GRADE_TIERS];
 
 	float			m_fSuperMeterMarvelousPercentChange;
 	float			m_fSuperMeterPerfectPercentChange;
diff --git a/stepmania/src/ScreenBranch.cpp b/stepmania/src/ScreenBranch.cpp
index 40364944d5..a07de86fb9 100644
--- a/stepmania/src/ScreenBranch.cpp
+++ b/stepmania/src/ScreenBranch.cpp
@@ -36,13 +36,13 @@ bool EvaluateCondition( CString sCondition )
 
 	if( as.size()==3 && as[0].CompareNoCase("topgrade")==0 )
 	{
-		Grade top_grade = GRADE_E;
+		Grade top_grade = GRADE_FAILED;
 		vector<Song*> vSongs;
 		StageStats stats;
 		GAMESTATE->GetFinalEvalStatsAndSongs( stats, vSongs );
 		for( int p=0; p<NUM_PLAYERS; p++ )
 			if( GAMESTATE->IsHumanPlayer(p) )
-				top_grade = max( top_grade, stats.GetGrade((PlayerNumber)p) );
+				top_grade = min( top_grade, stats.GetGrade((PlayerNumber)p) );
 
 		CString &sOp = as[1];
 
diff --git a/stepmania/src/ScreenEvaluation.cpp b/stepmania/src/ScreenEvaluation.cpp
index daace9f6fd..e8073e8b0e 100644
--- a/stepmania/src/ScreenEvaluation.cpp
+++ b/stepmania/src/ScreenEvaluation.cpp
@@ -191,7 +191,7 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : Screen(sClassName)
 		if( GAMESTATE->IsPlayerEnabled(p) )
 			grade[p] = stageStats.GetGrade( (PlayerNumber)p );
 		else
-			grade[p] = GRADE_E;
+			grade[p] = GRADE_FAILED;
 
 		if (PREFSMAN->m_iScoringType == PrefsManager::SCORING_5TH)
 		{
@@ -209,7 +209,7 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : Screen(sClassName)
 		// if its extra stage, update # passed stages
 		if (PREFSMAN->m_bUseUnlockSystem &&
 			(GAMESTATE->IsExtraStage() || GAMESTATE->IsExtraStage2() ) &&
-			grade[p] > GRADE_E &&
+			grade[p] > GRADE_FAILED &&
 			m_Type != summary)
 					UNLOCKSYS->UnlockClearExtraStage();
 	}
@@ -434,6 +434,10 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : Screen(sClassName)
 	//
 	if( SHOW_GRADE_AREA )
 	{
+		// ugly: Touch all possible grade files to make sure their all present
+		for( int g=GRADE_TIER_1; g<NUM_GRADES; g++ )
+			THEME->GetPathToG( "ScreenEvaluation grade "+ GradeToString((Grade)g) );
+
 		for( p=0; p<NUM_PLAYERS; p++ ) 
 		{
 			if( !GAMESTATE->IsPlayerEnabled( (PlayerNumber)p ) )
@@ -451,6 +455,11 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : Screen(sClassName)
 			if( SPIN_GRADES )
 				m_Grades[p].Spin();
 			this->AddChild( &m_Grades[p] );
+
+			m_sprGrade[p].Load( THEME->GetPathToG( "ScreenEvaluation grade "+ GradeToString(grade[p]) ) );
+			m_sprGrade[p]->SetName( ssprintf("GradeP%d",p+1) );
+			SET_XY_AND_ON_COMMAND( m_sprGrade[p] );
+			this->AddChild( m_sprGrade[p] );
 		}
 	}
 
@@ -828,9 +837,9 @@ ScreenEvaluation::ScreenEvaluation( CString sClassName ) : Screen(sClassName)
 
 	switch( max_grade )
 	{
-	case GRADE_AA:
-	case GRADE_AAA:	
-	case GRADE_AAAA:	
+	case GRADE_TIER_1:
+	case GRADE_TIER_2:	
+	case GRADE_TIER_3:	
 		this->PostScreenMessage( SM_PlayCheer, CHEER_DELAY_SECONDS );	
 		break;
 	}
@@ -1002,6 +1011,7 @@ void ScreenEvaluation::TweenOffScreen()
 			continue;
 		OFF_COMMAND( m_sprGradeFrame[p] );
 		OFF_COMMAND( m_Grades[p] );
+		OFF_COMMAND( m_sprGrade[p] );
 	}
 
 	if( SHOW_GRAPH_AREA )
diff --git a/stepmania/src/ScreenEvaluation.h b/stepmania/src/ScreenEvaluation.h
index a0a623a82f..f5c3bbf0a2 100644
--- a/stepmania/src/ScreenEvaluation.h
+++ b/stepmania/src/ScreenEvaluation.h
@@ -84,6 +84,7 @@ protected:
 	// grade area
 	Sprite				m_sprGradeFrame[NUM_PLAYERS];
 	GradeDisplay		m_Grades[NUM_PLAYERS];
+	AutoActor			m_sprGrade[NUM_PLAYERS];
 
 	// graph area
 	Sprite				m_sprGraphFrame[NUM_PLAYERS];
diff --git a/stepmania/src/ScreenNameEntryTraditional.cpp b/stepmania/src/ScreenNameEntryTraditional.cpp
index 4165238265..c39183cbc4 100644
--- a/stepmania/src/ScreenNameEntryTraditional.cpp
+++ b/stepmania/src/ScreenNameEntryTraditional.cpp
@@ -82,7 +82,7 @@ ScreenNameEntryTraditional::ScreenNameEntryTraditional( CString sClassName ) : S
 				st.iActualDancePoints[i] = 985;
 
 				Steps::MemCardData::HighScore hs;
-				hs.grade = GRADE_A;
+				hs.grade = GRADE_TIER_3;
 				hs.iScore = 42;
 				int a, b;
 				GAMESTATE->m_pCurNotes[i]->AddHighScore( (PlayerNumber)i, hs, a, b );
@@ -388,19 +388,16 @@ void ScreenNameEntryTraditional::HandleScreenMessage( const ScreenMessage SM )
 				break;
 			}
 
-			Grade max_grade = GRADE_E;
+			Grade max_grade = GRADE_FAILED;
 			vector<Song*> vSongs;
 			StageStats stats;
 			GAMESTATE->GetFinalEvalStatsAndSongs( stats, vSongs );
 
 			for( int p=0; p<NUM_PLAYERS; p++ )
 				if( GAMESTATE->IsHumanPlayer(p) )
-					max_grade = max( max_grade, stats.GetGrade((PlayerNumber)p) );
-		//	if( max_grade >= GRADE_AA )
-		//		SCREENMAN->SetNewScreen( "ScreenCredits" );
-		//	else
-			//	SCREENMAN->SetNewScreen( "ScreenMusicScroll" );
-				SCREENMAN->SetNewScreen( NEXT_SCREEN );
+					max_grade = min( max_grade, stats.GetGrade((PlayerNumber)p) );
+
+			SCREENMAN->SetNewScreen( NEXT_SCREEN );
 		}
 		break;
 	}
diff --git a/stepmania/src/StageStats.cpp b/stepmania/src/StageStats.cpp
index 137b3a49be..d1e7aa18d9 100644
--- a/stepmania/src/StageStats.cpp
+++ b/stepmania/src/StageStats.cpp
@@ -140,7 +140,7 @@ Grade StageStats::GetGrade( PlayerNumber pn ) const
 	ASSERT( GAMESTATE->IsPlayerEnabled(pn) );	// shouldn't be calling this is player isn't joined!
 
 	if( bFailedEarlier[pn] )
-		return GRADE_E;
+		return GRADE_FAILED;
 
 	/* XXX: This entire calculation should be in ScoreKeeper, but final evaluation
 	 * is tricky since at that point the ScoreKeepers no longer exist. 
@@ -184,7 +184,8 @@ Grade StageStats::GetGrade( PlayerNumber pn ) const
 
 	/* check for "AAAA".  Check DP == 100%: if we're using eg. "LITTLE", we might have all
 	 * marvelouses but still not qualify for a AAAA. */
-	if( fPercentDancePoints > .9999 &&
+	if( PREFSMAN->m_bGradeTier1IsAllMarvelouses &&
+		fPercentDancePoints > .9999 &&
 		iTapNoteScores[pn][TNS_MARVELOUS] > 0 &&
 		iTapNoteScores[pn][TNS_PERFECT] == 0 &&
 		iTapNoteScores[pn][TNS_GREAT] == 0 &&
@@ -192,35 +193,33 @@ Grade StageStats::GetGrade( PlayerNumber pn ) const
 		iTapNoteScores[pn][TNS_BOO] == 0 &&
 		iTapNoteScores[pn][TNS_MISS] == 0 &&
 		iHoldNoteScores[pn][HNS_NG] == 0 )
-		return GRADE_AAAA;
+		return GRADE_TIER_1;
 
-	if( fPercentDancePoints > .9999 &&
+	if( PREFSMAN->m_bGradeTier2IsAllPerfects &&
+		fPercentDancePoints > .9999 &&
 		iTapNoteScores[pn][TNS_PERFECT] > 0 &&
 		iTapNoteScores[pn][TNS_GREAT] == 0 &&
 		iTapNoteScores[pn][TNS_GOOD] == 0 &&
 		iTapNoteScores[pn][TNS_BOO] == 0 &&
 		iTapNoteScores[pn][TNS_MISS] == 0 &&
 		iHoldNoteScores[pn][HNS_NG] == 0 )
-		return GRADE_AAA;
+		return GRADE_TIER_2;
 
-	/* Based on the percentage of your total "Dance Points" to the maximum
-	 * possible number, the following rank is assigned: 
-	 *
-	 * 100% - AAA
-	 *  93% - AA
-	 *  80% - A
-	 *  65% - B
-	 *  45% - C
-	 * Less - D
-	 * Fail - E
-	 */
 
-		 if( fPercentDancePoints >= 0.93 )		return GRADE_AA;
-	else if( fPercentDancePoints >= 0.80 )		return GRADE_A;
-	else if( fPercentDancePoints >= 0.65 )		return GRADE_B;
-	else if( fPercentDancePoints >= 0.45 )		return GRADE_C;
-	else if( fPercentDancePoints >= 0    )		return GRADE_D;
-	else										return GRADE_E;
+	// Start checking at TIER_3 if m_bGradeTier2IsAllPerfects is true.
+	// Start checking at TIER_2 if m_bGradeTier1IsAllMarvelouses is true.
+	int g;
+	if( PREFSMAN->m_bGradeTier2IsAllPerfects )
+		g = 2;
+	else if( PREFSMAN->m_bGradeTier1IsAllMarvelouses )
+		g = 1;
+	else
+		g = 0;
+	for( ; g<NUM_GRADE_TIERS; g++ )
+		if( fPercentDancePoints >= PREFSMAN->m_fGradePercentTier[g] )
+			return (Grade)(GRADE_TIER_1+g);
+
+	return (Grade)(GRADE_TIER_1+NUM_GRADE_TIERS-1);
 }
 
 bool StageStats::OnePassed() const
diff --git a/stepmania/src/UnlockSystem.cpp b/stepmania/src/UnlockSystem.cpp
index 89bf5c21d5..6f3d4d2d7f 100644
--- a/stepmania/src/UnlockSystem.cpp
+++ b/stepmania/src/UnlockSystem.cpp
@@ -425,13 +425,25 @@ float UnlockSystem::UnlockAddAP(float credit)
 	return ArcadePoints;
 }
 
-float UnlockSystem::UnlockAddAP(Grade credit)
+float UnlockSystem::UnlockAddAP(Grade grade)
 {
 	ReadValues( MEMCARD_PATH );
-	if (credit != GRADE_E && credit != GRADE_D)
-	ArcadePoints += 1;
-	if (credit == GRADE_AAA)
+	switch( grade )
+	{
+	case GRADE_FAILED:
+		;	// no points
+		break;
+	case GRADE_TIER_1:
+	case GRADE_TIER_2:
 		ArcadePoints += 9;
+		break;
+	case GRADE_NO_DATA:
+		ASSERT(0);
+		break;
+	default:
+		ArcadePoints += 1;
+		break;
+	}
 	WriteValues( MEMCARD_PATH );
 
 	return ArcadePoints;
@@ -457,12 +469,22 @@ float UnlockSystem::UnlockAddSP(float credit)
 	return SongPoints;
 }
 
-float UnlockSystem::UnlockAddSP(Grade credit)
+float UnlockSystem::UnlockAddSP( Grade grade )
 {
 	ReadValues( MEMCARD_PATH );
-	const float SongPointsVals[NUM_GRADES] = { -1 /* unused */, 0, 1, 2, 3, 4, 5, 10, 20 };
 
-	SongPoints += SongPointsVals[credit];
+	// TODO: move these to PREFS
+	switch( grade )
+	{
+	case GRADE_TIER_1:/*AAAA*/	SongPoints += 20;	break;
+	case GRADE_TIER_2:/*AAA*/	SongPoints += 10;	break;
+	case GRADE_TIER_3:/*AA*/	SongPoints += 5;	break;
+	case GRADE_TIER_4:/*A*/		SongPoints += 4;	break;
+	case GRADE_TIER_5:/*B*/		SongPoints += 3;	break;
+	case GRADE_TIER_6:/*C*/		SongPoints += 2;	break;
+	case GRADE_TIER_7:/*D*/		SongPoints += 1;	break;
+	}
+
 	WriteValues( MEMCARD_PATH );
 
 	return SongPoints;