```json
{
  "sym_variables": [
    ("x0", "sashimi"),
    ("x1", "ham sandwiches"),
    ("x2", "milkshakes"),
    ("x3", "potatoes"),
    ("x4", "kale salads")
  ],
  "objective_function": "9*x0 + 9*x1 + 5*x2 + 9*x3 + 8*x4",
  "constraints": [
    "11*x1 + 9*x3 >= 66",
    "8*x0 + 9*x3 >= 40",
    "17*x2 + 9*x3 >= 33",
    "11*x1 + 17*x2 + 9*x3 >= 57",
    "8*x0 + 11*x1 + 18*x4 >= 57",
    "8*x0 + 17*x2 + 9*x3 >= 57",
    "11*x1 + 17*x2 + 18*x4 >= 57",
    "17*x2 + 9*x3 + 18*x4 >= 57",
    "11*x1 + 17*x2 + 9*x3 >= 63",
    "8*x0 + 11*x1 + 18*x4 >= 63",
    "8*x0 + 17*x2 + 9*x3 >= 63",
    "11*x1 + 17*x2 + 18*x4 >= 63",
    "17*x2 + 9*x3 + 18*x4 >= 63",
    "11*x1 + 17*x2 + 9*x3 >= 43",
    "8*x0 + 11*x1 + 18*x4 >= 43",
    "8*x0 + 17*x2 + 9*x3 >= 43",
    "11*x1 + 17*x2 + 18*x4 >= 43",
    "17*x2 + 9*x3 + 18*x4 >= 43",
    "11*x1 + 17*x2 + 9*x3 >= 43",
    "8*x0 + 11*x1 + 18*x4 >= 43",
    "8*x0 + 17*x2 + 9*x3 >= 43",
    "11*x1 + 17*x2 + 18*x4 >= 43",
    "17*x2 + 9*x3 + 18*x4 >= 43",
    "11*x1 + 17*x2 + 9*x3 >= 64",
    "8*x0 + 11*x1 + 18*x4 >= 64",
    "8*x0 + 17*x2 + 9*x3 >= 64",
    "11*x1 + 17*x2 + 18*x4 >= 64",
    "17*x2 + 9*x3 + 18*x4 >= 64",
    "8*x0 + 11*x1 + 17*x2 + 9*x3 + 18*x4 >= 64",
    "-10*x0 + x1 >= 0",
    "8*x1 - 7*x4 >= 0",
    "8*x0 + 11*x1 + 18*x4 <= 150",
    "11*x1 + 9*x3 + 18*x4 <= 194",
    "8*x0 + 9*x3 + 18*x4 <= 217",
    "17*x2 + 9*x3 + 18*x4 <= 282",
    "8*x0 + 11*x1 + 17*x2 + 9*x3 + 18*x4 <= 367" 
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
sashimi = m.addVar(vtype=gp.GRB.INTEGER, name="sashimi")
ham_sandwiches = m.addVar(vtype=gp.GRB.INTEGER, name="ham_sandwiches")
milkshakes = m.addVar(vtype=gp.GRB.INTEGER, name="milkshakes")
potatoes = m.addVar(vtype=gp.GRB.INTEGER, name="potatoes")
kale_salads = m.addVar(vtype=gp.GRB.INTEGER, name="kale_salads")

# Set objective function
m.setObjective(9*sashimi + 9*ham_sandwiches + 5*milkshakes + 9*potatoes + 8*kale_salads, gp.GRB.MINIMIZE)

# Add constraints
m.addConstr(11*ham_sandwiches + 9*potatoes >= 66)
m.addConstr(8*sashimi + 9*potatoes >= 40)
m.addConstr(17*milkshakes + 9*potatoes >= 33)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 9*potatoes >= 57)
m.addConstr(8*sashimi + 11*ham_sandwiches + 18*kale_salads >= 57)
m.addConstr(8*sashimi + 17*milkshakes + 9*potatoes >= 57)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 18*kale_salads >= 57)
m.addConstr(17*milkshakes + 9*potatoes + 18*kale_salads >= 57)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 9*potatoes >= 63)
m.addConstr(8*sashimi + 11*ham_sandwiches + 18*kale_salads >= 63)
m.addConstr(8*sashimi + 17*milkshakes + 9*potatoes >= 63)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 18*kale_salads >= 63)
m.addConstr(17*milkshakes + 9*potatoes + 18*kale_salads >= 63)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 9*potatoes >= 64)
m.addConstr(8*sashimi + 11*ham_sandwiches + 18*kale_salads >= 64)
m.addConstr(8*sashimi + 17*milkshakes + 9*potatoes >= 64)
m.addConstr(11*ham_sandwiches + 17*milkshakes + 18*kale_salads >= 64)
m.addConstr(17*milkshakes + 9*potatoes + 18*kale_salads >= 64)
m.addConstr(8*sashimi + 11*ham_sandwiches + 17*milkshakes + 9*potatoes + 18*kale_salads >= 64)
m.addConstr(-10*sashimi + ham_sandwiches >= 0)
m.addConstr(8*ham_sandwiches - 7*kale_salads >= 0)
m.addConstr(8*sashimi + 11*ham_sandwiches + 18*kale_salads <= 150)
m.addConstr(11*ham_sandwiches + 9*potatoes + 18*kale_salads <= 194)
m.addConstr(8*sashimi + 9*potatoes + 18*kale_salads <= 217)
m.addConstr(17*milkshakes + 9*potatoes + 18*kale_salads <= 282)
m.addConstr(8*sashimi + 11*ham_sandwiches + 17*milkshakes + 9*potatoes + 18*kale_salads <= 367)


# 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("The problem is infeasible.")
else:
    print("The problem could not be solved to optimality.")

```