```json
{
  "sym_variables": [
    ("x0", "postage stamps"),
    ("x1", "manila envelopes"),
    ("x2", "3D printers"),
    ("x3", "packs of paper"),
    ("x4", "lanyards"),
    ("x5", "paper clips"),
    ("x6", "red pens"),
    ("x7", "color printers")
  ],
  "objective_function": "8*x0 + 7*x1 + 5*x2 + 5*x3 + 9*x4 + 8*x5 + 2*x6 + 1*x7",
  "constraints": [
    "13*x0 + 1*x2 >= 16",
    "1*x2 + 6*x3 >= 33",
    "7*x1 + 8*x5 >= 19",
    "8*x4 + 11*x6 >= 18",
    "13*x0 + 8*x4 >= 17",
    "7*x1 + 6*x3 >= 19",
    "6*x3 + 8*x4 >= 21",
    "6*x3 + 8*x5 >= 18",
    "8*x5 + 6*x7 >= 13",
    "7*x1 + 6*x3 + 8*x4 >= 24",
    "13*x0 + 1*x2 + 8*x5 >= 24",
    "13*x0 + 7*x1 + 11*x6 >= 24",
    "7*x1 + 8*x5 + 6*x7 >= 24",
    "6*x3 + 8*x4 + 6*x7 >= 24",
    "8*x4 + 11*x6 + 6*x7 >= 24",
    "1*x2 + 8*x5 + 11*x6 >= 24",
    "7*x1 + 1*x2 + 6*x3 >= 24",
    "7*x1 + 1*x2 + 6*x7 >= 24",
    "13*x0 + 1*x2 + 6*x7 >= 24",
    "6*x3 + 8*x4 + 8*x5 >= 24",
    "1*x2 + 6*x3 + 8*x5 >= 24",
    "13*x0 + 8*x5 + 6*x7 >= 24",
    "13*x0 + 6*x3 + 8*x4 >= 24",
    "13*x0 + 7*x1 + 8*x4 >= 24",
    "7*x1 + 8*x4 + 6*x7 >= 24",

    "5*x1 + 2*x5 >= 8",
    "6*x2 + 5*x4 >= 22",
    "2*x1 + 2*x5 + 11*x7 >= 19",
    "6*x2 + 3*x3 + 9*x6 >= 19",
    "3*x3 + 2*x5 + 11*x7 >= 19",
    "2*x1 + 5*x4 + 9*x6 >= 19",
    "5*x0 + 2*x1 + 3*x3 >= 19",
    "5*x4 + 2*x5 + 11*x7 >= 19",
    "2*x1 + 3*x3 + 11*x7 >= 19",
    "6*x2 + 3*x3 + 2*x5 >= 19",
    "5*x0 + 3*x3 + 9*x6 >= 19",
    "2*x1 + 3*x3 + 2*x5 >= 19",
    "3*x3 + 2*x5 + 9*x6 >= 19",
    "3*x3 + 5*x4 + 9*x6 >= 19",
    "6*x2 + 2*x5 + 11*x7 >= 19",
    "5*x0 + 2*x1 + 9*x6 >= 19",
    "13*x0 + 6*x7 <= 182",
    "13*x0 + 6*x3 <= 256",
    "8*x5 + 6*x7 <= 122",
    "6*x3 + 8*x4 <= 208",
    "7*x1 + 8*x5 <= 286",
    "13*x0 + 8*x4 <= 97",
    "8*x4 + 6*x7 <= 194",
    "6*x3 + 6*x7 <= 86",
    "13*x0 + 11*x6 <= 138",
    "7*x1 + 6*x7 <= 247",
    "8*x5 + 11*x6 <= 224",
    "1*x2 + 8*x5 <= 275",
    "1*x2 + 11*x6 <= 138",
    "7*x1 + 8*x4 <= 96",
    "13*x0 + 7*x1 <= 76",
    "1*x2 + 6*x3 <= 103",
    "13*x0 + 8*x5 <= 74",
    "7*x1 + 6*x3 <= 266",
    "6*x3 + 11*x6 <= 242",
    "13*x0 + 7*x1 + 1*x2 + 6*x3 + 8*x4 + 8*x5 + 11*x6 + 6*x7 <= 242",
    "6*x2 + 11*x7 <= 107",
    "5*x4 + 2*x5 <= 162",
    "2*x1 + 5*x4 + 9*x6 <= 200",
    "6*x2 + 3*x3 + 11*x7 <= 41",
    "5*x0 + 5*x4 + 2*x5 <= 157",
    "2*x1 + 6*x2 + 11*x7 <= 189",
    "5*x0 + 2*x5 + 9*x6 <= 197",
    "5*x0 + 2*x1 + 6*x2 + 3*x3 + 5*x4 + 2*x5 + 9*x6 + 11*x7 <= 197",
    "r0 <= 296",
    "r1 <= 214"

  ]
}
```

```python
from gurobipy import *

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

# Create variables
x = {}
item_names = ['postage stamps', 'manila envelopes', '3D printers', 'packs of paper', 'lanyards', 'paper clips', 'red pens', 'color printers']
for i in range(len(item_names)):
    x[i] = m.addVar(vtype=GRB.INTEGER, name=item_names[i])

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

# Add usefulness rating and weight constraints
usefulness = {'x0': 13, 'x1': 7, 'x2': 1, 'x3': 6, 'x4': 8, 'x5': 8, 'x6': 11, 'x7': 6}
weight = {'x0': 5, 'x1': 2, 'x2': 6, 'x3': 3, 'x4': 5, 'x5': 2, 'x6': 9, 'x7': 11}

r0 = quicksum(usefulness[f'x{i}'] * x[i] for i in range(len(item_names)))
r1 = quicksum(weight[f'x{i}'] * x[i] for i in range(len(item_names)))

m.addConstr(r0 <= 296)
m.addConstr(r1 <= 214)


# Add other constraints from JSON "constraints"
constraints_json = {
  "sym_variables": [
    ("x0", "postage stamps"),
    ("x1", "manila envelopes"),
    ("x2", "3D printers"),
    ("x3", "packs of paper"),
    ("x4", "lanyards"),
    ("x5", "paper clips"),
    ("x6", "red pens"),
    ("x7", "color printers")
  ],
    "objective_function": "8*x0 + 7*x1 + 5*x2 + 5*x3 + 9*x4 + 8*x5 + 2*x6 + 1*x7",
    "constraints": [
    # ... (Insert constraints from JSON here)
    ]
}

for constraint_str in constraints_json["constraints"]:
    m.addConstr(eval(constraint_str))


# 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("Model is infeasible")
else:
    print(f"Optimization ended with status {m.status}")

```