object Main extends App {
  import scala.io.StdIn._
  sealed class Person(val toIndex: Int)

  object J extends Person(1)
  object O extends Person(2)
  object I extends Person(4)
  object Person{
    val persons: List[Person] = List(J, O, I)
  }
  val mod = 10007
  val n = readLine.trim.toInt
  val res = readLine.trim.map{
    case 'J' ⇒ J
    case 'O' ⇒ O
    case _ ⇒ I
  }.toList
  println(
    solve(res, J.toIndex)
  )
  def solve(responsibility: List[Person], prePerson: Int, length: Int = 0)(implicit memo: Array[Array[Option[Int]]] = Array.tabulate(responsibility.length){_ ⇒ Array.tabulate(8){_ ⇒ None: Option[Int]}}): Int = {
    if (memo.length > length){
      memo(length)(prePerson) match {
        case Some(r) ⇒ r
        case None ⇒
          (responsibility match {
            case Nil ⇒ 1
            case h::t if (h.toIndex & prePerson) != 0 ⇒ Person.persons.filter(p ⇒ p != h).subset.map(l ⇒ solve(t, l.map(_.toIndex).foldLeft(h.toIndex){case (a, b) ⇒ a | b}, length + 1)).sum
            case h::t ⇒ Person.persons.filter(p ⇒ p != h).subset.map(l ⇒ l.map(_.toIndex).foldLeft(h.toIndex){case (a, b) ⇒ a | b}).filter(p ⇒ (p & prePerson) != 0).map(p ⇒ solve(t, p, length + 1)).sum
          }).let(_ % mod).also(i ⇒ memo(length)(prePerson) = Some(i))
      }
    }else 1
  }
  implicit class RichList[T](val list: List[T]) {
    def subset: List[List[T]] = subset(list)
    private def subset(li:List[T]): List[List[T]] = {
      li match {
        case Nil ⇒ Nil
        case h::Nil ⇒ List(h::Nil, Nil)
        case h::t ⇒ subset(t).flatMap(l ⇒ List(h::l, l))
      }
    }
  }
  implicit class ScopeFunc[T](value: T){
    def let[A](func: T ⇒ A): A = func(value)
    def also(func: T ⇒ Unit): T = {
      func(value)
      value
    }
  }
}
