#include <iostream>
#include <string>
#include <vector>
#include <functional> // std::function
#include <algorithm>  // std::count

// 作りかけの validation 用ライブラリ
namespace validate {
	using LL = long long int;
	using CC = std::function<bool(char)>;
	using S  = std::string;
	
	namespace char_class {
		bool upper(char c) { return ('A' <= c && c <= 'Z'); }
		bool lower(char c) { return ('a' <= c && c <= 'z'); }
		bool digit(char c) { return ('0' <= c && c <= '9'); }
		bool alpha(char c) { return (upper(c) || lower(c)); }
		bool alnum(char c) { return (alpha(c) || digit(c)); }
		bool digit_or_minus(char c) { return (digit(c) || c == '-'); }
		CC of(S const & s) {
			return [&](char c) { return (std::count(s.begin(), s.end(), c) > 0); };
		}
	}
	
	namespace internal {
		bool is_end = false;
		S input_while(CC ok) {
			S s;
			while(true) {
				char c = std::cin.get();
				if(ok(c)) { s += c; } else { std::cin.unget(); break; }
			}
			return s;
		}
		bool is_positive_integer(S const & s) {
			if(s == "" || s[0] == '0') { return false; }
			for(char c: s) { if(! char_class::digit(c)) { return false; } }
			return true;
		}
		bool is_integer(S const & s) {
			if(s == "") { return false; }
			if(s == "0") { return true; }
			return is_positive_integer(s.substr(s[0] == '-' ? 1 : 0));
		}
	}
	
	S tag_def = "[?]";
	S tag_sep = " --> ";
	void check(bool p, S tag = tag_def) {
		if(! p) {
			std::cerr << "[!] Validation error: " << tag << std::endl;
			internal::is_end = true;
			exit(1);
		}
	}
	void input_equal(S s, S tag = tag_def) {
		tag += tag_sep + __func__;
		for(char c: s) { check(std::cin.get() == c, tag); }
	}
	LL get_int(LL mi, LL ma, S term, S tag = tag_def) {
		tag += tag_sep + __func__;
		auto s = internal::input_while(char_class::digit_or_minus);
		check(internal::is_integer(s), tag + " (is_integer)");
		LL n = stoll(s);
		check(mi <= n && n <= ma, tag + " (range)");
		input_equal(term, tag + " (term)");
		return n;
	}
	std::vector<LL> get_vector_int(int n, LL mi, LL ma, S sep, S term, S tag = tag_def) {
		tag += tag_sep + __func__;
		check(0 <= n, tag + " (n: non-negative)");
		std::vector<LL> v;
		while(static_cast<int>(v.size()) < n) {
			auto tag_i = tag + " ([" + std::to_string(v.size()) + "])";
			v.push_back(get_int(mi, ma, "", tag_i));
			if(static_cast<int>(v.size()) < n) { input_equal(sep, tag_i + " (sep)"); }
		}
		input_equal(term, tag + " (term)");
		return v;
	}
	S get_string(int n, CC ok, S term, S tag = tag_def) {
		tag += tag_sep + __func__ + " by length";
		check(0 <= n, tag + " (n: non-negative)");
		S s;
		while(static_cast<int>(s.size()) < n) {
			s += std::cin.get();
			check(ok(s.back()), tag + " (char_class)");
		}
		input_equal(term, tag + " (term)");
		return s;
	}
	S get_string(CC ok, int mi, int ma, S term, S tag = tag_def) {
		tag += tag_sep + __func__ + " by char_class";
		auto s = internal::input_while(ok);
		check(mi <= static_cast<int>(s.size()) && static_cast<int>(s.size()) <= ma, tag + " (length)");
		input_equal(term, tag + " (term)");
		return s;
	}
	void input_end(S tag = tag_def) {
		tag += tag_sep + __func__;
		input_equal({ EOF }, tag);
		internal::is_end = true;
	}
	
	namespace internal {
		struct End { ~ End() { check(is_end, "Missing validate::input_end()."); } } end_;
	}
}

// ----

int main() {
	auto Y = validate::get_int(2000, 3000 - 1, " ");
	auto N = validate::get_int(1, 365, " ");
	auto D = validate::get_int(1, 365, "\n");
	validate::input_end();
	
	auto c = [](int y) -> int { return 365 + (y % 4 != 0 || (y % 100 == 0 && y % 400 != 0) ? 0 : 1); };
	if(D > 333) { D += c(Y - 12) - c(Y + 1); }
	int mi = N - std::min(N, D), ma = std::min(N, c(Y - 12) - D);
	validate::check(0 <= mi && mi <= ma && ma <= N);
	std::cout << mi << " " << ma << std::endl;
}
// validation