Your goal is to generate two things:

First, generate a python function named `gen_plan` that can take any discrete or continuous inputs. No list inputs are allowed.
and return the entire plan with all steps included where the parameters to the plan depend on the inputs.

The plan should be generated based on the initial high-level computation graph, which is composed of a sequence of subgoals.  
Each subgoal corresponds to either a manipulation action or a prerequisite operation (e.g., remove obstacle).

Second, generate a python function `gen_domain` that returns a set of bounds for the continuous or discrete input parameters. The number of bounds in the
generated domain should exactly match the number of inputs to the function excluding the state input

The function you give should always achieve the goal regardless of what parameters from the domain are passed as input. 
The `gen_plan` function therefore defines a family of solutions to the problem. Explain why the function will always satisfy the goal regardless of the input parameters.
Make sure your function inputs allow for as much variability in output plan as possible while still achieving the goal.
Your function should be as general as possible such that any correct answer corresponds to some input parameters to the function.

The main function should be named EXACTLY `gen_plan` and the domain of the main function should be named EXACTLY `gen_domain`. Do not change the names. Do not create any additional classes or overwrite any existing ones.
Aside from the inital state all inputs to the `gen_plan` function MUST NOT be of type List or Dict. List and Dict inputs to `gen_plan` are not allowed.
Additionally, the input to `gen_domain` must be exactly the `initial:RavenBelief` argument, even if this isn't explicitly used within the function!

#define user
Goal: Place a green block next to another green block
initial = RavenBelief({"object_0": RavenObject(category="block", color="yellow", pose=[0.04, -0.36, 0.02, 0.0, -0.0, -0.0]), "object_1": RavenObject(category="block", color="green", pose=[0.05, -0.55, 0.02, 0.0, -0.0, -0.0]), "object_2": RavenObject(category="block", color="blue", pose=[-0.08, -0.68, 0.02, 0.0, -0.0, -0.0]), "object_3": RavenObject(category="bowl", color="green", pose=[-0.14, -0.35, 0.03, 0.0, -0.0, 0.0])})
High-Level Subgoals = 1. Pick object_1; 2. Place object_1 next to object_3

#define assistant
```python
def gen_plan(initial:RavenBelief, x_offset:float, y_offset:float):
    plan = []
    block1 = initial.objects["object_1"]
    block3 = initial.objects["object_3"]
    plan.append(Action("pick", block1.pose.point))
    x, y, z = block3.pose.point
    plan.append(Action("place", [x+x_offset, y+y_offset, z]))
    return plan

def gen_domain(initial:RavenBelief):
    return {
        "x_offset": ContinuousSampler(-0.1, 0.1),
        "y_offset": ContinuousSampler(-0.1, 0.1),
    }
```

#define user
High-Level Subgoals: 1. Pick object_2; 2. Place object_2 at a clear location; 3. Pick object_1; 4. Place object_1 next to object_3

#define assistant
```python
def gen_plan(initial: RavenBelief, 
             x_clear: float, y_clear: float, 
             x_offset: float, y_offset: float):
    plan = []

    # subgoal 1: Pick object_2 (the blocker)
    block2 = initial.objects["object_2"]
    plan.append(Action("pick", block2.pose.point))

    # subgoal 2: Place object_2 at a clear location
    plan.append(Action("place", [x_clear, y_clear, block2.pose.point[2]]))

    # subgoal 3: Pick object_1 (target green block)
    block1 = initial.objects["object_1"]
    plan.append(Action("pick", block1.pose.point))

    # subgoal 4: Place object_1 next to object_3 (green bowl)
    block3 = initial.objects["object_3"]
    x, y, z = block3.pose.point
    plan.append(Action("place", [x + x_offset, y + y_offset, z]))

    return plan

def gen_domain(initial: RavenBelief):
    return {
        "x_clear": ContinuousSampler(TABLE_BOUNDS[0][0], TABLE_BOUNDS[0][1]),
        "y_clear": ContinuousSampler(TABLE_BOUNDS[1][0], TABLE_BOUNDS[1][1]),
        "x_offset": ContinuousSampler(-0.1, 0.1),
        "y_offset": ContinuousSampler(-0.1, 0.1),
    }

```
