| U_double_well |
Ran ran, violated the contract we drafted |
plainerman/variational-doob/potentials.py code served (permissive licence) · get_code("b5c718f1aa14ec63") 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 1, dtype family float, shape (2,) 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)
# Construct xs as a 2D tensor with shape (batch_size, 2)
# The function expects xs[:, 0] for x and xs[:, 1] for y
xs = torch.randn(2, 2)
# Define all parameters
ARGS = {
"xs": xs,
"a": 1.0,
"b": -4.0,
"c": 0,
"d": 1.0,
"beta": 1.0,
}
- 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 1, dtype family float, shape (2,) — shape (2,) 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
|
| U_double_well_dual_channel |
Ran ran, violated the contract we drafted |
plainerman/variational-doob/potentials.py code served (permissive licence) · get_code("8baa6fbffc8ae462") 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 ArrayImpl, ndim 1, dtype family float, shape (2,) 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 jax.numpy as jnp
import numpy as np
# Create sample input: a 2D array with shape (batch_size, 2)
# The function expects xs to be a 2D array where each row is [x, y]
xs = jnp.array([
[0.1, 0.2],
[-0.3, 0.4]
], dtype=jnp.float32)
beta = 1.0
ARGS = {
"xs": xs,
"beta": beta
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (2,) 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
|
| U_double_well_hard |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/potentials.py code served (permissive licence) · get_code("fba185b286872592") 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 ArrayImpl, ndim 1, dtype family float, shape (2,) 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 jax.numpy as jnp
# Create sample input data
# The function expects xs to be a 2D array or will reshape 1D to 2D
# Shape should be (batch_size, feature_dim) where feature_dim=2 based on function logic
xs = jnp.array([
[-2.5, 0.1],
[2.8, -0.2]
])
# The function also accepts a beta parameter (default 1.0)
beta = 1.0
ARGS = {
"xs": xs,
"beta": beta
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (2,) 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
|
| interpolate |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
plainerman/variational-doob/tps_baseline_mueller.py code served (permissive licence) · get_code("e15e209ec043ecb5") 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 list, 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 jax.numpy as jnp
import numpy as np
# Set seed for reproducibility
np.random.seed(0)
# Define arguments for the interpolate function
# points: a list of array-like objects to interpolate between
# steps: number of interpolation steps
points = [
np.array([0.0, 1.0, 2.0, 3.0]),
np.array([4.0, 5.0, 6.0, 7.0]),
np.array([8.0, 9.0, 10.0, 11.0])
]
steps = 10
ARGS = {
"points": points,
"steps": steps
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 2, dtype family float — a list output has no array shape of its own; none is stated
- 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
|
| is_within |
Ran ran, violated the contract we drafted |
plainerman/variational-doob/tps_baseline.py code served (permissive licence) · get_code("53f10abe63ad7724") 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 ArrayImpl, ndim 1, dtype family float, shape (2,) 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 jax
import jax.numpy as jnp
# Construct arguments for is_within function
# The function expects:
# - _phis_psis: array of shape (N, 2) representing angles/positions
# - _center: array of shape (2,) representing center position
# - _radius: scalar representing radius threshold
# - _period: scalar representing period (default 2*pi)
# Create small test data
_phis_psis = jnp.array([
[1.0, 2.0],
[1.5, 2.5]
], dtype=jnp.float32)
_center = jnp.array([1.2, 2.1], dtype=jnp.float32)
_radius = 0.5
_period = 2 * jnp.pi
ARGS = {
"_phis_psis": _phis_psis,
"_center": _center,
"_radius": _radius,
"_period": _period
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (2,) 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
|
| load |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/eval/evaluate_mueller.py code served (permissive licence) · get_code("77675113fedd2bb9") 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 list. 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 numpy as np
import tempfile
import os
# Create a temporary directory and file for testing
temp_dir = tempfile.mkdtemp()
temp_file = os.path.join(temp_dir, "test_data.npy")
# Create sample data: a list of arrays that will be reshaped to (-1, 2)
# We'll create 2 arrays with different shapes to test the functionality
sample_data = [
np.array([[1.5, 2.5], [3.5, 4.5], [5.5, 6.5]], dtype=np.float64),
np.array([[7.5, 8.5], [9.5, 10.5]], dtype=np.float64)
]
# Save the sample data using np.save with allow_pickle=True
np.save(temp_file, np.array(sample_data, dtype=object), allow_pickle=True)
ARGS = {
"path": temp_file
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- numpy — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list — a list output has no array shape of its own; none is 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
|
| mcmc_shooting |
Ran ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT) |
plainerman/variational-doob/tps/first_order.py code served (permissive licence) · get_code("a60329e7a81e48fe") 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 tuple. 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 jax
import jax.numpy as jnp
import numpy as np
# Define a simple system class that the proposal function will use
class SimpleSystem:
def __init__(self):
self.params = jnp.array([1.0, 0.5, 0.2, 0.1])
def force(self, state):
return -self.params * state
# Define a proposal function that generates new trajectories
def proposal_fn(system, trajectory, fixed_length, key):
"""
Proposal function that generates a new trajectory.
Takes: system, previous trajectory, fixed_length, random key
Returns: (found: bool, new_trajectory: array)
"""
# Simulate finding a new trajectory or not
subkey1, subkey2 = jax.random.split(key)
# With high probability, find a trajectory
found = jax.random.uniform(subkey1) > 0.1
if not found:
return False, trajectory
# Generate a new trajectory with slightly different length
current_length = len(trajectory)
if fixed_length > 0:
new_length = fixed_length
else:
# Random length between current_length and current_length + 5
new_length = current_length + jax.random.randint(subkey2, (), 0, 6)
new_length = min(new_length, 1000) # Respect MAX_STEPS
# Create new trajectory as random walk from last state
new_trajectory = jnp.concatenate([
trajectory,
jax.random.normal(subkey2, (new_length - current_length, 4))
], axis=0)
return True, new_trajectory
# Create initial trajectory (small, starting with shape (5, 4))
initial_trajectory = jnp.array([
[1.0, 0.5, 0.2, 0.1],
[0.9, 0.6, 0.3, 0.0],
[0.8, 0.7, 0.1, 0.2],
[0.7, 0.4, 0.4, 0.3],
[0.6, 0.5, 0.2, 0.4],
])
# Create system
system = SimpleSystem()
# Create JAX random key
key = jax.random.PRNGKey(0)
ARGS = {
'system': system,
'proposal': proposal_fn,
'initial_trajectory': initial_trajectory,
'num_paths': 5,
'key': key,
'fixed_length': 0,
'warmup': 2,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is 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
|
| one_way_shooting |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/tps/first_order.py code served (permissive licence) · get_code("585c37179b5aba1c") 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 tuple. 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 jax
import jax.numpy as jnp
import jax.random as jr
# Create a minimal system class that satisfies the interface
class MockSystem:
def __init__(self):
self.state_dim = 4
def step(self, state, key):
# Takes a state and key, returns next state
# state shape: (4,), returns (4,)
noise = jr.normal(key, shape=(self.state_dim,)) * 0.01
return state + noise
def start_state(self, state):
# Returns True if state is a start state
return jnp.allclose(state, 0.0, atol=1e-3)
def target_state(self, state):
# Returns True if state is a target state
return jnp.allclose(state, 1.0, atol=1e-3)
# Create trajectory as a list of jax arrays
key = jr.PRNGKey(0)
system = MockSystem()
# Initialize trajectory with a few points
trajectory = [
jnp.array([0.0, 0.0, 0.0, 0.0]), # start state
jnp.array([0.1, 0.1, 0.1, 0.1]),
jnp.array([0.2, 0.2, 0.2, 0.2]),
jnp.array([0.9, 0.9, 0.9, 0.9]), # near target
jnp.array([1.0, 1.0, 1.0, 1.0]), # target state
]
fixed_length = 0
ARGS = {
"system": system,
"trajectory": trajectory,
"fixed_length": fixed_length,
"key": key,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is 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
|
| plot_iterative_min_max_energy |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/eval/path_metrics.py code served (permissive licence) · get_code("ce65dad4f367f7f9") 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 list, ndim 1, 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 jax.numpy as jnp
import numpy as np
from tqdm import tqdm
# Define a simple potential energy function
def potential_func(path):
"""Simple potential that sums squared values"""
return jnp.sum(path ** 2)
# Create sample paths - list of small JAX arrays
paths = [
jnp.array([1.0, 2.0, 3.0, 4.0]),
jnp.array([0.5, 1.5, 2.5, 3.5]),
jnp.array([2.0, 3.0, 4.0, 5.0]),
]
# Define potential function U that takes a path and returns energy
U = potential_func
# Define potential_calls - number of calls for each path
potential_calls = [4, 4, 4]
ARGS = {
'paths': paths,
'U': U,
'potential_calls': potential_calls,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, matplotlib, numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type list, ndim 1, dtype family float — a list output has no array shape of its own; none is stated
- 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
|
| plot_path_energy |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/eval/path_metrics.py code served (permissive licence) · get_code("f3b550629c7127d4") 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 ArrayImpl, ndim 1, dtype family float, shape (2,) 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 jax.numpy as jnp
import numpy as np
# Define a simple potential energy function U that takes a path and returns energies
def potential_energy(path):
"""
Simple potential energy function.
Takes a path (array) and returns an array of energy values.
"""
return jnp.sum(path ** 2, axis=1) if len(path.shape) > 1 else jnp.array([jnp.sum(path ** 2)])
# Create sample paths - list of jnp arrays
# Each path is a trajectory/sequence of positions
paths = [
jnp.array([[1.0, 2.0, 0.5, -0.3],
[0.8, 1.9, 0.4, -0.2],
[0.6, 1.8, 0.3, -0.1]]),
jnp.array([[0.5, -1.0, 0.2, 0.1],
[0.4, -0.9, 0.15, 0.05],
[0.3, -0.8, 0.1, 0.0]]),
]
# Define ARGS dict with all parameters
ARGS = {
'paths': paths,
'U': potential_energy,
'reduce': jnp.max,
'add': 0.0,
'already_ln': False,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax, matplotlib, numpy, tqdm — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type ArrayImpl, ndim 1, dtype family float, shape (2,) — shape (2,) 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
|
| step_n |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/tps_baseline.py code served (permissive licence) · get_code("b1c11cc844c6637e") 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 tuple, ndim 4, 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 jax
import jax.numpy as jnp
# Define a simple step function that takes (_x, _v, _key) and returns updated (_x, _v)
def simple_step(_x, _v, _key):
# Simple update: add small noise to x and v
noise_x = jax.random.normal(_key, _x.shape) * 0.01
noise_v = jax.random.normal(_key, _v.shape) * 0.01
return _x + noise_x, _v + noise_v
# Create small initial tensors
_x = jnp.ones((2, 4)) # batch=2, features=4
_v = jnp.ones((2, 4)) # batch=2, features=4
# Create initial random key
_key = jax.random.PRNGKey(0)
# Number of iterations
n = 3
ARGS = {
"step": simple_step,
"_x": _x,
"_v": _v,
"n": n,
"_key": _key,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple, ndim 4, dtype family float — a tuple output has no array shape of its own; none is stated
- 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
|
| two_way_shooting |
Ran ran; our contract draft was wrong, not the code |
plainerman/variational-doob/tps/first_order.py code served (permissive licence) · get_code("2f18c8a3ab7cf955") 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 tuple. 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 jax
import jax.numpy as jnp
import jax.random
# Define a simple system class that implements the required interface
class SimpleSystem:
def __init__(self):
self.state_dim = 4
def step(self, point, key):
"""Take a step in the system dynamics"""
# Simple linear step with small noise
noise = jax.random.normal(key, point.shape) * 0.01
return point * 0.99 + noise
def start_state(self, point):
"""Check if point is a start state"""
# Start state is approximately [1, 0, 0, 0]
return jnp.linalg.norm(point - jnp.array([1.0, 0.0, 0.0, 0.0])) < 0.2
def target_state(self, point):
"""Check if point is a target state"""
# Target state is approximately [-1, 0, 0, 0]
return jnp.linalg.norm(point - jnp.array([-1.0, 0.0, 0.0, 0.0])) < 0.2
# Create system instance
system = SimpleSystem()
# Create a trajectory - a list of small jax arrays
trajectory = [
jnp.array([1.0, 0.1, 0.0, 0.0]),
jnp.array([0.95, 0.05, 0.0, 0.0]),
jnp.array([0.90, 0.02, 0.0, 0.0]),
jnp.array([0.85, 0.0, 0.0, 0.0]),
jnp.array([0.80, -0.05, 0.0, 0.0]),
jnp.array([-1.0, 0.0, 0.0, 0.0]),
]
# fixed_length parameter: 0 means use MAX_STEPS, otherwise use specified length
fixed_length = 0
# Create a random key for JAX
key = jax.random.PRNGKey(42)
# Construct the ARGS dictionary
ARGS = {
"system": system,
"trajectory": trajectory,
"fixed_length": fixed_length,
"key": key,
}
- Setup block drafted by
- a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
- Imports
- jax — import names as written, not package names to install; a name the repository itself provides is not a package
- Returned
- type tuple — a tuple output has no array shape of its own; none is 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
|
| decorrelated |
Not yet run unverified (harvested, no recorded run) |
plainerman/variational-doob/tps/paths.py code served (permissive licence) · get_code("f1acf61f58cd67a5") How it ran |