Newsgroup: it.fan.culo
Titolo: Leghisti, gioite!

Ah, ma che brava gente :)
http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
--
ciao, |   * 92 is full. Go a piedi.  --  Smog und stress   *
 Bak  | (Ri)scoprire la fede: 
http://members.xoom.it/ache/pd.htm

 
http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
Stavo cronometrando il tempo che avresti impiegato a recapitarci la
notizia: hai impiegato almeno tre quesrti d'ora in piu' del
previsto...
ByE,
FF

Fatto!!
Stai meglio ora?
Carlo

 Fatto!!
perche'? sei pure leghista? non ti bastava d'esse negro?
	-p-


http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
Bah, forse volevano solo che la gente la smettesse di pisciare sui
muri...
-- 
ciao, Marvin

  Bak  | (Ri)scoprire la fede: 
http://members.xoom.it/ache/pd.htm
Permettimi di crosspostarlo carissimo!


http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
Si potrebbe organizzare una spedizione mista atei-ebrei e mettersi a
passeggiare sul sagrato dopo esserci autodenunciati alla locale polizia.
-- 
ciao, | Software is like sex; it's better when it's free.  -- Linus Torvalds
Marco | (Ri)scoprire fidonet: 
http://bbs.mi.linux.it

 previsto...
Non sono piu' in forma come una volta, sto invecchiando.
Il fatto che tu aspettassi con trepidazione la notizia riportata in
questo ameno loco e' - in ogni caso - una bella fonte di soddisfazione.
E' bello vedere quanto sei attaccato alle sublimi poetiche dei tuoi
referenti politici (non c'e' nulla di cui vergognarsi nel votare delle
merde ambulanti, basta fare i dovuti distinguo e non dirsi d'accordo,
scaricando la coscienza nello sciaquone).
--
B.

 passeggiare sul sagrato dopo esserci autodenunciati alla locale
polizia.
Sai che non e' *per nulla* una cattiva idea?
--
B.

Sai che non e' *per nulla* una cattiva idea?
Proprio *per nulla*!
Si raccolgono adesioni?
MMAX

 scaricando la coscienza nello sciaquone).
Trascuro alcuni fatti come: mai votato Lega se non una volta per errore
(non tecnico, come quello degli idioti della Florida, ma politico:
bisogna saper riconoscere i propri errori) e scagli la prima pietra chi
ritiene di non aver votato mai per merde (se lo fa pero' entra in
concorso per l'Ingenuo dell'Anno od Idiota che Ama Pigliarselo nel
Topic).
Vado al sodo: dopo quello che hai scritto te la vedi con Isa da solo...
ByE,
FF

 Vado al sodo: dopo quello che hai scritto te la vedi con Isa da
solo...
Credo di aver rincarato la dose.
E chi mi parla di dinamiche bipolariste verra' immediatamente killato.
--
B.

 Si raccolgono adesioni?
Io ci sono, ci vorrebbe anche un pratico striscione :)
--
B.

Io ci sono, ci vorrebbe anche un pratico striscione :)
Troppo vistoso, secondo me basta organizzare un composto gruppo di
lettura della Torah e del Corano, accanto alle mura della chiesa.
MMAX

 passeggiare sul sagrato dopo esserci autodenunciati alla locale polizia.
io ci sono.
ipazia

 scaricando la coscienza nello sciaquone).
Ecco che parla il principino sul pisello. Raccontaci un poco dei tuoi
referenti politici tanto bravi, tanto buoni e tanto intelletualmente
onesti. Su, nanetto, facci scoprire la parte illuminata dell'universo.
Carlo

"Carlo"

Perche' aggiungere orrore su orrore alla tua coscienza bovina?
Non ti bastano quelle belle merde fumanti che voti in tutta
tranquillita'?
--
B.

 perche'? sei pure leghista? non ti bastava d'esse negro?
Nope,
ma disposto a tutto pur di stare sulla sponda opposta a certa gente.
Carlo

 tranquillita'?
Perchè non c'è limite al peggio e io adoro sguazzarci. E tu, carente di
peluria in testa, puoi dare un grosso contribuito alla causa.
Carlo

 peluria in testa, puoi dare un grosso contribuito alla causa.
Non ti preoccupare, per quanto mi possa sbattere non raggiungero' mai
certe vette, tipo quella della moschea, o quella riportata nell'articolo
succitato.
--
Boso

 
http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
                                          ====== ====== ======
  tanto per chiarire il concetto, i suppost

 E chi mi parla di dinamiche bipolariste verra' immediatamente killato.
Ed invece il motivo e' quello... :-PPP
Bye,
FF

 Boso
Ti avrei detto più Buso che altro.
Carlo

 faccioni abbronzati.
Che non dista molto dalla descrizione di D'Alema, prossimo presidente
dei rintronati compagni, che tra Ikarus, lampade abbronzanti, nani e
ballerini fa parte della tua consorteria. Checcevoifa? Con il vento che
tira, spesso, gli sputi ti ritornano in faccia.
Carlo

Sai che non e' *per nulla* una cattiva idea?
Sai che non l'ho scritto per scherzo?
Pero` voglio assistenza legale da uno degli avvocati del gruppo.


 A me non e' mai piaciuto essere prevedibile...
C'č un motivo particolare o č il solito noioso anticonformismo per
partito preso?
-- 
Ciao,
Matteo

 ma disposto a tutto pur di stare sulla sponda opposta a certa gente.
e' quindi questo il motivo per cui ti ritrovi a far continuamente
paperella a meta' del guado, coll'acqua alla gola e uno stronzo
in bocca[1]
	-p-
[1] mi dicono che milano non c'ha il depuratore. e' mai possibile?

 wrote in message
Pine.OSF.4.10.100112...@eolo.caspur.it...

ti dicono? vieni a fare un giro al delta del Po

Pero` voglio assistenza legale da uno degli avvocati del gruppo.
Anche questa e` una buona idea; pero` se non c'e` reato, a quali
rischi ci si esporrebbe? Secondo me, nessuno.
A parte questo, se vi serve un agnostico battezzato per completare la
delegazione, contate su di me.
-- 
ciao, Marvin

 Pero` voglio assistenza legale da uno degli avvocati del gruppo.
A che ti serve? L'ordinanza e' chiaramente inapplicabile ed
incostituzionale. Semmai potresti chiedere i danni nel caso provassero a
farlo...
ByE,
FF


http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
La Lega si e' dissociata (cosi' almeno hanno detto su RadioRai).
Ah, un fanculo alla suddetta radio, che nel GR nazionale ci mette cinque
minuti per il sommario perche' lo inframezza di parentesi, brevi
servizi, collegamenti, rimandi, eccetera.
Un povero ascoltatore non ci capisce niente, e quando poi arrivano le
notizie vere e proprie, il dubbio "ma non l'hanno gia' trattata?" ti
assale zompando.
[per non parlare del Gazzettino Padano, GR regionale...]
Ciao, Alessio.
-- 
  PER RISPONDERE TOGLIERE  .linus
Il manuale di Agent: 
http://space.tin.it/cinema/claveron/alessio/index.htm
Le FAQ di ICSN: 
http://space.tin.it/cinema/claveron/alessio/FAQ-icsn.htm
Guida a FAgent: 
http://space.tin.it/cinema/claveron/alessio/FAgent/FA-man.htm

Pero` voglio assistenza legale da uno degli avvocati del gruppo.
Non t'illudere. Sono avvocati, dei mostri senza cuore, ti faranno
pagare... al massimo puoi pietire uno sconto. 
MMAX

 [per non parlare del Gazzettino Padano, GR regionale...]
Beh.. io lo mando IT di default, perche' mi tocca ascoltarlo, pur essendo
piemontese. Idem per il T3 della Lombardia. Ma perche' la fate sempre
fuori dal vaso?
ByE,
FF


http://www.repubblica.it/online/cronaca/rovato/rovato/rovato.html
Divertente, ma la cosa piu' divertente della settimana e' stato un DS
che presenta ufficialmente, a nome del governo, la proposta che la
Lega ha fatto regolarmente negli ultimi dieci anni venendo tacciata di
razzismo e antidemocraticita' (schedare le impronte degli immigrati).
-- 
vb.          [v.bertola(at)
bertola.eu.org
 - M*RZ*'s Pusher User]<--------
----> 
http://bertola.eu.org/
    [Conan, Mononoke Hime e molto altro]<----
--------> 
http://www.poli.studenti.to.it/prometeo/
    [Progetto Prometeo]

che haider et similia non erano poi' cosi' kattivi,
Io non ho tuttora capito qual e' la colpa fattiva, pratica e
dimostrabile di Haider. Ha ammazzato qualcuno? Ha violato i diritti
umani di qualche gruppo di persone? O la sua unica colpa e' di avere
una idea di societa' diversa dalla tua, e di avere espresso delle
opinioni che non condividi?


 partito preso?
Imprevedibilita' ed anticonformismo non sono la stessa cosa. Inoltre il
fatto che non ti piaccia essere qualcosa non implica che tu non lo sia.
ByE,
FF

cosa non finisca nella stazione dei carabinieri].
Ci sto, ma devo avvertirvi che la mia prima domenica libera e` il 7
gennaio.
E` un problema? Altrimenti considero organizzato il pranzo a Rovato
per il 7 gennaio.
A proposito, dove cazzo e` Rovato?
Altra cosa che non c'entra niente ma vista la concentrazione di ebrei
nel gruppo vale comunque la pena di chiedere: sto cercando del codice
per convertire la data gregoriana in data ebraica, o almeno la
descrizione dell'algoritmo.
Per i curiosi, mi serve per calendar(1). Le feste mobili cattoliche le
ho ancorate alla pasqua, ma quelle ebraiche dovrei aggiornarle ogni anno
e non sono in grado. 


vuole
Credo che si chiami "costituzione".


 A proposito, dove cazzo e` Rovato?
Tra Bergamo e Brescia
http://mappe4.iol.it/SCRIPTS/hsrun.exe/MappeWS/MappeAP/StateId/B5ld0YJouh8heJrMEc8ZaLPDJJ/HAHTpage/HS_HtmlSearchPage?isemaf=1&isemaf=1&srcProvincia=&srcComu=rovato
-- 
. Simone Caldana - System Manager at Vitaminic spa              .
. Feel the usenet revolution: 
http://www.i2000.usenet.it/
       .
. E-Mail: 
e...@vitaminic.net
  Web URL: 
http://simone.caldana.org
 .

 [1] mi dicono che milano non c'ha il depuratore. e' mai possibile?
Chemmefrega. Io abito a Bergamo. E poi credo abbiano l'abitudine di
smaltire mandando il tutto a voi terroni.
Carlo

 Credo che si chiami "costituzione".
Che impedisce a un sindaco di emanare una direttiva che vieta di
camminare vicino a una chiesa del suo comune? Fammi un bel copiaincolla
del passo della costituzione che riporta questa norma. Grazie.
Carlo

 Tra Bergamo e Brescia
Più vicino a Brescia che a Bergamo.
Carlo

A questo proposito si potrebbe davvero organizzare un pranzIFQ
Beh per il 7 gennaio mi pare un po' tardi per farla a Rovato.
Pero' la magnata va salvata al limite parliamo di politica a bocca
piena. Riattiva la list su egroups e ci organizziamo.
Sia chiaro sin da ora prenoto il posto accanto a Manzotin!
MMAX

 Chemmefrega. Io abito a Bergamo. 
mi spiace per te.
	-p-


boh

 del passo della costituzione che riporta questa norma. Grazie.
Non puo' limitare la mobilita' di nessuno in base alla religione o
qualisasi altro fattore culturale/etnico.
Potrebbe, se volesse, limitare a __tutti__ l'accesso per, ad esempio, motivi
di ordine pubblico.
ByE,
FF

 Sia chiaro sin da ora prenoto il posto accanto a Manzotin!
e chi sarebbe?


e chi sarebbe?
Lo riconoscerai perchè arrivera' alla cena vestito da Rambo.
MMAX
ps
Dove organiziamo Lombardia o Piemont?

 Dove organiziamo Lombardia o Piemont?
Manda tu la mail! :)


 mi spiace per te.
A me invece non spiace. Ti spiace che non mi spiaccia?
Carlo

 di ordine pubblico.
E come mai allo stadio limitano l'ingresso solo ad alcuni per motivi
d'ordine pubblico? Dopotutto è un'altra forma di religiosità che trova
parecchi adepti in questa bella terra dei cachi
Il sindaco ritiene che determinate persone possano turbare l'ordine
pubblico con la loro presenza vicino a una chiesa.
Se è fesso mica possiamo impiccarlo. Al limite non farà più il sindaco a
Roat. Lo dico a beneficio dei patrioti che andranno a difendere le sacre
libertà del popolo in terra bresciana, in modo che sappiano come
pronunciarlo, non rischiando di passare per stranieri invasori. Inoltre,
se posso dare un consiglio, si portino anche qualche picchiatore di
professione, tipo il Seb, perchè da quelle parti hanno un senso
dell'ironia poco sviluppato e potrebbero farlo capire in modo non troppo
sublimale ai manifestatori.
Carlo

 Sia chiaro sin da ora prenoto il posto accanto a Manzotin!
Se è per domenica 7 sera va benissimo. Per il posto accanto a me:
mettiti in lista d'attesa, vedrò cosa posso fare.
Carlo

Per il posto accanto a me: mettiti in lista d'attesa, vedrò cosa posso fare.
Niente da fare, ho già opzionato il posto.
MMAX

 Niente da fare, ho già opzionato il posto.
Nella vita può capitare di non ottenere quello che si desidera. E tu lo
sai da sempre.
Carlo

 d'ordine pubblico? 
Forse perche' hanno commesso prima qualcosa che ha spinto un giudice a
candannarli a non entrare?
ByE,
FF


;; Keywords: calendar
;; Human-Keywords: Hebrew calendar, calendar, diary
;; This file is part of XEmacs.
;; XEmacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
;; the Free Software Foundation; either version 2, or (at your option)
;; any later version.
;; XEmacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
;; along with XEmacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.
;;; Synched up with: FSF 20.5
;;; Commentary:
;; This collection of functions implements the features of calendar.el and
;; diary.el that deal with the Hebrew calendar.
;; Technical details of all the calendrical calculations can be found in
;; ``Calendrical Calculations'' by Nachum Dershowitz and Edward M. Reingold,
;; Cambridge University Press (1997).
 
;; Comments, corrections, and improvements should be sent to
;;  Edward M. Reingold               Department of Computer Science
;;  
(217) 333-6733
                   University of Illinois at Urbana-Champaign
;;  
rein...@cs.uiuc.edu
             1304 West Springfield Avenue
;;                                   Urbana, Illinois 61801
;;; Code:
(require 'calendar)
(defun calendar-hebrew-from-absolute (date)
  "Compute the Hebrew date (month day year) corresponding to absolute DATE.
The absolute date is the number of days elapsed since the (imaginary)
Gregorian date Sunday, December 31, 1 BC."
  (let* ((greg-date (calendar-gregorian-from-absolute date))
         (month (aref [9 10 11 12 1 2 3 4 7 7 7 8]
                 (1- (extract-calendar-month greg-date))))
         (day)
         (year (+ 3760 (extract-calendar-year greg-date))))
    (while (>= date (calendar-absolute-from-hebrew (list 7 1 (1+ year))))
        (setq year (1+ year)))
    (let ((length (hebrew-calendar-last-month-of-year year)))
      (while (> date
                (calendar-absolute-from-hebrew
                 (list month
                       (hebrew-calendar-last-day-of-month month year)
                       year)))
        (setq month (1+ (% month length)))))
    (setq day (1+
               (- date (calendar-absolute-from-hebrew (list month 1 year)))))
    (list month day year)))
(defun hebrew-calendar-leap-year-p (year)
  "t if YEAR is a Hebrew calendar leap year."
  (< (% (1+ (* 7 year)) 19) 7))
(defun hebrew-calendar-last-month-of-year (year)
  "The last month of the Hebrew calendar YEAR."
  (if (hebrew-calendar-leap-year-p year)
      13
    12))
(defun hebrew-calendar-last-day-of-month (month year)
  "The last day of MONTH in YEAR."
  (if (or (memq month (list 2 4 6 10 13))
          (and (= month 12) (not (hebrew-calendar-leap-year-p year)))
          (and (= month 8) (not (hebrew-calendar-long-heshvan-p year)))
          (and (= month 9) (hebrew-calendar-short-kislev-p year)))
      29
    30))
(defun hebrew-calendar-elapsed-days (year)
  "Days from Sun. prior to start of Hebrew calendar to mean conjunction of Tishri of Hebrew YEAR."
  (let* ((months-elapsed
          (+ (* 235 (/ (1- year) 19));; Months in complete cycles so far.
             (* 12 (% (1- year) 19))      ;; Regular months in this cycle
             (/ (1+ (* 7 (% (1- year) 19))) 19)));; Leap months this cycle
         (parts-elapsed (+ 204 (* 793 (% months-elapsed 1080))))
         (hours-elapsed (+ 5
                           (* 12 months-elapsed)
                           (* 793 (/ months-elapsed 1080))
                           (/ parts-elapsed 1080)))
         (parts                                  ;; Conjunction parts
          (+ (* 1080 (% hours-elapsed 24)) (% parts-elapsed 1080)))
         (day                                    ;; Conjunction day
          (+ 1 (* 29 months-elapsed) (/ hours-elapsed 24)))
         (alternative-day
          (if (or (>= parts 19440)    ;; If the new moon is at or after midday,
                  (and (= (% day 7) 2);; ...or is on a Tuesday...
                       (>= parts 9924)  ;;    at 9 hours, 204 parts or later...
                       (not (hebrew-calendar-leap-year-p year)));; of a
                                                                ;; common year,
                  (and (= (% day 7) 1);; ...or is on a Monday...
                       (>= parts 16789) ;;   at 15 hours, 589 parts or later...
                       (hebrew-calendar-leap-year-p (1- year))));; at the end
                                                     ;; of a leap year
       ;; Then postpone Rosh HaShanah one day
              (1+ day)
       ;; Else
            day)))
    (if ;; If Rosh HaShanah would occur on Sunday, Wednesday, or Friday
        (memq (% alternative-day 7) (list 0 3 5))
  ;; Then postpone it one (more) day and return        
        (1+ alternative-day)
  ;; Else return        
      alternative-day)))
(defun hebrew-calendar-days-in-year (year)
  "Number of days in Hebrew YEAR."
  (- (hebrew-calendar-elapsed-days (1+ year))
     (hebrew-calendar-elapsed-days year)))
(defun hebrew-calendar-long-heshvan-p (year)
  "t if Heshvan is long in Hebrew YEAR."
  (= (% (hebrew-calendar-days-in-year year) 10) 5))
(defun hebrew-calendar-short-kislev-p (year)
  "t if Kislev is short in Hebrew YEAR."
  (= (% (hebrew-calendar-days-in-year year) 10) 3))
(defun calendar-absolute-from-hebrew (date)
  "Absolute date of Hebrew DATE.
The absolute date is the number of days elapsed since the (imaginary)
Gregorian date Sunday, December 31, 1 BC."
  (let* ((month (extract-calendar-month date))
         (day (extract-calendar-day date))
         (year (extract-calendar-year date)))
    (+ day                            ;; Days so far this month.
       (if (< month 7);; before Tishri
     ;; Then add days in prior months this year before and after Nisan
           (+ (calendar-sum
               m 7 (<= m (hebrew-calendar-last-month-of-year year))
               (hebrew-calendar-last-day-of-month m year))
              (calendar-sum
               m 1 (< m month)
               (hebrew-calendar-last-day-of-month m year)))
     ;; Else add days in prior months this year
         (calendar-sum
          m 7 (< m month)
          (hebrew-calendar-last-day-of-month m year)))
    (hebrew-calendar-elapsed-days year);; Days in prior years.
    -1373429)))                        ;; Days elapsed before absolute date 1.
(defvar calendar-hebrew-month-name-array-common-year
  ["Nisan" "Iyar" "Sivan" "Tammuz" "Av" "Elul" "Tishri"
   "Heshvan" "Kislev" "Teveth" "Shevat" "Adar"])
(defvar calendar-hebrew-month-name-array-leap-year
  ["Nisan" "Iyar" "Sivan" "Tammuz" "Av" "Elul" "Tishri"
   "Heshvan" "Kislev" "Teveth" "Shevat" "Adar I" "Adar II"])
(defun calendar-hebrew-date-string (&optional date)
  "String of Hebrew date before sunset of Gregorian DATE.
Defaults to today's date if DATE is not given.
Driven by the variable `calendar-date-display-form'."
  (let* ((hebrew-date (calendar-hebrew-from-absolute
                       (calendar-absolute-from-gregorian
                        (or date (calendar-current-date)))))
         (calendar-month-name-array
          (if (hebrew-calendar-leap-year-p (extract-calendar-year hebrew-date))
              calendar-hebrew-month-name-array-leap-year
            calendar-hebrew-month-name-array-common-year)))
    (calendar-date-string hebrew-date nil t)))
(defun calendar-print-hebrew-date ()
  "Show the Hebrew calendar equivalent of the date under the cursor."
  (interactive)
  (message "Hebrew date (until sunset): %s"
           (calendar-hebrew-date-string (calendar-cursor-to-date t))))
(defun hebrew-calendar-yahrzeit (death-date year)
  "Absolute date of the anniversary of Hebrew DEATH-DATE in Hebrew YEAR."
  (let* ((death-day (extract-calendar-day death-date))
         (death-month (extract-calendar-month death-date))
         (death-year (extract-calendar-year death-date)))
    (cond
     ;; If it's Heshvan 30 it depends on the first anniversary; if
     ;; that was not Heshvan 30, use the day before Kislev 1.
     ((and (= death-month 8)
           (= death-day 30)
           (not (hebrew-calendar-long-heshvan-p (1+ death-year))))
      (1- (calendar-absolute-from-hebrew (list 9 1 year))))
     ;; If it's Kislev 30 it depends on the first anniversary; if
     ;; that was not Kislev 30, use the day before Teveth 1.
     ((and (= death-month 9)
           (= death-day 30)
           (hebrew-calendar-short-kislev-p (1+ death-year)))
      (1- (calendar-absolute-from-hebrew (list 10 1 year))))
     ;; If it's Adar II, use the same day in last month of
     ;; year (Adar or Adar II).
     ((= death-month 13)
      (calendar-absolute-from-hebrew
       (list (hebrew-calendar-last-month-of-year year) death-day year)))
     ;; If it's the 30th in Adar I and year is not a leap year
     ;; (so Adar has only 29 days), use the last day in Shevat.
     ((and (= death-day 30)
           (= death-month 12)
           (not (hebrew-calendar-leap-year-p year)))
      (calendar-absolute-from-hebrew (list 11 30 year)))
     ;; In all other cases, use the normal anniversary of the date of death.
     (t (calendar-absolute-from-hebrew
         (list death-month death-day year))))))
(defun calendar-goto-hebrew-date (date &optional noecho)
  "Move cursor to Hebrew DATE; echo Hebrew date unless NOECHO is t."
  (interactive
   (let* ((today (calendar-current-date))
          (year (calendar-read
                 "Hebrew calendar year (>3760): "
                 '(lambda (x) (> x 3760))
                 (int-to-string
                  (extract-calendar-year
                   (calendar-hebrew-from-absolute
                    (calendar-absolute-from-gregorian today))))))
          (month-array (if (hebrew-calendar-leap-year-p year)
                           calendar-hebrew-month-name-array-leap-year
                         calendar-hebrew-month-name-array-common-year))
          (completion-ignore-case t)
          (month (cdr (assoc-ignore-case
                        (completing-read
                         "Hebrew calendar month name: "
                         (mapcar 'list (append month-array nil))
                         (if (= year 3761)
                             '(lambda (x)
                                (let ((m (cdr
                                          (assoc-ignore-case
                                           (car x)
                                           (calendar-make-alist
                                            month-array)))))
                                  (< 0
                                     (calendar-absolute-from-hebrew
                                      (list m
                                            (hebrew-calendar-last-day-of-month
                                             m year)
                                            year))))))
                         t)
                       (calendar-make-alist month-array 1))))
          (last (hebrew-calendar-last-day-of-month month year))
          (first (if (and (= year 3761) (= month 10))
                     18 1))
          (day (calendar-read
                (format "Hebrew calendar day (%d-%d): "
                        first last)
                '(lambda (x) (and (<= first x) (<= x last))))))
     (list (list month day year))))
  (calendar-goto-date (calendar-gregorian-from-absolute
                       (calendar-absolute-from-hebrew date)))
  (or noecho (calendar-print-hebrew-date)))
(defun holiday-hebrew (month day string)
  "Holiday on MONTH, DAY (Hebrew) called STRING.
If MONTH, DAY (Hebrew) is visible, the value returned is corresponding
Gregorian date in the form of the list (((month day year) STRING)).  Returns
nil if it is not visible in the current calendar window."
  (if (memq displayed-month;;  This test is only to speed things up a bit;
            (list          ;;  it works fine without the test too.
             (if (< 11 month) (- month 11) (+ month 1))
             (if (< 10 month) (- month 10) (+ month 2))
             (if (<  9 month) (- month  9) (+ month 3))
             (if (<  8 month) (- month  8) (+ month 4))
             (if (<  7 month) (- month  7) (+ month 5))))
      (let ((m1 displayed-month)
            (y1 displayed-year)
            (m2 displayed-month)
            (y2 displayed-year)
            (year))
        (increment-calendar-month m1 y1 -1)
        (increment-calendar-month m2 y2 1)
        (let* ((start-date (calendar-absolute-from-gregorian
                            (list m1 1 y1)))
               (end-date (calendar-absolute-from-gregorian
                          (list m2 (calendar-last-day-of-month m2 y2) y2)))
               (hebrew-start (calendar-hebrew-from-absolute start-date))
               (hebrew-end (calendar-hebrew-from-absolute end-date))
               (hebrew-y1 (extract-calendar-year hebrew-start))
               (hebrew-y2 (extract-calendar-year hebrew-end)))
          (setq year (if (< 6 month) hebrew-y2 hebrew-y1))
          (let ((date (calendar-gregorian-from-absolute
                       (calendar-absolute-from-hebrew
                        (list month day year)))))
            (if (calendar-date-is-visible-p date)
                (list (list date string))))))))
(defun holiday-rosh-hashanah-etc ()
  "List of dates related to Rosh Hashanah, as visible in calendar window."
  (if (or (< displayed-month 8)
          (> displayed-month 11))
      nil;; None of the dates is visible
    (let* ((abs-r-h (calendar-absolute-from-hebrew
                      (list 7 1 (+ displayed-year 3761))))
            (mandatory
             (list
              (list (calendar-gregorian-from-absolute abs-r-h)
                    (format "Rosh HaShanah %d" (+ 3761 displayed-year)))
              (list (calendar-gregorian-from-absolute (+ abs-r-h 9))
                    "Yom Kippur")
              (list (calendar-gregorian-from-absolute (+ abs-r-h 14))
                    "Sukkot")
              (list (calendar-gregorian-from-absolute (+ abs-r-h 21))
                    "Shemini Atzeret")
              (list (calendar-gregorian-from-absolute (+ abs-r-h 22))
                    "Simchat Torah")))
           (optional
            (list 
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (- abs-r-h 4)))
                   "Selichot (night)")
             (list (calendar-gregorian-from-absolute (1- abs-r-h))
                   "Erev Rosh HaShanah")
             (list (calendar-gregorian-from-absolute (1+ abs-r-h))
                   "Rosh HaShanah (second day)")
             (list (calendar-gregorian-from-absolute
                    (if (= (% abs-r-h 7) 4) (+ abs-r-h 3) (+ abs-r-h 2)))
                   "Tzom Gedaliah")
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (+ 7 abs-r-h)))
                   "Shabbat Shuvah")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 8))
                   "Erev Yom Kippur")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 13))
                   "Erev Sukkot")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 15))
                   "Sukkot (second day)")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 16))
                   "Hol Hamoed Sukkot (first day)")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 17))
                   "Hol Hamoed Sukkot (second day)")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 18))
                   "Hol Hamoed Sukkot (third day)")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 19))
                   "Hol Hamoed Sukkot (fourth day)")
             (list (calendar-gregorian-from-absolute (+ abs-r-h 20))
                   "Hoshannah Rabbah")))
            (output-list
             (filter-visible-calendar-holidays mandatory)))
      (if all-hebrew-calendar-holidays
          (setq output-list
                (append 
                 (filter-visible-calendar-holidays optional)
                 output-list)))
      output-list)))
(defun holiday-hanukkah ()
  "List of dates related to Hanukkah, as visible in calendar window."
    (if (memq displayed-month;;  This test is only to speed things up a bit;
              '(10 11 12 1 2));; it works fine without the test too.
        (let ((m displayed-month)
              (y displayed-year))
          (increment-calendar-month m y 1)
          (let* ((h-y (extract-calendar-year
                         (calendar-hebrew-from-absolute
                          (calendar-absolute-from-gregorian
                           (list m (calendar-last-day-of-month m y) y)))))
                 (abs-h (calendar-absolute-from-hebrew (list 9 25 h-y))))
            (filter-visible-calendar-holidays
             (list
              (list (calendar-gregorian-from-absolute (1- abs-h))
                    "Erev Hanukkah")
              (list (calendar-gregorian-from-absolute abs-h)
                    "Hanukkah (first day)")
              (list (calendar-gregorian-from-absolute (1+ abs-h))
                    "Hanukkah (second day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 2))
                    "Hanukkah (third day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 3))
                    "Hanukkah (fourth day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 4))
                    "Hanukkah (fifth day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 5))
                    "Hanukkah (sixth day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 6))
                    "Hanukkah (seventh day)")
              (list (calendar-gregorian-from-absolute (+ abs-h 7))
                    "Hanukkah (eighth day)")))))))
(defun holiday-passover-etc ()
  "List of dates related to Passover, as visible in calendar window."
 (if (< 7 displayed-month)
      nil;; None of the dates is visible
    (let* ((abs-p (calendar-absolute-from-hebrew
                      (list 1 15 (+ displayed-year 3760))))
           (mandatory
            (list
             (list (calendar-gregorian-from-absolute abs-p)
                   "Passover")
             (list (calendar-gregorian-from-absolute (+ abs-p 50))
                   "Shavuot")))
           (optional
            (list 
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (- abs-p 43)))
                   "Shabbat Shekalim")
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (- abs-p 30)))
                   "Shabbat Zachor")
             (list (calendar-gregorian-from-absolute
                    (if (= (% abs-p 7) 2) (- abs-p 33) (- abs-p 31)))
                   "Fast of Esther")
             (list (calendar-gregorian-from-absolute (- abs-p 31))
                   "Erev Purim")
             (list (calendar-gregorian-from-absolute (- abs-p 30))
                   "Purim")
             (list (calendar-gregorian-from-absolute
                    (if (zerop (% abs-p 7)) (- abs-p 28) (- abs-p 29)))
                   "Shushan Purim")
             (list (calendar-gregorian-from-absolute
                    (- (calendar-dayname-on-or-before 6 (- abs-p 14)) 7))
                   "Shabbat Parah")
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (- abs-p 14)))
                   "Shabbat HaHodesh")
             (list (calendar-gregorian-from-absolute
                    (calendar-dayname-on-or-before 6 (1- abs-p)))
                   "Shabbat HaGadol")
             (list (calendar-gregorian-from-absolute (1- abs-p))
                   "Erev Passover")
             (list (calendar-gregorian-from-absolute (1+ abs-p))
                   "Passover (second day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 2))
                   "Hol Hamoed Passover (first day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 3))
                   "Hol Hamoed Passover (second day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 4))
                   "Hol Hamoed Passover (third day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 5))
                   "Hol Hamoed Passover (fourth day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 6))
                   "Passover (seventh day)")
             (list (calendar-gregorian-from-absolute (+ abs-p 7))
                   "Passover (eighth day)")
             (list (calendar-gregorian-from-absolute
                    (if (zerop (% (+ abs-p 12) 7))
                        (+ abs-p 13)
                      (+ abs-p 12)))
                   "Yom HaShoah")
             (list (calendar-gregorian-from-absolute
                    (if (zerop (% abs-p 7))
                        (+ abs-p 18)
                      (if (= (% abs-p 7) 6)
                          (+ abs-p 19)
                        (+ abs-p 20))))
                   "Yom HaAtzma'ut")
             (list (calendar-gregorian-from-absolute (+ abs-p 33))
                   "Lag BaOmer")
             (list (calendar-gregorian-from-absolute (+ abs-p 43))
                   "Yom Yerushalaim")
             (list (calendar-gregorian-from-absolute (+ abs-p 49))
                   "Erev Shavuot")
             (list (calendar-gregorian-from-absolute (+ abs-p 51))
                   "Shavuot (second day)")))
           (output-list
             (filter-visible-calendar-holidays mandatory)))
      (if all-hebrew-calendar-holidays
          (setq output-list
                (append 
                 (filter-visible-calendar-holidays optional)
                 output-list)))
      output-list)))
(defun holiday-tisha-b-av-etc ()
  "List of dates around Tisha B'Av, as visible in calendar window."
  (if (or (< displayed-month 5)
          (> displayed-month 9))
      nil;; None of the dates is visible
    (let* ((abs-t-a (calendar-absolute-from-hebrew
                      (list 5 9 (+ displayed-year 3760)))))
      (filter-visible-calendar-holidays
       (list 
        (list (calendar-gregorian-from-absolute
               (if (= (% abs-t-a 7) 6) (- abs-t-a 20) (- abs-t-a 21)))
              "Tzom Tammuz")
        (list (calendar-gregorian-from-absolute
               (calendar-dayname-on-or-before 6 abs-t-a))
              "Shabbat Hazon")
        (list (calendar-gregorian-from-absolute
               (if (= (% abs-t-a 7) 6) (1+ abs-t-a) abs-t-a))
              "Tisha B'Av")
        (list (calendar-gregorian-from-absolute
               (calendar-dayname-on-or-before 6 (+ abs-t-a 7)))
              "Shabbat Nahamu"))))))
(defun list-hebrew-diary-entries ()
  "Add any Hebrew date entries from the diary file to `diary-entries-list'.
Hebrew date diary entries must be prefaced by `hebrew-diary-entry-symbol'
\(normally an `H').  The same diary date forms govern the style of the Hebrew
calendar entries, except that the Hebrew month names must be spelled in full.
The Hebrew months are numbered from 1 to 13 with Nisan being 1, 12 being
Adar I and 13 being Adar II; you must use `Adar I' if you want Adar of a
common Hebrew year.  If a Hebrew date diary entry begins with a
`diary-nonmarking-symbol', the entry will appear in the diary listing, but will
not be marked in the calendar.  This function is provided for use with the
`nongregorian-diary-listing-hook'."
  (if (< 0 number)
      (let ((buffer-read-only nil)
            (diary-modified (buffer-modified-p))
            (gdate original-date)
            (mark (regexp-quote diary-nonmarking-symbol)))
        (calendar-for-loop i from 1 to number do
           (let* ((d diary-date-forms)
                  (hdate (calendar-hebrew-from-absolute 
                          (calendar-absolute-from-gregorian gdate)))
                  (month (extract-calendar-month hdate))
                  (day (extract-calendar-day hdate))
                  (year (extract-calendar-year hdate)))
             (while d
               (let*
                   ((date-form (if (equal (car (car d)) 'backup)
                                   (cdr (car d))
                                 (car d)))
                    (backup (equal (car (car d)) 'backup))
                    (dayname
                     (concat
                      (calendar-day-name gdate) "\\|"
                      (substring (calendar-day-name gdate) 0 3) ".?"))
                    (calendar-month-name-array
                     calendar-hebrew-month-name-array-leap-year)
                    (monthname
                     (concat
                      "\\*\\|"
                      (calendar-month-name month)))
                    (month (concat "\\*\\|0*" (int-to-string month)))
                    (day (concat "\\*\\|0*" (int-to-string day)))
                    (year
                     (concat
                      "\\*\\|0*" (int-to-string year)
                      (if abbreviated-calendar-year
                          (concat "\\|" (int-to-string (% year 100)))
                        "")))
                    (regexp
                     (concat
                      "\\(\\`\\|\^M\\|\n\\)" mark "?"
                      (regexp-quote hebrew-diary-entry-symbol)
                      "\\("
                      (mapconcat 'eval date-form "\\)\\(")
                      "\\)"))
                    (case-fold-search t))
                 (goto-char (point-min))
                 (while (re-search-forward regexp nil t)
                   (if backup (re-search-backward "\\<" nil t))
                   (if (and (or (char-equal (preceding-char) ?\^M)
                                (char-equal (preceding-char) ?\n))
                            (not (looking-at " \\|\^I")))
                       ;;  Diary entry that consists only of date.
                       (backward-char 1)
                     ;;  Found a nonempty diary entry--make it visible and
                     ;;  add it to the list.
                     (let ((entry-start (point))
                           (date-start))
                       (re-search-backward "\^M\\|\n\\|\\`")
                       (setq date-start (point))
                       (re-search-forward "\^M\\|\n" nil t 2)
                       (while (looking-at " \\|\^I")
                         (re-search-forward "\^M\\|\n" nil t))
                       (backward-char 1)
                       (subst-char-in-region date-start (point) ?\^M ?\n t)
                       (add-to-diary-list
                        gdate
                        (buffer-substring-no-properties entry-start (point))
                        (buffer-substring-no-properties
                         (1+ date-start) (1- entry-start)))))))
              (setq d (cdr d))))
           (setq gdate
                 (calendar-gregorian-from-absolute
                  (1+ (calendar-absolute-from-gregorian gdate)))))
           (set-buffer-modified-p diary-modified))
        (goto-char (point-min))))
(defun mark-hebrew-diary-entries ()
  "Mark days in the calendar window that have Hebrew date diary entries.
Each entry in diary-file (or included files) visible in the calendar window
is marked.  Hebrew date entries are prefaced by a hebrew-diary-entry-symbol
\(normally an `H').  The same diary-date-forms govern the style of the Hebrew
calendar entries, except that the Hebrew month names must be spelled in full.
The Hebrew months are numbered from 1 to 13 with Nisan being 1, 12 being
Adar I and 13 being Adar II; you must use `Adar I' if you want Adar of a
common Hebrew year.  Hebrew date diary entries that begin with a
diary-nonmarking symbol will not be marked in the calendar.  This function
is provided for use as part of the nongregorian-diary-marking-hook."
  (let ((d diary-date-forms))
    (while d
      (let*
          ((date-form (if (equal (car (car d)) 'backup)
                          (cdr (car d))
                        (car d)));; ignore 'backup directive
           (dayname (diary-name-pattern calendar-day-name-array))
           (monthname
            (concat
             (diary-name-pattern calendar-hebrew-month-name-array-leap-year t)
             "\\|\\*"))
           (month "[0-9]+\\|\\*")
           (day "[0-9]+\\|\\*")
           (year "[0-9]+\\|\\*")
           (l (length date-form))
           (d-name-pos (- l (length (memq 'dayname date-form))))
           (d-name-pos (if (/= l d-name-pos) (+ 2 d-name-pos)))
           (m-name-pos (- l (length (memq 'monthname date-form))))
           (m-name-pos (if (/= l m-name-pos) (+ 2 m-name-pos)))
           (d-pos (- l (length (memq 'day date-form))))
           (d-pos (if (/= l d-pos) (+ 2 d-pos)))
           (m-pos (- l (length (memq 'month date-form))))
           (m-pos (if (/= l m-pos) (+ 2 m-pos)))
           (y-pos (- l (length (memq 'year date-form))))
           (y-pos (if (/= l y-pos) (+ 2 y-pos)))
           (regexp
            (concat
             "\\(\\`\\|\^M\\|\n\\)"
             (regexp-quote hebrew-diary-entry-symbol)
             "\\("
             (mapconcat 'eval date-form "\\)\\(")
             "\\)"))
           (case-fold-search t))
        (goto-char (point-min))
        (while (re-search-forward regexp nil t)
          (let* ((dd-name
                  (if d-name-pos
                      (buffer-substring
                       (match-beginning d-name-pos)
                       (match-end d-name-pos))))
                 (mm-name
                  (if m-name-pos
                      (buffer-substring
                       (match-beginning m-name-pos)
                       (match-end m-name-pos))))
                 (mm (string-to-int
                      (if m-pos
                          (buffer-substring
                           (match-beginning m-pos)
                           (match-end m-pos))
                        "")))
                 (dd (string-to-int
                      (if d-pos
                          (buffer-substring
                           (match-beginning d-pos)
                           (match-end d-pos))
                        "")))
                 (y-str (if y-pos
                            (buffer-substring
                             (match-beginning y-pos)
                             (match-end y-pos))))
                 (yy (if (not y-str)
                         0
                       (if (and (= (length y-str) 2)
                                abbreviated-calendar-year)
                           (let* ((current-y
                                   (extract-calendar-year
                                    (calendar-hebrew-from-absolute
                                     (calendar-absolute-from-gregorian
                                      (calendar-current-date)))))
                                  (y (+ (string-to-int y-str)
                                        (* 100 (/ current-y 100)))))
                             (if (> (- y current-y) 50)
                                 (- y 100)
                               (if (> (- current-y y) 50)
                                   (+ y 100)
                                 y)))
                         (string-to-int y-str)))))
            (if dd-name
                (mark-calendar-days-named
                 (cdr (assoc-ignore-case 
		       (substring dd-name 0 3)
                             (calendar-make-alist
                               calendar-day-name-array
                               0
                              '(lambda (x) (substring x 0 3))))))
              (if mm-name
                  (if (string-equal mm-name "*")
                      (setq mm 0)
                    (setq
                      mm
                      (cdr 
                        (assoc-ignore-case
			 mm-name
                            (calendar-make-alist
                               calendar-hebrew-month-name-array-leap-year))))))
              (mark-hebrew-calendar-date-pattern mm dd yy)))))
      (setq d (cdr d)))))
(defun mark-hebrew-calendar-date-pattern (month day year)
  "Mark dates in calendar window that conform to Hebrew date MONTH/DAY/YEAR.
A value of 0 in any position is a wildcard."
  (save-excursion
    (set-buffer calendar-buffer)
    (if (and (/= 0 month) (/= 0 day))
        (if (/= 0 year)
            ;; Fully specified Hebrew date.
            (let ((date (calendar-gregorian-from-absolute
                         (calendar-absolute-from-hebrew
                          (list month day year)))))
              (if (calendar-date-is-visible-p date)
                  (mark-visible-calendar-date date)))
          ;; Month and day in any year--this taken from the holiday stuff.
          (if (memq displayed-month;;  This test is only to speed things up a
                    (list          ;;  bit; it works fine without the test too.
                     (if (< 11 month) (- month 11) (+ month 1))
                     (if (< 10 month) (- month 10) (+ month 2))
                     (if (<  9 month) (- month  9) (+ month 3))
                     (if (<  8 month) (- month  8) (+ month 4))
                     (if (<  7 month) (- month  7) (+ month 5))))
              (let ((m1 displayed-month)
                    (y1 displayed-year)
                    (m2 displayed-month)
                    (y2 displayed-year)
                    (year))
                (increment-calendar-month m1 y1 -1)
                (increment-calendar-month m2 y2 1)
                (let* ((start-date (calendar-absolute-from-gregorian
                                    (list m1 1 y1)))
                       (end-date (calendar-absolute-from-gregorian
                                  (list m2
                                        (calendar-last-day-of-month m2 y2)
                                        y2)))
                       (hebrew-start
                        (calendar-hebrew-from-absolute start-date))
                       (hebrew-end (calendar-hebrew-from-absolute end-date))
                       (hebrew-y1 (extract-calendar-year hebrew-start))
                       (hebrew-y2 (extract-calendar-year hebrew-end)))
                  (setq year (if (< 6 month) hebrew-y2 hebrew-y1))
                  (let ((date (calendar-gregorian-from-absolute
                               (calendar-absolute-from-hebrew
                                (list month day year)))))
                    (if (calendar-date-is-visible-p date)
                        (mark-visible-calendar-date date)))))))
      ;; Not one of the simple cases--check all visible dates for match.
      ;; Actually, the following code takes care of ALL of the cases, but
      ;; it's much too slow to be used for the simple (common) cases.
      (let ((m displayed-month)
            (y displayed-year)
            (first-date)
            (last-date))
        (increment-calendar-month m y -1)
        (setq first-date
              (calendar-absolute-from-gregorian
               (list m 1 y)))
        (increment-calendar-month m y 2)
        (setq last-date
              (calendar-absolute-from-gregorian
               (list m (calendar-last-day-of-month m y) y)))
        (calendar-for-loop date from first-date to last-date do
          (let* ((h-date (calendar-hebrew-from-absolute date))
                 (h-month (extract-calendar-month h-date))
                 (h-day (extract-calendar-day h-date))
                 (h-year (extract-calendar-year h-date)))
            (and (or (zerop month)
                     (= month h-month))
                 (or (zerop day)
                     (= day h-day))
                 (or (zerop year)
                     (= year h-year))
                 (mark-visible-calendar-date
                  (calendar-gregorian-from-absolute date)))))))))
(defun insert-hebrew-diary-entry (arg)
  "Insert a diary entry.
For the Hebrew date corresponding to the date indicated by point.
Prefix arg will make the entry nonmarking."
  (interactive "P")
  (let* ((calendar-month-name-array
          calendar-hebrew-month-name-array-leap-year))
    (make-diary-entry
     (concat
      hebrew-diary-entry-symbol
      (calendar-date-string 
       (calendar-hebrew-from-absolute
        (calendar-absolute-from-gregorian
         (calendar-cursor-to-date t)))
       nil t))
     arg)))
(defun insert-monthly-hebrew-diary-entry (arg)
  "Insert a monthly diary entry.
For the day of the Hebrew month corresponding to the date indicated by point.
Prefix arg will make the entry nonmarking."
  (interactive "P")
  (let* ((calendar-date-display-form
          (if european-calendar-style '(day " * ") '("* " day )))
         (calendar-month-name-array
          calendar-hebrew-month-name-array-leap-year))
    (make-diary-entry
     (concat
      hebrew-diary-entry-symbol
      (calendar-date-string 
       (calendar-hebrew-from-absolute
        (calendar-absolute-from-gregorian
         (calendar-cursor-to-date t)))))
     arg)))
(defun insert-yearly-hebrew-diary-entry (arg)
  "Insert an annual diary entry.
For the day of the Hebrew year corresponding to the date indicated by point.
Prefix arg will make the entry nonmarking."
  (interactive "P")
  (let* ((calendar-date-display-form
          (if european-calendar-style
              '(day " " monthname)
            '(monthname " " day)))
         (calendar-month-name-array
          calendar-hebrew-month-name-array-leap-year))
    (make-diary-entry
     (concat
      hebrew-diary-entry-symbol
      (calendar-date-string 
       (calendar-hebrew-from-absolute
        (calendar-absolute-from-gregorian
         (calendar-cursor-to-date t)))))
     arg)))
;;;###autoload
(defun list-yahrzeit-dates (death-date start-year end-year)
  "List Yahrzeit dates for *Gregorian* DEATH-DATE from START-YEAR to END-YEAR.
When called interactively from the calendar window, the date of death is taken
from the cursor position."
  (interactive
   (let* ((death-date
           (if (equal (current-buffer) (get-buffer calendar-buffer))
               (calendar-cursor-to-date)
             (let* ((today (calendar-current-date))
                    (year (calendar-read
                           "Year of death (>0): "
                           '(lambda (x) (> x 0))
                           (int-to-string (extract-calendar-year today))))
                    (month-array calendar-month-name-array)
                    (completion-ignore-case t)
                    (month (cdr (assoc-ignore-case
                                  (completing-read
                                   "Month of death (name): "
                                   (mapcar 'list (append month-array nil))
                                   nil t)
                                 (calendar-make-alist month-array 1))))
                    (last (calendar-last-day-of-month month year))
                    (day (calendar-read
                          (format "Day of death (1-%d): " last)
                          '(lambda (x) (and (< 0 x) (<= x last))))))
               (list month day year))))
          (death-year (extract-calendar-year death-date))
          (start-year (calendar-read
                       (format "Starting year of Yahrzeit table (>%d): "
                               death-year)
                       '(lambda (x) (> x death-year))
                       (int-to-string (1+ death-year))))
          (end-year (calendar-read
                     (format "Ending year of Yahrzeit table (>=%d): "
                             start-year)
                       '(lambda (x) (>= x start-year)))))
   (list death-date start-year end-year)))
  (message "Computing yahrzeits...")
  (let* ((yahrzeit-buffer "*Yahrzeits*")
         (h-date (calendar-hebrew-from-absolute
                  (calendar-absolute-from-gregorian death-date)))
         (h-month (extract-calendar-month h-date))
         (h-day (extract-calendar-day h-date))
         (h-year (extract-calendar-year h-date)))
    (set-buffer (get-buffer-create yahrzeit-buffer))
    (setq buffer-read-only nil)
    (calendar-set-mode-line
     (format "Yahrzeit dates for %s = %s"
             (calendar-date-string death-date)
             (let ((calendar-month-name-array
                    (if (hebrew-calendar-leap-year-p h-year)
                        calendar-hebrew-month-name-array-leap-year
                      calendar-hebrew-month-name-array-common-year)))
               (calendar-date-string h-date nil t))))
    (erase-buffer)
    (goto-char (point-min))
    (calendar-for-loop i from start-year to end-year do
        (insert
         (calendar-date-string
          (calendar-gregorian-from-absolute
           (hebrew-calendar-yahrzeit
            h-date
            (extract-calendar-year
             (calendar-hebrew-from-absolute
              (calendar-absolute-from-gregorian (list 1 1 i))))))) "\n"))
    (goto-char (point-min))
    (set-buffer-modified-p nil)
    (setq buffer-read-only t)
    (display-buffer yahrzeit-buffer)
    (message "Computing yahrzeits...done")))
(defun diary-hebrew-date ()
  "Hebrew calendar equivalent of date diary entry."
  (format "Hebrew date (until sunset): %s" (calendar-hebrew-date-string date)))
(defun diary-omer ()
  "Omer count diary entry.
Entry applies if date is within 50 days after Passover."
  (let* ((passover
          (calendar-absolute-from-hebrew
           (list 1 15 (+ (extract-calendar-year date) 3760))))
         (omer (- (calendar-absolute-from-gregorian date) passover))
         (week (/ omer 7))
         (day (% omer 7)))
    (if (and (> omer 0) (< omer 50))
        (format "Day %d%s of the omer (until sunset)"
                omer
                (if (zerop week)
                    ""
                  (format ", that is, %d week%s%s"
                          week
                          (if (= week 1) "" "s")
                          (if (zerop day)
                              ""
                            (format " and %d day%s"
                                    day (if (= day 1) "" "s")))))))))
(defun diary-yahrzeit (death-month death-day death-year)
  "Yahrzeit diary entry--entry applies if date is yahrzeit or the day before.
Parameters are DEATH-MONTH, DEATH-DAY, DEATH-YEAR; the diary entry is assumed
to be the name of the person.  Date of death is on the *civil* calendar;
although the date of death is specified by the civil calendar, the proper
Hebrew calendar yahrzeit is determined.  If `european-calendar-style' is t, the
order of the parameters is changed to DEATH-DAY, DEATH-MONTH, DEATH-YEAR."
  (let* ((h-date (calendar-hebrew-from-absolute
                  (calendar-absolute-from-gregorian
                   (if european-calendar-style
                       (list death-day death-month death-year)
                   (list death-month death-day death-year)))))
         (h-month (extract-calendar-month h-date))
         (h-day (extract-calendar-day h-date))
         (h-year (extract-calendar-year h-date))
         (d (calendar-absolute-from-gregorian date))
         (yr (extract-calendar-year (calendar-hebrew-from-absolute d)))
         (diff (- yr h-year))
         (y (hebrew-calendar-yahrzeit h-date yr)))
    (if (and (> diff 0) (or (= y d) (= y (1+ d))))
        (format "Yahrzeit of %s%s: %d%s anniversary"
                entry
                (if (= y d) "" " (evening)")
                diff
                (cond ((= (% diff 10) 1) "st")
                      ((= (% diff 10) 2) "nd")
                      ((= (% diff 10) 3) "rd")
                      (t "th"))))))
(defun diary-rosh-hodesh ()
  "Rosh Hodesh diary entry.
Entry applies if date is Rosh Hodesh, the day before, or the Saturday before."
  (let* ((d (calendar-absolute-from-gregorian date))
         (h-date (calendar-hebrew-from-absolute d))
         (h-month (extract-calendar-month h-date))
         (h-day (extract-calendar-day h-date))
         (h-year (extract-calendar-year h-date))
         (leap-year (hebrew-calendar-leap-year-p h-year))
         (last-day (hebrew-calendar-last-day-of-month h-month h-year))
         (h-month-names
          (if leap-year
              calendar-hebrew-month-name-array-leap-year
            calendar-hebrew-month-name-array-common-year))
         (this-month (aref h-month-names (1- h-month)))
         (h-yesterday (extract-calendar-day
                       (calendar-hebrew-from-absolute (1- d)))))
    (if (or (= h-day 30) (and (= h-day 1) (/= h-month 7)))
        (format
         "Rosh Hodesh %s"
         (if (= h-day 30)
             (format
              "%s (first day)"
              ;; next month must be in the same year since this
              ;; month can't be the last month of the year since
              ;; it has 30 days
              (aref h-month-names h-month))
           (if (= h-yesterday 30)
               (format "%s (second day)" this-month)
             this-month)))
      (if (= (% d 7) 6);; Saturday--check for Shabbat Mevarhim
          (cond ((and (> h-day 22) (/= h-month 6) (= 29 last-day))
                 (format "Mevarhim Rosh Hodesh %s (%s)"
                         (aref h-month-names
                               (if (= h-month
                                      (hebrew-calendar-last-month-of-year
                                       h-year))
                                   0 h-month))
                         (aref calendar-day-name-array (- 29 h-day))))
                ((and (< h-day 30) (> h-day 22) (= 30 last-day))
                 (format "Mevarhim Rosh Hodesh %s (%s-%s)"
                         (aref h-month-names h-month)
                         (if (= h-day 29)
                             "tomorrow"
                           (aref calendar-day-name-array (- 29 h-day)))
                         (aref calendar-day-name-array
                               (% (- 30 h-day) 7)))))
        (if (and (= h-day 29) (/= h-month 6))
            (format "Erev Rosh Hodesh %s"
                    (aref h-month-names
                          (if (= h-month
                                 (hebrew-calendar-last-month-of-year
                                  h-year))
                              0 h-month))))))))
(defun diary-parasha ()
  "Parasha diary entry--entry applies if date is a Saturday."
  (let ((d (calendar-absolute-from-gregorian date)))
    (if (= (% d 7) 6);;  Saturday
        (let*
            ((h-year (extract-calendar-year
                      (calendar-hebrew-from-absolute d)))
             (rosh-hashanah
              (calendar-absolute-from-hebrew (list 7 1 h-year)))
             (passover
              (calendar-absolute-from-hebrew (list 1 15 h-year)))
             (rosh-hashanah-day
              (aref calendar-day-name-array (% rosh-hashanah 7)))
             (passover-day
              (aref calendar-day-name-array (% passover 7)))
             (long-h (hebrew-calendar-long-heshvan-p h-year))
             (short-k (hebrew-calendar-short-kislev-p h-year))
             (type (cond ((and long-h (not short-k)) "complete")
                         ((and (not long-h) short-k) "incomplete")
                         (t "regular")))
             (year-format
              (symbol-value
               (intern (format "hebrew-calendar-year-%s-%s-%s";; keviah
                               rosh-hashanah-day type passover-day))))
             (first-saturday;; of Hebrew year
              (calendar-dayname-on-or-before 6 (+ 6 rosh-hashanah)))
             (saturday;; which Saturday of the Hebrew year
              (/ (- d first-saturday) 7))
             (parasha (aref year-format saturday)))
          (if parasha
              (format
               "Parashat %s"
               (if (listp parasha);; Israel differs from diaspora
                   (if (car parasha)
                       (format "%s (diaspora), %s (Israel)"
                               (hebrew-calendar-parasha-name (car parasha))
                               (hebrew-calendar-parasha-name (cdr parasha)))
                     (format "%s (Israel)"
                             (hebrew-calendar-parasha-name (cdr parasha))))
                 (hebrew-calendar-parasha-name parasha))))))))
(defvar hebrew-calendar-parashiot-names
["Bereshith"   "Noah"      "Lech L'cha" "Vayera"    "Hayei Sarah" "Toledoth"
 "Vayetze"     "Vayishlah" "Vayeshev"   "Mikketz"   "Vayiggash"   "Vayhi"
 "Shemoth"     "Vaera"     "Bo"         "Beshallah" "Yithro"      "Mishpatim"
 "Terumah"     "Tetzavveh" "Ki Tissa"   "Vayakhel"  "Pekudei"     "Vayikra"
 "Tzav"        "Shemini"   "Tazria"     "Metzora"   "Aharei Moth" "Kedoshim"
 "Emor"        "Behar"     "Behukkotai" "Bemidbar"  "Naso"       "Behaalot'cha"
 "Shelah L'cha" "Korah"    "Hukkath"    "Balak"     "Pinhas"      "Mattoth"
 "Masei"       "Devarim"   "Vaethanan"  "Ekev"      "Reeh"        "Shofetim"
 "Ki Tetze"    "Ki Tavo"   "Nitzavim"   "Vayelech"  "Haazinu"]
  "The names of the parashiot in the Torah.")
;; The seven ordinary year types (keviot)
(defconst hebrew-calendar-year-Saturday-incomplete-Sunday
  [nil 52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22]
    23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 34 35 36 37 38 39 40 [41 42]
    43 44 45 46 47 48 49 50]
  "The structure of the parashiot.
Hebrew year starts on Saturday, is `incomplete' (Heshvan and Kislev each have
29 days), and has Passover start on Sunday.")
(defconst hebrew-calendar-year-Saturday-complete-Tuesday
  [nil 52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22]
    23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 34 35 36 37 38 39 40 [41 42]
    43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Saturday, is `complete' (Heshvan and Kislev each
have 30 days), and has Passover start on Tuesday.")
(defconst hebrew-calendar-year-Monday-incomplete-Tuesday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22]
    23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 34 35 36 37 38 39 40 [41 42]
    43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Monday, is `incomplete' (Heshvan and Kislev each
have 29 days), and has Passover start on Tuesday.")
(defconst hebrew-calendar-year-Monday-complete-Thursday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22]
   23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 (nil . 34) (34 . 35) (35 . 36)
   (36 . 37) (37 . 38) ([38 39] . 39) 40 [41 42] 43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Monday, is `complete' (Heshvan and Kislev each have
30 days), and has Passover start on Thursday.")
(defconst hebrew-calendar-year-Tuesday-regular-Thursday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22]
   23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 (nil . 34) (34 . 35) (35 . 36)
   (36 . 37) (37 . 38) ([38 39] . 39) 40 [41 42] 43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29 days and
Kislev has 30 days), and has Passover start on Thursday.")
(defconst hebrew-calendar-year-Thursday-regular-Saturday
  [52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 [21 22] 23
   24 nil (nil . 25) (25 . [26 27]) ([26 27] . [28 29]) ([28 29] . 30)
   (30 . 31) ([31 32] . 32) 33 34 35 36 37 38 39 40 [41 42] 43 44 45 46 47 48
   49 50]
  "The structure of the parashiot.
Hebrew year that starts on Thursday, is `regular' (Heshvan has 29 days and
Kislev has 30 days), and has Passover start on Saturday.")
(defconst hebrew-calendar-year-Thursday-complete-Sunday
  [52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
    23 24 nil 25 [26 27] [28 29] 30 [31 32] 33 34 35 36 37 38 39 40 [41 42]
    43 44 45 46 47 48 49 50]
  "The structure of the parashiot.
Hebrew year that starts on Thursday, is `complete' (Heshvan and Kislev each
have 30 days), and has Passover start on Sunday.")
;; The seven leap year types (keviot)
(defconst hebrew-calendar-year-Saturday-incomplete-Tuesday
  [nil 52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
    23 24 25 26 27 nil 28 29 30 31 32 33 34 35 36 37 38 39 40 [41 42]
    43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Saturday, is `incomplete' (Heshvan and Kislev each
have 29 days), and has Passover start on Tuesday.")
(defconst hebrew-calendar-year-Saturday-complete-Thursday
  [nil 52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
   23 24 25 26 27 nil 28 29 30 31 32 33 (nil . 34) (34 . 35) (35 . 36)
   (36 . 37) (37 . 38) ([38 39] . 39) 40 [41 42] 43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Saturday, is `complete' (Heshvan and Kislev each
have 30 days), and has Passover start on Thursday.")
(defconst hebrew-calendar-year-Monday-incomplete-Thursday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
   23 24 25 26 27 nil 28 29 30 31 32 33 (nil . 34) (34 . 35) (35 . 36)
   (36 . 37) (37 . 38) ([38 39] . 39) 40 [41 42] 43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Monday, is `incomplete' (Heshvan and Kislev each
have 29 days), and has Passover start on Thursday.")
(defconst hebrew-calendar-year-Monday-complete-Saturday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
   23 24 25 26 27 nil (nil . 28) (28 . 29) (29 . 30) (30 . 31) (31 . 32)
   (32 . 33) (33 . 34) (34 . 35) (35 . 36) (36 . 37) (37 . 38) (38 . 39)
   (39 . 40) (40 . 41) ([41 42] . 42) 43 44 45 46 47 48 49 50]
  "The structure of the parashiot.
Hebrew year that starts on Monday, is `complete' (Heshvan and Kislev each have
30 days), and has Passover start on Saturday.")
(defconst hebrew-calendar-year-Tuesday-regular-Saturday
  [51 52 nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
   23 24 25 26 27 nil (nil . 28) (28 . 29) (29 . 30) (30 . 31) (31 . 32)
   (32 . 33) (33 . 34) (34 . 35) (35 . 36) (36 . 37) (37 . 38) (38 . 39)
   (39 . 40) (40 . 41) ([41 42] . 42) 43 44 45 46 47 48 49 50]
  "The structure of the parashiot.
Hebrew year that starts on Tuesday, is `regular' (Heshvan has 29 days and
Kislev has 30 days), and has Passover start on Saturday.")
(defconst hebrew-calendar-year-Thursday-incomplete-Sunday
  [52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
    23 24 25 26 27 28 nil 29 30 31 32 33 34 35 36 37 38 39 40 41 42
    43 44 45 46 47 48 49 50]
  "The structure of the parashiot.
Hebrew year that starts on Thursday, is `incomplete' (Heshvan and Kislev both
have 29 days), and has Passover start on Sunday.")
(defconst hebrew-calendar-year-Thursday-complete-Tuesday
  [52 nil nil 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
    23 24 25 26 27 28 nil 29 30 31 32 33 34 35 36 37 38 39 40 41 42
    43 44 45 46 47 48 49 [50 51]]
  "The structure of the parashiot.
Hebrew year that starts on Thursday, is `complete' (Heshvan and Kislev both
have 30 days), and has Passover start on Tuesday.")
(defun hebrew-calendar-parasha-name (p)
  "Name(s) corresponding to parasha P."
  (if (arrayp p);; combined parasha
      (format "%s/%s"
              (aref hebrew-calendar-parashiot-names (aref p 0))
              (aref hebrew-calendar-parashiot-names (aref p 1)))
    (aref hebrew-calendar-parashiot-names p)))
(provide 'cal-hebrew)
;;; cal-hebrew.el ends here

sai da sempre.
Non ti conosco da cosi' a lungo Carle'.
MMAX

 candannarli a non entrare?
E cosa si deve fare per essere candannati?
E se il major intendesse fare un'azione preventiva?
Carlo

 Non ti conosco da cosi' a lungo Carle'.
Infatti, tu il problema ce l'hai da prima. Molto prima.
Carlo

 e non sono in grado. 
Nobile scopo.
-- 
     /kinkie
Ed ora, qualche parola dai nostri sponsor: 
Man invented language to satisfy his deep need to complain.
		-- Lily Tomlin

 Credo che si chiami "costituzione".
Senza scomodare tanto alti principi, ce ne e` anche un altro: "legge".
-- 
     /kinkie
Ed ora, qualche parola dai nostri sponsor: 
fortune: not found

 A me invece non spiace. Ti spiace che non mi spiaccia?
ma nemmeno un po'. chi s'accontenta gode, o almeno crede di godere.
	-p-

Credo che si chiami "costituzione".
Tu brandisci la costituzione come uno strumento autoritario, per
imporre una visione centrale a tutti (che e', peraltro, la colpa che
addosso ai vecchi padri della patria oggi un po' rincoglioniti,
modello Bobbio per intenderci). La costituzione e' una enunciazione
generica di principi la cui interpretazione e la cui importanza
reciproca deve variare a seconda dei momenti storici. In questo
momento, il trend sociale prevalente sostiene che e' piu' importante
la liberta' dell'eguaglianza.
-- 
vb.          [v.bertola(at)
bertola.eu.org
 - M*RZ*'s Pusher User]<--------
----> 
http://bertola.eu.org/
    [Conan, Mononoke Hime e molto altro]<----
--------> 
http://www.poli.studenti.to.it/prometeo/
    [Progetto Prometeo]

;;; cal-hebrew.el --- calendar functions for the Hebrew calendar.
<inserire commento sull'inutile complessita' del calendario ebraico e
sulla rottura di scatole che cio' rappresenta per la gente normale>
<generare un thread di protesta con le accuse di nazi-antisemitismo e
le lamentele per l'uso dell'aggettivo "normale">
<disconnettersi da IFQ per dieci giorni e tornare postando qualcosa di
completamente diverso>
Totale: 127 bait.


 un'azione preventiva?
Molto difficile poterla giustificare.
ByE,
FF

E se il major intendesse fare un'azione preventiva?
Mayor, Carlo. Major vuol dire "M/maggiore".
Affettuosamente,
-- 
Isa
Work like you don't need money,
Love like you've never been hurt,
And dance like no one's watching
http://web.tiscalinet.it/alfabeto_auschwitz/

 Affettuosamente,
Aisa, cribbio, non se n'era accorto nessuno. Torna la maestrina e con
chi se la prende?
Con l'unico con cui può scambiare post in dialetto. Lo so che lo fai con
affetto, ma...giv mi e breich :)
Carlo

affetto,
E alura cata soe e fa sito!


 la liberta' dell'eguaglianza.
E quindi? La costituzione ti lascia margini di manovra, ma ci sei o
dentro o fuori.
-- 
Ciao,
Matteo

 quello ci penseranno i suoi elettori.
Questo può avere senso solo se si ipotizza che uno passi l'interezza
della sua vita nel suo comune di residenza.
-- 
Ciao,
Matteo

 Imprevedibilita' ed anticonformismo non sono la stessa cosa.
Appunto. Ti avevo chiesto se il tuo non voler essere prevedibile era
dettato dall'anticonformismo o da un motivo serio.
-- 
Ciao,
Matteo

dentro o fuori.
Se la interpreti in modo massimalista, praticamente qualsiasi cosa ne
e' fuori.


della sua vita nel suo comune di residenza.
Ma la popolazione di un Comune e' o no libera di farsi i cazzi propri
a casa propria senza che arrivi qualcuno da Roma a predicare?


 Ad ogni modo, paesi governati dal centrosinistra come gli USA 
rotfl.
	-p-

 una democrazia?
Democracy.dll generated a general protection fault. Application Italia.exe will
be terminated.
-- 
. Simone Caldana - System Manager at Vitaminic spa              .
. Feel the usenet revolution: 
http://www.i2000.usenet.it/
       .
. E-Mail: 
e...@vitaminic.net
  Web URL: 
http://simone.caldana.org
 .

 a casa propria senza che arrivi qualcuno da Roma a predicare?
Spero che questa frase del mio portavoce chiarisca ai presenti le origini della
Lega Nord.


 
Istinto di sopravvivenza. Pare che l'imprevidibilita' sia sempre stata un
buon vantaggio evolutivo (spiega l'esistenza dei mancini, che in genere
tendono a crepare dieci anni prima)
ByE,
FF

;;; cal-hebrew.el --- calendar functions for the Hebrew calendar.
Le mie lamentele:
a) invece di 58 KB bastava un link, e comunque
b) lo conoscevo gia`, e comunque
c) non parlo l'elisp e nemmeno ci tengo troppo a impararlo
-- 
ciao, | Software is like sex; it's better when it's free.  -- Linus Torvalds
Marco | (Ri)scoprire fidonet: 
http://bbs.mi.linux.it

racconta.)
E` noto che i tumori sono comunisti, a quanto pare colpiscono
indifferentemente ricchi e poveri.


Ad ogni modo, paesi governati dal centrosinistra come gli USA e alcuni
ROFLASTC!


 tendono a crepare dieci anni prima)
naaaa, non ci credo.
	-p-

fuori dal vaso?
Espansionismo (ma soprattutto scarsa mira; e dire che il buco non e'
piccolo).
Ciao, Alessio.
-- 
  PER RISPONDERE TOGLIERE  .linus
Il manuale di Agent: 
http://space.tin.it/cinema/claveron/alessio/index.htm
Le FAQ di ICSN: 
http://space.tin.it/cinema/claveron/alessio/FAQ-icsn.htm
Guida a FAgent: 
http://space.tin.it/cinema/claveron/alessio/FAgent/FA-man.htm

Le feste mobili cattoliche le ho ancorate alla pasqua
E per la Pasqua come hai fatto?


ma nemmeno un po'. chi s'accontenta gode, o almeno crede di godere.
Chi gode s'accontenta di piu'.
-- 
Isa
I am in a rock band. 
I am in the best rock band in the world: 
I got Larry Mullen playing drums, got the Edge on guitar, 
got Adam Clayton on the bass.
(Bono Vox, on U2)
 

E per la Pasqua come hai fatto?
Ci ha pensato Gauss un bel po' di tempo fa.


tendono a crepare dieci anni prima)
Mavva'n'topic!
Come si fa' la faccina che si tocca le palle?
-- 
manuel 'left/handed' ferrero

 --
dovresti chiederlo a d'annunzio
ipazia

 c) non parlo l'elisp e nemmeno ci tengo troppo a impararlo
  le tue lamentele? tsk! tu chiedi... ti ricordi il racconto dei tre
  desideri? ancora ti e' andata bene!
  a) cercare il link, avrei perso 18 secondi almeno, mentre inserire
     il file nel buffer: 0.3 secondi, spedire 58 k: 0.1 secondi
  b) cosa cazzo chiedi le cose che conosci gia' (fanculo!)
  c) non parli l'elisp? milioni di fan si tigirano nel lettuccio: non
     parla l'elisp... [cross-posted on i.f.mdi]
ps: quanto tempo ho perso per qs reply? :-)
pps: da repubblica di ieri o ieri l'altro (non cerco il link) un
     calendario complicatissimo, anzi: *COMPLICATISSIMO* e' il
     calendario amarico, usato (tuttora? fino all'altro ieri?) in
     Etiopia (in emacs c'e' il calendario copto, non so se sia lo
     stesso...) (lo vuoi? te lo posto?)
ciao marco      

 non esistono.
  vista a riomaggiore (sp) su quei tabelloni che mettono fuori
  dall'edicola
  "cane lupo sbrana undici galline"
  una delle cose piu' belle delle mia vita
  fanculo

 ipazia
AleX

 e' fuori.
Esempio?
-- 
Ciao,
Matteo

 tendono a crepare dieci anni prima)
Mavaffanculo.
-- 
Ciao,
Matteo

 a casa propria senza che arrivi qualcuno da Roma a predicare?
No.
-- 
Ciao,
Matteo

 Esempio?
la copertina
-- 
. Simone Caldana - System Manager at Vitaminic spa              .
. Feel the usenet evolution: 
http://www.i2000.usenet.it/
        .
. E-Mail: 
e...@vitaminic.net
 Web URL: 
http://simone.caldana.org/
 .

dovresti chiederlo a d'annunzio
Qualcosa tipo
:(8)
?
Cazzo, ora m'hai pure fatto fare una faccina. Se mi vede l'MLF!
-- 
manuel 'fmf' ferrero

 Il tu...[esnippete]
Mi sorprendo sempre per la varieta' dei tuoi argomenti.
Per essere un bovino reggi bene le conversazioni.
Sara' lo spirito di mandria.
--
B.

 tendono a crepare dieci anni prima)
Ballero' sulla tua tomba.
--
bak

 Mavaffanculo.
E che ne posso io? Sei tu che sei nato mancino.
ByE,
FF

 Ballero' sulla tua tomba.
sai che lavoro... C'e' gia', ma non ti daro' il piacere di vederla
occupata.
BTW: un altro mancino? Ora si spiega la sinistrosita' del gruppo...
ByE,
FF

 Sara' lo spirito di mandria.
Mi viene un dubbio
Carlo

 Vicino a Romano, nella ridente (?) bergamasca, o bresciana, o giu` di
li`.
Effettivamente è ridente. Per la totale mancanza di conoscenze
geografiche di kinkie. A meno che il termine di paragone fosse
Acquapozzillo.
Carlo

 Acquapozzillo.
  e dillo! e' dietro il montorfano di brescia...

   e dillo! e' dietro il montorfano di brescia...
a me i bresciani sta simpatici e i bergamaschi invece no.
chissa' perche'.
	-p-

 chissa' perche'.
vedremo di evitare un suicidio di massa per la disperazione.
Carlo

 mi spiace per te.
Faccio un copia incolla o te li guardi da te?
Carlo

 vedremo di evitare un suicidio di massa per la disperazione.
perche'? sei bergamasco?
mi spiace per te.
	-p-

 Mi viene un dubbio
E' gia' qualcosa.
--
B.

 BTW: un altro mancino? Ora si spiega la sinistrosita' del gruppo...
Io non sono ambidestro, sono bimancino, checcevoifa'...
--
B.

 Io non sono ambidestro, sono bimancino, checcevoifa'...
C'e' gia' mio padre che lo dice da prima che tu nascessi.
ByE,
FF

 Faccio un copia incolla o te li guardi da te?
fai un copia-incolla, almeno fai qualcosa.
	-p-

 fai un copia-incolla, almeno fai qualcosa.
mi sto dando lo smalto alle unghie, forse più tardi.
Carlo

 C'e' gia' mio padre che lo dice da prima che tu nascessi.
Lo invitero' al rave :P
--
B.

 Acquapozzillo.
Il termine di paragone era la Groenlandia citeriore.
-- 
     /kinkie
Ed ora, qualche parola dai nostri sponsor: 
Tax reform means "Don't tax you, don't tax me, tax that fellow behind
the tree."
		-- Russell Long

 E che ne posso io? Sei tu che sei nato mancino.
Ora mi chiedo: dieci anni prima *di cosa*?
-- 
Ciao,
Matteo

 
Su dai un piccolo sforzo. Non mi pare che i mancini abbiano scarse
capacita' logico deduttive, crepano solo prima.
ByE,
FF

sarai pregato di non lamentarti.
Cio', come dicono i vecchi dei nostri paesi (che notoriamente sono
saggi e non sono ne' di destra ne' di sinistra) e' colpa dei verdi
cittadini, che non capendo un cazzo di vita di montagna hanno imposto
di non fare piu' i normali lavori di manutenzione dei fiumi, tipo
tagliare la vegetazione prima che ci cada dentro o dragare il fondo
ogni tanto, per "proteggere l'ambiente".
-- 
vb.          [v.bertola(at)
bertola.eu.org
 - M*RZ*'s Pusher User]<--------
----> 
http://bertola.eu.org/
    [Conan, Mononoke Hime e molto altro]<----
--------> 
http://www.poli.studenti.to.it/prometeo/
    [Progetto Prometeo]

No.
Sei uno statalista, di quelli che pianificano di mandare i carri
armati in Lombardia non appena verra' richiesta piu' autonomia, come
fece Milosevic col Kosovo. Ma non puoi poi lamentarti se il paese non
sta insieme. I russi hanno represso per anni l'indipendenza delle
comunita' baltiche piuttosto che islamiche, per non parlare dell'est
Europa, coi carri armati, e qui tutti a far finta di non sapere
perche' faceva comodo a tutti: la DC e il PSI che mangiavano il paese,
e il PCI che mangiava nelle roccaforti rosse (ma tu Zampini o Greganti
non sai neanche chi erano, vero?).
Fanno cinquantamila di bocca, e centomila scopare.
Pero' spiegami secondo te qual e' la differenza tra la repressione
serba in kosovo e quella romana in lombardia. Sono curioso.


ogni tanto, per "proteggere l'ambiente".
I vecchi delle tue parti nel 51 erano giovani, i verdi non c'erano e
tutto il polesine sembrava una grande venezia (ma senza il lido).
Gli e' che i giovani imbecilli invecchiando diventano dei vecchi
imbecilli.
-- 
Zonker
* * work is the curse of drinking class * *

non sai neanche chi erano, vero?).
Prino o Secondo?
-- 
manuel 'fmf' ferrero

Fanno cinquantamila di bocca, e centomila scopare.
Alle Cascine son piu' fini, "cinquanta di bbocca, cento l'ammore".
-- 
Isa
Work like you don't need money,
Love like you've never been hurt,
And dance like no one's watching
http://web.tiscalinet.it/alfabeto_auschwitz/

 capacita' logico deduttive, crepano solo prima.
Se non l'hai detto non l'hai detto, non c'č niente da dedurre.
-- 
Ciao,
Matteo

 serba in kosovo e quella romana in lombardia. Sono curioso.
C'è una cosa che si chiama "etica". Lo so che il calcolo etico non è
ancora stato inventato e a giudicare da quanto succede in Alpha
Centauri dovremo aspettare ancora qualche secolo, ma non puoi dire che
si tratti di cose equivalenti solo perché si tratta di costrizioni.
In ogni caso vorrei farti notare che la repressione romana in lombardia
in questione consiste nella repressione di una repressione nei confronti
di una minoranza. Quindi, anche supponendo che una repressione sia Male,
è problematico stabilire cos'è una meta-repressione.
-- 
Ciao,
Matteo

 è problematico stabilire cos'è una meta-repressione.
Matteo, e' solo un ingegnere, cerca di non farmelo incartare.
--
B.

di una minoranza.
Cosa cosa cosa? Ma tu leggi anche il testo degli articoli o hai un
sistema di analisi del tipo "$giudizio = 'Male' if /Lombardia/;" ?
Il provvedimento regionale represso dal governo centrale non diceva
mica "fuori i terroni dalla Lombardia". Diceva solo che si voleva
chiedere ai cittadini se volevano che la Lombardia, "nell'ambito
dell'unita' nazionale", gestisse autonomamente una serie di cose che
prima gestiva lo stato. E i cittadini, tra l'altro, potevano anche
rispondere "no", mentre adesso, avendo il Governo vietato ai cittadini
di esprimersi, avranno buon gioco a sostenere che in Lombardia sono
tutti d'accordo con il federalismo polista.
E BTW i sistemi di governo in cui il Governo centrale cancella
d'autorita' delle votazioni pubbliche di solito non sono considerati
molto democratici.


imbecilli.
Possibile; comunque mi sembra che nessuno contesti che negli ultimi
anni la frequenza di fenomeni naturali disastrosi e' molto aumentata.
Gli ecologisti sostengono che e' colpa dell'effetto serra e in
generale dell'intervento dell'industria sul nostro ecosistema; gli
anti-ecologisti sostengono che e' colpa dei divieti e in generale
dell'intervento degli ecologisti sul nostro ecosistema. Gli ecologisti
sono piu' simpatici alla stampa, che puo' fare ottimi articoli di
colore, ma come facciamo a sapere chi ha ragione?


 dell'unita' nazionale",
Le references asseriscono chiaramente che si parlava della vaccata che
hanno fatto a Rovato.
-- 
Ciao,
Matteo

come facciamo a sapere chi ha ragione?
Vai in libreria e/o nell'internette e ti documenti sulle
argomentazioni degli ecologisti, poi vai anche al bar sport e ti
documenti su quelle degli antiecologisti.
E ti fai una bella opinione rigorosamente indipendente dai partiti,
dalla politica, dal tifo e dalle ideologie.


 *proprietà privata* dei loro abitanti.
Se sostituisci 'abitanti' con 'chi paga le tasse' il parallelismo e'
ovvio. 
 
ByE,
FF

 ovvio. 
a parte che sono le imposte e non le tasse, sono il re d'italia.
e mo' rispedisco tutti gli autonomi in albania. per decreto.
inoppugnabile.
	-p-



Ale!!
Finalmente abbiamo trovato il punto di convergenza risolutivo e
inoppugnabile.
Chi paga le tasse (ma tutte pero', non cercate di fare i furbi) deve
avere tutto il potere e diritto di proprieta' sulle cose, gli uomini e
gli animali della nazione.
Chi le evade sara' ridotto in schiavitu'.
TUTTO IL POTERE ALLA CLASSE OPERAIA! (e anche ai parastatali, che noi
siamo diplomati - all'itis, va beh; ma sempre diplomati - e sappiamo
cosa si deve fare).
Lunga vita al compagno Fabio Forno! 


 Lunga vita al compagno Fabio Forno! 
Lunga vita a me, si' non sono in disaccordo.
ByE,
FF

 il numero di schivi a disposizione) dovrebbe essere proporzionale alle tasse pagate.
Ho sempre sognato di avere uno staff di dentisti, negozianti e piccoli imprenditori ai miei ordini.
bye bye
 sTeVe

 il numero di schivi a disposizione) dovrebbe essere proporzionale alle
tasse pagate.
E se sono espansivi non se ne fa niente?
Carlo

 imprenditori ai miei ordini.
Io schiavi, senza distinzioni (non sono classista)
ByE,
FF

 E se sono espansivi non se ne fa niente?
No, perche' non ho spazio.
ByE,
FF

 ovvio. 
ROTFL.
-- 
Ciao,
Matteo

il numero di schivi a disposizione) dovrebbe essere proporzionale alle tasse pagate. 
Facciamo che sia proporzionale alla percentuale di tasse pagate sul
dovuto e chiudiamo la trattativa.
Se concordi facciamo sta rivoluzione finale, riscriviamo un attimino i
libri di storia per spiegare bene cosa e' successo *davvero* e poi non
se ne parla piu'.
Ci stai?
('azz, gia' mi vedo i nostri nipotini cristonare sui libri di scuola
per imparare a memoria le date significative delle vite di Sciasbat e
Zonker: i Padri della Nuova Era)


 Zonker: i Padri della Nuova Era)
Io invece mi vedo gli 'storici' fare ricerche su deja per cercare le
fonti originali... 
ByE,
FF

documenti su quelle degli antiecologisti.
Si' ma cosi' e' un po' come farsi plagiare. Preferisco avere una
opinione indipendente dai dati di fatto.


 FF

> ovunque a Torino.
E per il quale il VCO non esiste.  D'altra parte i miei conterranei si
lamentano sempre, ma mai che abbiano pensato a nominare un addetto stampa
ed a mandarlo in giro per redazioni; perfino a Cuneo ci sono arrivati, ma
noi verbanesi no, questo tipo di intuito non ce l'abbiamo.
Comunque io ho bypassato il problema trasferendomi a Lugano tra gli
extracomunitari...
-- 
fB

extracomunitari...
Non dirlo a me, che tutte le volte che atterro a Caselle venendo da
Zurigo e' un casino.


Zurigo e' un casino.
Qui per il mal di schiena consigliano un atterraggio sulla pista
dell'aeroporto di Lugano/Agno.  Ovviamente il mal di schiena lo fa
venire e non passare.  Pista corta atterraggio brusco.
-- 
fB

venire e non passare.  Pista corta atterraggio brusco.
L'ho scoperto quando sono atterrato a Genova, la domenica
dell'alluvione. Non pensavo che i 747 potessero atterrare da fermi.
