Problem:
素数の性質
4 で割ると 3 あまる素数
n
(11、19、23 など) には、面白い性質があります。1 以上
n
未満の自然数 (1, 2,... ,
n
- 1) を 2 乗したものを
n
で割ったあまりを計算した結果を並べると、同じ数になるものがあるため、互いに異なった数の個数は、(
n
- 1)/2 になります。
この様にして得られた数の集合には、特別な性質があります。得られた数の集合から、互いに異なる 2 つ
a
と
b
を選んでその差を計算します。差が負になったときは、その差に
n
を足します。さらに結果が (
n
- 1)/2 より大きいときは、その差を
n
から引きます。
例えば、
n = 11
のとき 1 と 9 の差は、
1 − 9 = −8
→
−8 + n = −8 + 11 = 3
になります。9 と 1 の差も
9 −1 = 8
→
n − 8 = 11 − 8 = 3
で、同じ値 3 になります。この差は、円周上に 0, 1, ・・・,
n
- 1 を書いて、二つの数字の間の短い方の円弧を考えるとわかりやすくなります。(下図参照)
こうして得られた数の「差」は、1, 2, . . ., (
n
- 1)/2 のいずれかであり、同じ回数出現します。
【例】
n = 11
の時は、以下のようになります。
1 から
n
-1 までの数を 2 乗したものを
n
で割った余りを計算します。
1
2
=    1   →   1
 2
2
=    4   →   4
 3
2
=    9   →   9
 4
2
=   16   →   5
 5
2
=   25   →   3
 6
2
=   36   →   3
 7
2
=   49   →   5
 8
2
=   64   →   9
 9
2
=   81   →   4
10
2
=  100   →   1
a
,
b
の「差」の計算
1 で得られた 1, 3, 4, 5, 9 について異なる数同士の差を計算します。
計算結果が負の場合、
n
= 11 を加算します。
さらに、計算結果が  (
n
-1)/2 = 5 より大きい場合
n
= 11 から減算します。
出現回数を求める
計算結果 1, 2, 3, 4, 5 の出現回数をそれぞれ数え上げます。
これらの計算結果から 1, 2, 3, 4, 5 の出現回数が 4 回であることがわかります。この性質は 4 で割ると 3 あまる素数特有の性質であり 4 で割ると 1 あまる素数ではこのようなことはおきません。このことを確認するため、10000 以下の奇数
n
を入力とし、例題にあるような計算 (
n
で割ったあまりの 2 乗の差の頻度を求める)を実行し、その出現回数を出力するプログラムを作成してください。
Input
複数のデータセットが与えられます。各データセットとして１つの整数
n
(
n
≤ 10000) が１行に与えられます。入力は 0 を１つ含む行でおわります。
Output
各データセットについて、出現頻度を以下の形式で出力してください。
剰余の平方の差が 1 である(
a, b
)の出現個数(整数)
剰余の平方の差が 2 である(
a, b
)の出現個数(整数)
   :
   :
剰余の平方の差が (
n
-1)/2 である(
a, b
)の出現個数(整数)
Sample Input
11
15
0
Output for the Sample Input
4
4
4
4
4
2
2
4
2
4
4
2

Submitted solutions:

code_snippet: #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll myRand(ll B) { return (ull)rng() % B; }

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    while (cin >> n, n) {
        int m = (n+1)/2;
        vector<int> res(m);
        vector<int> v;
        for (int i = 1; i < n; ++i) {
            v.push_back(i*i%n);
        }
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        for (int i : v) {
            for (int j : v) {
                if (i == j) continue;
                int val = (i - j + n) % n;
                if (val > (n-1)/2) val = n - val;
                res[val] += 1;
            }
        }
        for (int i = 1; i < m; ++i) {
            cout << res[i] << "\n";
        }
    }
}
accuracy: 1
time_ms: 120
memory_kb: 3504
final_rank: 15

code_snippet: #include <stdio.h>
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (n); ++i)
#define Inf 1000000000000000



int main(){	

	
	while(true){
		int n;
		cin>>n;
		if(n==0)break;
		vector<int> t;
		for(int i=1;i<n;i++){
			t.push_back((i*i)%n);
		}
		sort(t.begin(),t.end());
		t.erase(unique(t.begin(),t.end()),t.end());
		vector<int> cnt(n/2+1);
		rep(i,t.size()){
			for(int j=i+1;j<t.size();j++){
				int d = t[j] - t[i];
				if(d>n/2)d = n-d;
				cnt[d]++;
			}
		}
		for(int i=1;i<cnt.size();i++)cout<<cnt[i]*2<<endl;
	}
	
	return 0;
	
}
accuracy: 1
time_ms: 30
memory_kb: 3428
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
using ll = long long;

int main(){
    int n;
    while(cin >> n, n){
        vector<int> b, ans((n + 1) / 2);
        for(int i = 1; i < n; i++)b.push_back(i * i % n);
        sort(b.begin(), b.end());
        b.erase(unique(b.begin(), b.end()), b.end());
        auto f = [&](int i, int j){
            int res = j - i;
            if(res < 0)res += n;
            if(res > (n - 1) / 2)res = n - res;
            return res;
        };
        for(int i = 0; i < b.size(); i++){
            for(int j = 0; j < b.size(); j++){
                if(i == j)continue;
                ans[f(b[i], b[j])]++;
            }
        }
        for(int i = 1; i < ans.size(); i++){
            cout << ans[i] << '\n';
        }
    }
}
accuracy: 1
time_ms: 50
memory_kb: 3288
final_rank: 8

code_snippet: #include <iostream>
#include <unordered_map>
#include <unordered_set>
#include <set>
#include <vector>
#include <numeric>
#include <algorithm>
#include <queue>
#include <string>
#include <random>
#include <array>
#include <climits>
#include <map>
#include <cassert>
#include <stack>
#include <iomanip>
#include <cfloat>
#include <bitset>
#include <fstream>
#include <chrono>

std::vector<int> solve(const int n) {
	const auto half = (n - 1) >> 1;
	std::vector<int> count(half);
	std::vector<int> num; num.reserve(n - 1);
	for (auto i = 1; i < n; ++i) {
		const auto r = i * i % n;
		num.push_back(r);
	}
	std::sort(num.begin(), num.end());
	num.erase(std::unique(num.begin(), num.end()), num.end());
	for (auto i = 0; i < num.size(); ++i) {
		for (auto j = 0; j < i; ++j) {
			const auto r = (num[i] - num[j]) % n;
			if (r > 0) count[(r > half) ? n - r - 1: r - 1] += 2;
		}
	}
	return count;
}
int main() {
	while (true) {
		int n; std::cin >> n;
		if (n == 0) break;
		for (const auto r : solve(n)) {
			std::cout << r << '\n';
		}
	}
}
accuracy: 1
time_ms: 60
memory_kb: 3468
final_rank: 14

code_snippet: #define _USE_MATH_DEFINES
#include<iostream>
#include<string>
#include<sstream>
#include<regex>
#include<vector>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<list>
#include<algorithm>
#include<numeric>
#include<cmath>
#include<iomanip>
#include<random>
using namespace std;
#define int long long
#define uint unsigned long long
const int mod=1e9+7;
const int inf=mod*mod;
const double eps=1e-10;
signed main(){
	int n;
	while(cin>>n,n){
		int cnt[5000]={};
		set<int>st;
		vector<int>v;
		for(int i=1;i<n;i++)
			st.insert(i*i%n);
		for(auto x:st)
			v.push_back(x);
		for(int i=0;i<v.size();i++){
			for(int j=0;j<v.size();j++){
				if(i==j)
					continue;
				int d=abs(v[i]-v[j]);
				d=min(d,n-d);
				cnt[d]++;
			}
		}
		for(int i=1;i<=n/2;i++)
			cout<<cnt[i]<<endl;
	}
}
accuracy: 1
time_ms: 60
memory_kb: 3588
final_rank: 16

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(){
    while(1){
        int n;
        cin >> n;
        if(n == 0) break;

        vector<int> a;
        for(int i=1; i<n; i++){
            a.push_back(i*i % n);
        }
        sort(a.begin(), a.end());
        a.erase(unique(a.begin(), a.end()), a.end());
        
        int m = a.size();
        vector<int> ans(n, 0);
        for(int i=0; i<m; i++){
            for(int j=0; j<m; j++){
                if(i == j) continue;
                int diff = a[i]-a[j];
                if(diff < 0) diff += n;
                if(diff > (n-1)/2) diff = n-diff;
                ans[diff]++;
            }
        }
        for(int i=1; i<=(n-1)/2; i++){
            cout << ans[i] << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 50
memory_kb: 3476
final_rank: 13

code_snippet: #include <iostream>
#include <set>
#include <vector>
#include <algorithm>

int main()
{
	int n;
	while (true) {
		std::cin >> n;
		if (n==0) break;
		
		std::set<int> rem;
		for (int i=1; i<=n/2; i++) {
			rem.insert((i*i)%n);
		}
		std::vector<int> v(n/2);
		for (std::set<int>::iterator it1 = rem.begin(); it1 != rem.end(); ++it1) {
			int a = *it1;
			for (std::set<int>::iterator it2 = rem.begin(); it2 != rem.end(); ++it2) {
				if (it1 == it2) continue;
				int b = *it2;
				int d = a-b;
				if (d<0) d += n;
				if (d>n/2) d = n - d;
				v[d-1]++;
			}
		}
		for (int i=0; i<n/2; i++) std::cout << v[i] << std::endl;
	}
		
	return 0;
}
accuracy: 1
time_ms: 430
memory_kb: 3252
final_rank: 17

code_snippet: #include <iostream>
#include <algorithm>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>

static const int MOD = 1000000007;
using ll = long long;
using u32 = unsigned;
using u64 = unsigned long long;
using namespace std;

template<class T> constexpr T INF = ::numeric_limits<T>::max()/32*15+208;

int main() {
    int n;
    while(cin >> n, n) {
        vector<int> v((n+1)/2);
        vector<int> a;
        for (int i = 1; i < n; ++i) {
            a.emplace_back(i*i%n);
        }
        sort(a.begin(), a.end());
        a.erase(unique(a.begin(), a.end()), a.end());
        for (int i = 0; i < a.size(); ++i) {
            for (int j = 0; j < a.size(); ++j) {
                if(i == j) continue;
                int val = (a[i]-a[j]+n)%n;
                if(val > (n-1)/2) val = n-val;
                v[val]++;
            }
        }
        for (int i = 1; i < v.size(); ++i) {
            printf("%d\n", v[i]);
        }
    }
    return 0;
}
accuracy: 1
time_ms: 150
memory_kb: 3292
final_rank: 9

code_snippet: #include <iostream>

using namespace std;

void calc(int n);

int main(void){
  int n;
  while(true){
    cin>>n;
    if(n==0){break;}
    calc(n);
  }
  return 0;
}

void calc(int n){
  int mod[n];
  for(int i=0;i<n;i++){
    mod[i]=0;
  }
  for(int i=1;i<n;i++){
    mod[(i*i)%n]=1;
  }
  int retval[1+n/2];
  for(int i=0;i<=n/2;i++){
    retval[i]=0;
  }
  for(int i=0;i<n;i++){
    if(mod[i]==0){
      continue;
    }
    for(int j=i+1;j<n;j++){
      if(mod[j]==0){
        continue;
      }
      int d=j-i;
      if(d<0){
        d+=n;
      }
      if(d>n/2){
        d=n-d;
      }
      retval[d]++;
    }
  }
  for(int i=1;i<=n/2;i++){
    cout<<retval[i]*2<<endl;
  }
}
accuracy: 1
time_ms: 170
memory_kb: 3064
final_rank: 5

code_snippet: #include<iostream>
#include<set>
#include<cstring>

using namespace std;

set<int> SubData;
set<int>::iterator it,tmp;
int CntData[10000];

void solve(int n, int limit) {
	int result;

    //cout<<"result_before: "<<*it<<"-"<<*tmp<<"="<<result<<endl;
	result = *it - *tmp;
	while (result<0 || result>limit) {
		if (result < 0) {
			result += n;
		}
		else if (result > limit) {
			result = n - result;
		}
	}
	//cout<<"result_after:"<<result<<endl;
	CntData[result]++;
}

int main() {
	int n, limit;

	while (cin >> n, n) {
		SubData.clear();
		memset(CntData, 0, sizeof(CntData));
		limit = (n - 1) / 2;
		for (int i = 1; i < n; i++) {
			SubData.insert((i*i) % n);
		}
		for (it = SubData.begin(); it != SubData.end(); it++) {
			for (tmp = SubData.begin(); tmp != SubData.end(); tmp++) {
				if (*tmp == *it) {
					continue;
				}
				solve(n, limit);
			}
		}
		limit++;
		for (int i = 1; i < limit; i++) {
			if (CntData[i] != 0) {
				cout << CntData[i] << endl;
			}
		}

	}

	return 0;
}
accuracy: 1
time_ms: 640
memory_kb: 3288
final_rank: 20

code_snippet: #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;

constexpr long double PI = acos(-1);
constexpr long double EPS = 1e-15;
constexpr int inf = 2e9;
constexpr ll INF = 2e18;
constexpr ll MOD = 1e9+7;
constexpr ll MOD1 = 998244353;
typedef pair<ll,ll> P;

#define rep(i,a,b) for (int i = (a); i < (b); i++)
#define rrep(i,a,b) for (int i = (a); i >= (b); i--)
#define REP(i,n) rep(i,0,n)
#define RREP(i,n) rrep(i,n,0)
#define sz(s) (s).size()
#define pb push_back
#define fi first
#define se second
//#define mp make_pair

int n;

int main(){
  while(cin >> n, n){
    bitset<11234> a;
    rep(i, 1, n) a[i * i % n] = 1;
    for(int i = 1; i <= n / 2; ++i){
      int cnt = 0;
      REP(j, n) if(a[j] && a[(j + i) % n]) ++cnt;
      cout << cnt * 2 << endl;
    }
  }
}
accuracy: 1
time_ms: 660
memory_kb: 3080
final_rank: 18

code_snippet: #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>

#define REP(i, a, b) for (int i = int(a); i < int(b); i++)
#ifdef _DEBUG_
#define dump(val) cerr << __LINE__ << ":\t" << #val << " = " << (val) << endl
#else
#define dump(val)
#endif

using namespace std;

typedef long long int ll;

template<typename T>
vector<T> make_v(size_t a, T b) {
    return vector<T>(a, b);
}
template<typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    int n;
    while (cin >> n, n) {
        vector<int> v(n - 1, 0);
        REP(i, 0, n - 1) {
            v[i] = ((i + 1) * (i + 1)) % n;
        }
        sort(v.begin(), v.end());
        v.erase(unique(v.begin(), v.end()), v.end());
        vector<int> m(n, 0);
        REP(i, 0, v.size()) {
            REP(j, 0, v.size()) {
                if (i == j) continue;
                int diff = v[i] - v[j];
                if (diff < 0) {
                    diff += n;
                }
                if ((n - 1) / 2 < diff) {
                    diff = n - diff;
                }
                m[diff] += 1;
            }
        }
        REP(i, 1, (n - 1) / 2 + 1) {
            cout << m[i] << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3216
final_rank: 7

code_snippet: #define _USE_MATH_DEFINES

#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>

using namespace std;

typedef pair<long long int, long long int> P;

long long int INF = 1e18;
long long int MOD = 1e9 + 7;

int main(){
    while(true){
        int n;
        cin >> n;
        if(n == 0){
            break;
        }
        map<int, bool> m;
        for(int i = 1; i < n; i++){
            m[(i * i) % n] = true;
        }
        vector<int> v;
        for(pair<int, bool> p : m){
            v.push_back(p.first);
        }
        int cnt[11000] = {};
        for(int i = 0; i < v.size(); i++){
            for(int j = 0; j < v.size(); j++){
                if(i == j){
                    continue;
                }
                int num = v[i] - v[j];
                if(num < 0){
                    num += n;
                }
                if(num > (n - 1) / 2){
                    num = n - num;
                }
                cnt[num] += 1;
            }
        }
        for(int i = 1; i <= (n - 1) / 2; i++){
            cout << cnt[i] << endl;
        }
    }
    return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 3376
final_rank: 11

code_snippet: #include <stdio.h>
#include <set>
#include <vector>
using namespace std;
const int N=1e4+10;
#define PB push_back
int abs(int n){return n>0?n:-n;}
int main(){
    int n,a[N],mid,temp;
    set<int> s;
    vector<int> v;
    while(scanf("%d",&n)!=EOF){
        if(n==0)return 0;
        s.clear();
        v.clear();
        for(int i=1;i<n;i++)s.insert((i*i)%n);
        mid=n>>1;
        for(int i=1;i<=mid;i++)a[i]=0;
        for(int i:s)v.PB(i);
        for(int i=0;i<v.size();i++)for(int j=0;j<v.size();j++)if(i!=j){
            temp=abs(v[j]-v[i]);
            if(temp>mid)a[n-temp]++;
            else a[temp]++;
        }
        for(int i=1;i<=mid;i++)printf("%d\n",a[i]);
    }
}
accuracy: 1
time_ms: 60
memory_kb: 3036
final_rank: 3

code_snippet: #include<iostream>
#include<set>
using namespace std;
int n;
main()
{
	while(cin>>n,n)
	{
		set<int>M;
		for(int i=1;i<n;i++)M.insert(i*i%n);
		int cnt[5555]={};
		for(int a:M)
		{
			for(int b:M)
			{
				if(a==b)continue;
				int d=a-b;
				if(d<0)d+=n;
				if(d>n/2)d=n-d;
				cnt[d]++;
			}
		}
		for(int i=1;i<=n/2;i++)cout<<cnt[i]<<endl;
	}
}
accuracy: 1
time_ms: 490
memory_kb: 3264
final_rank: 19

code_snippet: #include <iostream>
#include <map>
#include <set>
#include <cstring>

using namespace std;

const int N = 10000;
int cnt[N] = { 0 }, ans[N / 2 + 1] = { 0 };

int main(){
	int n;
	while(cin >> n, n) {
		// memset(cnt, 0, sizeof(cnt));
		memset(ans, 0, sizeof(ans));
		set<int> k;
		for(int i = 1;i < n;++i){
			int a = i % n;
			int v = (a * a) % n;
			// cnt[v]++;
			k.insert(v);
		}
		for(auto f = k.begin();f != k.end();++f){
			for(auto b = next(f, 1);b != k.end();++b){
				int diff = (*b - *f);
				// cout << "diff : " << diff << endl;
				if(diff > (n - 1) / 2) {
					diff = n - diff;
				}
				ans[diff] += 2;
			}
		}
		for(int i = 1;i <= (n - 1) / 2;++i){
			cout << ans[i] << endl;
		}
	}
	return 0;
}
accuracy: 1
time_ms: 230
memory_kb: 3288
final_rank: 12

code_snippet: #include<iostream>
#include<vector>
using namespace std;

int main(){
    while(1){
        int n;
        cin >> n;

        if(n == 0)  break;

        bool appear[n+1] = {};
        for(int i = 1; i < n; i++){
            appear[(i*i)%n] = true;
        }

        vector<int> p;
        for(int i = 0; i <= n; i++){
            if(appear[i])   p.push_back(i);
        }

        int len = p.size();
        int ans[(n-1)/2 + 1] = {};

        for(int i = 0; i < len; i++){
            for(int j = 0; j < len; j++){
                if(i == j)  continue;
                int diff = p[i] - p[j];
                if(diff < 0)        diff += n;
                if(diff > (n-1)/2)  diff = n - diff;
                ans[diff]++;
            }
        }

        for(int i = 1; i <= (n-1)/2; i++){
            cout << ans[i] << endl;
        }
    }

    return 0;
}
accuracy: 1
time_ms: 80
memory_kb: 3080
final_rank: 4

code_snippet: #include <cstdio>           // printf(), scanf()
#include <set>

using namespace std;

const int MAX_N = 10000;
const int MAX_R = 5000;

void
solve(int n)
{
	int bins[MAX_N / 2];
	set<int> remains;
	int re[MAX_R];

	int ix = 0;
	for (int i = 1; i < n; ++i)
	{
		int r = (i * i) % n;

		if (remains.find(r) == remains.end())
		{
			remains.insert(r);
			re[ix++] = r;
		}
	}

	int m = (n - 1) / 2;
	for (int i = 1; i <= m; ++i)
		bins[i] = 0;

	for (int i = 0; i < ix; ++i)
	{
		for (int j = i + 1; j < ix; ++j)
		{
			if (i != j)
			{
				int d = re[i] - re[j];
				if (d < 0)
					d += n;

				if (d > m)
					d = n - d;

				bins[d]++;
			}
		}
	}

	for (int i = 1; i <= m; ++i)
		printf("%d\n", 2 * bins[i]);
}

int
main(int argc, char **argv)
{
	while (true)
	{
		int n;
		scanf("%d", &n);
		if (n == 0)
			break;

		solve(n);
	}

	return 0;
}
accuracy: 1
time_ms: 40
memory_kb: 3036
final_rank: 2

code_snippet: #include <cstdio>           // printf(), scanf()
#include <set>

using namespace std;

const int MAX_N = 10000;
const int MAX_R = 5000;

void
solve(int n)
{
	int bins[MAX_N / 2];
	set<int> remains;
	int re[MAX_R];

	int ix = 0;
	for (int i = 1; i < n; ++i)
	{
		int r = (i * i) % n;

		if (remains.find(r) == remains.end())
		{
			remains.insert(r);
			re[ix++] = r;
		}
	}

	int m = (n - 1) / 2;
	for (int i = 1; i <= m; ++i)
		bins[i] = 0;

	for (int i = 0; i < ix; ++i)
	{
		for (int j = 0; j < ix; ++j)
		{
			if (i != j)
			{
				int d = re[i] - re[j];
				if (d < 0)
					d += n;

				if (d > m)
					d = n - d;

				bins[d]++;
			}
		}
	}

	for (int i = 1; i <= m; ++i)
		printf("%d\n", bins[i]);
}

int
main(int argc, char **argv)
{
	while (true)
	{
		int n;
		scanf("%d", &n);
		if (n == 0)
			break;

		solve(n);
	}

	return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 2972
final_rank: 1

code_snippet: #include <iostream>
#include <algorithm>
#include <vector>
using namespace std;

bool exists(vector<int> v, int n) {
    for (int i = 0; i < v.size(); i++) {
        if (v[i] == n) return true;
    }
    return false;
}

int main() {
    while (true) {
        int n;
        cin >> n;
        if (!n) return 0;
        int count[(n - 1) / 2 + 1];
        vector<int> mod;
        for (int i = 0; i < (n - 1) / 2 + 1; i++) {
            count[i] = 0;
        }
        for (int i = 1; i < n; i++) {
            int res = (i * i) % n;
            if (!exists(mod, res)) {
                mod.push_back(res);
            }
        }
        for (int i = 0; i < mod.size(); i++) {
            for (int j = 0; j < mod.size(); j++) {
                if (i == j) continue;
                int res = mod[i] - mod[j];
                if (res < 0) res += n;
                if (res > (n - 1) / 2) res = n - res;
                count[res]++;
            }
        }
        for (int i = 1; i < (n - 1) / 2 + 1; i++) {
            cout << count[i] << endl;
        }
    }
}
accuracy: 1
time_ms: 110
memory_kb: 3168
final_rank: 6