```go
package main

import "fmt"

const MOD = 1000000007

func main() {
	var n int
	fmt.Scan(&n)
	grid := make([]string, 3)
	for i := 0; i < 3; i++ {
		fmt.Scan(&grid[i])
	}
	var ro, co int
	for i := 0; i < 3; i++ {
		for j := 0; j < n; j++ {
			if grid[i][j] == 'O' {
				ro = i
				co = j
			}
		}
	}
	active := make([]int, n)
	for j := 0; j < n; j++ {
		for r := 0; r < 3; r++ {
			if grid[r][j] == '.' {
				active[j] |= 1 << r
			}
		}
	}

	compute := func(avoid bool) int64 {
		dp := make([][]int64, n+1)
		for i := range dp {
			dp[i] = make([]int64, 8)
		}
		dp[0][0] = 1
		var cover func(int, int, int, int, int64)
		cover = func(j, cur_row, remain, cur_out int, ways int64) {
			if cur_row == 3 {
				ok := true
				if avoid {
					bit := 1 << ro
					if co >= 2 && j == co-2 && (cur_out&bit) != 0 {
						ok = false
					}
					if co+2 < n && j == co+1 && (cur_out&bit) != 0 {
						ok = false
					}
				}
				if ok {
					dp[j+1][cur_out] = (dp[j+1][cur_out] + ways) % MOD
				}
				return
			}
			if (remain & (1 << cur_row)) == 0 {
				cover(j, cur_row+1, remain, cur_out, ways)
				return
			}
			// horizontal
			new_out := cur_out | (1 << cur_row)
			cover(j, cur_row+1, remain&^(1<<cur_row), new_out, ways)
			// vertical
			if cur_row+1 < 3 && (remain&(1<<(cur_row+1))) != 0 {
				forbidden := false
				if avoid && j == co {
					if cur_row == 0 && ro == 2 {
						forbidden = true
					}
					if cur_row == 1 && ro == 0 {
						forbidden = true
					}
				}
				if !forbidden {
					new_remain := remain & ^((1 << cur_row) | (1 << (cur_row + 1)))
					cover(j, cur_row+2, new_remain, cur_out, ways)
				}
			}
		}
		for j := 0; j < n; j++ {
			for inn := 0; inn < 8; inn++ {
				way := dp[j][inn]
				if way == 0 {
					continue
				}
				if (inn & ^active[j]) != 0 {
					continue
				}
				need := active[j] & ^inn
				cover(j, 0, need, 0, way)
			}
		}
		return dp[n][0]
	}

	total := compute(false)
	none := compute(true)
	ans := (total - none + MOD) % MOD
	fmt.Println(ans)
}
```