the code

function table.contains(table, element)
    for _, value in pairs(table) do
        if value == element then
            return true
        end
    end
    return false
end

function table.remove_from(table_, element)
    for _, value in pairs(table_) do
      if value == element then
        local a = table.remove(table_, _)
        print(a)
        return true
      end
    end
    return false
end

function Key_contains(table, element)
    for _, value in pairs(table) do
      if _ == element then
        return true
      end
    end
    return false
end

peripheral.find("modem", rednet.open)
G_requests = {}
local turtles = {}
local turtles_used = {}
local turtles_used_remove = {}

require("storage")

for index, value in ipairs(peripheral.getNames()) do
    if peripheral.hasType(value, "turtle")then
        turtles[#turtles+1] = peripheral.getNames()[index]
    end
end

local function listen()
    while true do
        sleep(0.05)
        local id, data = rednet.receive("craft_request")

        print(#data)

        G_requests[#G_requests+1] = data
    end
end

local function listen2()
    while true do
        sleep(0.05)
        local id, data = rednet.receive("unused_crafter")


        local inv = peripheral.wrap(Inv_Num(1))

        inv.pullItems(data, 1)

        turtles_used_remove[#turtles_used_remove+1] = data

    end
end


function table.num_of_same_element(table)
    local count = {}
    for i in pairs(table) do
        if not Key_contains(count, table[i]) then
            count[table[i]] = 1
        else
            count[table[i]] = count[table[i]] + 1
        end
    end
    return count
end


local function send_craft(key)

end


local function Main()
    while true do

        sleep(0.05)
        for key, value in pairs(G_requests) do

            for i, v in pairs(turtles_used_remove) do
                table.remove_from(turtles_used, v)
                print("removed from table.")
            end
            turtles_used_remove = {}

            local station = nil

            for key, value in pairs(turtles) do
                if not table.contains(turtles_used, value) then
                    station = value
                    turtles_used[#turtles_used+1] = value
                end
                if station ~= nil then
                    break
                end
            end

            if station == nil then
                print(station)
                break
            end


            local count = table.num_of_same_element(G_requests[key])

            local has_enough = true
            local list = {}

            for key2, value2 in pairs(G_requests[key]) do
                for i, val in pairs(Get_items_num()) do

                    if val.name ~= nil then
                        --print("value == "..value2..", val.name == "..val.name)
                        print(value2)
                        if val.name == value2 then
                            print(val.name)
                           if val.count >= count[value2] then
                                --has_enough = true
                                --print("set to true")
                                list[value2] = true
                            else
                                --has_enough = false
                                list[value2] = false
                                turtles_used_remove[#turtles_used_remove+1] = station
                                --print("set to false1")
                            end
                        else
                            --list[value2] = false
                            ---print("false...")
                            --if table.contains(G_requests[key], val.name) then
                            --    has_enough = false
                            --turtles_used_remove[#turtles_used_remove+1] = station
                            --    print("set to false2")
                            --end
                        end
                    end
                end
            end

            for key2, value2 in pairs(G_requests[key]) do
                if list[value2] == true and has_enough == true then
                    has_enough = true
                else
                    has_enough = false
                end
            end

            --has_enough = table.contains_more(Get_items_num(), G_requests[key])

            print(has_enough)

            if has_enough then
                for key2, value2 in pairs(G_requests[key]) do
                    local slot = key2

                    if slot >= 4 then
                        slot = slot + 1
                    end
                    if slot >= 8 then
                        slot = slot + 1
                    end

                    if value2 ~= nil then
                        send_to(station, value2, 1, slot)
                    end
                end
                table.remove(G_requests, key)
            else
                table.remove(G_requests, key)
                turtles_used_remove[#turtles_used_remove+1] = station
            end
        end
    end
end

parallel.waitForAll(listen, listen2, Main)