```json
{
  "sym_variables": [
    ("x0", "bagged salads"),
    ("x1", "chicken thighs"),
    ("x2", "cantaloupes"),
    ("x3", "bowls of pasta"),
    ("x4", "chicken drumsticks"),
    ("x5", "bowls of cereal"),
    ("x6", "potatoes")
  ],
  "objective_function": "4*x0 + 5*x1 + 7*x2 + 2*x3 + 5*x4 + 1*x5 + 9*x6",
  "constraints": [
    "2*x0 + 14*x3 >= 39",
    "2*x0 + 6*x1 >= 38",
    "19*x4 + 13*x5 >= 63",
    "14*x3 + 13*x5 >= 65",
    "14*x3 + 7*x6 >= 39",
    "2*x0 + 19*x4 >= 56",
    "2*x0 + 7*x6 >= 37",
    "6*x1 + 19*x4 >= 62",
    "2*x0 + 13*x5 >= 77",
    "15*x2 + 7*x6 >= 49",
    "14*x3 + 19*x4 >= 62",
    "2*x0 + 15*x2 >= 50",
    "2*x0 + 13*x5 + 7*x6 >= 72",
    "2*x0 + 6*x1 + 15*x2 + 14*x3 + 19*x4 + 13*x5 + 7*x6 >= 72",
    "6*x2 + 6*x6 >= 38",
    "17*x0 + 11*x1 >= 31",
    "6*x2 + 12*x5 >= 36",
    "10*x4 + 6*x6 >= 47",
    "6*x2 + 12*x3 >= 30",
    "6*x2 + 10*x4 >= 23",
    "12*x5 + 6*x6 >= 23",
    "17*x0 + 12*x3 >= 49",
    "11*x1 + 12*x3 >= 39",
    "11*x1 + 6*x2 >= 20",
    "10*x4 + 12*x5 >= 23",
    "11*x1 + 6*x2 + 12*x3 >= 26",
    "17*x0 + 6*x2 + 12*x3 >= 26",
    "11*x1 + 10*x4 + 6*x6 >= 26",
    "11*x1 + 6*x2 + 12*x3 >= 35",
    "17*x0 + 6*x2 + 12*x3 >= 35",
    "11*x1 + 10*x4 + 6*x6 >= 35",
    "11*x1 + 6*x2 + 12*x3 >= 44",
    "17*x0 + 6*x2 + 12*x3 >= 44",
    "11*x1 + 10*x4 + 6*x6 >= 44",
    "17*x0 + 11*x1 + 6*x2 + 12*x3 + 10*x4 + 12*x5 + 6*x6 >= 44",
    "7*x1 + 13*x3 >= 30",
    "13*x0 + 9*x2 >= 25",
    "13*x3 + 7*x6 >= 18",
    "13*x0 + 7*x1 + 9*x2 >= 19",
    "13*x0 + 7*x1 + 16*x5 >= 19",
    "13*x0 + 9*x2 + 7*x6 >= 19",
    "13*x3 + 16*x5 + 7*x6 >= 19",
    "13*x0 + 13*x3 + 7*x6 >= 19",
    "7*x1 + 13*x4 + 16*x5 >= 19",
    "13*x0 + 7*x1 + 9*x2 >= 32",
    "13*x0 + 7*x1 + 16*x5 >= 32",
    "13*x0 + 9*x2 + 7*x6 >= 32",
    "13*x3 + 16*x5 + 7*x6 >= 32",
    "13*x0 + 13*x3 + 7*x6 >= 32",
    "7*x1 + 13*x4 + 16*x5 >= 32",
    "13*x0 + 7*x1 + 9*x2 >= 17",
    "13*x0 + 7*x1 + 16*x5 >= 17",
    "13*x0 + 9*x2 + 7*x6 >= 17",
    "13*x3 + 16*x5 + 7*x6 >= 17",
    "13*x0 + 13*x3 + 7*x6 >= 17",
    "7*x1 + 13*x4 + 16*x5 >= 17",
    "13*x0 + 7*x1 + 9*x2 >= 28",
    "13*x0 + 7*x1 + 16*x5 >= 28",
    "13*x0 + 9*x2 + 7*x6 >= 28",
    "13*x3 + 16*x5 + 7*x6 >= 28",
    "13*x0 + 13*x3 + 7*x6 >= 28",
    "7*x1 + 13*x4 + 16*x5 >= 28",
    "13*x0 + 7*x1 + 9*x2 >= 31",
    "13*x0 + 7*x1 + 16*x5 >= 31",
    "13*x0 + 9*x2 + 7*x6 >= 31",
    "13*x3 + 16*x5 + 7*x6 >= 31",
    "13*x0 + 13*x3 + 7*x6 >= 31",
    "7*x1 + 13*x4 + 16*x5 >= 31",
    "13*x0 + 7*x1 + 9*x2 >= 26",
    "13*x0 + 7*x1 + 16*x5 >= 26",
    "13*x0 + 9*x2 + 7*x6 >= 26",
    "13*x3 + 16*x5 + 7*x6 >= 26",
    "13*x0 + 13*x3 + 7*x6 >= 26",
    "7*x1 + 13*x4 + 16*x5 >= 26",
    "13*x0 + 7*x1 + 9*x2 + 13*x3 + 13*x4 + 16*x5 + 7*x6 >= 26",
    "-5*x3 + 9*x5 >= 0",
    "-9*x1 + 3*x2 >= 0",
    "3*x0 - 7*x5 >= 0",
    "2*x0 + 15*x2 + 7*x6 <= 169",
    "2*x0 + 15*x2 + 13*x5 <= 378",
    "14*x3 + 19*x4 + 13*x5 <= 365",
    "15*x2 + 14*x3 + 19*x4 <= 307",
    "2*x0 + 19*x4 + 13*x5 <= 421",
    "6*x1 + 15*x2 + 13*x5 <= 157",
    "6*x1 + 14*x3 + 13*x5 <= 252",
    "2*x0 + 6*x1 + 14*x3 <= 85",
    "6*x1 + 14*x3 + 7*x6 <= 85",
    "2*x0 + 19*x4 + 7*x6 <= 552",
    "2*x0 + 6*x1 + 13*x5 <= 381",
    "15*x2 + 19*x4 + 7*x6 <= 424",
    "6*x1 + 13*x5 + 7*x6 <= 158",
    "2*x0 + 14*x3 + 7*x6 <= 546",
    "17*x0 + 6*x2 <= 299",
    "17*x0 + 12*x3 + 10*x4 <= 177",
    "13*x3 + 16*x5 <= 237",
    "13*x0 + 13*x3 <= 110",
    "13*x3 + 13*x4 + 7*x6 <= 110",
    "2*x0 + 6*x1 + 15*x2 + 14*x3 + 19*x4 + 13*x5 + 7*x6 <= 552",
    "17*x0 + 11*x1 + 6*x2 + 12*x3 + 10*x4 + 12*x5 + 6*x6 <= 343",
    "13*x0 + 7*x1 + 9*x2 + 13*x3 + 13*x4 + 16*x5 + 7*x6 <= 249"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = {}
x[0] = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="bagged salads")
x[1] = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="chicken thighs")
x[2] = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="cantaloupes")
x[3] = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="bowls of pasta")
x[4] = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="chicken drumsticks")
x[5] = m.addVar(lb=0, vtype=gp.GRB.INTEGER, name="bowls of cereal")
x[6] = m.addVar(lb=0, vtype=gp.GRB.CONTINUOUS, name="potatoes")


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

# Add constraints
m.addConstr(2*x[0] + 14*x[3] >= 39)
m.addConstr(2*x[0] + 6*x[1] >= 38)
m.addConstr(19*x[4] + 13*x[5] >= 63)
m.addConstr(14*x[3] + 13*x[5] >= 65)
m.addConstr(14*x[3] + 7*x[6] >= 39)
m.addConstr(2*x[0] + 19*x[4] >= 56)
m.addConstr(2*x[0] + 7*x[6] >= 37)
m.addConstr(6*x[1] + 19*x[4] >= 62)
m.addConstr(2*x[0] + 13*x[5] >= 77)
m.addConstr(15*x[2] + 7*x[6] >= 49)
m.addConstr(14*x[3] + 19*x[4] >= 62)
m.addConstr(2*x[0] + 15*x[2] >= 50)
m.addConstr(2*x[0] + 13*x[5] + 7*x[6] >= 72)
m.addConstr(2*x[0] + 6*x[1] + 15*x[2] + 14*x[3] + 19*x[4] + 13*x[5] + 7*x[6] >= 72)
m.addConstr(6*x[2] + 6*x[6] >= 38)
m.addConstr(17*x[0] + 11*x[1] >= 31)
m.addConstr(6*x[2] + 12*x[5] >= 36)
m.addConstr(10*x[4] + 6*x[6] >= 47)
m.addConstr(6*x[2] + 12*x[3] >= 30)
m.addConstr(6*x[2] + 10*x[4] >= 23)
m.addConstr(12*x[5] + 6*x[6] >= 23)
m.addConstr(17*x[0] + 12*x[3] >= 49)
m.addConstr(11*x[1] + 12*x[3] >= 39)
m.addConstr(11*x[1] + 6*x[2] >= 20)
m.addConstr(10*x[4] + 12*x[5] >= 23)
m.addConstr(11*x[1] + 6*x[2] + 12*x[3] >= 26)
m.addConstr(17*x[0] + 6*x[2] + 12*x[3] >= 26)
m.addConstr(11*x[1] + 10*x[4] + 6*x[6] >= 26)
m.addConstr(11*x[1] + 6*x[2] + 12*x[3] >= 35)
m.addConstr(17*x[0] + 6*x[2] + 12*x[3] >= 35)
m.addConstr(11*x[1] + 10*x[4] + 6*x[6] >= 35)
m.addConstr(11*x[1] + 6*x[2] + 12*x[3] >= 44)
m.addConstr(17*x[0] + 6*x[2] + 12*x[3] >= 44)
m.addConstr(11*x[1] + 10*x[4] + 6*x[6] >= 44)
m.addConstr(17*x[0] + 11*x[1] + 6*x[2] + 12*x[3] + 10*x[4] + 12*x[5] + 6*x[6] >= 44)


# Add resource constraints
tastiness = {'x0': 2, 'x1': 6, 'x2': 15, 'x3': 14, 'x4': 19, 'x5': 13, 'x6': 7}
fiber = {'x0': 17, 'x1': 11, 'x2': 6, 'x3': 12, 'x4': 10, 'x5': 12, 'x6': 6}
sourness = {'x0': 13, 'x1': 7, 'x2': 9, 'x3': 13, 'x4': 13, 'x5': 16, 'x6': 7}

m.addConstr(sum(tastiness[key]*x[int(key[1:])] for key in tastiness) <= 552)
m.addConstr(sum(fiber[key]*x[int(key[1:])] for key in fiber) <= 343)
m.addConstr(sum(sourness[key]*x[int(key[1:])] for key in sourness) <= 249)


# ... (rest of the constraints, added similarly as above)

# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    print('Obj: %g' % m.objVal)
    for v in m.getVars():
        print('%s %g' % (v.varName, v.x))
elif m.status == gp.GRB.INFEASIBLE:
    print('Optimization problem is infeasible.')
else:
    print('Optimization ended with status %d' % m.status)

```