text:
package org.cloudfoundry.reactor.client.v2.organizations;

import org.cloudfoundry.client.v2.organizations.AssociateOrganizationAuditorByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationAuditorByUsernameResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationAuditorRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationAuditorResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationBillingManagerByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationBillingManagerByUsernameResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationBillingManagerRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationBillingManagerResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationManagerByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationManagerByUsernameResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationManagerRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationManagerResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationPrivateDomainRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationPrivateDomainResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationUserByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationUserByUsernameResponse;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationUserRequest;
import org.cloudfoundry.client.v2.organizations.AssociateOrganizationUserResponse;
import org.cloudfoundry.client.v2.organizations.CreateOrganizationRequest;
import org.cloudfoundry.client.v2.organizations.CreateOrganizationResponse;
import org.cloudfoundry.client.v2.organizations.DeleteOrganizationRequest;
import org.cloudfoundry.client.v2.organizations.DeleteOrganizationResponse;
import org.cloudfoundry.client.v2.organizations.GetOrganizationInstanceUsageRequest;
import org.cloudfoundry.client.v2.organizations.GetOrganizationInstanceUsageResponse;
import org.cloudfoundry.client.v2.organizations.GetOrganizationMemoryUsageRequest;
import org.cloudfoundry.client.v2.organizations.GetOrganizationMemoryUsageResponse;
import org.cloudfoundry.client.v2.organizations.GetOrganizationRequest;
import org.cloudfoundry.client.v2.organizations.GetOrganizationResponse;
import org.cloudfoundry.client.v2.organizations.GetOrganizationUserRolesRequest;
import org.cloudfoundry.client.v2.organizations.GetOrganizationUserRolesResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationAuditorsRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationAuditorsResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationBillingManagersRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationBillingManagersResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationDomainsRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationDomainsResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationManagersRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationManagersResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationPrivateDomainsRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationPrivateDomainsResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationServicesRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationServicesResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationSpaceQuotaDefinitionsRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationSpaceQuotaDefinitionsResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationSpacesRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationSpacesResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationUsersRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationUsersResponse;
import org.cloudfoundry.client.v2.organizations.ListOrganizationsRequest;
import org.cloudfoundry.client.v2.organizations.ListOrganizationsResponse;
import org.cloudfoundry.client.v2.organizations.Organizations;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationAuditorByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationAuditorRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationBillingManagerByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationBillingManagerRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationManagerByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationManagerRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationPrivateDomainRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationUserByUsernameRequest;
import org.cloudfoundry.client.v2.organizations.RemoveOrganizationUserRequest;
import org.cloudfoundry.client.v2.organizations.SummaryOrganizationRequest;
import org.cloudfoundry.client.v2.organizations.SummaryOrganizationResponse;
import org.cloudfoundry.client.v2.organizations.UpdateOrganizationRequest;
import org.cloudfoundry.client.v2.organizations.UpdateOrganizationResponse;
import org.cloudfoundry.reactor.ConnectionContext;
import org.cloudfoundry.reactor.TokenProvider;
import org.cloudfoundry.reactor.client.v2.AbstractClientV2Operations;
import reactor.core.publisher.Mono;

/**
 * The Reactor-based implementation of {@link Organizations}
 */
public final class ReactorOrganizations extends AbstractClientV2Operations implements Organizations {

    /**
     * Creates an instance
     *
     * @param connectionContext the {@link ConnectionContext} to use when communicating with the server
     * @param root              the root URI of the server.  Typically something like {@code https://api.run.pivotal.io}.
     * @param tokenProvider     the {@link TokenProvider} to use when communicating with the server
     */
    public ReactorOrganizations(ConnectionContext connectionContext, Mono<String> root, TokenProvider tokenProvider) {
        super(connectionContext, root, tokenProvider);
    }

    @Override
    public Mono<AssociateOrganizationAuditorResponse> associateAuditor(AssociateOrganizationAuditorRequest request) {
        return put(request, AssociateOrganizationAuditorResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "auditors", request.getAuditorId()));
    }

    @Override
    public Mono<AssociateOrganizationAuditorByUsernameResponse> associateAuditorByUsername(AssociateOrganizationAuditorByUsernameRequest request) {
        return put(request, AssociateOrganizationAuditorByUsernameResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "auditors"));
    }

    @Override
    public Mono<AssociateOrganizationBillingManagerResponse> associateBillingManager(AssociateOrganizationBillingManagerRequest request) {
        return put(request, AssociateOrganizationBillingManagerResponse.class,
            builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "billing_managers", request.getBillingManagerId()));
    }

    @Override
    public Mono<AssociateOrganizationBillingManagerByUsernameResponse> associateBillingManagerByUsername(AssociateOrganizationBillingManagerByUsernameRequest request) {
        return put(request, AssociateOrganizationBillingManagerByUsernameResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "billing_managers"));
    }

    @Override
    public Mono<AssociateOrganizationManagerResponse> associateManager(AssociateOrganizationManagerRequest request) {
        return put(request, AssociateOrganizationManagerResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "managers", request.getManagerId()));
    }

    @Override
    public Mono<AssociateOrganizationManagerByUsernameResponse> associateManagerByUsername(AssociateOrganizationManagerByUsernameRequest request) {
        return put(request, AssociateOrganizationManagerByUsernameResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "managers"));
    }

    @Override
    public Mono<AssociateOrganizationPrivateDomainResponse> associatePrivateDomain(AssociateOrganizationPrivateDomainRequest request) {
        return put(request, AssociateOrganizationPrivateDomainResponse.class,
            builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "private_domains", request.getPrivateDomainId()));
    }

    @Override
    public Mono<AssociateOrganizationUserResponse> associateUser(AssociateOrganizationUserRequest request) {
        return put(request, AssociateOrganizationUserResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "users", request.getUserId()));
    }

    @Override
    public Mono<AssociateOrganizationUserByUsernameResponse> associateUserByUsername(AssociateOrganizationUserByUsernameRequest request) {
        return put(request, AssociateOrganizationUserByUsernameResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "users"));
    }

    @Override
    public Mono<CreateOrganizationResponse> create(CreateOrganizationRequest request) {
        return post(request, CreateOrganizationResponse.class, builder -> builder.pathSegment("v2", "organizations"));
    }

    @Override
    public Mono<DeleteOrganizationResponse> delete(DeleteOrganizationRequest request) {
        return delete(request, DeleteOrganizationResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId()));
    }

    @Override
    public Mono<GetOrganizationResponse> get(GetOrganizationRequest request) {
        return get(request, GetOrganizationResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId()));
    }

    @Override
    public Mono<GetOrganizationInstanceUsageResponse> getInstanceUsage(GetOrganizationInstanceUsageRequest request) {
        return get(request, GetOrganizationInstanceUsageResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "instance_usage"));
    }

    @Override
    public Mono<GetOrganizationMemoryUsageResponse> getMemoryUsage(GetOrganizationMemoryUsageRequest request) {
        return get(request, GetOrganizationMemoryUsageResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "memory_usage"));
    }

    @Override
    public Mono<GetOrganizationUserRolesResponse> getUserRoles(GetOrganizationUserRolesRequest request) {
        return get(request, GetOrganizationUserRolesResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "user_roles"));
    }

    @Override
    public Mono<ListOrganizationsResponse> list(ListOrganizationsRequest request) {
        return get(request, ListOrganizationsResponse.class, builder -> builder.pathSegment("v2", "organizations"));
    }

    @Override
    public Mono<ListOrganizationAuditorsResponse> listAuditors(ListOrganizationAuditorsRequest request) {
        return get(request, ListOrganizationAuditorsResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "auditors"));
    }

    @Override
    public Mono<ListOrganizationBillingManagersResponse> listBillingManagers(ListOrganizationBillingManagersRequest request) {
        return get(request, ListOrganizationBillingManagersResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "billing_managers"));
    }

    @Override
    public Mono<ListOrganizationDomainsResponse> listDomains(ListOrganizationDomainsRequest request) {
        return get(request, ListOrganizationDomainsResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "domains"));
    }

    @Override
    public Mono<ListOrganizationManagersResponse> listManagers(ListOrganizationManagersRequest request) {
        return get(request, ListOrganizationManagersResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "managers"));
    }

    @Override
    public Mono<ListOrganizationPrivateDomainsResponse> listPrivateDomains(ListOrganizationPrivateDomainsRequest request) {
        return get(request, ListOrganizationPrivateDomainsResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "private_domains"));
    }

    @Override
    public Mono<ListOrganizationServicesResponse> listServices(ListOrganizationServicesRequest request) {
        return get(request, ListOrganizationServicesResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "services"));
    }

    @Override
    public Mono<ListOrganizationSpaceQuotaDefinitionsResponse> listSpaceQuotaDefinitions(ListOrganizationSpaceQuotaDefinitionsRequest request) {
        return get(request, ListOrganizationSpaceQuotaDefinitionsResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "space_quota_definitions"));
    }

    @Override
    public Mono<ListOrganizationSpacesResponse> listSpaces(ListOrganizationSpacesRequest request) {
        return get(request, ListOrganizationSpacesResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "spaces"));
    }

    @Override
    public Mono<ListOrganizationUsersResponse> listUsers(ListOrganizationUsersRequest request) {
        return get(request, ListOrganizationUsersResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "users"));
    }

    @Override
    public Mono<Void> removeAuditor(RemoveOrganizationAuditorRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "auditors", request.getAuditorId()));
    }

    @Override
    public Mono<Void> removeAuditorByUsername(RemoveOrganizationAuditorByUsernameRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "auditors"));
    }

    @Override
    public Mono<Void> removeBillingManager(RemoveOrganizationBillingManagerRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "billing_managers", request.getBillingManagerId()));
    }

    @Override
    public Mono<Void> removeBillingManagerByUsername(RemoveOrganizationBillingManagerByUsernameRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "billing_managers"));
    }

    @Override
    public Mono<Void> removeManager(RemoveOrganizationManagerRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "managers", request.getManagerId()));
    }

    @Override
    public Mono<Void> removeManagerByUsername(RemoveOrganizationManagerByUsernameRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "managers"));
    }

    @Override
    public Mono<Void> removePrivateDomain(RemoveOrganizationPrivateDomainRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "private_domains", request.getPrivateDomainId()));
    }

    @Override
    public Mono<Void> removeUser(RemoveOrganizationUserRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "users", request.getUserId()));
    }

    @Override
    public Mono<Void> removeUserByUsername(RemoveOrganizationUserByUsernameRequest request) {
        return delete(request, Void.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "users"));
    }

    @Override
    public Mono<SummaryOrganizationResponse> summary(SummaryOrganizationRequest request) {
        return get(request, SummaryOrganizationResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId(), "summary"));
    }

    @Override
    public Mono<UpdateOrganizationResponse> update(UpdateOrganizationRequest request) {
        return put(request, UpdateOrganizationResponse.class, builder -> builder.pathSegment("v2", "organizations", request.getOrganizationId()));
    }

}


text:
![Tortuga](docs/img/tortuga.png)

Tortuga is a minimal [turtle graphics](https://en.wikipedia.org/wiki/Turtle_graphics)
implementation in JavaScript and Canvas, intended to be used in modern browsers.

## Installation

To install it just include [`Tortuga.min.js`](https://github.com/peregrinogris/tortuga/blob/master/lib/Tortuga.min.js)
and start using it. It has no external dependencies.

## Usage

Turtle Graphics and Logo are usually associated though they are different things.
This turtle graphics lib is not quite intended to be used by kids as it has no
special easy-to-use syntax, though it's quite simple anyway:

    Code
    Output

let turtle = new Tortuga('#canvas');
for (let i = 0; i < 5; i++) {
 turtle.forward();
 turtle.right(72);
}
turtle.drawPath();

## Documentation

For a complete documentation, check the [docs](docs/README.md) section.

If you like to learn by tinkering with some code, check out the
[examples](docs/Examples.md) folder.

## History

As I was perusing a book called [Turtle Geometry](https://mitpress.mit.edu/index.php?q=books/turtle-geometry) (Abelson,
Harold, Andrea A. diSessa. *Turtle Geometry*. Cambridge: MIT Press, 1983. Print.)
I got interested in trying out the examples and exercises and I needed a tool to
do it.

I did a brief search and couldn't find something simple enough and without any
dependencies, almost all that I found were Logo implementations. Since it didn't
seem overly complex, I decided to roll my own one and Tortuga was born.

The picture on top is from:
Schöpf, Johann David.
[*Naturgeschichte der Schildkröten*](http://dx.doi.org/10.5962/bhl.title.58644).
Erlangen: Johann Jakob Palm, 1792. Print.

redpajama_set_name: RedPajamaGithub


text:
using System.Collections.Generic;
using System.Net.Http;
using Httwrap.Interception;

namespace Httwrap.Auth
{
    public class OAuth2ClientCredentials : Credentials
    {
        private readonly string _clientId;
        private readonly string _clientSecret;
        private readonly string _tokenEndpoint;
        private readonly List<string> _scopes;

        public OAuth2ClientCredentials(string clientId, string clientSecret, string tokenEndpoint, List<string> scopes)
        {
            Check.NotNullOrEmpty(clientId, "clientId");
            Check.NotNullOrEmpty(clientSecret, "clientSecret");
            Check.NotNullOrEmpty(tokenEndpoint, "tokenEndpoint");
            Check.NotNull(scopes, "scopes");
            Check.NotZeroLength(scopes, "scopes");
            _clientId = clientId;
            _clientSecret = clientSecret;
            _tokenEndpoint = tokenEndpoint;
            _scopes = scopes;
        }

        public override HttpClient BuildHttpClient(HttpMessageHandler httpHandler = null)
        {
            var httpClient = httpHandler != null ? new HttpClient(httpHandler) : new HttpClient();
            return httpClient;
        }

        public override IHttpInterceptor GetInterceptor()
        {
            var interceptor = new OAuth2ClientCredentialsInterceptor(_clientId, _clientSecret, _tokenEndpoint, _scopes);
            return interceptor;
        }

        public override bool IsTlsCredentials()
        {
            throw new System.NotImplementedException();
        }
    }
}


text:
<?php

    class HomeController extends BaseController {

        public function login() {
            View::render('login');
        }

        public function fox() {
            $headers = array();
            $headers[] = 'Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8';
            $headers[] = 'Accept-Language: de,en;q=0.8';
            $headers[] = 'Cache-Control: max-age=0';
            $headers[] = 'Host: www.steamgifts.com';
            $headers[] = 'User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/44.0.2403.81 Safari/537.36';

            $c = curl_init('http://www.steamgifts.com/giveaways/entered');

            curl_setopt($c, CURLOPT_HTTPHEADER, $headers);
            curl_setopt($c, CURLOPT_VERBOSE, TRUE);
            curl_setopt($c, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($c, CURLOPT_COOKIE, 'PHPSESSID='.Session::get('phps'));

            session_write_close();
            $page = curl_exec ($c);

            curl_close ($c);
            session_start();

            if (strlen($page) == 0) {
                Router::redirect('./key');
            } else {
                preg_match("/a href\=\"\/user\/([A-z0-9_]+)\" class\=\"/si", $page, $username);
                preg_match("/
/si", $page, $useravtr);
                preg_match("/Account \(([0-9]+)<\/span>P \/ Level ([0-9]{1,2})<\/span>\)/si", $page, $userdata);
                preg_match_all("/[^<]+<\/a>/si", $page, $wishlist);

                $won = preg_match("/Giveaways Won\" class\=\"nav__button\" href=\"\/giveaways\/won\"><\/i>
([0-9]+)<\/div><\/a>/si", $page, $giftswon);

                $user = User::where(array(
                    array("token", "=", Session::get('sess'))
                ));

                $gwon = ($won != 0) ? intval($giftswon[1]) : 0;
                Registry::set('numwon', $gwon);

                $usermeta = $user->fetch();
                Registry::set('lastjoin', Session::get('sess'));
                Session::set('last', $usermeta->lastjoin);
                Session::set('s_wi', ($usermeta->autowish == 1));
                Session::set('s_ra', ($usermeta->autorand == 1));

                Registry::set('s_wi', Session::get('s_wi'));
                Registry::set('s_ra', Session::get('s_ra'));
                Registry::set('lastjoin', $usermeta->lastjoin);

                Registry::set('username', $username[1]);
                Registry::set('useravtr', $useravtr[1]);
                Registry::set('userpnts', $userdata[1]);
                Registry::set('userlvls', $userdata[2]);
                Registry::set('userjoin', str_replace('href="', 'href="http://steamgifts.com', implode(',  ', $wishlist[0])));

                View::render('fox');
            }
        }

        public function key() {
            View::render('key');
        }

        public function pwd() {
            View::render('pwd');
        }

        public function info() {
            View::render('info');
        }

    }

?>


text:
using System.ComponentModel;

namespace LinqAn.Google.Dimensions
{
	/// <summary>
	/// 	The name of the requested custom dimension, where 25 refers the number/index of the custom dimension.
	/// </summary>
	[Description("The name of the requested custom dimension, where 25 refers the number/index of the custom dimension.")]
	public class Dimension25: Dimension
	{
		/// <summary>
		/// 	Instantiates a <seealso cref="Dimension25" />.
		/// </summary>
		public Dimension25(): base("Custom Dimension 25",true,"ga:dimension25")
		{

		}
	}
}


text:
~/src/swarming/client/isolate.py archive -I https://isolateserver.appspot.com \
  -i recipes.isolate -s recipes.isolated --blacklist '.*\.expected'

# - PYTHONPATH=../..:../../../site_config is because build/scripts/ and
#   build/site_config are implicitly assumed to be in PYTHONPATH.
# - RUN_SLAVE_UPDATED_SCRIPTS=1 disables the gclient sync that would fail.
~/src/swarming/client/swarming.py trigger -I https://isolateserver.appspot.com \
  -S https://chromium-swarm.appspot.com recipes.isolated \
  --env PYTHONPATH ../..:../../../site_config \
  --env RUN_SLAVE_UPDATED_SCRIPTS 1 \
  -d os Linux \
  -d machine_type n1-standard-16 \
  -- '--factory-properties={"recipe":"chromium_trybot"}' \
  "$@"


text:
using System.Collections.Generic;

using ICSharpCode.SharpZipLib.Zip;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

namespace MineLib.PGL.Components
{
    public class GUITextures
    {
        // Background folder.
        public Texture2D Panorama0;
        public Texture2D Panorama1;
        public Texture2D Panorama2;
        public Texture2D Panorama3;
        public Texture2D Panorama4;
        public Texture2D Panorama5;

        // Title folder.
        public Texture2D Mojang;
        public Texture2D Minecraft;

        // CreativeInventory folder.
        public Texture2D Tabs;
        public Texture2D TabItems;
        public Texture2D TabItemSearch;
        public Texture2D TabInventory;

        // Container folder.
        public Texture2D Villager;
        public Texture2D StatsIcons;
        public Texture2D Inventory;
        public Texture2D Horse;
        public Texture2D Hopper;
        public Texture2D Generic54;
        public Texture2D Furnace;
        public Texture2D EnchantingTable;
        public Texture2D Dispenser;
        public Texture2D CraftingTable;
        public Texture2D BrewingStand;
        public Texture2D Beacon;
        public Texture2D Anvil;

        // Achievement folder.
        public Texture2D AchievementIcons;
        public Texture2D AchievementBackground;

        // -- Main folder.
        public Texture2D Widgets;
        public Texture2D StreamIndicator;
        public Texture2D ResourcePacks;
        public Texture2D OptionsBackground;
        public Texture2D Icons;
        public Texture2D DemoBackground;
        public Texture2D Book;
    }

    public class TextureStorageComponent : GameComponent
    {
        // -- Debugging
        public readonly List<string> UnhandledFiles = new List<string>();
        // -- Debugging

        public GUITextures GUITextures { get; private set; }

        private ZipFile MinecraftJar { get; set; }

        public TextureStorageComponent(Game game, ZipFile minecraft) : base(game) { MinecraftJar = minecraft; }

        public void ParseGUITextures()
        {
            GUITextures = new GUITextures();
            foreach (ZipEntry entry in MinecraftJar)
            {
                switch (entry.Name)
                {
                    #region Background folder.
                    case "assets/minecraft/textures/gui/title/background/panorama_0.png":
                        GUITextures.Panorama0 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/background/panorama_1.png":
                        GUITextures.Panorama1 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/background/panorama_2.png":
                        GUITextures.Panorama2 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/background/panorama_3.png":
                        GUITextures.Panorama3 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/background/panorama_4.png":
                        GUITextures.Panorama4 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/background/panorama_5.png":
                        GUITextures.Panorama5 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    #region Title folder.
                    case "assets/minecraft/textures/gui/title/mojang.png":
                        GUITextures.Mojang = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/title/minecraft.png":
                        GUITextures.Minecraft = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    #region CreativeInventory folder.
                    case "assets/minecraft/textures/gui/container/creative_inventory/tabs.png":
                        GUITextures.Tabs = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/creative_inventory/tab_items.png":
                        GUITextures.TabItems = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/creative_inventory/tab_item_search.png":
                        GUITextures.TabItemSearch = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/creative_inventory/tab_inventory.png":
                        GUITextures.TabInventory = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    #region Container folder.
                    case "assets/minecraft/textures/gui/container/villager.png":
                        GUITextures.Villager = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/stats_icons.png":
                        GUITextures.StatsIcons = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/inventory.png":
                        GUITextures.Inventory = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/horse.png":
                        GUITextures.Horse = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/hopper.png":
                        GUITextures.Hopper = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/generic_54.png":
                        GUITextures.Generic54 = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/furnace.png":
                        GUITextures.Furnace = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/enchanting_table.png":
                        GUITextures.EnchantingTable = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/dispenser.png":
                        GUITextures.Dispenser = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/crafting_table.png":
                        GUITextures.CraftingTable = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/brewing_stand.png":
                        GUITextures.BrewingStand = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/beacon.png":
                        GUITextures.Beacon = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/container/anvil.png":
                        GUITextures.Anvil = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    #region Achievement folder.
                    case "assets/minecraft/textures/gui/achievement/achievement_icons.png":
                        GUITextures.AchievementIcons = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/achievement/achievement_background.png":
                        GUITextures.AchievementBackground = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    #region Main folder.
                    case "assets/minecraft/textures/gui/widgets.png":
                        GUITextures.Widgets = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/stream_indicator.png":
                        GUITextures.StreamIndicator = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/resource_packs.png":
                        GUITextures.ResourcePacks = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/options_background.png":
                        GUITextures.OptionsBackground = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/icons.png":
                        GUITextures.Icons = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/demo_background.png":
                        GUITextures.DemoBackground = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;

                    case "assets/minecraft/textures/gui/book.png":
						GUITextures.Book = Texture2D.FromStream(Game.GraphicsDevice, MinecraftJar.GetInputStream(entry));
                        break;
                    #endregion

                    default:
                        if (entry.Name.StartsWith("assets/minecraft/textures/gui"))
                            UnhandledFiles.Add(entry.Name);
                        break;
                }
            }
        }
    }
}


text:
namespace HomeCloud.DataStorage.Business.Entities.Converters
{
	#region Usings

	using System;

	using HomeCloud.Core;

	using File = HomeCloud.DataStorage.DataAccess.Contracts.File;
	using FileDocument = HomeCloud.DataStorage.DataAccess.Contracts.FileDocument;

	#endregion

	/// <summary>
	/// Provides converter methods for <see cref="CatalogEntry" /> entity.
	/// </summary>
	/// <seealso cref="HomeCloud.Core.ITypeConverter{HomeCloud.DataStorage.Business.Entities.CatalogEntry, HomeCloud.DataStorage.DataAccess.Contracts.File}" />
	/// <seealso cref="HomeCloud.Core.ITypeConverter{HomeCloud.DataStorage.DataAccess.Contracts.File, HomeCloud.DataStorage.Business.Entities.CatalogEntry}" />
	/// <seealso cref="HomeCloud.Core.ITypeConverter{HomeCloud.DataStorage.Business.Entities.CatalogEntry, HomeCloud.DataStorage.DataAccess.Contracts.FileDocument}" />
	/// <seealso cref="HomeCloud.Core.ITypeConverter{HomeCloud.DataStorage.DataAccess.Contracts.FileDocument, HomeCloud.DataStorage.Business.Entities.CatalogEntry}" />
	public class CatalogEntryConverter : ITypeConverter<CatalogEntry, File>, ITypeConverter<File, CatalogEntry>, ITypeConverter<CatalogEntry, FileDocument>, ITypeConverter<FileDocument, CatalogEntry>
	{
		#region ITypeConverter<CatalogEntry, File> Implementations

		/// <summary>
		/// Converts the instance of <see cref="!:TSource" /> type to the instance of <see cref="!:TTarget" />.
		/// </summary>
		/// <param name="source">The instance of <see cref="!:TSource" />.</param>
		/// <param name="target">The instance of <see cref="!:TTarget" />.</param>
		/// <returns>
		/// The converted instance of <see cref="!:TTarget" />.
		/// </returns>
		public File Convert(CatalogEntry source, File target)
		{
			target.ID = source.ID;
			target.Name = string.IsNullOrWhiteSpace(source.Name) ? target.Name : source.Name.Trim();
			target.DirectoryID = (source.Catalog?.ID).GetValueOrDefault();

			return target;
		}

		#endregion

		#region ITypeConverter<File, CatalogEntry> Implementations

		/// <summary>
		/// Converts the instance of <see cref="!:TSource" /> type to the instance of <see cref="!:TTarget" />.
		/// </summary>
		/// <param name="source">The instance of <see cref="!:TSource" />.</param>
		/// <param name="target">The instance of <see cref="!:TTarget" />.</param>
		/// <returns>
		/// The converted instance of <see cref="!:TTarget" />.
		/// </returns>
		public CatalogEntry Convert(File source, CatalogEntry target)
		{
			target.ID = source.ID;
			target.Name = source.Name;
			target.Catalog = new Catalog() { ID = source.DirectoryID };
			target.CreationDate = source.CreationDate;

			return target;
		}

		#endregion

		#region ITypeConverter<CatalogEntry, FileDocument> Implementations

		/// <summary>
		/// Converts the instance of <see cref="!:TSource" /> type to the instance of <see cref="!:TTarget" />.
		/// </summary>
		/// <param name="source">The instance of <see cref="!:TSource" />.</param>
		/// <param name="target">The instance of <see cref="!:TTarget" />.</param>
		/// <returns>
		/// The converted instance of <see cref="!:TTarget" />.
		/// </returns>
		public FileDocument Convert(CatalogEntry source, FileDocument target)
		{
			target.ID = source.ID;
			target.Path = string.IsNullOrWhiteSpace(source.Path) ? target.Path : source.Path;
			target.Size = source.Size.HasValue ? source.Size.Value : target.Size;

			return target;
		}

		#endregion

		#region ITypeConverter<FileDocument, CatalogEntry> Implementations

		/// <summary>
		/// Converts the instance of <see cref="!:TSource" /> type to the instance of <see cref="!:TTarget" />.
		/// </summary>
		/// <param name="source">The instance of <see cref="!:TSource" />.</param>
		/// <param name="target">The instance of <see cref="!:TTarget" />.</param>
		/// <returns>
		/// The converted instance of <see cref="!:TTarget" />.
		/// </returns>
		public CatalogEntry Convert(FileDocument source, CatalogEntry target)
		{
			if (target.ID == Guid.Empty)
			{
				target.ID = source.ID;
			}

			target.Path = source.Path;
			target.Size = source.Size;

			return target;
		}

		#endregion
	}
}


text:
<!DOCTYPE html>

  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8"/>
  <meta name="viewport" content="width=device-width, initial-scale=1"/>
    <link rel="shortcut icon" href="favicon5.ico" type="image/x-icon">
    <title>Harsh Dasika</title>

  <link href="https://fonts.googleapis.com/icon?family=Material+Icons" rel="stylesheet">
  <link href="css/materialize.css" type="text/css" rel="stylesheet" media="screen,projection"/>
  <link href="css/style.css" type="text/css" rel="stylesheet" media="screen,projection"/>

Extras

Work/Service Experience

Violin

Tech Portfolio

Home

Home

Tech Portfolio

Violin

Work/Service Portfolio

Extras

      menu

Community Service

IOGT International

After witnessing tragic events concerning alcohol and substance abuse in my community, I partnered up with IOGT International and made animated videos to spread the message of staying sober and healthy. The videos are here ---->

Anti-Drugs Video

Anti-Alcohol Video

Contact Information

harsh.dasika@gmail.com

846-840-9459

      Made with Materialize


text:
import React, { Component } from 'react';
import ReactDOM from 'react-dom';

export default class Example extends Component {
    render() {
        return (

Example Component

I'm an example component!

        );
    }
}

if (document.getElementById('example')) {
    ReactDOM.render(<Example />, document.getElementById('example'));
}


text:
function handleNoGeolocation(errorFlag) {
    if (errorFlag) {
        var content = 'Error: The Geolocation service failed.';
    } else {
        var content = 'Error: Your browser doesn\'t support geolocation.';
    }

    var options = {
        map: map,
        position: new google.maps.LatLng(60, 105),
        content: content
    };

    var infowindow = new google.maps.InfoWindow(options);
    map.setCenter(options.position);
}

// credit: http://jquery-howto.blogspot.com/2009/09/get-url-parameters-values-with-jquery.html
function getUrlVars() {
    var vars = [], hash;
    var hashes = window.location.href.slice(window.location.href.indexOf('?') + 1).split('&');
    for(var i = 0; i < hashes.length; i++) {
        hash = hashes[i].split('=');
        vars.push(hash[0]);
        vars[hash[0]] = hash[1];
    }
    return vars;
}

function urldecode(str) {
    return decodeURIComponent((str+'').replace(/\+/g, '%20'));
}

function calcRoute(directions, start, end, mode) {
    var travelmode;
    if (mode == "driving") {
        travelmode = google.maps.TravelMode.DRIVING;
        directions.setOptions({ polylineOptions: {strokeColor: "#00FF00"} });
    } else if (mode == "walking") {
        travelmode = google.maps.TravelMode.WALKING;
        directions.setOptions({
            polylineOptions: {
                strokeColor: "#000000",
            strokeWeight: 7,
            strokeOpacity: 0.8,
            zIndex: -4,
            }
        });
    }

    var request = {
        origin:start,
        destination:end,
        travelMode: travelmode
    };
    directionsService.route(request, function(result, status) {
        if (status == google.maps.DirectionsStatus.OK) {
            directions.setOptions({ preserveViewport: true });
            directions.setDirections(result);
        }
    });
}

function resize() {
    $("#map-canvas").css("height",$(window).height()-$("#bottom").height());
}

function meterDisplay(meterData) {
    retString = "";
    var time_limit = parseInt(meterData.time_limit);
    if (time_limit > 60)
    {
        retString = retString + (Math.floor(time_limit / 60)).toString() + " hour parking
";
    }
    else
    {
        retString = retString + time_limit.toString() + " minute parking
";
    }

    var start = parseInt(meterData.enforcement_start);
    var end = parseInt(meterData.enforcement_end);

    if (start > 12)
    {
        start = (start - 12).toString() + "PM";
    }
    else if (start === 0)
    {
        start = "12AM";
    }
    else
    {
        start = start.toString() + "AM";
    }

    if (end > 12)
    {
        end = (end - 12).toString() + "PM";
    }
    else if (end === 0)
    {
        end = "12AM";
    }
    else
    {
        end = end.toString() + "AM";
    }
    retString = retString + "Meters enforced from " + start + " to " + end + "
";

    var tpq = parseInt(meterData.time_per_quarter);
    var cents = 100 * 15 / tpq % 100;
    if (cents < 10)
    {
        cents = cents.toString() + "0";
    }
    else
    {
        cents = cents.toString();
    }
    retString = retString + "$" + parseInt(15 / tpq).toString() + "." + cents + " per hour
";

    var con = parseInt(meterData.congestion);
    if (con < 4)
    {
        retString = retString + "This meter is likely unoccupied
";
    }
    if (con > 7)
    {
        retString = retString + "This meter is frequently occupied
";
    }
    return retString;
}


text:
package edu.jhu.thrax.lexprob;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class LexprobTest extends Configured implements Tool {
  public int run(String[] argv) throws Exception {
    if (argv.length < 1) {
      System.err.println("usage: LexprobTest <file>");
      return 1;
    }

    Configuration conf = getConf();
    HashMapLexprobTable t = new HashMapLexprobTable(conf, argv[0]);
    System.err.println("HashMap populated: " + t.toString());
    TrieLexprobTable trie = new TrieLexprobTable(conf, argv[0]);
    System.err.println("Trie populated: " + trie.toString());
    return 0;
  }

  public static void main(String[] argv) throws Exception {
    ToolRunner.run(null, new LexprobTest(), argv);
    return;
  }
}


text:
#include "road_graph_builder.hpp"

#include "indexer/mwm_set.hpp"

#include "base/macros.hpp"
#include "base/logging.hpp"

#include "std/algorithm.hpp"
#include "std/shared_ptr.hpp"

using namespace routing;

namespace
{

double const MAX_SPEED_KMPH = 5.0;

/// Class provides a valid instance of FeatureID for testing purposes
class TestValidFeatureIDProvider : private MwmSet
{
public:
  TestValidFeatureIDProvider()
  {
    UNUSED_VALUE(Register(platform::LocalCountryFile::MakeForTesting("0")));

    vector<shared_ptr<MwmInfo>> mwmsInfoList;
    GetMwmsInfo(mwmsInfoList);

    m_mwmInfo = mwmsInfoList[0];
  }

  FeatureID MakeFeatureID(uint32_t offset) const
  {
    return FeatureID(MwmSet::MwmId(m_mwmInfo), offset);
  }

private:
  /// @name MwmSet overrides
  //@{
  unique_ptr<MwmInfo> CreateInfo(platform::LocalCountryFile const &) const override
  {
    unique_ptr<MwmInfo> info(new MwmInfo());
    info->m_maxScale = 1;
    info->m_limitRect = m2::RectD(0, 0, 1, 1);
    info->m_version.SetFormat(version::Format::lastFormat);
    return info;
  }
  unique_ptr<MwmValueBase> CreateValue(MwmInfo &) const override
  {
    return make_unique<MwmValueBase>();
  }
  //@}

  shared_ptr<MwmInfo> m_mwmInfo;
};

}  // namespace

namespace routing_test
{

void RoadGraphMockSource::AddRoad(RoadInfo && ri)
{
  CHECK_GREATER_OR_EQUAL(ri.m_points.size(), 2, ("Empty road"));
  m_roads.push_back(move(ri));
}

IRoadGraph::RoadInfo RoadGraphMockSource::GetRoadInfo(FeatureID const & featureId) const
{
  CHECK_LESS(featureId.m_index, m_roads.size(), ("Invalid feature id."));
  return m_roads[featureId.m_index];
}

double RoadGraphMockSource::GetSpeedKMPH(FeatureID const & featureId) const
{
  CHECK_LESS(featureId.m_index, m_roads.size(), ("Invalid feature id."));
  return m_roads[featureId.m_index].m_speedKMPH;
}

double RoadGraphMockSource::GetMaxSpeedKMPH() const
{
  return MAX_SPEED_KMPH;
}

void RoadGraphMockSource::ForEachFeatureClosestToCross(m2::PointD const & /* cross */,
                                                       CrossEdgesLoader & edgesLoader) const
{
  for (size_t roadId = 0; roadId < m_roads.size(); ++roadId)
    edgesLoader(MakeTestFeatureID(roadId), m_roads[roadId]);
}

void RoadGraphMockSource::FindClosestEdges(m2::PointD const & point, uint32_t count,
                                           vector<pair<Edge, m2::PointD>> & vicinities) const
{
  UNUSED_VALUE(point);
  UNUSED_VALUE(count);
  UNUSED_VALUE(vicinities);
}

void RoadGraphMockSource::GetFeatureTypes(FeatureID const & featureId, feature::TypesHolder & types) const
{
  UNUSED_VALUE(featureId);
  UNUSED_VALUE(types);
}

void RoadGraphMockSource::GetJunctionTypes(Junction const & junction, feature::TypesHolder & types) const
{
  UNUSED_VALUE(junction);
  UNUSED_VALUE(types);
}

FeatureID MakeTestFeatureID(uint32_t offset)
{
  static TestValidFeatureIDProvider instance;
  return instance.MakeFeatureID(offset);
}

void InitRoadGraphMockSourceWithTest1(RoadGraphMockSource & src)
{
  double const speedKMPH = MAX_SPEED_KMPH;

  IRoadGraph::RoadInfo ri0;
  ri0.m_bidirectional = true;
  ri0.m_speedKMPH = speedKMPH;
  ri0.m_points.push_back(m2::PointD(0, 0));
  ri0.m_points.push_back(m2::PointD(5, 0));
  ri0.m_points.push_back(m2::PointD(10, 0));
  ri0.m_points.push_back(m2::PointD(15, 0));
  ri0.m_points.push_back(m2::PointD(20, 0));

  IRoadGraph::RoadInfo ri1;
  ri1.m_bidirectional = true;
  ri1.m_speedKMPH = speedKMPH;
  ri1.m_points.push_back(m2::PointD(10, -10));
  ri1.m_points.push_back(m2::PointD(10, -5));
  ri1.m_points.push_back(m2::PointD(10, 0));
  ri1.m_points.push_back(m2::PointD(10, 5));
  ri1.m_points.push_back(m2::PointD(10, 10));

  IRoadGraph::RoadInfo ri2;
  ri2.m_bidirectional = true;
  ri2.m_speedKMPH = speedKMPH;
  ri2.m_points.push_back(m2::PointD(15, -5));
  ri2.m_points.push_back(m2::PointD(15, 0));

  IRoadGraph::RoadInfo ri3;
  ri3.m_bidirectional = true;
  ri3.m_speedKMPH = speedKMPH;
  ri3.m_points.push_back(m2::PointD(20, 0));
  ri3.m_points.push_back(m2::PointD(25, 5));
  ri3.m_points.push_back(m2::PointD(15, 5));
  ri3.m_points.push_back(m2::PointD(20, 0));

  src.AddRoad(move(ri0));
  src.AddRoad(move(ri1));
  src.AddRoad(move(ri2));
  src.AddRoad(move(ri3));
}

void InitRoadGraphMockSourceWithTest2(RoadGraphMockSource & graph)
{
  double const speedKMPH = MAX_SPEED_KMPH;

  IRoadGraph::RoadInfo ri0;
  ri0.m_bidirectional = true;
  ri0.m_speedKMPH = speedKMPH;
  ri0.m_points.push_back(m2::PointD(0, 0));
  ri0.m_points.push_back(m2::PointD(10, 0));
  ri0.m_points.push_back(m2::PointD(25, 0));
  ri0.m_points.push_back(m2::PointD(35, 0));
  ri0.m_points.push_back(m2::PointD(70, 0));
  ri0.m_points.push_back(m2::PointD(80, 0));

  IRoadGraph::RoadInfo ri1;
  ri1.m_bidirectional = true;
  ri1.m_speedKMPH = speedKMPH;
  ri1.m_points.push_back(m2::PointD(0, 0));
  ri1.m_points.push_back(m2::PointD(5, 10));
  ri1.m_points.push_back(m2::PointD(5, 40));

  IRoadGraph::RoadInfo ri2;
  ri2.m_bidirectional = true;
  ri2.m_speedKMPH = speedKMPH;
  ri2.m_points.push_back(m2::PointD(12, 25));
  ri2.m_points.push_back(m2::PointD(10, 10));
  ri2.m_points.push_back(m2::PointD(10, 0));

  IRoadGraph::RoadInfo ri3;
  ri3.m_bidirectional = true;
  ri3.m_speedKMPH = speedKMPH;
  ri3.m_points.push_back(m2::PointD(5, 10));
  ri3.m_points.push_back(m2::PointD(10, 10));
  ri3.m_points.push_back(m2::PointD(70, 10));
  ri3.m_points.push_back(m2::PointD(80, 10));

  IRoadGraph::RoadInfo ri4;
  ri4.m_bidirectional = true;
  ri4.m_speedKMPH = speedKMPH;
  ri4.m_points.push_back(m2::PointD(25, 0));
  ri4.m_points.push_back(m2::PointD(27, 25));

  IRoadGraph::RoadInfo ri5;
  ri5.m_bidirectional = true;
  ri5.m_speedKMPH = speedKMPH;
  ri5.m_points.push_back(m2::PointD(35, 0));
  ri5.m_points.push_back(m2::PointD(37, 30));
  ri5.m_points.push_back(m2::PointD(70, 30));
  ri5.m_points.push_back(m2::PointD(80, 30));

  IRoadGraph::RoadInfo ri6;
  ri6.m_bidirectional = true;
  ri6.m_speedKMPH = speedKMPH;
  ri6.m_points.push_back(m2::PointD(70, 0));
  ri6.m_points.push_back(m2::PointD(70, 10));
  ri6.m_points.push_back(m2::PointD(70, 30));

  IRoadGraph::RoadInfo ri7;
  ri7.m_bidirectional = true;
  ri7.m_speedKMPH = speedKMPH;
  ri7.m_points.push_back(m2::PointD(39, 55));
  ri7.m_points.push_back(m2::PointD(80, 55));

  IRoadGraph::RoadInfo ri8;
  ri8.m_bidirectional = true;
  ri8.m_speedKMPH = speedKMPH;
  ri8.m_points.push_back(m2::PointD(5, 40));
  ri8.m_points.push_back(m2::PointD(18, 55));
  ri8.m_points.push_back(m2::PointD(39, 55));
  ri8.m_points.push_back(m2::PointD(37, 30));
  ri8.m_points.push_back(m2::PointD(27, 25));
  ri8.m_points.push_back(m2::PointD(12, 25));
  ri8.m_points.push_back(m2::PointD(5, 40));

  graph.AddRoad(move(ri0));
  graph.AddRoad(move(ri1));
  graph.AddRoad(move(ri2));
  graph.AddRoad(move(ri3));
  graph.AddRoad(move(ri4));
  graph.AddRoad(move(ri5));
  graph.AddRoad(move(ri6));
  graph.AddRoad(move(ri7));
  graph.AddRoad(move(ri8));
}

}  // namespace routing_test


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package eu.derbed.openmu.gs.client;

import java.io.IOException;

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

import com.notbed.muonline.util.DataDecrypter;
import com.notbed.muonline.util.Header;

import eu.derbed.openmu.gs.ClientThread;

/**
 * @author Miki
 */
@Header (0x23)
class CItemDropFromInwentoryRequest extends SimpleClientPackage {

	private static final Logger log = LoggerFactory.getLogger(CItemDropFromInwentoryRequest.class);

	/* (non-Javadoc)
	 * @see eu.derbed.openmu.gs.clientPackage.SimpleClientPackage#process(com.notbed.muonline.util.DataDecrypter, eu.derbed.openmu.gs.ClientThread)
	 */
	@Override
	protected void process(final DataDecrypter dataDecrypter, final ClientThread client) throws IOException {
		// readC();
		final int _xPos = dataDecrypter.data[1] & 0xff;
		final int _yPos = dataDecrypter.data[2] & 0xff;
		final int _slotFrom = dataDecrypter.data[3] & 0xff;
		// 23 ad 7f 0c
		log.debug("Drop Request from slot[{}] to wsp [ {}, {} ]", _slotFrom, _xPos, _yPos);
	}// 26 0c 00
	// 23 ad 7f 0c
}


text:
<?php include 'menu.php'; ?>

Platos Más Vendidos

<?php include 'footer.php'; ?>


text:
<?php

use Sts\Core\Regions\Endpoint;
use Sts\Core\Regions\EndpointProvider;
use Sts\Core\Regions\ProductDomain;

$regionIds = array("cn-hangzhou","cn-beijing","cn-qingdao","cn-hongkong","cn-shanghai","us-west-1","cn-shenzhen","ap-southeast-1");
$productDomains =array(
	new ProductDomain("Ecs", "ecs.aliyuncs.com"),
	new ProductDomain("Rds", "rds.aliyuncs.com"),
	new ProductDomain("BatchCompute", "batchCompute.aliyuncs.com"),
	new ProductDomain("Bss", "bss.aliyuncs.com"),
	new ProductDomain("Oms", "oms.aliyuncs.com"),
	new ProductDomain("Slb", "slb.aliyuncs.com"),
	new ProductDomain("Oss", "oss-cn-hangzhou.aliyuncs.com"),
	new ProductDomain("OssAdmin", "oss-admin.aliyuncs.com"),
	new ProductDomain("Sts", "sts.aliyuncs.com"),
	new ProductDomain("Yundun", "yundun-cn-hangzhou.aliyuncs.com"),
	new ProductDomain("Risk", "risk-cn-hangzhou.aliyuncs.com"),
	new ProductDomain("Drds", "drds.aliyuncs.com"),
	new ProductDomain("M-kvstore", "m-kvstore.aliyuncs.com"),
	new ProductDomain("Ram", "ram.aliyuncs.com"),
	new ProductDomain("Cms", "metrics.aliyuncs.com"),
	new ProductDomain("Crm", "crm-cn-hangzhou.aliyuncs.com"),
	new ProductDomain("Ocs", "pop-ocs.aliyuncs.com"),
	new ProductDomain("Ots", "ots-pop.aliyuncs.com"),
	new ProductDomain("Dqs", "dqs.aliyuncs.com"),
	new ProductDomain("Location", "location.aliyuncs.com"),
	new ProductDomain("Ubsms", "ubsms.aliyuncs.com"),
	new ProductDomain("Ubsms-inner", "ubsms-inner.aliyuncs.com")
	);
$endpoint = new Endpoint("cn-hangzhou", $regionIds, $productDomains);
$endpoints = array($endpoint);
EndpointProvider::setEndpoints($endpoints);


text:
Release 1.3.0 is a feature release bringing a slew of updates.

Noteworthy features:

* #37: Support for the Riak Search HTTP Interface (Mathias Meyer)
* #36: Support to store large files in Luwak (Mathias Meyer)
* #35: Convenience methods to enable, disable and check search indexing
       on Riak buckets (Mathias Meyer)
* #34: Port of Ripple's test server to Python, allows faster testing
       thanks to an in-memory Riak instance (Mathias Meyer)
* #31: New transports: A Protocol Buffers connection cache
       (riak.transports.pbc.RiakPbcCacheTransport), a transport to reuse the
       underlying TCP connections by setting SO_REUSEADDR on the socket
       (riak.transports.http.RiakHttpReuseTransport), and one that tries to
       reuse connections to the same host (riak.transports.http.RiakHttpPoolTransport)
       (Gilles Devaux)

Fixes:

* #33: Respect maximum link header size when using HTTP. Link header is now
       split up into multiple headers when it exceeds the maximum size of 8192 bytes.
       (Mathias Meyer)
* #41: Connections potentially not returned to the protocol buffers connection
       pool. (Reid Draper)
* #42: Reset protocol buffer connection up on connection error (Brett Hoerner)

## 1.2.2 Patch Release - 2011-06-22

Release 1.2.2 is a minor patch release.

Noteworthy fixes and improvements:

* #29: Add an nicer API for using key filters with MapReduce (Eric Moritz)
* #13 and #24: Let Riak generate a key when none is specified (Mark Erdmann)
* #28: Function aliases for the Riak built-in MapReduce functions (Eric Moritz)
* #20: Add a convenience method to create Riak object directly from file (Ana Nelson)
* #16: Support return\_body parameter when creating a new object (Stefan Praszalowicz, Andy Gross)
* #17: Storing an object fails when it doesn't exist in Riak (Eric Moritz, Andy Gross)
* #18: Ensure that a default content type is set when none specified (Andy Gross)
* #22: Fix user meta data support (Mathias Meyer)
* #23: Fix links to the wiki (Mikhail Sobolev)
* #25: Enable support for code coverage when running tests (Mikhail Sobolev)
* #26: Debian packaging (Dmitry Rozhkov)


text:
{% extends "layout-2.html" %}

{% block page_title %}
  GOV.UK payment page
{% endblock %}

{% block content %}

Check your email

        An email has been sent to john.smith@digital.cabinet-office.gov.uk.

        Click the link in the email to continue your registration.

{% endblock %}


text:
package v3

import (
	"context"
	"time"

	"github.com/rancher/norman/controller"
	"github.com/rancher/norman/objectclient"
	"github.com/rancher/norman/resource"
	"k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/runtime/schema"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/apimachinery/pkg/watch"
	"k8s.io/client-go/tools/cache"
)

var (
	NodePoolGroupVersionKind = schema.GroupVersionKind{
		Version: Version,
		Group:   GroupName,
		Kind:    "NodePool",
	}
	NodePoolResource = metav1.APIResource{
		Name:         "nodepools",
		SingularName: "nodepool",
		Namespaced:   true,

		Kind: NodePoolGroupVersionKind.Kind,
	}

	NodePoolGroupVersionResource = schema.GroupVersionResource{
		Group:    GroupName,
		Version:  Version,
		Resource: "nodepools",
	}
)

func init() {
	resource.Put(NodePoolGroupVersionResource)
}

func NewNodePool(namespace, name string, obj NodePool) *NodePool {
	obj.APIVersion, obj.Kind = NodePoolGroupVersionKind.ToAPIVersionAndKind()
	obj.Name = name
	obj.Namespace = namespace
	return &obj
}

type NodePoolList struct {
	metav1.TypeMeta `json:",inline"`
	metav1.ListMeta `json:"metadata,omitempty"`
	Items           []NodePool `json:"items"`
}

type NodePoolHandlerFunc func(key string, obj *NodePool) (runtime.Object, error)

type NodePoolChangeHandlerFunc func(obj *NodePool) (runtime.Object, error)

type NodePoolLister interface {
	List(namespace string, selector labels.Selector) (ret []*NodePool, err error)
	Get(namespace, name string) (*NodePool, error)
}

type NodePoolController interface {
	Generic() controller.GenericController
	Informer() cache.SharedIndexInformer
	Lister() NodePoolLister
	AddHandler(ctx context.Context, name string, handler NodePoolHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodePoolHandlerFunc)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, handler NodePoolHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, handler NodePoolHandlerFunc)
	Enqueue(namespace, name string)
	EnqueueAfter(namespace, name string, after time.Duration)
}

type NodePoolInterface interface {
	ObjectClient() *objectclient.ObjectClient
	Create(*NodePool) (*NodePool, error)
	GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NodePool, error)
	Get(name string, opts metav1.GetOptions) (*NodePool, error)
	Update(*NodePool) (*NodePool, error)
	Delete(name string, options *metav1.DeleteOptions) error
	DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error
	List(opts metav1.ListOptions) (*NodePoolList, error)
	ListNamespaced(namespace string, opts metav1.ListOptions) (*NodePoolList, error)
	Watch(opts metav1.ListOptions) (watch.Interface, error)
	DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error
	Controller() NodePoolController
	AddHandler(ctx context.Context, name string, sync NodePoolHandlerFunc)
	AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodePoolHandlerFunc)
	AddLifecycle(ctx context.Context, name string, lifecycle NodePoolLifecycle)
	AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodePoolLifecycle)
	AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodePoolHandlerFunc)
	AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodePoolHandlerFunc)
	AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodePoolLifecycle)
	AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodePoolLifecycle)
}

type nodePoolLister struct {
	controller *nodePoolController
}

func (l *nodePoolLister) List(namespace string, selector labels.Selector) (ret []*NodePool, err error) {
	err = cache.ListAllByNamespace(l.controller.Informer().GetIndexer(), namespace, selector, func(obj interface{}) {
		ret = append(ret, obj.(*NodePool))
	})
	return
}

func (l *nodePoolLister) Get(namespace, name string) (*NodePool, error) {
	var key string
	if namespace != "" {
		key = namespace + "/" + name
	} else {
		key = name
	}
	obj, exists, err := l.controller.Informer().GetIndexer().GetByKey(key)
	if err != nil {
		return nil, err
	}
	if !exists {
		return nil, errors.NewNotFound(schema.GroupResource{
			Group:    NodePoolGroupVersionKind.Group,
			Resource: NodePoolGroupVersionResource.Resource,
		}, key)
	}
	return obj.(*NodePool), nil
}

type nodePoolController struct {
	controller.GenericController
}

func (c *nodePoolController) Generic() controller.GenericController {
	return c.GenericController
}

func (c *nodePoolController) Lister() NodePoolLister {
	return &nodePoolLister{
		controller: c,
	}
}

func (c *nodePoolController) AddHandler(ctx context.Context, name string, handler NodePoolHandlerFunc) {
	c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
		if obj == nil {
			return handler(key, nil)
		} else if v, ok := obj.(*NodePool); ok {
			return handler(key, v)
		} else {
			return nil, nil
		}
	})
}

func (c *nodePoolController) AddFeatureHandler(ctx context.Context, enabled func() bool, name string, handler NodePoolHandlerFunc) {
	c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
		if !enabled() {
			return nil, nil
		} else if obj == nil {
			return handler(key, nil)
		} else if v, ok := obj.(*NodePool); ok {
			return handler(key, v)
		} else {
			return nil, nil
		}
	})
}

func (c *nodePoolController) AddClusterScopedHandler(ctx context.Context, name, cluster string, handler NodePoolHandlerFunc) {
	c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
		if obj == nil {
			return handler(key, nil)
		} else if v, ok := obj.(*NodePool); ok && controller.ObjectInCluster(cluster, obj) {
			return handler(key, v)
		} else {
			return nil, nil
		}
	})
}

func (c *nodePoolController) AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, cluster string, handler NodePoolHandlerFunc) {
	c.GenericController.AddHandler(ctx, name, func(key string, obj interface{}) (interface{}, error) {
		if !enabled() {
			return nil, nil
		} else if obj == nil {
			return handler(key, nil)
		} else if v, ok := obj.(*NodePool); ok && controller.ObjectInCluster(cluster, obj) {
			return handler(key, v)
		} else {
			return nil, nil
		}
	})
}

type nodePoolFactory struct {
}

func (c nodePoolFactory) Object() runtime.Object {
	return &NodePool{}
}

func (c nodePoolFactory) List() runtime.Object {
	return &NodePoolList{}
}

func (s *nodePoolClient) Controller() NodePoolController {
	genericController := controller.NewGenericController(NodePoolGroupVersionKind.Kind+"Controller",
		s.client.controllerFactory.ForResourceKind(NodePoolGroupVersionResource, NodePoolGroupVersionKind.Kind, true))

	return &nodePoolController{
		GenericController: genericController,
	}
}

type nodePoolClient struct {
	client       *Client
	ns           string
	objectClient *objectclient.ObjectClient
	controller   NodePoolController
}

func (s *nodePoolClient) ObjectClient() *objectclient.ObjectClient {
	return s.objectClient
}

func (s *nodePoolClient) Create(o *NodePool) (*NodePool, error) {
	obj, err := s.objectClient.Create(o)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) Get(name string, opts metav1.GetOptions) (*NodePool, error) {
	obj, err := s.objectClient.Get(name, opts)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) GetNamespaced(namespace, name string, opts metav1.GetOptions) (*NodePool, error) {
	obj, err := s.objectClient.GetNamespaced(namespace, name, opts)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) Update(o *NodePool) (*NodePool, error) {
	obj, err := s.objectClient.Update(o.Name, o)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) UpdateStatus(o *NodePool) (*NodePool, error) {
	obj, err := s.objectClient.UpdateStatus(o.Name, o)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) Delete(name string, options *metav1.DeleteOptions) error {
	return s.objectClient.Delete(name, options)
}

func (s *nodePoolClient) DeleteNamespaced(namespace, name string, options *metav1.DeleteOptions) error {
	return s.objectClient.DeleteNamespaced(namespace, name, options)
}

func (s *nodePoolClient) List(opts metav1.ListOptions) (*NodePoolList, error) {
	obj, err := s.objectClient.List(opts)
	return obj.(*NodePoolList), err
}

func (s *nodePoolClient) ListNamespaced(namespace string, opts metav1.ListOptions) (*NodePoolList, error) {
	obj, err := s.objectClient.ListNamespaced(namespace, opts)
	return obj.(*NodePoolList), err
}

func (s *nodePoolClient) Watch(opts metav1.ListOptions) (watch.Interface, error) {
	return s.objectClient.Watch(opts)
}

// Patch applies the patch and returns the patched deployment.
func (s *nodePoolClient) Patch(o *NodePool, patchType types.PatchType, data []byte, subresources ...string) (*NodePool, error) {
	obj, err := s.objectClient.Patch(o.Name, o, patchType, data, subresources...)
	return obj.(*NodePool), err
}

func (s *nodePoolClient) DeleteCollection(deleteOpts *metav1.DeleteOptions, listOpts metav1.ListOptions) error {
	return s.objectClient.DeleteCollection(deleteOpts, listOpts)
}

func (s *nodePoolClient) AddHandler(ctx context.Context, name string, sync NodePoolHandlerFunc) {
	s.Controller().AddHandler(ctx, name, sync)
}

func (s *nodePoolClient) AddFeatureHandler(ctx context.Context, enabled func() bool, name string, sync NodePoolHandlerFunc) {
	s.Controller().AddFeatureHandler(ctx, enabled, name, sync)
}

func (s *nodePoolClient) AddLifecycle(ctx context.Context, name string, lifecycle NodePoolLifecycle) {
	sync := NewNodePoolLifecycleAdapter(name, false, s, lifecycle)
	s.Controller().AddHandler(ctx, name, sync)
}

func (s *nodePoolClient) AddFeatureLifecycle(ctx context.Context, enabled func() bool, name string, lifecycle NodePoolLifecycle) {
	sync := NewNodePoolLifecycleAdapter(name, false, s, lifecycle)
	s.Controller().AddFeatureHandler(ctx, enabled, name, sync)
}

func (s *nodePoolClient) AddClusterScopedHandler(ctx context.Context, name, clusterName string, sync NodePoolHandlerFunc) {
	s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
}

func (s *nodePoolClient) AddClusterScopedFeatureHandler(ctx context.Context, enabled func() bool, name, clusterName string, sync NodePoolHandlerFunc) {
	s.Controller().AddClusterScopedFeatureHandler(ctx, enabled, name, clusterName, sync)
}

func (s *nodePoolClient) AddClusterScopedLifecycle(ctx context.Context, name, clusterName string, lifecycle NodePoolLifecycle) {
	sync := NewNodePoolLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
	s.Controller().AddClusterScopedHandler(ctx, name, clusterName, sync)
}

func (s *nodePoolClient) AddClusterScopedFeatureLifecycle(ctx context.Context, enabled func() bool, name, clusterName string, lifecycle NodePoolLifecycle) {
	sync := NewNodePoolLifecycleAdapter(name+"_"+clusterName, true, s, lifecycle)
	s.Controller().AddClusterScopedFeatureHandler(ctx, enabled, name, clusterName, sync)
}


text:
* {
  font: 12px/1.5 'Microsoft Yahei',tahoma,arial,'\5b8b\4f53';
  font-weight: normal;
}

#container {
  position: relative;
}
.img-container {
  position: relative;
  /*margin: 3px 70px;*/
  overflow: hidden;
}
#container .img-prev:hover, #container .img-next:hover {
  background: #e6e6e6;
}
#container .img-prev:hover .img-switch-btn {
  background-position: -46px -87px;
}
#container .img-next:hover .img-switch-btn {
  background-position: -46px 0px;
}
#container .img-prev, #container .img-next {
  position: absolute;
  top: 0/*-3px*/;
  right: 0;
  width: 70px;
  font-size: 40px;
  color: #ccc;
  background: transparent;
  border: 0;
  outline: 0;
  cursor: pointer;
  height: 100%;
  -webkit-transition: background-color .2s ease-in;
  -moz-transition: background-color .2s ease-in;
  -ms-transition: background-color .2s ease-in;
  -o-transition: background-color .2s ease-in;
  transition: background-color .2s ease-in;
  -webkit-user-select: none;
  -moz-user-select: none;
  -ms-user-select: none;
  user-select: none;
}
#container .img-prev {
  left: 0;
}
#container .img-prev .img-switch-btn, #container .img-next .img-switch-btn {
  position: absolute;
  left: 50%;
  top: 50%;
  margin: -85px 0 0 -18px;
  width: 40px;
  height: 72px;
  background: url(../img/slider_btn_icon_0624374.png) no-repeat 0 0;
}
#container .img-prev .img-switch-btn {
  background-position: 0 -87px;
  margin-left: -26px;
}