text:
+++
Title = "Location"
Type = "event"
Description = "Location for devopsdays Victoria 2019"
+++

Located in the heart of downtown Victoria, this years event is being held at the Victoria Conference Centre.

It is located at:

720 Douglas Street

Victoria, BC V8W 3M7

Canada

redpajama_set_name: RedPajamaGithub


text:
namespace dst
{

  class IntensityImageNode : public pipeline2::ComputeNode
  {
  public:
    pipeline2::Outlet<cv::Mat1b> outlet_;
    IntensityImageNode(pipeline2::Outlet<cv::Mat3b>* color_otl);

  protected:
    pipeline2::Outlet<cv::Mat3b>* color_otl_;
    cv::Mat1b intensity_;

    void _compute();
    void _display() const;
    void _flush();
    std::string _getName() const;
  };

  class HSVImageNode : public pipeline2::ComputeNode
  {
  public:
    pipeline2::Outlet<cv::Mat3f> outlet_;
    HSVImageNode(pipeline2::Outlet<cv::Mat3b>* rgb_otl);

  protected:
    pipeline2::Outlet<cv::Mat3b>* rgb_otl_;
    cv::Mat3f hsv_;
    cv::Mat3f rgb3f_;

    void _compute();
    void _display() const;
    void _flush();
    std::string _getName() const;
  };

  class IntegralImageNode : public pipeline2::ComputeNode
  {
  public:
    pipeline2::Outlet<cv::Mat1i> outlet_;

    IntegralImageNode(pipeline2::Outlet<cv::Mat1b>* intensity_otl);

  protected:
    pipeline2::Outlet<cv::Mat1b>* intensity_otl_;
    cv::Mat1i integral_;

    void _compute();
    void _display() const;
    void _flush();
    std::string _getName() const;
  };

}

#endif // IMAGE_PROCESSING_NODES_H


text:
// Based on .NET Source code

namespace System.Text
{
    internal static class StringBuilderCache
    {
        [ThreadStatic]
        static StringBuilder? cachedInstance;

        public static StringBuilder Aquire()
        {
            var sb = cachedInstance;

            if (sb is null)
            {
                return new StringBuilder(100);
            }

            sb.Length = 0;

            cachedInstance = null;

            return sb;
        }

        public static string ExtractAndRelease(StringBuilder sb)
        {
            var text = sb.ToString();

            cachedInstance = sb;

            return text;
        }
    }
}


text:
<?php
use yii\helpers\Url;
?>

<?= Yii::t('forms','visit_our_show_room') ?>

                        <form class="f-smr xhr-form" id="smr_form" method="POST" action="<?= Url::to(['/api/forms/add']) ?>" data-modal-success="thanks" data-modal-err="server-error">

                                <?= Yii::t('forms','your_name') ?>
                                <input type="text" class="g-input g-input--simple" name="name" id="smr_name" placeholder="<?= Yii::t('forms','your_name') ?>">

                                <?= Yii::t('forms','phone_number') ?> *
                                <input type="phone" class="g-input g-input--simple" name="phone" id="smr_phone" placeholder="<?= Yii::t('forms','phone_number') ?> *" required="required" aria-required="true">

                                <?= Yii::t('forms','your_email') ?>
                                <input type="email" class="g-input g-input--simple" name="email" id="smr_email" placeholder="<?= Yii::t('forms','your_email') ?>">

                                <input type="hidden" hidden name="form_type" value="show-room">
                                <input name="_csrf" value="<?=Yii::$app->request->getCsrfToken()?>" type="hidden">

                                    <button type="submit" class="btn btn--colored btn--normal"><?= Yii::t('forms','send') ?></button>

                        </form>


text:
package si.ncode.common;

import android.app.Application;
import android.test.ApplicationTestCase;

/**
 * Testing Fundamentals
 */
public class ApplicationTest extends ApplicationTestCase<Application> {
    public ApplicationTest() {
        super(Application.class);
    }
}


text:
package org.gradle.internal.resource.transport.http;

import org.gradle.authentication.http.BasicAuthentication;
import org.gradle.authentication.http.DigestAuthentication;
import org.gradle.internal.authentication.DefaultBasicAuthentication;
import org.gradle.internal.authentication.DefaultDigestAuthentication;
import org.gradle.internal.authentication.AuthenticationSchemeRegistry;
import org.gradle.internal.resource.connector.ResourceConnectorFactory;
import org.gradle.internal.service.ServiceRegistration;
import org.gradle.internal.service.scopes.PluginServiceRegistry;

public class HttpResourcesPluginServiceRegistry implements PluginServiceRegistry {
    public void registerGlobalServices(ServiceRegistration registration) {
        registration.addProvider(new GlobalScopeServices());
    }

    public void registerBuildSessionServices(ServiceRegistration registration) {
    }

    public void registerBuildServices(ServiceRegistration registration) {
        registration.addProvider(new AuthenticationSchemeAction());
    }

    public void registerGradleServices(ServiceRegistration registration) {
    }

    public void registerProjectServices(ServiceRegistration registration) {
    }

    private static class GlobalScopeServices {
        ResourceConnectorFactory createHttpConnectorFactory() {
            return new HttpConnectorFactory();
        }
    }

    private static class AuthenticationSchemeAction {
        public void configure(ServiceRegistration registration, AuthenticationSchemeRegistry authenticationSchemeRegistry) {
            authenticationSchemeRegistry.registerScheme(BasicAuthentication.class, DefaultBasicAuthentication.class);
            authenticationSchemeRegistry.registerScheme(DigestAuthentication.class, DefaultDigestAuthentication.class);
        }
    }
}


text:
package com.google.android.exoplayer2.source;

import android.net.Uri;
import android.os.Handler;
import com.google.android.exoplayer2.C;
import com.google.android.exoplayer2.Format;
import com.google.android.exoplayer2.FormatHolder;
import com.google.android.exoplayer2.decoder.DecoderInputBuffer;
import com.google.android.exoplayer2.extractor.DefaultExtractorInput;
import com.google.android.exoplayer2.extractor.DefaultTrackOutput;
import com.google.android.exoplayer2.extractor.DefaultTrackOutput.UpstreamFormatChangedListener;
import com.google.android.exoplayer2.extractor.Extractor;
import com.google.android.exoplayer2.extractor.ExtractorInput;
import com.google.android.exoplayer2.extractor.ExtractorOutput;
import com.google.android.exoplayer2.extractor.PositionHolder;
import com.google.android.exoplayer2.extractor.SeekMap;
import com.google.android.exoplayer2.extractor.TrackOutput;
import com.google.android.exoplayer2.trackselection.TrackSelection;
import com.google.android.exoplayer2.upstream.Allocator;
import com.google.android.exoplayer2.upstream.DataSource;
import com.google.android.exoplayer2.upstream.DataSpec;
import com.google.android.exoplayer2.upstream.Loader;
import com.google.android.exoplayer2.upstream.Loader.Loadable;
import com.google.android.exoplayer2.util.Assertions;
import com.google.android.exoplayer2.util.ConditionVariable;
import com.google.android.exoplayer2.util.Util;
import java.io.EOFException;
import java.io.IOException;
import java.util.Arrays;

/**
 * A {@link MediaPeriod} that extracts data using an {@link Extractor}.
 */
/* package */ final class ExtractorMediaPeriod implements MediaPeriod, ExtractorOutput,
    Loader.Callback<ExtractorMediaPeriod.ExtractingLoadable>, UpstreamFormatChangedListener {

  /**
   * When the source's duration is unknown, it is calculated by adding this value to the largest
   * sample timestamp seen when buffering completes.
   */
  private static final long DEFAULT_LAST_SAMPLE_DURATION_US = 10000;

  private final Uri uri;
  private final DataSource dataSource;
  private final int minLoadableRetryCount;
  private final Handler eventHandler;
  private final ExtractorMediaSource.EventListener eventListener;
  private final MediaSource.Listener sourceListener;
  private final Callback callback;
  private final Allocator allocator;
  private final Loader loader;
  private final ExtractorHolder extractorHolder;
  private final ConditionVariable loadCondition;

  private SeekMap seekMap;
  private boolean tracksBuilt;
  private boolean prepared;

  private boolean seenFirstTrackSelection;
  private boolean notifyReset;
  private int enabledTrackCount;
  private DefaultTrackOutput[] sampleQueues;
  private TrackGroupArray tracks;
  private long durationUs;
  private boolean[] trackEnabledStates;
  private long length;

  private long lastSeekPositionUs;
  private long pendingResetPositionUs;

  private int extractedSamplesCountAtStartOfLoad;
  private boolean loadingFinished;

  /**
   * @param uri The {@link Uri} of the media stream.
   * @param dataSource The data source to read the media.
   * @param extractors The extractors to use to read the data source.
   * @param minLoadableRetryCount The minimum number of times to retry if a loading error occurs.
   * @param eventHandler A handler for events. May be null if delivery of events is not required.
   * @param eventListener A listener of events. May be null if delivery of events is not required.
   * @param sourceListener A listener to notify when the timeline has been loaded.
   * @param callback A callback to receive updates from the period.
   * @param allocator An {@link Allocator} from which to obtain media buffer allocations.
   */
  public ExtractorMediaPeriod(Uri uri, DataSource dataSource, Extractor[] extractors,
      int minLoadableRetryCount, Handler eventHandler,
      ExtractorMediaSource.EventListener eventListener, MediaSource.Listener sourceListener,
      Callback callback, Allocator allocator) {
    this.uri = uri;
    this.dataSource = dataSource;
    this.minLoadableRetryCount = minLoadableRetryCount;
    this.eventHandler = eventHandler;
    this.eventListener = eventListener;
    this.sourceListener = sourceListener;
    this.callback = callback;
    this.allocator = allocator;
    loader = new Loader("Loader:ExtractorMediaPeriod");
    extractorHolder = new ExtractorHolder(extractors, this);
    loadCondition = new ConditionVariable();

    pendingResetPositionUs = C.TIME_UNSET;
    sampleQueues = new DefaultTrackOutput[0];
    length = C.LENGTH_UNSET;
    loadCondition.open();
    startLoading();
  }

  public void release() {
    final ExtractorHolder extractorHolder = this.extractorHolder;
    loader.release(new Runnable() {
      @Override
      public void run() {
        extractorHolder.release();
      }
    });
    for (DefaultTrackOutput sampleQueue : sampleQueues) {
      sampleQueue.disable();
    }
  }

  @Override
  public void maybeThrowPrepareError() throws IOException {
    maybeThrowError();
  }

  @Override
  public TrackGroupArray getTrackGroups() {
    return tracks;
  }

  @Override
  public long selectTracks(TrackSelection[] selections, boolean[] mayRetainStreamFlags,
      SampleStream[] streams, boolean[] streamResetFlags, long positionUs) {
    Assertions.checkState(prepared);
    // Disable old tracks.
    for (int i = 0; i < selections.length; i++) {
      if (streams[i] != null && (selections[i] == null || !mayRetainStreamFlags[i])) {
        int track = ((SampleStreamImpl) streams[i]).track;
        Assertions.checkState(trackEnabledStates[track]);
        enabledTrackCount--;
        trackEnabledStates[track] = false;
        sampleQueues[track].disable();
        streams[i] = null;
      }
    }
    // Enable new tracks.
    boolean selectedNewTracks = false;
    for (int i = 0; i < selections.length; i++) {
      if (streams[i] == null && selections[i] != null) {
        TrackSelection selection = selections[i];
        Assertions.checkState(selection.length() == 1);
        Assertions.checkState(selection.getIndexInTrackGroup(0) == 0);
        int track = tracks.indexOf(selection.getTrackGroup());
        Assertions.checkState(!trackEnabledStates[track]);
        enabledTrackCount++;
        trackEnabledStates[track] = true;
        streams[i] = new SampleStreamImpl(track);
        streamResetFlags[i] = true;
        selectedNewTracks = true;
      }
    }
    if (!seenFirstTrackSelection) {
      // At the time of the first track selection all queues will be enabled, so we need to disable
      // any that are no longer required.
      for (int i = 0; i < sampleQueues.length; i++) {
        if (!trackEnabledStates[i]) {
          sampleQueues[i].disable();
        }
      }
    }
    if (enabledTrackCount == 0) {
      notifyReset = false;
      if (loader.isLoading()) {
        loader.cancelLoading();
      }
    } else if (seenFirstTrackSelection ? selectedNewTracks : positionUs != 0) {
      positionUs = seekToUs(positionUs);
      // We'll need to reset renderers consuming from all streams due to the seek.
      for (int i = 0; i < streams.length; i++) {
        if (streams[i] != null) {
          streamResetFlags[i] = true;
        }
      }
    }
    seenFirstTrackSelection = true;
    return positionUs;
  }

  @Override
  public boolean continueLoading(long playbackPositionUs) {
    if (loadingFinished) {
      return false;
    }
    boolean continuedLoading = loadCondition.open();
    if (!loader.isLoading()) {
      startLoading();
      continuedLoading = true;
    }
    return continuedLoading;
  }

  @Override
  public long getNextLoadPositionUs() {
    return getBufferedPositionUs();
  }

  @Override
  public long readDiscontinuity() {
    if (notifyReset) {
      notifyReset = false;
      return lastSeekPositionUs;
    }
    return C.TIME_UNSET;
  }

  @Override
  public long getBufferedPositionUs() {
    if (loadingFinished) {
      return C.TIME_END_OF_SOURCE;
    } else if (isPendingReset()) {
      return pendingResetPositionUs;
    } else {
      long largestQueuedTimestampUs = getLargestQueuedTimestampUs();
      return largestQueuedTimestampUs == Long.MIN_VALUE ? lastSeekPositionUs
          : largestQueuedTimestampUs;
    }
  }

  @Override
  public long seekToUs(long positionUs) {
    // Treat all seeks into non-seekable media as being to t=0.
    positionUs = seekMap.isSeekable() ? positionUs : 0;
    lastSeekPositionUs = positionUs;
    // If we're not pending a reset, see if we can seek within the sample queues.
    boolean seekInsideBuffer = !isPendingReset();
    for (int i = 0; seekInsideBuffer && i < sampleQueues.length; i++) {
      if (trackEnabledStates[i]) {
        seekInsideBuffer = sampleQueues[i].skipToKeyframeBefore(positionUs);
      }
    }
    // If we failed to seek within the sample queues, we need to restart.
    if (!seekInsideBuffer) {
      pendingResetPositionUs = positionUs;
      loadingFinished = false;
      if (loader.isLoading()) {
        loader.cancelLoading();
      } else {
        for (int i = 0; i < sampleQueues.length; i++) {
          sampleQueues[i].reset(trackEnabledStates[i]);
        }
      }
    }
    notifyReset = false;
    return positionUs;
  }

  // SampleStream methods.

  /* package */ boolean isReady(int track) {
    return loadingFinished || (!isPendingReset() && !sampleQueues[track].isEmpty());
  }

  /* package */ void maybeThrowError() throws IOException {
    loader.maybeThrowError();
  }

  /* package */ int readData(int track, FormatHolder formatHolder, DecoderInputBuffer buffer) {
    if (notifyReset || isPendingReset()) {
      return C.RESULT_NOTHING_READ;
    }

    return sampleQueues[track].readData(formatHolder, buffer, loadingFinished, lastSeekPositionUs);
  }

  // Loader.Callback implementation.

  @Override
  public void onLoadCompleted(ExtractingLoadable loadable, long elapsedRealtimeMs,
      long loadDurationMs) {
    copyLengthFromLoader(loadable);
    loadingFinished = true;
    if (durationUs == C.TIME_UNSET) {
      long largestQueuedTimestampUs = getLargestQueuedTimestampUs();
      durationUs = largestQueuedTimestampUs == Long.MIN_VALUE ? 0
          : largestQueuedTimestampUs + DEFAULT_LAST_SAMPLE_DURATION_US;
      sourceListener.onSourceInfoRefreshed(
          new SinglePeriodTimeline(durationUs, seekMap.isSeekable()), null);
    }
  }

  @Override
  public void onLoadCanceled(ExtractingLoadable loadable, long elapsedRealtimeMs,
      long loadDurationMs, boolean released) {
    copyLengthFromLoader(loadable);
    if (!released && enabledTrackCount > 0) {
      for (int i = 0; i < sampleQueues.length; i++) {
        sampleQueues[i].reset(trackEnabledStates[i]);
      }
      callback.onContinueLoadingRequested(this);
    }
  }

  @Override
  public int onLoadError(ExtractingLoadable loadable, long elapsedRealtimeMs,
      long loadDurationMs, IOException error) {
    copyLengthFromLoader(loadable);
    notifyLoadError(error);
    if (isLoadableExceptionFatal(error)) {
      return Loader.DONT_RETRY_FATAL;
    }
    int extractedSamplesCount = getExtractedSamplesCount();
    boolean madeProgress = extractedSamplesCount > extractedSamplesCountAtStartOfLoad;
    configureRetry(loadable); // May reset the sample queues.
    extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();
    return madeProgress ? Loader.RETRY_RESET_ERROR_COUNT : Loader.RETRY;
  }

  // ExtractorOutput implementation.

  @Override
  public TrackOutput track(int id) {
    sampleQueues = Arrays.copyOf(sampleQueues, sampleQueues.length + 1);
    DefaultTrackOutput sampleQueue = new DefaultTrackOutput(allocator);
    sampleQueue.setUpstreamFormatChangeListener(this);
    sampleQueues[sampleQueues.length - 1] = sampleQueue;
    return sampleQueue;
  }

  @Override
  public void endTracks() {
    tracksBuilt = true;
    maybeFinishPrepare();
  }

  @Override
  public void seekMap(SeekMap seekMap) {
    this.seekMap = seekMap;
    maybeFinishPrepare();
  }

  // UpstreamFormatChangedListener implementation

  @Override
  public void onUpstreamFormatChanged(Format format) {
    maybeFinishPrepare();
  }

  // Internal methods.

  private void maybeFinishPrepare() {
    if (prepared || seekMap == null || !tracksBuilt) {
      return;
    }
    for (DefaultTrackOutput sampleQueue : sampleQueues) {
      if (sampleQueue.getUpstreamFormat() == null) {
        return;
      }
    }
    loadCondition.close();
    int trackCount = sampleQueues.length;
    TrackGroup[] trackArray = new TrackGroup[trackCount];
    trackEnabledStates = new boolean[trackCount];
    durationUs = seekMap.getDurationUs();
    for (int i = 0; i < trackCount; i++) {
      trackArray[i] = new TrackGroup(sampleQueues[i].getUpstreamFormat());
    }
    tracks = new TrackGroupArray(trackArray);
    prepared = true;
    sourceListener.onSourceInfoRefreshed(
        new SinglePeriodTimeline(durationUs, seekMap.isSeekable()), null);
    callback.onPrepared(this);
  }

  private void copyLengthFromLoader(ExtractingLoadable loadable) {
    if (length == C.LENGTH_UNSET) {
      length = loadable.length;
    }
  }

  private void startLoading() {
    ExtractingLoadable loadable = new ExtractingLoadable(uri, dataSource, extractorHolder,
        loadCondition);
    if (prepared) {
      Assertions.checkState(isPendingReset());
      if (durationUs != C.TIME_UNSET && pendingResetPositionUs >= durationUs) {
        loadingFinished = true;
        pendingResetPositionUs = C.TIME_UNSET;
        return;
      }
      loadable.setLoadPosition(seekMap.getPosition(pendingResetPositionUs));
      pendingResetPositionUs = C.TIME_UNSET;
    }
    extractedSamplesCountAtStartOfLoad = getExtractedSamplesCount();

    int minRetryCount = minLoadableRetryCount;
    if (minRetryCount == ExtractorMediaSource.MIN_RETRY_COUNT_DEFAULT_FOR_MEDIA) {
      // We assume on-demand before we're prepared.
      minRetryCount = !prepared || length != C.LENGTH_UNSET
          || (seekMap != null && seekMap.getDurationUs() != C.TIME_UNSET)
          ? ExtractorMediaSource.DEFAULT_MIN_LOADABLE_RETRY_COUNT_ON_DEMAND
          : ExtractorMediaSource.DEFAULT_MIN_LOADABLE_RETRY_COUNT_LIVE;
    }
    loader.startLoading(loadable, this, minRetryCount);
  }

  private void configureRetry(ExtractingLoadable loadable) {
    if (length != C.LENGTH_UNSET
        || (seekMap != null && seekMap.getDurationUs() != C.TIME_UNSET)) {
      // We're playing an on-demand stream. Resume the current loadable, which will
      // request data starting from the point it left off.
    } else {
      // We're playing a stream of unknown length and duration. Assume it's live, and
      // therefore that the data at the uri is a continuously shifting window of the latest
      // available media. For this case there's no way to continue loading from where a
      // previous load finished, so it's necessary to load from the start whenever commencing
      // a new load.
      lastSeekPositionUs = 0;
      notifyReset = prepared;
      for (int i = 0; i < sampleQueues.length; i++) {
        sampleQueues[i].reset(trackEnabledStates[i]);
      }
      loadable.setLoadPosition(0);
    }
  }

  private int getExtractedSamplesCount() {
    int extractedSamplesCount = 0;
    for (DefaultTrackOutput sampleQueue : sampleQueues) {
      extractedSamplesCount += sampleQueue.getWriteIndex();
    }
    return extractedSamplesCount;
  }

  private long getLargestQueuedTimestampUs() {
    long largestQueuedTimestampUs = Long.MIN_VALUE;
    for (DefaultTrackOutput sampleQueue : sampleQueues) {
      largestQueuedTimestampUs = Math.max(largestQueuedTimestampUs,
          sampleQueue.getLargestQueuedTimestampUs());
    }
    return largestQueuedTimestampUs;
  }

  private boolean isPendingReset() {
    return pendingResetPositionUs != C.TIME_UNSET;
  }

  private boolean isLoadableExceptionFatal(IOException e) {
    return e instanceof ExtractorMediaSource.UnrecognizedInputFormatException;
  }

  private void notifyLoadError(final IOException error) {
    if (eventHandler != null && eventListener != null) {
      eventHandler.post(new Runnable()  {
        @Override
        public void run() {
          eventListener.onLoadError(error);
        }
      });
    }
  }

  private final class SampleStreamImpl implements SampleStream {

    private final int track;

    public SampleStreamImpl(int track) {
      this.track = track;
    }

    @Override
    public boolean isReady() {
      return ExtractorMediaPeriod.this.isReady(track);
    }

    @Override
    public void maybeThrowError() throws IOException {
      ExtractorMediaPeriod.this.maybeThrowError();
    }

    @Override
    public int readData(FormatHolder formatHolder, DecoderInputBuffer buffer) {
      return ExtractorMediaPeriod.this.readData(track, formatHolder, buffer);
    }

    @Override
    public void skipToKeyframeBefore(long timeUs) {
      sampleQueues[track].skipToKeyframeBefore(timeUs);
    }

  }

  /**
   * Loads the media stream and extracts sample data from it.
   */
  /* package */ final class ExtractingLoadable implements Loadable {

    /**
     * The number of bytes that should be loaded between each each invocation of
     * {@link Callback#onContinueLoadingRequested(SequenceableLoader)}.
     */
    private static final int CONTINUE_LOADING_CHECK_INTERVAL_BYTES = 1024 * 1024;

    private final Uri uri;
    private final DataSource dataSource;
    private final ExtractorHolder extractorHolder;
    private final ConditionVariable loadCondition;
    private final PositionHolder positionHolder;

    private volatile boolean loadCanceled;

    private boolean pendingExtractorSeek;
    private long length;

    public ExtractingLoadable(Uri uri, DataSource dataSource, ExtractorHolder extractorHolder,
        ConditionVariable loadCondition) {
      this.uri = Assertions.checkNotNull(uri);
      this.dataSource = Assertions.checkNotNull(dataSource);
      this.extractorHolder = Assertions.checkNotNull(extractorHolder);
      this.loadCondition = loadCondition;
      this.positionHolder = new PositionHolder();
      this.pendingExtractorSeek = true;
      this.length = C.LENGTH_UNSET;
    }

    public void setLoadPosition(long position) {
      positionHolder.position = position;
      pendingExtractorSeek = true;
    }

    @Override
    public void cancelLoad() {
      loadCanceled = true;
    }

    @Override
    public boolean isLoadCanceled() {
      return loadCanceled;
    }

    @Override
    public void load() throws IOException, InterruptedException {
      int result = Extractor.RESULT_CONTINUE;
      while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
        ExtractorInput input = null;
        try {
          long position = positionHolder.position;
          length = dataSource.open(
              new DataSpec(uri, position, C.LENGTH_UNSET, Util.sha1(uri.toString())));
          if (length != C.LENGTH_UNSET) {
            length += position;
          }
          input = new DefaultExtractorInput(dataSource, position, length);
          Extractor extractor = extractorHolder.selectExtractor(input);
          if (pendingExtractorSeek) {
            extractor.seek(position);
            pendingExtractorSeek = false;
          }
          while (result == Extractor.RESULT_CONTINUE && !loadCanceled) {
            loadCondition.block();
            result = extractor.read(input, positionHolder);
            if (input.getPosition() > position + CONTINUE_LOADING_CHECK_INTERVAL_BYTES) {
              position = input.getPosition();
              loadCondition.close();
              callback.onContinueLoadingRequested(ExtractorMediaPeriod.this);
            }
          }
        } finally {
          if (result == Extractor.RESULT_SEEK) {
            result = Extractor.RESULT_CONTINUE;
          } else if (input != null) {
            positionHolder.position = input.getPosition();
          }
          dataSource.close();
        }
      }
    }

  }

  /**
   * Stores a list of extractors and a selected extractor when the format has been detected.
   */
  private static final class ExtractorHolder {

    private final Extractor[] extractors;
    private final ExtractorOutput extractorOutput;
    private Extractor extractor;

    /**
     * Creates a holder that will select an extractor and initialize it using the specified output.
     *
     * @param extractors One or more extractors to choose from.
     * @param extractorOutput The output that will be used to initialize the selected extractor.
     */
    public ExtractorHolder(Extractor[] extractors, ExtractorOutput extractorOutput) {
      this.extractors = extractors;
      this.extractorOutput = extractorOutput;
    }

    /**
     * Returns an initialized extractor for reading {@code input}, and returns the same extractor on
     * later calls.
     *
     * @param input The {@link ExtractorInput} from which data should be read.
     * @return An initialized extractor for reading {@code input}.
     * @throws ExtractorMediaSource.UnrecognizedInputFormatException Thrown if the input format
     *     could not be detected.
     * @throws IOException Thrown if the input could not be read.
     * @throws InterruptedException Thrown if the thread was interrupted.
     */
    public Extractor selectExtractor(ExtractorInput input)
        throws IOException, InterruptedException {
      if (extractor != null) {
        return extractor;
      }
      for (Extractor extractor : extractors) {
        try {
          if (extractor.sniff(input)) {
            this.extractor = extractor;
            break;
          }
        } catch (EOFException e) {
          // Do nothing.
        } finally {
          input.resetPeekPosition();
        }
      }
      if (extractor == null) {
        throw new ExtractorMediaSource.UnrecognizedInputFormatException(extractors);
      }
      extractor.init(extractorOutput);
      return extractor;
    }

    public void release() {
      if (extractor != null) {
        extractor.release();
        extractor = null;
      }
    }

  }

}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Agaricus inserenda Britzelm.

### Remarks
null


text:
require 'active_support/inflector'
require 'active_support/hash_with_indifferent_access'
require 'extensions/math'

require 'megar/version'
require 'megar/exception'
require 'megar/shell'
require 'megar/crypto'
require 'megar/connection'
require 'megar/session'
require 'megar/adapters'
require 'megar/catalog'


text:
package de.slackspace.openkeepass.domain;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;

/**
 * Represents a key value pair of an {@link Entry}.
 * All properties like username or password of an Entry are represented with this class.
 *
 */
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Property implements KeePassFileElement {

	@XmlElement(name = "Key")
	private String key;

	@XmlElement(name = "Value")
	private PropertyValue propertyValue;

	Property() { }

	public Property(String key, String value, boolean isProtected) {
		this.key = key;
		this.propertyValue = new PropertyValue(isProtected, value);
	}

	public String getKey() {
		return key;
	}

	public String getValue() {
		return propertyValue.getValue();
	}

	public boolean isProtected() {
		return propertyValue.isProtected();
	}

	public PropertyValue getPropertyValue() {
		return propertyValue;
	}

	@Override
	public String toString() {
		return "Property [key=" + key + ", propertyValue=" + propertyValue + "]";
	}

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((key == null) ? 0 : key.hashCode());
		result = prime * result + ((propertyValue == null) ? 0 : propertyValue.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Property other = (Property) obj;
		if (key == null) {
			if (other.key != null)
				return false;
		} else if (!key.equals(other.key))
			return false;
		if (propertyValue == null) {
			if (other.propertyValue != null)
				return false;
		} else if (!propertyValue.equals(other.propertyValue))
			return false;
		return true;
	}

}


text:
from oslo_log import log as logging
from oslo_utils.strutils import bool_from_string

from designate import exceptions
from designate.objects import PoolList
from designate.scheduler.filters import base

LOG = logging.getLogger(__name__)

class AttributeFilter(base.Filter):
    """This allows users to choose the pool by supplying hints to this filter.
    These are provided as attributes as part of the zone object provided at
    zone create time.

    .. code-block:: javascript
        :emphasize-lines: 3,4,5

        {
            "attributes": {
                "pool_level": "gold",
                "fast_ttl": "true",
                "pops": "global",
            },
            "email": "user@example.com",
            "name": "example.com."
        }

    The zone attributes are matched against the potential pool candidates, and
    any pools that do not match **all** hints are removed.

    .. warning::

        This should be uses in conjunction with the
        :class:`designate.scheduler.impl_filter.filters.random_filter.RandomFilter`
        in case of multiple Pools matching the filters, as without it, we will
        raise an error to the user.
        """

    name = 'attribute'
    """Name to enable in the ``[designate:central:scheduler].filters`` option
    list
    """

    def filter(self, context, pools, zone):

        try:
            zone_attributes = zone.attributes.to_dict()
        except exceptions.RelationNotLoaded:
            zone_attributes = {}

        def evaluate_pool(pool):
            try:
                pool_attributes = pool.attributes.to_dict()
            except exceptions.RelationNotLoaded:
                pool_attributes = {}

            # Remove the "pool_id" attribute, that is used in
            # PoolIDAttributeFilter. If the item is not in the dict, it is
            # fine, we should just continue.
            pool_attributes.pop('pool_id', None)

            if not pool_attributes:
                # If we did not send any attribute to filter on, we should
                # not filter the pools based on an empty set, as this will
                # return no pools.
                return True

            # Check if the keys requested exist in this pool
            if not {key for key in pool_attributes.keys()}.issuperset(
                    zone_attributes):
                LOG.debug(
                    '%(pool)s did not match list of requested attribute '
                    'keys - removing from list. Requested: %(r_key)s. Pool:'
                    '%(p_key)s',
                    {
                        'pool': pool,
                        'r_key': zone_attributes,
                        'p_key': pool_attributes
                    }
                )
                # Missing required keys - remove from the list
                return False

            for key in zone_attributes.keys():
                LOG.debug('Checking value of %s for %s', key, pool)

                pool_attr = bool_from_string(pool_attributes[key],
                                             default=pool_attributes[key])
                zone_attr = bool_from_string(zone_attributes[key],
                                             default=zone_attributes[key])

                if not pool_attr == zone_attr:
                    LOG.debug(
                        '%(pool)s did not match requested value of %(key)s. '
                        'Requested: %(r_val)s. Pool: %(p_val)s',
                        {
                            'pool': pool,
                            'key': key,
                            'r_val': zone_attr,
                            'p_val': pool_attr
                        })
                    # Value didn't match - remove from the list
                    return False

            # Pool matches list of attributes - keep
            return True

        pool_list = [pool for pool in pools if evaluate_pool(pool)]
        pools = PoolList(objects=pool_list)
        return pools


text:
using System;
using System.IO;
using System.Collections.Generic;

namespace MultiMiner.Utility.Parsers
{
    public class IniFileParser
    {
        private readonly Dictionary<string, string> keyPairs = new Dictionary<string, string>();

        public IniFileParser(string iniPath)
        {
            LoadIniFile(iniPath);
        }

        private void LoadIniFile(string iniPath)
        {
            if (File.Exists(iniPath))
            {
                TextReader iniFile = new StreamReader(iniPath);
                try
                {
                    string currentRoot = null;
                    string strLine = iniFile.ReadLine();

                    while (strLine != null)
                    {
                        strLine = strLine.TrimStart();

                        if (!String.IsNullOrEmpty(strLine) && !strLine.StartsWith("#") && !strLine.StartsWith(";"))
                        {
                            if (strLine.StartsWith("[") && strLine.EndsWith("]"))
                                currentRoot = strLine.Substring(1, strLine.Length - 2);
                            else
                            {
                                string[] keyPair = strLine.Split(new char[] { '=' }, 2);
                                string value = keyPair.Length > 1 ? keyPair[1].TrimStart() : null;

                                if (currentRoot == null)
                                    currentRoot = "ROOT";

                                string key = GetKey(currentRoot, keyPair[0]);
                                keyPairs[key] = value;
                            }
                        }
                        strLine = iniFile.ReadLine();
                    }
                }
                finally
                {
                    iniFile.Close();
                }
            }
            else
                throw new FileNotFoundException("Unable to locate " + iniPath);
        }

        private static string GetKey(string sectionName, string settingName)
        {
            return String.Format("{0}-{1}", sectionName.TrimEnd().ToUpper(), settingName.TrimEnd().ToUpper());
        }

        public string GetValue(string sectionName, string settingName)
        {
            string key = GetKey(sectionName, settingName);
            return keyPairs[key];
        }
    }
}


text:
import { push } from 'react-router-redux';
import { PROTOCOLS } from 'appConstants';
// import setupPreloadAPIs from './setupPreloadAPIs';;

//no logger to avoid duplicate msgs.
console.log( 'Peruse Browser window preloaded.' );

window.peruseNav = ( location ) =>
{
    if( peruseStore )
    {
        peruseStore.dispatch( push( location ) );
    }
    else
    {
        window.perusePendingNavigation = location;
    }
};

// setupPreloadAPIs( `${PROTOCOLS.SAFE_AUTH}:` );


text:
package org.drools.testcoverage.common.model;

import java.io.Serializable;

/**
 * Simple class used to give messages to rules or retrieve them from rules
 */
public class Message implements Serializable {

    private static final long serialVersionUID = -7176392345381065685L;

    private String message;

    public Message() {
        message = "";
    }

    public Message(final String message) {
        this.message = message;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(final String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return getClass().getName() + "[message='" + message + "']";
    }
}


text:
package com.squizbit.opendialer.library.widget.RecycleviewIndexer;

import android.annotation.TargetApi;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.ColorFilter;
import android.graphics.Paint;
import android.graphics.PorterDuff;
import android.graphics.PorterDuffColorFilter;
import android.graphics.Rect;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.os.Build;
import android.support.v4.graphics.drawable.DrawableCompat;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.RecyclerView.OnScrollListener;
import android.text.TextPaint;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;
import android.widget.FrameLayout;

import com.squizbit.opendialer.R;

/**
 * A ViewGroup that contains a RecycleView and adds fast scrolling and indexer support.
 */

public class RecyclerViewFastScroller extends FrameLayout {

    private RecyclerView mRecyclerView;
    private BitmapDrawable mBitmapDrawable;
    private int mHandlePaddingRight;
    private int mHandlePaddingTop;
    private float mScrollProportion = 0;
    private RecyclerView.OnScrollListener mOnScrollListener;
    private int mListVisibilityRange = -1;
    private Rect mHandleHitRect = new Rect();
    private int mInitialTouchRegion = 0;
    private boolean mFastScrollHandleSelected = false;

    private boolean mIsIndexBubbleEnabled = true;
    private int mIndexBubblePadding;
    private Drawable mIndexBubbleDrawable;
    private Rect mIndexBubbleRect;
    private TextPaint mIndexTextPaint;
    private Rect mTextBounds;

    private ColorFilter mSelectedColorFilter;
    private ColorFilter mUnselectedColorFilter;

    /**
     * Creates a new RecyclerViewFastSroller
     *
     * @param context The activity context
     */
    public RecyclerViewFastScroller(Context context) {
        this(context, null, 0);
    }

    /**
     * Creates a new RecyclerViewFastScroller
     *
     * @param context The activity context
     * @param attrs   The attribute set
     */
    public RecyclerViewFastScroller(Context context, AttributeSet attrs) {
        this(context, attrs, 0);

    }

    /**
     * Creates a new RecyclerViewFastScroller
     *
     * @param context      The activity context
     * @param attrs        The attribute set
     * @param defStyleAttr The default style resource id
     */
    public RecyclerViewFastScroller(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        init();
    }

    @SuppressWarnings({"deprecation"})
    private void init() {
        setWillNotDraw(false);
        int activeColor;
        int inactiveColor;
        int indexBubbleColor;

        mBitmapDrawable = (BitmapDrawable) getContext().getResources().getDrawable(R.drawable.ic_fastscroll_handle);
        activeColor = getContext().getResources().getColor(R.color.ab_primary);
        inactiveColor = getContext().getResources().getColor(R.color.handle_normal);
        indexBubbleColor = getContext().getResources().getColor(R.color.bubble_index_text);
        mIndexBubbleDrawable = DrawableCompat.wrap(getContext().getResources().getDrawable(R.drawable.bg_quick_scroll_bubble));
        DrawableCompat.setTint(mIndexBubbleDrawable, activeColor);

        mSelectedColorFilter = new PorterDuffColorFilter(
                activeColor,
                PorterDuff.Mode.SRC_ATOP);

        mUnselectedColorFilter = new PorterDuffColorFilter(
                inactiveColor,
                PorterDuff.Mode.SRC_ATOP);
        mHandlePaddingRight = getContext().getResources().getDimensionPixelOffset(R.dimen.fastscroll_padding_right);
        mHandlePaddingTop = getContext().getResources().getDimensionPixelOffset(R.dimen.fastscroll_padding_top);

        mIndexBubbleRect = new Rect();
        mIndexTextPaint = new TextPaint();
        mIndexTextPaint.setTextSize(getResources().getDimensionPixelSize(R.dimen.index_bubble_text));
        mIndexTextPaint.setColor(indexBubbleColor);
        mIndexTextPaint.setAntiAlias(true);
        mTextBounds = new Rect();
        mIndexTextPaint.getTextBounds("A", 0, 1, mTextBounds);
        mIndexTextPaint.setTextAlign(Paint.Align.CENTER);

        mIndexBubblePadding = getContext().getResources().getDimensionPixelOffset(R.dimen.index_bubble_padding);
    }

    /**
     * Creates a new recyclerViewFastScroller which provides fast scrolling functionality to a Recyclerview
     *
     * @param context      The activity context
     * @param attrs        The attribute set
     * @param defStyleAttr The default style resource id
     * @param defStyleRes  The default style resource
     */
    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
    public RecyclerViewFastScroller(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
        super(context, attrs, defStyleAttr, defStyleRes);
    }

    @Override
    public void addView(View child) {
        if ((mRecyclerView != null && !child.equals(mRecyclerView)) || !(child instanceof RecyclerView)) {
            throw new IllegalStateException("RecyclerViewFastScroller expects a single RecyclerView as a child");
        } else {
            initRecyclerView((RecyclerView) child);
            super.addView(child);
        }
    }

    @Override
    public void addView(View child, int index) {
        if ((mRecyclerView != null && !child.equals(mRecyclerView)) || !(child instanceof RecyclerView)) {
            throw new IllegalStateException("RecyclerViewFastScroller expects a single RecyclerView as a child");
        } else {
            initRecyclerView((RecyclerView) child);
            super.addView(child, index);
        }
    }

    @Override
    public void addView(View child, int width, int height) {
        if ((mRecyclerView != null && !child.equals(mRecyclerView)) || !(child instanceof RecyclerView)) {
            throw new IllegalStateException("RecyclerViewFastScroller expects a single RecyclerView as a child");
        } else {
            initRecyclerView((RecyclerView) child);
            super.addView(child, width, height);
        }
    }

    @Override
    public void addView(View child, ViewGroup.LayoutParams params) {
        if ((mRecyclerView != null && !child.equals(mRecyclerView)) || !(child instanceof RecyclerView)) {
            throw new IllegalStateException("RecyclerViewFastScroller expects a single RecyclerView as a child");
        } else {
            initRecyclerView((RecyclerView) child);
            super.addView(child, params);
        }
    }

    @Override
    public void addView(View child, int index, ViewGroup.LayoutParams params) {
        if ((mRecyclerView != null && !child.equals(mRecyclerView)) || !(child instanceof RecyclerView)) {
            throw new IllegalStateException("RecyclerViewFastScroller expects a single RecyclerView as a child");
        } else {
            initRecyclerView((RecyclerView) child);
            super.addView(child, index, params);
        }
    }

    private void initRecyclerView(RecyclerView recyclerView) {
        mRecyclerView = recyclerView;
        mRecyclerView.setVerticalScrollBarEnabled(false);
        mRecyclerView.setOnScrollListener(new InternalOnScrollListener());
    }

    @Override
    protected void dispatchDraw(Canvas canvas) {
        super.dispatchDraw(canvas);

        if (!shouldDisplayFastScroll()) {
            return;
        }

        int scrollHeight = getHeight() - mBitmapDrawable.getIntrinsicHeight() - (mHandlePaddingTop * 2);

        mHandleHitRect.offsetTo(mHandleHitRect.left, (int) (mHandlePaddingTop + (scrollHeight * mScrollProportion)));

        ColorFilter colorFilter = mFastScrollHandleSelected ? mSelectedColorFilter : mUnselectedColorFilter;
        mBitmapDrawable.setColorFilter(colorFilter);

        mBitmapDrawable.setBounds(getWidth() - mHandlePaddingRight - mBitmapDrawable.getIntrinsicWidth(),
                (int) (mHandlePaddingTop + (scrollHeight * mScrollProportion)),
                getWidth() - mHandlePaddingRight,
                (int) (mHandlePaddingTop + (scrollHeight * mScrollProportion)) + mBitmapDrawable.getIntrinsicHeight());
        mBitmapDrawable.draw(canvas);

        String index = null;

        if(shouldDisplayIndexBubble()) {
            index = getIndexForTopItem();
        }

        if(index != null) {
            mIndexBubbleRect.set(
                    mBitmapDrawable.getBounds().left - mIndexBubbleDrawable.getIntrinsicWidth() - mIndexBubblePadding,
                    mHandleHitRect.centerY() - mIndexBubbleDrawable.getIntrinsicHeight(),
                    mBitmapDrawable.getBounds().left - mIndexBubblePadding,
                    mHandleHitRect.centerY());

            if (mIndexBubbleRect.top < 0) {
                mIndexBubbleRect.offsetTo(mIndexBubbleRect.left, 0);
            } else if (mIndexBubbleRect.bottom > getHeight()) {
                mIndexBubbleRect.offset(0, mIndexBubbleRect.bottom - getHeight());
            }

            mIndexBubbleDrawable.setBounds(mIndexBubbleRect);
            mIndexBubbleDrawable.draw(canvas);

            canvas.drawText(index, mIndexBubbleRect.centerX(), mIndexBubbleRect.centerY() + (mTextBounds.height() / 2), mIndexTextPaint);
        }
    }

    private String getIndexForTopItem() {
        View child = mRecyclerView.getChildAt(0);
        if(child != null){
            int index = mRecyclerView.getChildAdapterPosition(child);

            return ((IndexedAdapter)mRecyclerView.getAdapter()).getIndexLabel(index);
        }

        return null;
    }

    @Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);

        mHandleHitRect.set(
                getMeasuredWidth() - mHandlePaddingRight - mBitmapDrawable.getIntrinsicWidth() - mHandlePaddingRight,
                mHandlePaddingTop,
                getMeasuredWidth(),
                mHandlePaddingTop + mBitmapDrawable.getIntrinsicHeight());
    }

    public void setOnScrollListener(RecyclerView.OnScrollListener onScrollListener) {
        mOnScrollListener = onScrollListener;
    }

    @Override
    public boolean onInterceptTouchEvent(MotionEvent ev) {
        return mHandleHitRect.contains((int) ev.getX(), (int) ev.getY());
    }

    private boolean shouldDisplayFastScroll() {
        return mRecyclerView.getAdapter() != null && getVisibleRange() < mRecyclerView.getAdapter().getItemCount();
    }

    private boolean shouldDisplayIndexBubble() {
        return shouldDisplayFastScroll() &&
                mRecyclerView.getAdapter() instanceof IndexedAdapter &&
                mFastScrollHandleSelected &&
                mIsIndexBubbleEnabled;
    }

    /**
     * Toggles the index scroll bubble on or off
     *
     * @param isIndexBubbleEnabled True if the index bubble should be displayed, false otherwise
     */
    public void setIsIndexBubbleEnabled(boolean isIndexBubbleEnabled) {
        mIsIndexBubbleEnabled = isIndexBubbleEnabled;
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        if (!shouldDisplayFastScroll()) {
            return false;
        }

        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            mFastScrollHandleSelected = true;
            mInitialTouchRegion = (int) (event.getY() - mBitmapDrawable.getBounds().top);
            return true;
        } else if (event.getAction() == MotionEvent.ACTION_MOVE) {
            mScrollProportion = Math.max(Math.min((event.getY() - mInitialTouchRegion) / getHeight(), 1), 0);

            ((LinearLayoutManager) mRecyclerView.getLayoutManager()).scrollToPositionWithOffset(
                    (int) (mScrollProportion * (mRecyclerView.getAdapter().getItemCount() - getVisibleRange() + 1)), 0);
            invalidate();
            if (mOnScrollListener != null) {
                mOnScrollListener.onScrollStateChanged(mRecyclerView, RecyclerView.SCROLL_STATE_DRAGGING);
            }
            return true;
        } else if (event.getAction() == MotionEvent.ACTION_CANCEL || event.getAction() == MotionEvent.ACTION_UP) {
            mFastScrollHandleSelected = false;
            invalidate();
        }

        return false;

    }

    private int getVisibleRange() {
        if (mListVisibilityRange == -1) {
            //Initial visibility range does not include a buffer view at top
            mListVisibilityRange = mRecyclerView.getChildCount();
        }
        return mListVisibilityRange;
    }

    /**
     * An internal listener which listens to the child recyclerview's OnScroll methods and positions
     * the fastscroller handle appropriately
     */
    private class InternalOnScrollListener extends OnScrollListener {
        @Override
        public void onScrolled(RecyclerView recyclerView, int dx, int dy) {

            if (!mFastScrollHandleSelected) {
                View firstChild = mRecyclerView.getChildAt(0);
                if (firstChild == null) {
                    return;
                }

                float firstVisiblePosition = mRecyclerView.getChildAdapterPosition(firstChild);

                float visibleRange = getVisibleRange();
                float visibilityDelta = recyclerView.getAdapter().getItemCount() - visibleRange;

                float currentScrollPercentage = firstVisiblePosition / visibilityDelta;
                float nextScrollPercentage = (firstVisiblePosition + 1) / visibilityDelta;

                float currentCellProportion =
                        Math.min((currentScrollPercentage - nextScrollPercentage) *
                                ((float) firstChild.getTop() / (float) firstChild.getHeight()), nextScrollPercentage);

                mScrollProportion = Math.min((firstVisiblePosition / visibilityDelta) + currentCellProportion, 1);
                invalidate();
            }

            if (mOnScrollListener != null) {
                mOnScrollListener.onScrolled(recyclerView, dx, dy);
            }
        }

        @Override
        public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
            if (mOnScrollListener != null) {
                mOnScrollListener.onScrollStateChanged(recyclerView, newState);
            }
        }

    }
}


text:
/*
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
/*
 * This code was generated by https://github.com/googleapis/google-api-java-client-services/
 * Modify at your own risk.
 */

package com.google.api.services.docs.v1.model;

/**
 * The properties of an embedded drawing and used to differentiate the object type. An embedded
 * drawing is one that's created and edited within a document. Note that extensive details are not
 * supported.
 *
 *
 This is the Java data model class that specifies how to parse/serialize into the JSON that is
 * transmitted over HTTP when working with the Google Docs API. For a detailed explanation see:
 * https://developers.google.com/api-client-library/java/google-http-java-client/json
 *

 *
 * @author Google, Inc.
 */
@SuppressWarnings("javadoc")
public final class EmbeddedDrawingProperties extends com.google.api.client.json.GenericJson {

  @Override
  public EmbeddedDrawingProperties set(String fieldName, Object value) {
    return (EmbeddedDrawingProperties) super.set(fieldName, value);
  }

  @Override
  public EmbeddedDrawingProperties clone() {
    return (EmbeddedDrawingProperties) super.clone();
  }

}


text:
namespace Minesweeper.Commands
{
    using System.Collections.Generic;

    /// <summary>
    /// Inherits the interface and sets a constructor for declaration of the desired parameters of the commands info
    /// </summary>
    public class CommandInfo : ICommandInfo
    {
        private string name;
        private IList<string> parameters;

        /// <summary>
        /// Object holding information for the command
        /// </summary>
        /// <param name="name">The namo of the command</param>
        /// <param name="parameters">Collection with the command parameters if any</param>
        public CommandInfo(string name, IList<string> parameters)
        {
            this.Name = name;
            this.Params = parameters;
        }

        /// <summary>
        /// Command name
        /// </summary>
        /// <value>
        /// Name
        /// </value>
        public string Name
        {
            get
            {
                return this.name;
            }

            private set
            {
                this.name = value;
            }
        }

        /// <summary>
        /// Collection of the command parameters
        /// </summary>
        public IList<string> Params
        {
            get
            {
                return this.parameters;
            }

            private set
            {
                this.parameters = value;
            }
        }
    }
}


text:
using System.Web;
using System.Web.Optimization;

namespace DpApiClient
{
    public class BundleConfig
    {
        // For more information on bundling, visit http://go.microsoft.com/fwlink/?LinkId=301862
        public static void RegisterBundles(BundleCollection bundles)
        {
            bundles.Add(new ScriptBundle("~/bundles/jquery").Include(
                        "~/Scripts/jquery-{version}.js",
                        "~/Scripts/jquery.serialize-object.js"));

            bundles.Add(new ScriptBundle("~/bundles/jqueryval").Include(
                        "~/Scripts/jquery.validate*"));

            // Use the development version of Modernizr to develop with and learn from. Then, when you're
            // ready for production, use the build tool at http://modernizr.com to pick only the tests you need.
            bundles.Add(new ScriptBundle("~/bundles/modernizr").Include(
                        "~/Scripts/modernizr-*"));

            bundles.Add(new ScriptBundle("~/bundles/bootstrap").Include(
                      "~/Scripts/bootstrap.js",
                      "~/Scripts/moment.min.js",
                      "~/Scripts/bootstrap-datetimepicker.min.js",
                      "~/Scripts/respond.js"));

            bundles.Add(new ScriptBundle("~/bundles/custom").Include(
                        "~/Scripts/custom.js"));

            bundles.Add(new StyleBundle("~/Content/css").Include(
                      "~/Content/bootstrap.css",
                      "~/Content/bootstrap-datetimepicker.min.css",
                      "~/Content/site.css",
                      "~/Content/jquery.timepicker.css"));
        }
    }
}


text:
<?php

namespace ServerGrove\Bundle\TranslationEditorBundle\Model;

/**
 * Storage agnostic Translation entity.
 *
 * @author Guilherme Blanco <guilhermeblanco@hotmail.com>
 */
class Translation implements TranslationInterface
{
    /**
     * @var int
     */
    protected $id;

    /**
     * @var Entry
     */
    protected $entry;

    /**
     * @var Locale
     */
    protected $locale;

    /**
     * @var string
     */
    protected $value;

    /**
     * Retrieve Entry identifier.
     *
     * @return int
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * {@inheritdoc}
     */
    public function getEntry()
    {
        return $this->entry;
    }

    /**
     * {@inheritdoc}
     */
    public function setEntry(EntryInterface $entry)
    {
        $entry->addTranslation($this);

        $this->entry = $entry;
    }

    /**
     * {@inheritdoc}
     */
    public function getLocale()
    {
        return $this->locale;
    }

    /**
     * {@inheritdoc}
     */
    public function setLocale(LocaleInterface $locale)
    {
        $locale->addTranslation($this);

        $this->locale = $locale;
    }

    /**
     * {@inheritdoc}
     */
    public function getValue()
    {
        return $this->value;
    }

    /**
     * {@inheritdoc}
     */
    public function setValue($value)
    {
        $this->value = $value;
    }
}


text:
.MMM-MyScoreboard {
  min-width: 300px;
}

.MMM-MyScoreboard .wrapper {
  margin-top: 10px;
}

.MMM-MyScoreboard .module-header {
  margin-bottom: 0px;
}

.MMM-MyScoreboard .league-separator {
  font-size: 15.5px;
  line-height: 18px;
  text-transform: uppercase;
  margin-top: 10px;
  border-bottom: solid 1px #222;
  text-align: left;
  padding: 0;
}
.MMM-MyScoreboard .league-separator > span {
  color: #000;
  font-weight: bold;
  padding-left: 6px;
  padding-right: 2px;
  background-color: #FFF;
  display: inline-block;
  vertical-align: top;
  position: relative;
  white-space: nowrap;
}
.MMM-MyScoreboard .league-separator > span:after {
  content: "";
  width: 0;
  height: 0;
  display: inline-block;
  vertical-align: top;
  border-style: solid;
  border-width: 18px 0 0 15px;
  border-color: transparent transparent transparent #FFF;
  margin-right: -15px;
  position: relative;
  right: -2px;
}

.MMM-MyScoreboard .box-score {
  min-width: 300px;
  height: 70px;
  position: relative;
  text-align: left;
  border-bottom: solid 1px #222;
}

.MMM-MyScoreboard .box-score .logo {
  position: absolute;

  display: flex;
  justify-content: center;
  align-items: center;
  overflow: hidden;

  width: 60px;
  height: 60px;
  top: 5px;

  border: none;

  -webkit-filter: grayscale(100%);
  filter: grayscale(100%);
}

.MMM-MyScoreboard .box-score .logo img {
  max-width: 100%;
  max-height: 100%;
}

.MMM-MyScoreboard .wrapper.colored .box-score .logo {
  -webkit-filter: none;
  filter: none;
}

.MMM-MyScoreboard .box-score .logo.visitor {
  left: 0px;
}
.MMM-MyScoreboard .box-score .logo.home {
  right: 0px;
}

.MMM-MyScoreboard .box-score.home-team-first .logo.visitor {
  right: 0px;
  left: auto;
}
.MMM-MyScoreboard .box-score.home-team-first .logo.home {
  left: 0px;
  right: auto;
}

.MMM-MyScoreboard .box-score .score {
  position: absolute;
  display: block;
  width: 44px;
  font-size: 32px;
  line-height: 1;
  top: 20px;
  color: #FFF;
  text-align: center;
}

.MMM-MyScoreboard .box-score .score.visitor {
  left: 62px;
}
.MMM-MyScoreboard .box-score .score.home {
  right: 62px;
}
.MMM-MyScoreboard .box-score.home-team-first .score.visitor {
  right: 62px;
  left: auto;
}
.MMM-MyScoreboard .box-score.home-team-first .score.home {
  left: 62px;
  right: auto;
}

.MMM-MyScoreboard .box-score .status {
  position: absolute;
  width: calc(100% - 200px);
  left: 100px;
  top: 0px;
  height: 70px;
  display: flex;
  flex-direction: row;
  flex-wrap: wrap;
  justify-content: center;
  align-content: center;
  align-items: center;
  line-height: 1;
  font-weight: 300;
  font-size: 20px;
  font-weight: 400;
}

.MMM-MyScoreboard .box-score .status > span {
  padding: 0 4px;
  white-space: nowrap;
}

.MMM-MyScoreboard .box-score .status sup {
  font-size: 68%;
  vertical-align: middle;
  display: inline-block;
  margin-bottom: 9px;
}

.MMM-MyScoreboard .box-score.in-progress .status {
  color: #FFF;
  font-weight: 400;
}

.MMM-MyScoreboard .box-score .logo .ranking {
  position: absolute;
  top: 0;
  right: 0;
  display: block;
  font-size: 12px;
  font-weight: bold;
  line-height: 13px;
  background-color: #FFF;
  color: #000;
  padding: 0 2px 0 3px;
  height: 13px;
  border-radius: 2px;
  border-bottom: solid 1px #000;
  border-left: solid 1px #000;
}

.MMM-MyScoreboard .box-score .team-name .ranking,
.MMM-MyScoreboard .box-score .team-short-code .ranking {
  font-size: 12px;
  display: inline-block;
  margin-right: 2px;
  vertical-align: bottom;
  margin-bottom: 4px;
  bottom: 2px;
  line-height: 13px;
  padding: 0 2px;
  height: 13px;
  background-color: #FFF;
  color: #000;
  border-radius: 2px;
  font-weight: bold;
}

.MMM-MyScoreboard .box-score .team-short-code .ranking {
  margin-bottom: 7px;
}

.MMM-MyScoreboard .box-score.in-progress .team-name,
.MMM-MyScoreboard .box-score.in-progress .team-short-code {
  color: #EFEFEF;
}

.MMM-MyScoreboard .wrapper.colored .box-score .logo .ranking,
.MMM-MyScoreboard .wrapper.colored .box-score .team-name .ranking,
.MMM-MyScoreboard .wrapper.colored .box-score .team-short-code .ranking {
  background-color: #C0FF00;
}

.MMM-MyScoreboard .wrapper.colored .box-score.in-progress .status {
  color: #f8dd70;
}

.MMM-MyScoreboard .box-score .status .game-clock {
  margin-right: 12px;
}

/* Row shading */
.MMM-MyScoreboard .wrapper.shade-rows .league-separator,
.MMM-MyScoreboard .wrapper.shade-rows .box-score {
  border-color: #282828;
}

.MMM-MyScoreboard .wrapper.shade-rows .box-score.odd {
  background-color: #181818;
}

.MMM-MyScoreboard .wrapper.shade-rows.no-league-separators .box-score.odd {
  background-color: initial;
}

.MMM-MyScoreboard .wrapper.shade-rows.no-league-separators .box-score:nth-child(odd) {
  background-color: #181818;
}

/* Dim the status while an in-progress game is delayed */
.MMM-MyScoreboard .box-score.in-progress.delay .status,
.MMM-MyScoreboard .wrapper.colored .box-score.in-progress.delay .status {
  color: #AAA;
}

/* Highlight the winners of finished games */
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .score.visitor {
  color: #777;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .team-short-code.home,
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .team-name.home {
  color: #EFEFEF;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .team-short-code.visitor,
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .team-name.visitor {
  color: #777
}

.MMM-MyScoreboard .wrapper.highlight-winners.colored .box-score.winner-h .score.home {
  color: #7AE4FF;
}

.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .score.home {
  color: #777;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .team-short-code.visitor,
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .team-name.visitor {
  color: #EFEFEF;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .team-short-code.home,
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .team-name.home {
  color: #777;
}
.MMM-MyScoreboard .wrapper.highlight-winners.colored .box-score.final.winner-v .score.visitor {
  color: #7AE4FF;
}

.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.tie .score.visitor,
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.tie .score.home {
  color: #AAA;
}

/*
  ------------- View Modifiers -------------
  The above styles default to the largeLogos
  view style.  The following can be used to
  modify the display
*/

/* mediumLogos */
.MMM-MyScoreboard .box-score.mediumLogos {
  height: 50px;
}

.MMM-MyScoreboard .box-score.mediumLogos .logo {
  width: 40px;
  height: 40px;
  top: 5px;
}

.MMM-MyScoreboard .box-score.mediumLogos .logo.home {
  right: 0px;
}
.MMM-MyScoreboard .box-score.mediumLogos .logo.visitor {
  left: 0px;
}
.MMM-MyScoreboard .box-score.mediumLogos.home-team-first .logo.home {
  left: 0px;
  right: auto;
}
.MMM-MyScoreboard .box-score.mediumLogos.home-team-first .logo.visitor {
  right: 0px;
  left: auto;
}

.MMM-MyScoreboard .box-score.mediumLogos .status {
  height: 50px;
  width: calc(100% - 160px);
  left: 80px;
}

.MMM-MyScoreboard .box-score.mediumLogos .score {
  font-size: 26px;
  top: 11px;
}
.MMM-MyScoreboard .box-score.mediumLogos .score.visitor {
  left: 42px;
}
.MMM-MyScoreboard .box-score.mediumLogos .score.home {
  right: 42px;
}
.MMM-MyScoreboard .box-score.mediumLogos.home-team-first .score.visitor {
  right: 42px;
  left: auto;
}
.MMM-MyScoreboard .box-score.mediumLogos.home-team-first .score.home {
  left: 42px;
  right: auto;
}

/* smallLogos */
.MMM-MyScoreboard .box-score.smallLogos {
  height: 30px;
}

.MMM-MyScoreboard .box-score.smallLogos .logo {
  width: 40px;
  height: 24px;
  top: 3px;
  /*overflow: visible;*/
}

.MMM-MyScoreboard .box-score.smallLogos .logo .ranking {
  top: 5px;
  border: solid 1px #000;
}

.MMM-MyScoreboard .box-score.smallLogos .logo.home {
  right: 0px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.home {
  left: 0px;
  right: auto;
}

.MMM-MyScoreboard .box-score.smallLogos .logo img {
  max-width: 24px;
  position: absolute;
}

.MMM-MyScoreboard .box-score.smallLogos .logo.home img {
  right: 0px;
}
.MMM-MyScoreboard .box-score.smallLogos .logo.visitor img {
  left: 0px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.home img {
  left: 0px;
  right: auto;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.visitor img {
  right: 0px;
  left: auto;
}

.MMM-MyScoreboard .box-score.smallLogos .logo.home .ranking {
  right: 20px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.home .ranking {
  left: 20px;
  right: auto;
}

.MMM-MyScoreboard .box-score.smallLogos .logo.visitor {
  left: 0px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.visitor {
  right: 0px;
  left: auto;
}

.MMM-MyScoreboard .box-score.smallLogos .logo.visitor .ranking {
  right: initial;
  left: 20px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .logo.visitor .ranking {
  left: auto;
  right: 20px;
}

.MMM-MyScoreboard .box-score.smallLogos .status {
  height: 30px;
  font-size: 16px;
  line-height: 30px;
  width: calc(100% - 124px);
  left: 62px;
  top: 0px;
}

.MMM-MyScoreboard .box-score.smallLogos .score {
  font-size: 20px;
  top: 0px;
  height: 30px;
  line-height: 30px;
}
.MMM-MyScoreboard .box-score.smallLogos .score.visitor {
  left: 38px;
}
.MMM-MyScoreboard .box-score.smallLogos .score.home {
  right: 38px;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .score.visitor {
  right: 38px;
  left: auto;
}
.MMM-MyScoreboard .box-score.smallLogos.home-team-first .score.home {
  left: 38px;
  right: auto;
}

/* oneLine / oneLineWithLogos */
.MMM-MyScoreboard .box-score.oneLine,
.MMM-MyScoreboard .box-score.oneLineWithLogos {
  height: 30px;
}

.MMM-MyScoreboard .box-score.oneLine .team-short-code,
.MMM-MyScoreboard .box-score.oneLine .status,
.MMM-MyScoreboard .box-score.oneLine .score,
.MMM-MyScoreboard .box-score.oneLine .vs-symbol,
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code,
.MMM-MyScoreboard .box-score.oneLineWithLogos .status,
.MMM-MyScoreboard .box-score.oneLineWithLogos .score,
.MMM-MyScoreboard .box-score.oneLineWithLogos .vs-symbol {
  display: block;
  position: absolute;
  top: 0px;
  font-size: 20px;
  line-height: 30px;
  height: 30px;
  margin: 0;
  padding: 0;
  white-space:nowrap;
  overflow: hidden;
  text-align: left;
}

.MMM-MyScoreboard .box-score.oneLine .vs-symbol,
.MMM-MyScoreboard .box-score.oneLineWithLogos .vs-symbol {
  left: 70px;
  font-size: 16px;
  line-height: 16px;
  display: inline-block;
  vertical-align: top;
  top: 6px;
  color: #AAA;
}

.MMM-MyScoreboard .box-score.oneLine .team-short-code,
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code {
  width: 57px;
  color: #AAA;
}

.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code {
  width: 52px;
}

.MMM-MyScoreboard .box-score.in-progress.oneLine .team-short-code,
.MMM-MyScoreboard .box-score.in-progress.oneLineWithLogos .team-short-code {
  color: #EFEFEF;
}

.MMM-MyScoreboard .box-score.oneLine .team-short-code.visitor,
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code.visitor {
  left: 0px;
}
.MMM-MyScoreboard .box-score.oneLine .team-short-code.home,
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code.home {
  left: 120px;
}

.MMM-MyScoreboard .box-score.oneLine.home-team-first .team-short-code.visitor,
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .team-short-code.visitor {
  left: 120px;
}
.MMM-MyScoreboard .box-score.oneLine.home-team-first .team-short-code.home,
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .team-short-code.home {
  left: 0px;
}

.MMM-MyScoreboard .box-score.oneLine .score,
.MMM-MyScoreboard .box-score.oneLineWithLogos .score {
  width: 40px;
  font-weight: bold;
  color: #FFF;
}
.MMM-MyScoreboard .box-score.oneLine .score.visitor,
.MMM-MyScoreboard .box-score.oneLineWithLogos .score.visitor {
  left: 62px;
}
.MMM-MyScoreboard .box-score.oneLine .score.home,
.MMM-MyScoreboard .box-score.oneLineWithLogos .score.home {
  left: 182px;
}

.MMM-MyScoreboard .box-score.oneLine.home-team-first .score.visitor,
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .score.visitor {
  left: 182px;
}
.MMM-MyScoreboard .box-score.oneLine.home-team-first .score.home,
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .score.home {
  left: 62px;
}

.MMM-MyScoreboard .box-score.oneLine .status,
.MMM-MyScoreboard .box-score.oneLineWithLogos .status {
  text-align: right;
  left: initial;
  right: 0px;
  font-size: 16px;
  width: calc(100% - 170px);
}

.MMM-MyScoreboard .box-score.oneLine .status sup,
.MMM-MyScoreboard .box-score.oneLineWithLogos .status sup {
  margin-bottom: 6px;
}

.MMM-MyScoreboard .box-score.oneLine .status > span,
.MMM-MyScoreboard .box-score.oneLineWithLogos .status > span {
  padding: 0 2px;
}

.MMM-MyScoreboard .box-score.oneLineWithLogos .logo {
  top: 3px;
  height: 24px;
  width: 24px;
  right: initial;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .logo.visitor {
  left: 0px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .logo.home {
  left: 120px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code.visitor {
  left: 30px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .team-short-code.home {
  left: 150px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .score.visitor {
  left: 80px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos .score.home {
  left: 202px;
}

.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .logo.visitor {
  left: 120px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .logo.home {
  left: 0px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .team-short-code.visitor {
  left: 150px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .team-short-code.home {
  left: 30px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .score.visitor {
  left: 202px;
}
.MMM-MyScoreboard .box-score.oneLineWithLogos.home-team-first .score.home {
  left: 80px;
}

.MMM-MyScoreboard .box-score.oneLineWithLogos .vs-symbol {
  left: 85px;
}

/* stacked / stackedWithLogos */
.MMM-MyScoreboard .box-score.stacked {
  height: 60px;
}

.MMM-MyScoreboard .box-score.stackedWithLogos {
  height: 66px;
}

.MMM-MyScoreboard .box-score.stacked .team-name,
.MMM-MyScoreboard .box-score.stacked .status,
.MMM-MyScoreboard .box-score.stacked .score,
.MMM-MyScoreboard .box-score.stacked .vs-symbol,
.MMM-MyScoreboard .box-score.stackedWithLogos .team-name,
.MMM-MyScoreboard .box-score.stackedWithLogos .status,
.MMM-MyScoreboard .box-score.stackedWithLogos .score {
  display: block;
  position: absolute;
  font-size: 20px;
  line-height: 24px;
  height: 30px;
  margin: 0;
  padding: 0;
  white-space:nowrap;
  overflow: hidden;
  text-overflow: ellipsis;
  text-align: left;
}

.MMM-MyScoreboard .box-score.stacked .team-name,
.MMM-MyScoreboard .box-score.stackedWithLogos .team-name {
  left: 0px;
  width: 150px;
  color: #AAA;
}
.MMM-MyScoreboard .box-score.in-progress.stacked .team-name,
.MMM-MyScoreboard .box-score.in-progress.stackedWithLogos .team-name {
  color: #EFEFEF;
}
.MMM-MyScoreboard .box-score.stacked .team-name.visitor {
  top: 6px;
}
.MMM-MyScoreboard .box-score.stacked .team-name.home {
  top: 30px;
}
.MMM-MyScoreboard .box-score.stacked.home-team-first .team-name.visitor {
  top: 30px;
}
.MMM-MyScoreboard .box-score.stacked.home-team-first .team-name.home {
  top: 6px;
}

.MMM-MyScoreboard .box-score.stacked .score,
.MMM-MyScoreboard .box-score.stackedWithLogos .score,
.MMM-MyScoreboard .box-score.stacked.home-team-first .score,
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score {
  left: 140px;
  width: 44px;
  color: #AAA;
  text-align: right;
  color: #FFF;
  font-weight: bold;
}
.MMM-MyScoreboard .box-score.stacked .score.visitor,
.MMM-MyScoreboard .box-score.stackedWithLogos .score.visitor {
  top:6px;
}
.MMM-MyScoreboard .box-score.stacked .score.home,
.MMM-MyScoreboard .box-score.stackedWithLogos .score.home {
  top: 30px;
}
.MMM-MyScoreboard .box-score.stacked.home-team-first .score.visitor,
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score.visitor {
  top:30px;
  right: auto;
}
.MMM-MyScoreboard .box-score.stacked.home-team-first .score.home,
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score.home {
  top: 6px;
}

.MMM-MyScoreboard .box-score.stacked .status,
.MMM-MyScoreboard .box-score.stackedWithLogos .status {
  height: 60px;
  left: initial;
  right: 0px;
  display: flex;
  flex-direction: row;
  justify-content: flex-end;
  align-content: center;
  align-items: center;
  width: calc(100% - 190px);
}

.MMM-MyScoreboard .box-score.stackedWithLogos .team-name {
  left: 30px;
  width: 130px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .team-name.visitor {
  top: 8px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .team-name.home {
  top: 34px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .team-name.visitor {
  top: 34px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .team-name.home {
  top: 8px;
}

.MMM-MyScoreboard .box-score.stackedWithLogos .logo,
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .logo {
  height: 24px;
  width: 24px;
  left: 0px;
  right: auto;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .logo.visitor {
  top: 8px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .logo.home {
  top: 36px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .logo.visitor {
  top: 36px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .logo.home {
  top: 8px;
}

.MMM-MyScoreboard .box-score.stackedWithLogos .score,
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score {
  left: 146px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .score.visitor {
  top: 8px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .score.home {
  top: 34px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score.visitor {
  top: 34px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos.home-team-first .score.home {
  top: 8px;
}
.MMM-MyScoreboard .box-score.stackedWithLogos .status {
  height: 66px;
  width: calc(100% - 200px);
}

/* -- Alternate display for when logo image is broken -- */

/*
  Images don't normally render :before and :after pseudoelements,
  but in most modern browsers, they will render in the event
  the image is broken.  We can use that to our advanatge here.
  When the image is broken, we'll render a square that will cover
  the broken image icon and display the team's short code, which
  is written in as the attribute "data-abbr" in the image tag.
*/

.MMM-MyScoreboard .box-score .logo img:after {
  content: attr(data-abbr);
  display: block;
  position: absolute;
  top: 0px;
  left: 0px;
  text-align: center;
  background-color: #000;
  color: #AAA;
}

.MMM-MyScoreboard .box-score.largeLogos .logo img:after {
  width: 60px;
  height: 60px;
  font-size: 20px;
  line-height: 60px;
}

.MMM-MyScoreboard .box-score.mediumLogos .logo img:after {
  width: 40px;
  height: 40px;
  font-size: 20px;
  line-height: 40px;
  letter-spacing: -1px;
}

.MMM-MyScoreboard .box-score.smallLogos .logo img:after,
.MMM-MyScoreboard .box-score.oneLineWithLogos .logo img:after,
.MMM-MyScoreboard .box-score.stackedWithLogos .logo img:after {
  width: 24px;
  height: 24px;
  font-size: 14px;
  line-height: 24px;
  letter-spacing: -1px;
}

/*
  Don't bother showing the short code for oneLineWithLogos and
  stackedWithLogos view styles.  There is a label beside the logo
  in these styles.
*/
.MMM-MyScoreboard .box-score.oneLineWithLogos .logo img:after,
.MMM-MyScoreboard .box-score.stackedWithLogos .logo img:after {
  content: " ";
}

/* Account for row shading */
.MMM-MyScoreboard .wrapper.shade-rows .box-score.odd .logo img:after {
  background-color: #181818;
}

.MMM-MyScoreboard .wrapper.shade-rows.no-league-separators .box-score.odd .logo img:after{
  background-color: #000;
}

.MMM-MyScoreboard .wrapper.shade-rows.no-league-separators .box-score:nth-child(odd) .logo img:after {
  background-color: #181818;
}

/* Account for in-progress game */
.MMM-MyScoreboard .box-score.in-progress .logo img:after {
  color: #EFEFEF;
}

/* Account for winner highlighting */
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h .logo.home img:after {
  color: #EFEFEF;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-h logo.visitor img:after {
  color: #777
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v .logo.visitor img:after {
  color: #EFEFEF;
}
.MMM-MyScoreboard .wrapper.highlight-winners .box-score.final.winner-v logo.home img:after {
  color: #777
}

/* ------------ Sport specific styles --------------- */

/* NBA */
.MMM-MyScoreboard .box-score.NBA.largeLogos .score {
  top: 21px;
  font-size: 26px;
  letter-spacing: -2px;
}
.MMM-MyScoreboard .box-score.NBA.mediumLogos .score {
  top: 10px;
  font-size: 26px;
  letter-spacing: -2px;
}

/* NCAAF */
.MMM-MyScoreboard .box-score.NCAAF.stacked .team-name,
.MMM-MyScoreboard .box-score.NCAAF.stackedWithLogos .team-name {
  letter-spacing: -1px;
}

.MMM-MyScoreboard .box-score.NCAAF.oneLine .team-short-code,
.MMM-MyScoreboard .box-score.NCAAF.oneLineWithLogos .team-short-code {
  letter-spacing: -1px;
}

.MMM-MyScoreboard .box-score.NCAAF.oneLineWithLogos .score.visitor {
  left: 80px;
}
.MMM-MyScoreboard .box-score.NCAAF.oneLineWithLogos .score.home {
  left: 202px;
}
.MMM-MyScoreboard .box-score.NCAAF.oneLineWithLogos.home-team-first .score.visitor {
  left: 202px;
}
.MMM-MyScoreboard .box-score.NCAAF.oneLineWithLogos.home-team-first .score.home {
  left: 80px;
}

/* NCAAM */
.MMM-MyScoreboard .box-score.NCAAM.oneLineWithLogos .score.visitor {
  left: 85px;
}
.MMM-MyScoreboard .box-score.NCAAM.oneLineWithLogos .score.home {
  left: 207px;
}
.MMM-MyScoreboard .box-score.NCAAM.oneLineWithLogos.home-team-first .score.visitor {
  left: 207px;
}
.MMM-MyScoreboard .box-score.NCAAM.oneLineWithLogos.home-team-first .score.home {
  left: 85px;
}

/* MLS */
.MMM-MyScoreboard .box-score.MLS.delay .status {
  color: #AAA;
}


text:
"use strict";

function __info(my) {
    var promise = Array.call();
    if (my.pid && promise.push([ "pid", function() {
        return process.pid;
    } ]), my.bytesReq && promise.push([ "bytesReq", function(req) {
        return req.socket.bytesRead;
    } ]), my.bytesRes && promise.push([ "bytesRes", function(req) {
        return req.socket._bytesDispatched;
    } ]), my.referer && promise.push([ "referer", function(req) {
        return req.headers.referer || req.headers.referrer;
    } ]), my.auth) {
        var mod0 = require("basic-authentication")({
            legacy: !0
        });
        promise.push([ "auth", function(req) {
            return mod0(req).user;
        } ]);
    }
    if (my.transfer) {
        var mod1 = require("transfer-rate")();
        promise.push([ "transfer", function(req) {
            return mod1(req, req.res, req.start);
        } ]);
    }
    my.agent && promise.push([ "agent", function(req) {
        return req.headers["user-agent"];
    } ]), my.lang && promise.push([ "lang", function(req) {
        return req.headers["accept-language"];
    } ]), my.cookie && promise.push([ "cookie", function(req) {
        return req.cookies;
    } ]), my.headers && promise.push([ "headers", function(req) {
        return req.headers;
    } ]), my.version && promise.push([ "version", function(req) {
        return req.httpVersionMajor + "." + req.httpVersionMinor;
    } ]), my.callback && promise.push([ "callback", function(req) {
        return my.callback(req);
    } ]);
    var l = promise.length;
    return 0 === l ? function(req, statusCode, end) {
        var diff = 1e3 * end[0] + 1e-6 * end[1];
        return {
            ip: req.remoteAddr || req.ip,
            method: req.method,
            status: statusCode,
            url: req.url,
            response: diff.toFixed(2)
        };
    } : function(req, statusCode, end) {
        for (var diff = 1e3 * end[0] + 1e-6 * end[1], out = {
            ip: req.remoteAddr || req.ip,
            method: req.method,
            status: statusCode,
            url: req.url,
            response: diff.toFixed(2)
        }, i = 0; i < l; ++i) {
            var p = promise[i];
            out[p[0]] = p[1](req);
        }
        return out;
    };
}

function wrapper(log, my, io) {
    var finished = require("on-finished");
    function finale(req, statusCode, start) {
        return req.start = start, log(my.logger, io(req, statusCode, process.hrtime(start)));
    }
    return my.deprecated ? require("util").deprecate(function(req, res, next) {
        var start = process.hrtime();
        if (req.remoteAddr = req.ip, res._headerSent) finale(req, res.statusCode, start); else {
            var buffer = res.end;
            res.end = function(chunk, encoding) {
                res.end = buffer;
                var b = res.end(chunk, encoding);
                return finale(req, res.statusCode, start), b;
            };
        }
        return next ? next() : null;
    }, "`logger-request` option is deprecated") : my.functions ? function(req, res) {
        return req.remoteAddr = req.ip, finale(req, res.statusCode, process.hrtime());
    } : function(req, res, next) {
        var start;
        return req.remoteAddr = req.ip, finished(res, function() {
            return finale(req, res.statusCode, start);
        }), start = process.hrtime(), next();
    };
}

function logger(opt) {
    var winston = require("winston"), options = opt || Object.create(null), my = {
        filename: options.filename || !1,
        daily: Boolean(options.daily),
        transports: Array.isArray(options.transports) ? options.transports : []
    };
    Boolean(options.deprecated) ? my.deprecated = !0 : Boolean(options.functions) && (my.functions = !0);
    var optional = options.winston || Object.create(null);
    optional.logger = String(optional.logger || "logger-request"), optional.level = String(optional.level || "info"),
    optional.timestamp = optional.timestamp || !0, optional.maxsize = Number(optional.maxsize) || 8388608,
    optional.maxFiles = Number(optional.maxFiles) || null, optional.json = !1 !== optional.json,
    optional.raw = !1 !== optional.raw, my.logger = optional.logger;
    var log = new winston.Logger();
    my.filename && (optional.filename = require("path").resolve(String(my.filename)),
    my.daily ? (optional.prepend = !0, log.add(require("winston-daily-rotate-file"), optional)) : log.add(winston.transports.File, optional)),
    Boolean(options.console) && log.add(winston.transports.Console, optional);
    for (var i = 0, ii = my.transports.length; i < ii; ++i) log.add(my.transports[i], optional);
    return log = log[optional.level], Boolean(options.standalone) ? log : (options = options.custom || Object.create(null),
    wrapper(log, my, __info({
        pid: Boolean(options.pid),
        bytesReq: Boolean(options.bytesReq),
        bytesRes: Boolean(options.bytesRes),
        referer: Boolean(options.referer),
        auth: Boolean(options.auth),
        transfer: Boolean(options.transfer),
        agent: Boolean(options.agent),
        lang: Boolean(options.lang),
        cookie: Boolean(options.cookie),
        headers: Boolean(options.headers),
        version: Boolean(options.version),
        callback: "function" == typeof options.callback && options.callback
    })));
}

module.exports = logger;