```json
{
  "sym_variables": [
    ("x0", "protein bars"),
    ("x1", "cantaloupes"),
    ("x2", "strips of bacon"),
    ("x3", "fruit salads"),
    ("x4", "kiwis"),
    ("x5", "milkshakes"),
    ("x6", "lemons")
  ],
  "objective_function": "7*x0 + 1*x1 + 5*x2 + 2*x3 + 3*x4 + 9*x5 + 7*x6",
  "constraints": [
    "13*x0 + 8*x1 + 2*x2 + 20*x3 + 9*x4 + 6*x5 + 8*x6 <= 761",
    "11*x0 + 3*x1 + 16*x2 + 4*x3 + 19*x4 + 9*x5 + 3*x6 <= 174",
    "8*x0 + 4*x1 + 15*x2 + 19*x3 + 13*x4 + 10*x5 + 4*x6 <= 182",
    "20*x3 + 6*x5 >= 43",
    "8*x1 + 6*x5 >= 57",
    "20*x3 + 8*x6 >= 45",
    "9*x4 + 8*x6 >= 102",
    "13*x0 + 8*x6 >= 86",
    "2*x2 + 20*x3 >= 64",
    "8*x1 + 2*x2 + 6*x5 >= 65",
    "13*x0 + 20*x3 + 6*x5 >= 65",
    "13*x0 + 20*x3 + 9*x4 >= 65",
    "13*x0 + 8*x1 + 6*x5 >= 65",
    "8*x1 + 20*x3 + 6*x5 >= 65",
    "13*x0 + 9*x4 + 6*x5 >= 65",
    "8*x1 + 2*x2 + 8*x6 >= 65",
    "13*x0 + 6*x5 + 8*x6 >= 65",
    "8*x1 + 20*x3 + 8*x6 >= 65",
    "8*x1 + 20*x3 + 9*x4 >= 65",
    "13*x0 + 8*x1 + 9*x4 >= 65",
    "2*x2 + 20*x3 + 8*x6 >= 65",
    "13*x0 + 2*x2 + 20*x3 >= 65",
    "13*x0 + 2*x2 + 9*x4 >= 65",
    "20*x3 + 6*x5 + 8*x6 >= 65",
    "13*x0 + 8*x1 + 2*x2 >= 65",
    "8*x1 + 2*x2 + 20*x3 >= 65",
    "13*x0 + 20*x3 + 8*x6 >= 65",
    "2*x2 + 9*x4 + 6*x5 >= 65",
    "2*x2 + 9*x4 + 8*x6 >= 65",
    "2*x2 + 6*x5 + 8*x6 >= 65",
    "2*x2 + 20*x3 + 6*x5 >= 65",
    "8*x1 + 9*x4 + 6*x5 >= 65",
    "8*x1 + 9*x4 + 8*x6 >= 65",
    "20*x3 + 9*x4 + 6*x5 >= 65",
    "8*x1 + 2*x2 + 6*x5 >= 82",
    "8*x0 + 4*x1 + 15*x2 + 19*x3 + 13*x4 + 10*x5 + 4*x6 <= 182",
    "x0 >= 0",
    "x1 >= 0",
    "x2 >= 0",
    "x3 >= 0",
    "x4 >= 0",
    "x5 >= 0",
    "x6 >= 0",
    "x0 == int(x0)",
    "x1 == int(x1)",
    "x3 == int(x3)",
    "x4 == int(x4)",
    "x5 == int(x5)",
    "x6 == int(x6)"
  ]
}
```

```python
from gurobipy import Model, GRB

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

# Create variables
x = {}
items = ['protein bars', 'cantaloupes', 'strips of bacon', 'fruit salads', 'kiwis', 'milkshakes', 'lemons']
for i in range(len(items)):
    if items[i] in ['strips of bacon']:
        x[i] = m.addVar(vtype=GRB.CONTINUOUS, name=f"x{i}")
    else:
        x[i] = m.addVar(vtype=GRB.INTEGER, name=f"x{i}")


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

# Add constraints based on resources
resources = {
    'r0': {'upper_bound': 761, 'x0': 13, 'x1': 8, 'x2': 2, 'x3': 20, 'x4': 9, 'x5': 6, 'x6': 8},
    'r1': {'upper_bound': 174, 'x0': 11, 'x1': 3, 'x2': 16, 'x3': 4, 'x4': 19, 'x5': 9, 'x6': 3},
    'r2': {'upper_bound': 182, 'x0': 8, 'x1': 4, 'x2': 15, 'x3': 19, 'x4': 13, 'x5': 10, 'x6': 4}
}

for r_key, r_data in resources.items():
    m.addConstr(sum(r_data[f'x{i}'] * x[i] for i in range(len(items))) <= r_data['upper_bound'], name=r_key)

# Add additional constraints from the problem description
m.addConstr(20*x[3] + 6*x[5] >= 43)
m.addConstr(8*x[1] + 6*x[5] >= 57)
m.addConstr(20*x[3] + 8*x[6] >= 45)
m.addConstr(9*x[4] + 8*x[6] >= 102)
m.addConstr(13*x[0] + 8*x[6] >= 86)
m.addConstr(2*x[2] + 20*x[3] >= 64)


# ... (Add all other constraints similarly)


# 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 terminated with status {m.status}")

```