func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var result = 0
    var index = 0
    while index < buckets.count {
        var sum = 0
        for i in 0..<buckets.count {
            if index + i < buckets.count {
                sum += buckets[index + i]
            }
        }
        if sum == 0 {
            index += 1
        } else {
            result += 1
            index += buckets.count
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var result = 0
    var index = 0
    while index < buckets.count {
        var sum = 0
        for i in 0..<buckets.count {
            if index + i < buckets.count {
                sum += buckets[index + i]
            }
        }
        if sum == 0 {
            index += 1
        } else {
            result += 1
            index += buckets.count
        }
    }
    return result
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var res = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                res += 1
            }
        }
    }
    return res
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var res = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                res += 1
            }
        }
    }
    return res
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var buckets = Array(repeating: capacity, count: grid.count)
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    result += 1
                }
            }
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var buckets = Array(repeating: capacity, count: grid.count)
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    result += 1
                }
            }
        }
    }
    return result
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var total = 0
    var max = 0
    for i in 0..<buckets.count {
        if buckets[i] > max {
            max = buckets[i]
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] == max {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var total = 0
    var max = 0
    for i in 0..<buckets.count {
        if buckets[i] > max {
            max = buckets[i]
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] == max {
            total += 1
        }
    }
    return total
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var waterExtracted = 0
    
    if grid[row][col] <= capacity {
        waterExtracted = grid[row][col]
        grid[row][col] = 0
    } else {
        waterExtracted = capacity
        grid[row][col] -= capacity
    }
    
    waterExtracted += dfs(grid: grid, row: row + 1, col: col, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row - 1, col: col, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row, col: col + 1, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row, col: col - 1, visited: &visited, capacity: capacity)
    
    return waterExtracted
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var waterExtracted = 0
    
    if grid[row][col] <= capacity {
        waterExtracted = grid[row][col]
        grid[row][col] = 0
    } else {
        waterExtracted = capacity
        grid[row][col] -= capacity
    }
    
    waterExtracted += dfs(grid: grid, row: row + 1, col: col, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row - 1, col: col, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row, col: col + 1, visited: &visited, capacity: capacity)
    waterExtracted += dfs(grid: grid, row: row, col: col - 1, visited: &visited, capacity: capacity)
    
    return waterExtracted
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var sum = 0
    for i in 0..<m {
        for j in 0..<n {
            sum += grid[i][j]
        }
    }
    if sum == 0 { return 0 }
    if sum <= capacity { return 1 }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += 1
                if ans >= capacity { return ans }
            }
        }
    }
    return ans
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var sum = 0
    for i in 0..<m {
        for j in 0..<n {
            sum += grid[i][j]
        }
    }
    if sum == 0 { return 0 }
    if sum <= capacity { return 1 }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += 1
                if ans >= capacity { return ans }
            }
        }
    }
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater / capacity
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var water = 0
    
    for (dr, dc) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
        water += dfs(grid: grid, row: row + dr, col: col + dc, visited: &visited, capacity: capacity)
    }
    
    return min(water + 1, capacity)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater / capacity
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var water = 0
    
    for (dr, dc) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
        water += dfs(grid: grid, row: row + dr, col: col + dc, visited: &visited, capacity: capacity)
    }
    
    return min(water + 1, capacity)
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        var left = 0
        var right = n - 1
        while left <= right {
            if grid[i][left] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[i][right] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, min(water[i], water[j]) - j)
            }
        }
    }
    return ans / capacity
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        var left = 0
        var right = n - 1
        while left <= right {
            if grid[i][left] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[i][right] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, min(water[i], water[j]) - j)
            }
        }
    }
    return ans / capacity
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var sum = 0
    for i in 0..<m {
        for j in 0..<n {
            sum += grid[i][j]
        }
    }
    if sum == 0 { return 0 }
    if sum % capacity != 0 { return -1 }
    ans = sum / capacity
    return ans
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var sum = 0
    for i in 0..<m {
        for j in 0..<n {
            sum += grid[i][j]
        }
    }
    if sum == 0 { return 0 }
    if sum % capacity != 0 { return -1 }
    ans = sum / capacity
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] += capacity
                left += 1
            } else if grid[right][j] == 1 {
                water[right] += capacity
                right -= 1
            } else {
                water[left] += capacity
                water[right] += capacity
                left += 1
                right -= 1
            }
        }
    }
    for i in 0..<m {
        ans += water[i]
    }
    return ans
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] += capacity
                left += 1
            } else if grid[right][j] == 1 {
                water[right] += capacity
                right -= 1
            } else {
                water[left] += capacity
                water[right] += capacity
                left += 1
                right -= 1
            }
        }
    }
    for i in 0..<m {
        ans += water[i]
    }
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                water[i] += 1
            }
        }
    }
    for i in 0..<m {
        var left = 0
        var right = n - 1
        while left < right {
            if water[i] <= capacity {
                ans += water[i]
                water[i] = 0
                left += 1
            } else {
                ans += capacity
                water[i] -= capacity
                right -= 1
            }
        }
    }
    return ans
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                water[i] += 1
            }
        }
    }
    for i in 0..<m {
        var left = 0
        var right = n - 1
        while left < right {
            if water[i] <= capacity {
                ans += water[i]
                water[i] = 0
                left += 1
            } else {
                ans += capacity
                water[i] -= capacity
                right -= 1
            }
        }
    }
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, min(water[i], capacity) - water[j])
            }
        }
    }
    return ans
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, min(water[i], capacity) - water[j])
            }
        }
    }
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater / capacity
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var water = 0
    
    for (dr, dc) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
        water += dfs(grid: grid, row: row + dr, col: col + dc, visited: &visited, capacity: capacity)
    }
    
    return min(water + 1, capacity)
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var visited = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 && !visited[row][col] {
                totalWater += dfs(grid: grid, row: row, col: col, visited: &visited, capacity: capacity)
            }
        }
    }
    
    return totalWater / capacity
}

func dfs(grid: [[Int]], row: Int, col: Int, visited: inout [[Bool]], capacity: Int) -> Int {
    if row < 0 || row >= grid.count || col < 0 || col >= grid[0].count || grid[row][col] == 0 || visited[row][col] {
        return 0
    }
    
    visited[row][col] = true
    var water = 0
    
    for (dr, dc) in [(0, 1), (0, -1), (1, 0), (-1, 0)] {
        water += dfs(grid: grid, row: row + dr, col: col + dc, visited: &visited, capacity: capacity)
    }
    
    return min(water + 1, capacity)
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, water[i] - j)
            }
        }
    }
    return ans / capacity
}

<bos><start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = Array(repeating: 0, count: m)
    for j in 0..<n {
        var left = 0
        var right = m - 1
        while left <= right {
            if grid[left][j] == 1 {
                water[left] = max(water[left], left)
            }
            if grid[right][j] == 1 {
                water[right] = max(water[right], right)
            }
            if water[left] <= water[right] {
                left += 1
            } else {
                right -= 1
            }
        }
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                ans += max(0, water[i] - j)
            }
        }
    }
    return ans / capacity
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i)
                queue.append(j)
            }
        }
    }
    while!queue.isEmpty {
        let i = queue.removeFirst()
        let j = queue.removeFirst()
        if i > 0 && grid[i - 1][j] == 0 {
            grid[i - 1][j] = 1
            queue.append(i - 1)
            queue.append(j)
            result += 1
        }
        if i < grid.count - 1 && grid[i + 1][j] == 0 {
            grid[i + 1][j] = 1
            queue.append(i + 1)
            queue.append(j)
            result += 1
        }
        if j > 0 && grid[i][j - 1] == 0 {
            grid[i][j - 1] = 1
            queue.append(i)
            queue.append(j - 1)
            result += 1
        }
        if j < grid[i].count - 1 && grid[i][j + 1] == 0 {
            grid[i][j + 1] = 1
            queue.append(i)
            queue.append(j + 1)
            result += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i)
                queue.append(j)
            }
        }
    }
    while!queue.isEmpty {
        let i = queue.removeFirst()
        let j = queue.removeFirst()
        if i > 0 && grid[i - 1][j] == 0 {
            grid[i - 1][j] = 1
            queue.append(i - 1)
            queue.append(j)
            result += 1
        }
        if i < grid.count - 1 && grid[i + 1][j] == 0 {
            grid[i + 1][j] = 1
            queue.append(i + 1)
            queue.append(j)
            result += 1
        }
        if j > 0 && grid[i][j - 1] == 0 {
            grid[i][j - 1] = 1
            queue.append(i)
            queue.append(j - 1)
            result += 1
        }
        if j < grid[i].count - 1 && grid[i][j + 1] == 0 {
            grid[i][j + 1] = 1
            queue.append(i)
            queue.append(j + 1)
            result += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                var left = j
                var right = j
                var top = i
                var bottom = i
                while left >= 0 && grid[top][left] == 1 {
                    grid[top][left] = 2
                    left -= 1
                }
                while right < grid[i].count && grid[top][right] == 1 {
                    grid[top][right] = 2
                    right += 1
                }
                while top >= 0 && grid[top][left] == 1 {
                    grid[top][left] = 2
                    top -= 1
                }
                while bottom < grid.count && grid[bottom][left] == 1 {
                    grid[bottom][left] = 2
                    bottom += 1
                }
                maxFill += right - left - 1
            }
        }
    }
    return maxFill
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                var left = j
                var right = j
                var top = i
                var bottom = i
                while left >= 0 && grid[top][left] == 1 {
                    grid[top][left] = 2
                    left -= 1
                }
                while right < grid[i].count && grid[top][right] == 1 {
                    grid[top][right] = 2
                    right += 1
                }
                while top >= 0 && grid[top][left] == 1 {
                    grid[top][left] = 2
                    top -= 1
                }
                while bottom < grid.count && grid[bottom][left] == 1 {
                    grid[bottom][left] = 2
                    bottom += 1
                }
                maxFill += right - left - 1
            }
        }
    }
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var water = 0
    var i = 0
    var j = 0
    var max = 0
    while i < grid.count {
        j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                water += 1
            }
            j += 1
        }
        if water > max {
            max = water
        }
        i += 1
    }
    result = max / capacity
    if max % capacity > 0 {
        result += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var water = 0
    var i = 0
    var j = 0
    var max = 0
    while i < grid.count {
        j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                water += 1
            }
            j += 1
        }
        if water > max {
            max = water
        }
        i += 1
    }
    result = max / capacity
    if max % capacity > 0 {
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            let capacity = capacity
            var k = i
            while k < grid.count && grid[k][j] == 1 {
                grid[k][j] = 0
                k += 1
            }
            count += 1
            j += 1
        } else {
            j += 1
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            let capacity = capacity
            var k = i
            while k < grid.count && grid[k][j] == 1 {
                grid[k][j] = 0
                k += 1
            }
            count += 1
            j += 1
        } else {
            j += 1
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            result += 1
            j += 1
        } else {
            i += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            result += 1
            j += 1
        } else {
            i += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var water = 0
    var i = 0
    var j = 0
    var max = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                water += capacity
                count += 1
            }
            j += 1
        }
        i += 1
    }
    i = 0
    j = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if water >= capacity {
                    water -= capacity
                    count -= 1
                } else {
                    max = max > count? max : count
                    count = 0
                    water = 0
                }
            }
            j += 1
        }
        i += 1
    }
    return max > count? max : count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var water = 0
    var i = 0
    var j = 0
    var max = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                water += capacity
                count += 1
            }
            j += 1
        }
        i += 1
    }
    i = 0
    j = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if water >= capacity {
                    water -= capacity
                    count -= 1
                } else {
                    max = max > count? max : count
                    count = 0
                    water = 0
                }
            }
            j += 1
        }
        i += 1
    }
    return max > count? max : count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var water = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[0].count {
        if grid[i][j] == 1 {
            water += 1
            if water == capacity {
                result += 1
                water = 0
            }
        } else {
            water = 0
        }
        j += 1
        if j == grid[0].count {
            j = 0
            i += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var water = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[0].count {
        if grid[i][j] == 1 {
            water += 1
            if water == capacity {
                result += 1
                water = 0
            }
        } else {
            water = 0
        }
        j += 1
        if j == grid[0].count {
            j = 0
            i += 1
        }
    }
    return result
}
```

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var next = 0
    var prev = 0
    var prevNext = 0
    var prevPrev = 0
    var prevPrevNext = 0
    var prevPrevPrev = 0
    var prevPrevPrevNext = 0
    var prevPrevPrevPrev = 0
    var prevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrev = 0
    var prevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrev = 0
    var prevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrev = 0
    var prevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrev = 0
    var prevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrev = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevNext = 0
    var prevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrevPrev

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var currentFill = 0
    var currentWell = 0
    var currentBucket = 0
    var currentWells = 0
    var currentBuckets = 0
    var currentWellsFilled = 0
    var currentBucketsFilled = 0
    var currentWellsFilledBuckets = 0
    var currentBucketsFilledWells = 0
    var currentWellsFilledBucketsWells = 0
    var currentBucketsFilledWellsWells = 0
    var currentWellsFilledBucketsWellsWells = 0
    var currentWellsFilledBucketsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentBucketsFilledWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsBuckets = 0
    var currentWellsFilledBucketsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWellsWell

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentRow = 0
    var currentColumn = 0
    var currentCapacity = 0
    var currentWell = 0
    var currentBucket = 0
    var currentWells = 0
    var currentBuckets = 0
    var currentWellsAndBuckets = 0
    var currentWellsAndBucketsAndCapacity = 0
    var currentWellsAndBucketsAndCapacityAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWell = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucket = 0
    var currentWellsAndBucketsAndCapacityAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAndWellAndBucketAnd

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var i = 0
        while i < row.count {
            if row[i] == 1 {
                if capacity > 0 {
                    row[i] = 0
                    capacity -= 1
                } else {
                    break
                }
            }
            i += 1
        }
        if!row.isEmpty {
            grid.append(row)
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var i = 0
        while i < row.count {
            if row[i] == 1 {
                if capacity > 0 {
                    row[i] = 0
                    capacity -= 1
                } else {
                    break
                }
            }
            i += 1
        }
        if!row.isEmpty {
            grid.append(row)
        }
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var capacity = capacity
        while!row.isEmpty {
            if row.first == 1 {
                row.removeFirst()
                capacity -= 1
            } else {
                break
            }
        }
        if capacity < 0 {
            count += 1
            capacity = capacity + 1
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var capacity = capacity
        while!row.isEmpty {
            if row.first == 1 {
                row.removeFirst()
                capacity -= 1
            } else {
                break
            }
        }
        if capacity < 0 {
            count += 1
            capacity = capacity + 1
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here.
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here.
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var capacity = capacity
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                capacity -= 1
            }
        }
        if capacity < 0 {
            result += 1
            capacity = capacity
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var capacity = capacity
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                capacity -= 1
            }
        }
        if capacity < 0 {
            result += 1
            capacity = capacity
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while capacity > 0 {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    capacity -= 1
                    if capacity == 0 {
                        return count
                    }
                }
            }
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while capacity > 0 {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    capacity -= 1
                    if capacity == 0 {
                        return count
                    }
                }
            }
        }
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var rowCapacity = capacity
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                rowCapacity -= 1
            }
        }
        if rowCapacity > 0 {
            count += 1
            capacity = rowCapacity
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var capacity = capacity
    var grid = grid
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var rowCapacity = capacity
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                rowCapacity -= 1
            }
        }
        if rowCapacity > 0 {
            count += 1
            capacity = rowCapacity
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {

}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {

}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    while!grid.isEmpty {
        let row = grid.removeFirst()
        var bucket = 0
        for i in 0..<row.count {
            if row[i] == 0 {
                bucket += 1
            } else {
                bucket = 0
            }
            if bucket == capacity {
                count += 1
                bucket = 0
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    while!grid.isEmpty {
        let row = grid.removeFirst()
        var bucket = 0
        for i in 0..<row.count {
            if row[i] == 0 {
                bucket += 1
            } else {
                bucket = 0
            }
            if bucket == capacity {
                count += 1
                bucket = 0
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                for k in 0..<capacity {
                    if i + k < grid.count {
                        grid[i + k][j] = 0
                    }
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                for k in 0..<capacity {
                    if i + k < grid.count {
                        grid[i + k][j] = 0
                    }
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
  // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
  // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {

}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {

}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: capacity, count: grid[0].count)
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[j] -= 1
                if buckets[j] == 0 {
                    count += 1
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: capacity, count: grid[0].count)
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[j] -= 1
                if buckets[j] == 0 {
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    var j = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                j += capacity
            } else {
                j += 1
            }
        }
        i += 1
        j = 0
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    var j = 0
    while i < grid.count {
        while j < grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                j += capacity
            } else {
                j += 1
            }
        }
        i += 1
        j = 0
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                if j + 1 < grid[i].count && grid[i][j + 1] == 1 {
                    count += 1
                    grid[i][j + 1] = 0
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                if j + 1 < grid[i].count && grid[i][j + 1] == 1 {
                    count += 1
                    grid[i][j + 1] = 0
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: capacity, count: grid[0].count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                if buckets[i] == 0 {
                    count += 1
                    buckets = [Int](repeating: capacity, count: grid[0].count)
                }
                buckets[i] -= 1
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: capacity, count: grid[0].count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                if buckets[i] == 0 {
                    count += 1
                    buckets = [Int](repeating: capacity, count: grid[0].count)
                }
                buckets[i] -= 1
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                if j + 1 < grid[i].count && grid[i][j + 1] == 1 {
                    count += 1
                    grid[i][j + 1] = 0
                }
                if i + 1 < grid.count && grid[i + 1][j] == 1 {
                    count += 1
                    grid[i + 1][j] = 0
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                if j + 1 < grid[i].count && grid[i][j + 1] == 1 {
                    count += 1
                    grid[i][j + 1] = 0
                }
                if i + 1 < grid.count && grid[i + 1][j] == 1 {
                    count += 1
                    grid[i + 1][j] = 0
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[row].count {
        let well = grid[row][col]
        
        if well == 1 {
            total += 1
        }
        
        if total > capacity {
            result += 1
            total -= 1
        }
        
        col += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[row].count {
        let well = grid[row][col]
        
        if well == 1 {
            total += 1
        }
        
        if total > capacity {
            result += 1
            total -= 1
        }
        
        col += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[row].count {
        let water = min(capacity, grid[row][col])
        total += water
        grid[row][col] -= water
        if grid[row][col] == 0 {
            col += 1
        }
        result += water
        row += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[row].count {
        let water = min(capacity, grid[row][col])
        total += water
        grid[row][col] -= water
        if grid[row][col] == 0 {
            col += 1
        }
        result += water
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                total += 1
                if total > capacity {
                    result += 1
                    total -= 1
                }
            }
            col += 1
        }
        total = 0
        row += 1
        col = 0
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                total += 1
                if total > capacity {
                    result += 1
                    total -= 1
                }
            }
            col += 1
        }
        total = 0
        row += 1
        col = 0
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    guard!grid.isEmpty else {
        return 0
    }
    
    var result = 0
    var queue = [grid.count - 1]
    
    while!queue.isEmpty {
        let row = queue.removeFirst()
        
        for col in 0..<grid[row].count {
            if grid[row][col] == 1 {
                let newRow = row - 1
                let newCol = col - 1
                
                if newRow >= 0 && newCol >= 0 {
                    grid[newRow][newCol] += 1
                    queue.append(newRow)
                }
                
                if newRow >= 0 && newCol < grid[row].count - 1 {
                    grid[newRow][newCol + 1] += 1
                    queue.append(newRow)
                }
                
                if newRow < grid.count - 1 && newCol >= 0 {
                    grid[newRow + 1][newCol] += 1
                    queue.append(newRow + 1)
                }
                
                if newRow < grid.count - 1 && newCol < grid[row].count - 1 {
                    grid[newRow + 1][newCol + 1] += 1
                    queue.append(newRow + 1)
                }
            }
        }
        
        result += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    guard!grid.isEmpty else {
        return 0
    }
    
    var result = 0
    var queue = [grid.count - 1]
    
    while!queue.isEmpty {
        let row = queue.removeFirst()
        
        for col in 0..<grid[row].count {
            if grid[row][col] == 1 {
                let newRow = row - 1
                let newCol = col - 1
                
                if newRow >= 0 && newCol >= 0 {
                    grid[newRow][newCol] += 1
                    queue.append(newRow)
                }
                
                if newRow >= 0 && newCol < grid[row].count - 1 {
                    grid[newRow][newCol + 1] += 1
                    queue.append(newRow)
                }
                
                if newRow < grid.count - 1 && newCol >= 0 {
                    grid[newRow + 1][newCol] += 1
                    queue.append(newRow + 1)
                }
                
                if newRow < grid.count - 1 && newCol < grid[row].count - 1 {
                    grid[newRow + 1][newCol + 1] += 1
                    queue.append(newRow + 1)
                }
            }
        }
        
        result += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= capacity
        }
        
        col += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= capacity
        }
        
        col += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            total += 1
        }
        if total > capacity {
            total -= 1
            row += 1
        } else {
            col += 1
        }
        result += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            total += 1
        }
        if total > capacity {
            total -= 1
            row += 1
        } else {
            col += 1
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[0].count {
        if total + grid[row][col] <= capacity {
            total += grid[row][col]
            col += 1
        } else {
            result += 1
            total = grid[row][col]
            col = 0
            row += 1
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    while row < grid.count, col < grid[0].count {
        if total + grid[row][col] <= capacity {
            total += grid[row][col]
            col += 1
        } else {
            result += 1
            total = grid[row][col]
            col = 0
            row += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            total += 1
            if total > capacity {
                result += 1
                total = 0
            }
        }
        col += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            total += 1
            if total > capacity {
                result += 1
                total = 0
            }
        }
        col += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= 1
        }
        
        col += 1
        
        if col == grid[0].count {
            col = 0
            row += 1
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= 1
        }
        
        col += 1
        
        if col == grid[0].count {
            col = 0
            row += 1
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= capacity
        }
        
        col += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var water = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            water += 1
        }
        
        if water > capacity {
            result += 1
            water -= capacity
        }
        
        col += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for row in 0..<rows {
        var col = 0
        while col < cols {
            if grid[row][col] == 1 {
                col += 1
                continue
            }

            var count = 0
            for i in col..<cols {
                if grid[row][i] == 1 {
                    break
                }
                count += 1
            }

            let filled = min(count, capacity)
            result += filled
            for i in col..<col + filled {
                grid[row][i] = 0
            }
            col += filled
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for row in 0..<rows {
        var col = 0
        while col < cols {
            if grid[row][col] == 1 {
                col += 1
                continue
            }

            var count = 0
            for i in col..<cols {
                if grid[row][i] == 1 {
                    break
                }
                count += 1
            }

            let filled = min(count, capacity)
            result += filled
            for i in col..<col + filled {
                grid[row][i] = 0
            }
            col += filled
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }

    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)

        for i in 0..<rows {
            if wells[i] > 0 {
                var filledCurrentRow = 0
                var j = 0

                while filledCurrentRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledCurrentRow += 1
                        grid[i][j] = 0
                        j += 1
                    } else {
                        j += 1
                    }
                }

                filled[i] = filledCurrentRow
                wells[i] -= filledCurrentRow
            }
        }

        result += filled.max()!
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }

    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)

        for i in 0..<rows {
            if wells[i] > 0 {
                var filledCurrentRow = 0
                var j = 0

                while filledCurrentRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledCurrentRow += 1
                        grid[i][j] = 0
                        j += 1
                    } else {
                        j += 1
                    }
                }

                filled[i] = filledCurrentRow
                wells[i] -= filledCurrentRow
            }
        }

        result += filled.max()!
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var wells = [Int]()
    var rows = grid.count
    var cols = grid[0].count

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                wells.append(row)
            }
        }
    }

    while!wells.isEmpty {
        var level = 0
        var i = 0
        while i < wells.count {
            let row = wells[i]
            if grid[row][0] == 1 {
                grid[row][0] = 0
                for col in 1..<cols {
                    if grid[row][col] == 1 {
                        grid[row][col] = 0
                        level += 1
                    } else {
                        break
                    }
                }
                if level == capacity {
                    result += 1
                    level = 0
                }
            }
            i += 1
        }
        wells.removeAll()
        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 {
                    wells.append(row)
                }
            }
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var wells = [Int]()
    var rows = grid.count
    var cols = grid[0].count

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                wells.append(row)
            }
        }
    }

    while!wells.isEmpty {
        var level = 0
        var i = 0
        while i < wells.count {
            let row = wells[i]
            if grid[row][0] == 1 {
                grid[row][0] = 0
                for col in 1..<cols {
                    if grid[row][col] == 1 {
                        grid[row][col] = 0
                        level += 1
                    } else {
                        break
                    }
                }
                if level == capacity {
                    result += 1
                    level = 0
                }
            }
            i += 1
        }
        wells.removeAll()
        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 {
                    wells.append(row)
                }
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = grid[0].count - 1
    
    while i < grid.count && j >= 0 {
        var count = 0
        while j >= 0 && grid[i][j] == 1 {
            count += 1
            j -= 1
        }
        if count == 0 {
            i += 1
            continue
        }
        let canFill = min(count, capacity)
        result += canFill
        for k in 0..<canFill {
            grid[i][j + k + 1] -= 1
        }
        j -= canFill
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = grid[0].count - 1
    
    while i < grid.count && j >= 0 {
        var count = 0
        while j >= 0 && grid[i][j] == 1 {
            count += 1
            j -= 1
        }
        if count == 0 {
            i += 1
            continue
        }
        let canFill = min(count, capacity)
        result += canFill
        for k in 0..<canFill {
            grid[i][j + k + 1] -= 1
        }
        j -= canFill
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }
    
    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        
        for i in 0..<rows {
            if wells[i] > 0 {
                var filledInRow = 0
                var j = 0
                
                while filledInRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledInRow += 1
                        grid[i][j] = 0
                        j += 1
                    } else {
                        j += 1
                    }
                }
                
                result += 1
                wells[i] -= capacity
                filled[i] = capacity
            }
        }
        
        for i in 0..<rows {
            if filled[i] > 0 {
                for j in 0..<cols {
                    if grid[i][j] == 0 {
                        wells[i] += 1
                    }
                }
            }
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }
    
    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        
        for i in 0..<rows {
            if wells[i] > 0 {
                var filledInRow = 0
                var j = 0
                
                while filledInRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledInRow += 1
                        grid[i][j] = 0
                        j += 1
                    } else {
                        j += 1
                    }
                }
                
                result += 1
                wells[i] -= capacity
                filled[i] = capacity
            }
        }
        
        for i in 0..<rows {
            if filled[i] > 0 {
                for j in 0..<cols {
                    if grid[i][j] == 0 {
                        wells[i] += 1
                    }
                }
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }
    
    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        
        for i in 0..<rows {
            if wells[i] > 0 {
                var filledCurrentRow = 0
                var j = 0
                
                while filledCurrentRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledCurrentRow += 1
                        grid[i][j] = 0
                    }
                    j += 1
                }
                
                filled[i] = filledCurrentRow
                wells[i] -= filledCurrentRow
            }
        }
        
        result += filled.max()!
        wells = wells.enumerated().map { i, well in well + filled[i] }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }
    
    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        
        for i in 0..<rows {
            if wells[i] > 0 {
                var filledCurrentRow = 0
                var j = 0
                
                while filledCurrentRow < capacity && j < cols {
                    if grid[i][j] == 1 {
                        filledCurrentRow += 1
                        grid[i][j] = 0
                    }
                    j += 1
                }
                
                filled[i] = filledCurrentRow
                wells[i] -= filledCurrentRow
            }
        }
        
        result += filled.max()!
        wells = wells.enumerated().map { i, well in well + filled[i] }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = grid[0].count - 1
    
    while row < grid.count && col >= 0 {
        var count = 0
        var col = grid[0].count - 1
        
        while col >= 0 && grid[row][col] == 1 {
            count += 1
            col -= 1
        }
        
        if count == 0 {
            row += 1
            continue
        }
        
        var filled = min(count, capacity)
        grid[row][col + 1] -= filled
        result += filled
        
        while filled < count {
            col -= 1
            filled = min(capacity, grid[row][col + 1] + filled)
            grid[row][col + 1] -= filled
            result += filled
        }
        
        row += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = grid[0].count - 1
    
    while row < grid.count && col >= 0 {
        var count = 0
        var col = grid[0].count - 1
        
        while col >= 0 && grid[row][col] == 1 {
            count += 1
            col -= 1
        }
        
        if count == 0 {
            row += 1
            continue
        }
        
        var filled = min(count, capacity)
        grid[row][col + 1] -= filled
        result += filled
        
        while filled < count {
            col -= 1
            filled = min(capacity, grid[row][col + 1] + filled)
            grid[row][col + 1] -= filled
            result += filled
        }
        
        row += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }

    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        for i in 0..<rows {
            if wells[i] > 0 {
                let fill = min(capacity - filled[i], wells[i])
                filled[i] += fill
                wells[i] -= fill
                result += fill
            }
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                wells[i] += 1
            }
        }
    }

    while wells.contains(where: { $0 > 0 }) {
        var filled = [Int](repeating: 0, count: rows)
        for i in 0..<rows {
            if wells[i] > 0 {
                let fill = min(capacity - filled[i], wells[i])
                filled[i] += fill
                wells[i] -= fill
                result += fill
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    while i < grid.count {
        var j = grid[i].count - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                var count = 0
                while j >= 0 && grid[i][j] == 1 {
                    count += 1
                    j -= 1
                }
                result += count / capacity
            }
            j -= 1
        }
        i += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    while i < grid.count {
        var j = grid[i].count - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                var count = 0
                while j >= 0 && grid[i][j] == 1 {
                    count += 1
                    j -= 1
                }
                result += count / capacity
            }
            j -= 1
        }
        i += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for col in 0..<cols {
        for row in 0..<rows {
            if grid[row][col] == 1 {
                wells[row] += 1
            }
        }
    }

    while wells.contains(where: { $0 < capacity }) {
        for row in 0..<rows {
            if wells[row] < capacity {
                wells[row] += 1
                result += 1
            }
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: rows)

    for col in 0..<cols {
        for row in 0..<rows {
            if grid[row][col] == 1 {
                wells[row] += 1
            }
        }
    }

    while wells.contains(where: { $0 < capacity }) {
        for row in 0..<rows {
            if wells[row] < capacity {
                wells[row] += 1
                result += 1
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxCount = 0
    var row = 0
    var col = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i < grid.count && j < grid[i].count {
                    if grid[i][j] == 1 {
                        count += 1
                        grid[i][j] = 0
                        if count == capacity {
                            maxCount += 1
                            break
                        }
                    }
                    i += 1
                    j += 1
                }
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return maxCount
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxCount = 0
    var row = 0
    var col = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i < grid.count && j < grid[i].count {
                    if grid[i][j] == 1 {
                        count += 1
                        grid[i][j] = 0
                        if count == capacity {
                            maxCount += 1
                            break
                        }
                    }
                    i += 1
                    j += 1
                }
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return maxCount
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        let row = copy.first(where: { $0.contains(1) })!
        let index = row.firstIndex(of: 1)!
        let count = row.prefix(index + 1).reduce(0, { $0 + $1 })
        let fill = min(count, capacity)
        result += fill
        row[index] -= fill
        if row[index] == 0 {
            copy.remove(at: row)
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        let row = copy.first(where: { $0.contains(1) })!
        let index = row.firstIndex(of: 1)!
        let count = row.prefix(index + 1).reduce(0, { $0 + $1 })
        let fill = min(count, capacity)
        result += fill
        row[index] -= fill
        if row[index] == 0 {
            copy.remove(at: row)
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if copy[row][col] == 1 {
                var count = 0
                var colCopy = col
                while colCopy < grid[row].count && copy[row][colCopy] == 1 {
                    colCopy += 1
                    count += 1
                }
                if count <= capacity {
                    result += 1
                    col = colCopy
                } else {
                    col += 1
                }
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if copy[row][col] == 1 {
                var count = 0
                var colCopy = col
                while colCopy < grid[row].count && copy[row][colCopy] == 1 {
                    colCopy += 1
                    count += 1
                }
                if count <= capacity {
                    result += 1
                    col = colCopy
                } else {
                    col += 1
                }
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var row = 0
    var col = 0
    
    while row < grid.count {
        while col < grid[0].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i < grid.count && j < grid[0].count && grid[i][j] == 1 {
                    count += 1
                    i += 1
                    j += 1
                }
                max = max(max, count / capacity)
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var row = 0
    var col = 0
    
    while row < grid.count {
        while col < grid[0].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i < grid.count && j < grid[0].count && grid[i][j] == 1 {
                    count += 1
                    i += 1
                    j += 1
                }
                max = max(max, count / capacity)
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxCount = 0
    var row = 0
    while row < grid.count {
        var col = 0
        var count = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                count += capacity
            }
            col += 1
        }
        maxCount = max(maxCount, count)
        row += 1
    }
    return maxCount
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxCount = 0
    var row = 0
    while row < grid.count {
        var col = 0
        var count = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                count += capacity
            }
            col += 1
        }
        maxCount = max(maxCount, count)
        row += 1
    }
    return maxCount
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        let row = copy.first(where: { $0.contains(1) })!
        let index = row.firstIndex(of: 1)!
        let count = row.prefix(index + 1).reduce(0, { $0 + $1 })
        let filled = min(count, capacity)
        result += filled
        row[index] = 0
        row[index + 1..<row.count].prefix(filled).forEach { $0 = 0 }
        copy = copy.map { $0 == row? $0 : $0 }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        let row = copy.first(where: { $0.contains(1) })!
        let index = row.firstIndex(of: 1)!
        let count = row.prefix(index + 1).reduce(0, { $0 + $1 })
        let filled = min(count, capacity)
        result += filled
        row[index] = 0
        row[index + 1..<row.count].prefix(filled).forEach { $0 = 0 }
        copy = copy.map { $0 == row? $0 : $0 }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                while i < grid.count {
                    var j = col
                    while j < grid[i].count {
                        if grid[i][j] == 1 {
                            count += 1
                            grid[i][j] = 0
                        }
                        j += 1
                    }
                    i += 1
                }
                result += count / capacity
            }
            col += 1
        }
        row += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                while i < grid.count {
                    var j = col
                    while j < grid[i].count {
                        if grid[i][j] == 1 {
                            count += 1
                            grid[i][j] = 0
                        }
                        j += 1
                    }
                    i += 1
                }
                result += count / capacity
            }
            col += 1
        }
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var col2 = col
                while col2 < grid[row].count && grid[row][col2] == 1 {
                    count += 1
                    col2 += 1
                }
                var row2 = row + 1
                while row2 < grid.count && grid[row2][col] == 1 {
                    count += 1
                    row2 += 1
                }
                if count <= capacity {
                    result += 1
                    col = col2
                } else {
                    col += 1
                }
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var col2 = col
                while col2 < grid[row].count && grid[row][col2] == 1 {
                    count += 1
                    col2 += 1
                }
                var row2 = row + 1
                while row2 < grid.count && grid[row2][col] == 1 {
                    count += 1
                    row2 += 1
                }
                if count <= capacity {
                    result += 1
                    col = col2
                } else {
                    col += 1
                }
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        result += 1
        let row = copy.firstIndex(where: { $0.contains(1) })!
        let col = copy[row].firstIndex(where: { $0 == 1 })!
        copy[row][col] = 0
        let rowUp = row > 0? row - 1 : nil
        let rowDown = row < copy.count - 1? row + 1 : nil
        let colLeft = col > 0? col -1 : nil
        let colRight = col < copy[row].count - 1? col + 1 : nil
        if let rowUp = rowUp, let colLeft = colLeft, copy[rowUp][colLeft] ==  == 1 {
            copy[rowUp][colLeft] = 0
        }
        if let rowUp = rowUp, copy[rowUp].contains(where: { $0 ==  == 1 }) {
            copy[rowUp][col] = 0
        }
        if let rowDown = rowDown, let colLeft = colLeft, copy[rowDown][colLeft] ==  == 1 {
            copy[rowDown][colLeft] = 0
        }
        if let rowDown = rowDown, copy[rowDown].contains(where: { $0 == 1 }) {
            copy[rowDown][col] = 0
        }
        if let colRight = colRight, let rowUp = rowUp, copy[rowUp][colRight] ==  == 1 {
            copy[rowUp][colRight] = 0
        }
        if let colRight = colRight, copy[row].contains(where: { $0 == 1 }) {
            copy[row][colRight] = 0
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var copy = grid
    while copy.contains(where: { $0.contains(1) }) {
        result += 1
        let row = copy.firstIndex(where: { $0.contains(1) })!
        let col = copy[row].firstIndex(where: { $0 == 1 })!
        copy[row][col] = 0
        let rowUp = row > 0? row - 1 : nil
        let rowDown = row < copy.count - 1? row + 1 : nil
        let colLeft = col > 0? col -1 : nil
        let colRight = col < copy[row].count - 1? col + 1 : nil
        if let rowUp = rowUp, let colLeft = colLeft, copy[rowUp][colLeft] ==  == 1 {
            copy[rowUp][colLeft] = 0
        }
        if let rowUp = rowUp, copy[rowUp].contains(where: { $0 ==  == 1 }) {
            copy[rowUp][col] = 0
        }
        if let rowDown = rowDown, let colLeft = colLeft, copy[rowDown][colLeft] ==  == 1 {
            copy[rowDown][colLeft] = 0
        }
        if let rowDown = rowDown, copy[rowDown].contains(where: { $0 == 1 }) {
            copy[rowDown][col] = 0
        }
        if let colRight = colRight, let rowUp = rowUp, copy[rowUp][colRight] ==  == 1 {
            copy[rowUp][colRight] = 0
        }
        if let colRight = colRight, copy[row].contains(where: { $0 == 1 }) {
            copy[row][colRight] = 0
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i >= 0 && grid[i][j] == 1 {
                    count += 1
                    i -= 1
                }
                i = row
                j = col
                while j < grid[row].count && grid[i][j] == 1 {
                    count += 1
                    j += 1
                }
                let fillCount = count / (capacity + 1)
                result += fillCount
                col += fillCount
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    while row < grid.count {
        var col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                var count = 0
                var i = row
                var j = col
                while i >= 0 && grid[i][j] == 1 {
                    count += 1
                    i -= 1
                }
                i = row
                j = col
                while j < grid[row].count && grid[i][j] == 1 {
                    count += 1
                    j += 1
                }
                let fillCount = count / (capacity + 1)
                result += fillCount
                col += fillCount
            } else {
                col += 1
            }
        }
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    var water = 0
    
    for row in grid {
        wells += row.count(where: { $0 == 1 })
        water += capacity
        
        for well in row {
            if well == 1 {
                if water >= 1 {
                    maxFill += 1
                    water -= 1
                }
            }
        }
    }
    
    return max(maxFill, wells - maxFill)
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    var water = 0
    
    for row in grid {
        wells += row.count(where: { $0 == 1 })
        water += capacity
        
        for well in row {
            if well == 1 {
                if water >= 1 {
                    maxFill += 1
                    water -= 1
                }
            }
        }
    }
    
    return max(maxFill, wells - maxFill)
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    for row in grid {
        var fill = capacity
        for well in row {
            if well == 1 {
                if fill == 0 {
                    wells -= 1
                } else {
                    fill -= 1
                }
            }
        }
        maxFill = max(maxFill, wells + fill)
        wells += row.count
    }
    return maxFill
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    for row in grid {
        var fill = capacity
        for well in row {
            if well == 1 {
                if fill == 0 {
                    wells -= 1
                } else {
                    fill -= 1
                }
            }
        }
        maxFill = max(maxFill, wells + fill)
        wells += row.count
    }
    return maxFill
}

// Test cases
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) // Output: 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0], [1, 1, 1], [0, 1, 1]], capacity: 2) // Output: 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) // Output: 0
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return max
        }
    }
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return max
        }
    }
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        var sum = 0
        for well in row {
            sum += well
        }
        max = max > sum? max : sum
        count += sum
    }
    return count > capacity? max + (count - capacity) / max : max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        var sum = 0
        for well in row {
            sum += well
        }
        max = max > sum? max : sum
        count += sum
    }
    return count > capacity? max + (count - capacity) / max : max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return max
        }
    }
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return max
        }
    }
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var wells = 0
    var row = 0
    var col = 0
    while row < grid.count {
        col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                wells += 1
                max = max > capacity - wells? max : capacity - wells
            } else {
                wells = wells > capacity? wells - capacity : 0
            }
            col += 1
        }
        row += 1
    }
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var wells = 0
    var row = 0
    var col = 0
    while row < grid.count {
        col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                wells += 1
                max = max > capacity - wells? max : capacity - wells
            } else {
                wells = wells > capacity? wells - capacity : 0
            }
            col += 1
        }
        row += 1
    }
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return capacity
        }
    }
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for row in grid {
        max = 0
        count = 0
        for well in row {
            if well == 1 {
                count += 1
            } else {
                max = max > count? max : count
                count = 0
            }
        }
        max = max > count? max : count
        if max == capacity {
            return capacity
        }
    }
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var wells = Array(repeating: capacity, count: grid[0].count)
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                wells[i] = wells[i] - 1
            }
        }
        result = max(result, wells.reduce(0, +))
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var wells = Array(repeating: capacity, count: grid[0].count)
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                wells[i] = wells[i] - 1
            }
        }
        result = max(result, wells.reduce(0, +))
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    var row = 0
    var col = 0
    while row < grid.count {
        col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                count += 1
                if count > max {
                    max = count
                }
            } else {
                count = 0
            }
            col += 1
        }
        row += 1
    }
    return max
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    var row = 0
    var col = 0
    while row < grid.count {
        col = 0
        while col < grid[row].count {
            if grid[row][col] == 1 {
                count += 1
                if count > max {
                    max = count
                }
            } else {
                count = 0
            }
            col += 1
        }
        row += 1
    }
    return max
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    var water = 0
    for row in grid {
        wells += row.count(where: { $0 == 1 })
        water += capacity
        maxFill = max(maxFill, min(water, wells))
    }
    return maxFill
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var wells = 0
    var water = 0
    for row in grid {
        wells += row.count(where: { $0 == 1 })
        water += capacity
        maxFill = max(maxFill, min(water, wells))
    }
    return maxFill
}
```

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
 */
    
    
    
    
    
    var result = 0, 0
    return 0
    var result = 0

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
 */











    return 0

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
 */




    return 0
    
    return 0
    

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
 */
    
    
    
    
    return 0
    return 0

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
 */
    var count: Int {
    var count = 0
    var

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {

import Foundation

func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

```swift
import Foundation

/* 
 Function to multiply two matrices represented as 2D arrays of Doubles.
 Returns a new matrix that is the product of `lhs` and `rhs`, or `nil` if the matrices cannot be multiplied.
 */
func multiply(_ lhs: [[Double]], _ rhs: [[Double]]) -> [[Double]]? {
    guard lhs[0].count == rhs.count else { 
        return nil 
    }
    
    var result = [[Double]](repeating: [Double](repeating: 0, count: rhs[0].count), count: lhs.count)
    for i in 0..<lhs.count {
        for j in 0..<rhs[0].count {
            for k in 0..<rhs.count {
                result[i][j] += lhs[i][k] * rhs[k][j]
            }
        }
    }
    
    return result
}

/*
 You are given a rectangular grid of wells. Each row represents a single well,
 and each 1 in a row represents a single unit of water.
 Each well has a corresponding bucket that can be used to extract water from it, 
 and all buckets have the same capacity.
 Your task is to use the buckets to empty the wells.
 Output the number of times you need to lower the buckets.
 Example 1:
 Example 2:
 Example 3:
 Constraints:
 * all wells have the same length
 * 1 <= grid.length <= 10^2
 * 1 <= grid[:,1].length <= 10^2
 * grid[i][j] -> 0 | 1
 * 1 <= capacity <= 10
 maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
 maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
 maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
 */
func maxFill(grid: [[Int]], capacity: Int) -> Int {
 */

    return 0, 0, 0, 0, 0, 0, 0
    return 0
    return 0
    return 0

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {






Here is to empty the number of wells, such that can be emptied the buckets to determine the number of times the buckets to empty the buckets to empty the wells.

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {









The function maxFill the

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {






Here is a function maxFill the grid:

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {








The function maxFill the buckets are

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {





Here is to empty the number of wells are all wells are empty of buckets have the same length, such that can be empty, given that can be emptied in one bucket has a single bucket

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {








Here is






The function maxFill the grid:

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {








Here is a bucketLowering the buckets are all wells are empty if the number of times the buckets need

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {






Here is the number of times the buckets need to empty the buckets need to empty the wells.

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
        buckets = []
    }
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
        buckets = []
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        buckets[0] -= 1
        buckets.remove(at: 0)
        count += 1
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        buckets[0] -= 1
        buckets.remove(at: 0)
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        buckets[0] -= 1
        buckets.remove(at: 0)
        count += 1
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        buckets[0] -= 1
        buckets.remove(at: 0)
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets.removeAll(where: { $0 == capacity })
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets.removeAll(where: { $0 == capacity })
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    
    while !buckets.isEmpty && buckets.last! > capacity {
        buckets.removeLast()
        count += 1
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    
    while !buckets.isEmpty && buckets.last! > capacity {
        buckets.removeLast()
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                count += 1
            }
        }
        buckets = [capacity]
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                count += 1
            }
        }
        buckets = [capacity]
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    
    return drops
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    
    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var refills = 0
    for row in grid {
        for well in row {
            if well == 1 {
                refills += 1
                buckets -= 1
            }
            if buckets == 0 {
                buckets = capacity
                refills += 1
            }
        }
    }
    return refills
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var refills = 0
    for row in grid {
        for well in row {
            if well == 1 {
                refills += 1
                buckets -= 1
            }
            if buckets == 0 {
                buckets = capacity
                refills += 1
            }
        }
    }
    return refills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var refills = 0
    for row in grid {
        for well in row {
            if well == 1 {
                if buckets > 0 {
                    buckets -= 1
                } else {
                    refills += 1
                    buckets = capacity - 1
                }
            }
        }
    }
    return refills
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var refills = 0
    for row in grid {
        for well in row {
            if well == 1 {
                if buckets > 0 {
                    buckets -= 1
                } else {
                    refills += 1
                    buckets = capacity - 1
                }
            }
        }
    }
    return refills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var drops = 0
    for row in grid {
        for well in row {
            if well == 1 {
                drops += 1
                if buckets == 1 {
                    buckets = capacity
                } else {
                    buckets -= 1
                }
            }
        }
    }
    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var bucket = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                if bucket > 0 {
                    bucket -= 1
                } else {
                    count += 1
                    bucket = capacity - 1
                }
            }
        }
    }
    if bucket < capacity {
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var buckets = 0
    var wells = [Int]()

    for i in 0..<rows {
        var count = 0
        for j in 0..<cols {
            count += grid[i][j]
        }
        wells.append(count)
    }

    wells.sort(by: >)

    for i in 0..<rows {
        while wells[i] > 0 {
            buckets += 1
            for j in 0..<capacity {
                if i+j < rows && wells[i+j] > 0 {
                    wells[i+j] -= 1
                }
            }
        }
    }

    return buckets
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var buckets = 0
    var wells = [Int]()

    for i in 0..<rows {
        var count = 0
        for j in 0..<cols {
            count += grid[i][j]
        }
        wells.append(count)
    }

    wells.sort(by: >)

    for i in 0..<rows {
        while wells[i] > 0 {
            buckets += 1
            for j in 0..<capacity {
                if i+j < rows && wells[i+j] > 0 {
                    wells[i+j] -= 1
                }
            }
        }
    }

    return buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = [Int](repeating: 0, count: capacity)
    
    while !wells.isEmpty {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket[j] == 0 {
                    bucket[j] = 1
                    count += 1
                }
            }
        }
        wells = wells.map { $0.filter { $0 == 0 } }.filter { !$0.isEmpty }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = [Int](repeating: 0, count: capacity)
    
    while !wells.isEmpty {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket[j] == 0 {
                    bucket[j] = 1
                    count += 1
                }
            }
        }
        wells = wells.map { $0.filter { $0 == 0 } }.filter { !$0.isEmpty }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var buckets = [Int]()
    
    for i in 0..<wells.count {
        var bucket = [Int]()
        for j in 0..<wells[i].count {
            bucket.append(wells[i][j])
            if bucket.count == capacity {
                buckets.append(bucket.reduce(0, +))
                bucket = []
            }
        }
        if !bucket.isEmpty {
            buckets.append(bucket.reduce(0, +))
        }
    }
    
    while buckets.contains(0) {
        let index = buckets.firstIndex(of: 0) ?? -1
        if index != -1 {
            buckets.remove(at: index)
        }
    }
    
    while !buckets.isEmpty {
        let maxIndex = buckets.firstIndex(of: buckets.max()!) ?? -1
        if maxIndex != -1 {
            buckets.remove(at: maxIndex)
        }
        count += 1
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var buckets = [Int]()
    
    for i in 0..<wells.count {
        var bucket = [Int]()
        for j in 0..<wells[i].count {
            bucket.append(wells[i][j])
            if bucket.count == capacity {
                buckets.append(bucket.reduce(0, +))
                bucket = []
            }
        }
        if !bucket.isEmpty {
            buckets.append(bucket.reduce(0, +))
        }
    }
    
    while buckets.contains(0) {
        let index = buckets.firstIndex(of: 0) ?? -1
        if index != -1 {
            buckets.remove(at: index)
        }
    }
    
    while !buckets.isEmpty {
        let maxIndex = buckets.firstIndex(of: buckets.max()!) ?? -1
        if maxIndex != -1 {
            buckets.remove(at: maxIndex)
        }
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var wells = grid
    var count = 0
    var buckets = [Int](repeating: 0, count: rows)
    
    for col in 0..<cols {
        for row in 0..<rows {
            if wells[row][col] == 1 && buckets[row] < capacity {
                buckets[row] += 1
                if buckets[row] == capacity {
                    count += 1
                }
            }
        }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var wells = grid
    var count = 0
    var buckets = [Int](repeating: 0, count: rows)
    
    for col in 0..<cols {
        for row in 0..<rows {
            if wells[row][col] == 1 && buckets[row] < capacity {
                buckets[row] += 1
                if buckets[row] == capacity {
                    count += 1
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var wells = [[Int]]()
    for i in 0..<m {
        wells.append(Array(repeating: 0, count: n))
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                for k in 0..<capacity {
                    if i-k >= 0 {
                        wells[i-k][j] += 1
                    }
                }
            }
        }
    }
    var maxFills = 0
    for i in 0..<m {
        for j in 0..<n {
            maxFills = max(maxFills, wells[i][j])
        }
    }
    return maxFills
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var wells = [[Int]]()
    for i in 0..<m {
        wells.append(Array(repeating: 0, count: n))
    }
    for i in 0..<m {
        for j in 0..<n {
            if grid[i][j] == 1 {
                for k in 0..<capacity {
                    if i-k >= 0 {
                        wells[i-k][j] += 1
                    }
                }
            }
        }
    }
    var maxFills = 0
    for i in 0..<m {
        for j in 0..<n {
            maxFills = max(maxFills, wells[i][j])
        }
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 && bucket > 0 {
                    wells[i][j] = 0
                    bucket -= 1
                }
            }
        }
        count += 1
        bucket = capacity
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid.map { $0.reduce(0, +) }
    var buckets = 0
    while !wells.isEmpty {
        let sortedWells = wells.sorted(by: >)
        var filled = 0
        for i in 0..<min(capacity, sortedWells.count) {
            filled += sortedWells[i]
        }
        buckets += filled
        wells = wells.map { $0 - filled }.filter { $0 > 0 }
    }
    return buckets
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid.map { $0.reduce(0, +) }
    var buckets = 0
    while !wells.isEmpty {
        let sortedWells = wells.sorted(by: >)
        var filled = 0
        for i in 0..<min(capacity, sortedWells.count) {
            filled += sortedWells[i]
        }
        buckets += filled
        wells = wells.map { $0 - filled }.filter { $0 > 0 }
    }
    return buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 {
                    wells[i][j] = 0
                    bucket -= 1
                    if bucket == 0 {
                        count += 1
                        bucket = capacity
                    }
                }
            }
        }
        if bucket < capacity {
            count += 1
            bucket = capacity
        }
    }
    
    return count
}

<｜begin▁of▁sentence｜>You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var count = 0
    var bucket = capacity
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 {
                    wells[i][j] = 0
                    bucket -= 1
                    if bucket == 0 {
                        count += 1
                        bucket = capacity
                    }
                }
            }
        }
        if bucket < capacity {
            count += 1
            bucket = capacity
        }
    }
    
    return count
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var buckets = 0
    let rows = grid.count
    let cols = grid[0].count

    for i in 0..<rows {
        var currentCapacity = capacity
        for j in 0..<cols {
            if grid[i][j] == 1 {
                if currentCapacity == capacity {
                    buckets += 1
                }
                grid[i][j] = 0
                currentCapacity -= 1
                if currentCapacity == 0 {
                    currentCapacity = capacity
                }
            }
        }
    }
    return buckets
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var buckets = 0
    let rows = grid.count
    let cols = grid[0].count

    for i in 0..<rows {
        var currentCapacity = capacity
        for j in 0..<cols {
            if grid[i][j] == 1 {
                if currentCapacity == capacity {
                    buckets += 1
                }
                grid[i][j] = 0
                currentCapacity -= 1
                if currentCapacity == 0 {
                    currentCapacity = capacity
                }
            }
        }
    }
    return buckets
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var bucket = capacity
    var operations = 0

    for row in grid {
        for well in row {
            if well == 1 {
                if bucket == 0 {
                    bucket = capacity
                    operations += 1
                }
                bucket -= 1
                operations += 1
            }
        }
    }

    return operations
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var bucket = capacity
    var operations = 0

    for row in grid {
        for well in row {
            if well == 1 {
                if bucket == 0 {
                    bucket = capacity
                    operations += 1
                }
                bucket -= 1
                operations += 1
            }
        }
    }

    return operations
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                bucket -= 1
                grid[row][col] = 0
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
            }
        }
        if bucket < capacity {
            operations += 1
        }
    }

    return operations
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                bucket -= 1
                grid[row][col] = 0
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
            }
        }
        if bucket < capacity {
            operations += 1
        }
    }

    return operations
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
                bucket -= 1
                grid[row][col] = 0
            }
        }
    }

    return operations
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
                bucket -= 1
                grid[row][col] = 0
            }
        }
    }

    return operations
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    func fill(row: Int, col: Int, capacity: Int) {
        var capacity = capacity
        for i in col..<cols {
            if grid[row][i] == 1 {
                grid[row][i] = 0
                capacity -= 1
                if capacity == 0 {
                    operations += 1
                    return
                }
            }
        }
    }

    for row in 0..<rows {
        var capacityLeft = capacity
        for col in 0..<cols {
            if grid[row][col] == 1 {
                fill(row: row, col: col, capacity: capacityLeft)
                capacityLeft = capacity
            }
        }
    }

    return operations
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    func fill(row: Int, col: Int, capacity: Int) {
        var capacity = capacity
        for i in col..<cols {
            if grid[row][i] == 1 {
                grid[row][i] = 0
                capacity -= 1
                if capacity == 0 {
                    operations += 1
                    return
                }
            }
        }
    }

    for row in 0..<rows {
        var capacityLeft = capacity
        for col in 0..<cols {
            if grid[row][col] == 1 {
                fill(row: row, col: col, capacity: capacityLeft)
                capacityLeft = capacity
            }
        }
    }

    return operations
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                bucket -= 1
                grid[row][col] = 0
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
            }
        }
        if bucket < capacity {
            operations += 1
        }
    }

    return operations
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var operations = 0
    let rows = grid.count
    let cols = grid[0].count

    for col in 0..<cols {
        var bucket = capacity
        for row in 0..<rows {
            if grid[row][col] == 1 {
                bucket -= 1
                grid[row][col] = 0
                if bucket == 0 {
                    operations += 1
                    bucket = capacity
                }
            }
        }
        if bucket < capacity {
            operations += 1
        }
    }

    return operations
}
```

import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
import Foundation

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var currentFill = 0

    for row in grid {
        for well in row {
            if well == 1 {
                currentFill += 1
                if currentFill == capacity {
                    buckets += 1
                    currentFill = 0
                }
            }
        }
    }

    if currentFill > 0 {
        buckets += 1
    }

    return buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let wellCount = grid[0].count
    
    for well in grid {
        let waterUnits = well.filter { $0 == 1 }.count
        totalBucketLowerings += (waterUnits + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let wellCount = grid[0].count
    
    for well in grid {
        let waterUnits = well.filter { $0 == 1 }.count
        totalBucketLowerings += (waterUnits + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            maxFills += 1
        }
    }
    
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            maxFills += 1
        }
    }
    
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            maxFill += 1
        }
    }
    
    return maxFill
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            maxFill += 1
        }
    }
    
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.reduce(0, +)
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.reduce(0, +)
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
        }
        totalBucketLowerings += (currentRowWater + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
        }
        totalBucketLowerings += (currentRowWater + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        let row = grid[i]
        let waterUnits = row.reduce(0, +)
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        let row = grid[i]
        let waterUnits = row.reduce(0, +)
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += Int(ceil(Double(waterUnits) / Double(capacity)))
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += Int(ceil(Double(waterUnits) / Double(capacity)))
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentFill = 0
        for j in 0..<cols {
            if grid[i][j] == 1 {
                currentFill += 1
            }
        }
        maxFill += (currentFill + capacity - 1) / capacity
    }
    
    return maxFill
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentFill = 0
        for j in 0..<cols {
            if grid[i][j] == 1 {
                currentFill += 1
            }
        }
        maxFill += (currentFill + capacity - 1) / capacity
    }
    
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentFill = 0
        for col in 0..<cols {
            if grid[row][col] == 1 {
                currentFill += 1
            }
        }
        maxFills += (currentFill + capacity - 1) / capacity
    }
    
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentFill = 0
        for col in 0..<cols {
            if grid[row][col] == 1 {
                currentFill += 1
            }
        }
        maxFills += (currentFill + capacity - 1) / capacity
    }
    
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFill += (waterUnits + capacity - 1) / capacity
    }
    return maxFill
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFill += (waterUnits + capacity - 1) / capacity
    }
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
        }
        totalBucketLowerings += (currentRowWater + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var totalBucketLowerings = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
        }
        totalBucketLowerings += (currentRowWater + capacity - 1) / capacity
    }
    
    return totalBucketLowerings
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var bucketCount = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            bucketCount += 1
        }
    }
    
    return bucketCount
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var bucketCount = 0
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        var currentRow = grid[i]
        var waterUnits = currentRow.reduce(0, +)
        
        while waterUnits > 0 {
            waterUnits -= capacity
            bucketCount += 1
        }
    }
    
    return bucketCount
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        count += row.filter { $0 == 1 }.count
    }
    return (count + capacity - 1) / capacity
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        count += row.filter { $0 == 1 }.count
    }
    return (count + capacity - 1) / capacity
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        count += row.filter { $0 == 1 }.count / capacity
    }
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        count += row.filter { $0 == 1 }.count / capacity
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += (waterUnits + capacity - 1) / capacity
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += Int(ceil(Double(waterUnits) / Double(capacity)))
    }
    return maxFills
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFills = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFills += Int(ceil(Double(waterUnits) / Double(capacity)))
    }
    return maxFills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFill += (waterUnits + capacity - 1) / capacity
    }
    return maxFill
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        let waterUnits = row.filter { $0 == 1 }.count
        maxFill += (waterUnits + capacity - 1) / capacity
    }
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var bucketCount = 0
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 {
                    wells[i][j] = 0
                    bucketCount += 1
                    
                    if bucketCount % capacity == 0 {
                        return bucketCount
                    }
                }
            }
        }
    }
    
    return bucketCount
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var wells = grid
    var bucketCount = 0
    
    while wells.contains(where: { $0.contains(1) }) {
        for i in 0..<wells.count {
            for j in 0..<wells[i].count {
                if wells[i][j] == 1 {
                    wells[i][j] = 0
                    bucketCount += 1
                    
                    if bucketCount % capacity == 0 {
                        return bucketCount
                    }
                }
            }
        }
    }
    
    return bucketCount
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var result = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    func dfs(_ row: Int, _ col: Int, _ capacity: Int) {
        if row < 0 || row >= rows || col < 0 || col >= cols || visited[row][col] || grid[row][col] == 0 {
            return
        }
        
        visited[row][col] = true
        
        if grid[row][col] == 1 {
            result += capacity
            grid[row][col] = 0
        }
        
        dfs(row - 1, col, capacity)
        dfs(row + 1, col, capacity)
        dfs(row, col - 1, capacity)
        dfs(row, col + 1, capacity)
    }
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                dfs(row, col, capacity)
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var result = 0
    var visited = Array(repeating: Array(repeating: false, count: cols), count: rows)
    
    func dfs(_ row: Int, _ col: Int, _ capacity: Int) {
        if row < 0 || row >= rows || col < 0 || col >= cols || visited[row][col] || grid[row][col] == 0 {
            return
        }
        
        visited[row][col] = true
        
        if grid[row][col] == 1 {
            result += capacity
            grid[row][col] = 0
        }
        
        dfs(row - 1, col, capacity)
        dfs(row + 1, col, capacity)
        dfs(row, col - 1, capacity)
        dfs(row, col + 1, capacity)
    }
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                dfs(row, col, capacity)
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var result = 0
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                result += capacity
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var result = 0
    
    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                result += capacity
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    
    while capacity > 0 {
        for row in grid {
            for (index, value) in row.enumerated() {
                if value == 1 {
                    if index > 0 && row[index - 1] == 0 {
                        grid[row.index(of: 1)!][index - 1] = 1
                        capacity -= 1
                    }
                    if index < row.count - 1 && row[index + 1] == 0 {
                        grid[row.index(of: 1)!][index + 1] = 1
                        capacity -= 1
                    }
                    if index > 0 && grid[row.index(of: 1)! - 1][index] == 0 {
                        grid[row.index(of: 1)! - 1][index] = 1
                        capacity -= 1
                    }
                    if index < row.count - 1 && grid[row.index(of: 1)! + 1][index] == 0 {
                        grid[row.index(of: 1)! + 1][index] = 1
                        capacity -= 1
                    }
                }
            }
        }
        result += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    
    while capacity > 0 {
        for row in grid {
            for (index, value) in row.enumerated() {
                if value == 1 {
                    if index > 0 && row[index - 1] == 0 {
                        grid[row.index(of: 1)!][index - 1] = 1
                        capacity -= 1
                    }
                    if index < row.count - 1 && row[index + 1] == 0 {
                        grid[row.index(of: 1)!][index + 1] = 1
                        capacity -= 1
                    }
                    if index > 0 && grid[row.index(of: 1)! - 1][index] == 0 {
                        grid[row.index(of: 1)! - 1][index] = 1
                        capacity -= 1
                    }
                    if index < row.count - 1 && grid[row.index(of: 1)! + 1][index] == 0 {
                        grid[row.index(of: 1)! + 1][index] = 1
                        capacity -= 1
                    }
                }
            }
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var result = 0
    
    while grid.contains(where: { $0.contains(1) }) {
        for (i, row) in grid.enumerated() {
            for (j, well) in row.enumerated() {
                if well == 1 {
                    let min = min(capacity, row.filter { $0 == 1 }.count)
                    grid[i][j] = 0
                    result += min
                }
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var result = 0
    
    while grid.contains(where: { $0.contains(1) }) {
        for (i, row) in grid.enumerated() {
            for (j, well) in row.enumerated() {
                if well == 1 {
                    let min = min(capacity, row.filter { $0 == 1 }.count)
                    grid[i][j] = 0
                    result += min
                }
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    
    for row in grid {
        for well in row {
            if well == 1 {
                result += capacity
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    
    for row in grid {
        for well in row {
            if well == 1 {
                result += capacity
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    
    while capacity > 0 {
        var row = 0
        var column = 0
        var max = 0
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    row = i
                    column = j
                    max = 1
                    break
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i < row {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i > row {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if j < column {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if j > column {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == row && j == column {
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == row && j == column {
                        grid[i][j] = 0
                        capacity -= 1
                        result += 1
                    }
                }
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    
    while capacity > 0 {
        var row = 0
        var column = 0
        var max = 0
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    row = i
                    column = j
                    max = 1
                    break
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i < row {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i > row {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if j < column {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if j > column {
                        row = i
                        column = j
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == row && j == column {
                        max = 1
                    }
                }
            }
        }
        
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == row && j == column {
                        grid[i][j] = 0
                        capacity -= 1
                        result += 1
                    }
                }
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentCol = 0
    var currentRowLength = grid[0].count
    var currentRowCapacity = 0
    
    while current < grid.count * grid[0].count {
        if currentRowCapacity == 0 {
            currentRowCapacity = currentRowLength
            currentCol = 0
        }
        
        if grid[currentRow][currentCol] == 1 {
            currentCapacity -= 1
            currentRowCapacity -= 1
            current += 1
        }
        
        if currentCapacity == 0 {
            currentCapacity = capacity
            currentRow += 1
            currentRowCapacity = currentRowLength
        }
        
        currentCol += 1
        result += 1
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentCol = 0
    var currentRowLength = grid[0].count
    var currentRowCapacity = 0
    
    while current < grid.count * grid[0].count {
        if currentRowCapacity == 0 {
            currentRowCapacity = currentRowLength
            currentCol = 0
        }
        
        if grid[currentRow][currentCol] == 1 {
            currentCapacity -= 1
            currentRowCapacity -= 1
            current += 1
        }
        
        if currentCapacity == 0 {
            currentCapacity = capacity
            currentRow += 1
            currentRowCapacity = currentRowLength
        }
        
        currentCol += 1
        result += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    
    while grid.contains(where: { $0.contains(1) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    var count = 0
                    
                    for k in 0..<grid.count {
                        if grid[k][j] == 1 {
                            count += 1
                        }
                    }
                    
                    if count <= capacity {
                        for k in 0..<grid.count {
                            grid[k][j] = 0
                        }
                        result += count
                    } else {
                        for k in 0..<grid.count {
                            if grid[k][j] == 1 {
                                grid[k][j] = 0
                                result += 1
                            }
                        }
                    }
                }
            }
        }
    }
    
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    
    while grid.contains(where: { $0.contains(1) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    var count = 0
                    
                    for k in 0..<grid.count {
                        if grid[k][j] == 1 {
                            count += 1
                        }
                    }
                    
                    if count <= capacity {
                        for k in 0..<grid.count {
                            grid[k][j] = 0
                        }
                        result += count
                    } else {
                        for k in 0..<grid.count {
                            if grid[k][j] == 1 {
                                grid[k][j] = 0
                                result += 1
                            }
                        }
                    }
                }
            }
        }
    }
    
    return result
}
```

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var current<bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos><bos>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var queue = [Int]()
    var visited = [Int]()
    var visitedCount = 0
    var count = 0
    var row = 0
    var col = 0
    var maxRow = grid.count
    var maxCol = grid[0].count
    var dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]]
    for row = 0; row < maxRow; row++ {
        for col = 0; col < maxCol; col++ {
            if grid[row][col] == 1 {
                queue.append(row * maxCol + col)
                visited.append(row * maxCol + col)
                visitedCount += 1
            }
        }
    }
    while visitedCount > 0 {
        count = 0
        for i in 0..<queue.count {
            let current = queue[i]
            let row = current / maxCol
            let col = current % maxCol
            for dir in dirs {
                let nextRow = row + dir[0]
                let nextCol = col + dir[1]
                if nextRow < 0 || nextRow >= maxRow || nextCol < 0 || nextCol >= maxCol {
                    continue
                }
                if grid[nextRow][nextCol] == 1 && visited.contains(nextRow * maxCol + nextCol) == false {
                    queue.append(nextRow * maxCol + nextCol)
                    visited.append(nextRow * maxCol + nextCol)
                    visitedCount += 1
                    count += 1
                    if count == capacity {
                        result += 1
                        count = 0
                    }
                }
            }
        }
        queue.removeAll(where: {visited.contains($0)})
        visited.removeAll(where: {visited.contains($0)})
        visitedCount -= queue.count
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var queue = [Int]()
    var visited = [Int]()
    var visitedCount = 0
    var count = 0
    var row = 0
    var col = 0
    var maxRow = grid.count
    var maxCol = grid[0].count
    var dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]]
    for row = 0; row < maxRow; row++ {
        for col = 0; col < maxCol; col++ {
            if grid[row][col] == 1 {
                queue.append(row * maxCol + col)
                visited.append(row * maxCol + col)
                visitedCount += 1
            }
        }
    }
    while visitedCount > 0 {
        count = 0
        for i in 0..<queue.count {
            let current = queue[i]
            let row = current / maxCol
            let col = current % maxCol
            for dir in dirs {
                let nextRow = row + dir[0]
                let nextCol = col + dir[1]
                if nextRow < 0 || nextRow >= maxRow || nextCol < 0 || nextCol >= maxCol {
                    continue
                }
                if grid[nextRow][nextCol] == 1 && visited.contains(nextRow * maxCol + nextCol) == false {
                    queue.append(nextRow * maxCol + nextCol)
                    visited.append(nextRow * maxCol + nextCol)
                    visitedCount += 1
                    count += 1
                    if count == capacity {
                        result += 1
                        count = 0
                    }
                }
            }
        }
        queue.removeAll(where: {visited.contains($0)})
        visited.removeAll(where: {visited.contains($0)})
        visitedCount -= queue.count
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var visited = [Int]()
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i)
                visited.append(j)
            }
        }
    }
    while!queue.isEmpty {
        var current = queue.removeFirst()
        var currentVisited = visited.removeFirst()
        var currentCapacity = capacity
        while currentCapacity > 0 {
            if current + 1 < grid.count && grid[current + 1][currentVisited] == 1 {
                queue.append(current + 1)
                visited.append(currentVisited)
                current++
            } else if current - 1 >= 0 && grid[current - 1][currentVisited] == 1 {
                queue.append(current - 1)
                visited.append(currentVisited)
                current--
            } else if currentVisited + 1 < grid[current].count && grid[current][currentVisited + 1] == 1 {
                queue.append(current)
                visited.append(currentVisited + 1)
                currentVisited++
            } else if currentVisited - 1 >= 0 && grid[current][currentVisited - 1] == 1 {
                queue.append(current)
                visited.append(currentVisited - 1)
                currentVisited--
            } else {
                currentCapacity--
            }
        }
        result += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var result = 0
    var visited = [Int]()
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i)
                visited.append(j)
            }
        }
    }
    while!queue.isEmpty {
        var current = queue.removeFirst()
        var currentVisited = visited.removeFirst()
        var currentCapacity = capacity
        while currentCapacity > 0 {
            if current + 1 < grid.count && grid[current + 1][currentVisited] == 1 {
                queue.append(current + 1)
                visited.append(currentVisited)
                current++
            } else if current - 1 >= 0 && grid[current - 1][currentVisited] == 1 {
                queue.append(current - 1)
                visited.append(currentVisited)
                current--
            } else if currentVisited + 1 < grid[current].count && grid[current][currentVisited + 1] == 1 {
                queue.append(current)
                visited.append(currentVisited + 1)
                currentVisited++
            } else if currentVisited - 1 >= 0 && grid[current][currentVisited - 1] == 1 {
                queue.append(current)
                visited.append(currentVisited - 1)
                currentVisited--
            } else {
                currentCapacity--
            }
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your solution here
    var result = 0
    var count = 0
    var visited = [Int]()
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                queue.append(i)
                visited.append(j)
            }
        }
    }
    while count > 0 {
        var next = queue.removeFirst()
        var nextIndex = visited.removeFirst()
        var nextCapacity = capacity
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 &&!(visited.contains(j)) {
                    if nextCapacity > 0 {
                        queue.append(i)
                        visited.append(j)
                        nextCapacity -= 1
                    } else {
                        result += 1
                        grid[i][j] = 0
                    }
                }
            }
        }
        count -= 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your solution here
    var result = 0
    var count = 0
    var visited = [Int]()
    var queue = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                queue.append(i)
                visited.append(j)
            }
        }
    }
    while count > 0 {
        var next = queue.removeFirst()
        var nextIndex = visited.removeFirst()
        var nextCapacity = capacity
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 &&!(visited.contains(j)) {
                    if nextCapacity > 0 {
                        queue.append(i)
                        visited.append(j)
                        nextCapacity -= 1
                    } else {
                        result += 1
                        grid[i][j] = 0
                    }
                }
            }
        }
        count -= 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var count = 0
    var gridCopy = grid
    var gridCopy2 = grid
    var gridCopy3 = grid
    var gridCopy4 = grid
    var gridCopy5 = grid
    var gridCopy6 = grid
    var gridCopy7 = grid
    var gridCopy8 = grid
    var gridCopy9 = grid
    var gridCopy10 = grid
    var gridCopy11 = grid
    var gridCopy12 = grid
    var gridCopy13 = grid
    var gridCopy14 = grid
    var gridCopy15 = grid
    var gridCopy16 = grid
    var gridCopy17 = grid
    var gridCopy18 = grid
    var gridCopy19 = grid
    var gridCopy20 = grid
    var gridCopy21 = grid
    var gridCopy22 = grid
    var gridCopy23 = grid
    var gridCopy24 = grid
    var gridCopy25 = grid
    var gridCopy26 = grid
    var gridCopy27 = grid
    var gridCopy28 = grid
    var gridCopy29 = grid
    var gridCopy30 = grid
    var gridCopy31 = grid
    var gridCopy32 = grid
    var gridCopy33 = grid
    var gridCopy34 = grid
    var gridCopy35 = grid
    var gridCopy36 = grid
    var gridCopy37 = grid
    var gridCopy38 = grid
    var gridCopy39 = grid
    var gridCopy40 = grid
    var gridCopy41 = grid
    var gridCopy42 = grid
    var gridCopy43 = grid
    var gridCopy44 = grid
    var gridCopy45 = grid
    var gridCopy46 = grid
    var gridCopy47 = grid
    var gridCopy48 = grid
    var gridCopy49 = grid
    var gridCopy50 = grid
    var gridCopy51 = grid
    var gridCopy52 = grid
    var gridCopy53 = grid
    var gridCopy54 = grid
    var gridCopy55 = grid
    var gridCopy56 = grid
    var gridCopy57 = grid
    var gridCopy58 = grid
    var gridCopy59 = grid
    var gridCopy60 = grid
    var gridCopy61 = grid
    var gridCopy62 = grid
    var gridCopy63 = grid
    var gridCopy64 = grid
    var gridCopy65 = grid
    var gridCopy66 = grid
    var gridCopy67 = grid
    var gridCopy68 = grid
    var gridCopy69 = grid
    var gridCopy70 = grid
    var gridCopy71 = grid
    var gridCopy72 = grid
    var gridCopy73 = grid
    var gridCopy74 = grid
    var gridCopy75 = grid
    var gridCopy76 = grid
    var gridCopy77 = grid
    var gridCopy78 = grid
    var gridCopy79 = grid
    var gridCopy80 = grid
    var gridCopy81 = grid
    var gridCopy82 = grid
    var gridCopy83 = grid
    var gridCopy84 = grid
    var gridCopy85 = grid
    var gridCopy86 = grid
    var gridCopy87 = grid
    var gridCopy88 = grid
    var gridCopy89 = grid
    var gridCopy90 = grid
    var gridCopy91 = grid
    var gridCopy92 = grid
    var gridCopy93 = grid
    var gridCopy94 = grid
    var gridCopy95 = grid
    var gridCopy96 = grid
    var gridCopy97 = grid
    var gridCopy98 = grid
    var gridCopy99 = grid
    var gridCopy100 = grid
    var gridCopy101 = grid
    var gridCopy102 = grid
    var gridCopy103 = grid
    var gridCopy104 = grid
    var gridCopy105 = grid
    var gridCopy106 = grid
    var gridCopy107 = grid
    var gridCopy108 = grid
    var gridCopy109 = grid
    var gridCopy110 = grid
    var gridCopy111 = grid
    var gridCopy112 = grid
    var gridCopy113 = grid
    var gridCopy114 = grid
    var gridCopy115 = grid
    var gridCopy116 = grid
    var gridCopy117 = grid
    var gridCopy118 = grid
    var gridCopy119 = grid
    var gridCopy120 = grid
    var gridCopy121 = grid
    var gridCopy122 = grid
    var gridCopy123 = grid
    var gridCopy124 = grid
    var gridCopy125 = grid
    var gridCopy126 = grid
    var grid

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int), Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j, 1))
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (i, j, currentCount) = queue.removeFirst()
        
        if i > 0 && grid[i-1][j] == 1 {
            let fillCount = min(currentCount, 1)
            grid[i-1][j] -= fillCount
            queue.append((i-1, j, fillCount))
        }
        
        if j > 0 && grid[i][j-1] == 1 {
            let fillCount = min(currentCount, 1)
            grid[i][j-1] -= fillCount
            queue.append((i, j-1, fillCount))
        }
        
        count += currentCount
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int), Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j, 1))
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (i, j, currentCount) = queue.removeFirst()
        
        if i > 0 && grid[i-1][j] == 1 {
            let fillCount = min(currentCount, 1)
            grid[i-1][j] -= fillCount
            queue.append((i-1, j, fillCount))
        }
        
        if j > 0 && grid[i][j-1] == 1 {
            let fillCount = min(currentCount, 1)
            grid[i][j-1] -= fillCount
            queue.append((i, j-1, fillCount))
        }
        
        count += currentCount
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int) ] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int) ] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int) ] = []

    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
            }
        }
    }

    while!queue.isEmpty {
        var nextQueue: [ (row: Int, col: Int, water: Int) ] = []

        for well in queue {
            if well.water <= capacity {
                let emptyWellRow = well.row
                let emptyWellCol = well.col - 1

                if emptyWellCol >= 0 && grid[emptyWellRow][emptyWellCol] == 1 {
                    grid[emptyWellRow][emptyWellCol] = 0
                    nextQueue.append( (row: emptyWellRow, col: emptyWellCol, water: well.water + 1) )
                }
            }
        }

        count += 1
        queue = nextQueue
    }

    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int) ] = []

    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
            }
        }
    }

    while!queue.isEmpty {
        var nextQueue: [ (row: Int, col: Int, water: Int) ] = []

        for well in queue {
            if well.water <= capacity {
                let emptyWellRow = well.row
                let emptyWellCol = well.col - 1

                if emptyWellCol >= 0 && grid[emptyWellRow][emptyWellCol] == 1 {
                    grid[emptyWellRow][emptyWellCol] = 0
                    nextQueue.append( (row: emptyWellRow, col: emptyWellCol, water: well.water + 1) )
                }
            }
        }

        count += 1
        queue = nextQueue
    }

    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (x, y) = queue.removeFirst()
        if x > 0 && grid[x-1][y] == 1 {
            grid[x-1][y] = -1
            queue.append((x-1, y))
        }
        if y > 0 && grid[x][y-1] == 1 {
            grid[x][y-1] = -1
            queue.append((x, y-1))
        }
        count += 1
        if count == capacity {
            return count
        }
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (x, y) = queue.removeFirst()
        if x > 0 && grid[x-1][y] == 1 {
            grid[x-1][y] = -1
            queue.append((x-1, y))
        }
        if y > 0 && grid[x][y-1] == 1 {
            grid[x][y-1] = -1
            queue.append((x, y-1))
        }
        count += 1
        if count == capacity {
            return count
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i * grid[i].count + j)
            }
        }
    }
    
    while!queue.isEmpty {
        let size = queue.count
        count += 1
        
        for _ in 0..<size {
            let index = queue.removeFirst()
            let row = index / grid[0].count
            let col = index % grid[0].count
            
            if row > 0 && grid[row - 1][col] == 1 {
                grid[row - 1][col] -= 1
                if grid[row - 1][col] == 0 {
                    queue.append(row * grid[0].count + col)
                }
            }
            
            if col > 0 && grid[row][col - 1] == 1 {
                grid[row][col - 1] -= 1
                if grid[row][col - 1] == 0 {
                    queue.append(row * grid[0].count + col - 1)
                }
            }
        }
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [Int] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append(i * grid[i].count + j)
            }
        }
    }
    
    while!queue.isEmpty {
        let size = queue.count
        count += 1
        
        for _ in 0..<size {
            let index = queue.removeFirst()
            let row = index / grid[0].count
            let col = index % grid[0].count
            
            if row > 0 && grid[row - 1][col] == 1 {
                grid[row - 1][col] -= 1
                if grid[row - 1][col] == 0 {
                    queue.append(row * grid[0].count + col)
                }
            }
            
            if col > 0 && grid[row][col - 1] == 1 {
                grid[row][col - 1] -= 1
                if grid[row][col - 1] == 0 {
                    queue.append(row * grid[0].count + col - 1)
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int)] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
            if col < cols - 1 && grid[row][col+1] == 1 {
                grid[row][col+1] = 0
                queue.append( (row: row, col: col+1, water: water+1) )
            }
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if row < rows - 1 && grid[row+1][col] == 1 {
                grid[row+1][col] = 0
                queue.append( (row: row+1, col: col, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int)] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
            if col < cols - 1 && grid[row][col+1] == 1 {
                grid[row][col+1] = 0
                queue.append( (row: row, col: col+1, water: water+1) )
            }
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if row < rows - 1 && grid[row+1][col] == 1 {
                grid[row+1][col] = 0
                queue.append( (row: row+1, col: col, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int)] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (row: Int, col: Int, water: Int)] = []
    let rows = grid.count
    let cols = grid[0].count
    
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                queue.append( (row: i, col: j, water: 1) )
                grid[i][j] = 0
            }
        }
    }
    
    while!queue.isEmpty {
        let (row, col, water) = queue.removeFirst()
        if water <= capacity {
            if row > 0 && grid[row-1][col] == 1 {
                grid[row-1][col] = 0
                queue.append( (row: row-1, col: col, water: water+1) )
            }
            if col > 0 && grid[row][col-1] == 1 {
                grid[row][col-1] = 0
                queue.append( (row: row, col: col-1, water: water+1) )
            }
        }
        count += 1
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}

<|im_start|>system
You are a helpful assistant.<|im_end|>
<|im_start|>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<|im_end|>
<|im_start|>assistant
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var queue: [ (Int, Int)] = []
    
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                queue.append((i, j))
                grid[i][j] = -1
            }
        }
    }
    
    while!queue.isEmpty {
        let (r, c) = queue.removeFirst()
        if r > 0 && grid[r-1][c] == 1 {
            grid[r-1][c] = -1
            queue.append((r-1, c))
            count += 1
            if count == capacity {
                return count
            }
        }
        if c > 0 && grid[r][c-1] == 1 {
            grid[r][c-1] = -1
            queue.append((r, c-1))
            count += 1
            if count == capacity {
                return count
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        var current = 0
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
            if current > result {
                result = current
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        var current = 0
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
            if current > result {
                result = current
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            result += 1
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            result += 1
        }
    }
    return result
}
```
### Description

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var current = 0
        for well in row {
            if well == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
        }
        result = max(result, current)
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var current = 0
        for well in row {
            if well == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
        }
        result = max(result, current)
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
            if currentCapacity == 0 {
                result += 1
                break
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
            if currentCapacity == 0 {
                result += 1
                break
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
            if currentCapacity == 0 {
                result += 1
                break
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
            }
            if currentCapacity == 0 {
                result += 1
                break
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var current = 0
        for element in row {
            if element == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
        }
        result = max(result, current)
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var current = 0
        for element in row {
            if element == 1 {
                current += 1
            }
            if current > capacity {
                break
            }
        }
        result = max(result, current)
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}
```
### Problem

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                result += 1
            }
        }
    }
    return result
}
```
### Inst

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int](repeating: 0, count: grid.count)
    var maxBucket = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                buckets[i] += 1
                maxBucket = max(maxBucket, buckets[i])
            }
        }
    }
    return count - maxBucket
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int](repeating: 0, count: grid.count)
    var maxBucket = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                buckets[i] += 1
                maxBucket = max(maxBucket, buckets[i])
            }
        }
    }
    return count - maxBucket
}
```
### Link

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = 0
    var currentRow = 0
    var currentColumn = 0
    var isRowFinished = false
    var isColumnFinished = false
    var isGridFinished = false
    var isBucketFinished = false
    var isGridEmpty = false
    
    while !isGridFinished {
        if !isRowFinished {
            if grid[currentRow][currentColumn] == 1 {
                currentCapacity += 1
            }
            if currentColumn == grid[currentRow].count - 1 {
                isRowFinished = true
            } else {
                currentColumn += 1
            }
        }
        if isRowFinished {
            if currentCapacity > capacity {
                result += 1
                currentCapacity = 0
            }
            if currentRow == grid.count - 1 {
                isGridFinished = true
            } else {
                currentRow += 1
                currentColumn = 0
                isRowFinished = false
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = 0
    var currentRow = 0
    var currentColumn = 0
    var isRowFinished = false
    var isColumnFinished = false
    var isGridFinished = false
    var isBucketFinished = false
    var isGridEmpty = false
    
    while !isGridFinished {
        if !isRowFinished {
            if grid[currentRow][currentColumn] == 1 {
                currentCapacity += 1
            }
            if currentColumn == grid[currentRow].count - 1 {
                isRowFinished = true
            } else {
                currentColumn += 1
            }
        }
        if isRowFinished {
            if currentCapacity > capacity {
                result += 1
                currentCapacity = 0
            }
            if currentRow == grid.count - 1 {
                isGridFinished = true
            } else {
                currentRow += 1
                currentColumn = 0
                isRowFinished = false
            }
        }
    }
    return result
}
```
### Test

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for i in 0..<grid.count {
        var sum = 0
        for j in 0..<grid[i].count {
            sum += grid[i][j]
        }
        if sum > capacity {
            count += 1
            max = max > count ? max : count
            count = 0
        }
    }
    return max
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for i in 0..<grid.count {
        var sum = 0
        for j in 0..<grid[i].count {
            sum += grid[i][j]
        }
        if sum > capacity {
            count += 1
            max = max > count ? max : count
            count = 0
        }
    }
    return max
}
```
### Test

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = 0
    var maxBuckets = 0
    for row in grid {
        var rowBuckets = 0
        var rowMaxBuckets = 0
        for cell in row {
            if cell == 1 {
                rowBuckets += 1
                rowMaxBuckets += 1
            } else {
                rowMaxBuckets += 1
            }
            if rowBuckets > capacity {
                result += 1
                rowBuckets = 0
            }
            if rowMaxBuckets > maxBuckets {
                maxBuckets = rowMaxBuckets
            }
        }
        buckets += rowBuckets
        if buckets > capacity {
            result += 1
            buckets = 0
        }
    }
    if buckets > 0 {
        result += 1
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = 0
    var maxBuckets = 0
    for row in grid {
        var rowBuckets = 0
        var rowMaxBuckets = 0
        for cell in row {
            if cell == 1 {
                rowBuckets += 1
                rowMaxBuckets += 1
            } else {
                rowMaxBuckets += 1
            }
            if rowBuckets > capacity {
                result += 1
                rowBuckets = 0
            }
            if rowMaxBuckets > maxBuckets {
                maxBuckets = rowMaxBuckets
            }
        }
        buckets += rowBuckets
        if buckets > capacity {
            result += 1
            buckets = 0
        }
    }
    if buckets > 0 {
        result += 1
    }
    return result
}
```
### Link

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for i in 0..<grid.count {
        var sum = 0
        for j in 0..<grid[i].count {
            sum += grid[i][j]
        }
        if sum > capacity {
            count += 1
            max = max > count ? max : count
            count = 0
        }
    }
    return max
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var max = 0
    var count = 0
    for i in 0..<grid.count {
        var sum = 0
        for j in 0..<grid[i].count {
            sum += grid[i][j]
        }
        if sum > capacity {
            count += 1
            max = max > count ? max : count
            count = 0
        }
    }
    return max
}
```
### Test

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        var currentFill = 0
        for unit in row {
            if unit == 1 {
                currentFill += 1
            }
            if currentFill > capacity {
                maxFill += 1
                currentFill = 0
            }
        }
    }
    return maxFill
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    for row in grid {
        var currentFill = 0
        for unit in row {
            if unit == 1 {
                currentFill += 1
            }
            if currentFill > capacity {
                maxFill += 1
                currentFill = 0
            }
        }
    }
    return maxFill
}
```
### Test

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = capacity
    var wells = grid
    while !wells.isEmpty {
        var row = wells.removeFirst()
        var bucket = buckets
        var count = 0
        while !row.isEmpty {
            let well = row.removeFirst()
            if well == 1 {
                bucket -= 1
                count += 1
            }
            if bucket == 0 {
                buckets = capacity
                result += count
                count = 0
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = capacity
    var wells = grid
    while !wells.isEmpty {
        var row = wells.removeFirst()
        var bucket = buckets
        var count = 0
        while !row.isEmpty {
            let well = row.removeFirst()
            if well == 1 {
                bucket -= 1
                count += 1
            }
            if bucket == 0 {
                buckets = capacity
                result += count
                count = 0
            }
        }
    }
    return result
}
```
### Link

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentRow = 0
    var currentColumn = 0
    var currentCapacity = capacity
    var currentRowLength = grid[currentRow].count
    var currentColumnLength = grid.count
    var currentRowValue = grid[currentRow][currentColumn]
    var currentColumnValue = grid[currentColumn][currentColumn]
    var currentRowValueCount = 0
    var currentColumnValueCount = 0
    var currentRowValueCountMax = 0
    var currentColumnValueCountMax = 0
    var currentRowValueCountMaxIndex = 0
    var currentColumnValueCountMaxIndex = 0
    var currentRowValueCountMaxIndexMax = 0
    var currentColumnValueCountMaxIndexMax = 0
    var currentRowValueCountMaxIndexMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentRowValueCountMaxIndexMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMaxMax = 0
    var currentColumnValue

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = 0
    var maxBuckets = 0
    var maxRow = 0
    var maxCol = 0
    var maxRowCount = 0
    var maxColCount = 0
    var rowCount = 0
    var colCount = 0
    var row = 0
    var col = 0
    var rowIndex = 0
    var colIndex = 0
    var rowCountIndex = 0
    var colCountIndex = 0
    var rowIndexIndex = 0
    var colIndexIndex = 0
    var rowCountIndexIndex = 0
    var colCountIndexIndex = 0
    var rowIndexIndexIndex = 0
    var colIndexIndexIndex = 0
    var rowCountIndexIndexIndex = 0
    var colCountIndexIndexIndex = 0
    var rowIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var colCountIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndexIndex = 0
    var rowIndex

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var currentFill = 0
    var currentRow = 0
    var currentColumn = 0
    var isLastRow = false
    var isLastColumn = false
    var isLastRowColumn = false
    var isLastRowLastColumn = false
    var isLastColumnLastRow = false
    var isLastColumnLastRowColumn = false
    var isLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowColumn = false
    var isLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumn = false
    var isLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRow = false
    var isLastColumnLastRowLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLastColumnLastRowLast

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    while currentRow < grid.count {
        var currentColumn = 0
        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
                currentCapacity -= 1
            }
            currentColumn += 1
        }
        currentRow += 1
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    while currentRow < grid.count {
        var currentColumn = 0
        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
                currentCapacity -= 1
            }
            currentColumn += 1
        }
        currentRow += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity - 1
                }
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity - 1
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for cell in row {
            if cell == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            }
        }
        if currentCapacity < capacity {
            currentCapacity = capacity
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for cell in row {
            if cell == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            }
        }
        if currentCapacity < capacity {
            currentCapacity = capacity
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    var currentRowLength = grid[currentRow].count
    var currentRowValue = grid[currentRow][currentColumn]
    
    while currentRow < grid.count {
        while currentColumn < currentRowLength {
            if currentCapacity > 0 {
                if currentRowValue == 1 {
                    currentCapacity -= 1
                }
                currentColumn += 1
                if currentColumn < currentRowLength {
                    currentRowValue = grid[currentRow][currentColumn]
                }
            } else {
                result += 1
                currentCapacity = capacity
                currentRow += 1
                currentColumn = 0
                currentRowLength = grid[currentRow].count
                currentRowValue = grid[currentRow][currentColumn]
            }
        }
        currentColumn = 0
        currentRow += 1
        currentRowLength = grid[currentRow].count
        currentRowValue = grid[currentRow][currentColumn]
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    var currentRowLength = grid[currentRow].count
    var currentRowValue = grid[currentRow][currentColumn]
    
    while currentRow < grid.count {
        while currentColumn < currentRowLength {
            if currentCapacity > 0 {
                if currentRowValue == 1 {
                    currentCapacity -= 1
                }
                currentColumn += 1
                if currentColumn < currentRowLength {
                    currentRowValue = grid[currentRow][currentColumn]
                }
            } else {
                result += 1
                currentCapacity = capacity
                currentRow += 1
                currentColumn = 0
                currentRowLength = grid[currentRow].count
                currentRowValue = grid[currentRow][currentColumn]
            }
        }
        currentColumn = 0
        currentRow += 1
        currentRowLength = grid[currentRow].count
        currentRowValue = grid[currentRow][currentColumn]
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity - 1
                }
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity - 1
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            } else if element == 0 {
                currentCapacity = capacity
            }
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for element in row {
            if element == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            } else if element == 0 {
                currentCapacity = capacity
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    var currentValue = 0
    var isFilled = false

    while currentRow < grid.count {
        currentColumn = 0
        currentValue = 0
        isFilled = false

        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                currentValue += 1
            }

            currentColumn += 1
        }

        if currentValue > currentCapacity {
            result += currentCapacity
            currentRow += 1
            continue
        }

        if currentValue > 0 {
            result += currentValue
            isFilled = true
        }

        if isFilled {
            currentRow += 1
            currentCapacity = capacity
        } else {
            currentCapacity -= currentValue
        }
    }

    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    var currentValue = 0
    var isFilled = false

    while currentRow < grid.count {
        currentColumn = 0
        currentValue = 0
        isFilled = false

        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                currentValue += 1
            }

            currentColumn += 1
        }

        if currentValue > currentCapacity {
            result += currentCapacity
            currentRow += 1
            continue
        }

        if currentValue > 0 {
            result += currentValue
            isFilled = true
        }

        if isFilled {
            currentRow += 1
            currentCapacity = capacity
        } else {
            currentCapacity -= currentValue
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var row = 0
    while row < grid.count && currentCapacity > 0 {
        var column = 0
        while column < grid[row].count && currentCapacity > 0 {
            if grid[row][column] == 1 {
                currentCapacity -= 1
            }
            column += 1
        }
        if currentCapacity > 0 {
            result += 1
        }
        currentCapacity = capacity
        row += 1
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var row = 0
    while row < grid.count && currentCapacity > 0 {
        var column = 0
        while column < grid[row].count && currentCapacity > 0 {
            if grid[row][column] == 1 {
                currentCapacity -= 1
            }
            column += 1
        }
        if currentCapacity > 0 {
            result += 1
        }
        currentCapacity = capacity
        row += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    while currentRow < grid.count {
        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity
                }
            }
            currentColumn += 1
        }
        currentColumn = 0
        currentRow += 1
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    while currentRow < grid.count {
        while currentColumn < grid[currentRow].count {
            if grid[currentRow][currentColumn] == 1 {
                if currentCapacity > 0 {
                    currentCapacity -= 1
                } else {
                    result += 1
                    currentCapacity = capacity
                }
            }
            currentColumn += 1
        }
        currentColumn = 0
        currentRow += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    while currentRow < grid.count && currentColumn < grid[currentRow].count {
        if grid[currentRow][currentColumn] == 1 {
            if currentCapacity > 0 {
                currentCapacity -= 1
                result += 1
            } else {
                currentCapacity = capacity
                result += 1
            }
        }
        currentColumn += 1
        if currentColumn == grid[currentRow].count {
            currentColumn = 0
            currentRow += 1
        }
    }
    return result
}

### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    var currentRow = 0
    var currentColumn = 0
    while currentRow < grid.count && currentColumn < grid[currentRow].count {
        if grid[currentRow][currentColumn] == 1 {
            if currentCapacity > 0 {
                currentCapacity -= 1
                result += 1
            } else {
                currentCapacity = capacity
                result += 1
            }
        }
        currentColumn += 1
        if currentColumn == grid[currentRow].count {
            currentColumn = 0
            currentRow += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for col in row {
            if col == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for col in row {
            if col == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for col in row {
            if col == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for col in row {
            if col == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // your code goes here
    return 0
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // your code goes here
    return 0
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        for cell in row {
            if cell == 1 {
                count += capacity
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        for cell in row {
            if cell == 1 {
                count += capacity
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var total = 0
    for row in grid {
        var count = 0
        for cell in row {
            if cell == 1 {
                count += 1
            }
        }
        total += count / capacity
        if count % capacity != 0 {
            total += 1
        }
    }
    return total
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        var bucket = capacity
        for cell in row {
            if cell == 1 && bucket > 0 {
                bucket -= 1
            } else if cell == 1 && bucket == 0 {
                bucket = capacity
                count += 1
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    for row in grid {
        var bucket = capacity
        for cell in row {
            if cell == 1 && bucket > 0 {
                bucket -= 1
            } else if cell == 1 && bucket == 0 {
                bucket = capacity
                count += 1
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        buckets.append(capacity)
    }
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                if buckets[i] > 0 {
                    buckets[i] -= 1
                } else {
                    count += 1
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        buckets.append(capacity)
    }
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                if buckets[i] > 0 {
                    buckets[i] -= 1
                } else {
                    count += 1
                }
            }
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var temp = buckets
        buckets = [Int]()
        for i in 0..<temp.count {
            if temp[i] > 0 {
                buckets.append(temp[i] - 1)
            }
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var temp = buckets
        buckets = [Int]()
        for i in 0..<temp.count {
            if temp[i] > 0 {
                buckets.append(temp[i] - 1)
            }
        }
        count += 1
    }
    return count
}

// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var temp = buckets
        buckets = [Int]()
        for i in 0..<temp.count {
            if temp[i] > 0 {
                buckets.append(temp[i] - 1)
            }
        }
        count += 1
    }
    return count
}

// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    var i = 0
    while i < buckets.count {
        if buckets[i] > 0 {
            buckets[i] -= 1
            i += 1
        } else {
            count += 1
            buckets[i] = capacity
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    var i = 0
    while i < buckets.count {
        if buckets[i] > 0 {
            buckets[i] -= 1
            i += 1
        } else {
            count += 1
            buckets[i] = capacity
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: 0, count: grid.count)
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] += capacity
            }
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] > 0 {
            result += buckets[i] / capacity
            buckets[i] %= capacity
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: 0, count: grid.count)
    var result = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] += capacity
            }
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] > 0 {
            result += buckets[i] / capacity
            buckets[i] %= capacity
        }
    }
    return result
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var result = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
            }
        }
        result += buckets.max()!
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var result = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
            }
        }
        result += buckets.max()!
    }
    return result
}<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for (i, well) in row.enumerated() {
            if well == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for (i, well) in row.enumerated() {
            if well == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if i == buckets.count - 1 {
                newBuckets.append(buckets[i] - buckets[i - 1])
            } else if i == 0 {
                newBuckets.append(buckets[i + 1] - buckets[i])
            } else {
                newBuckets.append(buckets[i + 1] - buckets[i - 1])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if i == buckets.count - 1 {
                newBuckets.append(buckets[i] - buckets[i - 1])
            } else if i == 0 {
                newBuckets.append(buckets[i + 1] - buckets[i])
            } else {
                newBuckets.append(buckets[i + 1] - buckets[i - 1])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        var sum = 0
        for i in row {
            sum += i
        }
        if sum > 0 {
            count += sum - buckets.max()!
            buckets = buckets.map { $0 - sum }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        var sum = 0
        for i in row {
            sum += i
        }
        if sum > 0 {
            count += sum - buckets.max()!
            buckets = buckets.map { $0 - sum }
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var newBuckets = [Int]()
        for i in 0..<buckets.count {
            if buckets[i] > 0 {
                buckets[i] -= 1
                newBuckets.append(buckets[i])
            }
        }
        buckets = newBuckets
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for bucket in row {
            buckets.append(bucket)
        }
    }
    var count = 0
    var i = 0
    while i < buckets.count {
        var j = i
        while j < buckets.count {
            if buckets[i] == buckets[j] {
                buckets[i] = buckets[i] + buckets[j]
                buckets[j] = 0
            }
            j += 1
        }
        i += 1
    }
    for bucket in buckets {
        if bucket != 0 {
            count += 1
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for bucket in row {
            buckets.append(bucket)
        }
    }
    var count = 0
    var i = 0
    while i < buckets.count {
        var j = i
        while j < buckets.count {
            if buckets[i] == buckets[j] {
                buckets[i] = buckets[i] + buckets[j]
                buckets[j] = 0
            }
            j += 1
        }
        i += 1
    }
    for bucket in buckets {
        if bucket != 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] += 1
            }
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] > capacity {
            count += buckets[i] - capacity
            buckets[i] = capacity
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] += 1
            }
        }
    }
    for i in 0..<buckets.count {
        if buckets[i] > capacity {
            count += buckets[i] - capacity
            buckets[i] = capacity
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var min = buckets[0]
        for bucket in buckets {
            if bucket < min {
                min = bucket
            }
        }
        for i in 0..<buckets.count {
            if buckets[i] == min {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    buckets.remove(at: i)
                }
            }
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var min = buckets[0]
        for bucket in buckets {
            if bucket < min {
                min = bucket
            }
        }
        for i in 0..<buckets.count {
            if buckets[i] == min {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    buckets.remove(at: i)
                }
            }
        }
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: capacity, count: grid.count)
    var count = 0
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    count += abs(buckets[i])
                    buckets[i] = 0
                }
            }
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: capacity, count: grid.count)
    var total = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                total += 1
            }
        }
    }
    return total
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
    var buckets = Array(repeating: capacity, count: grid.count)
    var total = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                total += 1
            }
        }
    }
    return total
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] += capacity
            }
        }
        if buckets[i] > 0 {
            count += 1
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var count = 0
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets[i] += capacity
            }
        }
        if buckets[i] > 0 {
            count += 1
        }
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var temp = buckets
        buckets = [Int]()
        for i in 0..<temp.count {
            if temp[i] > 0 {
                buckets.append(temp[i] - 1)
            }
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 1 {
        var temp = buckets
        buckets = [Int]()
        for i in 0..<temp.count {
            if temp[i] > 0 {
                buckets.append(temp[i] - 1)
            }
        }
        count += 1
    }
    return count
}<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var min = buckets[0]
        var index = 0
        for i in 1..<buckets.count {
            if buckets[i] < min {
                min = buckets[i]
                index = i
            }
        }
        buckets[index] -= 1
        if buckets[index] == 0 {
            buckets.remove(at: index)
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    for row in grid {
        for well in row {
            if well == 1 {
                buckets.append(capacity)
            }
        }
    }
    var count = 0
    while buckets.count > 0 {
        var min = buckets[0]
        var index = 0
        for i in 1..<buckets.count {
            if buckets[i] < min {
                min = buckets[i]
                index = i
            }
        }
        buckets[index] -= 1
        if buckets[index] == 0 {
            buckets.remove(at: index)
        }
        count += 1
    }
    return count
}
<|file_separator|>

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var maxFill = 0
    
    for i in 0..<rows {
        var currentFill = 0
        for j in 0..<cols {
            currentFill += grid[i][j]
        }
        maxFill += min(currentFill, capacity)
    }
    
    return maxFill
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var maxFill = 0
    
    for i in 0..<rows {
        var currentFill = 0
        for j in 0..<cols {
            currentFill += grid[i][j]
        }
        maxFill += min(currentFill, capacity)
    }
    
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    var j = 0
    while i < grid.count && j < grid[0].count {
        if grid[i][j] == 1 {
            if capacity > 0 {
                grid[i][j] = 0
                capacity -= 1
                result += 1
            } else {
                i += 1
                capacity = capacity
            }
        } else {
            j += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    var j = 0
    while i < grid.count && j < grid[0].count {
        if grid[i][j] == 1 {
            if capacity > 0 {
                grid[i][j] = 0
                capacity -= 1
                result += 1
            } else {
                i += 1
                capacity = capacity
            }
        } else {
            j += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var res = 0
    var buckets = Array(repeating: 0, count: m)
    for i in stride(from: n - 1, to: -1, by: -1) {
        for j in stride(from: m - 1, to: -1, by: -1) {
            if grid[i][j] == 1 {
                buckets[j] += 1
            }
        }
        for j in stride(from: m - 1, to: -1, by: -1) {
            if buckets[j] >= capacity {
                buckets[j] -= capacity
                res += capacity
            } else {
                res += buckets[j]
                buckets[j] = 0
            }
        }
    }
    return res
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var res = 0
    var buckets = Array(repeating: 0, count: m)
    for i in stride(from: n - 1, to: -1, by: -1) {
        for j in stride(from: m - 1, to: -1, by: -1) {
            if grid[i][j] == 1 {
                buckets[j] += 1
            }
        }
        for j in stride(from: m - 1, to: -1, by: -1) {
            if buckets[j] >= capacity {
                buckets[j] -= capacity
                res += capacity
            } else {
                res += buckets[j]
                buckets[j] = 0
            }
        }
    }
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let columns = grid[0].count
    
    var result = 0
    var buckets = [Int](repeating: 0, count: columns)
    var wells = grid
    
    while true {
        var isDone = true
        for j in 0..<columns {
            if buckets[j] < capacity {
                var i = rows - 1
                while i >= 0 {
                    if wells[i][j] == 1 {
                        buckets[j] += 1
                        wells[i][j] = 0
                        break
                    }
                    i -= 1
                }
                if i >= 0 {
                    isDone = false
                }
            }
        }
        if isDone {
            break
        }
        result += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let columns = grid[0].count
    
    var result = 0
    var buckets = [Int](repeating: 0, count: columns)
    var wells = grid
    
    while true {
        var isDone = true
        for j in 0..<columns {
            if buckets[j] < capacity {
                var i = rows - 1
                while i >= 0 {
                    if wells[i][j] == 1 {
                        buckets[j] += 1
                        wells[i][j] = 0
                        break
                    }
                    i -= 1
                }
                if i >= 0 {
                    isDone = false
                }
            }
        }
        if isDone {
            break
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    var j = 0
    while i < grid.count {
        j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                result += capacity
                grid[i][j] = 0
                j += 1
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    var j = 0
    while i < grid.count {
        j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                result += capacity
                grid[i][j] = 0
                j += 1
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var row = 0
    var col = 0
    while row < grid.count && col < grid[0].count {
        if grid[row][col] == 1 {
            var count = 0
            while row < grid.count && grid[row][col] == 1 {
                count += 1
                row += 1
            }
            result += count / capacity
            if count % capacity == 0 {
                col += 1
            }
        } else {
            col += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var row = 0
    var col = 0
    while row < grid.count && col < grid[0].count {
        if grid[row][col] == 1 {
            var count = 0
            while row < grid.count && grid[row][col] == 1 {
                count += 1
                row += 1
            }
            result += count / capacity
            if count % capacity == 0 {
                col += 1
            }
        } else {
            col += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var res = 0
    var buckets = [Int](repeating: 0, count: m)
    var wells = [Int](repeating: 0, count: m)
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] += 1
            }
        }
    }
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                if buckets[j] == 0 {
                    res += 1
                    buckets[j] = capacity
                }
                buckets[j] -= 1
            }
        }
    }
    return res
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var res = 0
    var buckets = [Int](repeating: 0, count: m)
    var wells = [Int](repeating: 0, count: m)
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] += 1
            }
        }
    }
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                if buckets[j] == 0 {
                    res += 1
                    buckets[j] = capacity
                }
                buckets[j] -= 1
            }
        }
    }
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if capacity >= grid[i].count - j {
                    result += grid[i].count - j
                    capacity -= grid[i].count - j
                    grid[i].removeSubrange(j ..< grid[i].count)
                } else {
                    result += capacity
                    grid[i].removeSubrange(j ..< j + capacity)
                    capacity = 0
                }
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var capacity = capacity
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if capacity >= grid[i].count - j {
                    result += grid[i].count - j
                    capacity -= grid[i].count - j
                    grid[i].removeSubrange(j ..< grid[i].count)
                } else {
                    result += capacity
                    grid[i].removeSubrange(j ..< j + capacity)
                    capacity = 0
                }
            } else {
                j += 1
            }
        }
        i += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * m
    var result: Int = 0
    for i in 0..<n {
        var max: Int = 0
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] = capacity
                max = max.max(buckets[j])
            } else {
                buckets[j] = buckets[j].max(0)
                if buckets[j] >= max {
                    buckets[j] = buckets[j] - max
                    max = 0
                } else {
                    max = max - buckets[j]
                    buckets[j] = 0
                }
            }
        }
        result += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * m
    var result: Int = 0
    for i in 0..<n {
        var max: Int = 0
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] = capacity
                max = max.max(buckets[j])
            } else {
                buckets[j] = buckets[j].max(0)
                if buckets[j] >= max {
                    buckets[j] = buckets[j] - max
                    max = 0
                } else {
                    max = max - buckets[j]
                    buckets[j] = 0
                }
            }
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = [0..n]
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] += 1
            }
        }
    }
    var count = 0
    while buckets.any {
        let max = buckets.max!
        if max <= capacity {
            break
        }
        for i in 0..<n {
            if buckets[i] == max {
                buckets[i] -= max
                buckets[i+1] += max
                count += 1
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = [0..n]
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] += 1
            }
        }
    }
    var count = 0
    while buckets.any {
        let max = buckets.max!
        if max <= capacity {
            break
        }
        for i in 0..<n {
            if buckets[i] == max {
                buckets[i] -= max
                buckets[i+1] += max
                count += 1
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * n
    var times: Int = 0
    for i in 0..<n {
        var max_bucket: Int = 0
        for j in 0..<m {
            if grid[i][j] == 1 {
                max_bucket = max(max_bucket, buckets[i])
            }
        }
        if max_bucket + capacity > 0 {
            times += 1
            buckets[i] = max_bucket + capacity
        }
    }
    return times
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * n
    var times: Int = 0
    for i in 0..<n {
        var max_bucket: Int = 0
        for j in 0..<m {
            if grid[i][j] == 1 {
                max_bucket = max(max_bucket, buckets[i])
            }
        }
        if max_bucket + capacity > 0 {
            times += 1
            buckets[i] = max_bucket + capacity
        }
    }
    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = Array(n).map { _ in capacity }
    var count = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                var minBucket = buckets.min()!
                buckets[i] -= minBucket
                buckets[j] -= minBucket
                count += minBucket
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = Array(n).map { _ in capacity }
    var count = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                var minBucket = buckets.min()!
                buckets[i] -= minBucket
                buckets[j] -= minBucket
                count += minBucket
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let mut buckets = Array(n).map { _ in 0..n }
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] = j
                break
            }
        }
    }
    let mut count = 0
    for i in 0..<n {
        let mut j = buckets[i]
        while j < m && grid[i][j] == 1 {
            j += 1
        }
        count += j - buckets[i]
        buckets[i] = j
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let mut buckets = Array(n).map { _ in 0..n }
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] = j
                break
            }
        }
    }
    let mut count = 0
    for i in 0..<n {
        let mut j = buckets[i]
        while j < m && grid[i][j] == 1 {
            j += 1
        }
        count += j - buckets[i]
        buckets[i] = j
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * n
    var result = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] += 1
            }
        }
    }
    for i in 0..<n {
        if buckets[i] > capacity {
            result += buckets[i] - capacity
            buckets[i] = capacity
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets: [Int] = [0] * n
    var result = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] += 1
            }
        }
    }
    for i in 0..<n {
        if buckets[i] > capacity {
            result += buckets[i] - capacity
            buckets[i] = capacity
        }
    }
    return result
}

// Test cases
print(maxFill([[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], 1)) // 6
print(maxFill([[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], 2)) // 5
print(maxFill([[0, 0, 0], [0, 0, 0]], 5)) // 0
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = Array(n).map { _ in capacity }
    var res = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    buckets[i] = capacity
                    res += 1
                }
            }
        }
    }
    return res
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    var buckets = Array(n).map { _ in capacity }
    var res = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[i] -= 1
                if buckets[i] < 0 {
                    buckets[i] = capacity
                    res += 1
                }
            }
        }
    }
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let mut buckets = [0; m]
    let mut count = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] = capacity
            } else {
                let mut min_bucket = capacity
                for k in 0..<m {
                    if buckets[k] < min_bucket {
                        min_bucket = buckets[k]
                    }
                }
                buckets[j] -= min_bucket
                if buckets[j] == 0 {
                    count += 1
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let mut buckets = [0; m]
    let mut count = 0
    for i in 0..<n {
        for j in 0..<m {
            if grid[i][j] == 1 {
                buckets[j] = capacity
            } else {
                let mut min_bucket = capacity
                for k in 0..<m {
                    if buckets[k] < min_bucket {
                        min_bucket = buckets[k]
                    }
                }
                buckets[j] -= min_bucket
                if buckets[j] == 0 {
                    count += 1
                }
            }
        }
    }
    return count
}
```

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let buckets = Array(n).map { _ in capacity }
    let wells = Array(n).map { i in grid[i].map { it == 1 } }
    let wells_filled = Array(n).map { _ in false }
    let buckets_filled = Array(n).map { _ in false }
    let mut count = 0
    while !wells_filled.all {
        for i in 0..<n {
            if !wells_filled[i] && !buckets_filled[i] {
                let mut j = 0
                while j < m && !wells[i][j] {
                    j += 1
                }
                if j < m {
                    wells_filled[i] = true
                    buckets[i] -= 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] {
                let mut j = m - 1
                while j >= 0 && !wells[i][j] {
                    j -= 1
                }
                if j >= 0 {
                    wells_filled[i] = true
                    buckets[i] += 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] && buckets[i] > 0 {
                let mut j = 0
                while j < m && wells[i][j] {
                    j += 1
                }
                if j < m {
                    wells_filled[i] = true
                    buckets[i] -= 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] && buckets[i] > 0 {
                let mut j = m - 1
                while j >= 0 && wells[i][j] {
                    j -= 1
                }
                if j >= 0 {
                    wells_filled[i] = true
                    buckets[i] += 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] {
                let mut j = 0
                while j < m && !wells[i][j] {
                    j += 1
                }
                if j < m {
                    wells_filled[i] = true
                    buckets[i] -= 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] && buckets[i] > 0 {
                let mut j = m - 1
                while j >= 0 && !wells[i][j] {
                    j -= 1
                }
                if j >= 0 {
                    wells_filled[i] = true
                    buckets[i] += 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] && buckets[i] > 0 {
                let mut j = 0
                while j < m && wells[i][j] {
                    j += 1
                }
                if j < m {
                    wells_filled[i] = true
                    buckets[i] -= 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] {
                let mut j = m - 1
                while j >= 0 && wells[i][j] {
                    j -= 1
                }
                if j >= 0 {
                    wells_filled[i] = true
                    buckets[i] += 1
                    count += 1
                }
            }
        }
        for i in 0..<n {
            if !buckets_filled[i] && buckets[i] > 0 {
                let mut j = 0
                while j < m && !wells[i][j] {
                    j += 1
                }
                if j < m {
                    wells_filled[i] = true
                    buckets[i] -= 1
                    count += 1
                }
            }
        }
        for i in 0..<

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let n = grid.count
    let m = grid[0].count
    let buckets = Array(n).map { _ in capacity }
    let wells = Array(n).map { i in grid[i].map { it == 1 } }
    let wells_count = Array(n).map { i in grid[i].count { it == 1 } }
    let wells_index = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min_max_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min_max_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max_min_max_min_max = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_min_max_min_max_min_max_min_max_min = Array(n).map { i in grid[i].mapIndexed { index, it in if it == 1 { index } else { -1 } } }
    let wells_index_max_min_max_min_max_min_max_min_max_min = Array(n).

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rowLength = grid.count
    let colLength = grid[0].count
    
    var result = 0
    
    for row in 0..<rowLength {
        for col in 0..<colLength {
            if grid[row][col] == 1 {
                result += 1
                
                for i in row..<rowLength {
                    for j in col..<colLength {
                        if grid[i][j] == 1 {
                            grid[i][j] = 0
                        }
                    }
                }
                
                for i in stride(from: row, to: rowLength, by: capacity) {
                    for j in stride(from: col, to: colLength, by: capacity) {
                        if grid[i][j] == 1 {
                            grid[i][j] = 0
                        }
                    }
                }
            }
        }
    }
    
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rowLength = grid.count
    let colLength = grid[0].count
    
    var result = 0
    
    for row in 0..<rowLength {
        for col in 0..<colLength {
            if grid[row][col] == 1 {
                result += 1
                
                for i in row..<rowLength {
                    for j in col..<colLength {
                        if grid[i][j] == 1 {
                            grid[i][j] = 0
                        }
                    }
                }
                
                for i in stride(from: row, to: rowLength, by: capacity) {
                    for j in stride(from: col, to: colLength, by: capacity) {
                        if grid[i][j] == 1 {
                            grid[i][j] = 0
                        }
                    }
                }
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let row = grid.count
    let column = grid[0].count
    var times = 0
    var sum = 0
    for i in 0..<row {
        for j in 0..<column {
            if grid[i][j] == 1 {
                if sum < capacity {
                    sum += 1
                } else {
                    times += 1
                    sum = 0
                }
            }
        }
    }
    if sum != 0 {
        times += 1
    }
    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let row = grid.count
    let column = grid[0].count
    var times = 0
    var sum = 0
    for i in 0..<row {
        for j in 0..<column {
            if grid[i][j] == 1 {
                if sum < capacity {
                    sum += 1
                } else {
                    times += 1
                    sum = 0
                }
            }
        }
    }
    if sum != 0 {
        times += 1
    }
    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var water = 0
    var times = 0
    var left = Array(repeating: 0, count: width)
    var right = Array(repeating: width - 1, count: width)
    for i in 0..<height {
        for j in 0..<width {
            if grid[i][j] == 1 {
                water += 1
                left[j] = max(left[j], j + 1)
                right[j] = min(right[j], j - 1)
            }
        }
        for j in left..<right {
            times += min(capacity, water)
            water -= (right[j] - left[j] + 1)
        }
    }
    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var water = 0
    var times = 0
    var left = Array(repeating: 0, count: width)
    var right = Array(repeating: width - 1, count: width)
    for i in 0..<height {
        for j in 0..<width {
            if grid[i][j] == 1 {
                water += 1
                left[j] = max(left[j], j + 1)
                right[j] = min(right[j], j - 1)
            }
        }
        for j in left..<right {
            times += min(capacity, water)
            water -= (right[j] - left[j] + 1)
        }
    }
    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = 0
    
    for i in stride(from: 0, to: m, by: 1) {
        for j in stride(from: 0, to: n, by: 1) {
            if grid[i][j] == 1 {
                water += 1
            }
        }
    }
    
    for i in stride(from: 0, to: m, by: 1) {
        for j in stride(from: 0, to: n, by: 1) {
            if grid[i][j] == 1 {
                grid[i][j] = 0
                water -= 1
                ans += 1
                if water == 0 {
                    return ans
                }
                
                if i - 1 >= 0 && grid[i - 1][j] == 0 {
                    grid[i - 1][j] = 1
                    water += 1
                } else if i + 1 < m && grid[i + 1][j] == 0 {
                    grid[i + 1][j] = 1
                    water += 1
                } else if j - 1 >= 0 && grid[i][j - 1] == 0 {
                    grid[i][j - 1] = 1
                    water += 1
                } else if j + 1 < n && grid[i][j + 1] == 0 {
                    grid[i][j + 1] = 1
                    water += 1
                }
            }
        }
    }
    
    return ans
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let m = grid.count
    let n = grid[0].count
    var ans = 0
    var water = 0
    
    for i in stride(from: 0, to: m, by: 1) {
        for j in stride(from: 0, to: n, by: 1) {
            if grid[i][j] == 1 {
                water += 1
            }
        }
    }
    
    for i in stride(from: 0, to: m, by: 1) {
        for j in stride(from: 0, to: n, by: 1) {
            if grid[i][j] == 1 {
                grid[i][j] = 0
                water -= 1
                ans += 1
                if water == 0 {
                    return ans
                }
                
                if i - 1 >= 0 && grid[i - 1][j] == 0 {
                    grid[i - 1][j] = 1
                    water += 1
                } else if i + 1 < m && grid[i + 1][j] == 0 {
                    grid[i + 1][j] = 1
                    water += 1
                } else if j - 1 >= 0 && grid[i][j - 1] == 0 {
                    grid[i][j - 1] = 1
                    water += 1
                } else if j + 1 < n && grid[i][j + 1] == 0 {
                    grid[i][j + 1] = 1
                    water += 1
                }
            }
        }
    }
    
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
            if currentRowWater == capacity {
                result += 1
                currentRowWater = 0
            }
        }
        if currentRowWater > 0 {
            result += 1
        }
    }
    
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0
    
    for row in 0..<rows {
        var currentRowWater = 0
        for col in 0..<cols {
            currentRowWater += grid[row][col]
            if currentRowWater == capacity {
                result += 1
                currentRowWater = 0
            }
        }
        if currentRowWater > 0 {
            result += 1
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var water = 0
    for i in 0..<height {
        for j in 0..<width {
            if grid[i][j] == 1 {
                water += 1
            }
        }
    }
    var times = 0
    while water > 0 {
        times += 1
        water -= capacity
        if water < 0 {
            water = 0
        }
    }
    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var water = 0
    for i in 0..<height {
        for j in 0..<width {
            if grid[i][j] == 1 {
                water += 1
            }
        }
    }
    var times = 0
    while water > 0 {
        times += 1
        water -= capacity
        if water < 0 {
            water = 0
        }
    }
    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let row = grid.count
    let col = grid[0].count
    
    var ans = 0
    var left = Array(repeating: 0, count: col)
    var right = Array(repeating: col - 1, count: col)
    
    for i in 0..<row {
        var leftMax = 0
        var rightMax = 0
        for j in 0..<col {
            if grid[i][j] == 1 {
                leftMax = max(leftMax, j)
                left[j] = leftMax
            }
        }
        for j in stride(from: col - 1, through: 0, by: -1) {
            if grid[i][j] == 1 {
                rightMax = max(rightMax, j)
                right[j] = rightMax
            }
        }
        
        for j in 0..<col {
            ans += min(min(left[j], right[j]) - j, capacity)
        }
    }
    
    return ans
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let row = grid.count
    let col = grid[0].count
    
    var ans = 0
    var left = Array(repeating: 0, count: col)
    var right = Array(repeating: col - 1, count: col)
    
    for i in 0..<row {
        var leftMax = 0
        var rightMax = 0
        for j in 0..<col {
            if grid[i][j] == 1 {
                leftMax = max(leftMax, j)
                left[j] = leftMax
            }
        }
        for j in stride(from: col - 1, through: 0, by: -1) {
            if grid[i][j] == 1 {
                rightMax = max(rightMax, j)
                right[j] = rightMax
            }
        }
        
        for j in 0..<col {
            ans += min(min(left[j], right[j]) - j, capacity)
        }
    }
    
    return ans
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var bucket = 0
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                totalWater += 1
            }
        }
    }
    var result = 0
    while totalWater > 0 {
        result += 1
        bucket += capacity
        if bucket >= totalWater {
            totalWater = 0
        } else {
            totalWater -= bucket
        }
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var bucket = 0
    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                totalWater += 1
            }
        }
    }
    var result = 0
    while totalWater > 0 {
        result += 1
        bucket += capacity
        if bucket >= totalWater {
            totalWater = 0
        } else {
            totalWater -= bucket
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rowLength = grid.first?.count ?? 0
    let colLength = grid.count

    var result = 0

    for col in 0..<colLength {
        for row in 0..<rowLength {
            if grid[col][row] == 1 {
                result += capacity
            }
        }
    }

    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rowLength = grid.first?.count ?? 0
    let colLength = grid.count

    var result = 0

    for col in 0..<colLength {
        for row in 0..<rowLength {
            if grid[col][row] == 1 {
                result += capacity
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var result = 0
    var water = 0
    for row in stride(from: height - 1, to: -1, by: -1) {
        for col in stride(from: width - 1, to: -1, by: -1) {
            if grid[row][col] == 1 {
                water += 1
            }
            if water == capacity {
                result += 1
                water = 0
            }
        }
    }
    return result
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let height = grid.count
    let width = grid[0].count
    var result = 0
    var water = 0
    for row in stride(from: height - 1, to: -1, by: -1) {
        for col in stride(from: width - 1, to: -1, by: -1) {
            if grid[row][col] == 1 {
                water += 1
            }
            if water == capacity {
                result += 1
                water = 0
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for row in 0..<rows {
        var waterCount = 0
        for col in 0..<cols {
            if grid[row][col] == 1 {
                waterCount += 1
            }
        }
        totalWater += waterCount
    }

    var steps = 0
    while totalWater > 0 {
        for row in 0..<rows {
            for col in 0..<cols {
                if !filled[row][col] && grid[row][col] == 1 {
                    filled[row][col] = true
                    totalWater -= capacity
                }
            }
        }
        steps += 1
    }

    return steps
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for row in 0..<rows {
        var waterCount = 0
        for col in 0..<cols {
            if grid[row][col] == 1 {
                waterCount += 1
            }
        }
        totalWater += waterCount
    }

    var steps = 0
    while totalWater > 0 {
        for row in 0..<rows {
            for col in 0..<cols {
                if !filled[row][col] && grid[row][col] == 1 {
                    filled[row][col] = true
                    totalWater -= capacity
                }
            }
        }
        steps += 1
    }

    return steps
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filledWater = 0

    for col in 0..<cols {
        var currentRow = 0

        for row in 0..<rows {
            if grid[row][col] == 1 {
                currentRow += 1
                filledWater += 1

                if filledWater == capacity {
                    filledWater = 0
                    totalWater += 1
                }
            }
        }
    }

    return totalWater
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filledWater = 0

    for col in 0..<cols {
        var currentRow = 0

        for row in 0..<rows {
            if grid[row][col] == 1 {
                currentRow += 1
                filledWater += 1

                if filledWater == capacity {
                    filledWater = 0
                    totalWater += 1
                }
            }
        }
    }

    return totalWater
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    for i in 0..<rows {
        totalWater += grid[i].filter({ $0 == 1 }).count
    }
    var lowered = 0
    while totalWater > 0 {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    totalWater -= 1
                }
                if totalWater == 0 {
                    return lowered
                }
            }
        }
        lowered += 1
    }
    return lowered
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    for i in 0..<rows {
        totalWater += grid[i].filter({ $0 == 1 }).count
    }
    var lowered = 0
    while totalWater > 0 {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    totalWater -= 1
                }
                if totalWater == 0 {
                    return lowered
                }
            }
        }
        lowered += 1
    }
    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    for row in 0..<rows {
        for col in 0..<cols {
            totalWater += grid[row][col]
        }
    }
    
    var filledWater = 0
    var lowerCount = 0
    while filledWater < totalWater {
        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 && filledWater < capacity {
                    filledWater += 1
                    grid[row][col] = 0
                }
            }
        }
        lowerCount += 1
    }
    
    return lowerCount
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    for row in 0..<rows {
        for col in 0..<cols {
            totalWater += grid[row][col]
        }
    }
    
    var filledWater = 0
    var lowerCount = 0
    while filledWater < totalWater {
        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 && filledWater < capacity {
                    filledWater += 1
                    grid[row][col] = 0
                }
            }
        }
        lowerCount += 1
    }
    
    return lowerCount
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                totalWater += 1
            }
        }
    }

    var fills = 0
    while totalWater > 0 {
        fills += 1
        for i in 0..<rows {
            for j in 0..<cols {
                if !filled[i][j] && grid[i][j] == 1 {
                    filled[i][j] = true
                    totalWater -= 1
                    if totalWater == 0 {
                        return fills
                    }
                }
            }
        }
    }

    return fills
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for i in 0..<rows {
        for j in 0..<cols {
            if grid[i][j] == 1 {
                totalWater += 1
            }
        }
    }

    var fills = 0
    while totalWater > 0 {
        fills += 1
        for i in 0..<rows {
            for j in 0..<cols {
                if !filled[i][j] && grid[i][j] == 1 {
                    filled[i][j] = true
                    totalWater -= 1
                    if totalWater == 0 {
                        return fills
                    }
                }
            }
        }
    }

    return fills
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    var lowered = 0
    
    while totalWater < rows * cols {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 {
                    totalWater += 1
                    grid[i][j] = 0
                    
                    if totalWater == rows * cols {
                        return lowered
                    }
                }
            }
        }
        
        lowered += 1
    }
    
    return lowered
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    var lowered = 0
    
    while totalWater < rows * cols {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 {
                    totalWater += 1
                    grid[i][j] = 0
                    
                    if totalWater == rows * cols {
                        return lowered
                    }
                }
            }
        }
        
        lowered += 1
    }
    
    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var filled = [[Int]](repeating: [Int](repeating: 0, count: cols), count: rows)
    var times = 0

    while filled != grid {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 && filled[i][j] < capacity {
                    filled[i][j] += 1
                }
            }
        }
        times += 1
    }

    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var filled = [[Int]](repeating: [Int](repeating: 0, count: cols), count: rows)
    var times = 0

    while filled != grid {
        for i in 0..<rows {
            for j in 0..<cols {
                if grid[i][j] == 1 && filled[i][j] < capacity {
                    filled[i][j] += 1
                }
            }
        }
        times += 1
    }

    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            totalWater += grid[i][j]
        }
    }
    
    var filledWater = 0
    var times = 0
    
    while filledWater < totalWater {
        for i in 0..<rows {
            for j in 0..<cols {
                if !filled[i][j] && grid[i][j] > 0 {
                    filled[i][j] = true
                    filledWater += 1
                    
                    if filledWater == totalWater {
                        return times
                    }
                }
            }
        }
        
        times += 1
    }
    
    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    
    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)
    
    for i in 0..<rows {
        for j in 0..<cols {
            totalWater += grid[i][j]
        }
    }
    
    var filledWater = 0
    var times = 0
    
    while filledWater < totalWater {
        for i in 0..<rows {
            for j in 0..<cols {
                if !filled[i][j] && grid[i][j] > 0 {
                    filled[i][j] = true
                    filledWater += 1
                    
                    if filledWater == totalWater {
                        return times
                    }
                }
            }
        }
        
        times += 1
    }
    
    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                totalWater += 1
            }
        }
    }

    var lowered = 0

    while totalWater > 0 {
        for row in 0..<rows {
            for col in 0..<cols {
                if !filled[row][col] && grid[row][col] == 1 {
                    filled[row][col] = true
                    totalWater -= 1
                    if totalWater == 0 {
                        return lowered
                    }
                }
            }
        }

        lowered += 1
    }

    return lowered
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var totalWater = 0
    var filled = [[Bool]](repeating: [Bool](repeating: false, count: cols), count: rows)

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                totalWater += 1
            }
        }
    }

    var lowered = 0

    while totalWater > 0 {
        for row in 0..<rows {
            for col in 0..<cols {
                if !filled[row][col] && grid[row][col] == 1 {
                    filled[row][col] = true
                    totalWater -= 1
                    if totalWater == 0 {
                        return lowered
                    }
                }
            }
        }

        lowered += 1
    }

    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var filled = [[Int]](repeating: [Int](repeating: 0, count: cols), count: rows)

    var times = 0

    while filled != grid {
        times += 1

        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 && filled[row][col] < capacity {
                    filled[row][col] += 1
                }
            }
        }
    }

    return times
}

<start_of_turn>user
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0<end_of_turn>
<start_of_turn>model
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count

    var filled = [[Int]](repeating: [Int](repeating: 0, count: cols), count: rows)

    var times = 0

    while filled != grid {
        times += 1

        for row in 0..<rows {
            for col in 0..<cols {
                if grid[row][col] == 1 && filled[row][col] < capacity {
                    filled[row][col] += 1
                }
            }
        }
    }

    return times
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    for row in grid {
        var currentCapacity = capacity
        for well in row {
            if well == 1 {
                currentCapacity -= 1
                if currentCapacity == 0 {
                    result += 1
                    currentCapacity = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var filled = 0
    var lowered = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
            }
        }
    }

    while filled > 0 {
        for row in grid {
            for cell in row {
                if cell == 1 {
                    buckets[row] += 1
                    filled -= 1
                }
            }
        }

        for row in grid {
            if buckets[row] > capacity {
                lowered += 1
                buckets[row] = 0
            }
        }
    }

    return lowered
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = Array(repeating: 0, count: grid.count)
    var filled = 0
    var lowered = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
            }
        }
    }

    while filled > 0 {
        for row in grid {
            for cell in row {
                if cell == 1 {
                    buckets[row] += 1
                    filled -= 1
                }
            }
        }

        for row in grid {
            if buckets[row] > capacity {
                lowered += 1
                buckets[row] = 0
            }
        }
    }

    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var rows = grid.count
    var cols = grid[0].count
    var buckets = capacity
    var loweredBuckets = 0

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                if buckets > 0 {
                    buckets -= 1
                    loweredBuckets += 1
                } else {
                    return loweredBuckets
                }
            }
        }
    }

    return loweredBuckets
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var rows = grid.count
    var cols = grid[0].count
    var buckets = capacity
    var loweredBuckets = 0

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                if buckets > 0 {
                    buckets -= 1
                    loweredBuckets += 1
                } else {
                    return loweredBuckets
                }
            }
        }
    }

    return loweredBuckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var filled = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = Array(repeating: Array(repeating: 0, count: cols), count: rows)
    var bucketCapacity = capacity

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                filled += 1
                if filled > bucketCapacity {
                    buckets += 1
                    filled = 1
                }
                wells[row][col] = 1
            }
        }
    }

    return buckets
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = 0
    var filled = 0
    var rows = grid.count
    var cols = grid[0].count
    var wells = Array(repeating: Array(repeating: 0, count: cols), count: rows)
    var bucketCapacity = capacity

    for row in 0..<rows {
        for col in 0..<cols {
            if grid[row][col] == 1 {
                filled += 1
                if filled > bucketCapacity {
                    buckets += 1
                    filled = 1
                }
                wells[row][col] = 1
            }
        }
    }

    return buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var filled = 0
    var lowered = 0
    var buckets = Array(repeating: 0, count: capacity)

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                if filled > capacity {
                    lowered += 1
                    filled = capacity
                }
            }
        }
    }

    return lowered
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var filled = 0
    var lowered = 0
    var buckets = Array(repeating: 0, count: capacity)

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                if filled > capacity {
                    lowered += 1
                    filled = capacity
                }
            }
        }
    }

    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    var wells = [Int]()
    var filled = 0
    var lowered = 0

    for row in grid {
        wells.append(row.filter { $0 == 1 }.count)
    }

    while filled < capacity {
        for i in 0..<wells.count {
            if wells[i] > 0 {
                buckets.append(wells[i])
                wells[i] = 0
                filled += buckets[i]
            }
        }
        lowered += 1
    }

    return lowered
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int]()
    var wells = [Int]()
    var filled = 0
    var lowered = 0

    for row in grid {
        wells.append(row.filter { $0 == 1 }.count)
    }

    while filled < capacity {
        for i in 0..<wells.count {
            if wells[i] > 0 {
                buckets.append(wells[i])
                wells[i] = 0
                filled += buckets[i]
            }
        }
        lowered += 1
    }

    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var wells = [Int](repeating: 0, count: grid.count)
    var loweredBuckets = 0

    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                if buckets[i] < capacity {
                    buckets[i] += 1
                    wells[i] -= 1
                } else {
                    loweredBuckets += 1
                    buckets[i] = 0
                    wells[i] -= 1
                }
            }
        }
    }

    return loweredBuckets
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var wells = [Int](repeating: 0, count: grid.count)
    var loweredBuckets = 0

    for row in grid {
        for i in 0..<row.count {
            if row[i] == 1 {
                if buckets[i] < capacity {
                    buckets[i] += 1
                    wells[i] -= 1
                } else {
                    loweredBuckets += 1
                    buckets[i] = 0
                    wells[i] -= 1
                }
            }
        }
    }

    return loweredBuckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var filled = 0
    var buckets = capacity
    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                buckets -= 1
                if buckets == 0 {
                    return filled
                }
            }
        }
    }
    return filled
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var filled = 0
    var buckets = capacity
    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                buckets -= 1
                if buckets == 0 {
                    return filled
                }
            }
        }
    }
    return filled
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var loweredBuckets = 0
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                var bucketIndex = 0
                while bucketIndex < buckets.count && buckets[bucketIndex] == capacity {
                    bucketIndex += 1
                }
                
                if bucketIndex < buckets.count {
                    buckets[bucketIndex] += 1
                    loweredBuckets += 1
                }
            }
        }
    }
    
    return loweredBuckets
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var loweredBuckets = 0
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                var bucketIndex = 0
                while bucketIndex < buckets.count && buckets[bucketIndex] == capacity {
                    bucketIndex += 1
                }
                
                if bucketIndex < buckets.count {
                    buckets[bucketIndex] += 1
                    loweredBuckets += 1
                }
            }
        }
    }
    
    return loweredBuckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var loweredBuckets = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                let bucketIndex = buckets.firstIndex(where: { $0 == 0 }) ?? 0
                buckets[bucketIndex] += 1
                loweredBuckets += 1
            }
        }
    }

    return loweredBuckets
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: capacity)
    var loweredBuckets = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                let bucketIndex = buckets.firstIndex(where: { $0 == 0 }) ?? 0
                buckets[bucketIndex] += 1
                loweredBuckets += 1
            }
        }
    }

    return loweredBuckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: grid.count)
    var filled = 0
    var lowered = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                if filled > capacity {
                    lowered += 1
                    filled = 0
                }
            }
        }
    }

    return lowered
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = [Int](repeating: 0, count: grid.count)
    var filled = 0
    var lowered = 0

    for row in grid {
        for cell in row {
            if cell == 1 {
                filled += 1
                if filled > capacity {
                    lowered += 1
                    filled = 0
                }
            }
        }
    }

    return lowered
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var buckets = [Int](repeating: 0, count: rows)
    var result = 0

    for col in 0..<cols {
        for row in 0..<rows {
            if grid[row][col] == 1 {
                buckets[row] += 1
            }
        }

        for row in 0..<rows {
            if buckets[row] > capacity {
                result += 1
                buckets[row] = 0
            }
        }
    }

    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var buckets = [Int](repeating: 0, count: rows)
    var result = 0

    for col in 0..<cols {
        for row in 0..<rows {
            if grid[row][col] == 1 {
                buckets[row] += 1
            }
        }

        for row in 0..<rows {
            if buckets[row] > capacity {
                result += 1
                buckets[row] = 0
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for column in row {
            if column == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            break
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for column in row {
            if column == 1 && currentCapacity > 0 {
                result += 1
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            break
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Initialize variables
    var totalWater = 0
    var buckets = [Int](repeating: 0, count: grid.count)

    // Loop through each row of the grid
    for i in 0..<grid.count {
        // Loop through each column of the current row
        for j in 0..<grid[i].count {
            // If the current cell has water, add it to the total water
            if grid[i][j] == 1 {
                totalWater += 1
            }

            // If the current cell is not empty and the bucket is not full, add water to the bucket
            if grid[i][j] == 1 && buckets[i] < capacity {
                buckets[i] += 1
            }
        }
    }

    // Return the number of times the buckets were lowered
    return buckets.count
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Initialize variables
    var totalWater = 0
    var buckets = [Int](repeating: 0, count: grid.count)

    // Loop through each row of the grid
    for i in 0..<grid.count {
        // Loop through each column of the current row
        for j in 0..<grid[i].count {
            // If the current cell has water, add it to the total water
            if grid[i][j] == 1 {
                totalWater += 1
            }

            // If the current cell is not empty and the bucket is not full, add water to the bucket
            if grid[i][j] == 1 && buckets[i] < capacity {
                buckets[i] += 1
            }
        }
    }

    // Return the number of times the buckets were lowered
    return buckets.count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }

        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }

    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }

        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                result += 1
                currentCapacity = capacity
            }
        }
    }

    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                result += 1
                currentCapacity = capacity
            }
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }
        result += 1
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }
        result += 1
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }
        result += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }
    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity
    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            }
        }
        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Initialize variables
    var totalWater = 0
    var bucketCapacity = capacity
    var row = 0
    var col = 0

    // Loop through the grid
    while row < grid.count {
        // Check if the current cell has water
        if grid[row][col] == 1 {
            // If the bucket is not full, fill it with water from the current cell
            if bucketCapacity > 0 {
                bucketCapacity -= 1
                totalWater += 1
            } else {
                // If the bucket is full, move on to the next row
                row += 1
                col = 0
                bucketCapacity = capacity
            }
        } else {
            // If the current cell does not have water, move on to the next cell
            col += 1
        }
    }

    return totalWater
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Initialize variables
    var totalWater = 0
    var bucketCapacity = capacity
    var row = 0
    var col = 0

    // Loop through the grid
    while row < grid.count {
        // Check if the current cell has water
        if grid[row][col] == 1 {
            // If the bucket is not full, fill it with water from the current cell
            if bucketCapacity > 0 {
                bucketCapacity -= 1
                totalWater += 1
            } else {
                // If the bucket is full, move on to the next row
                row += 1
                col = 0
                bucketCapacity = capacity
            }
        } else {
            // If the current cell does not have water, move on to the next cell
            col += 1
        }
    }

    return totalWater
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }

        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }

    return result
}

[INST] Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0 [/INST] ```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var currentCapacity = capacity

    for row in grid {
        for unit in row {
            if unit == 1 && currentCapacity > 0 {
                currentCapacity -= 1
            } else if unit == 0 && currentCapacity < capacity {
                currentCapacity += 1
            }
        }

        if currentCapacity == 0 {
            result += 1
            currentCapacity = capacity
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var row = 0
    var col = 0
    var bucket = 0

    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            if bucket == capacity {
                bucket = 0
                row += 1
            } else {
                bucket += 1
            }
        } else {
            bucket = 0
            col += 1
        }
        count += 1
    }

    return count
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var row = 0
    var col = 0
    var bucket = 0

    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            if bucket == capacity {
                bucket = 0
                row += 1
            } else {
                bucket += 1
            }
        } else {
            bucket = 0
            col += 1
        }
        count += 1
    }

    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var bucket = 0
    var max = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                if bucket == capacity {
                    result += 1
                    bucket = 0
                }
                bucket += 1
            }
            col += 1
        }
        col = 0
        row += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var bucket = 0
    var max = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                if bucket == capacity {
                    result += 1
                    bucket = 0
                }
                bucket += 1
            }
            col += 1
        }
        col = 0
        row += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[0].count {
        let count = min(capacity, grid[row][col])
        total += count
        grid[row][col] -= count
        if grid[row][col] == 0 {
            col += 1
        }
        row += 1
    }
    
    return res
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var total = 0
    
    while row < grid.count, col < grid[0].count {
        let count = min(capacity, grid[row][col])
        total += count
        grid[row][col] -= count
        if grid[row][col] == 0 {
            col += 1
        }
        row += 1
    }
    
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = Array(repeating: 0, count: capacity)
    
    for row in grid {
        for well in row {
            if well == 1 {
                let index = buckets.firstIndex(of: 0)!
                buckets[index] += 1
            }
        }
        
        for i in 0..<capacity {
            if buckets[i] > 0 {
                result += buckets[i] - 1
                buckets[i] = 1
            }
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = Array(repeating: 0, count: capacity)
    
    for row in grid {
        for well in row {
            if well == 1 {
                let index = buckets.firstIndex(of: 0)!
                buckets[index] += 1
            }
        }
        
        for i in 0..<capacity {
            if buckets[i] > 0 {
                result += buckets[i] - 1
                buckets[i] = 1
            }
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var bucket = 0
    var maxBucket = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            bucket += 1
            maxBucket = max(maxBucket, bucket)
        } else {
            bucket -= 1
        }
        
        if bucket < 0 {
            result += abs(bucket)
            bucket = 0
        }
        
        row += 1
        col += 1
    }
    
    return result + maxBucket
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var bucket = 0
    var maxBucket = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            bucket += 1
            maxBucket = max(maxBucket, bucket)
        } else {
            bucket -= 1
        }
        
        if bucket < 0 {
            result += abs(bucket)
            bucket = 0
        }
        
        row += 1
        col += 1
    }
    
    return result + maxBucket
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var bucket = 0
    var left = 0
    var right = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            if bucket == 0 {
                bucket = capacity
                left = col
                right = col
            }
            bucket -= 1
            col += 1
        } else {
            if bucket > 0 {
                res += bucket
                bucket = 0
            }
            row += 1
            col = left
        }
    }
    
    if bucket > 0 {
        res += bucket
    }
    
    return res
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var bucket = 0
    var left = 0
    var right = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            if bucket == 0 {
                bucket = capacity
                left = col
                right = col
            }
            bucket -= 1
            col += 1
        } else {
            if bucket > 0 {
                res += bucket
                bucket = 0
            }
            row += 1
            col = left
        }
    }
    
    if bucket > 0 {
        res += bucket
    }
    
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var row = 0
    var col = 0
    var bucket = 0
    var maxBucket = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                if bucket == 0 {
                    maxBucket = capacity
                }
                bucket += 1
                if bucket == capacity {
                    bucket = 0
                    count += 1
                }
            } else {
                bucket = 0
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return count
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var row = 0
    var col = 0
    var bucket = 0
    var maxBucket = 0
    
    while row < grid.count {
        while col < grid[row].count {
            if grid[row][col] == 1 {
                if bucket == 0 {
                    maxBucket = capacity
                }
                bucket += 1
                if bucket == capacity {
                    bucket = 0
                    count += 1
                }
            } else {
                bucket = 0
            }
            col += 1
        }
        row += 1
        col = 0
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var left = 0
    var right = 0
    
    for row in grid {
        while left < row.count && row[left] == 0 {
            left += 1
        }
        
        while right < row.count && row[right] == 1 {
            right += 1
        }
        
        res += max(right - left, 0)
    }
    
    return res
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var left = 0
    var right = 0
    
    for row in grid {
        while left < row.count && row[left] == 0 {
            left += 1
        }
        
        while right < row.count && row[right] == 1 {
            right += 1
        }
        
        res += max(right - left, 0)
    }
    
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var bucket = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            if bucket < capacity {
                bucket += 1
            } else {
                res += 1
                bucket = 1
            }
        }
        col += 1
    }
    
    return res
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var row = 0
    var col = 0
    var bucket = 0
    
    while row < grid.count, col < grid[0].count {
        let well = grid[row][col]
        if well == 1 {
            if bucket < capacity {
                bucket += 1
            } else {
                res += 1
                bucket = 1
            }
        }
        col += 1
    }
    
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var buckets = Array(repeating: 0, count: capacity)
    var row = 0
    var col = 0
    var count = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            count += 1
            buckets[count % capacity] += 1
        } else {
            count = 0
            row += 1
        }
        
        res = max(res, buckets.max()!)
    }
    
    return res
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var res = 0
    var buckets = Array(repeating: 0, count: capacity)
    var row = 0
    var col = 0
    var count = 0
    
    while row < grid.count, col < grid[row].count {
        if grid[row][col] == 1 {
            count += 1
            buckets[count % capacity] += 1
        } else {
            count = 0
            row += 1
        }
        
        res = max(res, buckets.max()!)
    }
    
    return res
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for row in 0..<rows {
        var col = 0
        var water = 0

        while col < cols {
            if grid[row][col] == 1 {
                water += 1
            } else {
                water = 0
            }

            if water == capacity {
                result += 1
                water = 0

                for c in 0..<cols {
                    if grid[row][c] == 1 {
                        grid[row][c] = 0
                    }
                }
            }

            col += 1
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for row in 0..<rows {
        var col = 0
        var water = 0

        while col < cols {
            if grid[row][col] == 1 {
                water += 1
            } else {
                water = 0
            }

            if water == capacity {
                result += 1
                water = 0

                for c in 0..<cols {
                    if grid[row][c] == 1 {
                        grid[row][c] = 0
                    }
                }
            }

            col += 1
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = grid[0].count - 1
    
    while i < grid.count && j >= 0 {
        var count = 0
        var k = j
        
        while k >= 0 && grid[i][k] == 1 {
            count += 1
            k -= 1
        }
        
        if count == 0 {
            i += 1
            continue
        }
        
        var filled = min(count, capacity)
        result += filled
        j -= filled
        
        while filled > 0 && i < grid.count {
            grid[i][j] = 0
            i += 1
            filled -= 1
        }
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var i = 0
    var j = grid[0].count - 1
    
    while i < grid.count && j >= 0 {
        var count = 0
        var k = j
        
        while k >= 0 && grid[i][k] == 1 {
            count += 1
            k -= 1
        }
        
        if count == 0 {
            i += 1
            continue
        }
        
        var filled = min(count, capacity)
        result += filled
        j -= filled
        
        while filled > 0 && i < grid.count {
            grid[i][j] = 0
            i += 1
            filled -= 1
        }
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: cols)
    var i = 0
    while i < rows {
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells[j] += 1
            }
            j += 1
        }
        i += 1
    }
    var maxWells = wells.max()?? 0
    while maxWells > 0 {
        var i = 0
        var filled = 0
        while i < rows {
            var j = 0
            while j < cols {
                if grid[i][j] == 1 && wells[j] > 0 {
                    grid[i][j] = 0
                    wells[j] -= 1
                    filled += 1
                }
                j += 1
            }
            i += 1
        }
        if filled == 0 {
            break
        }
        result += 1
        maxWells = wells.max()?? 0
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: cols)
    var i = 0
    while i < rows {
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells[j] += 1
            }
            j += 1
        }
        i += 1
    }
    var maxWells = wells.max()?? 0
    while maxWells > 0 {
        var i = 0
        var filled = 0
        while i < rows {
            var j = 0
            while j < cols {
                if grid[i][j] == 1 && wells[j] > 0 {
                    grid[i][j] = 0
                    wells[j] -= 1
                    filled += 1
                }
                j += 1
            }
            i += 1
        }
        if filled == 0 {
            break
        }
        result += 1
        maxWells = wells.max()?? 0
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var i = 0
    while i < rows {
        var j = cols - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                j -= 1
            } else {
                var k = j
                while k >= 0 && grid[i][k] == 0 {
                    k -= 1
                }
                if k < 0 {
                    break
                }
                let amount = min(j - k + 1, capacity)
                for l in k...j {
                    grid[i][l] -= amount
                }
                j = k - 1
                result += amount
            }
        }
        i += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var i = 0
    while i < rows {
        var j = cols - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                j -= 1
            } else {
                var k = j
                while k >= 0 && grid[i][k] == 0 {
                    k -= 1
                }
                if k < 0 {
                    break
                }
                let amount = min(j - k + 1, capacity)
                for l in k...j {
                    grid[i][l] -= amount
                }
                j = k - 1
                result += amount
            }
        }
        i += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var i = 0
    var j = 0
    var count = 0
    
    while i < rows {
        while j < cols && grid[i][j] == 1 {
            count += 1
            j += 1
        }
        
        if count == cols {
            result += 1
        } else if count > 0 {
            result += count / capacity
            if count % capacity > 0 {
                result += 1
            }
        }
        
        count = 0
        j = 0
        i += 1
    }
    
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var i = 0
    var j = 0
    var count = 0
    
    while i < rows {
        while j < cols && grid[i][j] == 1 {
            count += 1
            j += 1
        }
        
        if count == cols {
            result += 1
        } else if count > 0 {
            result += count / capacity
            if count % capacity > 0 {
                result += 1
            }
        }
        
        count = 0
        j = 0
        i += 1
    }
    
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for i in 0..< rows {
        var wells = [Int]()
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells.append(j)
                j += 1
            } else {
                j += 1
            }
        }

        var wellsIndex = 0
        var capacityLeft = capacity
        while wellsIndex < wells.count && capacityLeft > 0 {
            let wellIndex = wellsIndex
            var wellCapacityLeft = capacityLeft
            while wellCapacityLeft > 0 && wellIndex < wells.count {
                let well = wells[wellIndex]
                let wellCol = well
                let wellRow = i
                let wellValue = grid[wellRow][wellCol]
                let wellCapacity = wellValue
                let newWellCapacity = wellCapacity - wellCapacityLeft
                if newWellCapacity == 0 {
                    grid[wellRow][wellCol] = 0
                    wells.remove(at: wellIndex)
                } else {
                    grid[wellRow][wellCol] = newWellCapacity
                    wellsIndex += 1
                    break
                }
                wellCapacityLeft -= wellCapacity
            }
            capacityLeft -= wellCapacityLeft
        }
        result += wells.count
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count

    for i in 0..< rows {
        var wells = [Int]()
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells.append(j)
                j += 1
            } else {
                j += 1
            }
        }

        var wellsIndex = 0
        var capacityLeft = capacity
        while wellsIndex < wells.count && capacityLeft > 0 {
            let wellIndex = wellsIndex
            var wellCapacityLeft = capacityLeft
            while wellCapacityLeft > 0 && wellIndex < wells.count {
                let well = wells[wellIndex]
                let wellCol = well
                let wellRow = i
                let wellValue = grid[wellRow][wellCol]
                let wellCapacity = wellValue
                let newWellCapacity = wellCapacity - wellCapacityLeft
                if newWellCapacity == 0 {
                    grid[wellRow][wellCol] = 0
                    wells.remove(at: wellIndex)
                } else {
                    grid[wellRow][wellCol] = newWellCapacity
                    wellsIndex += 1
                    break
                }
                wellCapacityLeft -= wellCapacity
            }
            capacityLeft -= wellCapacityLeft
        }
        result += wells.count
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: cols)
    var i = 0
    while i < rows {
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells[j] += 1
            }
            j += 1
        }
        i += 1
    }
    var wellsCount = wells.count
    var wellsSum = wells.reduce(0, +)
    while wellsSum > 0 {
        var wellsIndex = 0
        var wellsMax = 0
        for i in 0..<wellsCount {
            if wells[i] > wellsMax {
                wellsMax = wells[i]
                wellsIndex = i
            }
        }
        if wellsMax <= capacity {
            result += wellsMax
            wellsSum -= wellsMax
            wells[wellsIndex] = 0
        } else {
            result += capacity
            wellsSum -= capacity
            wells[wellsIndex] -= capacity
        }
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    let rows = grid.count
    let cols = grid[0].count
    var wells = [Int](repeating: 0, count: cols)
    var i = 0
    while i < rows {
        var j = 0
        while j < cols {
            if grid[i][j] == 1 {
                wells[j] += 1
            }
            j += 1
        }
        i += 1
    }
    var wellsCount = wells.count
    var wellsSum = wells.reduce(0, +)
    while wellsSum > 0 {
        var wellsIndex = 0
        var wellsMax = 0
        for i in 0..<wellsCount {
            if wells[i] > wellsMax {
                wellsMax = wells[i]
                wellsIndex = i
            }
        }
        if wellsMax <= capacity {
            result += wellsMax
            wellsSum -= wellsMax
            wells[wellsIndex] = 0
        } else {
            result += capacity
            wellsSum -= capacity
            wells[wellsIndex] -= capacity
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0

    for col in 0..<cols {
        var wells = [Int](repeating: 0, count: rows)
        var level = 0

        for row in 0..<rows {
            if grid[row][col] == 1 {
                wells[row] += 1
            }
        }

        while level < capacity && wells.contains(where: { $0 > 0 }) {
            for row in 0..<rows {
                if wells[row] > 0 {
                    wells[row] -= 1
                    result += 1
                }
            }
            level += 1
        }
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0

    for col in 0..<cols {
        var wells = [Int](repeating: 0, count: rows)
        var level = 0

        for row in 0..<rows {
            if grid[row][col] == 1 {
                wells[row] += 1
            }
        }

        while level < capacity && wells.contains(where: { $0 > 0 }) {
            for row in 0..<rows {
                if wells[row] > 0 {
                    wells[row] -= 1
                    result += 1
                }
            }
            level += 1
        }
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0
    var i = 0
    while i < rows {
        var j = cols - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                j -= 1
            } else {
                let height = min(capacity, grid[i].reduce(0, { $0 + $1 }))
                grid[i].removeFirst(height)
                grid[i].append(contentsOf: Array(repeating: 0, count: height))
                result += 1
                j -= 1
            }
        }
        i += 1
    }
    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    let rows = grid.count
    let cols = grid[0].count
    var result = 0
    var i = 0
    while i < rows {
        var j = cols - 1
        while j >= 0 {
            if grid[i][j] == 1 {
                j -= 1
            } else {
                let height = min(capacity, grid[i].reduce(0, { $0 + $1 }))
                grid[i].removeFirst(height)
                grid[i].append(contentsOf: Array(repeating: 0, count: height))
                result += 1
                j -= 1
            }
        }
        i += 1
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var maxCol = grid[0].count - 1

    while col <= maxCol {
        var wells = 0
        var bucket = capacity

        while bucket > 0 && row < grid.count {
            if grid[row][col] == 1 {
                wells += 1
            } else {
                bucket -= 1
            }
            row += 1
        }

        result += wells
        col += 1
        row = 0
    }

    return result
}

Question:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0

Answer:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var row = 0
    var col = 0
    var maxCol = grid[0].count - 1

    while col <= maxCol {
        var wells = 0
        var bucket = capacity

        while bucket > 0 && row < grid.count {
            if grid[row][col] == 1 {
                wells += 1
            } else {
                bucket -= 1
            }
            row += 1
        }

        result += wells
        col += 1
        row = 0
    }

    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    var drops = 0

    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }

    while wells > 0 {
        if buckets >= wells {
            drops += 1
            wells = 0
        } else {
            drops += 1
            wells -= buckets
        }
    }

    return drops
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    var drops = 0

    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }

    while wells > 0 {
        if buckets >= wells {
            drops += 1
            wells = 0
        } else {
            drops += 1
            wells -= buckets
        }
    }

    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 && buckets > 0 {
                buckets -= 1
                count += 1
            }
        }
        buckets = capacity
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 && buckets > 0 {
                buckets -= 1
                count += 1
            }
        }
        buckets = capacity
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var operations = 0
    for row in grid {
        for well in row {
            if well == 1 {
                operations += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    operations += 1
                }
            }
        }
    }
    return operations
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var operations = 0
    for row in grid {
        for well in row {
            if well == 1 {
                operations += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    operations += 1
                }
            }
        }
    }
    return operations
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var operations = 0
    for row in grid {
        for well in row {
            if well == 1 {
                operations += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    operations += 1
                }
            }
        }
    }
    return operations
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var operations = 0
    for row in grid {
        for well in row {
            if well == 1 {
                operations += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    operations += 1
                }
            }
        }
    }
    return operations
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    var drops = 0

    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }

    while wells > 0 {
        if buckets >= wells {
            drops += 1
            wells = 0
        } else {
            drops += 1
            wells -= buckets
        }
    }

    return drops
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    var drops = 0

    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }

    while wells > 0 {
        if buckets >= wells {
            drops += 1
            wells = 0
        } else {
            drops += 1
            wells -= buckets
        }
    }

    return drops
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 && buckets > 0 {
                buckets -= 1
                count += 1
            }
        }
        buckets = capacity
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 && buckets > 0 {
                buckets -= 1
                count += 1
            }
        }
        buckets = capacity
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }
    return (wells + buckets - 1) / buckets
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }
    return (wells + buckets - 1) / buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                count += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    count += 1
                }
            }
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                count += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                count += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    count += 1
                }
            }
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = capacity
    for row in grid {
        for well in row {
            if well == 1 {
                count += 1
                buckets -= 1
                if buckets == 0 {
                    buckets = capacity
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }
    return (wells + buckets - 1) / buckets
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var buckets = capacity
    var wells = 0
    for row in grid {
        for well in row {
            if well == 1 {
                wells += 1
            }
        }
    }
    return (wells + buckets - 1) / buckets
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let bucketCapacity = buckets.removeFirst()
            let water = min(bucketCapacity, row.count)
            row = row.map { $0 - max($0 - water, 0) }
            count += 1
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let bucketCapacity = buckets.removeFirst()
            let water = min(bucketCapacity, row.count)
            row = row.map { $0 - max($0 - water, 0) }
            count += 1
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[0] > 0 {
                    buckets[0] -= 1
                    buckets.remove(at: 0)
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets = buckets.sorted(by: >)
        while buckets.count > 0 {
            let index = buckets.firstIndex(of: capacity)!
            buckets.remove(at: index)
            count += 1
        }
        buckets = [capacity]
    }
    buckets = buckets.sorted(by: >)
    while buckets.count > 0 {
        let index = buckets.firstIndex(of: capacity)!
        buckets.remove(at: index)
        count += 1
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets = buckets.sorted(by: >)
        while buckets.count > 0 {
            let index = buckets.firstIndex(of: capacity)!
            buckets.remove(at: index)
            count += 1
        }
        buckets = [capacity]
    }
    buckets = buckets.sorted(by: >)
    while buckets.count > 0 {
        let index = buckets.firstIndex(of: capacity)!
        buckets.remove(at: index)
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while !buckets.isEmpty && buckets.last! > capacity {
                    buckets.removeLast()
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let index = buckets.index(buckets.startIndex, offsetBy: count % buckets.count)
            buckets[index] -= 1
            if buckets[index] == 0 {
                buckets.remove(at: index)
            }
            count += 1
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let index = buckets.index(buckets.startIndex, offsetBy: count % buckets.count)
            buckets[index] -= 1
            if buckets[index] == 0 {
                buckets.remove(at: index)
            }
            count += 1
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let index = buckets.firstIndex(of: capacity)!
            buckets.remove(at: index)
            count += 1
        }
        buckets.removeAll()
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let index = buckets.firstIndex(of: capacity)!
            buckets.remove(at: index)
            count += 1
        }
        buckets.removeAll()
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let filled = min(buckets.removeFirst(), buckets.count > 0 ? buckets.removeFirst() : 0)
            buckets.sort(by: >)
            if filled > 0 {
                count += 1
                buckets.removeAll(where: { $0 < filled })
            }
        }
    }
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            }
        }
        buckets.sort(by: >)
        while buckets.count > 0 {
            let filled = min(buckets.removeFirst(), buckets.count > 0 ? buckets.removeFirst() : 0)
            buckets.sort(by: >)
            if filled > 0 {
                count += 1
                buckets.removeAll(where: { $0 < filled })
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for _ in 0..<buckets.count {
            buckets[buckets.count - 1] -= 1
            count += 1
        }
        buckets = [capacity]
    }
    
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for _ in 0..<buckets.count {
            buckets[buckets.count - 1] -= 1
            count += 1
        }
        buckets = [capacity]
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for _ in 0..<buckets.count {
            buckets[buckets.count - 1] -= 1
            count += 1
        }
        buckets = [capacity]
    }
    
    return count
}

You are an AI programming assistant, utilizing the Deepseek Coder model, developed by Deepseek Company, and you only answer questions related to computer science. For politically sensitive questions, security and privacy issues, and other non-computer science questions, you will refuse to answer
### Instruction:
Write code in Swift programming language. Don't include usage examples or tests.
You are given a rectangular grid of wells. Each row represents a single well,
and each 1 in a row represents a single unit of water.
Each well has a corresponding bucket that can be used to extract water from it, 
and all buckets have the same capacity.
Your task is to use the buckets to empty the wells.
Output the number of times you need to lower the buckets.
Example 1:
Example 2:
Example 3:
Constraints:
* all wells have the same length
* 1 <= grid.length <= 10^2
* 1 <= grid[:,1].length <= 10^2
* grid[i][j] -> 0 | 1
* 1 <= capacity <= 10
maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
### Response:
```swift
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var buckets = [Int]()
    
    for row in grid {
        for cell in row {
            if cell == 1 {
                buckets.append(capacity)
            } else {
                while buckets.count > 0 && buckets[buckets.count - 1] > 0 {
                    buckets[buckets.count - 1] -= 1
                    count += 1
                }
            }
        }
        buckets = [capacity]
    }
    
    while buckets.count > 0 {
        for _ in 0..<buckets.count {
            buckets[buckets.count - 1] -= 1
            count += 1
        }
        buckets = [capacity]
    }
    
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                let left = j - 1
                let right = j + 1
                while left >= 0 && grid[i][left] == 1 {
                    grid[i][left] = 0
                    left -= 1
                }
                while right < grid[i].count && grid[i][right] == 1 {
                    grid[i][right] = 0
                    right += 1
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                grid[i][j] = 0
                let left = j - 1
                let right = j + 1
                while left >= 0 && grid[i][left] == 1 {
                    grid[i][left] = 0
                    left -= 1
                }
                while right < grid[i].count && grid[i][right] == 1 {
                    grid[i][right] = 0
                    right += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // TODO: Implement me
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // TODO: Implement me
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    while true {
        var changed = false
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    let left = j > 0? grid[i][j - 1] : 0
                    let right = j < grid[i].count - 1? grid[i][j + 1] : 0
                    let up = i > 0? grid[i - 1][j] : 0
                    let down = i < grid.count - 1? grid[i + 1][j] : 0
                    let min = min(left, right, up, down)
                    if min > 0 {
                        grid[i][j] = min
                        changed = true
                    }
                }
            }
        }
        if!changed {
            break
        }
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    while true {
        var changed = false
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    let left = j > 0? grid[i][j - 1] : 0
                    let right = j < grid[i].count - 1? grid[i][j + 1] : 0
                    let up = i > 0? grid[i - 1][j] : 0
                    let down = i < grid.count - 1? grid[i + 1][j] : 0
                    let min = min(left, right, up, down)
                    if min > 0 {
                        grid[i][j] = min
                        changed = true
                    }
                }
            }
        }
        if!changed {
            break
        }
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if j > 0 && grid[i][j - 1] == 0 {
                    grid[i][j - 1] = 1
                    count += 1
                }
                if j < grid[i].count - 1 && grid[i][j + 1] == 0 {
                    grid[i][j + 1] = 1
                    count += 1
                }
                if i > 0 && grid[i - 1][j] == 0 {
                    grid[i - 1][j] = 1
                    count += 1
                }
                if i < grid.count - 1 && grid[i + 1][j] == 0 {
                    grid[i + 1][j] = 1
                    count += 1
                }
            }
            j += 1
        }
        i += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                if j > 0 && grid[i][j - 1] == 0 {
                    grid[i][j - 1] = 1
                    count += 1
                }
                if j < grid[i].count - 1 && grid[i][j + 1] == 0 {
                    grid[i][j + 1] = 1
                    count += 1
                }
                if i > 0 && grid[i - 1][j] == 0 {
                    grid[i - 1][j] = 1
                    count += 1
                }
                if i < grid.count - 1 && grid[i + 1][j] == 0 {
                    grid[i + 1][j] = 1
                    count += 1
                }
            }
            j += 1
        }
        i += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                var k = j + 1
                while k < grid[i].count && grid[i][k] == 1 {
                    k += 1
                }
                if k - j > capacity {
                    count += k - j - capacity
                    grid[i][j] = 0
                    grid[i][k - 1] = 1
                }
                j = k
            } else {
                j += 1
            }
        }
        i += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                var k = j + 1
                while k < grid[i].count && grid[i][k] == 1 {
                    k += 1
                }
                if k - j > capacity {
                    count += k - j - capacity
                    grid[i][j] = 0
                    grid[i][k - 1] = 1
                }
                j = k
            } else {
                j += 1
            }
        }
        i += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                let left = j - 1 >= 0? grid[i][j - 1] : 0
                let right = j + 1 < grid[i].count? grid[i][j + 1] : 0
                let up = i - 1 >= 0? grid[i - 1][j] : 0
                let down = i + 1 < grid.count? grid[i + 1][j] : 0
                let max = max(left, right, up, down)
                if max > 0 {
                    let diff = min(capacity, max - grid[i][j])
                    grid[i][j] += diff
                    count += diff
                }
            }
            j += 1
        }
        i += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                let left = j - 1 >= 0? grid[i][j - 1] : 0
                let right = j + 1 < grid[i].count? grid[i][j + 1] : 0
                let up = i - 1 >= 0? grid[i - 1][j] : 0
                let down = i + 1 < grid.count? grid[i + 1][j] : 0
                let max = max(left, right, up, down)
                if max > 0 {
                    let diff = min(capacity, max - grid[i][j])
                    grid[i][j] += diff
                    count += diff
                }
            }
            j += 1
        }
        i += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var row = 0
    var col = 0
    while row < grid.count && col < grid[row].count {
        if grid[row][col] == 0 {
            count += 1
            grid[row][col] = 1
            if col + 1 < grid[row].count {
                col += 1
            } else {
                row += 1
                col = 0
            }
        } else {
            col += 1
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    var row = 0
    var col = 0
    while row < grid.count && col < grid[row].count {
        if grid[row][col] == 0 {
            count += 1
            grid[row][col] = 1
            if col + 1 < grid[row].count {
                col += 1
            } else {
                row += 1
                col = 0
            }
        } else {
            col += 1
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            current += 1
        } else {
            if current > capacity {
                result += 1
                current = capacity
            } else {
                current = 0
            }
        }
        j += 1
        if j == grid[i].count {
            j = 0
            i += 1
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var current = 0
    var i = 0
    var j = 0
    while i < grid.count && j < grid[i].count {
        if grid[i][j] == 1 {
            current += 1
        } else {
            if current > capacity {
                result += 1
                current = capacity
            } else {
                current = 0
            }
        }
        j += 1
        if j == grid[i].count {
            j = 0
            i += 1
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                var count = 0
                var left = j - 1
                var right = j + 1
                while left >= 0 && grid[i][left] == 1 {
                    count += 1
                    left -= 1
                }
                while right < grid[i].count && grid[i][right] == 1 {
                    count += 1
                    right += 1
                }
                if count > 0 {
                    result += count
                    grid[i][j] = 0
                    grid[i][left + 1] = 0
                    grid[i][right - 1] = 0
                }
            }
            j += 1
        }
        i += 1
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var grid = grid
    var i = 0
    while i < grid.count {
        var j = 0
        while j < grid[i].count {
            if grid[i][j] == 1 {
                var count = 0
                var left = j - 1
                var right = j + 1
                while left >= 0 && grid[i][left] == 1 {
                    count += 1
                    left -= 1
                }
                while right < grid[i].count && grid[i][right] == 1 {
                    count += 1
                    right += 1
                }
                if count > 0 {
                    result += count
                    grid[i][j] = 0
                    grid[i][left + 1] = 0
                    grid[i][right - 1] = 0
                }
            }
            j += 1
        }
        i += 1
    }
    return result
}
```

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var grid = grid
    var count = 0
    while true {
        let (i, j) = findFirst(grid: grid, capacity: capacity)
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity: capacity, from: (i, j))
        if i == -1 {
            break
        }
        let (i, j) = findFirst(grid: grid, capacity:

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var count = 0
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                count += 1
            }
        }
        if count > 0 {
            maxFill += 1
            capacity -= count
        }
    }
    return maxFill
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var maxFill = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var count = 0
        while!row.isEmpty {
            if row.removeFirst() == 1 {
                count += 1
            }
        }
        if count > 0 {
            maxFill += 1
            capacity -= count
        }
    }
    return maxFill
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.allSatisfy({ $0.allSatisfy({ $0 == 0 }) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == 0 {
                        grid[i][j] = 0
                        count += 1
                    } else {
                        grid[i][j] = 0
                        grid[i - 1][j] = 1
                        count += 1
                    }
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.allSatisfy({ $0.allSatisfy({ $0 == 0 }) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    if i == 0 {
                        grid[i][j] = 0
                        count += 1
                    } else {
                        grid[i][j] = 0
                        grid[i - 1][j] = 1
                        count += 1
                    }
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here.
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here.
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var index = 0
        while index < row.count {
            if row[index] == 1 {
                row[index] = 0
                count += 1
                capacity -= 1
                if capacity == 0 {
                    break
                }
            }
            index += 1
        }
        if capacity == 0 {
            break
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        var row = grid.removeFirst()
        var index = 0
        while index < row.count {
            if row[index] == 1 {
                row[index] = 0
                count += 1
                capacity -= 1
                if capacity == 0 {
                    break
                }
            }
            index += 1
        }
        if capacity == 0 {
            break
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while!grid.isEmpty {
        var newGrid = [[Int]]()
        for row in grid {
            var newRow = [Int]()
            for i in 0..<row.count {
                if row[i] == 1 {
                    newRow.append(0)
                } else {
                    newRow.append(1)
                }
            }
            newGrid.append(newRow)
        }
        grid = newGrid
        count += 1
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while!grid.isEmpty {
        var newGrid = [[Int]]()
        for row in grid {
            var newRow = [Int]()
            for i in 0..<row.count {
                if row[i] == 1 {
                    newRow.append(0)
                } else {
                    newRow.append(1)
                }
            }
            newGrid.append(newRow)
        }
        grid = newGrid
        count += 1
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while grid.count > 0 {
        var row = grid.removeFirst()
        while row.count > 0 {
            let cell = row.removeFirst()
            if cell == 1 {
                count += 1
                capacity -= 1
            }
            if capacity == 0 {
                break
            }
        }
        if capacity == 0 {
            break
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while grid.count > 0 {
        var row = grid.removeFirst()
        while row.count > 0 {
            let cell = row.removeFirst()
            if cell == 1 {
                count += 1
                capacity -= 1
            }
            if capacity == 0 {
                break
            }
        }
        if capacity == 0 {
            break
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        for i in 0..<grid.count {
            if grid[i].contains(1) {
                for j in 0..<grid[i].count {
                    if grid[i][j] == 1 {
                        grid[i][j] = 0
                        capacity -= 1
                        if capacity == 0 {
                            capacity = 1
                            count += 1
                            break
                        }
                    }
                }
            }
        }
        grid.removeFirst()
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    while!grid.isEmpty {
        for i in 0..<grid.count {
            if grid[i].contains(1) {
                for j in 0..<grid[i].count {
                    if grid[i][j] == 1 {
                        grid[i][j] = 0
                        capacity -= 1
                        if capacity == 0 {
                            capacity = 1
                            count += 1
                            break
                        }
                    }
                }
            }
        }
        grid.removeFirst()
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your code here
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                if j + capacity < grid[i].count {
                    grid[i][j...j+capacity] = Array(repeating: 0, count: capacity+1)
                } else {
                    grid[i][j...] = Array(repeating: 0, count: grid[i].count - j)
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                if j + capacity < grid[i].count {
                    grid[i][j...j+capacity] = Array(repeating: 0, count: capacity+1)
                } else {
                    grid[i][j...] = Array(repeating: 0, count: grid[i].count - j)
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                capacity -= 1
                if capacity == 0 {
                    capacity = 1
                    count += 1
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    var capacity = capacity
    for i in 0..<grid.count {
        for j in 0..<grid[i].count {
            if grid[i][j] == 1 {
                count += 1
                capacity -= 1
                if capacity == 0 {
                    capacity = 1
                    count += 1
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while grid.contains(where: { $0.contains(1) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    count += 1
                    if capacity == 1 {
                        return count
                    }
                    for k in 1..<capacity {
                        if i + k < grid.count {
                            grid[i + k][j] = 0
                        }
                    }
                }
            }
        }
    }
    return count
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var count = 0
    var grid = grid
    while grid.contains(where: { $0.contains(1) }) {
        for i in 0..<grid.count {
            for j in 0..<grid[i].count {
                if grid[i][j] == 1 {
                    grid[i][j] = 0
                    count += 1
                    if capacity == 1 {
                        return count
                    }
                    for k in 1..<capacity {
                        if i + k < grid.count {
                            grid[i + k][j] = 0
                        }
                    }
                }
            }
        }
    }
    return count
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = Array(repeating: capacity, count: grid[0].count)
    for row in grid {
        for (i, well) in row.enumerated() {
            if well == 1 {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    result += 1
                    buckets[i] = capacity
                }
            }
        }
    }
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    var result = 0
    var buckets = Array(repeating: capacity, count: grid[0].count)
    for row in grid {
        for (i, well) in row.enumerated() {
            if well == 1 {
                buckets[i] -= 1
                if buckets[i] == 0 {
                    result += 1
                    buckets[i] = capacity
                }
            }
        }
    }
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your solution here
    var result = 0
    var count = 0
    var bucket = capacity
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 0 {
                count += 1
            }
            if row[i] == 1 {
                if bucket == 0 {
                    result += 1
                    bucket = capacity
                }
                bucket -= 1
            }
        }
    }
    result += count
    return result
}

```swift
// You are given a rectangular grid of wells. Each row represents a single well,
// and each 1 in a row represents a single unit of water.
// Each well has a corresponding bucket that can be used to extract water from it, 
// and all buckets have the same capacity.
// Your task is to use the buckets to empty the wells.
// Output the number of times you need to lower the buckets.
// Example 1:
// Example 2:
// Example 3:
// Constraints:
// * all wells have the same length
// * 1 <= grid.length <= 10^2
// * 1 <= grid[:,1].length <= 10^2
// * grid[i][j] -> 0 | 1
// * 1 <= capacity <= 10
// maxFill(grid: [[0, 0, 1, 0], [0, 1, 0, 0], [1, 1, 1, 1]], capacity: 1) == 6
// maxFill(grid: [[0, 0, 1, 1], [0, 0, 0, 0], [1, 1, 1, 1], [0, 1, 1, 1]], capacity: 2) == 5
// maxFill(grid: [[0, 0, 0], [0, 0, 0]], capacity: 5) == 0
func maxFill(grid: [[Int]], capacity: Int) -> Int {
    // Write your solution here
    var result = 0
    var count = 0
    var bucket = capacity
    for row in grid {
        for i in 0..<row.count {
            if row[i] == 0 {
                count += 1
            }
            if row[i] == 1 {
                if bucket == 0 {
                    result += 1
                    bucket = capacity
                }
                bucket -= 1
            }
        }
    }
    result += count
    return result
}
```

func maxFill(grid: [[Int]], capacity: Int) -> Int {
    
}