#include <iostream>
#include <initializer_list>
#include <algorithm>
#include <vector>
#include <functional>
#include <stdexcept>
#include <list>

template<typename TipE1, template<typename...>class Kontejner=std::vector>
class Tok
{
    Kontejner<TipE1>kolekcija;
public:
    template<typename TipE12, template<typename...>class Kontejner2>
    friend class Tok;
    template<typename IterTip>
    Tok(IterTip pocetak, const IterTip iza_kraja)
    {
        auto ito=std::begin(kolekcija);
        while(pocetak!=iza_kraja)
        {
            ito=kolekcija.insert(ito, *pocetak);
            pocetak++;
        }
        std::reverse(std::begin(kolekcija), std::end(kolekcija));
    }
    template<typename IterabilniKontejner>
    Tok(const IterabilniKontejner &kontejner)
    {
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(kontejner);
        while(ito2!=std::end(kontejner))
        {
            ito1=kolekcija.insert(ito1, *ito2);
            ito2++;
        }
        std::reverse(std::begin(kolekcija), std::end(kolekcija));
    }
    Tok(std::initializer_list<TipE1>lista)
    {
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(lista);
        while(ito2!=std::end(lista))
        {
            ito1=kolekcija.insert(ito1, *ito2);
            ito2++;
        }
        std::reverse(std::begin(kolekcija), std::end(kolekcija));
    }
    static Tok<TipE1, Kontejner>Opseg(TipE1 poc, TipE1 kraj, TipE1 korak=1)
    {
        Tok povratni{};
        auto ito=std::begin(povratni.kolekcija);
        for(int i=poc; i<=kraj; i+=korak)
        {
            ito=povratni.kolekcija.insert(ito, poc);
        }
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    unsigned int Velicina()const
    {
        unsigned int povratni=0;
        auto ito=std::begin(kolekcija);
        while(ito!=std::end(kolekcija))
        {
            povratni++;
            ito++;
        }
        return povratni;
    }
    bool Prazan()const
    {
        return std::begin(kolekcija)==std::end(kolekcija);
    }
    Tok<TipE1, Kontejner>Limitiraj(unsigned int n)const
    {
        if(n==Velicina())
        {
            return *this;
        }
        Tok povratni{};
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(povratni.kolekcija);
        for(int i=0; i<n; i++)
        {
            ito2=povratni.kolekcija.insert(ito2, *ito1);
            ito1++;
        }
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    Tok<TipE1, Kontejner>Preskoci(unsigned int n)const
    {
        Tok povratni{};
        if(n>Velicina()) return povratni;
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(povratni.kolekcija);
        for(int i=0; i<n; i++) ito1++;
        while(ito1!=std::end(kolekcija))
        {
            ito2=povratni.kolekcija.insert(ito2, *ito1);
            ito1++;
        }
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    Tok<TipE1, Kontejner>Obrnut()const
    {
        Tok povratni{};
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(povratni.kolekcija);
        while(ito1!=std::end(kolekcija))
        {
            ito2=povratni.kolekcija.insert(ito2, *ito1);
            ito1++;
        }
        return povratni;
    }
    Tok<TipE1, Kontejner>Akcija(std::function<void(void)>akcija)const
    {
        Tok povratni{};
        auto ito1=std::begin(kolekcija);
        auto ito2=std::begin(povratni.kolekcija);
        while(ito1!=std::end(kolekcija))
        {
            ito2=povratni.kolekcija.insert(ito2, *ito1);
            ito1++;
        }
        akcija();
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    void ZaSvaki(std::function<void(TipE1)> akcija)const
    {
        std::for_each(std::begin(kolekcija), std::end(kolekcija), akcija);
    }
    Tok<TipE1, Kontejner>Filtriraj(std::function<bool(TipE1)>predikat)const
    {
        Tok povratni{};
        auto ito1=std::begin(povratni.kolekcija);
        auto ito2=std::begin(kolekcija);
        while(ito2!=std::end(kolekcija))
        {
            if(predikat(*ito2))
            {
                ito1=povratni.kolekcija.insert(ito1, *ito2);
            }
            ito2++;
        }
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    TipE1 PronadjiPrvi()const
    {
        if(Velicina()==0) throw std::logic_error("Tok je prazan");
        return *std::begin(kolekcija);
    }
    TipE1 PronadjiPosljednji()const
    {
        if(Velicina()==0) throw std::logic_error("Tok je prazan");
        auto ito=std::end(kolekcija);
        ito--;
        return *ito;
    }
    bool ZadovoljavaBaremJedan(std::function<bool(TipE1)>kriterij)const
    {
        auto ito=std::begin(kolekcija);
        while(ito!=std::end(kolekcija))
        {
            if(kriterij(*ito)) return true;
            ito++;
        }
        return false;
    }
    bool ZadovoljavaNijedan(std::function<bool(TipE1)>kriterij)const
    {
        auto ito=std::begin(kolekcija);
        while(ito!=std::end(kolekcija))
        {
            if(kriterij(*ito)) return false;
            ito++;
        }
        return true;
    }
    bool ZadovoljavajuSvi(std::function<bool(TipE1)>kriterij)const
    {
        auto ito=std::begin(kolekcija);
        while(ito!=std::end(kolekcija))
        {
            if(!kriterij(*ito)) return false;
            ito++;
        }
        return true;
    }
    TipE1 Akumuliraj(TipE1 inicijalna, std::function<TipE1(TipE1, TipE1)>akumulator)const
    {
        if(Velicina()==0) return inicijalna;
        auto ito=std::begin(kolekcija);
        TipE1 povratna;
        povratna=akumulator(inicijalna, *ito);
        ito++;
        while(ito!=std::end(kolekcija))
        {
            povratna=akumulator(povratna, *ito);
            ito++;
        }
        return povratna;
    }
    TipE1 Akumuliraj(std::function<TipE1(TipE1, TipE1)>akumulator)const
    {
        if(Velicina()==0) throw std::logic_error("Tok je prazan");
        auto ito1=std::begin(kolekcija);
        if(Velicina()==1) return *ito1;
        auto ito2=std::begin(kolekcija);
        ito2++;
        TipE1 povratna;
        povratna=akumulator(*ito1, *ito2);
        ito2++;
        while(ito2!=std::end(kolekcija))
        {
            povratna=akumulator(povratna, *ito2);
            ito2++;
        }
        return povratna;
    }
    Tok<TipE1, Kontejner>Sortirano(std::function<bool(TipE1, TipE1)>komparator=
    [](TipE1 x, TipE1 y){return x<y;})const
    {
        Tok povratni{};
        auto ito1=std::begin(povratni.kolekcija);
        auto ito2=std::begin(kolekcija);
        while(ito2!=std::end(kolekcija))
        {
            ito1=povratni.kolekcija.insert(ito1, *ito2);
            ito2++;
        }
        std::sort(std::begin(povratni), std::end(povratni), komparator);
        return povratni;
    }
    Tok<TipE1, Kontejner>Unikatno(std::function<bool(TipE1, TipE1)>komparator=
    [](TipE1 x, TipE1 y){return x==y;})const
    {
        Tok povratni{};
        auto ito1=std::begin(povratni.kolekcija);
        auto ito2=std::begin(kolekcija);
        while(ito2!=std::end(kolekcija))
        {
            auto ito3=std::begin(povratni.kolekcija);
            bool provjera(true);
            while(ito3!=std::end(povratni.kolekcija))
            {
                if(komparator(*ito2, *ito3))
                {
                    provjera=false;
                    break;
                }
                ito3++;
            }
            if(provjera==true)
            {
                ito1=povratni.kolekcija.insert(ito1, *ito2);
            }
            ito2++;
        }
        std::reverse(std::begin(povratni.kolekcija), std::end(povratni.kolekcija));
        return povratni;
    }
    Tok<TipE1, Kontejner>Proviri(std::function<void(TipE1)>akcija)const
    {
        Tok povratni{};
        std::copy(std::begin(kolekcija), std::end(kolekcija), povratni);
        std::for_each(std::begin(kolekcija), std::end(kolekcija), akcija);
        return povratni;
    }
    TipE1 Minimalan(std::function<bool(TipE1, TipE1)>komparator=
    [](TipE1 x, TipE1 y){return x<y;})const
    {
        if(Velicina()==0) throw std::logic_error("Tok je prazan");
        auto it=std::min_element(std::begin(kolekcija), std::end(kolekcija), komparator);
        return *it;
    }
    TipE1 Maksimalan(std::function<bool(TipE1, TipE1)>komparator=
    [](TipE1 x, TipE1 y){return x>y;})const
    {
        if(Velicina()==0) throw std::logic_error("Tok je prazan");
        auto it=std::min_element(std::begin(kolekcija), std::end(kolekcija), komparator);
        return *it;
    }
    template<typename Kont2>
    Kont2 Sakupi(std::function<void(Kont2 &, TipE1)>kombinator)const
    {
        std::for_each(std::begin(kolekcija), std::end(kolekcija), std::bind(kombinator, povratna, std::placeholders::_1 ))
        return povratni;

    }
   template<typename TipE12>
    Tok<TipE12, Kontejner> Mapiraj(std::function<TipE12(TipE1)>maper)const
    {
        Kontejner<TipE12>povratni;
        for(auto ito=std::begin(kolekcija); ito!=std::end(kolekcija); ito++)
        {
            ito=povratni.insert(std::begin(povratni), maper(*ito));
        }
        std::reverse(std::begin(povratni), std::end(povratni));
        Tok<TipE12, Kontejner>vrati(std::begin(povratni), std::end(povratni));
        return vrati;

    }
    template<typename TipE12>
    Tok<TipE12, Kontejner> MapirajPoravnato(
        std::function<Tok<TipE12, Kontejner>(TipE1)>maper)const*/

};

int main ()
{

	std::cout << Tok<int>{1, 500, 8, 100}.Maksimalan()<<std::endl;
    std::cout << Tok<int>{111, 7, 8, 100}.Minimalan();

	return 0;
}