x2], x5         //load row 1 in destination
    subs      w6, w6, #2                //decrement ht by 2
    st1       {v1.8b}, [x2], x5         //load row 2 in destination
    bgt       loop_4_uv                 //if greater than 0 repeat the loop again
    b         end_loops_uv

loop_8_uv:                              //each iteration processes four rows

    ld1       {v0.8b, v1.8b}, [x0], x3  //load row 1 in source 1
    ld1       {v8.8b, v9.8b}, [x1], x4  //load row 1 in source 2
    ld1       {v2.8b, v3.8b}, [x0], x3  //load row 2 in source 1
    urhadd    v0.16b, v0.16b , v8.16b
    urhadd    v1.16b, v1.16b , v9.16b
    ld1       {v10.8b, v11.8b}, [x1], x4 //load row 2 in source 2
    ld1       {v4.8b, v5.8b}, [x0], x3  //load row 3 in source 1
    urhadd    v2.16b, v2.16b , v10.16b
    urhadd    v3.16b, v3.16b , v11.16b
    ld1       {v12.8b, v13.8b}, [x1], x4 //load row 3 in source 2
    ld1       {v6.8b, v7.8b}, [x0], x3  //load row 4 in source 1
    urhadd    v4.16b, v4.16b , v12.16b
    urhadd    v5.16b, v5.16b , v13.16b
    ld1       {v14.8b, v15.8b}, [x1], x4 //load row 4 in source 2
    st1       {v0.8b, v1.8b}, [x2], x5  //load row 1 in destination
    urhadd    v6.16b, v6.16b , v14.16b
    urhadd    v7.16b, v7.16b , v15.16b
    st1       {v2.8b, v3.8b}, [x2], x5  //load row 2 in destination
    subs      w6, w6, #4                //decrement ht by 4
    st1       {v4.8b, v5.8b}, [x2], x5  //load row 3 in destination
    st1       {v6.8b, v7.8b}, [x2], x5  //load row 4 in destination
    bgt       loop_8_uv                 //if greater than 0 repeat the loop again

end_loops_uv:
    ldp       x19, x20, [sp], #16
    pop_v_regs
    ret


talBuilds').fold(0, (a, b) => a + b.intValue);
    final successful = metrics.where((m) => m.name == 'SuccessfulBuilds').fold(0, (a, b) => a + b.intValue);
    final partiallySuccessful =
        metrics.where((m) => m.name == 'PartiallySuccessfulBuilds').fold(0, (a, b) => a + b.intValue);
    final failed = metrics.where((m) => m.name == 'FailedBuilds').fold(0, (a, b) => a + b.intValue);
    final canceled = metrics.where((m) => m.name == 'CanceledBuilds').fold(0, (a, b) => a + b.intValue);

    return PipelinesMetrics(
      total: total,
      successful: successful,
      partiallySuccessful: partiallySuccessful,
      failed: failed,
      canceled: canceled,
    );
  }

  @override
  Future<ApiResponse<List<WorkItem>>> getWorkItems({
    Set<Project>? projects,
    Set<WorkItemType>? types,
    Set<WorkItemState>? states,
    Set<GraphUser>? assignedTo,
    AreaOrIteration? area,
    AreaOrIteration? iteration,
    int? id,
    String? title,
    String? savedQuery,
  }) async {
    final query = <String>[];

    final typesQuery = _getMultipleFilter(
      '[System.TeamProject]',
      projects ?? (_chosenProjects ?? _projects),
      (t) => t.name ?? '',
    );
    query.add(typesQuery);

    if (types != null) {
      final typesQuery = _getMultipleFilter('[System.WorkItemType]', types.toList(), (t) => t.name);
      query.add(typesQuery);
    }

    if (states != null) {
      final statesQuery = _getMultipleFilter('[System.State]', states.toList(), (s) => s.name);
      query.add(statesQuery);
    }

    if (assignedTo != null) {
      final assignedToQuery =
          _getMultipleFilter('[System.AssignedTo]', assignedTo.toList(), (s) => s.mailAddress ?? '');
      query.add(assignedToQuery);
    }

    if (area != null) {
      query.add(" [System.AreaPath] = '${area.escapedAreaPath}' ");
    }

    if (iteration != null) {
      query.add(" [System.IterationPath] = '${iteration.escapedIterationPath}' ");
    }

    if (title != null) {
      query.add(" [System.Title] Contains '$title' ");
    }

    if (id != null) {
      query.add(' [System.Id] = $id ');
    }

    var queryStr = '';
    if (query.isNotEmpty) {
      queryStr = query.join(' and ');
      queryStr = ' Where $queryStr ';
    }

    final effectiveQuery =
        savedQuery ?? 'Select [System.Id] From WorkItems $queryStr Order By [System.ChangedDate] desc';

    final workItemIdsRes = await _post(
      '$_basePath/_apis/wit/wiql?\$top=200&$_apiVersion',
      body: {'query': effectiveQuery},
    );
    if (workItemIdsRes.isError) return ApiResponse.error(workItemIdsRes);

    final workItemIds = GetWorkItemIds.fromResponse(workItemIdsRes);
    if (workItemIds.isEmpty) return ApiResponse.ok([]);

    final ids = workItemIds.map((e) => e.id);

    final allWorkItemsRes = await _getWorkItemsBatch(ids);
    if (allWorkItemsRes.isError) return ApiResponse.error(allWorkItemsRes.errorResponse);

    return ApiResponse.ok(allWorkItemsRes.data);
  }

  Future<ApiResponse<List<WorkItem>>> _getWorkItemsBatch(Iterable<int> ids) async {
    final batch = ids.join(',');
    final allWorkItemsRes = await _get('$_basePath/_apis/wit/workitems?ids=$batch&$_apiVersion');

    if (allWorkItemsRes.isError) return ApiResponse.error(


s->buffer, cpu)->nr = 0;
	}
	spin_unlock_irq(&stats->lock);
}

void bch2_time_stats_exit(struct bch2_time_stats *stats)
{
	if ((unsigned long) stats->buffer > TIME_STATS_NONPCPU)
		free_percpu(stats->buffer);
	stats->buffer = NULL;
}

void bch2_time_stats_init(struct bch2_time_stats *stats)
{
	memset(stats, 0, sizeof(*stats));
	stats->min_duration = U64_MAX;
	stats->min_freq = U64_MAX;
	spin_lock_init(&stats->lock);
}

void bch2_time_stats_init_no_pcpu(struct bch2_time_stats *stats)
{
	bch2_time_stats_init(stats);
	stats->buffer = (struct time_stat_buffer __percpu *) TIME_STATS_NONPCPU;
}


/*
 * xrick/rects.c
 *
 * Copyright (C) 1998-2002 BigOrno (bigorno@bigorno.net).
 * Copyright (C) 2008-2014 Pierluigi Vicinanza.
 * All rights reserved.
 *
 * The use and distribution terms for this software are contained in the file
 * named README, which can be found in the root of this distribution. By
 * using this software in any fashion, you are agreeing to be bound by the
 * terms of this license.
 *
 * You must not remove this notice, or any other, from this software.
 */

#include "xrick/rects.h"
#include "xrick/system/system.h"

/*
 * Free a list of rectangles and set the pointer to NULL.
 *
 * p: rectangle list CHANGED to NULL
 */
void
rects_free(rect_t *r)
{
    while (r)
    {
        rect_t * next = r->next;
        sysmem_pop(r);
        r = next;
    }
}

/*
 * Add a rectangle to a list of rectangles
 */
rect_t *
rects_new(U16 x, U16 y, U16 width, U16 height, rect_t *next)
{
    rect_t *r;

    r = sysmem_push(sizeof(*r));
    if (!r)
    {
        return NULL;
    }
    r->x = x;
    r->y = y;
    r->width = width;
    r->height = height;
    r->next = next;
    return r;
}

/* eof */


# Binary Search Algorithm

print("\n\nProgram Created by Kieran\n\n")

def Binary_Search(array, target):
    start_index = 0
    end_index = len(array) -1

    while (start_index <= end_index):
        mid = (start_index + end_index) // 2

        if array[mid] == target:
            return mid

        elif array[mid] < target:
            start_index = mid + 1

        else:
            end_index = mid - 1
    return -1

# Example usage
# The array must be sorted for binary search to work correctly
# The target is the number we are searching for in the array
# The function returns the index of the target if found, otherwise returns None
array_items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

goal_target = 5

print(Binary_Search(array_items, goal_target))


from sqlalchemy import Column, Integer, String, Date, ForeignKey, DateTime
from sqlalchemy.orm import relationship, backref

from .database import Base

class BaseModel():
    id = Column(Integer, primary_key=True, index=True, nullable=False)

class Driver(Base, BaseModel):
    __tablename__ = "driver"

    last_name = Column(String(30), index=True, nullable=False)
    first_name = Column(String(30), index=True, nullable=False)
    patronymic = Column(String(30), index=True, nullable=False)
    passport = Column(String(10), index=True, nullable=False)
    experience = Column(Date, index=True, nullable=False)

    trips = relationship("Trip", cascade="all, delete-orphan")

class Trip(Base, BaseModel):
    __tablename__ = "trip"

    driver_id = Column(Integer, ForeignKey("driver.id"))
    departure_time  = Column(DateTime, index=True, nullable=False)

    driver = relationship("Driver", back_populates="trips")

class User(Base, BaseModel):
    __tablename__ = "user"

    last_name = Column(String(30), index=True, nullable=False)
    first_name = Column(String(30), index=True, nullable=False)
    patronymic = Column(String(30), index=True, nullable=False)
    group = Column(String(10), index=True, nullable=False)


oroutineRunner.StartLateCoroutine(_processEnumerator, runningOrder);
            }
        }
    }

    namespace ExtraLean.Unity
    {
        public class UpdateMonoRunner : UpdateMonoRunner<IEnumerator>
        {
            public UpdateMonoRunner(string name) : base(name) {}
            public UpdateMonoRunner(string name, uint runningOrder) : base(name, runningOrder) {}
        }

        public class UpdateMonoRunner<T> : Svelto.Tasks.ExtraLean.SteppableRunner
        {
            public UpdateMonoRunner(string name) : base(name)
            {
                UnityCoroutineRunner.StartLateCoroutine(_processEnumerator, 0);
            }

            public UpdateMonoRunner(string name, uint runningOrder) : base(name)
            {
                UnityCoroutineRunner.StartLateCoroutine(_processEnumerator, runningOrder);
            }
        }
    }
}
#endif


DimensionedField<scalar, volMesh>& iF
        ) const
        {
            return tmp<fvPatchScalarField>
            (
                new wideBandDiffusiveRadiationMixedFvPatchScalarField(*this, iF)
            );
        }

    // Member functions

        // Access

            //- Return the temperature field name
            const word& TName() const
            {
                return TName_;
            }

            //- Return reference to the temperature field name to allow
            //  adjustment
            word& TName()
            {
                return TName_;
            }

        // Evaluation functions

            //- Update the coefficients associated with the patch field
            virtual void updateCoeffs();

        // I-O

            //- Write
            virtual void write(Ostream&) const;
};

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

} // End namespace Foam
}

// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

#endif

// ************************************************************************* //


import unittest

import hcl2

from checkov.terraform.checks.resource.azure.AzureDefenderOnKubernetes import check
from checkov.common.models.enums import CheckResult

class TestAzureDefenderOnKubernetes(unittest.TestCase):

    def test_failure1(self):
        hcl_res = hcl2.loads("""
                resource "azurerm_security_center_subscription_pricing" "example" {
                  tier          = "Free"
                  resource_type = "KubernetesService"
                }
                """)
        resource_conf = hcl_res['resource'][0]['azurerm_security_center_subscription_pricing']['example']
        scan_result = check.scan_resource_conf(conf=resource_conf)
        self.assertEqual(CheckResult.FAILED, scan_result)

    def test_success(self):
        hcl_res = hcl2.loads("""
                resource "azurerm_security_center_subscription_pricing" "example" {
                  tier          = "Standard"
                  resource_type = "KubernetesService"
                }
                """)
        resource_conf = hcl_res['resource'][0]['azurerm_security_center_subscription_pricing']['example']
        scan_result = check.scan_resource_conf(conf=resource_conf)
        self.assertEqual(CheckResult.PASSED, scan_result)

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


19] = "Collar luminoso",
[30420] = "Anillo de jade pesado",
[30421] = "Anillo rojo de destrucción",
[30422] = "Anillo de diamante de enfoque",
[30423] = "Monster - Staff, Blood Elf A01 Blue - Med Blue Glow",
[30424] = "Monster - Staff, Blood Elf A01 Red - High Red Glow",
[30425] = "Sangre de Foso Sangrante",
[30426] = "Llave de cofre de Cicatriz Espiral",
[30427] = "Naga Treasure Map - Questgiver (PH)",
[30428] = "Primer trozo de la Clave de Condenación",
[30429] = "Caja fuerte de Grom'tor",
[30430] = "Sangre hervida",
[30431] = "Artefacto del clan Señor del Trueno",
[30432] = "Tambor del clan Señor del Trueno",
[30433] = "Flecha del clan Señor del Trueno",
[30434] = "Tablilla del clan Señor del Trueno",
[30435] = "La Punta de Trueno",
[30436] = "Cristal azul dentado",
[30437] = "Cristal rojo dentado",
[30439] = "Monster - Polearm, 2H Ruul",
[30440] = "Monstruo - lanza, La Punta de Trueno",
[30441] = "Monster - Staff, Blood Elf A02 Red (Yellow Flame)",
[30442] = "Llave cristalina",
[30443] = "Receta: transmutar fuego primigenio a tierra",
[30444] = "Patrón: bolsa de minero reforzada",
[30445] = "Monster - Mace, Kurdran's Hammer",
[30446] = "Zafiro solar",
[30447] = "Escrito sobre Redención ígnea",
[30448] = "Garfa de Al'ar",
[30449] = "Dije de estrella del Vacío",
[30450] = "Anillo de saltadistorsión",
[30451] = "Lohn'goron, arco del corazón roto",
[30452] = "Monster - Bow, Spirit Hunter",
[30453] = "Segundo trozo de la Clave de Condenación",
[30454] = "Caja fuerte de Ar'tor",
[30455] = "Monster - 2H Typhoon",
[30456] = "Monster - Bow, Hunter Epic",
[30457] = "Agua con gas de Gilneas",
[30458] = "Munster de Stromgarde",
[30459] = "Toga de llama abisal",
[30460] = "Cinturón de llama abisal",
[30461] = "Botas de llama abisal",
[30462] = "Silbato de jabalíes de Oronok",
[30463] = "Cinturón de sangrevida",
[30464] = "Brazales de sangrevida",
[30465] = "Leotardos sangrevida",
[30466] = "Diente de crocolisco",
[30467] = "Cola de crocolisco incomible",
[30468] = "Pipa de agua de T'chali",
[30469] = "Patrón: toga de llama abisal",
[30470] = "Patrón: cinturón de llama abisal",
[30471] = "Patrón: botas de llama abisal",
[30472] = "Patrón: leotardos de sangrevida",
[30473] = "Patrón: cinturón de sangrevida",
[30474] = "Patrón: brazales de sangrevida",
[30475] = "Espina de cuchilla",
[30476] = "Flor hipnótica",
[30477] = "Tejido conectivo",
[30478] = "Ectoplasma viscoso


ing,
        label:string,
        type:string,
        setValue: React.Dispatch<string>
    }

}///////////////////*Start quiz*////////////////
function generateToken(min, max) {
    min = Math.ceil(min);
    max = Math.ceil(max);
    let token = Math.floor(Math.random() * (max - min) + min);

    if (localStorage.getItem(token.toString()) != null) return generateToken(min, max * max);
    else return token.toString();
}

function initialize(nickName) {
    let id = generateToken(1, 1000);
    sessionStorage.setItem("id", id);
    sessionStorage.setItem("nickName", nickName);
}

function startQuiz() {
    let nick = document.getElementById("nickName") as HTMLInputElement;

    if (nick.value.length == 0) {
        window.alert("Proszę podać nazwę użytkownika");
        return;
    }

    if (window.confirm("Czy chcesz zacząć quiz? Po zatwierdzeniu zacznie sie odliczanie czasu")) {
        initialize(nick.value);
        window.location.href = 'multiply.html';
    }
}

//////////////*Table with results*///////////

function showStandings() {
    let ul = document.createElement("ul");
    document.body.appendChild(ul);
    ul.setAttribute("style", "width: 300px; margin: auto; margin-top: 10px;")
    let results = JSON.parse(localStorage.getItem("top"));
    if(results == null) {
        let li = document.createElement('li');
        ul.appendChild(li);
        li.innerHTML += "Brak wyników";

        return;
    }

    let place = 1;
    for (let i = 0; i < 10; i ++) {
        if (results[i][1] != "") {

            let li = document.createElement('li');
            li.setAttribute("style", "list-style-type: none;border-color: purple;border-width: 2px;border-style: solid;");
            ul.appendChild(li);

            li.innerHTML += place + ". " + results[i][0] + " " + results[i][1];

            place ++;
        }
    }
}import * as actions from "./notification-center.actions";
import { NotificationState, REDUCER_KEY } from "./notification-center.reducer";

const createInterceptorMiddleware =
  (interceptors) => (store) => (next) => (action) => {
    interceptors
      .filter((interceptor) => interceptor.type === action.type)
      .forEach((interceptor) =>
        interceptor.handler(action, store.dispatch, store.getState())
      );

    next(action);
  };

const interceptors = [
  {
    type: actions.TOGGLE_NOTIFICATION_CENTER,
    handler: (_, dispatch, state: NotificationState) => {
      const { hasNoNotification, isOpen, notifications } = state[REDUCER_KEY];
      if (!hasNoNotification && !isOpen && notifications.length === 0) {
        dispatch(actions.fetchNotificationPending());
        fetch(`http://localhost:4280?pageSize=5&pageNumber=1`)
          .then((res) => res.json())
          .then((response) => {
            dispatch(
              actions.fetchNotificationSuccess(
                response.notifications,
                response.count
              )
            );
          })
          .catch((error) => dispatch(actions.fetchNotificationFailure(error)));
      }
    },
  },
  {
    type: actions.HAS_NO_NOTIFICATIONS,
    handler: (_, dispatch, state: NotificationState) => {
      const { hasNoNotification, isOpen } = state[REDUCER_KEY];
      if (!hasNoNotification && isOpen) {


	//long start = System.currentTimeMillis();
		for (int i = 0; i < cache.size(); i++) {
			CachedRegion region = cache.get(i);
			if (region.snap == snap && region.contains(address)) {
				cache.remove(i);
				cache.add(0, region);
				//hits++;
				//totalCheck += System.currentTimeMillis() - start;
				return region;
			}
		}
		//totalCheck += System.currentTimeMillis() - start;
		CachedRegion region;
		if (cache.size() >= maxRegions) {
			region = cache.remove(0);
			region.reInit(snap, computeNewCachedRange(address));
		}
		else {
			region = new CachedRegion(snap, computeNewCachedRange(address));
		}
		//start = System.currentTimeMillis();
		loadCachedRegion(region);
		//totalLoad += System.currentTimeMillis() - start;
		cache.add(region);
		//misses++;
		return region;
	}

	protected AddressRange computeNewCachedRange(Address address) {
		return ImmutableTraceAddressSnapRange.rangeCentered(address, addressBreadth);
	}

	public T getFloor(long snap, Address address) {
		//long start = System.currentTimeMillis();
		T result = ensureInCache(snap, address).getFloor(address);
		//totalQuery += System.currentTimeMillis() - start;
		return result;
	}

	public T getCeiling(long snap, Address address) {
		//long start = System.currentTimeMillis();
		T result = ensureInCache(snap, address).getCeiling(address);
		//totalQuery += System.currentTimeMillis() - start;
		return result;
	}

	public void notifyNewEntry(Lifespan lifespan, AddressRangeImpl range, T item) {
		// TODO: Can this be smarter?
		invalidate();
	}

	public void notifyEntryRemoved(Lifespan lifespan, AddressRange range, T item) {
		// TODO: Can this be smarter?
		invalidate();
	}

	public void notifyEntryShapeChanged(Lifespan lifespan, AddressRange range, T item) {
		// TODO: Can this be smarter?
		invalidate();
	}

	public void invalidate() {
		cache.clear();
	}
}
/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package ghidra.trace.model;

import ghidra.program.model.address.*;
import ghidra.util.database.spatial.rect.EuclideanSpace2D;

public class ImmutableTraceAddressSnapRange implements TraceAddressSnapRange {
	public static AddressRange rangeCentered(Address address, int breadth) {
		AddressSpace space = address.getAddressSpace();
		Address min = Long.compareUnsigned(address.subtract(space.getMinAddress()), breadth) <= 0
				? space.getMinAddress()
				: address.subtract(breadth);
		Address max = Long.compareUnsigned(space.getMaxAddress().subtract(address), breadth) <= 0
				? space.getMaxAddress()
				: address.add(breadth);
		return new AddressRangeImpl(min, max);
	}

	public static Lifespan spanCentered(long snap, int breadth) {
		long min = Long.compareUnsigned(snap - Long.MIN_VALUE, breadth) <= 0
				? Long.MIN_VALUE
				: snap - breadth;
		long max = Long.compareUnsigned(Long.M


.bind(this),
      });
    }

    if (componentName === 'StationItem') {
      const station = stationStore.$state.stations[Number(el.dataset.key)];
      return new StationItem(el, {
        name: station.name,
        editStation: () => this.$modal.open(station),
        removeStation: () => this.removeStation(station),
      });
    }
  }

  private get $modal(): StationUpdateModal {
    return this.$components.StationUpdateModal as StationUpdateModal;
  }

  private async addStation(stationName: string) {
    try {
      this.validateStationName(stationName);
    } catch (message) {
      return alert(message);
    }

    try {
      await stationStore.dispatch(ADD_STATION, stationName);
      alert('역이 추가되었습니다.');
    } catch (e) {
      alert(e.message);
    }
  }

  private async updateStation(station: StationResponse) {
    try {
      this.validateStationName(station.name);
    } catch (message) {
      return alert(message);
    }

    try {
      await stationStore.dispatch(UPDATE_STATION, station);
      alert('역이 수정되었습니다.');
      this.$modal.close();
    } catch (e) {
      alert(e.message);
    }
  }

  private async removeStation(station: StationResponse) {

    try {
      await stationStore.dispatch(REMOVE_STATION, station);
      alert('역이 삭제되었습니다.');
    } catch (e) {
      alert(e.message);
    }

  }

  private validateStationName(stationName: string) {
    if (stationName.length < STATION_NAME_MIN_LENGTH) {
      throw `역의 이름은 ${STATION_NAME_MIN_LENGTH}글자 이상으로 입력해주세요.`;
    }

    if (stationName.length >= STATION_NAME_MAX_LENGTH) {
      throw `역의 이름은 ${STATION_NAME_MAX_LENGTH}글자 이하로 입력해주세요.`;
    }
  }
}
/*
 * This provides responses to UI input.
 */
import {AnimatedSprite} from "../scene/sprite/AnimatedSprite"
import {SceneGraph} from "../scene/SceneGraph"
import { CircleObject } from "../scene/sprite/CircleObject";
import { ResourceManager } from "../files/ResourceManager";
import { AnimatedSpriteType } from "../scene/sprite/AnimatedSpriteType";

export class UIController {
    private hoveredSprite : AnimatedSprite;
    private spriteToDrag : AnimatedSprite;
    private circleToDrag : CircleObject;
    private scene : SceneGraph;
    private dragOffsetX : number;
    private dragOffsetY : number;
    private resourceManager : ResourceManager;
    private hoveredCircle : CircleObject;

    public constructor() {}

    public init(canvasId : string, initScene : SceneGraph, resourseManager: ResourceManager) : void {
        this.hoveredSprite = null

        this.spriteToDrag = null;
        this.scene = initScene;
        this.dragOffsetX = -1;
        this.dragOffsetY = -1;
        this.resourceManager = resourseManager;

        let canvas : HTMLCanvasElement = <HTMLCanvasElement>document.getElementById(canvasId);
        canvas.addEventListener("mousedown", this.mouseDownHandler);
        canvas.addEventListener("mousemove", this.mouseMoveHandler);
        canvas.addEventListener("mousemove", this.mouseHoverHandler);
        canvas.addEventListener("mouseup", this.mouseUpHandler);
        canvas.addEventListener("dblclick", this.mouseDoubleClickHandler);
    }
    public getHoveredSprite() : AnimatedSprite {
        return this.hoveredSprite;
    }
    public getHoveredCircle() : CircleObject{
        return this.hoveredCircle;
    }
    //Mouse over details
    public mouseHoverHandler = (event: MouseEvent) : void => {
        let mouseLocationX : number


 'package:miro/config/locator.dart';
import 'package:miro/infra/dto/shared/messages/msg_send.dart';
import 'package:miro/shared/models/network/network_properties_model.dart';
import 'package:miro/shared/models/tokens/token_alias_model.dart';
import 'package:miro/shared/models/tokens/token_amount_model.dart';
import 'package:miro/shared/models/transactions/form_models/msg_send_form_model.dart';
import 'package:miro/shared/models/transactions/messages/msg_send_model.dart';
import 'package:miro/shared/models/transactions/messages/tx_msg_type.dart';
import 'package:miro/shared/models/transactions/signed_transaction_model.dart';
import 'package:miro/shared/models/transactions/tx_local_info_model.dart';
import 'package:miro/shared/models/transactions/tx_remote_info_model.dart';
import 'package:miro/shared/models/wallet/wallet_address.dart';
import 'package:miro/test/mock_locator.dart';
import 'package:miro/test/utils/test_utils.dart';

// To run this test type in console:
// fvm flutter test test/unit/blocs/pages/transactions/tx_process_cubit_test.dart --platform chrome --null-assertions
Future<void> main() async {
  await initMockLocator();
  await TestUtils.setupNetworkModel(networkUri: Uri.parse('https://healthy.kira.network/'));

  AuthCubit actualAuthCubit = globalLocator<AuthCubit>();
  SignedTxModel signedTxModel = SignedTxModel(
    txLocalInfoModel: TxLocalInfoModel(
      memo: 'Test transaction',
      feeTokenAmountModel: TokenAmountModel(
        defaultDenominationAmount: Decimal.fromInt(100),
        tokenAliasModel: TokenAliasModel.local('ukex'),
      ),
      txMsgModel: MsgSendModel(
        fromWalletAddress: WalletAddress.fromBech32('kira143q8vxpvuykt9pq50e6hng9s38vmy844n8k9wx'),
        toWalletAddress: WalletAddress.fromBech32('kira177lwmjyjds3cy7trers83r4pjn3dhv8zrqk9dl'),
        tokenAmountModel: TokenAmountModel(
          defaultDenominationAmount: Decimal.fromInt(100),
          tokenAliasModel: TokenAliasModel.local('ukex'),
        ),
      ),
    ),
    txRemoteInfoModel: const TxRemoteInfoModel(
      accountNumber: '669',
      chainId: 'testnet-9',
      sequence: '106',
    ),
    signedCosmosTx: CosmosTx.signed(
      body: CosmosTxBody(
        messages: <ProtobufAny>[
          MsgSend(
            fromAddress: 'kira143q8vxpvuykt9pq50e6hng9s38vmy844n8k9wx',
            toAddress: 'kira177lwmjyjds3cy7trers83r4pjn3dhv8zrqk9dl',
            amount: <CosmosCoin>[
              CosmosCoin(denom: 'ukex', amount: BigInt.from(100)),
            ],
          ),
        ],
        memo: 'Test transaction',
      ),
      authInfo: CosmosAuthInfo(
        signerInfos: <CosmosSignerInfo>[
          CosmosSignerInfo(
            publicKey: CosmosSimplePublicKey(base64Decode('AlLas8CJ6lm5yZJ8h0U5Qu9nzVvgvskgHuURPB3jvUx8')),
            modeInfo: CosmosModeInfo.single(CosmosSignMode.signModeDirect),
            sequence: 106,
          ),
        ],
        fee: CosmosFee(
          gasLimit: BigInt.from(20000),
          amount: <CosmosCoin>[
            CosmosCoin(denom: 'ukex', amount: BigInt.from(100)),
          ],
        ),
      ),
      signatures: <CosmosSignature>[
        CosmosSignature(
          s: BigInt.parse('242877016729030984790609754355231764528325631634698


/*
 * Generated by asn1c-0.9.29 (http://lionet.info/asn1c)
 * From ASN.1 module "NR-RRC-Definitions"
 * 	found in "asn/nr-rrc-15.6.0.asn1"
 * 	`asn1c -fcompound-names -pdu=all -findirect-choice -fno-include-deps -gen-PER -no-gen-OER -no-gen-example -D rrc`
 */

#ifndef	_ASN_RRC_MobilityFromNRCommand_H_
#define	_ASN_RRC_MobilityFromNRCommand_H_

#include <asn_application.h>

/* Including external dependencies */
#include "ASN_RRC_RRC-TransactionIdentifier.h"
#include <constr_SEQUENCE.h>
#include <constr_CHOICE.h>

#ifdef __cplusplus
extern "C" {
#endif

/* Dependencies */
typedef enum ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR {
	ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR_NOTHING,	/* No components present */
	ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR_mobilityFromNRCommand,
	ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR_criticalExtensionsFuture
} ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR;

/* Forward declarations */
struct ASN_RRC_MobilityFromNRCommand_IEs;

/* ASN_RRC_MobilityFromNRCommand */
typedef struct ASN_RRC_MobilityFromNRCommand {
	ASN_RRC_RRC_TransactionIdentifier_t	 rrc_TransactionIdentifier;
	struct ASN_RRC_MobilityFromNRCommand__criticalExtensions {
		ASN_RRC_MobilityFromNRCommand__criticalExtensions_PR present;
		union ASN_RRC_MobilityFromNRCommand__ASN_RRC_criticalExtensions_u {
			struct ASN_RRC_MobilityFromNRCommand_IEs	*mobilityFromNRCommand;
			struct ASN_RRC_MobilityFromNRCommand__criticalExtensions__criticalExtensionsFuture {

				/* Context for parsing across buffer boundaries */
				asn_struct_ctx_t _asn_ctx;
			} *criticalExtensionsFuture;
		} choice;

		/* Context for parsing across buffer boundaries */
		asn_struct_ctx_t _asn_ctx;
	} criticalExtensions;

	/* Context for parsing across buffer boundaries */
	asn_struct_ctx_t _asn_ctx;
} ASN_RRC_MobilityFromNRCommand_t;

/* Implementation */
extern asn_TYPE_descriptor_t asn_DEF_ASN_RRC_MobilityFromNRCommand;
extern asn_SEQUENCE_specifics_t asn_SPC_ASN_RRC_MobilityFromNRCommand_specs_1;
extern asn_TYPE_member_t asn_MBR_ASN_RRC_MobilityFromNRCommand_1[2];

#ifdef __cplusplus
}
#endif

#endif	/* _ASN_RRC_MobilityFromNRCommand_H_ */
#include <asn_internal.h>


tagify--select) {
  cursor: default;
}

.tagify[disabled]:not(.tagify--mix):not(.tagify--select) > .tagify__input, .tagify[readonly]:not(.tagify--mix):not(.tagify--select) > .tagify__input {
  visibility: hidden;
  width: 0;
  margin: 5px 0;
}

.tagify[disabled]:not(.tagify--mix):not(.tagify--select) .tagify__tag > div, .tagify[readonly]:not(.tagify--mix):not(.tagify--select) .tagify__tag > div {
  padding: var(--tag-pad);
}

.tagify[disabled]:not(.tagify--mix):not(.tagify--select) .tagify__tag > div::before, .tagify[readonly]:not(.tagify--mix):not(.tagify--select) .tagify__tag > div::before {
  animation: readonlyStyles 1s calc(-1s * (var(--readonly-striped) - 1)) paused;
}

@keyframes readonlyStyles {
  0% {
    background: linear-gradient(45deg, var(--tag-bg) 25%, transparent 25%, transparent 50%, var(--tag-bg) 50%, var(--tag-bg) 75%, transparent 75%, transparent) 0/5px 5px;
    box-shadow: none;
    filter: brightness(0.95);
  }
}
.tagify[disabled] .tagify__tag__removeBtn, .tagify[readonly] .tagify__tag__removeBtn {
  display: none;
}

.tagify--loading .tagify__input > br:last-child {
  display: none;
}

.tagify--loading .tagify__input::before {
  content: none;
}

.tagify--loading .tagify__input::after {
  content: "";
  vertical-align: middle;
  opacity: 1;
  width: 0.7em;
  height: 0.7em;
  width: var(--loader-size);
  height: var(--loader-size);
  min-width: 0;
  border: 3px solid;
  border-color: #eee #bbb #888 transparent;
  border-radius: 50%;
  animation: rotateLoader 0.4s infinite linear;
  content: "" !important;
  margin: -2px 0 -2px 0.5em;
}

.tagify--loading .tagify__input:empty::after {
  margin-left: 0;
}

.tagify + input, .tagify + textarea {
  position: absolute !important;
  left: -9999em !important;
  transform: scale(0) !important;
}

.tagify__tag {
  display: inline-flex;
  align-items: center;
  margin: 5px 0 5px 5px;
  position: relative;
  z-index: 1;
  outline: 0;
  line-height: normal;
  cursor: default;
  transition: 0.13s ease-out;
}

.tagify__tag > div {
  vertical-align: top;
  box-sizing: border-box;
  max-width: 100%;
  padding: var(--tag-pad);
  color: var(--tag-text-color);
  line-height: inherit;
  border-radius: var(--tag-border-radius);
  white-space: nowrap;
  transition: 0.13s ease-out;
}

.tagify__tag > div > * {
  white-space: pre-wrap;
  overflow: hidden;
  text-overflow: ellipsis;
  display: inline-block;
  vertical-align: top;
  min-width: var(--tag--min-width);
  max-width: var(--tag--max-width);
  transition: 0.8s ease, 0.1s color;
}

.tagify__tag > div > [contenteditable] {
  outline: 0;
  -webk


313-2.25.594-.406.124-.188.344s-.086.18-.437.438c-.352.258-.91.531-1.813.531-.308 0-.48-.172-.562-.594z"/></svg>';
  static const String hand_point_left =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M16.906 3C15.29 3 14 4.23 14 5.656c0 1.336.469 2.328.938 2.969.292.402.421.469.624.625l.188.75H5c-1.645 0-3 1.355-3 3s1.355 3 3 3h3.563l1.656 7.625A3.016 3.016 0 0013.156 26H30V10h-5.594l-6.781-6.719L17.312 3zm-.312 2.094L23 11.406V24h-9.844c-.476 0-.898-.313-1-.781l-1.781-8.438-.188-.781H5c-.566 0-1-.434-1-1 0-.566.434-1 1-1h13.344l-.313-1.25-.593-2.25-.125-.406-.344-.188s-.18-.086-.438-.437c-.258-.352-.531-.91-.531-1.813 0-.308.172-.48.594-.562zM25 12h3v12h-3z"/></svg>';
  static const String hand_point_left_solid =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="M16.906 3C15.29 3 14 4.23 14 5.656c0 1.336.469 2.328.938 2.969.292.402.421.469.624.625l.188.75H5c-1.645 0-3 1.355-3 3s1.355 3 3 3h3.563l1.656 7.625A3.016 3.016 0 0013.156 26H30V10h-5.594l-6.781-6.719L17.312 3zm-.312 2.094L23 11.406V24h-9.844c-.476 0-.898-.313-1-.781l-1.781-8.438-.188-.781H5c-.566 0-1-.434-1-1 0-.566.434-1 1-1h13.344l-.313-1.25-.593-2.25-.125-.406-.344-.188s-.18-.086-.438-.437c-.258-.352-.531-.91-.531-1.813 0-.308.172-.48.594-.562zM25 12h3v12h-3z"/></svg>';
  static const String hand_point_right =
      '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="32" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 32 32"><path fill="currentColor" d="m14.688 3-.313.281L7.594 10H2v16h16.844c1.41 0 2.64-.996 2.937-2.375L23.438 16H27c1.645 0 3-1.355 3-3s-1.355-3-3-3H16.25l.188-.75c.203-.156.332-.223.625-.625.468-.64.937-1.633.937-2.969C18 4.23 16.71 3 15.094 3zm.718 2.094c.422.082.594.254.594.562 0 .903-.27


s
            full_path = main_path + animation
            self.animations[animation] = pygame.image.load(F"{full_path}/{animation}.png").convert_alpha()

    # -----------------------------------------------------------------------------------------------------------------
    def get_player_distance_direction(self, player) -> tuple:
        """
        Метод, расчитывающий дистанциую от игрока и возвращающий эту дистанцию вместе с вектором движения, на
        который должен двигаться враг, чтобы добраться до игрока
        :param player: объект игрока
        """
        enemy_vector = pygame.math.Vector2(self.rect.center)  # ВЕКТОР ДВИЖЕНИЯ ВРАГА
        player_vector = pygame.math.Vector2(player.rect.center)  # ВЕКТОР ДВИЖЕНИЯ ИГРОКА

        distance = (player_vector - enemy_vector).magnitude()  # ПОЛУЧЕНИЕ ДЛИНЫ ВЕКТОРА МЕЖДУ ИГРОКОМ И ВРАГОМ

        if distance > 0:  # ЕСЛИ ВЕКТОР СУЩЕСТВУЕТ (его длина ненулевая)
            direction = (player_vector - enemy_vector).normalize()  # ПРОИЗВОДИТСЯ ЕГО ОБЯЗАТЕЛЬНАЯ НОРМАЛИЗАЦИЯ
        else:  # ИНАЧЕ
            direction = pygame.math.Vector2(0, 0)  # ВЕКТОР НУЛЕВОЙ

        return distance, direction

    # -----------------------------------------------------------------------------------------------------------------
    def get_status(self, player) -> None:
        """
        Метод, определяющий тип поведения врага
        :param player: объект игрока
        """
        distance = self.get_player_distance_direction(player)[0]  # ДИСТАНЦИЯ МЕЖДУ ИГРОКОМ И ВРАГОМ

        if distance <= self.attack_radius and self.can_attack:  # ЕСЛИ ДИСТАНЦИЯ ДОСТАТОЧНА ДЛЯ АТАКИ
            if self.status != "attack":  # ЕСЛИ ВРАГ НЕ АТАКОВАЛ
                self.frame_index = 0  # СТАВИТСЯ ПЕРВЫЙ КАДР (для обновления покадровой анимации)
            self.status = "attack"  # СТАТУС ВРАГА ЯВЛЯЕТСЯ АТАКОЙ
        elif distance <= self.notice_radius:  # ЕСЛИ ДИСТАНЦИЯ ДОСТАТОЧНА ДЛЯ ОБНАРУЖЕНИЯ
            self.status = "move"  # ВРАГ СЛЕДУЕТ ЗА ИГРОКОМ
        else:  # ИНАЧЕ
            self.status = "idle"  # ВРАГ СТОИТ

    # -----------------------------------------------------------------------------------------------------------------
    def actions(self, player) -> None:
        """
        Метод, реализующий действия врагов
        :param player: объект игрока
        """
        if self.status == "attack":  # ЕСЛИ СТАТУС ВРАГА - АТАКА
            self.attack_time = pygame.time.get_ticks()  # ПОЛУЧАЕМ ВРЕМЯ В МОМЕНТ АТАКИ
            self.damage_player(self.attack_damage, self.attack_type)  # НАНОСИМ УРОН ИГРОКУ
        elif self.status == "move":  # ЕСЛИ СТАТУС ВРАГА - ДВИЖЕНИЕ
            self.direction = self.get_player_distance_direction(player)[1]  # ПОЛУЧАЕМ ВЕКТОР ДВИЖ. К ИГРОКУ
        else:  # ИНАЧЕ
            self.direction = pygame.math.Vector2()  # ВЕКТОР НУЛЕВОЙ (игрок стоит, self.status == "idle")

    # -----------------------------------------------------------------------------------------------------------------
    def animate(self) -> None:
        """Функция анмации врагов"""
        animation = self.animations[self.status]  # НАБОР С АНИМАЦИИ ДЛЯ ТЕКУЩЕГО ВРАГА
        self.frame_index += self.animation_speed  # ПРИБАВЛЯЕМ НЕКОТОРОЕ ЗНАЧЕНИЕ К ПОКАДРОВОЙ АНИМАЦИИ

        if self.monster_name == "Eye" or self.monster_name == "Spirit":  # ЕСЛИ ВРАГ - ГЛАЗ ИЛИ ЛЕТУЧАЯ ДУША:
            if self.frame_index >= animation.height / 48:  # ЕСЛИ ЦИКЛ АНИМАЦИИ ТЕКУЩЕГО ДЕЙСТВИЯ ЗАВЕРШЕН
                if self.status == "attack":  # ЕСЛИ ВРАГ АТАКОВАЛ
                    self.can_attack = False  # ВРАГ АТАКОВАТЬ БОЛЬШЕ НЕ МОЖЕТ
                self.frame_index = 0  # ПОКАДРОВАЯ АНИМАЦИЯ НАЧИНАЕТСЯ С НУЛЕВОГО КАДРА

            self.image = animation.subsurface((0, int(self.frame_index) * 48 + 1, 48, 47))  # ПОЛУЧЕНИЕ НУЖНОГО КАДРА
            self.rect = self.image.get_rect(center=self.hitbox.center)  # ПОЛУЧЕНИЕ РАСПОЛОЖЕНИЯ ТЕКУЩЕГО КАДРА

        if self.monster_name == "Owl" or self.monster_name == "Flam":
            if self.frame_index >= animation.height / 64:  # ЕСЛИ ЦИКЛ АНИМАЦИИ ТЕКУЩЕГО ДЕЙСТВИЯ ЗАВЕРШЕН
                if self.status == "attack":  # ЕСЛИ ВРАГ АТАКОВАЛ
                    self.can_attack = False  # ВРАГ АТАКОВАТЬ БОЛЬШЕ НЕ МОЖЕТ
                self.frame_index = 0  # ПОКАДРОВАЯ АНИМАЦИЯ НАЧИНАЕТСЯ С НУЛЕВОГО КАДРА

            self.image = animation.subsurface((0, int(self.frame_index) * 64 + 2, 64, 62))  # ПОЛУЧЕНИЕ НУЖНО


(SL.of(context).onlineSourcesPage_attribution +
                      (tmsData.attribution)), //"Attribution: "
                  new Text(
                      "${SL.of(context).onlineSourcesPage_minZoom}: ${tmsData.minZoom}"), //"Min zoom:"
                  new Text(
                      "${SL.of(context).onlineSourcesPage_maxZoom}: ${tmsData.maxZoom}"), //"Max zoom:"
                ],
              ),
            ),
            actions: <Widget>[
              new TextButton(
                child: new Text(
                    SL.of(context).onlineSourcesPage_cancel), //"CANCEL"
                onPressed: () {
                  Navigator.pop(context, false);
                },
              ),
              new TextButton(
                child: new Text(SL.of(context).onlineSourcesPage_ok), //"OK"
                onPressed: () {
                  Navigator.pop(context, true);
                },
              ),
            ],
          );
        },
      );

      if (okToGo != null && okToGo) {
        var json = '''
        {
            "$LAYERSKEY_LABEL": "${tmsData.name}",
            "$LAYERSKEY_URL": "${tmsData.url}",
            "$LAYERSKEY_MINZOOM": ${tmsData.minZoom},
            "$LAYERSKEY_MAXZOOM": ${tmsData.maxZoom},
            "$LAYERSKEY_OPACITY": 100,
            "$LAYERSKEY_ATTRIBUTION": "${tmsData.attribution}",
            "$LAYERSKEY_TYPE": "$LAYERSTYPE_TMS",
            "$LAYERSKEY_ISVISIBLE": true,
            "$LAYERSKEY_SUBDOMAINS": "${tmsData.subdomains}"
        }
        ''';
        Navigator.pop(context, json);
      } else if (okToGo != null && !okToGo) {
        Navigator.pop(context);
      }
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text(SL
            .of(context)
            .onlineSourcesPage_newTmsOnlineService), //"New TMS Online Service"
      ),
      body: new Form(
        key: _formKey,
        child: Column(
          children: <Widget>[
            Expanded(
              child: Stepper(
                steps: steps,
                currentStep: currentStep,
                onStepContinue: next,
                onStepCancel: cancel,
                onStepTapped: (step) => goTo(step),
              ),
            ),
            Padding(
              padding: SmashUI.defaultPadding(),
              child: new ElevatedButton(
                child: Padding(
                  padding: SmashUI.defaultPadding(),
                  child: SmashUI.titleText(
                      SL.of(context).onlineSourcesPage_save, //"Save"
                      color: SmashColors.mainBackground),
                ),
                onPressed: _submitDetails,
                style: ElevatedButton.styleFrom(
                  backgroundColor: SmashColors.mainDecorations,
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }
}

class WmsData {
  String layer = "";
  String url = "";
  String attribution = "";
  String minZoom = "0";
  String maxZoom = "19";
  String format = LAYERSTYPE_FORMAT_JPG;
  String version = "1.1.1";
  int srid = SmashPrj.EPSG3857_INT;
}

class AddWmsStepper extends StatefulWidget {
  WmsData? wmsData;
  AddWmsStepper({this.wmsData, Key? key}) : super(key: key);

  @override
  _AddWmsStepperState createState() => _AddWmsStepperState();
}

class _AddWmsStepperState extends State<AddWmsStepper> with Localization {
  GlobalKey<FormState> _formKey = new GlobalKey<FormState>();

  late List<Step> steps;
  late WmsData wmsData;

  @override
  void initState() {
    if (widget.wmsData == null) {
      wmsData = WmsData();
    } els


ttl	'RADAR DEMO'	Program title

	include	h:\devpac\incdir\gemmacro.i
	include	h:\devpac\incdir\tosmacro.s

size	equ	16	size of table entry
delay	equ	140	delay period
colour4	equ	$FF8248	COLOUR 4

f_col	equ	0	colour flag
f_blip	equ	1	=1 when blip detected
f_col4	equ	2	toggles coast line colour

;The program proper

start_of_pgm	move.l	4(sp),a3	base page
	move.l	#stack,sp	move SP
	move.l	12(a3),d0	text len
	add.l	20(a3),d0	data len
	add.l	28(a3),d0	BSS len
	add.l	#256,d0	basepage

	move.l	d0,-(sp)	shrink memory
	move.l	a3,-(sp)
	clr	-(sp)
	move	#$4a,-(sp)
	trap	#1
	lea	12(sp),sp

	appl_init		initialise application
	move	d0,ap_id	and store the app ident
	graf_handle		fetch graf handle code
	move	d0,current_handle  and store VDI handle

	lea	intin,a0	initialise intin array
	moveq	#10-1,d0
shell1	move	#1,(a0)+	most params are 1
	dbra	d0,shell1
	move	#2,(a0)+	use RC system
	v_opnvwk		open work station
	v_hide_c		hide mouse

	vs_clip	#1,#0,#0,#639,#399
	vsl_color	#1

shell2	bsr	main	run main program

	v_show_c	#0	show mouse
shell3	v_clsvwk		close workstation
	appl_exit		close application

	clr	-(sp)	status code
	move	#$4c,-(sp)	P_TERM
	trap	#1	exit pgm

;--------------------- Main program sub-routine ------------------------

main	bsr	getscrn
	v_clrwk		clr screen
	bsr	initneo
	bsr	init
	bsr	set_scrn	set up screens
	graf_mouse	#0
	bsr	ms_show
	move.b	#'1',mode
	bsr	install_int

	bsr	test	test of polyline

	bsr	de_install
	setscreen	#-1,screen,screen

	rts

test	bsr	chk_move	  move blips

	lea	co_ords,a6
	move	#159,d2
	move	#31,d3
	bclr	#f_col,flags1
	move	#160,d0	centre
	move	#106,d1

	bsr	draw_line
	lea	blip_list,a5

test1	bsr	scr_copy

	cmp	#-1,(a6)	end ?
	beq	test

	bclr	#f_col,flags1
	move	#160,d0	centre
	move	#106,d1

	bsr	ms_hide
	cmp.b	#'1',mode	skip if not normal
	bne	test3

	bsr	draw_line   erase old
test3	bset	#f_col,flags1
	move	(a6)+


using System;
using System.Collections.Generic;
using System.Linq;
using E015.ApplicationServices.Factory;
using E015.Contracts;
using E015.Domain.DomainServices;
// ReSharper disable InconsistentNaming
namespace E015.Domain.ApplicationServices.Factory
{
    /// <summary>
    /// Base class that acts as execution environment (container) for our application
    /// service. It will be responsible for wiring in test version of services to
    /// factory and executing commands
    /// </summary>
    public abstract class factory_application_service_spec : application_service_spec
    {
        public TestBlueprintLibrary Library;

        protected override void SetupServices()
        {
            Library = new TestBlueprintLibrary();
        }

        protected override IEvent[] ExecuteCommand(IEvent[] given, ICommand cmd)
        {
            var store = new SingleCommitMemoryStore();
            foreach (var e in given.OfType<IFactoryEvent>())
            {
                store.Preload(e.Id.ToString(),e);
            }
            new FactoryApplicationService(store, Library).Execute(cmd);
            return store.Appended ?? new IEvent[0];
        }

        protected void When(IFactoryCommand when)
        {
            WhenMessage(when);
        }
        protected void Given(params IFactoryEvent[] given)
        {
            GivenMessages(given);
        }
        protected void GivenSetup(params SpecSetupEvent[] setup)
        {
            GivenMessages(setup);
        }
        protected void Expect(params IFactoryEvent[] given)
        {
            ExpectMessages(given);
        }

        // additional helper builders

        protected static InventoryShipment NewShipment


ojo/_base/declare", "dojo/_base/window", "dojo/_base/sniff",
	"dojo/_base/connect", "dojo/_base/array", "dojo/dom-construct", "dojo/_base/Color", "./matrix"],
  function(g, lang, declare, win, has, events, arr, domConstruct, Color, matrixLib){

/*=====
	dojox.gfx.shape = {
		// summary:
		//		This module contains the core graphics Shape API.
		//		Different graphics renderer implementation modules (svg, canvas, vml, silverlight, etc.) extend this
		//		basic api to provide renderer-specific implementations for each shape.
	};
  =====*/

	var shape = g.shape = {};
	// a set of ids (keys=type)
	var _ids = {};
	// a simple set impl to map shape<->id
	var registry = {};

	shape.register = function(/*dojox.gfx.shape.Shape*/shape){
		// summary:
		//		Register the specified shape into the graphics registry.
		// shape: dojox.gfx.shape.Shape
		//		The shape to register.
		// returns:
		//		The unique id associated with this shape.
		// the id pattern : type+number (ex: Rect0,Rect1,etc)
		var t = shape.declaredClass.split('.').pop();
		var i = t in _ids ? ++_ids[t] : ((_ids[t] = 0));
		var uid = t+i;
		registry[uid] = shape;
		return uid;
	};

	shape.byId = function(/*String*/id){
		// summary:
		//		Returns the shape that matches the specified id.
		// id: String
		//		The unique identifier for this Shape.
		return registry[id]; //dojox.gfx.shape.Shape
	};

	shape.dispose = function(/*dojox.gfx.shape.Shape*/shape){
		// summary:
		//		Removes the specified shape from the registry.
		// shape: dojox.gfx.shape.Shape
		//		The shape to unregister.
		delete registry[shape.getUID()];
	};

	declare("dojox.gfx.shape.Shape", null, {
		// summary: a Shape object, which knows how to apply
		// graphical attributes and transformations

		constructor: function(){
			//	rawNode: Node
			//		underlying graphics-renderer-specific implementation object (if applicable)
			this.rawNode = null;
			//	shape: Object: an abstract shape object
			//	(see dojox.gfx.defaultPath,
			//	dojox.gfx.defaultPolyline,
			//	dojox.gfx.defaultRect,
			//	dojox.gfx.defaultEllipse,
			//	dojox.gfx.defaultCircle,
			//	dojox.gfx.defaultLine,
			//	or dojox.gfx.defaultImage)
			this.shape = null;

			//	matrix: dojox.gfx.Matrix2D
			//		a transformation matrix
			this.matrix = null;

			//	fillStyle: Object
			//		a fill object
			//		(see dojox.gfx.defaultLinearGradient,
			//		dojox.gfx.defaultRadialGradient,
			//		dojox.gfx.defaultPattern,


"a) c #314791",
"b) c #304892",
"c) c #304893",
"d) c #2F4995",
"e) c #2F4997",
"f) c #2D4A9A",
"g) c #2A4A9D",
"h) c #294A9F",
"i) c #284AA0",
"j) c #294AA0",
"k) c #2B4AA1",
"l) c #2D4CA3",
"m) c #C9CAC9",
"n) c #455D9B",
"o) c #242F78",
"p) c #1B2F85",
"q) c #C6C3C8",
"r) c #B5B2B6",
"s) c #B5B7B4",
"t) c #B5B7B3",
"u) c #B5B2B5",
"v) c #B5B3B4",
"w) c #B5B5B4",
"x) c #B5B6B3",
"y) c #B5B4B4",
"z) c #B5B3B5",
"A) c #B5B4B5",
"B) c #B5B5B5",
"C) c #B5B5B3",
"D) c #B5B5B6",
"E) c #BAC3BE",
"F) c #B9C3BD",
"G) c #C1C3C4",
"H) c #BFC3C2",
"I) c #B9C3BE",
"J) c #BBC3BF",
"K) c #BDC3C1",
"L) c #C0C3C3",
"M) c #BEC3C1",
"N) c #C2C3C5",
"O) c #E6E3E8",
"P) c #E0E2DF",
"Q) c #E1E1E1",
"R) c #E2E1E3",
"S) c #E4E1E6",
"T) c #E4E2E7",
"U) c #E4E2E6",
"V) c #E3E3E4",
"W) c #E2E3E3",
"X) c #E1E3E2",
"Y) c #E3E3E3",
"Z) c #E3E3E2",
"`) c #EBEDEA",
" ! c #EAECE9",
".! c #E9EBE8",
"+! c #ECEEEB",
". . + @ # $ $ $ $ $ $ $ % $ $ $ $ $ % $ $ $ $ $ $ % $ $ $ $ $ % $ $ $ $ $ $ $ $ $ % $ $ & * = - ; > , , ' ) ! ! ~ { ] ^ / ( _ : < [ } | | 1 2 3 3 4 4 4 4 4 4 4 5 6 4 4 4 5 6 7 8 9 4 5 6 7 8 9 6 7 8 9 ",
"0 a b % $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ $ c d d d d $ $ $ $ $ c d e f g h i i i i j k l m n o p q r s t u v w x y z 4 A B C D 9 9 E 9 E F G H I F J K L L L L J


 await conn.query("INSERT INTO casts (artistId, entryId, creditTypeId, name) VALUES (?, ?, ?, ?)", [cast.artistId, cast.entryId, cast.castTypeId, cast.name]);
    if(result[0].insertId > 0){
        return result[0].insertId;
    }
    return null;
}

export async function updateCastQuery(conn: any, cast: ICast): Promise<boolean>{
    const result =
    await conn.query("UPDATE casts SET name = ?, creditTypeId = ? WHERE id = ?", [cast.name, cast.castTypeId, cast.id]);
    if(result[0].affectedRows > 0){
        return true;
    }
    return false;
}

export async function deleteCastQuery(conn: any, id: number): Promise<boolean>{
    const result =
    await conn.query("DELETE FROM casts WHERE id = ?", [id]);
    if(result[0].affectedRows > 0){
        return true;
    }
    return false;
}

export async function selectCastByArtistQuery(conn: any, artistId: number): Promise<ICast[]>{
    const result =
    await conn.query("SELECT casts.id, casts.artistId, casts.entryId, casts.creditTypeId as castTypeId, casts.name as castName, entries.title as entryTitle, artists.name as artistName FROM casts INNER JOIN entries on casts.entryId = entries.id INNER JOIN artists on casts.artistId = artists.id WHERE casts.artistId = ? GROUP BY casts.id", [artistId]);
    return result[0];
}

export async function selectSpotLightQuery(conn: any, limit: number, offset: number): Promise<ICast>{
    const today: string = new Date().toISOString().split('T')[0];
    const result =
    await conn.query("SELECT casts.id, casts.artistId, casts.entryId, casts.creditTypeId as castTypeId, casts.name as castName, entries.title as entryTitle, artists.name as artistName FROM entries INNER JOIN casts ON entries.id = casts.entryId INNER JOIN artists ON casts.artistId = artists.id WHERE entries.seasonId IS NULL AND entries.releaseDate <= ? AND (casts.creditTypeId = 4 OR casts.creditTypeId = 5) GROUP BY casts.id ORDER BY movies.releaseDate DESC LIMIT ? OFFSET ?", [today, limit, offset]);
    return result[0];
}

export async function selectCastTypesQuery(conn: any): Promise<ICastType[]>{
    const result = await conn.query("SELECT id as value, name FROM creditTypes");
    return result[0];
}

export async function selectArtistCastsByArtistQuery(conn, artistId: number): Promise<IArtistCast>{
    const result = await conn.query("SELECT casts.id, casts.artistId, casts.entryId, casts.creditTypeId AS castTypeId, casts.name AS name, entries.title AS entryTitle, entries.type as entryType, entries.releaseDate AS entryDate, creditTypes.name AS castTypeName, series.id as seriesId, series.title as seriesTitle FROM casts INNER JOIN entries ON casts.entryId = entries.id INNER JOIN creditTypes ON casts.creditTypeId = creditTypes.id LEFT OUTER JOIN seasons ON entries.seasonId = entries.seasonId LEFT OUTER JOIN series ON seasons.seriesId = series.id WHERE casts.artistId = ? GROUP BY casts.id", [artistId]); //ez retardált, de nem merek hozzányúlni
    return result[0];
}

export async function selectCastsByEntriesQuery(conn, entryIds: number[]): Promise<ICast[]>{
    const result =
    await conn.query("SELECT casts.id, casts.artistId, casts.entryId, casts.creditTypeId as castTypeId, casts.name as name, entries.title as entryTitle, artists.name as artistName FROM casts INNER JOIN entries on casts.entryId = entries.id INNER JOIN artists on casts.art


];
							obj.classList.add("valueChanged");
						}
						// Get Ascii for address
						const asciiObjs = getAsciiObjsForAddress(address);
						for(const obj of asciiObjs) {
							obj.firstChild.textContent = addrVal[2];
							obj.classList.add("valueChanged");
						}
					}
 				}   break;

				case 'foundAddresses':
				{
					// De-highlight the previous found addresses
					// HEX
					if(!allHexObjs) {
						allHexObjs = document.querySelectorAll("td[address]");
						allHexMap = new Map();
						for(const elem of allHexObjs) {
							const addr = elem.getAttribute('address');
							allHexMap.set(parseInt(addr), elem);
						}
					}
					for(const obj of allHexObjs) {
						obj.classList.remove("foundAddress");
					}
					// ASCII
					if(!allAsciiObjs) {
						allAsciiObjs = document.querySelectorAll("span[address]");
						allAsciiMap = new Map();
						for(const elem of allAsciiObjs) {
							const addr = elem.getAttribute('address');
							allAsciiMap.set(parseInt(addr), elem);
						}
					}
					for(const obj of allAsciiObjs) {
						obj.classList.remove("foundAddressAscii");
					}

					// Check for error (message.addresses == undefined)
					const searchContainer = document.getElementById("searchContainer");
					if(message.addresses == undefined) {
						selectedLength = 0;
						foundAddresses = [];
						// Note: adding the same class twice will actually only result in one item in the classList
						searchContainer.classList.add("searchError");
						return;
					}
					searchContainer.classList.remove("searchError");

					// Highlight the new  found addresses:
					selectedLength = message.length;
					foundAddresses = message.addresses;

					// HEX
					for(let i=0; i<selectedLength; i++) {
						for(const address of foundAddresses) {
							const elem = allHexMap.get(address+i);
							if(elem)
								elem.classList.add("foundAddress");
						}
					}

					// ASCII
					for(let i=0; i<selectedLength; i++) {
						for(const address of foundAddresses) {
							const elem = allAsciiMap.get(address+i);
							if(elem)
								elem.classList.add("foundAddressAscii");
						}
					}

					// Select first
					selectedAddress = 0;
					selectAddress();
 				}   break;

           }
        });

		//# sourceURL=memorydumpview-htmlscript.js
		</script>
`;
		return html;
	}

	/**
	 * Creates one html table out of a meta block.
	 * @param index The number of the memory block, starting at 0.
	 * Used for the id.
	 * @param metaBlock The block to convert. The template takes only the name from it.
	 */
	protected createHtmlTableTemplate(index: number, metaBlock: MetaBlock): string {
		// Add html body
		let caption = metaBlock.title || '...';	// NOSONAR

		const table = this.createHtmlTable(metaBlock);	// Is necessary, otherwise nothing might be shown the first time

		const html = `

			${caption}

			${table}

		`;
		return html;
	}

	/**
	 * Creates one html table out of a meta block.
	 * @param index The number of the memory block, starting at 0.
	 * Used for the id.
	 * @param metaBlock The block to convert.
	 */
	protected createHtmlTable(metaBlock: MetaBlock): string {
		if (!metaBlock.data)
			return '';

		const addressColor = Settings.launch.memoryViewer.addressColor;
		const asciiColor = Settings.launch.memoryViewer.asciiColor;
		const bytesColor = Settings.launch.memoryViewer.


00398978  D0 1F 02 F8 */	stfs f0, 0x2f8(r31)
/* 8039BA3C 0039897C  80 9F 01 00 */	lwz r4, 0x100(r31)
/* 8039BA40 00398980  C0 04 00 D8 */	lfs f0, 0xd8(r4)
/* 8039BA44 00398984  D0 1F 02 FC */	stfs f0, 0x2fc(r31)
/* 8039BA48 00398988  81 9D 00 00 */	lwz r12, 0(r29)
/* 8039BA4C 0039898C  81 8C 00 3C */	lwz r12, 0x3c(r12)
/* 8039BA50 00398990  7D 89 03 A6 */	mtctr r12
/* 8039BA54 00398994  4E 80 04 21 */	bctrl
/* 8039BA58 00398998  90 7F 01 04 */	stw r3, 0x104(r31)
/* 8039BA5C 0039899C  80 1F 01 04 */	lwz r0, 0x104(r31)
/* 8039BA60 003989A0  28 00 00 00 */	cmplwi r0, 0
/* 8039BA64 003989A4  40 82 00 18 */	bne .L_8039BA7C
/* 8039BA68 003989A8  38 7E 00 0C */	addi r3, r30, 0xc
/* 8039BA6C 003989AC  38 BE 00 1C */	addi r5, r30, 0x1c
/* 8039BA70 003989B0  38 80 04 08 */	li r4, 0x408
/* 8039BA74 003989B4  4C C6 31 82 */	crclr 6
/* 8039BA78 003989B8  4B C8 EB C9 */	bl panic_f__12JUTExceptionFPCciPCce
.L_8039BA7C:
/* 8039BA7C 003989BC  80 DF 01 04 */	lwz r6, 0x104(r31)
/* 8039BA80 003989C0  3C A0 69 67 */	lis r5, 0x69676832@ha
/* 8039BA84 003989C4  3C 80 50 6C */	lis r4, 0x506C6F6C@ha
/* 8039BA88 003989C8  7F A3 EB 78 */	mr r3, r29
/* 8039BA8C 003989CC  C0 06 00 D4 */	lfs f0, 0xd4(r6)
/* 8039BA90 003989D0  38 C5 68 32 */	addi r6, r5, 0x69676832@l
/* 8039BA94 003989D4  38 A4 6F 6C */	addi r5, r4, 0x506C6F6C@l
/* 8039BA98 003989D8  D0 1F 03 00 */	stfs f0, 0x300(r31)
/* 8039BA9C 003989DC  80 9F 01 04 */	lwz r4, 0x104(r31)
/* 8039BAA0 003989E0  C0 04 00 D8 */	lfs f0, 0xd8(r4)
/* 8039BAA4 003989E4  D0 1F 03 04 */	stfs f0, 0x304(r31)
/* 8039BAA8 003989E8  81 9D 00 00 */	lwz r12, 0(r29)
/* 8039BAAC 003989EC  81 8C 00 3C */	lwz r12, 0x3c(r12)
/* 8039BAB0 003989F0  7D 89 03 A6 */	mtctr r12
/* 8039BAB4 003989F4  4E 80 04 21 */	bctrl
/* 8039BAB8 003989F8  7C 76 1B 79 */	or. r22, r3, r3
/* 8039BABC 0039


            512 => Val(GENCTRL7_A::GCLK9),
            1024 => Val(GENCTRL7_A::GCLK10),
            2048 => Val(GENCTRL7_A::GCLK11),
            i => Res(i),
        }
    }
    #[doc = "Checks if the value of the field is `GCLK0`"]
    #[inline(always)]
    pub fn is_gclk0(&self) -> bool {
        *self == GENCTRL7_A::GCLK0
    }
    #[doc = "Checks if the value of the field is `GCLK1`"]
    #[inline(always)]
    pub fn is_gclk1(&self) -> bool {
        *self == GENCTRL7_A::GCLK1
    }
    #[doc = "Checks if the value of the field is `GCLK2`"]
    #[inline(always)]
    pub fn is_gclk2(&self) -> bool {
        *self == GENCTRL7_A::GCLK2
    }
    #[doc = "Checks if the value of the field is `GCLK3`"]
    #[inline(always)]
    pub fn is_gclk3(&self) -> bool {
        *self == GENCTRL7_A::GCLK3
    }
    #[doc = "Checks if the value of the field is `GCLK4`"]
    #[inline(always)]
    pub fn is_gclk4(&self) -> bool {
        *self == GENCTRL7_A::GCLK4
    }
    #[doc = "Checks if the value of the field is `GCLK5`"]
    #[inline(always)]
    pub fn is_gclk5(&self) -> bool {
        *self == GENCTRL7_A::GCLK5
    }
    #[doc = "Checks if the value of the field is `GCLK6`"]
    #[inline(always)]
    pub fn is_gclk6(&self) -> bool {
        *self == GENCTRL7_A::GCLK6
    }
    #[doc = "Checks if the value of the field is `GCLK7`"]
    #[inline(always)]
    pub fn is_gclk7(&self) -> bool {
        *self == GENCTRL7_A::GCLK7
    }
    #[doc = "Checks if the value of the field is `GCLK8`"]
    #[inline(always)]
    pub fn is_gclk8(&self) -> bool {
        *self == GENCTRL7_A::GCLK8
    }
    #[doc = "Checks if the value of the field is `GCLK9`"]
    #[inline(always)]
    pub fn is_gclk9(&self) -> bool {
        *self == GENCTRL7_A::GCLK9
    }
    #[doc = "Checks if the value of the field is `GCLK10`"]
    #[inline(always)]
    pub fn is_gclk10(&self) -> bool {
        *self == GENCTRL7_A::GCLK10
    }
    #[doc = "Checks if the value of the field is `GCLK11`"]
    #[inline(always)]
    pub fn is_gclk11(&self) -> bool {
        *self == GENCTRL7_A::GCLK11
    }
}
#[doc = "Generic Clock Generator Control 8 Synchronization Busy bits\n\nValue on reset: 0"]
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum GENCTRL8_A {
    #[doc = "1: Generic clock generator 0"]
    GCLK0,
    #[doc = "2: Generic clock generator 1"]
    GCLK1,
    #[doc = "4: Generic clock generator 2"]
    GCLK2,
    #[doc = "8: Generic clock generator 3"]
    GCLK3,
    #[doc = "16: Generic clock generator 4"]
    GCLK4,
    #[doc = "32: Generic clock generator 5"]
    GCLK5,
    #[doc = "64: Generic clock generator 6"]
    GCLK6,
    #[doc = "1


public string DownloadUri
        {
            get;
            private set;
        }

        /// <summary>
        /// 获取错误信息。
        /// </summary>
        public string ErrorMessage
        {
            get;
            private set;
        }

        /// <summary>
        /// 获取用户自定义数据。
        /// </summary>
        public object UserData
        {
            get;
            private set;
        }

        /// <summary>
        /// 清理下载失败事件。
        /// </summary>
        public override void Clear()
        {
            SerialId = default(int);
            DownloadPath = default(string);
            DownloadUri = default(string);
            ErrorMessage = default(string);
            UserData = default(object);
        }

        /// <summary>
        /// 填充下载失败事件。
        /// </summary>
        /// <param name="e">内部事件。</param>
        /// <returns>下载失败事件。</returns>
        public DownloadFailureEventArgs Fill(GameFramework.Download.DownloadFailureEventArgs e)
        {
            SerialId = e.SerialId;
            DownloadPath = e.DownloadPath;
            DownloadUri = e.DownloadUri;
            ErrorMessage = e.ErrorMessage;
            UserData = e.UserData;

            return this;
        }
    }
}


 below will run in the foreground and output its logs to
that console. They are designed to all run from files in the same directory.

For convenience, you can find a shell script to extract the configuration files
and run the commands the from this document in the nginx-connect-proxy/
sub-directory. The script should be a handy reference even if you don't want to
run it directly.

## Start Consul Agent with the Services Configured

Start the consul agent in dev mode using the configuration file below for the
'webserver' and 'ingress' services.

```shell
$ consul agent -dev -log-level=info -config-file=consul-services.json
```

#### consul-services.json

This contains the service definitions for both the `webserver` and the
`ingress` proxy (below). The names used are important as those are how you will
refer to them later.

```hcl
cat > consul-services.json << EOF
{
  "services": [
    {
      "name": "ingress",
      "port": 8080
    },
    {
      "name": "webserver",
      "connect": { "sidecar_service": {} },
      "port": 8000
    }
  ]
}
EOF
```

## Start the Webserver (a Connect-unaware Service)

First, you need a web server to proxy to and for that we'll just use the simple
http server included with Python as you probably already have it installed. By
default it listens on port 8000 and will publish an `index.html` if found.

```shell
$ python -m SimpleHTTPServer
```
### Use a Sidecar to add it to the Connect mesh network

Then start the sidecar for the `webserver` service.

```shell
$ consul connect proxy -sidecar-for webserver
```

**Note**: the argument to `-sidecar-for` needs to match the name registered
with consul in the `consul-services.json` config file above.

#### index.html
```html
cat > index.html << EOF
Brought to you by NGINX!
EOF
```

## NGINX Ingress Proxy to Web-Server via Mesh Sidecar

Now that you have a web-server running, registered with Consul with a sidecar
proxy running, you can run a NGINX proxy that will route traffic directly to
the web-server's sidecar via the encrypted mesh network.

To connect to the mesh network you will need the required TLS certificates,
the root certificate (the CA) and the client certificates. You can use a
separate template for each certificate, to put each in their own file.

#### ca.crt
```liquid
cat > ca.crt.tmpl << EOF
{{range caRoots}}{{.RootCertPEM}}{{end}}
EOF
```
#### cert.pem
```liquid
cat > cert.pem.tmpl << EOF
{{with caLeaf "ingress"}}{{.CertPEM}}{{end}}
EOF
```
#### cert.key
```liquid
cat > cert.key.tmpl << EOF
{{with caLeaf "ingress"}}{{.PrivateKeyPEM}}{{end}}
EOF
```

With all the certificate templates in place, you now just need the
configuration file template for the NGINX proxy, it uses the `connect` template
function to get all the "webserver" connect enabled services.

#### nginx-proxy.conf.tmpl
```nginx
cat > nginx-proxy.conf.tmpl << EOF
daemon off;
master_process off;
pid nginx.pid;
error_log /dev/stdout;

events {}

http {
  access_log /dev/stdout;

  server {
    listen 8080 default_server;

    location / {
{{range connect "webserver"}}
      proxy_pass https://{{.Address}}:{{.Port}};
{{end}}
      # these refer to files written by templates above
      proxy_ssl_certificate cert.pem;
      proxy_ssl_certificate_key cert.key;
      proxy_ssl_trusted_certificate ca.crt;
    }
  }
}
EOF
```
For more on the details of the NGINX configuration file, please see the [NGINX
documentation][nginx].

## Running the NGINX Ingress Proxy with Consul-Template

Usin


IOS
      // VALIDATORS HACE VALIDACIONES DE CONTENIDO
      // [ngModel]="aaa" ESTO CARGA EL VALOR, EL PRIMER VALOR DEL FormGroup HACE LO MISMO. O SEA CARGA EL VALOR PASADO AL INPUT CON formControlName: nombre
      // VALIDACIONES: REQUIRED, PATTERN, MINLENGHT
      'nombre': new FormControl('',Validators.required),
      'apellido': new FormControl('',Validators.minLength(2)),
      'correo': new FormControl('', [Validators.required, Validators.minLength(10)])
      // new FormControl('')
    })
  }

  ngOnInit() {

  }

  guardar(){
    console.log(this.valor); // MOSTRAMOS
  }

}
import { Pipe, PipeTransform } from '@angular/core';

@Pipe({
  name: 'searchBy'
})
export class SearchByPipe implements PipeTransform {
  transform(restaurants: any, args?: any): any {
    if (restaurants && args[0] !== '') {
      const searchedValue = args[0].toLowerCase();
      const props = args[1];
      let result = [];
      props.forEach(prop => {
        result.push(...restaurants.filter(restaurant => restaurant[prop].toLowerCase().includes(searchedValue)));
      });
      return result;
    }
  }
}
export enum ProductCategories {
  Green = "green",
  Black = "black",
  White = "white"
}

export type ProductId = string;

export interface ProductModel {
  readonly id: string;
  readonly name: string;
  readonly price: number;
  readonly description?: string;
  readonly category: ProductCategories;
  readonly isAvailable: boolean;
}
import { IToken, TokenMeta, TokenType } from ".";
import { FloatTypeInfo } from "../TypeInfo";

export default class FloatToken implements IToken<number, FloatTypeInfo> {
    public readonly type = TokenType.FloatLiteral;
    constructor(public readonly value: number, public readonly info: FloatTypeInfo, public readonly meta: TokenMeta) { }
}
import parser from './parser/parser.js';
import parserExt from './parser/parserExt.js';
import Attribute from './Attribute.js';
import Relation from './Relation.js';

const Orientation = {
	HORIZONTAL: 1,
	VERTICAL: 2,
	ZINDEX: 4,
};

/**
 * Helper function that inserts equal spacers (~).
 * @private
 */
function _processEqualSpacer(context, stackView) {
	// Determine unique name for the spacer
	context.equalSpacerIndex = context.equalSpacerIndex || 1;
	const name = '_~' + context.lineIndex + ':' + context.equalSpacerIndex + '~';
	if (context.equalSpacerIndex > 1) {
		// Ensure that all spacers have the same width/height
		context.constraints.push({
			view1: '_~' + context.lineIndex + ':1~',
			attr1: context.horizontal ? Attribute.WIDTH : Attribute.HEIGHT,
			relation: context.relation.relation || Relation.EQU,
			view2: name,
			attr2: context.horizontal ? Attribute.WIDTH : Attribute.HEIGHT,
			priority: context.relation.priority,
		});
	}
	context.equalSpacerIndex++;

	// Enforce view/proportional width/height
	if (context.relation.view || (context.relation.multiplier && context.relation.multiplier !== 1)) {
		context.constraints.push({
			view1: name,
			attr1: context.horizontal ? Attribute.WIDTH : Attribute.HEIGHT,
			relation: context.relation.relation || Relation.EQU,
			view2: context.relation.view,
			attr2: context.horizontal ? Attribute.WIDTH : Attribute.HEIGHT,
			priority: context.relation.priority,
			multiplier: context.relation.multiplier,
		})


unit.api_viewing

import android.content.Context
import android.os.Build
import com.madness.collision.util.X
import com.madness.collision.util.X.A
import com.madness.collision.util.X.B
import com.madness.collision.util.X.C
import com.madness.collision.util.X.D
import com.madness.collision.util.X.E
import com.madness.collision.util.X.E_0_1
import com.madness.collision.util.X.E_MR1
import com.madness.collision.util.X.F
import com.madness.collision.util.X.G
import com.madness.collision.util.X.G_MR1
import com.madness.collision.util.X.H
import com.madness.collision.util.X.H_MR1
import com.madness.collision.util.X.H_MR2
import com.madness.collision.util.X.I
import com.madness.collision.util.X.I_MR1
import com.madness.collision.util.X.J
import com.madness.collision.util.X.J_MR1
import com.madness.collision.util.X.J_MR2
import com.madness.collision.util.X.K
import com.madness.collision.util.X.K_WATCH
import com.madness.collision.util.X.L
import com.madness.collision.util.X.L_MR1
import com.madness.collision.util.X.M
import com.madness.collision.util.X.N
import com.madness.collision.util.X.N_MR1
import com.madness.collision.util.X.O
import com.madness.collision.util.X.O_MR1
import com.madness.collision.util.X.P
import com.madness.collision.util.X.Q
import com.madness.collision.util.os.OsUtils
import com.madness.collision.util.regexOf

internal object Utils {

    fun getAndroidVersionByAPI(api: Int, exact: Boolean, isCompact: Boolean = false): String {
        return when (api) {
            OsUtils.Baklava -> "16"
            OsUtils.V -> "15"
            OsUtils.U -> "14"
            OsUtils.T -> "13"
            OsUtils.S_V2 -> if (exact) "12L" else "12"
            OsUtils.S -> "12"
            X.R -> "11"
            Q -> "10"
            P -> "9"  // 9 Pie
            O_MR1 -> if (exact) "8.1" else "8"  // 8.1.0 Oreo
            O -> if (exact) "8.0" else "8"  // 8.0.0 Oreo
            N_MR1-> if (exact) "7.1" else "7"  // 7.1 Nougat
            N -> if (exact) "7.0" else "7"  // 7.0 Nougat
            M -> if (exact) "6.0" else "6"  // 6.0 Marshmallow
            L_MR1 -> if (exact) "5.1" else "5"  // 5.1 Lollipop
            L -> if (exact) "5.0" else "5"  // 5.0 Lollipop
            K_WATCH -> if (exact) "4.4W" else "4"  // 4.4W KitKat
            K -> if (isCompact) "4.4" else if (exact) "4.4 - 4.4.4" else "4"  // 4.4 - 4.4.4 KitKat
            J_MR2 -> if (isCompact) "4.3" else if (exact) "4.3.x" else "4"  // 4.3.x Jelly Bean
            J_MR1 -> if (isCompact) "4.2" else if (e


全面、深切地影响到亿万百姓的生活和命运，社会各界对探讨当代史的一些问题一直抱有浓厚的兴趣，坊间也出现了大量有关 1949 年后的各类出版物，外国相关研究也被逐步介绍到中国。

总之，社会有需要，也具备了研究的初步条件，故而当代人可以研究当代历史。这种研究虽然存在着某些客观限制，但也有诸多便利条件，例如距今时代较近，研究者对研究对象可保持较鲜活的个人感受；在资料搜集方面，也因距今不远而较为方便。

对 50 年代历史的研究在当代史研究中有着特殊的意义。首先，50 年代是当代史的开端。研究当代史从五十年代起步，不仅是研究时序展开的需要，更重要的是从五十年代初开始或从更久远处启动的一切，仍在以不同的方式影响我们当下的社会和我们每个人的生活。马克。布洛赫认为：理解活生生现实的能力是历史学家最基本的素质。[^6]（p.36）50 年代为今日之基础，影响既深且远，今日之结构，框架，均奠定于此时期。以往在国内的学科分类谱系中，将这一时段的研究划归于政治学范畴，时光已进入到 21 世纪，50 年代的历史应属于历史学范畴了。其次，把研究范围置放在 50 年代和 60 年代初，还是因为自那以后的年代距今天较近，某些事情还在发展中，人们认识它，不仅需要更多的，今天仍没公布的历史资料，还需要一个认识沉淀的阶段，即研究者主观感情因素的冷却，而 50 年代，已慢慢隐身于历史厚重的帷幕之中，成为渐离渐远的过去。

应该如何研究 50 年代这个距今不甚遥远而影像又相对模糊的历史时期？长久以来，对 50 年代至 60 年代初历史的研究，在“革命叙事”的视野下，就是“凯歌行进”、“艰苦探索”、“挫折调整”；而“现代化叙事”则将这十多年丰富、复杂的历史简化为“社会主义工业化”进程。在这两种叙事的视野下，我们有时就难以看到历史的全貌，对那个时代无法获得生动、具体的影象。


import abc

class PuppyState(abc.ABC):
    @abc.abstractmethod
    def feed(self, puppy):
        pass

    @abc.abstractmethod
    def play(self, puppy):
        pass


/*
 *
 * Copyright 2021-2025 Software Radio Systems Limited
 *
 * This file is part of srsRAN.
 *
 * srsRAN is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of
 * the License, or (at your option) any later version.
 *
 * srsRAN is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Affero General Public License for more details.
 *
 * A copy of the GNU Affero General Public License can be found in
 * the LICENSE file in the top-level directory of this distribution
 * and at http://www.gnu.org/licenses/.
 *
 */

#pragma once

#include "srsran/e2/e2.h"
#include "srsran/srslog/srslog.h"
#include "srsran/support/async/async_task.h"
#include "srsran/support/async/manual_event.h"

namespace srsran {

class task_executor;

class e2_connection_client;

class e2_connection_handler
{
public:
  e2_connection_handler(e2_connection_client&  client_handler_,
                        e2_message_handler&    rx_pdu_handler_,
                        e2ap_e2agent_notifier& agent_notifier_,
                        task_executor&         ctrl_exec_);
  ~e2_connection_handler();

  /// Initiate new TNL association to the Near-RT RIC via E2 interface.
  /// \return Notifier used by the E2AP to E2AP NGAP PDUs to the E2 gateway.
  std::unique_ptr<e2_message_notifier> connect_to_ric();

  async_task<void> handle_tnl_association_removal();

  /// \brief Check if the connection is active.
  [[nodiscard]] bool is_connected() const { return connected_flag; }

private:
  // Called by the E2 GW when the E2 TNL association drops.
  void handle_connection_loss();

  // Called from within E2AP execution context to handle a TNL association loss.
  void handle_connection_loss_impl();

  e2_connection_client&  client_handler;
  e2_message_handler&    rx_pdu_handler;
  e2ap_e2agent_notifier& agent_notifier;
  task_executor&         ctrl_exec;
  srslog::basic_logger&  logger;

  bool connected_flag{false};

  std::unique_ptr<e2_message_notifier> tx_pdu_notifier;

  manual_event_flag rx_path_disconnected;
};

} // namespace srsran


map(
              (version2) => ({
                id: `${sequenceId}/${version2}`,
                scope: "record",
                filter: (r) => r.typeName === typeName && r.type === subType,
                up: (record) => {
                  const result2 = migrations.migrators[version2].up(record);
                  if (result2) {
                    return result2;
                  }
                },
                down: (record) => {
                  const result2 = migrations.migrators[version2].down(record);
                  if (result2) {
                    return result2;
                  }
                }
              })
            )
          })
        );
      }
    }
    return result;
  }
  function createPropsMigration(typeName, subType, m) {
    return {
      id: m.id,
      dependsOn: m.dependsOn,
      scope: "record",
      filter: (r) => r.typeName === typeName && r.type === subType,
      up: (record) => {
        const result = m.up(record.props);
        if (result) {
          record.props = result;
        }
      },
      down: typeof m.down === "function" ? (record) => {
        const result = m.down(record.props);
        if (result) {
          record.props = result;
        }
      } : void 0
    };
  }

  // node_modules/@tldraw/tlschema/dist-esm/styles/TLColorStyle.mjs
  var defaultColorNames = [
    "black",
    "grey",
    "light-violet",
    "violet",
    "blue",
    "light-blue",
    "yellow",
    "orange",
    "green",
    "light-green",
    "light-red",
    "red",
    "white"
  ];
  var DefaultColorThemePalette = {
    lightMode: {
      id: "light",
      text: "#000000",
      background: "rgb(249, 250, 251)",
      solid: "#fcfffe",
      black: {
        solid: "#1d1d1d",
        fill: "#1d1d1d",
        note: {
          fill: "#FCE19C",
          text: "#000000"
        },
        semi: "#e8e8e8",
        pattern: "#494949",
        highlight: {
          srgb: "#fddd00",
          p3: "color(display-p3 0.972 0.8705 0.05)"
        }
      },
      blue: {
        solid: "#4465e9",
        fill: "#4465e9",
        note: {
          fill: "#8AA3FF",
          text: "#000000"
        },
        semi: "#dce1f8",
        pattern: "#6681ee",
        highlight: {
          srgb: "#10acff",
          p3: "color(display-p3 0.308 0.6632 0.9996)"
        }
      },
      green: {
        solid: "#099268",
        fill: "#099268",
        note: {
          fill: "#6FC896",
          text: "#000000"
        },
        semi: "#d3e9e3",
        pattern: "#39a785",
        highlight: {
          srgb: "#00ffc8",
          p3: "color(display-p3 0.2536 0.984 0.7981)"
        }
      },
      grey: {
        solid: "#9fa8b2",
        fill: "#9fa8b2",
        note: {
          fill: "#C0CAD3",
          text: "#000000"
        },
        semi: "#eceef0",
        pattern: "#bcc3c9",


.TungstenSteel, new long[]{800000L, 512L, 3L, -1L}), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"SXd", "GMG", "PBP", 'X', aOreDictName, 'M', ItemList.Electric_Motor_HV.get(1L, new Object[0]), 'S', OrePrefixes.screw.get(Materials.TungstenSteel), 'P', OrePrefixes.plate.get(Materials.TungstenSteel), 'G', OrePrefixes.gearGtSmall.get(Materials.TungstenSteel), 'B', ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0])});
                GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(GT_MetaGenerated_Tool_01.JACKHAMMER, 1, aMaterial, Materials.Titanium, new long[]{1600000L, 512L, 3L, -1L}), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', ItemList.Electric_Piston_HV.get(1L, new Object[0]), 'S', OrePrefixes.screw.get(Materials.Titanium), 'P', OrePrefixes.plate.get(Materials.Titanium), 'R', OrePrefixes.spring.get(Materials.Titanium), 'B', ItemList.Battery_RE_HV_Lithium.get(1L, new Object[0])});
                GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(GT_MetaGenerated_Tool_01.JACKHAMMER, 1, aMaterial, Materials.Titanium, new long[]{1200000L, 512L, 3L, -1L}), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', ItemList.Electric_Piston_HV.get(1L, new Object[0]), 'S', OrePrefixes.screw.get(Materials.Titanium), 'P', OrePrefixes.plate.get(Materials.Titanium), 'R', OrePrefixes.spring.get(Materials.Titanium), 'B', ItemList.Battery_RE_HV_Cadmium.get(1L, new Object[0])});
                GT_ModHandler.addCraftingRecipe(GT_MetaGenerated_Tool_01.INSTANCE.getToolWithStats(GT_MetaGenerated_Tool_01.JACKHAMMER, 1, aMaterial, Materials.Titanium, new long[]{800000L, 512L, 3L, -1L}), GT_ModHandler.RecipeBits.DISMANTLEABLE | GT_ModHandler.RecipeBits.DO_NOT_CHECK_FOR_COLLISIONS | GT_ModHandler.RecipeBits.BUFFERED, new Object[]{"SXd", "PRP", "MPB", 'X', OrePrefixes.stickLong.get(aMaterial), 'M', ItemList.Electric_Piston_HV.get(1L, new Object[0]), 'S', OrePrefixes.screw.get(Materials.Titanium), 'P', OrePrefixes.plate.get(Materials.Titanium), 'R', OrePrefixes.spring.get(Materials.Titanium), 'B', ItemList.Battery_RE_HV_Sodium.get(1L, new Object[0])});
                if (aSpecialRecipeReq2) GT_ModHandler.addCraftingRecipe(GT_OreDictUnificator.get(OrePrefixes.toolHeadDrill, aMaterial, 1L), GT_Proxy.tBits, new Object[]{"XSX


# -*- coding: utf-8 -*-

from pmdarima.preprocessing.exog import base
from pmdarima import datasets
import numpy as np
import pandas as pd

wineind = datasets.load_wineind()

class RandomExogFeaturizer(base.BaseExogFeaturizer):
    """Creates random exog features. This is just used to test base func"""

    def _get_prefix(self):
        return "RND"

    def fit(self, y, X, **_):
        return self

    def transform(self, y, X=None, n_periods=0, **_):
        Xt = np.random.rand(y.shape[0], 4)
        Xt = self._safe_hstack(X, Xt)
        return y, Xt

def test_default_get_feature_names():
    feat = RandomExogFeaturizer()
    y_trans, X = feat.fit_transform(wineind)
    assert y_trans is wineind
    assert X.columns.tolist() == \
        ['RND_0', 'RND_1', 'RND_2', 'RND_3']

def test_default_get_feature_names_with_X():
    feat = RandomExogFeaturizer()
    X = pd.DataFrame.from_records(
        np.random.rand(wineind.shape[0], 2), columns=['a', 'b'])
    y_trans, X_trans = feat.fit_transform(wineind, X)
    assert y_trans is wineind
    assert X_trans.columns.tolist() == \
        ['a', 'b', 'RND_0', 'RND_1', 'RND_2', 'RND_3']


Stream.readSer("CC4.ser");

    }
    public static byte[] makeByteCode() throws Exception{
        ClassPool pool = ClassPool.getDefault();
        CtClass ctClass = pool.get(MyTemplate.class.getName());
        String cmd = "Runtime.getRuntime().exec(\"calc.exe\");";
        ctClass.makeClassInitializer().insertBefore(cmd);
        ctClass.setName("NormalClass");
        return ctClass.toBytecode();
    }
}
package com.hardwork.fg607.relaxfinger.adapter;

import android.content.Context;
import android.support.v7.widget.RecyclerView;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.CheckBox;
import android.widget.ImageView;
import android.widget.TextView;

import com.hardwork.fg607.relaxfinger.R;
import com.hardwork.fg607.relaxfinger.model.ShortcutInfo;

import java.util.ArrayList;

import butterknife.BindView;
import butterknife.ButterKnife;

/**
 * Created by fg607 on 15-11-26.
 */
public class ShortcutAdapter extends BaseAdapter {

    private ArrayList<ShortcutInfo> mShortcutList;
    private Context mContext;
    private ArrayList<String> mChoosedNameList;

    public ShortcutAdapter(Context context){
        this.mContext = context;
    }

    public void addList(ArrayList<ShortcutInfo> list){

        this.mShortcutList = list;
    }

    public void setShortcutChecked(ArrayList<String> choosedNameList){

        this.mChoosedNameList = choosedNameList;

    }

    @Override
    public int getCount() {
        return mShortcutList!=null?mShortcutList.size():0;
    }

    @Override
    public Object getItem(int i) {
        return null;
    }

    @Override
    public long getItemId(int i) {
        return 0;
    }

    @Override
    public View getView(int i, View view, ViewGroup viewGroup) {

        MyHolder holder = null;

        if(view == null){

            view = View.inflate(mContext, R.layout.choosekey_item, null);

            holder = new MyHolder(view);

            view.setTag(holder);
        }else {

           holder = (MyHolder) view.getTag();
        }

        holder.icon.setImageDrawable(mShortcutList.get(i).getShortcutIcon());
        holder.name.setText(mShortcutList.get(i).getShortcutTitle());

        if(mChoosedNameList.contains(mShortcutList.get(i).getShortcutIntent())){

            holder.checkBox.setChecked(true);
        }else {

            holder.checkBox.setChecked(false);
        }

        return view;
    }

    public class MyHolder extends RecyclerView.ViewHolder{

        @BindView(R.id.image) ImageView icon;
        @BindView(R.id.text) TextView name;
        @BindView(R.id.checkbox) CheckBox checkBox;

        public MyHolder(View itemView) {
            super(itemView);
            ButterKnife.bind(this,itemView);
        }
    }
}
package com.hardwork.fg607.relaxfinger.receiver;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.graphics.PixelFormat;
import android.os.Build;
import android.util.Log;
import android.view.Gravity;
import android.view.WindowManager;
import android.widget.TextView;

import com.hardwork.fg607.relaxfinger.SettingActivity;
import com.hardwork.fg607.relaxfinger.service.FloatService;
import com.hardwork.fg607.relaxfinger.model.Config;
import com.hardwork.fg607.relaxfinger.utils.FloatingBallUtils;

import net.grandcentrix.tray.AppPreferences;
import net.grandcentrix.tray.TrayAppPreferences;
import net.grandcentrix.tray.TrayPreference


           [":man_vampire_tone2:"] = "\U0001f9db\U0001f3fc\u200d\u2642\ufe0f",
            [":man_vampire_medium_light_skin_tone:"] = "\U0001f9db\U0001f3fc\u200d\u2642\ufe0f",
            [":man_vampire::skin-tone-2:"] = "\U0001f9db\U0001f3fc\u200d\u2642\ufe0f",
            [":man_vampire_tone3:"] = "\U0001f9db\U0001f3fd\u200d\u2642\ufe0f",
            [":man_vampire_medium_skin_tone:"] = "\U0001f9db\U0001f3fd\u200d\u2642\ufe0f",
            [":man_vampire::skin-tone-3:"] = "\U0001f9db\U0001f3fd\u200d\u2642\ufe0f",
            [":man_vampire_tone4:"] = "\U0001f9db\U0001f3fe\u200d\u2642\ufe0f",
            [":man_vampire_medium_dark_skin_tone:"] = "\U0001f9db\U0001f3fe\u200d\u2642\ufe0f",
            [":man_vampire::skin-tone-4:"] = "\U0001f9db\U0001f3fe\u200d\u2642\ufe0f",
            [":man_vampire_tone5:"] = "\U0001f9db\U0001f3ff\u200d\u2642\ufe0f",
            [":man_vampire_dark_skin_tone:"] = "\U0001f9db\U0001f3ff\u200d\u2642\ufe0f",
            [":man_vampire::skin-tone-5:"] = "\U0001f9db\U0001f3ff\u200d\u2642\ufe0f",
            [":man_walking:"] = "\U0001f6b6\u200d\u2642\ufe0f",
            [":man_walking_facing_right:"] = "\U0001f6b6\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right_tone1:"] = "\U0001f6b6\U0001f3fb\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right_light_skin_tone:"] = "\U0001f6b6\U0001f3fb\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right::skin-tone-1:"] = "\U0001f6b6\U0001f3fb\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right_tone2:"] = "\U0001f6b6\U0001f3fc\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right_medium_light_skin_tone:"] = "\U0001f6b6\U0001f3fc\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right::skin-tone-2:"] = "\U0001f6b6\U0001f3fc\u200d\u2642\ufe0f\u200d\u27a1\ufe0f",
            [":man_walking_facing_right_tone3:"] = "\U0001f6b6\U0001f3fd\u200d\u2642\ufe0f\u200


  }
    }
}
use std::cmp;

pub fn max_area(height: Vec<i32>) -> i32 {
    if height.len() == 0 {
        return 0;
    }
    let mut left_idx = 0;
    let mut right_idx = height.len() - 1;
    let mut surface_area = 0;

    while left_idx < right_idx {
        if height[left_idx] < height[right_idx] {
            surface_area = cmp::max(
                (right_idx - left_idx) as i32 * height[left_idx],
                surface_area,
            );
            left_idx += 1;
        } else {
            surface_area = cmp::max(
                (right_idx - left_idx) as i32 * height[right_idx],
                surface_area,
            );
            right_idx -= 1;
        }
    }
    surface_area
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_cases() {
        let height = vec![1, 8, 6, 2, 5, 4, 8, 3, 7];
        assert_eq!(max_area(height), 49);

        let height = vec![1, 1];
        assert_eq!(max_area(height), 1);

        let height = vec![1, 1, 1, 1, 2, 2, 1, 1, 1];
        assert_eq!(max_area(height), 8);
    }
}
pub mod array;
pub mod bit_util;
pub mod buffer;
pub mod builder;
pub mod error;
pub mod prelude;
pub mod vec;
<filename>crate/map_loading/src/map_loading_bundle.rs
use amethyst::{
    assets::Processor,
    core::bundle::SystemBundle,
    ecs::{DispatcherBuilder, World},
    Error,
};
use derive_new::new;
use map_model::config::MapDefinition;

/// Adds the following `System`s to the `World`:
///
/// * `Processor<MapDefinition>`
#[derive(Debug, new)]
pub struct MapLoadingBundle;

impl<'a, 'b> SystemBundle<'a, 'b> for MapLoadingBundle {
    fn build(
        self,
        _world: &mut World,
        builder: &mut DispatcherBuilder<'a, 'b>,
    ) -> Result<(), Error> {
        builder.add(
            Processor::<MapDefinition>::new(),
            "map_definition_processor",
            &[],
        );
        Ok(())
    }
}
/// ListAllInterfacesRequest is the request type of the ListAllInterfaces RPC.
#[derive(Serialize, Deserialize)]
#[serde(default)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAllInterfacesRequest {}
/// ListAllInterfacesResponse is the response type of the ListAllInterfaces RPC.
#[derive(Serialize, Deserialize)]
#[serde(default)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListAllInterfacesResponse {
    /// interface_names is an array of all the registered interfaces.
    #[prost(string, repeated, tag = "1")]
    pub interface_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
/// ListImplementationsRequest is the request type of the ListImplementations
/// RPC.
#[derive(Serialize, Deserialize)]
#[serde(default)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListImplementationsRequest {
    /// interface_name defines the interface to query the implementations for.
    #[prost(string, tag = "1")]
    pub interface_name: ::prost::alloc::string::String,
}
/// ListImplementationsResponse is the response type of the ListImplementations
/// RPC.
#[derive(Serialize, Deserialize)]
#[serde(default)]
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ListImplementationsResponse {
    #[prost(string, repeated, tag = "1")]
    pub implementation_message_names: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
}
#[cfg(feature


;Selector.s
;Selector currently planned for main game memory to covers Inns, Market and Shops

;When displaying drunkards, Health and Mana should oscillate.

SelectorDriver
	;Test it for now
	ldx #03
	stx EntryIndex
	lda #00
	sta CharacterID
.(
loop1	jsr DisplayCharacterForm
	dec EntryIndex
	bpl loop1
.)
	;Infinite loop
infinitum	nop
	jmp infinitum

EntryIndex	.byt 0
CharacterID	.byt 0
;Parsed
; CharacterID ID of Character the form represents
; EntryIndex Index of the entry on screen (0-3)
DisplayCharacterForm
	jsr DisplayCharacterTemplate

	; Fetch property list for character
	ldx CharacterID
	lda GameCharacterPropertyListLo,x
	sta source
	lda GameCharacterPropertyListHi,x
	sta source+1

	; Convert Grotes BCD to text
	jsr ConvertCharactersBCD2TEXT

	; Fetch screen base for form
	ldx EntryIndex
	lda EntryScreenBaseLo,x
	sta screen2
	lda EntryScreenBaseHi,x
	sta screen2+1

	ldy #00
	sty CharacterFormField
.(
loop1	; Calc screen location of field
	ldy CharacterFormField
	lda CharacterFormFieldScreenOffsetLo,y
	clc
	adc screen2
	sta screen
	lda CharacterFormFieldScreenOffsetHi,y
	clc
	adc screen2+1
	sta screen+1

	; Fetch the code vector that will display this information
	lda CharacterFormFieldDisplayVectorLo,y
	sta vector1+1
	lda CharacterFormFieldDisplayVectorHi,y
	sta vector1+2

	; Fetch Field Value
	lda (source),y

	; Display Field Value
vector1	jsr $dead

	; Proceed to next Field
	inc CharacterFormField
	ldy CharacterFormField
	cpy #40
	bcc loop1
.)
	; Fetch Face Graphic location
	ldy #43
	lda (source),y
	tax
	iny
	lda (source),y
	sta source+1
	stx source

	; Set Face Screen Location
	lda screen
	clc
	adc #<$FA-$59
	sta screen
.(
	bcc skip1
	inc screen+1
skip1
.)
	ldx #15
.(
loop2	ldy #2
loop1	lda (source),y
	sta (screen),y
	dey
	bpl loop1
	lda #3
	jsr add_source
	jsr nl_screen
	dex
	bne loop2
.)
	rts

DisplayCharacterTemplate

	; Fetch screen base for form
	ldx EntryIndex
	lda EntryScreenBaseLo,x
	sta screen
	lda EntryScreenBaseHi,x
	sta screen+1

	lda #<CharacterFormTemplate
	sta source
	lda #>CharacterFormTemplate
	sta source+1

	ldx #23
.(
loop2	ldy #39
loop1	lda (source),y
	sta (screen),y
	dey
	bpl loop1
	jsr nl_source
	jsr nl_screen
	dex
	bne loop2
.)
	rts

;A contains Health 0(Low) to 15(High)
;screen2 points to bottom entry
DisplayCharacterMana   ;+01
DisplayCharacterHealth ;+00
	sta temp01
	ldx #00
	ldy #00
.(
loop1	lda TubeByteGraphic,x
	sta (screen),y
	lda #40
	jsr ssc_SubScreen
	inx
	dec


slimApi` configuration for Kotlin dsl with options
 */
fun DependencyHandler.slimApi(
    dependencyNotation: String,
    dependencyOptions: Action<ExternalModuleDependency>
): ExternalModuleDependency? {
    return withOptions(SLIM_API_CONFIGURATION_NAME, dependencyNotation, dependencyOptions)
}

/**
 * Alternative for adding `slim` configuration for Kotlin dsl but without options
 */
fun DependencyHandler.slim(dependencyNotation: Any): Dependency? = add(SLIM_CONFIGURATION_NAME, dependencyNotation)

/**
 * Alternative for adding `slimApi` configuration for Kotlin dsl but without options
 */
fun DependencyHandler.slimApi(dependencyNotation: Any): Dependency? =
    add(SLIM_API_CONFIGURATION_NAME, dependencyNotation)

/**
 * Creates a configuration with options
 */
private fun DependencyHandler.withOptions(
    configuration: String,
    dependencyNotation: String,
    dependencyConfiguration: Action<ExternalModuleDependency>
): ExternalModuleDependency? = run {
    uncheckedCast<ExternalModuleDependency>(create(dependencyNotation)).also { dependency ->
        if (dependency == null) return@run null
        dependencyConfiguration.execute(dependency)
        add(configuration, dependency)
    }
}/*
 * Copyright (C) 2017-2019 Hazuki
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package jp.hazuki.yuzubrowser.adblock.filter.unified

import android.net.Uri
import jp.hazuki.yuzubrowser.adblock.core.ContentRequest
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
import org.mockito.Mockito.mock

class ContainsFilterTest {

    @Test
    fun check() {
        val uri = mock(Uri::class.java)
        whenever(uri.toString()).thenReturn("http://blog.livedoor.jp/dqnplus/settings/lite2/ads.js")

        assertThat(ContainsFilter("/lite2/ads.js", ContentRequest.TYPE_ALL, true, null, -1).check(uri)).isEqualTo(true)
    }
}
package fulguris.favicon

import fulguris.SDK_VERSION
import fulguris.TestApplication
import androidx.core.net.toUri
import fulguris.favicon.ValidUri
import fulguris.favicon.toValidUri
import org.assertj.core.api.Assertions.assertThat
import org.junit.Test
import org.junit.runner.RunWith
import org.robolectric.RobolectricTestRunner
import org.robolectric.annotation.Config

/**
 * Unit tests for UriExtensions.kt
 */
@RunWith(RobolectricTestRunner::class)
@Config(application = TestApplication::class, sdk = [SDK_VERSION])
class FaviconUtilsTest {

    @Test
    fun `safeUri returns null for empty url`() = assertThat("".toUri().toValidUri()).isNull()

    @Test
    fun `safeUri returns null for url without scheme`() = assertThat("test.com".toUri().toValidUri()).isNull()

    @Test
    fun `safeUri returns null for url without host`() = assertThat("http://".toUri().toValidUri()).isNull()

    @Test
    fun `safeUri returns valid Uri for full url`() {
        assertThat("http://test.com".toUri().toValidUri()).isEqualTo(ValidUri("http", "test.com"))
    }
}
package fulguris.search.suggestions

import fulguris.unimplemented
import android.app.Application
import android.content.res.Configuration
import android.content.res.Resources
import android.os.LocaleList
import com.nhaarman.mockito_kotlin


1];
     char 	cmd [MAX_PATH+1];

     rc = RegOpenKeyEx(HKEY_CLASSES_ROOT, "HTTP\\shell\\open\\command", 0, KEY_QUERY_VALUE, &hKey);
     if (rc == ERROR_SUCCESS)
     {
	 dwSize=sizeof(browser);
	 if (RegQueryValueEx(hKey, NULL, NULL, &dwType, (BYTE *)&browser, &dwSize) == ERROR_SUCCESS)
	 {
		sprintf(cmd, "%s %s", browser, "http:\\\\www.adobe.com");
		Execute(cmd, FALSE);
		RegCloseKey(hKey);
	 }

     }

}

BOOL
CInstallation::IsCurrentAcrobatAlreadyInstalled()
{
    HKEY	hKey = 0;
    int		rc;

#ifdef WIN64
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
		      "SOFTWARE\\Wow6432Node\\Adobe\\Acrobat Reader\\7.0", 0,
		      KEY_QUERY_VALUE, &hKey );
#else
    rc = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
		      "SOFTWARE\\Adobe\\Acrobat Reader\\7.0", 0,
		      KEY_QUERY_VALUE, &hKey );
#endif  /* WIN64 */

    if (rc == ERROR_SUCCESS)
    {
	if (hKey)
	    RegCloseKey(hKey);
	return TRUE;
    }
    else
	return FALSE;
}

BOOL
CInstallation::RegisterActiveXControls()
{
    BOOL	bret=TRUE;
    CString	cmd;

    AppendToLog(IDS_REGISTERCONTROLS);

    cmd.Format("/s \"%s\\ingres\\bin\\IJACTRL.OCX\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\ipm.ocx\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\sqlquery.ocx\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\vcda.ocx\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\vsda.ocx\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\SVRIIA.DLL\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    cmd.Format("/s \"%s\\ingres\\bin\\svrsqlas.dll\"", (LPCSTR)m_installPath);
    bret = (Exec("REGSVR32.EXE", cmd, TRUE, FALSE)==0);

    return bret;
}

CComponent * CInstallation::GetESQLFORTRAN()
{
    CComponent *c;
    CString	s;
    int		i;

    s.LoadString(IDS_LABELESQLFORTRAN);

    for (i = 0; i < m_components.GetSize(); i++)
    {
	c = (CComponent *)m_components.GetAt(i);

	if (c && c->m_name == s)
	    return c;
    }
    return 0;
}

/*
**	History:
**	23-July-2001 (penga03)
**	    Check if there are MSI and Cabinet files in ingres temp directory,
**	    if so, delete them.
*/
void CInstallation::RemoveTempMSIAndCab()
{
	char SubKey[128];
	char msiloc[MAX