בלאט 1 פון 3

אידישע לוח

געשריבן: זונטאג סעפטעמבער 18, 2011 4:07 pm
דורך ריק פערי
איך זיך א אידישע לוח וואס גייט לויט די חדשים, ד.ה. נישט די זמנים פון יעדן טאג, נאר אזוי ווי די דיפאולד ענדראוד קעלענדער וויל איך אויף די אידישע לוח, ד. ה. יעדע חודש אויף איין בלאט, יעדע שורה א וואך, וכו' אזוי ווי א נארמאלע לוח.

געשריבן: זונטאג סעפטעמבער 18, 2011 4:13 pm
דורך moshele11211
פון דא קענסטו דאונלאודן צו א דשימעיל אדער אוטלאק וכו': שוין דא אשכולות אויף דעם

געשריבן: זונטאג סעפטעמבער 18, 2011 8:40 pm
דורך פאטאקי08

געשריבן: זונטאג סעפטעמבער 18, 2011 9:05 pm
דורך ריק פערי
פאטאקי די לינק ארבייט נישט.

בכלל איך רעד פון א ענדרויד פאון, די לינקס וואס ענק ברענגען איז פאר סעלפאונס? איך האב פראבירט די ערשטע לינק אבער איך זעה נישט קיין אפשן פאר ענדרויד פאון, איך האב פראבירט 'גוגל קאלענדער' אבער איך זעה נישט אז עפעס האט זיך געטוישט מיט מיין דיפאולט קעלענדער, עני העלפ? יש"כ פון פאראויס.

געשריבן: זונטאג סעפטעמבער 18, 2011 9:14 pm
דורך בחורהזעצער
די קומענדיגע איז פאר גוגל קאלענדער, איך האב נישט קיין ענדראוד צו וויסן צו עס איז גוט פאר דעם, סא פרוביר דאס אליין אויס.

איך האב דאס אנגעשטעלט לויט מיין געשמאק, קענסט עס מאכן ווי אזוי דו ווילסט, איך האף אז דו וועסט אליין פארשטיין.

קליק אויף גוגל קאלענדער

געשריבן: זונטאג סעפטעמבער 18, 2011 9:20 pm
דורך בחורהזעצער
סאררי איך האב נישט באמערקט אז דו האסט שוין גערעדט דערפון.

דא האסטו צוויי לינקס ספעציעל פאר ענדראוד, איך האב עס נישט פרובירט.

איינס
צוויי

געשריבן: זונטאג סעפטעמבער 18, 2011 9:20 pm
דורך בחורהזעצער
תשלומי כפל?

געשריבן: זונטאג סעפטעמבער 18, 2011 11:11 pm
דורך פאטאקי08
ריק פערי האט געשריבן:פאטאקי די לינק ארבייט נישט.

ארבעט שוין

געשריבן: זונטאג סעפטעמבער 18, 2011 11:12 pm
דורך ריק פערי
א גרויסן שכ'ח פאר אלע ב"ה ס'ארבייט שוין אין מיין דיפאולד קאלענדער.

געשריבן: זונטאג נובעמבער 25, 2012 7:32 pm
דורך פאטאקי08
http://luach.ontimedatasolutions.com/
ציגעלייגט די פרשיות
דערווייל נאר ביז שנת פ"א
בקרוב וועט דאס ווערן געאפדעיט אויף ווייטער בעז"ה
ווי אויך וועט ציקומען קאלאר אויף די טעג וואס זענען יומא דפגרא וכדומה
דערנאך וועט ציקומען ספירת העומר
וואס נאך?

געשריבן: זונטאג נובעמבער 25, 2012 8:07 pm
דורך ריק פערי
האט דאס א שייכות צו ענדראוד? אדער ס'איז נאר א אנליין לוח?

געשריבן: זונטאג נובעמבער 25, 2012 8:43 pm
דורך פאטאקי08
אנליין לוח

געשריבן: זונטאג דעצמבער 02, 2012 5:22 pm
דורך פאטאקי08
ציגעלייגט די מועדים
אויב איז יענע טאג א מועד וועט עס זיין פינק און עס באקומט א טולטיפ מיט די מועד (לייג ארויף די מייזל אויף די באטטאן זעסטו די מועד פון יענע טאג)
http://luach.ontimedatasolutions.com/

געשריבן: פרייטאג דעצמבער 21, 2012 1:03 pm
דורך פאטאקי08
איך זוך א גוטע דאמעין פאר די לוח
וואס קען זיין גוט?

געשריבן: דאנארשטאג פאברואר 21, 2013 8:57 am
דורך פאטאקי08
אפדעיטעד:

1) ציגעלייגט מען זאל קענען טוישן פון יודישע לוח צי ענגליש
דריקט די דעיט באטטאן העכער די לוח

2) ציגעלייגט טולטיפס tooltips (באלונס) אויף יעדע טאג

http://luach.ontimedatasolutions.com/

הערות און קאמענטארן זענען וועלקאמן



נ. ב. די זמנים ווערן אויסגערעכנט ווי פאלגענד
איך רעכן אויס די פלאץ:
קרית יואל איז latitude = 41.3409, longitude = -74.1684
וויליאמסבורג איז latitude = 40.7054, longitude = -73.9561

דערנאך ניץ איך די פאלגענדע קאוד וואס רעכענט אויס די זייגער לויט ווי די זון איז אויף די פלאץ לויט די טאג פון יאר לויט די UTC OFFSET אלץ -5
6 אזייגער צופרי פאר די sunrise
6 אזייגער נאכמיטאג פאר די sunset

קאוד: וועל אויס אלע

        private int Calculate(Direction direction)
        {
            /* doy (N) */
            int N = date.DayOfYear;

            /* appr. time (t) */
            double lngHour = longitude / 15.0;

            double t;

            if (direction == Direction.Sunrise)
                t = N + ((6.0 - lngHour) / 24.0);
            else
                t = N + ((18.0 - lngHour) / 24.0);

            /* mean anomaly (M) */
            double M = (0.9856 * t) - 3.289;

            /* true longitude (L) */
            double L = M + (1.916 * Math.Sin(Deg2Rad(M))) + (0.020 * Math.Sin(Deg2Rad(2 * M))) + 282.634;
            L = FixValue(L, 0, 360);

            /* right asc (RA) */
            double RA = Rad2Deg(Math.Atan(0.91764 * Math.Tan(Deg2Rad(L))));
            RA = FixValue(RA, 0, 360);

            /* adjust quadrant of RA */
            double Lquadrant = (Math.Floor(L / 90.0)) * 90.0;
            double RAquadrant = (Math.Floor(RA / 90.0)) * 90.0;
            RA = RA + (Lquadrant - RAquadrant);

            RA = RA / 15.0;

            /* sin cos DEC (sinDec / cosDec) */
            double sinDec = 0.39782 * Math.Sin(Deg2Rad(L));
            double cosDec = Math.Cos(Math.Asin(sinDec));

            /* local hour angle (cosH) */
            double cosH = (Math.Cos(Deg2Rad((double)zenith / 1000.0f)) - (sinDec * Math.Sin(Deg2Rad(latitude)))) / (cosDec * Math.Cos(Deg2Rad(latitude)));

            /* local hour (H) */
            double H;

            if (direction == Direction.Sunrise)
                H = 360.0 - Rad2Deg(Math.Acos(cosH));
            else
                H = Rad2Deg(Math.Acos(cosH));

            H = H / 15.0;

            /* time (T) */
            double T = H + RA - (0.06571 * t) - 6.622;

            /* universal time (T) */
            double UT = T - lngHour;

            UT += utcOffset;  // local UTC offset

            if (daylightChanges != null)
                if ((date > daylightChanges.Start) && (date < daylightChanges.End))
                    UT += daylightChanges.Delta.TotalHours;

            UT = FixValue(UT, 0, 24);

            return (int)Math.Round(UT * 3600);  // Convert to seconds
        }


דאס רעכענט נאר די זון און נישט די elevation אדער אויב סאיז דא בערג ארום

האב איך די נץ sunrise
מיט די שקיעה sunset

עלות = 72 מינוט פארן נץ
הנחת טלית 22 מינוט נאכן עלות
זריחה = נץ
סוף זמן ק"ש
עלות + אמאונט אוו סעקונדעס צווישן עלות און צאת דעויידעט ביי 4
חצות היום
נץ + אמאונט אוו סעקונדעס צווישן נץ און שקיעה דעויידעט ביי 2
שקיעה = sunset
צאת הכוכבים = 72 מינוט נאכן שקיעה

געשריבן: מאנטאג מארטש 04, 2013 10:51 pm
דורך פאטאקי08
ציגעלייגט אז מען קען זען די זמנים פון וועלכע פלאץ מען וויל
http://www.jewishluach.com/default.aspx

געשריבן: מאנטאג מארטש 04, 2013 11:03 pm
דורך פאטאקי08
ווער עס קען זאל ביטע אריין גיין אין די לינק
http://en.wikipedia.org/wiki/Hebrew_cal ... converters
און דריקט אויף די לעצטע לינק דארט:
Hebrew/Gregorian Calendar converter, including a full Jewish Calendar.
דערנאך נעוויגעיט ארום די לוח א שיינע פאר מאל

איך פרוביר עפעס אויס
דאנקע

געשריבן: דאנארשטאג מאי 02, 2013 7:03 pm
דורך אלס פריש
ריק פערי האט געשריבן:א גרויסן שכ'ח פאר אלע ב"ה ס'ארבייט שוין אין מיין דיפאולד קאלענדער.

ווי אזוי האסטו דאס געמאכט?
צו די רעגולער ענדרויד קעלענדער?

געשריבן: דאנארשטאג מאי 02, 2013 8:05 pm
דורך פאטאקי08

געשריבן: פרייטאג מאי 03, 2013 5:33 am
דורך אלס פריש
!יישר כח, פאטאקי

געשריבן: מיטוואך מאי 22, 2013 8:52 pm
דורך פאטאקי08
פאטאקי08 האט געשריבן:אפדעיטעד:


נ. ב. די זמנים ווערן אויסגערעכנט ווי פאלגענד
איך רעכן אויס די פלאץ:
קרית יואל איז latitude = 41.3409, longitude = -74.1684
וויליאמסבורג איז latitude = 40.7054, longitude = -73.9561

דערנאך ניץ איך די פאלגענדע קאוד וואס רעכענט אויס די זייגער לויט ווי די זון איז אויף די פלאץ לויט די טאג פון יאר


איך האב געטוישט די זמנים צו די פאלגענדע קאוד

נ.ב. דערווייל ווייזט עס נישט קיין סעקונדעס
ועוד חזון..

קאוד: וועל אויס אלע

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;

//////////////////////////////////////////////////////////////////////////////////////////////////////
// 
//  C# Singleton class and thread-safe class for calculating Sunrise and Sunset times.
//
// The algorithm was adapted from the JavaScript sample provided here:
//      http://home.att.net/~srschmitt/script_sun_rise_set.html
//
//  NOTICE: this code is provided "as-is", without any warrenty, obligations or liability for it.
//          You may use this code freely for any use.
//
//  Zacky Pickholz (zacky.pickholz@gmail.com)
//
/////////////////////////////////////////////////////////////////////////////////////////////////////
namespace SunNET
{
    public sealed class SunTimes
    {
        #region Private Data Members

        private object mLock = new object();

        private const double mDR = Math.PI / 180;
        private const double mK1 = 15 * mDR * 1.0027379;

        private int[] mRiseTimeArr = new int[2] { 0, 0 };
        private int[] mSetTimeArr = new int[2] { 0, 0 };
        private double mRizeAzimuth = 0.0;
        private double mSetAzimuth = 0.0;

        private double[] mSunPositionInSkyArr = new double[2] { 0.0, 0.0 };
        private double[] mRightAscentionArr = new double[3] { 0.0, 0.0, 0.0 };
        private double[] mDecensionArr = new double[3] { 0.0, 0.0, 0.0 };
        private double[] mVHzArr = new double[3] { 0.0, 0.0, 0.0 };

        private bool mIsSunrise = false;
        private bool mIsSunset = false;

        #endregion

        #region Singleton

        private static readonly SunTimes mInstance = new SunTimes();    // The singleton instance

        private SunTimes() { }

        public static SunTimes Instance
        {
            get { return mInstance; }
        }

        #endregion

        public abstract class Coords
        {
            internal protected int mDegrees = 0;
            internal protected int mMinutes = 0;
            internal protected int mSeconds = 0;

            public double ToDouble()
            {
                return Sign() * (mDegrees + ((double)mMinutes / 60) + ((double)mSeconds / 3600));
            }

            internal protected abstract int Sign();
        }

        public class LatitudeCoords : Coords
        {
            public enum Direction
            {
                North,
                South
            }
            internal protected Direction mDirection = Direction.North;

            public LatitudeCoords(int degrees, int minutes, int seconds, Direction direction)
            {
                mDegrees = degrees;
                mMinutes = minutes;
                mSeconds = seconds;
                mDirection = direction;
            }

            protected internal override int Sign()
            {
                return (mDirection == Direction.North ? 1 : -1);
            }
        }

        public class LongitudeCoords : Coords
        {
            public enum Direction
            {
                East,
                West
            }

            internal protected Direction mDirection = Direction.East;

            public LongitudeCoords(int degrees, int minutes, int seconds, Direction direction)
            {
                mDegrees = degrees;
                mMinutes = minutes;
                mSeconds = seconds;
                mDirection = direction;
            }

            protected internal override int Sign()
            {
                return (mDirection == Direction.East ? 1 : -1);
            }
        }

        /// <summary>
        /// Calculate sunrise and sunset times. Returns false if time zone and longitude are incompatible.
        /// </summary>
        /// <param name="lat">Latitude coordinates.</param>
        /// <param name="lon">Longitude coordinates.</param>
        /// <param name="date">Date for which to calculate.</param>
        /// <param name="riseTime">Sunrise time (output)</param>
        /// <param name="setTime">Sunset time (output)</param>
        /// <param name="isSunrise">Whether or not the sun rises at that day</param>
        /// <param name="isSunset">Whether or not the sun sets at that day</param>
        public bool CalculateSunRiseSetTimes(LatitudeCoords lat, LongitudeCoords lon, DateTime date,
                                                ref DateTime riseTime, ref DateTime setTime,
                                                ref bool isSunrise, ref bool isSunset)
        {
            return CalculateSunRiseSetTimes(lat.ToDouble(), lon.ToDouble(), date, ref riseTime, ref setTime, ref isSunrise, ref isSunset);
        }

        /// <summary>
        /// Calculate sunrise and sunset times. Returns false if time zone and longitude are incompatible.
        /// </summary>
        /// <param name="lat">Latitude in decimal notation.</param>
        /// <param name="lon">Longitude in decimal notation.</param>
        /// <param name="date">Date for which to calculate.</param>
        /// <param name="riseTime">Sunrise time (output)</param>
        /// <param name="setTime">Sunset time (output)</param>
        /// <param name="isSunrise">Whether or not the sun rises at that day</param>
        /// <param name="isSunset">Whether or not the sun sets at that day</param>
        public bool CalculateSunRiseSetTimes(double lat, double lon, DateTime date,
                                                ref DateTime riseTime, ref DateTime setTime,
                                                ref bool isSunrise, ref bool isSunset)
        {
            lock (mLock)    // lock for thread safety
            {
                double zone = -(int)Math.Round(TimeZone.CurrentTimeZone.GetUtcOffset(date).TotalSeconds / 3600);
                double jd = GetJulianDay(date) - 2451545;  // Julian day relative to Jan 1.5, 2000

                if ((Sign(zone) == Sign(lon)) && (zone != 0))
                {
                    Debug.Print("WARNING: time zone and longitude are incompatible!");
                    return false;
                }

                lon = lon / 360;
                double tz = zone / 24;
                double ct = jd / 36525 + 1;                                 // centuries since 1900.0
                double t0 = LocalSiderealTimeForTimeZone(lon, jd, tz);      // local sidereal time

                // get sun position at start of day
                jd += tz;
                CalculateSunPosition(jd, ct);
                double ra0 = mSunPositionInSkyArr[0];
                double dec0 = mSunPositionInSkyArr[1];

                // get sun position at end of day
                jd += 1;
                CalculateSunPosition(jd, ct);
                double ra1 = mSunPositionInSkyArr[0];
                double dec1 = mSunPositionInSkyArr[1];

                // make continuous
                if (ra1 < ra0)
                    ra1 += 2 * Math.PI;

                // initialize
                mIsSunrise = false;
                mIsSunset = false;

                mRightAscentionArr[0] = ra0;
                mDecensionArr[0] = dec0;

                // check each hour of this day
                for (int k = 0; k < 24; k++)
                {
                    mRightAscentionArr[2] = ra0 + (k + 1) * (ra1 - ra0) / 24;
                    mDecensionArr[2] = dec0 + (k + 1) * (dec1 - dec0) / 24;
                    mVHzArr[2] = TestHour(k, zone, t0, lat);

                    // advance to next hour
                    mRightAscentionArr[0] = mRightAscentionArr[2];
                    mDecensionArr[0] = mDecensionArr[2];
                    mVHzArr[0] = mVHzArr[2];
                }

                riseTime = new DateTime(date.Year, date.Month, date.Day, mRiseTimeArr[0], mRiseTimeArr[1], 0);
                setTime = new DateTime(date.Year, date.Month, date.Day, mSetTimeArr[0], mSetTimeArr[1], 0);

                isSunset = true;
                isSunrise = true;

                // neither sunrise nor sunset
                if ((!mIsSunrise) && (!mIsSunset))
                {
                    if (mVHzArr[2] < 0)
                        isSunrise = false; // Sun down all day
                    else
                        isSunset = false; // Sun up all day
                }
                // sunrise or sunset
                else
                {
                    if (!mIsSunrise)
                        // No sunrise this date
                        isSunrise = false;
                    else if (!mIsSunset)
                        // No sunset this date
                        isSunset = false;
                }

                return true;
            }
        }

        #region Private Methods

        private int Sign(double value)
        {
            int rv = 0;

            if (value > 0.0) rv = 1;
            else if (value < 0.0) rv = -1;
            else rv = 0;

            return rv;
        }

        // Local Sidereal Time for zone
        private double LocalSiderealTimeForTimeZone(double lon, double jd, double z)
        {
            double s = 24110.5 + 8640184.812999999 * jd / 36525 + 86636.6 * z + 86400 * lon;
            s = s / 86400;
            s = s - Math.Floor(s);
            return s * 360 * mDR;
        }

        // determine Julian day from calendar date
        // (Jean Meeus, "Astronomical Algorithms", Willmann-Bell, 1991)
        private double GetJulianDay(DateTime date)
        {
            int month = date.Month;
            int day = date.Day;
            int year = date.Year;

            bool gregorian = (year < 1583) ? false : true;

            if ((month == 1) || (month == 2))
            {
                year = year - 1;
                month = month + 12;
            }

            double a = Math.Floor((double)year / 100);
            double b = 0;

            if (gregorian)
                b = 2 - a + Math.Floor(a / 4);
            else
                b = 0.0;

            double jd = Math.Floor(365.25 * (year + 4716))
                       + Math.Floor(30.6001 * (month + 1))
                       + day + b - 1524.5;

            return jd;
        }

        // sun's position using fundamental arguments
        // (Van Flandern & Pulkkinen, 1979)
        private void CalculateSunPosition(double jd, double ct)
        {
            double g, lo, s, u, v, w;

            lo = 0.779072 + 0.00273790931 * jd;
            lo = lo - Math.Floor(lo);
            lo = lo * 2 * Math.PI;

            g = 0.993126 + 0.0027377785 * jd;
            g = g - Math.Floor(g);
            g = g * 2 * Math.PI;

            v = 0.39785 * Math.Sin(lo);
            v = v - 0.01 * Math.Sin(lo - g);
            v = v + 0.00333 * Math.Sin(lo + g);
            v = v - 0.00021 * ct * Math.Sin(lo);

            u = 1 - 0.03349 * Math.Cos(g);
            u = u - 0.00014 * Math.Cos(2 * lo);
            u = u + 0.00008 * Math.Cos(lo);

            w = -0.0001 - 0.04129 * Math.Sin(2 * lo);
            w = w + 0.03211 * Math.Sin(g);
            w = w + 0.00104 * Math.Sin(2 * lo - g);
            w = w - 0.00035 * Math.Sin(2 * lo + g);
            w = w - 0.00008 * ct * Math.Sin(g);

            // compute sun's right ascension
            s = w / Math.Sqrt(u - v * v);
            mSunPositionInSkyArr[0] = lo + Math.Atan(s / Math.Sqrt(1 - s * s));

            // ...and declination
            s = v / Math.Sqrt(u);
            mSunPositionInSkyArr[1] = Math.Atan(s / Math.Sqrt(1 - s * s));
        }

        // test an hour for an event
        private double TestHour(int k, double zone, double t0, double lat)
        {
            double[] ha = new double[3];
            double a, b, c, d, e, s, z;
            double time;
            int hr, min;
            double az, dz, hz, nz;

            ha[0] = t0 - mRightAscentionArr[0] + k * mK1;
            ha[2] = t0 - mRightAscentionArr[2] + k * mK1 + mK1;

            ha[1] = (ha[2] + ha[0]) / 2;    // hour angle at half hour
            mDecensionArr[1] = (mDecensionArr[2] + mDecensionArr[0]) / 2;  // declination at half hour

            s = Math.Sin(lat * mDR);
            c = Math.Cos(lat * mDR);
            z = Math.Cos(90.833 * mDR);    // refraction + sun semidiameter at horizon

            if (k <= 0)
                mVHzArr[0] = s * Math.Sin(mDecensionArr[0]) + c * Math.Cos(mDecensionArr[0]) * Math.Cos(ha[0]) - z;

            mVHzArr[2] = s * Math.Sin(mDecensionArr[2]) + c * Math.Cos(mDecensionArr[2]) * Math.Cos(ha[2]) - z;

            if (Sign(mVHzArr[0]) == Sign(mVHzArr[2]))
                return mVHzArr[2];  // no event this hour

            mVHzArr[1] = s * Math.Sin(mDecensionArr[1]) + c * Math.Cos(mDecensionArr[1]) * Math.Cos(ha[1]) - z;

            a = 2 * mVHzArr[0] - 4 * mVHzArr[1] + 2 * mVHzArr[2];
            b = -3 * mVHzArr[0] + 4 * mVHzArr[1] - mVHzArr[2];
            d = b * b - 4 * a * mVHzArr[0];

            if (d < 0)
                return mVHzArr[2];  // no event this hour

            d = Math.Sqrt(d);
            e = (-b + d) / (2 * a);

            if ((e > 1) || (e < 0))
                e = (-b - d) / (2 * a);

            time = (double)k + e + (double)1 / (double)120; // time of an event

            hr = (int)Math.Floor(time);
            min = (int)Math.Floor((time - hr) * 60);

            hz = ha[0] + e * (ha[2] - ha[0]);                 // azimuth of the sun at the event
            nz = -Math.Cos(mDecensionArr[1]) * Math.Sin(hz);
            dz = c * Math.Sin(mDecensionArr[1]) - s * Math.Cos(mDecensionArr[1]) * Math.Cos(hz);
            az = Math.Atan2(nz, dz) / mDR;
            if (az < 0) az = az + 360;

            if ((mVHzArr[0] < 0) && (mVHzArr[2] > 0))
            {
                mRiseTimeArr[0] = hr;
                mRiseTimeArr[1] = min;
                mRizeAzimuth = az;
                mIsSunrise = true;
            }

            if ((mVHzArr[0] > 0) && (mVHzArr[2] < 0))
            {
                mSetTimeArr[0] = hr;
                mSetTimeArr[1] = min;
                mSetAzimuth = az;
                mIsSunset = true;
            }

            return mVHzArr[2];
        }

        #endregion  // Private Methods
    }
}

געשריבן: מיטוואך מאי 22, 2013 9:16 pm
דורך בחורהזעצער
אה פאטאקית דו האסט אויך געמאכט די סמארט ליסט? #הישגעוויסט, עס איז באמת א מעסיוו איידיע און מעסיוו אפליקעישאנס (לשון רבים, אלע פלאטפארמעס).

געשריבן: מיטוואך מאי 22, 2013 9:39 pm
דורך פאטאקי08
איך האב געטוישט אביסל פון דעם פיקעלס קאוד און איך האב צוגעלייגט די פאלגענדע קאוד די לעצטע שורה:

קאוד: וועל אויס אלע

hr = (int)Math.Floor(time);
min = (int)Math.Floor((time - hr) * 60);
sec = (int)Math.Floor((((time - hr) * 60) - min) * 60);


וואס זאגט איר צו דעם?
וועט ער מיר געבן די ריכטיגע סעקונדען?


---
בחור האקט
איך כאפ נישט פון וואס דו רעדסט

געשריבן: מיטוואך מאי 22, 2013 9:41 pm
דורך בחורהזעצער
פון דיין ענדרויד עפפ, וואס דער זעלבער דעוואלאפער האט געמאכט די סמארט ליסט.

געשריבן: מיטוואך מאי 22, 2013 9:54 pm
דורך פאטאקי08
די עפפ האט גארנישט מיט מיר