From 9ab65f685e5ed29f9c00a427b7e5b45e05e2b4d7 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 09:27:56 -0500
Subject: [PATCH 01/71] Implemented reading input from a stream.

---
 montepy/input_parser/input_reader.py | 10 ++++++----
 montepy/mcnp_problem.py              | 14 ++++++++++----
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/montepy/input_parser/input_reader.py b/montepy/input_parser/input_reader.py
index 400d5e1f..4c508a01 100644
--- a/montepy/input_parser/input_reader.py
+++ b/montepy/input_parser/input_reader.py
@@ -3,15 +3,17 @@
 from montepy.constants import DEFAULT_VERSION
 
 
-def read_input(input_file, mcnp_version=DEFAULT_VERSION, replace=True):
+def read_input(destination, mcnp_version=DEFAULT_VERSION, replace=True):
     """
     Reads the specified MCNP Input file.
 
     The MCNP version must be a three component tuple e.g., (6, 2, 0) and (5, 1, 60).
 
+    .. note::
+        if a stream is provided. It will not be closed by this function.
 
-    :param input_file: the path to the input file to read.
-    :type input_file: str
+    :param destination: the path to the input file to read, or a readable stream.
+    :type destination: io.TextIOBase, str, os.PathLike
     :param mcnp_version: The version of MCNP that the input is intended for.
     :type mcnp_version: tuple
     :returns: The MCNP_Problem instance representing this file.
@@ -24,7 +26,7 @@ def read_input(input_file, mcnp_version=DEFAULT_VERSION, replace=True):
     :raises BrokenObjectLinkError: If a reference is made to an object that is not in the input file.
     :raises UnknownElement: If an isotope is specified for an unknown element.
     """
-    problem = mcnp_problem.MCNP_Problem(input_file)
+    problem = mcnp_problem.MCNP_Problem(destination)
     problem.mcnp_version = mcnp_version
     problem.parse_input(replace=replace)
     return problem
diff --git a/montepy/mcnp_problem.py b/montepy/mcnp_problem.py
index 2f1ae98b..8cae65ae 100644
--- a/montepy/mcnp_problem.py
+++ b/montepy/mcnp_problem.py
@@ -23,12 +23,18 @@ class MCNP_Problem:
     """
     A class to represent an entire MCNP problem in a semantic way.
 
-    :param file_name: the path to the file that will be read.
-    :type file_name: str
+    .. note::
+        If a stream is provided. It will not be closed by this function.
+
+    :param destination: the path to the input file to read, or a readable stream.
+    :type destination: io.TextIOBase, str, os.PathLike
     """
 
-    def __init__(self, file_name):
-        self._input_file = MCNP_InputFile(file_name)
+    def __init__(self, destination):
+        if hasattr(destination, "read") and callable(getattr(destination, "read")):
+            self._input_file = MCNP_InputFile.from_open_stream(destination)
+        elif isinstance(destination, (str, os.PathLike)):
+            self._input_file = MCNP_InputFile(destination)
         self._title = None
         self._message = None
         self._print_in_data_block = CellDataPrintController()

From 97683b953859e337591dd43544955b95bfbe00aa Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 09:29:28 -0500
Subject: [PATCH 02/71] Test read/write all input files.

---
 tests/test_integration.py | 20 ++++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 10ab35f6..4e3b0189 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -1,6 +1,7 @@
 # Copyright 2024, Battelle Energy Alliance, LLC All Rights Reserved.
 import copy
 import io
+from pathlib import Path
 
 import pytest
 import os
@@ -17,6 +18,8 @@
 from montepy.particle import Particle
 import numpy as np
 
+from tests import constants
+
 
 @pytest.fixture(scope="module")
 def simple_problem():
@@ -1066,3 +1069,20 @@ def test_alternate_encoding():
     montepy.read_input(
         os.path.join("tests", "inputs", "bad_encoding.imcnp"), replace=True
     )
+
+
+@pytest.mark.parametrize(
+    "file",
+    set((Path("tests") / "inputs").iterdir())
+    - {
+        Path("tests") / "inputs" / p
+        for p in constants.BAD_INPUTS | constants.IGNORE_FILES
+    },
+)
+def test_read_write_cycle(file):
+    print(f"Testing against {file} *********************")
+    problem = montepy.read_input(file)
+    fh = io.StringIO()
+    problem.write_problem(fh)
+    fh.seek(0)
+    new_problem = montepy.MCNP_Problem("foo")

From c5534ae1e7e8431a6f2f8a26ab17aaae99687816 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 09:35:12 -0500
Subject: [PATCH 03/71] Made verification tests harder.

---
 tests/test_integration.py | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 4e3b0189..3c16ed1c 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -1085,4 +1085,12 @@ def test_read_write_cycle(file):
     fh = io.StringIO()
     problem.write_problem(fh)
     fh.seek(0)
+    # test valid syntax
     new_problem = montepy.MCNP_Problem("foo")
+    # verify lines are similar
+    fh.seek(0)
+    with open(file, "r") as gold_fh:
+        for gold_line, new_line in zip(gold_fh, fh):
+            pretty_line = new_line.rstrip()
+            print(pretty_line)
+            assert pretty_line == gold_line.rstrip()

From c260d75a9a07cb91a526a7c3b9efdb7293c1679f Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 09:47:17 -0500
Subject: [PATCH 04/71] Replicated #499 by forcing a recompression.

---
 tests/inputs/test_importance.imcnp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/inputs/test_importance.imcnp b/tests/inputs/test_importance.imcnp
index b279bb2e..8580b633 100644
--- a/tests/inputs/test_importance.imcnp
+++ b/tests/inputs/test_importance.imcnp
@@ -41,7 +41,7 @@ MT3 lwtr.23t
 C execution
 ksrc 0 0 0
 imp:n,p 1 1 1 0 3
-imp:e   0 0 0 1 2
+imp:e   0 2R 1 2
 kcode 100000 1.000 50 1050
 phys:p j 1 2j 1
 mode n p e

From 94233d4a81b2f2713556a4ee2e360a8ba16cac74 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 09:47:32 -0500
Subject: [PATCH 05/71] Dumped whole file to stdout.

---
 tests/test_integration.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 3c16ed1c..6129a2d2 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -1089,8 +1089,8 @@ def test_read_write_cycle(file):
     new_problem = montepy.MCNP_Problem("foo")
     # verify lines are similar
     fh.seek(0)
+    lines = [line.rstrip() for line in fh]
+    [print(line) for line in lines]
     with open(file, "r") as gold_fh:
-        for gold_line, new_line in zip(gold_fh, fh):
-            pretty_line = new_line.rstrip()
-            print(pretty_line)
-            assert pretty_line == gold_line.rstrip()
+        for gold_line, new_line in zip(gold_fh, lines):
+            assert new_line == gold_line.rstrip()

From e377297366acad07594137a8654191a84cb393ea Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 10:03:13 -0500
Subject: [PATCH 06/71] Expand tabs and update test to new inputs.

---
 tests/test_integration.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 6129a2d2..85c5e95f 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -484,7 +484,7 @@ def test_importance_format_unmutated(importance_problem):
     print(output)
     assert len(output) == 2
     assert "imp:n,p 1 1 1 0 3" == output[0]
-    assert "imp:e   0 0 0 1 2" == output[1]
+    assert "imp:e   0 2R 1 2" == output[1]
 
 
 def test_importance_format_mutated(importance_problem):
@@ -1093,4 +1093,4 @@ def test_read_write_cycle(file):
     [print(line) for line in lines]
     with open(file, "r") as gold_fh:
         for gold_line, new_line in zip(gold_fh, lines):
-            assert new_line == gold_line.rstrip()
+            assert new_line == gold_line.rstrip().expandtabs(8)

From 37cf930b6ea1996cce82941e27cfcb3979818cb4 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 14:48:48 -0500
Subject: [PATCH 07/71] tried to use interpolation for test.

---
 tests/inputs/test_importance.imcnp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/inputs/test_importance.imcnp b/tests/inputs/test_importance.imcnp
index 8580b633..1cd45ea6 100644
--- a/tests/inputs/test_importance.imcnp
+++ b/tests/inputs/test_importance.imcnp
@@ -41,7 +41,7 @@ MT3 lwtr.23t
 C execution
 ksrc 0 0 0
 imp:n,p 1 1 1 0 3
-imp:e   0 2R 1 2
+imp:e   0 2i 1 2
 kcode 100000 1.000 50 1050
 phys:p j 1 2j 1
 mode n p e

From 0eab3c9d9b1054bceb8f0b090643f83eac863562 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 15:43:24 -0500
Subject: [PATCH 08/71] Actually replicated #499 with multiple shortcuts in a
 line.

---
 tests/inputs/test_importance.imcnp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/inputs/test_importance.imcnp b/tests/inputs/test_importance.imcnp
index 1cd45ea6..3c44d740 100644
--- a/tests/inputs/test_importance.imcnp
+++ b/tests/inputs/test_importance.imcnp
@@ -41,7 +41,7 @@ MT3 lwtr.23t
 C execution
 ksrc 0 0 0
 imp:n,p 1 1 1 0 3
-imp:e   0 2i 1 2
+imp:e   0 2r 1 r
 kcode 100000 1.000 50 1050
 phys:p j 1 2j 1
 mode n p e

From 2f928648a56968adf838640d4d8a815b31722df8 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 17:31:17 -0500
Subject: [PATCH 09/71] Updated test again with new importance gold.

---
 tests/test_integration.py | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 85c5e95f..5c2b3d1e 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -484,7 +484,7 @@ def test_importance_format_unmutated(importance_problem):
     print(output)
     assert len(output) == 2
     assert "imp:n,p 1 1 1 0 3" == output[0]
-    assert "imp:e   0 2R 1 2" == output[1]
+    assert "imp:e   0 2r 1 r" == output[1]
 
 
 def test_importance_format_mutated(importance_problem):
@@ -1073,15 +1073,18 @@ def test_alternate_encoding():
 
 @pytest.mark.parametrize(
     "file",
-    set((Path("tests") / "inputs").iterdir())
-    - {
-        Path("tests") / "inputs" / p
-        for p in constants.BAD_INPUTS | constants.IGNORE_FILES
-    },
+    {"tests/inputs/test_importance.imcnp"},
+    # set((Path("tests") / "inputs").iterdir())
+    # - {
+    #    Path("tests") / "inputs" / p
+    #    for p in constants.BAD_INPUTS | constants.IGNORE_FILES
+    # },
 )
 def test_read_write_cycle(file):
     print(f"Testing against {file} *********************")
     problem = montepy.read_input(file)
+    print(problem.cells._importance._real_tree[montepy.particle.Particle.ELECTRON])
+    print()
     fh = io.StringIO()
     problem.write_problem(fh)
     fh.seek(0)

From c577a88cd2d26a64cebe61274a0de6eb456a8561 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 17:32:11 -0500
Subject: [PATCH 10/71] Fixed logic to detect when you can smash repeats
 together.

---
 montepy/input_parser/syntax_node.py | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index c9775d90..38650b78 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1834,7 +1834,7 @@ def _can_consume_node(self, node, direction, last_edge_shortcut=False):
         :type node: ValueNode
         :param direction: the direct to go in. Must be in {-1, 1}
         :type direction: int
-        :param last_edge_shortcut: Whether or the previous node in the list was
+        :param last_edge_shortcut: Whether or not the previous node in the list was
             part of a different shortcut
         :type last_edge_shortcut: bool
         :returns: true it can be consumed.
@@ -1967,7 +1967,24 @@ def _format_jump(self):
         return f"{num_jumps.format()}{j}"
 
     def _format_repeat(self, leading_node=None):
-        if leading_node is not None:
+        def can_use_last_node(node):
+            """Last node can be used if
+            - it's a basic ValueNode
+            - it's a different shortcut that concludes itself well.
+            - it's also a repeat, with the same edge values.
+            """
+            return isinstance(node, ValueNode) or (
+                isinstance(node, type(self))
+                and (
+                    leading_node._type != Shortcuts.REPEAT
+                    or (
+                        leading_node._type == Shortcuts.REPEAT
+                        and math.isclose(self.nodes[0].value, node.nodes[-1].value)
+                    )
+                )
+            )
+
+        if can_use_last_node(leading_node):
             first_val = ""
             num_extra = 0
         else:

From c4b56aceeaaed49e6d980050b9985f7bf7911418 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 17:37:20 -0500
Subject: [PATCH 11/71] Updated logic to test for matching value with
 valueNode.

---
 montepy/input_parser/syntax_node.py | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 38650b78..87f4608c 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1969,11 +1969,14 @@ def _format_jump(self):
     def _format_repeat(self, leading_node=None):
         def can_use_last_node(node):
             """Last node can be used if
-            - it's a basic ValueNode
+            - it's a basic ValueNode that matches this repeat
             - it's a different shortcut that concludes itself well.
             - it's also a repeat, with the same edge values.
             """
-            return isinstance(node, ValueNode) or (
+            return (
+                isinstance(node, ValueNode)
+                and math.isclose(node.value, self.nodes[0].value)
+            ) or (
                 isinstance(node, type(self))
                 and (
                     leading_node._type != Shortcuts.REPEAT

From 4f71d4ac87edef95f777cd523b1954ae7d5e769f Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 17:37:31 -0500
Subject: [PATCH 12/71] Undid debugging.

---
 tests/test_integration.py | 13 +++++--------
 1 file changed, 5 insertions(+), 8 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 5c2b3d1e..37c8cb26 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -1073,18 +1073,15 @@ def test_alternate_encoding():
 
 @pytest.mark.parametrize(
     "file",
-    {"tests/inputs/test_importance.imcnp"},
-    # set((Path("tests") / "inputs").iterdir())
-    # - {
-    #    Path("tests") / "inputs" / p
-    #    for p in constants.BAD_INPUTS | constants.IGNORE_FILES
-    # },
+    set((Path("tests") / "inputs").iterdir())
+    - {
+        Path("tests") / "inputs" / p
+        for p in constants.BAD_INPUTS | constants.IGNORE_FILES
+    },
 )
 def test_read_write_cycle(file):
     print(f"Testing against {file} *********************")
     problem = montepy.read_input(file)
-    print(problem.cells._importance._real_tree[montepy.particle.Particle.ELECTRON])
-    print()
     fh = io.StringIO()
     problem.write_problem(fh)
     fh.seek(0)

From 4284c03cd326b6a238ffaa617fbb42321c1b26bc Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 28 Aug 2024 17:40:59 -0500
Subject: [PATCH 13/71] Updated logic to always check for edge node matching.

---
 montepy/input_parser/syntax_node.py | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 87f4608c..e1e5b980 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1970,21 +1970,14 @@ def _format_repeat(self, leading_node=None):
         def can_use_last_node(node):
             """Last node can be used if
             - it's a basic ValueNode that matches this repeat
-            - it's a different shortcut that concludes itself well.
-            - it's also a repeat, with the same edge values.
+            - it's also a shortcut, with the same edge values.
             """
             return (
                 isinstance(node, ValueNode)
                 and math.isclose(node.value, self.nodes[0].value)
             ) or (
                 isinstance(node, type(self))
-                and (
-                    leading_node._type != Shortcuts.REPEAT
-                    or (
-                        leading_node._type == Shortcuts.REPEAT
-                        and math.isclose(self.nodes[0].value, node.nodes[-1].value)
-                    )
-                )
+                and (math.isclose(self.nodes[0].value, node.nodes[-1].value))
             )
 
         if can_use_last_node(leading_node):

From 4c7265e2ef50247cf63c10f9f802ac978ba922b0 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 07:41:20 -0500
Subject: [PATCH 14/71] Updated tests to cover more edge cases.

---
 tests/test_syntax_parsing.py | 133 +++++++++++++++++++----------------
 1 file changed, 71 insertions(+), 62 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index e4411d32..5653beb2 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -823,38 +823,6 @@ def test_shortcut_end_padding_setter(self):
         with self.assertRaises(TypeError):
             short.end_padding = " "
 
-    """
-    Most examples, unless otherwise noted are taken from Section 2.8.1
-    of LA-UR-17-29981.
-    """
-    tests = {
-        "1 3M 2r": [1, 3, 3, 3],
-        # unofficial
-        "0.01 2ILOG 10": [0.01, 0.1, 1, 10],
-        "1 3M I 4": [1, 3, 3.5, 4],
-        "1 3M 3M": [1, 3, 9],
-        "1 2R 2I 2.5": [1, 1, 1, 1.5, 2, 2.5],
-        "1 R 2m": [1, 1, 2],
-        "1 R R": [1, 1, 1],
-        "1 2i 4 3m": [1, 2, 3, 4, 12],
-        # unofficial
-        "1 i 3": [1, 2, 3],
-        # unofficial
-        "1 ilog 100": [1, 10, 100],
-        # last official one
-        "1 2i 4 2i 10": [
-            1,
-            2,
-            3,
-            4,
-            6,
-            8,
-            10,
-        ],
-        "1 2j 4": [1, montepy.Jump(), montepy.Jump(), 4],
-        "1 j": [1, montepy.Jump()],
-    }
-
     def test_shortcut_expansion(self):
         invalid = [
             "3J 4R",
@@ -869,7 +837,7 @@ def test_shortcut_expansion(self):
         ]
 
         parser = ShortcutTestFixture()
-        for test, answer in self.tests.items():
+        for test, answer in tests.items():
             print(test)
             input = Input([test], BlockType.DATA)
             parsed = parser.parse(input.tokenize())
@@ -908,35 +876,76 @@ def test_shortcut_geometry_expansion(self):
             for val, gold in zip(parsed, answer):
                 self.assertAlmostEqual(val.value, gold)
 
-    def test_shortcut_format(self):
-        parser = ShortcutTestFixture()
-        for in_str, answer in [
-            ("1 5R", "1 5R"),
-            ("1 5r", "1 5r"),
-            ("1 r", "1 r"),
-            ("1 2i 5", "1 2i 5"),
-            ("1 2ilog 5", "1 2ilog 5"),
-            ("1 r 2i 5", "1 r 2i 5"),
-            ("1 r 2ilog 5", "1 r 2ilog 5"),
-            ("1 5M", "1 5M"),
-            ("1 5m", "1 5m"),
-            ("2j ", "2j "),
-            ("2j", "2j"),
-            ("2J ", "2J "),
-            ("J", "J"),
-        ]:
-            print(in_str, answer)
-            input = Input([in_str], BlockType.CELL)
-            shortcut = parser.parse(input.tokenize())
-            self.assertEqual(shortcut.format(), answer)
-        # try jump with empty jump shortcut
-        shortcut.nodes.clear()
-        self.assertEqual(shortcut.format(), "")
-        for in_str in self.tests.keys():
-            print(in_str)
-            input = Input([in_str], BlockType.CELL)
-            shortcut = parser.parse(input.tokenize())
-            self.assertEqual(shortcut.format(), in_str)
+
+"""
+Most examples, unless otherwise noted are taken from Section 2.8.1
+of LA-UR-17-29981.
+"""
+tests = {
+    "1 3M 2r": [1, 3, 3, 3],
+    # unofficial
+    "0.01 2ILOG 10": [0.01, 0.1, 1, 10],
+    "1 3M I 4": [1, 3, 3.5, 4],
+    "1 3M 3M": [1, 3, 9],
+    "1 2R 2I 2.5": [1, 1, 1, 1.5, 2, 2.5],
+    "1 R 2m": [1, 1, 2],
+    "1 R R": [1, 1, 1],
+    "1 2i 4 3m": [1, 2, 3, 4, 12],
+    # unofficial
+    "1 i 3": [1, 2, 3],
+    # unofficial
+    "1 ilog 100": [1, 10, 100],
+    # last official one
+    "1 2i 4 2i 10": [
+        1,
+        2,
+        3,
+        4,
+        6,
+        8,
+        10,
+    ],
+    "1 2j 4": [1, montepy.Jump(), montepy.Jump(), 4],
+    "1 j": [1, montepy.Jump()],
+}
+
+
+@pytest.mark.parametrize(
+    "in_str, answer",
+    [
+        ("1 5R", "1 5R"),
+        ("1 5r", "1 5r"),
+        ("1 r", "1 r"),
+        ("1 r 2 2r", "1 r 2 2r"),
+        ("1 J 5 2R", "1 J 5 2R"),
+        ("1 2i 5", "1 2i 5"),
+        ("1 2ilog 5", "1 2ilog 5"),
+        ("1 r 2i 5", "1 r 2i 5"),
+        ("1 2i 5 r", "1 2i 5 r"),
+        ("1 r 2ilog 5", "1 r 2ilog 5"),
+        ("1 5M", "1 5M"),
+        ("1 5m", "1 5m"),
+        ("1 5m 2r", "1 5m 2r"),
+        ("2j ", "2j "),
+        ("2j", "2j"),
+        ("2J ", "2J "),
+        ("J", "J"),
+    ],
+)
+def test_shortcut_format(in_str, answer):
+    parser = ShortcutTestFixture()
+    print(in_str, answer)
+    input = Input([in_str], BlockType.CELL)
+    shortcut = parser.parse(input.tokenize())
+    assert shortcut.format() == answer
+    # try jump with empty jump shortcut
+    shortcut.nodes.clear()
+    assert shortcut.format() == ""
+    for in_str in tests.keys():
+        print(in_str)
+        input = Input([in_str], BlockType.CELL)
+        shortcut = parser.parse(input.tokenize())
+        assert shortcut.format() == in_str
 
 
 class ShortcutTestFixture(MCNP_Parser):

From 15298861bcf6268189e5f959593b857d13e423af Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 07:43:26 -0500
Subject: [PATCH 15/71] Made logic clearer and more pythonic.

---
 montepy/input_parser/syntax_node.py | 16 +++++++++-------
 1 file changed, 9 insertions(+), 7 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index e1e5b980..911649d4 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1972,13 +1972,15 @@ def can_use_last_node(node):
             - it's a basic ValueNode that matches this repeat
             - it's also a shortcut, with the same edge values.
             """
-            return (
-                isinstance(node, ValueNode)
-                and math.isclose(node.value, self.nodes[0].value)
-            ) or (
-                isinstance(node, type(self))
-                and (math.isclose(self.nodes[0].value, node.nodes[-1].value))
-            )
+            if isinstance(node, ValueNode):
+                value = node.value
+            elif isinstance(node, ShortcutNode):
+                value = node.nodes[-1].value
+            else:
+                return False
+            if value is None:
+                return False
+            return math.isclose(self.nodes[0].value, value)
 
         if can_use_last_node(leading_node):
             first_val = ""

From 5e0f8ab7a3929564b20423bf9f226af5322ba436 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 08:28:55 -0500
Subject: [PATCH 16/71] Removed implicit importance to avoid parrot out bug.

---
 tests/inputs/test_complement_edge.imcnp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/inputs/test_complement_edge.imcnp b/tests/inputs/test_complement_edge.imcnp
index 5d39a8a4..e83b83fc 100644
--- a/tests/inputs/test_complement_edge.imcnp
+++ b/tests/inputs/test_complement_edge.imcnp
@@ -11,6 +11,7 @@ C Bounding water outer capsule
      U=6000 IMP:N=1
 61441 814 0.087
       (-61867 61870 -61759):(-61868 61869 -61759): (-61870 61868 -61759 61758)
+      IMP:N=0
 
 1 SO 5.0
 2 PZ 0.0

From 2d3aa5417ef78dbcef318fa3b2427cfe99e2e86e Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 08:34:17 -0500
Subject: [PATCH 17/71] Fixed bug in validate for cylinder_on_axis.

---
 montepy/surfaces/cylinder_on_axis.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/montepy/surfaces/cylinder_on_axis.py b/montepy/surfaces/cylinder_on_axis.py
index c557d39f..0ade7c00 100644
--- a/montepy/surfaces/cylinder_on_axis.py
+++ b/montepy/surfaces/cylinder_on_axis.py
@@ -44,7 +44,7 @@ def radius(self):
 
     def validate(self):
         super().validate()
-        if not self.radius:
+        if self.radius is None:
             raise IllegalState(f"Surface: {self.number} does not have a radius set.")
 
     def find_duplicate_surfaces(self, surfaces, tolerance):

From 8ff6b69ec61ac4ea87f293081ccd1c1a6eaf3e6e Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 09:18:33 -0500
Subject: [PATCH 18/71] Made it possible to have integer interpolations.

---
 montepy/input_parser/cell_parser.py | 3 ++-
 montepy/input_parser/syntax_node.py | 9 +++++++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/montepy/input_parser/cell_parser.py b/montepy/input_parser/cell_parser.py
index e728922f..7f141a29 100644
--- a/montepy/input_parser/cell_parser.py
+++ b/montepy/input_parser/cell_parser.py
@@ -112,7 +112,8 @@ def geometry_term(self, p):
         "geometry_term LOG_INTERPOLATE padding number_phrase",
     )
     def geometry_term(self, p):
-        shortcut = syntax_node.ShortcutNode(p)
+        # TODO mark this is a shortcut
+        shortcut = syntax_node.ShortcutNode(p, data_type=int)
         node_iter = iter(shortcut.nodes)
         if isinstance(p.geometry_term, syntax_node.GeometryTree):
             left = p.geometry_term
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 911649d4..d46f0989 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1674,13 +1674,14 @@ class ShortcutNode(ListNode):
     }
     _num_finder = re.compile(r"\d+")
 
-    def __init__(self, p=None, short_type=None):
+    def __init__(self, p=None, short_type=None, data_type=float):
         self._type = None
         self._end_pad = None
         self._nodes = collections.deque()
         self._original = []
         self._full = False
         self._num_node = ValueNode(None, float, never_pad=True)
+        self._data_type = data_type
         if p is not None:
             for search_strs, shortcut in self._shortcut_names.items():
                 for search_str in search_strs:
@@ -1820,7 +1821,11 @@ def _expand_interpolate(self, p):
                 new_val = 10 ** (begin + spacing * (i + 1))
             else:
                 new_val = begin + spacing * (i + 1)
-            self.append(ValueNode(str(new_val), float, never_pad=True))
+            self.append(
+                ValueNode(
+                    str(self._data_type(new_val)), self._data_type, never_pad=True
+                )
+            )
         self._begin = begin
         self._end = end
         self._spacing = spacing

From 73800b83a8f2cb4712acfd7a84de7d2df212bb59 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 09:58:38 -0500
Subject: [PATCH 19/71] Started framework for geometry tree recompressing
 interpolations.

---
 montepy/input_parser/cell_parser.py |  1 +
 montepy/input_parser/syntax_node.py | 10 ++++++++--
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/cell_parser.py b/montepy/input_parser/cell_parser.py
index 7f141a29..e5cea29e 100644
--- a/montepy/input_parser/cell_parser.py
+++ b/montepy/input_parser/cell_parser.py
@@ -126,6 +126,7 @@ def geometry_term(self, p):
                 "*",
                 left,
                 node,
+                is_shortcut=True,
             )
             left = new_tree
         return new_tree
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index d46f0989..cd394b5f 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -295,26 +295,32 @@ class GeometryTree(SyntaxNodeBase):
     :type right: GeometryTree, ValueNode
     """
 
-    def __init__(self, name, tokens, op, left, right=None):
+    def __init__(self, name, tokens, op, left, right=None, is_shortcut=False):
         super().__init__(name)
         assert all(list(map(lambda v: isinstance(v, SyntaxNodeBase), tokens.values())))
         self._nodes = tokens
         self._operator = Operator(op)
         self._left_side = left
         self._right_side = right
+        self._is_shortcut = is_shortcut
 
     def __str__(self):
-        return f"Geometry: ( {self._left_side} {self._operator} {self._right_side} )"
+        return f"Geometry: ( {self._left_side} {self._operator} {self._right_side} {'Short' if self._is_shortcut else ''})"
 
     def __repr__(self):
         return str(self)
 
     def format(self):
+        if self._is_shortcut:
+            return self._format_shortcut()
         ret = ""
         for node in self.nodes.values():
             ret += node.format()
         return ret
 
+    def _format_shortcut(self):
+        pass
+
     @property
     def comments(self):
         for node in self.nodes.values():

From b8b8b3b5cd87bafff5267960bb0a474a7a25e843 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 11:43:22 -0500
Subject: [PATCH 20/71] Switched to preserving shortcut type for geometry
 stuff.

---
 montepy/input_parser/cell_parser.py |  2 +-
 montepy/input_parser/syntax_node.py | 24 ++++++++++++++++++++----
 2 files changed, 21 insertions(+), 5 deletions(-)

diff --git a/montepy/input_parser/cell_parser.py b/montepy/input_parser/cell_parser.py
index e5cea29e..5e05a38f 100644
--- a/montepy/input_parser/cell_parser.py
+++ b/montepy/input_parser/cell_parser.py
@@ -126,7 +126,7 @@ def geometry_term(self, p):
                 "*",
                 left,
                 node,
-                is_shortcut=True,
+                short_type=shortcut.type,
             )
             left = new_tree
         return new_tree
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index cd394b5f..48dd036b 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -295,29 +295,45 @@ class GeometryTree(SyntaxNodeBase):
     :type right: GeometryTree, ValueNode
     """
 
-    def __init__(self, name, tokens, op, left, right=None, is_shortcut=False):
+    def __init__(self, name, tokens, op, left, right=None, short_type=None):
         super().__init__(name)
         assert all(list(map(lambda v: isinstance(v, SyntaxNodeBase), tokens.values())))
         self._nodes = tokens
         self._operator = Operator(op)
         self._left_side = left
         self._right_side = right
-        self._is_shortcut = is_shortcut
+        self._short_type = short_type
 
     def __str__(self):
-        return f"Geometry: ( {self._left_side} {self._operator} {self._right_side} {'Short' if self._is_shortcut else ''})"
+        return (
+            f"Geometry: ( {self._left_side} {self._operator} {self._right_side} "
+            f"{f'Short:{self._short_type.value}' if self._short_type else ''})"
+        )
 
     def __repr__(self):
         return str(self)
 
     def format(self):
-        if self._is_shortcut:
+        if self._check_all_shortcut():
             return self._format_shortcut()
         ret = ""
         for node in self.nodes.values():
             ret += node.format()
         return ret
 
+    def _check_all_shortcut(self):
+        if not self._short_type:
+            return False
+        if isinstance(self.left, type(self)) and not self.left._check_all_shortcut():
+            return False
+        if (
+            self.right is not None
+            and isinstance(self.right, type(self))
+            and self.right._check_all_shortcut()
+        ):
+            return False
+        return True
+
     def _format_shortcut(self):
         pass
 

From 058245702e35f6578cce52b1cc5e2573129f8c9d Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 11:44:13 -0500
Subject: [PATCH 21/71] Exposed shortcut type.

---
 montepy/input_parser/syntax_node.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 48dd036b..eadd557f 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1751,6 +1751,13 @@ def end_padding(self, padding):
             )
         self._end_pad = padding
 
+    @property
+    def type(self):
+        """
+        TODO
+        """
+        return self._type
+
     def __repr__(self):
         return f"(shortcut:{self._type}: {self.nodes})"
 

From dd16501e333d43fa48fcbec663b8ec3c6dde9d1b Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 11:44:33 -0500
Subject: [PATCH 22/71] Made system to make a shortcutNode from scratch kind
 of.

---
 montepy/input_parser/syntax_node.py | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index eadd557f..a1bdbc76 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1734,6 +1734,19 @@ def __init__(self, p=None, short_type=None, data_type=float):
                 self._num_node = ValueNode(None, int, never_pad=True)
             self._end_pad = PaddingNode(" ")
 
+    def load_nodes(self, nodes):
+        """
+        TODO
+        """
+        self._nodes = collections.deque(nodes)
+        if self.type in {Shortcuts.INTERPOLATE, Shortcuts.LOG_INTERPOLATE}:
+            self._begin = nodes[0].value
+            self._end = nodes[-1].value
+            if self.type == Shortcuts.LOG_INTERPOLATE:
+                self._begin = math.log10(self._begin)
+                self._end = math.log10(self._end)
+            self._spacing = (self._end - self._begin) / (len(nodes) - 1)
+
     @property
     def end_padding(self):
         """

From e9d2e4e4a320363906a37fe399e967f78b76c06b Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 11:45:00 -0500
Subject: [PATCH 23/71] Formatted shortcuts inside of GeometryTree

---
 montepy/input_parser/syntax_node.py | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index a1bdbc76..07580120 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -335,7 +335,13 @@ def _check_all_shortcut(self):
         return True
 
     def _format_shortcut(self):
-        pass
+        new_vals = [n for n in self.flatten() if isinstance(n, ValueNode)]
+        list_wrap = ListNode("list wrapper")
+        short = ShortcutNode(short_type=self._short_type)
+        short.load_nodes(new_vals)
+        list_wrap.append(short)
+        list_wrap.update_with_new_values(new_vals)
+        return list_wrap.format()
 
     @property
     def comments(self):

From 5d17fd1984777dec0a0b0c2baec3a49a7a7defdf Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Thu, 29 Aug 2024 14:02:00 -0500
Subject: [PATCH 24/71] Updated tests to avoid complex reads and implicit
 importances.

---
 tests/test_integration.py | 40 +++++++++++++++++++++++++++++++++++----
 1 file changed, 36 insertions(+), 4 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 37c8cb26..8b7214d7 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -1071,17 +1071,28 @@ def test_alternate_encoding():
     )
 
 
+_SKIP_LINES = {
+    # skip lines of added implied importances
+    "tests/inputs/test_universe_data.imcnp": {5: True, 14: True, 15: True},
+}
+
+
 @pytest.mark.parametrize(
     "file",
     set((Path("tests") / "inputs").iterdir())
     - {
-        Path("tests") / "inputs" / p
-        for p in constants.BAD_INPUTS | constants.IGNORE_FILES
+        Path("tests")
+        / "inputs"
+        / p  #                           Skip complexity of read
+        for p in constants.BAD_INPUTS
+        | constants.IGNORE_FILES
+        | {"testRead.imcnp", "readEdgeCase.imcnp"}
     },
 )
 def test_read_write_cycle(file):
     print(f"Testing against {file} *********************")
     problem = montepy.read_input(file)
+    SKIPPERS = _SKIP_LINES.get(str(file), {})
     fh = io.StringIO()
     problem.write_problem(fh)
     fh.seek(0)
@@ -1092,5 +1103,26 @@ def test_read_write_cycle(file):
     lines = [line.rstrip() for line in fh]
     [print(line) for line in lines]
     with open(file, "r") as gold_fh:
-        for gold_line, new_line in zip(gold_fh, lines):
-            assert new_line == gold_line.rstrip().expandtabs(8)
+        gold_fh_iter = iter(gold_fh)
+        lines_iter = iter(lines)
+        for i, (gold_line, new_line) in enumerate(zip(gold_fh_iter, lines_iter)):
+            if i in SKIPPERS:
+                # True means skip new file line
+                if SKIPPERS[i]:
+                    new_line = next(lines_iter)
+                else:
+                    gold_line = next(gold_fh_iter)
+            # edge case override for not fixing #527.
+            if str(file) == "tests/inputs/test_interp_edge.imcnp" and i == 1:
+                assert new_line == "10214   0    (1  2I 4 )"
+                continue
+            try:
+                assert new_line == gold_line.rstrip().expandtabs(8)
+            except AssertionError as e:
+                # handle case of making importance explicit
+                if "IMP:n=0.0" in new_line:
+                    assert (
+                        new_line.replace("IMP:n=0.0", "").rstrip() == gold_line.rstrip()
+                    )
+                else:
+                    raise e

From ba4ce30164fd1ecfc8b156936d3f708b78337ab2 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Thu, 29 Aug 2024 20:43:32 -0500
Subject: [PATCH 25/71] Replicated #352.

---
 tests/inputs/test_trail_comment_edge.imcnp | 11 +++++++++++
 tests/test_edge_cases.py                   | 11 +++++++++++
 tests/test_integration.py                  | 10 ++++++++++
 3 files changed, 32 insertions(+)
 create mode 100644 tests/inputs/test_trail_comment_edge.imcnp

diff --git a/tests/inputs/test_trail_comment_edge.imcnp b/tests/inputs/test_trail_comment_edge.imcnp
new file mode 100644
index 00000000..b921151e
--- /dev/null
+++ b/tests/inputs/test_trail_comment_edge.imcnp
@@ -0,0 +1,11 @@
+Model with issues trailing comments
+100103  3926  5.00000E-02 (-1          -1  1):   $ Lower Rodlet Sodium Bond
+                          (-1  1  -1   1)    u=424 
+c
+c comment for next cell... 
+c
+2 0 -1
+
+1 SO 5
+
+M3926 1001.80c 1.0
diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
index e9cf3ca5..87654701 100644
--- a/tests/test_edge_cases.py
+++ b/tests/test_edge_cases.py
@@ -3,6 +3,7 @@
 import io
 import montepy
 from montepy.errors import *
+from pathlib import Path
 import os
 
 import pytest
@@ -231,3 +232,13 @@ def test_universe_after_comment():
             os.remove(out_file)
         except FileNotFoundError:
             pass
+
+
+def test_trailing_comment_edge():
+    problem = montepy.read_input(
+        Path("tests") / "inputs" / "test_trail_comment_edge.imcnp"
+    )
+    print(problem.cells[100103]._tree)
+    print(problem.cells[2]._tree)
+    assert len(problem.cells[2].leading_comments) == 1
+    assert False
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 8b7214d7..8517e768 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -71,6 +71,16 @@ def test_lazy_comments_check(simple_problem):
     print(material2._tree.get_trailing_comment())
 
 
+def test_moving_trail_comments(universe_problem):
+    problem = copy.deepcopy(universe_problem)
+    mat = problem.materials[2]
+    idx = problem.data_inputs.index(mat)
+    print(problem.data_inputs[idx - 1]._tree)
+    print(mat._tree)
+    assert len(mat.comments) == 1
+    assert len(mat.leading_comments) == 1
+
+
 def test_material_parsing(simple_problem):
     mat_numbers = [1, 2, 3]
     for i, mat in enumerate(simple_problem.materials):

From 0f79257aea1b3a6c1560a0b33a5e4ac3ea4b7687 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Thu, 29 Aug 2024 21:39:47 -0500
Subject: [PATCH 26/71] Fixed test to expect three leading comments.

---
 tests/test_edge_cases.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/tests/test_edge_cases.py b/tests/test_edge_cases.py
index 87654701..4745d76e 100644
--- a/tests/test_edge_cases.py
+++ b/tests/test_edge_cases.py
@@ -238,7 +238,4 @@ def test_trailing_comment_edge():
     problem = montepy.read_input(
         Path("tests") / "inputs" / "test_trail_comment_edge.imcnp"
     )
-    print(problem.cells[100103]._tree)
-    print(problem.cells[2]._tree)
-    assert len(problem.cells[2].leading_comments) == 1
-    assert False
+    assert len(problem.cells[2].leading_comments) == 3

From fabfb52a5b2ea02674d54f91e7abbea1eab17306 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Thu, 29 Aug 2024 21:41:18 -0500
Subject: [PATCH 27/71] Made system to ignore default parameters for trailing
 comments.

---
 montepy/cell.py                     |  2 +-
 montepy/input_parser/syntax_node.py | 12 +++++++++---
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/montepy/cell.py b/montepy/cell.py
index 98d6ac5a..c2600fd0 100644
--- a/montepy/cell.py
+++ b/montepy/cell.py
@@ -142,7 +142,7 @@ def _parse_keyword_modifiers(self):
                         break
             if (class_pref == "imp" and not has_imp) or class_pref != "imp":
                 tree = getattr(self, attr)._tree
-                self._tree["parameters"].append(tree)
+                self._tree["parameters"].append(tree, True)
 
     def _load_blank_modifiers(self):
         """
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 07580120..59781a56 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -2287,7 +2287,7 @@ def __init__(self):
         super().__init__("parameters")
         self._nodes = {}
 
-    def append(self, val):
+    def append(self, val, is_default=False):
         """
         Append the node to this node.
 
@@ -2296,6 +2296,8 @@ def append(self, val):
 
         :param val: the parameter to append.
         :type val: SyntaxNode
+        :param is_default: whether this parameter was added as a default tree not from the user.
+        :type is_default: bool
         """
         classifier = val["classifier"]
         key = (
@@ -2304,6 +2306,8 @@ def append(self, val):
         ).lower()
         if key in self._nodes:
             raise RedundantParameterSpecification(key, val)
+        if is_default:
+            val._is_default = True
         self._nodes[key] = val
 
     def __str__(self):
@@ -2325,8 +2329,10 @@ def format(self):
         return ret
 
     def get_trailing_comment(self):
-        tail = next(reversed(self.nodes.items()))
-        return tail[1].get_trailing_comment()
+        for key, node in reversed(self.nodes.items()):
+            if hasattr(node, "_is_default"):
+                continue
+            return node.get_trailing_comment()
 
     def _delete_trailing_comment(self):
         tail = next(reversed(self.nodes.items()))

From f033d97480be64a668e95e285abae63404b6f66c Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Fri, 30 Aug 2024 08:39:20 -0500
Subject: [PATCH 28/71] Avoid cross-block trailing comment transfer.

---
 montepy/mcnp_problem.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/montepy/mcnp_problem.py b/montepy/mcnp_problem.py
index 8cae65ae..a284064d 100644
--- a/montepy/mcnp_problem.py
+++ b/montepy/mcnp_problem.py
@@ -250,6 +250,7 @@ def parse_input(self, check_input=False, replace=True):
         """
         trailing_comment = None
         last_obj = None
+        last_block = None
         OBJ_MATCHER = {
             block_type.BlockType.CELL: (Cell, self._cells),
             block_type.BlockType.SURFACE: (
@@ -272,6 +273,9 @@ def parse_input(self, check_input=False, replace=True):
                     self._title = input
 
                 elif isinstance(input, mcnp_input.Input):
+                    if last_block != input.block_type:
+                        trailing_comment = None
+                        last_block = input.block_type
                     obj_parser, obj_container = OBJ_MATCHER[input.block_type]
                     if len(input.input_lines) > 0:
                         try:

From 3edca07a022f53652127c9e26815155e112f764f Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Fri, 30 Aug 2024 08:43:32 -0500
Subject: [PATCH 29/71] Updated delete trailing comment to match new
 get_trailing_comment.

---
 montepy/input_parser/syntax_node.py | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 59781a56..fc76a4bc 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -2329,14 +2329,16 @@ def format(self):
         return ret
 
     def get_trailing_comment(self):
-        for key, node in reversed(self.nodes.items()):
+        for node in reversed(self.nodes.values()):
             if hasattr(node, "_is_default"):
                 continue
             return node.get_trailing_comment()
 
     def _delete_trailing_comment(self):
-        tail = next(reversed(self.nodes.items()))
-        tail[1]._delete_trailing_comment()
+        for node in reversed(self.nodes.values()):
+            if hasattr(node, "_is_default"):
+                continue
+            node._delete_trailing_comment()
 
     @property
     def comments(self):

From 08a0c989cad78364f2ae36bfe5d08bb33af92b9f Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Fri, 30 Aug 2024 14:53:32 -0500
Subject: [PATCH 30/71] Skip empty nodes in the tail.

---
 montepy/input_parser/syntax_node.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index fc76a4bc..bd323baa 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -259,7 +259,7 @@ def get_trailing_comment(self):
         if len(self.nodes) == 0:
             return
         for node in reversed(self.nodes.values()):
-            if node is not None:
+            if node is not None and len(node) > 0:
                 return node.get_trailing_comment()
 
     def _delete_trailing_comment(self):

From bd3e31fa0da156b8c52915e64563287ffeffbb50 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 11:56:59 -0500
Subject: [PATCH 31/71] Updated test to be more thurough)

---
 tests/test_integration.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 8517e768..508b946f 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -75,10 +75,11 @@ def test_moving_trail_comments(universe_problem):
     problem = copy.deepcopy(universe_problem)
     mat = problem.materials[2]
     idx = problem.data_inputs.index(mat)
-    print(problem.data_inputs[idx - 1]._tree)
-    print(mat._tree)
+    dat = problem.data_inputs[idx - 1]
     assert len(mat.comments) == 1
     assert len(mat.leading_comments) == 1
+    assert len(dat.leading_comments) == 0
+    assert len(dat.comments) == 0
 
 
 def test_material_parsing(simple_problem):

From 081d4dbe61fc13ef2ba372313e0a77d8c5ca3677 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 11:58:53 -0500
Subject: [PATCH 32/71] Updated ClassifierNode handling of padding for trailing
 and str.

---
 montepy/input_parser/syntax_node.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index bd323baa..12f4a8af 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -2229,7 +2229,8 @@ def __str__(self):
     def __repr__(self):
         return (
             f"(Classifier: mod: {self.modifier}, prefix: {self.prefix}, "
-            f"number: {self.number}, particles: {self.particles})"
+            f"number: {self.number}, particles: {self.particles},"
+            f" padding: {self.padding})"
         )
 
     @property
@@ -2239,6 +2240,10 @@ def comments(self):
         else:
             yield from []
 
+    def get_trailing_comment(self):
+        if self.padding:
+            return self.padding.get_trailing_comment()
+
     def flatten(self):
         ret = []
         if self.modifier:

From 50299464e12d1a58fc22a1662ecc46881ca601c4 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 12:00:13 -0500
Subject: [PATCH 33/71] Updated get trailing comment logic to handle valueNodes
 in tree.

---
 montepy/input_parser/syntax_node.py | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 12f4a8af..0e58f52a 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -259,8 +259,12 @@ def get_trailing_comment(self):
         if len(self.nodes) == 0:
             return
         for node in reversed(self.nodes.values()):
-            if node is not None and len(node) > 0:
-                return node.get_trailing_comment()
+            if node is not None:
+                if isinstance(node, ValueNode):
+                    if node.value is not None:
+                        return node.get_trailing_comment()
+                elif len(node) > 0:
+                    return node.get_trailing_comment()
 
     def _delete_trailing_comment(self):
         tail = next(reversed(self.nodes.items()))

From f87c8753417dc4711b1466ceb3cc40e0b27627f2 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 12:06:29 -0500
Subject: [PATCH 34/71] Updated complex logic for deleteing trailing comments.

---
 montepy/input_parser/syntax_node.py | 18 ++++++++++++++----
 1 file changed, 14 insertions(+), 4 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 0e58f52a..1ce392b6 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -256,19 +256,24 @@ def comments(self):
             yield from node.comments
 
     def get_trailing_comment(self):
+        node = self._get_trailing_node()
+        if node:
+            return node.get_trailing_comment()
+
+    def _get_trailing_node(self):
         if len(self.nodes) == 0:
             return
         for node in reversed(self.nodes.values()):
             if node is not None:
                 if isinstance(node, ValueNode):
                     if node.value is not None:
-                        return node.get_trailing_comment()
+                        return node
                 elif len(node) > 0:
-                    return node.get_trailing_comment()
+                    return node
 
     def _delete_trailing_comment(self):
-        tail = next(reversed(self.nodes.items()))
-        tail[1]._delete_trailing_comment()
+        node = self._get_trailing_node()
+        node._delete_trailing_comment()
 
     def flatten(self):
         ret = []
@@ -2248,6 +2253,11 @@ def get_trailing_comment(self):
         if self.padding:
             return self.padding.get_trailing_comment()
 
+    def _delete_trailing_comment(self):
+        print("hi")
+        if self.padding:
+            self.padding._delete_trailing_comment()
+
     def flatten(self):
         ret = []
         if self.modifier:

From ee085834c0dfdd9278670171a25e680b52d26711 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 12:20:56 -0500
Subject: [PATCH 35/71] Updated geometry expansion tests to be more exhaustive.

---
 tests/test_syntax_parsing.py | 45 ++++++++++++++++++++----------------
 1 file changed, 25 insertions(+), 20 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 5653beb2..024f91f6 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -854,27 +854,32 @@ def test_shortcut_expansion(self):
                 if parsed is None:
                     raise montepy.errors.MalformedInputError("", "")
 
-    def test_shortcut_geometry_expansion(self):
-        tests = {
-            "1 3r ": [1, 1, 1, 1],
-            "1 1 3r ": [1, 1, 1, 1, 1],
-            "1 -2M ": [1, -2],
-            "1 2i 4 ": [1, 2, 3, 4],
-            "1 1 2i 4 ": [1, 1, 2, 3, 4],
-            "1 ilog 100 ": [1, 10, 100],
-            # secretly test iterator
-            "#1": [1],
-            "#(1 2 3)": [1, 2, 3],
-            "1 2:( 3 4 5)": [1, 2, 3, 4, 5],
-        }
 
-        parser = ShortcutGeometryTestFixture()
-        for test, answer in tests.items():
-            print(test)
-            input = Input([test], BlockType.CELL)
-            parsed = parser.parse(input.tokenize())
-            for val, gold in zip(parsed, answer):
-                self.assertAlmostEqual(val.value, gold)
+@pytest.mark.parametrize(
+    "test, answer",
+    [
+        ("1 3r ", [1, 1, 1, 1]),
+        ("1 1 3r ", [1, 1, 1, 1, 1]),
+        ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2]),
+        ("1 -2M ", [1, -2]),
+        ("1 2i 4 ", [1, 2, 3, 4]),
+        ("1 1 2i 4 ", [1, 1, 2, 3, 4]),
+        ("1 ilog 100 ", [1, 10, 100]),
+        # secretly test iterator
+        ("#1", [1]),
+        ("#(1 2 3)", [1, 2, 3]),
+        ("1 2:( 3 4 5)", [1, 2, 3, 4, 5]),
+    ],
+)
+def test_shortcut_geometry_expansion(test, answer):
+
+    parser = ShortcutGeometryTestFixture()
+    print(test)
+    input = Input([test], BlockType.CELL)
+    parsed = parser.parse(input.tokenize())
+    for val, gold in zip(parsed, answer):
+        assert val.value == gold
+    assert parsed.format() == test.upper()
 
 
 """

From aa06f2242645c65b4a9fb88989031cb963276b40 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 12:43:14 -0500
Subject: [PATCH 36/71] Fixed test to be looser.

---
 tests/test_syntax_parsing.py | 29 ++++++++++++++++-------------
 1 file changed, 16 insertions(+), 13 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 024f91f6..a44aabfc 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -856,22 +856,22 @@ def test_shortcut_expansion(self):
 
 
 @pytest.mark.parametrize(
-    "test, answer",
+    "test, answer, form_ans",
     [
-        ("1 3r ", [1, 1, 1, 1]),
-        ("1 1 3r ", [1, 1, 1, 1, 1]),
-        ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2]),
-        ("1 -2M ", [1, -2]),
-        ("1 2i 4 ", [1, 2, 3, 4]),
-        ("1 1 2i 4 ", [1, 1, 2, 3, 4]),
-        ("1 ilog 100 ", [1, 10, 100]),
+        ("1 3r ", [1, 1, 1, 1], None),
+        ("1 1 3r ", [1, 1, 1, 1, 1], None),
+        ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2], None),
+        ("1 -2M ", [1, -2], None),
+        ("1 2i 4 ", [1, 2, 3, 4], None),
+        ("1 1 2i 4 ", [1, 1, 2, 3, 4], None),
+        ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
         # secretly test iterator
-        ("#1", [1]),
-        ("#(1 2 3)", [1, 2, 3]),
-        ("1 2:( 3 4 5)", [1, 2, 3, 4, 5]),
+        ("#1", [1], None),
+        ("#(1 2 3)", [1, 2, 3], None),
+        ("1 2:( 3 4 5)", [1, 2, 3, 4, 5], None),
     ],
 )
-def test_shortcut_geometry_expansion(test, answer):
+def test_shortcut_geometry_expansion(test, answer, form_ans):
 
     parser = ShortcutGeometryTestFixture()
     print(test)
@@ -879,7 +879,10 @@ def test_shortcut_geometry_expansion(test, answer):
     parsed = parser.parse(input.tokenize())
     for val, gold in zip(parsed, answer):
         assert val.value == gold
-    assert parsed.format() == test.upper()
+    if form_ans:
+        assert parsed.format().rstrip() == form_ans
+    else:
+        assert parsed.format().rstrip() == test.upper().rstrip()
 
 
 """

From 3f7f277ab6ac753ce0d8004ad96461d625fd95b8 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 13:00:38 -0500
Subject: [PATCH 37/71] fixed bugs in M in geometry.

---
 montepy/input_parser/syntax_node.py | 11 ++++++++---
 1 file changed, 8 insertions(+), 3 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 1ce392b6..007ae164 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1823,6 +1823,11 @@ def _expand_multiply(self, p):
         self._num_node = ValueNode(mult_str, float, never_pad=True)
         if isinstance(p[0], ValueNode):
             last_val = self.nodes[-1]
+        elif isinstance(p[0], GeometryTree):
+            if "right" in p[0].nodes:
+                last_val = p[0].nodes["right"]
+            else:
+                last_val = p[0].nodes["left"]
         else:
             last_val = p[0].nodes[-1]
         if last_val.value is None:
@@ -2073,10 +2078,10 @@ def _format_multiply(self, leading_node=None):
         else:
             first_val = self.nodes[0]
             first_val_str = first_val
-        if "M" in self._original[-1]:
-            m = "M"
-        else:
+        if self._original and "m" in self._original[-1]:
             m = "m"
+        else:
+            m = "M"
         self._num_node.value = self.nodes[-1].value / first_val.value
         return f"{first_val_str.format()}{self._num_node.format()}{m}"
 

From a00afe43413de1d0b2f521911ddc4619ee737af4 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 13:43:17 -0500
Subject: [PATCH 38/71] Added more edge cases.

---
 tests/test_syntax_parsing.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index a44aabfc..031c7c09 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -863,7 +863,10 @@ def test_shortcut_expansion(self):
         ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2], None),
         ("1 -2M ", [1, -2], None),
         ("1 2i 4 ", [1, 2, 3, 4], None),
+        ("1 2i 4 ", [1, 2, 3, 4], None),
         ("1 1 2i 4 ", [1, 1, 2, 3, 4], None),
+        ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], None),
+        ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], None),
         ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
         # secretly test iterator
         ("#1", [1], None),
@@ -877,6 +880,7 @@ def test_shortcut_geometry_expansion(test, answer, form_ans):
     print(test)
     input = Input([test], BlockType.CELL)
     parsed = parser.parse(input.tokenize())
+    print(parsed)
     for val, gold in zip(parsed, answer):
         assert val.value == gold
     if form_ans:

From ab65de63075c22557958b5e93859944f2b8a2bed Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sat, 31 Aug 2024 13:43:36 -0500
Subject: [PATCH 39/71] Started debugging.

---
 montepy/input_parser/syntax_node.py | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 007ae164..f616c833 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -323,6 +323,9 @@ def __repr__(self):
         return str(self)
 
     def format(self):
+        # TODO flatten
+        # TODO label each node as shortcut
+        print(self._check_all_shortcut())
         if self._check_all_shortcut():
             return self._format_shortcut()
         ret = ""
@@ -334,6 +337,8 @@ def _check_all_shortcut(self):
         if not self._short_type:
             return False
         if isinstance(self.left, type(self)) and not self.left._check_all_shortcut():
+            print(self)
+            print(self.left._check_all_shortcut())
             return False
         if (
             self.right is not None
@@ -349,7 +354,9 @@ def _format_shortcut(self):
         short = ShortcutNode(short_type=self._short_type)
         short.load_nodes(new_vals)
         list_wrap.append(short)
+        print(new_vals)
         list_wrap.update_with_new_values(new_vals)
+        print(list_wrap)
         return list_wrap.format()
 
     @property

From 97bca51df7c8d0cfcac04625c7208d4a3aa76efb Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 22:53:23 -0500
Subject: [PATCH 40/71] Made system for tracking left and right shortuts

---
 montepy/input_parser/cell_parser.py | 10 ++++++++--
 montepy/input_parser/syntax_node.py | 20 ++++++++++++++++----
 2 files changed, 24 insertions(+), 6 deletions(-)

diff --git a/montepy/input_parser/cell_parser.py b/montepy/input_parser/cell_parser.py
index 5e05a38f..10c3f160 100644
--- a/montepy/input_parser/cell_parser.py
+++ b/montepy/input_parser/cell_parser.py
@@ -112,13 +112,18 @@ def geometry_term(self, p):
         "geometry_term LOG_INTERPOLATE padding number_phrase",
     )
     def geometry_term(self, p):
-        # TODO mark this is a shortcut
         shortcut = syntax_node.ShortcutNode(p, data_type=int)
         node_iter = iter(shortcut.nodes)
         if isinstance(p.geometry_term, syntax_node.GeometryTree):
             left = p.geometry_term
+            left.mark_last_leaf_shortcut(shortcut.type)
         else:
             left = next(node_iter)
+        left_type = (
+            shortcut.type
+            if isinstance(left, syntax_node.ValueNode) and left == shortcut.nodes[0]
+            else None
+        )
         for node in node_iter:
             new_tree = syntax_node.GeometryTree(
                 "intersection",
@@ -126,7 +131,8 @@ def geometry_term(self, p):
                 "*",
                 left,
                 node,
-                short_type=shortcut.type,
+                left_short_type=left_type,
+                right_short_type=shortcut.type,
             )
             left = new_tree
         return new_tree
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index f616c833..46c6384c 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -304,19 +304,31 @@ class GeometryTree(SyntaxNodeBase):
     :type right: GeometryTree, ValueNode
     """
 
-    def __init__(self, name, tokens, op, left, right=None, short_type=None):
+    def __init__(
+        self,
+        name,
+        tokens,
+        op,
+        left,
+        right=None,
+        left_short_type=None,
+        right_short_type=None,
+    ):
         super().__init__(name)
         assert all(list(map(lambda v: isinstance(v, SyntaxNodeBase), tokens.values())))
         self._nodes = tokens
         self._operator = Operator(op)
         self._left_side = left
         self._right_side = right
-        self._short_type = short_type
+        self._left_short_type = left_short_type
+        self._right_short_type = right_short_type
 
     def __str__(self):
         return (
-            f"Geometry: ( {self._left_side} {self._operator} {self._right_side} "
-            f"{f'Short:{self._short_type.value}' if self._short_type else ''})"
+            f"Geometry: ( {self._left_side}"
+            f" {f'Short:{self._left_short_type.value}' if self._left_short_type else ''}"
+            f" {self._operator} {self._right_side} "
+            f"{f'Short:{self._right_short_type.value}' if self._right_short_type else ''})"
         )
 
     def __repr__(self):

From 24ca152c5865f9e360098f7b86c8c06118692a15 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 22:54:33 -0500
Subject: [PATCH 41/71] Updated shortcut finding logic to find shortcuts in the
 middle.

---
 montepy/input_parser/syntax_node.py | 84 ++++++++++++++++++++---------
 1 file changed, 58 insertions(+), 26 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 46c6384c..9a56eb4a 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -335,40 +335,72 @@ def __repr__(self):
         return str(self)
 
     def format(self):
-        # TODO flatten
-        # TODO label each node as shortcut
-        print(self._check_all_shortcut())
-        if self._check_all_shortcut():
+        if self._left_short_type or self._right_short_type:
             return self._format_shortcut()
         ret = ""
         for node in self.nodes.values():
             ret += node.format()
         return ret
 
-    def _check_all_shortcut(self):
-        if not self._short_type:
-            return False
-        if isinstance(self.left, type(self)) and not self.left._check_all_shortcut():
-            print(self)
-            print(self.left._check_all_shortcut())
-            return False
-        if (
-            self.right is not None
-            and isinstance(self.right, type(self))
-            and self.right._check_all_shortcut()
-        ):
-            return False
-        return True
+    def mark_last_leaf_shortcut(self, short_type):
+        if self.right is not None:
+            node = self.right
+        else:
+            node = self.left
+        if isinstance(node, type(self)):
+            return node.mark_last_leaf_shortcut(short_type)
+        if self.right is not None:
+            self._right_short_type = short_type
+        else:
+            self._left_short_type = short_type
+
+    def _flatten_shortcut(self):
+        def add_leaf(list_node, leaf, short_type):
+            end = list_node.nodes[-1] if len(list_node) > 0 else None
+
+            def flush_shortcut():
+                # TODO this will probably blow up
+                end.load_nodes(end.nodes)
+                list_node.append(leaf)
+
+            def start_shortcut():
+                short = ShortcutNode(short_type=short_type)
+                short.append(leaf)
+                if not leaf.padding:
+                    leaf.padding = PaddingNode(" ")
+                list_node.append(short)
+
+            if short_type:
+                if isinstance(end, ShortcutNode):
+                    if end.type == short_type:
+                        end.append(leaf)
+                    else:
+                        flush_shortcut()
+                        start_shortcut()
+                else:
+                    start_shortcut()
+            else:
+                if isinstance(end, ShortcutNode):
+                    flush_shortcut()
+                else:
+                    list_node.append(leaf)
+
+        if isinstance(self.left, ValueNode):
+            ret = ListNode("list wrapper")
+            add_leaf(ret, self.left, self._left_short_type)
+        else:
+            ret = self.left._flatten_shortcut()
+        if self.right is not None:
+            if isinstance(self.right, ValueNode):
+                add_leaf(ret, self.right, self._right_short_type)
+            else:
+                [ret.append(n) for n in self.right.right._flatten_shortcut()]
+        print(ret)
+        return ret
 
     def _format_shortcut(self):
-        new_vals = [n for n in self.flatten() if isinstance(n, ValueNode)]
-        list_wrap = ListNode("list wrapper")
-        short = ShortcutNode(short_type=self._short_type)
-        short.load_nodes(new_vals)
-        list_wrap.append(short)
-        print(new_vals)
-        list_wrap.update_with_new_values(new_vals)
-        print(list_wrap)
+        # TODO how to handle operators
+        list_wrap = self._flatten_shortcut()
         return list_wrap.format()
 
     @property

From a9517e89b002e9a67ab7c047cf21aa3b08e29380 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 22:54:51 -0500
Subject: [PATCH 42/71] Close enough with padding.

---
 tests/test_syntax_parsing.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 031c7c09..ae706c8d 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -865,8 +865,8 @@ def test_shortcut_expansion(self):
         ("1 2i 4 ", [1, 2, 3, 4], None),
         ("1 2i 4 ", [1, 2, 3, 4], None),
         ("1 1 2i 4 ", [1, 1, 2, 3, 4], None),
-        ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], None),
-        ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], None),
+        ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4  5 6"),
+        ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4 :5 6"),
         ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
         # secretly test iterator
         ("#1", [1], None),

From aca2f85f12d0800064e9f96bc51bc4ef92657253 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 22:55:21 -0500
Subject: [PATCH 43/71] Updated changelog with #520 PR.

---
 doc/source/changelog.rst | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/doc/source/changelog.rst b/doc/source/changelog.rst
index 530c536c..ffa90309 100644
--- a/doc/source/changelog.rst
+++ b/doc/source/changelog.rst
@@ -4,6 +4,16 @@ MontePy Changelog
 #Next Version#
 --------------
 
+**Features Added**
+
+* Added support for reading an input from either file paths or streams (file handles) with ``montepy.read_input`` (:issue:`519`).
+
+**Bug Fixes**
+
+* Fixed bug with shortcuts right after another shortcut (e.g., ``1 2M 3R``) not being properly recompressed on export (:issue:`499`).
+* Fixed bug with shortcuts in cell geometry definitions not being recompressed on export (:issue:`489`).
+* Fixed bug where leading comments were not always transferred to the appropriate input. (:issue:`352`, :issue:`526`).
+
 **Performance Improvement**
 
 * Fixed method of linking ``Material`` to ``ThermalScattering`` objects, avoiding a very expensive O(N:sup:`2`) (:issue:`510`).

From 59058d067740f17751d05128a3eaab07ac1c0eed Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 23:57:35 -0500
Subject: [PATCH 44/71] Avoided marking shortcuts overriding old shortcut.

---
 montepy/input_parser/syntax_node.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 9a56eb4a..7626636f 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -345,8 +345,12 @@ def format(self):
     def mark_last_leaf_shortcut(self, short_type):
         if self.right is not None:
             node = self.right
+            if self._right_short_type:
+                return
         else:
             node = self.left
+            if self._left_short_type:
+                return
         if isinstance(node, type(self)):
             return node.mark_last_leaf_shortcut(short_type)
         if self.right is not None:

From b6ec5d4a8613373b3ea11f098a4f6d9c6ea9aa22 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Sun, 1 Sep 2024 23:58:26 -0500
Subject: [PATCH 45/71] Fixed over-appending leaves to the new list.

---
 montepy/input_parser/syntax_node.py | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 7626636f..3c393afd 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -365,7 +365,6 @@ def add_leaf(list_node, leaf, short_type):
             def flush_shortcut():
                 # TODO this will probably blow up
                 end.load_nodes(end.nodes)
-                list_node.append(leaf)
 
             def start_shortcut():
                 short = ShortcutNode(short_type=short_type)
@@ -386,6 +385,7 @@ def start_shortcut():
             else:
                 if isinstance(end, ShortcutNode):
                     flush_shortcut()
+                    list_node.append(leaf)
                 else:
                     list_node.append(leaf)
 
@@ -399,11 +399,9 @@ def start_shortcut():
                 add_leaf(ret, self.right, self._right_short_type)
             else:
                 [ret.append(n) for n in self.right.right._flatten_shortcut()]
-        print(ret)
         return ret
 
     def _format_shortcut(self):
-        # TODO how to handle operators
         list_wrap = self._flatten_shortcut()
         return list_wrap.format()
 
@@ -2314,7 +2312,6 @@ def get_trailing_comment(self):
             return self.padding.get_trailing_comment()
 
     def _delete_trailing_comment(self):
-        print("hi")
         if self.padding:
             self.padding._delete_trailing_comment()
 

From b42f4a8f1bc138f8c79b3581a0dbf3d7f43a49e5 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 09:24:47 -0500
Subject: [PATCH 46/71] Added tests for mark_last_leaf_shortcut.

---
 tests/test_syntax_parsing.py | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index ae706c8d..4916bbd3 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -11,6 +11,7 @@
 from montepy.input_parser.block_type import BlockType
 from montepy.input_parser.input_file import MCNP_InputFile
 from montepy.input_parser.parser_base import MCNP_Parser
+from montepy.input_parser.shortcuts import Shortcuts
 from montepy.input_parser import syntax_node
 from montepy.particle import Particle
 import warnings
@@ -485,6 +486,38 @@ def test_geometry_comments(self):
         self.assertEqual(len(comments), 1)
 
 
+def test_geometry_tree_mark_last_leaf_shortcut():
+    # test left leaf
+    tree = {
+        "left": syntax_node.ValueNode("123", int),
+        "operator": syntax_node.PaddingNode(" "),
+    }
+    geom = syntax_node.GeometryTree(
+        "test", tree, montepy.Operator.INTERSECTION, tree["left"]
+    )
+    geom.mark_last_leaf_shortcut(Shortcuts.REPEAT)
+    assert geom._left_short_type == Shortcuts.REPEAT
+    # try overriding old shortcut
+    geom.mark_last_leaf_shortcut(Shortcuts.MULTIPLY)
+    assert geom._left_short_type == Shortcuts.REPEAT
+    tree["right"] = syntax_node.ValueNode("789", int)
+    geom = syntax_node.GeometryTree(
+        "test", tree, montepy.Operator.INTERSECTION, tree["left"], tree["right"]
+    )
+    del tree["right"]
+    tree["left"] = syntax_node.ValueNode("456", int)
+    # make unbalanced tree in the other way for rigor
+    geom = syntax_node.GeometryTree(
+        "test", tree, montepy.Operator.INTERSECTION, tree["left"], geom
+    )
+    # test a right-side leaf
+    geom.mark_last_leaf_shortcut(Shortcuts.REPEAT)
+    assert geom.right._right_short_type == Shortcuts.REPEAT
+    # try overriding old shortcut
+    geom.mark_last_leaf_shortcut(Shortcuts.MULTIPLY)
+    assert geom.right._right_short_type == Shortcuts.REPEAT
+
+
 class TestPaddingNode(TestCase):
     def test_padding_init(self):
         pad = syntax_node.PaddingNode(" ")

From 847d2d2b22d3e8b3dd934eb83aefff2a4ead22bc Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 09:25:09 -0500
Subject: [PATCH 47/71] Started testing for flatten_shortcut.

---
 tests/test_syntax_parsing.py | 34 +++++++++++++++++++++++++++++++++-
 1 file changed, 33 insertions(+), 1 deletion(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 4916bbd3..e16f4d48 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -913,7 +913,39 @@ def test_shortcut_geometry_expansion(test, answer, form_ans):
     print(test)
     input = Input([test], BlockType.CELL)
     parsed = parser.parse(input.tokenize())
-    print(parsed)
+    for val, gold in zip(parsed, answer):
+        assert val.value == gold
+    if form_ans:
+        assert parsed.format().rstrip() == form_ans
+    else:
+        assert parsed.format().rstrip() == test.upper().rstrip()
+
+
+@pytest.mark.parametrize(
+    "test, answer, form_ans",
+    [
+        ("1 3r ", [1, 1, 1, 1], None),
+        ("1 1 3r ", [1, 1, 1, 1, 1], None),
+        ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2], None),
+        ("1 -2M ", [1, -2], None),
+        ("1 2i 4 ", [1, 2, 3, 4], None),
+        ("1 2i 4 ", [1, 2, 3, 4], None),
+        ("1 1 2i 4 ", [1, 1, 2, 3, 4], None),
+        ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4  5 6"),
+        ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4 :5 6"),
+        ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
+        # secretly test iterator
+        ("#1", [1], None),
+        ("#(1 2 3)", [1, 2, 3], None),
+        ("1 2:( 3 4 5)", [1, 2, 3, 4, 5], None),
+    ],
+)
+def test_shortcut_flatten(test, length, indices):
+
+    parser = ShortcutGeometryTestFixture()
+    print(test)
+    input = Input([test], BlockType.CELL)
+    parsed = parser.parse(input.tokenize())
     for val, gold in zip(parsed, answer):
         assert val.value == gold
     if form_ans:

From 06a44cbc64b1570c18d0f380dff231d9c3350820 Mon Sep 17 00:00:00 2001
From: Micah Gale <mg@gale.engineer>
Date: Tue, 3 Sep 2024 10:08:17 -0500
Subject: [PATCH 48/71] Finished test for flatten_shortcuts.

---
 tests/test_syntax_parsing.py | 39 ++++++++++++++++++------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index e16f4d48..172a87e7 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -922,22 +922,22 @@ def test_shortcut_geometry_expansion(test, answer, form_ans):
 
 
 @pytest.mark.parametrize(
-    "test, answer, form_ans",
+    "test, length, indices",
     [
-        ("1 3r ", [1, 1, 1, 1], None),
-        ("1 1 3r ", [1, 1, 1, 1, 1], None),
-        ("1 1 2M 3r ", [1, 1, 2, 2, 2, 2], None),
-        ("1 -2M ", [1, -2], None),
-        ("1 2i 4 ", [1, 2, 3, 4], None),
-        ("1 2i 4 ", [1, 2, 3, 4], None),
-        ("1 1 2i 4 ", [1, 1, 2, 3, 4], None),
-        ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4  5 6"),
-        ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4 :5 6"),
-        ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
+        ("1 3r ", 2, {1: Shortcuts.REPEAT}),
+        ("1 1 3r ", 3, {2: Shortcuts.REPEAT}),
+        ("1 1 2M 3r ", 4, {2: Shortcuts.MULTIPLY, 3: Shortcuts.REPEAT}),
+        ("1 -2M ", 2, {1: Shortcuts.MULTIPLY}),
+        ("1 2i 4 ", 1, {0: Shortcuts.INTERPOLATE}),
+        ("1 2i 4 ", 1, {0: Shortcuts.INTERPOLATE}),
+        ("1 1 2i 4 ", 2, {1: Shortcuts.INTERPOLATE}),
+        ("1 1 2i 4 5 6 ", 4, {1: Shortcuts.INTERPOLATE}),
+        ("1 1 2i 4:5 6 ", 4, {1: Shortcuts.INTERPOLATE}),
+        ("1 ilog 100 ", 1, {0: Shortcuts.INTERPOLATE}),
         # secretly test iterator
-        ("#1", [1], None),
-        ("#(1 2 3)", [1, 2, 3], None),
-        ("1 2:( 3 4 5)", [1, 2, 3, 4, 5], None),
+        ("#1", 1, {}),
+        ("#(1 2 3)", 3, {}),
+        ("1 2:( 3 4 5)", 5, {}),
     ],
 )
 def test_shortcut_flatten(test, length, indices):
@@ -946,12 +946,11 @@ def test_shortcut_flatten(test, length, indices):
     print(test)
     input = Input([test], BlockType.CELL)
     parsed = parser.parse(input.tokenize())
-    for val, gold in zip(parsed, answer):
-        assert val.value == gold
-    if form_ans:
-        assert parsed.format().rstrip() == form_ans
-    else:
-        assert parsed.format().rstrip() == test.upper().rstrip()
+    flatpack = parsed._flatten_shortcut()
+    assert len(flatpack) == length
+    for index, short_type in indices.items():
+        assert isinstance(flatpack[index], ShortcutNode)
+        assert flatpack[index].type == short_type
 
 
 """

From bfa81a86404922fc7bc9217f53bcc581f6557fd1 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 11:55:47 -0500
Subject: [PATCH 49/71] Fixed test typos.

---
 tests/test_syntax_parsing.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 172a87e7..ad3087ba 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -949,8 +949,8 @@ def test_shortcut_flatten(test, length, indices):
     flatpack = parsed._flatten_shortcut()
     assert len(flatpack) == length
     for index, short_type in indices.items():
-        assert isinstance(flatpack[index], ShortcutNode)
-        assert flatpack[index].type == short_type
+        assert isinstance(flatpack.nodes[index], syntax_node.ShortcutNode)
+        assert flatpack.nodes[index].type == short_type
 
 
 """

From 0e15135ca2623fe05b65ea165bcde21e4156bd79 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 11:56:03 -0500
Subject: [PATCH 50/71] Fixed tests because I can't count at all.

---
 tests/test_syntax_parsing.py | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index ad3087ba..0ebc1506 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -924,16 +924,16 @@ def test_shortcut_geometry_expansion(test, answer, form_ans):
 @pytest.mark.parametrize(
     "test, length, indices",
     [
-        ("1 3r ", 2, {1: Shortcuts.REPEAT}),
-        ("1 1 3r ", 3, {2: Shortcuts.REPEAT}),
-        ("1 1 2M 3r ", 4, {2: Shortcuts.MULTIPLY, 3: Shortcuts.REPEAT}),
-        ("1 -2M ", 2, {1: Shortcuts.MULTIPLY}),
+        ("1 3r ", 1, {0: Shortcuts.REPEAT}),
+        ("1 1 3r ", 2, {1: Shortcuts.REPEAT}),
+        ("1 1 2M 3r ", 3, {1: Shortcuts.MULTIPLY, 2: Shortcuts.REPEAT}),
+        ("1 -2M ", 1, {0: Shortcuts.MULTIPLY}),
         ("1 2i 4 ", 1, {0: Shortcuts.INTERPOLATE}),
         ("1 2i 4 ", 1, {0: Shortcuts.INTERPOLATE}),
         ("1 1 2i 4 ", 2, {1: Shortcuts.INTERPOLATE}),
         ("1 1 2i 4 5 6 ", 4, {1: Shortcuts.INTERPOLATE}),
         ("1 1 2i 4:5 6 ", 4, {1: Shortcuts.INTERPOLATE}),
-        ("1 ilog 100 ", 1, {0: Shortcuts.INTERPOLATE}),
+        ("1 ilog 100 ", 1, {0: Shortcuts.LOG_INTERPOLATE}),
         # secretly test iterator
         ("#1", 1, {}),
         ("#(1 2 3)", 3, {}),

From f7d140d7844479e574bf284c7aa39e390cc8634e Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 11:56:21 -0500
Subject: [PATCH 51/71] Fixed bug with excess depth in call.

---
 montepy/input_parser/syntax_node.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 3c393afd..12d85516 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -398,7 +398,7 @@ def start_shortcut():
             if isinstance(self.right, ValueNode):
                 add_leaf(ret, self.right, self._right_short_type)
             else:
-                [ret.append(n) for n in self.right.right._flatten_shortcut()]
+                [ret.append(n) for n in self.right._flatten_shortcut()]
         return ret
 
     def _format_shortcut(self):

From 058b757edf3656eb198234478d0c9b35cf95e5a7 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 12:01:50 -0500
Subject: [PATCH 52/71] Cleaned up with @tjlaboss feedback.

---
 montepy/input_parser/cell_parser.py | 8 +++-----
 montepy/input_parser/syntax_node.py | 3 +--
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/montepy/input_parser/cell_parser.py b/montepy/input_parser/cell_parser.py
index 10c3f160..65d347e6 100644
--- a/montepy/input_parser/cell_parser.py
+++ b/montepy/input_parser/cell_parser.py
@@ -119,11 +119,9 @@ def geometry_term(self, p):
             left.mark_last_leaf_shortcut(shortcut.type)
         else:
             left = next(node_iter)
-        left_type = (
-            shortcut.type
-            if isinstance(left, syntax_node.ValueNode) and left == shortcut.nodes[0]
-            else None
-        )
+        left_type = None
+        if isinstance(left, syntax_node.ValueNode) and left == shortcut.nodes[0]:
+            left_type = shortcut.type
         for node in node_iter:
             new_tree = syntax_node.GeometryTree(
                 "intersection",
diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 12d85516..76813e10 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -1954,8 +1954,7 @@ def _can_consume_node(self, node, direction, last_edge_shortcut=False):
         :type node: ValueNode
         :param direction: the direct to go in. Must be in {-1, 1}
         :type direction: int
-        :param last_edge_shortcut: Whether or not the previous node in the list was
-            part of a different shortcut
+        :param last_edge_shortcut: Whether the previous node in the list was part of a different shortcut
         :type last_edge_shortcut: bool
         :returns: true it can be consumed.
         :rtype: bool

From f7ff8ba928f37a3b8592fbe3d7cbb83e7de21e1a Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 12:48:20 -0500
Subject: [PATCH 53/71] Added test replicate new edge case from @tjlaboss.

---
 tests/test_syntax_parsing.py | 131 ++++++++++++++++++-----------------
 1 file changed, 69 insertions(+), 62 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 0ebc1506..eabe9ad8 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -856,36 +856,75 @@ def test_shortcut_end_padding_setter(self):
         with self.assertRaises(TypeError):
             short.end_padding = " "
 
-    def test_shortcut_expansion(self):
-        invalid = [
-            "3J 4R",
-            "1 4I 3M",
-            # last official test
-            "1 4I J",
-            "1 2Ilog J",
-            "J 2Ilog 5",
-            "3J 2M",
-            "10 M",
-            "2R",
-        ]
 
-        parser = ShortcutTestFixture()
-        for test, answer in tests.items():
-            print(test)
-            input = Input([test], BlockType.DATA)
-            parsed = parser.parse(input.tokenize())
-            for val, gold in zip(parsed, answer):
-                if val.value is None:
-                    self.assertEqual(gold, montepy.Jump())
-                else:
-                    self.assertAlmostEqual(val.value, gold)
-        for test in invalid:
-            print(test)
-            with self.assertRaises(ValueError):
-                input = Input([test], BlockType.DATA)
-                parsed = parser.parse(input.tokenize())
-                if parsed is None:
-                    raise montepy.errors.MalformedInputError("", "")
+"""
+Most examples, unless otherwise noted are taken from Section 2.8.1
+of LA-UR-17-29981.
+"""
+tests = {
+    "1 3M 2r": [1, 3, 3, 3],
+    # unofficial
+    "0.01 2ILOG 10": [0.01, 0.1, 1, 10],
+    "1 3M I 4": [1, 3, 3.5, 4],
+    "1 3M 3M": [1, 3, 9],
+    "1 2R 2I 2.5": [1, 1, 1, 1.5, 2, 2.5],
+    "1 R 2m": [1, 1, 2],
+    "1 R R": [1, 1, 1],
+    "1 2i 4 3m": [1, 2, 3, 4, 12],
+    # unofficial
+    "1 i 3": [1, 2, 3],
+    # unofficial
+    "1 ilog 100": [1, 10, 100],
+    # last official one
+    "1 2i 4 2i 10": [
+        1,
+        2,
+        3,
+        4,
+        6,
+        8,
+        10,
+    ],
+    "1 2j 4": [1, montepy.Jump(), montepy.Jump(), 4],
+    "1 j": [1, montepy.Jump()],
+}
+
+
+@pytest.mark.parametrize("test, answer", tests.items())
+def test_shortcut_expansion_valid(test, answer):
+    parser = ShortcutTestFixture()
+    print(test)
+    input = Input([test], BlockType.DATA)
+    parsed = parser.parse(input.tokenize())
+    for val, gold in zip(parsed, answer):
+        if val.value is None:
+            assert gold == montepy.Jump()
+        else:
+            assert val.value == pytest.approx(gold)
+
+
+@pytest.mark.parametrize(
+    "test",
+    [
+        ("3J 4R"),
+        ("1 4I 3M"),
+        # last official test
+        ("1 4I J"),
+        ("1 2Ilog J"),
+        ("J 2Ilog 5"),
+        ("3J 2M"),
+        ("10 M"),
+        ("2R"),
+    ],
+)
+def test_shortcut_expansion_invalid(test):
+    print(test)
+    parser = ShortcutTestFixture()
+    with pytest.raises(ValueError):
+        input = Input([test], BlockType.DATA)
+        parsed = parser.parse(input.tokenize())
+        if parsed is None:
+            raise montepy.errors.MalformedInputError("", "")
 
 
 @pytest.mark.parametrize(
@@ -953,39 +992,6 @@ def test_shortcut_flatten(test, length, indices):
         assert flatpack.nodes[index].type == short_type
 
 
-"""
-Most examples, unless otherwise noted are taken from Section 2.8.1
-of LA-UR-17-29981.
-"""
-tests = {
-    "1 3M 2r": [1, 3, 3, 3],
-    # unofficial
-    "0.01 2ILOG 10": [0.01, 0.1, 1, 10],
-    "1 3M I 4": [1, 3, 3.5, 4],
-    "1 3M 3M": [1, 3, 9],
-    "1 2R 2I 2.5": [1, 1, 1, 1.5, 2, 2.5],
-    "1 R 2m": [1, 1, 2],
-    "1 R R": [1, 1, 1],
-    "1 2i 4 3m": [1, 2, 3, 4, 12],
-    # unofficial
-    "1 i 3": [1, 2, 3],
-    # unofficial
-    "1 ilog 100": [1, 10, 100],
-    # last official one
-    "1 2i 4 2i 10": [
-        1,
-        2,
-        3,
-        4,
-        6,
-        8,
-        10,
-    ],
-    "1 2j 4": [1, montepy.Jump(), montepy.Jump(), 4],
-    "1 j": [1, montepy.Jump()],
-}
-
-
 @pytest.mark.parametrize(
     "in_str, answer",
     [
@@ -1006,6 +1012,7 @@ def test_shortcut_flatten(test, length, indices):
         ("2j", "2j"),
         ("2J ", "2J "),
         ("J", "J"),
+        ("0 2i 3 10 2i 16 1", "0 2i 3 10 2i 16 1"),
     ],
 )
 def test_shortcut_format(in_str, answer):

From 9483f899ac9da367874e89b974e624ffedd90435 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 15:29:11 -0500
Subject: [PATCH 54/71] Added more exhaustive shortcut tests.

---
 tests/test_syntax_parsing.py | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index eabe9ad8..422d5f43 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -875,6 +875,7 @@ def test_shortcut_end_padding_setter(self):
     "1 i 3": [1, 2, 3],
     # unofficial
     "1 ilog 100": [1, 10, 100],
+    "1 1r ilog 100": [1, 1, 10, 100],
     # last official one
     "1 2i 4 2i 10": [
         1,
@@ -901,6 +902,7 @@ def test_shortcut_expansion_valid(test, answer):
             assert gold == montepy.Jump()
         else:
             assert val.value == pytest.approx(gold)
+    assert parsed.format() == test
 
 
 @pytest.mark.parametrize(
@@ -940,6 +942,7 @@ def test_shortcut_expansion_invalid(test):
         ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4  5 6"),
         ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4 :5 6"),
         ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
+        ("1 1r ilog 100 ", [1, 1, 10, 100], "1 1r 1ILOG 100"),
         # secretly test iterator
         ("#1", [1], None),
         ("#(1 2 3)", [1, 2, 3], None),
@@ -997,6 +1000,7 @@ def test_shortcut_flatten(test, length, indices):
     [
         ("1 5R", "1 5R"),
         ("1 5r", "1 5r"),
+        ("1 5r 2m", "1 5r 2m"),
         ("1 r", "1 r"),
         ("1 r 2 2r", "1 r 2 2r"),
         ("1 J 5 2R", "1 J 5 2R"),
@@ -1017,18 +1021,12 @@ def test_shortcut_flatten(test, length, indices):
 )
 def test_shortcut_format(in_str, answer):
     parser = ShortcutTestFixture()
-    print(in_str, answer)
     input = Input([in_str], BlockType.CELL)
     shortcut = parser.parse(input.tokenize())
     assert shortcut.format() == answer
     # try jump with empty jump shortcut
     shortcut.nodes.clear()
     assert shortcut.format() == ""
-    for in_str in tests.keys():
-        print(in_str)
-        input = Input([in_str], BlockType.CELL)
-        shortcut = parser.parse(input.tokenize())
-        assert shortcut.format() == in_str
 
 
 class ShortcutTestFixture(MCNP_Parser):

From 6b6cdcb259f180f8443d4af99ab0437985ab0a31 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 15:46:00 -0500
Subject: [PATCH 55/71] Expanded using last node on formatting to all
 shortcuts, and handled interpolate messiness.

---
 montepy/input_parser/syntax_node.py | 42 +++++++++++++++++------------
 1 file changed, 25 insertions(+), 17 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 76813e10..e8414909 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -2056,8 +2056,10 @@ def format(self, leading_node=None):
         # repeat
         elif self._type == Shortcuts.REPEAT:
             temp = self._format_repeat(leading_node)
+        # multiply
         elif self._type == Shortcuts.MULTIPLY:
             temp = self._format_multiply(leading_node)
+        # interpolate
         elif self._type in {Shortcuts.INTERPOLATE, Shortcuts.LOG_INTERPOLATE}:
             temp = self._format_interpolate(leading_node)
         if self.end_padding:
@@ -2085,23 +2087,26 @@ def _format_jump(self):
 
         return f"{num_jumps.format()}{j}"
 
+    def _can_use_last_node(self, node, start=None):
+        """Last node can be used if
+        - it's a basic ValueNode that matches this repeat
+        - it's also a shortcut, with the same edge values.
+        """
+        if isinstance(node, ValueNode):
+            value = node.value
+        elif isinstance(node, ShortcutNode):
+            value = node.nodes[-1].value
+        else:
+            return False
+        if value is None:
+            return False
+        if start is None:
+            start = self.nodes[0].value
+        return math.isclose(start, value)
+
     def _format_repeat(self, leading_node=None):
-        def can_use_last_node(node):
-            """Last node can be used if
-            - it's a basic ValueNode that matches this repeat
-            - it's also a shortcut, with the same edge values.
-            """
-            if isinstance(node, ValueNode):
-                value = node.value
-            elif isinstance(node, ShortcutNode):
-                value = node.nodes[-1].value
-            else:
-                return False
-            if value is None:
-                return False
-            return math.isclose(self.nodes[0].value, value)
 
-        if can_use_last_node(leading_node):
+        if self._can_use_last_node(leading_node):
             first_val = ""
             num_extra = 0
         else:
@@ -2124,7 +2129,7 @@ def can_use_last_node(node):
         return f"{first_val}{num_repeats.format()}{r}"
 
     def _format_multiply(self, leading_node=None):
-        if leading_node is not None:
+        if self._can_use_last_node(leading_node):
             first_val = leading_node.nodes[-1]
             first_val_str = ""
         else:
@@ -2138,7 +2143,10 @@ def _format_multiply(self, leading_node=None):
         return f"{first_val_str.format()}{self._num_node.format()}{m}"
 
     def _format_interpolate(self, leading_node=None):
-        if leading_node is not None:
+        begin = self._begin
+        if self.type == Shortcuts.LOG_INTERPOLATE:
+            begin = 10**begin
+        if self._can_use_last_node(leading_node, begin):
             start = ""
             num_extra_nodes = 1
         else:

From 82d7c9e3f1fe554a57d433c602f75d43a88dee28 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 16:54:59 -0500
Subject: [PATCH 56/71] Fixed test to be all caps.

---
 tests/test_syntax_parsing.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/test_syntax_parsing.py b/tests/test_syntax_parsing.py
index 422d5f43..5353237a 100644
--- a/tests/test_syntax_parsing.py
+++ b/tests/test_syntax_parsing.py
@@ -897,6 +897,7 @@ def test_shortcut_expansion_valid(test, answer):
     print(test)
     input = Input([test], BlockType.DATA)
     parsed = parser.parse(input.tokenize())
+    print(parsed)
     for val, gold in zip(parsed, answer):
         if val.value is None:
             assert gold == montepy.Jump()
@@ -942,7 +943,7 @@ def test_shortcut_expansion_invalid(test):
         ("1 1 2i 4 5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4  5 6"),
         ("1 1 2i 4:5 6 ", [1, 1, 2, 3, 4, 5, 6], "1 1 2I 4 :5 6"),
         ("1 ilog 100 ", [1, 10, 100], "1 1ILOG 100"),
-        ("1 1r ilog 100 ", [1, 1, 10, 100], "1 1r 1ILOG 100"),
+        ("1 1r ilog 100 ", [1, 1, 10, 100], "1 1R 1ILOG 100"),
         # secretly test iterator
         ("#1", [1], None),
         ("#(1 2 3)", [1, 2, 3], None),

From 9430561dcd16ac318f11165f072d7c94bb2f516d Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 16:55:35 -0500
Subject: [PATCH 57/71] Updated logic for multiply shortcuts using neigbors.

---
 montepy/input_parser/syntax_node.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index e8414909..f25f53cb 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -403,6 +403,8 @@ def start_shortcut():
 
     def _format_shortcut(self):
         list_wrap = self._flatten_shortcut()
+        if isinstance(list_wrap.nodes[-1], ShortcutNode):
+            list_wrap.nodes[-1].load_nodes(list_wrap.nodes[-1].nodes)
         return list_wrap.format()
 
     @property

From 5a8b34a2adda8e446cc2dd168bbf1a3543d5ac65 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 16:56:00 -0500
Subject: [PATCH 58/71] Created system to track starting value for interpolate
 in geometry trees.

---
 montepy/input_parser/syntax_node.py | 15 +++++++++++++--
 1 file changed, 13 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index f25f53cb..51461204 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -363,11 +363,19 @@ def add_leaf(list_node, leaf, short_type):
             end = list_node.nodes[-1] if len(list_node) > 0 else None
 
             def flush_shortcut():
-                # TODO this will probably blow up
                 end.load_nodes(end.nodes)
 
             def start_shortcut():
                 short = ShortcutNode(short_type=short_type)
+                # give an interpolate it's old beginning to give it right
+                # start value
+                if short_type in {
+                    Shortcuts.LOG_INTERPOLATE,
+                    Shortcuts.INTERPOLATE,
+                } and isinstance(end, ShortcutNode):
+                    short.append(end.nodes[-1])
+                    short._has_pseudo_start = True
+
                 short.append(leaf)
                 if not leaf.padding:
                     leaf.padding = PaddingNode(" ")
@@ -2131,7 +2139,8 @@ def _format_repeat(self, leading_node=None):
         return f"{first_val}{num_repeats.format()}{r}"
 
     def _format_multiply(self, leading_node=None):
-        if self._can_use_last_node(leading_node):
+        # Multiply doesn't usually consume other nodes
+        if leading_node is not None and len(self) == 1:
             first_val = leading_node.nodes[-1]
             first_val_str = ""
         else:
@@ -2151,6 +2160,8 @@ def _format_interpolate(self, leading_node=None):
         if self._can_use_last_node(leading_node, begin):
             start = ""
             num_extra_nodes = 1
+            if hasattr(self, "_has_pseudo_start"):
+                num_extra_nodes += 1
         else:
             start = self.nodes[0]
             num_extra_nodes = 2

From 628cd9ddbd4a502944a580c0ec392f0f42867cf5 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 3 Sep 2024 17:21:19 -0500
Subject: [PATCH 59/71] Added doc strings for new functions.

---
 montepy/input_parser/syntax_node.py | 49 +++++++++++++++++++++++++++--
 1 file changed, 46 insertions(+), 3 deletions(-)

diff --git a/montepy/input_parser/syntax_node.py b/montepy/input_parser/syntax_node.py
index 51461204..ae9743b4 100644
--- a/montepy/input_parser/syntax_node.py
+++ b/montepy/input_parser/syntax_node.py
@@ -292,6 +292,9 @@ class GeometryTree(SyntaxNodeBase):
     .. versionadded:: 0.2.0
         This was added with the major parser rework.
 
+    .. versionchanged:: 0.4.1
+        Added left/right_short_type
+
     :param name: a name for labeling this node.
     :type name: str
     :param tokens: The nodes that are in the tree.
@@ -302,6 +305,10 @@ class GeometryTree(SyntaxNodeBase):
     :type left: GeometryTree, ValueNode
     :param right: the node of the right side of the binary tree.
     :type right: GeometryTree, ValueNode
+    :param left_short_type: The type of Shortcut that right left leaf is involved in.
+    :type left_short_type: Shortcuts
+    :param right_short_type: The type of Shortcut that the right leaf is involved in.
+    :type right_short_type: Shortcuts
     """
 
     def __init__(
@@ -343,6 +350,12 @@ def format(self):
         return ret
 
     def mark_last_leaf_shortcut(self, short_type):
+        """
+        Mark the final (rightmost) leaf node in this tree as being a shortcut.
+
+        :param short_type: the type of shortcut that this leaf is.
+        :type short_type: Shortcuts
+        """
         if self.right is not None:
             node = self.right
             if self._right_short_type:
@@ -359,6 +372,14 @@ def mark_last_leaf_shortcut(self, short_type):
             self._left_short_type = short_type
 
     def _flatten_shortcut(self):
+        """
+        Flattens this tree into a ListNode.
+
+        This will add ShortcutNodes as well.
+
+        :rtype: ListNode
+        """
+
         def add_leaf(list_node, leaf, short_type):
             end = list_node.nodes[-1] if len(list_node) > 0 else None
 
@@ -410,6 +431,9 @@ def start_shortcut():
         return ret
 
     def _format_shortcut(self):
+        """
+        Handles formatting a subset of tree that has shortcuts in it.
+        """
         list_wrap = self._flatten_shortcut()
         if isinstance(list_wrap.nodes[-1], ShortcutNode):
             list_wrap.nodes[-1].load_nodes(list_wrap.nodes[-1].nodes)
@@ -1814,7 +1838,13 @@ def __init__(self, p=None, short_type=None, data_type=float):
 
     def load_nodes(self, nodes):
         """
-        TODO
+        Loads the given nodes into this shortcut, and update needed information.
+
+        For interpolate nodes should start and end with the beginning/end of
+        the interpolation.
+
+        :param nodes: the nodes to be loaded.
+        :type nodes: list
         """
         self._nodes = collections.deque(nodes)
         if self.type in {Shortcuts.INTERPOLATE, Shortcuts.LOG_INTERPOLATE}:
@@ -1845,7 +1875,9 @@ def end_padding(self, padding):
     @property
     def type(self):
         """
-        TODO
+        The Type of shortcut this ShortcutNode represents.
+
+        :rtype: Shortcuts
         """
         return self._type
 
@@ -2098,9 +2130,20 @@ def _format_jump(self):
         return f"{num_jumps.format()}{j}"
 
     def _can_use_last_node(self, node, start=None):
-        """Last node can be used if
+        """
+        Determine if the previous node can be used as the start to this node
+        (and therefore skip the start of this one).
+
+        Last node can be used if
         - it's a basic ValueNode that matches this repeat
         - it's also a shortcut, with the same edge values.
+
+        :param node: the previous node to test.
+        :type node: ValueNode, ShortcutNode
+        :param start: the starting value for this node (specifically for interpolation)
+        :type start: float
+        :returns: True if the node given can be used.
+        :rtype: bool
         """
         if isinstance(node, ValueNode):
             value = node.value

From c43e8cf4d1052b1997e73034fe01737a6108e457 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 13:58:27 -0500
Subject: [PATCH 60/71] Triggered edge case from #526 #520

---
 tests/inputs/test_importance.imcnp | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/inputs/test_importance.imcnp b/tests/inputs/test_importance.imcnp
index 3c44d740..ef0c8abe 100644
--- a/tests/inputs/test_importance.imcnp
+++ b/tests/inputs/test_importance.imcnp
@@ -41,6 +41,7 @@ MT3 lwtr.23t
 C execution
 ksrc 0 0 0
 imp:n,p 1 1 1 0 3
+c special comment related to #520
 imp:e   0 2r 1 r
 kcode 100000 1.000 50 1050
 phys:p j 1 2j 1

From 128c65166f1a127d766a5c5253d7ba6e2cb0b1b1 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 14:01:08 -0500
Subject: [PATCH 61/71] Update gold value with new line.

---
 tests/test_integration.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 508b946f..13b309c5 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -505,7 +505,7 @@ def test_importance_format_mutated(importance_problem):
     with pytest.warns(LineExpansionWarning):
         output = imp.format_for_mcnp_input((6, 2, 0))
     print(output)
-    assert len(output) == 3
+    assert len(output) == 4
     assert "imp:n 0.5 1 1 0 3" in output
 
 

From bfdb083130647b28075bec99fc3afaaff06c6ed1 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 14:26:11 -0500
Subject: [PATCH 62/71] Tried to move the trailing comments around the special
 tree for now.

---
 montepy/data_inputs/importance.py | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)

diff --git a/montepy/data_inputs/importance.py b/montepy/data_inputs/importance.py
index 8ef1c322..0f231340 100644
--- a/montepy/data_inputs/importance.py
+++ b/montepy/data_inputs/importance.py
@@ -340,6 +340,41 @@ def _try_combine_values(self, new_vals, particle_pairings):
     def _update_cell_values(self):
         pass
 
+    @property
+    def trailing_comment(self):
+        """
+        The trailing comments and padding of an input.
+
+        Generally this will be blank as these will be moved to be a leading comment for the next input.
+
+        :returns: the trailing ``c`` style comments and intermixed padding (e.g., new lines)
+        :rtype: list
+        """
+        last_tree = list(self._real_tree.values())[-1]
+        if last_tree:
+            return last_tree.get_trailing_comment()
+
+    def _delete_trailing_comment(self):
+        last_tree = list(self._real_tree.values())[-1]
+        if last_tree:
+            last_tree._delete_trailing_comment()
+
+    def _grab_beginning_comment(self, new_padding):
+        last_tree = None
+        last_padding = None
+        print(self._real_tree.keys())
+        for tree in self._real_tree.values():
+            print(tree)
+            if last_padding is not None and last_tree is not None:
+                last_tree._grab_beginning_comment(last_padding)
+                last_tree._delete_trailing_comment()
+            last_padding = tree.get_trailing_comment()
+            last_tree = tree
+        if new_padding:
+            next(iter(self._real_tree.values()))["start_pad"]._grab_beginning_comment(
+                new_padding
+            )
+
 
 def _generate_default_data_tree(particle):
     list_node = syntax_node.ListNode("number sequence")

From 9a88b22aed1c3dec6e98d336beec36d8cefa57b1 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 16:21:10 -0500
Subject: [PATCH 63/71] Updated test with new input model.

---
 tests/test_integration.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 13b309c5..5d094020 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -493,9 +493,9 @@ def test_importance_format_unmutated(importance_problem):
     imp = importance_problem.cells._importance
     output = imp.format_for_mcnp_input((6, 2, 0))
     print(output)
-    assert len(output) == 2
+    assert len(output) == 3
     assert "imp:n,p 1 1 1 0 3" == output[0]
-    assert "imp:e   0 2r 1 r" == output[1]
+    assert "imp:e   0 2r 1 r" == output[2]
 
 
 def test_importance_format_mutated(importance_problem):

From 9acdc7f75c74ca12b4bf628f4fcdbf7d2a938af5 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 16:21:44 -0500
Subject: [PATCH 64/71] Fixed potential repr bug.

---
 montepy/data_inputs/universe_input.py | 2 +-
 montepy/data_inputs/volume.py         | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/montepy/data_inputs/universe_input.py b/montepy/data_inputs/universe_input.py
index 291c8eed..f189f058 100644
--- a/montepy/data_inputs/universe_input.py
+++ b/montepy/data_inputs/universe_input.py
@@ -194,7 +194,7 @@ def __repr__(self):
             f"UNIVERSE: in_cell: {self._in_cell_block}"
             f" set_in_block: {self.set_in_cell_block}, "
             f"Universe : {self._universe}, "
-            f"Old Numbers: {self._old_numbers}"
+            f"Old Numbers: {self._old_numbers if hasattr(self, '_old_numbers') else ''}"
         )
         return ret
 
diff --git a/montepy/data_inputs/volume.py b/montepy/data_inputs/volume.py
index b78be685..e6db1e57 100644
--- a/montepy/data_inputs/volume.py
+++ b/montepy/data_inputs/volume.py
@@ -182,7 +182,7 @@ def __repr__(self):
         ret = (
             f"VOLUME: in_cell: {self._in_cell_block}, calc_by_mcnp: {self.is_mcnp_calculated},"
             f" set_in_block: {self.set_in_cell_block}, "
-            f"Volume : {self._volume}"
+            f"Volume : {self._volume if hasattr(self, '_volume') else ''}"
         )
         return ret
 

From 39a12c40072c8c418129668670cd6c43500d268b Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 16:22:14 -0500
Subject: [PATCH 65/71] Tried to figure out where this stupid valuenode comment
 is coming from.

---
 montepy/data_inputs/importance.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/montepy/data_inputs/importance.py b/montepy/data_inputs/importance.py
index 0f231340..a283f85f 100644
--- a/montepy/data_inputs/importance.py
+++ b/montepy/data_inputs/importance.py
@@ -355,16 +355,20 @@ def trailing_comment(self):
             return last_tree.get_trailing_comment()
 
     def _delete_trailing_comment(self):
-        last_tree = list(self._real_tree.values())[-1]
-        if last_tree:
-            last_tree._delete_trailing_comment()
+        for part, tree in self._real_tree.items():
+            tree._delete_trailing_comment()
+            for cell in reversed(list(self._problem.cells)):
+                print(cell.importance._particle_importances)
+                tree = cell.importance._particle_importances
+                if part in tree and tree[part].get_trailing_comment():
+                    tree._delete_trailing_comment()
+                    break
+        print(self._real_tree)
 
     def _grab_beginning_comment(self, new_padding):
         last_tree = None
         last_padding = None
-        print(self._real_tree.keys())
         for tree in self._real_tree.values():
-            print(tree)
             if last_padding is not None and last_tree is not None:
                 last_tree._grab_beginning_comment(last_padding)
                 last_tree._delete_trailing_comment()

From 35ffa26ab28d91dcbd7800e4aee19a87ddf08330 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 17:46:12 -0500
Subject: [PATCH 66/71] Made test more robust.

---
 tests/test_integration.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index 5d094020..ccea7751 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -507,6 +507,8 @@ def test_importance_format_mutated(importance_problem):
     print(output)
     assert len(output) == 4
     assert "imp:n 0.5 1 1 0 3" in output
+    assert "c special comment related to #520" == output[2]
+    assert False
 
 
 def test_importance_write_unmutated(importance_problem):

From ff6b81f75ac5a171e8b4c27d15b14a7c2131e666 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Tue, 10 Sep 2024 17:46:32 -0500
Subject: [PATCH 67/71] Found where the syntax node actually lives; needs work.

---
 montepy/data_inputs/importance.py | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/montepy/data_inputs/importance.py b/montepy/data_inputs/importance.py
index a283f85f..03034713 100644
--- a/montepy/data_inputs/importance.py
+++ b/montepy/data_inputs/importance.py
@@ -355,15 +355,11 @@ def trailing_comment(self):
             return last_tree.get_trailing_comment()
 
     def _delete_trailing_comment(self):
-        for part, tree in self._real_tree.items():
+        for part, tree in reversed(self._real_tree.items()):
             tree._delete_trailing_comment()
-            for cell in reversed(list(self._problem.cells)):
-                print(cell.importance._particle_importances)
-                tree = cell.importance._particle_importances
-                if part in tree and tree[part].get_trailing_comment():
-                    tree._delete_trailing_comment()
-                    break
-        print(self._real_tree)
+            part_tree = self._particle_importances[part]
+            part_tree["data"]._delete_trailing_comment()
+            break
 
     def _grab_beginning_comment(self, new_padding):
         last_tree = None

From b8b1a2c1f21f875c9265ce1da2779d94585ddfe5 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 11 Sep 2024 08:08:17 -0500
Subject: [PATCH 68/71] Removed forsed failure.

---
 tests/test_integration.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tests/test_integration.py b/tests/test_integration.py
index ccea7751..b50d0a65 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -508,7 +508,6 @@ def test_importance_format_mutated(importance_problem):
     assert len(output) == 4
     assert "imp:n 0.5 1 1 0 3" in output
     assert "c special comment related to #520" == output[2]
-    assert False
 
 
 def test_importance_write_unmutated(importance_problem):

From 9da343a6a7b9cb4e0abf3803115af855927100f3 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 11 Sep 2024 08:08:45 -0500
Subject: [PATCH 69/71] Setup system to track which particles were paired up.

---
 montepy/data_inputs/importance.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/montepy/data_inputs/importance.py b/montepy/data_inputs/importance.py
index 03034713..394a5299 100644
--- a/montepy/data_inputs/importance.py
+++ b/montepy/data_inputs/importance.py
@@ -29,6 +29,7 @@ class Importance(CellModifierInput):
     def __init__(self, input=None, in_cell_block=False, key=None, value=None):
         self._particle_importances = {}
         self._real_tree = {}
+        self._part_combos = []
         super().__init__(input, in_cell_block, key, value)
         if self.in_cell_block:
             if key:
@@ -39,6 +40,7 @@ def __init__(self, input=None, in_cell_block=False, key=None, value=None):
                     raise ValueError(
                         f"Cell importance must be a number ≥ 0. {val.value} was given"
                     )
+                self._part_combos.append(self.particle_classifiers)
                 for particle in self.particle_classifiers:
                     self._particle_importances[particle] = value
         elif input:
@@ -52,6 +54,7 @@ def __init__(self, input=None, in_cell_block=False, key=None, value=None):
                     raise MalformedInputError(
                         input, f"Importances must be ≥ 0 value: {node} given"
                     )
+            self._part_combos.append(self.particle_classifiers)
             for particle in self.particle_classifiers:
                 self._particle_importances[particle] = copy.deepcopy(self._tree)
                 self._real_tree[particle] = copy.deepcopy(self._tree)

From 5882881925421c3d985b5f09a98d2ec31a3905e2 Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 11 Sep 2024 08:09:10 -0500
Subject: [PATCH 70/71] Updated to use actual trees, and ensured all affected
 trees cleared.

---
 montepy/data_inputs/importance.py | 21 ++++++++++++++-------
 1 file changed, 14 insertions(+), 7 deletions(-)

diff --git a/montepy/data_inputs/importance.py b/montepy/data_inputs/importance.py
index 394a5299..6c8b38cf 100644
--- a/montepy/data_inputs/importance.py
+++ b/montepy/data_inputs/importance.py
@@ -360,23 +360,30 @@ def trailing_comment(self):
     def _delete_trailing_comment(self):
         for part, tree in reversed(self._real_tree.items()):
             tree._delete_trailing_comment()
-            part_tree = self._particle_importances[part]
-            part_tree["data"]._delete_trailing_comment()
+            self.__delete_common_trailing(part)
             break
 
+    def __delete_common_trailing(self, part):
+        to_delete = {part}
+        for combo_set in self._part_combos:
+            if part in combo_set:
+                to_delete |= combo_set
+        for part in to_delete:
+            self._particle_importances[part]["data"]._delete_trailing_comment()
+
     def _grab_beginning_comment(self, new_padding):
         last_tree = None
         last_padding = None
-        for tree in self._real_tree.values():
+        for part, tree in self._particle_importances.items():
             if last_padding is not None and last_tree is not None:
                 last_tree._grab_beginning_comment(last_padding)
-                last_tree._delete_trailing_comment()
+                self.__delete_common_trailing(part)
             last_padding = tree.get_trailing_comment()
             last_tree = tree
         if new_padding:
-            next(iter(self._real_tree.values()))["start_pad"]._grab_beginning_comment(
-                new_padding
-            )
+            next(iter(self._particle_importances.values()))[
+                "start_pad"
+            ]._grab_beginning_comment(new_padding)
 
 
 def _generate_default_data_tree(particle):

From a30549b4513891919fd50a5c23f9cfc436faa64e Mon Sep 17 00:00:00 2001
From: "Micah D. Gale" <micah.gale@inl.gov>
Date: Wed, 11 Sep 2024 10:00:37 -0500
Subject: [PATCH 71/71] Fixed bug where the parameters weren't actually loaded
 into syntax tree.

---
 montepy/input_parser/material_parser.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/montepy/input_parser/material_parser.py b/montepy/input_parser/material_parser.py
index bb85bf75..1a932188 100644
--- a/montepy/input_parser/material_parser.py
+++ b/montepy/input_parser/material_parser.py
@@ -18,8 +18,8 @@ def material(self, p):
         for key, node in p.introduction.nodes.items():
             ret[key] = node
         ret["data"] = p.isotopes
-        if hasattr(p, "parameters"):
-            ret["parameters"] = p.parameters
+        if len(p) > 2:
+            ret["parameters"] = p[2]
         return syntax_node.SyntaxNode("data", ret)
 
     @_("isotope_fractions", "number_sequence", "isotope_hybrid_fractions")