text:
#pragma once
#include <aws/mediaconvert/MediaConvert_EXPORTS.h>

namespace Aws
{
namespace Utils
{
namespace Json
{
  class JsonValue;
  class JsonView;
} // namespace Json
} // namespace Utils
namespace MediaConvert
{
namespace Model
{

  /**
   * Required when you set Codec, under AudioDescriptions>CodecSettings, to the value
   * OPUS.

See Also:
   AWS
   * API Reference

   */
  class AWS_MEDIACONVERT_API OpusSettings
  {
  public:
    OpusSettings();
    OpusSettings(Aws::Utils::Json::JsonView jsonValue);
    OpusSettings& operator=(Aws::Utils::Json::JsonView jsonValue);
    Aws::Utils::Json::JsonValue Jsonize() const;

    /**
     * Optional. Specify the average bitrate in bits per second. Valid values are
     * multiples of 8000, from 32000 through 192000. The default value is 96000, which
     * we recommend for quality and bandwidth.
     */
    inline int GetBitrate() const{ return m_bitrate; }

    /**
     * Optional. Specify the average bitrate in bits per second. Valid values are
     * multiples of 8000, from 32000 through 192000. The default value is 96000, which
     * we recommend for quality and bandwidth.
     */
    inline bool BitrateHasBeenSet() const { return m_bitrateHasBeenSet; }

    /**
     * Optional. Specify the average bitrate in bits per second. Valid values are
     * multiples of 8000, from 32000 through 192000. The default value is 96000, which
     * we recommend for quality and bandwidth.
     */
    inline void SetBitrate(int value) { m_bitrateHasBeenSet = true; m_bitrate = value; }

    /**
     * Optional. Specify the average bitrate in bits per second. Valid values are
     * multiples of 8000, from 32000 through 192000. The default value is 96000, which
     * we recommend for quality and bandwidth.
     */
    inline OpusSettings& WithBitrate(int value) { SetBitrate(value); return *this;}

    /**
     * Specify the number of channels in this output audio track. Choosing Mono on the
     * console gives you 1 output channel; choosing Stereo gives you 2. In the API,
     * valid values are 1 and 2.
     */
    inline int GetChannels() const{ return m_channels; }

    /**
     * Specify the number of channels in this output audio track. Choosing Mono on the
     * console gives you 1 output channel; choosing Stereo gives you 2. In the API,
     * valid values are 1 and 2.
     */
    inline bool ChannelsHasBeenSet() const { return m_channelsHasBeenSet; }

    /**
     * Specify the number of channels in this output audio track. Choosing Mono on the
     * console gives you 1 output channel; choosing Stereo gives you 2. In the API,
     * valid values are 1 and 2.
     */
    inline void SetChannels(int value) { m_channelsHasBeenSet = true; m_channels = value; }

    /**
     * Specify the number of channels in this output audio track. Choosing Mono on the
     * console gives you 1 output channel; choosing Stereo gives you 2. In the API,
     * valid values are 1 and 2.
     */
    inline OpusSettings& WithChannels(int value) { SetChannels(value); return *this;}

    /**
     * Optional. Sample rate in hz. Valid values are 16000, 24000, and 48000. The
     * default value is 48000.
     */
    inline int GetSampleRate() const{ return m_sampleRate; }

    /**
     * Optional. Sample rate in hz. Valid values are 16000, 24000, and 48000. The
     * default value is 48000.
     */
    inline bool SampleRateHasBeenSet() const { return m_sampleRateHasBeenSet; }

    /**
     * Optional. Sample rate in hz. Valid values are 16000, 24000, and 48000. The
     * default value is 48000.
     */
    inline void SetSampleRate(int value) { m_sampleRateHasBeenSet = true; m_sampleRate = value; }

    /**
     * Optional. Sample rate in hz. Valid values are 16000, 24000, and 48000. The
     * default value is 48000.
     */
    inline OpusSettings& WithSampleRate(int value) { SetSampleRate(value); return *this;}

  private:

    int m_bitrate;
    bool m_bitrateHasBeenSet;

    int m_channels;
    bool m_channelsHasBeenSet;

    int m_sampleRate;
    bool m_sampleRateHasBeenSet;
  };

} // namespace Model
} // namespace MediaConvert
} // namespace Aws


text:
package nz.co.doltech.databind.reflect;

import java.lang.annotation.*;

/**
 * Ignore this field or method from the class info generation.
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(value = {ElementType.FIELD, ElementType.METHOD})
public @interface IgnoreInfo {
}

redpajama_set_name: RedPajamaGithub


text:
using namespace v8;
using namespace node;

static Handle<Value> Waitpid(const Arguments& args) {
  HandleScope scope;
  int r, child, status;

  if (args[0]->IsInt32()) {
    child = args[0]->Int32Value();

    do {
      r = waitpid(child, &status, 0);
    } while (r != -1);

    Local<Object> result = Object::New();

    if (WIFEXITED(status)) {
      result->Set(String::New("exitCode"), Integer::New(WEXITSTATUS(status)));
      result->Set(String::New("signalCode"), Null());
      return scope.Close(result);
    }
    else if (WIFSIGNALED(status)) {
      result->Set(String::New("exitCode"), Null());
      result->Set(String::New("signalCode"), Integer::New(WTERMSIG(status)));
      return scope.Close(result);
    }
    return scope.Close(Undefined());
  }
  else {
    return ThrowException(Exception::Error(String::New("Not an integer.")));
  }
}

extern "C" void init(Handle<Object> target) {
  HandleScope scope;
  NODE_SET_METHOD(target, "waitpid", Waitpid);
}

NODE_MODULE(waitpid, init)


text:
import sys
from os import path
import re

PY2 = sys.version_info[0] == 2
data_path = path.join(path.dirname(__file__), 'data')
default_words = path.join(data_path, 'words.dat')
default_verbs = path.join(data_path, 'verbs.dat')

escapeSeq = lambda seq: u'[%s]' % u''.join(map(re.escape, seq))


text:
<?php

if ( ! defined( 'IN_IPB' ) )
{
	print "
Incorrect access
You cannot access this file directly. If you have recently upgraded, make sure you upgraded 'admin.php'.";
	exit();
}

/**
 *
 * @class		plugin_forums_announcements
 * @brief		Moderator control panel plugin: manage announcements
 *
 */
class plugin_forums_announcements
{
	/**
	 * Registry Object Shortcuts
	 *
	 * @var		$registry
	 * @var		$DB
	 * @var		$settings
	 * @var		$request
	 * @var		$lang
	 * @var		$member
	 * @var		$memberData
	 * @var		$cache
	 * @var		$caches
	 */
	protected $registry;
	protected $DB;
	protected $settings;
	protected $request;
	protected $lang;
	protected $member;
	protected $memberData;
	protected $cache;
	protected $caches;

	/**
	 * Main function executed automatically by the controller
	 *
	 * @param	object		$registry		Registry object
	 * @return	@e void
	 */
	public function __construct( ipsRegistry $registry )
	{
		//-----------------------------------------
		// Make shortcuts
		//-----------------------------------------

		$this->registry		= $registry;
		$this->DB			= $this->registry->DB();
		$this->settings		=& $this->registry->fetchSettings();
		$this->request		=& $this->registry->fetchRequest();
		$this->member		= $this->registry->member();
		$this->memberData	=& $this->registry->member()->fetchMemberData();
		$this->cache		= $this->registry->cache();
		$this->caches		=& $this->registry->cache()->fetchCaches();
		$this->lang			= $this->registry->class_localization;
	}

	/**
	 * Returns the primary tab key for the navigation bar
	 *
	 * @return	@e string
	 */
	public function getPrimaryTab()
	{
		return 'announcements';
	}

	/**
	 * Returns the secondary tab key for the navigation bar
	 *
	 * @return	@e string
	 */
	public function getSecondaryTab()
	{
		return 'announcements';
	}

	/**
	 * Determine if we can view tab
	 *
	 * @param	array 	$permissions	Moderator permissions
	 * @return	@e bool
	 */
	public function canView( $permissions )
	{
		if( $this->memberData['g_is_supmod'] )
		{
			return true;
		}

		return false;
	}

	/**
	 * Execute plugin
	 *
	 * @param	array 	$permissions	Moderator permissions
	 * @return	@e string
	 */
	public function executePlugin( $permissions )
	{
		//-----------------------------------------
		// Check permissions
		//-----------------------------------------

		if( !$this->canView( $permissions ) )
		{
			return '';
		}

		//-----------------------------------------
		// Doing something else?
		//-----------------------------------------

		switch( $this->request['_do'] )
		{
			case 'delete':
				return $this->_delete();
			break;

			case 'add':
			case 'edit':
				return $this->_form( $this->request['_do'] );
			break;

			case 'save':
				return $this->_save( $this->request['type'] );
			break;
		}

		//-----------------------------------------
		// INIT
		//-----------------------------------------

		$announcements	= array();

		//-----------------------------------------
		// Get announcements
		//-----------------------------------------

		$this->DB->build( array(
								'select'	=> 'a.*',
								'from'		=> array( 'announcements' => 'a' ),
								'order'		=> 'a.announce_end DESC',
								'add_join'	=> array(
													array( 'select'	=> 'm.member_id, m.members_display_name, m.member_group_id, m.members_seo_name',
															'from'	=> array( 'members' => 'm' ),
															'where'	=> 'm.member_id=a.announce_member_id',
															'type'	=> 'left'
														)
													)
								)		);
		$this->DB->execute();

		while ( $r = $this->DB->fetch() )
		{
			$r['announce_seo_title']	= $r['announce_seo_title'] ? $r['announce_seo_title'] : IPSText::makeSeoTitle( $r['announce_title'] );

			if ( $r['announce_forum'] == '*' )
			{
				$r['announce_forum_show'] = $this->lang->words['announce_page_allforums'];
			}
			else
			{
				$tmp_forums = explode(",",$r['announce_forum']);

				if ( is_array( $tmp_forums ) and count($tmp_forums) )
				{
					if ( count($tmp_forums) > 5 )
					{
						$r['announce_forum_show'] = count($tmp_forums) . ' ' . $this->lang->words['announce_page_numforums'];
					}
					else
					{
						$r['_forums'] = array();

						foreach( $tmp_forums as $id )
						{
							$r['_forums'][] = array( $id, $this->registry->getClass('class_forums')->forum_by_id[ $id ]['name'] );
						}
					}
				}
			}

			$announcements[] = $r;
		}

		return $this->registry->getClass('output')->getTemplate('modcp')->modAnnouncements( $announcements );
	}

	/**
	 * Delete announcement
	 *
	 * @return	@e void
	 */
	protected function _delete()
	{

		if ( $this->request['secure_key'] != $this->member->form_hash )
		{
			$this->registry->output->showError( 'no_permission', 10311902, null, null, 403 );
		}

		$announce_id	= intval( $this->request['announce_id'] );

		//-----------------------------------------
		// Delete it
		//-----------------------------------------

		$this->DB->delete( 'announcements', 'announce_id=' . $announce_id );

		//-----------------------------------------
		// Update cache and redirect
		//-----------------------------------------

		$this->registry->cache()->rebuildCache( 'announcements', 'forums' );

		$this->registry->getClass('output')->redirectScreen( $this->lang->words['announcement_deleted'], $this->settings['base_url']."app=core&module=modcp&tab=announcements&fromapp=forums" );
	}

	/**
	 * Show announcement form
	 *
	 * @param	string	$type	Add or edit
	 * @param	string	$msg	Message to show
	 * @return	@e string
	 */
	protected function _form( $type='add', $msg='' )
	{
		//-----------------------------------------
		// INIT the editor/bbcode classes
		//-----------------------------------------

		IPSText::getTextClass( 'bbcode' )->parsing_section			= 'announcement';

		//-----------------------------------------
		// Set up
		//-----------------------------------------

		if ( $type == 'add' )
		{
			$announce	= array( 'announce_active' => 1, 'announce_id' => 0 );
		}
		else
		{
			$announce_id				= intval( $this->request['announce_id'] );
			$announce					= $this->DB->buildAndFetch( array( 'select' => '*', 'from' => 'announcements', 'where' => 'announce_id='.$announce_id ) );
			$announce['announce_forum']	= explode( ",", $announce['announce_forum'] );
			$announce['announce_start']	= $announce['announce_start'] ? strftime( '%m-%d-%Y', $announce['announce_start'] ) : '';
			$announce['announce_end']	= $announce['announce_end']   ? strftime( '%m-%d-%Y', $announce['announce_end'] ) : '';
		}

		//-----------------------------------------
		// Do we have _POST?
		//-----------------------------------------

		foreach( array( 'announce_html_enabled', 'announce_title', 'announce_post', 'announce_start', 'announce_end', 'announce_forum', 'announce_active' ) as $bit )
		{
			if ( !empty($this->request[$bit]) )
			{
				$announce[ $bit ]	= $bit == 'announce_post' ? $_POST[ $bit ] : $this->request[ $bit ];
			}
			else if( !isset($announce[ $bit] ) )
			{
				$announce[ $bit ]	= null;
			}
		}

		$classToLoad	= IPSLib::loadLibrary( IPS_ROOT_PATH . 'sources/classes/editor/composite.php', 'classes_editor_composite' );
		$editor			= new $classToLoad();
		$editor->setAllowHtml( $announce['announce_html_enabled'] );

		$_editor		= $editor->show( 'announce_post', array( 'type' => 'full' ), $announce['announce_post'] );

		//-----------------------------------------
		// Forums
		//-----------------------------------------

		$forum_html	= "<option value='*'>" . $this->lang->words['announce_form_allforums'] . "</option>" . $this->registry->getClass('class_forums')->forumsForumJump( false, true, true );

		//-----------------------------------------
		// Save forums?
		//-----------------------------------------

		if ( is_array( $announce['announce_forum'] ) and count( $announce['announce_forum'] ) )
		{
			foreach( $announce['announce_forum'] as $f )
			{
				$forum_html = preg_replace( "#option\s+value=[\"'](".preg_quote($f,'#').")[\"']#i", "option value='\\1' selected='selected'", $forum_html );
			}
		}

		$announce['announce_active_checked'] = $announce['announce_active'] 	  ? 'checked="checked"'  : '';
		$announce['html_checkbox']			 = $announce['announce_html_enabled'] ? "checked='checked' " : '';
		$announce['nlbr_checkbox']			 = $announce['announce_nlbr_enabled'] ? "checked='checked' " : '';

		return $this->registry->getClass('output')->getTemplate('modcp')->modAnnounceForm( $announce, $forum_html, $type, $_editor, $msg );
	}

	/**
	 * Add or update an announcement
	 *
	 * @param	string	$type	add|edit
	 * @return	@e void
	 */
	protected function _save( $type='add' )
	{

		if ( $this->request['secure_key'] != $this->member->form_hash )
		{
			$this->registry->output->showError( 'no_permission', 10311903, null, null, 403 );
		}

		//-----------------------------------------
		// INIT
		//-----------------------------------------

		$forums_to_save	= "";
		$start_date		= 0;
		$end_date		= 0;
		$announce_id	= intval( $this->request['announce_id'] );

		//-----------------------------------------
		// check...
		//-----------------------------------------

		if ( ! $this->request['announce_title'] or ! $this->request['announce_post'] )
		{
			return $this->_form( $type, $this->lang->words['announce_error_title'] );
		}

		//-----------------------------------------
		// Get forums to add announce in
		//-----------------------------------------

		if ( is_array( $this->request['announce_forum'] ) and count( $this->request['announce_forum'] ) )
		{
			if ( in_array( '*', $this->request['announce_forum'] ) )
			{
				$forums_to_save = '*';
			}
			else
			{
				$forums_to_save = implode( ",", $this->request['announce_forum'] );
			}
		}

		if ( ! $forums_to_save )
		{
			return $this->_form( $type, $this->lang->words['announce_error_forums'] );
		}

		//-----------------------------------------
		// Check Dates
		//-----------------------------------------

		if ( strstr( $this->request['announce_start'], '-' ) )
		{
			$start_array = explode( '-', $this->request['announce_start'] );

			if ( $start_array[0] and $start_array[1] and $start_array[2] )
			{
				if ( ! checkdate( $start_array[0], $start_array[1], $start_array[2] ) )
				{
					return $this->_form( $type, $this->lang->words['announce_error_date'] );
				}
			}

			$start_date = mktime( 12, 0, 0, $start_array[0], $start_array[1], $start_array[2] );
		}

		if ( strstr( $this->request['announce_end'], '-' ) )
		{
			$end_array = explode( '-', $this->request['announce_end']  );

			if ( $end_array[0] and $end_array[1] and $end_array[2] )
			{
				if ( ! checkdate( $end_array[0], $end_array[1], $end_array[2] ) )
				{
					return $this->_form( $type, $this->lang->words['announce_error_date'] );
				}
			}

			$end_date = mktime( 12, 0, 0, $end_array[0], $end_array[1], $end_array[2] );
		}

		//-----------------------------------------
		// Sort out the content
		//-----------------------------------------

		$classToLoad		= IPSLib::loadLibrary( IPS_ROOT_PATH . 'sources/classes/editor/composite.php', 'classes_editor_composite' );
		$editor				= new $classToLoad();
		$editor->setAllowBbcode( true );
		$editor->setAllowHtml( intval($this->request['announce_html_enabled']) );

		if ( intval($this->request['announce_html_enabled']) )
		{
			$editor->setBypassHtmlPurify( true );
		}

		$announceContent	= $editor->process( $_POST['announce_post'] );

		IPSText::getTextClass( 'bbcode' )->bypass_badwords	= 1;
		IPSText::getTextClass( 'bbcode' )->parse_smilies	= 1;
		IPSText::getTextClass( 'bbcode' )->parse_html		= intval($this->request['announce_html_enabled']);
		IPSText::getTextClass( 'bbcode' )->parse_nl2br		= $this->request['announce_html_enabled'] ? $this->request['announce_nlbr_enabled'] : 0;
		IPSText::getTextClass( 'bbcode' )->parse_bbcode		= 1;
		IPSText::getTextClass( 'bbcode' )->parsing_section	= 'announcement';

		$announceContent	= IPSText::getTextClass( 'bbcode' )->preDbParse( $announceContent );

		//-----------------------------------------
		// Build save array
		//-----------------------------------------

		$save_array = array( 'announce_title'			=> $this->request['announce_title'],
							 'announce_post'			=> $announceContent,
							 'announce_active'			=> $this->request['announce_active'] ? $this->request['announce_active'] : 0,
							 'announce_forum'			=> $forums_to_save,
							 'announce_html_enabled'	=> $this->request['announce_html_enabled'] ? $this->request['announce_html_enabled'] : 0,
							 'announce_nlbr_enabled'	=> $this->request['announce_nlbr_enabled'] ? $this->request['announce_nlbr_enabled'] : 0,
							 'announce_start'			=> $start_date,
							 'announce_end'				=> $end_date,
							 'announce_seo_title'		=> IPSText::makeSeoTitle( $this->request['announce_title'] ),
						   );

		//-----------------------------------------
		// Save..
		//-----------------------------------------

		if ( $type == 'add' )
		{
			$save_array['announce_member_id']	= $this->memberData['member_id'];

			$this->DB->insert( 'announcements', $save_array );
		}
		else
		{
			if ( $announce_id )
			{
				$this->DB->update( 'announcements', $save_array, 'announce_id=' . $announce_id );
			}
		}

		//-----------------------------------------
		// Update cache
		//-----------------------------------------

		$this->registry->cache()->rebuildCache( 'announcements', 'forums' );

		$this->registry->getClass('output')->redirectScreen( $this->lang->words['announcement_saved'], $this->settings['base_url'] . "app=core&module=modcp&tab=announcements&fromapp=forums" );
	}
}


text:
package com.helger.xml.namespace;

import java.util.Iterator;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
import javax.xml.XMLConstants;

import com.helger.commons.ValueEnforcer;
import com.helger.commons.annotation.Nonempty;
import com.helger.commons.annotation.ReturnsMutableCopy;
import com.helger.commons.collection.CollectionHelper;
import com.helger.commons.collection.impl.CommonsArrayList;
import com.helger.commons.collection.impl.ICommonsMap;
import com.helger.commons.string.ToStringGenerator;

/**
 * Represents a namespace context having exactly 1 item.
 *
 * @author Philip Helger
 */
@Immutable
public class SingleElementNamespaceContext extends AbstractNamespaceContext
{
  private final String m_sPrefix;
  private final String m_sNamespaceURI;

  /**
   * Create a namespace context with the default (empty) prefix
   *
   * @param sNamespaceURI
   *        The namespace URI to use. May neither be null nor
   *        empty.
   */
  public SingleElementNamespaceContext (@Nonnull @Nonempty final String sNamespaceURI)
  {
    this (XMLConstants.DEFAULT_NS_PREFIX, sNamespaceURI);
  }

  public SingleElementNamespaceContext (@Nonnull final String sPrefix, @Nonnull @Nonempty final String sNamespaceURI)
  {
    m_sPrefix = ValueEnforcer.notNull (sPrefix, "Prefix");
    m_sNamespaceURI = ValueEnforcer.notEmpty (sNamespaceURI, "NamespaceURI");
  }

  @Override
  @Nullable
  public String getDefaultNamespaceURI ()
  {
    return m_sPrefix.equals (XMLConstants.DEFAULT_NS_PREFIX) ? m_sNamespaceURI : null;
  }

  @Override
  @Nullable
  protected Iterator <String> getCustomPrefixes (@Nullable final String sNamespaceURI)
  {
    return m_sNamespaceURI.equals (sNamespaceURI) ? new CommonsArrayList <> (m_sPrefix).iterator () : null;
  }

  @Override
  @Nullable
  protected String getCustomPrefix (@Nullable final String sNamespaceURI)
  {
    return m_sNamespaceURI.equals (sNamespaceURI) ? m_sPrefix : null;
  }

  @Override
  @Nullable
  protected String getCustomNamespaceURI (@Nullable final String sPrefix)
  {
    return m_sPrefix.equals (sPrefix) ? m_sNamespaceURI : null;
  }

  @Nonnull
  @ReturnsMutableCopy
  public ICommonsMap <String, String> getPrefixToNamespaceURIMap ()
  {
    return CollectionHelper.newMap (m_sPrefix, m_sNamespaceURI);
  }

  @Override
  public String toString ()
  {
    return new ToStringGenerator (this).append ("prefix", m_sPrefix).append ("namespaceURI", m_sNamespaceURI).getToString ();
  }
}


text:
azure.mgmt.datalake.analytics.job.operations module
===================================================

.. automodule:: azure.mgmt.datalake.analytics.job.operations
    :members:
    :undoc-members:
    :show-inheritance:


text:
package org.caleydo.view.bicluster.sorting;

import java.util.List;

import org.caleydo.core.data.virtualarray.group.GroupList;

/**
 * special version of a {@link ISortingStrategy}, which determines a grouping criteria
 *
 * @author Samuel Gratzl
 *
 */
public interface IGroupingStrategy {

	GroupList getGrouping(List<IntFloat> sortedList);
}


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

using ASC.Common.Logging;
using ASC.Core.Common.Contracts;
using ASC.Data.Backup.Storage;
using ASC.Data.Backup.Utils;

namespace ASC.Data.Backup.Service
{
    internal class BackupService : IBackupService, IHealthCheckService
    {
        private readonly ILog log = LogManager.GetLogger("ASC.Backup.Service");

        public BackupProgress StartBackup(StartBackupRequest request)
        {
            var progress = BackupWorker.StartBackup(request);
            if (!string.IsNullOrEmpty(progress.Error))
            {
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public BackupProgress GetBackupProgress(int tenantId)
        {
            var progress = BackupWorker.GetBackupProgress(tenantId);
            if (progress != null && !string.IsNullOrEmpty(progress.Error))
            {
                BackupWorker.ResetBackupError(tenantId);
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public void DeleteBackup(Guid id)
        {
            var backupRepository = BackupStorageFactory.GetBackupRepository();
            var backupRecord = backupRepository.GetBackupRecord(id);
            backupRepository.DeleteBackupRecord(backupRecord.Id);

            var storage = BackupStorageFactory.GetBackupStorage(backupRecord);
            if (storage == null) return;
            storage.Delete(backupRecord.StoragePath);
        }

        public void DeleteAllBackups(int tenantId)
        {
            var backupRepository = BackupStorageFactory.GetBackupRepository();
            foreach (var backupRecord in backupRepository.GetBackupRecordsByTenantId(tenantId))
            {
                try
                {
                    backupRepository.DeleteBackupRecord(backupRecord.Id);
                    var storage = BackupStorageFactory.GetBackupStorage(backupRecord);
                    if (storage == null) continue;
                    storage.Delete(backupRecord.StoragePath);
                }
                catch (Exception error)
                {
                    log.Warn("error while removing backup record: {0}", error);
                }
            }
        }

        public List<BackupHistoryRecord> GetBackupHistory(int tenantId)
        {
            var backupHistory = new List<BackupHistoryRecord>();
            var backupRepository = BackupStorageFactory.GetBackupRepository();
            foreach (var record in backupRepository.GetBackupRecordsByTenantId(tenantId))
            {
                var storage = BackupStorageFactory.GetBackupStorage(record);
                if (storage == null) continue;
                if (storage.IsExists(record.StoragePath))
                {
                    backupHistory.Add(new BackupHistoryRecord
                    {
                        Id = record.Id,
                        FileName = record.FileName,
                        StorageType = record.StorageType,
                        CreatedOn = record.CreatedOn,
                        ExpiresOn = record.ExpiresOn
                    });
                }
                else
                {
                    backupRepository.DeleteBackupRecord(record.Id);
                }
            }
            return backupHistory;
        }

        public BackupProgress StartTransfer(StartTransferRequest request)
        {
            var progress = BackupWorker.StartTransfer(request.TenantId, request.TargetRegion, request.BackupMail, request.NotifyUsers);
            if (!string.IsNullOrEmpty(progress.Error))
            {
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public BackupProgress GetTransferProgress(int tenantID)
        {
            var progress = BackupWorker.GetTransferProgress(tenantID);
            if (!string.IsNullOrEmpty(progress.Error))
            {
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public BackupProgress StartRestore(StartRestoreRequest request)
        {
            if (request.StorageType == BackupStorageType.Local)
            {
                if (string.IsNullOrEmpty(request.FilePathOrId) || !File.Exists(request.FilePathOrId))
                {
                    throw new FileNotFoundException();
                }
            }

            if (!request.BackupId.Equals(Guid.Empty))
            {
                var backupRepository = BackupStorageFactory.GetBackupRepository();
                var backupRecord = backupRepository.GetBackupRecord(request.BackupId);
                if (backupRecord == null)
                {
                    throw new FileNotFoundException();
                }

                request.FilePathOrId = backupRecord.StoragePath;
                request.StorageType = backupRecord.StorageType;
                request.StorageParams = backupRecord.StorageParams;
            }

            var progress = BackupWorker.StartRestore(request);
            if (!string.IsNullOrEmpty(progress.Error))
            {
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public BackupProgress GetRestoreProgress(int tenantId)
        {
            var progress = BackupWorker.GetRestoreProgress(tenantId);
            if (progress != null && !string.IsNullOrEmpty(progress.Error))
            {
                BackupWorker.ResetRestoreError(tenantId);
                throw new FaultException(progress.Error);
            }
            return progress;
        }

        public string GetTmpFolder()
        {
            return BackupWorker.TempFolder;
        }

        public List<TransferRegion> GetTransferRegions()
        {
            var webConfigs = BackupConfigurationSection.GetSection().WebConfigs;
            return webConfigs
                .Cast<WebConfigElement>()
                .Select(configElement =>
                    {
                        var config = ConfigurationProvider.Open(PathHelper.ToRootedConfigPath(configElement.Path));
                        var baseDomain = config.AppSettings.Settings["core.base-domain"].Value;
                        return new TransferRegion
                        {
                            Name = configElement.Region,
                            BaseDomain = baseDomain,
                            IsCurrentRegion = configElement.Region.Equals(webConfigs.CurrentRegion, StringComparison.InvariantCultureIgnoreCase)
                        };
                    })
                .ToList();
        }

        public void CreateSchedule(CreateScheduleRequest request)
        {
            BackupStorageFactory.GetBackupRepository().SaveBackupSchedule(
                new Schedule(request.TenantId)
                {
                    Cron = request.Cron,
                    BackupMail = request.BackupMail,
                    NumberOfBackupsStored = request.NumberOfBackupsStored,
                    StorageType = request.StorageType,
                    StorageBasePath = request.StorageBasePath,
                    StorageParams = request.StorageParams
                });
        }

        public void DeleteSchedule(int tenantId)
        {
            BackupStorageFactory.GetBackupRepository().DeleteBackupSchedule(tenantId);
        }

        public ScheduleResponse GetSchedule(int tenantId)
        {
            var schedule = BackupStorageFactory.GetBackupRepository().GetBackupSchedule(tenantId);
            return schedule != null
                       ? new ScheduleResponse
                       {
                           StorageType = schedule.StorageType,
                           StorageBasePath = schedule.StorageBasePath,
                           BackupMail = schedule.BackupMail,
                           NumberOfBackupsStored = schedule.NumberOfBackupsStored,
                           Cron = schedule.Cron,
                           LastBackupTime = schedule.LastBackupTime,
                           StorageParams = schedule.StorageParams
                       }
                       : null;
        }

        public HealthCheckResponse CheckHealth()
        {
            return HealthCheckResult.ToResponse(new HealthCheckResult
            {
                Message = "Service Backup is OK! Warning: Method is not implement. Always return the Healthy status",
                Status = HealthStatus.Healthy
            });
        }

    }
}


text:
<?php
/**
 * Created by PhpStorm.
 * User: fu
 * Date: 2015/4/13
 * Time: 11:22
 */
class MsgWeiXin {

    function __construct()
    {

    }

    private function  GetUserDeviceToken($userid)
    {
        $redis=CacheFactory::createCache("Redis");
        if($redis->IsExist("userdivertoken_" . $userid)) {
            return $userdivertoken = $redis->GetHValue("userdivertoken_" . $userid, "diverToken");
        }
        else
        {
            $userdivertoken = Userdivertoken::findFirstByUserId($userid);
            if ($userdivertoken)
                return $userdivertoken->getDiverToken();
            else
                return null;
        }

    }
    public function  sendMsg($disption,$content,$type,$userid)
    {
        $devicetoken=$this->GetUserDeviceToken($userid);
        $msgpush = new msgpush("551a4f4cfd98c537c5000891", "xc0sjxlclm0dtvx8s1wt41ov6esct9wn");
        $msgpush->sendIOSUnicast($disption,$content,$type,$devicetoken);
    }

}


text:
package com.facebook.buck.features.python;

import com.facebook.buck.core.model.BuildTarget;
import com.facebook.buck.core.model.FlavorDomain;
import com.facebook.buck.core.model.targetgraph.AbstractNodeBuilder;
import com.facebook.buck.core.sourcepath.SourcePath;
import com.facebook.buck.core.toolchain.impl.ToolchainProviderBuilder;
import com.facebook.buck.cxx.toolchain.CxxPlatformUtils;
import com.facebook.buck.cxx.toolchain.CxxPlatformsProvider;
import com.facebook.buck.cxx.toolchain.UnresolvedCxxPlatform;
import com.facebook.buck.features.python.toolchain.PythonPlatform;
import com.facebook.buck.features.python.toolchain.PythonPlatformsProvider;
import com.google.common.collect.ImmutableSortedSet;

public class PrebuiltPythonLibraryBuilder
    extends AbstractNodeBuilder<
        PrebuiltPythonLibraryDescriptionArg.Builder,
        PrebuiltPythonLibraryDescriptionArg,
        PrebuiltPythonLibraryDescription,
        PrebuiltPythonLibrary> {

  PrebuiltPythonLibraryBuilder(
      BuildTarget target,
      FlavorDomain<PythonPlatform> pythonPlatforms,
      FlavorDomain<UnresolvedCxxPlatform> cxxPlatforms) {
    super(
        new PrebuiltPythonLibraryDescription(
            new ToolchainProviderBuilder()
                .withToolchain(
                    PythonPlatformsProvider.DEFAULT_NAME,
                    PythonPlatformsProvider.of(pythonPlatforms))
                .withToolchain(
                    CxxPlatformsProvider.DEFAULT_NAME,
                    CxxPlatformsProvider.of(
                        CxxPlatformUtils.DEFAULT_UNRESOLVED_PLATFORM, cxxPlatforms))
                .build()),
        target);
  }

  public static PrebuiltPythonLibraryBuilder createBuilder(BuildTarget target) {
    return new PrebuiltPythonLibraryBuilder(
        target, PythonTestUtils.PYTHON_PLATFORMS, CxxPlatformUtils.DEFAULT_PLATFORMS);
  }

  public PrebuiltPythonLibraryBuilder setDeps(ImmutableSortedSet<BuildTarget> deps) {
    getArgForPopulating().setDeps(deps);
    return this;
  }

  public PrebuiltPythonLibraryBuilder setBinarySrc(SourcePath binarySrc) {
    getArgForPopulating().setBinarySrc(binarySrc);
    return this;
  }

  public PrebuiltPythonLibraryBuilder setExcludeDepsFromMergedLinking(
      boolean excludeDepsFromOmnibus) {
    getArgForPopulating().setExcludeDepsFromMergedLinking(excludeDepsFromOmnibus);
    return this;
  }
}


text:
/* globals BrainTreeConnect, braintree */

var gateway = BrainTreeConnect({
  environment: Braintree.Environment.Sandbox,
  merchantId: Meteor.settings.BRAIN_TREE.MERCHANT_ID,
  publicKey:  Meteor.settings.BRAIN_TREE.PUBLIC_KEY,
  privateKey: Meteor.settings.BRAIN_TREE.PRIVATE_KEY
})

var nonce = Braintree.Test.Nonces.Transactable;

var user;

// describe('transaction meteor method', function() {
//
//   beforeAll(function() {
//     user = Meteor.users.findOne();
//   });
//
//   it('should be able to successfully sell $10.00 of goods/services and update a user', function() {
//     var result = Meteor.call('braintreeTransaction', {
//       total: 10, user: user, paymentMethodNonce: 'fake-paypal-one-time-nonce', options: {store:true}
//     });
//
//     expect(result.success).toBeTruthy();
//     expect(result.errors).toBeFalsy();
//     expect(result.transaction.status).toBe('settling');
//     expect(result.transaction.type).toBe('sale');
//   });
//
//   it('consumed nonce should fail to sell $10.00 of goods.', function() {
//     var nonce = Braintree.Test.Nonces.Consumed;
//
//     var result = Meteor.call('braintreeTransaction', {
//       total: 10, user: user, paymentMethodNonce: nonce, options: {store:false}
//     });
//     expect(result.errors).toBeTruthy();
//     expect(result.success).toBe(false);
//     expect(result.message).toBe('Cannot use a payment_method_nonce more than once.')
//   });
// });


text:
"""Cleverbot chats with himself."""
import traceback

import cleverbot

def main():
    # instantiate two Cleverbot objects
    cleverbot_client_one = cleverbot.Cleverbot()
    cleverbot_client_two = cleverbot.Cleverbot()

    print '>> Cleverbot #1: Hi.'
    answer = cleverbot_client_two.ask('Hi.')

    while True:
        print '>> Cleverbot #2: {}'.format(answer)
        answer = cleverbot_client_one.ask(answer)
        print '>> Cleverbot #1: {}'.format(answer)
        answer = cleverbot_client_two.ask(answer)

if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print '>> Exiting...'
    except Exception, err:
        print traceback.format_exc(err)


text:
package com.lightcrafts.mediax.jai;

import java.awt.image.renderable.ParameterBlock;

/**
 * The RenderableCollectionImageFactory (RCIF) interface
 * is intended to be implemented by classes that wish to act as factories
 * to produce different collection image operators.  In JAI, the
 * create() method defined by this interface will be
 * invoked in a chain of CollectionOps when the operation is
 * being executed in renderable mode.  The images contained in the
 * generated CollectionImage would be expected to be
 * RenderableImages.
 *
 * @since JAI 1.1
 */
public interface RenderableCollectionImageFactory {

    /**
     * Creates a CollectionImage that represents the
     * result of an operation (or chain of operations) for a given
     * ParameterBlock.
     * If the operation is unable to handle the input arguments, this
     * method should return null.
     *
     *
 Generally this method is expected to be invoked by an operation
     * being executed in renderable mode.  Therefore the images contained
     * in the generated CollectionImage would be expected to
     * be RenderableImages.
     *
     * @param args  Input arguments to the operation, including
     *        sources and/or parameters.
     *
     * @return  A CollectionImage containing the desired output.
     */
    CollectionImage create(ParameterBlock parameters);
}


text:
<?php

return [

    /*
    |--------------------------------------------------------------------------
    | HTTP Language Lines
    |--------------------------------------------------------------------------
    |
    | The following language lines are used in the views/errors files.
    |
    */

    '404' => [
        'title' => 'La Página que intento acceder no ha sido encontrada.',
        'description' => 'Parece ser que la página que buscas no existe.',
    ],

    '503' => [
        'title' => 'Servicio no disponible.',
        'description' => 'Volveremos en breve.',
    ],

];


text:
/*
 * decaffeinate suggestions:
 * DS101: Remove unnecessary use of Array.from
 * DS102: Remove unnecessary code created because of implicit returns
 * DS205: Consider reworking code to avoid use of IIFEs
 * DS206: Consider reworking classes to avoid initClass
 * DS207: Consider shorter variations of null checks
 * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
 */
class InputStages {
    constructor() {
        return {
            replace: false,
            transclude: false,
            restrict: 'E', // E: Element
            scope: {allStages: '=', stages: '=', placeholder:"@"},
            template: require('./input_stages.tpl.jade'),
            controller: '_InputStagesController'
        };
    }
}

var _InputStages = (function() {
    let self = undefined;
    _InputStages = class _InputStages {
        static initClass() {
            self = null;
        }
        constructor($scope) {
            let t;
            self = this;
            $scope.stages_model = [];
            if ($scope.stages == null) { $scope.stages = []; }
            for (t of Array.from($scope.stages)) {
                if (angular.isObject(t)) {
                    t = t.text;
                }
                $scope.stages_model.push({text:t});
            }

            const updateStages = function() {
                $scope.stages.splice(0, $scope.stages.length);
                return (() => {
                    const result = [];
                    for (t of Array.from($scope.stages_model)) {
                        result.push($scope.stages_model.push(t.text));
                    }
                    return result;
                })();
            };
            updateStages();
            $scope.$watch("stages_model", updateStages, true);
        }
    };
    _InputStages.initClass();
    return _InputStages;
})();

angular.module('app')
.directive('inputStages', [InputStages])
.controller('_InputStagesController', ['$scope', _InputStages]);


text:
export abstract class BaseError extends Error {
    constructor(message: string) {
        super(message);

        this.message = message;
    }
}


text:
CBase
====================================================================================================

.. cpp:class:: Lib3MF::CBase

.. cpp:type:: std::shared_ptr<CBase> Lib3MF::PBase

	Shared pointer to CBase to easily allow reference counting.


text:
using ShaNetCore;
using ShaNetDate;
using ShaNetHoliday.Models;
using ShaNetHoliday.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

using static System.DayOfWeek;
using static ShaNetHoliday.Syntax.Count;
using static ShaNetHoliday.Syntax.Month;
using static ShaNetHoliday.Models.RuleType;
using static ShaNetHoliday.Models.Calendar;
using static ShaNetHoliday.Syntax.YearType;

namespace ShaNetHoliday.Countries
{
    /// <summary>
    /// Définition pour United States of America
    /// </summary>
    public partial class UnitedStates
    {
        /// <summary>
        /// Initialise une nouvelle instance pour la classe <see cref="UnitedStates"/>.
        /// </summary>
        public UnitedStates()
        {
            DaysOff.Add( Sunday );
            Rules = new List<Rule>()
            {
                new GregorianRule()
                {
                    Expression = ExpressionTree.Observe.Fix(On.January.The1st).If(Sunday).Then.Next(Monday).Or.If(Saturday).Then.Previous(Friday),
                    Names = NamesBuilder.Make.Add(Language.ENG, "New Year's Day").AsDictionary(),
                    Substitute = true
                },
                new GregorianRule()
                {
                    Key = "3MOJAN",
                    Expression = ExpressionTree.Date.Movable(Third, Monday).In(January),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Martin Luther King Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Key = "3MOFEB",
                    Expression = ExpressionTree.Date.Movable(Third, Monday).In(February),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Washington's Birthday").AsDictionary()
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Fix(On.February.The14th),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Valentine's Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Move.Fix(On.April.The15th).If(Friday).Then.Next(Monday).Or.If(Saturday).Then.Next(Tuesday).Or.If(Sunday).Then.Next(Tuesday),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Tax Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(First, Wednesday).Before("04-28"),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Administrative Professionals Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(Second, Sunday).In(May),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Mother's Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(First, Monday).Before(June),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Memorial Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(Third, Sunday).In(June),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Father's Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Observe.Fix(On.July.The4th).If(Sunday).Then.Next(Monday).Or.If(Saturday).Then.Previous(Friday),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Independence Day").AsDictionary(),
                    Substitute = true
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(First, Monday).In(September),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Labor Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Key = "2MOOCT",
                    Expression = ExpressionTree.Date.Movable(Second, Monday).In(October),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Columbus Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Fix(On.October.The31st).StartAt("18:00"),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Halloween").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Fix(On.November.The11th),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Veterans Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Key = "ELECTIONDAY",
                    Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).Every(4).Year.Since(1848),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Election Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Date.Movable(Fourth, Thursday).In(November),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Thanksgiving Day").AsDictionary()
                },
                new GregorianRule()
                {
                    Key = "1FRIA4THUNOV",
                    Expression = ExpressionTree.Date.MovableFromMovable(First, Friday).After(Fourth, Thursday).In(November),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Day after Thanksgiving Day").AsDictionary(),
                    Type = Observance
                },
                new GregorianRule()
                {
                    Key = "DEC24",
                    Expression = ExpressionTree.Date.Fix(On.December.The24th),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Christmas Eve").AsDictionary(),
                    Type = Optional
                },
                new GregorianRule()
                {
                    Expression = ExpressionTree.Observe.Fix(On.December.The25th).If(Sunday).Then.Next(Monday).Or.If(Saturday).Then.Previous(Friday),
                    Names = NamesBuilder.Make.Add(Language.ENG, "Christmas Day").AsDictionary(),
                    Substitute = true
                },
                new GregorianRule()
                {
                    Key = "DEC31",
                    Expression = ExpressionTree.Date.Fix(On.December.The31st).StartAt("18:00"),
                    Names = NamesBuilder.Make.Add(Language.ENG, "New Year's Eve").AsDictionary(),
                    Type = Observance
                }
            };
        }
        internal partial class US_AL
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Robert E. Lee/ Martin Luther King Birthday").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        Names = NamesBuilder.Make.Add(Language.ENG, "George Washington/ Thomas Jefferson Birthday").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Fourth, Monday).In(April),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Confederate Memorial Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Monday).In(June),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Jefferson Davis' birthday").AsDictionary()
                    }
                };
        }
        internal partial class US_AK
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Monday).Before(April),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Seward's Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.October.The18th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Alaska Day").AsDictionary()
                    }
                };
        }
        internal partial class US_AZ
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Dr. Martin Luther King Jr./ Civil Rights Day").AsDictionary(),
                        Overrides = Overrides.Name
                    }
                };
        }
        internal partial class US_AR
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Dr. Martin Luther King Jr./ Robert E. Lee's Birthdays").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        Names = NamesBuilder.Make.Add(Language.ENG, "George Washington's Birthday/ Daisy Gatson Bates Day").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_CA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The15th),
                        Names = NamesBuilder.Make.Add(Language.ENG , "Susan B. Anthony Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.March.The31st),
                        Names = NamesBuilder.Make.Add(Language.ENG , "César Chávez Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.May.The19th),
                        Names = NamesBuilder.Make.Add(Language.ENG , "Malcolm X Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.May.The23rd),
                        Names = NamesBuilder.Make.Add(Language.ENG , "Harvey Milk Day").AsDictionary()
                    }
                };
            internal partial class US_CA_LO
            {
                public override List<Rule> Rules => new List<Rule>()
                    {
                        new GregorianRule()
                        {
                            Expression = ExpressionTree.Date.Fix(On.August.The24th).StartAtMidnight.UntilMidnight.Every(1).Year.Since(2016),
                            Names = NamesBuilder.Make.Add(Language.ENG , "Kobe Bryant Day").AsDictionary(),
                            Type = Observance
                        }
                    };
            }
        }
        internal partial class US_CO
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        Type = Observance,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_CT
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    }
                };
        }
        internal partial class US_DE
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).In(Even),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Election Day").AsDictionary()
                    }
                };
        }
        internal partial class US_DC
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.April.The16th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Emancipation Day").AsDictionary()
                    }
                };
        }
        internal partial class US_FL
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The15th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Susan B. Anthony Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_GA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key ="3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.January.The19th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Robert E. Lee's Birthday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Monday).Before(May),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Confederate Memorial Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Expression = ExpressionTree.Substitute.Fix(On.December.The24th).If(Wednesday).Then.Next(Friday),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Washington's Birthday").AsDictionary(),
                        Type = Public,
                        Overrides = Overrides.Name | Overrides.Expression | Overrides.Type
                    }
                };
        }
        internal partial class US_HI
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.March.The26th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Prince Jonah Kuhio Kalanianaole Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.June.The11th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Kamehameha Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Third, Friday).In(August),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Statehood Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).In(Even),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Election Day").AsDictionary()
                    }
                };
        }
        internal partial class US_ID
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Martin Luther King, Jr./ Idaho Human Rights Day").AsDictionary(),
                        Overrides = Overrides.Name
                    }
                };
        }
        internal partial class US_IL
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Monday).In(March),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Casimir Pulaski Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.May.The19th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Malcolm X Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).In(Even),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    }
                };
        }
        internal partial class US_IN
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(May),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Primary Election Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary(),
                        Type = Public,
                        Overrides = Overrides.Name | Overrides.Type
                    }
                };
        }
        internal partial class US_IA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary()
                    }
                };
        }
        internal partial class US_KS
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    }
                };
        }
        internal partial class US_KY
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday.StartAt("14:00"),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Type = Public,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "DEC31",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_LA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).In(Even),
                        Type = RuleType.Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    },
                };
            internal partial class US_LA_NO
            {
                public override List<Rule> Rules => new List<Rule>()
                    {
                        new GregorianRule()
                        {
                            Expression = ExpressionTree.Date.Catholic.CarnivalTuesday,
                            Names = NamesBuilder.Make.Add(Language.ENG, "Mardi Gras").AsDictionary()
                        }
                    };
            }
        }
        internal partial class US_ME
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Third, Monday).In(April),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Patriots' Day").AsDictionary()
                    }
                };
        }
        internal partial class US_MD
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Friday).Before(First, Monday).Before(June),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Service Reduction Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Native American Heritage Day").AsDictionary(),
                        Type = Public,
                        Overrides = Overrides.Name | Overrides.Type
                    }
                };
        }
        internal partial class US_MA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.March.The17th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Evacuation Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Third, Monday).In(April),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Patriots' Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.June.The17th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Bunker Hill Day").AsDictionary()
                    }
                };
        }
        internal partial class US_MI
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Type = Public,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "DEC31",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_MS
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Martin Luther King's and Robert E. Lee's Birthdays").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Monday).Before(May),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Confederate Memorial Day").AsDictionary()
                    }
                };
        }
        internal partial class US_MO
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.May.The8th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Truman Day").AsDictionary()
                    }
                };
        }
        internal partial class US_MT
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November),
                        Type = RuleType.Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Type = Public,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "DEC31",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_NE
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Friday).Before(May),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Arbor Day").AsDictionary()
                    }
                };
        }
        internal partial class US_NV
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Friday).Before(November),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Nevada Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Family Day").AsDictionary(),
                        Type = RuleType.Public,
                        Overrides = Overrides.Name | Overrides.Type
                    }
                };
        }
        internal partial class US_NH
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        Type = Observance,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "3MOJAN",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Martin Luther King, Jr./ Civil Rights Day").AsDictionary(),
                        Overrides = Overrides.Name
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November).In(Even),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_NJ
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    }
                };
        }
        internal partial class US_NM
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_NY
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Birthday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The15th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Susan B. Anthony Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    }
                };
        }
        internal partial class US_NC
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "3MOFEB",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Key = "2MOOCT",
                        IsEnable = false,
                        Overrides = Overrides.IsEnable
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Expression = ExpressionTree.Observe.Fix(On.December.The24th).If(Friday).Then.Previous(Thursday).Or.If(Saturday).Then.Previous(Friday).Or.If(Sunday).Then.Previous(Friday),
                        Substitute = true,
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    }
                };
        }
        internal partial class US_OK
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_PA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.June.The14th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Flag Day").AsDictionary()
                    }
                };
        }
        internal partial class US_RI
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Second, Monday).In(August),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Victory Day").AsDictionary()
                    }
                };
        }
        internal partial class US_SC
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.May.The10th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Confederate Memorial Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.December.The26th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Boxing Day").AsDictionary()
                    }
                };
        }
        internal partial class US_TN
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Catholic.GoodFriday,
                        Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "DEC24",
                        Type = Public,
                        Overrides = Overrides.Type
                    }
                };
        }
        internal partial class US_TX
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.January.The19th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Confederate Heroes Day").AsDictionary(),
                        Type = Observance,
                        Note = "state agencies are partially staffed"
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.March.The2nd),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Texas Independence Day").AsDictionary(),
                        Type = Observance,
                        Note = "state agencies are partially staffed"
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.March.The31st),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Cesar Chavez Day").AsDictionary(),
                        Type = Observance
                    },
                     new GregorianRule()
                     {
                         Expression = ExpressionTree.Date.Catholic.GoodFriday,
                         Names = NamesBuilder.Make.Add(Language.ENG, "Good Friday").AsDictionary(),
                         Type = Observance
                     },
                     new GregorianRule()
                     {
                         Expression = ExpressionTree.Date.Fix(On.April.The21st),
                         Names = NamesBuilder.Make.Add(Language.ENG, "San Jacinto Day").AsDictionary(),
                         Type = Observance,
                         Note = "state agencies are partially staffed"
                     },
                     new GregorianRule()
                     {
                         Expression = ExpressionTree.Date.Fix(On.June.The19th),
                         Names = NamesBuilder.Make.Add(Language.ENG, "Emancipation Day In Texas").AsDictionary(),
                         Type = Observance,
                         Note = "state agencies are partially staffed"
                     },
                     new GregorianRule()
                     {
                         Expression = ExpressionTree.Date.Fix(On.August.The27th),
                         Names = NamesBuilder.Make.Add(Language.ENG, "Lyndon Baines Johnson Day").AsDictionary(),
                         Type = Observance,
                         Note = "state agencies are partially staffed"
                     },
                     new GregorianRule()
                     {
                         Key = "1FRIA4THUNOV",
                         Type = Public,
                         Overrides = Overrides.Type,
                     },
                     new GregorianRule()
                     {
                         Key = "DEC24",
                         Type = Public,
                         Overrides = Overrides.Type
                     },
                     new GregorianRule()
                     {
                         Expression = ExpressionTree.Date.Fix(On.December.The26th),
                         Names = NamesBuilder.Make.Add(Language.ENG, "Day after Christmas").AsDictionary()
                     }
                };
        }
        internal partial class US_UT
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.July.The24th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Pioneer Day").AsDictionary()
                    }
                };
        }
        internal partial class US_VT
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(First, Tuesday).In(March),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Town Meeting Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Third, Monday).In(August),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Bennington Battle Da").AsDictionary()
                    }
                };
        }
        internal partial class US_VA
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Friday).Before(Third, Monday).In(January),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lee–Jackson Day").AsDictionary()
                    }
                };
        }
        internal partial class US_WV
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The15th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Susan B. Anthony Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.June.The20th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "West Virginia Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "1FRIA4THUNOV",
                        Names = NamesBuilder.Make.Add(Language.ENG, "Lincoln's Day").AsDictionary(),
                        Type = Public,
                        Overrides = Overrides.Name | Overrides.Type
                    }
                };
        }
        internal partial class US_WI
        {
            public override List<Rule> Rules => new List<Rule>()
                {
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Fix(On.February.The15th),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Susan B. Anthony Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Expression = ExpressionTree.Date.Movable(Second, Tuesday).In(September),
                        Names = NamesBuilder.Make.Add(Language.ENG, "Primary Election Day").AsDictionary()
                    },
                    new GregorianRule()
                    {
                        Key = "ELECTIONDAY",
                        Expression = ExpressionTree.Date.MovableFromMovable(First, Tuesday).After(First, Monday).In(November),
                        Type = Public,
                        Overrides = Overrides.Expression | Overrides.Type
                    }
                };
        }
    }
}


text:
layout: page
title: Wiki
description: 吾生也有涯,而知也无涯。
keywords: 维基, Wiki
comments: false
menu: 维基
permalink: /wiki/
---

> 请直接查看<https://github.com/pezy/blog/wiki>

{% for wiki in site.wiki %}
{% if wiki.title != "Wiki Template" %}

{{ wiki.title }}

{% endif %}
{% endfor %}