def solveFlour(itemName, items):
    solver = pywraplp.Solver.CreateSolver('GLOP')
    item = getItem(itemName, items)

    nrOfSameItems = distributionOfItems(item.recipe)

    variables = []
    x = solver.NumVar(0, solver.infinity(), item.name)  # flour
    variables.append([item.name, x])
    xF = solver.NumVar(0, solver.infinity(), 'xF')  # flour/Sec
    y = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # grain
    variables.append([getItem(item.recipe[0], items).name, y])
    yG = solver.NumVar(0, solver.infinity(), 'yG')  # grain/Sec

    solver.Add(x + y <= main.worker)
    solver.Add(xF <= x * item.unitsPerSecond)
    solver.Add(yG <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(xF <= yG / nrOfSameItems[0])

    solver.Maximize(xF)

    status = solver.Solve()

    printResult(status, solver, variables)

--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
def solveBreadLin(itemName, items):
    solver = pywraplp.Solver.CreateSolver('GLOP')
    item = getItem(itemName, items)

    variables = []
    x = solver.NumVar(0, solver.infinity(), item.name)  # bread
    variables.append([item.name, x])
    xB = solver.NumVar(0, solver.infinity(), 'xF')  # bread/Sec
    y = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # flour
    variables.append([getItem(item.recipe[0], items).name, y])
    yF = solver.NumVar(0, solver.infinity(), 'yG')  # flour/Sec
    z = solver.NumVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[0], items).name)  # grain
    variables.append([getItem(getItem(item.recipe[0], items).recipe[0], items).name, z])
    zG = solver.NumVar(0, solver.infinity(), 'xF')  # grain/Sec

    nrOfSameItems = distributionOfItems(getItem(item.recipe[0], items).recipe)

    solver.Add(y + x + z <= main.worker)
    solver.Add(yF <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(zG <= z * getItem(getItem(item.recipe[0], items).recipe[0], items).unitsPerSecond)
    solver.Add(yF <= zG / nrOfSameItems[0])
    solver.Add(xB <= x * item.unitsPerSecond)

    nrOfSameItems = distributionOfItems(item.recipe)

    solver.Add(xB <= yF / nrOfSameItems[0])

    solver.Maximize(xB)

    status = solver.Solve()

    printResult(status, solver, variables)
	
def solveBreadInt(itemName, items):
    solver = pywraplp.Solver.CreateSolver('SCIP')
    item = getItem(itemName, items)

    variables = []
    x = solver.IntVar(0, solver.infinity(), item.name)  # bread
    variables.append([item.name, x])
    xB = solver.NumVar(0, solver.infinity(), 'xF')  # bread/Sec
    y = solver.IntVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # flour
    variables.append([getItem(item.recipe[0], items).name, y])
    yF = solver.NumVar(0, solver.infinity(), 'yG')  # flour/Sec
    z = solver.IntVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[0], items).name)  # grain
    variables.append([getItem(getItem(item.recipe[0], items).recipe[0], items).name, z])
    zG = solver.NumVar(0, solver.infinity(), 'xF')  # grain/Sec

    nrOfSameItems = distributionOfItems(getItem(item.recipe[0], items).recipe)

    solver.Add(y + x + z <= main.worker)
    solver.Add(yF <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(zG <= z * getItem(getItem(item.recipe[0], items).recipe[0], items).unitsPerSecond)
    solver.Add(yF <= zG / nrOfSameItems[0])
    solver.Add(xB <= x * item.unitsPerSecond)

    nrOfSameItems = distributionOfItems(item.recipe)

    solver.Add(xB <= yF / nrOfSameItems[0])

    solver.Maximize(xB)

    status = solver.Solve()

    printResult(status, solver, variables)


--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
def solvePlankLin(itemName, items):
    item = getItem(itemName, items)
    solver = pywraplp.Solver.CreateSolver('GLOP')

    nrOfSameItems = distributionOfItems(item.recipe)

    x = solver.NumVar(0, solver.infinity(), item.name)  # plank
    xP = solver.NumVar(0, solver.infinity(), 'xP')  # plank/Sec
    y = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # wood
    yW = solver.NumVar(0, solver.infinity(), 'yW')  # wood/Sec

    solver.Add(y + x <= main.worker)
    solver.Add(xP <= x * item.unitsPerSecond)
    solver.Add(yW <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(xP <= yW / nrOfSameItems[0])

    solver.Maximize(xP)

    status = solver.Solve()

    if status == pywraplp.Solver.OPTIMAL:
        print('Solution:')
        print('Objective value =', solver.Objective().Value())
        print('x =', x.solution_value())
        print('y =', y.solution_value())

    else:
        print('The problem does not have an optimal solution.')

    print('\nAdvanced usage:')
    print('Problem solved in %f milliseconds' % solver.wall_time())
    print('Problem solved in %d iterations' % solver.iterations())


def solvePlankInt(itemName, items):
    item = getItem(itemName, items)
    solver = pywraplp.Solver.CreateSolver('SCIP')

    nrOfSameItems = distributionOfItems(item.recipe)

    variables = []
    x = solver.IntVar(0, solver.infinity(), item.name)  # plank
    variables.append([item.name, x])
    xP = solver.IntVar(0, solver.infinity(), 'xP')  # plank/Sec
    y = solver.IntVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # wood
    variables.append([getItem(item.recipe[0], items).name, y])
    yW = solver.IntVar(0, solver.infinity(), 'yW')  # wood/Sec

    solver.Add(y + x <= main.worker)
    solver.Add(xP <= x * item.unitsPerSecond)
    solver.Add(yW <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(0 <= yW / nrOfSameItems[0] - xP)

    solver.Maximize(xP)

    status = solver.Solve()

    printResult(status, solver, variables)
	
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
def solvePaper(itemName, items):
    solver = pywraplp.Solver.CreateSolver('GLOP')
    item = getItem(itemName, items)

    nrOfSameItems = distributionOfItems(item.recipe)

    variables = []
    x = solver.NumVar(0, solver.infinity(), item.name)  # paper
    variables.append([item.name, x])
    xF = solver.NumVar(0, solver.infinity(), 'xF')  # paper/Sec
    y = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # wood
    variables.append([getItem(item.recipe[0], items).name, y])
    yG = solver.NumVar(0, solver.infinity(), 'yG')  # wood/Sec
    z = solver.NumVar(0, solver.infinity(), getItem(item.recipe[1], items).name)  # water
    variables.append([getItem(item.recipe[1], items).name, z])
    zG = solver.NumVar(0, solver.infinity(), 'zG')  # water/Sec

    solver.Add(y + x + z <= main.worker)
    solver.Add(yG <= y * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(zG <= z * getItem(item.recipe[1], items).unitsPerSecond)
    solver.Add(xF <= x * item.unitsPerSecond)

    solver.Add(0 <= (zG / nrOfSameItems[1]) / 2 - xF)
    solver.Add(0 <= (yG / nrOfSameItems[0]) / 2 - xF)

    solver.Maximize(xF)

    status = solver.Solve()

    printResult(status, solver, variables)
	
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
def solveProteinShake(itemName, items):
    solver = pywraplp.Solver.CreateSolver('GLOP')
    item = getItem(itemName, items)

    variables = []
    ps = solver.NumVar(0, solver.infinity(), item.name)  # shake
    variables.append([item.name, ps])
    psS = solver.NumVar(0, solver.infinity(), 'psS')  # shake/Sec

    m = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # milk
    variables.append([getItem(item.recipe[0], items).name, m])
    mS = solver.NumVar(0, solver.infinity(), 'mS')  # milk/Sec

    e = solver.NumVar(0, solver.infinity(), getItem(item.recipe[1], items).name)  # egg
    variables.append([getItem(item.recipe[1], items).name, e])
    eS = solver.NumVar(0, solver.infinity(), 'eS')  # egg/Sec

    s = solver.NumVar(0, solver.infinity(), getItem(item.recipe[2], items).name)  # sugar
    variables.append([getItem(item.recipe[2], items).name, s])
    sS = solver.NumVar(0, solver.infinity(), 'SS')  # sugar/Sec

    a = solver.NumVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[0], items).name)  # feed
    variables.append([getItem(getItem(item.recipe[0], items).recipe[0], items).name, a])
    aS = solver.NumVar(0, solver.infinity(), 'aS')  # feed/Sec

    w = solver.NumVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[2], items).name)  # water
    variables.append([getItem(getItem(item.recipe[0], items).recipe[2], items).name, w])
    wS = solver.NumVar(0, solver.infinity(), 'wS')  # water/Sec

    g = solver.NumVar(0, solver.infinity(),
                      getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name)  # gain
    variables.append([getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name, g])
    gs = solver.NumVar(0, solver.infinity(), 'gs')  # gain/Sec

    solver.Add(ps + m + e + s + a + w + g <= main.worker)

    solver.Add(psS <= ps * item.unitsPerSecond)
    solver.Add(mS <= m * getItem(item.recipe[0], items).unitsPerSecond)
    solver.Add(eS <= e * getItem(item.recipe[1], items).unitsPerSecond)
    solver.Add(sS <= s * getItem(item.recipe[2], items).unitsPerSecond)
    solver.Add(aS <= a * getItem(getItem(item.recipe[0], items).recipe[0], items).unitsPerSecond)
    solver.Add(wS <= w * getItem(getItem(item.recipe[0], items).recipe[2], items).unitsPerSecond)
    solver.Add(
        gs <= g * getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).unitsPerSecond)

    nrOfSameItems = distributionOfItems(item.recipe)
    solver.Add(0 <= mS / nrOfSameItems[0] - psS)
    solver.Add(0 <= eS / nrOfSameItems[1] - psS)
    solver.Add(0 <= sS / nrOfSameItems[2] - psS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[0], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - mS)
    solver.Add(0 <= wS / nrOfSameItems[1] - mS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[1], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - eS)

    nrOfSameItems = distributionOfItems(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe)
    solver.Add(0 <= gs / nrOfSameItems[0] - aS)

    solver.Maximize(psS)

    status = solver.Solve()

    printResult(status, solver, variables)
	
def solveProteinShake(itemName, items):
    solver = pywraplp.Solver.CreateSolver('GLOP')
    item = getItem(itemName, items)

    variables = []
    ps = solver.NumVar(0, solver.infinity(), item.name)  # shake
    variables.append([item.name, ps])
    psS = solver.NumVar(0, solver.infinity(), 'psS')  # shake/Sec

    solver.Add(psS <= ps * item.unitsPerSecond)

    m = solver.NumVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # milk
    variables.append([getItem(item.recipe[0], items).name, m])
    mS = solver.NumVar(0, solver.infinity(), 'mS')  # milk/Sec

    solver.Add(mS <= m * getItem(item.recipe[0], items).unitsPerSecond)

    a = solver.NumVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[0], items).name)  # feed
    variables.append([getItem(getItem(item.recipe[0], items).recipe[0], items).name, a])
    aS = solver.NumVar(0, solver.infinity(), 'aS')  # feed/Sec

    solver.Add(aS <= a * getItem(getItem(item.recipe[0], items).recipe[0], items).unitsPerSecond)

    g = solver.NumVar(0, solver.infinity(),
                      getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name)  # gain
    variables.append([getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name, g])
    gs = solver.NumVar(0, solver.infinity(), 'gs')  # gain/Sec

    solver.Add(
        gs <= g * getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).unitsPerSecond)

    w = solver.NumVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[2], items).name)  # water
    variables.append([getItem(getItem(item.recipe[0], items).recipe[2], items).name, w])
    wS = solver.NumVar(0, solver.infinity(), 'wS')  # water/Sec

    solver.Add(wS <= w * getItem(getItem(item.recipe[0], items).recipe[2], items).unitsPerSecond)

    e = solver.NumVar(0, solver.infinity(), getItem(item.recipe[1], items).name)  # egg
    variables.append([getItem(item.recipe[1], items).name, e])
    eS = solver.NumVar(0, solver.infinity(), 'eS')  # egg/Sec

    solver.Add(eS <= e * getItem(item.recipe[1], items).unitsPerSecond)

    s = solver.NumVar(0, solver.infinity(), getItem(item.recipe[2], items).name)  # sugar
    variables.append([getItem(item.recipe[2], items).name, s])
    sS = solver.NumVar(0, solver.infinity(), 'SS')  # sugar/Sec

    solver.Add(sS <= s * getItem(item.recipe[2], items).unitsPerSecond)

    solver.Add(ps + m + e + s + a + w + g <= main.worker)

    nrOfSameItems = distributionOfItems(item.recipe)
    solver.Add(0 <= mS / nrOfSameItems[0] - psS)
    solver.Add(0 <= eS / nrOfSameItems[1] - psS)
    solver.Add(0 <= sS / nrOfSameItems[2] - psS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[0], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - mS)
    solver.Add(0 <= wS / nrOfSameItems[1] - mS)

    nrOfSameItems = distributionOfItems(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe)
    solver.Add(0 <= gs / nrOfSameItems[0] - aS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[1], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - eS)

    solver.Maximize(psS)

    status = solver.Solve()

    printResult(status, solver, variables)	
	
    solver = pywraplp.Solver.CreateSolver('SCIP')
    item = getItem(itemName, items)

    variables = []
    ps = solver.IntVar(0, solver.infinity(), item.name)  # shake
    variables.append([item.name, ps])
    psS = solver.NumVar(0, solver.infinity(), 'psS')  # shake/Sec

    solver.Add(psS <= ps * item.unitsPerSecond)

    m = solver.IntVar(0, solver.infinity(), getItem(item.recipe[0], items).name)  # milk
    variables.append([getItem(item.recipe[0], items).name, m])
    mS = solver.NumVar(0, solver.infinity(), 'mS')  # milk/Sec

    solver.Add(mS <= m * getItem(item.recipe[0], items).unitsPerSecond)

    a = solver.IntVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[0], items).name)  # feed
    variables.append([getItem(getItem(item.recipe[0], items).recipe[0], items).name, a])
    aS = solver.NumVar(0, solver.infinity(), 'aS')  # feed/Sec

    solver.Add(aS <= a * getItem(getItem(item.recipe[0], items).recipe[0], items).unitsPerSecond)

    g = solver.IntVar(0, solver.infinity(),
                      getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name)  # gain
    variables.append([getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).name, g])
    gs = solver.NumVar(0, solver.infinity(), 'gs')  # gain/Sec

    solver.Add(
        gs <= g * getItem(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe[0], items).unitsPerSecond)

    w = solver.IntVar(0, solver.infinity(), getItem(getItem(item.recipe[0], items).recipe[2], items).name)  # water
    variables.append([getItem(getItem(item.recipe[0], items).recipe[2], items).name, w])
    wS = solver.NumVar(0, solver.infinity(), 'wS')  # water/Sec

    solver.Add(wS <= w * getItem(getItem(item.recipe[0], items).recipe[2], items).unitsPerSecond)

    e = solver.IntVar(0, solver.infinity(), getItem(item.recipe[1], items).name)  # egg
    variables.append([getItem(item.recipe[1], items).name, e])
    eS = solver.NumVar(0, solver.infinity(), 'eS')  # egg/Sec

    solver.Add(eS <= e * getItem(item.recipe[1], items).unitsPerSecond)

    s = solver.IntVar(0, solver.infinity(), getItem(item.recipe[2], items).name)  # sugar
    variables.append([getItem(item.recipe[2], items).name, s])
    sS = solver.NumVar(0, solver.infinity(), 'SS')  # sugar/Sec

    solver.Add(sS <= s * getItem(item.recipe[2], items).unitsPerSecond)

    solver.Add(ps + m + a + g + w + e + s <= main.worker)

    nrOfSameItems = distributionOfItems(item.recipe)
    solver.Add(0 <= mS / nrOfSameItems[0] - psS)
    solver.Add(0 <= eS / nrOfSameItems[1] - psS)
    solver.Add(0 <= sS / nrOfSameItems[2] - psS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[0], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - mS)
    solver.Add(0 <= wS / nrOfSameItems[1] - mS)

    nrOfSameItems = distributionOfItems(getItem(getItem(item.recipe[0], items).recipe[0], items).recipe)
    solver.Add(0 <= gs / nrOfSameItems[0] - aS)

    nrOfSameItems = distributionOfItems(getItem(item.recipe[1], items).recipe)
    solver.Add(0 <= aS / nrOfSameItems[0] - eS)

    solver.Maximize(psS)

    status = solver.Solve()

    printResult(status, solver, variables)
