using System;
using System.Collections.Generic;
using System.Linq;

using static Constans;
using static Common;

public static class Common
{
    public static void CountAdd<T>(this Dictionary<T, ModInt> dict, T key, ModInt v)
    {
        if (dict.ContainsKey(key))
        {
            dict[key] += v;
        }
        else
        {
            dict[key] = v;
        }
    }
}

public static class Constans
{
    public const long Mod = (long)1e9 + 7;
}

public struct ModInt
{
    public long Num;

    public ModInt(long num)
    {
        Num = num;
    }

    // x^n
    public static long Power(long x, long n)
    {
        long pow = 1;
        while (n > 0)
        {
            if (n % 2 == 0)
            {
                x *= x;
                x %= Mod;
                n /= 2;
            }
            else
            {
                pow *= x;
                pow %= Mod;
                n--;
            }
        }

        return pow;
    }

    public static ModInt GetInv(long f)
    {
        // フェルマーの小定理 a^(-1) = a^(mod-2)
        return new ModInt(Power(f, Mod - 2));
    }

    public ModInt GetInv()
    {
        return GetInv(Num);
    }

    public override string ToString()
    {
        return Num.ToString();
    }

    public static ModInt operator +(ModInt l, ModInt r)
    {
        l.Num += r.Num;
        if (l.Num >= Mod)
        {
            l.Num -= Mod;
        }
        return l;
    }

    public static ModInt operator -(ModInt l, ModInt r)
    {
        l.Num -= r.Num;
        if (l.Num < 0)
        {
            l.Num += Mod;
        }
        return l;
    }

    public static ModInt operator *(ModInt l, ModInt r)
    {
        return new ModInt(l.Num * r.Num % Mod);
    }

    public static implicit operator ModInt(long n)
    {
        n %= Mod;
        if (n < 0)
        {
            n += Mod;
        }
        return new ModInt(n);
    }
}

public struct State
{
    public int[] Colors;

    public State(int[] colors)
    {
        Colors = colors;
    }

    public override bool Equals(object obj)
    {
        if (!(obj is State))
        {
            return false;
        }
        return ((State)obj).Colors.SequenceEqual(Colors);
    }

    public override int GetHashCode()
    {
        return (Colors[0] << 16) ^ (Colors[1] << 8) ^ Colors[2];
    }

    public static bool operator ==(State left, State right)
    {
        return left.Equals(right);
    }

    public static bool operator !=(State left, State right)
    {
        return !(left == right);
    }
}

public class Solution
{

    public static void Main()
    {
        var N = int.Parse(Console.ReadLine());
        var A = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

        Dictionary<State, ModInt> current = new Dictionary<State, ModInt>();

        current.Add(new State(new int[3]), 1);
        foreach (var a in A)
        {
            var next = new Dictionary<State, ModInt>();
            foreach (var cur in current)
            {
                for (int i = 0; i < 3; i++)
                {
                    if (cur.Key.Colors[i] == a)
                    {
                        var colors = cur.Key.Colors.ToArray();
                        colors[i]++;
                        var st = new State(colors);
                        next.CountAdd(st, cur.Value);
                    }
                }
            }
            current = next;
        }

        if (current.Count == 0)
        {
            Console.WriteLine(0);
            return;
        }

        var sum = current.Values.Aggregate((a, b) => a + b);
        Console.WriteLine(sum);
    }
}

Measured memory_bytes: 27704