// Filing Status



var 	SINGLE_FILER	  		  = 0;

var 	MARRIED_JOINT_FILER	  	  = 1;

var 	MARRIED_SEPARATE_FILER	 	  = 2;

var 	HEAD_HOUSE			  = 3;

var 	QUAL_WIDOW			  = 4;



var 	MAX_STATUS		       	  = 5;

var 	NUM_TAXRATES			  = 6;

var 	CURRENT_YEAR	                  = 0;

var 	PP_BIWEEKLY 		      	  = 0;

var 	Tax_DedMedicalPct	      	  = 0.075;

var     ED_CREDIT_THRESHOLD_MFJ = 106000;

var     ED_CREDIT_THRESHOLD_NON_MFJ = 52000;

var     AMTI_MFS = 29000;

var     AMTI_LIMIT_MFS = 191000;

var     RefCTC_Threshold = 10750;

var     RefCTC_Threshold_Wages = 87900;

var	CHILD_TAX_CREDIT = 1000;

var	ExtraAmtMFJ  =  950;

var	ExtraAmtSingle =1200;

var	MinDepStd = 800;

var	PersonalExemption = 3100;







// ***************************************************************************

//

// Class: TaxRateYearConst

//

// ***************************************************************************



function TaxRateYearConst( ) 

{



		this.NumBrackets = NUM_TAXRATES;



		this.TaxRate = new Array( 10.00, 15.00, 25.00, 28.00, 33.00, 35.00 );



		this.IncomeLimit = new Array(

		0, 7150.00, 	29050.00,  70350.00, 146750.00, 319100.00,

		0, 14300.00,	58100.00, 117250.00, 178650.00, 319100.00,

		0, 7150.00, 	29050.00,  58625.00,  89325.00, 159550.00,

		0, 10200.00,	38900.00,  100500.00, 162700.00, 319100.00,

		0, 14300.00,	58100.00, 117250.00, 178650.00, 319100.00 );





		//standard deductions

		this.Deduction = new Array(

			4850.00,

			9700.00,

			4850.00,

			7150.00,

			9700.00 );





		this.AMTExemption = new Array(

			 40250.00,

			 58000.00,

			 29000.00,

			 40250.00,

			 58000.00 );	



		this.BracketWH = new Array(

                                2650, 9700, 30800, 68500, 148700, 321200,

                                8000, 22300, 64750, 118050, 185550, 326100 );

                this.WHAmt = new Array(

                                0, 705, 3870, 13295, 35751, 92676,

                                0, 1430, 7797.5, 21122.50, 40022.50, 86404 );





		this.TaxRateOld = new Array( 10.00, 15.00, 27.00, 30.00, 35.00, 38.60 );



		this.IncomeLimitOld = new Array(

			0, 6000.00, 	28400.00,  68800.00, 143500.00, 311950.00,

			0, 12000.00,	47450.00, 114650.00, 174700.00, 311950.00,

			0, 6000.00, 	23725.00,  57325.00,  87350.00, 155975.00,

			0, 10000.00,	38050.00,  98250.00, 159100.00, 311950.00,

			0, 12000.00,	47450.00, 114650.00, 174700.00, 311950.00 );



		this.AMTExemptionOld = new Array(

			 35750.00,

			 49000.00,

			 24500.00,

			 35750.00,

			 49000.00 );



		//old standard deductions

		this.DeductionOld = new Array(

			4750.00,

			7950.00,

			3975.00,

			7000.00,

			7950.00 );







} // TaxRateYearConst



// ***************************************************************************

//

// Class: TaxRates

//

// ***************************************************************************

function TaxRates()

{

		//

		// Public Methods

		//

			this.SetTaxRatesForYear	= SetTaxRatesForYear;



		//

		// Public Members

		//

			this.Tax_NumTaxRates;

			this.Tax_TaxRates		= new Array( NUM_TAXRATES );	 // taxRate

			this.Tax_DeductionStandard = new Array( MAX_STATUS );	 // deduction

			this.Tax_DeductionStandardOld = new Array( MAX_STATUS );



			this.IDPOThreshold		= new Array( MAX_STATUS );



			this.iIDPOThreshold		= new Array(

				142700.00,	// SINGLE

				142700.00,	// MARRIED_JOINT

				 71350.00,	// MARRIED_SEPARATE_FILER

				142700.00,	// HEAD_HOUSE

				142700.00 );	// QUAL_WIDOW





			this.PEPOThreshold		= new Array( MAX_STATUS );



			this.iPEPOThreshold		= new Array(

				142700.00,	// SINGLE

				214050.00,	// MARRIED_JOINT

				107025.00,	// MARRIED_SEPARATE_FILER

				178350.00,	// HEAD_HOUSE

				214050.00); // QUAL_WIDOW





			this.AMTExemptionPO		= new Array( MAX_STATUS );

			this.iAMTExemptionPO	= new Array(

				112500.00,	// SINGLE

				150000.00,	// MARRIED_JOINT

				 75000.00,	// MARRIED_SEPARATE_FILER

				112500.00,	// HEAD_HOUSE

				150000.00); // QUAL_WIDOW





			this.rThisYear			= new TaxRateYearConst( 2004 ); 



} // TaxRates





function SetTaxRatesForYear( TaxYear)

{



		var i, j;

		var rPtr;



		if( TaxYear == CURRENT_YEAR )

		{

			rPtr = this.rThisYear;

		}



		this.Tax_NumTaxRates  = rPtr.NumBrackets;





		for( i=0;i<MAX_STATUS;i++ )

		{

			var taxAmount;



			this.Tax_DeductionStandard[i] = rPtr.Deduction[i]; 



			this.Tax_DeductionStandardOld[i] = rPtr.DeductionOld[i];



			if( TaxYear == CURRENT_YEAR )

			{

			  this.IDPOThreshold[i] = this.iIDPOThreshold[i];

			}





			this.AMTExemptionPO[i] = this.iAMTExemptionPO[i];



		}



} // SetTaxRatesForYear













// ***************************************************************************

//  function: Calc_SelfAndSpouse (class: FormBasic)

//

//	1, if "You" are not a dependent, +

//	1, if married filing joint and the spouse is not a dependent

//

// ***************************************************************************

function Calc_SelfAndSpouse( FilingStatus, Deduct_DedOther, Deduct_SPDedOther )

{

		var NumCount = 0;



		if( Deduct_DedOther == 2  ) {

			NumCount = 1;

		}



		if( FilingStatus == MARRIED_JOINT_FILER  && Deduct_SPDedOther == 2 ) {

			NumCount += 1;

		}



		this.Exempt_SelfAndSpouse = NumCount;

		return( this.Exempt_SelfAndSpouse );



} // Calc_SelfAndSpouse





// ***************************************************************************

// function: Calc_TotChildDependents (class: FormBasic)

//

//                        TotChildDependents Calculation

// ***************************************************************************

function Calc_TotChildDependents()

{

		var TotDepChild = 0;

		TotDepChild += this.Exempt_Dependents;

		TotDepChild += this.Exempt_Under17;

		TotDepChild += this.Exempt_Under14to16;

		TotDepChild += this.Exempt_Student19to24;

		TotDepChild += this.Exempt_DisabledChild;

		TotDepChild += this.Other_Dependents;



		return ( TotDepChild );



} //Calc_TotChildDependents





// ***************************************************************************

// function: Calc_TotExemptions (class: FormBasic)

//

//                            Personal Exemption  Calculation

// ***************************************************************************

function Calc_TotExemptions( FilingStatus, Deduct_DedOther, Deduct_SPDedOther, AGI )

{

		var DisPerExemptions;

		var status = Estimator.FilingStatus;

		var dropRemValue = 0;

		var diff = 0;

		var PEPOThreshold = this.TaxRates.iPEPOThreshold[status];



		this.Exempt_TotExemptions = this.Calc_SelfAndSpouse( FilingStatus, Deduct_DedOther, Deduct_SPDedOther );



		this.Exempt_TotExemptions += this.Exempt_Dependents;

		this.Exempt_TotExemptions += this.Exempt_Under17;

		this.Exempt_TotExemptions += this.Exempt_Under14to16;

		this.Exempt_TotExemptions += this.Exempt_Student19to24;

		this.Exempt_TotExemptions += this.Exempt_DisabledChild;

		this.Exempt_TotExemptions += this.Other_Dependents;

		this.Exempt_TotExemptions *= PersonalExemption;



		if ( Estimator.AGI > PEPOThreshold )

		{



			 if ( status == MARRIED_SEPARATE_FILER )

			 {



				 // Drop Remainder Calculations

				 diff =  (( AGI - PEPOThreshold ) / 1250 );

				 dropRemValue =  Math.round( diff );



				 if ( diff < dropRemValue ) {

				   dropRemValue -= 1;

				 }

				 DisPerExemptions = 0.02 *  ( dropRemValue + 1 ) * this.Exempt_TotExemptions;

			 }else

			 {

				// Drop Remainder Calculations

				 diff =  (( AGI - PEPOThreshold) / 2500 );

				 dropRemValue =  Math.round( diff );



				 if ( diff < dropRemValue ) {

				   dropRemValue -= 1;

				 }

				  DisPerExemptions = 0.02 *  ( dropRemValue  + 1 ) * this.Exempt_TotExemptions;



			 }



			 this.Exempt_TotExemptions -= DisPerExemptions;



		}



		    return ( Math.max( this.Exempt_TotExemptions, 0.0 ));



}// Calc_TotExemptions









// ***************************************************************************

// function: Calc_AllowMed (class: FormBasic)

//

//           Allowable Medical Expenses Calculation

// ***************************************************************************

function Calc_AllowMed( AGI )

{

		var amt = 0;



		amt =  this.Deduct_Med - round( Tax_DedMedicalPct * AGI );

		this.Deduct_AllowMed = Math.max( 0.0, amt );



		return ( this.Deduct_AllowMed );

}// Calc_AllowMed







// ***************************************************************************

// function: Calc_StudentLoanInterest (class: FormBasic)

//

//            Calculation Returns value for Student Loan Interst Deduction

// ***************************************************************************



function Calc_StudentLoanInterest()

{

		var status = Estimator.FilingStatus;

		var IntDisAllowed = 0;

		var POThreshold = 0;



		var AGI = Estimator.Calc_StudentLoanIntAGI();

		var Interest = Estimator.FBasic.StudentLoanInt;

		var MaxExp = Math.min( 2500, Interest )



		if ( status  == MARRIED_SEPARATE_FILER )

		{

		  return (0);

		}



		if ( status == MARRIED_JOINT_FILER )

		{

		  POThreshold = 100000;

		}

		else {

		  POThreshold = 50000;

		}



		if ( AGI > POThreshold &&  status != MARRIED_JOINT_FILER )

		{

		  IntDisAllowed = MaxExp * Math.min(1.0, (( AGI - POThreshold )/ 15000 ));

		}

		else

		if ( AGI > POThreshold &&  status == MARRIED_JOINT_FILER )

		{

		  IntDisAllowed = MaxExp * Math.min(1.0, (( AGI - POThreshold )/ 30000 ));

		}



		return ( MaxExp - IntDisAllowed );



 }  // Calc_StudentLoanInterest









// ***************************************************************************

//      function: Calc_StdDeduction (class: FormBasic)

//

//      Function Returns Calculated value of standard Deduction

// ***************************************************************************

function Calc_StdDeduction() 

{

		var status   = Estimator.FilingStatus;

		var IsADependent = Estimator.FBasic.Deduct_DedOther;

		var IsSPDependent =  Estimator.FBasic.Deduct_SPDedOther;



		var self     = this.Deduct_SelfBlind;

		var spouse   = this.Deduct_SpouseBlind;



		var deduction;



		var NumExtras	= 0;

		var amtToAdd = 0;

		var ExtraAmt = 0;

		var TPIncome = Estimator.FBasic.TPIncLoss;

		var SelfWages = Estimator.SelfWages;

		var SpouseWages = Estimator.SpouseWages

		var Income = 0;



		var SelfWages = Estimator.SelfWages;

		var SpouseWages = Estimator.SpouseWages



		var SEIncomeLoss = Estimator.FBasic.TPIncLoss;

		var SPIncomeLoss = Estimator.FBasic.SPIncLoss;

		var TPSETax = CalcTPSETax();







		if ( Estimator.TPAge > 64 ){

			NumExtras += 1;

		}



		if ( self == 1){

		   NumExtras += 1;

		}



		if ( status == MARRIED_JOINT_FILER )

		{

			 if ( Estimator.SPAge > 64 ){

				NumExtras += 1;

			  }

			 if ( spouse == 1 ){

				NumExtras += 1;

			  }

		}





		if (( status == MARRIED_JOINT_FILER ) || ( status == QUAL_WIDOW ) || ( status == MARRIED_SEPARATE_FILER ))

		{

		   ExtraAmt = ExtraAmtMFJ ;

		}else

		{

		   ExtraAmt = ExtraAmtSingle;

		}





		amtToAdd = ExtraAmt * NumExtras;

		stdDed = this.TaxRates.Tax_DeductionStandard[status];



		Income = (SelfWages + SpouseWages + SEIncomeLoss + SPIncomeLoss  - (0.5 * CalcTPSETax()) - (0.5 * CalcSPSETax() ));

		if ( IsADependent == 1  ||  IsSPDependent == 1 )

		{

		  stdDed = amtToAdd + Math.min(Math.max( MinDepStd, Income + 250 ), stdDed );

		}

		else

		{

		  stdDed += amtToAdd;

		}



	    return ( stdDed );



} // Calc_StdDeduction





function Calc_CapitalGainTax(AGI)

{

 var OrdinaryInc = 0;

 var TaxableInc = 0;

 var NetCapitalGain = 0;

 var DiffTaxIncAndNGC = 0;



 var status = Estimator.FilingStatus;



 var theTaxRateYearConst;

 var theTaxRateYearConst = Estimator.TaxRates.rThisYear;



 var MinTIOr3dBP = 0;

 var PctTax10 = 0;

 var PctTax20 = 0;



 var OrdTax1;

 var OrdTax2 = 0;

 var TentCGTax = 0;



 TaxableInc = this.Calc_TaxableInc(AGI);



 NCapGain = this.NetCapitalGain() + Estimator.FBasic.QualifyingDividend;



 var GainGTOneYear = Estimator.FBasic.HeldGTOneYr + Estimator.FBasic.QualifyingDividend;

 var NetCapitalGain = Math.min(GainGTOneYear, NCapGain);





 DiffTaxIncAndNGC = TaxableInc  - NetCapitalGain;





 OrdinaryInc = Math.max(0, DiffTaxIncAndNGC);

 OrdTax1 = Calc_OrdinaryTaxWithOrdIncome(Estimator.AGI, OrdinaryInc)





 var TaxBracket = (theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + 2])



var LowestRateGain = Math.max(0, Estimator.FBasic.QualifyingDividend + Estimator.FBasic.HeldGTOneYr);

 var AmtToTaxAt5Pct = 0;

 var PctTax5 = 0;

 var AmtToTaxAt15Pct = 0;

 var PctTax15 = 0;



 MinTIOr3dBP = Math.min(TaxableInc, TaxBracket);



 if (MinTIOr3dBP >  OrdinaryInc) {

     AmtToTaxAt5Pct =  Math.min(LowestRateGain, MinTIOr3dBP - OrdinaryInc);

     PctTax5 = 0.05 * AmtToTaxAt5Pct;

     PctTax10 = 0.10 * (MinTIOr3dBP - OrdinaryInc - AmtToTaxAt5Pct);

  }

  else {

    PctTax10 = 0;

  }





 if (NetCapitalGain == (MinTIOr3dBP - OrdinaryInc)) {

    PctTax20 = 0;

  }

  else {

        var CapGainNotToTax = (MinTIOr3dBP - OrdinaryInc);

                if ( CapGainNotToTax < 0 )

                {

                  CapGainNotToTax = 0;

                }

                var CapGainLeftToTax = Math.max(0,  Math.min(TaxableInc, NetCapitalGain) - CapGainNotToTax);

                AmtToTaxAt15Pct = Math.min(LowestRateGain, CapGainLeftToTax);

                PctTax15 = 0.15 * AmtToTaxAt15Pct;

        PctTax20 = 0.20 *  (CapGainLeftToTax - AmtToTaxAt15Pct);

  }



 TentCGTax =  OrdTax1 + PctTax10 + PctTax20 + PctTax5 + PctTax15;





 OrdTax2 = Calc_OrdinaryTax(Estimator.AGI)







 return (Math.min(TentCGTax, OrdTax2));





}











// ***************************************************************************

// function: Calc_OrdinaryTaxWithOrdIncome (class: FormEstimator)

//  Calculation For Regular Tax

// ***************************************************************************



function Calc_OrdinaryTaxWithOrdIncome(AGI, OrdinaryInc)

{

        var status = Estimator.FilingStatus;



    var Tax = 0;

    var i = 0;

    var MinInc = 0;

    var TaxableInc = 0;



        var DiffTaxIncAndNGC = 0;

        var     NetCapitalGain = 0;



    TaxableInc = OrdinaryInc;



    var theTaxRateYearConst;

        var theTaxRateYearConst = Estimator.TaxRates.rThisYear;





                for ( i=1 ; i<6; i++ )



                {

                  if ( TaxableInc > theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + (i-1) ] )

                  {

                     MinInc = Math.min(TaxableInc, theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + i]) - theTaxRateYearConst

.IncomeLimit[(status*NUM_TAXRATES) + (i-1) ];

                     Tax = Tax + Math.round(theTaxRateYearConst.TaxRate[i-1] * MinInc);



                  }

                }



                if ( TaxableInc > theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + 5] )

                {

                        Tax = Tax + Math.round(theTaxRateYearConst.TaxRate[5] * (TaxableInc - theTaxRateYearConst.IncomeLimit[(status * NUM_TAXRATES) + 5] )); }



                        Tax = Math.round(1.0 * Tax / 100);

                        return ( Tax );



} // Calc_OrdinaryTaxWithOrdIncome





// ***************************************************************************

// function: Calc_OrdinaryTax (class: FormEstimator)

//  Calculation For Regular Tax

// ***************************************************************************



function Calc_OrdinaryTax(AGI)

{

        var status = Estimator.FilingStatus;



    var Tax = 0;

    var i = 0;

    var MinInc = 0;

    var TaxableInc = 0;

        var OrdinaryInc = 0;



        var DiffTaxIncAndNGC = 0;

        var     NetCapitalGain = 0;



    TaxableInc = this.Calc_TaxableInc(AGI);



        NetCapitalGain = this.NetCapitalGain() + Estimator.FBasic.QualifyingDividend; // BH 6/6 add qualifying divs

    DiffTaxIncAndNGC = TaxableInc  - NetCapitalGain;

    OrdinaryInc = Math.max(0, DiffTaxIncAndNGC);



    var theTaxRateYearConst;

        var theTaxRateYearConst = Estimator.TaxRates.rThisYear;



                for ( i=1 ; i<6; i++ )



                {

                  if ( TaxableInc > theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + (i-1) ] )

                  {

                     MinInc = Math.min(TaxableInc, theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + i]) - theTaxRateYearConst

.IncomeLimit[(status*NUM_TAXRATES) + (i-1) ];

                     Tax = Tax + Math.round(theTaxRateYearConst.TaxRate[i-1] * MinInc);



                  }

                }



                if ( TaxableInc > theTaxRateYearConst.IncomeLimit[(status*NUM_TAXRATES) + 5] )

                {

                        Tax = Tax + Math.round(theTaxRateYearConst.TaxRate[5] * (TaxableInc - theTaxRateYearConst.IncomeLimit[(status * NUM_TAXRATES) + 5] ));

                }



                        Tax = Math.round(1.0 * Tax / 100);

                        return ( Tax );

} // Calc_OrdinaryTax







// ***************************************************************************

// function: Calc_RegularTax(class: FormEstimator)

//  Calculation For RegularTax

// ***************************************************************************





function Calc_RegularTax(AGI)

{

  var NCapGain = 0

    NCapGain = Estimator.NetCapitalGain() + Estimator.FBasic.QualifyingDividend; 



  var GainGTOneYear = Estimator.FBasic.HeldGTOneYr + Estimator.FBasic.QualifyingDividend;     // BH 6/6 add qualifying divs

  var NCG = Math.min(GainGTOneYear, NCapGain);



  var RegTax = 0;

  var TaxableInc = 0;



  if ( NCG  > 0 ){



        RegTax = this.Calc_CapitalGainTax(AGI);



  } else

  {

        RegTax = Estimator.Calc_OrdinaryTax(AGI);

  }



  return ( RegTax );



}











// ***************************************************************************

// function: Calc_ChildTaxCredit (class: FormEstimator)

//   Calculation For Child Tax Credit

// ***************************************************************************



function Calc_ChildTaxCredit()

{

        var result;

        var TopLimit, tL1, tL2, tL4, tL5, tL6, tL7;

        var ChildRate;

        var JointLim = 110000;

        var SepLim = 55000;

        var ElseLim = 75000;

        var AGIToUse = Estimator.AGI;

        var TotCldUnder17 = 0;



        ChildRate = CHILD_TAX_CREDIT;  



        TotCldUnder17 = Estimator.FBasic.Exempt_Dependents + Estimator.FBasic.Exempt_Under14to16;



        if ( TotCldUnder17 > 0 )

        {



                tL1 = ChildRate * TotCldUnder17;



                if (Estimator.FilingStatus == MARRIED_JOINT_FILER)

                        TopLimit = JointLim

                else

                if (Estimator.FilingStatus == MARRIED_SEPARATE_FILER)

                        TopLimit = SepLim

                else

                        TopLimit = ElseLim;



                tL4 = Math.max(0, AGIToUse - TopLimit);

                if (tL4 > 0)

                {



          if ( Math.round(tL4/1000) != (tL4/1000) )

                  {

                        tL4 = tL4 + 1000;

          }

                        tL4 = parseInt( tL4/1000 );

            tL5 = tL4 * 1000;

                        tL6 = tL5 * .05;



                }

                else

                        tL6 = 0;





                tL7 = (tL1 - tL6);



                if (tL7 <= 0)

                        result = 0

                else

                        result = Math.max(0,tL7);



		result = Math.max(0, result); 



                return result

        }else

        {

         return 0;

        }



}









// ***************************************************************************

// function: Calc_EIC (class: FormEstimator)

//   Calculation For Earned Income Credit

// ***************************************************************************



function Calc_EIC(AGI)

{



var TotDep = 0;

var NumberEICKids = 0;

var NetGain;

var Status = Estimator.FilingStatus;

var earnedIncCrdt;

var earnedIncCrdtAGI;

var earnedIncCrdtWages;

var TotWagesNSelfEmly;



var TPSETax = CalcTPSETax();

var SPSETax = CalcSPSETax();

var IsADependent = Estimator.FBasic.Deduct_DedOther;

var IsSPDependent =  Estimator.FBasic.Deduct_SPDedOther;





TotDep = Estimator.FBasic.Exempt_Dependents;

TotDep += Estimator.FBasic.Exempt_Under17;

TotDep += Estimator.FBasic.Exempt_DisabledChild;

TotDep += Estimator.FBasic.Exempt_Under14to16;

TotDep += Estimator.FBasic.Exempt_Student19to24;

TotDep += Estimator.FBasic.Other_Dependents;



NumberEICKids = TotDep -  Estimator.FBasic.Other_Dependents;

NetGain = NetCapitalGain();



earnedIncCrdtAGI = EarnedIncomeCredit(AGI, NumberEICKids);



TotWagesNSelfEmly = Estimator.SelfWages + Estimator.SpouseWages +  Estimator.FBasic.TPIncLoss + Estimator.FBasic.SPIncLoss - (0.5 * (TPSETax + SPSETax));



earnedIncCrdtWages = EarnedIncomeCredit(TotWagesNSelfEmly, NumberEICKids);





if ((Status == MARRIED_SEPARATE_FILER ) ||

    ((NetGain  + Estimator.FBasic.QualifyingDividend)> 2650) ||

    (AGI > 35458) ||

    (IsADependent == 1)  ||  (IsSPDependent == 1) ||

    (NumberEICKids == 0 && ((Estimator.TPAge < 25 || Estimator.TPAge > 64) && (Estimator.SPAge < 25 || Estimator.SPAge > 64))))

    {

      earnedIncCrdt = 0;

    }

else

{

 earnedIncCrdt = Math.min( earnedIncCrdtAGI, earnedIncCrdtWages )

}



 if ( Estimator.TPAge < 25 && Estimator.SPAge >= 25  && (Status == SINGLE_FILER || Status == HEAD_HOUSE || Status == QUAL_WIDOW) )

 {

   this.TaxCalc_TotalCredits = 0;

 }

 else

 {

   this.TaxCalc_TotalCredits = earnedIncCrdt;

 }



 return this.TaxCalc_TotalCredits;



//return earnedIncCrdtAGI;



}



// New EIC numbers









function EarnedIncomeCredit(Income, NumKids)

{



    var status = Estimator.FilingStatus;

    var  kMFJAdjustment = 0;

        if ( status == MARRIED_JOINT_FILER  )

	{

		kMFJAdjustment = 1000;

	}

	else

	{

		kMFJAdjustment = 0;

	}





    var kEarnedIncAmtNoKids = 5100;

    var kEarnedIncAmt1Kid = 7660;

    var kEarnedIncAmt2Kids = 10750;



    var kEICPhaseOutStart1Or2Kids = 14040 + kMFJAdjustment;

    var kEICPhaseOutStartNoKids = 6390 + kMFJAdjustment;

    var kCodeEICPhaseOutStart1Or2Kids = 13520 + kMFJAdjustment;

    var kCodeEICPhaseOutStartNoKids = 6150 + kMFJAdjustment;



    var kMaxEICIncomeNoKids = 11060 - 1+ kMFJAdjustment;

    var kMaxEICIncome1Kid = 29201 - 1 + kMFJAdjustment;

    var kMaxEICIncome2Kids = 33178 -1 + kMFJAdjustment;

    var kMinEICAmtNoKids = 100;

    var kMinEICAmt1Kid = 100;

    var kMinEICAmt2Kids = 300;

    var kMinRangeStartNoKids = 11050 + kMFJAdjustment;

    var kMinRangeStart1Kid = 29200 + kMFJAdjustment;

    var kMinRangeStart2Kids = 33150 + kMFJAdjustment;



    var kLowerBracketFloor0Kid = 4900;

    var kLowerBracketCeiling0Kid = 4950;

    var kUpperBracketFloor0Kid = 6100 + kMFJAdjustment;

    var kUpperBracketCeiling0Kid = 6150 + kMFJAdjustment;

    var kLowerBracketFloor1Kid = 7350;

    var kLowerBracketCeiling1Kid = 7400;

    var kUpperBracketFloor1Kid = 13500 + kMFJAdjustment;

    var kUpperBracketCeiling1Kid = 13550 + kMFJAdjustment;

    var kLowerBracketFloor2Kids = 10350;

    var kLowerBracketCeiling2Kids = 10400;

    var kUpperBracketFloor2Kids = 14500 + kMFJAdjustment;

    var kUpperBracketCeiling2Kids = 14550 + kMFJAdjustment;

    var kMaxCredit0Kid  = 39000;

    var kMaxCredit1Kid  = 260400;

    var kMaxCredit2Kids  = 430000;



    var FResult = 0;

        var temp = 0;



    var CreditPct = new Array(3);

        var PhaseOutPct = new Array(3);

    //var CreditPct = new CreditArray;



    CreditPct[0] = 7.65;

    CreditPct[1] = 34.0;

    CreditPct[2] = 40.0;



    var PhaseOutAmt = 0.0;



    //var PhaseOutPct = TCReal;



    PhaseOutPct[0] = 7.65;

    PhaseOutPct[1] = 15.98;

    PhaseOutPct[2] = 21.06;



    //var EICTableAmtX  = TCReal;

    var EICTableAmtX = 0.0;



    var ActualIncome  = 0;



    ActualIncome = Income;



    if (Income > 0)

    {

     //Income = Math.round( 50.0 * (Math.round(Income) / 50) + 25);

         Income = ( 50.0 * ((Income) / 50) + 25);

    }



    if (NumKids > 2)

    {

      NumKids = 2;

    }



    var CreditPctToUse  = 0;

    var PhaseOutPctToUse = 0;



    CreditPctToUse = CreditPct[NumKids];

    PhaseOutPctToUse = PhaseOutPct[NumKids];





    if ( NumKids == 0 )

    {

              if ( Income > kEICPhaseOutStartNoKids )

               {

                 PhaseOutAmt  = ( Income - kEICPhaseOutStartNoKids ) * PhaseOutPctToUse;

               }



              EICtableAmtX =  Math.min(Income, kEarnedIncAmtNoKids) * CreditPctToUse - PhaseOutAmt;



              if (ActualIncome >= kMinRangeStartNoKids &&   ActualIncome <= kMaxEICIncomeNoKids)

              {

                    EICtableAmtX = kMinEICAmtNoKids;

              }



              if (ActualIncome >= kLowerBracketFloor0Kid &&  ActualIncome < kLowerBracketCeiling0Kid)

                {

                    EICtableAmtX = kMaxCredit0Kid;

                }

              if (ActualIncome >= kUpperBracketFloor0Kid &&  ActualIncome < kUpperBracketCeiling0Kid)

                {

                    EICtableAmtX = kMaxCredit0Kid;

                }



                        EICtableAmtX = Math.max(EICtableAmtX, 0.0);

                        temp  = Math.round(EICtableAmtX / 100);

                        return temp;

    }



    if ( NumKids == 1 )

    {

              if (ActualIncome > kEICPhaseOutStart1Or2Kids )

               {



                 PhaseOutAmt  = ( Income - kEICPhaseOutStart1Or2Kids ) * PhaseOutPctToUse;

               }



               EICtableAmtX =  Math.min(ActualIncome, kEarnedIncAmt1Kid) * CreditPctToUse - PhaseOutAmt;





               if ( ActualIncome >= kMinRangeStart1Kid &&  ActualIncome <= kMaxEICIncome1Kid )

                {

                    EICtableAmtX = kMinEICAmt1Kid;



                }



                if (ActualIncome >= kLowerBracketFloor1Kid &&  ActualIncome < kLowerBracketCeiling1Kid)

                {

                    EICtableAmtX = kMaxCredit1Kid;



                }

                if (ActualIncome >= kUpperBracketFloor1Kid &&  ActualIncome < kUpperBracketCeiling1Kid)

                {

                    EICtableAmtX = kMaxCredit1Kid;



                }



                if (ActualIncome < 6250 && (Math.round(ActualIncome) % 100) < 50)

                {

                    EICtableAmtX += 49;



                }



                        EICtableAmtX = Math.max(EICtableAmtX, 0.0);

                          temp  = Math.round(EICtableAmtX / 100);

                        return   temp;







    }



    if ( NumKids == 2 )

    {

               if (ActualIncome > kEICPhaseOutStart1Or2Kids )

                {

                  PhaseOutAmt  = ( Income - kEICPhaseOutStart1Or2Kids ) * PhaseOutPctToUse;

                }



                EICtableAmtX =  [Math.min(Income, kEarnedIncAmt2Kids) * CreditPctToUse] - PhaseOutAmt;





               if (ActualIncome >= kMinRangeStart2Kids &&  ActualIncome <= kMaxEICIncome2Kids)

                {

                    EICtableAmtX = kMinEICAmt2Kids;

                }

               if (ActualIncome >= kLowerBracketFloor2Kids && ActualIncome < kLowerBracketCeiling2Kids)

                {

                    EICtableAmtX = kMaxCredit2Kids;

                }

               if (ActualIncome >= kUpperBracketFloor2Kids && ActualIncome < kUpperBracketCeiling2Kids)

                {

                    EICtableAmtX = kMaxCredit2Kids;

                }



                        EICtableAmtX = Math.max(EICtableAmtX, 0.0);

                        temp  = Math.round(EICtableAmtX / 100);

                        return temp;



    }



}



// ***************************************************************************

// function: min

// ***************************************************************************

function min(a,b)

{



        if(a < b) {

                return(a);

        }

        else {

                return(b);

        }



}



// ***************************************************************************

// function: Math.max

// ***************************************************************************

function max(a,b)



{

        if(a > b)

                {

                return(a);

        }

                else

                {

                return(b);

        }



}





// ***************************************************************************

// function: round

// ***************************************************************************

function round(a)

{



        return (Math.round(a*100)/100);

}





// ***************************************************************************

// function: round100

// ***************************************************************************

function round100(a)

{

        return (Math.round(a));

}





function NetCapitalGain()

{

 var NGC;

 NGC = ( Estimator.FBasic.HeldOneYrOrLess + Estimator.FBasic.HeldGTOneYr);



 if ( NGC < 0 )

 {

   if ( Estimator.FilingStatus == MARRIED_SEPARATE_FILER )

   {

     NGC = Math.max(NGC, -1500)

   }

   else

   {

    NGC = Math.max(NGC, -3000)

   }



 }



return NGC;



}





function CalcTPSETax()

{

        var TPSEBase;

        if ( (.9235 * Estimator.FBasic.TPIncLoss) < 400 )

        {

                this.TPSETax = 0;

        }

        else

        {

                TPSEBase = ( 0.9235 * Math.max(0, Estimator.FBasic.TPIncLoss ));

                this.TPSETax  = ( 0.029  * TPSEBase )  +  ( 0.124 * Math.min( TPSEBase, Math.max(0, (RefCTC_Threshold_Wages - Estimator.SelfWages))));

        }



       return this.TPSETax;



}



function CalcSPSETax()

{

        var SPSETax;

        var SPSEBase;

        if ( (.9235 * Estimator.FBasic.SPIncLoss) < 400 )

        {

                SPSETax = 0;

        }

        else

        {

                SPSEBase = ( 0.9235 * Math.max(0, Estimator.FBasic.SPIncLoss ));

                SPSETax  = ( 0.029  * SPSEBase )  +  ( 0.124 * Math.min( SPSEBase, Math.max(0, (RefCTC_Threshold_Wages - Estimator.SpouseWages))));

        }



       return SPSETax;

}





function OnChangeCalculatedField(theField)

{

                alert("This field will be Calculated automatically.");

}



function FormatDollarAmont( theVar )

{

        var StringVal = new String;

        StringVal = round100( theVar );

        return StringVal;

}



function FormatInteger( theVar )

{

                var StringVal = new String;



                StringVal = theVar;



                return StringVal;

}





function EvaluateDollar( theField )

{

                var TemStr      = new String;

                var RetVal = 0.0;

                var bCheckDigit = false;



                for ( var i=0 ; i<theField.value.length ; i++ )

                {

                        if ( '0' <= theField.value.charAt(i) &&

                                 theField.value.charAt(i) <= '9' )

                                {

                                                TemStr += theField.value.charAt(i);

                                                bCheckDigit = true;

                                }

                                else

                                if ( theField.value.charAt(i) == '.' ||

                                         theField.value.charAt(i) == '-' )

                                {

                                                TemStr += theField.value.charAt(i);

                                }

                }



                if ( bCheckDigit == true )

                {

                                RetVal = parseFloat( TemStr );

                                RetVal = Math.round(RetVal);

                }





                return RetVal;

}







function EvaluateIntVal( theField )

{

                var TemStr      = new String;

                var RetVal = 0;

                var bCheckDigit = false;



                for ( var i=0 ; i<theField.value.length ; i++ )

                {

                        if ( '0' <= theField.value.charAt(i) &&

                                 theField.value.charAt(i) <= '9' )

                                {

                                                TemStr += theField.value.charAt(i);

                                                bCheckDigit = true;

                                }

                                else

                                if ( theField.value.charAt(i) == '-' )

                                {

                                                TemStr += theField.value.charAt(i);

                                }

                }



                if ( bCheckDigit == true )

                {

                                RetVal = parseInt( TemStr,10 );

                }

                return RetVal;

}





// ***************************************************************************

// function: Calc_AllowedItemDeduction (class: FormBasic)

//

//            Calculation Returns value for Allowed Itemized Deductions

//

// ***************************************************************************

function Calc_AllowedItemDeduction( FilingStatus, AGI )

{

                var C,D;

                var status = FilingStatus;



                var itemDeduction;

                this.Deduct_ItemReduction = 0.0;



                itemDeduction = this.Calc_TotItemized( FilingStatus, AGI );



                if ( AGI > this.TaxRates.IDPOThreshold[status] )

                {

                        C  =  0.03 * ( AGI - this.TaxRates.IDPOThreshold[status] );

                        D  =  0.80 * ( itemDeduction - this.Calc_AllowMed(AGI) );



                        this.Deduct_ItemReduction = Math.min(C, D);

                        this.Deduct_ItemReduction = itemDeduction -  this.Deduct_ItemReduction;

                }

                else

                {

                    this.Deduct_ItemReduction = itemDeduction;

                }





                return ( this.Deduct_ItemReduction );





} // Calc_AllowedItemDeduction





// ***************************************************************************

// function: Calc_DisAllowedItemDeduction (class: FormBasic)

//

//            Calculation Returns value for DisAllowed Itemized Deductions

//

// ***************************************************************************

function Calc_DisAllowedItemDeduction( FilingStatus, AGI )

{

        var C,D;

        var status = FilingStatus;



        var itemDeduction;

        this.Deduct_ItemReduction = 0.0;



        itemDeduction = this.Calc_TotItemized( FilingStatus, AGI );

        if ( AGI > this.TaxRates.IDPOThreshold[status] )

        {

                C  =  0.03 * ( AGI - this.TaxRates.IDPOThreshold[status] );

                D  =  0.80 * ( itemDeduction - this.Calc_AllowMed(AGI) );



                   this.Deduct_ItemReduction = Math.min( C, D );

                }





        return ( this.Deduct_ItemReduction );





} // Calc_DisAllowedItemDeduction









// ***************************************************************************

// function: Calc_GrStdOrItmReduction (class: FormBasic)

//

// BH: actually this returns the greater of standard or itemized

// ***************************************************************************

function Calc_GrStdOrItmReduction( FilingStatus, AGI)

{

                var C,D;

                var status = FilingStatus;

                var stdDed = Estimator.FBasic.Calc_StdDeduction();



                var itemDeduction;

                this.Deduct_ItemReduction = 0.0;



                itemDeduction = this.Calc_TotItemized( FilingStatus, AGI );



                if ( AGI > this.TaxRates.IDPOThreshold[status] )

                {

                        C  =  0.03 * ( AGI - this.TaxRates.IDPOThreshold[status] );

                        D  =  0.80 * ( itemDeduction - this.Calc_AllowMed(AGI) );



                this.Deduct_ItemReduction = Math.min( C, D );

                this.Deduct_ItemReduction = itemDeduction -  this.Deduct_ItemReduction;

                }

                else

                {

                  this.Deduct_ItemReduction = itemDeduction;

                }



                this.Deduct_ItemReduction = Math.max( this.Deduct_ItemReduction, stdDed );



                return ( this.Deduct_ItemReduction );



} // Calc_GrStdOrItmReduction



// ***************************************************************************

//

//      Function CalcChildCareCredit

//      Calculation for Cahild Care Credit

//

// ***************************************************************************



function CalcChildCareCredit( AGI)

{



 EligibleChildCareExpenses = 0;

 ChildCareCredit = 0;

 childCareMultiplyer = 0;

 var ChildCareExpenses = Estimator.TaxCalc_DepCare;

 var MaxChildCareExpenses = 0;



 var SelfWages = Estimator.SelfWages;

 var SpouseWages = Estimator.SpouseWages



 var SEIncomeLoss = Estimator.FBasic.TPIncLoss;

 var SPIncomeLoss = Estimator.FBasic.SPIncLoss;



 var mAGI = Estimator.AGI;



 var TotUnder13 =  Estimator.FBasic.Exempt_Dependents;

 var TotDisabled = Estimator.FBasic.Exempt_DisabledChild;





                if ( mAGI <= 15000)  {

                   childCareMultiplyer = 0.35;

                  }

                else

                 if ( mAGI > 15000 && mAGI <= 17000 ){

                   childCareMultiplyer = 0.34;

                  }

                else

                 if ( mAGI > 17000 && mAGI <= 19000 ) {

                   childCareMultiplyer = 0.33;

                 }

                else

                if ( mAGI > 19000 &&  mAGI <= 21000 ){

                  childCareMultiplyer = 0.32;

                }

                else

                if ( mAGI > 21000 && mAGI <= 23000 ){

                  childCareMultiplyer = 0.31;

                }

                else

                if ( mAGI > 23000 && mAGI <= 25000 ){

                  childCareMultiplyer = 0.30;

                }

                else

                if ( mAGI > 25000 && mAGI <= 27000 ){

                  childCareMultiplyer = 0.29;

                }

                else

                if ( mAGI > 27000 && mAGI <= 29000 ){

                  childCareMultiplyer = 0.28;

                }

                else

                if ( mAGI > 29000 && mAGI <= 31000 ){

                  childCareMultiplyer = 0.27;

                }

                else

                if ( mAGI > 31000 && mAGI <= 33000 ){

                  childCareMultiplyer = 0.26;

                }



                else

                if ( mAGI > 33000 && mAGI <= 35000 ){

                  childCareMultiplyer = 0.25;

                }



                else

                if ( mAGI > 35000 && mAGI <= 37000 ){

                  childCareMultiplyer = 0.24;

                }



                else

                if ( mAGI > 37000 && mAGI <= 39000 ){

                  childCareMultiplyer = 0.23;

                }



                else

                if ( mAGI > 39000 && mAGI <= 41000 ){

                  childCareMultiplyer = 0.22;

                }



                else

                if ( mAGI > 41000 && mAGI <= 43000 ){

                  childCareMultiplyer = 0.21;

                }



        else

                if ( mAGI >= 43000){

                  childCareMultiplyer = 0.20;

                }





        MaxChildCareExpenses = Math.min( 6000, ( 3000 * [TotUnder13 + TotDisabled] ));

   EligibleChildCareExpenses = Math.min( MaxChildCareExpenses, ChildCareExpenses );

   EligibleChildCareExpenses = Math.min( EligibleChildCareExpenses, (SelfWages + SEIncomeLoss - 0.5 * CalcTPSETax() ));







       if( Estimator.FilingStatus == MARRIED_JOINT_FILER )

           {

                   EligibleChildCareExpenses = Math.min( EligibleChildCareExpenses, ( SpouseWages + SPIncomeLoss - 0.5 * CalcSPSETax() ));

       }





 childCareCredit = ( childCareMultiplyer * EligibleChildCareExpenses );





 var RegTax = this.Calc_RegularTax( Estimator.AGI, 2004 ); //Changed 12/13



 var AMT = Estimator.Calc_AMT( Estimator.AGI);





 return childCareCredit;





}





//**********************************************************************************

//   Function Calc_TaxAfterCredit

//

//       Calulation For Tax After Credit

//**********************************************************************************



function Calc_TaxAfterCredit()

{

         var childCareCredit;

         var NonRefChildCareCredit = 0;

         var TaxAfterCredit = 0;

         var AGI = Estimator.AGI;

         var Year = 2004; 



         RegTax = this.Calc_RegularTax( AGI, Year );



         var AMTTax = Estimator.Calc_AMT( AGI, Year );

         var OtherCredits = Estimator.FBasic.Deduct_OtherCredits;

         var EducationCredit;



         var ChldTaxCrdt = this.Calc_ChildTaxCredit()

         childCareCredit = CalcChildCareCredit( AGI, Year );



         EducationCredit =  Estimator.Calc_EducationCredit();

         NonRefChildCareCredit = Math.min( ChldTaxCrdt, Math.max( RegTax, AMTTax ) - ( EducationCredit + childCareCredit ));





         TaxAfterCredit = Math.max( RegTax, AMTTax ) - childCareCredit - NonRefChildCareCredit - EducationCredit - OtherCredits;





         return ( Math.max( 0.0, TaxAfterCredit ));



}





//**********************************************************************************

//   Function Calc_TotalTax

//

//       Calulation For Total Tax

//**********************************************************************************



function Calc_TotalTax()

{

        var TaxAfterCredit = Calc_TaxAfterCredit()

        var TPSETax = CalcTPSETax();

        var SPSETax = CalcSPSETax();

        var OtherTaxes  = Estimator.FBasic.Deduct_RETax;



        this.TotalTax = ( TaxAfterCredit + TPSETax + OtherTaxes );



         if( Estimator.FilingStatus == MARRIED_JOINT_FILER )

         {

                this.TotalTax = TaxAfterCredit + TPSETax + SPSETax + OtherTaxes;

         }

         return ( this.TotalTax );

  }



// ***************************************************************************

// function: Calc_StudentLoanIntAGI (class: FormEstimator)

//   Calculation For Student Loan Interset AGIncome

// ***************************************************************************

function Calc_StudentLoanIntAGI()

{

          var NetCapGain = NetCapitalGain();

          var TPSETax = CalcTPSETax();

          var SPSETax = CalcSPSETax();

         var StudentLoanAGI;



           StudentLoanAGI  =  Estimator.SelfWages + Estimator.FBasic.QualifyingDividend + NetCapGain + Estimator.FBasic.TPIncLoss;

           StudentLoanAGI += Estimator.FBasic.OtherIncLoss - Estimator.FBasic.DeductibleIRA - Estimator.FBasic.OtherAdjToInc - (0.5 * TPSETax );



          if( Estimator.FilingStatus == MARRIED_JOINT_FILER )

          {

            StudentLoanAGI +=  Estimator.SpouseWages + Estimator.FBasic.SPIncLoss;

            StudentLoanAGI -= (0.5 *  SPSETax);

          }



           return( StudentLoanAGI );

}





// ***************************************************************************

// function: Calc_AGI (class: FormEstimator)

//   Calculation For Adjusted Gross Income

// ***************************************************************************

function Calc_AGI()

{

          var NetCapGain = NetCapitalGain();

          var TPSETax = CalcTPSETax();

          var SPSETax = CalcSPSETax();



          var StudentLoanInt = Estimator.FBasic.Calc_StudentLoanInterest();



          this.AGI  =  Estimator.SelfWages + Estimator.FBasic.QualifyingDividend + NetCapGain + Estimator.FBasic.TPIncLoss;

          this.AGI += Estimator.FBasic.OtherIncLoss - Estimator.FBasic.DeductibleIRA - StudentLoanInt - Estimator.FBasic.OtherAdjToInc - (0.5 * TPSETax );



          if( Estimator.FilingStatus == MARRIED_JOINT_FILER )

          {

            this.AGI +=  Estimator.SpouseWages + Estimator.FBasic.SPIncLoss;

            this.AGI -= (0.5 *  SPSETax);

          }



          return(this.AGI);

}





// ***************************************************************************

// function: Calc_TaxableInc (class: FormEstimator)

//   Calculation For Taxable Income

//

// ***************************************************************************

function Calc_TaxableInc(AGI)

{



                var count  = 0;



                var status = Estimator.FilingStatus;



                var GtItmOrStd = Estimator.FBasic.Calc_GrStdOrItmReduction(Estimator.FilingStatus, AGI)



                var Deduct_DedOther = Estimator.FBasic.Deduct_DedOther;

                var Deduct_SPDedOther = Estimator.FBasic.Deduct_SPDedOther;





                count = Estimator.FBasic.Calc_TotExemptions(status, Deduct_DedOther, Deduct_SPDedOther,AGI);





                //this.TaxableInc = this.Calc_AGI() - GtItmOrStd - count ;



		this.TaxableInc = AGI - GtItmOrStd - count ;



                if ( this.TaxableInc < 0.0 )

                {

                                this.TaxableInc = 0.0;

                }



                return (this.TaxableInc);





}





//**********************************************************************

//function: AMTExemption

//Calculation of AMT Exemption amount

//**********************************************************************

function CalcDeduct_AMTExemp(AMTI)

{

        var status = Estimator.FilingStatus;

        var theTaxRateYearConst;

        theTaxRateYearConst = Estimator.TaxRates.rThisYear;

        var CalcMax =  ( 0.25 * Math.max(0, [AMTI - Estimator.TaxRates.AMTExemptionPO[status]] ));

        var AMTExmp = Math.round(theTaxRateYearConst.AMTExemption[status] - CalcMax);

        if (Estimator.TPAge < 14)

         {

                AMTExmp = Math.min(AMTExmp, (5750 + Estimator.SelfWages + Estimator.FBasic.TPIncLoss - (0.5 * CalcTPSETax())));

        }



        var AMTEXMP = Math.round (AMTExmp);



        return (Math.max(0, AMTEXMP));



}







function RefundableChildTaxCredit(AGI, Year)

{

 var RefdChildTaxCredit = 0 ;

 var SEIncomeLoss = Estimator.FBasic.TPIncLoss;

 var SPIncomeLoss = Estimator.FBasic.SPIncLoss;

 var TentativeCreditFor3OrMore = 0;

 var RegTax = Estimator.Calc_RegularTax(AGI, Year);

 var TotWages = Estimator.SelfWages + Estimator.SpouseWages + SEIncomeLoss + SPIncomeLoss - 0.5 * CalcTPSETax() - 0.5  *CalcSPSETax();

 var childTaxCredit = this.Calc_ChildTaxCredit();

 var NonRefCldTaxCrdt = Estimator.NonRefChildTaxCredit(Estimator.AGI, Year);

 var MaxCredit =  Math.max(0, childTaxCredit - NonRefCldTaxCrdt);

 var TotCldUnder17 = Estimator.FBasic.Exempt_Dependents + Estimator.FBasic.Exempt_Under14to16;



 if ( !( MaxCredit > 0))

 {

    return 0;

 }



 RefdChildTaxCredit = Math.min( MaxCredit, [0.10 * (TotWages - RefCTC_Threshold)] );  



 if ( TotCldUnder17 > 2 )

 {

       TentativeCreditFor3OrMore = 0.5 * CalcTPSETax() + 0.5 * CalcSPSETax() + 0.0145 * (Estimator.SelfWages + Estimator.SpouseWages) + 0.062 * (Math.min(RefCTC_Threshold_Wages, Estimator.SelfWages) + Math.min(RefCTC_Threshold_Wages, Estimator.SpouseWages)) - Estimator.Calc_EIC(Estimator.AGI);

           TentativeCreditFor3OrMore = Math.max(TentativeCreditFor3OrMore, RefdChildTaxCredit);

           return(Math.max(0.0, Math.min(TentativeCreditFor3OrMore, MaxCredit)));

 }

 return (Math.max(0.0, RefdChildTaxCredit));



}





//**********************************************************************************

//   Function DisplayBlankField

//       Calulation For DisplayBlankField

//

//**********************************************************************************





function DisplayBlankField()

{

         var a = "";

         return a;

}