How Long Does Caffeine Stay In Your System? It Depends.
Up to 99% of natural caffeine is absorbed within 45 minutes.
It passes through the blood brain barrier, placenta, and into breast milk, as well as all body tissues.
Then about 97% of it is metabolized by the liver into more than 25 different chemicals.
Both tea caffeine and coffee are metabolized into theophylline but through different pathways.
Approximately 90% of North American and European adults report daily consumption of caffeinated products, with approximately 54% of Americans averaging 3 cups of coffee daily.
Other countries (approximately 5 billion people) use daily green or black tea, which is much lower in caffeine than coffee.
Ashihara H et al: Caffeine and related purine alkaloids: biosynthesis, catabolism, function and genetic engineering. Phytochemistry 69, 2008, 841–856.
Atkinson HC et al: Drugs in human milk. Clinical pharmacokinetic considerations. Clin Pharmacokinet, April 1988, 217-40.
Bechtel YC et al: Caffeine metabolism differences in acute hepatitis of viral and drug origin. Therapie, Sept0Oct 2000, 619-27.
Bergey MR et al: Behavioral and perceived stressor effects on urinary catecholamine excretion in adult Samoans. Am J Hum Biol, Sept-Oct 2011, 693-702.
Carrillo JA andBenitez J: Clinically significant pharmacokinetic interactions between dietary caffeine and medications. Clin Pharmacokinet, August 2000, 127-53.
Chen Y and Parrish D: Caffeine's effects on cerebrovascular reactivity and coupling between cerebral blood flow and oxygen metabolism. Neuroimage 44, 2008, 647–652.
Chou T. (1992). Wake up and smell the coffee. Caffeine, coffee and the medical consequences. West. J. Med. 157, 544–553.
Croft M et al: Predicting Drug Candidate Victims of Drug-Drug Interactions, using Microdosing. Clin Pharmacokinet. February 2012.
Del Coso J et al: Caffeine during exercise in the heat: thermoregulation and fluid-electrolyte balance. Med Sci Sports Exerc, January 2009, 164-73.
Ginsberg G et al: Incorporating pharmacokinetic differences between children and adults in assessing children's risks to environmental toxicants. Toxicol Appl Pharmacol, July 2004, 164-83.
Grosso L. M., Bracken M. B. (2005). Caffeine metabolism, genetics and perinatal outcomes: a review of exposure assessment considerations during pregnancy. Ann. Epidemiol. 15, 460–466.
Ito E et al: Theophylline metabolism in higher plants. Biochim Biophys Acta, August 1997, 323-30.
James J: Can Consuming Caffeine While Breastfeeding Harm Your Baby? An Interview with Ruth Lawrence, PhD. Journal of Caffeine Research, December 2011.
Magkos F and Kavouras SA: Caffeine use in sports, pharmacokinetics in man, and cellular mechanisms of action. Crit Rev Food Sci Nutr, 2005;45(7-8), p535-62.
Murray S et al: Effect of cruciferous vegetable consumption on heterocyclic aromatic amine metabolism in man. Carcinogenesis, September 2001, 1413-20.
Nehlig A. (1998). Are we dependent upon coffee and caffeine? A review on human and animal data. Neurosci. Biobehav. Rev. 23, 563–576.
Reissig C. J., Strain E. C., Griffiths R. R. (2009). Caffeinated energy drinks – a growing problem. Drug Alcohol Depend. 99, 1–10.
Sinués B et al: Influence of the urine flow rate on some caffeine metabolite ratios used to assess CYP1A2 activity. Ther Drug Monit, December 2002, 715-21.
Temple J. L. (2009). Caffeine use in children: what we know, what we have to learn and why we should worry. Neurosci. Biobehav. Rev. 33, 793–806.
Vrtic F et al: Interaction of ibuprofen and probenecid with drug metabolizing enzyme phenotyping procedures using caffeine as the probe drug. British Journal Clin Pharmacol, February 2003, 191-8.


The other night I saw a portion of NOW with Bill Moyers on PBS. He was interviewing Will Hutton (author of the book A DECLARATION OF INTERDEPENDENCE: WHY AMERICA SHOULD JOIN THE WORLD, an old friend of America's, but a friendly critic as well. Hutton was for years Editor-in-Chief of one of Britain's most influential newspapers, THE OBSERVER, for which he still writes a column).
What I wanted to talk about is this. Two of the things that Hutton says worry him about American politics are the increasing role of money in the drawing of political boundaries, positions, etc., and the absolute inability of the Left to put together a cohesive platform to debate the Right, thereby causing the Big Eagle to flop around in circles because frankly, it's really only got one viable wing. There is as a result no real debate, nor ideological banter. There is only a murky middle ground and the Extreme Right.
So, when you look at it, in a society where true education is not prized, the religious temperament is inclined to blindly follow leaders without personal revelation, and where personal gain is placed higher in the social contract that universal growth, it is no wonder that the promulgators of the Right have so many more followers than the left. Further, in the absence of any true Radical Left, it is unlikely that the anykind Left (which of course includes the milksop, pantywaist Democratic party of which I am a member) will be capable of producing any candidates that are truly worth a damn and that possess any kind of backbone or recognizable agenda – particularly when they, like the Social Democrats and Catholic Center parties in 1930's Germany are not able to put into plain, everyday language exactly what it is they stand for, and why anyone should stand with them.


Nokia 1 smartphone was launched in February 2018. It Features a 4.50-inch touchscreen display with a resolution of 480 pixels by 854 pixels.
The Smartphone is powered by 1.1GHz quad-core MediaTek MT6737M processor and it comes with 1GB of RAM in built speed. The phone packs 8GB of internal storage which is expandable up to 128GB using an external microSD card. As far as the cameras are concerned, the Nokia 1 packs a 5-megapixel primary camera on the rear and a 2-megapixel front shooter for selfies.
← How To Sell And Make Profit On Coins Exchange.


text:
Exhibits & Programs
The Gulf War started on August 2, 1990, when the forces of Iraqi dictator Saddam Hussein invaded oil-rich Kuwait. U.S. officials worried that the invasion might be Iraq's first step in a larger effort to consolidate its power over other nations in the Middle East, such as Saudi Arabia. Hussein defied United Nations Security Council demands to withdraw from Kuwait by mid-January 1991, and the Persian Gulf War began with a massive U.S.-led air offensive known as Operation Desert Storm. After 42 days of relentless attacks by the allied coalition in the air and on the ground, U.S. President George H. W. Bush declared a cease-fire on February 28, 1991.
Below is a timeline of the Gulf War that demonstrates how two High Pointers participated in Operation Desert Storm along with photographs and information from trusted historical sources.
High Point Museum
1859 East Lexington Ave.
What is the admission fee to the Museum?
When is the Museum open?
What exhibits are currently on display at the Museum?

redpajama_set_name: RedPajamaCommonCrawl


text:
package com.intellij.openapi.editor.impl.view;

import com.intellij.openapi.editor.*;
import com.intellij.openapi.editor.colors.EditorColors;
import com.intellij.openapi.editor.colors.EditorFontType;
import com.intellij.openapi.editor.ex.MarkupModelEx;
import com.intellij.openapi.editor.ex.RangeHighlighterEx;
import com.intellij.openapi.editor.highlighter.EditorHighlighter;
import com.intellij.openapi.editor.highlighter.HighlighterIterator;
import com.intellij.openapi.editor.impl.*;
import com.intellij.openapi.editor.impl.softwrap.SoftWrapDrawingType;
import com.intellij.openapi.editor.markup.*;
import com.intellij.openapi.util.Couple;
import com.intellij.openapi.util.Ref;
import com.intellij.openapi.util.TextRange;
import com.intellij.openapi.util.registry.Registry;
import com.intellij.openapi.wm.impl.IdeBackgroundUtil;
import com.intellij.ui.ColorUtil;
import com.intellij.ui.Gray;
import com.intellij.ui.JBColor;
import com.intellij.ui.paint.EffectPainter;
import com.intellij.util.DocumentUtil;
import com.intellij.util.text.CharArrayUtil;
import com.intellij.util.ui.JBUI;
import com.intellij.util.ui.UIUtil;
import gnu.trove.TFloatArrayList;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

import javax.swing.*;
import java.awt.*;
import java.awt.geom.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Renders editor contents.
 */
class EditorPainter implements TextDrawingCallback {
  private static final Color CARET_LIGHT = Gray._255;
  private static final Color CARET_DARK = Gray._0;
  private static final Stroke IME_COMPOSED_TEXT_UNDERLINE_STROKE = new BasicStroke(1, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND, 0,
                                                                                new float[]{0, 2, 0, 2}, 0);
  private static final int CARET_DIRECTION_MARK_SIZE = 5;
  private static final char IDEOGRAPHIC_SPACE = '\u3000'; // http://www.marathon-studios.com/unicode/U3000/Ideographic_Space
  private static final String WHITESPACE_CHARS = " \t" + IDEOGRAPHIC_SPACE;

  private final EditorView myView;
  private final EditorImpl myEditor;
  private final Document myDocument;

  private XCorrector myCorrector;

  EditorPainter(EditorView view) {
    myView = view;
    myEditor = view.getEditor();
    myDocument = myEditor.getDocument();
    myCorrector = XCorrector.create(myView);
  }

  void paint(Graphics2D g) {
    myCorrector = myCorrector.align(myView);
    Rectangle clip = g.getClipBounds();

    if (myEditor.getContentComponent().isOpaque()) {
      g.setColor(myEditor.getBackgroundColor());
      g.fillRect(clip.x, clip.y, clip.width, clip.height);
    }

    if (paintPlaceholderText(g)) {
      paintCaret(g, 0);
      return;
    }

    int startLine = myView.yToVisualLine(clip.y);
    int endLine = myView.yToVisualLine(clip.y + clip.height - 1);
    int startOffset = myView.visualLineToOffset(startLine);
    int endOffset = myView.visualLineToOffset(endLine + 1);
    ClipDetector clipDetector = new ClipDetector(myEditor, clip);
    IterationState.CaretData caretData = myEditor.isPaintSelection() ? IterationState.createCaretData(myEditor) : null;

    int yShift = -clip.y;
    g.translate(0, -yShift);

    float[] marginShifts = paintBackground(g, clip, yShift, startLine, endLine, caretData);
    paintRightMargin(g, clip, yShift, startLine, endLine, marginShifts);
    paintCustomRenderers(g, yShift, startOffset, endOffset);
    MarkupModelEx docMarkup = myEditor.getFilteredDocumentMarkupModel();
    paintLineMarkersSeparators(g, clip, yShift, docMarkup, startOffset, endOffset);
    paintLineMarkersSeparators(g, clip, yShift, myEditor.getMarkupModel(), startOffset, endOffset);
    paintTextWithEffects(g, clip, yShift, startLine, endLine, caretData);
    paintHighlightersAfterEndOfLine(g, yShift, docMarkup, startOffset, endOffset);
    paintHighlightersAfterEndOfLine(g, yShift, myEditor.getMarkupModel(), startOffset, endOffset);
    paintBorderEffect(g, clipDetector, yShift, myEditor.getHighlighter(), startOffset, endOffset);
    paintBorderEffect(g, clipDetector, yShift, docMarkup, startOffset, endOffset);
    paintBorderEffect(g, clipDetector, yShift, myEditor.getMarkupModel(), startOffset, endOffset);

    paintCaret(g, yShift);

    paintComposedTextDecoration(g, yShift);

    g.translate(0, yShift);
  }

  private boolean paintPlaceholderText(Graphics2D g) {
    CharSequence hintText = myEditor.getPlaceholder();
    EditorComponentImpl editorComponent = myEditor.getContentComponent();
    if (myDocument.getTextLength() > 0 || hintText == null || hintText.length() == 0 ||
        KeyboardFocusManager.getCurrentKeyboardFocusManager().getFocusOwner() == editorComponent &&
        !myEditor.getShowPlaceholderWhenFocused()) {
      return false;
    }

    hintText = SwingUtilities.layoutCompoundLabel(g.getFontMetrics(), hintText.toString(), null, 0, 0, 0, 0,
                                                  SwingUtilities.calculateInnerArea(editorComponent, null), // account for insets
                                                  new Rectangle(), new Rectangle(), 0);
    EditorFontType fontType = EditorFontType.PLAIN;
    Color color = myEditor.getFoldingModel().getPlaceholderAttributes().getForegroundColor();
    TextAttributes attributes = myEditor.getPlaceholderAttributes();
    if (attributes != null) {
      int type = attributes.getFontType();
      if (type == Font.ITALIC) fontType = EditorFontType.ITALIC;
      else if (type == Font.BOLD) fontType = EditorFontType.BOLD;
      else if (type == (Font.ITALIC | Font.BOLD)) fontType = EditorFontType.BOLD_ITALIC;

      Color attColor = attributes.getForegroundColor();
      if (attColor != null) color = attColor;
    }
    g.setColor(color);
    g.setFont(myEditor.getColorsScheme().getFont(fontType));
    Insets insets = myView.getInsets();
    g.drawString(hintText.toString(), insets.left, insets.top + myView.getAscent());
    return true;
  }

  private void paintRightMargin(Graphics g,
                                Rectangle clip,
                                int yShift,
                                int startVisualLine,
                                int endVisualLine,
                                float[] marginShifts) {
    if (!isMarginShown()) return;
    g.setColor(myEditor.getColorsScheme().getColor(EditorColors.RIGHT_MARGIN_COLOR));
    if (marginShifts == null) {
      int x = myCorrector.marginX();
      UIUtil.drawLine(g, x, 0, x, clip.height);
    }
    else {
      int y = myView.visualLineToY(startVisualLine) + yShift;
      int lineHeight = myView.getLineHeight();
      for(int i = startVisualLine; i <= endVisualLine; i++) {
        int x = myCorrector.marginX(marginShifts[i - startVisualLine]);
        int nextX = myCorrector.marginX(marginShifts[i - startVisualLine + 1]);
        g.fillRect(x, y, 1, lineHeight);
        if (nextX != x) g.fillRect(Math.min(x, nextX), y + lineHeight - 1, Math.abs(x - nextX) + 1, 1);
        y += lineHeight;
      }
    }
    Color visualGuidesColor = myEditor.getColorsScheme().getColor(EditorColors.VISUAL_INDENT_GUIDE_COLOR);
    if (visualGuidesColor != null) {
      g.setColor(visualGuidesColor);
      for (Integer marginX : myCorrector.softMarginsX()) {
        UIUtil.drawLine(g, marginX, 0, marginX, clip.height);
      }
    }
  }

  private boolean isMarginShown() {
    return isMarginShown(myEditor);
  }

  private static boolean isMarginShown(@NotNull Editor editor) {
    return editor.getSettings().isRightMarginShown() &&
           editor.getColorsScheme().getColor(EditorColors.RIGHT_MARGIN_COLOR) != null &&
           (Registry.is("editor.show.right.margin.in.read.only.files") || editor.getDocument().isWritable());
  }

  private float[] paintBackground(Graphics2D g, Rectangle clip, int yShift,
                               int startVisualLine, int endVisualLine, IterationState.CaretData caretData) {
    Ref<float[]> marginShifts = new Ref<>();
    boolean calculateMarginShift = Registry.is("editor.adjust.right.margin") && isMarginShown();
    int maxVisualLine = endVisualLine + (calculateMarginShift ? 1 : 0);
    int lineCount = myEditor.getVisibleLineCount();

    final Map<Integer, Couple<Integer>> virtualSelectionMap = createVirtualSelectionMap(startVisualLine, endVisualLine);
    final VisualPosition primarySelectionStart = myEditor.getSelectionModel().getSelectionStartPosition();
    final VisualPosition primarySelectionEnd = myEditor.getSelectionModel().getSelectionEndPosition();

    LineLayout prefixLayout = myView.getPrefixLayout();
    if (startVisualLine == 0 && prefixLayout != null) {
      final Insets insets = myView.getInsets();
      float width = prefixLayout.getWidth();
      paintBackground(g, myView.getPrefixAttributes(), myCorrector.startX(startVisualLine), insets.top + yShift, width);
    }

    VisualLinesIterator visLinesIterator = new VisualLinesIterator(myEditor, startVisualLine);
    while (!visLinesIterator.atEnd()) {
      int visualLine = visLinesIterator.getVisualLine();
      if (visualLine > maxVisualLine || visualLine >= lineCount) break;
      int y = visLinesIterator.getY() + yShift;
      boolean dryRun = visualLine > endVisualLine;
      paintLineFragments(g, clip, visLinesIterator, caretData, y, new LineFragmentPainter() {
        @Override
        public void paintBeforeLineStart(Graphics2D g, TextAttributes attributes, boolean hasSoftWrap, int columnEnd, float xEnd, int y) {
          if (dryRun) return;
          paintBackground(g, attributes, myView.getInsets().left, y, xEnd);
          if (!hasSoftWrap) return;
          paintSelectionOnSecondSoftWrapLineIfNecessary(g, visualLine, columnEnd, xEnd, y, primarySelectionStart, primarySelectionEnd);
        }

        @Override
        public void paint(Graphics2D g, VisualLineFragmentsIterator.Fragment fragment, int start, int end,
                          TextAttributes attributes, float xStart, float xEnd, int y) {
          if (dryRun) return;
          paintBackground(g, attributes, xStart, y, xEnd - xStart);
        }

        @Override
        public void paintAfterLineEnd(Graphics2D g, Rectangle clip, IterationState it, int columnStart, float x, int y) {
          if (dryRun) return;
          paintBackground(g, it.getPastLineEndBackgroundAttributes(), x, y, clip.x + clip.width - x);
          int offset = it.getEndOffset();
          SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset);
          if (softWrap == null) {
            paintVirtualSelectionIfNecessary(g, visualLine, virtualSelectionMap, columnStart, x, clip.x + clip.width, y);
          }
          else {
            paintSelectionOnFirstSoftWrapLineIfNecessary(g, visualLine, columnStart, x, clip.x + clip.width, y,
                                                         primarySelectionStart, primarySelectionEnd);
          }
        }
      }, calculateMarginShift ? shift -> {
        if (marginShifts.isNull()) marginShifts.set(new float[endVisualLine - startVisualLine + 2]);
        marginShifts.get()[visualLine - startVisualLine] += shift;
      } : null);
      visLinesIterator.advance();
    }
    return marginShifts.get();
  }

  private Map<Integer, Couple<Integer>> createVirtualSelectionMap(int startVisualLine, int endVisualLine) {
    HashMap<Integer, Couple<Integer>> map = new HashMap<>();
    for (Caret caret : myEditor.getCaretModel().getAllCarets()) {
      if (caret.hasSelection()) {
        VisualPosition selectionStart = caret.getSelectionStartPosition();
        VisualPosition selectionEnd = caret.getSelectionEndPosition();
        if (selectionStart.line == selectionEnd.line) {
          int line = selectionStart.line;
          if (line >= startVisualLine && line <= endVisualLine) {
            map.put(line, Couple.of(selectionStart.column, selectionEnd.column));
          }
        }
      }
    }
    return map;
  }

  private void paintVirtualSelectionIfNecessary(Graphics2D g,
                                                int visualLine,
                                                Map<Integer, Couple<Integer>> virtualSelectionMap,
                                                int columnStart,
                                                float xStart,
                                                float xEnd,
                                                int y) {
    Couple<Integer> selectionRange = virtualSelectionMap.get(visualLine);
    if (selectionRange == null || selectionRange.second <= columnStart) return;
    float startX = selectionRange.first <= columnStart ? xStart :
                   (float)myView.visualPositionToXY(new VisualPosition(visualLine, selectionRange.first)).getX();
    float endX = (float)Math.min(xEnd, myView.visualPositionToXY(new VisualPosition(visualLine, selectionRange.second)).getX());
    paintBackground(g, myEditor.getColorsScheme().getColor(EditorColors.SELECTION_BACKGROUND_COLOR), startX, y, endX - startX);
  }

  private void paintSelectionOnSecondSoftWrapLineIfNecessary(Graphics2D g, int visualLine, int columnEnd, float xEnd, int y,
                                                             VisualPosition selectionStartPosition, VisualPosition selectionEndPosition) {
    if (selectionStartPosition.equals(selectionEndPosition) ||
        visualLine < selectionStartPosition.line ||
        visualLine > selectionEndPosition.line ||
        visualLine == selectionStartPosition.line && selectionStartPosition.column >= columnEnd) {
      return;
    }

    float startX = (selectionStartPosition.line == visualLine && selectionStartPosition.column > 0) ?
                   (float)myView.visualPositionToXY(selectionStartPosition).getX() : myCorrector.startX(visualLine);
    float endX = (selectionEndPosition.line == visualLine && selectionEndPosition.column < columnEnd) ?
                 (float)myView.visualPositionToXY(selectionEndPosition).getX() : xEnd;

    paintBackground(g, myEditor.getColorsScheme().getColor(EditorColors.SELECTION_BACKGROUND_COLOR), startX, y, endX - startX);
  }

  private void paintSelectionOnFirstSoftWrapLineIfNecessary(Graphics2D g, int visualLine, int columnStart, float xStart, float xEnd, int y,
                                                            VisualPosition selectionStartPosition, VisualPosition selectionEndPosition) {
    if (selectionStartPosition.equals(selectionEndPosition) ||
        visualLine < selectionStartPosition.line ||
        visualLine > selectionEndPosition.line ||
        visualLine == selectionEndPosition.line && selectionEndPosition.column <= columnStart) {
      return;
    }

    float startX = selectionStartPosition.line == visualLine && selectionStartPosition.column > columnStart ?
                   (float)myView.visualPositionToXY(selectionStartPosition).getX() : xStart;
    float endX = selectionEndPosition.line == visualLine ?
                 (float)myView.visualPositionToXY(selectionEndPosition).getX() : xEnd;

    paintBackground(g, myEditor.getColorsScheme().getColor(EditorColors.SELECTION_BACKGROUND_COLOR), startX, y, endX - startX);
  }

  private void paintBackground(Graphics2D g, TextAttributes attributes, float x, int y, float width) {
    if (attributes == null) return;
    paintBackground(g, attributes.getBackgroundColor(), x, y, width);
  }

  private void paintBackground(Graphics2D g, Color color, float x, int y, float width) {
    if (width <= 0 ||
        color == null ||
        color.equals(myEditor.getColorsScheme().getDefaultBackground()) ||
        color.equals(myEditor.getBackgroundColor())) return;
    g.setColor(color);
    g.fill(new Rectangle2D.Float(x, y, width, myView.getLineHeight()));
  }

  private void paintCustomRenderers(final Graphics2D g, int yShift, final int startOffset, final int endOffset) {
    g.translate(0, yShift);
    myEditor.getMarkupModel().processRangeHighlightersOverlappingWith(startOffset, endOffset, highlighter -> {
      CustomHighlighterRenderer customRenderer = highlighter.getCustomRenderer();
      if (customRenderer != null && startOffset < highlighter.getEndOffset() && highlighter.getStartOffset() < endOffset) {
        customRenderer.paint(myEditor, highlighter, g);
      }
      return true;
    });
    g.translate(0, -yShift);
  }

  private void paintLineMarkersSeparators(final Graphics g,
                                          final Rectangle clip,
                                          int yShift,
                                          MarkupModelEx markupModel,
                                          int startOffset,
                                          int endOffset) {
    // we decrement startOffset to capture also line-range highlighters on the previous line,
    // cause they can render a separator visible on current line
    markupModel.processRangeHighlightersOverlappingWith(startOffset - 1, endOffset, highlighter -> {
      paintLineMarkerSeparator(highlighter, clip, g, yShift);
      return true;
    });
  }

  private void paintLineMarkerSeparator(RangeHighlighter marker, Rectangle clip, Graphics g, int yShift) {
    Color separatorColor = marker.getLineSeparatorColor();
    LineSeparatorRenderer lineSeparatorRenderer = marker.getLineSeparatorRenderer();
    if (separatorColor == null && lineSeparatorRenderer == null) {
      return;
    }
    int line = myDocument.getLineNumber(marker.getLineSeparatorPlacement() == SeparatorPlacement.TOP
                                        ? marker.getStartOffset()
                                        : marker.getEndOffset());
    int visualLine = myView.logicalToVisualPosition(new LogicalPosition(line + (marker.getLineSeparatorPlacement() ==
                                                                                SeparatorPlacement.TOP ? 0 : 1), 0), false).line;
    int y = myView.visualLineToY(visualLine) - 1 + yShift;
    int startX = myCorrector.lineSeparatorStart(clip.x);
    int endX = myCorrector.lineSeparatorEnd(clip.x + clip.width);
    g.setColor(separatorColor);
    if (lineSeparatorRenderer != null) {
      lineSeparatorRenderer.drawLine(g, startX, endX, y);
    }
    else {
      UIUtil.drawLine(g, startX, y, endX, y);
    }
  }

  private void paintTextWithEffects(Graphics2D g, Rectangle clip, int yShift, int startVisualLine, int endVisualLine,
                                    IterationState.CaretData caretData) {
    final CharSequence text = myDocument.getImmutableCharSequence();
    final LineWhitespacePaintingStrategy whitespacePaintingStrategy = new LineWhitespacePaintingStrategy(myEditor.getSettings());
    boolean paintAllSoftWraps = myEditor.getSettings().isAllSoftWrapsShown();
    int lineCount = myEditor.getVisibleLineCount();
    final int whiteSpaceStrokeWidth = JBUI.scale(1);
    final Stroke whiteSpaceStroke = new BasicStroke(whiteSpaceStrokeWidth);

    LineLayout prefixLayout = myView.getPrefixLayout();
    if (startVisualLine == 0 && prefixLayout != null) {
      TextAttributes attributes = myView.getPrefixAttributes();
      g.setColor(attributes.getForegroundColor());
      paintLineLayoutWithEffect(g, prefixLayout, myCorrector.startX(startVisualLine), myView.getAscent() + yShift,
                                attributes.getEffectColor(), attributes.getEffectType());
    }

    VisualLinesIterator visLinesIterator = new VisualLinesIterator(myEditor, startVisualLine);
    while (!visLinesIterator.atEnd()) {
      int visualLine = visLinesIterator.getVisualLine();
      if (visualLine > endVisualLine || visualLine >= lineCount) break;

      int y = visLinesIterator.getY() + yShift;
      final boolean paintSoftWraps = paintAllSoftWraps ||
                                     myEditor.getCaretModel().getLogicalPosition().line == visLinesIterator.getStartLogicalLine();
      final int[] currentLogicalLine = new int[] {-1};

      paintLineFragments(g, clip, visLinesIterator, caretData, y + myView.getAscent(), new LineFragmentPainter() {
        @Override
        public void paintBeforeLineStart(Graphics2D g, TextAttributes attributes, boolean hasSoftWrap, int columnEnd, float xEnd, int y) {
          if (paintSoftWraps && hasSoftWrap) {
            SoftWrapModelImpl softWrapModel = myEditor.getSoftWrapModel();
            int symbolWidth = softWrapModel.getMinDrawingWidthInPixels(SoftWrapDrawingType.AFTER_SOFT_WRAP);
            softWrapModel.doPaint(g, SoftWrapDrawingType.AFTER_SOFT_WRAP,
                                  (int)xEnd - symbolWidth, y - myView.getAscent(), myView.getLineHeight());
          }
        }

        @Override
        public void paint(Graphics2D g, VisualLineFragmentsIterator.Fragment fragment, int start, int end,
                          TextAttributes attributes, float xStart, float xEnd, int y) {
          int lineHeight = myView.getLineHeight();
          Inlay inlay = fragment.getCurrentInlay();
          if (inlay != null) {
            inlay.getRenderer().paint(myEditor, g,
                                      new Rectangle((int) xStart, y - myView.getAscent(), inlay.getWidthInPixels(), lineHeight),
                                      attributes);
            return;
          }
          boolean allowBorder = fragment.getCurrentFoldRegion() != null;
          if (attributes != null && hasTextEffect(attributes.getEffectColor(), attributes.getEffectType(), allowBorder)) {
            paintTextEffect(g, xStart, xEnd, y, attributes.getEffectColor(), attributes.getEffectType(), allowBorder);
          }
          if (attributes != null && attributes.getForegroundColor() != null) {
            g.setColor(attributes.getForegroundColor());
            fragment.draw(g, xStart, y, start, end);
          }
          if (fragment.getCurrentFoldRegion() == null) {
            int logicalLine = fragment.getStartLogicalLine();
            if (logicalLine != currentLogicalLine[0]) {
              whitespacePaintingStrategy.update(text, myDocument.getLineStartOffset(logicalLine), myDocument.getLineEndOffset(logicalLine));
              currentLogicalLine[0] = logicalLine;
            }
            paintWhitespace(g, text, xStart, y, start, end, whitespacePaintingStrategy, fragment, whiteSpaceStroke, whiteSpaceStrokeWidth);
          }
        }

        @Override
        public void paintAfterLineEnd(Graphics2D g, Rectangle clip, IterationState iterationState, int columnStart, float x, int y) {
          int offset = iterationState.getEndOffset();
          SoftWrapModelImpl softWrapModel = myEditor.getSoftWrapModel();
          if (softWrapModel.getSoftWrap(offset) == null) {
            int logicalLine = myDocument.getLineNumber(offset);
            paintLineExtensions(g, logicalLine, x, y);
          }
          else if (paintSoftWraps) {
            softWrapModel.doPaint(g, SoftWrapDrawingType.BEFORE_SOFT_WRAP_LINE_FEED,
                                  (int)x, y - myView.getAscent(), myView.getLineHeight());
          }
        }
      }, null);
      visLinesIterator.advance();
    }
    ComplexTextFragment.flushDrawingCache(g);
  }

  private float paintLineLayoutWithEffect(Graphics2D g, LineLayout layout, float x, float y,
                                  @Nullable Color effectColor, @Nullable EffectType effectType) {
    if (hasTextEffect(effectColor, effectType, false)) {
      paintTextEffect(g, x, x + layout.getWidth(), (int)y, effectColor, effectType, false);
    }
    for (LineLayout.VisualFragment fragment : layout.getFragmentsInVisualOrder(x)) {
      fragment.draw(g, x, y);
      x = fragment.getEndX();
    }
    return x;
  }

  private static boolean hasTextEffect(@Nullable Color effectColor, @Nullable EffectType effectType, boolean allowBorder) {
    return effectColor != null && (effectType == EffectType.LINE_UNDERSCORE ||
                                   effectType == EffectType.BOLD_LINE_UNDERSCORE ||
                                   effectType == EffectType.BOLD_DOTTED_LINE ||
                                   effectType == EffectType.WAVE_UNDERSCORE ||
                                   effectType == EffectType.STRIKEOUT ||
                                   allowBorder && (effectType == EffectType.BOXED || effectType == EffectType.ROUNDED_BOX));
  }

  private void paintTextEffect(Graphics2D g, float xFrom, float xTo, int y, Color effectColor, EffectType effectType, boolean allowBorder) {
    g.setColor(effectColor);
    int xStart = (int)xFrom;
    int xEnd = (int)xTo;
    if (effectType == EffectType.LINE_UNDERSCORE) {
      EffectPainter.LINE_UNDERSCORE.paint(g, xStart, y, xEnd - xStart, myView.getDescent(),
                                          myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
    }
    else if (effectType == EffectType.BOLD_LINE_UNDERSCORE) {
      EffectPainter.BOLD_LINE_UNDERSCORE.paint(g, xStart, y, xEnd - xStart, myView.getDescent(),
                                               myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
    }
    else if (effectType == EffectType.STRIKEOUT) {
      EffectPainter.STRIKE_THROUGH.paint(g, xStart, y, xEnd - xStart, myView.getCharHeight(),
                                         myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
    }
    else if (effectType == EffectType.WAVE_UNDERSCORE) {
      EffectPainter.WAVE_UNDERSCORE.paint(g, xStart, y, xEnd - xStart, myView.getDescent(),
                                          myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
    }
    else if (effectType == EffectType.BOLD_DOTTED_LINE) {
      EffectPainter.BOLD_DOTTED_UNDERSCORE.paint(g, xStart, y, xEnd - xStart, myView.getDescent(),
                                                 myEditor.getColorsScheme().getFont(EditorFontType.PLAIN));
    }
    else if (allowBorder && (effectType == EffectType.BOXED || effectType == EffectType.ROUNDED_BOX)) {
      drawSimpleBorder(g, xFrom, xTo, y - myView.getAscent(), effectType == EffectType.ROUNDED_BOX);
    }
  }

  private void paintWhitespace(Graphics2D g, CharSequence text, float x, int y, int start, int end,
                               LineWhitespacePaintingStrategy whitespacePaintingStrategy,
                               VisualLineFragmentsIterator.Fragment fragment, Stroke stroke, int strokeWidth) {
    Stroke oldStroke = g.getStroke();
    try {
      g.setColor(myEditor.getColorsScheme().getColor(EditorColors.WHITESPACES_COLOR));
      g.setStroke(stroke); // applied for tab & ideographic space

      boolean isRtl = fragment.isRtl();
      int baseStartOffset = fragment.getStartOffset();
      int startOffset = isRtl ? baseStartOffset - start : baseStartOffset + start;
      y -= 1;

      for (int i = start; i < end; i++) {
        int charOffset = isRtl ? baseStartOffset - i - 1 : baseStartOffset + i;
        char c = text.charAt(charOffset);
        if (" \t\u3000".indexOf(c) >= 0 && whitespacePaintingStrategy.showWhitespaceAtOffset(charOffset)) {
          int startX = (int)fragment.offsetToX(x, startOffset, isRtl ? baseStartOffset - i : baseStartOffset + i);
          int endX = (int)fragment.offsetToX(x, startOffset, isRtl ? baseStartOffset - i - 1 : baseStartOffset + i + 1);

          if (c == ' ') {
            //noinspection SuspiciousNameCombination
            g.fillRect((startX + endX - strokeWidth) / 2, y - strokeWidth + 1, strokeWidth, strokeWidth);
          }
          else if (c == '\t') {
            endX -= myView.getPlainSpaceWidth() / 4;
            int height = myView.getCharHeight();
            int halfHeight = height / 2;
            int mid = y - halfHeight;
            int top = y - height;
            UIUtil.drawLine(g, startX, mid, endX, mid);
            UIUtil.drawLine(g, endX, y, endX, top);
            g.fillPolygon(new int[]{endX - halfHeight, endX - halfHeight, endX}, new int[]{y, y - height, y - halfHeight}, 3);
          }
          else if (c == '\u3000') { // ideographic space
            int charHeight = myView.getCharHeight();
            g.drawRect(startX + JBUI.scale(2) + strokeWidth/2, y - charHeight + strokeWidth/2,
                       endX - startX - JBUI.scale(4) - (strokeWidth - 1), charHeight - (strokeWidth - 1));
          }
        }
      }
    } finally {
      g.setStroke(oldStroke);
    }
  }

  private void paintLineExtensions(Graphics2D g, int line, float x, int y) {
    float[] curX = {x};
    myEditor.processLineExtensions(line, (info) -> {
      LineLayout layout = LineLayout.create(myView, info.getText(), info.getFontType());
      g.setColor(info.getColor());
      curX[0] = paintLineLayoutWithEffect(g, layout, curX[0], y, info.getEffectColor(), info.getEffectType());
      int currentLineWidth = myCorrector.lineWidth(line, curX[0]);
      EditorSizeManager sizeManager = myView.getSizeManager();
      if (currentLineWidth > sizeManager.getMaxLineWithExtensionWidth()) {
        sizeManager.setMaxLineWithExtensionWidth(line, currentLineWidth);
      }
      return true;
    });
  }

  private void paintHighlightersAfterEndOfLine(final Graphics2D g,
                                               int yShift,
                                               MarkupModelEx markupModel,
                                               final int startOffset,
                                               int endOffset) {
    markupModel.processRangeHighlightersOverlappingWith(startOffset, endOffset, highlighter -> {
      if (highlighter.getStartOffset() >= startOffset) {
        paintHighlighterAfterEndOfLine(g, yShift, highlighter);
      }
      return true;
    });
  }

  private void paintHighlighterAfterEndOfLine(Graphics2D g, int yShift, RangeHighlighterEx highlighter) {
    if (!highlighter.isAfterEndOfLine()) {
      return;
    }
    int startOffset = highlighter.getStartOffset();
    int lineEndOffset = myDocument.getLineEndOffset(myDocument.getLineNumber(startOffset));
    if (myEditor.getFoldingModel().isOffsetCollapsed(lineEndOffset)) return;
    Point2D lineEnd = myView.offsetToXY(lineEndOffset, true, false);
    float x = (float)lineEnd.getX();
    int y = (int)lineEnd.getY() + yShift;
    TextAttributes attributes = highlighter.getTextAttributes();
    paintBackground(g, attributes, x, y, myView.getPlainSpaceWidth());
    if (attributes != null && hasTextEffect(attributes.getEffectColor(), attributes.getEffectType(), false)) {
      paintTextEffect(g, x, x + myView.getPlainSpaceWidth() - 1, y + myView.getAscent(),
                      attributes.getEffectColor(), attributes.getEffectType(), false);
    }
  }

  private void paintBorderEffect(Graphics2D g,
                                 ClipDetector clipDetector,
                                 int yShift,
                                 EditorHighlighter highlighter,
                                 int clipStartOffset,
                                 int clipEndOffset) {
    HighlighterIterator it = highlighter.createIterator(clipStartOffset);
    while (!it.atEnd() && it.getStart() < clipEndOffset) {
      TextAttributes attributes = it.getTextAttributes();
      if (isBorder(attributes)) {
        paintBorderEffect(g, clipDetector, yShift, it.getStart(), it.getEnd(), attributes);
      }
      it.advance();
    }
  }

  private void paintBorderEffect(final Graphics2D g,
                                 final ClipDetector clipDetector,
                                 int yShift,
                                 MarkupModelEx markupModel,
                                 int clipStartOffset,
                                 int clipEndOffset) {
    markupModel.processRangeHighlightersOverlappingWith(clipStartOffset, clipEndOffset, rangeHighlighter -> {
      TextAttributes attributes = rangeHighlighter.getTextAttributes();
      if (isBorder(attributes)) {
        paintBorderEffect(g, clipDetector, yShift,
                          rangeHighlighter.getAffectedAreaStartOffset(), rangeHighlighter.getAffectedAreaEndOffset(), attributes);
      }
      return true;
    });
  }

  private static boolean isBorder(TextAttributes attributes) {
    return attributes != null &&
           (attributes.getEffectType() == EffectType.BOXED || attributes.getEffectType() == EffectType.ROUNDED_BOX) &&
           attributes.getEffectColor() != null;
  }

  private void paintBorderEffect(Graphics2D g, ClipDetector clipDetector, int yShift,
                                 int startOffset, int endOffset, TextAttributes attributes) {
    startOffset = DocumentUtil.alignToCodePointBoundary(myDocument, startOffset);
    endOffset = DocumentUtil.alignToCodePointBoundary(myDocument, endOffset);
    if (!clipDetector.rangeCanBeVisible(startOffset, endOffset)) return;
    int startLine = myDocument.getLineNumber(startOffset);
    int endLine = myDocument.getLineNumber(endOffset);
    if (startLine + 1 == endLine &&
        startOffset == myDocument.getLineStartOffset(startLine) &&
        endOffset == myDocument.getLineStartOffset(endLine)) {
      // special case of line highlighters
      endLine--;
      endOffset = myDocument.getLineEndOffset(endLine);
    }

    boolean rounded = attributes.getEffectType() == EffectType.ROUNDED_BOX;
    g.setColor(attributes.getEffectColor());
    VisualPosition startPosition = myView.offsetToVisualPosition(startOffset, true, false);
    VisualPosition endPosition = myView.offsetToVisualPosition(endOffset, false, true);
    if (startPosition.line == endPosition.line) {
      int y = myView.visualLineToY(startPosition.line) + yShift;
      TFloatArrayList ranges = adjustedLogicalRangeToVisualRanges(startOffset, endOffset);
      for (int i = 0; i < ranges.size() - 1; i+= 2) {
        float startX = myCorrector.singleLineBorderStart(ranges.get(i));
        float endX = myCorrector.singleLineBorderEnd(ranges.get(i + 1));
        drawSimpleBorder(g, startX, endX, y, rounded);
      }
    }
    else {
      TFloatArrayList leadingRanges = adjustedLogicalRangeToVisualRanges(
        startOffset, myView.visualPositionToOffset(new VisualPosition(startPosition.line, Integer.MAX_VALUE, true)));
      TFloatArrayList trailingRanges = adjustedLogicalRangeToVisualRanges(
        myView.visualPositionToOffset(new VisualPosition(endPosition.line, 0)), endOffset);
      if (!leadingRanges.isEmpty() && !trailingRanges.isEmpty()) {
        int minX = Math.min(myCorrector.minX(startPosition.line, endPosition.line), (int)leadingRanges.get(0));
        int maxX = Math.max(myCorrector.maxX(startPosition.line, endPosition.line), (int)trailingRanges.get(trailingRanges.size() - 1));
        boolean containsInnerLines = endPosition.line > startPosition.line + 1;
        int lineHeight = myView.getLineHeight() - 1;
        int leadingTopY = myView.visualLineToY(startPosition.line) + yShift;
        int leadingBottomY = leadingTopY + lineHeight;
        int trailingTopY = myView.visualLineToY(endPosition.line) + yShift;
        int trailingBottomY = trailingTopY + lineHeight;
        float start = 0;
        float end = 0;
        float leftGap = leadingRanges.get(0) - (containsInnerLines ? minX : trailingRanges.get(0));
        int adjustY = leftGap == 0 ? 2 : leftGap > 0 ? 1 : 0; // avoiding 1-pixel gap between aligned lines
        for (int i = 0; i < leadingRanges.size() - 1; i += 2) {
          start = leadingRanges.get(i);
          end = leadingRanges.get(i + 1);
          if (i > 0) {
            drawLine(g, leadingRanges.get(i - 1), leadingBottomY, start, leadingBottomY, rounded);
          }
          drawLine(g, start, leadingBottomY + (i == 0 ? adjustY : 0), start, leadingTopY, rounded);
          if ((i + 2) < leadingRanges.size()) {
            drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
            drawLine(g, end, leadingTopY, end, leadingBottomY, rounded);
          }
        }
        end = Math.max(end, maxX);
        drawLine(g, start, leadingTopY, end, leadingTopY, rounded);
        drawLine(g, end, leadingTopY, end, trailingTopY - 1, rounded);
        float targetX = trailingRanges.get(trailingRanges.size() - 1);
        drawLine(g, end, trailingTopY - 1, targetX, trailingTopY - 1, rounded);
        adjustY = end == targetX ? -2 : -1; // for lastX == targetX we need to avoid a gap when rounding is used
        for (int i = trailingRanges.size() - 2; i >= 0; i -= 2) {
          start = trailingRanges.get(i);
          end = trailingRanges.get(i + 1);

          drawLine(g, end, trailingTopY + (i == 0 ? adjustY : 0), end, trailingBottomY, rounded);
          drawLine(g, end, trailingBottomY, start, trailingBottomY, rounded);
          drawLine(g, start, trailingBottomY, start, trailingTopY, rounded);
          if (i > 0) {
            drawLine(g, start, trailingTopY, trailingRanges.get(i - 1), trailingTopY, rounded);
          }
        }
        float lastX = start;
        if (containsInnerLines) {
          if (start != minX) {
            drawLine(g, start, trailingTopY, start, trailingTopY - 1, rounded);
            drawLine(g, start, trailingTopY - 1, minX, trailingTopY - 1, rounded);
            drawLine(g, minX, trailingTopY - 1, minX, leadingBottomY + 1, rounded);
          }
          else {
            drawLine(g, minX, trailingTopY, minX, leadingBottomY + 1, rounded);
          }
          lastX = minX;
        }
        targetX = leadingRanges.get(0);
        if (lastX < targetX) {
          drawLine(g, lastX, leadingBottomY + 1, targetX, leadingBottomY + 1, rounded);
        }
        else {
          drawLine(g, lastX, leadingBottomY + 1, lastX, leadingBottomY, rounded);
          drawLine(g, lastX, leadingBottomY, targetX, leadingBottomY, rounded);
        }
      }
    }
  }

  private void drawSimpleBorder(Graphics2D g, float xStart, float xEnd, float y, boolean rounded) {
    Shape border = getBorderShape(xStart, y, xEnd - xStart, myView.getLineHeight(), rounded);
    if (border != null) {
      Object old = g.getRenderingHint(RenderingHints.KEY_ANTIALIASING);
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      g.fill(border);
      g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, old);
    }
  }

  private static Shape getBorderShape(float x, float y, float width, int height, boolean rounded) {
    if (width <= 0 || height <= 0) return null;
    Shape outer = rounded
                  ? new RoundRectangle2D.Float(x, y, width, height, 2, 2)
                  : new Rectangle2D.Float(x, y, width, height);

    if (width <= 2 || height <= 2) return outer;
    Shape inner = new Rectangle2D.Float(x + 1, y + 1, width - 2, height - 2);

    Path2D path = new Path2D.Float(Path2D.WIND_EVEN_ODD);
    path.append(outer, false);
    path.append(inner, false);
    return path;
  }

  private static void drawLine(Graphics2D g, float x1, int y1, float x2, int y2, boolean rounded) {
    if (rounded) {
      UIUtil.drawLinePickedOut(g, (int) x1, y1, (int)x2, y2);
    } else {
      UIUtil.drawLine(g, (int)x1, y1, (int)x2, y2);
    }
  }

  /**
   * Returns ranges obtained from {@link #logicalRangeToVisualRanges(int, int)}, adjusted for painting range border - lines should
   * line inside target ranges (except for empty range). Target offsets are supposed to be located on the same visual line.
   */
  private TFloatArrayList adjustedLogicalRangeToVisualRanges(int startOffset, int endOffset) {
    TFloatArrayList ranges = logicalRangeToVisualRanges(startOffset, endOffset);
    for (int i = 0; i < ranges.size() - 1; i += 2) {
      float startX = ranges.get(i);
      float endX = ranges.get(i + 1);
      if (startX == endX) {
        if (startX > 0) {
          startX--;
        }
        else {
          endX++;
        }
      }
      else {
        endX--;
      }
      ranges.set(i, startX);
      ranges.set(i + 1, endX);
    }
    return ranges;
  }

    /**
     * Returns a list of pairs of x coordinates for visual ranges representing given logical range. If
     * {@code startOffset == endOffset}, a pair of equal numbers is returned, corresponding to target position. Target offsets are
     * supposed to be located on the same visual line.
     */
  private TFloatArrayList logicalRangeToVisualRanges(int startOffset, int endOffset) {
    assert startOffset <= endOffset;
    TFloatArrayList result = new TFloatArrayList();
    if (myDocument.getTextLength() == 0) {
      int minX = myCorrector.emptyTextX();
      result.add(minX);
      result.add(minX);
    }
    else {
      float lastX = -1;
      for (VisualLineFragmentsIterator.Fragment fragment : VisualLineFragmentsIterator.create(myView, startOffset, false, true)) {
        int minOffset = fragment.getMinOffset();
        int maxOffset = fragment.getMaxOffset();
        if (startOffset == endOffset) {
          lastX = fragment.getEndX();
          Inlay inlay = fragment.getCurrentInlay();
          if (inlay != null && !inlay.isRelatedToPrecedingText()) continue;
          if (startOffset >= minOffset && startOffset < maxOffset) {
            float x = fragment.offsetToX(startOffset);
            result.add(x);
            result.add(x);
            break;
          }
        }
        else if (startOffset < maxOffset && endOffset > minOffset) {
          float x1 = minOffset == maxOffset ? fragment.getStartX() : fragment.offsetToX(Math.max(minOffset, startOffset));
          float x2 = minOffset == maxOffset ? fragment.getEndX() : fragment.offsetToX(Math.min(maxOffset, endOffset));
          if (x1 > x2) {
            float tmp = x1;
            x1 = x2;
            x2 = tmp;
          }
          if (result.isEmpty() || x1 > result.get(result.size() - 1)) {
            result.add(x1);
            result.add(x2);
          }
          else {
            result.set(result.size() - 1, x2);
          }
        }
      }
      if (startOffset == endOffset && result.isEmpty() && lastX >= 0) {
        result.add(lastX);
        result.add(lastX);
      }
    }
    return result;
  }

  private void paintComposedTextDecoration(Graphics2D g, int yShift) {
    TextRange composedTextRange = myEditor.getComposedTextRange();
    if (composedTextRange != null) {
      Point2D p1 = myView.offsetToXY(Math.min(composedTextRange.getStartOffset(), myDocument.getTextLength()), true, false);
      Point2D p2 = myView.offsetToXY(Math.min(composedTextRange.getEndOffset(), myDocument.getTextLength()), false, true);

      int y = (int)p1.getY() + myView.getAscent() + 1 + yShift;

      g.setStroke(IME_COMPOSED_TEXT_UNDERLINE_STROKE);
      g.setColor(myEditor.getColorsScheme().getDefaultForeground());
      UIUtil.drawLine(g, (int)p1.getX(), y, (int)p2.getX(), y);
    }
  }

  private void paintCaret(Graphics2D g_, int yShift) {
    EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(true);
    if (locations == null) return;

    Graphics2D g = IdeBackgroundUtil.getOriginalGraphics(g_);
    int nominalLineHeight = myView.getNominalLineHeight();
    int topOverhang = myView.getTopOverhang();
    EditorSettings settings = myEditor.getSettings();
    Color caretColor = myEditor.getColorsScheme().getColor(EditorColors.CARET_COLOR);
    if (caretColor == null) caretColor = new JBColor(CARET_DARK, CARET_LIGHT);
    int minX = myView.getInsets().left;
    for (EditorImpl.CaretRectangle location : locations) {
      float x = location.myPoint.x;
      int y = location.myPoint.y - topOverhang + yShift;
      Caret caret = location.myCaret;
      CaretVisualAttributes attr = caret == null ? CaretVisualAttributes.DEFAULT : caret.getVisualAttributes();
      g.setColor(attr.getColor() != null ? attr.getColor() : caretColor);
      boolean isRtl = location.myIsRtl;
      if (myEditor.isInsertMode() != settings.isBlockCursor()) {
        int lineWidth = JBUI.scale(attr.getWidth(settings.getLineCursorWidth()));
        // fully cover extra character's pixel which can appear due to antialiasing
        // see IDEA-148843 for more details
        if (x > minX && lineWidth > 1) x -= 1 / JBUI.sysScale(g);
        g.fill(new Rectangle2D.Float(x, y, lineWidth, nominalLineHeight));
        if (myDocument.getTextLength() > 0 && caret != null &&
            !myView.getTextLayoutCache().getLineLayout(caret.getLogicalPosition().line).isLtr()) {
          GeneralPath triangle = new GeneralPath(Path2D.WIND_NON_ZERO, 3);
          triangle.moveTo(isRtl ? x + lineWidth : x, y);
          triangle.lineTo(isRtl ? x + lineWidth - CARET_DIRECTION_MARK_SIZE : x + CARET_DIRECTION_MARK_SIZE, y);
          triangle.lineTo(isRtl ? x + lineWidth : x, y + CARET_DIRECTION_MARK_SIZE);
          triangle.closePath();
          g.fill(triangle);
        }
      }
      else {
        int width = location.myWidth;
        float startX = Math.max(minX, isRtl ? x - width : x);
        g.fill(new Rectangle2D.Float(startX, y, width, nominalLineHeight));
        if (myDocument.getTextLength() > 0 && caret != null) {
          int targetVisualColumn = caret.getVisualPosition().column - (isRtl ? 1 : 0);
          for (VisualLineFragmentsIterator.Fragment fragment : VisualLineFragmentsIterator.create(myView,
                                                                                caret.getVisualLineStart(),
                                                                                false)) {
            if (fragment.getCurrentInlay() != null) continue;
            int startVisualColumn = fragment.getStartVisualColumn();
            int endVisualColumn = fragment.getEndVisualColumn();
            if (startVisualColumn <= targetVisualColumn && targetVisualColumn < endVisualColumn) {
              g.setColor(ColorUtil.isDark(caretColor) ? CARET_LIGHT : CARET_DARK);
              fragment.draw(g, startX, y + topOverhang + myView.getAscent(),
                            fragment.visualColumnToOffset(targetVisualColumn - startVisualColumn),
                            fragment.visualColumnToOffset(targetVisualColumn + 1 - startVisualColumn));
              break;
            }
          }
          ComplexTextFragment.flushDrawingCache(g);
        }
      }
    }
  }

  void repaintCarets() {
    EditorImpl.CaretRectangle[] locations = myEditor.getCaretLocations(false);
    if (locations == null) return;
    int nominalLineHeight = myView.getNominalLineHeight();
    int topOverhang = myView.getTopOverhang();
    for (EditorImpl.CaretRectangle location : locations) {
      int x = location.myPoint.x;
      int y = location.myPoint.y - topOverhang;
      int width = Math.max(location.myWidth, CARET_DIRECTION_MARK_SIZE);
      myEditor.getContentComponent().repaintEditorComponent(x - width, y, width * 2, nominalLineHeight);
    }
  }

  private interface MarginShiftConsumer {
    void process(float shift);
  }

  private void paintLineFragments(Graphics2D g, Rectangle clip, VisualLinesIterator visLineIterator, IterationState.CaretData caretData,
                                  int y, LineFragmentPainter painter, MarginShiftConsumer marginShiftConsumer) {
    int visualLine = visLineIterator.getVisualLine();
    float x = myCorrector.startX(visualLine) + (visualLine == 0 ? myView.getPrefixTextWidthInPixels() : 0);
    int offset = visLineIterator.getVisualLineStartOffset();
    int visualLineEndOffset = visLineIterator.getVisualLineEndOffset();
    IterationState it = null;
    int prevEndOffset = -1;
    boolean firstFragment = true;
    int maxColumn = 0;
    for (VisualLineFragmentsIterator.Fragment fragment : VisualLineFragmentsIterator.create(myView, visLineIterator, null, true)) {
      int fragmentStartOffset = fragment.getStartOffset();
      int start = fragmentStartOffset;
      int end = fragment.getEndOffset();
      x = fragment.getStartX();
      if (firstFragment) {
        firstFragment = false;
        SoftWrap softWrap = myEditor.getSoftWrapModel().getSoftWrap(offset);
        boolean hasSoftWrap = softWrap != null;
        if (hasSoftWrap || myEditor.isRightAligned()) {
          prevEndOffset = offset;
          it = new IterationState(myEditor, offset == 0 ? 0 : DocumentUtil.getPreviousCodePointOffset(myDocument, offset), visualLineEndOffset,
                                  caretData, false, false, false, false);
          if (it.getEndOffset() <= offset) {
            it.advance();
          }
          if (x >= clip.getMinX()) {
            TextAttributes attributes = it.getStartOffset() == offset ? it.getBeforeLineStartBackgroundAttributes() :
                                        it.getMergedAttributes();
            painter.paintBeforeLineStart(g, attributes, hasSoftWrap, fragment.getStartVisualColumn(), x, y);
          }
        }
      }
      float marginShift = 0;
      FoldRegion foldRegion = fragment.getCurrentFoldRegion();
      if (foldRegion == null) {
        if (start != prevEndOffset) {
          it = new IterationState(myEditor, start, fragment.isRtl() ? offset : visualLineEndOffset,
                                  caretData, false, false, false, fragment.isRtl());
        }
        prevEndOffset = end;
        assert it != null;
        if (start == end) { // special case of inlays
          if (start == it.getEndOffset() && !it.atEnd()) {
            it.advance();
          }
          TextAttributes attributes = it.getStartOffset() == start ? it.getBreakAttributes() : it.getMergedAttributes();
          float xNew = fragment.getEndX();
          if (xNew >= clip.getMinX()) {
            painter.paint(g, fragment, 0, 0, attributes, x, xNew, y);
          }
          if (marginShiftConsumer != null) marginShift = xNew - x;
          x = xNew;
        }
        else {
          while (fragment.isRtl() ? start > end : start < end) {
            if (fragment.isRtl() ? it.getEndOffset() >= start : it.getEndOffset() <= start) {
              assert !it.atEnd();
              it.advance();
            }
            TextAttributes attributes = it.getMergedAttributes();
            int curEnd = fragment.isRtl() ? Math.max(it.getEndOffset(), end) : Math.min(it.getEndOffset(), end);
            float xNew = fragment.offsetToX(x, start, curEnd);
            if (xNew >= clip.getMinX()) {
              painter.paint(g, fragment,
                            fragment.isRtl() ? fragmentStartOffset - start : start - fragmentStartOffset,
                            fragment.isRtl() ? fragmentStartOffset - curEnd : curEnd - fragmentStartOffset,
                            attributes, x, xNew, y);
            }
            x = xNew;
            start = curEnd;
          }
        }
      }
      else {
        float xNew = fragment.getEndX();
        if (xNew >= clip.getMinX()) {
          painter.paint(g, fragment, 0, fragment.getVisualLength(), getFoldRegionAttributes(foldRegion), x, xNew, y);
        }
        x = xNew;
        prevEndOffset = -1;
        it = null;
        if (marginShiftConsumer != null) marginShift = x - myCorrector.startX(visualLine)
                                                       - fragment.getEndLogicalColumn() * myView.getPlainSpaceWidth();
      }
      if (marginShift != 0) marginShiftConsumer.process(marginShift);
      if (x > clip.getMaxX()) return;
      maxColumn = fragment.getEndVisualColumn();
    }
    if (firstFragment && myEditor.isRightAligned()) {
      it = new IterationState(myEditor, offset, visualLineEndOffset, caretData, false, false, false, false);
      if (it.getEndOffset() <= offset) {
        it.advance();
      }
      painter.paintBeforeLineStart(g, it.getBeforeLineStartBackgroundAttributes(), false, maxColumn, x, y);
    }
    if (it == null || it.getEndOffset() != visualLineEndOffset) {
      it = new IterationState(myEditor, visualLineEndOffset == offset ? visualLineEndOffset
                                                                      : DocumentUtil.getPreviousCodePointOffset(myDocument, visualLineEndOffset),
                              visualLineEndOffset, caretData, false, false, false, false);
    }
    if (!it.atEnd()) {
      it.advance();
    }
    assert it.atEnd();
    painter.paintAfterLineEnd(g, clip, it, maxColumn, x, y);
  }

  private TextAttributes getFoldRegionAttributes(FoldRegion foldRegion) {
    TextAttributes selectionAttributes = isSelected(foldRegion) ? myEditor.getSelectionModel().getTextAttributes() : null;
    TextAttributes foldAttributes = myEditor.getFoldingModel().getPlaceholderAttributes();
    TextAttributes defaultAttributes = getDefaultAttributes();
    return mergeAttributes(mergeAttributes(selectionAttributes, foldAttributes), defaultAttributes);
  }

  @SuppressWarnings("UseJBColor")
  private TextAttributes getDefaultAttributes() {
    TextAttributes attributes = myEditor.getColorsScheme().getAttributes(HighlighterColors.TEXT);
    if (attributes.getForegroundColor() == null) attributes.setForegroundColor(Color.black);
    if (attributes.getBackgroundColor() == null) attributes.setBackgroundColor(Color.white);
    return attributes;
  }

  private static boolean isSelected(FoldRegion foldRegion) {
    int regionStart = foldRegion.getStartOffset();
    int regionEnd = foldRegion.getEndOffset();
    int[] selectionStarts = foldRegion.getEditor().getSelectionModel().getBlockSelectionStarts();
    int[] selectionEnds = foldRegion.getEditor().getSelectionModel().getBlockSelectionEnds();
    for (int i = 0; i < selectionStarts.length; i++) {
      int start = selectionStarts[i];
      int end = selectionEnds[i];
      if (regionStart >= start && regionEnd <= end) return true;
    }
    return false;
  }

  private static TextAttributes mergeAttributes(TextAttributes primary, TextAttributes secondary) {
    if (primary == null) return secondary;
    if (secondary == null) return primary;
    return new TextAttributes(primary.getForegroundColor() == null ? secondary.getForegroundColor() : primary.getForegroundColor(),
                              primary.getBackgroundColor() == null ? secondary.getBackgroundColor() : primary.getBackgroundColor(),
                              primary.getEffectColor() == null ? secondary.getEffectColor() : primary.getEffectColor(),
                              primary.getEffectType() == null ? secondary.getEffectType() : primary.getEffectType(),
                              primary.getFontType() == Font.PLAIN ? secondary.getFontType() : primary.getFontType());
  }

  @Override
  public void drawChars(@NotNull Graphics g, @NotNull char[] data, int start, int end, int x, int y, Color color, FontInfo fontInfo) {
    g.setFont(fontInfo.getFont());
    g.setColor(color);
    g.drawChars(data, start, end - start, x, y);
  }

  interface LineFragmentPainter {
    void paintBeforeLineStart(Graphics2D g, TextAttributes attributes, boolean hasSoftWrap, int columnEnd, float xEnd, int y);
    void paint(Graphics2D g, VisualLineFragmentsIterator.Fragment fragment, int start, int end, TextAttributes attributes,
               float xStart, float xEnd, int y);
    void paintAfterLineEnd(Graphics2D g, Rectangle clip, IterationState iterationState, int columnStart, float x, int y);
  }

  private static class LineWhitespacePaintingStrategy {
    private final boolean myWhitespaceShown;
    private final boolean myLeadingWhitespaceShown;
    private final boolean myInnerWhitespaceShown;
    private final boolean myTrailingWhitespaceShown;

    // Offsets on current line where leading whitespace ends and trailing whitespace starts correspondingly.
    private int currentLeadingEdge;
    private int currentTrailingEdge;

    public LineWhitespacePaintingStrategy(EditorSettings settings) {
      myWhitespaceShown = settings.isWhitespacesShown();
      myLeadingWhitespaceShown = settings.isLeadingWhitespaceShown();
      myInnerWhitespaceShown = settings.isInnerWhitespaceShown();
      myTrailingWhitespaceShown = settings.isTrailingWhitespaceShown();
    }

    private void update(CharSequence chars, int lineStart, int lineEnd) {
      if (myWhitespaceShown
          && (myLeadingWhitespaceShown || myInnerWhitespaceShown || myTrailingWhitespaceShown)
          && !(myLeadingWhitespaceShown && myInnerWhitespaceShown && myTrailingWhitespaceShown)) {
        currentTrailingEdge = CharArrayUtil.shiftBackward(chars, lineStart, lineEnd - 1, WHITESPACE_CHARS) + 1;
        currentLeadingEdge = CharArrayUtil.shiftForward(chars, lineStart, currentTrailingEdge, WHITESPACE_CHARS);
      }
    }

    private boolean showWhitespaceAtOffset(int offset) {
      return myWhitespaceShown
             && (offset < currentLeadingEdge ? myLeadingWhitespaceShown :
                 offset >= currentTrailingEdge ? myTrailingWhitespaceShown :
                 myInnerWhitespaceShown);
    }
  }

  private interface XCorrector {
    float startX(int line);
    int lineWidth(int line, float x);
    int emptyTextX();
    int minX(int startLine, int endLine);
    int maxX(int startLine, int endLine);
    int lineSeparatorStart(int minX);
    int lineSeparatorEnd(int maxX);
    float singleLineBorderStart(float x);
    float singleLineBorderEnd(float x);
    int marginX();
    int marginX(float shift);
    List<Integer> softMarginsX();

    @NotNull
    default XCorrector align(@NotNull EditorView view) {
      boolean rightAligned = view.getEditor().isRightAligned();
      return rightAligned && this instanceof RightAligned || !rightAligned && this instanceof LeftAligned ? this : create(view);
    }

    @NotNull
    static XCorrector create(@NotNull EditorView view) {
      return view.getEditor().isRightAligned() ? new RightAligned(view) : new LeftAligned(view);
    }

    class LeftAligned implements XCorrector {
      private final EditorView myView;

      private LeftAligned(@NotNull EditorView view) {
        myView = view;
      }

      @Override
      public float startX(int line) {
        return myView.getInsets().left;
      }

      @Override
      public int emptyTextX() {
        return myView.getInsets().left;
      }

      @Override
      public int minX(int startLine, int endLine) {
        return myView.getInsets().left;
      }

      @Override
      public int maxX(int startLine, int endLine) {
        return minX(startLine, endLine) + myView.getMaxTextWidthInLineRange(startLine, endLine - 1) - 1;
      }

      @Override
      public float singleLineBorderStart(float x) {
        return x;
      }

      @Override
      public float singleLineBorderEnd(float x) {
        return x + 1;
      }

      @Override
      public int lineWidth(int line, float x) {
        return (int)x - myView.getInsets().left;
      }

      @Override
      public int lineSeparatorStart(int maxX) {
        return myView.getInsets().left;
      }

      @Override
      public int lineSeparatorEnd(int maxX) {
        return isMarginShown(myView.getEditor()) ? Math.min(marginX(), maxX) : maxX;
      }

      @Override
      public int marginX() {
        EditorImpl editor = myView.getEditor();
        return (int) (myView.getInsets().left + editor.getSettings().getRightMargin(editor.getProject()) * myView.getPlainSpaceWidth());
      }

      @Override
      public int marginX(float shift) {
        return marginX() + (int)shift;
      }

      @Override
      public List<Integer> softMarginsX() {
        List<Integer> margins = myView.getEditor().getSettings().getSoftMargins();
        List<Integer> result = new ArrayList<>(margins.size());
        for (Integer margin : margins) {
          result.add((int)(myView.getInsets().left + margin * myView.getPlainSpaceWidth()));
        }
        return result;
      }
    }

    class RightAligned implements XCorrector {
      private final EditorView myView;

      private RightAligned(@NotNull EditorView view) {
        myView = view;
      }

      @Override
      public float startX(int line) {
        return myView.getRightAlignmentLineStartX(line);
      }

      @Override
      public int lineWidth(int line, float x) {
        return (int)(x - myView.getRightAlignmentLineStartX(line));
      }

      @Override
      public int emptyTextX() {
        return myView.getRightAlignmentMarginX();
      }

      @Override
      public int minX(int startLine, int endLine) {
        return myView.getRightAlignmentMarginX() - myView.getMaxTextWidthInLineRange(startLine, endLine - 1) - 1;
      }

      @Override
      public int maxX(int startLine, int endLine) {
        return myView.getRightAlignmentMarginX() - 1;
      }

      @Override
      public float singleLineBorderStart(float x) {
        return x - 1;
      }

      @Override
      public float singleLineBorderEnd(float x) {
        return x;
      }

      @Override
      public int lineSeparatorStart(int minX) {
        return isMarginShown(myView.getEditor()) ? Math.max(marginX(), minX) : minX;
      }

      @Override
      public int lineSeparatorEnd(int maxX) {
        return maxX;
      }

      @Override
      public int marginX() {
        EditorImpl editor = myView.getEditor();
        return (int) (myView.getRightAlignmentMarginX() -
                      editor.getSettings().getRightMargin(editor.getProject()) * myView.getPlainSpaceWidth());
      }

      @Override
      public int marginX(float shift) {
        return marginX() - (int)shift;
      }

      @Override
      public List<Integer> softMarginsX() {
        List<Integer> margins = myView.getEditor().getSettings().getSoftMargins();
        List<Integer> result = new ArrayList<>(margins.size());
        for (Integer margin : margins) {
          result.add((int)(myView.getRightAlignmentMarginX() - margin * myView.getPlainSpaceWidth()));
        }
        return result;
      }
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
There's so much more going on at Lost River Cave. Check out the full calendar of upcoming events.
Is the Cave Open Year Round?
Lost River Cave is open year round, but does close for Thanksgiving Day, Christmas Eve, Christmas Day, New Year's Day and closes at noon on New Year's Eve.
Lost River Cave operates on Central Standard Time. Please see our Cave Tours page or Zipline Tours page for hours of operation.
How Often are Tours?
Tours start at the top of every hour. Walk-in tickets are sold first come, first served each day. You can also reserve your Boat Tour or Zip Tour.
How Much are the Tours?
Please see our Boat Tour and Zip Tour page for detailed pricing.
How Long is the Boat Tour?
45 minutes – 20 minute walk into the valley, 25 minute ride on the boat.
How Long are the Zipline Tours?
Flying Squirrel zipline tours typically last about 1 hour. Lightening Bug zipline tours are 30 minutes.
What are the Participant Requirements for Zipline Tours?
Please see our Know Before You Go section on the Tours page.
Do I Need to Make a Reservation?
Online reservations can be made in advance to secure tour spots. Advance reservations must be made 4 hours prior to a given tour departure time.
Walk-in tour tickets are sold on a first come, first served basis. Be sure to purchase your tickets upon arrival at the park. Then, enjoy all the other activities on the grounds while you wait for your tour to begin.
Is There an Age Limit?
There is no age limit for the Cave Boat tour. Participants on the Flying Squirrel zipline must be at least 8 years old, participants on the Lightening Bug zipline must be between 3-10 years old.
How Can I Get Group Rates?
Special group rates are not offered during the summer. In the off season we do book groups of 20 or larger at a discount rate. Please contact Kate for more information at 270.393.0077.
How Cold is the Cave?
The cave maintains a year round temperature of 57 degrees. A light jacket may be suitable.
Can I Take a Stroller to the Cave?
You may use a stroller for the walking portion of the tour (first 20 minutes); however, it must be left at the entrance of the cave before boarding the boat.
Can I Bring My Pet?
Yes, pets are welcome inside the park, but are not allowed on the tours.
We do not have kennels for your pet. We do require that your pet be on a leash. Please do not leave your pet in the car during your tour in the summer, our parking lot gets very hot.
How Much Walking is Involved in the Boat Tour?
From the Visitor's Center to the mouth of the cave, via our treetop bridge, 1560 feet (or one-third mile), 30% slope paved road. There are a few steps at the entrance to the cave.
What Else is There to Do at Lost River Cave?
There are about 2.5 miles of nature trails to explore, featuring 3 blue holes, a spring and a diverse variety of urban wildlife habitats.
At the end of May, our butterfly habitat will be open for visitation.
The rock and mineral sluice, where visitors young and old can experience panning for precious minerals like in the old days.
Check out our upcoming events page for information on special events taking place at the park!
What Else is There to Do in the Area?
There are many great attractions in the Bowling Green area as well as surrounding counties. There are many beautiful show caves within 30 – 45 minutes driving of our cave. For more information, please visit these websites:
visitbgky.com
kentuckytourism.com
mammothcave.com
caveslakescorvettes.com
Is There Camping On-Site?
No. There is a KOA nearby along with Beech Bend Park Campground.
More information is available at visitbgky.com
Keep Me in the Know
Join the LRC family! Stay up to date on all the nature-centered happenings here on the park.


Oshman Family JCC: Community is Our Middle Name - Duration: 6 minutes, 18 seconds.
OFJCC Annual Benefit 2018 - Duration: 5 minutes, 39 seconds.
The OFJCC Leslie Family Preschool - Duration: 4 minutes, 15 seconds.
J-Camp at the OFJCC - Duration: 2 minutes, 40 seconds.
Building the Dream - Duration: 19 minutes.
OFJCC's Vision & Mission - Duration: 85 seconds.
Ever Wonder How the Crisis in Gaza Will End? - Duration: 1 hour, 26 minutes.
The Jewish American Paradox - Duration: 1 hour, 25 minutes.
OFJCC Annual Benefit 2019 - Duration: 5 minutes, 20 seconds.
Act Fully Mitzvah Day Video - Duration: 2 minutes, 9 seconds.
Zionism 3.0 (2018) - Breakout Session 2 The Punishment of Exile & The Blessing of Diasporta - Duration: 47 minutes.
Zionism 3.0 (2018) - Breakout Session 2 Text Study with Adam Mintz and Tova Hartman - Duration: 51 minutes.
Zionism 3.0 (2018) - Breakout Session 3 Showcasing Israel's Z3 Coalition - Duration: 1 hour, 6 minutes.
Zionism 3.0 (2018) - Breakout Session 3 Retro Tech Reuniting the Tribe - Duration: 1 hour.
Zionism 3.0 (2018) - Breakout Session 1 Does World Jewry Need a Lobbyist in Israel? - Duration: 1 hour, 10 minutes.


Ron and Denize have been involved with ChildFund since 2000. Their first involvement came when Ron undertook a strategic review of ChildFund in 2000, then joined the Board in 2004, succeeded David Taylor as Chair in 2008 and retired from the Board in 2013.
Ron and Denize live in Melbourne where Ron is Chief Executive of Vision Australia, a national for purpose organisation providing services to the vision impaired, a position he has held since early 2013. Prior to joining Vision Australia, Ron was for seven years Chief Executive of the Auckland based primary health company ProCare. Denize is a project manager specialising in the information technology sector.
Ron and Denize retain a deep interest in improving the health, education and living standards of children in developing nations through their role as Members of ChildFund New Zealand.


Enter to win tickets for 102 Indianapolis 500 at the Indianapolis Motor Speedway for Sunday, May 27.
Winner will be drawn Tuesday, May 22nd.
Must be 18 to register/win. See complete contest rules here.
Please provide the city you're listening from.
Please enter the validation text in the empty box.
Sorry, the text you entered was incorrect. Please try again. You must enter the text you see into the empty box to proceed.


Pork tenderloin is often overlooked when it's time to fire up the grill. That's too bad, because it's an excellent source of lean protein that'll show your muscles some love—and it's less likely to dry out on the grill. To feast on safer meat, marinate it in beer for at least 4 hours (to avoid creating harmful compounds), tenderize the meat, and lay the foundation for a stellar finishing sauce.
Place pork in a large shallow container. In a bowl, whisk together beer, lime juice, olive oil, garlic, thyme, cumin, salt, black pepper, and cayenne. Add marinade to pork, turn meat to coat, cover, and marinate in refrigerator for 4 hours or more.
Remove pork from marinade, letting excess drip off. Reserve marinade. Grill pork for about 12 minutes, turning a couple times, until it reaches an internal temperature of 145°F. Let meat rest for 5 minutes before slicing.
Place reserved marinade in a saucepan, bring to a boil and simmer over medium-high heat until reduced by nearly a half, about 5 minutes. Serve pork topped with beer sauce and parsley.


BILOXI, Miss. – The Mississippi Department of Marine Resources (MDMR) Marine Patrol received a call at 8:58 a.m. today reporting that a group of people had been camping on Deer Island overnight and had not been heard from. At 9:32 a.m., Marine Patrol arrived on Deer Island and found the campers--seven children and nine adults--on the south side, east end of the island.
Marine Patrol Officers Paul Elmore and Mike Strickland brought the seven children, whose ages ranged from eight to 13, to Biloxi Small Craft Harbor where Marine Patrol Officer Rocky Southern and American Medical Response were on site. The nine adult campers followed in a camper's personal boat. Fourteen of the 16 campers were taken to Biloxi Regional and Ocean Springs hospitals for evaluation. All but one of the campers have been released.
Proper supply is an momentous part of leading a healthy lifestyle. How can medicines help us? Nowadays, online drugstores fill hundreds of thousands of online prescriptions worldwide. Many individuals think about buy levitra online. What is the most great information you probably know consider about generic levitra online? There are varied other questions the drug. Certainly levitra is an extremely complicated matter. Some drugstores describe it as levitra online pharmacy. However to diagnose a man's erectile problem, the heartiness care producer likely will begin with a thorough history of signs. Preparatory to ordering Cialis or other medicine, tell your physician if you are allergic to it. Druds may contain some other ingredients, which can cause other problems.


text:
He earned his net worth from being the vocalist of the band Limp Bizkit. He also does acting and directing jobs in the entertainment industry. Sammy Siegler took over drumming duties for the band for much of the album. And how much money does Fred Durst earn?
Fred Durst net worth: Fred Durst is Rapper from Jacksonville, FL. View full biography and discover how much Fred Durst is worth today. He spent his formative years playing in a number of local bands.
How old is fred durst
As a renowned musician, he is a guitarist, rapper, singer, and songwriter. Fred Durst is a famous American actor, film director, and businessperson. The American musician-director has an estimated net worth of $145 million. The ranking is significant for many Fred fans, who have been waiting for his triumphant return to the glory days for what. BUSINESS A d33 at University of Nairobi. He worked for many bands in Jacksonville, Florida. How many children does Fred Durst have?
Play Dead, Sorry, Haters, and many other movies and shows. Value $$$$ FRED DURST AND CARMEN ELECTRA Suggested Title Three. Discover how much Fred Durst is worth today, view full biography, facts, and family life.
Fred durst net worth
With Fred Durst on vocals, Wes Borland on guitar, Sam Rivers on bass. Limp Bizkit frontman Fred Durst has officially settled his divorce from wife number three. Durst is best known as the vocalist of the American rap-rock band Limp Bizkit.
William Frederick Durst is an American musician and film director. Fred Durst Net Worth, Wife or Spouse and Other Facts You Need To Know. Despite the scandals, Limp Bizkit has also garnered much critical. Wondering how much Fred Durst is worth?
Britney Spears Net: Worth Read on to find out how this sensation earned her. The album that brought us "Bodies" is worth a spot on this list and more. Rare photograph of Fred Durst making obscene hand gesture at Summer Sanitarium ON MARCH 21. How much does Fred Durst worth? Eat You Alive," was the real Fred Durst or one of his many known body doubles. Asked about Woodstock 99, Fred Durst said, "Limp Bizkit is an easy target.
Fred Durst, Wes Borland, Sam Rivers, John Otto and DJ Lethal? For this question we spent 4 hours on research (Wikipedia, Youtube, we read books in libraries, etc) to. Limp Bizkit, asking his son if he finds any value in the hard-driving beats. According to The Hollywood Reporter, the new Fred Durst -directed movie "The Fanatic" flopped spectacularly in theaters this weekend. Moose has so far made reference to needing to poop, and wanting a strawberry. Hows that Fred Durst direction looking? Fred Durst has earned his net worth through his acting roles in films and television.
And indeed there are so so many occasions when she courted the press.
Bobby marx son of barbara sinatra
How old is ralph sampson
How to Use AVG Antivirus security software Software
The Benefits of Shopping for Affordable Papers Re-wind
Avast Anti Malware Software
How did robert kraft make money
Easy Payback Together With Online Installment Loans


Events, past and upcoming are meant as catalysts to trigger your imaginations, learn new things, develop industry specific skills, network and grow together and the workshops to get your hands dirty, do things in real-time, make and break , bring-out the creator in you.
A one of its kind UX hack-a-thon where startups post a challenge around a user goal they want to achieve and contributors submit their personalized solutions of what can be tweaked/improved to get closer to the goal.
It is meant for B2C Startups looking forward to get quick improvements, visibility & potential young talent. It is also meant for FRESHERS AND PROFESSIONALS who would like to Showcase their UX and Product Management skills by giving quick solutions to startup problems. And get rewarded as well!
"Is it the cubicle which has to be broken or the ice?"
Unboxed Co-working presents "Overtime-Time over", an event where the eternal battle of Employer v/s Employee will be brought to center stage.
Your opinion can transform your work space dynamics.
Friday, 3rd march, 2017, 5 pm onward.
Join us. Take responsibility. Create a better workplace.
UnBoxed Coworking in collaboration with MBASTAR is organising a Digital Marketing 101 Workshop on Friday, Oct. 21st, 2016 from 5:00 PM to 7:00 PM, which will be conducted by Sunil Barsaiyan, Digital Marketing Lead at Amity Education Group. All the Entrepreneurs, Employers, Professionals, Employees, Students, Freelancers, soon-to-be Professionals should definitely attend this workshop.
A Legal session to help you understand the crucial legalities involved in creating and running a successful venture.
What if you were told that sustain development had very little to do with what the world is focusing on these days – Renewable Energy, green building, clean energy, smart cities and alternative fuels?
What if you were told that the language you spoke, the food you ate, and the clothes you wore, influence your impact on the climate more than anything else does?
What if the stories and songs you heard in your childhood determine whether you would grow up to protect the environment, or destroy it through sheer apathy?
"Speak Up" at Unboxed is a platform to share what you do, think or believe. The idea to provide a democratic way of creating a free flow of ideas among all coworkers at Unboxed.
Occasions are truly celebrated when all the people of the community take part in the process. Celebrations and events are not about any certain occasion rather the participatory effort of the people in itself becomes a life size occasion.
Participation and involvement at community level is rare yet essential. In urban centres and cities, people have become individualistic yet everyone yearns for community life. In such events communities are built and individual recognitions are formed.


Words I often have to repeat to myself. When chaos comes or disaster strikes, my default setting is, "FIX IT!" I think that, as Moms, we feel the like it's our job. Like robots- 'fix it. fix it. fix it.' It helps us feel like we're in control.
But, there are some things that we have zero control over. Our health, and the health of our children are big ones. No matter what we do, it's just not in our hands.
I've been battling some health issues for the past few weeks, and I've nearly driven myself insane trying to fix everything. It's like trying to treat only the symptoms and ignoring what's causing them. It NEVER works. Everything snowballs until you have an even bigger problem.
Then when we can't hold it all together, our pal Mom guilt steps in. Because, when Mom is down for the count, everything quickly unravels. It's crazy how fast the laundry and dishes pile up, how dusty the floors get. It begins to weigh on me and I panic.
But, guess what? My boys couldn't care less if the house is messy. They want a healthy Momma. And there's no way you're going to get better if you're not resting.
We need to CHILL OUT. STOP stressing. Take care of ourselves. And if we feel like we have to fix it all- turn it over to the One who actually can. HE'S got this!
Yes, hard times will come. Sickness. Pain. Money troubles. So many things that we have no control over. But, we just have to trust and believe that He's working it all together for His good.
Be still and give it to Him. He will fight for us.


So what's coming this week in v1.34?
Your feedback has been heard! 'Neo Tokyo' is back, and we've redesigned it as a Standard Arena. We left the scenery untouched to maintain that futuristic metropolis look, while removing the parallel ramps on either side of the goals. 'Neo Tokyo' will be returning to all Playlists, including Competitive, and will be available in Private matches as well.
For those who love the original 'Neo Tokyo,' we have you covered! We are keeping the original Arena in Rocket League, but with a new name: 'Tokyo Underpass.' This new name/old look Arena will be available in offline and Private matches only for now. 'Tokyo Underpass' is also replacing the original 'Underpass' map, which will be removed from the Rocket Labs rotation starting with this update.
A New Battle-Car Enters the Arena!
Available only as a limited-drop inside our next Crate (more on that below), Mantis is a car many of you have been asking about since our Batman v Superman DLC update in 2016. Mantis is fully customizable and has an all-new look, but it uses the same low, flat hitbox, and turn radius as the Batmobile. We're also including six new Decals with Mantis: Arrowhead, Battleworn, Kaze, Maxx, Roasted, and Uproar. Here's a link for the 4K version of the image above!
The new Nitro Crate includes the Mantis Battle-Car mentioned above, along with limited-drop Wheels, Decals, Rocket Trails, and Black Market customizations. See below for a sneak peek at some of the included items!
This week's update also includes the framework for in-game items tied to our Zag Toys Mini Pull-Back Racers! Once the blind-bag toys start hitting store shelves in June, Rare and Very Rare Pull-Back Racers will include unique codes redeemable for a set of in-game items. You can find out more about the Pull-Back Racers in our blog post from last week.
Curious to see what else is going into v1.34? We'll have full patch notes up on the blog before release on Wednesday. Stay tuned!


This page contains answers to general frequently asked questions. There are product specific FAQ on most of the pages throughout this site, but these are the most common general questions we are asked. As always, if you have a question and don't see the answer here, you can use the Live Support chat link, visit the Contact Us page to send an e-mail or call us for assistance.
No, any product can be ordered in any quantity.
Yes, quantity discounts are available on most products and will be shown in the shopping cart. On display hardware, quantity prices are shown at the top of the product detail page for reference, and will also be applied when the item is added to your shopping cart. The quanity discounts on some product options will not appear on the product page, but will also be shown in the shopping cart.
For most print jobs, the normal production time is 4 business days, which is 2-3 days from the proof approval for most orders. Larger orders can take longer, and there are some products we offer that have longer production times. Rush service is available for most products that reduces the production time, and a 1 day rush is also available for select items. During the checkout process in the shipping method section, the estimated delivery date will be shown based on what you're ordering, as well as the shipping method and any rush services you have selected. There is also place to indicate if you have a specific due date, and we always recommend entering the date you need your order if you have any particular deadline. When you specify your due date, our system will figure out the least expensive combination of shipping and rush service options to get your order to you by your deadline and give you the option to accept those or specifiy different options. You will not be able to continue with options selected that will not meet your due date to prevent any errors from occurring that cause your job to be late. Even if you don't need a rush or faster shipping and the estimated delivery date is in plenty of time for your deadline, it's beneficial for us to know your due date in case anything goes wrong with your order that will cause a delay. Because the estimated delivery date shown is not a guarantee, if you have not specified a due date and a delay occurs, we won't know to contact you to make arrangements for different shipping methods, etc.
Orders for display hardware without printing that are in stock will often ship the same day or the next day if ordered by 2pm Mountain Time. This is dependent on the product ordered as some products are manufactured to order and take 1 or 2 days to ship. Some trade show displays are custom built and can take even longer, so check in the product description for this information, or look at the estimated delivery date during checkout to see when to expect your order to arrive.
Can I place my order via e-mail or over the phone?
We prefer that orders be placed on our website. We have spent a significant amount of time and money to create a system that is easy for the customer, increases our efficiency, speeds the order and printing process and eliminates data entry errors. This saves on our operating costs, which is part of the reason we are able to offer such excellent pricing. However, we do realize that sometimes it's not possible for customers to place an order online for various reasons. While many of our competitors will only accept online orders, we wanted to be more accommodating to our customers, so we do allow phone orders. This way the customer can catch any errors before the order is processed. Because of this, phone orders are slower to process so there is typically a one day delay compared to online orders, so be sure to factor that into your planning in order to meet any deadline you may have. We have also found that errors are much more likely with phone orders, so to help prevent that, we require that confirmation be sent via e-mail for verification before the order will proceed, and that can cause further delays if we don't receive timely approval.
E-mail orders are treated like phone orders. They rarely contain all the information we need, including payment info that is not safe to send via e-mail, so the process for e-mail orders is the same as phone orders, and the same limitations apply.
We are more than happy to help walk anyone through the order process if they are having difficulty so that they can avoid any delays and enjoy the benefits of having their order placed on the website, such as order and shipping confirmation, order tracking, order history, and the ability to reorder products.
Are there are any hidden fees or additional costs when I order?
We don't have any hidden costs such as RIP fees or set up charges. These are just hidden fees to increase the cost of your job in a way that makes printing prices look less expensive than they really are. As long as you provide print ready files, there are no additional charges related to printing your job. We do charge set up fees for fixing any problems with customer files, or if the files are not set up at the correct size and ready to print. In these cases we always contact the customer to see if they would like to fix the issues themselves, or provide a quote for what it would cost for us to fix the files so they are ready to print. Any other costs associated with your order would be selected as options so you always know what you are paying for and have the choice to avoid any options that would add to the cost of your order.
There is also a $10 service charge for phone orders. See the question above about phone orders for an explanation of that charge.
What kinds of files do you accept?
We can accept most graphics files and also native files from professional layout programs such as QuarkXpress and InDesign. For our complete file specifications, visit the File Specifications page.
What resolution does my file need to be?
This varies according to the type of print you are ordering, but we recommend 200-300 dpi at actual size for giclee prints, and 100-150 dpi at actual size for general large format prints. For our complete file specifications, visit the File Specifications page.
If I know what I want, can you design my graphic for me?
Yes we can, even if you don't know what you want. But, since all our design time is charged by the hour, if you already know what you want your design to look like, it can save quite a bit of time, and therefore cost a lot less than if we have to come up with the concept and the design. So, if you know what information you want in your design, and have any logos or photos that you want to use, send them to us with your order, indicate you need design work when the option appears, and we will contact you to discuss it and give you a cost estimate. Once we create your design, we'll send you an electronic proof for approval prior to printing.
We charge $75 per hour for design time, but the amount of time it will take, and therefore the cost, depends on several factors. As we explained in the previous question, if you already know what you want, and can send us any necessary logos, photos, etc., the design cost could be as little as $15-$20. If you have no idea and want us to come up with concepts and designs, it can cost hundreds of dollars. In our experience, most people have an idea of what they want, and if we provide alternatives, they will almost always come back to what they had in mind in the first place, so you should always tell us your ideas. It will save time and money, and that's always a good thing.
What is the color of the printing material, can I choose a different color of material?
All printing materials themselves are generally white, so any color other than white needs to be created as part of the design that is printed. If you want a banner with a red background and white letters, we are basically printing the red background and leaving the letters unprinted so the white of the banner material shows through. Just like printing on paper with a desktop printer. Some materials are clear, so unprinted areas can be left clear or printed with some density of white to create different effects.
How many colors can I use in my design, is there a charge per color?
You may use any number of colors in your designs. Since all our printing is full color digital, there is no limit, and no extra charge, for any number of colors in your design. Anything from black and white to full color photography all costs the same amount, so you are free to create anything you can imagine and the price is the same.
How can I get a sample of a particular material to see how it prints before I order?
We have printed samples of most every material we offer. Go to the Contact Us page and fill out the form with your shipping address, and tell us which samples you would like. The samples will ship via US Mail, but if you need them in a hurry, you can also provide a UPS account and we will ship them to you however quickly you like.
Do you have templates for designing graphics for your displays?
Yes, there are templates available for most of our displays including banner stands, trade show displays, and outdoor displays. Check the page for the individual product and look at the Specs & Templates tab to find templates and instructions where available.
For printed items, such as window graphics, floor decals, and wall murals, installation instructions for the particular printing material you ordered can be found in the Instructions tab on the product page. General instructions are included with the print itself, but it's always a good idea to review the product specific instructions before installing your graphics.
For display hardware, instructions are typically included with the display, but the information can also be found in the Instructions tab on the product page. For some displays, there will also be video instructions available as well.
How long does shipping take and what are the shipping costs?
Most printing orders ship from Utah using the shipping method you choose during the checkout process. We offer a few displays were the graphics are printed by the display manufacturer to ensure a proper fit, and those would ship directly from their facility. If you choose ground shipping during checkout, it will show the number of days that ground shipping will take to reach you. The estimated delivery time is also shown during checkout in the shipping method section so that you can see when your order should be delivered and can choose a different shipping method if necessary.
The shipping cost for most items will be displayed next to each service when you choose the shipping method. For some items, the shipping cost will not be shown, so for those items, shipping will be calculated manually and you will be contacted with the shipping cost before you are charged for the order. Some items that fall into this category are large trade show displays that are too large to ship via UPS. If you aren't given shipping costs for your order, and need to find out the cost before placing your order, you can contact us and we can provide an estimate in advance.
How do you ship and can I use my own shipping account?
We ship using UPS, and any available UPS service to your location can be selected as a shipping method. During the checkout process, you can also choose to use your own UPS account for shipping. We do not ship via USPS or FedEx, so you cannot use your own FedEx account for shipping costs. Some displays drop ship directly from the manufacturer, and we do not have any control over what carrier they use, so some of them may ship your order via FedEx, but we still cannot charge FedEx shipping to your account in those cases.
Our complete return policy is listed on our Customer Service page, but in general, all our printing is custom and can't be returned, but we would always replace any defective graphics at no charge. Most display hardware is returnable if unused, as determined by the manufacturer, but most have some kind of restocking fee. A few items are not returnable at all, and that information will appear with the product description and in the product comparisons.


Families with individuals who have special needs are invited to enjoy a quiet, relaxing evening after regu-lar operating hours of Centennial Beach. The shallow end and slide will be open Sundays from 6:30-8:00 p.m. on June 16, 30 and July 14, 28. No registration is required. Cost is $3.00/person at the door or you may apply your membership toward entry.