Я так скажу,што я сначала сверху осмотрел илюстрация к кинь и решил што это муравьи маленькие и обрадовался , потомушто интересно как живут муравьи и как они кушают и трудятся ,и я вспомнил,про как в лес ходил то погрибки то какие ягоды и сел отдыхать на дерево короткое,достал кушанье—хлеб колбасу и чай в термосе и сахар в термос размешал сижу кушаю , смеюсь , потом глаза так прекрыл и слегка ушёл в сон,открываю глаза а у меня рука с термосом вся чёрная,я закричал ааааа, потом ещё раз ааааа, думаю ну цероз руки произошёл , а потом пригляделся и што вижу батюшки мои это муравье а сел я на их жильё и там ещё и уснуть умудрился хорошо был балкон с газом я брызнул и все они рашолись домой к себе а я пошёл к себе весь красный и без грибов и ягод , потому што ничего не набрал ,но перекусил . Кинь про бытовые дела,как все крутятся штобы жить и если ещё и семья большая сложности в ее прикормлении . Надо радоваться хоть тому што у тебя есть—тепло,кушанье, если близкие есть —это счастье вышее. Кинь рекомендовать если кто шибает што житие у него плохое совсем.

Помню как послали в колхоз работать на свекле ,заплатили очень мало,но кушанье было бесплатное. Ну и я до этого копил и на все складчину купил видео аппарат,он подключался к телевизору и проигрывал касеты. И первая касета была с этим актером што имя длинное. Он там показывал как он исскуство мастерство драки ,я потом выходил и так у нас яблоня была и я представлял што это мой противник и отходил яблоню,потой мере што она сдачи дать не могла , тк стояло прочно , а так если такие дела крутить с реальным человеком,то это надо быть хорошим специалистом и тренироваться много дней ,хотя бы неделю. И вот осмотрел этот кинь,и. Так защемилось в душе,што как годы взяли своё с этих актеров и их мастерства,но кинь слабый и все это не их уровень, жалко што такие актёр с хорошимнавыками,так упустили штоки свою удачу или просто востребованность прошла.оба героя видно жизнь их потрепала ,вид ослабленный может конешно болезнь какая напала,сейчас руки не помыл уже бактерии схватил, што и говорить там может хлебнули чего не свежего. Надо было их взбодрить, лицо хотя бы посвежить косметикой. И видно што они стараются но силы их покинули,шитай кинь не достоин таких актёров,да и им надо уже не ногами мазать,а более посерьёзнее врачей играть или там работников банка,более солидно. Кинь не рекомендовать, он только расстроит и даст понять што время идёт и мы тоже вместе с ним идём в сторону того о чем и думать не хочется .

Вспомнилось как я был свидетелем, как когда-то в прошлом тысячелетии упоротые программисты в павильоне "Вычислительная Техника" на ВДНХ измывались над прототипом голосового синтезатора, и когда на словосочетании "Фрунзик Мкртчян" железка отчаянно захрипела, у всех присутствующих на лицах мелькнула довольная улыбка, прямо как у тех сибирских лесорубов победивших японскую пилу.

// Note: The following is all standard-conforming C++, this is not a hypothetical language extension.

#include "analogliterals.hpp"
#include 

int main ()
{
  using namespace analog_literals::symbols;

// Consider:

  unsigned int a = 4;

// Have you ever felt that integer literals like "4" don't convey the true size of the value they denote? If so, use an analog integer literal instead:

  unsigned int b = I---------I;

  assert( a == b );

// Due to the way C++ operators work, we must use N*2+1 dashes between the I's to get a value of N:

  assert( I-I == 0 );
  assert( I---I == 1 );
  assert( I-----I == 2 );
  assert( I-------I == 3 );

// These one-dimensional analog literals are of type analog_literals::line, which is convertible to unsigned int.

// In some cases, two-dimensional analog literals are appropriate:

  unsigned int c = ( o-----o
                     |     !
                     !     !
                     !     !
                     o-----o ).area;

  assert( c == (I-----I) * (I-------I) );

  assert( ( o-----o
            |     !
            !     !
            !     !
            !     !
            o-----o ).area == ( o---------o
                                |         !
                                !         !
                                o---------o ).area );

// Two-dimensional analog literals are of type analog_literals::rectangle which exposes static member constants width, height, and area.

/* As an example use-case, imagine specifying window dimensions in a GUI toolkit API using:

   window.dimensions = o-----------o
                       |           !
                       !           !
                       !           !
                       !           !
                       o-----------o ;

Who said C++ was unintuitive!? */

// But wait, there's more. We can use three-dimensional analog literals, too:

  assert( ( o-------------o
            |L             \
            | L             \
            |  L             \
            |   o-------------o
            |   !             !
            !   !             !
            o   |             !
             L  |             !
              L |             !
               L|             !
                o-------------o ).volume == ( o-------------o
                                              |             !
                                              !             !
                                              !             !
                                              o-------------o ).area * int(I-------------I) );

// Three-dimensional analog literals are of type analog_literals::cuboid which exposes static member constants width, height, depth, and volume. In addition, three free-standing functions top, side, and front are provided which yield rectangles:

  assert( top( o-------o
               |L       \
               | L       \
               |  o-------o
               |  !       !
               !  !       !
               o  |       !
                L |       !
                 L|       !
                  o-------o ) == ( o-------o
                                   |       !
                                   !       !
                                   o-------o ) );

// The current implementation has one restriction on cuboid dimensions: the height of a cuboid literal must be at least its depth + 2.

// Note that storing these literals directly in a variable requires you to specify the dimension sizes:

  analog_literals::rectangle<4, 2> r = o---------o
                                       |         !
                                       !         !
                                       o---------o;

// This of course defeats the purpose of using the analog literal. C++0x's proposed `auto' feature would come in quite handy here. We can actually fix this problem partially (using the stack-ref-to-temporary's-base trick used by Alexandrescu's ScopeGuard), but we would no longer be able to use the values in ICE's, and frankly I think this madness has gone far enough already.

}

#ifndef ANALOGLITERALS_HPP
#define ANALOGLITERALS_HPP

namespace analog_literals {

typedef unsigned int uint;

// Symbols

  enum line_end { o, I };
  enum Lsymbol { L };

// Intermediary types used during construction

  struct eLsymbol {};
  eLsymbol operator! (Lsymbol) { return eLsymbol(); }

  struct gen { template <typename T> operator T () const { return T(); } };

  template <typename T, uint n> struct excls { excls operator! () const { return gen(); } };

  template <typename T, uint n> struct dashes: excls, 0>
  { dashes operator-- (int) const { return gen(); } };

  template <typename, uint> struct L_symbols {}; // represents a L|L|L|.. series
  template <typename T, uint n> L_symbols operator| (L_symbols, Lsymbol) { return gen(); }

  template <typename, uint> struct eL_symbols {}; // represents a !L|!L|!L|.. series
  template <typename T, uint n> eL_symbols operator| (eL_symbols, eLsymbol) { return gen(); }

  dashes operator-- (line_end, int) { return gen(); }
  excls operator! (line_end) { return gen(); }

// Result types

  template  struct line: L_symbols, 0>
  { static uint const length; operator uint () const { return len; } };
  template  struct rectangle { static uint const width, height, area; };
  template  struct cuboid { static uint const width, height, depth, volume; };

// Static members

  template  uint const line::length = len;

  template  uint const rectangle::width = x;
  template  uint const rectangle::height = y;
  template  uint const rectangle::area = x * y;

  template  uint const cuboid::width = x;
  template  uint const cuboid::height = y;
  template  uint const cuboid::depth = z;
  template  uint const cuboid::volume = x * y * z;

  template  rectangle front (cuboid) { return gen(); }
  template  rectangle side (cuboid) { return gen(); }
  template  rectangle top (cuboid) { return gen(); }

// Equality

  template  bool operator== (line, line) { return ax == bx; }

  template  bool operator== (rectangle, rectangle)
  { return ax == bx && ay == by; }

  template 
  bool operator== (cuboid, cuboid) { return ax == bx && ay == by && az == bz; }

// Construction

  // line

  line<0> operator- (line_end, line_end) { return gen(); }
  template  line operator- (dashes, line_end) { return gen(); }

  // rectangle

  template  struct lower_rectangle {}; // with lower right corner

  template 
  lower_rectangle 2> operator- (excls, excl_marks>, line_end)
  { return gen(); }

  template  rectangle operator| (line, lower_rectangle) { return gen(); }

  // cuboid

  template  struct cuboid_top {};
  template  struct half_cuboid {};
    // dimensions of complete cuboid known, rest is for show

  template 
  cuboid_top operator| (L_symbols, n>, line) { return gen(); }

  template 
  eL_symbols 3, z>, 0> // todo: assert: n%3=2
    operator| (cuboid_top, excls) { return gen(); }

  template 
  cuboid operator| (eL_symbols, z>, lower_rectangle) { return gen(); }

// Convenience namespaces that can be "using namespace"'d:

  namespace symbols
  {
    using analog_literals::o;
    using analog_literals::I;
    using analog_literals::L;
  }

  namespace shapes
  {
    using analog_literals::line;
    using analog_literals::rectangle;
    using analog_literals::cuboid;
  }

} // analog_literals

#endif // header guard

#ifdef ANALOGLITERALS_TEST

int main ()
{
  using namespace analog_literals::symbols;
  using namespace analog_literals::shapes;

  line<3>(I-------I);

  rectangle<2, 3>(o-----o
                  |     !
                  !     !
                  !     !
                  o-----o);

  cuboid<6, 6, 3>(o-------------o
                  |L             \
                  | L             \
                  |  L             \
                  |   o-------------o
                  |   !             !
                  !   !             !
                  o   |             !
                   L  |             !
                    L |             !
                     L|             !
                      o-------------o );

  cuboid<3, 4, 2>(o-------o
                  |L       \
                  | L       \
                  |  o-------o
                  |  !       !
                  o  |       !
                   L |       !
                    L|       !
                     o-------o);
}

#endif // testing

Сотрудники патрульной службы государственной инспекции по маломерным судам задержали жителя Сахалина, который пытался уплыть на самодельной лодке в Японию. Как сообщило издание Sakhalin.Info, случай произошёл в районе села Правда.

Во время задержания мужчина пытался оказывать сопротивление и не хотел покидать своё судно. Мужчину также не пугали прогнозы надвигающегося шторма и долгая дорога. В его лодке нашёлся запас необходимых в путешествии вещей, в том числе еда, вода, сменная одежда и палатка.

Какой-то африканский охотник снял с добытого аиста GPS-трекер, вытащил симку, вставил себе в телефон и наговорил на $2700.
Счет пришел орнитологам, исследовавшим миграции аистов.