pro

pro@common-lisp.net

1 participants
346 discussions

[Final CfP] European Lisp Symposium 2018 -- Deadline extension
by Didier Verna 20 Feb '18

20 Feb '18

ELS'18 - 11th European Lisp Symposium Centro Cultural Cortijo de Miraflores Marbella, Málaga Spain April 16-17 2018 Sponsored by Brunner Software GmbH and EPITA http://www.european-lisp-symposium.org/ *** Important: submission deadline extended to Sunday Feb. 25! The purpose of the European Lisp Symposium is to provide a forum for the discussion and dissemination of all aspects of design, implementation and application of any of the Lisp and Lisp-inspired dialects, including Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, ECMAScript, Racket, SKILL, Hop and so on. We encourage everyone interested in Lisp to participate. The 11th European Lisp Symposium invites high quality papers about novel research results, insights and lessons learned from practical applications and educational perspectives. We also encourage submissions about known ideas as long as they are presented in a new setting and/or in a highly elegant way. Topics include but are not limited to: - Context-, aspect-, domain-oriented and generative programming - Macro-, reflective-, meta- and/or rule-based development approaches - Language design and implementation - Language integration, inter-operation and deployment - Development methodologies, support and environments - Educational approaches and perspectives - Experience reports and case studies We invite submissions in the following forms: Papers: Technical papers of up to 8 pages that describe original results or explain known ideas in new and elegant ways. Demonstrations: Abstracts of up to 2 pages for demonstrations of tools, libraries, and applications. Tutorials: Abstracts of up to 4 pages for in-depth presentations about topics of special interest for at least 90 minutes and up to 180 minutes. The symposium will also provide slots for lightning talks, to be registered on-site every day. All submissions should be formatted following the ACM SIGS guidelines and include ACM Computing Classification System 2012 concepts and terms. Submissions should be uploaded to Easy Chair, at the following address: https://www.easychair.org/conferences/?conf=els2018 Note: to help us with the review process please indicate the type of submission by entering either "paper", "demo", or "tutorial" in the Keywords field. Important dates: - 25 Feb 2018 Submission deadline (*** extended! ***) - 19 Mar 2018 Notification of acceptance - 25 Mar 2018 Early registration deadline - 02 Apr 2018 Final papers due - 16-17 Apr 2018 Symposium Programme chair: David Cooper, Genworks Intl., USA Local chairs: Andrew Lawson, Ravenpack, Spain Programme committee: Andy Wingo, Igalia, Spain Christophe Rhodes, Goldsmiths University, UK Christopher Wellons Null Program Canada Irène Durand, LaBRI, Université de Bordeaux, France Julian Padget, University of Bath, UK Ludovic Courtès, Inria, France Michael Sperber, DeinProgramm, Germany Nicolas Neuss, FAU Erlangen-Nürnberg, Germany Olin Shivers Northwestern University USA Philipp Marek, Austria Robert Strandh, LaBRI, Université de Bordeaux, France Sacha Chua Living an Awesome Life Canada Scott McKay, Future Fuel, USA Search Keywords: #els2018, ELS 2018, ELS '18, European Lisp Symposium 2018, European Lisp Symposium '18, 10th ELS, 10th European Lisp Symposium, European Lisp Conference 2018, European Lisp Conference '18 -- Resistance is futile. You will be jazzimilated. Lisp, Jazz, Aïkido: http://www.didierverna.info

1 0

[CfP] ELS 2018, April 16-17, Marbella, Spain
by Didier Verna 13 Feb '18

13 Feb '18

Reminder: submission deadline this sunday! ELS'18 - 11th European Lisp Symposium Centro Cultural Cortijo de Miraflores Marbella, Málaga Spain April 16-17 2018 Sponsored by Brunner Software GmbH and EPITA http://www.european-lisp-symposium.org/ The purpose of the European Lisp Symposium is to provide a forum for the discussion and dissemination of all aspects of design, implementation and application of any of the Lisp and Lisp-inspired dialects, including Common Lisp, Scheme, Emacs Lisp, AutoLisp, ISLISP, Dylan, Clojure, ACL2, ECMAScript, Racket, SKILL, Hop and so on. We encourage everyone interested in Lisp to participate. The 11th European Lisp Symposium invites high quality papers about novel research results, insights and lessons learned from practical applications and educational perspectives. We also encourage submissions about known ideas as long as they are presented in a new setting and/or in a highly elegant way. Topics include but are not limited to: - Context-, aspect-, domain-oriented and generative programming - Macro-, reflective-, meta- and/or rule-based development approaches - Language design and implementation - Language integration, inter-operation and deployment - Development methodologies, support and environments - Educational approaches and perspectives - Experience reports and case studies We invite submissions in the following forms: Papers: Technical papers of up to 8 pages that describe original results or explain known ideas in new and elegant ways. Demonstrations: Abstracts of up to 2 pages for demonstrations of tools, libraries, and applications. Tutorials: Abstracts of up to 4 pages for in-depth presentations about topics of special interest for at least 90 minutes and up to 180 minutes. The symposium will also provide slots for lightning talks, to be registered on-site every day. All submissions should be formatted following the ACM SIGS guidelines and include ACM Computing Classification System 2012 concepts and terms. Submissions should be uploaded to Easy Chair, at the following address: https://www.easychair.org/conferences/?conf=els2018 Note: to help us with the review process please indicate the type of submission by entering either "paper", "demo", or "tutorial" in the Keywords field. Important dates: - 18 Feb 2018 Submission deadline - 19 Mar 2018 Notification of acceptance - 25 Mar 2018 Early registration deadline - 02 Apr 2018 Final papers due - 16-17 Apr 2018 Symposium Programme chair: David Cooper, Genworks Intl., USA Local chairs: Andrew Lawson, Ravenpack, Spain Programme committee: Christophe Rhodes, Goldsmiths University, UK Christopher Wellons Null Program Canada Irène Durand, LaBRI, Université de Bordeaux, France Julian Padget, University of Bath, UK Ludovic Courtès, Inria, France Michael Sperber, DeinProgramm, Germany Nicolas Neuss, Universität Karlsruhe, Germany Olin Shivers Northwestern University USA Robert Strandh, LaBRI, Université de Bordeaux, France Sacha Chua Living an Awesome Life Canada Scott McKay, Future Fuel, USA Search Keywords: #els2018, ELS 2018, ELS '18, European Lisp Symposium 2018, European Lisp Symposium '18, 10th ELS, 10th European Lisp Symposium, European Lisp Conference 2018, European Lisp Conference '18 -- Resistance is futile. You will be jazzimilated. Lisp, Jazz, Aïkido: http://www.didierverna.info

1 0

Contradiction between the MOP and the standard ?
by Didier Verna 22 Jan '18

22 Jan '18

Hi, In the CLHS page for ENSURE-GENERIC-FUNCTION, there is this paragraph: "If function-name specifies a generic function that has a different value for the :generic-function-class argument and if the new generic function class is compatible[1] with the old, change-class is called to change the class of the generic function; otherwise an error is signaled." In the AMOP however, one can read the following. >From the page on ENSURE-GENERIC-FUNCTION: "The behavior of this function is actually implemented by the generic function ensure-generic-function-using-class. When ensure-generic-function is called, it immediately calls ensure-generic-function-using-class and returns that result as its own." And then from the page on ENSURE-GENERIC-FUNCTION-USING-CLASS: "If the class of the generic-function-or-nil argument is not the same as the class specified by the :generic-function-class argument, an error is signaled." Let alone the fact that this should only apply when there actually is an existing generic function, this seems to be in contradiction with the Common Lisp standard, as it would explicitly forbid changing the class of the generic function, even in a "compatible" way. Comments? Footnotes: [1] BTW, what does "compatible" mean ? -- Resistance is futile. You will be jazzimilated. Lisp, Jazz, Aïkido: http://www.didierverna.info

2 2

One annoyance of ensure-generic-function-using-class
by Didier Verna 02 Jan '18

02 Jan '18

Hello, there is something annoying with ensure-generic-function-using-class. The MOP specifies that if the :generic-function-class option is not provided, it defaults to standard-generic-function. While this makes perfect sense when the generic function doesn't already exist, it seems to also apply when it does. As a result, if you want to call ensure-generic-function on an existing generic function using a different meta-class, for instance like this: (ensure-generic-function gf-name :generic-function-class (class-of gf)) This is a bit annoying, and I don't understand the rationale behind this, if there's one. Why not defaulting to the existing generic function's meta-class? -- Resistance is futile. You will be jazzimilated. Lisp, Jazz, Aïkido: http://www.didierverna.info

3 3

Re: ASDF debugging on Hangouts?
by Faré 27 Dec '17

27 Dec '17

OK, I'm setting the day and time for the next ASDF debugging session to Tuesday January 2nd 2018 at 14:00 EST (19:00 UTC). Please send me a private email if you can make it, I'll add you to a Google Calendar event with a Hangout invitation. —♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org When it comes to giving, some men stop at nothing. — Saul Gorn On Wed, Dec 27, 2017 at 6:06 PM, Faré <fahree(a)gmail.com> wrote: > On Wed, Dec 27, 2017 at 10:33 AM, Robert Goldman <rpgoldman(a)sift.info> wrote: >> On 4 Dec 2017, at 21:56, Faré wrote: >>> https://bugs.launchpad.net/asdf/+bug/1739514 >>> Basically, ASDF fails spuriously rebuilds misnamed secondary systems >>> and/or things that depend on them, instead of just issuing a warning >>> as intended. >> >> Another editing query here. Looks like it might be either "ASDF fails to rebuild" or "ASDF spuriously rebuilds misnamed..." >> > Yes, it's "ASDF spuriously rebuilds misnamed...". > > Note that if it were a simple circular dependency, it would have just > broken the build and be very visible and I'd have caught it last year. > > Without having looked at the code or tried to debug it yet, my working > hypothesis is that having "foo" in "foo.asd" depend on "bar" also > defined in "foo.asd" causes dependency from (define-op "foo") to > (define-op . "bar"), which is always in need of build because there is > no "bar.asd" and the associated timestamp is therefore NIL. If that is > correct, the backward-compatible solution would be to make sure that > "bar" remembers that it was defined in "foo.asd", so that it gets the > timestamp from "foo.asd", and the next time around, if there is no > up-to-date "bar.asd", ASDF falls back on looking at the previously > loaded "foo.asd" or a more up-to-date version of it. > > Note that if "bar" is defined in both "foo.asd" and "bar.asd" you'll > still have a mighty bug. Therefore people should still fix their code > to properly name secondary system, ASDF should still issue a warning > when they are misnamed, and this warning should still be upgraded to a > cerror then an error when all of Quicklisp is fixed (>300 systems).

1 0

ASDF debugging on Hangouts?
by Faré 27 Dec '17

27 Dec '17

Dear CLers, with ASDF 3.3.1 released and the syntax-control branch pending review, there's not much left for me to do with ASDF before I actually retire. Now I'm looking for hackers to whom to pass the torch of ASDF hacking. It so happens that I seem to have introduced (probably with 3.3.0) a regression that breaks static image dumping of workout-timer with cffi-toolchain. If people are interested, I could do the entire debugging session over Google Hangouts, from isolating the bug and filing a bug report to writing regression test and submitting a merge request. That would be a good way to introduce newcomers to ASDF hacking. Having a public ask questions as I make progress would be a good way to keep the video relevant. Is anyone interested? —♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org If there's a book you really want to read but it hasn't been written yet, then you must write it. — Toni Morrison [same with software, —♯f]

11 27

Common Lisp Blockchain - Scheme Coin
by Burton Samograd 24 Dec '17

24 Dec '17

Here’s a little ditty I decided to share. A Common Lisp Blockchain implementation of a coin that has a useful Proof of Work: Scheme Evaluation. Incomplete, but still interesting per the previous week’s discussion. ;; ;; scheme coin - a common lisp blockchain ;; ;; Burton Samograd ;; 2017 (load "~/quicklisp/setup.lisp") (defconstant *coin-name* "Scheme Coin") (eval-when (compile load) (ql:quickload "ironclad")) (defun rest2 (l) (cddr l)) (defun interp (x &optional env) "Interpret (evaluate) the expression x in the environment env." (cond ((symbolp x) (get-var x env)) ((atom x) x) ((scheme-macro (first x)) (interp (scheme-macro-expand x) env)) ((case (first x) (QUOTE (second x)) (BEGIN (last1 (mapcar #'(lambda (y) (interp y env)) (rest x)))) (SET! (set-var! (second x) (interp (third x) env) env)) (if (if (interp (second x) env) (interp (third x) env) (interp (fourth x) env))) (LAMBDA (let ((parms (second x)) (code (maybe-add 'begin (rest2 x)))) #'(lambda (&rest args) (interp code (extend-env parms args env))))) (t ;; a procedure application (apply (interp (first x) env) (mapcar #'(lambda (v) (interp v env)) (rest x)))))))) (defun scheme-macro (symbol) (and (symbolp symbol) (get symbol 'scheme-macro))) (defmacro def-scheme-macro (name parmlist &body body) `(setf (get ',name 'scheme-macro) #'(lambda ,parmlist .,body))) (defun scheme-macro-expand (x) (if (and (listp x) (scheme-macro (first x))) (scheme-macro-expand (apply (scheme-macro (first x)) (rest x))) x)) (defun set-var! (var val env) "Set a variable to a value, in the given or global environment." (if (assoc var env) (setf (second (assoc var env)) val) (set-global-var! var val)) val) (defun get-var (var env) (if (assoc var env) (second (assoc var env)) (get-global-var var))) (defun set-global-var! (var val) (setf (get var 'global-val) val)) (defun get-global-var (var) (let* ((default "unbound") (val (get var 'global-val default))) (if (eq val default) (error "Unbound scheme variable: ~A" var) val))) (defun extend-env (vars vals env) "Add some variables and values to and environment." (nconc (mapcar #'list vars vals) env)) (defparameter *scheme-procs* '(+ - * / = < > <= >= cons car cdr not append list read member (null? null) (eq? eq) (equal? equal) (eqv? eql) (write prin1) (display princ) (newline terpri))) (defun init-scheme-interp () (mapc #'init-scheme-proc *scheme-procs*) (set-global-var! t t) (set-global-var! nil nil)) (defun init-scheme-proc (f) (if (listp f) (set-global-var! (first f) (symbol-function (second f))) (set-global-var! f (symbol-function f)))) (defun maybe-add (op exps &optional if-nil) (cond ((null exps) if-nil) ((length=1 exps) (first exps)) (t (cons op exps)))) (defun length=1 (x) (and (consp x) (null (cdr x)))) (defun last1 (list) (first (last list))) (defun scheme () (init-scheme-interp) (loop (format t "~&==> ") (print (interp (read) nil)))) (def-scheme-macro let (bindings &rest body) `((lambda ,(mapcar #'first bindings) . ,body) .,(mapcar #'second bindings))) (def-scheme-macro let* (bindings &rest body) (if (null bindings) `(begin . ,body) `(let (,(first bindings)) (let* ,(rest bindings) . ,body)))) (def-scheme-macro and (&rest args) (cond ((null args) 'T) ((length=1 args) (first args)) (t `(if ,(first args) (and . ,(rest args)))))) (def-scheme-macro or (&rest args) (cond ((null args) 'nil) ((length=1 args) (first args)) (t (let ((var (gensym))) `(let ((,var ,(first args))) (if ,var ,var (or . ,(rest args)))))))) (init-scheme-interp) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;;;;;; and there we have a scheme interpreter with macros. ;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (defstruct block (index 0) (timestamp 0) data (previous-hash "") hash) (defstruct transaction from to (value 0) (accuracy 1) (duration 0) data hash previous-hash) (defun to-byte-array (x) (let ((retval (make-array 0 :adjustable t :fill-pointer t :element-type '(unsigned-byte 8)))) (map 'nil (lambda (c) (vector-push-extend (char-code c) retval)) (format nil "~A" x)) ; (coerce retval 'ironclad::simple-octet-vector))) (defun make-address (x) (let ((digester (ironclad:make-digest :sha3))) (ironclad:update-digest digester (to-byte-array x)) (ironclad:produce-digest digester))) (defun hash-block (block) (let ((digester (ironclad:make-digest :sha3))) (ironclad:update-digest digester (to-byte-array (block-index block))) (ironclad:update-digest digester (to-byte-array (block-timestamp block))) (ironclad:update-digest digester (to-byte-array (block-data block))) (ironclad:update-digest digester (to-byte-array (block-previous-hash block))) (ironclad:produce-digest digester))) (defun hash-transaction (block) (let ((digester (ironclad:make-digest :sha3))) (ironclad:update-digest digester (to-byte-array (transaction-from block))) (ironclad:update-digest digester (to-byte-array (transaction-to block))) (ironclad:update-digest digester (to-byte-array (transaction-value block))) (ironclad:update-digest digester (to-byte-array (transaction-accuracy block))) (ironclad:update-digest digester (to-byte-array (transaction-duration block))) (ironclad:update-digest digester (to-byte-array (transaction-data block))) (ironclad:produce-digest digester))) (defun make-genesis-block (data time) (let* ((block (make-block :index 0 :timestamp time :data data :hash 0)) (hash (hash-block block))) (setf (block-hash block) hash) block)) (defmacro create-genesis-block (data) `(let ((time (get-universal-time))) (make-genesis-block ,data time))) (defun next-block (last-block data) (let ((block (make-block :index (1+ (block-index last-block)) :timestamp (get-universal-time) :data data :previous-hash (hash-block last-block)))) (setf (block-hash block) (hash-block block)) (push block *blockchain*) block)) (setf *print-base* 16) (defconstant *base-code* '(set! x 0)) (defparameter *network-address* (make-address *coin-name*)) (defparameter *quester-address* (make-address "quester")) (defparameter *miner-address* (make-address "miner")) (defparameter *contract-address* (make-address "contract")) (defparameter *block-transactions* (let ((transaction (make-transaction :from *network-address* :to *quester-address* :value (* 10000 10000 10000) :data *base-code*))) (setf (transaction-hash transaction) (hash-transaction transaction)) (list transaction))) (defparameter *blockchain* (list (create-genesis-block *block-transactions*))) (defparameter *previous-block* (car *blockchain*)) (defparameter *solved-transactions* (make-hash-table :test #'equalp :weak-kind t)) (eval-when (compile load) (defun new-transaction (&key from to (value 0) accuracy data previous-hash duration) (let ((transaction (make-transaction :from from :to to :value value :accuracy accuracy :data data :previous-hash previous-hash :duration duration))) (setf (transaction-hash transaction) (hash-transaction transaction)) (when previous-hash (setf (gethash (transaction-hash transaction) *solved-transactions*) t)) transaction))) (defmacro submit-answer (from transaction data) `(push (new-transaction :from ,from :to *contract-address* :previous-hash (transaction-hash transaction) :data ,data) *block-transactions*)) (defun has-transaction-not-been-solved (transaction) (if (gethash (transaction-hash transaction) *solved-transactions*) (not (setf (gethash (transaction-hash transaction) *solved-transactions*) transaction)) t)) (defun viable-transaction (transaction) (and (has-transaction-not-been-solved transaction) (<= (block-index (car *blockchain*)) (or (transaction-duration transaction) (get-universal-time))))) ;; can still submit (defun verify-transaction (transaction) (handler-case (interp (transaction-data transaction)) (error (e) e))) (defun execute-transactions (miner-address) (dolist (transaction *block-transactions*) (when (viable-transaction transaction) (print :submitting-answer) (submit-answer miner-address transaction (verify-transaction transaction)) ))) (defun mine () (when *block-transactions* (execute-transactions *miner-address*) (transfer *network-address* *miner-address* 1) (setf *previous-block* (next-block *previous-block* *block-transactions*)) (setf *block-transactions* nil))) (defmacro transfer (from to value) `(push (new-transaction :from ,from :to ,to :value ,value) *block-transactions*)) (defmacro execute (from value code &key (accuracy value) (duration (+ 2 (block-index (car *blockchain*))))) `(push (new-transaction :from ,from :to *contract-address* :value ,value :accuracy ,accuracy :data ',code :duration ,duration) *block-transactions*)) (defun process-transfer-request (request stream) (destructuring-bind (from to value) request (transfer from to value))) (defun process-execute-request (request stream) (destructuring-bind (from value data &key (accuracy value) (duration (+ 2 (block-index (car *blockchain*))))) request (execute from value data :accuracy accuracy :duration duration))) (defun process-blocks-request (request stream) (print *blockchain* stream)) (defun process-coin-server-request (stream) (let ((request (read stream))) (case request (transfer (process-transfer-request (cdr request) stream)) (execute (process-execute-request (cdr request) stream)) (blocks (process-blocks-request (cdr request) stream))))) (defun coin-server (handle) (let ((stream (make-instance 'comm:socket-stream :socket handle :direction :io :element-type 'base-char))) (process-coin-server-request stream))) (defvar *server* (comm:start-up-server :function #'coin-server :service 9999 :process-name (format nil "~A server" *coin-name*))) (loop (mine) (sleep 1)) Enjoy! If you have any questions, feel free to ask. Made with LispWorks, but it really only uses the function comm:start-up-server I think. — Burton Samograd BusFactor1 Inc. http://busfactor1.ca/ <http://busfactor1.ca/> Check out my software in the macOS App Store.

6 18

Dependency of discriminating functions on method combinations
by Didier Verna 22 Dec '17

22 Dec '17

Hi, Computing an effective method depends on the generic function's method combination. But is it also the case for computing the discriminating function? I don't see why it should in theory, but evidence seems to suggest otherwise[1]. Maybe it does for technical reasons? Thanks. Footnotes: [1] In SBCL for instance, flushing the effective method cache is not enough for direct modifications to a generic function's method combination to take effect on the next call. -- Resistance is futile. You will be jazzimilated. Lisp, Jazz, Aïkido: http://www.didierverna.info

2 2

Errata for hyperspec?
by Chaitanya Gupta 21 Dec '17

21 Dec '17

I noticed a mistake in one of the examples in the hyperspec, and went looking for an errata. I saw this page on cliki but didn't find the issue there, so I am wondering if the "comprehensive" list is elsewhere: http://www.cliki.net/Proposed%20ANSI%20Revisions%20and%20Clarifications FWIW, the issue is in the second example under the documentation for SHADOW[1]. (package-shadowing-symbols (make-package 'temp)) => NIL (find-symbol 'car 'temp) => CAR, :INHERITED FIND-SYMBOL does not accept a symbol as the first argument. All the Lisps that I have checked this on signal an error. Also, I think the first example should be modified to: (package-shadowing-symbols (make-package 'temp :use '("CL"))) SBCL by default does not use the CL package. So (find-symbol "CAR" 'temp) returns NIL, NIL instead. It took me a while to figure why the spec example returned a different set of values. Chaitanya 1. http://www.lispworks.com/documentation/HyperSpec/Body/f_shadow.htm

6 22

Re: Common Lisp Blockchain - Scheme Coin
by Alessio Stalla 19 Dec '17

19 Dec '17

Well, that's a great idea! Il 19 dic 2017 11:36, "David McClain" <dbm(a)refined-audiometrics.com> ha scritto: It seems to me that, instead of performing totally useless computations for POW, a group like CERN might enlist the miners to search for W-Boson events from their detector trails, or astronomers might enlist the mining enclaves to search for SETI events… (no joke…) - DM On Dec 18, 2017, at 23:03, Antoniotti Marco <antoniotti.marco@disco. unimib.it> wrote: On Dec 18, 2017, at 23:54 , Pascal Bourguignon <pjb(a)informatimago.com> wrote: On 18 Dec 2017, at 23:31, David McClain <dbm(a)refined-audiometrics.com> wrote: umm… was this supposed to be some kind of joke? I’ll bite... I don’t get it. I was actually hoping to learn something here... But the code does look rather peculiar on close inspection. Why the use of macros for pushing new transaction blocks? And the conversions to octet vectors may work for strings, but not in general for arbitrary integer or float values… If it is supposed to be a joke, I’ll chuckle and just chuck the code… I guess not: https://dev.to/damcosset/trying-to-understand- blockchain-by-making-one-ce4 It’s like, everybody will be busy implementing blockchains. It’s the new fizz-buzz… … or planting tulips :) :) :) Cheers MA -- Marco Antoniotti

1 0

← Newer
1
...
7
8
9
10
11
12
13
...
35
Older →

Jump to page:

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

2010

pro