using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Dijkstra
{
    public class DijkstraData
    {
        public Node Previous { get; set; }
        public double Price { get; set; }
    }

    public class Program
    {
        public static Tuple<double, List<Node>> Dijkstra(Graph graph, Dictionary<Edge, double> weights, Node start, Node end)
        {
            var notVisited = graph.Nodes.ToList();
            var track = new Dictionary<Node, DijkstraData>();
            track.Add(start, new DijkstraData() { Price = 1, Previous = null });

            while (true)
            {
                Node toOpen = null;
                var bestPrice = double.PositiveInfinity;
                foreach (var e in notVisited)
                {
                    if (track.ContainsKey(e) && track[e].Price < bestPrice)
                    {
                        bestPrice = track[e].Price;
                        toOpen = e;
                    }
                }

                if (toOpen == (null)) return null;
                if (toOpen.Equals(end)) break;

                foreach (var e in toOpen.IncidentEdges.Where(z => z.From.Equals(toOpen)))
                {
                    var currentPrice = track[toOpen].Price * weights[e];
                    var nextNode = e.OtherNode(toOpen);
                    if (!track.ContainsKey(nextNode) || track[nextNode].Price > currentPrice)
                    {
                        track[nextNode] = new DijkstraData { Previous = toOpen, Price = currentPrice };
                    }
                }

                notVisited.Remove(toOpen);
            }

            var result = new List<Node>();
            var weight = track[end].Price;
            while (end != null)
            {
                result.Add(end);
                end = track[end].Previous;
            }
            result.Reverse();
            return Tuple.Create(weight, result);
        }
        public static void Main()
        {
            var tuple = ReadInput();
            var resultTuple = Dijkstra(tuple.Item1, tuple.Item2, tuple.Item3, tuple.Item4);
            WriteOut(resultTuple);
        }

        public static Tuple<Graph, Dictionary<Edge, double>, Node, Node> ReadInput()
        {
            Graph graph = null;
            var weight = new Dictionary<Edge, double>();
            Node start = null;
            Node end = null;
            using (var stream = new StreamReader("in.txt"))
            {
                var nodeNumber = int.Parse(stream.ReadLine());
                var currNode = 0;
                graph = new Graph(nodeNumber);
                while (currNode < nodeNumber)
                {
                    var str = stream.ReadLine();
                    var splitted = str.Split(' ');
                    for (var j = 0; j < splitted.Length - 1; j ++)
                    {
                        weight.Add(graph.Connect(currNode, j), Convert.ToDouble(splitted[j]));
                    }
                    currNode++;

                }
                start = new Node(int.Parse(stream.ReadLine()) - 1);
                end = new Node(int.Parse(stream.ReadLine()) - 1);
            }
            return Tuple.Create(graph, weight, start, end);

        }

        public static void WriteOut(Tuple<double, List<Node>> resultTuple)
        {
            var result = new List<string>();
            if (resultTuple == null)
                File.WriteAllText("out.txt", "N");
            else
            {
                result.Add("Y");
                var str = new StringBuilder();
                foreach (var e in resultTuple.Item2)
                {
                    str.Append(e.NodeNumber + 1);
                    str.Append(" ");
                }
                result.Add(str.ToString());
                result.Add(resultTuple.Item1.ToString());
                File.WriteAllLines("out.txt", result);
            }
        }
    }

    public class Edge
    {
        public readonly Node From;
        public readonly Node To;
        public Edge(Node first, Node second)
        {
            this.From = first;
            this.To = second;
        }
        public bool IsIncident(Node node)
        {
            return From == node || To == node;
        }
        public Node OtherNode(Node node)
        {
            if (!IsIncident(node)) throw new ArgumentException();
            if (From == node) return To;
            return From;
        }
    }

    public class Node
    {
        private readonly List<Edge> edges = new List<Edge>();
        public readonly int NodeNumber;

        public Node(int number)
        {
            NodeNumber = number;
        }

        public IEnumerable<Node> IncidentNodes
        {
            get { return edges.Select(z => z.OtherNode(this)); }
        }

        public IEnumerable<Edge> IncidentEdges
        {
            get { foreach (var e in edges) yield return e; }
        }

        public static Edge Connect(Node node1, Node node2, Graph graph)
        {
            if (!graph.Nodes.Contains(node1) || !graph.Nodes.Contains(node2)) throw new ArgumentException();
            var edge = new Edge(node1, node2);
            node1.edges.Add(edge);
            node2.edges.Add(edge);
            return edge;
        }

        public static void Disconnect(Edge edge)
        {
            edge.From.edges.Remove(edge);
            edge.To.edges.Remove(edge);
        }

        public override bool Equals(object obj)
        {
            if (obj is Node)
            {
                var node = (Node)obj;
                return node.NodeNumber == NodeNumber;
            }
            return false;
        }

        public override int GetHashCode()
        {
            return NodeNumber.GetHashCode();
        }
    }

    public class Graph
    {
        private Node[] nodes;

        public Graph(int nodesCount)
        {
            nodes = Enumerable.Range(0, nodesCount).Select(z => new Node(z)).ToArray();
        }

        public int Length => nodes.Length;

        public Node this[int index] { get { return nodes[index]; } }


        public IEnumerable<Node> Nodes
        {
            get
            {
                foreach (var node in nodes) yield return node;
            }
        }

        public Edge Connect(int index1, int index2)
        {
            return Node.Connect(nodes[index1], nodes[index2], this);
        }

        public void Delete(Edge edge)
        {
            Node.Disconnect(edge);
        }

        public IEnumerable<Edge> Edges
        {
            get
            {
                return nodes.SelectMany(z => z.IncidentEdges).Distinct();
            }
        }

        public static Graph MakeGraph(params int[] incidentNodes)
        {
            var graph = new Graph(incidentNodes.Max() + 1);
            for (int i = 0; i < incidentNodes.Length - 1; i += 2)
                graph.Connect(incidentNodes[i], incidentNodes[i + 1]);
            return graph;
        }
    }
}