| CKG_Loss |
Ran ran on a synthesized input |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("bcceb1a21bf0d6de") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
from scipy.sparse import csr_matrix
INIT_ARGS = {
'tau': 0.05,
'ab_weight': 0.5,
'n_view': 2,
'intra_weight': 1.0
}
# Create small tensors for the forward pass
batch_size = 2
feature_dim = 4
num_nodes = 6 # Must be >= batch_size * 2 for train_links
# Embedding tensor: (num_nodes, feature_dim)
emb = torch.randn(num_nodes, feature_dim)
# Train links: (batch_size, 2) - pairs of node indices
train_links = torch.tensor([[0, 3], [1, 4]], dtype=torch.long)
# Optional mask: (num_nodes,) - binary mask for nodes
mask = torch.tensor([1, 1, 0, 1, 1, 0], dtype=torch.float32)
ARGS = {
'emb': emb,
'train_links': train_links,
'mask': mask
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- Imports
- numpy, scipy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| CM_Loss |
Ran ran on a synthesized input |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("5e980ee90e9e3dbd") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 0, dtype family float; no output shape is stated. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import numpy as np
# INIT_ARGS for CM_Loss.__init__
INIT_ARGS = {
'tau': 0.05,
'ab_weight': 0.5,
'weight': 1.0
}
# ARGS for CM_Loss.forward
# Create embeddings for two modalities
batch_size = 6 # Total entities in each modality
embedding_dim = 8
num_train_links = 4 # Number of training links
# Embeddings from modality 1 and modality 2
m1_emb = torch.randn(batch_size, embedding_dim)
m2_emb = torch.randn(batch_size, embedding_dim)
# Train links: pairs of indices linking entities between modalities
# Shape: (num_train_links, 2) where each row is [idx_in_m1, idx_in_m2]
train_links = torch.tensor([
[0, 1],
[2, 3],
[1, 4],
[3, 5]
], dtype=torch.int64)
# Optional loss masks (can be None or tensors of shape [batch_size])
# These indicate which entities should contribute to the loss
loss_mask_l = torch.tensor([1.0, 1.0, 1.0, 1.0, 0.0, 0.0])
loss_mask_r = torch.tensor([0.0, 1.0, 0.0, 1.0, 1.0, 1.0])
ARGS = {
'm1_emb': m1_emb,
'm2_emb': m2_emb,
'train_links': train_links,
'loss_mask_l': loss_mask_l,
'loss_mask_r': loss_mask_r
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 0, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| CustomMultiLossLayer |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("40f8a8faf24955d4") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, CustomMultiLossLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# The CustomMultiLossLayer.__init__ takes loss_num as parameter
# The forward method takes loss_list (list of loss values/tensors)
# Create a small list of loss values (scalars or 0-d tensors)
loss_list = [
torch.tensor(0.5),
torch.tensor(0.3),
torch.tensor(0.7)
]
ARGS = {
"loss_num": len(loss_list)
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type CustomMultiLossLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a CustomMultiLossLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| GAT |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("d6be02987f151a14") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, GAT: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import math
torch.manual_seed(0)
# Create a minimal sparse adjacency matrix
# For a graph with N=2 nodes, we need edge indices and values
N = 2
edge_indices = torch.tensor([[0, 1], [1, 0]], dtype=torch.long).t()
edge_values = torch.ones(2, dtype=torch.float32)
adj = torch.sparse_coo_tensor(edge_indices, edge_values, (N, N))
# Create input features: (N, f_in) where N=2, f_in=4
x = torch.randn(2, 4)
# Define GAT parameters
n_units = [4, 8, 3] # input_dim=4, hidden_dim=8, output_dim=3
n_heads = [2, 2] # 2 heads for each of the 2 layers
dropout = 0.1
attn_dropout = 0.1
instance_normalization = True
diag = True
ARGS = {
'n_units': n_units,
'n_heads': n_heads,
'dropout': dropout,
'attn_dropout': attn_dropout,
'instance_normalization': instance_normalization,
'diag': diag,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type GAT — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a GAT output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| GCN |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("55399663a530eb02") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, GCN: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
torch.manual_seed(0)
class GraphConvolution(Module):
"""
Simple GCN layer, similar to https://arxiv.org/abs/1609.02907
"""
def __init__(self, in_features, out_features, bias=True):
super(GraphConvolution, self).__init__()
self.in_features = in_features
self.out_features = out_features
self.weight = Parameter(torch.FloatTensor(in_features, out_features))
if bias:
self.bias = Parameter(torch.FloatTensor(out_features))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def reset_parameters(self):
stdv = 1.0 / math.sqrt(self.weight.size(1))
self.weight.data.uniform_(-stdv, stdv)
if self.bias is not None:
self.bias.data.uniform_(-stdv, stdv)
def forward(self, input, adj):
support = torch.mm(input, self.weight)
output = torch.spmm(adj, support)
if self.bias is not None:
return output + self.bias
else:
return output
def __repr__(self):
return self.__class__.__name__ + ' (' + str(self.in_features) + ' -> ' + str(self.out_features) + ')'
class GCN(nn.Module):
def __init__(self, nfeat, nhid, nout, dropout):
super(GCN, self).__init__()
self.gc1 = GraphConvolution(nfeat, nhid)
self.gc2 = GraphConvolution(nhid, nout)
self.dropout = dropout
def forward(self, x, adj):
x = F.relu(self.gc1(x, adj))
x = F.dropout(x, self.dropout, training=self.training)
x = self.gc1(x, adj)
return x
# Create small tensors
num_nodes = 2
nfeat = 4
nhid = 3
nout = 5
# Feature matrix: (num_nodes, nfeat)
x = torch.randn(num_nodes, nfeat)
# Adjacency matrix as sparse tensor: (num_nodes, num_nodes)
indices = torch.LongTensor([[0, 1], [1, 0]])
values = torch.FloatTensor([1.0, 1.0])
adj = torch.sparse_coo_tensor(indices.t(), values, (num_nodes, num_nodes))
ARGS = {
'nfeat': nfeat,
'nhid': nhid,
'nout': nout,
'dropout': 0.5
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type GCN — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a GCN output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| MultiHeadGraphAttention |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("c23ba7846955e383") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MultiHeadGraphAttention: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
import math
torch.manual_seed(0)
# Create a small sparse adjacency matrix
# For a graph with N=2 nodes, we need edge indices and values
N = 2
edge_indices = torch.tensor([[0, 1], [1, 0]], dtype=torch.long).t() # 2 edges: 0->1, 1->0
edge_values = torch.tensor([1.0, 1.0], dtype=torch.float)
adj = torch.sparse_coo_tensor(edge_indices, edge_values, (N, N))
# Create input features: N nodes, f_in=3 features
input_data = torch.randn(N, 3, dtype=torch.float)
# Define parameters for MultiHeadGraphAttention
n_head = 2
f_in = 3
f_out = 4
attn_dropout = 0.5
diag = True
init = None
bias = False
ARGS = {
'n_head': n_head,
'f_in': f_in,
'f_out': f_out,
'attn_dropout': attn_dropout,
'diag': diag,
'init': init,
'bias': bias,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type MultiHeadGraphAttention — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MultiHeadGraphAttention output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| PMFusion |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("cb74d190b5c6e785") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, PMFusion: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
torch.manual_seed(0)
# Build a minimal args object with the attributes used in forward()
class Args:
def __init__(self):
self.with_weight = 1
args = Args()
# Parameters for PMFusion.__init__
ent_num = 10
modal_num = 2
with_weight = 1
# Build sample data for forward() call
# embs_dict: dict with keys mapping to embeddings (or None)
# Each embedding should be shape (batch_size, embedding_dim)
batch_size = 2
embedding_dim = 4
embs_dict = {
'modal_0': torch.randn(batch_size, embedding_dim),
'modal_1': torch.randn(batch_size, embedding_dim),
}
# input_idx: not used in forward, but required as parameter
input_idx = torch.tensor([0, 1])
# adj: not used in forward, but required as parameter
adj = torch.randn(ent_num, ent_num)
# mask: dict with keys matching embs_dict, values are 1D tensors of shape (batch_size,)
mask = {
'modal_0': torch.ones(batch_size),
'modal_1': torch.ones(batch_size),
}
ARGS = {
'args': args,
'ent_num': ent_num,
'modal_num': modal_num,
'with_weight': with_weight,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type PMFusion — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PMFusion output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| SpecialSpmm |
Ran ran on a synthesized input |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("32c82917ea1d7b9c") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import torch.nn as nn
class SpecialSpmmFunction(torch.autograd.Function):
"""Special function for only sparse region backpropataion layer."""
@staticmethod
def forward(ctx, indices, values, shape, b):
assert indices.requires_grad is False
a = torch.sparse_coo_tensor(indices, values, shape)
ctx.save_for_backward(a, b)
ctx.N = shape[0]
return torch.matmul(a, b)
@staticmethod
def backward(ctx, grad_output):
a, b = ctx.saved_tensors
grad_values = grad_b = None
if ctx.needs_input_grad[1]:
grad_a_dense = grad_output.matmul(b.t())
edge_idx = a._indices()[0, :] * ctx.N + a._indices()[1, :]
grad_values = grad_a_dense.view(-1)[edge_idx]
if ctx.needs_input_grad[3]:
grad_b = a.t().matmul(grad_output)
return (None, grad_values, None, grad_b)
class SpecialSpmm(nn.Module):
def forward(self, indices, values, shape, b):
return SpecialSpmmFunction.apply(indices, values, shape, b)
INIT_ARGS = {}
indices = torch.tensor([[0, 1, 0, 1], [0, 1, 1, 0]], dtype=torch.long)
values = torch.tensor([1.0, 2.0, 3.0, 4.0], dtype=torch.float32, requires_grad=True)
shape = (2, 2)
b = torch.randn(2, 3, requires_grad=True)
ARGS = {
'indices': indices,
'values': values,
'shape': shape,
'b': b
}
- Setup block drafted by
- a language model, class construct-then-call prompt, model not recorded
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
|
| SpecialSpmmFunction |
Ran ran on a synthesized input · constructed an object; no result was computed |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("4c08e0d2ffc7bc34") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, SpecialSpmmFunction: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
torch.manual_seed(0)
# Construct arguments for SpecialSpmmFunction.forward(ctx, indices, values, shape, b)
# indices: LongTensor of shape (2, nnz) for COO format
# values: Tensor of non-zero values, shape (nnz,)
# shape: tuple for sparse tensor shape (m, n)
# b: dense tensor to multiply with sparse matrix, shape (n, batch_size)
nnz = 3 # number of non-zero elements
m, n = 4, 5 # sparse matrix dimensions
batch_size = 2 # batch dimension for b
# Create indices for sparse COO tensor
# Must be 2D: first row is row indices, second row is column indices
indices = torch.tensor(
[[0, 1, 3],
[0, 2, 4]],
dtype=torch.long,
requires_grad=False
)
# Create values for sparse tensor
values = torch.tensor([1.0, 2.0, 3.0], dtype=torch.float32, requires_grad=True)
# Shape of sparse matrix (m x n)
shape = (m, n)
# Dense tensor b with shape (n, batch_size)
b = torch.randn(n, batch_size, requires_grad=True)
ARGS = {
"indices": indices,
"values": values,
"shape": shape,
"b": b
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type SpecialSpmmFunction — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SpecialSpmmFunction output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| pairwise_distances |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("70fa9d2ca12c8bc3") How it ranRan in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.
import torch
import numpy as np
torch.manual_seed(0)
# Create small tensors for testing
# x: Nxd matrix where N=2 (batch size), d=4 (dimensions)
x = torch.randn(2, 4)
# y: Mxd matrix where M=3 (different batch size), d=4 (same dimensions)
y = torch.randn(3, 4)
ARGS = {
"x": x,
"y": y,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
- dtype family
- int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
- Environment
- image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
|
| PMF |
Not yet run unverified (harvested, no recorded run) |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("7bdecc4812362ce3") How it ran |
| PMF_Encoder |
Not yet run unverified (harvested, no recorded run) |
ninibymilk/PMF-MMEA/model/PMF.py code served (permissive licence) · get_code("a9f2ada726003d51") How it ran |