Mostra notizie nelle discussioni
  • Avatar
    Scritto da
    Non Autenticato
    il 2008-10-21 22:23:00.0 alle 2008-10-21 22:23:00.0
    pythonisty
    come si può migliorare questo codice?
    deve cercare le posizioni in cui una stringa (pattern senza espressioni regolari) in un'altra stringa data

    tipo come fa re.findall(), ma senza scomodare il motore che sta dietro il matcher delle regex che è lento.
    def allindices(string, sub, listindex=[], offset=0):
        i = string.find(sub, offset)
        while i >= 0:
            listindex.append(i)
            i = string.find(sub, i + 1)
        return listindex
    
    • Avatar
      Scritto da
      Non Autenticato
      il 2008-10-21 22:29:00.0 alle 2008-10-21 22:29:00.0
      Re: pythonisty

      - Scritto da:
      > come si può migliorare questo codice?
      > deve cercare le posizioni in cui una stringa
      > (pattern senza espressioni regolari) in un'altra
      > stringa
      > data
      >
      > tipo come fa re.findall(), ma senza scomodare il
      > motore che sta dietro il matcher delle regex che
      > è
      > lento.
      >
      > def allindices(string, sub, listindex=[],
      > offset=0):
      >     i = string.find(sub, offset)
      >     while i >= 0:
      >         listindex.append(i)
      >         i = string.find(sub, i + 1)
      >     return listindex
      > 


      il python fa cagare, ha l'indentazione obbligatoria
      Immagine postata dall'utente
      • Avatar
        Scritto da
        Non Autenticato
        il 2008-10-21 22:33:00.0 alle 2008-10-21 22:33:00.0
        Re: pythonisty
        - Scritto da:
        >
        > - Scritto da:
        > > come si può migliorare questo codice?
        > > deve cercare le posizioni in cui una stringa
        > > (pattern senza espressioni regolari) in un'altra
        > > stringa
        > > data
        > >
        > > tipo come fa re.findall(), ma senza scomodare il
        > > motore che sta dietro il matcher delle regex che
        > > è
        > > lento.
        > >
        > > def allindices(string, sub, listindex=[],
        > > offset=0):
        > >     i = string.find(sub, offset)
        > >     while i >= 0:
        > >         listindex.append(i)
        > >         i = string.find(sub, i + 1)
        > >     return listindex
        > > 

        >
        > il python fa cagare, ha l'indentazione
        > obbligatoria
        > [img]http://i.somethingawful.com/forumsystem/emoti

        il python è compatto e potente, e ci scrivo bot con 10 righe di codice.
        • Avatar
          Scritto da
          Non Autenticato
          il 2008-10-21 22:35:00.0 alle 2008-10-21 22:35:00.0
          Re: pythonisty

          - Scritto da:
          > - Scritto da:
          > >
          > > - Scritto da:
          > > > come si può migliorare questo codice?
          > > > deve cercare le posizioni in cui una stringa
          > > > (pattern senza espressioni regolari) in
          > un'altra
          > > > stringa
          > > > data
          > > >
          > > > tipo come fa re.findall(), ma senza scomodare
          > il
          > > > motore che sta dietro il matcher delle regex
          > che
          > > > è
          > > > lento.
          > > >
          > > > def allindices(string, sub, listindex=[],
          > > > offset=0):
          > > >     i = string.find(sub, offset)
          > > >     while i >= 0:
          > > >         listindex.append(i)
          > > >         i = string.find(sub, i + 1)
          > > >     return listindex
          > > > 

          > >
          > > il python fa cagare, ha l'indentazione
          > > obbligatoria
          > >
          > Immagine postata dall'utente
          >
          > il python è compatto e potente, e ci scrivo bot
          > con 10 righe di
          > codice.

          Immagine postata dall'utente
        • Avatar
          Scritto da
          Non Autenticato
          il 2008-10-21 22:38:00.0 alle 2008-10-21 22:38:00.0
          Re: pythonisty

          - Scritto da:
          > - Scritto da:
          > >
          > > - Scritto da:
          > > > come si può migliorare questo codice?
          > > > deve cercare le posizioni in cui una stringa
          > > > (pattern senza espressioni regolari) in
          > un'altra
          > > > stringa
          > > > data
          > > >
          > > > tipo come fa re.findall(), ma senza scomodare
          > il
          > > > motore che sta dietro il matcher delle regex
          > che
          > > > è
          > > > lento.
          > > >
          > > > def allindices(string, sub, listindex=[],
          > > > offset=0):
          > > >     i = string.find(sub, offset)
          > > >     while i >= 0:
          > > >         listindex.append(i)
          > > >         i = string.find(sub, i + 1)
          > > >     return listindex
          > > > 

          > >
          > > il python fa cagare, ha l'indentazione
          > > obbligatoria
          > >
          > [img]http://i.somethingawful.com/forumsystem/emoti
          >
          > il python è compatto e potente, e ci scrivo bot
          > con 10 righe di
          > codice.

          ma dai, un linguaggio con l'indentazione obbligatoria non può essere serio, è peggio del visual basic! Rotola dal ridere
          • Avatar
            Scritto da
            Non Autenticato
            il 2008-10-21 22:40:00.0 alle 2008-10-21 22:40:00.0
            Re: pythonisty

            - Scritto da:
            >
            > - Scritto da:
            > > - Scritto da:
            > > >
            > > > - Scritto da:
            > > > > come si può migliorare questo codice?
            > > > > deve cercare le posizioni in cui una stringa
            > > > > (pattern senza espressioni regolari) in
            > > un'altra
            > > > > stringa
            > > > > data
            > > > >
            > > > > tipo come fa re.findall(), ma senza
            > scomodare
            > > il
            > > > > motore che sta dietro il matcher delle regex
            > > che
            > > > > è
            > > > > lento.
            > > > >
            > > > > def allindices(string, sub, listindex=[],
            > > > > offset=0):
            > > > >     i = string.find(sub, offset)
            > > > >     while i >= 0:
            > > > >         listindex.append(i)
            > > > >         i = string.find(sub, i + 1)
            > > > >     return listindex
            > > > > 

            > > >
            > > > il python fa cagare, ha l'indentazione
            > > > obbligatoria
            > > >
            > >
            > [img]http://i.somethingawful.com/forumsystem/emoti
            > >
            > > il python è compatto e potente, e ci scrivo bot
            > > con 10 righe di
            > > codice.
            >
            > ma dai, un linguaggio con l'indentazione
            > obbligatoria non può essere serio, è peggio del
            > visual basic!
            > Rotola dal ridere

            lo diceva anche Eric S. Raymond, poi ha cambiato completamente idea
            • Avatar
              Scritto da
              Non Autenticato
              il 2008-10-21 22:45:00.0 alle 2008-10-21 22:45:00.0
              Re: pythonisty

              - Scritto da:
              >
              > - Scritto da:
              > >
              > > - Scritto da:
              > > > - Scritto da:
              > > > >
              > > > > - Scritto da:
              > > > > > come si può migliorare questo codice?
              > > > > > deve cercare le posizioni in cui una
              > stringa
              > > > > > (pattern senza espressioni regolari) in
              > > > un'altra
              > > > > > stringa
              > > > > > data
              > > > > >
              > > > > > tipo come fa re.findall(), ma senza
              > > scomodare
              > > > il
              > > > > > motore che sta dietro il matcher delle
              > regex
              > > > che
              > > > > > è
              > > > > > lento.
              > > > > >
              > > > > > def allindices(string, sub, listindex=[],
              > > > > > offset=0):
              > > > > >     i = string.find(sub, offset)
              > > > > >     while i >= 0:
              > > > > >         listindex.append(i)
              > > > > >         i = string.find(sub, i + 1)
              > > > > >     return listindex
              > > > > > 

              > > > >
              > > > > il python fa cagare, ha l'indentazione
              > > > > obbligatoria
              > > > >
              > > >
              > >
              > [img]http://i.somethingawful.com/forumsystem/emoti
              > > >
              > > > il python è compatto e potente, e ci scrivo
              > bot
              > > > con 10 righe di
              > > > codice.
              > >
              > > ma dai, un linguaggio con l'indentazione
              > > obbligatoria non può essere serio, è peggio del
              > > visual basic!
              > > Rotola dal ridere
              >
              > lo diceva anche Eric S. Raymond, poi ha cambiato
              > completamente
              > idea

              argumentum ad verecundium
              • Avatar
                Scritto da
                Non Autenticato
                il 2008-10-21 22:47:00.0 alle 2008-10-21 22:47:00.0
                Re: pythonisty

                - Scritto da:
                >
                > - Scritto da:
                > >
                > > - Scritto da:
                > > >
                > > > - Scritto da:
                > > > > - Scritto da:
                > > > > >
                > > > > > - Scritto da:
                > > > > > > come si può migliorare questo codice?
                > > > > > > deve cercare le posizioni in cui una
                > > stringa
                > > > > > > (pattern senza espressioni regolari) in
                > > > > un'altra
                > > > > > > stringa
                > > > > > > data
                > > > > > >
                > > > > > > tipo come fa re.findall(), ma senza
                > > > scomodare
                > > > > il
                > > > > > > motore che sta dietro il matcher delle
                > > regex
                > > > > che
                > > > > > > è
                > > > > > > lento.
                > > > > > >
                > > > > > > def allindices(string, sub,
                > listindex=[],
                > > > > > > offset=0):
                > > > > > >     i = string.find(sub, offset)
                > > > > > >     while i >= 0:
                > > > > > >         listindex.append(i)
                > > > > > >         i = string.find(sub, i + 1)
                > > > > > >     return listindex
                > > > > > > 

                > > > > >
                > > > > > il python fa cagare, ha l'indentazione
                > > > > > obbligatoria
                > > > > >
                > > > >
                > > >
                > >
                > [img]http://i.somethingawful.com/forumsystem/emoti
                > > > >
                > > > > il python è compatto e potente, e ci scrivo
                > > bot
                > > > > con 10 righe di
                > > > > codice.
                > > >
                > > > ma dai, un linguaggio con l'indentazione
                > > > obbligatoria non può essere serio, è peggio
                > del
                > > > visual basic!
                > > > Rotola dal ridere
                > >
                > > lo diceva anche Eric S. Raymond, poi ha cambiato
                > > completamente
                > > idea
                >
                > argumentum ad verecundium

                prendila come vuoi (anche in culo) volevo sottolineare che l'obiezione che alzi non è certo originale
                • Avatar
                  Scritto da
                  Non Autenticato
                  il 2008-10-21 22:53:00.0 alle 2008-10-21 22:53:00.0
                  Re: pythonisty

                  - Scritto da:
                  >
                  > - Scritto da:
                  > >
                  > > - Scritto da:
                  > > >
                  > > > - Scritto da:
                  > > > >
                  > > > > - Scritto da:
                  > > > > > - Scritto da:
                  > > > > > >
                  > > > > > > - Scritto da:
                  > > > > > > > come si può migliorare questo codice?
                  > > > > > > > deve cercare le posizioni in cui una
                  > > > stringa
                  > > > > > > > (pattern senza espressioni regolari)
                  > in
                  > > > > > un'altra
                  > > > > > > > stringa
                  > > > > > > > data
                  > > > > > > >
                  > > > > > > > tipo come fa re.findall(), ma senza
                  > > > > scomodare
                  > > > > > il
                  > > > > > > > motore che sta dietro il matcher delle
                  > > > regex
                  > > > > > che
                  > > > > > > > è
                  > > > > > > > lento.
                  > > > > > > >
                  > > > > > > > def allindices(string, sub,
                  > > listindex=[],
                  > > > > > > > offset=0):
                  > > > > > > >     i = string.find(sub, offset)
                  > > > > > > >     while i >= 0:
                  > > > > > > >         listindex.append(i)
                  > > > > > > >         i = string.find(sub, i + 1)
                  > > > > > > >     return listindex
                  > > > > > > > 

                  > > > > > >
                  > > > > > > il python fa cagare, ha l'indentazione
                  > > > > > > obbligatoria
                  > > > > > >
                  > > > > >
                  > > > >
                  > > >
                  > >
                  > Immagine postata dall'utente
                  > > > > >
                  > > > > > il python è compatto e potente, e ci
                  > scrivo
                  > > > bot
                  > > > > > con 10 righe di
                  > > > > > codice.
                  > > > >
                  > > > > ma dai, un linguaggio con l'indentazione
                  > > > > obbligatoria non può essere serio, è peggio
                  > > del
                  > > > > visual basic!
                  > > > > Rotola dal ridere
                  > > >
                  > > > lo diceva anche Eric S. Raymond, poi ha
                  > cambiato
                  > > > completamente
                  > > > idea
                  > >
                  > > argumentum ad verecundium
                  >
                  > prendila come vuoi (anche in culo) volevo
                  > sottolineare che l'obiezione che alzi non è certo
                  > originale

                  Immagine postata dall'utente
                  • Avatar
                    Scritto da
                    Non Autenticato
                    il 2008-10-21 22:56:00.0 alle 2008-10-21 22:56:00.0
                    Re: pythonisty
                    - Scritto da:
                    >
                    > - Scritto da:
                    > >
                    > > - Scritto da:
                    > > >
                    > > > - Scritto da:
                    > > > >
                    > > > > - Scritto da:
                    > > > > >
                    > > > > > - Scritto da:
                    > > > > > > - Scritto da:
                    > > > > > > >
                    > > > > > > > - Scritto da:
                    > > > > > > > > come si può migliorare questo
                    > codice?
                    > > > > > > > > deve cercare le posizioni in cui una
                    > > > > stringa
                    > > > > > > > > (pattern senza espressioni regolari)
                    > > in
                    > > > > > > un'altra
                    > > > > > > > > stringa
                    > > > > > > > > data
                    > > > > > > > >
                    > > > > > > > > tipo come fa re.findall(), ma senza
                    > > > > > scomodare
                    > > > > > > il
                    > > > > > > > > motore che sta dietro il matcher
                    > delle
                    > > > > regex
                    > > > > > > che
                    > > > > > > > > è
                    > > > > > > > > lento.
                    > > > > > > > >
                    > > > > > > > > def allindices(string, sub,
                    > > > listindex=[],
                    > > > > > > > > offset=0):
                    > > > > > > > >     i = string.find(sub, offset)
                    > > > > > > > >     while i >= 0:
                    > > > > > > > >         listindex.append(i)
                    > > > > > > > >         i = string.find(sub, i + 1)
                    > > > > > > > >     return listindex
                    > > > > > > > > 

                    > > > > > > >
                    > > > > > > > il python fa cagare, ha l'indentazione
                    > > > > > > > obbligatoria
                    > > > > > > >
                    > > > > > >
                    > > > > >
                    > > > >
                    > > >
                    > >
                    > [img]http://i.somethingawful.com/forumsystem/emoti
                    > > > > > >
                    > > > > > > il python è compatto e potente, e ci
                    > > scrivo
                    > > > > bot
                    > > > > > > con 10 righe di
                    > > > > > > codice.
                    > > > > >
                    > > > > > ma dai, un linguaggio con l'indentazione
                    > > > > > obbligatoria non può essere serio, è
                    > peggio
                    > > > del
                    > > > > > visual basic!
                    > > > > > Rotola dal ridere
                    > > > >
                    > > > > lo diceva anche Eric S. Raymond, poi ha
                    > > cambiato
                    > > > > completamente
                    > > > > idea
                    > > >
                    > > > argumentum ad verecundium
                    > >
                    > > prendila come vuoi (anche in culo) volevo
                    > > sottolineare che l'obiezione che alzi non è
                    > certo
                    > > originale
                    >
                    > img]http://img234.imageshack.us/img234/4527/specc

                    toh fatti una cultura

                    http://www.python.org/about/success/esr/
                    • Avatar
                      Scritto da
                      Non Autenticato
                      il 2008-10-21 22:59:00.0 alle 2008-10-21 22:59:00.0
                      Re: pythonisty

                      - Scritto da:
                      > - Scritto da:
                      > >
                      > > - Scritto da:
                      > > >
                      > > > - Scritto da:
                      > > > >
                      > > > > - Scritto da:
                      > > > > >
                      > > > > > - Scritto da:
                      > > > > > >
                      > > > > > > - Scritto da:
                      > > > > > > > - Scritto da:
                      > > > > > > > >
                      > > > > > > > > - Scritto da:
                      > > > > > > > > > come si può migliorare questo
                      > > codice?
                      > > > > > > > > > deve cercare le posizioni in cui
                      > una
                      > > > > > stringa
                      > > > > > > > > > (pattern senza espressioni
                      > regolari)
                      > > > in
                      > > > > > > > un'altra
                      > > > > > > > > > stringa
                      > > > > > > > > > data
                      > > > > > > > > >
                      > > > > > > > > > tipo come fa re.findall(), ma
                      > senza
                      > > > > > > scomodare
                      > > > > > > > il
                      > > > > > > > > > motore che sta dietro il matcher
                      > > delle
                      > > > > > regex
                      > > > > > > > che
                      > > > > > > > > > è
                      > > > > > > > > > lento.
                      > > > > > > > > >
                      > > > > > > > > > def allindices(string, sub,
                      > > > > listindex=[],
                      > > > > > > > > > offset=0):
                      > > > > > > > > >     i = string.find(sub, offset)
                      > > > > > > > > >     while i >= 0:
                      > > > > > > > > >         listindex.append(i)
                      > > > > > > > > >         i = string.find(sub, i +
                      > 1)
                      > > > > > > > > >     return listindex
                      > > > > > > > > > 

                      > > > > > > > >
                      > > > > > > > > il python fa cagare, ha
                      > l'indentazione
                      > > > > > > > > obbligatoria
                      > > > > > > > >
                      > > > > > > >
                      > > > > > >
                      > > > > >
                      > > > >
                      > > >
                      > >
                      > [img]http://i.somethingawful.com/forumsystem/emoti
                      > > > > > > >
                      > > > > > > > il python è compatto e potente, e ci
                      > > > scrivo
                      > > > > > bot
                      > > > > > > > con 10 righe di
                      > > > > > > > codice.
                      > > > > > >
                      > > > > > > ma dai, un linguaggio con l'indentazione
                      > > > > > > obbligatoria non può essere serio, è
                      > > peggio
                      > > > > del
                      > > > > > > visual basic!
                      > > > > > > Rotola dal ridere
                      > > > > >
                      > > > > > lo diceva anche Eric S. Raymond, poi ha
                      > > > cambiato
                      > > > > > completamente
                      > > > > > idea
                      > > > >
                      > > > > argumentum ad verecundium
                      > > >
                      > > > prendila come vuoi (anche in culo) volevo
                      > > > sottolineare che l'obiezione che alzi non è
                      > > certo
                      > > > originale
                      > >
                      > >
                      > img]http://img234.imageshack.us/img234/4527/specc
                      >
                      > toh fatti una cultura
                      >
                      > http://www.python.org/about/success/esr/

                      Oste com'è il vino? Rotola dal ridere
                      • Avatar
                        Scritto da
                        Non Autenticato
                        il 2008-10-21 23:01:00.0 alle 2008-10-21 23:01:00.0
                        Re: pythonisty

                        > > > > > argumentum ad verecundium
                        > > > >
                        > > > > prendila come vuoi (anche in culo) volevo
                        > > > > sottolineare che l'obiezione che alzi non è
                        > > > certo
                        > > > > originale
                        > > >
                        > > >
                        > >
                        > img]http://img234.imageshack.us/img234/4527/specc
                        > >
                        > > toh fatti una cultura
                        > >
                        > > http://www.python.org/about/success/esr/
                        >
                        > Oste com'è il vino? Rotola dal ridere

                        My first look at Python was an accident, and I didn't much like what I saw at the time.

                        neanche hai letto la prima riga.

                        mah non dovrei perdere tempo con te, non sai un cazzo di python e quindi le tue critiche valgono come la merda su un badile

                        buona notte genio
                        • Avatar
                          Scritto da
                          Non Autenticato
                          il 2008-10-21 23:04:00.0 alle 2008-10-21 23:04:00.0
                          Re: pythonisty

                          - Scritto da:
                          >
                          > > > > > > argumentum ad verecundium
                          > > > > >
                          > > > > > prendila come vuoi (anche in culo) volevo
                          > > > > > sottolineare che l'obiezione che alzi non
                          > è
                          > > > > certo
                          > > > > > originale
                          > > > >
                          > > > >
                          > > >
                          > >
                          > img]http://img234.imageshack.us/img234/4527/specc
                          > > >
                          > > > toh fatti una cultura
                          > > >
                          > > > http://www.python.org/about/success/esr/
                          > >
                          > > Oste com'è il vino? Rotola dal ridere
                          >
                          > My first look at Python was an accident, and I
                          > didn't much like what I saw at the
                          > time.

                          >
                          > neanche hai letto la prima riga.
                          >
                          > mah non dovrei perdere tempo con te, non sai un
                          > cazzo di python e quindi le tue critiche valgono
                          > come la merda su un
                          > badile
                          >
                          > buona notte genio

                          e dovrei prendere come attendibile un'opinione presa dal sito del python? Rotola dal ridere
          • Avatar
            Scritto da
            Non Autenticato
            il 2008-10-21 22:46:00.0 alle 2008-10-21 22:46:00.0
            Re: pythonisty

            - Scritto da:
            >
            > - Scritto da:
            > > - Scritto da:
            > > >
            > > > - Scritto da:
            > > > > come si può migliorare questo codice?
            > > > > deve cercare le posizioni in cui una stringa
            > > > > (pattern senza espressioni regolari) in
            > > un'altra
            > > > > stringa
            > > > > data
            > > > >
            > > > > tipo come fa re.findall(), ma senza
            > scomodare
            > > il
            > > > > motore che sta dietro il matcher delle regex
            > > che
            > > > > è
            > > > > lento.
            > > > >
            > > > > def allindices(string, sub, listindex=[],
            > > > > offset=0):
            > > > >     i = string.find(sub, offset)
            > > > >     while i >= 0:
            > > > >         listindex.append(i)
            > > > >         i = string.find(sub, i + 1)
            > > > >     return listindex
            > > > > 

            > > >
            > > > il python fa cagare, ha l'indentazione
            > > > obbligatoria
            > > >
            > >
            > [img]http://i.somethingawful.com/forumsystem/emoti
            > >
            > > il python è compatto e potente, e ci scrivo bot
            > > con 10 righe di
            > > codice.
            >
            > ma dai, un linguaggio con l'indentazione
            > obbligatoria non può essere serio, è peggio del
            > visual basic!
            > Rotola dal ridere

            indentazione obbligatoria e ; obbligatori sono sintatticamente equivalenti

            sicuramente hai un QI molto basso e non sai un cazzo di automi LR e parser
      • Avatar
        ☺
        Scritto da
        avvelentani
        Cubicolario
        il 2008-10-21 23:06:00.0 alle 2008-10-21 23:06:00.0
        Trollate totali: 18184
        Re: pythonisty

        - Scritto da:
        >
        > - Scritto da:
        > > come si può migliorare questo codice?
        > > deve cercare le posizioni in cui una stringa
        > > (pattern senza espressioni regolari) in un'altra
        > > stringa
        > > data
        > >
        > > tipo come fa re.findall(), ma senza scomodare il
        > > motore che sta dietro il matcher delle regex che
        > > è
        > > lento.
        > >
        > > def allindices(string, sub, listindex=[],
        > > offset=0):
        > >     i = string.find(sub, offset)
        > >     while i >= 0:
        > >         listindex.append(i)
        > >         i = string.find(sub, i + 1)
        > >     return listindex
        > > 

        >
        > il python fa cagare, ha l'indentazione
        > obbligatoria

        paragonato al fatto che lo scoping fa cagare a spruzzo e` niente.
        I think happiness is love
        - Vladimir Putin
    • Avatar
      ☺
      Scritto da
      avvelentani
      Cubicolario
      il 2008-10-21 23:05:00.0 alle 2008-10-21 23:05:00.0
      Trollate totali: 18184
      Re: pythonisty

      - Scritto da:
      > come si può migliorare questo codice?
      > deve cercare le posizioni in cui una stringa
      > (pattern senza espressioni regolari) in un'altra
      > stringa
      > data
      >
      > tipo come fa re.findall(), ma senza scomodare il
      > motore che sta dietro il matcher delle regex che
      > è
      > lento.
      >
      > def allindices(string, sub, listindex=[],
      > offset=0):
      >     i = string.find(sub, offset)
      >     while i >= 0:
      >         listindex.append(i)
      >         i = string.find(sub, i + 1)
      >     return listindex
      > 


      Questo codice e` buggato, il valore di default di un argomento "persiste".

      Per il resto non c'e` molto che tu possa fare, supponendo che string.find (btw non e` un problema che una variabile si chiami come una classe?) ricostruisca l'automa ogni volta che la chiami potresti ottimizzare riusando lo stesso automa, ma se lo fai in python il guadagno non compensera` il rallentamento delle prestazioni rispetto all'implementazione nativa di find, tranne forse nel caso in cui sub sia molto lunga e piena di ripetizioni.
      I think happiness is love
      - Vladimir Putin
<softv>

Pagina generata in 77 millisecondi

Utenti attivi: 15 nell'ultimo minuto, 39 negli ultimi cinque minuti, 83 negli ultimi 15 minuti