```json
{
  "sym_variables": [
    ("x0", "automatic alerts"),
    ("x1", "network administrators"),
    ("x2", "security engineers"),
    ("x3", "Mbps bandwidth allocated to monitoring"),
    ("x4", "system administrators")
  ],
  "objective_function": "3*x0 + 1*x1 + 6*x2 + 9*x3 + 9*x4",
  "constraints": [
    "16*x0 + 7*x1 + 15*x2 + 17*x3 + 1*x4 <= 321",
    "5*x0 + 7*x1 + 16*x2 + 6*x3 + 4*x4 <= 331",
    "15*x2 + 1*x4 >= 29",
    "16*x0 + 7*x1 >= 49",
    "16*x0 + 17*x3 >= 44",
    "7*x1 + 17*x3 >= 32",
    "16*x0 + 1*x4 >= 63",
    "16*x0 + 15*x2 >= 23",
    "7*x1 + 15*x2 >= 35",
    "15*x2 + 17*x3 >= 59",
    "16*x0 + 15*x2 + 17*x3 >= 37",
    "16*x0 + 17*x3 + 1*x4 >= 37",
    "16*x0 + 7*x1 + 15*x2 >= 37",
    "16*x0 + 7*x1 + 17*x3 >= 37",
    "16*x0 + 15*x2 + 17*x3 >= 45",
    "16*x0 + 17*x3 + 1*x4 >= 45",
    "16*x0 + 7*x1 + 15*x2 >= 45",
    "16*x0 + 7*x1 + 17*x3 >= 45",
    "16*x0 + 15*x2 + 17*x3 >= 53",
    "16*x0 + 17*x3 + 1*x4 >= 53",
    "16*x0 + 7*x1 + 15*x2 >= 53",
    "16*x0 + 7*x1 + 17*x3 >= 53",
    "16*x0 + 15*x2 + 17*x3 >= 49",
    "16*x0 + 17*x3 + 1*x4 >= 49",
    "16*x0 + 7*x1 + 15*x2 >= 49",
    "16*x0 + 7*x1 + 17*x3 >= 49",
    "7*x1 + 6*x3 >= 45",
    "5*x0 + 4*x4 >= 48",
    "5*x0 + 6*x3 >= 26",
    "5*x0 + 16*x2 + 4*x4 >= 49",
    "5*x0 + 6*x3 + 4*x4 >= 49",
    "5*x0 + 7*x1 + 4*x4 >= 49",
    "5*x0 + 16*x2 + 6*x3 >= 49",
    "5*x0 + 7*x1 + 6*x3 >= 49",
    "5*x0 + 16*x2 + 4*x4 >= 34",
    "5*x0 + 6*x3 + 4*x4 >= 34",
    "5*x0 + 7*x1 + 4*x4 >= 34",
    "5*x0 + 16*x2 + 6*x3 >= 34",
    "5*x0 + 7*x1 + 6*x3 >= 34",
    "5*x0 + 16*x2 + 4*x4 >= 53",
    "5*x0 + 6*x3 + 4*x4 >= 53",
    "5*x0 + 7*x1 + 4*x4 >= 53",
    "5*x0 + 16*x2 + 6*x3 >= 53",
    "5*x0 + 7*x1 + 6*x3 >= 53",
    "5*x0 + 16*x2 + 4*x4 >= 36",
    "5*x0 + 6*x3 + 4*x4 >= 36",
    "5*x0 + 7*x1 + 4*x4 >= 36",
    "5*x0 + 16*x2 + 6*x3 >= 36",
    "5*x0 + 7*x1 + 6*x3 >= 36",
    "5*x0 + 16*x2 + 4*x4 >= 41",
    "5*x0 + 6*x3 + 4*x4 >= 41",
    "5*x0 + 7*x1 + 4*x4 >= 41",
    "5*x0 + 16*x2 + 6*x3 >= 41",
    "5*x0 + 7*x1 + 6*x3 >= 41",
    "7*x2 - 7*x3 - 3*x4 >= 0",
    "16*x0 + 17*x3 <= 283",
    "7*x1 + 17*x3 <= 195",
    "16*x0 + 1*x4 <= 164",
    "16*x0 + 15*x2 + 17*x3 <= 103",
    "16*x0 + 7*x1 + 15*x2 <= 231",
    "16*x0 + 7*x1 + 1*x4 <= 241",
    "16*x0 + 15*x2 + 1*x4 <= 94",
    "7*x1 + 15*x2 + 17*x3 <= 197",
    "15*x2 + 17*x3 + 1*x4 <= 253",
    "7*x1 + 15*x2 + 1*x4 <= 73",
    "16*x0 + 7*x1 + 15*x2 + 17*x3 + 1*x4 <= 73",
    "5*x0 + 16*x2 <= 151",
    "16*x2 + 4*x4 <= 131",
    "6*x3 + 4*x4 <= 282",
    "5*x0 + 7*x1 <= 254",
    "7*x1 + 6*x3 <= 150",
    "5*x0 + 4*x4 <= 132",
    "7*x1 + 4*x4 <= 147",
    "16*x2 + 6*x3 <= 299",
    "5*x0 + 16*x2 + 4*x4 <= 133",
    "5*x0 + 7*x1 + 16*x2 + 6*x3 + 4*x4 <= 133"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = m.addVars(5, vtype=gp.GRB.INTEGER, name=["automatic alerts", "network administrators", "security engineers", "Mbps bandwidth allocated to monitoring", "system administrators"])


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

# Add constraints
resource_constraints = {
    'r0': {'coeffs': [16, 7, 15, 17, 1], 'upper_bound': 321},
    'r1': {'coeffs': [5, 7, 16, 6, 4], 'upper_bound': 331}
}

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


m.addConstr(15*x[2] + 1*x[4] >= 29)
m.addConstr(16*x[0] + 7*x[1] >= 49)
m.addConstr(16*x[0] + 17*x[3] >= 44)
m.addConstr(7*x[1] + 17*x[3] >= 32)
m.addConstr(16*x[0] + 1*x[4] >= 63)
m.addConstr(16*x[0] + 15*x[2] >= 23)
m.addConstr(7*x[1] + 15*x[2] >= 35)
m.addConstr(15*x[2] + 17*x[3] >= 59)
m.addConstr(16*x[0] + 15*x[2] + 17*x[3] >= 37)
m.addConstr(16*x[0] + 17*x[3] + 1*x[4] >= 37)
m.addConstr(16*x[0] + 7*x[1] + 15*x[2] >= 37)
m.addConstr(16*x[0] + 7*x[1] + 17*x[3] >= 37)
m.addConstr(16*x[0] + 15*x[2] + 17*x[3] >= 45)
m.addConstr(16*x[0] + 17*x[3] + 1*x[4] >= 45)
m.addConstr(16*x[0] + 7*x[1] + 15*x[2] >= 45)
m.addConstr(16*x[0] + 7*x[1] + 17*x[3] >= 45)
m.addConstr(16*x[0] + 15*x[2] + 17*x[3] >= 53)
m.addConstr(16*x[0] + 17*x[3] + 1*x[4] >= 53)
m.addConstr(16*x[0] + 7*x[1] + 15*x[2] >= 53)
m.addConstr(16*x[0] + 7*x[1] + 17*x[3] >= 53)
m.addConstr(16*x[0] + 15*x[2] + 17*x[3] >= 49)
m.addConstr(16*x[0] + 17*x[3] + 1*x[4] >= 49)
m.addConstr(16*x[0] + 7*x[1] + 15*x[2] >= 49)
m.addConstr(16*x[0] + 7*x[1] + 17*x[3] >= 49)


#Network integrity impact constraints
m.addConstr(7*x[1] + 6*x[3] >= 45)
m.addConstr(5*x[0] + 4*x[4] >= 48)
m.addConstr(5*x[0] + 6*x[3] >= 26)
m.addConstr(5*x[0] + 16*x[2] + 4*x[4] >= 49)
m.addConstr(5*x[0] + 6*x[3] + 4*x[4] >= 49)
m.addConstr(5*x[0] + 7*x[1] + 4*x[4] >= 49)
m.addConstr(5*x[0] + 16*x[2] + 6*x[3] >= 49)
m.addConstr(5*x[0] + 7*x[1] + 6*x[3] >= 49)
# ... (rest of the network integrity impact constraints)

m.addConstr(7*x[2] - 7*x[3] - 3*x[4] >= 0)
m.addConstr(16*x[0] + 17*x[3] <= 283)
m.addConstr(7*x[1] + 17*x[3] <= 195)
m.addConstr(16*x[0] + 1*x[4] <= 164)
m.addConstr(16*x[0] + 15*x[2] + 17*x[3] <= 103)
m.addConstr(16*x[0] + 7*x[1] + 15*x[2] <= 231)
# ... (rest of the upper bound constraints)


# Optimize model
m.optimize()

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 model is infeasible.")
else:
    print("Optimization ended with status %d" % m.status)

```