int tests (void) {
  assert(isLeapYear(2012) == 1);
  assert(isLeapYear(2042) == 0);
  assert(isLeapYear(2000) == 1);
  assert(isLeapYear(1900) == 0);
  assert(isLeapYear(1933) == 0);

  assert(yearToDoomsday(2005) == 4);
  assert(yearToDoomsday(2006) == 5);
  assert(yearToDoomsday(2015) == 2);

  assert(dayOfWeek(6, 1, 3, 7) == 6);
  assert(dayOfWeek(6, 1, 8, 16) == 0);
  assert(dayOfWeek(6, 1, 4, 1) == 3);
  assert(dayOfWeek(5, 0, 12, 25) == 4);
  assert(dayOfWeek(6, 1, 3, 31) == 2);
 

  assert(daysToNextThursday(1856, 9, 22) == 3);
  assert(daysToNextThursday(1899, 3, 21) == 2);
  assert(daysToNextThursday(1899, 9, 14) == 7);
  assert(daysToNextThursday(1899, 11, 12) == 4);
  assert(daysToNextThursday(2048, 2, 29) == 5);
  assert(daysToNextThursday(2048, 3, 1) == 4);
  assert(daysToNextThursday(2048, 3, 2) == 3);
 
  return 0;
}

// ISO compliant week numbering, not traditional number, rename in KDE5 to isoWeekNumber()
// JPL still need to fully clean up here
int KCalendarSystem::weekNumber( const QDate &date, int *yearNum ) const
{
    if ( isValid( date ) ) {
        QDate firstDayWeek1, lastDayOfYear;
        int y = year( date );
        int week;
        int weekDay1, dayOfWeek1InYear;

        // let's guess 1st day of 1st week
        setDate( firstDayWeek1, y, 1, 1 );
        weekDay1 = dayOfWeek( firstDayWeek1 );

        // iso 8601: week 1  is the first containing thursday and week starts on monday
        if ( weekDay1 > 4 /*Thursday*/ ) {
            firstDayWeek1 = addDays( firstDayWeek1 , daysInWeek( date ) - weekDay1 + 1 ); // next monday
        }

        dayOfWeek1InYear = dayOfYear( firstDayWeek1 );

        // our date in prev year's week
        if ( dayOfYear( date ) < dayOfWeek1InYear ) { 
            if ( yearNum ) {
                *yearNum = y - 1;
            }
            return weeksInYear( y - 1 );
        }

        // let's check if its last week belongs to next year
        d->setAnyDate( lastDayOfYear, y + 1, 1, 1 );
        lastDayOfYear = addDays( lastDayOfYear, -1 );
        // if our date is in last week && 1st week in next year has thursday
        if ( ( dayOfYear( date ) >= daysInYear( date ) - dayOfWeek( lastDayOfYear ) + 1 )
             && dayOfWeek( lastDayOfYear ) < 4 ) {
            if ( yearNum ) {
                * yearNum = y + 1;
            }
             week = 1;
        } else {
            // To calculate properly the number of weeks from day a to x let's make a day 1 of week
            if( weekDay1 < 5 ) {
                firstDayWeek1 = addDays( firstDayWeek1, -( weekDay1 - 1 ) );
            }

            week = firstDayWeek1.daysTo( date ) / daysInWeek( date ) + 1;
        }

        return week;
    }

    return -1;
}

void drawEditReminder()
{	
	char str[128];
	
	setFont(font_arial_11);
	
	if(isReverseDate())
		sprintf(str,"%s, %d %s, %d", l_days[dayOfWeek(curDay, curMonth, curYear)], curDay, l_months[curMonth-1], curYear);
	else
		sprintf(str,"%s, %s %d, %d", l_days[dayOfWeek(curDay, curMonth, curYear)], l_months[curMonth-1], curDay, curYear);
	
	setColor(genericTextColor);
	bg_dispString(13,20-2,str);
}

std::string Date::toString(const std::string& fmt) const
{
  int year;
  unsigned month;
  unsigned day;

  get(year, month, day);

  std::string str;

  enum {
    state_0,
    state_fmt
  } state = state_0;

  for (std::string::const_iterator it = fmt.begin(); it != fmt.end(); ++it)
  {
    switch (state)
    {
      case state_0:
        if (*it == '%')
          state = state_fmt;
        else
          str += *it;
        break;

      case state_fmt:
        switch (*it)
        {
          case 'Y': appendDn(str, 4, year); break;
          case 'y': appendDn(str, 2, year % 100); break;
          case 'm': appendDn(str, 2, month); break;
          case 'd': appendDn(str, 2, day); break;
          case 'w': appendDn(str, 1, dayOfWeek()); break;
          case 'W': { int dow = dayOfWeek(); appendDn(str, 1, dow == 0 ? 7 : dow); } break;
          default:
            str += '%';
        }

        if (*it != '%')
          state = state_0;
        break;
    }
  }

  if (state == state_fmt)
    str += '%';

  return str;
}

int ExtDate::weekNumber( int *yearNum ) const
{
	// the year and week number are those of the next Sunday.
	ExtDate a_date( jd() - dayOfWeek() + 7);
	*yearNum = a_date.year();
	return 1 + int( a_date.dayOfYear()/7 );
}

int getDayFromTouch(int tx, int ty)
{
	uint16 z = 1;	
	uint16 x = dayOfWeek(1,curMonth,curYear);
	uint16 y = 0;
	
	while(z <= daysInMonth(curMonth-1,curYear))
	{	
		if(tx > (x*31) && tx < 21+(x*31))
		{
			if(ty > (15*y) && ty < 13+(15*y))
				return z;
		}		
		
		x++;
		if(x > 6)
		{
			x = 0;
			y++;
		}
		
		z++;
	}
	
	return -1;
}

inline QString RecordingsModel::sectionName(const QDate &modDate)
{
    auto curDate = QDate::currentDate();
    auto days = modDate.daysTo(curDate);
    if (days == 0)
    {
        return tr("Today");
    }
    if (days == 1)
    {
        return tr("Yesterday");
    }
    if (days < 7 && modDate.dayOfWeek() < curDate.dayOfWeek())
    {
        return tr("This week");
    }
    if (days < curDate.daysInMonth() && modDate.day() < curDate.day())
    {
        return tr("This month");
    }
    if (days < 183)
    {
        return tr("Last 6 months");
    }
    return tr("Older");
}

void PrintGregDate( date_t dt )
{
   if (!noGreg_sw)
      {
	 if (gregDateOutputFormatCode_sw == GREG_DATEFORMAT_ISO){
	    printf ("%d-%02d-%02d", dt.yy,dt.mm, dt.dd);        /* YYYY-MM-DD */
	 }
	 else
	    {
	       if( gregDateOutputFormatCode_sw == GREG_DATEFORMAT_EURO)
		  printf ("%d.%d.", dt.dd, dt.mm);        /* dd/mm/yyyy */
	       else
		  printf ("%d/%d/", dt.mm, dt.dd);        /* mm/dd/yyyy */
	       
	       if (yearDigits_sw)
		  printf ("%d", dt.yy % 100);
	       else
		  printf ("%d", dt.yy);
	    }
	 
	 if (tabs_sw)
            putchar ('\t');
	 else
            putchar (' ');
    }
    
    if (weekday_sw)
        printf ("%s, ", ShortDayNames[dayOfWeek (dt)]);
}

// Offset from January 1st to Monday of the ISO 8601's first week.
//   ex. If January 1st is Friday, such Monday is 3 days later. Returns 3.
static int offsetTo1stWeekStart(int year)
{
    int offsetTo1stWeekStart = 1 - dayOfWeek(year, 0, 1);
    if (offsetTo1stWeekStart <= -4)
        offsetTo1stWeekStart += 7;
    return offsetTo1stWeekStart;
}

int main ()
{
	int day;
	scanf( "%d", & day );
	printf( "%s\n", dayOfWeek( day ) );
	return 0;
}          

int daysToNextThursday(int year, int month, int day){

  int e;
  e = yearToDoomsday(year);
  int f;
  f = isLeapYear(year);
  int A;
  A = dayOfWeek (e,f,month,day);

    if(A == 0){
        return 7;
    } else if(A == 1){ 
        return 6;
    } else if(A == 2){ 
        return 5;
    } else if(A == 3){ 
        return 4;
    } else if(A == 4){ 
        return 3;
    } else if(A == 5){
        return 2;
    } 
    //else if(yearToDoomsDay == 3){ 
    return 1;
}

int KCalendarSystemHebrew::weekNumber(const TQDate& date, int * yearNum) const
{
  TQDate firstDayWeek1, lastDayOfYear;
  int y = year(date);
  int week;
  int weekDay1, dayOfWeek1InYear;

  // let's guess 1st day of 1st week
  setYMD(firstDayWeek1, y, 1, 1);
  weekDay1 = dayOfWeek(firstDayWeek1);

  // iso 8601: week 1  is the first containing thursday and week starts on
  // monday
  if (weekDay1 > 4 /*Thursday*/)
    firstDayWeek1 = addDays(firstDayWeek1 , 7 - weekDay1 + 1); // next monday

  dayOfWeek1InYear = dayOfYear(firstDayWeek1);

  if ( dayOfYear(date) < dayOfWeek1InYear ) // our date in prev year's week
  {
    if ( yearNum )
      *yearNum = y - 1;
    return weeksInYear(y - 1);
  }

  // let's check if its last week belongs to next year
  setYMD(lastDayOfYear, y + 1, 1, 1);
  lastDayOfYear = addDays(lastDayOfYear, -1);
  if ( (dayOfYear(date) >= daysInYear(date) - dayOfWeek(lastDayOfYear) + 1)
       // our date is in last week
       && dayOfWeek(lastDayOfYear) < 4) // 1st week in next year has thursday
    {
      if ( yearNum )
        *yearNum = y + 1;
      week = 1;
    }
  else
  {
   if( weekDay1 < 5 ) // To calculate properly the number of weeks
                     //  from day a to x let's make a day 1 of week
      firstDayWeek1 = addDays( firstDayWeek1, -( weekDay1 - 1));

   week = firstDayWeek1.daysTo(date) / 7 + 1;
  }

  return week;
}

QString KCalendarSystem::weekDayName( const QDate &date, WeekDayNameFormat format ) const
{
    if ( isValid( date ) ) {
        return weekDayName( dayOfWeek( date ), format );
    }

    return QString();
}

 uint8_t TimeAlarmsClass::getDigitsNow( dtUnits_t Units)
 {
   time_t time = now();
   if(Units == dtSecond) return numberOfSeconds(time);
   if(Units == dtMinute) return numberOfMinutes(time); 
   if(Units == dtHour) return numberOfHours(time);
   if(Units == dtDay) return dayOfWeek(time);
   return 255;  // This should never happen 
 }

void CalendarDatePrivate::ComputeDays() {
    gint month = 1;
    gint year = 1970;
    gint ndays_in_month = 31;
    gint ndays_in_prevmonth = 31;
    gint first_day = 4;
    gint row = 0;
    gint col = 0;
    gint day = 1;

    year = m_selectedYear;
    month = m_selectedMonth;

    ndays_in_month = month_length[leap(year)][month];

    first_day = dayOfWeek(year, month, 1);
    first_day = (first_day + 7 - m_weekStart) % 7;
    if (0 == first_day) {
        first_day = 7;
    }

    if (1 < month) {
        ndays_in_prevmonth = month_length[leap(year)][month - 1];
    } else {
        ndays_in_prevmonth = month_length[leap(year - 1)][12];
    }

    day = ndays_in_prevmonth - first_day + 1;
    for (col = 0; col < first_day; ++col) {
        m_day[0][col] = day;
        m_dayMonth[0][col] = MONTH_PREV;
        ++day;
    }

    row = first_day / 7;
    col = first_day % 7;
    for (day = 1; day <= ndays_in_month; ++day) {
        m_day[row][col] = day;
        m_dayMonth[row][col] = MONTH_CURRENT;

        ++col;
        if (7 == col) {
            ++row;
            col = 0;
        }
    }

    day = 1;
    for (; row <= 5; ++row) {
        for (; col <= 6; ++col) {
            m_day[row][col] = day;
            m_dayMonth[row][col] = MONTH_NEXT;
            ++day;
        }
        col = 0;
    }
}

void checkKiniti(char *kiniti, int *mera, int *minas, char *onoma)
{
    if (kiniti[0] != '*')
    {
        if ((*mera == 11 && *minas == 12) || strcmp(onoma, "ΧΛΟΗ") == 0)
        {
            if (dayOfWeek(*mera, *minas, current_year) != 0)
            {
                *mera = *mera + (7-(dayOfWeek(*mera, *minas, current_year)));
            }
        }
        else
        {
            *mera = easter_day + atoi(kiniti);      /* Flawfinder: ignore */
            *minas = easter_month;
        }
        while (*mera < 0)
        {
            *mera += monthDays(*minas-1, current_year);
            *minas = *minas-1;
        }
        while (*mera > monthDays(*minas, current_year))
        {
            *mera -= monthDays(*minas, current_year);
            *minas = *minas+1;
        }
        if (strcmp(onoma, "ΓΕΩΡΓΙΑ") == 0 || strcmp(onoma, "ΓΕΩΡΓΙΟΣ") == 0)
        {
            if (easter_day < 24 && easter_month < 5)
            {
                *mera = 23;
                *minas = 4;
            }
        }
        if (strcmp(onoma, "ΜΑΡΚΟΣ") == 0)
        {
            if (easter_day < 24 && easter_month < 5)
            {
                *mera = 25;
                *minas = 4;
            }
        }
    }
}

  openstudio::Date RunPeriodControlSpecialDays_Impl::getDate(const std::string& text) const
  {
    Date result;
    YearDescription yd = this->model().getUniqueModelObject<YearDescription>();

    /*
     \note  <number>/<number>  (month/day)
     \note  <number> <Month>
     \note  <Month> <number>
     \note <Nth> <Weekday> in <Month)
     \note Last <WeekDay> in <Month>
     \note <Month> can be January, February, March, April, May, June, July, August, September, October, November, December
     \note Months can be the first 3 letters of the month
     \note <Weekday> can be Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday
     \note <Nth> can be 1 or 1st, 2 or 2nd, etc. up to 5(?)
    */
    boost::smatch matches;
    if (boost::regex_search(text, matches, boost::regex("(\\d+)\\s?\\/\\s?(\\d+)"))){

      std::string monthString(matches[1].first, matches[1].second);
      MonthOfYear monthOfYear(boost::lexical_cast<unsigned>(monthString));

      std::string dayOfMonthString(matches[2].first, matches[2].second);
      unsigned dayOfMonth = boost::lexical_cast<unsigned>(dayOfMonthString);

      result = yd.makeDate(monthOfYear, dayOfMonth);
      return result;
    }else if (boost::regex_search(text, matches, boost::regex("(\\d+)\\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)", boost::regex::icase))){
             
      std::string dayOfMonthString(matches[1].first, matches[1].second);
      unsigned dayOfMonth = boost::lexical_cast<unsigned>(dayOfMonthString);
      std::string monthString(matches[2].first, matches[2].second);

      result = yd.makeDate(monthOfYear(monthString), dayOfMonth);
      return result;
    }else if (boost::regex_search(text, matches, boost::regex("(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)\\s+(\\d+)", boost::regex::icase))){
          
      std::string monthString(matches[1].first, matches[1].second);
      std::string dayOfMonthString(matches[2].first, matches[2].second);
      unsigned dayOfMonth = boost::lexical_cast<unsigned>(dayOfMonthString);

      result = yd.makeDate(monthOfYear(monthString), dayOfMonth);
      return result;
    }else if (boost::regex_search(text, matches, boost::regex("(1|2|3|4|5|1st|2nd|3rd|4th|5th|Last)\\s+(Sun|Mon|Tue|Wed|Thu|Fri|Sat|Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday)\\s+in\\s+(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)", boost::regex::icase))){
               
      std::string nthString(matches[1].first, matches[1].second);
      std::string dayOfWeekString(matches[2].first, matches[2].second);
      std::string monthString(matches[3].first, matches[3].second);

      result = yd.makeDate(nthDayOfWeekInMonth(nthString), dayOfWeek(dayOfWeekString), monthOfYear(monthString));
      return result;
    }

    LOG_AND_THROW("Could not determine date for startDate = '" << text << "'");
    return Date();
  }

void DateTime::format(std::string& str, const std::string& fmt, int timeZoneDifferential)
{
    std::string::const_iterator it  = fmt.begin();
    std::string::const_iterator end = fmt.end();
    while (it != end)
    {
        if (*it == '%')
        {
            if (++it != end)
            {
                switch (*it)
                {
                case 'w': str.append(WEEKDAY_NAMES[dayOfWeek()], 0, 3); break;
                case 'W': str.append(WEEKDAY_NAMES[dayOfWeek()]); break;
                case 'b': str.append(MONTH_NAMES[month() - 1], 0, 3); break;
                case 'B': str.append(MONTH_NAMES[month() - 1]); break;
                case 'd': NumberFormatter::append0(str, (int32_t)day(), 2); break;
                case 'e': NumberFormatter::append(str, (int32_t)day()); break;
                case 'f': NumberFormatter::append(str, (int32_t)day(), 2); break;
                case 'm': NumberFormatter::append0(str, (int32_t)month(), 2); break;
                case 'n': NumberFormatter::append(str, (int32_t)month()); break;
                case 'o': NumberFormatter::append(str, (int32_t)month(), 2); break;
                case 'y': NumberFormatter::append0(str, (int32_t)year() % 100, 2); break;
                case 'Y': NumberFormatter::append0(str, (int32_t)year(), 4); break;
                case 'H': NumberFormatter::append0(str, (int32_t)hour(), 2); break;
                case 'h': NumberFormatter::append0(str, (int32_t)hourAMPM(), 2); break;
                case 'a': str.append(isAM() ? "am" : "pm"); break;
                case 'A': str.append(isAM() ? "AM" : "PM"); break;
                case 'M': NumberFormatter::append0(str, (int32_t)minute(), 2); break;
                case 'S': NumberFormatter::append0(str, (int32_t)second(), 2); break;
                case 'i': NumberFormatter::append0(str, (int32_t)millisecond(), 3); break;
                case 'c': NumberFormatter::append(str, (int32_t)millisecond()/100); break;
                case 'F': NumberFormatter::append0(str, (int32_t)millisecond()*1000 + microsecond(), 6); break;
                case 'z': tzdISO(str, timeZoneDifferential); break;
                case 'Z': tzdRFC(str, timeZoneDifferential); break;
                default:  str += *it;
                }
                ++it;
            }
        }
        else str += *it++;
    }
}

unsigned int CDateTime::weekOfYear(int year, unsigned int month, unsigned int day)
{
    if (!isValid(year, month, day))
    {
        return 0;
    }

    CDateTime d1(year, month, day);
    int a = dayOfWeek(year, month, day);
    d1.addDays(4 - a); // Jeudi de cette semaine

    int y1 = d1.getYear();

    CDateTime d2(y1, 1, 4);
    int b = dayOfWeek(y1, 1, 4);
    d2.addDays(1 - b); // Lundi de cette semaine

    int y2 = d2.getYear();

    if (y1 < y2)
    {
        unsigned int a1 = (isLeapYear(y1) ? 366 : 365) - dayOfYear(y1, d1.getMonth(), d1.getDay());
        unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay());

        return (1 + (a1 + a2) / 7);
    }
    else if (y1 > y2)
    {
        unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay());
        unsigned int a2 = (isLeapYear(y2) ? 366 : 365) - dayOfYear(y2, d2.getMonth(), d2.getDay());

        return (1 + (a1 + a2) / 7);
    }
    else
    {
        unsigned int a1 = dayOfYear(y1, d1.getMonth(), d1.getDay());
        unsigned int a2 = dayOfYear(y2, d2.getMonth(), d2.getDay());

        return (1 + (a2 > a1 ? a2 - a1 : a1 - a2) / 7);
    }
}

void resetScreen (void)
{
    system("clear");
    char day[10];
    Date *date = getDate(NULL);
    dayOfWeek(day, date);
    
    fprintf(stdout, "%sCalendario Spyridon%s          %s-%d/%d/%d\n%s", KBLU, KCYN, day, peekDateDay(date), peekDateMonth(date), peekDateYear(date), RESET);
    fprintf(stdout, "0-Voltar/Cancelar\n");
    
    free(date);
}