 			outputItem( stats.timeSolve);
 			// Total amount of time
 			outputItem( stats.timeSetup + stats.timeSolve);
-		}
-		else if (!setupSuccess)
-			outputItem ( "Out of memory");
-		else if (ISNAN(cusp::blas::nrm1(x)))
-			outputItem ( "Zero pivoting");
-		else
+		} else
 			outputItem ( "Not converged");
 
 		cout << "</tr>" << endl;

// -----------------------------------------------------------------------------
void ShowUsage()
{
	cout << "Usage:  driver_mm [OPTIONS]" << endl;
	cout << endl;
	cout << " -p=NUM_PARTITIONS" << endl;
	cout << " --num-partitions=NUM_PARTITIONS" << endl;

	SpmvFunctor  mySpmv(A);
	Vector       x(A.num_rows, 0);

	bool solveSuccess = true; 

	OutputItem outputItem(cout);

	cout << "<tr valign=top>" << endl;

	// Name of matrix
	{
		int i;
		for (i = fileMat.size()-1; i>=0 && fileMat[i] != '/' && fileMat[i] != '\\'; i--);
		i++;

		outputItem( fileMat.substr(i));
	}

	// Dimension
	outputItem( A.num_rows);
	// No. of non-zeros
	outputItem( A.num_entries);

	try {
		mySolver.setup(A);
	} catch (const std::bad_alloc& ba) {
		solveSuccess = false;
		// Half-bandwidth
		outputItem( "N/A");
		// Half-bandwidth after MC64
		outputItem( "N/A");
		// Solve the problem successfully
		outputItem( solveSuccess);
		// Reason why cannot solve (for unsuccessful solving only)
		outputItem ("Out of memory (in setup stage)");

		return 1;
	} catch (const spike::system_error& se) {
		solveSuccess = false;
		// Half-bandwidth
		outputItem( "N/A");
		// Half-bandwidth after MC64
		outputItem( "N/A");
		// Solve the problem successfully
		outputItem( solveSuccess);

		// Reason why cannot solve (for unsuccessful solving only)
		switch(se.reason()) {
			case spike::system_error::Zero_pivoting:
				outputItem( "Zero pivoting");
				break;
			case spike::system_error::Illegal_update:
				outputItem( "Illegal update");
				break;
			case spike::system_error::Negative_MC64_weight:
				outputItem( "Internal system error");
				break;
			default:
				outputItem( "Unknown error");
				break;
		}

		return 1;
	}

	try {
		solveSuccess = mySolver.solve(mySpmv, b, x);
	} catch (const std::bad_alloc& ba) {
		solveSuccess = false;
		// Half-bandwidth
		outputItem( "N/A");
		// Half-bandwidth after MC64
		outputItem( "N/A");
		// Solve the problem successfully
		outputItem( solveSuccess);
		// Reason why cannot solve (for unsuccessful solving only)
		outputItem ("Out of memory (in solve stage)");

		return 1;
	} catch (const spike::system_error& se) {
		solveSuccess = false;
		// Half-bandwidth
		outputItem( "N/A");
		// Half-bandwidth after MC64
		outputItem( "N/A");
		// Solve the problem successfully
		outputItem( solveSuccess);

		// Reason why cannot solve (for unsuccessful solving only)
		switch(se.reason()) {
			case spike::system_error::Zero_pivoting:
				outputItem( "Zero pivoting");
				break;
			case spike::system_error::Illegal_update:
				outputItem( "Illegal update");
				break;
			case spike::system_error::Negative_MC64_weight:
				outputItem( "Internal system error");
				break;
			default:
				outputItem( "Unknown error");
				break;
		}

		return 1;
	}

	{
		spike::Stats stats = mySolver.getStats();
		// Half-bandwidth
		outputItem( stats.bandwidth);
		// Half-bandwidth after MC64
