#include <stdio.h>

const char *ms[12] = {"janvier","fevrier","mars","avril","mai","juin","juillet","aout", "septembre","octobre","novembre","decembre"};
int md[12]={31,28,31,30,31,30, 31,31,30,31,30,31};

int anneeBis(int a)
{
	return (a%4==0&&a%100!=0) || a%400==0;
}
int nbJM(int m, int a) //nombre de jour par mois
{
	if(m == 1 && anneeBis(a))
		return 29;
	else 
		return md[m];
}

int main()
{
	char s[100];
	int jour, an, mois=-1;
	int i,j,c; //variables / indices pour les boucles

	
	scanf("%d%s%d", &jour, s,&an);
	for(i=0;i<12;i++)
	{
		for(j=0; s[j] && s[j] == ms[i][j]; j++) ;
			
		if(s[j] == ms[i][j])
			mois = i;
	}
	if(mois ==-1 || jour < 0 || jour > nbJM(mois, an))
	{
		printf("entree invalide\n");
		return 0;
	}
	
	
	
	c=0;
	printf("cb de jour dans le futur????\n");
	scanf("%d",&c);
	
	while(c)
	{
		jour = jour%nbJM(mois,an)+1;
		if(jour==1)
		{
			mois = (mois+1)%12;
			if(mois==0)
				an++;
		}
		c--;
	}
	
	printf("%d %s %d\n", jour,ms[mois],an); //affiche resultat
	
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <stdarg.h>
#include <math.h>

/* type bool */
typedef char bool;
#define true  1
#define false 0

/* Une date (contient un jour, un mois, et une année) */
typedef struct Date
{
    unsigned day; /* 1 - 28,29,30,31 selon le mois */
    unsigned month; /* 0 - 11 */
    unsigned year; /* 0 - beaucoup  */
} Date;

char const * monthsArray[] = {"janvier",
                              "fevrier",
                              "mars",
                              "avril",
                              "mai",
                              "juin",
                              "juillet",
                              "aout",
                              "septembre",
                              "octobre",
                              "novembre",
                              "decembre"};

/* Prototypes */
void clearBuffer(void); /* Vide stdin */

void secureInput(char const* text, char const* format, int count,...);
/* saisie sécurisée */

unsigned stringToMonth(char const* str); /* Permet d’obtenir le numéro
d’un mois à partir d’une chaîne de caractères */

bool isLeapYear(unsigned year); /* Renvoi true si l’année est
bissextile, sinon false */

unsigned nbOfDaysForMonth(unsigned month, unsigned year); /* Renvoi le
nombre de jours du mois « month » de l’année « year » */

void getDate(char const* text, Date* dt); /* Obtient une date depuis
stdin */

void dateOffset(Date* dt, int offset); /* Décale une date d’un
« offset » en jour(s) */

int main(void)
{
    Date dt;
    int offset;

    printf("Entrez une date.\n");
    getDate(">> ", &dt);

    printf("\nEntrez un décalage (en jour(s)).\n");
    secureInput(">> ", "%d", 1, &offset);

    dateOffset(&dt, offset);

    printf("\nOn est maintenant le %u %s %u !\n",
           dt.day,
           monthsArray[dt.month],
           dt.year);

    return EXIT_SUCCESS;
}

void clearBuffer(void)
{
    int c;

    do c = getchar();
    while (c != '\n' && c != EOF);
}

void secureInput(char const* text, char const* format, int count, ...)
{
    va_list ap;
    int ret;

    va_start(ap, count);

    do
    {
        if(text != NULL)
        {
            printf("%s", text);
            fflush(stdout);
        }
        ret = vscanf(format, ap);
        clearBuffer();

        if(feof(stdin))
        {
            fprintf(stderr, "\n\n\tEOF\n");
            exit(EXIT_FAILURE);
        }
    }
    while(ret != count);
}

unsigned stringToMonth(char const* str)
{
    unsigned month;

    for(month = 0u; month < 12u; ++month)
    {
        if(strcmp(str, monthsArray[month]) == 0)
            return month;
    }

    return UINT_MAX;
}

bool isLeapYear(unsigned year)
{
    /* Définition de Wikipédia */
    return (year % 4u == 0u && year % 100u != 0u)
        || (year % 400u == 0u);
}

unsigned nbOfDaysForMonth(unsigned month, unsigned year)
{
    if(month == 1u) /* 1 = Février */
        return isLeapYear(year) ? 29u : 28u;
    else if(month <= 6u) /* 6 = Juillet */
        return (month+1u) % 2u + 30u;
    else
        return month % 2u + 30u;
}

void getDate(char const* text, Date* dt)
{
    char buf[20];

    do
    {
        secureInput(text, "%u %19s %u", 3,
                    &dt->day, buf, &dt->year);
        dt->month = stringToMonth(buf);
    }
    while (dt->month == UINT_MAX
        || dt->day > nbOfDaysForMonth(dt->month, dt->year));
}

void dateOffset(Date* dt, int offset)
{
    int offsetForNewMonth;

    while(offset != 0)
    {
        if(offset > 0)
            offsetForNewMonth = nbOfDaysForMonth(dt->month, dt->year)
                                - dt->day + 1u;
        else
            offsetForNewMonth = -dt->day;

        if(abs(offsetForNewMonth) <= abs(offset)) /* change de mois */
        {
            offset -= offsetForNewMonth;
            if(offsetForNewMonth > 0)
            {
                ++dt->month;
                if(dt->month >= 12u)
                {
                    dt->month = 0u;
                    ++dt->year;
                }
                dt->day = 1u;
            }
            else
            {
                --dt->month;
                if(dt->month >= 12u) /* unsigned => -1 = UINT_MAX */
                {
                    dt->month = 11u;
                    --dt->year;
                }
                dt->day = nbOfDaysForMonth(dt->month, dt->year);
            }
        }
        else
        {
            dt->day += offset;
            offset = 0;
        }
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <ctype.h>

/* type bool */
typedef enum{false, true} bool;

/* X-macro */
#define X_MONTH \
            X(JANVIER), \
            X(FEVRIER), \
            X(MARS), \
            X(AVRIL), \
            X(MAI), \
            X(JUIN), \
            X(JUILLET), \
            X(AOUT), \
            X(SEPTEMBRE), \
            X(OCTOBRE), \
            X(NOVEMBRE), \
            X(DECEMBRE)

/* Énumération pour les mois */
#define X(month) month
typedef enum Month{X_MONTH, NB_MONTH} Month;
#undef X

/* Une date (contient un jour, un mois, et une année) */
typedef struct Date
{
    int day; /* 1 - 28,29,30,31 selon le mois */
    int year; /* 0 - beaucoup  */
    Month month; /* 0 - 11 */
} Date;

#define X(month) #month
char const * const monthsArray[] = {X_MONTH};
#undef X

/* Prototypes */
void clearBuffer(void); /* Vide stdin */

void secureInput(char const* text, char const* format, ...);
/* saisie sécurisée, le dernier argument doit être NULL */

Month stringToMonth(char const* str); /* Permet d’obtenir le numéro
d’un mois à partir d’une chaîne de caractères */

bool isLeapYear(int year); /* Renvoi true si l’année est
bissextile, sinon false */

int nbOfDaysForMonth(Month month, int year); /* Renvoi le
nombre de jours du mois « month » de l’année « year » */

void getDate(char const* text, Date* dt); /* Obtient une date depuis
stdin */

void addDateOffset(Date* dt, int offset); /* Ajoute un décalage à une
date */

void subtractDateOffset(Date* dt, int offset); /* Retire un décalage à
une date */

bool equalText(char const* str1, char const* str2); /* Indique si deux
chaînes de caractères sont egaux, en ignorant la casse */

int main(void)
{
    Date dt;
    int offset;

    printf("Entrez une date.\n");
    getDate(">> ", &dt);

    printf("\nEntrez un décalage (en jour(s)).\n");
    secureInput(">> ", "%d", &offset, NULL);

    addDateOffset(&dt, offset);

    printf("\nOn est maintenant le %d %s %d !\n",
           dt.day,
           monthsArray[dt.month],
           dt.year);

    return EXIT_SUCCESS;
}

void clearBuffer(void)
{
    int c;

    do
    {
        c = getchar();
    }
    while (c != '\n' && c != EOF);
}

void secureInput(char const* text, char const* format, ...)
{
    va_list ap;
    int ret, count;

    va_start(ap, format);
    for(count = 0; va_arg(ap, void*) != NULL; ++count);
    va_end(ap);

    do
    {
        if(text != NULL)
        {
            printf("%s", text);
            fflush(stdout);
        }
        va_start(ap, format);
        ret = vscanf(format, ap);
        va_end(ap);
        clearBuffer();

        if(feof(stdin))
        {
            fprintf(stderr, "\n\n\tEOF\n");
            exit(EXIT_FAILURE);
        }
    }
    while(ret != count);
}

Month stringToMonth(char const* str)
{
    Month month;

    for(month = JANVIER; month <= DECEMBRE; ++month)
    {
        if(equalText(str, monthsArray[month]))
            return month;
    }

    return NB_MONTH;
}

bool isLeapYear(int year)
{
    /* Définition de Wikipédia */
    return (year % 4 == 0 && year % 100 != 0)
        || (year % 400 == 0);
}

int nbOfDaysForMonth(Month month, int year)
{
    if(month == FEVRIER)
        return isLeapYear(year) ? 29 : 28;
    else if(month <= JUILLET)
        return (month+1) % 2 + 30;
    else
        return month % 2 + 30;
}

void getDate(char const* text, Date* dt)
{
    char buf[20];

    do
    {
        secureInput(text, "%d %19s %d",
                    &dt->day, buf, &dt->year, NULL);
        dt->month = stringToMonth(buf);
    }
    while (dt->month == NB_MONTH
        || dt->year < 0
        || dt->day < 0
        || dt->day > nbOfDaysForMonth(dt->month, dt->year));
}

void addDateOffset(Date* dt, int offset)
{
    int offsetForNewMonth;

    if(offset < 0)
    {
        subtractDateOffset(dt, -offset);
        return;
    }

    while(offset > 0)
    {
        offsetForNewMonth = nbOfDaysForMonth(dt->month, dt->year)
                            - dt->day + 1;

        if(offsetForNewMonth <= offset) /* change de mois */
        {
            offset -= offsetForNewMonth;
            ++dt->month;
            if(dt->month > DECEMBRE)
            {
                dt->month = JANVIER;
                ++dt->year;
            }
            dt->day = 1;
        }
        else
        {
            dt->day += offset;
            offset = 0;
        }
    }
}

void subtractDateOffset(Date* dt, int offset)
{
    int offsetForNewMonth;

    if(offset < 0)
    {
        subtractDateOffset(dt, -offset);
        return;
    }
    else
        offset = -offset;

    while(offset < 0)
    {
        offsetForNewMonth = -dt->day;

        if(offsetForNewMonth >= offset) /* change de mois */
        {
            offset -= offsetForNewMonth;
            --dt->month;
            /* unsigned, -1 = UINT_MAX */
            if(dt->month > DECEMBRE)
            {
                dt->month = DECEMBRE;
                --dt->year;
            }
            dt->day = nbOfDaysForMonth(dt->month, dt->year);
        }
        else
        {
            dt->day += offset;
            offset = 0;
        }
    }
}

bool equalText(char const* str1, char const* str2)
{
    for(; *str1 != '\0' && *str2 != '\0'; ++str1, ++str2)
    {
        if(toupper(*str1) != toupper(*str2))
            return false;
    }
    return (*str1 == '\0' && *str2 == '\0');
}