text:
<?xml version="1.0"?>
<!DOCTYPE module PUBLIC
    "-//Puppy Crawl//DTD Check Configuration 1.2//EN"
    "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">

<!--
  Please refer to the documentation at http://checkstyle.sourceforge.net/config.html for details
-->

<module name="Checker">
  <property name="severity" value="warning"/>

  <module name="NewlineAtEndOfFile"/>
  <module name="Translation"/>

  <!-- See http://checkstyle.sf.net/config_sizes.html -->
  <module name="FileLength">
    <property name="max" value="1500"/>
  </module>
  <module name="FileTabCharacter"/>

  <module name="TreeWalker">
    <!-- Javadoc -->
    <module name="JavadocMethod">
      <property name="scope" value="public"/>
      <property name="allowUndeclaredRTE" value="true"/>
      <property name="allowMissingPropertyJavadoc" value="true"/>
    </module>

    <module name="JavadocType">
      <property name="scope" value="public"/>
    </module>

    <module name="JavadocVariable">
      <property name="scope" value="protected"/>
    </module>

    <module name="JavadocStyleCheck">
      <property name="checkEmptyJavadoc" value="true"/>
      <property name="checkFirstSentence" value="false"/>
      <property name="checkHtml" value="false"/>
      <property name="scope" value="public"/>
    </module>

    <!-- Naming -->
    <module name="ConstantName"/>
    <module name="LocalFinalVariableName"/>
    <module name="LocalVariableName"/>
    <module name="MemberName"/>
    <module name="MethodName"/>
    <module name="PackageName"/>
    <module name="ParameterName">
      <property name="format" value="^[a-zA-Z0-9]*$"/>
    </module>
    <module name="StaticVariableName"/>

    <module name="TypeName"/>

    <!-- Checks for Headers                              -->
    <!-- See http://checkstyle.sf.net/config_header.html -->
    <!--
    <module name="Header">
        <property name="headerFile" value="${checkstyle.header.file}"/>
    </module>
    -->

    <!-- Following interprets the header file as regular expressions. -->
    <!-- <module name="RegexpHeader"/>                                -->

    <!-- Checks for imports                              -->
    <!-- See http://checkstyle.sf.net/config_import.html -->
    <!-- module name="AvoidStarImport"/-->
    <module name="IllegalImport"/> <!-- defaults to sun.* packages -->
    <module name="RedundantImport"/>
    <module name="UnusedImports"/>

    <!-- Checks for Size Violations.                    -->
    <module name="LineLength">
      <property name="max" value="120"/>
      <property name="ignorePattern" value="^\s*\*\s*\S"/>
    </module>
    <module name="MethodLength">
      <property name="max" value="150"/>
    </module>
    <module name="AnonInnerLength">
      <property name="max" value="30"/>
    </module>
    <module name="ParameterNumber"/>

    <!-- Whitespace -->
    <module name="EmptyForIteratorPad"/>

    <module name="NoWhitespaceAfter"/>
    <module name="NoWhitespaceBefore"/>

    <!-- <module name="OperatorWrap"/> -->
    <module name="ParenPad"/>

    <module name="TypecastParenPad"/>
    <module name="WhitespaceAfter"/>
    <module name="WhitespaceAround">
      <property name="allowEmptyConstructors" value="true"/>
      <property name="allowEmptyMethods" value="true"/>
      <property name="tokens"
                value=
               "ASSIGN, BAND, BAND_ASSIGN, BOR, BOR_ASSIGN, BSR, BSR_ASSIGN,
                BXOR, BXOR_ASSIGN, COLON, DIV, DIV_ASSIGN, EQUAL, GE, GT, LAND, LCURLY,
                LE, LITERAL_ASSERT, LITERAL_CATCH, LITERAL_DO, LITERAL_ELSE, LITERAL_FINALLY,
                LITERAL_FOR, LITERAL_IF, LITERAL_RETURN, LITERAL_SYNCHRONIZED, LITERAL_TRY,
                LITERAL_WHILE, LOR, LT, MINUS, MINUS_ASSIGN, MOD, MOD_ASSIGN, NOT_EQUAL,
                PLUS, PLUS_ASSIGN, QUESTION, SL, SLIST, SL_ASSIGN, SR, SR_ASSIGN,
                STAR, STAR_ASSIGN, TYPE_EXTENSION_AND, WILDCARD_TYPE"/>
    </module>

    <!-- Modifier Checks -->
    <!-- See http://checkstyle.sf.net/config_modifiers.html -->

    <!-- <module name="ModifierOrder"/> -->
    <module name="RedundantModifier"/>

    <!-- Checks for blocks. You know, those {}'s -->
    <!-- See http://checkstyle.sf.net/config_blocks.html -->
    <module name="AvoidNestedBlocks"/>
    <module name="EmptyBlock">
      <property name="option" value="text"/>
    </module>
    <module name="LeftCurly"/>
    <module name="NeedBraces"/>
    <module name="RightCurly">
      <property name="option" value="same"/>
      <property name="tokens" value="LITERAL_CATCH,LITERAL_ELSE,LITERAL_TRY"/>
    </module>

    <!-- Checks for common coding problems -->
    <!-- See http://checkstyle.sf.net/config_coding.html -->
    <!-- <module name="AvoidInlineConditionals"/> -->
    <module name="DoubleCheckedLocking"/>
    <module name="EmptyStatement"/>
    <module name="EqualsHashCode"/>
    <module name="HiddenField">
        <property name="severity" value="error"/>
    </module>
    <module name="InnerAssignment"/>
    <!-- <module name="MagicNumber"/> -->
    <module name="MissingSwitchDefault"/>
    <module name="RedundantThrows">
      <property name="allowUnchecked" value="true"/>
    </module>
    <module name="RedundantThrows"/>

    <module name="SimplifyBooleanExpression"/>
    <module name="SimplifyBooleanReturn"/>
    <module name="StringLiteralEquality"/>
    <module name="IllegalCatch">
      <property name="severity" value="warning"/>
    </module>
    <module name="JUnitTestCase"/>
    <module name="ParameterAssignment"/>

    <module name="UnnecessaryParentheses"/>

    <!-- Checks for class design -->
    <!-- See http://checkstyle.sf.net/config_design.html -->
    <!-- <module name="DesignForExtension"/> -->
    <module name="FinalClass"/>
    <module name="HideUtilityClassConstructor"/>
    <module name="InterfaceIsType"/>

    <module name="VisibilityModifier">
      <property name="protectedAllowed" value="true"/>
    </module>

    <!-- Miscellaneous other checks. -->
    <!-- See http://checkstyle.sf.net/config_misc.html -->
    <module name="ArrayTypeStyle"/>
    <!-- <module name="FinalParameters"/> -->

    <module name="TodoComment">
        <property name="severity" value="info"/>
    </module>

    <module name="UpperEll"/>

    <module name="UncommentedMain"/>

    <!-- Needed for the suppression comment holder to work -->
    <module name="FileContentsHolder"/>
  </module>

  <module name="RegexpSingleline">
    <property name="format" value="printStacktrace"/>
    <property name="message"
              value="Don't dump stacktraces with printStacktrace(). Use logging instead"/>
  </module>

  <module name="RegexpSingleline">
    <property name="format" value="System\.(out|err)\.print"/>
    <property name="message"
              value="System.out.println and System.err.println are not allowed. Use logging instead."/>
  </module>

  <module name="RegexpSingleline">
    <property name="format" value="\s+$"/>
    <property name="message" value="Avoid trailing spaces in a line"/>
  </module>

  <!-- Filter for supressing checkstyle comments-->
  <module name="SuppressionCommentFilter">
    <property name="offCommentFormat" value="CS\:OFF"/>
    <property name="onCommentFormat" value="CS\:ON"/>
  </module>
</module>


text:
// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2018 The Machinecoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#ifndef MACHINECOIN_SYNC_H
#define MACHINECOIN_SYNC_H

#include <threadsafety.h>

#include <condition_variable>
#include <thread>
#include <mutex>

////////////////////////////////////////////////
//                                            //
// THE SIMPLE DEFINITION, EXCLUDING DEBUG CODE //
//                                            //
////////////////////////////////////////////////

/*
CCriticalSection mutex;
    std::recursive_mutex mutex;

LOCK(mutex);
    std::unique_lock<std::recursive_mutex> criticalblock(mutex);

LOCK2(mutex1, mutex2);
    std::unique_lock<std::recursive_mutex> criticalblock1(mutex1);
    std::unique_lock<std::recursive_mutex> criticalblock2(mutex2);

TRY_LOCK(mutex, name);
    std::unique_lock<std::recursive_mutex> name(mutex, std::try_to_lock_t);

ENTER_CRITICAL_SECTION(mutex); // no RAII
    mutex.lock();

LEAVE_CRITICAL_SECTION(mutex); // no RAII
    mutex.unlock();
 */

///////////////////////////////
//                           //
// THE ACTUAL IMPLEMENTATION //
//                           //
///////////////////////////////

/**
 * Template mixin that adds -Wthread-safety locking
 * annotations to a subset of the mutex API.
 */
template <typename PARENT>
class LOCKABLE AnnotatedMixin : public PARENT
{
public:
    void lock() EXCLUSIVE_LOCK_FUNCTION()
    {
        PARENT::lock();
    }

    void unlock() UNLOCK_FUNCTION()
    {
        PARENT::unlock();
    }

    bool try_lock() EXCLUSIVE_TRYLOCK_FUNCTION(true)
    {
        return PARENT::try_lock();
    }
};

#ifdef DEBUG_LOCKORDER
void EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false);
void LeaveCritical();
std::string LocksHeld();
void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) ASSERT_EXCLUSIVE_LOCK(cs);
void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs);
void DeleteLock(void* cs);
#else
void static inline EnterCritical(const char* pszName, const char* pszFile, int nLine, void* cs, bool fTry = false) {}
void static inline LeaveCritical() {}
void static inline AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) ASSERT_EXCLUSIVE_LOCK(cs) {}
void static inline AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, void* cs) {}
void static inline DeleteLock(void* cs) {}
#endif
#define AssertLockHeld(cs) AssertLockHeldInternal(#cs, __FILE__, __LINE__, &cs)
#define AssertLockNotHeld(cs) AssertLockNotHeldInternal(#cs, __FILE__, __LINE__, &cs)

/**
 * Wrapped mutex: supports recursive locking, but no waiting
 * TODO: We should move away from using the recursive lock by default.
 */
class CCriticalSection : public AnnotatedMixin<std::recursive_mutex>
{
public:
    ~CCriticalSection() {
        DeleteLock((void*)this);
    }
};

/** Wrapped mutex: supports waiting but not recursive locking */
typedef AnnotatedMixin<std::mutex> CWaitableCriticalSection;

/** Just a typedef for std::condition_variable, can be wrapped later if desired */
typedef std::condition_variable CConditionVariable;

/** Just a typedef for std::unique_lock, can be wrapped later if desired */
typedef std::unique_lock<std::mutex> WaitableLock;

#ifdef DEBUG_LOCKCONTENTION
void PrintLockContention(const char* pszName, const char* pszFile, int nLine);
#endif

/** Wrapper around std::unique_lock<CCriticalSection> */
class SCOPED_LOCKABLE CCriticalBlock
{
private:
    std::unique_lock<CCriticalSection> lock;

    void Enter(const char* pszName, const char* pszFile, int nLine)
    {
        EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()));
#ifdef DEBUG_LOCKCONTENTION
        if (!lock.try_lock()) {
            PrintLockContention(pszName, pszFile, nLine);
#endif
            lock.lock();
#ifdef DEBUG_LOCKCONTENTION
        }
#endif
    }

    bool TryEnter(const char* pszName, const char* pszFile, int nLine)
    {
        EnterCritical(pszName, pszFile, nLine, (void*)(lock.mutex()), true);
        lock.try_lock();
        if (!lock.owns_lock())
            LeaveCritical();
        return lock.owns_lock();
    }

public:
    CCriticalBlock(CCriticalSection& mutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(mutexIn) : lock(mutexIn, std::defer_lock)
    {
        if (fTry)
            TryEnter(pszName, pszFile, nLine);
        else
            Enter(pszName, pszFile, nLine);
    }

    CCriticalBlock(CCriticalSection* pmutexIn, const char* pszName, const char* pszFile, int nLine, bool fTry = false) EXCLUSIVE_LOCK_FUNCTION(pmutexIn)
    {
        if (!pmutexIn) return;

        lock = std::unique_lock<CCriticalSection>(*pmutexIn, std::defer_lock);
        if (fTry)
            TryEnter(pszName, pszFile, nLine);
        else
            Enter(pszName, pszFile, nLine);
    }

    ~CCriticalBlock() UNLOCK_FUNCTION()
    {
        if (lock.owns_lock())
            LeaveCritical();
    }

    operator bool()
    {
        return lock.owns_lock();
    }
};

#define PASTE(x, y) x ## y
#define PASTE2(x, y) PASTE(x, y)

#define LOCK(cs) CCriticalBlock PASTE2(criticalblock, __COUNTER__)(cs, #cs, __FILE__, __LINE__)
#define LOCK2(cs1, cs2) CCriticalBlock criticalblock1(cs1, #cs1, __FILE__, __LINE__), criticalblock2(cs2, #cs2, __FILE__, __LINE__)
#define TRY_LOCK(cs, name) CCriticalBlock name(cs, #cs, __FILE__, __LINE__, true)

#define ENTER_CRITICAL_SECTION(cs)                            \
    {                                                         \
        EnterCritical(#cs, __FILE__, __LINE__, (void*)(&cs)); \
        (cs).lock();                                          \
    }

#define LEAVE_CRITICAL_SECTION(cs) \
    {                              \
        (cs).unlock();             \
        LeaveCritical();           \
    }

class CSemaphore
{
private:
    std::condition_variable condition;
    std::mutex mutex;
    int value;

public:
    explicit CSemaphore(int init) : value(init) {}

    void wait()
    {
        std::unique_lock<std::mutex> lock(mutex);
        condition.wait(lock, [&]() { return value >= 1; });
        value--;
    }

    bool try_wait()
    {
        std::lock_guard<std::mutex> lock(mutex);
        if (value < 1)
            return false;
        value--;
        return true;
    }

    void post()
    {
        {
            std::lock_guard<std::mutex> lock(mutex);
            value++;
        }
        condition.notify_one();
    }
};

/** RAII-style semaphore lock */
class CSemaphoreGrant
{
private:
    CSemaphore* sem;
    bool fHaveGrant;

public:
    void Acquire()
    {
        if (fHaveGrant)
            return;
        sem->wait();
        fHaveGrant = true;
    }

    void Release()
    {
        if (!fHaveGrant)
            return;
        sem->post();
        fHaveGrant = false;
    }

    bool TryAcquire()
    {
        if (!fHaveGrant && sem->try_wait())
            fHaveGrant = true;
        return fHaveGrant;
    }

    void MoveTo(CSemaphoreGrant& grant)
    {
        grant.Release();
        grant.sem = sem;
        grant.fHaveGrant = fHaveGrant;
        fHaveGrant = false;
    }

    CSemaphoreGrant() : sem(nullptr), fHaveGrant(false) {}

    explicit CSemaphoreGrant(CSemaphore& sema, bool fTry = false) : sem(&sema), fHaveGrant(false)
    {
        if (fTry)
            TryAcquire();
        else
            Acquire();
    }

    ~CSemaphoreGrant()
    {
        Release();
    }

    operator bool() const
    {
        return fHaveGrant;
    }
};

#endif // MACHINECOIN_SYNC_H

redpajama_set_name: RedPajamaGithub


text:
#include "OgreLodWorkQueueInjector.h"
#include "OgreLodWorkQueueInjectorListener.h"
#include "OgreLodWorkQueueRequest.h"
#include "OgreMeshLodGenerator.h"
#include "OgreRoot.h"

namespace Ogre
{
	template<> LodWorkQueueInjector* Singleton<LodWorkQueueInjector>::msSingleton = 0;
	LodWorkQueueInjector* LodWorkQueueInjector::getSingletonPtr(void)
	{
		return msSingleton;
	}
	LodWorkQueueInjector& LodWorkQueueInjector::getSingleton(void)
	{
		assert( msSingleton );  return ( *msSingleton );
	}

	LodWorkQueueInjector::LodWorkQueueInjector() :
		mInjectorListener(0)
	{
		WorkQueue* wq = Root::getSingleton().getWorkQueue();
		unsigned short workQueueChannel = wq->getChannel("PMGen");
		wq->addResponseHandler(workQueueChannel, this);
	}

	LodWorkQueueInjector::~LodWorkQueueInjector()
	{
		Root* root = Root::getSingletonPtr();
		if (root) {
			WorkQueue* wq = root->getWorkQueue();
			if (wq) {
				unsigned short workQueueChannel = wq->getChannel("PMGen");
				wq->removeResponseHandler(workQueueChannel, this);
			}
		}
	}

	void LodWorkQueueInjector::handleResponse(const WorkQueue::Response* res, const WorkQueue* srcQ)
	{
		LodWorkQueueRequest* request = any_cast<LodWorkQueueRequest*>(res->getData());

		if(mInjectorListener){
			if(!mInjectorListener->shouldInject(request)) {
				return;
			}
		}

		request->output->inject();
		MeshLodGenerator::_configureMeshLodUsage(request->config);
		//lodConfig.mesh->buildEdgeList();

		if(mInjectorListener){
			mInjectorListener->injectionCompleted(request);
		}
	}

}


text:
package io.github.kaioru.species.forme;

import java.io.Serializable;
import java.util.List;

import io.github.kaioru.species.SpeciesStat;

/**
 * @todo Class Description
 *
 * @author Kaioru
 **/
public abstract class SpeciesForme implements Serializable {

	private static final long serialVersionUID = -8100723888240177965L;

	private Integer formeId;
	private String formeName;
	private String primaryType, secondaryType;
	private String species; // Doubt this ever changes but oh well..

	public Integer getFormeId() {
		return formeId;
	}

	public void setFormeId(Integer formeId) {
		this.formeId = formeId;
	}

	public String getFormeName() {
		return formeName;
	}

	public void setFormeName(String formeName) {
		this.formeName = formeName;
	}

	public String getPrimaryType() {
		return primaryType;
	}

	public void setPrimaryType(String primaryType) {
		this.primaryType = primaryType;
	}

	public String getSecondaryType() {
		return secondaryType;
	}

	public void setSecondaryType(String secondaryType) {
		this.secondaryType = secondaryType;
	}

	public String getSpecies() {
		return species;
	}

	public void setSpecies(String species) {
		this.species = species;
	}

	public abstract List<String> getAbilities();

	public abstract void setAbilities(List<String> abilities);

	public abstract List<String> getHiddenAbilities();

	public abstract void setHiddenAbilities(List<String> hiddenAbilities);

	public abstract SpeciesStat getBaseStats();

	public abstract void setBaseStats(SpeciesStat baseStats);

	public abstract SpeciesStat getEVYield();

	public abstract void setEVYield(SpeciesStat evYield);

	public abstract Short getCaptureRate();

	public abstract void setCaptureRate(Short captureRate);

	public abstract Short getBaseHappiness();

	public abstract void setBaseHappiness(Short baseHappiness);

	public abstract Short getBaseExperience();

	public abstract void setBaseExperience(Short baseExperience);

	public abstract String getGrowthRate();

	public abstract void setGrowthRate(String growthRate);

}


text:
:root {
  --primary-foreground:#d1e5d4;
  --primary-background:#262625;
  --secondary-background: #474745;
  --primary-accent:#57c589;
  --secondary-accent:#2B4737;
  --secondary-foreground:#D4CC90;
  --normal-text-weight: 300;
  --bold-text-weight: 400;
}

body {
  background-color: var(--primary-background);
  color: var(--primary-foreground);
  font-weight: var(--normal-text-weight);
	font-feature-settings: "kern";
	font-kerning: normal;
  font-variant-ligatures: common-ligatures;
}
html,
button,
input,
select,
textarea,
.pure-g [class *= "pure-u"] {
  font-family: 'Source Sans Pro', sans-serif;
}

.donate-content-area {
  margin: 5px;
  padding: 5px;
  background-color: var(--secondary-foreground);
  border-radius: 2px;
  text-align: center;
  height: 120px;
}

.donate-content-area h3, .donate-content-area code {
  color: var(--primary-background);
}

tr td, th {
  border: 1px solid var(--secondary-background);
}

td, th {
  padding: 5px;
}

th {
  background: var(--secondary-accent);
}

a, a:visited {
  text-decoration: none;
  color: var(--primary-accent);
}

header .luxbar-menu i {
  vertical-align: text-bottom;
  line-height: 18px;
}

.luxbar-menu-light {
  background: var(--secondary-accent);
  color: var(--primary-foreground);
}

.luxbar-menu-light a, .luxbar-menu-light a:visited {
  color: var(--primary-foreground);
}

.luxbar-menu-light .active, .luxbar-menu-light .luxbar-item:hover,
.luxbar-menu-light .active a, .luxbar-menu-light .luxbar-item:hover a {
  background: var(--primary-background);
  color: var(--primary-accent);
}

.luxbar-menu-light .luxbar-hamburger span,
.luxbar-menu-light .luxbar-hamburger span::before,
.luxbar-menu-light .luxbar-hamburger span::after {
  background-color: var(--primary-foreground);
}

.pure-button-primary, .pure-button-selected, a.pure-button-primary, a.pure-button-selected {
  background: var(--primary-accent);
  color: var(--primary-background);
}

.pure-g > section {
  box-sizing: border-box;
}

article {
  margin-top: 40px;
}

:target:before {
  content:"";
  display:block;
  height:60px;
  margin:-60px 0 0;
}

article, section {
  padding: 1em;
}

.centered {
  text-align: center;
  margin: auto;
}

b, strong, dt {
  font-weight: var(--bold-text-weight);
}

dt {
  margin-top: 1em;
}

code, pre, .kwd, .cmd, .file, .dir, kbd, .kbd, .ext, .min-terminal {
  font-family: 'Source Code Pro',  monospace;
  font-size: 90%;
}

.kwd, .kwd, .cmd, .file, .dir, .ext, kbd, .kbd {
  font-weight: var(--bold-text-weight);
}

h1, h2, h3, h4, h5, h6 {
  font-weight: var(--normal-text-weight);
  color: var(--secondary-foreground);
}

.pitch {
  font-size: 1.2em;
}

.operator {
  margin-left: 2em;
}

dl {
  margin-left: 1em;
}

.min-terminal {
  border: 1px solid var(--secondary-accent);
  padding: 5px;
  white-space: pre;
}

.min-terminal p {
  margin: 0.5em 0;
}

.min-terminal p:first-child {
  margin-top: 0;
}

.min-terminal p:last-child {
  margin-bottom: 0;
}

.min-terminal .prompt {
  color: var(--secondary-foreground);
}

.note p:first-child:before {
  font-family: "themify";
  font-style: normal;
  font-weight: var(--normal-text-weight);
  font-size: 100%;
  content: "\e717" " ";
}
.tip p:first-child:before {
  font-family: "themify";
  font-style: normal;
  font-weight: var(--normal-text-weight);
  font-size: 100%;
  content: "\e64d" " ";
}
.warning p:first-child:before {
  font-family: "themify";
  font-style: normal;
  font-weight: var(--normal-text-weight);
  font-size: 100%;
  content: "\e6c5" " ";
}
.sidebar, .note, .tip, .warning, pre {
  -moz-background-clip: padding;
  -webkit-background-clip: padding-box;
  background-clip: padding-box;
  -webkit-border-radius: 3px;
  -moz-border-radius: 3px;
  border-radius: 3px;
  margin: 10px auto;
  padding: 2px 4px 2px 4px;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
  background-color: var(--secondary-background);
  font-size: 90%;
}

.sidebar pre {
  box-shadow: none;
}

.sidebar p:first-child,
.note p:first-child,
.tip p:first-child,
.warning p:first-child {
  font-weight: var(--bold-text-weight);
}
.sidebar p:first-child:before {
  font-family: "themify";
  font-style: normal;
  font-weight: var(--normal-text-weight);
  font-size: 100%;
  content: "\e717" " ";
}
.tip p, .warning p, .note p, .sidebar p {
  margin: 0 auto;
  line-height: 1.7em;
}

.sigil {
  color: var(--primary-foreground);
}
.sigil:before {
  color: var(--primary-foreground);
  background-color: var(--secondary-accent);
  padding: 0 3px 0;
  display: inline-block;
  width: auto;
  margin: 1px;
  -webkit-border-radius: 2px;
  -moz-border-radius: 2px;
  border-radius: 2px;
  -moz-background-clip: padding;
  -webkit-background-clip: padding-box;
  background-clip: padding-box;
  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
  -webkit-border-radius: 4px;
  -moz-border-radius: 4px;
  border-radius: 4px;
  padding: 1px 1px 1px 1px;
  height: 25px;
  width: 50px;
  text-align: center;
  margin-right: 3px;
  box-shadow: none;
  font-size: 90%;
  font-variant: small-caps;
  font-weight: var(--bold-text-weight);
  content: "sigil";
}

footer {
  font-size: 80%;
  text-align: center;
  margin: auto;
  padding: 5px;
}


text:
#pragma once

#include "CSSGroupingRule.h"

namespace WebCore {

class MediaList;
class StyleRuleMedia;

class CSSMediaRule final : public CSSGroupingRule {
public:
    static Ref<CSSMediaRule> create(StyleRuleMedia& rule, CSSStyleSheet* sheet) { return adoptRef(*new CSSMediaRule(rule, sheet)); }

    virtual ~CSSMediaRule();

    void reattach(StyleRuleBase&) override;
    String cssText() const override;

    MediaList* media() const;

private:
    CSSMediaRule(StyleRuleMedia&, CSSStyleSheet*);

    CSSRule::Type type() const override { return MEDIA_RULE; }

    MediaQuerySet* mediaQueries() const;

    mutable RefPtr<MediaList> m_mediaCSSOMWrapper;
};

} // namespace WebCore

SPECIALIZE_TYPE_TRAITS_CSS_RULE(CSSMediaRule, CSSRule::MEDIA_RULE)


text:
require_relative "../user"

class Chef
  class Provider
    class User
      class Aix < Chef::Provider::User
        provides :user, os: "aix"
        provides :aix_user

        def create_user
          shell_out!("useradd", universal_options, useradd_options, new_resource.username)
          add_password
        end

        def manage_user
          add_password
          manage_home
          return if universal_options.empty? && usermod_options.empty?

          shell_out!("usermod", universal_options, usermod_options, new_resource.username)
        end

        def remove_user
          shell_out!("userdel", userdel_options, new_resource.username)
        end

        # Aix does not support -r like other unix, system account is created by adding to 'system' group
        def useradd_options
          opts = []
          opts << "-g" << "system" if new_resource.system
          if updating_home?
            if new_resource.manage_home
              logger.trace("#{new_resource} managing the users home directory")
              opts << "-m"
            else
              logger.trace("#{new_resource} setting home to #{new_resource.home}")
            end
          end
          opts
        end

        def userdel_options
          opts = []
          opts << "-r" if new_resource.manage_home
          opts << "-f" if new_resource.force
          opts
        end

        def usermod_options
          []
        end

        def check_lock
          lock_info = shell_out!("lsuser", "-a", "account_locked", new_resource.username)
          if whyrun_mode? && passwd_s.stdout.empty? && lock_info.stderr.include?("does not exist")
            # if we're in whyrun mode and the user is not yet created we assume it would be
            return false
          end
          raise Chef::Exceptions::User, "Cannot determine if #{new_resource} is locked!" if lock_info.stdout.empty?

          status = /\S+\s+account_locked=(\S+)/.match(lock_info.stdout)
          @locked =
            if status && status[1] == "true"
              true
            else
              false
            end

          @locked
        end

        def lock_user
          shell_out!("chuser", "account_locked=true", new_resource.username)
        end

        def unlock_user
          shell_out!("chuser", "account_locked=false", new_resource.username)
        end

        def universal_options
          opts = []
          opts << "-c" << new_resource.comment if should_set?(:comment)
          opts << "-g" << new_resource.gid if should_set?(:gid)
          opts << "-s" << new_resource.shell if should_set?(:shell)
          opts << "-u" << new_resource.uid if should_set?(:uid)
          opts << "-d" << new_resource.home if updating_home?
          opts << "-o" if new_resource.non_unique
          opts
        end

        private

        def add_password
          return unless current_resource.password != new_resource.password && new_resource.password

          logger.trace("#{new_resource.username} setting password to #{new_resource.password}")
          command = "echo '#{new_resource.username}:#{new_resource.password}' | chpasswd -c -e"
          shell_out!(command)
        end

        # Aix specific handling to update users home directory.
        def manage_home
          return unless updating_home? && new_resource.manage_home

          # -m option does not work on aix, so move dir.
          if ::File.directory?(current_resource.home)
            logger.trace("Changing users home directory from #{current_resource.home} to #{new_resource.home}")
            FileUtils.mv current_resource.home, new_resource.home
          else
            logger.trace("Creating users home directory #{new_resource.home}")
            FileUtils.mkdir_p new_resource.home
          end
        end

      end
    end
  end
end


text:
package Feb2021Leetcode;

public class _0105ConstructBinaryTreeFromPreorderAndInorderTraversal {
	public static class TreeNode {
		int val;
		TreeNode left;
		TreeNode right;

		TreeNode() {
		}

		TreeNode(int val) {
			this.val = val;
		}

		TreeNode(int val, TreeNode left, TreeNode right) {
			this.val = val;
			this.left = left;
			this.right = right;
		}
	}

	public static void main(String[] args) {
		printNodes(buildTree(new int[] { 3, 9, 20, 15, 7 }, new int[] { 9, 3, 15, 20, 7 }));
		System.out.println();
	}

	public static void printNodes(TreeNode tn) {
		if (tn == null)
			return;
		printNodes(tn.left);
		System.out.print(tn.val + "->");
		printNodes(tn.right);
	}

	public static TreeNode buildTree(int[] preorder, int[] inorder) {
		if (preorder == null || preorder.length == 0)
			return null;
		return helper(0, 0, inorder.length - 1, preorder, inorder);
	}

	public static TreeNode helper(int preStart, int inStart, int inEnd, int[] preorder, int[] inorder) {
		if (preStart > preorder.length - 1 || inStart > inEnd)
			return null;

		int inIndex = -1;
		for (int i = inStart; i <= inEnd; i++) {
			if (inorder[i] == preorder[preStart]) {
				inIndex = i;
				break;
			}
		}

		TreeNode tn = new TreeNode(preorder[preStart]);
		tn.left = helper(preStart + 1, inStart, inIndex - 1, preorder, inorder);
		tn.right = helper(preStart + inIndex - inStart + 1, inIndex + 1, inEnd, preorder, inorder);
		return tn;
	}

}


text:
package org.camunda.bpm.application.impl.event;

import java.util.ArrayList;
import java.util.List;

import org.camunda.bpm.engine.impl.bpmn.parser.BpmnParseListener;
import org.camunda.bpm.engine.impl.cfg.AbstractProcessEnginePlugin;
import org.camunda.bpm.engine.impl.cfg.ProcessEngineConfigurationImpl;
import org.camunda.bpm.engine.impl.cfg.ProcessEnginePlugin;

/**
 * <p>{@link ProcessEnginePlugin} enabling the process application event listener support.</p>
 *
 * @author Daniel Meyer
 *
 */
public class ProcessApplicationEventListenerPlugin extends AbstractProcessEnginePlugin {

  public void preInit(ProcessEngineConfigurationImpl processEngineConfiguration) {
    List<BpmnParseListener> preParseListeners = processEngineConfiguration.getCustomPreBPMNParseListeners();
    if(preParseListeners == null) {
      preParseListeners = new ArrayList<BpmnParseListener>();
      processEngineConfiguration.setCustomPreBPMNParseListeners(preParseListeners);
    }
    preParseListeners.add(new ProcessApplicationEventParseListener());
  }

}


text:
matlabbatch{1}.spm.stats.con.spmmat = { fullfile( dest_dir_subj, 'SPM.mat') };

for k=1:length(model.contrast)

    matlabbatch{1}.spm.stats.con.consess{k}.tcon.name    = model.contrast(k).name;
    matlabbatch{1}.spm.stats.con.consess{k}.tcon.convec  = model.contrast(k).vec;
    if(  ~isfield(model.contrast(k),'sessrep') )
        model.contrast(k).sessrep = 'repl';
    end
    matlabbatch{1}.spm.stats.con.consess{k}.tcon.sessrep = model.contrast(k).sessrep;

end

if length(sessions(1).names) > 0
    matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+1}.fcon.name = 'EOI';
    matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+1}.fcon.convec = { eye(length(sessions(1).names)); }';
    matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+1}.fcon.sessrep = 'repl';

    if ~isempty(sessions(r).regfile)

        tmp = load( sessions(r).regfile );
        [tmp2 tmp_name tmp_ext] = fileparts( sessions(r).regfile );

        matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2}.fcon.name = 'EOI_ALL';
        matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2}.fcon.convec = { eye(length(sessions(1).names)+size(tmp,2)) }';
        matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2}.fcon.sessrep = 'repl';

        columns_offset = length(sessions(1).names);
        for k=1:length(sessions(1).regcontrast)
            cols = sessions(1).regcontrast(k).columns;
            matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2+k}.fcon.name = sessions(1).regcontrast(k).name;
            matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2+k}.fcon.convec = { [zeros(cols,columns_offset) , eye(cols)] }';
            matlabbatch{1}.spm.stats.con.consess{length(model.contrast)+2+k}.fcon.sessrep = 'repl';
            columns_offset = columns_offset + cols;
        end

    end
end

matlabbatch{1}.spm.stats.con.delete = 1;


text:
module WillPaginate
  module ViewHelpers
    # This class does the heavy lifting of actually building the pagination
    # links. It is used by +will_paginate+ helper internally.
    class LinkRendererBase

      # * +collection+ is a WillPaginate::Collection instance or any other object
      #   that conforms to that API
      # * +options+ are forwarded from +will_paginate+ view helper
      def prepare(collection, options)
        @collection = collection
        @options    = options

        # reset values in case we're re-using this instance
        @total_pages = nil
      end

      def pagination
        items = @options[:page_links] ? windowed_page_numbers : []
        items.unshift :previous_page
        items.push :next_page
      end

    protected

      # Calculates visible page numbers using the <tt>:inner_window</tt> and
      # <tt>:outer_window</tt> options.
      def windowed_page_numbers
        inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
        window_from = current_page - inner_window
        window_to = current_page + inner_window

        # adjust lower or upper limit if either is out of bounds
        if window_to > total_pages
          window_from -= window_to - total_pages
          window_to = total_pages
        end
        if window_from < 1
          window_to += 1 - window_from
          window_from = 1
          window_to = total_pages if window_to > total_pages
        end

        # these are always visible
        middle = window_from..window_to

        # left window
        if outer_window + 3 < middle.first # there's a gap
          left = (1..(outer_window + 1)).to_a
          left << :gap
        else # runs into visible pages
          left = 1...middle.first
        end

        # right window
        if total_pages - outer_window - 2 > middle.last # again, gap
          right = ((total_pages - outer_window)..total_pages).to_a
          right.unshift :gap
        else # runs into visible pages
          right = (middle.last + 1)..total_pages
        end

        left.to_a + middle.to_a + right.to_a
      end

    private

      def current_page
        @collection.current_page
      end

      def total_pages
        @total_pages ||= @collection.total_pages
      end
    end
  end
end


text:
package com.client.pygmy;

import com.lib.pygmy.EntityType;
import com.lib.pygmy.GameLevel;
import com.lib.pygmy.GameMove;
import com.lib.pygmy.PygmyGameEntity;
import com.lib.pygmy.Tile;
import com.lib.pygmy.util.Point;

public class Pawn extends PygmyGameEntity {

	public Pawn(GameLevel level, String playerId, EntityType type, Point p) {
		super(level, playerId, type, p);
	}

	@Override
	public void oneStepMoveAddedBehavior() {

	}

	@Override
	public boolean isLegalMove(GameMove move) {
		Tile src = getCurrentTile();
		Tile dst = move.getDestination();
		return (dst.getPosition().y - src.getPosition().y) == 0;
	}

}


text:
<!DOCTYPE html>

    <title>Smart Payment</title>

    <meta name="viewport" content="width=device-width, initial-scale=1">

    <link href="//fonts.googleapis.com/css?family=Raleway:400,300,600" rel="stylesheet" type="text/css">

    <link rel="stylesheet" href="modules_bower/skeleton/css/normalize.css">
    <link rel="stylesheet" href="modules_bower/skeleton/css/skeleton.css">
    <link rel="stylesheet" href="modules_manual/wyd_skeleton/skeleton-extended.css">

    <link rel="stylesheet" href="app/default.css">

Smart Payment

                    Laptop

                    Tablet

                    Phone

Smart Payment - Payment Gateway Simulator.      © Wybis India Pvt. Ltd.