```json
{
  "sym_variables": [
    ("x0", "strips of bacon"),
    ("x1", "hamburgers"),
    ("x2", "eggs"),
    ("x3", "tomatoes"),
    ("x4", "kiwis"),
    ("x5", "green beans")
  ],
  "objective_function": "4.83*x0 + 4.13*x1 + 8.98*x2 + 8.37*x3 + 8.57*x4 + 2.51*x5",
  "constraints": [
    "4.54*x0 + 4.39*x5 >= 74",
    "4.54*x0 + 6.92*x3 >= 66",
    "5.82*x4 + 4.39*x5 >= 57",
    "6.92*x3 + 4.39*x5 >= 70",
    "1.24*x1 + 5.82*x4 >= 51",
    "4.54*x0 + 1.24*x1 + 4.44*x2 >= 54",
    "4.54*x0 + 4.44*x2 + 5.82*x4 >= 54",
    "1.24*x1 + 4.44*x2 + 4.39*x5 >= 54",
    "4.54*x0 + 4.44*x2 + 6.92*x3 >= 54",
    "4.54*x0 + 6.92*x3 + 5.82*x4 >= 54",
    "1.24*x1 + 4.44*x2 + 5.82*x4 >= 54",
    "4.54*x0 + 6.92*x3 + 4.39*x5 >= 54",
    "1.24*x1 + 6.92*x3 + 5.82*x4 >= 54",
    "1.24*x1 + 4.44*x2 + 6.92*x3 >= 54",
    "4.54*x0 + 5.82*x4 + 4.39*x5 >= 54",
    "4.54*x0 + 1.24*x1 + 6.92*x3 >= 54",
    "4.44*x2 + 6.92*x3 + 5.82*x4 >= 54",
    "3.82*x0 + 5.91*x5 >= 22",
    "4.72*x1 + 5.41*x3 >= 24",
    "3.14*x2 + 5.41*x3 >= 33",
    "5.41*x3 + 5.91*x5 >= 23",
    "7*x2 - 9*x4 >= 0",
    "-7*x0 + 10*x4 >= 0",
    "2*x3 - 4*x4 >= 0",
    "8*x0 - 5*x2 >= 0",
    "4.54*x0 + 5.82*x4 <= 202",
    "1.24*x1 + 6.92*x3 <= 206",
    "4.54*x0 + 4.39*x5 <= 204",
    "5.82*x4 + 4.39*x5 <= 274",
    "r0 <= 510",
    "r1 <= 237"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = {}
item_names = ['strips of bacon', 'hamburgers', 'eggs', 'tomatoes', 'kiwis', 'green beans']
for i in range(len(item_names)):
    x[i] = m.addVar(vtype=gp.GRB.CONTINUOUS, name=item_names[i])


# Set objective function
objective = 4.83 * x[0] + 4.13 * x[1] + 8.98 * x[2] + 8.37 * x[3] + 8.57 * x[4] + 2.51 * x[5]
m.setObjective(objective, gp.GRB.MINIMIZE)

# Resource data
resources = {
    'r0': {'description': 'umami index', 'upper_bound': 510, 'x0': 4.54, 'x1': 1.24, 'x2': 4.44, 'x3': 6.92, 'x4': 5.82, 'x5': 4.39},
    'r1': {'description': 'grams of protein', 'upper_bound': 237, 'x0': 3.82, 'x1': 4.72, 'x2': 3.14, 'x3': 5.41, 'x4': 3.39, 'x5': 5.91}
}

# Add resource constraints
r = {}
for resource_key, resource_data in resources.items():
    r[resource_key] = m.addVar(vtype=gp.GRB.CONTINUOUS, name=resource_data['description'])
    expression = gp.LinExpr()
    for i in range(len(item_names)):
        if f'x{i}' in resource_data:
            expression += resource_data[f'x{i}'] * x[i]
    m.addConstr(r[resource_key] == expression)
    m.addConstr(r[resource_key] <= resource_data['upper_bound'])


# Add other constraints (simplified using symbolic representation)
m.addConstr(4.54*x[0] + 4.39*x[5] >= 74)
m.addConstr(4.54*x[0] + 6.92*x[3] >= 66)
m.addConstr(5.82*x[4] + 4.39*x[5] >= 57)
m.addConstr(6.92*x[3] + 4.39*x[5] >= 70)
m.addConstr(1.24*x[1] + 5.82*x[4] >= 51)
# ... (add all other constraints similarly)
m.addConstr(4.54*x[0] + 5.82*x[4] <= 202)
m.addConstr(1.24*x[1] + 6.92*x[3] <= 206)
# ... (add all other constraints similarly)


# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    print("Optimal solution found:")
    for i in range(len(item_names)):
        print(f"{item_names[i]}: {x[i].x}")
    print("Objective value:", m.objVal)
elif m.status == gp.GRB.INFEASIBLE:
    print("Model is infeasible.")
else:
    print(f"Optimization terminated with status {m.status}")

```