```json
{
  "sym_variables": [
    ("x0", "medical platoons"),
    ("x1", "transportation companies"),
    ("x2", "military intelligence companies"),
    ("x3", "logistics companies"),
    ("x4", "signal platoons")
  ],
  "objective_function": "4.98 * x0 + 8.23 * x1 + 1.79 * x2 + 7.38 * x3 + 4.81 * x4",
  "constraints": [
    "12 * x2 + 13 * x3 >= 36",
    "17 * x0 + 5 * x4 >= 26",
    "13 * x3 + 5 * x4 >= 27",
    "2 * x1 + 5 * x4 >= 31",
    "2 * x1 + 12 * x2 >= 54",
    "17 * x0 + 12 * x2 + 5 * x4 >= 30",
    "2 * x1 + 13 * x3 + 5 * x4 >= 30",
    "17 * x0 + 12 * x2 + 5 * x4 >= 44",
    "2 * x1 + 13 * x3 + 5 * x4 >= 44",
    "17 * x0 + 2 * x1 + 12 * x2 + 13 * x3 + 5 * x4 >= 44",
    "17 * x0 + 2 * x1 >= 40",
    "17 * x0 + 18 * x3 >= 30",
    "2 * x1 + 3 * x2 >= 40",
    "18 * x3 + 8 * x4 >= 18",
    "17 * x0 + 8 * x4 >= 30",
    "2 * x1 + 8 * x4 >= 46",
    "17 * x0 + 3 * x2 >= 38",
    "17 * x0 + 2 * x1 + 18 * x3 >= 44",
    "2 * x1 + 3 * x2 + 8 * x4 >= 44",
    "17 * x0 + 2 * x1 + 3 * x2 >= 44",
    "17 * x0 + 2 * x1 + 18 * x3 >= 43",
    "2 * x1 + 3 * x2 + 8 * x4 >= 43",
    "17 * x0 + 2 * x1 + 3 * x2 >= 43",
    "17 * x0 + 2 * x1 + 18 * x3 >= 37",
    "2 * x1 + 3 * x2 + 8 * x4 >= 37",
    "17 * x0 + 2 * x1 + 3 * x2 >= 37",
    "17 * x0 + 2 * x1 + 3 * x2 + 18 * x3 + 8 * x4 >= 37",
    "10 * x0 - 7 * x1 >= 0",
    "3 * x3 - x4 >= 0",
    "x0 + 5 * x2 - 2 * x3 >= 0",
    "17 * x0 + 5 * x4 <= 244",
    "2 * x1 + 13 * x3 <= 263",
    "17 * x0 + 13 * x3 <= 68",
    "17 * x0 + 2 * x1 + 5 * x4 <= 206",
    "17 * x0 + 2 * x1 + 12 * x2 <= 93",
    "2 * x1 + 13 * x3 + 5 * x4 <= 143",
    "12 * x2 + 13 * x3 + 5 * x4 <= 172",
    "17 * x0 + 12 * x2 + 13 * x3 <= 243",
    "2 * x1 + 3 * x2 <= 144",
    "17 * x0 + 8 * x4 <= 125",
    "3 * x2 + 18 * x3 <= 164",
    "18 * x3 + 8 * x4 <= 116",
    "17 * x0 + 18 * x3 <= 184",
    "17 * x0 + 2 * x1 <= 207",
    "2 * x1 + 18 * x3 <= 63",
    "17 * x0 + 3 * x2 <= 187",
    "3 * x2 + 8 * x4 <= 227",
    "3 * x2 + 18 * x3 + 8 * x4 <= 85",
    "17 * x0 + 18 * x3 + 8 * x4 <= 129",
    "x0 == int",
    "x1 == int",
    "x2 == int",
    "x3 == int",
    "x4 == int"
  ]
}
```

```python
import gurobipy as gp

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

# Create variables
x = {}
var_names = ["medical platoons", "transportation companies", "military intelligence companies", "logistics companies", "signal platoons"]
for i in range(len(var_names)):
    x[i] = m.addVar(vtype=gp.GRB.INTEGER, name=var_names[i])


# Set objective function
obj_coeffs = [4.98, 8.23, 1.79, 7.38, 4.81]
m.setObjective(gp.quicksum(obj_coeffs[i] * x[i] for i in range(len(var_names))), gp.GRB.MINIMIZE)

# Add constraints
fun_factor = [17, 2, 12, 13, 5]
logistical_capacity = [17, 2, 3, 18, 8]

m.addConstr(12 * x[2] + 13 * x[3] >= 36)
m.addConstr(17 * x[0] + 5 * x[4] >= 26)
m.addConstr(13 * x[3] + 5 * x[4] >= 27)
m.addConstr(2 * x[1] + 5 * x[4] >= 31)
m.addConstr(2 * x[1] + 12 * x[2] >= 54)
m.addConstr(17 * x[0] + 12 * x[2] + 5 * x[4] >= 30)
m.addConstr(2 * x[1] + 13 * x[3] + 5 * x[4] >= 30)
m.addConstr(17 * x[0] + 12 * x[2] + 5 * x[4] >= 44)
m.addConstr(2 * x[1] + 13 * x[3] + 5 * x[4] >= 44)
m.addConstr(17 * x[0] + 2 * x[1] + 12 * x[2] + 13 * x[3] + 5 * x[4] >= 44)
m.addConstr(17 * x[0] + 2 * x[1] >= 40)
m.addConstr(17 * x[0] + 18 * x[3] >= 30)
m.addConstr(2 * x[1] + 3 * x[2] >= 40)
m.addConstr(18 * x[3] + 8 * x[4] >= 18)
m.addConstr(17 * x[0] + 8 * x[4] >= 30)
m.addConstr(2 * x[1] + 8 * x[4] >= 46)
m.addConstr(17 * x[0] + 3 * x[2] >= 38)
m.addConstr(17 * x[0] + 2 * x[1] + 18 * x[3] >= 44)
m.addConstr(2 * x[1] + 3 * x[2] + 8 * x[4] >= 44)
m.addConstr(17 * x[0] + 2 * x[1] + 3 * x[2] >= 44)
m.addConstr(17 * x[0] + 2 * x[1] + 18 * x[3] >= 43)
m.addConstr(2 * x[1] + 3 * x[2] + 8 * x[4] >= 43)
m.addConstr(17 * x[0] + 2 * x[1] + 3 * x[2] >= 43)
m.addConstr(17 * x[0] + 2 * x[1] + 18 * x[3] >= 37)
m.addConstr(2 * x[1] + 3 * x[2] + 8 * x[4] >= 37)
m.addConstr(17 * x[0] + 2 * x[1] + 3 * x[2] >= 37)
m.addConstr(17 * x[0] + 2 * x[1] + 3 * x[2] + 18 * x[3] + 8 * x[4] >= 37)
m.addConstr(10 * x[0] - 7 * x[1] >= 0)
m.addConstr(3 * x[3] - x[4] >= 0)
m.addConstr(x[0] + 5 * x[2] - 2 * x[3] >= 0)
m.addConstr(17 * x[0] + 5 * x[4] <= 244)
m.addConstr(2 * x[1] + 13 * x[3] <= 263)
m.addConstr(17 * x[0] + 13 * x[3] <= 68)
m.addConstr(17 * x[0] + 2 * x[1] + 5 * x[4] <= 206)
m.addConstr(17 * x[0] + 2 * x[1] + 12 * x[2] <= 93)
m.addConstr(2 * x[1] + 13 * x[3] + 5 * x[4] <= 143)
m.addConstr(12 * x[2] + 13 * x[3] + 5 * x[4] <= 172)
m.addConstr(17 * x[0] + 12 * x[2] + 13 * x[3] <= 243)
m.addConstr(2 * x[1] + 3 * x[2] <= 144)
m.addConstr(17 * x[0] + 8 * x[4] <= 125)
m.addConstr(3 * x[2] + 18 * x[3] <= 164)
m.addConstr(18 * x[3] + 8 * x[4] <= 116)
m.addConstr(17 * x[0] + 18 * x[3] <= 184)
m.addConstr(17 * x[0] + 2 * x[1] <= 207)
m.addConstr(2 * x[1] + 18 * x[3] <= 63)
m.addConstr(17 * x[0] + 3 * x[2] <= 187)
m.addConstr(3 * x[2] + 8 * x[4] <= 227)
m.addConstr(3 * x[2] + 18 * x[3] + 8 * x[4] <= 85)
m.addConstr(17 * x[0] + 18 * x[3] + 8 * x[4] <= 129)


# Optimize model
m.optimize()

# Print results
if m.status == gp.GRB.OPTIMAL:
    for v in m.getVars():
        print(f'{v.varName}: {v.x}')
    print(f'Objective Value: {m.objVal}')
elif m.status == gp.GRB.INFEASIBLE:
    print("The model is infeasible.")
else:
    print(f"Optimization terminated with status {m.status}")

```