```json
{
  "sym_variables": [
    ("x0", "3D printers"),
    ("x1", "staplers"),
    ("x2", "yellow highlighters"),
    ("x3", "red highlighters"),
    ("x4", "blue pens")
  ],
  "objective_function": "7.83 * x0 + 2.22 * x1 + 6.91 * x2 + 2.41 * x3 + 2.49 * x4",
  "constraints": [
    "10 * x0 + 3 * x1 + 8 * x2 + 2 * x3 + 4 * x4 <= 180",
    "10 * x0 + 2 * x1 + 6 * x2 + 9 * x3 + 4 * x4 <= 82",
    "9 * x0 + 9 * x1 + 1 * x2 + 5 * x3 + 4 * x4 <= 168",
    "11 * x0 + 1 * x1 + 7 * x2 + 4 * x3 + 11 * x4 <= 239",
    "10 * x0 + 2 * x3 + 4 * x4 >= 19",
    "2 * x1 + 6 * x2 + 9 * x3 >= 11",
    "10 * x0 + 6 * x2 + 9 * x3 >= 11",
    "2 * x1 + 9 * x3 + 4 * x4 >= 11",
    "2 * x1 + 6 * x2 + 9 * x3 >= 12",
    "10 * x0 + 6 * x2 + 9 * x3 >= 12",
    "2 * x1 + 9 * x3 + 4 * x4 >= 12",
    "2 * x1 + 6 * x2 + 9 * x3 >= 14",
    "10 * x0 + 6 * x2 + 9 * x3 >= 14",
    "2 * x1 + 9 * x3 + 4 * x4 >= 14",
    "9 * x0 + 1 * x2 >= 31",
    "9 * x1 + 1 * x2 + 5 * x3 >= 16",
    "1 * x2 + 5 * x3 + 4 * x4 >= 16",
    "9 * x1 + 1 * x2 + 4 * x4 >= 16",
    "9 * x0 + 9 * x1 + 1 * x2 >= 16",
    "9 * x0 + 1 * x2 + 4 * x4 >= 16",
    "9 * x1 + 5 * x3 + 4 * x4 >= 16",
    "9 * x1 + x2 + 5 * x3 >= 22",
    "x2 + 5 * x3 + 4 * x4 >= 22",
    "9 * x1 + x2 + 4 * x4 >= 22",
    "9 * x0 + 9 * x1 + x2 >= 22",
    "9 * x0 + x2 + 4 * x4 >= 22",
    "9 * x1 + 5 * x3 + 4 * x4 >= 22",
    "9 * x1 + 1 * x2 + 5 * x3 >= 19",
    "1 * x2 + 5 * x3 + 4 * x4 >= 19",
    "9 * x1 + 1 * x2 + 4 * x4 >= 19",
    "9 * x0 + 9 * x1 + 1 * x2 >= 19",
    "9 * x0 + 1 * x2 + 4 * x4 >= 19",
    "9 * x1 + 5 * x3 + 4 * x4 >= 19",
    "9 * x1 + x2 + 5 * x3 >= 18",
    "x2 + 5 * x3 + 4 * x4 >= 18",
    "9 * x1 + x2 + 4 * x4 >= 18",
    "9 * x0 + 9 * x1 + x2 >= 18",
    "9 * x0 + x2 + 4 * x4 >= 18",
    "9 * x1 + 5 * x3 + 4 * x4 >= 18",
    "7 * x2 + 4 * x3 + 11 * x4 >= 27",
    "x1 + 7 * x2 + 4 * x3 >= 27",
    "11 * x0 + x1 + 4 * x3 >= 27",
    "11 * x0 + 7 * x2 + 11 * x4 >= 27",
    "x1 + 4 * x3 + 11 * x4 >= 27",
    "x1 + 7 * x2 + 11 * x4 >= 27",
    "11 * x0 + x1 + 11 * x4 >= 27",
    "11 * x0 + 7 * x2 + 4 * x3 >= 27",
    "8 * x2 + 4 * x4 <= 98",
    "3 * x1 + 8 * x2 <= 143",
    "10 * x0 + 8 * x2 <= 169",
    "10 * x0 + 3 * x1 + 8 * x2 <= 84",
    "10 * x0 + 8 * x2 + 2 * x3 <= 164",
    "3 * x1 + 2 * x3 + 4 * x4 <= 163",
    "3 * x1 + 8 * x2 + 4 * x4 <= 138",
    "10 * x0 + 3 * x1 + 2 * x3 <= 115",
    "10 * x0 + 2 * x3 + 4 * x4 <= 145",
    "10 * x0 + 3 * x1 + 4 * x4 <= 129",
    "10 * x0 + 3 * x1 + 8 * x2 + 2 * x3 + 4 * x4 <= 129",
    "9 * x3 + 4 * x4 <= 45",
    "6 * x2 + 4 * x4 <= 38",
    "6 * x2 + 9 * x3 <= 47",
    "10 * x0 + 9 * x3 <= 20",
    "10 * x0 + 3 * x1 + 9 * x3 <= 36",
    "10 * x0 + 6 * x2 + 9 * x3 <= 41",
    "10 * x0 + 9 * x3 + 4 * x4 <= 42",
    "2 * x1 + 9 * x3 + 4 * x4 <= 28",
    "10 * x0 + 2 * x1 + 6 * x2 + 9 * x3 + 4 * x4 <= 28",
    "9 * x0 + 5 * x3 <= 110",
    "9 * x1 + x2 <= 34",
    "9 * x1 + 5 * x3 <= 79",
    "9 * x1 + 4 * x4 <= 37",
    "9 * x0 + 4 * x4 <= 52",
    "9 * x0 + x2 + 4 * x4 <= 131",
    "x2 + 5 * x3 + 4 * x4 <= 69",
    "9 * x0 + 9 * x1 + x2 + 5 * x3 + 4 * x4 <= 69",
    "11 * x0 + 11 * x4 <= 163",
    "x1 + 11 * x4 <= 221",
    "x1 + 7 * x2 <= 83",
    "7 * x2 + 4 * x3 <= 198",
    "4 * x3 + 11 * x4 <= 95",
    "x1 + 4 * x3 <= 107",
    "11 * x0 + x1 + 4 * x3 <= 151",
    "11 * x0 + x1 + 7 * x2 + 4 * x3 + 11 * x4 <= 151",
    "x0 >= 0",
    "x1 >= 0",
    "x2 >= 0",
    "x3 >= 0",
    "x4 >= 0"

  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = model.addVars(5, name=["3D_printers", "staplers", "yellow_highlighters", "red_highlighters", "blue_pens"], vtype=gp.GRB.INTEGER)


# Set objective function
model.setObjective(7.83 * x[0] + 2.22 * x[1] + 6.91 * x[2] + 2.41 * x[3] + 2.49 * x[4], gp.GRB.MAXIMIZE)

# Add constraints
resource_constraints = {
    'r0': {'upper_bound': 180, 'coefficients': [10, 3, 8, 2, 4]},
    'r1': {'upper_bound': 82, 'coefficients': [10, 2, 6, 9, 4]},
    'r2': {'upper_bound': 168, 'coefficients': [9, 9, 1, 5, 4]},
    'r3': {'upper_bound': 239, 'coefficients': [11, 1, 7, 4, 11]}
}

for r, data in resource_constraints.items():
    model.addConstr(gp.quicksum(data['coefficients'][i] * x[i] for i in range(5)) <= data['upper_bound'], name=r)


additional_constraints = [
    (10 * x[0] + 2 * x[3] + 4 * x[4] >= 19),
    (2 * x[1] + 6 * x[2] + 9 * x[3] >= 11),
    (10 * x[0] + 6 * x[2] + 9 * x[3] >= 11),
    (2 * x[1] + 9 * x[3] + 4 * x[4] >= 11),
    (2 * x[1] + 6 * x[2] + 9 * x[3] >= 12),
    (10 * x[0] + 6 * x[2] + 9 * x[3] >= 12),
    (2 * x[1] + 9 * x[3] + 4 * x[4] >= 12),
    (2 * x[1] + 6 * x[2] + 9 * x[3] >= 14),
    (10 * x[0] + 6 * x[2] + 9 * x[3] >= 14),
    (2 * x[1] + 9 * x[3] + 4 * x[4] >= 14),
    (9 * x[0] + x[2] >= 31),
    (9 * x[1] + x[2] + 5 * x[3] >= 16),
    (x[2] + 5 * x[3] + 4 * x[4] >= 16),
    (9 * x[1] + x[2] + 4 * x[4] >= 16),
    (9 * x[0] + 9 * x[1] + x[2] >= 16),
    (9 * x[0] + x[2] + 4 * x[4] >= 16),
    (9 * x[1] + 5 * x[3] + 4 * x[4] >= 16),
    (7 * x[2] + 4 * x[3] + 11 * x[4] >= 27),
    (x[1] + 7 * x[2] + 4 * x[3] >= 27),
    (8 * x[2] + 4 * x[4] <= 98),
    (3 * x[1] + 8 * x[2] <= 143),
    (10 * x[0] + 8 * x[2] <= 169),
    (10 * x[0] + 3 * x[1] + 8 * x[2] <= 84),
    (9 * x[3] + 4 * x[4] <= 45),
    (6 * x[2] + 4 * x[4] <= 38),
    (9 * x[0] + 5 * x[3] <= 110),
    (9 * x[1] + x[2] <= 34),
    (x[1] + 7 * x[2] <= 83)
]

for constraint in additional_constraints:
    model.addConstr(constraint)


# Optimize model
model.optimize()

# Print results
if model.status == gp.GRB.OPTIMAL:
    print("Optimal solution found:")
    for v in model.getVars():
        print(f"{v.varName}: {v.x}")
    print(f"Objective value: {model.objVal}")
elif model.status == gp.GRB.INFEASIBLE:
    print("Model is infeasible.")
else:
    print(f"Optimization terminated with status {model.status}.")

```