#include <iostream>

using namespace std;

template<typename E>
class DLinkedList
 { 
     private :
            struct DNode { E elem; DNode* prev; DNode* next;};
                    DNode *header , *trailer;
                            int numberOfElements;

                                    public:
                                            DLinkedList(){
                                                    header = new DNode;
                                                            trailer = new DNode;
                                                                    header ->next = trailer;
                                                                            trailer ->prev = header;
                                                                                    numberOfElements = 0;}
                                                                                          //  virtual ~DLinkedList(); 

                                                                                               class Iterator{ 
                                                                                                   private : 
                                                                                                       DNode* current; 

                                                                                                               public: 
                                                                                                                   Iterator(DNode* u){ current = u; };

                                                                                                                        E& operator*(){ return current->elem; }

                                                                                                                                     Iterator& operator++() 
                                                                                                                                            {
                                                                                                                                                        current = current->next;
                                                                                                                                                                    return *this;
                                                                                                                                                                            } 
                                                                                                                                                                                 Iterator& operator -- ()
                                                                                                                                                                                         {
                                                                                                                                                                                                     current = current->prev;
                                                                                                                                                                                                                 return *this;
                                                                                                                                                                                                                         } // move backward 
                                                                                                                                                                                                                              bool operator == (const Iterator& it) const
                                                                                                                                                                                                                                   {
                                                                                                                                                                                                                                            return current == it.current;
                                                                                                                                                                                                                                                 }
                                                                                                                                                                                                                                                      bool operator != (const Iterator& it) const
                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                   return current != it.current;
                                                                                                                                                                                                                                                                       }
                                                                                                                                                                                                                                                                            friend class DLinkedList;
                                                                                                                                                                                                                                                                                 };


                                                                                                                                                                                                                                                                                            bool empty() const { return (numberOfElements == 0); } 

                                                                                                                                                                                                                                                                                                            int size() const { return numberOfElements; } 

                                                                                                                                                                                                                                                                                                                          E& front() const { return header ->next ->elem; }
                                                                                                                                                                                                                                                                                                                                  E& back() const { return trailer ->prev ->elem; }

                                                                                                                                                                                                                                                                                                                                                  void push_front(const E& e)
                                                                                                                                                                                                                                                                                                                                                          {insert(begin(), e);
                                                                                                                                                                                                                                                                                                                                                          } 

                                                                                                                                                                                                                                                                                                                                                                          void push_back(const E& e)
                                                                                                                                                                                                                                                                                                                                                                                  {insert(end(), e);}

                                                                                                                                                                                                                                                                                                                                                                                          void pop_front(){erase(begin());}
                                                                                                                                                                                                                                                                                                                                                                                                  void pop_back(){erase(--end());
                                                                                                                                                                                                                                                                                                                                                                                                  } 
                                                                                                                                                                                                                                                                                                                                                                                                          Iterator begin() const { return Iterator(header ->next); } 
                                                                                                                                                                                                                                                                                                                                                                                                                  Iterator end() const { return Iterator(trailer); } 
                                                                                                                                                                                                                                                                                                                                                                                                                          void insert(const Iterator& it, const E& e)
                                                                                                                                                                                                                                                                                                                                                                                                                                  {

                                                                                                                                                                                                                                                                                                                                                                                                                                                          DNode* w = it.current; // it's node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                      DNode* u = w->prev; // it's predecessor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DNode* v = new DNode; // new node to insert
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              v->elem = e;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          v->next = w; w->prev = v; // link in v before w
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      v->prev = u; u->next = v; // link in v after u
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  numberOfElements++; // one more 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  void erase(const Iterator& it){DNode* v = it.current; // node to remove
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DNode* w = v->next; // successor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          DNode* u = v->prev; // predecessor
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      u->next = w; w->prev = u; // unlink p
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  delete v; // delete this node
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              numberOfElements --;}

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          };


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    template <typename E>
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          bool containsSublist(DLinkedList<E>& L,DLinkedList<E>& S)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                {   if (S.empty()) return true;    // Αν η S είναι κενή είναι υπολίστα


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  //Ξεκινάω απο το πρώτο στοιχειο τησ L και τη διατρεχω
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       for (typename DLinkedList<E>::Iterator  it=L.begin(); it != L.end(); ++it)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         // Δεύτερος iterator στη L (για να προχωράμε χωρίς να χάσουμε το it)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 typename DLinkedList<E>::Iterator it2 = it;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         // Iterator για τη S (αρχή της υπολίστας που ψάχνουμε)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 typename DLinkedList<E>::Iterator ot = S.begin();


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          //οσο Δεν τελειώσε η L, δεν τελείωσε η S και Τα στοιχεία είναι ίσα:
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  while (it2 != L.end() && ot != S.end() && *it2 == *ot)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ++it2; // Πήγαινε στο επόμενο στοιχείο της L
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  ++ot;  // Πήγαινε στο επόμενο στοιχείο της S
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (ot == S.end())
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              return true;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      return false;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            bool containsDuplicates(L)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            {containsDuplicates(L)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                // η οποία δέχεται ως παράμετρο μια διπλά συνδεδεμένη λίστα n στοιχείων,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                //και σε O(n2) χρόνο ελέγχει αν αυτή περιέχει τουλάχιστον ένα στοιχείο που επαναλαμβάνεται (σ.σ.,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                //επιστρέφει true στη θετική περίπτωση και false διαφορετικά).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    if(){
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       return true 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       } 
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       }return false


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       }
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       int main()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       {


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               DLinkedList<int> L,S;

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   L.push_back(1);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       L.push_back(2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           L.push_back(3);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               L.push_back(4);

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   S.push_back(2);
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       S.push_back(3);


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              bool result = containsSublist(L, S);


                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  if (result)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          cout << "YES\n";
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              else
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      cout << "NO\n";

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          return 0;
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }