//
//====================================================================================================
//
//					    Date Functions
//                                           Version 1.5
//
//                                    Copyright (c) 2004 - 2005
//                                          Linda Walters
//                                       All Rights Reserved
//
//====================================================================================================
//

//
//====================================================================================================
//
// NOTE: Most, if not all, of these routines differ from the JavaScript Date class in that
// the months start with January = 1 and weeks with Sunday = 1 (vice January = 0 and Sunday = 0)
//
//====================================================================================================
//

//
// Global Constants
//
var gcDateDelimiter = "+";

//
//	Array of Month Names
//
var monthName	= new Array(13);

monthName[0]	= "";		// Reserved
monthName[1]	= "January";
monthName[2]	= "February";
monthName[3]	= "March";
monthName[4]	= "April";
monthName[5]	= "May";
monthName[6]	= "June";
monthName[7]	= "July";
monthName[8]	= "August";
monthName[9]	= "September";
monthName[10]	= "October";
monthName[11]	= "November";
monthName[12]	= "December";


//
//	Array of Abbreviated Month Names
//
var monthNameShort = new Array(13);

monthNameShort[0]	= "";		// Reserved
monthNameShort[1]	= "Jan";
monthNameShort[2]	= "Feb";
monthNameShort[3]	= "Mar";
monthNameShort[4]	= "Apr";
monthNameShort[5]	= "May";
monthNameShort[6]	= "Jun";
monthNameShort[7]	= "Jul";
monthNameShort[8]	= "Aug";
monthNameShort[9]	= "Sep";
monthNameShort[10]	= "Oct";
monthNameShort[11]	= "Nov";
monthNameShort[12]	= "Dec";


//
//	Array of Days in Month
//
var daysInMonth = new Array(13);

daysInMonth[0] 	= 29;	// Number of days in February in a leap year
daysInMonth[1] 	= 31;
daysInMonth[2] 	= 28;
daysInMonth[3] 	= 31;
daysInMonth[4] 	= 30;
daysInMonth[5] 	= 31;
daysInMonth[6] 	= 30;
daysInMonth[7] 	= 31;
daysInMonth[8] 	= 31;
daysInMonth[9] 	= 30;
daysInMonth[10]	= 31;
daysInMonth[11] = 30;
daysInMonth[12] = 31;

//
//	Array of Day Names
//
var dayName	= new Array(8);

dayName[0] = "";		// Reserved
dayName[1] = "Sunday";
dayName[2] = "Monday";
dayName[3] = "Tuesday";
dayName[4] = "Wednesday";
dayName[5] = "Thursday";
dayName[6] = "Friday";
dayName[7] = "Saturday";


//
//	Array of Abbreviated Day Names
//
var dayNameShort	= new Array(8);

dayNameShort[0]	= "";		// Reserved
dayNameShort[1] = "Sun";
dayNameShort[2] = "Mon";
dayNameShort[3] = "Tue";
dayNameShort[4] = "Wed";
dayNameShort[5] = "Thr";
dayNameShort[6] = "Fri";
dayNameShort[7] = "Sat";

var dayNameLetter	= new Array(8);

dayNameLetter[0] = "";		// Reserved
dayNameLetter[1] = "S";
dayNameLetter[2] = "M";
dayNameLetter[3] = "T";
dayNameLetter[4] = "W";
dayNameLetter[5] = "T";
dayNameLetter[6] = "F";
dayNameLetter[7] = "S";

//
// Global constants
//
var January 	= 1;
var February 	= 2;
var March 	= 3;
var April 	= 4;
var May 	= 5;
var June 	= 6;
var July 	= 7;
var August 	= 8;
var September 	= 9;
var October 	= 10;
var November 	= 11;
var December	= 12;

var Sunday 	= 1;
var Monday 	= 2;
var Tuesday 	= 3;
var Wednesday	= 4;
var Thursday 	= 5;
var Friday 	= 6;
var Saturday	= 7;



//
//====================================================================================================
//
//	Function to Initialize Arrays
//
//====================================================================================================
//
function Initialize()
{
	this.length = Initialize.arguments.length;
	
	for (var i = 0; i < this.length; i++) 
	{
		this[i + 1] = Initialize.arguments[i];
	} // for (var i = 0; i < this.length; i++)
} // function Initialize()



//
//====================================================================================================
//
//	Function format today's date into <weekday>, <month> <day>, <year>
//	for example, "Wednesday, January 26, 2005"
//	or "Wednesday, 26 January, 2005" if regionIn is not "USA"
//
//====================================================================================================
//
function GetDateToday(isISOIn)
{
var result;	// Function return value
var today;	// Today's date

	today = new Date();

	result = dayName[today.getDay() + 1] + ", ";

	if (isISOIn)
	{
		result = result + today.getDate() +  " " + monthName[(today.getMonth() + 1)];
	}
	else
	{
		result = result + monthName[(today.getMonth() + 1)] + " " + today.getDate();
	} // if (isISOIn)

	result = result + ", " + today.getFullYear();

	return(result);	
} // function GetDateToday()



//
//====================================================================================================
//
//	Function to get today's month name
//
//====================================================================================================
//
function GetMonthNameToday()
{
var today;	// Today's date
var month;	// Today's month

	today = new Date();
	month = today.getMonth();
	return(monthName[month])
} // function GetMonthNameToday()



//
//====================================================================================================
//
// Function to get the text for the today's name
//
//====================================================================================================
//
function GetDayNameToday()
{
var today;	// Today's date
var day;	// Today's day of week

	today = new Date();
	day = today.getDate();
	return(dayName[day])
} // function GetMonthNameToday()



//
//====================================================================================================
//
//	This function is called by the CountdownToEvent function and should not be called
//	from a page's HTML
//
//====================================================================================================
//
function daysBetweenDates(earlierDate, laterDate)
{
var result;			// Function return value. Days between the two dates
var earlierMilliseconds;	// Number of milliseconds since 01/01/1970 00:00:00 for earlier date
var laterMilliseconds;		// Number of milliseconds since 01/01/1970 00:00:00 for later date

	earlierMilliseconds = earlierDate.valueOf();
	laterMilliseconds = laterDate.valueOf();	
	result = (laterMilliseconds - earlierMilliseconds) / 86400000;	
	result = Math.ceil(result);
 	return(result);
} // function daysBetweenDates(earlierDate, laterDate)



//
//====================================================================================================
//
//	Call this function from a page to display the number of days until an event.
//	Give the date of the event as the first argument ("mm/dd/yyyy" with leading 0s)
//	and a string describing the event as the second argument. For Example:
//
//	<script type="text/javascript">CountdownToEvent("02/09/2005", "Tet Nguyen Dan")</script>
//
//	If viewed on Jan 26, 2005 it will say: "14 days until Tet Nguyen Dan"
//	If viewed on Feb 8, 2005 it will say:  "1 day until Tet Nguyen Dan"
//	If viewed on Feb 9, 2005 it will say:  "Today: Tet Nguyen Dan"
//	If viewed AFTER Feb 9, 2005 it will NOT display
//
//	NOTE: if the date of the event has past, this function will display nothing.
//
//====================================================================================================
//
function CountdownToEvent(dateOfEvent, textForEvent)
{
var result;		// Function return value
var todayDate;		// Today's date object instance
var eventDate;		// Event date object instance
var daysBetween;	// Days between todayDate and dateOfEvent

	todayDate = new Date();
	eventDate = new Date(dateOfEvent);
	daysBetween = daysBetweenDates(todayDate, eventDate);

	//
	// If the date of the event has already past, daysBetween will
	// be negative, and we don't want to display the message at all.
	// We also change the message if the event is today and change
	// "days" to "day" if the event is tomorrow
	//
	if (daysBetween >= 0)
	{
	  if (daysBetween == 0)
	  {
	    result = "Today: " + textForEvent
	  }

	  else if (daysBetween == 1)
	  {
	    result = daysBetween + " day until " + textForEvent;
	  }

	  else
	  {
	    result = daysBetween + " days until " + textForEvent;
	  } // if (daysBetween == 0)

	  document.write("<br />" + result);
	} // if (daysBetween >= 0)

	return(result);
} // function CountdownToEvent(dateOfEvent, textForEvent)



//
//====================================================================================================
//
// Function to return the number of days in the month
//
//====================================================================================================
//
function DaysInMonth(monthIn, yearIn) 
{
	return(((monthIn == February) && (LeapYear(yearIn))) ? daysInMonth[0] : daysInMonth[monthIn]);
} // function DaysInMonth(monthIn, yearIn)


//
//====================================================================================================
//
// Function to determine if the input year is a leap year
//
//====================================================================================================
//
function LeapYear(yr) 
{
	return ((yr % 4 == 0 && yr % 100 != 0) || yr % 400 == 0 ? true : false);
} // function LeapYear(yr)




//
//====================================================================================================
//
//	Function to compute the Nth Weekday of a given month. For example, the third Monday in 
//	February (Columbus Day).
//	If the NthIn argument is equal to 99 then the function will look for the LAST WeekdayIn 
//	of the month. For example, NthWeekday(99, 2, 5, 2005) will find the date for Memorial Day 
//	(last Monday in May) for the year 2005 CE
//
//====================================================================================================
//
function NthWeekday(NthIn, WeekdayIn, monthIn, yearIn)
{
var result = 0;			// function return value
var thisMonthNumber;		// current month
var thisYear4Digit;		// current year
var thisMonthDays;		// number of days in the current month
var firstDayOfMonth;		// day of week of first of the month
var doneLooking = false;	// flags if we are done looking for the day
var lastWeekday = false;	// flags the day of the week of the last day of the month

	//
	// If we are looking for the LAST (99th) weekday in the month, we set the 
	// flag and first test for the 5th weekday in the month.
	//
	if (NthIn == 99)
	{
		lastWeekday = true;
		NthIn = 5;
	} // if (NthIn == 99)

	//
	// Validate and if necessary correct the input month and year
	//
	if (((NthIn > 5) || (NthIn < 1)) || ((WeekdayIn > 7) || (WeekdayIn < 1)))
	{
		return(result);
	} // if (((NthIn > 5) || (NthIn < 1)) || ((WeekdayIn > 7) || (WeekdayIn < 1)))

	//
	// Validate or set the default Month and Year
	//
	thisMonthNumber = ((monthIn != null) && (monthIn != "")) ? monthIn : ((new Date()).getMonth()) + 1;
	thisYear4Digit = ((yearIn != null) &&+ (yearIn != "") && (((new String(yearIn)).length) == 4)) ? yearIn : ((new Date()).getFullYear());

	//
	// Determine the number of days in the Month and the Weekday of the first day of the Month
	//
	thisMonthDays = ((thisMonthNumber == 2) && (LeapYear(thisYear4Digit))) ? daysInMonth[0] : daysInMonth[thisMonthNumber];
	firstDayOfMonth = (new Date(thisMonthNumber + "/1/" + thisYear4Digit)).getDay() + 1;

	//
	// If the input Weekday is the same as the first weekday of the month and we are
	// also looking for the first Weekday, set the result to 1.
	//
	// ...Otherwise compute the date of the week day depending upon whether it is
	// in the first week or later.
	//
	if ((WeekdayIn == firstDayOfMonth) && (NthIn == 1))
	{
		result = 1;
	} // if ((WeekdayIn == firstDayOfMonth) && (NthIn == 1))

	else if (WeekdayIn <= firstDayOfMonth)
	{
		result = (WeekdayIn - firstDayOfMonth) + (NthIn * 7) + 1;
	}
	else
	{
		result = (WeekdayIn - firstDayOfMonth) + ((NthIn - 1) * 7) + 1;
	} // if ((WeekdayIn == firstDayOfMonth) && (NthIn == 1))

	//
	// If the result is greater than the number of days in the month there is
	// and error, unless we were looking for the last weekday in the month as
	// being the 5th weekday. If so, then we try to find it using the 4th weekday.
	//
	if (result > thisMonthDays)
	{
		result = (lastWeekday) ? NthWeekday(4, WeekdayIn, monthIn, yearIn) : 0;
	} // if (result > thisMonthDays)

	return(result);

} // function NthWeekday(NthIn, WeekdayIn, monthIn, yearIn)



//
//====================================================================================================
//
//	Function DateOfEaster
//	Determines the date of Easter.
//	Based on an algorithm in "Practical Astronomy for Your PC" by Peter Duffet-Smith.
//	Value returned is of the form <month_number>+<day>. For Example: "3+15" is March 15.
//
//====================================================================================================
//
function DateOfEaster(yearIn)
{
var c;		// Century
var n;		// Decade
var k;		// Intermediate value
var i;		// Intermediate value
var j;		// Intermediate value
var l;		// Intermediate value
var month;	// Month in which Easter falls (March or April)
var day;	// Day on which Easter falls (must be a Sunday)

    c = Math.floor(yearIn / 100);
    n = yearIn - 19 * Math.floor(yearIn / 19);
    k = Math.floor((c - 17) / 25);
    i = c - Math.floor(c / 4) - Math.floor((c - k) / 3) + 19 * n + 15;
    i = i - 30 * Math.floor(i / 30);
    i = i - Math.floor(i / 28) * (1 - Math.floor(i / 28) * Math.floor(29 / (i + 1))  * Math.floor((21 - n) / 11))
    j = yearIn + Math.floor(yearIn / 4) + i + 2 - c + Math.floor(c / 4);
    j = j - 7 * Math.floor(j / 7);
    l = i - j;
    month = 3 + Math.floor((l + 40) / 44);
    day = (l + 28) - (31 * Math.floor(month / 4));

    return(month + gcDateDelimiter + day);
} // function DateOfEaster(yearIn)



//
//====================================================================================================
//
//	Function DateOfAshWednesday
//	Determines the date of Ash Wednesday from the date of Easter.
//	Value returned is of the form <month_number>+<day>. For Example: "3+15" is March 15.
//
//====================================================================================================
//
function DateOfAshWednesday(yearIn)
{
var result;		// Function return value (m+d)
var isLeapYear;		// Boolean to flag if yearIn is a leap year
var daysLeft;		// Days left in month
var AWMonth;		// Month of Ash Wednesday
var AWDay;		// Day of Ash Wednesday
var EasterMonthDay	// Date of Easter (m+d)
var EMonthDay		// Array of Easter Month, Day
var daysInLent = 46;	// Days in Lent

	isLeapYear = LeapYear(yearIn);

	EasterMonthDay = DateOfEaster(yearIn);
	EMonthDay = EasterMonthDay.split(gcDateDelimiter);

	//
	// Ensure that the values are numeric
	//
	EMonthDay[0] = EMonthDay[0] * 1;
	EMonthDay[1] = EMonthDay[1] * 1;

	if (EMonthDay[0] == 4)
	{
		daysLeft = daysInLent - EMonthDay[1];
		
		if (daysLeft <= 31)
		{
			AWMonth = 3;
			AWDay = 31 - daysLeft;
		}
		else
		{
			AWMonth = 2;
			daysLeft = daysLeft - 31;
			AWDay = (isLeapYear ? 29 : 28) - daysLeft;
		} // if (daysLeft <= 31)
	}
	else
	{
		AWMonth = 2;
		daysLeft = daysInLent - EMonthDay[1];
		AWDay = (isLeapYear ? 29 : 28) - daysLeft;
	} // if (EMonthDay[0] == 4)

	result = AWMonth + gcDateDelimiter + AWDay;
	return(result);
} // function DateOfAshWednesday(yearIn)



//
//====================================================================================================
//
//	Function DateOfMardiGras
//	Determines the date of Mardi Gras from the date of Ash Wednesday, which is deterimed from
//	the date of Easter.
//	Value returned is of the form <month_number>+<day>. For Example: "3+15" is March 15.
//
//====================================================================================================
//
function DateOfMardiGras(yearIn)
{
var result;			// Function return value
var isLeapYear;			// Boolean to flag if the input year is a leap year
var AshWednesdayMonthDay;	// Month+Day of Ash Wednesday
var AWMonthDay;			// Array of Month, Day
var MGMonth;			// Mardi Gras Month
var MGDay;			// Mardi Gras Day

	isLeapYear = LeapYear(yearIn);
	AshWednesdayMonthDay = DateOfAshWednesday(yearIn);
	AWMonthDay = AshWednesdayMonthDay.split(gcDateDelimiter);

	//
	// Ensure that the values are numeric
	//
	AWMonthDay[0] = AWMonthDay[0] * 1;
	AWMonthDay[1] = AWMonthDay[1] * 1;

	if ((AWMonthDay[1] - 1) > 0)
	{
		MGMonth = AWMonthDay[0];
		MGDay = AWMonthDay[1] - 1;
	}
	else
	{
		MGMonth = AWMonthDay[0] - 1;
		MGDay = isLeapYear ? 29 : 28;
	}

	result = MGMonth + gcDateDelimiter + MGDay;
	return(result);
} // function DateOfMardiGras



function DateOfGoodFriday(yearIn)
{
var result;		// Function return value
var EasterMonthDay;	// Month+Day of Easter
var EMonthDay;		// Array of Month, Day
var GFMonth;		// Good Friday Month
var GFDay;		// Good Friday Day

	EasterMonthDay = DateOfEaster(yearIn);
	EMonthDay = EasterMonthDay.split(gcDateDelimiter);

	//
	// Ensure that the values are numeric
	//
	EMonthDay[0] = EMonthDay[0] * 1;
	EMonthDay[1] = EMonthDay[1] * 1;

	if ((EMonthDay[1] - 2) <= 0)
	{
		GFMonth = EMonthDay[0] - 1;
		GFDay = (31 + (EMonthDay[1] - 2));
	}
	else
	{
		GFMonth = EMonthDay[0];
		GFDay = EMonthDay[1] - 2;
	} // if ((EMonthDay[1] - 2) <= 0)

	result = GFMonth + gcDateDelimiter + GFDay;
	return(result);	

} // function DateOfGoodFriday



//
//====================================================================================================
//
//	Function DateOfPassover
//	Determines the date of Passover in the common solar calendar.
// 	Adapted from an algorithm developed by Karl Friedrich Gauss (1777-1855)
// 	as it appears in "The Calculated Confusion of Calendars" by Wolfgang Alexander Shocken
//	Value returned is of the form <month_number>+<day>. For Example: "3+15" is March 15.
//
//====================================================================================================
//
function DateOfPassover(yearIn)
{
var result;		// function return value
var dyear = 5757;	// default for no input
var da;			// Intermediate value
var db;			// Intermediate value
var dm;			// Intermediate value
var dmfrac;		// Intermediate value
var dc;			// Intermediate value
var ds;			// Intermediate value
var dadd;		// Intermediate value
var dcomyear;		// Year of the Common Era
var month;		// Gregorian month

	dcomyear = yearIn;
	dyear = yearIn + 3760;
	
	da = (12 * dyear + 17) % 19;
	db = dyear % 4;
	dm = 32 + 4343 / 98496 + da + da * (272953 / 492480) + db / 4;
	dm = dm - dyear * (313 / 98496);
	dmfrac = dm - Math.floor(dm);
	
	dc = (3 * dyear + 5 * db + Math.floor(dm) + 5) % 7;

	if ((dc == 2) || (dc == 4) || (dc == 6))
	{
		dm = dm + 1;
	} // if ((dc == 2) || (dc == 4) || (dc == 6))

	if (dc == 1 && da >  6 && dmfrac >=  1367 /  2160)
	{
		dm = dm + 2;
	} // if (dc == 1 && da >  6 && dmfrac >=  1367 /  2160)

	if (dc == 0 && da > 11 && dmfrac >= 23269 / 25920)
	{
		dm = dm + 1;
	} // if (dc == 0 && da > 11 && dmfrac >= 23269 / 25920)

	ds = Math.floor(dcomyear / 100);
	dadd = Math.floor((3 * ds - 5) / 4);

	//
	// If the Common Era year is after the start of the Gregorian Calendar,
	// apply the additive
	//
	if (dcomyear > 1582)
	{
		dm = dm + dadd;
	} // if (dcomyear > 1582)

	dm = Math.floor(dm);
	month = 3;

	if (dm > 153)
	{
		month = 8;
		dm = dm - 153;
	} // if (dm > 153)
	
	if (dm > 122)
	{
		month = 7;
		dm = dm - 122;
	} // if (dm > 122)

	if (dm > 92)
	{
		month = 6;
		dm = dm - 92;
	} // if (dm > 92)
	
	if (dm > 61)
	{
		month = 5;
		dm = dm - 61;
	} // if (dm > 61)
	
	if (dm > 31)
	{
		month = 4;
		dm = dm - 31;
	} // if (dm > 31)
	
	dm = (dm == 1) ? daysInMonth[--month] : dm - 1;
	result = month + gcDateDelimiter + dm;

	return(result);
} // function DateOfPassover(yearIn)


//
//====================================================================================================
//
//	Function DateOfRoshHashanah
//	Determines the date of Rosh Hashanah (starting at sundown) in the common solar calendar.
//	This algorithm is valid only for years 1900 to 2099.
//	Value returned is of the form <month_number>+<day>. For Example: "10+3" is October 3.
//
//====================================================================================================
//
function DateOfRoshHashanah(yearIn)
{
var G;			// "Golden Number" 
var GoldenNumber	// "Golden Number"
var N;			// Day number value
var y;			// Year minus 1900
var Rem1;		// Buffer for intermediate modulo value
var Rem2;		// Buffer for intermediate modulo value
var RDay;		// Integer part of day
var RFract;		// Fractional part of day
var RDayFract;		// Fractional part of day
var RMonth = 9;		// September

	//
	// Since this algorithm is only accurate between 1900 and 2099,
	// we return an empty string as the result
	//
	if ((yearIn > 2099) || (yearIn < 1900))
	{
		return("");
	} // if ((yearIn > 2099) || (yearIn < 1900))
	
	G = (yearIn % 19) + 1;
	y = yearIn - 1900;
	Rem1 = (12 * G) % 19;
	Rem2 = y % 4;
	N = 6.057778996 + 1.554241797 * Rem1 + 0.25 * Rem2 - 0.003177794 * y;
	RDay = Math.floor(N);
	RFract = N - RDay;

	if (RDay > 30)
	{
		RDay = RDay - 30;
		RMonth++;
	} // if (RDay > 30)

	dayOfWeek = (new Date("RMonth/RDay/yearIn")).getDay();

	if ((dayOfWeek == 0) || (dayOfWeek == 3) || (dayOfWeek == 5))
	{
		dayOfWeek++;
                RDay++;

	}
	else if (dayOfWeek == 1)
	{
		if ((RDayFract >= (23269 / 25920)) && (((12 * GoldenNumber) % 19) > 11))
		{		
			dayOfWeek++;	
                        RDay++;
		}
	}
	else if (dayOfWeek == 2)
	{
		if ((RDayFract >= (1367 / 2160)) && (((12 * GoldenNumber) % 19) > 6))
		{
			dayOfWeek = dayOfWeek + 2;
                        RDay = RDay + 2;
		}
	}

	if (RDay > 30)
	{
		RDay = RDay - 30;
		RMonth++;
	} // if (RDay > 30)

	return(RMonth + gcDateDelimiter + RDay);
} // function DateOfRoshHashanah(yearIn)


function DateOfYomKippur(yearIn)
{
var result;			// Function return value
var RoshHashanahMonthDay;	// Month+Day of Rosh Hashanah
var RHMonthDay;			// Array of Month and Day of Rosh Hashanah
var YMonth;			// Initially we assume they are in the same month
var YDay;			// The day is 9 days after Rosh Hashanah
		
	//
	// Since this algorithm is only accurate between 1900 and 2099,
	// we return an empty string as the result
	//
	if ((yearIn > 2099) || (yearIn < 1900))
	{
		return("");
	} // if ((yearIn > 2099) || (yearIn < 1900))

	RoshHashanahMonthDay = DateOfRoshHashanah(yearIn);
	RHMonthDay = RoshHashanahMonthDay.split(gcDateDelimiter);

	//
	// Ensure that the values are numeric
	//
	RHMonthDay[0] = RHMonthDay[0] * 1;
	RHMonthDay[1] = RHMonthDay[1] * 1;

	YMonth = RHMonthDay[0];
	YDay = RHMonthDay[1] + 9;

	//
	// If nine days later is in the next month, adjust the day and the month
	//
	if (YDay > 30)
	{
		YDay = YDay - 30;
		YMonth++;
	} // if (YDay > 30)

	result = YMonth + gcDateDelimiter + YDay;
	return(result);

} // function DateOfYomKippur(yearIn);


function GetNextMeeting()
{
var today = new Date();
var todayDay = today.getDate();
var meetingMonth = today.getMonth() + 1;
var meetingYear = today.getFullYear();

//	For 2007
//var meetingDay = NthWeekday(1, Thursday, meetingMonth, meetingYear);
//	For 2008
var meetingDay = NthWeekday(4, Tuesday, meetingMonth, meetingYear);

	if (meetingDay < todayDay)
	{
		meetingMonth++;

		if (meetingMonth > December)
		{
			meetingMonth = January;
			meetingYear++;
		} // if (meetingMonth > December)

//		meetingDay = NthWeekday(1, Thursday, meetingMonth, meetingYear);
		meetingDay = NthWeekday(4, Tuesday, meetingMonth, meetingYear);
	} // if (meetingDay < todayDay)
	
	return(monthName[meetingMonth] + " " + meetingDay + ", " + meetingYear);
} // function GetNextMeeting()