Language: C++

//#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <queue>
#include <algorithm>
#include <sstream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cctype>
#include <cstdlib>      // srand,rand


using namespace std;
#define ll long long

#define modd 1000000007
#define INF 1000000000000000000ll


typedef pair<long long, long long> pl;



typedef string::const_iterator State;
class ParseError {};








class UnionFind {
public:
	vector <ll> par;
	vector <ll> siz;

	// Constructor
	UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
		for (ll i = 0; i < sz_; ++i) par[i] = i;
	}
	void init(ll sz_) {
		par.resize(sz_);
		siz.assign(sz_, 1LL);  // resize だとなぜか初期化されなかった
		for (ll i = 0; i < sz_; ++i) par[i] = i; // 初期では親は自分自身
	}

	// Member Function
	// Find
	ll root(ll x) { // 根の検索
		while (par[x] != x) {
			x = par[x] = par[par[x]]; // x の親の親を x の親とする
		}
		return x;
	}

	// Union(Unite, Merge)
	bool merge(ll x, ll y) {
		x = root(x);
		y = root(y);
		if (x == y) return false;

		// merge technique（データ構造をマージするテク．小を大にくっつける）
		if (siz[x] < siz[y]) swap(x, y);
		siz[x] += siz[y];
		par[y] = x;
		return true;
	}



	bool issame(ll x, ll y) { // 連結判定
		return root(x) == root(y);
	}

	ll size(ll x) { // 素集合のサイズ
		return siz[root(x)];
	}


};

/*
struct SegmentTree {
private:
	ll n;
	vector<ll> node;

public:
	// 元配列 v をセグメント木で表現する
	SegmentTree(vector<ll> v) {
		// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 -> これを n とおく
		// セグメント木全体で必要なノード数は 2n-1 個である
		ll sz = v.size();
		n = 1; while (n < sz) n *= 2;
		node.resize(2 * n - 1, INF);

		// 最下段に値を入れたあとに、下の段から順番に値を入れる
		// 値を入れるには、自分の子の 2 値を参照すれば良い
		for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
		for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1], node[2 * i + 2]);
	}


	void update(ll x, ll val) {
		// 最下段のノードにアクセスする
		x += (n - 1);

		// 最下段のノードを更新したら、あとは親に上って更新していく
		node[x] = val;
		while (x > 0) {
			x = (x - 1) / 2;
			node[x] = min(node[2 * x + 1], node[2 * x + 2]);
		}
	}

};
*/


ll N, M, K, a, b, c, d, e, H, W, L, T;
ll x, y;
ll A[2000004] = {};
ll B[2000004] = {};
ll C[2000004] = {};
ll D[1000006] = {};
ll E[1000006] = {};
bool f, ff;
string S[200000];
string SS;
set <long long>sll;
pl bufpl;
vector <long long>vl[300005];
vector <long long>vll;
vector <pl>vpl;
vector <string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
multiset<pl> plmset;


struct ST
{
	ll first;
	ll second;
	ll kaisuu;


	/*bool operator<(const ST& another) const
	{
		return first < another.first;//比較
	};*/

};
queue<ST> qpl;



/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/

/*
long long modinv(long long aa, long long mm) {
	long long bb = mm, uu = 1, vv = 0;
	while (bb) {
		long long tt = aa / bb;
		aa -= tt * bb; swap(aa, bb);
		uu -= tt * vv; swap(uu, vv);
	}
	uu %= mm;
	if (uu < 0) uu += mm;
	return uu;
}


*/


ll zettai(ll aa) {

	if (aa < 0) {
		aa *= -1;
	}
	return aa;

}





/*
struct edge {
	ll from;
	ll to;
	ll cost;
};



ll V, E, d[300000];
edge es[300000];
bool fa[5000][5000];
bool ffa[5000];

bool has_negative_loop(ll s) {
	fill(d, d + V, 50000000000000000);
	d[s] = 0;
	for (ll i = 0; i <=2* V+1; i++) {
		for (ll j = 0; j < E; j++) {
			edge e = es[j];
			if (d[(int)e.to] > d[(int)e.from] + e.cost) {
				d[(int)e.to] = d[(int)e.from] + e.cost;
				if (i >= V+1 && fa[(int)e.to][V-1]==true &&fa[0][(int)e.from] == true) {
					return true;
				}
			}
		}
	}
	return false;
}
*/

/*struct cww { cww() { ios::sync_with_stdio(false); cin.tie(0); } }star;


bool is_prime[1000000 + 1];
vector<int> P;
void Eratosthenes(const int N)
{
	for (int i = 0; i <= N; i++)
	{
		is_prime[i] = true;//初期化
	}
	for (int i = 2; i <= N; i++)
	{
		if (is_prime[i])
		{
			for (int j = 2 * i; j <= N; j += i)
			{
				is_prime[j] = false;
			}
			P.emplace_back(i);
		}
	}
}*/

ll t;

ll RepeatSquaring(ll N, ll P, ll MO) {
	if (P == 0) return 1;
	if (P % 2 == 0) {
		ll t = RepeatSquaring(N, P / 2, MO);
		return t * t % MO;
	}
	return N * RepeatSquaring(N, P - 1, MO);
}

ll gyakugen(ll numb, ll MO) {
	return RepeatSquaring(numb, MO - 2, MO);
}

/*
ll Com(ll NN, ll KK) {
	e = D[NN];
	e *= C[KK];
	e %= modd;
	e *= C[NN - KK];
	e %= modd;
	return e;

}

*/



double an;

int main() {

	cin >> N >> a >> b;

	for (int i = 0; i < N; i++) {
		cin >> A[i];
		vll.push_back(A[i]);
	}

	sort(vll.begin(), vll.end());
	reverse(vll.begin(), vll.end());

	for (int i = 0; i < a; i++) {
		an += (double)vll[i];
		x = vll[i];
	}
	an /= (double)a;
	d = -1;

	for (int i = 0; i < N; i++) {
		if(vll[i]==x){
			c++;
			if (d == -1) {
				d = i;
				H = c;
			}
		}
		
	}

	e = min(c, b - d);

	y = 1;

	for (int j = H; j <= e; j++) {
		y = 1;
		for (int i = 0; i < j; i++) {
			y *= (c - i);
			y /= (i + 1);
		}
		W += y;
	}

	cout << fixed << setprecision(10) << an << endl;
	cout << W << endl;


	//cout << fixed << setprecision(10) << ansa << endl;
	return 0;




}
//#pragma once
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <queue>
#include <algorithm>
#include <sstream>
#include <vector>
#include <math.h>
#include <set>
#include <map>
#include <numeric>
#include <bitset>
#include <iomanip>
#include <cctype>
#include <cstdlib>      // srand,rand


using namespace std;
#define ll long long

#define modd 1000000007
#define INF 1000000000000000000ll


typedef pair<long long, long long> pl;



typedef string::const_iterator State;
class ParseError {};








class UnionFind {
public:
	vector <ll> par;
	vector <ll> siz;

	// Constructor
	UnionFind(ll sz_) : par(sz_), siz(sz_, 1LL) {
		for (ll i = 0; i < sz_; ++i) par[i] = i;
	}
	void init(ll sz_) {
		par.resize(sz_);
		siz.assign(sz_, 1LL);  // resize だとなぜか初期化されなかった
		for (ll i = 0; i < sz_; ++i) par[i] = i; // 初期では親は自分自身
	}

	// Member Function
	// Find
	ll root(ll x) { // 根の検索
		while (par[x] != x) {
			x = par[x] = par[par[x]]; // x の親の親を x の親とする
		}
		return x;
	}

	// Union(Unite, Merge)
	bool merge(ll x, ll y) {
		x = root(x);
		y = root(y);
		if (x == y) return false;

		// merge technique（データ構造をマージするテク．小を大にくっつける）
		if (siz[x] < siz[y]) swap(x, y);
		siz[x] += siz[y];
		par[y] = x;
		return true;
	}



	bool issame(ll x, ll y) { // 連結判定
		return root(x) == root(y);
	}

	ll size(ll x) { // 素集合のサイズ
		return siz[root(x)];
	}


};

/*
struct SegmentTree {
private:
	ll n;
	vector<ll> node;

public:
	// 元配列 v をセグメント木で表現する
	SegmentTree(vector<ll> v) {
		// 最下段のノード数は元配列のサイズ以上になる最小の 2 冪 -> これを n とおく
		// セグメント木全体で必要なノード数は 2n-1 個である
		ll sz = v.size();
		n = 1; while (n < sz) n *= 2;
		node.resize(2 * n - 1, INF);

		// 最下段に値を入れたあとに、下の段から順番に値を入れる
		// 値を入れるには、自分の子の 2 値を参照すれば良い
		for (ll i = 0; i < sz; i++) node[i + n - 1] = v[i];
		for (ll i = n - 2; i >= 0; i--) node[i] = min(node[2 * i + 1], node[2 * i + 2]);
	}


	void update(ll x, ll val) {
		// 最下段のノードにアクセスする
		x += (n - 1);

		// 最下段のノードを更新したら、あとは親に上って更新していく
		node[x] = val;
		while (x > 0) {
			x = (x - 1) / 2;
			node[x] = min(node[2 * x + 1], node[2 * x + 2]);
		}
	}

};
*/


ll N, M, K, a, b, c, d, e, H, W, L, T;
ll x, y;
ll A[2000004] = {};
ll B[2000004] = {};
ll C[2000004] = {};
ll D[1000006] = {};
ll E[1000006] = {};
bool f, ff;
string S[200000];
string SS;
set <long long>sll;
pl bufpl;
vector <long long>vl[300005];
vector <long long>vll;
vector <pl>vpl;
vector <string> vs;
set<ll> llset;
multiset<ll> llmset;
queue<ll> ql;
multiset<pl> plmset;


struct ST
{
	ll first;
	ll second;
	ll kaisuu;


	/*bool operator<(const ST& another) const
	{
		return first < another.first;//比較
	};*/

};
queue<ST> qpl;



/*vector <ST> vst;
ST st[200005];
ST bufst;
bitset<5000> bits;*/

/*
long long modinv(long long aa, long long mm) {
	long long bb = mm, uu = 1, vv = 0;
	while (bb) {
		long long tt = aa / bb;
		aa -= tt * bb; swap(aa, bb);
		uu -= tt * vv; swap(uu, vv);
	}
	uu %= mm;
	if (uu < 0) uu += mm;
	return uu;
}


*/


ll zettai(ll aa) {

	if (aa < 0) {
		aa *= -1;
	}
	return aa;

}





/*
struct edge {
	ll from;
	ll to;
	ll cost;
};



ll V, E, d[300000];
edge es[300000];
bool fa[5000][5000];
bool ffa[5000];

bool has_negative_loop(ll s) {
	fill(d, d + V, 50000000000000000);
	d[s] = 0;
	for (ll i = 0; i <=2* V+1; i++) {
		for (ll j = 0; j < E; j++) {
			edge e = es[j];
			if (d[(int)e.to] > d[(int)e.from] + e.cost) {
				d[(int)e.to] = d[(int)e.from] + e.cost;
				if (i >= V+1 && fa[(int)e.to][V-1]==true &&fa[0][(int)e.from] == true) {
					return true;
				}
			}
		}
	}
	return false;
}
*/

/*struct cww { cww() { ios::sync_with_stdio(false); cin.tie(0); } }star;


bool is_prime[1000000 + 1];
vector<int> P;
void Eratosthenes(const int N)
{
	for (int i = 0; i <= N; i++)
	{
		is_prime[i] = true;//初期化
	}
	for (int i = 2; i <= N; i++)
	{
		if (is_prime[i])
		{
			for (int j = 2 * i; j <= N; j += i)
			{
				is_prime[j] = false;
			}
			P.emplace_back(i);
		}
	}
}*/

ll t;

ll RepeatSquaring(ll N, ll P, ll MO) {
	if (P == 0) return 1;
	if (P % 2 == 0) {
		ll t = RepeatSquaring(N, P / 2, MO);
		return t * t % MO;
	}
	return N * RepeatSquaring(N, P - 1, MO);
}

ll gyakugen(ll numb, ll MO) {
	return RepeatSquaring(numb, MO - 2, MO);
}

/*
ll Com(ll NN, ll KK) {
	e = D[NN];
	e *= C[KK];
	e %= modd;
	e *= C[NN - KK];
	e %= modd;
	return e;

}

*/



double an;

int main() {

	cin >> N >> a >> b;

	for (int i = 0; i < N; i++) {
		cin >> A[i];
		vll.push_back(A[i]);
	}

	sort(vll.begin(), vll.end());
	reverse(vll.begin(), vll.end());

	for (int i = 0; i < a; i++) {
		an += (double)vll[i];
		x = vll[i];
	}
	an /= (double)a;
	d = -1;

	for (int i = 0; i < N; i++) {
		if(vll[i]==x){
			c++;
			if (d == -1) {
				d = i;
				H = c;
			}
		}
		
	}

	e = min(c, b - d);

	y = 1;

	for (int j = H; j <= e; j++) {
		y = 1;
		for (int i = 0; i < j; i++) {
			y *= (c - i);
			y /= (i + 1);
		}
		W += y;
	}

	cout << fixed << setprecision(10) << an << endl;
	cout << W << endl;


	//cout << fixed << setprecision(10) << ansa << endl;
	return 0;




}


Compiler output:
a.cc:376:7: error: redefinition of 'class ParseError'
  376 | class ParseError {};
      |       ^~~~~~~~~~
a.cc:32:7: note: previous definition of 'class ParseError'
   32 | class ParseError {};
      |       ^~~~~~~~~~
a.cc:385:7: error: redefinition of 'class UnionFind'
  385 | class UnionFind {
      |       ^~~~~~~~~
a.cc:41:7: note: previous definition of 'class UnionFind'
   41 | class UnionFind {
      |       ^~~~~~~~~
a.cc:473:4: error: redefinition of 'long long int N'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |    ^
a.cc:129:4: note: 'long long int N' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |    ^
a.cc:473:7: error: redefinition of 'long long int M'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |       ^
a.cc:129:7: note: 'long long int M' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |       ^
a.cc:473:10: error: redefinition of 'long long int K'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |          ^
a.cc:129:10: note: 'long long int K' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |          ^
a.cc:473:13: error: redefinition of 'long long int a'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |             ^
a.cc:129:13: note: 'long long int a' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |             ^
a.cc:473:16: error: redefinition of 'long long int b'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                ^
a.cc:129:16: note: 'long long int b' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                ^
a.cc:473:19: error: redefinition of 'long long int c'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                   ^
a.cc:129:19: note: 'long long int c' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                   ^
a.cc:473:22: error: redefinition of 'long long int d'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                      ^
a.cc:129:22: note: 'long long int d' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                      ^
a.cc:473:25: error: redefinition of 'long long int e'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                         ^
a.cc:129:25: note: 'long long int e' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                         ^
a.cc:473:28: error: redefinition of 'long long int H'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                            ^
a.cc:129:28: note: 'long long int H' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                            ^
a.cc:473:31: error: redefinition of 'long long int W'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                               ^
a.cc:129:31: note: 'long long int W' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                               ^
a.cc:473:34: error: redefinition of 'long long int L'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                                  ^
a.cc:129:34: note: 'long long int L' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                                  ^
a.cc:473:37: error: redefinition of 'long long int T'
  473 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                                     ^
a.cc:129:37: note: 'long long int T' previously declared here
  129 | ll N, M, K, a, b, c, d, e, H, W, L, T;
      |                                     ^
a.cc:474:4: error: redefinition of 'long long int x'
  474 | ll x, y;
      |    ^
a.cc:130:4: note: 'long long int x' previously declared here
  130 | ll x, y;
      |    ^
a.cc:474:7: error: redefinition of 'long long int y'
  474 | ll x, y;
      |       ^
a.cc:130:7: note: 'long long int y' previously declared here
  130 | ll x, y;
      |       ^
a.cc:475:4: error: redefinition of 'long long int A [2000004]'
  475 | ll A[2000004] = {};
      |    ^
a.cc:131:4: note: 'long long int A [2000004]' previously defined here
  131 | ll A[2000004] = {};
      |    ^
a.cc:476:4: error: redefinition of 'long long int B [2000004]'
  476 | ll B[2000004] = {};
      |    ^
a.cc:132:4: note: 'long long int B [2000004]' previously defined here
  132 | ll B[2000004] = {};
      |    ^
a.cc:477:4: error: redefinition of 'long long int C [2000004]'
  477 | ll C[2000004] = {};
      |    ^
a.cc:133:4: note: 'long long int C [2000004]' previously defined here
  133 | ll C[2000004] = {};
      |    ^
a.cc:478:4: error: redefinition of 'long long int D [1000006]'
  478 | ll D[1000006] = {};
      |    ^
a.cc:134:4: note: 'long long int D [1000006]' previously defined here
  134 | ll D[1000006] = {};
      |    ^
a.cc:479:4: error: redefinition of 'long long int E [1000006]'
  479 | ll E[1000006] = {};
      |    ^
a.cc:135:4: note: 'long long int E [1000006]' previously defined here
  135 | ll E[1000006] = {};
      |    ^
a.cc:480:6: error: redefinition of 'bool f'
  480 | bool f, ff;
      |      ^
a.cc:136:6: note: 'bool f' previously declared here
  136 | bool f, ff;
      |      ^
a.cc:480:9: error: redefinition of 'bool ff'
  480 | bool f, ff;
      |         ^~
a.cc:136:9: note: 'bool ff' previously declared here
  136 | bool f, ff;
      |         ^~
a.cc:481:8: error: redefinition of 'std::string S [200000]'
  481 | string S[200000];
      |        ^
a.cc:137:8: note: 'std::string S [200000]' previously declared here
  137 | string S[200000];
      |        ^
a.cc:482:8: error: redefinition of 'std::string SS'
  482 | string SS;
      |        ^~
a.cc:138:8: note: 'std::string SS' previously declared here
  138 | string SS;
      |        ^~
a.cc:483:16: error: redefinition of 'std::set<long long int> sll'
  483 | set <long long>sll;
      |                ^~~
a.cc:139:16: note: 'std::set<long long int> sll' previously declared here
  139 | set <long long>sll;
      |                ^~~
a.cc:484:4: error: redefinition of 'pl bufpl'
  484 | pl bufpl;
      |    ^~~~~
a.cc:140:4: note: 'pl bufpl' previously defined here
  140 | pl bufpl;
      |    ^~~~~
a.cc:485:19: error: redefinition of 'std::vector<long long int> vl [300005]'
  485 | vector <long long>vl[300005];
      |                   ^~
a.cc:141:19: note: 'std::vector<long long int> vl [300005]' previously declared here
  141 | vector <long long>vl[300005];
      |                   ^~
a.cc:486:19: error: redefinition of 'std::vector<long long int> vll'
  486 | vector <long long>vll;
      |                   ^~~
a.cc:142:19: note: 'std::vector<long long int> vll' previously declared here
  142 | vector <long long>vll;
      |                   ^~~
a.cc:487:12: error: redefinition of 'std::vector<std::pair<long long int, long long int> > vpl'
  487 | vector <pl>vpl;
      |            ^~~
a.cc:143:12: note: 'std::vector<std::pair<long long int, long long int> > vpl' previously declared here
  143 | vector <pl>vpl;
      |            ^~~
a.cc:488:17: error: redefinition of 'std::vector<std::__cxx11::basic_string<char> > vs'
  488 | vector <string> vs;
      |                 ^~
a.cc:144:17: note: 'std::vector<std::__cxx11::basic_string<char> > vs' previously declared here
  144 | vector <string> vs;
      |                 ^~
a.cc:489:9: error: redefinition of 'std::set<long long int> llset'
  489 | set<ll> llset;
      |         ^~~~~
a.cc:145:9: note: 'std::set<long long int> llset' previously declared here
  145 | set<ll> llset;
      |         ^~~~~
a.cc:490:14: error: redefinition of 'std::multiset<long long int> llmset'
  490 | multiset<ll> llmset;
      |              ^~~~~~
a.cc:146:14: note: 'std::multiset<long long int> llmset' previously declared here
  146 | multiset<ll> llmset;
      |              ^~~~~~
a.cc:491:11: error: redefinition of 'std::queue<long long int> ql'
  491 | queue<ll> ql;
      |           ^~
a.cc:147:11: note: 'std::queue<long long int> ql' previously declared here
  147 | queue<ll> ql;
      |           ^~
a.cc:492:14: error: redefinition of 'std::multiset<std::pair<long long int, long long int> > plmset'
  492 | multiset<pl> plmset;
      |              ^~~~~~
a.cc:148:14: note: 'std::multiset<std::pair<long long int, long long int> > plmset' previously declared here
  148 | multiset<pl> plmset;
      |              ^~~~~~
a.cc:495:8: error: redefinition of 'struct ST'
  495 | struct ST
      |        ^~
a.cc:151:8: note: previous definition of 'struct ST'
  151 | struct ST
      |        ^~
a.cc:508:11: error: redefinition of 'std::queue<ST> qpl'
  508 | queue<ST> qpl;
      |           ^~~
a.cc:164:11: note: 'std::queue<ST> qpl' previously declared here
  164 | queue<ST> qpl;
      |           ^~~
a.cc:534:4: error: redefinition of 'long long int zettai(long long int)'
  534 | ll zettai(ll aa) {
      |    ^~~~~~
a.cc:190:4: note: 'long long int zettai(long long int)' previously defined here
  190 | ll zettai(ll aa) {
      |    ^~~~~~
a.cc:603:4: error: redefinition of 'long long int t'
  603 | ll t;
      |    ^
a.cc:259:4: note: 'long long int t' previously declared here
  259 | ll t;
      |    ^
a.cc:605:4: error: redefinition of 'long long int RepeatSquaring(long long int, long long int, long long int)'
  605 | ll RepeatSquaring(ll N, ll P, ll MO) {
      |    ^~~~~~~~~~~~~~
a.cc:261:4: note: 'long long int RepeatSquaring(long long int, long long int, long long int)' previously defined here
  261 | ll RepeatSquaring(ll N, ll P, ll MO) {
      |    ^~~~~~~~~~~~~~
a.cc:614:4: error: redefinition of 'long long int gyakugen(long long int, long long int)'
  614 | ll gyakugen(ll numb, ll MO) {
      |    ^~~~~~~~
a.cc:270:4: note: 'long long int gyakugen(long long int, long long int)' previously defined here
  270 | ll gyakugen(ll numb, ll MO) {
      |    ^~~~~~~~
a.cc:633:8: error: redefinition of 'double an'
  633 | double an;
      |        ^~
a.cc:289:8: note: 'double an' previously declared here
  289 | double an;
      |        ^~
a.cc:635:5: error: redefinition of 'int main()'
  635 | int main() {
      |     ^~~~
a.cc:291:5: note: 'int main()' previously defined here