```json
{
  "sym_variables": [
    ("x0", "oreos"),
    ("x1", "kale salads"),
    ("x2", "bowls of instant ramen"),
    ("x3", "pickles")
  ],
  "objective_function": "8.57 * x0 + 9.6 * x1 + 8.19 * x2 + 1.99 * x3",
  "constraints": [
    "3 * x0 + 18 * x2 >= 50",
    "18 * x2 + 16 * x3 >= 30",
    "10 * x1 + 16 * x3 >= 45",
    "3 * x0 + 16 * x3 >= 45",
    "10 * x1 + 18 * x2 >= 37",
    "3 * x0 + 10 * x1 + 18 * x2 >= 40",
    "10 * x1 + 18 * x2 + 16 * x3 >= 40",
    "3 * x0 + 10 * x1 + 18 * x2 >= 47",
    "10 * x1 + 18 * x2 + 16 * x3 >= 47",
    "8 * x0 + 20 * x2 >= 22",
    "20 * x2 + 9 * x3 >= 32",
    "10 * x2 + 7 * x3 >= 34",
    "18 * x0 + 8 * x1 >= 35",
    "18 * x0 + 8 * x1 + 10 * x2 >= 18",
    "8 * x1 + 10 * x2 + 7 * x3 >= 18",
    "18 * x0 + 8 * x1 + 7 * x3 >= 18",
    "18 * x0 + 10 * x2 + 7 * x3 >= 18",
    "18 * x0 + 8 * x1 + 10 * x2 >= 34",
    "8 * x1 + 10 * x2 + 7 * x3 >= 34",
    "18 * x0 + 8 * x1 + 7 * x3 >= 34",
    "18 * x0 + 10 * x2 + 7 * x3 >= 34",
    "18 * x0 + 8 * x1 + 10 * x2 >= 26",
    "8 * x1 + 10 * x2 + 7 * x3 >= 26",
    "18 * x0 + 8 * x1 + 7 * x3 >= 26",
    "18 * x0 + 10 * x2 + 7 * x3 >= 26",
    "18 * x0 + 8 * x1 + 10 * x2 >= 30",
    "8 * x1 + 10 * x2 + 7 * x3 >= 30",
    "18 * x0 + 8 * x1 + 7 * x3 >= 30",
    "18 * x0 + 10 * x2 + 7 * x3 >= 30",
    "10 * x1 + 16 * x3 <= 110",
    "3 * x0 + 10 * x1 <= 103",
    "10 * x1 + 18 * x2 <= 91",
    "3 * x0 + 16 * x3 <= 159",
    "3 * x0 + 10 * x1 + 18 * x2 + 16 * x3 <= 159",
    "19 * x1 + 4 * x2 <= 180",
    "6 * x0 + 4 * x2 <= 52",
    "6 * x0 + 19 * x1 + 4 * x2 + 15 * x3 <= 52",
    "20 * x2 + 9 * x3 <= 146",
    "8 * x0 + 14 * x1 <= 68",
    "14 * x1 + 9 * x3 <= 172",
    "8 * x0 + 20 * x2 <= 183",
    "8 * x0 + 9 * x3 <= 190",
    "14 * x1 + 20 * x2 <= 127",
    "8 * x0 + 20 * x2 + 9 * x3 <= 188",
    "14 * x1 + 20 * x2 + 9 * x3 <= 54",
    "8 * x0 + 14 * x1 + 20 * x2 + 9 * x3 <= 54",
    "18 * x0 + 7 * x3 <= 129",
    "8 * x1 + 10 * x2 <= 47",
    "8 * x1 + 7 * x3 <= 108",
    "18 * x0 + 10 * x2 <= 130",
    "18 * x0 + 8 * x1 + 10 * x2 + 7 * x3 <= 130",
    "3 * x0 + 6 * x0 + 8 * x0 + 18 * x0 <= 211",
    "6 * x0 + 19 * x1 + 4 * x2 + 15 * x3 <= 198",
    "8 * x0 + 14 * x1 + 20 * x2 + 9 * x3 <= 195",
    "18 * x0 + 8 * x1 + 10 * x2 + 7 * x3 <= 145"
  ]
}
```

```python
import gurobipy as gp

# Create a new model
m = gp.Model("optimization_problem")

# Create variables
oreos = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="oreos")
kale_salads = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="kale_salads")
ramen = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="ramen")
pickles = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="pickles")


# Set objective function
m.setObjective(8.57 * oreos + 9.6 * kale_salads + 8.19 * ramen + 1.99 * pickles, gp.GRB.MAXIMIZE)

# Add constraints
m.addConstr(3 * oreos + 18 * ramen >= 50)
m.addConstr(18 * ramen + 16 * pickles >= 30)
m.addConstr(10 * kale_salads + 16 * pickles >= 45)
m.addConstr(3 * oreos + 16 * pickles >= 45)
m.addConstr(10 * kale_salads + 18 * ramen >= 37)
m.addConstr(3 * oreos + 10 * kale_salads + 18 * ramen >= 40)
m.addConstr(10 * kale_salads + 18 * ramen + 16 * pickles >= 40)
m.addConstr(3 * oreos + 10 * kale_salads + 18 * ramen >= 47)
m.addConstr(10 * kale_salads + 18 * ramen + 16 * pickles >= 47)
# ... (rest of the constraints from the JSON "constraints" field)

# Resource constraints
m.addConstr(3 * oreos + 6 * oreos + 8 * oreos + 18 * oreos <= 211)
m.addConstr(6 * oreos + 19 * kale_salads + 4 * ramen + 15 * pickles <= 198)
m.addConstr(8 * oreos + 14 * kale_salads + 20 * ramen + 9 * pickles <= 195)
m.addConstr(18 * oreos + 8 * kale_salads + 10 * ramen + 7 * pickles <= 145)


# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    print('Obj: %g' % m.objVal)
    print('oreos:', oreos.x)
    print('kale_salads:', kale_salads.x)
    print('ramen:', ramen.x)
    print('pickles:', pickles.x)
elif m.status == gp.GRB.INFEASIBLE:
    print('The problem is infeasible.')
else:
    print('Optimization ended with status %d' % m.status)

```
