text:
<!DOCTYPE html>

<meta name="generator" content="Hexo 3.8.0">
  <meta charset="utf-8">

  <title>Archives | B-Side Book Club</title>
  <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
  <meta property="og:type" content="website">
<meta property="og:title" content="B-Side Book Club">
<meta property="og:url" content="https://bsidebookclub.com/archives/index.html">
<meta property="og:site_name" content="B-Side Book Club">
<meta property="og:locale" content="en">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="B-Side Book Club">

    <link rel="icon" href="/favicon.png">

    <link href="//fonts.googleapis.com/css?family=Source+Code+Pro" rel="stylesheet" type="text/css">

  <link rel="stylesheet" href="/blog/css/style.css">

          Home

          About Us

          Our Music

          Gallery

          Events

          Blog

          Contact Us

          2019

  <time datetime="2019-03-03T08:00:00.000Z" itemprop="datePublished">Mar 3</time>

      Welcome, Our Three New Members!

  <time datetime="2019-02-17T08:00:00.000Z" itemprop="datePublished">Feb 17</time>

      Stage Fright Ain't No Thang

  <time datetime="2019-01-13T08:00:00.000Z" itemprop="datePublished">Jan 13</time>

      What Even Is A Cappella?

  <time datetime="2019-01-01T20:00:00.000Z" itemprop="datePublished">Jan 1</time>

      A New Year, A New Blog

Categories

music

news

Archives

March 2019

February 2019

January 2019

Recent Posts

            Welcome, Our Three New Members!

            Stage Fright Ain't No Thang

            What Even Is A Cappella?

            A New Year, A New Blog

B-Side Book Club

An A Cappella Group

Portland, Oregon

Contact Us

© 2019 B-Side Book Club

    Home

    About Us

    Our Music

    Gallery

    Events

    Blog

    Contact Us

  <link rel="stylesheet" href="/blog/fancybox/jquery.fancybox.css">


text:
package org.apache.hadoop.hdfs.server.datanode;

import java.util.HashMap;
import java.util.Map;
import java.util.SortedSet;

import org.apache.hadoop.classification.InterfaceAudience;
import org.apache.hadoop.hdfs.protocol.LayoutVersion;
import org.apache.hadoop.hdfs.protocol.LayoutVersion.FeatureInfo;
import org.apache.hadoop.hdfs.protocol.LayoutVersion.LayoutFeature;

@InterfaceAudience.Private
public class DataNodeLayoutVersion {
  /** Build layout version and corresponding feature matrix */
  public final static Map<Integer, SortedSet<LayoutFeature>> FEATURES =
    new HashMap<Integer, SortedSet<LayoutFeature>>();

  public static final int CURRENT_LAYOUT_VERSION
      = LayoutVersion.getCurrentLayoutVersion(Feature.values());

  static{
    LayoutVersion.updateMap(FEATURES, LayoutVersion.Feature.values());
    LayoutVersion.updateMap(FEATURES, DataNodeLayoutVersion.Feature.values());
  }

  public static SortedSet<LayoutFeature> getFeatures(int lv) {
    return FEATURES.get(lv);
  }

  public static boolean supports(final LayoutFeature f, final int lv) {
    return LayoutVersion.supports(FEATURES, f, lv);
  }

  /**
   * Enums for features that change the layout version.
   *

   * To add a new layout version:
   *

   *
Define a new enum constant with a short enum name, the new layout version
   * and description of the added feature.

   *
When adding a layout version with an ancestor that is not same as
   * its immediate predecessor, use the constructor where a specific ancestor
   * can be passed.
   *

   *

   */
  public static enum Feature implements LayoutFeature {
    FIRST_LAYOUT(-49, -48, "First datanode layout", false),
    BLOCKID_BASED_LAYOUT(-50,
        "The block ID of a finalized block uniquely determines its position " +
            "in the directory structure");

    private final FeatureInfo info;

    /**
     * DataNodeFeature that is added at layout version {@code lv} - 1.
     * @param lv new layout version with the addition of this feature
     * @param description description of the feature
     */
    Feature(final int lv, final String description) {
      this(lv, lv + 1, description, false);
    }

    /**
     * DataNode feature that is added at layout version {@code ancestoryLV}.
     * @param lv new layout version with the addition of this feature
     * @param ancestorLV layout version from which the new lv is derived from.
     * @param description description of the feature
     * @param reserved true when this is a layout version reserved for previous
     *        version
     * @param features set of features that are to be enabled for this version
     */
    Feature(final int lv, final int ancestorLV, final String description,
        boolean reserved, Feature... features) {
      info = new FeatureInfo(lv, ancestorLV, description, reserved, features);
    }

    @Override
    public FeatureInfo getInfo() {
      return info;
    }
  }
}

redpajama_set_name: RedPajamaGithub


text:
namespace Newtonsoft.Json4.Tests.TestObjects
{
  public class SearchResult
  {
    public string Title { get; set; }
    public string Content { get; set; }
    public string Url { get; set; }
  }
}


text:
"""Tests for the LaMetric notify platform."""
from unittest.mock import MagicMock

from demetriek import (
    LaMetricError,
    Notification,
    NotificationIconType,
    NotificationPriority,
    NotificationSound,
    NotificationSoundCategory,
    Simple,
)
import pytest

from homeassistant.components.notify import (
    ATTR_DATA,
    ATTR_MESSAGE,
    DOMAIN as NOTIFY_DOMAIN,
)
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import HomeAssistantError

from tests.common import MockConfigEntry

NOTIFY_SERVICE = "frenck_s_lametric"

async def test_notification_defaults(
    hass: HomeAssistant,
    init_integration: MockConfigEntry,
    mock_lametric: MagicMock,
) -> None:
    """Test the LaMetric notification defaults."""
    await hass.services.async_call(
        NOTIFY_DOMAIN,
        NOTIFY_SERVICE,
        {
            ATTR_MESSAGE: "Try not to become a man of success. Rather become a man of value",
        },
        blocking=True,
    )

    assert len(mock_lametric.notify.mock_calls) == 1

    notification: Notification = mock_lametric.notify.mock_calls[0][2]["notification"]
    assert notification.icon_type is NotificationIconType.NONE
    assert notification.life_time is None
    assert notification.model.cycles == 1
    assert notification.model.sound is None
    assert notification.notification_id is None
    assert notification.notification_type is None
    assert notification.priority is NotificationPriority.INFO

    assert len(notification.model.frames) == 1
    frame = notification.model.frames[0]
    assert type(frame) is Simple
    assert frame.icon == "a7956"
    assert (
        frame.text == "Try not to become a man of success. Rather become a man of value"
    )

async def test_notification_options(
    hass: HomeAssistant,
    init_integration: MockConfigEntry,
    mock_lametric: MagicMock,
) -> None:
    """Test the LaMetric notification options."""
    await hass.services.async_call(
        NOTIFY_DOMAIN,
        NOTIFY_SERVICE,
        {
            ATTR_MESSAGE: "The secret of getting ahead is getting started",
            ATTR_DATA: {
                "icon": "1234",
                "sound": "positive1",
                "cycles": 3,
                "icon_type": "alert",
                "priority": "critical",
            },
        },
        blocking=True,
    )

    assert len(mock_lametric.notify.mock_calls) == 1

    notification: Notification = mock_lametric.notify.mock_calls[0][2]["notification"]
    assert notification.icon_type is NotificationIconType.ALERT
    assert notification.life_time is None
    assert notification.model.cycles == 3
    assert notification.model.sound is not None
    assert notification.model.sound.category is NotificationSoundCategory.NOTIFICATIONS
    assert notification.model.sound.sound is NotificationSound.POSITIVE1
    assert notification.model.sound.repeat == 1
    assert notification.notification_id is None
    assert notification.notification_type is None
    assert notification.priority is NotificationPriority.CRITICAL

    assert len(notification.model.frames) == 1
    frame = notification.model.frames[0]
    assert type(frame) is Simple
    assert frame.icon == 1234
    assert frame.text == "The secret of getting ahead is getting started"

async def test_notification_error(
    hass: HomeAssistant,
    init_integration: MockConfigEntry,
    mock_lametric: MagicMock,
) -> None:
    """Test the LaMetric notification error."""
    mock_lametric.notify.side_effect = LaMetricError

    with pytest.raises(
        HomeAssistantError, match="Could not send LaMetric notification"
    ):
        await hass.services.async_call(
            NOTIFY_DOMAIN,
            NOTIFY_SERVICE,
            {
                ATTR_MESSAGE: "It's failure that gives you the proper perspective on success",
            },
            blocking=True,
        )


text:
<!DOCTYPE html>

    <meta http-equiv="content-type" content="text/html; charset=UTF-8" />

    <title>GOV.UK - The best place to find government services and information</title>

<link href="https://assets.digital.cabinet-office.gov.uk/static/header-footer-only-6363f06b59a02988b1299b1615c3770d.css" media="screen" rel="stylesheet" type="text/css" />

<link href="https://assets.digital.cabinet-office.gov.uk/static/print-0d9fb31f928fd75de11684e3753752fc.css" media="print" rel="stylesheet" type="text/css" />

  <link href="https://assets.digital.cabinet-office.gov.uk/static/fonts-0fb6b917e34e45c93a44eec72dcc21de.css" media="all" rel="stylesheet" type="text/css" />

    <link rel="shortcut icon" href="https://assets.digital.cabinet-office.gov.uk/static/favicon-447e4ac1ab790342660eacfe3dcce264.ico" type="image/x-icon" />

<link rel="apple-touch-icon-precomposed" sizes="144x144" href="https://assets.digital.cabinet-office.gov.uk/static/apple-touch-icon-144x144-4e306e01c31e237722b82b7aa7130082.png">

<link rel="apple-touch-icon-precomposed" sizes="114x114" href="https://assets.digital.cabinet-office.gov.uk/static/apple-touch-icon-114x114-f1d7ccdc7b86d923386b373a9ba5e3db.png">

<link rel="apple-touch-icon-precomposed" sizes="72x72" href="https://assets.digital.cabinet-office.gov.uk/static/apple-touch-icon-72x72-2ddbe540853e3ba0d30fbad2a95eab3c.png">

<link rel="apple-touch-icon-precomposed" href="https://assets.digital.cabinet-office.gov.uk/static/apple-touch-icon-57x57-37527434942ed8407b091aae5feff3f3.png">

<link rel="stylesheet" href="../css/carers-allowance.css">

<meta name="viewport" content="width=device-width, initial-scale=1">
<meta name="og:image" content="https://assets.digital.cabinet-office.gov.uk/static/opengraph-image-4e469785ca4cc8f8dd18d0627bc43d19.png">

    Skip to main content

Carer's Allowance beta

GOV.UK uses cookies to make the site simpler. Find out more about cookies

For a safer, faster, better experience online you should upgrade your browser. Find out more about browsers Close

    				Security

    				About You

    				Other Info

    				Declaration

About You - the Carer

			<fieldset class="form-elements">
				<legend>Update your address details</legend>

*Address

								*Address
								<input type="text" name="address1" id="address1">

								Address 2
								<input type="text" name="address1" id="address1">

								Address 3
								<input type="text" name="address1" id="address1">

						*Postcode
						<input type="text" name="postcode" id="postcode" class="postcode">

						Daytime phone number (optional)
						<input type="tel" name="daytime" id="daytime">

						Mobile number (optional)
						<input type="tel" name="mobile" id="mobile">

			</fieldset>

				Back
				Next

Support

Cookies

Feedback

Cymraeg

Built by the Government Digital Service

All content is available under the Open Government Licence, except where otherwise stated

    © Crown Copyright


text:
<?php

namespace GitElephant\Command\Remote;

use \GitElephant\Command\SubCommandCommand;
use \GitElephant\Repository;

/**
 * Class AddRemoteCommand
 *
 * remote subcommand generator for add
 *
 * @package GitElephant\Objects
 * @author  David Neimeyer <davidneimeyer@gmail.com>
 */

class AddSubCommand extends SubCommandCommand
{
    const GIT_REMOTE_ADD = 'add';
    const GIT_REMOTE_ADD_OPTION_FETCH = '-f';
    const GIT_REMOTE_ADD_OPTION_TAGS = '--tags';
    const GIT_REMOTE_ADD_OPTION_NOTAGS = '--no-tags';
    const GIT_REMOTE_ADD_OPTION_MIRROR = '--mirror';
    const GIT_REMOTE_ADD_OPTION_SETHEAD = '-m';
    const GIT_REMOTE_ADD_OPTION_TRACK = '-t';

    /**
     * constructor
     *
     * @param \GitElephant\Repository $repo The repository object this command
     *                                      will interact with
     */
    public function __construct(Repository $repo = null)
    {
        parent::__construct($repo);
    }

    /**
     * Valid options for remote command that require an associated value
     *
     * @return array Array of all value-required options
     */
    public function addCmdValueOptions()
    {
        return array(
            self::GIT_REMOTE_ADD_OPTION_TRACK => self::GIT_REMOTE_ADD_OPTION_TRACK,
            self::GIT_REMOTE_ADD_OPTION_MIRROR => self::GIT_REMOTE_ADD_OPTION_MIRROR,
            self::GIT_REMOTE_ADD_OPTION_SETHEAD => self::GIT_REMOTE_ADD_OPTION_SETHEAD,
        );
    }

    /**
     * switch only options for the add subcommand
     *
     * @return array
     */
    public function addCmdSwitchOptions()
    {
        return array(
            self::GIT_REMOTE_ADD_OPTION_TAGS => self::GIT_REMOTE_ADD_OPTION_TAGS,
            self::GIT_REMOTE_ADD_OPTION_NOTAGS => self::GIT_REMOTE_ADD_OPTION_NOTAGS,
            self::GIT_REMOTE_ADD_OPTION_FETCH => self::GIT_REMOTE_ADD_OPTION_FETCH,
        );
    }

    /**
     * build add sub command
     *
     * @param string $name    remote name
     * @param string $url     URL of remote
     * @param array  $options options for the add subcommand
     *
     * @return string
     */
    public function prepare($name, $url, $options = array())
    {
        $options = $this->normalizeOptions(
            $options,
            $this->addCmdSwitchOptions(),
            $this->addCmdValueOptions()
        );

        $this->addCommandName(self::GIT_REMOTE_ADD);
        $this->addCommandSubject($name);
        $this->addCommandSubject($url);
        foreach ($options as $option) {
            $this->addCommandArgument($option);
        }

        return $this;
    }
}


text:
typedef enum {
    kSelectionBehaviorPartial,
    kSelectionBehaviorFull
} kSelectionBehavior;

typedef enum {
    kDragTypeNone,
    kDragTypeSelect
} kDragType;

@class LJSelectionView;

@interface LJSelectionViewController : NSObject <LJSelectionViewDelegate>

@property (nonatomic, unsafe_unretained) IBOutlet LJSelectionView* selectionView;
@property (nonatomic, assign) BOOL shouldManageSelectionUndo;
@property (nonatomic, strong) NSUndoManager* undoManager;
@property (nonatomic, assign) kSelectionBehavior selectionBehavior;
@property (nonatomic, assign) kDragType dragType;
@property (nonatomic, strong) NSSet* selectedItems;
@property (nonatomic, assign) NSRect selectionRect;

@end


text:
    <input
      <?php if($AskEnabled) : ?>checked="yes"<?php endif; ?>
      type="checkbox"
      value="1"
      name="AskEnabled"/>
      Enable questions

    Ask page title

    <input type="text" name="AskLabel" value="<?php echo $AskLabel ?>" />

    <input
      <?php if($AskEnabled) : ?>checked="yes"<?php endif; ?>
      type="checkbox"
      value="1"
      name="SubmissionsEnabled"/>
      Enable submissions

    Submit page title

    <input type="text" name="SubmitLabel" value="<?php echo $SubmitLabel ?>" />

  Twitter Username

  <input type="text" name="TwitterUsername" value="<?php echo $TwitterUsername ?>" />

Leave blank to disable.

  Post Limit:
  <select name="_per_page">
  <?php for($i = 1; $i <= 15; $i++) : ?>
    <option
      <?php if($i == $_per_page) : ?>selected="selected"<?php endif; ?>
      value="<?php echo $i; ?>"><?php echo $i; ?></option>
  <?php endfor; ?>
  </select>

CustomCSS

    <textarea name="CustomCSS" id="custom-css"><?php echo $CustomCSS; ?></textarea>


text:
#pragma once

/**
 * \file sal/logger/event.hpp
 * Logging event information
 *
 * \addtogroup logger
 * \{
 */

#include <sal/config.hpp>
#include <sal/logger/fwd.hpp>
#include <sal/char_array.hpp>
#include <sal/time.hpp>

__sal_begin

namespace logger {

/**
 * Logging event. This class shouldn't be instantiated directly but through
 * channel that handles event lifecycle etc.
 */
struct event_t
{
  /// Maximum message length
  static constexpr size_t max_message_size = 4000
    - sizeof(time_t)
    - sizeof(sink_t *)
    - sizeof(void *)
    - sizeof(char_array_t<1>) - 1
  ;

  /// Event creation time
  time_t time{};

  /// Final sink where event will be sent to
  sink_t *sink{};

  /// Opaque sink-specific data (should be used only by sink)
  void *sink_data{};

  /// Event message
  char_array_t<max_message_size> message{};

private:

  static constexpr void static_checks () noexcept
  {
    static_assert(sizeof(event_t) <= 4096);
  }
};

} // namespace logger

__sal_end

/// \}


text:
package com.baasbox.android.test;

import com.baasbox.android.BaasBox;
import com.baasbox.android.BaasHandler;
import com.baasbox.android.BaasResult;
import com.baasbox.android.BaasUser;
import com.baasbox.android.json.JsonObject;
import com.baasbox.android.test.common.BaasTestBase;

/**
 * Created by eto on 14/04/14.
 */
public class SetupGCMTest extends BaasTestBase {

    public void testEnable(){

    }
}


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Lichenotheca Veneta no. 98 (1869)

#### Original name
Lecanora sphinctrina var. pholidotoides Nyl.

### Remarks
null


text:
package org.carrot2.core;

import java.util.Map;

import org.carrot2.core.attribute.*;
import org.carrot2.util.attribute.*;

import org.carrot2.shaded.guava.common.base.Predicates;
import org.carrot2.shaded.guava.common.collect.Maps;

/**
 * Static life cycle and controller utilities (for use within the core package).
 *

 * This code is refactored to make sure the tests can perform exactly the same sequence of
 * actions without using the controller as a whole.
 */
final class ControllerUtils
{
    /**
     *
     */
    private ControllerUtils()
    {
        // no instances.
    }

    /**
     * Performs all life cycle actions required upon initialization.
     */
    @SuppressWarnings("unchecked")
    public static void init(IProcessingComponent processingComponent,
        Map<String, Object> inputAttributes, Map<String, Object> outputAttributes,
        boolean checkRequiredAttributes, IControllerContext context)
        throws ComponentInitializationException
    {
        try
        {
            AttributeBinder.set(processingComponent, inputAttributes,
                checkRequiredAttributes, Input.class, Init.class);

            processingComponent.init(context);

            AttributeBinder.get(processingComponent, outputAttributes, Output.class,
                Init.class);
        }
        catch (final InstantiationException e)
        {
            throw new ComponentInitializationException("Attribute binding failed", e);
        }
    }

    /**
     * Performs all life cycle actions required before processing starts.
     */
    @SuppressWarnings("unchecked")
    public static void beforeProcessing(IProcessingComponent processingComponent,
        Map<String, Object> attributes) throws ProcessingException
    {
        try
        {
            // Check if we need to do binding.
            if (processingComponent.getClass().getAnnotation(Bindable.class) != null)
            {
                AttributeBinder.set(processingComponent, attributes, Input.class,
                    Processing.class);
            }

            processingComponent.beforeProcessing();
        }
        catch (final InstantiationException e)
        {
            throw new ProcessingException("Attribute binding failed: " + e.getMessage(),
                e);
        }
        catch (final AttributeBindingException e)
        {
            throw new ProcessingException("Attribute binding failed: " + e.getMessage(),
                e);
        }
    }

    /**
     * Performs processing with the provided {@link IProcessingComponent}, including
     * {@link IProcessingComponent#beforeProcessing()} and
     * {@link IProcessingComponent#afterProcessing()} hooks. Please note that
     * outputAttributes will not be copied back to the inputAttributes.
     */
    public static void performProcessing(IProcessingComponent processingComponent,
        Map<String, Object> inputAttributes, Map<String, Object> outputAttributes)
    {
        try
        {
            beforeProcessing(processingComponent, inputAttributes);
            processingComponent.process();
        }
        finally
        {
            afterProcessing(processingComponent, outputAttributes);
        }
    }

    /**
     * Perform all life cycle actions after processing is completed.
     */
    @SuppressWarnings("unchecked")
    public static void afterProcessing(IProcessingComponent processingComponent,
        Map<String, Object> attributes)
    {
        try
        {
            processingComponent.afterProcessing();

            final Map<String, Object> outputAttributesWithNulls = Maps.newHashMap();
            // Check if we need to do binding.
            if (processingComponent.getClass().getAnnotation(Bindable.class) != null)
            {
                AttributeBinder.get(processingComponent, outputAttributesWithNulls,
                    Output.class, Processing.class);
            }
            attributes.putAll(Maps.filterValues(outputAttributesWithNulls,
                Predicates.notNull()));
        }
        catch (final InstantiationException e)
        {
            throw new ProcessingException("Attribute binding failed", e);
        }
    }
}


text:
    /*
    ****************************************************************
    File:     "IAbool.c" --
    Author:   Tim Hickey
    Date:     15 January 1997

    This is a placeholder file where we can later put in
    boolean interval operators.

    History:
    1/16/97 -- made shell of the file
    1/24/97 -- adjusted headers
    ****************************************************************
    */

#include "smath.h"
#include "ieeemath.h"


text:
using System;
using System.Diagnostics;
using System.Threading;

namespace Microsoft.AspNet.SignalR.Infrastructure
{
    /// <summary>
    /// Helper class to manage disposing a resource at an arbirtary time
    /// </summary>
    internal class Disposer : IDisposable
    {
        private static readonly object _disposedSentinel = new object();

        private object _disposable;

        public void Set(IDisposable disposable)
        {
            if (disposable == null)
            {
                throw new ArgumentNullException("disposable");
            }

            object originalFieldValue = Interlocked.CompareExchange(ref _disposable, disposable, null);
            if (originalFieldValue == null)
            {
                // this is the first call to Set() and Dispose() hasn't yet been called; do nothing
            }
            else if (originalFieldValue == _disposedSentinel)
            {
                // Dispose() has already been called, so we need to dispose of the object that was just added
                disposable.Dispose();
            }
            else
            {
                // Set has been called multiple times, fail
                Debug.Fail("Multiple calls to Disposer.Set(IDisposable) without calling Disposer.Dispose()");
            }
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                var disposable = Interlocked.Exchange(ref _disposable, _disposedSentinel) as IDisposable;
                if (disposable != null)
                {
                    disposable.Dispose();
                }
            }
        }

        public void Dispose()
        {
            Dispose(true);
        }
    }
}


text:
from flask import request

def get_page():
    """ Get current page

    Get current page from query string `page=x`,
    if page not given returns `1` instead.
    """
    try:
        page = request.args.get('page', 1)
        return int(page)
    except ValueError:
        return 1


text:
package dbsync;

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

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * This class handles the actual synchronization between the databases. It does
 * this by calling each database respective Handler class.
 *
 */
public class Middleware
{
	final static Logger logger = LoggerFactory.getLogger(Middleware.class);

	private Configuration configuration;

	public Middleware(Configuration configuration)
	{
		this.configuration = configuration;
	}

	/**
	 * Starts the synchronization cycle. This can also be detoured to a separate
	 * thread.
	 *
	 * @throws Exception
	 */
	public void run() throws Exception
	{
		// this will hold all rows from the Animallog table
		List<Animallog> logs = new ArrayList<Animallog>();

		MySQLHandler mysql = new MySQLHandler(this.configuration);
		PostgreHandler postgre = new PostgreHandler(this.configuration);

		while (true)
		{
			logger.info("== CHECKING ==");

			// one or more connections failed
			if (mysql.getConnection() == null
					|| postgre.getConnection() == null)
			{
				logger.error("Failed to connect to the databases.");
				break;
			}

			// query PostGre changes & save them
			logs = postgre.getAnimallog();

			// synchronize MySQL
			if (!mysql.doSync(postgre.getConnection().createStatement()))
			{
				mysql.getConnection().rollback();
				postgre.getConnection().rollback();

				logger.error("Failed to synchronize MySQL");

				break;
			}

			// Synchronize PostGre
			if (!postgre.doSync(logs, mysql.getConnection().createStatement()))
			{
				mysql.getConnection().rollback();
				postgre.getConnection().rollback();

				logger.error("Failed to synchronize Postgre");

				break;
			}

			// clear the logging tables, so we don't synchronize the same stuff
			// multiple times.
			mysql.getConnection().createStatement()
					.executeUpdate("TRUNCATE TABLE translationlog");
			postgre.getConnection().createStatement()
					.executeUpdate("TRUNCATE TABLE animallog");

			// write the above changes to the databases.
			mysql.getConnection().commit();
			postgre.getConnection().commit();

			Thread.sleep(configuration.pollingInterval);
		}

		if (mysql.getConnection() != null)
			mysql.getConnection().close();
		if (postgre.getConnection() != null)
			postgre.getConnection().close();
	}
}


text:
"""Tests for naming module."""

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

from tensorflow.python.autograph.core import naming
from tensorflow.python.platform import test

class NamerTest(test.TestCase):

  def test_function_name_tracks_names(self):
    namer = naming.Namer({})
    self.assertEqual('tf__foo', namer.function_name('foo'))
    self.assertEqual('tf__bar', namer.function_name('bar'))
    self.assertItemsEqual(('tf__bar', 'tf__foo'), namer.generated_names)

  def test_function_name_consistent(self):
    namer = naming.Namer({})
    self.assertEqual('tf__foo', namer.function_name('foo'))
    self.assertEqual('tf__foo', namer.function_name('foo'))

  def test_function_name_unsanitized_fqn(self):
    namer = naming.Namer({})
    self.assertEqual('tf__foo_bar', namer.function_name('foo.bar'))
    self.assertEqual('tf__foo_bar_baz', namer.function_name(('foo.bar', 'baz')))

  def test_class_name_basic(self):
    namer = naming.Namer({})
    self.assertEqual('TfFooBar', namer.class_name(('foo', 'Bar')))

  def test_class_name_unsanitized_fqn(self):
    namer = naming.Namer({})
    self.assertEqual('TfFooBarBaz', namer.class_name(('foo.bar', 'Baz')))

  def test_function_name_avoids_global_conflicts(self):
    namer = naming.Namer({'tf__foo': 1})
    self.assertEqual('tf__foo_1', namer.function_name('foo'))

  def test_new_symbol_tracks_names(self):
    namer = naming.Namer({})
    self.assertEqual('temp', namer.new_symbol('temp', set()))
    self.assertItemsEqual(('temp',), namer.generated_names)

  def test_new_symbol_avoids_duplicates(self):
    namer = naming.Namer({})
    self.assertEqual('temp', namer.new_symbol('temp', set()))
    self.assertEqual('temp_1', namer.new_symbol('temp', set()))
    self.assertItemsEqual(('temp', 'temp_1'), namer.generated_names)

  def test_new_symbol_avoids_conflicts(self):
    namer = naming.Namer({'temp': 1})
    # temp is reserved in the global namespace
    self.assertEqual('temp_1', namer.new_symbol('temp', set()))
    # temp_2 is reserved in the local namespace
    self.assertEqual('temp_3', namer.new_symbol('temp', set(('temp_2',))))
    self.assertItemsEqual(('temp_1', 'temp_3'), namer.generated_names)

if __name__ == '__main__':
  test.main()


text:
package com.vlitvak.todoapp.utils;

import java.util.HashMap;
import java.util.Map;

import com.google.appengine.api.utils.SystemProperty;
import com.google.inject.persist.PersistFilter;
import com.google.inject.persist.jpa.JpaPersistModule;
import com.google.inject.servlet.ServletModule;
import com.vlitvak.todoapp.auth.AuthFilter;
import com.vlitvak.todoapp.auth.AuthServlet;
import com.vlitvak.todoapp.todos.TodoListServlet;

public class MyGuiceServletModule extends ServletModule {

  @Override
  public void configureServlets() {
    serve("/v1/todos", "/v1/todos/").with(TodoListServlet.class);
    serve("/v1/auth", "/v1/auth/").with(AuthServlet.class);

    if (isOnProduction()) {
      configureProductionEnvironment();
    } else {
      configureTestEnvironment();
    }

    filter("/*").through(JsonFilter.class);
    filter("/*").through(PersistFilter.class);
    //filter("/v1/todos*").through(AuthFilter.class);
    filter("/*").through(CorsFilter.class);
  }

  public boolean isOnProduction() {
    return SystemProperty.environment.value() ==
      SystemProperty.Environment.Value.Production;
  }

  public void configureTestEnvironment() {
    Map<String, String> properties = new HashMap<String, String>();
    properties.put("javax.persistence.jdbc.driver",
        "com.mysql.jdbc.Driver");
    properties.put("javax.persistence.jdbc.url",
        System.getProperty("cloudsql.url.dev"));
    JpaPersistModule persistModule = new JpaPersistModule("Demo");
    persistModule.properties(properties);
    install(persistModule);
  }

  public void configureProductionEnvironment() {
    Map<String, String> properties = new HashMap<String, String>();
    properties.put("javax.persistence.jdbc.driver",
        "com.mysql.jdbc.GoogleDriver");
    properties.put("javax.persistence.jdbc.url",
        System.getProperty("cloudsql.url"));
    JpaPersistModule persistModule = new JpaPersistModule("Demo");
    persistModule.properties(properties);
    install(persistModule);
  }

}


text:
package ops

import "github.com/phzfi/RIC/server/images"

type Operation interface {
	Marshal() string
	Apply(images.Image) error
}


text:
package org.apache.zeppelin.rinterpreter

import java.util.Properties

import org.apache.zeppelin.RTest
import org.apache.zeppelin.rinterpreter.rscala.RException
import org.scalatest.Matchers._
import org.scalatest._

/**
 * Created by aelberg on 8/15/15.
 */
class RContextTest extends FlatSpec {
  RContext.resetRcon()

  val rcon = RContext(new Properties())

  "The RContext Singleton" should "create an RContext without Spark" in { () =>
    rcon shouldBe a[RContext]
  }

  "The RContext" should "be openable without spark" in { () =>
    rcon.open(false)
    assert(rcon.isOpen)
  }

  it should "be able to confirm that stats is available" taggedAs(RTest) in { () =>
    assertResult(true) {
      rcon.testRPackage("stats")
    }
  }

  it should "be able to confirm that a bogus package is not available"  taggedAs(RTest) in { () =>

    assertResult(false) {
      rcon.testRPackage("thisisagarbagepackagename")
    }
  }

  it should "be able to add 2 + 2"  taggedAs(RTest) in { () =>

    assertResult(4) {
      rcon.evalI0("2 + 2")
    }
  }
  it should "be able to return a vector"  taggedAs(RTest) in { () =>

    assertResult(10) {
      rcon.evalI1("1:10").length
    }
  }
  it should "be able to return a string"  taggedAs(RTest) in { () =>

    assertResult("hello world") {
      rcon.evalS0("'hello world'")
    }
  }
  it should "be able to return a vector of strings"  taggedAs(RTest)  in { () =>

    assertResult(26) {
      rcon.evalS1("LETTERS").length
    }
  }

  it should "throw an RException if told to evaluate garbage code"  taggedAs(RTest)  in { () =>

    intercept[RException] {
      rcon.eval("funkyfunction()")
    }
  }

//  it should "Throw an exception if we try to initialize SparkR without a SQLContext" in {() =>
//
//    intercept[RuntimeException] {
//      rcon.initializeSparkRTest()
//    }
//  }

  it should "have rzeppelin available"  taggedAs(RTest) in { () =>

    assertResult(true) {
      rcon.testRPackage("rzeppelin")
    }
  }
  it should "have evaluate available"  taggedAs(RTest) in { () =>

    assertResult(true) {
      rcon.testRPackage("evaluate")
    }
  }
  it should "have repr available"  taggedAs(RTest) in { () =>

    assertResult(true) {
      rcon.testRPackage("repr")
    }
  }
  it should "also close politely"  taggedAs(RTest) in { () =>

    rcon.close()
    assertResult(2) {rcon.isOpen}
  }
}


text:
require 'spec_helper'

describe GameBoard do
  describe '#duplicate_random_board' do
    context 'no eligible board' do
      before { described_class.delete_all }

      it 'instantiates a new GameBoard' do
        expect(described_class).to receive(:new)
        described_class.duplicate_random_board(size: 4, operators: :all)
      end

      it 'instantiates a new GameBoard' do
        GenerateBoards.generate_single_board(4)
        expect(described_class).to receive(:new)
        described_class.duplicate_random_board(size: 4, operators: :addition)
      end
    end

    context 'eligible board' do
      before { GenerateBoards.generate_single_board(4) }

      it 'does not instantiate a new Gameboard' do
        expect(described_class).to_not receive(:new)
        described_class.duplicate_random_board(size: 4)
      end

      it 'dups existing GameBoard' do
        expect_any_instance_of(GameBoard).to receive(:dup)
        described_class.duplicate_random_board(size: 4)
      end
    end

    context 'params' do
      it 'searches for size for and all operators by default' do
        expect(GameBoard).to receive(:where)
          .with(size: 4, operators: :all, step: 0).and_call_original
        described_class.duplicate_random_board({})
      end

      it 'searches for params when specified' do
        expect(GameBoard).to receive(:where)
          .with(size: 8, operators: :addition, step: 0).and_call_original
        described_class.duplicate_random_board(size: 8, operators: :addition)
      end
    end
  end
end


text:
package com.wesabe.grendel.openpgp;

import java.math.BigInteger;
import java.security.spec.DSAParameterSpec;

/**
 * A pre-generated {@link DSAParameterSpec} for 1024-bit
 * {@link AsymmetricAlgorithm#DSA} keys.
 *

 * N.B.: {@code P}, {@code Q}, and {@code G} are all public values and
 * can be shared across networks of users.
 * @see Digital Signature Algorithm
 * @author coda
 */
public final class PregeneratedDSAParameterSpec extends DSAParameterSpec {
	private static final BigInteger G = new BigInteger(
		"42iz5oiscx7wtyascmwkesjh4socl98ex5y2kgmnl5xnc4ny2romijch7uk53qxtnq2k" +
		"grvbx4z5qclbkkz930by9iva1dk7o5s816nen7vdwtzo6bk7nnx40y2gu55wdyzirjct" +
		"5dzh0jqjjbl0vzqmzw2si1abrrrzfaskkpb7kyqne1qctmrt2j0ozls69boond",
		36
	);
	private static final BigInteger Q = new BigInteger(
		"pcemwdiwzfzg7vw8n8el73hi1v3pelp",
		36
	);
	private static final BigInteger P = new BigInteger(
		"pmqpa15uksb3tr1710v3m0ohs0i1utcoavzgk066lbp5rkvgjtjgqb0fj847osr54s23" +
		"w4g60p0a7v3yn0twefnvvqdqn29xpe9auvblylpirmeio1usdnxwdp9bcu9n1i9jtvty" +
		"glg49753mkd5wnyaztp3qo5sm6ussie7fsf2rss7jjbcj2trgnfq4sshdm6sp7",
		36
	);

	public PregeneratedDSAParameterSpec() {
		super(P, Q, G);
	}
}


text:
import DisplayObject = require("../display/DisplayObject");
import Bounds = require("../geom/Bounds");
import Size = require("../geom/Size");
import Point = require("../geom/Point");

class ArrayUtils
{
	public static getMaxSize(arr:DisplayObject[]):Size
	{
		var size = new Size(0, 0);
		for(var i = 0; i < arr.length; i++)
		{
			size.width = Math.max(arr[i].width, size.width);
			size.height = Math.max(arr[i].height, size.height);
		}

		return size;
	}

	public static getSize(arr:DisplayObject[]):Size
	{
		var size = new Size(0, 0);
		for(var i = 0; i < arr.length; i++)
		{
			size.width += arr[i].width;
			size.height += arr[i].height;
		}

		return size;
	}
}

export = ArrayUtils;


text:
"""
Some utility functions used throughout the project.
"""
import warnings
from six.moves import filterfalse
from contextlib import contextmanager
from functools import wraps
import six

import bs4

from django.template import Context
from django.template.loader import select_template, get_template
from django.db import models
from django.db.models import query
from django.utils.http import urlencode
from django.utils.functional import memoize
from django.conf import settings

from django.contrib.auth import get_user_model
from django.utils.html import format_html
from django.utils.encoding import force_text, force_bytes

def deprecate(fn):
    @wraps(fn)
    def new(*args, **kwargs):
        warnings.warn(
            "widgy.utils.{} is deprecated. Use the version from {} instead.".format(
                fn.__name__,
                fn.__module__
            ),
            DeprecationWarning,
            stacklevel=2,
        )
        return fn(*args, **kwargs)
    return new

get_user_model = deprecate(get_user_model)
format_html = deprecate(format_html)
force_text = deprecate(force_text)
force_bytes = deprecate(force_bytes)

def extract_id(url):
    """
    >>> extract_id('/bacon/eggs/')
    'eggs'
    """
    return url and url.split('/')[-2]

def exception_to_bool(fn, exception=Exception):
    """
    :Returns: wrapped function objects that caste exceptions to `False`
        and returns `True` otherwise.

    >>> exception_to_bool(lambda: True)()
    True
    >>> exception_to_bool(lambda: arst)()  # NameError
    False
    """
    def new(*args, **kwargs):
        try:
            fn(*args, **kwargs)
            return True
        except exception:
            return False
    return new

def fancy_import(name):
    """
    This takes a fully qualified object name, like 'accounts.models.ProxyUser'
    and turns it into the accounts.models.ProxyUser object.
    """
    import_path, import_me = name.rsplit('.', 1)
    imported = __import__(import_path, globals(), locals(), [import_me])
    return getattr(imported, import_me)

@contextmanager
def update_context(context, dict):
    if context is None:
        context = {}
    if not isinstance(context, Context):
        context = Context(context)
    context.update(dict)
    yield context
    context.pop()

def build_url(path, **kwargs):
    if kwargs:
        path += '?' + urlencode(kwargs)
    return path

def html_to_plaintext(html):

    def get_text(node):
        IGNORED_TAGS = ['script', 'style', 'head']
        INDEXED_ATTRIBUTES = ['title', 'alt']
        if node.name in IGNORED_TAGS:
            pass
        else:
            for c in node.children:
                if isinstance(c, six.string_types):
                    if not isinstance(c, bs4.Comment):
                        yield c.strip()
                elif isinstance(c, bs4.Tag):
                    for attr in INDEXED_ATTRIBUTES:
                        if c.has_attr(attr):
                            yield c[attr]
                    for t in get_text(c):
                        yield t

    soup = bs4.BeautifulSoup(html)
    # This only get the element having <elem role="main">, allowing
    # to index only the main text of the page.
    main = soup.find(role='main')
    if main:
        soup = main
    text = ' '.join(get_text(soup))
    return text

def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # http://docs.python.org/2/library/itertools.html
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

class SelectRelatedManager(models.Manager):
    """
    A Manager that makes it easy to always use prefetch_related or
    select_related. ::

        objects = SelectRelatedManager(select_related=['image'])

    """

    def __init__(self, *args, **kwargs):
        self.select_related = kwargs.pop('select_related', [])
        self.prefetch_related = kwargs.pop('prefetch_related', [])
        super(SelectRelatedManager, self).__init__(*args, **kwargs)

    def get_query_set(self, *args, **kwargs):
        qs = super(SelectRelatedManager, self).get_query_set(*args, **kwargs)
        return qs.select_related(*self.select_related).prefetch_related(*self.prefetch_related)

# Pending https://code.djangoproject.com/ticket/20806, Widgy's use of
# select_template is very slow (calling it many times with a long list of
# templates to choose from). Until it's fixed in Django, memoizing
# select_template has the same effect. This is only done when DEBUG=False,
# because it requires restarting the server in order to reload the templates.
# When developping, we want to be able to update the templates and see the
# result right away.
if not settings.DEBUG:
    select_template = memoize(select_template, {}, 1)
def render_to_string(template_name, dictionary=None, context_instance=None):
    """
    Loads the given template_name and renders it with the given dictionary as
    context. The template_name may be a string to load a single template using
    get_template, or it may be a tuple to use select_template to find one of
    the templates in the list. Returns a string.
    """
    dictionary = dictionary or {}
    if isinstance(template_name, (list, tuple)):
        t = select_template(tuple(template_name))
    else:
        t = get_template(template_name)
    if not context_instance:
        return t.render(Context(dictionary))
    # Add the dictionary to the context stack, ensuring it gets removed again
    # to keep the context_instance in the same state it started in.
    with context_instance.push(dictionary):
        return t.render(context_instance)

if hasattr(models.Manager, 'from_queryset'):
    Manager = models.Manager
else:
    # Minimal and lazy backport of https://github.com/django/django/pull/1328
    class Manager(models.Manager):
        @classmethod
        def from_queryset(cls, queryset_class, class_name=None):
            if class_name is None:
                class_name = '%sFrom%s' % (cls.__name__,
                                           queryset_class.__name__)
            return type(class_name, (cls, ), {'_queryset_class': queryset_class})

        def get_queryset(self):
            return self._queryset_class(self.model, using=self.db)

        get_query_set = get_queryset # BBB

        def __getattr__(self, name):
            try:
                return super(Manager, self).__getattr__(name)
            except AttributeError:
                # Don't copy dunder methods
                if not name.startswith('_') and name not in ('delete', 'as_manager'):
                    attribute = getattr(self.get_queryset(), name, None)
                    if callable(attribute):
                        return attribute
                raise

if hasattr(query.QuerySet, 'as_manager'):
    QuerySet = query.QuerySet
else:
    # Minimal and lazy backport of https://github.com/django/django/pull/1328
    class QuerySet(query.QuerySet):
        @classmethod
        def as_manager(cls):
            return Manager.from_queryset(cls)()

def unset_pks(obj):
    """
    Unsets the pk field of a model, including its parent's pks during
    multi-table inheritance. Normally we would say

       obj.pk = None
       obj.id = None

    but we can't know for sure what the name of the actually primary key field
    is called.  So we do this to set all the primary keys to None.
    """
    for field in obj._meta.fields:
        if field.primary_key:
            setattr(obj, field.attname, None)

def model_has_field(cls, field_name):
    """
    Check if a field is already present on a model in a `safe` manner that does
    not trigger or violate application loading.
    """
    exists = field_name in [f.name for f in cls._meta.local_fields]
    if exists:
        return exists
    elif cls._meta.parents:
        return any((
            model_has_field(parent, field_name) for parent in cls._meta.parents.keys()
        ))
    else:
        return False


text:
package org.apache.beehive.netui.script.el.util;

import java.util.Collection;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.Iterator;
import java.util.Collections;

/**
 * Facade used to put a {@link Map} API atop another object.  For example, a sublcass might allow
 * the {@link javax.servlet.http.HttpSession} to be treated like a Map for purposes of referencing session
 * attributes from expressions.
 */
public abstract class MapFacade
    implements Map {

    private Map _map = null;

    /**
     * Subclasses should implement this method in order to get a value from the
     * backing object.
     * @param key the key of the object
     * @return the value associated with the key.
     */
    protected abstract Object getValue(Object key);

    /**
     * Subclasses should implement this method in order to set a value in
     * the backing object.
     * @param key the key of the object
     * @param value the value to associate with the key
     * @return the previous value associated with this key or null if no value was associated
     */
    protected abstract Object putValue(Object key, Object value);

    /**
     * Get an {@link Enumeration} of the keys associated with a backing object.  Note,
     * an {@link Enumeration} is used here because many web-based attribute maps
     * expose their list of keys only as enumeration objects.
     * @return the {@link Enumeration} of keys available from the backing object
     */
    protected abstract Iterator getKeys();

    /*--------------------------------------------------------------------------

    Implementation of the {@link Map} interface.

    -------------------------------------------------------------------------- */
    public void clear() {
    }

    public boolean containsKey(Object key) {
        return getValue(key) != null;
    }

    public Object get(Object key) {
        return getValue(key);
    }

    public Object put(Object key, Object value) {
        return putValue(key, value);
    }

    public boolean containsValue(Object key) {
        assert getMap() != null;
        return getMap().containsValue(key);
    }

    public Set entrySet() {
        assert getMap() != null;
        return Collections.unmodifiableSet(getMap().entrySet());
    }

    public boolean isEmpty() {
        assert getMap() != null;
        return getMap().isEmpty();
    }

    public Set keySet() {
        assert getMap() != null;
        return Collections.unmodifiableSet(getMap().keySet());
    }

    public void putAll(Map t) {
        assert getMap() != null;
        getMap().putAll(t);
    }

    public Object remove(Object key) {
        assert getMap() != null;
        return getMap().remove(key);
    }

    public int size() {
        assert getMap() != null;
        return getMap().size();
    }

    public Collection values() {
        assert getMap() != null;
        return Collections.unmodifiableCollection(getMap().values());
    }

    private Map getMap() {
        if(_map == null) {
            _map = new HashMap();

            Iterator keys = getKeys();
            assert keys != null;
            while(keys.hasNext()) {
                Object key = keys.next();
                _map.put(key, getValue(key));
            }
        }
        return _map;
    }
}


text:
var path = require("path");
var Resolver = require("../lib/Resolver");
var DirectoryDescriptionFileFieldAliasPlugin = require("../lib/DirectoryDescriptionFileFieldAliasPlugin");
var ModulesInDirectoriesPlugin = require("../lib/ModulesInDirectoriesPlugin");
var ModuleAsFilePlugin = require("../lib/ModuleAsFilePlugin");
var ModuleAsDirectoryPlugin = require("../lib/ModuleAsDirectoryPlugin");
var DirectoryDescriptionFilePlugin = require("../lib/DirectoryDescriptionFilePlugin");
var DirectoryDefaultFilePlugin = require("../lib/DirectoryDefaultFilePlugin");
var FileAppendPlugin = require("../lib/FileAppendPlugin");
var SyncNodeJsInputFileSystem = require("../lib/SyncNodeJsInputFileSystem");
var should = require("should");

var browserModule = path.join(__dirname, "fixtures", "browser-module");

function p() {
	return path.join.apply(path, [browserModule].concat(Array.prototype.slice.call(arguments)));
};

describe("browserField", function() {
	var resolver;

	beforeEach(function() {
		resolver = new Resolver(new SyncNodeJsInputFileSystem());
		resolver.apply(
			new DirectoryDescriptionFileFieldAliasPlugin("package.json", "browser"),
			new ModulesInDirectoriesPlugin("node", ["node_modules"]),
			new ModuleAsFilePlugin("node"),
			new ModuleAsDirectoryPlugin("node"),
			new DirectoryDescriptionFilePlugin("package.json", ["main"]),
			new DirectoryDefaultFilePlugin(["index"]),
			new FileAppendPlugin(["", ".js"])
		);
	});

	it("should ignore", function(done) {
		resolver.resolve(p(), "./lib/ignore", function(err, result) {
			if(err) throw err;
			result.should.be.eql(false);
			done();
		})
	});
	it("should ignore", function() {
		resolver.resolveSync(p(), "./lib/ignore").should.be.eql(false);
		resolver.resolveSync(p(), "./lib/ignore.js").should.be.eql(false);
		resolver.resolveSync(p("lib"), "./ignore").should.be.eql(false);
		resolver.resolveSync(p("lib"), "./ignore.js").should.be.eql(false);
	});

	it("should replace a file", function() {
		resolver.resolveSync(p(), "./lib/replaced").should.be.eql(p("lib", "browser.js"));
		resolver.resolveSync(p(), "./lib/replaced.js").should.be.eql(p("lib", "browser.js"));
		resolver.resolveSync(p("lib"), "./replaced").should.be.eql(p("lib", "browser.js"));
		resolver.resolveSync(p("lib"), "./replaced.js").should.be.eql(p("lib", "browser.js"));
	});

	it("should replace a module with a file", function() {
		resolver.resolveSync(p(), "module-a").should.be.eql(p("browser", "module-a.js"));
		resolver.resolveSync(p("lib"), "module-a").should.be.eql(p("browser", "module-a.js"));
	});

	it("should replace a module with a module", function() {
		resolver.resolveSync(p(), "module-b").should.be.eql(p("node_modules", "module-c.js"));
		resolver.resolveSync(p("lib"), "module-b").should.be.eql(p("node_modules", "module-c.js"));
	});
});