Dataset Preview

Split (1)

train

The full dataset viewer is not available (click to read why). Only showing a preview of the rows.

The dataset generation failed

Error code:   DatasetGenerationError
Exception:    TypeError
Message:      Couldn't cast array of type
struct<source_dataset: string, source_index: int64, task_name: string, size: int64, train_examples: list<item: struct<input: list<item: int64>, output: list<item: int64>>>, test_example: struct<input: list<item: int64>, output: list<item: int64>>, difficulty: struct<size: list<item: int64>>>
to
{'chain_rendered': List(Value('string')), 'is_structurally_valid': Value('bool')}
Traceback:    Traceback (most recent call last):
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1816, in _prepare_split_single
                  for key, table in generator:
                                    ^^^^^^^^^
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 613, in wrapped
                  for item in generator(*args, **kwargs):
                              ~~~~~~~~~^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 343, in _generate_tables
                  self._cast_table(pa_table, json_field_paths=json_field_paths),
                  ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
                  pa_table = table_cast(pa_table, self.info.features.arrow_schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2369, in table_cast
                  return cast_table_to_schema(table, schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2303, in cast_table_to_schema
                  cast_array_to_feature(
                  ~~~~~~~~~~~~~~~~~~~~~^
                      table[name] if name in table_column_names else pa.array([None] * len(table), type=schema.field(name).type),
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                      feature,
                      ^^^^^^^^
                  )
                  ^
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 1852, in wrapper
                  return pa.chunked_array([func(chunk, *args, **kwargs) for chunk in array.chunks])
                                           ~~~~^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2149, in cast_array_to_feature
                  raise TypeError(f"Couldn't cast array of type\n{_short_str(array.type)}\nto\n{_short_str(feature)}")
              TypeError: Couldn't cast array of type
              struct<source_dataset: string, source_index: int64, task_name: string, size: int64, train_examples: list<item: struct<input: list<item: int64>, output: list<item: int64>>>, test_example: struct<input: list<item: int64>, output: list<item: int64>>, difficulty: struct<size: list<item: int64>>>
              to
              {'chain_rendered': List(Value('string')), 'is_structurally_valid': Value('bool')}
              
              The above exception was the direct cause of the following exception:
              
              Traceback (most recent call last):
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 1369, in compute_config_parquet_and_info_response
                  parquet_operations, partial, estimated_dataset_info = stream_convert_to_parquet(
                                                                        ~~~~~~~~~~~~~~~~~~~~~~~~~^
                      builder, max_dataset_size_bytes=max_dataset_size_bytes
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  )
                  ^
                File "/src/services/worker/src/worker/job_runners/config/parquet_and_info.py", line 948, in stream_convert_to_parquet
                  builder._prepare_split(split_generator=splits_generators[split], file_format="parquet")
                  ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1683, in _prepare_split
                  for job_id, done, content in self._prepare_split_single(
                                               ~~~~~~~~~~~~~~~~~~~~~~~~~~^
                      gen_kwargs=gen_kwargs, job_id=job_id, **_prepare_split_args
                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  ):
                  ^
                File "/usr/local/lib/python3.14/site-packages/datasets/builder.py", line 1869, in _prepare_split_single
                  raise DatasetGenerationError("An error occurred while generating the dataset") from e
              datasets.exceptions.DatasetGenerationError: An error occurred while generating the dataset

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

question string	answer string	metadata dict
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> GOLD -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "GOLD", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> GOLD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "GOLD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> GOLD -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "GOLD", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> GOLD -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "GOLD", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> GOLD -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "GOLD", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> GOLD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "GOLD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> GOLD -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "GOLD", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> GOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "GOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> GOLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "GOLD", "CORD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> GOLD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	no	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "GOLD", "CARD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> GOLD -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "SPOT", "GOLD", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: GOLD -> SOLD -> COLD -> CORD -> CARD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters...	yes	{ "chain_rendered": [ "GOLD", "SOLD", "COLD", "CORD", "CARD" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> GOLD -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "GOLD", "MEET", "MELT" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> SPOT -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "STOP", "SPOT", "POTS", "POST" ], "is_structurally_valid": true }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: STOP -> GOLD -> POTS -> POST Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "STOP", "GOLD", "POTS", "POST" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> GOLD Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	no	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "GOLD" ], "is_structurally_valid": false }
You are evaluating a word mutation link path in an Anagram Word Ladder puzzle. Proposed Transition Chain: TEAM -> MEAT -> MEET -> MELT Rules: - A step is valid if you change exactly ONE letter while keeping the order the same (e.g., COLD -> CORD). - A step is also valid if you rearrange the exact same letters to form...	yes	{ "chain_rendered": [ "TEAM", "MEAT", "MEET", "MELT" ], "is_structurally_valid": true }

End of preview.

YAML Metadata Warning:empty or missing yaml metadata in repo card

Check out the documentation for more information.

RLVR training dataset focused on spatial and logic reasoning

This dataset has the objective to let the LLMs discover spatial reasoning capabilities in puzzles and games that focus on the need to develop a spatial sense of the environment and the definition of simple strategies to solve them.

Downloads last month: -

Total file size:

14.8 MB