```json
{
  "sym_variables": [
    ("x0", "rotisserie chickens"),
    ("x1", "bananas"),
    ("x2", "bowls of instant ramen"),
    ("x3", "bowls of pasta"),
    ("x4", "strips of bacon"),
    ("x5", "ham sandwiches")
  ],
  "objective_function": "1*x0 + 1*x1 + 9*x2 + 6*x3 + 7*x4 + 4*x5",
  "constraints": [
    "8*x0 + 2*x1 + 13*x2 + 13*x3 + 10*x4 + 5*x5 <= 181",
    "8*x0 + 11*x1 + 6*x2 + 4*x3 + 1*x4 + 2*x5 <= 214",
    "9*x0 + 1*x1 + 6*x2 + 13*x3 + 11*x4 + 13*x5 <= 503",
    "13*x3 + 5*x5 >= 23",
    "8*x0 + 13*x3 >= 30",
    "13*x2 + 10*x4 >= 29",
    "8*x0 + 10*x4 >= 13",
    "2*x1 + 13*x2 >= 26",
    "2*x1 + 13*x3 >= 22",
    "8*x0 + 5*x5 >= 21",
    "8*x0 + 11*x1 + 4*x3 >= 32",
    "8*x0 + 4*x3 + 2*x5 >= 32",
    "6*x2 + 1*x4 + 2*x5 >= 32",
    "8*x0 + 11*x1 + 4*x3 >= 26",
    "8*x0 + 4*x3 + 2*x5 >= 26",
    "6*x2 + 1*x4 + 2*x5 >= 26",
    "8*x0 + 11*x1 + 4*x3 >= 30",
    "8*x0 + 4*x3 + 2*x5 >= 30",
    "6*x2 + 1*x4 + 2*x5 >= 30",
    "11*x4 + 13*x5 >= 60",
    "13*x3 + 13*x5 >= 75",
    "9*x0 + 6*x2 >= 52",
    "9*x0 + 13*x3 + 13*x5 >= 62",
    "9*x0 + 6*x2 + 11*x4 >= 62",
    "9*x0 + 6*x2 + 13*x5 >= 62",
    "1*x1 + 13*x3 + 11*x4 >= 62",
    "6*x2 + 13*x3 + 13*x5 >= 62",
    "1*x1 + 6*x2 + 13*x3 >= 62",
    "9*x0 + 1*x1 + 11*x4 >= 62",
    "1*x1 + 6*x2 + 13*x5 >= 62",
    "6*x2 + 11*x4 + 13*x5 >= 62",
    "1*x1 + 6*x2 + 11*x4 >= 62",
    "8*x0 + 10*x4 <= 69",
    "2*x1 + 13*x3 <= 43",
    "13*x3 + 10*x4 <= 125",
    "2*x1 + 13*x2 <= 33",
    "8*x0 + 13*x2 <= 62",
    "2*x1 + 10*x4 <= 87",
    "8*x0 + 5*x5 <= 116",
    "8*x0 + 13*x3 <= 39",
    "2*x1 + 5*x5 <= 111",
    "8*x0 + 13*x3 + 5*x5 <= 146",
    "13*x2 + 13*x3 + 5*x5 <= 36",
    "8*x0 + 2*x1 + 13*x2 + 13*x3 + 10*x4 + 5*x5 <= 36",
    "8*x0 + 6*x2 <= 136",
    "4*x3 + 2*x5 <= 97",
    "11*x1 + 1*x4 <= 147",
    "6*x2 + 1*x4 <= 182",
    "11*x1 + 4*x3 <= 151",
    "8*x0 + 4*x3 <= 73",
    "8*x0 + 1*x4 <= 70",
    "6*x2 + 2*x5 <= 117",
    "4*x3 + 1*x4 <= 63",
    "8*x0 + 6*x2 + 1*x4 <= 52",
    "11*x1 + 6*x2 + 4*x3 <= 132",
    "8*x0 + 4*x3 + 1*x4 <= 107",
    "8*x0 + 11*x1 + 6*x2 + 4*x3 + 1*x4 + 2*x5 <= 107",
    "1*x1 + 11*x4 <= 281",
    "9*x0 + 11*x4 <= 477",
    "6*x2 + 13*x5 <= 343",
    "13*x3 + 13*x5 <= 134",
    "9*x0 + 13*x5 <= 365",
    "9*x0 + 6*x2 + 11*x4 <= 308",
    "9*x0 + 1*x1 + 13*x5 <= 441",
    "9*x0 + 13*x3 + 11*x4 <= 476",
    "1*x1 + 6*x2 + 11*x4 <= 278",
    "9*x0 + 1*x1 + 6*x2 <= 360",
    "9*x0 + 1*x1 + 11*x4 <= 459",
    "13*x3 + 11*x4 + 13*x5 <= 90",
    "6*x2 + 13*x3 + 11*x4 <= 185",
    "1*x1 + 13*x3 + 11*x4 <= 117",
    "1*x1 + 6*x2 + 13*x5 <= 201",
    "9*x0 + 1*x1 + 6*x2 + 13*x3 + 11*x4 + 13*x5 <= 201"
  ]
}
```

```python
from gurobipy import Model, GRB

# Create a new model
m = Model("food_optimization")

# Create variables
x = {}
item_names = ['rotisserie chickens', 'bananas', 'bowls of instant ramen', 'bowls of pasta', 'strips of bacon', 'ham sandwiches']
for i in range(len(item_names)):
    x[i] = m.addVar(vtype=GRB.CONTINUOUS, name=item_names[i])


# Set objective function
m.setObjective(1*x[0] + 1*x[1] + 9*x[2] + 6*x[3] + 7*x[4] + 4*x[5], GRB.MAXIMIZE)

# Add constraints
resource_data = {
    'r0': {'upper_bound': 181, 'x0': 8, 'x1': 2, 'x2': 13, 'x3': 13, 'x4': 10, 'x5': 5},
    'r1': {'upper_bound': 214, 'x0': 8, 'x1': 11, 'x2': 6, 'x3': 4, 'x4': 1, 'x5': 2},
    'r2': {'upper_bound': 503, 'x0': 9, 'x1': 1, 'x2': 6, 'x3': 13, 'x4': 11, 'x5': 13}
}

for resource, data in resource_data.items():
    m.addConstr(sum(data[f'x{i}'] * x[i] for i in range(6)) <= data['upper_bound'], resource)


constraints = [
    (13*x[3] + 5*x[5], ">=", 23),
    (8*x[0] + 13*x[3], ">=", 30),
    (13*x[2] + 10*x[4], ">=", 29),
    (8*x[0] + 10*x[4], ">=", 13),
    (2*x[1] + 13*x[2], ">=", 26),
    (2*x[1] + 13*x[3], ">=", 22),
    (8*x[0] + 5*x[5], ">=", 21),
    (8*x[0] + 11*x[1] + 4*x[3], ">=", 32),
    (8*x[0] + 4*x[3] + 2*x[5], ">=", 32),
    (6*x[2] + 1*x[4] + 2*x[5], ">=", 32),
    # ... (rest of the constraints)
]

for expr, sense, rhs in constraints:
    if sense == ">=":
        m.addConstr(expr >= rhs)
    elif sense == "<=":
        m.addConstr(expr <= rhs)
    elif sense == "=":
        m.addConstr(expr == rhs)


# Optimize model
m.optimize()

# Print results
if m.status == GRB.OPTIMAL:
    print('Obj: %g' % m.objVal)
    for v in m.getVars():
        print('%s %g' % (v.varName, v.x))
elif m.status == GRB.INFEASIBLE:
    print("The model is infeasible.")
else:
    print(f"Optimization ended with status {m.status}")

```