hexsha stringlengths 40 40 | size int64 5 1.05M | ext stringclasses 588
values | lang stringclasses 305
values | max_stars_repo_path stringlengths 3 363 | max_stars_repo_name stringlengths 5 118 | max_stars_repo_head_hexsha stringlengths 40 40 | max_stars_repo_licenses listlengths 1 10 | max_stars_count float64 1 191k ⌀ | max_stars_repo_stars_event_min_datetime stringdate 2015-01-01 00:00:35 2022-03-31 23:43:49 ⌀ | max_stars_repo_stars_event_max_datetime stringdate 2015-01-01 12:37:38 2022-03-31 23:59:52 ⌀ | max_issues_repo_path stringlengths 3 363 | max_issues_repo_name stringlengths 5 118 | max_issues_repo_head_hexsha stringlengths 40 40 | max_issues_repo_licenses listlengths 1 10 | max_issues_count float64 1 134k ⌀ | max_issues_repo_issues_event_min_datetime stringlengths 24 24 ⌀ | max_issues_repo_issues_event_max_datetime stringlengths 24 24 ⌀ | max_forks_repo_path stringlengths 3 363 | max_forks_repo_name stringlengths 5 135 | max_forks_repo_head_hexsha stringlengths 40 40 | max_forks_repo_licenses listlengths 1 10 | max_forks_count float64 1 105k ⌀ | max_forks_repo_forks_event_min_datetime stringdate 2015-01-01 00:01:02 2022-03-31 23:27:27 ⌀ | max_forks_repo_forks_event_max_datetime stringdate 2015-01-03 08:55:07 2022-03-31 23:59:24 ⌀ | content stringlengths 5 1.05M | avg_line_length float64 1.13 1.04M | max_line_length int64 1 1.05M | alphanum_fraction float64 0 1 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
43752c3c976a51d1707f011725bc8788ec9e76de | 584 | h | C | uboot/board/micronas/vct/vcth/reg_gpio.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 35 | 2019-04-26T04:00:10.000Z | 2022-03-30T11:37:06.000Z | uboot/board/micronas/vct/vcth/reg_gpio.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 4 | 2016-08-30T11:30:25.000Z | 2020-12-27T09:58:07.000Z | uboot/board/micronas/vct/vcth/reg_gpio.h | bingchunjin/1806_SDK | d5ed0258fc22f60e00ec025b802d175f33da6e41 | [
"MIT"
] | 30 | 2018-05-02T08:43:27.000Z | 2022-01-23T03:25:54.000Z | /*
* (C) Copyright 2008 Stefan Roese <sr@denx.de>, DENX Software Engineering
*
* SPDX-License-Identifier: GPL-2.0+
*/
#define GPIO1_BASE 0x00088000
#define GPIO2_BASE 0x0008c000
/* Instances */
#define GPIO_INSTANCES 2
/* Relative offsets of the register adresses */
#define GPIO_SWPORTA_DR_OFFS 0x00000000
#define GPIO_SWPORTA_DR(base) ((base) + GPIO_SWPORTA_DR_OFFS)
#define GPIO_SWPORTA_DDR_OFFS 0x00000004
#define GPIO_SWPORTA_DDR(base) ((base) + GPIO_SWPORTA_DDR_OFFS)
#define GPIO_EXT_PORTA_OFFS 0x00000050
#define GPIO_EXT_PORTA(base) ((base) + GPIO_EXT_PORTA_OFFS)
| 29.2 | 74 | 0.77911 |
2ea204c69bd98ed0de2b5db34b138d7857ee1dd6 | 169 | h | C | System_Module/CommonModule/CommonModule/Common/Classes/BaseClass/View/MTImageView.h | ireliaBR/Component | 24d1b23233b01815aaec4b325720e7c19a14e1ef | [
"MIT"
] | 7 | 2018-04-27T09:24:42.000Z | 2021-04-28T09:48:42.000Z | System_Module/CommonModule/CommonModule/Common/Classes/BaseClass/View/MTImageView.h | ireliaBR/Component | 24d1b23233b01815aaec4b325720e7c19a14e1ef | [
"MIT"
] | null | null | null | System_Module/CommonModule/CommonModule/Common/Classes/BaseClass/View/MTImageView.h | ireliaBR/Component | 24d1b23233b01815aaec4b325720e7c19a14e1ef | [
"MIT"
] | 3 | 2018-05-28T07:45:10.000Z | 2021-06-25T03:31:46.000Z | //
// MTImageView.h
// CommonModule
//
// Created by 范冬冬 on 2018/4/23.
//
#import <UIKit/UIKit.h>
/**
UIImageView基类
*/
@interface MTImageView : UIImageView
@end
| 10.5625 | 36 | 0.64497 |
ec8f51cfaffa078b0ff40468a3d5d4e1bad6e6af | 773 | h | C | include/system/allocator.h | chenhengqi/WasmEdge | 80eb92e5989433b65d0e1670abe0b13670c0bc2d | [
"Apache-2.0"
] | 1 | 2021-09-04T16:36:24.000Z | 2021-09-04T16:36:24.000Z | include/system/allocator.h | chenhengqi/WasmEdge | 80eb92e5989433b65d0e1670abe0b13670c0bc2d | [
"Apache-2.0"
] | null | null | null | include/system/allocator.h | chenhengqi/WasmEdge | 80eb92e5989433b65d0e1670abe0b13670c0bc2d | [
"Apache-2.0"
] | 1 | 2021-08-09T08:37:27.000Z | 2021-08-09T08:37:27.000Z | // SPDX-License-Identifier: Apache-2.0
//===-- wasmedge/system/allocator.h - large memory allocator --------------===//
//
// Part of the WasmEdge Project.
//
//===----------------------------------------------------------------------===//
///
/// \file
/// This file contains the memory allocator for various operating system.
///
//===----------------------------------------------------------------------===//
#pragma once
#include <cstdint>
namespace WasmEdge {
class Allocator {
public:
static uint8_t *allocate(uint32_t PageCount) noexcept;
static uint8_t *resize(uint8_t *Pointer, uint32_t OldPageCount,
uint32_t NewPageCount) noexcept;
static void release(uint8_t *Pointer, uint32_t PageCount) noexcept;
};
} // namespace WasmEdge
| 29.730769 | 80 | 0.544631 |
08996d9de3a5d13e14ecbdc01735d7fb941940e3 | 9,358 | c | C | components/esp32/test/test_wifi.c | balazsracz/esp-idf | 55dd81639b015743c9934b37ee717cf42a2f01a0 | [
"Apache-2.0"
] | 12 | 2021-04-15T14:15:27.000Z | 2022-01-17T03:40:35.000Z | components/esp32/test/test_wifi.c | Wangrenai/esp-idf | abea9e4c02bb17e86298aec4e299780399e4789f | [
"Apache-2.0"
] | 5 | 2020-04-30T03:47:19.000Z | 2021-03-31T02:10:11.000Z | components/esp32/test/test_wifi.c | Wangrenai/esp-idf | abea9e4c02bb17e86298aec4e299780399e4789f | [
"Apache-2.0"
] | 13 | 2019-12-31T21:22:09.000Z | 2022-03-07T15:55:27.000Z | /*
Tests for the Wi-Fi
*/
#include "string.h"
#include "esp_system.h"
#include "unity.h"
#include "esp_system.h"
#include "esp_event_loop.h"
#include "esp_wifi.h"
#include "esp_wifi_types.h"
#include "esp_log.h"
#include "nvs_flash.h"
#include "test_utils.h"
#include "freertos/task.h"
#include "freertos/event_groups.h"
static const char* TAG = "test_wifi";
#define DEFAULT_SSID "TEST_SSID"
#define DEFAULT_PWD "TEST_PASS"
#define GOT_IP_EVENT 0x00000001
#define DISCONNECT_EVENT 0x00000002
#define EVENT_HANDLER_FLAG_DO_NOT_AUTO_RECONNECT 0x00000001
static uint32_t wifi_event_handler_flag;
static EventGroupHandle_t wifi_events;
static esp_err_t event_handler(void *ctx, system_event_t *event)
{
printf("ev_handle_called.\n");
switch(event->event_id) {
case SYSTEM_EVENT_STA_START:
ESP_LOGI(TAG, "SYSTEM_EVENT_STA_START");
//do not actually connect in test case
//;
break;
case SYSTEM_EVENT_STA_GOT_IP:
ESP_LOGI(TAG, "SYSTEM_EVENT_STA_GOT_IP");
ESP_LOGI(TAG, "got ip:%s\n",
ip4addr_ntoa(&event->event_info.got_ip.ip_info.ip));
if (wifi_events) {
xEventGroupSetBits(wifi_events, GOT_IP_EVENT);
}
break;
case SYSTEM_EVENT_STA_DISCONNECTED:
ESP_LOGI(TAG, "SYSTEM_EVENT_STA_DISCONNECTED");
if (! (EVENT_HANDLER_FLAG_DO_NOT_AUTO_RECONNECT & wifi_event_handler_flag) ) {
TEST_ESP_OK(esp_wifi_connect());
}
if (wifi_events) {
xEventGroupSetBits(wifi_events, DISCONNECT_EVENT);
}
break;
default:
break;
}
return ESP_OK;
}
#define EMPH_STR(s) "****** "s" ******"
static void test_wifi_init_deinit(wifi_init_config_t *cfg, wifi_config_t* wifi_config)
{
ESP_LOGI(TAG, EMPH_STR("esp_wifi_deinit"));
TEST_ESP_ERR(ESP_ERR_WIFI_NOT_INIT, esp_wifi_deinit());
ESP_LOGI(TAG, EMPH_STR("esp_wifi_get_mode"));
wifi_mode_t mode_get;
TEST_ESP_ERR(ESP_ERR_WIFI_NOT_INIT, esp_wifi_get_mode(&mode_get));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_init"));
TEST_ESP_OK(esp_wifi_init(cfg));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_set_mode"));
TEST_ESP_OK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_set_config"));
TEST_ESP_OK(esp_wifi_set_config(ESP_IF_WIFI_STA, wifi_config));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_deinit..."));
TEST_ESP_OK(esp_wifi_deinit());
}
static void test_wifi_start_stop(wifi_init_config_t *cfg, wifi_config_t* wifi_config)
{
ESP_LOGI(TAG, EMPH_STR("esp_wifi_stop"));
TEST_ESP_ERR(ESP_ERR_WIFI_NOT_INIT, esp_wifi_stop());
ESP_LOGI(TAG, EMPH_STR("esp_wifi_init"));
TEST_ESP_OK(esp_wifi_init(cfg));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_set_mode"));
TEST_ESP_OK(esp_wifi_set_mode(WIFI_MODE_STA));
ESP_LOGI(TAG, EMPH_STR("esp_wifi_set_config"));
TEST_ESP_OK(esp_wifi_set_config(ESP_IF_WIFI_STA, wifi_config));
//now start wifi
ESP_LOGI(TAG, EMPH_STR("esp_wifi_start..."));
TEST_ESP_OK(esp_wifi_start());
//wifi stop
ESP_LOGI(TAG, EMPH_STR("esp_wifi_stop..."));
TEST_ESP_OK( esp_wifi_stop() );
ESP_LOGI(TAG, EMPH_STR("esp_wifi_deinit..."));
TEST_ESP_OK(esp_wifi_deinit());
}
TEST_CASE("wifi stop and deinit","[wifi]")
{
test_case_uses_tcpip();
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
wifi_config_t wifi_config = {
.sta = {
.ssid = DEFAULT_SSID,
.password = DEFAULT_PWD
},
};
//init nvs
ESP_LOGI(TAG, EMPH_STR("nvs_flash_init"));
esp_err_t r = nvs_flash_init();
if (r == ESP_ERR_NVS_NO_FREE_PAGES || r == ESP_ERR_NVS_NEW_VERSION_FOUND) {
ESP_LOGI(TAG, EMPH_STR("no free pages or nvs version mismatch, erase.."));
TEST_ESP_OK(nvs_flash_erase());
r = nvs_flash_init();
}
TEST_ESP_OK(r);
//init tcpip
ESP_LOGI(TAG, EMPH_STR("tcpip_adapter_init"));
tcpip_adapter_init();
//init event loop
ESP_LOGI(TAG, EMPH_STR("esp_event_loop_init"));
TEST_ESP_OK(esp_event_loop_init(event_handler, NULL));
ESP_LOGI(TAG, "test wifi init & deinit...");
test_wifi_init_deinit(&cfg, &wifi_config);
ESP_LOGI(TAG, "wifi init & deinit seem to be OK.");
ESP_LOGI(TAG, "test wifi start & stop...");
test_wifi_start_stop(&cfg, &wifi_config);
ESP_LOGI(TAG, "wifi start & stop seem to be OK.");
ESP_LOGI(TAG, EMPH_STR("nvs_flash_deinit..."));
nvs_flash_deinit();
ESP_LOGI(TAG, "test passed...");
TEST_IGNORE_MESSAGE("this test case is ignored due to the critical memory leak of tcpip_adapter and event_loop.");
}
static void start_wifi_as_softap(void)
{
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
cfg.nvs_enable = false;
wifi_config_t w_config = {
.ap.ssid = DEFAULT_SSID,
.ap.password = DEFAULT_PWD,
.ap.ssid_len = 0,
.ap.channel = 1,
.ap.authmode = WIFI_AUTH_WPA2_PSK,
.ap.ssid_hidden = false,
.ap.max_connection = 4,
.ap.beacon_interval = 100,
};
TEST_ESP_OK(esp_event_loop_init(event_handler, NULL));
// can't deinit event loop, need to reset leak check
unity_reset_leak_checks();
if (wifi_events == NULL) {
wifi_events = xEventGroupCreate();
}
TEST_ESP_OK(esp_wifi_init(&cfg));
TEST_ESP_OK(esp_wifi_set_mode(WIFI_MODE_AP));
TEST_ESP_OK(esp_wifi_set_config(WIFI_IF_AP, &w_config));
TEST_ESP_OK(esp_wifi_start());
}
static void start_wifi_as_sta(void)
{
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
cfg.nvs_enable = false;
// do not auto connect
wifi_event_handler_flag |= EVENT_HANDLER_FLAG_DO_NOT_AUTO_RECONNECT;
TEST_ESP_OK(esp_event_loop_init(event_handler, NULL));
// can't deinit event loop, need to reset leak check
unity_reset_leak_checks();
if (wifi_events == NULL) {
wifi_events = xEventGroupCreate();
} else {
xEventGroupClearBits(wifi_events, 0x00ffffff);
}
TEST_ESP_OK(esp_wifi_init(&cfg));
TEST_ESP_OK(esp_wifi_set_mode(WIFI_MODE_STA));
TEST_ESP_OK(esp_wifi_start());
}
static void stop_wifi(void)
{
printf("stop wifi\n");
TEST_ESP_OK(esp_wifi_stop());
TEST_ESP_OK(esp_wifi_deinit());
if (wifi_events) {
vEventGroupDelete(wifi_events);
wifi_events = NULL;
}
vTaskDelay(1000/portTICK_PERIOD_MS);
}
static void receive_ds2ds_packet(void)
{
test_case_uses_tcpip();
start_wifi_as_softap();
unity_wait_for_signal("sender ready");
unity_send_signal("receiver ready");
// wait for sender to send packets
vTaskDelay(1000/portTICK_PERIOD_MS);
stop_wifi();
}
static const char ds2ds_pdu[] = {
0x48, 0x03, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xE8, 0x65, 0xD4, 0xCB, 0x74, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0x60, 0x94, 0xE8, 0x65, 0xD4, 0xCB, 0x74, 0x1C, 0x26, 0xB9,
0x0D, 0x02, 0x7D, 0x13, 0x00, 0x00, 0x01, 0xE8, 0x65, 0xD4, 0xCB, 0x74,
0x1C, 0x00, 0x00, 0x26, 0xB9, 0x00, 0x00, 0x00, 0x00
};
static void send_ds2ds_packet(void)
{
test_case_uses_tcpip();
start_wifi_as_softap();
unity_send_signal("sender ready");
unity_wait_for_signal("receiver ready");
// send packet 20 times to make sure receiver will get this packet
for (uint16_t i = 0; i < 20; i++) {
esp_wifi_80211_tx(ESP_IF_WIFI_AP, ds2ds_pdu, sizeof(ds2ds_pdu), true);
vTaskDelay(50 / portTICK_PERIOD_MS);
}
stop_wifi();
}
TEST_CASE_MULTIPLE_DEVICES("receive ds2ds packet without exception", "[wifi][test_env=UT_T2_1]", receive_ds2ds_packet, send_ds2ds_packet);
static void wifi_connect_by_bssid(uint8_t *bssid)
{
EventBits_t bits;
wifi_config_t w_config = {
.sta.ssid = DEFAULT_SSID,
.sta.password = DEFAULT_PWD,
.sta.bssid_set = true,
};
memcpy(w_config.sta.bssid, bssid, 6);
TEST_ESP_OK(esp_wifi_set_config(WIFI_IF_STA, &w_config));
TEST_ESP_OK(esp_wifi_connect());
bits = xEventGroupWaitBits(wifi_events, GOT_IP_EVENT, 1, 0, 5000/portTICK_RATE_MS);
TEST_ASSERT(bits == GOT_IP_EVENT);
}
static void test_wifi_connection_sta(void)
{
char mac_str[19];
uint8_t mac[6];
EventBits_t bits;
test_case_uses_tcpip();
start_wifi_as_sta();
unity_wait_for_signal_param("SoftAP mac", mac_str, 19);
TEST_ASSERT_TRUE(unity_util_convert_mac_from_string(mac_str, mac));
wifi_connect_by_bssid(mac);
unity_send_signal("STA connected");
bits = xEventGroupWaitBits(wifi_events, DISCONNECT_EVENT, 1, 0, 60000 / portTICK_RATE_MS);
// disconnect event not triggered
printf("wait finish\n");
TEST_ASSERT(bits == 0);
stop_wifi();
}
static void test_wifi_connection_softap(void)
{
char mac_str[19] = {0};
uint8_t mac[6];
test_case_uses_tcpip();
start_wifi_as_softap();
TEST_ESP_OK(esp_wifi_get_mac(ESP_IF_WIFI_AP, mac));
sprintf(mac_str, MACSTR, MAC2STR(mac));
unity_send_signal_param("SoftAP mac", mac_str);
unity_wait_for_signal("STA connected");
vTaskDelay(60000 / portTICK_PERIOD_MS);
stop_wifi();
}
TEST_CASE_MULTIPLE_DEVICES("test wifi retain connection for 60s", "[wifi][test_env=UT_T2_1][timeout=90]", test_wifi_connection_sta, test_wifi_connection_softap);
| 29.707937 | 161 | 0.685937 |
08d2388ef06ac7a7361ec14208ccaba3332b40c7 | 225 | h | C | src/Simulation.h | gogarcia/SiPAG | 8bb6e346eb45475966cf263147d3321cab8c5317 | [
"MIT"
] | 2 | 2019-12-12T05:04:56.000Z | 2021-03-07T22:01:27.000Z | src/Simulation.h | gogarcia/SiPAG | 8bb6e346eb45475966cf263147d3321cab8c5317 | [
"MIT"
] | null | null | null | src/Simulation.h | gogarcia/SiPAG | 8bb6e346eb45475966cf263147d3321cab8c5317 | [
"MIT"
] | null | null | null | //MIT License
//Copyright (c) 2019 Gonzalo G Campos
/* PRAGMA */
#pragma once
int start(int argv, char **argc);
void loop(void);
void subStep(void);
void close();
void processNormalKeys(unsigned char key, int x, int y); | 15 | 56 | 0.697778 |
2327ee84dacfbb214c3aa98c16ff96b5edc6f445 | 4,705 | h | C | include/openthread-windows-config.h | yuzhyang/openthread | 38f206c6708d8fc7eae21db6ff3e3a50a2053b58 | [
"BSD-3-Clause"
] | null | null | null | include/openthread-windows-config.h | yuzhyang/openthread | 38f206c6708d8fc7eae21db6ff3e3a50a2053b58 | [
"BSD-3-Clause"
] | null | null | null | include/openthread-windows-config.h | yuzhyang/openthread | 38f206c6708d8fc7eae21db6ff3e3a50a2053b58 | [
"BSD-3-Clause"
] | 1 | 2019-08-03T17:35:08.000Z | 2019-08-03T17:35:08.000Z | /*
* Copyright (c) 2016, The OpenThread Authors.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holder nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/* Define to 1 to enable the NCP UART interface. */
// On the command line: #define OPENTHREAD_ENABLE_NCP_UART 0
/* Define to 1 to enable the NCP SPI interface. */
// On the command line: #define OPENTHREAD_ENABLE_NCP_SPI 1
/* Define to 1 if you want to enable support for multiple OpenThread
instances. */
#define OPENTHREAD_ENABLE_MULTIPLE_INSTANCES 1
/* Define to 1 if you want to enable default log output. */
#define OPENTHREAD_CONFIG_LOG_OUTPUT OPENTHREAD_CONFIG_LOG_OUTPUT_PLATFORM_DEFINED
/* Define to 1 to enable the commissioner role. */
#define OPENTHREAD_ENABLE_COMMISSIONER 1
/* Define to 1 if you want to use diagnostics module */
#define OPENTHREAD_ENABLE_DIAG 0
/* Define to 1 if you want to enable legacy network. */
#define OPENTHREAD_ENABLE_LEGACY 0
/* Define to 1 to enable dtls support. */
#define OPENTHREAD_ENABLE_DTLS 1
/* Define to 1 to enable the joiner role. */
#define OPENTHREAD_ENABLE_JOINER 1
/* Define to 1 to enable the jam detection. */
#define OPENTHREAD_ENABLE_JAM_DETECTION 0
/* Define to 1 to enable DHCPv6 Client. */
#define OPENTHREAD_ENABLE_DHCP6_CLIENT 1
/* Define to 1 to enable DHCPv6 SERVER. */
#define OPENTHREAD_ENABLE_DHCP6_SERVER 1
/* Define to 1 to enable MAC whitelist/blacklist feature. */
#define OPENTHREAD_ENABLE_MAC_FILTER 1
/* Define to 1 to enable TMF proxy feature. */
#define OPENTHREAD_ENABLE_TMF_PROXY 0
/* Define to 1 to enable raw link-layer API. */
#ifdef _KERNEL_MODE
#define OPENTHREAD_ENABLE_RAW_LINK_API 0
#else
#define OPENTHREAD_ENABLE_RAW_LINK_API 1
#endif
/* Define to the platform name. */
#define OPENTHREAD_CONFIG_PLATFORM_INFO "Windows"
/* Define to 1 to enable Border Router feature. */
#define OPENTHREAD_ENABLE_BORDER_ROUTER 1
/* Define to 1 to enable Service feature. */
#define OPENTHREAD_ENABLE_SERVICE 0
/* Name of package */
#define PACKAGE "openthread"
/* Define to the address where bug reports for this package should be sent. */
#define PACKAGE_BUGREPORT "openthread-devel@googlegroups.com"
/* Define to the full name of this package. */
#define PACKAGE_NAME "OPENTHREAD"
/* Define to the full name and version of this package. */
#define PACKAGE_STRING "OPENTHREAD 0.01.00"
/* Define to the one symbol short name of this package. */
#define PACKAGE_TARNAME "openthread"
/* Define to the home page for this package. */
#define PACKAGE_URL "http://github.com/openthread/openthread"
/* Define to the version of this package. */
#define PACKAGE_VERSION "0.01.00"
/* Version number of package */
#define VERSION "0.01.00"
// Windows Kernel only has sprintf_s
#ifdef _KERNEL_MODE
#define snprintf sprintf_s
#endif // _KERNEL_MODE
// Redefine rand to random for test code
#define random rand
// Disable a few warnings that we don't care about
#pragma warning(disable:4200) // nonstandard extension used: zero-sized array in struct/union
#pragma warning(disable:4201) // nonstandard extension used : nameless struct/union
#pragma warning(disable:4291) // no matching operator delete found
#pragma warning(disable:4815) // zero-sized array in stack object will have no elements
| 37.64 | 94 | 0.765781 |
d6c491764ba44ad8b6258e39074c96845164ad4c | 1,204 | h | C | System/Library/PrivateFrameworks/PhotosUICore.framework/PXCMMTranscriptBubbleFooterView.h | lechium/tvOS130Headers | 6b47cdcd4a6f453b399aa9d742b5d0f7e3f732fd | [
"MIT"
] | 11 | 2019-11-06T04:48:48.000Z | 2022-02-09T17:48:15.000Z | System/Library/PrivateFrameworks/PhotosUICore.framework/PXCMMTranscriptBubbleFooterView.h | lechium/tvOS130Headers | 6b47cdcd4a6f453b399aa9d742b5d0f7e3f732fd | [
"MIT"
] | 1 | 2020-04-16T01:41:56.000Z | 2020-04-16T04:32:00.000Z | System/Library/PrivateFrameworks/PhotosUICore.framework/PXCMMTranscriptBubbleFooterView.h | lechium/tvOS130Headers | 6b47cdcd4a6f453b399aa9d742b5d0f7e3f732fd | [
"MIT"
] | 3 | 2019-12-22T20:17:53.000Z | 2021-01-25T09:47:49.000Z | /*
* This header is generated by classdump-dyld 1.0
* on Tuesday, November 5, 2019 at 2:43:38 AM Mountain Standard Time
* Operating System: Version 13.0 (Build 17J586)
* Image Source: /System/Library/PrivateFrameworks/PhotosUICore.framework/PhotosUICore
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <PhotosUICore/PhotosUICore-Structs.h>
#import <UIKitCore/UIView.h>
@class UILabel, UIImageView, NSString;
@interface PXCMMTranscriptBubbleFooterView : UIView {
UILabel* _primaryLabel;
UILabel* _secondaryLabel;
UIImageView* _chevronImageView;
}
@property (nonatomic,copy) NSString * primaryText;
@property (nonatomic,copy) NSString * secondaryText;
@property (assign,nonatomic) BOOL chevronIsHidden;
+(double)_primaryToSecondaryBaselineSpacing;
+(double)_topToPrimaryBaselineSpacing;
+(double)_secondaryBaselineToBottomSpacing;
+(double)desiredHeight;
-(id)initWithCoder:(id)arg1 ;
-(id)initWithFrame:(CGRect)arg1 ;
-(NSString *)primaryText;
-(void)setPrimaryText:(NSString *)arg1 ;
-(NSString *)secondaryText;
-(void)setSecondaryText:(NSString *)arg1 ;
-(void)layoutSubviews;
-(void)setChevronIsHidden:(BOOL)arg1 ;
-(BOOL)chevronIsHidden;
@end
| 30.1 | 85 | 0.784053 |
d6c80a95742a271a3e8445b5abbe8cbc2013da24 | 4,598 | h | C | robotino_arduino/libraries/ros_lib/mavros_msgs/HilStateQuaternion.h | aadi-mishra/robotino | 43830c3f4078ba553c968d755b7d487b19c159f7 | [
"MIT"
] | 2 | 2021-04-26T22:43:40.000Z | 2021-05-28T13:58:03.000Z | robotino_arduino/libraries/ros_lib/mavros_msgs/HilStateQuaternion.h | aadi-mishra/robotino | 43830c3f4078ba553c968d755b7d487b19c159f7 | [
"MIT"
] | null | null | null | robotino_arduino/libraries/ros_lib/mavros_msgs/HilStateQuaternion.h | aadi-mishra/robotino | 43830c3f4078ba553c968d755b7d487b19c159f7 | [
"MIT"
] | null | null | null | #ifndef _ROS_mavros_msgs_HilStateQuaternion_h
#define _ROS_mavros_msgs_HilStateQuaternion_h
#include <stdint.h>
#include <string.h>
#include <stdlib.h>
#include "ros/msg.h"
#include "std_msgs/Header.h"
#include "geometry_msgs/Quaternion.h"
#include "geometry_msgs/Vector3.h"
#include "geographic_msgs/GeoPoint.h"
namespace mavros_msgs
{
class HilStateQuaternion : public ros::Msg
{
public:
typedef std_msgs::Header _header_type;
_header_type header;
typedef geometry_msgs::Quaternion _orientation_type;
_orientation_type orientation;
typedef geometry_msgs::Vector3 _angular_velocity_type;
_angular_velocity_type angular_velocity;
typedef geometry_msgs::Vector3 _linear_acceleration_type;
_linear_acceleration_type linear_acceleration;
typedef geometry_msgs::Vector3 _linear_velocity_type;
_linear_velocity_type linear_velocity;
typedef geographic_msgs::GeoPoint _geo_type;
_geo_type geo;
typedef float _ind_airspeed_type;
_ind_airspeed_type ind_airspeed;
typedef float _true_airspeed_type;
_true_airspeed_type true_airspeed;
HilStateQuaternion():
header(),
orientation(),
angular_velocity(),
linear_acceleration(),
linear_velocity(),
geo(),
ind_airspeed(0),
true_airspeed(0)
{
}
virtual int serialize(unsigned char *outbuffer) const override
{
int offset = 0;
offset += this->header.serialize(outbuffer + offset);
offset += this->orientation.serialize(outbuffer + offset);
offset += this->angular_velocity.serialize(outbuffer + offset);
offset += this->linear_acceleration.serialize(outbuffer + offset);
offset += this->linear_velocity.serialize(outbuffer + offset);
offset += this->geo.serialize(outbuffer + offset);
union {
float real;
uint32_t base;
} u_ind_airspeed;
u_ind_airspeed.real = this->ind_airspeed;
*(outbuffer + offset + 0) = (u_ind_airspeed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_ind_airspeed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_ind_airspeed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_ind_airspeed.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->ind_airspeed);
union {
float real;
uint32_t base;
} u_true_airspeed;
u_true_airspeed.real = this->true_airspeed;
*(outbuffer + offset + 0) = (u_true_airspeed.base >> (8 * 0)) & 0xFF;
*(outbuffer + offset + 1) = (u_true_airspeed.base >> (8 * 1)) & 0xFF;
*(outbuffer + offset + 2) = (u_true_airspeed.base >> (8 * 2)) & 0xFF;
*(outbuffer + offset + 3) = (u_true_airspeed.base >> (8 * 3)) & 0xFF;
offset += sizeof(this->true_airspeed);
return offset;
}
virtual int deserialize(unsigned char *inbuffer) override
{
int offset = 0;
offset += this->header.deserialize(inbuffer + offset);
offset += this->orientation.deserialize(inbuffer + offset);
offset += this->angular_velocity.deserialize(inbuffer + offset);
offset += this->linear_acceleration.deserialize(inbuffer + offset);
offset += this->linear_velocity.deserialize(inbuffer + offset);
offset += this->geo.deserialize(inbuffer + offset);
union {
float real;
uint32_t base;
} u_ind_airspeed;
u_ind_airspeed.base = 0;
u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_ind_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->ind_airspeed = u_ind_airspeed.real;
offset += sizeof(this->ind_airspeed);
union {
float real;
uint32_t base;
} u_true_airspeed;
u_true_airspeed.base = 0;
u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
u_true_airspeed.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
this->true_airspeed = u_true_airspeed.real;
offset += sizeof(this->true_airspeed);
return offset;
}
virtual const char * getType() override { return "mavros_msgs/HilStateQuaternion"; };
virtual const char * getMD5() override { return "c858c0f05d4ab30256be7c53edee8e3c"; };
};
}
#endif
| 38 | 90 | 0.644411 |
033d597cfed4f57620b92d770f317d35398c203a | 3,074 | h | C | source/util_api/tls/containers/TlsModuleContainer/tls_mco_global.h | lgirdk/ccsp-common-library | 8d912984e96f960df6dadb4b0e6bc76c76376776 | [
"Apache-2.0"
] | 4 | 2018-02-26T05:41:14.000Z | 2019-12-20T07:31:39.000Z | source/util_api/tls/containers/TlsModuleContainer/tls_mco_global.h | rdkcmf/rdkb-CcspCommonLibrary | 3eba76685bbf5eb6656f45eb4b57fdb5c269c2a1 | [
"Apache-2.0"
] | null | null | null | source/util_api/tls/containers/TlsModuleContainer/tls_mco_global.h | rdkcmf/rdkb-CcspCommonLibrary | 3eba76685bbf5eb6656f45eb4b57fdb5c269c2a1 | [
"Apache-2.0"
] | 3 | 2017-07-30T15:35:16.000Z | 2020-08-18T20:44:08.000Z | /*
* If not stated otherwise in this file or this component's Licenses.txt file the
* following copyright and licenses apply:
*
* Copyright 2015 RDK Management
*
* 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.
*/
/**********************************************************************
Copyright [2014] [Cisco Systems, Inc.]
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.
**********************************************************************/
/**********************************************************************
module: tls_mco_global.h
For Transport Layer Security Implementation (TLS),
BroadWay Service Delivery System
---------------------------------------------------------------
description:
This header file includes all the header files required by
the Tls Module Container implementation.
---------------------------------------------------------------
environment:
platform independent
---------------------------------------------------------------
author:
Xuechen Yang
---------------------------------------------------------------
revision:
09/13/02 initial revision.
**********************************************************************/
#ifndef _TLS_MCO_GLOBAL_
#define _TLS_MCO_GLOBAL_
#include "ansc_platform.h"
#include "ansc_crypto_interface.h"
#include "ansc_crypto_external_api.h"
#include "ansc_object_mapper_interface.h"
#include "ansc_object_mapper_external_api.h"
#include "ansc_mco_interface.h"
#include "ansc_mco_external_api.h"
#include "ansc_atoproto_interface.h"
#include "ansc_atoproto_external_api.h"
#include "ansc_qio_interface.h"
#include "ansc_qio_external_api.h"
#include "ansc_ifo_csp.h"
#include "ansc_ifo_iqc.h"
#include "tls_co_oid.h"
#include "tls_co_name.h"
#include "tls_co_type.h"
#include "tls_properties.h"
#include "tls_mco_interface.h"
#include "tls_mco_exported_api.h"
#include "tls_mco_internal_api.h"
#include "tls_eco_interface.h"
#include "tls_eco_exported_api.h"
#endif
| 29.27619 | 81 | 0.611581 |
d96fb452f4674e92c41b3a616698fb8ec0580d12 | 91 | h | C | include/enemy_manager.h | 2020wmarvil/top-down-platformer | c968a9150ede03a03ef16acb7cf1bf5ec6806bc4 | [
"MIT"
] | null | null | null | include/enemy_manager.h | 2020wmarvil/top-down-platformer | c968a9150ede03a03ef16acb7cf1bf5ec6806bc4 | [
"MIT"
] | null | null | null | include/enemy_manager.h | 2020wmarvil/top-down-platformer | c968a9150ede03a03ef16acb7cf1bf5ec6806bc4 | [
"MIT"
] | null | null | null | #pragma once
#include <vector>
#include "enemy.h"
extern std::vector<Enemy> enemy_list;
| 11.375 | 37 | 0.725275 |
fcce15cb5011c6e40df988a7413781307859f3ba | 2,279 | c | C | libzathura/annotations/annotation-stamp.c | pwmt/libzathura | 25ef21efbc5a7bf26d6dedbf5bc7b91a8eea350b | [
"Zlib"
] | 1 | 2022-03-18T02:22:40.000Z | 2022-03-18T02:22:40.000Z | libzathura/annotations/annotation-stamp.c | pwmt/libzathura | 25ef21efbc5a7bf26d6dedbf5bc7b91a8eea350b | [
"Zlib"
] | null | null | null | libzathura/annotations/annotation-stamp.c | pwmt/libzathura | 25ef21efbc5a7bf26d6dedbf5bc7b91a8eea350b | [
"Zlib"
] | null | null | null | /* See LICENSE file for license and copyright information */
#include <stdlib.h>
#include "annotation-stamp.h"
#include "../annotations.h"
#include "../error.h"
#include "internal.h"
#define ANNOTATION_STAMP_CHECK_TYPE() \
if (annotation->type != ZATHURA_ANNOTATION_STAMP) { \
return ZATHURA_ERROR_ANNOTATION_INVALID_TYPE; \
}
#define ANNOTATION_STAMP_CHECK_DATA() \
if (annotation->data.stamp == NULL) { \
return ZATHURA_ERROR_UNKNOWN; \
}
#define ANNOTATION_STAMP_CHECK_TYPE_AND_DATA() \
ANNOTATION_STAMP_CHECK_TYPE() \
ANNOTATION_STAMP_CHECK_DATA()
zathura_error_t
zathura_annotation_stamp_init(zathura_annotation_t* annotation)
{
if (annotation == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
ANNOTATION_STAMP_CHECK_TYPE()
if (annotation->data.stamp != NULL) {
free(annotation->data.stamp);
annotation->data.stamp = NULL;
}
annotation->data.stamp = calloc(1, sizeof(zathura_annotation_stamp_t));
if (annotation->data.stamp == NULL) {
return ZATHURA_ERROR_OUT_OF_MEMORY;
}
annotation->data.stamp->icon_name = NULL;
return ZATHURA_ERROR_OK;
}
zathura_error_t
zathura_annotation_stamp_clear(zathura_annotation_t* annotation)
{
if (annotation == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
ANNOTATION_STAMP_CHECK_TYPE()
if (annotation->data.stamp != NULL) {
g_free(annotation->data.stamp->icon_name);
}
free(annotation->data.stamp);
annotation->data.stamp = NULL;
return ZATHURA_ERROR_OK;
}
zathura_error_t
zathura_annotation_stamp_set_icon_name(zathura_annotation_t*
annotation, char* icon_name)
{
if (annotation == NULL || icon_name == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
ANNOTATION_STAMP_CHECK_TYPE_AND_DATA()
if (annotation->data.stamp->icon_name != NULL) {
g_free(annotation->data.stamp->icon_name);
}
annotation->data.stamp->icon_name = g_strdup(icon_name);
return ZATHURA_ERROR_OK;
}
zathura_error_t
zathura_annotation_stamp_get_icon_name(zathura_annotation_t*
annotation, char** icon_name)
{
if (annotation == NULL || icon_name == NULL) {
return ZATHURA_ERROR_INVALID_ARGUMENTS;
}
ANNOTATION_STAMP_CHECK_TYPE_AND_DATA()
*icon_name = annotation->data.stamp->icon_name;
return ZATHURA_ERROR_OK;
}
| 22.343137 | 73 | 0.744186 |
d85c496f2a9b25464499b309ee710e6db515de3f | 31,123 | c | C | private/windbg64/debugger/dm/util.c | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 11 | 2017-09-02T11:27:08.000Z | 2022-01-02T15:25:24.000Z | private/windbg64/debugger/dm/util.c | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | null | null | null | private/windbg64/debugger/dm/util.c | King0987654/windows2000 | 01f9c2e62c4289194e33244aade34b7d19e7c9b8 | [
"MIT"
] | 14 | 2019-01-16T01:01:23.000Z | 2022-02-20T15:54:27.000Z | /*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
util.c
Abstract:
This file contains a set of general utility routines for the
Debug Monitor module
Author:
Jim Schaad (jimsch) 9-12-92
Environment:
Win32 user mode
--*/
#include "precomp.h"
#pragma hdrstop
extern EXPECTED_EVENT masterEE, *eeList;
extern HTHDX thdList;
extern HPRCX prcList;
extern CRITICAL_SECTION csThreadProcList;
extern char abEMReplyBuf[]; // Buffer for EM to reply to us in
static HPRCX HprcRead;
static HANDLE HFileRead = 0; // Read File handle
static DWORDLONG QwMemory = 0; // Read File Address
static ULONG CbOffset = 0; // Offset of read address
BOOL
AddrWriteMemory(
HPRCX hprc,
HTHDX hthd,
LPADDR paddr,
LPVOID lpv,
DWORD cb,
LPDWORD pcbWritten
)
/*++
Routine Description:
This function is used to do a verified write to memory. Most of the
time it will just do a simple call to WriteMemory but some times
it will do validations of writes.
Arguments:
hprc - Supplies the handle to the process
paddr - Supplies the address to be written at
lpv - Supplies a pointer to the bytes to be written
cb - Supplies the count of bytes to be written
pcbWritten - Returns the number of bytes actually written
Return Value:
TRUE if successful and FALSE otherwise
--*/
{
BOOL fRet;
ADDR addr;
/*
* Can't resolve linker indices from here.
*/
assert(!(ADDR_IS_LI(*paddr)));
if (ADDR_IS_LI(*paddr)) {
return FALSE;
}
/*
* Make a local copy to mess with
*/
addr = *paddr;
if (!ADDR_IS_FLAT(addr)) {
fRet = TranslateAddress(hprc, hthd, &addr, TRUE);
//assert(fRet);
if (!fRet) {
return fRet;
}
}
return DbgWriteMemory(hprc,
GetAddrOff(addr),
lpv,
cb,
pcbWritten);
} /* AddrWriteMemory() */
BOOL
AddrReadMemory(
HPRCX hprc,
HTHDX hthd,
LPADDR paddr,
LPVOID lpv,
DWORD cb,
LPDWORD lpRead
)
/*++
Routine Description:
Read data from a process, using a full ADDR packet.
Arguments:
hprc - Supplies the process structure
hthd - Supplies the thread structure. This must be valid if the
address is not flat; otherwise the thread is not used.
paddr - Supplies the address to read from
lpv - Supplies a pointer to the local buffer
cb - supplies the count of bytes to read
lpRead - Returns the number of bytes actually read
Return Value:
TRUE if successful and FALSE otherwise
--*/
{
BOOL fRet;
ADDR addr;
#ifndef KERNEL
PBREAKPOINT bp;
DWORD offset;
BP_UNIT instr;
#endif
/*
* We can't resolve linker indices from here.
*/
DPRINT(1,("AddrReadMemory @%p: Flat:%i Off32:%i Li:%i Re:%i\n",
GetAddrOff(*paddr),
ADDR_IS_FLAT(*paddr),
ADDR_IS_OFF32(*paddr),
ADDR_IS_LI(*paddr),
ADDR_IS_REAL(*paddr)
));
assert(!(ADDR_IS_LI(*paddr)));
if (ADDR_IS_LI(*paddr)) {
return FALSE;
}
/*
* Make a local copy to mess with
*/
addr = *paddr;
if (!ADDR_IS_FLAT(addr)) {
fRet = TranslateAddress(hprc, hthd, &addr, TRUE);
//assert(fRet);
if (!fRet) {
return fRet;
}
}
if (!DbgReadMemory(hprc, GetAddrOff(addr), lpv, cb, lpRead)) {
return FALSE;
}
#ifndef KERNEL
/* The memory has been read into the buffer now sanitize it : */
/* (go through the entire list of breakpoints and see if any */
/* are in the range. If a breakpoint is in the range then an */
/* offset relative to the start address and the original inst */
/* ruction is returned and put into the return buffer) */
for (bp=bpList->next; bp; bp=bp->next) {
if (BPInRange(hprc, hthd, bp, &addr, *lpRead, &offset, &instr)) {
if (offset < 0) {
memcpy(lpv, ((char *) &instr) - offset,
sizeof(BP_UNIT) + offset);
} else if (offset + sizeof(BP_UNIT) > *lpRead) {
memcpy(((char *)lpv)+offset, &instr, *lpRead - offset);
} else {
*((BP_UNIT UNALIGNED *)((char *)lpv+offset)) = instr;
}
#if defined (TARGET_IA64)
// restore template to MLI if displaced instruction is MOVL and in range
if(((bp->flags & BREAKPOINT_IA64_MOVL) && (offset >= 0)) && ((GetAddrOff(bp->addr) & 0xf) == 4)) {
*((char *)lpv + offset - 4) &= ~(0x1e);
*((char *)lpv + offset - 4) |= 0x4;
}
#endif // TARGET_IA64
}
}
#endif // !KERNEL
return TRUE;
} /* AddrReadMemory() */
#if 0
BOOL
SanitizedMemoryRead(
HPRCX hprc,
HTHDX hthd,
LPADDR paddr,
LPVOID lpb,
DWORD cb,
LPDWORD lpcb
)
/*++
Routine Description:
This routine is provided to do the actual read of memory. This allows
multiple routines in the DM to do the read through a single common
interface. This routine will correct the read memory for any breakpoints
currently set in memory.
Arguments:
hprc - Supplies the process handle for the read
hthd - Supplies the thread handle for the read
paddr - Supplies the address to read memory from
lpb - Supplies the buffer to do the read into
cb - Supplies the number of bytes to be read
lpcb - Returns the number of bytes actually read
Return Value:
TRUE on success and FALSE on failure
--*/
{
DWORD offset;
BP_UNIT instr;
BREAKPOINT *bp;
if (!AddrReadMemory(hprc, hthd, paddr, lpb, cb, lpcb)) {
return FALSE;
}
#ifndef KERNEL
/* The memory has been read into the buffer now sanitize it : */
/* (go through the entire list of breakpoints and see if any */
/* are in the range. If a breakpoint is in the range then an */
/* offset relative to the start address and the original inst */
/* ruction is returned and put into the return buffer) */
for (bp=bpList->next; bp; bp=bp->next) {
if (BPInRange(hprc, hthd, bp, paddr, *lpcb, &offset, &instr)) {
if (offset < 0) {
memcpy(lpb, ((char *) &instr) - offset,
sizeof(BP_UNIT) + offset);
} else if (offset + sizeof(BP_UNIT) > *lpcb) {
memcpy(((char *)lpb)+offset, &instr, *lpcb - offset);
} else {
*((BP_UNIT UNALIGNED *)((char *)lpb+offset)) = instr;
}
#ifdef TARGET_IA64
// restore template to MLI if displaced instruction is MOVL and in range
if(((bp->flags & BREAKPOINT_IA64_MOVL) && (offset >= 0)) && ((GetAddrOff(bp->addr) & 0xf) == 4)) {
*((char *)lpv + offset - 4) &= ~(0x1e);
*((char *)lpv + offset - 4) |= 0x4;
}
#endif // TARGET_IA64
}
}
#endif // !KERNEL
return TRUE;
}
#endif
ULONG
SetReadPointer(
ULONG cbOffset,
int iFrom
)
/*++
Routine Description:
This routine is used to deal with changing the location of where
the next read should occur. This will take effect on the current
file pointer or debuggee memory pointer address.
Arguments:
cbOffset - Supplies the offset to set the file pointer at
iFrom - Supplies the type of set to be preformed.
Return Value:
The new file offset
--*/
{
if (QwMemory == 0) {
CbOffset = SetFilePointer(HFileRead, cbOffset, NULL, iFrom);
} else {
switch( iFrom ) {
case FILE_BEGIN:
CbOffset = cbOffset;
break;
case FILE_CURRENT:
CbOffset += cbOffset;
break;
default:
assert(FALSE);
break;
}
}
return CbOffset;
} /* SetReadPointer() */
VOID
SetPointerToFile(
HANDLE hFile
)
/*++
Routine Description:
This routine is called to specify which file handle should be used for
doing reads from
Arguments:
hFile - Supplies the file handle to do future reads from
Return Value:
None.
--*/
{
HFileRead = hFile;
HprcRead = NULL;
QwMemory = 0;
return;
} /* SetPointerToFile() */
VOID
SetPointerToMemory(
HPRCX hprc,
DWORDLONG qw
)
/*++
Routine Description:
This routine is called to specify where in debuggee memory reads should
be done from.
Arguments:
hProc - Supplies the handle to the process to read memory from
lpv - Supplies the base address of the dll to read memory at.
Return Value:
None.
--*/
{
HprcRead = hprc;
QwMemory = qw;
HFileRead = NULL;
return;
} /* SetPointerToMemory() */
BOOL
DoRead(
LPVOID lpv,
DWORD cb
)
/*++
Routine Description:
This routine is used to preform the actual read operation from either
a file handle or from the dlls memory.
Arguments:
lpv - Supplies the pointer to read memory into
cb - Supplies the count of bytes to be read
Return Value:
TRUE If read was fully successful and FALSE otherwise
--*/
{
DWORD cbRead;
if (QwMemory) {
if ( !DbgReadMemory( HprcRead, QwMemory+CbOffset, lpv, cb, &cbRead ) ||
(cb != cbRead) ) {
return FALSE;
}
CbOffset += cb;
} else if ((ReadFile(HFileRead, lpv, cb, &cbRead, NULL) == 0) ||
(cb != cbRead)) {
return FALSE;
}
return TRUE;
} /* DoRead() */
BOOL
AreAddrsEqual(
HPRCX hprc,
HTHDX hthd,
LPADDR paddr1,
LPADDR paddr2
)
/*++
Routine Description:
This function is used to compare to addresses for equality
Arguments:
hprc - Supplies process for address context
hthd - Supplies thread for address context
paddr1 - Supplies a pointer to an ADDR structure
paddr2 - Supplies a pointer to an ADDR structure
Return Value:
TRUE if the addresses are equivalent
--*/
{
ADDR addr1;
ADDR addr2;
/*
* Step 1. Addresses are equal if
* - Both addresses are flat
* - The two offsets are the same
*/
if ((ADDR_IS_FLAT(*paddr1) == TRUE) &&
(ADDR_IS_FLAT(*paddr1) == ADDR_IS_FLAT(*paddr2)) &&
(paddr1->addr.off == paddr2->addr.off)) {
return TRUE;
}
/*
* Step 2. Address are equal if the linear address are the same
*/
addr1 = *paddr1;
addr2 = *paddr2;
if (addr1.addr.off == addr2.addr.off) {
return TRUE;
}
return FALSE;
} /* AreAddrsEqual() */
HTHDX
HTHDXFromPIDTID(
PID pid,
TID tid
)
{
HTHDX hthd;
EnterCriticalSection(&csThreadProcList);
for ( hthd = thdList->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse;
hthd;
hthd = hthd->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse ) {
if (hthd->tid == tid && hthd->hprc->pid == pid ) {
break;
}
}
LeaveCriticalSection(&csThreadProcList);
return hthd;
}
HTHDX
HTHDXFromHPIDHTID(
HPID hpid,
HTID htid
)
{
HTHDX hthd;
EnterCriticalSection(&csThreadProcList);
for (hthd = thdList->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse;
hthd;
hthd = hthd->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse) {
if (hthd->htid == htid && hthd->hprc->hpid == hpid ) {
break;
}
}
LeaveCriticalSection(&csThreadProcList);
return hthd;
}
HPRCX
HPRCFromPID(
PID pid
)
{
HPRCX hprc;
EnterCriticalSection(&csThreadProcList);
for( hprc = prcList->next; hprc; hprc = hprc->next) {
if (hprc->pid == pid) {
break;
}
}
LeaveCriticalSection(&csThreadProcList);
return hprc;
}
HPRCX
HPRCFromHPID(
HPID hpid
)
{
HPRCX hprc;
EnterCriticalSection(&csThreadProcList);
for ( hprc = prcList->next; hprc; hprc = hprc->next ) {
if (hprc->hpid == hpid) {
break;
}
}
LeaveCriticalSection(&csThreadProcList);
return hprc;
}
HPRCX
HPRCFromRwhand(
HANDLE rwHand
)
{
HPRCX hprc;
EnterCriticalSection(&csThreadProcList);
for ( hprc=prcList->next; hprc; hprc=hprc->next ) {
if (hprc->rwHand==rwHand) {
break;
}
}
LeaveCriticalSection(&csThreadProcList);
return hprc;
}
void
FreeHthdx(
HTHDX hthd
)
{
HTHDX * ppht;
BREAKPOINT * pbp;
BREAKPOINT * pbpT;
EnterCriticalSection(&csThreadProcList);
/*
* Free all breakpoints unique to thread
*/
for (pbp = BPNextHthdPbp(hthd, NULL); pbp; pbp = pbpT) {
pbpT = BPNextHthdPbp(hthd, pbp);
RemoveBP(pbp);
}
for (ppht = &(hthd->hprc->hthdChild); *ppht; ppht = & ( (*ppht)->nextSibling ) ) {
if (*ppht == hthd) {
*ppht = (*ppht)->nextSibling;
break;
}
}
for (ppht = &(thdList->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse);
*ppht;
ppht = & ( (*ppht)->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse ) ) {
if (*ppht == hthd) {
*ppht = (*ppht)->nextGlobalThreadThisProbablyIsntTheOneYouWantedToUse;
break;
}
}
LeaveCriticalSection(&csThreadProcList);
MHFree(hthd);
}
VOID
ClearContextPointers(
PKNONVOLATILE_CONTEXT_POINTERS ctxptrs
)
/*++
Routine - Clear Context Pointers
Purpose - clears the context pointer structure.
Argument - lpvoid - pointer to context pointers structure;
void on on architectures that don't have such.
--*/
{
memset(ctxptrs, 0, sizeof (KNONVOLATILE_CONTEXT_POINTERS));
}
/*** FGETEXPORT
*
* PURPOSE:
* Given the base address of a DLL in the debuggee's memory space, find
* the value (if any) of a specified export in that DLL.
*
* INPUT:
* pdi DLLLOAD_ITEM structure for module
* hfile Handle to disk file of DLL
* szExport Name of symbol to search for in its export table
*
* OUPTUT:
* *plpvValue Address of the symbol, from the export table.
* plpvValue may be NULL if caller doesn't care.
* return code TRUE if symbol was found, FALSE if not
*/
BOOL
FGetExport(
PDLLLOAD_ITEM pdi,
HFILE hfile,
LPCTSTR szExport,
LPVOID* plpvValue
)
{
IMAGE_DOS_HEADER doshdr;
IMAGE_NT_HEADERS nthdr;
IMAGE_EXPORT_DIRECTORY exphdr;
LONG inameFirst, inameLast, iname; // must be signed
UOFFSET uoffExpTable;
UOFFSET uoffNameTable;
UOFFSET uoffFuncTable;
UOFFSET uoffOrdinalTable;
UOFFSET uoffString;
INT iRet = 1;
size_t cbValueRead = _ftcslen(szExport) + 1;
LPTSTR szValueRead = MHAlloc( cbValueRead * sizeof(TCHAR));
UOFFSET uoffBasePE = (UOFFSET)0;
DWORD dw;
/*
** Check for both initial MZ (oldheader) or initial PE header.
*/
VERIFY(CbReadDllHdr(hfile, 0, &doshdr, sizeof(doshdr)) == sizeof(doshdr));
if ( doshdr.e_magic != IMAGE_DOS_SIGNATURE ) {
return FALSE;
}
uoffBasePE = doshdr.e_lfanew;
VERIFY(CbReadDllHdr(hfile, uoffBasePE, &nthdr, sizeof(nthdr)) ==
sizeof(nthdr));
uoffExpTable = nthdr.OptionalHeader.
DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT].VirtualAddress;
if (uoffExpTable == 0) {
return FALSE;
}
uoffExpTable = FileOffFromVA(pdi, hfile, uoffBasePE, &nthdr, uoffExpTable);
VERIFY(CbReadDllHdr(hfile, uoffExpTable, &exphdr, sizeof(exphdr)) ==
sizeof(exphdr));
if ( exphdr.NumberOfNames == 0L ) {
return FALSE;
}
uoffNameTable = FileOffFromVA(pdi, hfile, uoffBasePE, &nthdr,
(UOFFSET)exphdr.AddressOfNames);
// Do a binary search through the export table
inameFirst = 0;
inameLast = exphdr.NumberOfNames - 1;
while (inameFirst <= inameLast) {
iname = (inameFirst + inameLast) / 2;
VERIFY(CbReadDllHdr(hfile,
uoffNameTable + (iname * sizeof(DWORD)),
&dw,
sizeof(DWORD)) == sizeof(DWORD));
uoffString = FileOffFromVA(pdi, hfile, uoffBasePE, &nthdr, dw);
VERIFY(CbReadDllHdr(hfile, uoffString, szValueRead, cbValueRead) == cbValueRead);
iRet = _ftcsncmp( szValueRead, szExport, cbValueRead );
if (iRet < 0) {
inameFirst = iname + 1;
} else if (iRet > 0) {
inameLast = iname - 1;
} else /* iRet == 0: match */ {
/* if caller wants its value, get value */
if (plpvValue) {
USHORT usOrdinal;
/* read symbol value from export table */
uoffOrdinalTable = FileOffFromVA(pdi, hfile, uoffBasePE,
&nthdr, (UOFFSET)exphdr.AddressOfNameOrdinals);
VERIFY(CbReadDllHdr(hfile,
uoffOrdinalTable + (iname * sizeof(USHORT)),
&usOrdinal, sizeof(usOrdinal)) == sizeof(usOrdinal));
uoffFuncTable = FileOffFromVA(pdi, hfile, uoffBasePE,
&nthdr, (UOFFSET)exphdr.AddressOfFunctions);
VERIFY(CbReadDllHdr(hfile,
uoffFuncTable + (usOrdinal * sizeof(DWORD)),
plpvValue, sizeof(*plpvValue)) == sizeof(*plpvValue));
assert( Is64PtrSE(pdi->offBaseOfImage) );
*plpvValue = (LPVOID) ((UOFFSET)*plpvValue + pdi->offBaseOfImage);
}
break;
}
}
MHFree( szValueRead );
return !iRet;
}
UOFFSET
FileOffFromVA(
PDLLLOAD_ITEM pdi,
HFILE hfile,
UOFFSET uoffBasePE,
const IMAGE_NT_HEADERS *pnthdr,
UOFFSET va
)
/*++
Routine Description:
Given a virtual address, calculate the file offset at which it
can be found in an EXE/DLL.
Arguments:
pdi - Supplies the DLLLOAD_ITEM structure for this exe/dll
hfile - Supplies a read handle to the exe/dll file
uoffBasePE - Supplies offset of beginning of PE header in exe/dll
pnthdr - Supplies ptr to NTHDR for the exe/dll
va - Supplies virtual address to convert
Return Value:
the file offset for the given va, 0 for failure
--*/
{
UOFFSET uoffObjs;
WORD iobj, cobj;
IMAGE_SECTION_HEADER isecthdr;
PIMAGE_SECTION_HEADER psect;
UOFFSET uoffFile = 0;
uoffObjs = uoffBasePE +
FIELD_OFFSET(IMAGE_NT_HEADERS, OptionalHeader) +
pnthdr->FileHeader.SizeOfOptionalHeader;
cobj = pnthdr->FileHeader.NumberOfSections;
/*
* If we have not yet read the section headers into the DLLINFO, do
* so now.
*/
if (pdi->Sections == NULL) {
pdi->Sections = MHAlloc(cobj * sizeof(IMAGE_SECTION_HEADER));
VERIFY(
CbReadDllHdr(hfile, uoffObjs, pdi->Sections, cobj * sizeof(IMAGE_SECTION_HEADER))
);
}
/*
* Look for the address.
*/
for (iobj=0; iobj<cobj; iobj++) {
DWORD offset, cbObject;
offset = pdi->Sections[iobj].VirtualAddress;
cbObject = pdi->Sections[iobj].Misc.VirtualSize;
if (cbObject == 0) {
cbObject = pdi->Sections[iobj].SizeOfRawData;
}
if (va >= offset && va < offset + cbObject) {
// found it
uoffFile = pdi->Sections[iobj].PointerToRawData + va - offset;
break;
}
}
assert(uoffFile); // caller shouldn't have called with a bogus VA
return uoffFile;
}
DWORD
CbReadDllHdr(
HFILE hfile,
UOFFSET uoff,
LPVOID lpvBuf,
DWORD cb
)
{
VERIFY(_llseek(hfile, (DWORD)uoff, 0) != HFILE_ERROR);
return _lread(hfile, lpvBuf, cb);
}
XOSD
DMSendRequestReply (
DBC dbc,
HPID hpid,
HTID htid,
DWORD cbInput,
LPVOID lpInput,
DWORD cbOutput,
LPVOID lpOutput
)
/*++
Routine Description:
Arguments:
dbc - Supplies command to send to EM
hpid - Supplies process handle
htis - Supplies thread handle
cbInput - Supplies size of packet to send
lpInput - Supplies packet to send
cbOutput - Supplies size of packet to receive
lpOutput - Returns data from reply
Return Value:
xosdNone or xosd error value
--*/
{
XOSD xosd = xosdNone;
if ( cbInput == 0 ) {
RTP rtp;
rtp.dbc = dbc;
rtp.hpid = hpid;
rtp.htid = htid;
rtp.cb = 0;
xosd = DmTlFunc
( tlfRequest, hpid, FIELD_OFFSET( RTP, rgbVar ), (LPARAM) &rtp );
}
else {
LPRTP lprtp = MHAlloc ( FIELD_OFFSET( RTP, rgbVar ) + cbInput );
lprtp->dbc = dbc;
lprtp->hpid = hpid;
lprtp->htid = htid;
lprtp->cb = cbInput;
_fmemcpy ( lprtp->rgbVar, lpInput, cbInput );
xosd = DmTlFunc
( tlfRequest, hpid, FIELD_OFFSET( RTP, rgbVar ) + cbInput, (LPARAM) lprtp );
MHFree ( lprtp );
}
if (xosd == xosdNone && cbOutput != 0) {
_fmemcpy(lpOutput, abEMReplyBuf, cbOutput);
}
return xosd;
} /* DMSendRequestReply */
XOSD
DMSendDebugPacket (
DBC dbc,
HPID hpid,
HTID htid,
DWORD cbInput,
LPVOID lpInput
)
/*++
Routine Description:
Arguments:
dbc - Supplies command to send to EM
hpid - Supplies process handle
htid - Supplies thread handle
cbInput - Supplies size of packet to send
lpInput - Supplies packet to send
Return Value:
xosdNone or xosd error value
--*/
{
XOSD xosd = xosdNone;
if ( cbInput == 0 ) {
RTP rtp;
rtp.dbc = dbc;
rtp.hpid = hpid;
rtp.htid = htid;
rtp.cb = 0;
xosd = DmTlFunc
( tlfDebugPacket, hpid, FIELD_OFFSET( RTP, rgbVar ), (LPARAM) &rtp );
}
else {
LPRTP lprtp = MHAlloc ( FIELD_OFFSET( RTP, rgbVar ) + cbInput );
lprtp->dbc = dbc;
lprtp->hpid = hpid;
lprtp->htid = htid;
lprtp->cb = cbInput;
_fmemcpy ( lprtp->rgbVar, lpInput, cbInput );
xosd = DmTlFunc
( tlfDebugPacket, hpid, FIELD_OFFSET( RTP, rgbVar ) + cbInput, (LPARAM) lprtp );
MHFree ( lprtp );
}
return xosd;
} /* DMSendRequestReply */
PVOID
DMCopyLargeReply(
DWORD size
)
/*++
Routine Description:
This routine is called to get a reply packet whose size is not known
before calling DMSendRequestReply. It allocates a buffer and copies
the reply packet into the buffer.
Arguments:
size - Supplies the size in bytes of the packet to be copied
Return Value:
Returns the copy of the reply packet. If memory could not be allocated,
returns NULL.
--*/
{
PVOID pv = MHAlloc(size);
if (pv) {
memcpy(pv, abEMReplyBuf, size);
}
return pv;
} /* DMCopyLargeReply */
DWORD64
GetEndOfRange (
HPRCX hprc,
HTHDX hthd,
DWORD64 Addr
)
/*++
Routine Description:
Given an address, gets the end of the range for that address.
Arguments:
hprc - Supplies process
hthd - Supplies thread
Addr - Supplies the address
Return Value:
DWORD - End of range
--*/
{
ADDR AddrPC;
AddrFromHthdx(&AddrPC, hthd);
SetAddrOff( &AddrPC, Addr );
DMSendRequestReply(
dbcLastAddr,
hprc->hpid,
hthd->htid,
sizeof(ADDR),
&AddrPC,
sizeof(DWORD),
&Addr
);
Addr = (*(DWORD *)abEMReplyBuf);
// NOTENOTE : jimsch --- Is this correct?
return (DWORD) Addr;
}
DWORD
GetCanStep (
HPID hpid,
HTID htid,
LPADDR Addr,
LPCANSTEP CanStep
)
/*++
Routine Description:
Arguments:
hprc - Supplies process
hthd - Supplies thread
Addr - Supplies Address
Return Value:
CANSTEP_YES or CANSTEP_NO (or CANSTEP_THUNK?)
--*/
{
return DMSendRequestReply(
dbcCanStep,
hpid,
htid,
sizeof(ADDR),
Addr,
sizeof(CANSTEP),
CanStep
);
}
BOOL
CheckBpt(
HTHDX hthd,
PBREAKPOINT pbp
)
{
DEBUG_EVENT64 de;
if (pbp->bpNotify == bpnsStop) {
return TRUE;
} else if (pbp->bpNotify == bpnsCheck) {
de.dwDebugEventCode = CHECK_BREAKPOINT_DEBUG_EVENT;
de.dwProcessId = hthd->hprc->pid;
de.dwThreadId = hthd->tid;
de.u.Exception.ExceptionRecord.ExceptionCode = EXCEPTION_BREAKPOINT;
NotifyEM(&de, hthd, 0, (UINT_PTR)pbp);
return *(DWORD *)abEMReplyBuf;
}
return FALSE;
}
LPTSTR
MHStrdup(
LPCTSTR s
)
{
int l = _tcslen(s);
LPTSTR p = MHAlloc(l + sizeof(TCHAR));
_tcscpy(p, s);
return p;
}
/*** ISTHUNK
*
* PURPOSE:
* Determine if we are in a thunk
*
* INPUT:
* hthd - Handle to thread
* uoffEIP - address to check for a thunk
* lpf - Type of thunk
* lpuoffThunkDest - Where the thunk is going to
*
* OUTPUT:
*
* EXCEPTIONS:
*
* IMPLEMENTATION:
*
****************************************************************************/
BOOL
IsThunk (
HTHDX hthd,
UOFFSET uoffset,
LPINT lpfThunkType,
UOFFSET * lpuoffThunkDest,
LPDWORD lpdwThunkSize
)
{
BYTE rgbBuffer[CB_THUNK_MAX];
DWORD dwLength = CB_THUNK_MAX;
INT ThunkType = THUNK_NONE;
UOFFSET ThunkDest = 0;
DWORD ThunkSize = 0;
BOOL Is = FALSE;
//
// Read until a read succeeds or there's no room left to read
//
if (DbgReadMemory ( hthd->hprc, uoffset, rgbBuffer, dwLength, &dwLength)) {
//
// System or ilink thunks
//
if (FIsDirectJump( rgbBuffer, dwLength, hthd, uoffset, &ThunkDest, &ThunkSize ) ||
FIsIndirectJump( rgbBuffer, dwLength, hthd, uoffset, &ThunkDest, &ThunkSize )
) {
Is = TRUE;
if (IsInSystemDll(ThunkDest)) {
ThunkType = THUNK_SYSTEM;
} else {
ThunkType = THUNK_USER;
}
} else {
//
// Note: it is possible that the offset passed in is NOT the PC
// for the current thread. Some of the thunk checks below
// may require valid registers. The following thunks require
// valid registers to determine the destination address for a
// thunk. If uoffset is NOT the PC, then do not check for
// these thunks. These thunks are actually C++ thunks.
//
if ( PC(hthd) == uoffset &&
( FIsVCallThunk( rgbBuffer, dwLength, hthd, uoffset, &ThunkDest, &ThunkSize ) ||
FIsVTDispAdjustorThunk( rgbBuffer, dwLength, hthd, uoffset, &ThunkDest, &ThunkSize ) ||
FIsAdjustorThunk( rgbBuffer, dwLength, hthd, uoffset, &ThunkDest, &ThunkSize ) )
) {
Is = TRUE;
ThunkType = THUNK_USER;
}
}
}
if (lpuoffThunkDest) {
*lpuoffThunkDest = ThunkDest;
}
if (lpdwThunkSize) {
*lpdwThunkSize = ThunkSize;
}
if (lpfThunkType) {
*lpfThunkType = ThunkType;
}
return Is;
}
#if 0
BOOL
IsPassingException(
HPRCX hprc
)
/*++
Routine Description:
TRUE if there is an exception and we are passing it on to the app. This
routine looks at the exception status of the thread we got the debug event
on. It doesn't make sense to look at any other thread.
Arguments:
Return Value:
--*/
{
HTHDX hthd = HTHDXFromPIDTID (hprc->pid, hprc->lastTidDebugEvent);
return ((hthd->tstate & (ts_first | ts_second)) && !hthd->fExceptionHandled);
}
#endif
int
NumberOfThreadsInProcess(
HPRCX hprc
)
{
int nthrds = 0;
HTHDX hthd;
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
nthrds++;
}
return nthrds;
}
void
SetHandledStateInStoppedThreads(
HPRCX hprc,
BOOL ContinueHandled
)
/*++
Routine Description:
Arguments:
Return Value:
--*/
{
HTHDX hthd;
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
if (hthd->tstate & ts_stopped) {
//
// don't just set this to ContinueHandled;
// it may already be set.
//
if (ContinueHandled) {
hthd->fExceptionHandled = TRUE;
}
}
}
}
HTHDX
FindStoppedThread(
HPRCX hprc
)
{
HTHDX hthd;
for (hthd = hprc->hthdChild; hthd; hthd = hthd->nextSibling) {
if (hthd->tstate & ts_stopped) {
return hthd;
}
}
return NULL;
}
| 22.439077 | 111 | 0.540693 |
9bba9cd015f35457207cc2c41ab6b53749c17a06 | 2,146 | h | C | SGPLibraryCode/modules/sgp_render/opengles2/sgp_OpenGLES2ParticleDynamicBuffer.h | phoenixzz/VoronoiMapGen | 5afd852f8bb0212baba9d849178eb135f62df903 | [
"MIT"
] | 11 | 2017-03-03T03:31:15.000Z | 2019-03-01T17:09:12.000Z | SGPLibraryCode/modules/sgp_render/opengles2/sgp_OpenGLES2ParticleDynamicBuffer.h | phoenixzz/VoronoiMapGen | 5afd852f8bb0212baba9d849178eb135f62df903 | [
"MIT"
] | null | null | null | SGPLibraryCode/modules/sgp_render/opengles2/sgp_OpenGLES2ParticleDynamicBuffer.h | phoenixzz/VoronoiMapGen | 5afd852f8bb0212baba9d849178eb135f62df903 | [
"MIT"
] | 2 | 2017-03-03T03:31:17.000Z | 2021-05-27T21:50:43.000Z | #ifndef __SGP_OPENGLES2PARTICLEDYNAMICBUFFER_HEADER__
#define __SGP_OPENGLES2PARTICLEDYNAMICBUFFER_HEADER__
/**
* A buffer to store particle mesh data to be rendered with SGP OpenGL Engine
*
* The buffer can hold an vertex buffer and one index buffer of 16 bits indices.
* Moreover, it can be used as VBO and store on the GPU side in an optimized way.
*/
class SGP_API OpenGLES2ParticleDynamicBuffer : public SPARK::Buffer
{
friend class OpenGLES2ParticleDynamicBufferCreator;
public:
inline COpenGLES2VertexBufferObject* getVBO() { return m_pVBO; }
void updateMaterial(const SGPParticleMaterial& material);
void initVertexBuffers();
SGPSkin m_MaterialSkin; // Render Material Skin
uint32 m_NumOfParticles;
uint32 m_particleVertexSize;
uint32 m_particleIndexSize;
float m_Thickness;
float m_BlendMode;
uint32 m_NumOfActiveParticles;
private:
COpenGLES2VertexCacheManager *m_pVCManager;
COpenGLES2VertexBufferObject *m_pVBO;
OpenGLES2ParticleDynamicBuffer(COpenGLES2VertexCacheManager *pVCManager, uint32 nbParticles, uint32 particleVertexSize, uint32 particleIndexSize);
OpenGLES2ParticleDynamicBuffer(const OpenGLES2ParticleDynamicBuffer& buffer);
OpenGLES2ParticleDynamicBuffer& operator=(const OpenGLES2ParticleDynamicBuffer& buffer);
virtual ~OpenGLES2ParticleDynamicBuffer();
virtual void swap(int , int ) {}
};
class SGP_API OpenGLES2ParticleDynamicBufferCreator : public SPARK::BufferCreator
{
public:
/**
* Constructor of OpenGLParticleDynamicBufferCreator
* pVCManager : A pointer to the OpenGL VertexCache Manager
* particleVertexSize : the number of vertices per particle
* particleIndexSize : the number of indices per particle
*/
OpenGLES2ParticleDynamicBufferCreator(COpenGLES2VertexCacheManager *pVCManager, uint32 particleVertexSize, uint32 particleIndexSize);
private:
COpenGLES2VertexCacheManager* m_pVCManager;
uint32 particleVertexSize;
uint32 particleIndexSize;
virtual OpenGLES2ParticleDynamicBuffer* createBuffer(int nbParticles, const SPARK::Group& group) const;
};
#endif // __SGP_OPENGLES2PARTICLEDYNAMICBUFFER_HEADER__ | 28.613333 | 147 | 0.808481 |
4b555fece0be3fb891cae9b48c2871e5a7fe58ee | 13,334 | h | C | orly/indy/util/block_vec.h | orlyatomics/orly | d413f999f51a8e553832dab4e3baa7ca68928840 | [
"Apache-2.0"
] | 69 | 2015-01-06T05:12:57.000Z | 2021-11-06T20:34:10.000Z | orly/indy/util/block_vec.h | waderly/orly | 9d7660ea9d07591f8cc6b1b92d8e6c3b8b78eeee | [
"Apache-2.0"
] | 5 | 2015-07-09T02:21:50.000Z | 2021-08-13T11:10:26.000Z | orly/indy/util/block_vec.h | waderly/orly | 9d7660ea9d07591f8cc6b1b92d8e6c3b8b78eeee | [
"Apache-2.0"
] | 15 | 2015-01-23T13:34:05.000Z | 2020-06-15T16:46:50.000Z | /* <orly/indy/util/block_vec.h>
TODO
Copyright 2010-2014 OrlyAtomics, Inc.
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. */
#pragma once
#include <cassert>
#include <iterator>
#include <functional>
#include <map>
#include <sstream>
#include <base/likely.h>
namespace Orly {
namespace Indy {
namespace Util {
/* TODO */
class TBlockVec {
public:
/* TODO */
typedef std::map<size_t, std::pair<size_t, size_t>> TBlockMap;
/* TODO */
class TRandomIterator
: public std::iterator<std::random_access_iterator_tag, size_t> {
protected:
/* TODO */
const TBlockMap *BlockMap;
/* TODO */
TBlockMap::const_iterator Iterator;
/* TODO */
size_t ElementIndex;
public:
/* TODO */
typedef std::random_access_iterator_tag iterator_category;
typedef typename std::iterator<std::random_access_iterator_tag, size_t>::value_type value_type;
typedef typename std::iterator<std::random_access_iterator_tag, size_t>::difference_type difference_type;
typedef typename std::iterator<std::random_access_iterator_tag, size_t>::reference reference;
typedef typename std::iterator<std::random_access_iterator_tag, size_t>::pointer pointer;
/* TODO */
TRandomIterator() : BlockMap(nullptr), ElementIndex(0UL) {}
/* TODO */
inline TRandomIterator(const TRandomIterator &r)
: BlockMap(r.BlockMap), Iterator(r.Iterator), ElementIndex(r.ElementIndex) {}
/* TODO */
inline TRandomIterator(const TBlockMap *block_map, const TBlockMap::const_iterator &it, size_t elem_idx)
: BlockMap(block_map), Iterator(it), ElementIndex(elem_idx) {
if (Iterator != BlockMap->end()) {
Refresh();
} else if (Iterator != BlockMap->begin()) {
--Iterator;
} /* otherwise it's an empty block vec */
}
/* TODO */
inline TRandomIterator &operator=(const TRandomIterator &r) {
BlockMap = r.BlockMap;
Iterator = r.Iterator;
ElementIndex = r.ElementIndex;
Refresh();
return *this;
}
/* TODO */
inline TRandomIterator& operator++() {
++ElementIndex;
Refresh();
return *this;
}
/* TODO */
inline TRandomIterator& operator--() {
--ElementIndex;
Refresh();
return *this;
}
/* TODO */
inline TRandomIterator operator++(int) {
return TRandomIterator(BlockMap, Iterator, ElementIndex++);
}
/* TODO */
inline TRandomIterator operator--(int) {
return TRandomIterator(BlockMap, Iterator, ElementIndex--);
}
/* TODO */
inline TRandomIterator operator+(const difference_type& n) const {
return TRandomIterator(BlockMap, Iterator, ElementIndex + n);
}
/* TODO */
inline TRandomIterator& operator+=(const difference_type& n) {
ElementIndex += n;
Refresh();
return *this;
}
/* TODO */
inline TRandomIterator operator-(const difference_type& n) const {
return TRandomIterator(BlockMap, Iterator, ElementIndex - n);
}
/* TODO */
inline TRandomIterator& operator-=(const difference_type& n) {
ElementIndex -= n;
Refresh();
return *this;
}
/* TODO */
inline size_t operator*() const {
assert(BlockMap);
assert(Iterator != BlockMap->end());
const size_t start_idx = Iterator->first;
const int64_t pos_from_start_idx = static_cast<int64_t>(ElementIndex) - start_idx;
#ifndef NDEBUG
const size_t end_idx = start_idx + Iterator->second.second;
assert(pos_from_start_idx < static_cast<int64_t>(end_idx) && pos_from_start_idx >= 0L);
#endif
return Iterator->second.first + pos_from_start_idx;
}
/* TODO */
inline size_t operator->() const {
return **this;
}
/* TODO */
friend inline bool operator==(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend inline bool operator!=(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend inline bool operator<(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend inline bool operator>(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend inline bool operator<=(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend inline bool operator>=(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend typename TRandomIterator::difference_type operator+(const TRandomIterator &r1, const TRandomIterator &r2);
/* TODO */
friend typename TRandomIterator::difference_type operator-(const TRandomIterator &r1, const TRandomIterator &r2);
private:
/* TODO */
inline void Refresh() {
assert(BlockMap);
assert(Iterator != BlockMap->end());
Start:
const size_t start_idx = Iterator->first;
const size_t end_idx = start_idx + Iterator->second.second;
if (ElementIndex >= end_idx && Iterator != BlockMap->end()) {
/* we need to move forward */
++Iterator;
goto Start;
} else if (ElementIndex < start_idx && Iterator != BlockMap->begin()) {
/* we need to move backward */
--Iterator;
goto Start;
}
assert(Iterator == BlockMap->end() ||
(ElementIndex >= Iterator->first && ElementIndex < (Iterator->first + Iterator->second.second)));
}
}; // TRandomIterator
/* TODO */
TBlockVec() : VecSize(0UL) {}
/* TODO */
~TBlockVec() {}
/* TODO */
inline size_t operator[](size_t pos) const {
assert(this);
assert(pos < VecSize);
auto ub = BlockMap.upper_bound(pos);
assert(ub != BlockMap.begin());
--ub;
assert(ub != BlockMap.end());
const size_t expected_block_offset = pos - ub->first;
assert(ub->second.second > expected_block_offset);
return ub->second.first + expected_block_offset;
}
/* TODO */
inline size_t Front() const {
assert(this);
assert(VecSize > 0UL);
return BlockMap.begin()->second.first;
}
/* TODO */
inline size_t Size() const {
assert(this);
return VecSize;
}
/* TODO */
TRandomIterator begin() const {
assert(this);
return TRandomIterator(&BlockMap, BlockMap.begin(), 0UL);
}
/* TODO */
TRandomIterator end() const {
assert(this);
return TRandomIterator(&BlockMap, BlockMap.end(), VecSize);
}
/* Push back a single block id */
inline void PushBack(size_t block_id) {
assert(this);
if (unlikely(VecSize == 0)) {
BlockMap.emplace(0, std::make_pair(block_id, 1UL));
} else {
assert(BlockMap.size() > 0UL);
auto back = BlockMap.rbegin();
/* back is the last vector index added. If the last block in the sequential allocation is 1 before what we're adding now, we can just add
1 to the count. Otherwise we need to make a new entry. */
if (back->second.first + back->second.second == block_id) {
++back->second.second;
} else {
BlockMap.emplace(VecSize, std::make_pair(block_id, 1UL));
}
}
++VecSize;
}
/* Push back a sequential range */
inline void PushBack(const std::pair<size_t, size_t> &block_range) {
assert(this);
if (unlikely(VecSize == 0)) {
BlockMap.emplace(0, std::make_pair(block_range.first, block_range.second));
} else {
assert(BlockMap.size() > 0UL);
auto back = BlockMap.rbegin();
/* back is the last vector index added. If the last block in the sequential allocation is 1 before what we're adding now, we can just add
n to the count. Otherwise we need to make a new entry. */
if (back->second.first + back->second.second == block_range.first) {
back->second.second += block_range.second;
} else {
BlockMap.emplace(VecSize, std::make_pair(block_range.first, block_range.second));
}
}
VecSize += block_range.second;
}
/* remove the last n elements from the vector */
void Trim(size_t n) {
assert(this);
assert(n <= VecSize);
const size_t pos = VecSize - n;
auto pub = BlockMap.upper_bound(pos);
auto ub = pub;
--ub;
assert(ub != BlockMap.end());
const size_t idx_of_map_entry = ub->first;
if (idx_of_map_entry == pos) {
BlockMap.erase(ub, BlockMap.end());
} else {
assert(pos > idx_of_map_entry);
ub->second.second = pos - idx_of_map_entry;
BlockMap.erase(pub, BlockMap.end());
}
VecSize -= n;
}
/* TODO */
const TBlockMap &GetSeqBlockMap() const {
assert(this);
return BlockMap;
}
/* Call back for each sequential range (block, num seq block) where the index is >= start_index and < end_index */
void ForEachSeqRangeInRange(const std::function<bool (size_t, size_t)> &cb, size_t start_index, size_t end_index) const {
assert(this);
assert(start_index <= end_index);
if (start_index < end_index) {
auto ub = BlockMap.upper_bound(start_index);
assert(ub != BlockMap.begin());
--ub;
assert(ub != BlockMap.end());
const size_t from_block_offset = start_index - ub->first;
assert(ub->second.second > from_block_offset);
size_t left = end_index - start_index;
size_t amt = std::min(left, ub->second.second - from_block_offset);
bool cont = cb(ub->second.first + from_block_offset, amt);
left -= amt;
++ub;
for (; cont && left > 0; ) {
assert(ub != BlockMap.end());
amt = std::min(left, ub->second.second);
cont = cb(ub->second.first, amt);
left -= amt;
++ub;
}
}
}
/* Debug Print facility */
void Print(std::stringstream &ss) const {
assert(this);
for (const auto &it : BlockMap) {
ss << "[" << it.first << "] -> (" << it.second.first << " -> " << it.second.second << ")" << std::endl;
}
}
private:
/* A mapping from the starting index in the vector (of a sequential range) to the pair of (block_id -> num sequential blocks)*/
TBlockMap BlockMap;
/* TODO */
size_t VecSize;
}; // TBlockVec
/* TODO */
inline bool operator==(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex == r2.ElementIndex;
}
/* TODO */
inline bool operator!=(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex != r2.ElementIndex;
}
/* TODO */
inline bool operator<(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex < r2.ElementIndex;
}
/* TODO */
inline bool operator>(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex > r2.ElementIndex;
}
/* TODO */
inline bool operator<=(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex <= r2.ElementIndex;
}
/* TODO */
inline bool operator>=(const TBlockVec::TRandomIterator &r1, const TBlockVec::TRandomIterator &r2) {
return r1.ElementIndex >= r2.ElementIndex;
}
} // Util
} // Indy
} // Orly | 34.102302 | 149 | 0.557597 |
18e4b82fdec83e68b4eb338e499cc40d8787fa36 | 176 | h | C | include/class_size_slave.h | jwlawson/qvmmi | a3e121187751374a218bacdcb22d1aeddd01e623 | [
"Apache-2.0"
] | null | null | null | include/class_size_slave.h | jwlawson/qvmmi | a3e121187751374a218bacdcb22d1aeddd01e623 | [
"Apache-2.0"
] | null | null | null | include/class_size_slave.h | jwlawson/qvmmi | a3e121187751374a218bacdcb22d1aeddd01e623 | [
"Apache-2.0"
] | null | null | null | /*
* class_size_slave.h
*/
#pragma once
#include "slave.h"
namespace qvmmi {
class ClassSizeSlave : public Slave<int> {
protected:
virtual int calc_result();
};
}
| 11 | 43 | 0.664773 |
b5006114c25ff4d79308f5d9cbe2039b5044bda4 | 14,387 | h | C | PreciselyAPIsIOSSDK/Model/PBValidateMailingAddressUSCANAPIOutput.h | PreciselyData/PreciselyAPIsSDK-IOS | 984b18ceaebb68dfe30bcff42e27517b59a9e247 | [
"Apache-2.0"
] | null | null | null | PreciselyAPIsIOSSDK/Model/PBValidateMailingAddressUSCANAPIOutput.h | PreciselyData/PreciselyAPIsSDK-IOS | 984b18ceaebb68dfe30bcff42e27517b59a9e247 | [
"Apache-2.0"
] | null | null | null | PreciselyAPIsIOSSDK/Model/PBValidateMailingAddressUSCANAPIOutput.h | PreciselyData/PreciselyAPIsSDK-IOS | 984b18ceaebb68dfe30bcff42e27517b59a9e247 | [
"Apache-2.0"
] | 1 | 2020-11-28T01:07:25.000Z | 2020-11-28T01:07:25.000Z | #import <Foundation/Foundation.h>
#import "PBObject.h"
/**
* Precisely APIs
* Enhance & enrich your data, applications, business processes, and workflows with rich location, information, and identify APIs.
*
* OpenAPI spec version: 11.8.0
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*
* 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.
*/
#import "PBValidateMailingAddressInputRowUserFields.h"
@protocol PBValidateMailingAddressUSCANAPIOutput
@end
@interface PBValidateMailingAddressUSCANAPIOutput : PBObject
/* These fields are returned, unmodified, in the user_fields section of the response. [optional]
*/
@property(nonatomic) NSArray<PBValidateMailingAddressInputRowUserFields>* userFields;
/* Reports the success or failure of the match attempt. [optional]
*/
@property(nonatomic) NSString* status;
/* Reason for failure, if there is one. [optional]
*/
@property(nonatomic) NSString* statusCode;
/* Specifies the description of the problem, if there is one. [optional]
*/
@property(nonatomic) NSString* statusDescription;
/* Specifies the first line of the validated and standardized address. [optional]
*/
@property(nonatomic) NSString* addressLine1;
/* Specifies the second line of the validated and standardized address. [optional]
*/
@property(nonatomic) NSString* addressLine2;
/* Specifies the validated city name. [optional]
*/
@property(nonatomic) NSString* city;
/* Specifies the validated state or province abbreviation. [optional]
*/
@property(nonatomic) NSString* stateProvince;
/* Specifies the validated ZIP Code or postal code. [optional]
*/
@property(nonatomic) NSString* postalCode;
/* Specifies the country in the format determined by the selection from ISO or UPO or English. [optional]
*/
@property(nonatomic) NSString* country;
/* Specifies the validated firm or company name. [optional]
*/
@property(nonatomic) NSString* firmName;
/* Specifies the formatted address, as it would appear on a physical mail piece. [optional]
*/
@property(nonatomic) NSString* blockAddress;
/* Specifies the 5-digit ZIP Code. [optional]
*/
@property(nonatomic) NSString* postalCodeBase;
/* Specifies the 4-digit add-on part of the ZIP Code. [optional]
*/
@property(nonatomic) NSString* postalCodeAddOn;
/* Specifies input data not used by the address validation process. [optional]
*/
@property(nonatomic) NSString* additionalInputData;
/* Specifies the address component that could not be validated, in case no match is found. [optional]
*/
@property(nonatomic) NSString* couldNotValidate;
/* Specifies the type of address data being returned. [optional]
*/
@property(nonatomic) NSString* addressFormat;
/* Specifies the third line of the validated and standardized address. If the address could not be validated, the third line of the input address without any changes. [optional]
*/
@property(nonatomic) NSString* addressLine3;
/* Specifies the fourth line of the validated and standardized address. If the address could not be validated, the fourth line of the input address without any changes. [optional]
*/
@property(nonatomic) NSString* addressLine4;
/* Specifies the result codes that apply to international addresses only. [optional]
*/
@property(nonatomic) NSString* addressRecordResult;
/* Specifies the apartment designator such as STE or APT. [optional]
*/
@property(nonatomic) NSString* apartmentLabel;
/* Specifies the apartment designator such as STE or APT. [optional]
*/
@property(nonatomic) NSString* apartmentLabelInput;
/* Specifies the result of apartment label. [optional]
*/
@property(nonatomic) NSString* apartmentLabelResult;
/* Specifies the apartment number. [optional]
*/
@property(nonatomic) NSString* apartmentNumber;
/* Specifies the apartment number. [optional]
*/
@property(nonatomic) NSString* apartmentNumberInput;
/* Specifies the result of apartment number. [optional]
*/
@property(nonatomic) NSString* apartmentNumberResult;
/* Specifies the validated city name. [optional]
*/
@property(nonatomic) NSString* cityInput;
/* Specifies the result of the validated city name. [optional]
*/
@property(nonatomic) NSString* cityResult;
/* Specifies the the level of confidence assigned to the address being returned. [optional]
*/
@property(nonatomic) NSString* confidence;
/* Specifies the name of the country. [optional]
*/
@property(nonatomic) NSString* countryInput;
/* Specifies the result code for the country. [optional]
*/
@property(nonatomic) NSString* countryResult;
/* Specifies the category of address matching available. [optional]
*/
@property(nonatomic) NSString* countryLevel;
/* Specifies the validated firm or company name. [optional]
*/
@property(nonatomic) NSString* firmNameInput;
/* Specifies if the firm name got validated. [optional]
*/
@property(nonatomic) NSString* firmNameResult;
/* Specifies the house number. [optional]
*/
@property(nonatomic) NSString* houseNumber;
/* Specifies the house number. [optional]
*/
@property(nonatomic) NSString* houseNumberInput;
/* Specifies the result for house number. [optional]
*/
@property(nonatomic) NSString* houseNumberResult;
/* Specifies the leading directional. [optional]
*/
@property(nonatomic) NSString* leadingDirectional;
/* Specifies the leading directional. [optional]
*/
@property(nonatomic) NSString* leadingDirectionalInput;
/* Specifies the result of leading directional. [optional]
*/
@property(nonatomic) NSString* leadingDirectionalResult;
/* Specifies the address component with multiple matches, if multiple matches were found: [optional]
*/
@property(nonatomic) NSString* multipleMatches;
/* Specifies the post office box number. [optional]
*/
@property(nonatomic) NSString* pOBox;
/* Specifies the post office box number. [optional]
*/
@property(nonatomic) NSString* pOBoxInput;
/* Specifies the result of post office box number. [optional]
*/
@property(nonatomic) NSString* pOBoxResult;
/* Specifies the validated postal code. For U.S. addresses, this is the ZIP code. [optional]
*/
@property(nonatomic) NSString* postalCodeInput;
/* Specifies the result of validated postal code. [optional]
*/
@property(nonatomic) NSString* postalCodeResult;
/* Specifies the result code. [optional]
*/
@property(nonatomic) NSString* postalCodeSource;
/* Specifies the type of postal code returned. [optional]
*/
@property(nonatomic) NSString* postalCodeType;
/* Specifies the international result code. [optional]
*/
@property(nonatomic) NSString* postalCodeCityResult;
/* Specifies the private mailbox indicator. [optional]
*/
@property(nonatomic) NSString* privateMailbox;
/* Specifies the private mailbox indicator. [optional]
*/
@property(nonatomic) NSString* privateMailboxInput;
/* Specifies the type of private mailbox. [optional]
*/
@property(nonatomic) NSString* privateMailboxType;
/* Specifies the type of private mailbox. [optional]
*/
@property(nonatomic) NSString* privateMailboxTypeInput;
/* Specifies the type of address record, as defined by U.S. and Canadian postal authorities. [optional]
*/
@property(nonatomic) NSString* recordType;
/* Specifies the code indicating the default match. [optional]
*/
@property(nonatomic) NSString* recordTypeDefault;
/* Specifies the Rural Route/Highway Contract indicator. [optional]
*/
@property(nonatomic) NSString* rRHC;
/* Specifies the Rural Route/Highway Contract indicator. [optional]
*/
@property(nonatomic) NSString* rRHCInput;
/* Specifies the result for Rural Route/Highway Contract indicator. [optional]
*/
@property(nonatomic) NSString* rRHCResult;
/* Specifies the result code for Rural Route/Highway Contract indicator. [optional]
*/
@property(nonatomic) NSString* rRHCType;
/* Specifies the validated state or province abbreviation. [optional]
*/
@property(nonatomic) NSString* stateProvinceInput;
/* Specifies the result of validated state or province abbreviation. [optional]
*/
@property(nonatomic) NSString* stateProvinceResult;
/* Specifies the result codes for international addresses. [optional]
*/
@property(nonatomic) NSString* streetResult;
/* Specifies the street name. [optional]
*/
@property(nonatomic) NSString* streetName;
/* Specifies result code that applies to U.S. addresses only. [optional]
*/
@property(nonatomic) NSString* streetNameAliasType;
/* Specifies the street name. [optional]
*/
@property(nonatomic) NSString* streetNameInput;
/* Specifies the result of the street name. [optional]
*/
@property(nonatomic) NSString* streetNameResult;
/* Indicates the result of abbreviated alias processing. [optional]
*/
@property(nonatomic) NSString* streetNameAbbreviatedAliasResult;
/* Specifies the result of preferred alias processing. [optional]
*/
@property(nonatomic) NSString* streetNamePreferredAliasResult;
/* Specifies the street suffix. [optional]
*/
@property(nonatomic) NSString* streetSuffix;
/* Specifies the street suffix. [optional]
*/
@property(nonatomic) NSString* streetSuffixInput;
/* Specifies the result of the street suffix. [optional]
*/
@property(nonatomic) NSString* streetSuffixResult;
/* Specifies the trailing directional. [optional]
*/
@property(nonatomic) NSString* trailingDirectional;
/* Specifies the trailing directional. [optional]
*/
@property(nonatomic) NSString* trailingDirectionalInput;
/* Specifies the result of the trailing directional. [optional]
*/
@property(nonatomic) NSString* trailingDirectionalResult;
/* Specifies an indication of the degree to which the output address is correct. [optional]
*/
@property(nonatomic) NSString* matchScore;
/* Specifies whether the address is a candidate for LACS conversion. This is for U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSLACS;
/* Specifies the the success or failure of LACS processing. This is for U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSLACSReturnCode;
/* Specifies the values indicating address type. [optional]
*/
@property(nonatomic) NSString* rDI;
/* Specifies if the address is a Commercial Mail Receiving Agency (CMRA). [optional]
*/
@property(nonatomic) NSString* cMRA;
/* Specifies the results of Delivery Point Validation (DPV) processing. [optional]
*/
@property(nonatomic) NSString* dPV;
/* Specifies the DPV footnote codes. [optional]
*/
@property(nonatomic) NSString* dPVFootnote;
/* Indicates whether or not API corrected the secondary address information (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* suiteLinkReturnCode;
/* Provides additional information on the SuiteLink match attempt. (U.S. addresses only) [optional]
*/
@property(nonatomic) NSString* suiteLinkMatchCode;
/* Indicates how well ValidateAddress matched the firm name to the firm names in the SuiteLink database. [optional]
*/
@property(nonatomic) NSString* suiteLinkFidelity;
/* Specifies the check-digit portion of the 11-digit delivery point barcode. [optional]
*/
@property(nonatomic) NSString* uSBCCheckDigit;
/* Specifies the delivery point portion of the delivery point barcode. [optional]
*/
@property(nonatomic) NSString* postalBarCode;
/* Specifies carrier route code. [optional]
*/
@property(nonatomic) NSString* uSCarrierRouteCode;
/* Specifies FIPS (Federal Information Processing Standards) county number (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSFIPSCountyNumber;
/* Specifies the county name (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSCountyName;
/* Specifies congressional district (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSCongressionalDistrict;
/* Specifies whether the alternate address matching logic was used, and if so which logic was used (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSAltAddr;
/* Specifies a six-character alphanumeric value that groups together ZIP Codes that share the same primary city. [optional]
*/
@property(nonatomic) NSString* uSLastLineNumber;
/* Specifies the finance number in which the address resides (U.S. addresses only). [optional]
*/
@property(nonatomic) NSString* uSFinanceNumber;
/* U.S. address urbanization name. Used primarily for Puerto Rico addresses. [optional]
*/
@property(nonatomic) NSString* uSUrbanName;
/* U.S. address urbanization name. Used primarily for Puerto Rico addresses. [optional]
*/
@property(nonatomic) NSString* uSUrbanNameInput;
/* U.S. address urbanization name. Used primarily for Puerto Rico addresses. [optional]
*/
@property(nonatomic) NSString* uSUrbanNameResult;
/* If the address was matched to multiple candidate addresses in the reference data, this field contains the number of candidate matches found. [optional]
*/
@property(nonatomic) NSString* multimatchCount;
/* AddressBlock1 [optional]
*/
@property(nonatomic) NSString* addressBlock1;
/* AddressBlock2 [optional]
*/
@property(nonatomic) NSString* addressBlock2;
/* AddressBlock3 [optional]
*/
@property(nonatomic) NSString* addressBlock3;
/* AddressBlock4 [optional]
*/
@property(nonatomic) NSString* addressBlock4;
/* AddressBlock5 [optional]
*/
@property(nonatomic) NSString* addressBlock5;
/* AddressBlock6 [optional]
*/
@property(nonatomic) NSString* addressBlock6;
/* AddressBlock7 [optional]
*/
@property(nonatomic) NSString* addressBlock7;
/* AddressBlock8 [optional]
*/
@property(nonatomic) NSString* addressBlock8;
/* AddressBlock9 [optional]
*/
@property(nonatomic) NSString* addressBlock9;
/* Specifies whether the address is in English or French. This is for Canadian address only. [optional]
*/
@property(nonatomic) NSString* canLanguage;
/* Specifies whether the building is a no stat building and therefore unable to receive mail. [optional]
*/
@property(nonatomic) NSString* dPVNoStat;
/* Specifies whether the building is vacant, unoccupied for 90 days. [optional]
*/
@property(nonatomic) NSString* dPVVacant;
@end
| 39.416438 | 179 | 0.770626 |
e46de83f9fa28a7ece8ce42c1e830b27c59db1de | 268 | c | C | Books/Teach-YourSelf-C.Herbert-Schildt/chapter-10/Examples/e08-passes-a-structure-to-a-function-a7.c | shihab4t/Competitive-Programming | e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be | [
"Unlicense"
] | 3 | 2021-06-15T01:19:23.000Z | 2022-03-16T18:23:53.000Z | Books/Teach-YourSelf-C.Herbert-Schildt/chapter-10/Examples/e08-passes-a-structure-to-a-function-a7.c | shihab4t/Competitive-Programming | e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be | [
"Unlicense"
] | null | null | null | Books/Teach-YourSelf-C.Herbert-Schildt/chapter-10/Examples/e08-passes-a-structure-to-a-function-a7.c | shihab4t/Competitive-Programming | e8eec7d4f7d86bfa1c00b7fbbedfd6a1518f19be | [
"Unlicense"
] | null | null | null | #include <stdio.h>
struct s_type {
int i; double d;
};
void f(struct s_type temp);
int main(void)
{
struct s_type var1;
var1.i = 99;
var1.d = 98.6;
f(var1);
return 0;
}
void f(struct s_type temp) {
printf("%d %f\n", temp.i, temp.d);
} | 12.181818 | 38 | 0.563433 |
e4ae9d4bacbed6210d9f962e68204012a04e03a6 | 552 | h | C | chrone_multithreading/chrone_multithreading/include/scheduler/ThreadFiberData.h | Eszrah/chrone-multithreading | 0e4b38500db5ad946b71bad2707ecf59ed70acea | [
"Unlicense"
] | null | null | null | chrone_multithreading/chrone_multithreading/include/scheduler/ThreadFiberData.h | Eszrah/chrone-multithreading | 0e4b38500db5ad946b71bad2707ecf59ed70acea | [
"Unlicense"
] | null | null | null | chrone_multithreading/chrone_multithreading/include/scheduler/ThreadFiberData.h | Eszrah/chrone-multithreading | 0e4b38500db5ad946b71bad2707ecf59ed70acea | [
"Unlicense"
] | null | null | null | #pragma once
namespace chrone::multithreading::fiberScheduler
{
struct Fiber;
struct Semaphore;
struct ThreadFiberData
{
ThreadFiberData() = default;
ThreadFiberData(const ThreadFiberData&) = default;
ThreadFiberData(ThreadFiberData&&) = default;
~ThreadFiberData() = default;
ThreadFiberData& operator=(const ThreadFiberData&) = default;
ThreadFiberData& operator=(ThreadFiberData&&) = default;
Fiber* syncSrcFiber{ nullptr };
Semaphore* syncSemaphore{ nullptr };
Fiber* previousFiber{ nullptr };
Fiber* currentFiber{ nullptr };
};
}
| 21.230769 | 62 | 0.76087 |
9d33386fb68499c5590d6e4f69d7057f5fe1e8ff | 617 | c | C | libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c | alexcrichton/wasi-libc | 215adc8ac9f91eb055311acc72683fd2eb1ae15a | [
"Apache-2.0",
"MIT"
] | 1 | 2020-01-27T21:56:09.000Z | 2020-01-27T21:56:09.000Z | libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c | alexcrichton/wasi-libc | 215adc8ac9f91eb055311acc72683fd2eb1ae15a | [
"Apache-2.0",
"MIT"
] | 1 | 2020-10-07T15:13:20.000Z | 2020-10-07T15:13:20.000Z | libc-bottom-half/cloudlibc/src/libc/sys/time/gettimeofday.c | alexcrichton/wasi-libc | 215adc8ac9f91eb055311acc72683fd2eb1ae15a | [
"Apache-2.0",
"MIT"
] | 2 | 2021-06-28T12:31:21.000Z | 2021-09-17T17:01:41.000Z | // Copyright (c) 2015-2016 Nuxi, https://nuxi.nl/
//
// SPDX-License-Identifier: BSD-2-Clause
#include <common/time.h>
#include <sys/time.h>
#include <wasi/api.h>
#ifdef __wasilibc_unmodified_upstream
int gettimeofday(struct timeval *restrict tp, ...) {
#else
int gettimeofday(struct timeval *restrict tp, void *tz) {
#endif
__wasi_timestamp_t ts = 0;
#ifdef __wasilibc_unmodified_upstream // generated constant names
(void)__wasi_clock_time_get(__WASI_CLOCK_REALTIME, 1000, &ts);
#else
(void)__wasi_clock_time_get(__WASI_CLOCKID_REALTIME, 1000, &ts);
#endif
*tp = timestamp_to_timeval(ts);
return 0;
}
| 24.68 | 66 | 0.748784 |
4ffe7116908a2dcf04fbc0632590bf5136e29da8 | 16,767 | h | C | zetasql/base/arena_allocator.h | yarri-oss/zetasql | c2240edf7f20df40c1c810b520b5a3aab9626a97 | [
"Apache-2.0"
] | null | null | null | zetasql/base/arena_allocator.h | yarri-oss/zetasql | c2240edf7f20df40c1c810b520b5a3aab9626a97 | [
"Apache-2.0"
] | null | null | null | zetasql/base/arena_allocator.h | yarri-oss/zetasql | c2240edf7f20df40c1c810b520b5a3aab9626a97 | [
"Apache-2.0"
] | null | null | null | //
// Copyright 2018 Google LLC
//
// 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.
//
#ifndef THIRD_PARTY_ZETASQL_ZETASQL_BASE_ARENA_ALLOCATOR_H_
#define THIRD_PARTY_ZETASQL_ZETASQL_BASE_ARENA_ALLOCATOR_H_
// In this file we define the arena template code. This includes the
// ArenaAllocator, which is meant only to be used with STL, and also
// the Gladiator (which needs to know how to new and delete various
// types of objects).
//
// If you're only using the MALLOC-LIKE functionality of the arena,
// you don't need to include this file at all! You do need to include
// it (in your own .cc file) if you want to use the STRING, STL, or
// NEW aspects of the arena. See arena.h for details on these types.
//
// ArenaAllocator is an STL allocator, but because it relies on unequal
// instances, it may not work with all standards-conforming STL
// implementations. But it works with SGI STL so we're happy.
//
// Here's an example of how the ArenaAllocator would be used.
// Say we have a vector of ints that we want to have use the arena
// for memory allocation. Here's one way to do it:
// UnsafeArena* arena = new UnsafeArena(1024); // or SafeArena
// std::vector<int, ArenaAllocator<int, UnsafeArena> > v(arena);
//
// Note that every STL type always allows the allocator (in this case,
// the arena, which is automatically promoted to an allocator) as the last
// arg to the constructor. So if you would normally do
// std::vector<...> v(foo, bar),
// with the arena you can do
// std::vector<...> v(foo, bar, arena);
#include <assert.h>
#include <stddef.h>
#include <limits>
#include <memory>
#include <new>
#include <type_traits>
#include <utility>
#include "absl/base/macros.h"
#include "zetasql/base/arena.h"
#include "zetasql/base/logging.h"
namespace zetasql_base {
// T is the type we want to allocate, and C is the type of the arena.
// ArenaAllocator has the thread-safety characteristics of C.
template <class T, class C> class ArenaAllocator {
public:
typedef T value_type;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
// These are required for gcc-4.7 / crosstoolv16 to match default behavior
// of gcc-4.6, so e.g.
// Arena a1, a2;
// astring s1(&a1), s2(&a2);
// s1.swap(s2); // s1 should now use a2, s2 should now use a1.
// s2 = s1; // s2 should now use a2, s1 should still use a2.
typedef std::true_type propagate_on_container_copy_assignment;
typedef std::true_type propagate_on_container_move_assignment;
typedef std::true_type propagate_on_container_swap;
typedef T* pointer;
typedef const T* const_pointer;
typedef T& reference;
typedef const T& const_reference;
typedef std::false_type is_always_equal;
size_type max_size() const {
return size_t(std::numeric_limits<size_type>::max()) / sizeof(value_type);
}
pointer address(reference x) const noexcept {
return std::addressof(x);
}
const_pointer address(const_reference x) const noexcept {
return std::addressof(x);
}
template <class U, class... Args>
void construct(U* u, Args&&... args) {
new(static_cast<void*>(u)) U(std::forward<Args>(args)...);
}
template <class U>
void destroy(U* u) { u->~U(); }
// This is not an explicit constructor! So you can pass in an arena*
// to functions needing an ArenaAllocator (like the astring constructor)
// and everything will work ok.
ArenaAllocator(C* arena) : arena_(arena) { } // NOLINT
pointer allocate(size_type n,
std::allocator<void>::const_pointer /*hint*/ = nullptr) {
assert(arena_ && "No arena to allocate from!");
return reinterpret_cast<T*>(arena_->AllocAligned(n * sizeof(T),
kAlignment));
}
void deallocate(pointer p, size_type n) {
arena_->Free(p, n * sizeof(T));
}
C* arena() const { return arena_; }
template<class U> struct rebind {
typedef ArenaAllocator<U, C> other;
};
template<class U> ArenaAllocator(const ArenaAllocator<U, C>& other)
: arena_(other.arena()) { }
template<class U> bool operator==(const ArenaAllocator<U, C>& other) const {
return arena_ == other.arena();
}
template<class U> bool operator!=(const ArenaAllocator<U, C>& other) const {
return arena_ != other.arena();
}
protected:
static const int kAlignment;
C* arena_;
};
template <class T, class C>
const int ArenaAllocator<T, C>::kAlignment = alignof(T);
// Ordinarily in C++, one allocates all instances of a class from an
// arena. If that's what you want to do, you don't need Gladiator.
// (However you may find ArenaOnlyGladiator useful.)
//
// However, for utility classes that are used by multiple clients, the
// everything-in-one-arena model may not work. Some clients may wish
// not to use an arena at all. Or perhaps a composite structure
// (tree) will contain multiple objects (nodes) and some of those
// objects will be created by a factory, using an arena, while other
// objects will be created on-the-fly by an unsuspecting user who
// doesn't know anything about the arena.
//
// To support that, have the arena-allocated class inherit from
// Gladiator. The ordinary operator new will continue to allocate
// from the heap. To allocate from an arena, do
// Myclass * m = new (AllocateInArena, a) Myclass (args, to, constructor);
// where a is either an arena or an allocator. Now you can call
// delete on all the objects, whether they are allocated from an arena
// or on the heap. Heap memory will be released, while arena memory will
// not be.
//
// If a client knows that no objects were allocated on the heap, it
// need not delete any objects (but it may if it wishes). The only
// objects that must be deleted are those that were actually allocated
// from the heap.
//
// NOTE: an exception to the google C++ style guide rule for "No multiple
// implementation inheritance" is granted for this class: you can treat this
// class as an "Interface" class, and use it in a multiple inheritance context,
// even though it implements operator new/delete.
class Gladiator {
public:
Gladiator() { }
virtual ~Gladiator() { }
// We do not override the array allocators, so array allocation and
// deallocation will always be from the heap. Typically, arrays are
// larger, and thus the costs of arena allocation are higher and the
// benefits smaller. Since arrays are typically allocated and deallocated
// very differently from scalars, this may not interfere too much with
// the arena concept. If it does pose a problem, flesh out the
// ArrayGladiator class below.
void* operator new(const size_t size) {
void* ret = ::operator new(1 + size);
static_cast<char *>(ret)[size] = 1; // mark as heap-allocated
return ret;
}
// the ignored parameter keeps us from stepping on placement new
template<class T> void* operator new(const size_t size, const int ignored,
T* allocator) {
if (allocator) {
void* ret = allocator->AllocAligned(1 + size,
BaseArena::kDefaultAlignment);
static_cast<char*>(ret)[size] = 0; // mark as arena-allocated
return ret;
} else {
return operator new(size); // this is the function above
}
}
void operator delete(void* memory, const size_t size) {
if (static_cast<char*>(memory)[size]) {
assert (1 == static_cast<char *>(memory)[size]);
::operator delete(memory);
} else {
// We never call the allocator's Free method. If we need to do
// that someday, we can store a pointer to the arena instead of
// the Boolean marker flag.
}
}
template<class T> void operator delete(void* memory, const size_t size,
const int ign, T* allocator) {
// This "placement delete" can only be called if the constructor
// throws an exception.
if (allocator) {
allocator->Free(memory, 1 + size);
} else {
::operator delete(memory);
}
}
private:
virtual void UnusedKeyMethod(); // Dummy key method to avoid weak vtable.
};
// ArenaOnlyGladiator is a base class of types intended to be allocated only in
// arenas. It enables allocation with zetasql_base::NewInArea and prevents accidental
// use of the global operator new and delete with derived types.
//
// Brief example (see documentation for zetasql_base::NewInArena / zetasql_base::DeleteInArena
// for full details):
//
// class MyType : public ArenaOnlyGladiator {
// // ...
// };
//
// UnsafeArena arena(1024);
// MyType* t1 = zetasql_base::NewInArena<MyType>(&arena);
//
// MyType* t2 = new MyType(); // ERROR
//
class ArenaOnlyGladiator {
public:
ArenaOnlyGladiator() { }
// No virtual destructor is needed because we ignore the size
// parameter in all the delete functions.
// virtual ~ArenaOnlyGladiator() { }
void* operator new(size_t) = delete;
void* operator new[](size_t) = delete;
// the ignored parameter keeps us from stepping on placement new
template <class T>
ABSL_DEPRECATED("use zetasql_base::NewInArena from base/arena_allocator.h instead")
void* operator new(const size_t size, const int ignored, T* allocator) {
assert(allocator);
return allocator->AllocAligned(size, BaseArena::kDefaultAlignment);
}
void operator delete(void* /*memory*/, const size_t /*size*/) {}
template <class T>
ABSL_DEPRECATED("use zetasql_base::DeleteInArena from base/arena_allocator.h instead")
void operator delete(void* memory, const size_t size, const int ign,
T* allocator) {}
void operator delete[](void* /*memory*/) {}
template <class T>
ABSL_DEPRECATED("use zetasql_base::DeleteInArena from base/arena_allocator.h instead")
void operator delete(void* memory, const int ign, T* allocator) {}
};
#if 0 // ********** for example purposes only; 100% untested.
// Note that this implementation incurs an overhead of kHeaderSize for
// every array that is allocated. *Before* the space is returned to the
// user, we store the address of the Arena that owns the space, and
// the length of th space itself.
class ArrayGladiator : public Gladiator {
public:
void * operator new[] (const size_t size) {
const int sizeplus = size + kHeaderSize;
void * const ret = ::operator new(sizeplus);
*static_cast<Arena **>(ret) = nullptr; // mark as heap-allocated
*static_cast<size_t *>(ret + sizeof(Arena *)) = sizeplus;
return ret + kHeaderSize;
}
// the ignored parameter keeps us from stepping on placement new
template<class T> void * operator new[] (const size_t size,
const int ignored, T * allocator) {
if (allocator) {
const int sizeplus = size + kHeaderSize;
void * const ret =
allocator->AllocAligned(sizeplus, BaseArena::kDefaultAlignment);
*static_cast<Arena **>(ret) = allocator->arena();
*static_cast<size_t *>(ret + sizeof(Arena *)) = sizeplus;
return ret + kHeaderSize;
} else {
return operator new[](size); // this is the function above
}
}
void operator delete [] (void * memory) {
memory -= kHeaderSize;
Arena * const arena = *static_cast<Arena **>(memory);
const size_t sizeplus = *static_cast<size_t *>(memory + sizeof(arena));
if (arena) {
arena->SlowFree(memory, sizeplus);
} else {
::operator delete (memory);
}
}
template<class T> void * operator delete (void * memory,
const int ign, T * allocator) {
// This "placement delete" can only be called if the constructor
// throws an exception.
memory -= kHeaderSize;
const size_t sizeplus = *static_cast<size_t *>(memory + sizeof(Arena *));
if (allocator) {
allocator->Free(memory, 1 + size);
} else {
operator delete (memory);
}
}
protected:
static const int kMinSize = sizeof size_t + sizeof(Arena *);
static const int kHeaderSize = kMinSize > BaseArena::kDefaultAlignment ?
2 * BaseArena::kDefaultAlignment : BaseArena::kDefaultAlignment;
};
#endif // ********** example
// NewInArena<T>, DeleteInArena<T>: functions for constructing and destroying
// C++ objects inside an Arena. This is useful when doing one-time allocations,
// instead of having to create a persisting ArenaAllocator for each desired
// type. It is also safer and less verbose than dealing with the C-style
// interface of Arena directly.
//
// NewInArena<T> properly supports over-aligned types. These are types with
// alignment requirement greater than that of any fundamental type
// (i.e. alignof(std::max_align_t)). These types can occur as either platform
// specific extension types or as user types defined with an alignas specifier.
//
// NewInArena<T> is a drop-in replacement for the `AllocateInArena` operator
// new overloads that are defined below and as part of `ArenaOnlyGladiator`
// above. It is *not* a replacement for the operator new overloads in
// `Gladiator`, and using the function in this way will result in compile-time
// error.
//
// Example allocation:
//
// struct MyType {
// MyType();
// MyType(int, int);
// };
//
// UnsafeArena arena(1024);
// MyType* p = zetasql_base::NewInArena<MyType>(&arena, 5, 3);
// MyType* q = zetasql_base::NewInArena<MyType[]>(&arena, 10);
//
// When finished, you must destroy the objects and return memory as follows:
//
// zetasql_base::DeleteInArena(&arena, p);
// zetasql_base::DeleteInArena(&arena, q, 10);
//
// NOTE: there are current uses of the `AllocateInArena` operator new that
// do not call delete. These uses rely on Arena::Reset() or ~Arena() to return
// memory, because the types in question have trivial destructors or do not
// perform resource management. Such uses should be updated to use
// DeleteInArena<T> for safety against undefined behavior.
template <typename T, typename ArenaType, typename... Args,
std::enable_if_t<!std::is_array<T>::value>* = nullptr>
// NOLINTNEXTLINE - suppress ClangTidy raw pointer return.
T* NewInArena(ArenaType* arena, Args&&... args) {
static_assert(!std::is_base_of<Gladiator, T>::value,
"Allocating an object with type inheriting from Gladiator is "
"not supported by NewInArena.");
return ::new (static_cast<void*>(arena->AllocAligned(sizeof(T), alignof(T))))
T(std::forward<Args>(args)...);
}
template <typename T, typename ArenaType,
std::enable_if_t<std::is_array<T>::value &&
std::extent<T>::value == 0>* = nullptr>
// NOLINTNEXTLINE - suppress ClangTidy raw pointer return.
std::remove_extent_t<T>* NewInArena(ArenaType* arena, size_t n) {
static_assert(!std::is_base_of<Gladiator, T>::value,
"Allocating an object with type inheriting from Gladiator is "
"not supported by NewInArena.");
using U = std::remove_extent_t<T>;
U* p = static_cast<U*>(arena->AllocAligned(n * sizeof(U), alignof(U)));
for (size_t i = 0; i < n; ++i) ::new (static_cast<void*>(p + i)) U;
return p;
}
template <typename T, typename... Args,
std::enable_if_t<std::is_array<T>::value &&
std::extent<T>::value != 0>* = nullptr>
// NOLINTNEXTLINE - suppress ClangTidy raw pointer return.
T* NewInArena(Args&&... args) = delete;
template <typename ArenaType, typename T>
void DeleteInArena(ArenaType* arena, T* t) {
static_assert(!std::is_base_of<Gladiator, T>::value,
"Destroying an object with type inheriting from Gladiator is "
"not supported by DeleteInArena.");
t->~T();
arena->Free(t, sizeof(T));
}
template <typename ArenaType, typename T>
void DeleteInArena(ArenaType* arena, T* t, size_t n) {
static_assert(!std::is_base_of<Gladiator, T>::value,
"Destroying an object with type inheriting from Gladiator is "
"not supported by DeleteInArena.");
for (size_t i = 0; i < n; ++i) (t + i)->~T();
arena->Free(t, n * sizeof(T));
}
enum AllocateInArenaType { AllocateInArena };
} // namespace zetasql_base
#endif // THIRD_PARTY_ZETASQL_ZETASQL_BASE_ARENA_ALLOCATOR_H_
| 38.722864 | 94 | 0.680324 |
8b285c9fbb10f8018355613b15e085a0a03a5a72 | 7,002 | c | C | qmk_firmware/layouts/community/60_ansi_arrow_split_bs_7u_spc/mrsendyyk/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | 2 | 2021-04-16T23:29:01.000Z | 2021-04-17T02:26:22.000Z | qmk_firmware/layouts/community/60_ansi_arrow_split_bs_7u_spc/mrsendyyk/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | null | null | null | qmk_firmware/layouts/community/60_ansi_arrow_split_bs_7u_spc/mrsendyyk/keymap.c | DanTupi/personal_setup | 911b4951e4d8b78d6ea8ca335229e2e970fda871 | [
"MIT"
] | null | null | null | /*
* 60 ANSI Arrow Split Backspace & 7U Space Keymap
* with RGB Lighting/LED/Underglow as Caps Lock, Num Lock, Scroll Lock, and Layer Indicator.
*
* Copyright (C) 2020 Sendy YK <https://mr.sendyyk.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
#include QMK_KEYBOARD_H
enum layer_names {
_BASE, // Base Layer
_FN, // Fn Layer
_RESET // Reset Layer
};
const uint16_t PROGMEM keymaps[][MATRIX_ROWS][MATRIX_COLS] = {
/*
* [_BASE] Base Layer
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
* │Esc│1 │2 │3 │4 │5 │6 │7 │8 │9 │0 │- │+ │\ │Del│
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤
* │Tab │Q │W │E │R │T │Y │U │I │O │P │[ │] │Bspc │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤
* │Caps │A │S │D │F │G │H │J │K │L │; │' │Return │
* ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴┬───┬───┤
* │Shift │Z │X │C │V │B │N │M │, │. │Shift │↑ │/ │
* ├─────┬──┴┬──┴──┬┴───┴───┴───┴───┴───┴───┴──┬┴──┬───┼───┼───┤
* │Ctrl │OS │Alt │Space │Fn │← │↓ │→ │
* └─────┴───┴─────┴───────────────────────────┴───┴───┴───┴───┘
*/
[_BASE] = LAYOUT_60_ansi_arrow_split_bs_7u_spc(
KC_GESC, KC_1, KC_2, KC_3, KC_4, KC_5, KC_6, KC_7, KC_8, KC_9, KC_0, KC_MINS, KC_EQL, KC_BSLS, KC_DEL,
KC_TAB, KC_Q, KC_W, KC_E, KC_R, KC_T, KC_Y, KC_U, KC_I, KC_O, KC_P, KC_LBRC, KC_RBRC, KC_BSPC,
KC_CAPS, KC_A, KC_S, KC_D, KC_F, KC_G, KC_H, KC_J, KC_K, KC_L, KC_SCLN, KC_QUOT, KC_ENT,
KC_LSFT, KC_Z, KC_X, KC_C, KC_V, KC_B, KC_N, KC_M, KC_COMM, KC_DOT, KC_RSFT, KC_UP, KC_SLSH,
KC_LCTL, KC_LGUI, KC_LALT, KC_SPC, MO(_FN), KC_LEFT, KC_DOWN, KC_RGHT
),
/*
* [_FN] Fn Layer
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
* │` │F1 │F2 │F3 │F4 │F5 │F6 │F7 │F8 │F9 │F10│F11│F12│ │Ejc│
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤
* │ │ │ │End│RGB│ │ │ │Ins│ │PSc│ │ │Mute │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤
* │ │ │SLc│ │ │ │Hm │ │ │ │ │ │Pause │
* ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴┬───┬───┤
* │Vol + │ │ │Cal│ │BLT│NLc│Ml │ │ │ │PgU│MSt│
* ├─────┬──┴┬──┴──┬┴───┴───┴───┴───┴───┴───┴──┬┴──┬───┼───┼───┤
* │Vol -│Rwd│FFd │Play │ │Prv│PgD│Nxt│
* └─────┴───┴─────┴───────────────────────────┴───┴───┴───┴───┘
*/
[_FN] = LAYOUT_60_ansi_arrow_split_bs_7u_spc(
KC_GRV, KC_F1, KC_F2, KC_F3, KC_F4, KC_F5, KC_F6, KC_F7, KC_F8, KC_F9, KC_F10, KC_F11, KC_F12, _______, KC_EJCT,
_______, _______, _______, KC_END, RGB_TOG, _______, _______, _______, KC_INS, _______, KC_PSCR, _______, _______, KC_MUTE,
_______, _______, KC_SLCK, _______, _______, _______, KC_HOME, _______, _______, _______, _______, _______, KC_PAUS,
KC_VOLU, _______, _______, KC_CALC, _______, BL_TOGG, KC_NLCK, KC_MAIL, _______, _______, MO(_RESET), KC_PGUP, KC_MSTP,
KC_VOLD, KC_MRWD, KC_MFFD, KC_MPLY, _______, KC_MPRV, KC_PGDN, KC_MNXT
),
/*
* [_RESET] Reset Layer
* ┌───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┬───┐
* │ │ │ │ │ │ │ │ │ │ │ │ │ │ │ │
* ├───┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┤
* │ │ │ │ │Rst│ │ │ │ │ │ │ │ │ │
* ├─────┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴┬──┴─────┤
* │ │ │ │ │ │ │ │ │ │ │ │ │ │
* ├──────┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴─┬─┴───┴┬───┬───┤
* │ │ │ │ │ │ │ │ │ │ │ │ │ │
* ├─────┬──┴┬──┴──┬┴───┴───┴───┴───┴───┴───┴──┬┴──┬───┼───┼───┤
* │ │ │ │ │ │ │ │ │
* └─────┴───┴─────┴───────────────────────────┴───┴───┴───┴───┘
*/
[_RESET] = LAYOUT_60_ansi_arrow_split_bs_7u_spc(
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, RESET, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______, _______,
_______, _______, _______, _______, _______, _______, _______, _______
)
};
void keyboard_post_init_user(void) {
rgblight_enable_noeeprom();
rgblight_setrgb(100, 255, 100);
}
// RGB Lighting/LED/Underglow as Caps Lock, Num Lock, Scroll Lock, and Layer Indicator
void update_led(void) {
// Num Lock Indicator
if (host_keyboard_led_state().num_lock) {
rgblight_setrgb(225, 8, 0);
}
// Scroll Lock Indicator
if (host_keyboard_led_state().scroll_lock) {
rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_GRADIENT + 2);
}
}
void led_set_user(uint8_t usb_led) {
// Caps Lock Indicator
if (IS_LED_ON(usb_led, USB_LED_CAPS_LOCK)) {
writePinLow(B2);
rgblight_setrgb(255, 110, 0);
}
// Layer Indicator
else {
switch (get_highest_layer(layer_state)) {
// Fn Layer Indicator
case _FN:
rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_GRADIENT + 1);
break;
// Reset Layer Indicator
case _RESET:
rgblight_mode_noeeprom(RGBLIGHT_MODE_STATIC_GRADIENT + 3);
break;
// Base Layer Indicator
case _BASE:
rgblight_setrgb(100, 255, 100);
break;
}
update_led();
}
}
layer_state_t layer_state_set_user(layer_state_t state) {
update_led();
return state;
}
| 49.309859 | 145 | 0.442731 |
48f316e5c7bcf3f0c24d25800935dd542a0e3cc0 | 932 | c | C | test/avl_insert-prioqueue.c | ecsv/avltree-helper | 75873fd16174438becd3e20abbd7eac3267baf53 | [
"MIT"
] | 1 | 2019-12-20T14:22:33.000Z | 2019-12-20T14:22:33.000Z | test/avl_insert-prioqueue.c | ecsv/avltree-helper | 75873fd16174438becd3e20abbd7eac3267baf53 | [
"MIT"
] | null | null | null | test/avl_insert-prioqueue.c | ecsv/avltree-helper | 75873fd16174438becd3e20abbd7eac3267baf53 | [
"MIT"
] | 1 | 2020-09-09T15:43:55.000Z | 2020-09-09T15:43:55.000Z | // SPDX-License-Identifier: MIT
/* Minimal AVL-tree helper functions test
*
* SPDX-FileCopyrightText: Sven Eckelmann <sven@narfation.org>
*/
#include <assert.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include "../avltree.h"
#include "common.h"
#include "common-prioqueue.h"
static uint16_t values[256];
int main(void)
{
struct avl_prioqueue queue;
size_t i, j;
struct avlitem *item;
for (i = 0; i < 256; i++) {
random_shuffle_array(values, (uint16_t)ARRAY_SIZE(values));
avl_prioqueue_init(&queue);
for (j = 0; j < ARRAY_SIZE(values); j++) {
item = (struct avlitem *)malloc(sizeof(*item));
assert(item);
item->i = values[j];
avl_prioqueue_insert_balanced(&queue, item);
}
for (j = 0; j < ARRAY_SIZE(values); j++) {
item = avl_prioqueue_pop_balanced(&queue);
assert(item);
assert(item->i == j);
free(item);
}
assert(avl_empty(&queue.root));
}
return 0;
}
| 19.416667 | 62 | 0.660944 |
e30ba93de2c90bc2d56bb309ae9180032f24f89a | 1,536 | c | C | wol.c | kei-g/wol | 52f0bb5163aeb97cd807381112dc2bc7aa3ba5c1 | [
"BSD-3-Clause"
] | null | null | null | wol.c | kei-g/wol | 52f0bb5163aeb97cd807381112dc2bc7aa3ba5c1 | [
"BSD-3-Clause"
] | 1 | 2022-03-30T16:27:57.000Z | 2022-03-30T16:27:57.000Z | wol.c | kei-g/wol | 52f0bb5163aeb97cd807381112dc2bc7aa3ba5c1 | [
"BSD-3-Clause"
] | null | null | null | #ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <unistd.h>
int main(int argc, char *argv[]) {
if (argc < 2) {
fputs("too few argument\n", stderr);
return 1;
}
uint8_t macaddr[6], *dst = macaddr;
for (char *tok, *s = strtok_r(argv[1], ":", &tok), n = 0; s && n < 6;
s = strtok_r(NULL, ":", &tok), n++) {
char *ep;
unsigned long ul = strtoul(s, &ep, 16);
if (*ep || UINT8_MAX < ul) {
fprintf(stderr, "invalid argument, %s\n", s);
return 1;
}
*dst++ = (uint8_t)ul;
}
if (dst < macaddr + 6) {
fputs("too short macaddr\n", stderr);
return 1;
}
int sock = socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0) {
perror("socket");
return 1;
}
int bc = 1;
if (setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &bc, sizeof(bc)) < 0) {
perror("setsockopt");
close(sock);
return 1;
}
struct sockaddr_in raddr;
memset(&raddr, 0, sizeof(raddr));
raddr.sin_family = AF_INET;
raddr.sin_port = htons(9);
raddr.sin_addr.s_addr = -1;
uint8_t msg[102];
memset(msg, -1, 6);
for (int i = 0; i < 16; i++)
memcpy(msg + (i + 1) * 6, macaddr, 6);
ssize_t wlen = sendto(sock, msg, sizeof(msg), 0,
(struct sockaddr *)&raddr, sizeof(raddr));
if (wlen < 0) {
perror("sendto");
close(sock);
return 1;
}
close(sock);
return 0;
}
| 23.630769 | 72 | 0.568359 |
e320b8f183f0b2492a710801c763e56e92b635f4 | 6,567 | c | C | src/verilog/rtl/memory/cachesim.c | cousteaulecommandant/miaow | 6ed88045a2dacd0314594e48900c5b3d851e74dd | [
"BSD-3-Clause"
] | 783 | 2015-01-23T11:57:01.000Z | 2022-03-27T12:37:02.000Z | src/verilog/rtl/memory/cachesim.c | cousteaulecommandant/miaow | 6ed88045a2dacd0314594e48900c5b3d851e74dd | [
"BSD-3-Clause"
] | 20 | 2015-08-26T15:21:59.000Z | 2020-09-26T00:14:52.000Z | src/verilog/rtl/memory/cachesim.c | cousteaulecommandant/miaow | 6ed88045a2dacd0314594e48900c5b3d851e74dd | [
"BSD-3-Clause"
] | 209 | 2015-01-15T21:54:15.000Z | 2022-03-21T02:55:27.000Z | // Somayeh Sardashti
// May 2009
// ECE/CS 552
// Cache Simulator
//
// Updated by Cherin Joseph
// April 2013
// Added support for pseudo random replacement
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <math.h>
#include <time.h>
#include <sys/time.h>
//defines a cache way
typedef struct __Way {
int valid;
int dirty;
int tag;
int data;
// int LRUCnt;
struct timeval LRUTime;
} cacheWay;
//define a cache set
typedef struct __Set {
// int LRU;
cacheWay *ways;
} cacheSet;
//define a cache trace
typedef struct __Trace {
int write;
int read;
int address;
int data;
} cacheTrace;
int associativity;
int cacheSize;
int blockSize;
int numSets;
cacheSet *cacheLines;
int wordSize;
int indexSize;
int tagSize;
int pseudo_random;
void setAddressBits(){
//address = Tag&Index&Word
wordSize = log2(blockSize);
indexSize = log2(numSets);
tagSize = log2(cacheSize) - indexSize - wordSize;
}
int getIndex (int address){
//address = Tag&Index&Word
int index = address % (numSets*blockSize);
index = index / blockSize;
return index;
}
int getTag (int address){
//address = Tag&Index&Word
int tag = address/(numSets*blockSize);
return tag;
}
void updateLRUCnt(int index, int way){
/* int i;
for (i=0; i<associativity; i++){
if (i != way)
cacheLines[index].ways[i].LRUCnt--;
else
cacheLines[index].ways[i].LRUCnt++;
}*/
gettimeofday( &(cacheLines[index].ways[way].LRUTime), NULL);
}
int getLRU(int index){
int i;
struct timeval curTime;
gettimeofday( &curTime, NULL);
double minTime = curTime.tv_sec + curTime.tv_usec + 1000;
////printf ("minTime %f \n", minTime);
int LRU;
for (i=0; i<associativity; i++){
double t = (cacheLines[index].ways[i].LRUTime).tv_sec + (cacheLines[index].ways[i].LRUTime).tv_usec;
////printf ("way %d, time %f \n", i, t);
if ( t < minTime ){
LRU = i;
minTime = (cacheLines[index].ways[i].LRUTime).tv_sec + (cacheLines[index].ways[i].LRUTime).tv_usec;
}
}
////printf ("LRU %d \n", LRU);
return LRU;
}
int updatePseudoRandomState()
{
static int victimWay = 0;
//Toggle 1/0 for each access
victimWay = (1 + victimWay) % associativity;
return victimWay;
}
int runTrace (cacheTrace trace)
{
int index = getIndex (trace.address);
int tag = getTag (trace.address);
int data = trace.data;
int i;
int found = 0;
int pseudoRandom_victimWay;
int PR;
if (pseudo_random)
{
pseudoRandom_victimWay = updatePseudoRandomState();
}
for (i=0; i<associativity; i++){
if (cacheLines[index].ways[i].valid && (cacheLines[index].ways[i].tag == tag)){
if (trace.write) {
//printf ("Store Hit for Address %d \n", trace.address);
updateLRUCnt(index, i);
cacheLines[index].ways[i].dirty = 1;
found = 1;
break;
}
if (trace.read) {
//printf ("Load Hit for Address %d \n", trace.address);
updateLRUCnt(index, i);
found = 1;
break;
}
}
}
if (!found) {
int LRU = getLRU(index);
//Code section to fine a victim for Pseudo random replacement
if(pseudo_random)
{
for(i=0; i<associativity; i++) {
if(0 == cacheLines[index].ways[i].valid) {
PR = i;
break;
}
}
if(i == associativity) {
PR = pseudoRandom_victimWay;
}
//FIXME
//This is a hack to reuse below code without change
//Better use a variable called victim and assign one of LRU or PR to it
LRU = PR;
}
if (trace.write){
if (cacheLines[index].ways[LRU].valid && (cacheLines[index].ways[LRU].dirty)) {
//printf ("Store Miss for Address %d with a Dirty Eviction \n", trace.address);
updateLRUCnt(index, LRU);
}
else {
if (cacheLines[index].ways[LRU].valid){
//printf ("Store Miss for Address %d with Eviction \n", trace.address);
updateLRUCnt(index, LRU);
}
else{
//printf ("Store Miss for Address %d \n", trace.address);
updateLRUCnt(index, LRU);
}
}
cacheLines[index].ways[LRU].valid = 1;
cacheLines[index].ways[LRU].dirty = 1;
cacheLines[index].ways[LRU].tag = tag;
cacheLines[index].ways[LRU].data = data;
}
else if (trace.read) {
if (cacheLines[index].ways[LRU].valid && (cacheLines[index].ways[LRU].dirty)) {
//printf ("Load Miss for Address %d with a Dirty Eviction \n", trace.address);
updateLRUCnt(index, LRU);
}
else {
if (cacheLines[index].ways[LRU].valid) {
//printf ("Load Miss for Address %d with Eviction \n", trace.address);
updateLRUCnt(index, LRU);
}
else {
//printf ("Load Miss for Address %d \n", trace.address);
updateLRUCnt(index, LRU);
}
}
cacheLines[index].ways[LRU].valid = 1;
cacheLines[index].ways[LRU].dirty = 0;
cacheLines[index].ways[LRU].tag = tag;
cacheLines[index].ways[LRU].data = data;
}
}
return found;
}
int RunTraceWrapper(int write, int read, int address, int data)
{
cacheTrace trace;
trace.write = write;
trace.read = read;
trace.address = address;
trace.data = data;
return runTrace(trace);
}
void Init_cache(int a, int c, int b)
{
associativity = a;
cacheSize = c;
blockSize = b;
pseudo_random = 1;
numSets = cacheSize / (blockSize * associativity);
cacheLines = malloc (numSets*sizeof(cacheSet));
int i;
for (i=0; i<numSets; i++) {
cacheLines[i].ways = malloc (associativity*sizeof(cacheWay));
}
//initializing
int j;
cacheWay* ways;
struct timeval curTime;
gettimeofday(&curTime, NULL);
double t = curTime.tv_sec;
for (i=0; i<numSets; i++){
for (j=0; j<associativity; j++){
cacheLines[i].ways[j].valid = 0;
cacheLines[i].ways[j].dirty = 0;
cacheLines[i].ways[j].tag = 0;
cacheLines[i].ways[j].data = 0;
//cacheLines[i].ways[j].LRUCnt = 0;
cacheLines[i].ways[j].LRUTime.tv_sec = curTime.tv_sec;
}
}
//set address bits
setAddressBits();
}
| 23.707581 | 103 | 0.573626 |
d424630e5fa60dc414808a668206cf61c3293613 | 707 | c | C | homework4/Hw4Task2/Hw4Task2/testMostFrequentElement.c | artemiipatov/HomeworksSPbU | 73e8412351cf56ce6839928a478c59557f0a5149 | [
"Apache-2.0"
] | null | null | null | homework4/Hw4Task2/Hw4Task2/testMostFrequentElement.c | artemiipatov/HomeworksSPbU | 73e8412351cf56ce6839928a478c59557f0a5149 | [
"Apache-2.0"
] | null | null | null | homework4/Hw4Task2/Hw4Task2/testMostFrequentElement.c | artemiipatov/HomeworksSPbU | 73e8412351cf56ce6839928a478c59557f0a5149 | [
"Apache-2.0"
] | null | null | null | #include "testMostFrequentElement.h"
#include "sort.h"
#include "mostFrequentElementSearch.h"
#include <stdbool.h>
bool testMostFrequentElement()
{
// One element array test
int testArray1[1] = { 5 };
quickSort(0, 1, testArray1);
if (findMostFrequent(testArray1, 1) != 5)
{
return false;
}
// identical elements test
int testArray2[12] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };
quickSort(0, 12, testArray2);
if (findMostFrequent(testArray2, 12) != 5)
{
return false;
}
// usual array test
int testArray3[11] = { 1, 0, 4, 1, 9, 2, 8, 9, 2, 4, 9 };
quickSort(0, 11, testArray3);
return 9 == findMostFrequent(testArray3, 11);
} | 25.25 | 64 | 0.598303 |
ac2c259666eb0c3e395f9353b1bb4778f4c23077 | 14,055 | h | C | targets/efm32-series1/hw/PRS.h | minuteos/lib-efm32 | 526128f7f6788d3b4ddac7ec2a9c7ed9d3e1b6d1 | [
"MIT"
] | null | null | null | targets/efm32-series1/hw/PRS.h | minuteos/lib-efm32 | 526128f7f6788d3b4ddac7ec2a9c7ed9d3e1b6d1 | [
"MIT"
] | null | null | null | targets/efm32-series1/hw/PRS.h | minuteos/lib-efm32 | 526128f7f6788d3b4ddac7ec2a9c7ed9d3e1b6d1 | [
"MIT"
] | null | null | null | /*
* Copyright (c) 2019 triaxis s.r.o.
* Licensed under the MIT license. See LICENSE.txt file in the repository root
* for full license information.
*
* efm32-series1/hw/PRS.h
*/
#pragma once
#include <base/base.h>
#include <hw/CMU.h>
#include <hw/GPIO.h>
#ifndef PRS_1MHZ_DMA
#define PRS_1MHZ_DMA 0
#endif
class PRSChannel : public PRS_CH_TypeDef
{
public:
enum Flags
{
SourceNone = 0,
SourcePRS0 = PRS_CH_CTRL_SOURCESEL_PRSL | PRS_CH_CTRL_SIGSEL_PRSCH0,
SourcePRS1, SourcePRS2, SourcePRS3, SourcePRS4, SourcePRS5, SourcePRS6, SourcePRS7,
SourcePRS8 = PRS_CH_CTRL_SOURCESEL_PRSH | PRS_CH_CTRL_SIGSEL_PRSCH8,
SourcePRS9, SourcePRS10, SourcePRS11,
SourceACMP0 = PRS_CH_CTRL_SOURCESEL_ACMP0 | PRS_CH_CTRL_SIGSEL_ACMP0OUT,
SourceACMP1 = PRS_CH_CTRL_SOURCESEL_ACMP1 | PRS_CH_CTRL_SIGSEL_ACMP1OUT,
SourceADC0_Single = PRS_CH_CTRL_SOURCESEL_ADC0 | PRS_CH_CTRL_SIGSEL_ADC0SINGLE,
SourceADC0_Scan = PRS_CH_CTRL_SOURCESEL_ADC0 | PRS_CH_CTRL_SIGSEL_ADC0SCAN,
SourceUSART0_IRTx = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0IRTX,
SourceUSART0_TxComplete = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0TXC,
SourceUSART0_DataValid = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0RXDATAV,
SourceUSART0_Rts = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0RTS,
SourceUSART0_Tx = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0TX,
SourceUSART0_Cs = PRS_CH_CTRL_SOURCESEL_USART0 | PRS_CH_CTRL_SIGSEL_USART0CS,
SourceUSART1_TxComplete = PRS_CH_CTRL_SOURCESEL_USART1 | PRS_CH_CTRL_SIGSEL_USART1TXC,
SourceUSART1_DataValid = PRS_CH_CTRL_SOURCESEL_USART1 | PRS_CH_CTRL_SIGSEL_USART1RXDATAV,
SourceUSART1_Rts = PRS_CH_CTRL_SOURCESEL_USART1 | PRS_CH_CTRL_SIGSEL_USART1RTS,
SourceUSART1_Tx = PRS_CH_CTRL_SOURCESEL_USART1 | PRS_CH_CTRL_SIGSEL_USART1TX,
SourceUSART1_Cs = PRS_CH_CTRL_SOURCESEL_USART1 | PRS_CH_CTRL_SIGSEL_USART1CS,
#ifdef PRS_CH_CTRL_SOURCESEL_USART2
SourceUSART2_IRTx = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2IRTX,
SourceUSART2_TxComplete = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2TXC,
SourceUSART2_DataValid = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2RXDATAV,
SourceUSART2_Rts = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2RTS,
SourceUSART2_Tx = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2TX,
SourceUSART2_Cs = PRS_CH_CTRL_SOURCESEL_USART2 | PRS_CH_CTRL_SIGSEL_USART2CS,
#endif
SourceTIMER0_Underflow = PRS_CH_CTRL_SOURCESEL_TIMER0 | PRS_CH_CTRL_SIGSEL_TIMER0UF,
SourceTIMER0_Overflow = PRS_CH_CTRL_SOURCESEL_TIMER0 | PRS_CH_CTRL_SIGSEL_TIMER0OF,
SourceTIMER0_CC0 = PRS_CH_CTRL_SOURCESEL_TIMER0 | PRS_CH_CTRL_SIGSEL_TIMER0CC0,
SourceTIMER0_CC1 = PRS_CH_CTRL_SOURCESEL_TIMER0 | PRS_CH_CTRL_SIGSEL_TIMER0CC1,
SourceTIMER1_Underflow = PRS_CH_CTRL_SOURCESEL_TIMER1 | PRS_CH_CTRL_SIGSEL_TIMER1UF,
SourceTIMER1_Overflow = PRS_CH_CTRL_SOURCESEL_TIMER1 | PRS_CH_CTRL_SIGSEL_TIMER1OF,
SourceTIMER1_CC0 = PRS_CH_CTRL_SOURCESEL_TIMER1 | PRS_CH_CTRL_SIGSEL_TIMER1CC0,
SourceTIMER1_CC1 = PRS_CH_CTRL_SOURCESEL_TIMER1 | PRS_CH_CTRL_SIGSEL_TIMER1CC1,
SourceRTCC_CV0 = PRS_CH_CTRL_SOURCESEL_RTCC | PRS_CH_CTRL_SIGSEL_RTCCCCV0,
SourceRTCC_CV1, SourceRTCC_CV2,
SourceGPIO0 = PRS_CH_CTRL_SOURCESEL_GPIOL | PRS_CH_CTRL_SIGSEL_GPIOPIN0,
SourceGPIO1, SourceGPIO2, SourceGPIO3, SourceGPIO4, SourceGPIO5, SourceGPIO6, SourceGPIO7,
SourceGPIO8 = PRS_CH_CTRL_SOURCESEL_GPIOH | PRS_CH_CTRL_SIGSEL_GPIOPIN8,
SourceGPIO9, SourceGPIO10, SourceGPIO11, SourceGPIO12, SourceGPIO13, SourceGPIO14, SourceGPIO15,
SourceLETIMER0_CH0 = PRS_CH_CTRL_SOURCESEL_LETIMER0 | PRS_CH_CTRL_SIGSEL_LETIMER0CH0,
SourceLETIMER0_CH1,
SourcePCNT0_TrigComp = PRS_CH_CTRL_SOURCESEL_PCNT0 | PRS_CH_CTRL_SIGSEL_PCNT0TCC,
SourcePCNT0_UnderOverflow = PRS_CH_CTRL_SOURCESEL_PCNT0 | PRS_CH_CTRL_SIGSEL_PCNT0UFOF,
SourcePCNT0_Direction = PRS_CH_CTRL_SOURCESEL_PCNT0 | PRS_CH_CTRL_SIGSEL_PCNT0DIR,
SourceCRYOTIMER = PRS_CH_CTRL_SOURCESEL_CRYOTIMER | PRS_CH_CTRL_SIGSEL_CRYOTIMERPERIOD,
SourceCMU_Clock0 = PRS_CH_CTRL_SOURCESEL_CMU | PRS_CH_CTRL_SIGSEL_CMUCLKOUT0,
SourceCMU_Clock1,
EdgeNone = PRS_CH_CTRL_EDSEL_OFF,
EdgeRising = PRS_CH_CTRL_EDSEL_POSEDGE,
EdgeFalling = PRS_CH_CTRL_EDSEL_NEGEDGE,
EdgeBoth = PRS_CH_CTRL_EDSEL_BOTHEDGES,
EdgeMask = _PRS_CH_CTRL_EDSEL_MASK,
Stretch = PRS_CH_CTRL_STRETCH,
Invert = PRS_CH_CTRL_INV,
OrPrev = PRS_CH_CTRL_ORPREV,
AndNext = PRS_CH_CTRL_ANDNEXT,
Async = PRS_CH_CTRL_ASYNC,
};
DECLARE_FLAG_ENUM(Flags);
ALWAYS_INLINE unsigned Index() const { return ((unsigned)this & 0x3F) >> 2; }
ALWAYS_INLINE void Setup(Flags flags) { CTRL = flags; }
ALWAYS_INLINE void DMARequest(unsigned n) { (&PRS->DMAREQ0)[n] = Index() << _PRS_DMAREQ0_PRSSEL_SHIFT; }
};
class PRSChannelHandle
{
private:
constexpr PRSChannelHandle(unsigned index) : index(index) {}
unsigned index;
public:
constexpr PRSChannelHandle() : index(~0u) {}
constexpr operator unsigned() const { return index; }
ALWAYS_INLINE unsigned Index() const { return index; }
ALWAYS_INLINE void Setup(PRSChannel::Flags flags) { PRS->CH[index].CTRL = flags; }
ALWAYS_INLINE void DMARequest(unsigned n) { (&PRS->DMAREQ0)[n] = Index() << _PRS_DMAREQ0_PRSSEL_SHIFT; }
friend class _PRS;
};
#undef PRS
#define PRS CM_PERIPHERAL(_PRS, PRS_BASE)
class _PRS : public PRS_TypeDef
{
public:
#ifdef _SILICON_LABS_32B_SERIES_1
#ifdef _EFM32_GIANT_FAMILY
void ConfigureOutput0(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 0,
GPIO_LOC(pA(0), pF(3), pC(14), pF(2))); }
void ConfigureOutput1(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 1,
GPIO_LOC(pA(1), pF(4), pC(15), pE(12))); }
void ConfigureOutput2(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 2,
GPIO_LOC(pC(0), pF(5), pE(10), pE(13))); }
void ConfigureOutput3(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 3,
GPIO_LOC(pC(1), pE(8), pE(11), pA(0))); }
void ConfigureOutput4(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 4,
GPIO_LOC(pC(8), pB(0), pF(1))); }
void ConfigureOutput5(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 5,
GPIO_LOC(pC(9), pB(1), pD(6))); }
void ConfigureOutput6(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 6,
GPIO_LOC(pA(6), pB(14), pE(6))); }
void ConfigureOutput7(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 7,
GPIO_LOC(pB(13), pA(7), pE(7))); }
void ConfigureOutput8(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 8,
GPIO_LOC(pA(8), pA(2), pE(9))); }
void ConfigureOutput9(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 9,
GPIO_LOC(pA(9), pA(3), pB(10))); }
void ConfigureOutput10(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 10,
GPIO_LOC(pA(10), pC(2), pD(4))); }
void ConfigureOutput11(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 11,
GPIO_LOC(pA(11), pD(3), pD(5))); }
void ConfigureOutput12(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 12,
GPIO_LOC(pA(12), pB(6), pD(8))); }
void ConfigureOutput13(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 13,
GPIO_LOC(pA(13), pB(9), pE(14))); }
void ConfigureOutput14(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 14,
GPIO_LOC(pA(14), pC(6), pE(15))); }
void ConfigureOutput15(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 15,
GPIO_LOC(pA(15), pC(7), pF(0))); }
void ConfigureOutput16(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 16,
GPIO_LOC(pA(4), pB(12), pE(4))); }
void ConfigureOutput17(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 17,
GPIO_LOC(pA(5), pB(15), pE(5))); }
void ConfigureOutput18(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 18,
GPIO_LOC(pB(2), pC(10), pC(4))); }
void ConfigureOutput19(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 19,
GPIO_LOC(pB(3), pC(11), pC(5))); }
void ConfigureOutput20(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 20,
GPIO_LOC(pB(4), pC(12), pE(2))); }
void ConfigureOutput21(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 21,
GPIO_LOC(pB(5), pC(13), pB(11))); }
void ConfigureOutput22(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 22,
GPIO_LOC(pB(7), pE(0), pF(6))); }
void ConfigureOutput23(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 23,
GPIO_LOC(pB(8), pE(1), pF(7))); }
#else
void ConfigureOutput0(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 0, 4,
GPIO_LOC(pF(0), pF(1), pF(2), pF(3), pF(4), pF(5), pF(6), pF(7), pC(6), pC(7), pC(8), pC(9), pC(10), pC(11))); }
void ConfigureOutput1(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 1, 5,
GPIO_LOC(pF(1), pF(2), pF(3), pF(4), pF(5), pF(6), pF(7), pF(0))); }
void ConfigureOutput2(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 2, 6,
GPIO_LOC(pF(2), pF(3), pF(4), pF(5), pF(6), pF(7), pF(0), pF(1))); }
void ConfigureOutput3(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 3, 7,
GPIO_LOC(pF(3), pF(4), pF(5), pF(6), pF(7), pF(0), pF(1), pF(2), pD(9), pD(10), pD(11), pD(12), pD(13), pD(14), pD(15))); }
void ConfigureOutput4(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 4, 8,
GPIO_LOC(pD(9), pD(10), pD(11), pD(12), pD(13), pD(14), pD(15))); }
void ConfigureOutput5(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 5, 9,
GPIO_LOC(pD(10), pD(11), pD(12), pD(13), pD(14), pD(15), pD(9))); }
void ConfigureOutput6(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 6, 10,
GPIO_LOC(pA(0), pA(1), pA(2), pA(3), pA(4), pA(5), pB(11), pB(12), pB(13), pB(14), pB(15), pD(9), pD(10), pD(11), pD(12), pD(13), pD(14), pD(15))); }
void ConfigureOutput7(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 7, 11,
GPIO_LOC(pA(1), pA(2), pA(3), pA(4), pA(5), pB(11), pB(12), pB(13), pB(14), pB(15), pA(0))); }
void ConfigureOutput8(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 8, 12,
GPIO_LOC(pA(2), pA(3), pA(4), pA(5), pB(11), pB(12), pB(13), pB(14), pB(15), pA(0), pA(1))); }
void ConfigureOutput9(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 9, 13,
GPIO_LOC(pA(3), pA(4), pA(5), pB(11), pB(12), pB(13), pB(14), pB(15), pA(0), pA(1), pA(2), pC(6), pC(7), pC(8), pC(9), pC(10), pC(11))); }
void ConfigureOutput10(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 10, 14,
GPIO_LOC(pC(6), pC(7), pC(8), pC(9), pC(10), pC(11))); }
void ConfigureOutput11(GPIOPin pin, GPIOPin::Mode mode = GPIOPin::PushPull) { pin.ConfigureAlternate(mode, ROUTEPEN, 11, 15,
GPIO_LOC(pC(7), pC(8), pC(9), pC(10), pC(11), pC(6))); }
#endif
#endif
//! Configures a 1 MHz DMA trigger on the specified channel (useful for things such as DMA-based PWM)
void Configure1MHzDMA(unsigned channel);
//! Enables the clock to PRS
void EnableClock() { CMU->EnablePRS(); }
//! Gets a reference representing the specified channel
PRSChannel& Channel(unsigned n) const { return *(PRSChannel*)&CH[n]; }
//! Gets the channel with the specified flags or allocates a new one
PRSChannelHandle GetChannel(PRSChannel::Flags flags);
//! Gets the specified ACMP channel with the specified flags or allocates a new one
PRSChannelHandle GetACMPChannel(unsigned index, PRSChannel::Flags flags) { ASSERT(index < ACMP_COUNT); return GetChannel(flags | PRSChannel::Flags(PRSChannel::SourceACMP0 + index)); }
//! Gets the specified GPIO channel with the specified flags or allocates a new one
PRSChannelHandle GetGPIOChannel(unsigned index, PRSChannel::Flags flags) { ASSERT(index < 16); return GetChannel(flags | PRSChannel::Flags((GETBIT(index, 3) ? PRSChannel::SourceGPIO8 : PRSChannel::SourceGPIO0) + (index & 7))); }
//! Generates a pulse on the specified channel
void PulseChannel(unsigned n) { SWPULSE = BIT(n); }
private:
friend class PRSChannel;
};
DEFINE_FLAG_ENUM(PRSChannel::Flags);
| 58.807531 | 232 | 0.703237 |
ac664e8a161c706221a0330d668288ef12b5da3d | 630 | c | C | Sem-5/USP/Minor Assignment 5/Sol25.c | siddhant2002/ITER-ASSIGNMENTS | a72810bc665b04be287d3cd8f9e7b987692d1ae1 | [
"MIT"
] | null | null | null | Sem-5/USP/Minor Assignment 5/Sol25.c | siddhant2002/ITER-ASSIGNMENTS | a72810bc665b04be287d3cd8f9e7b987692d1ae1 | [
"MIT"
] | null | null | null | Sem-5/USP/Minor Assignment 5/Sol25.c | siddhant2002/ITER-ASSIGNMENTS | a72810bc665b04be287d3cd8f9e7b987692d1ae1 | [
"MIT"
] | 1 | 2022-03-02T05:07:39.000Z | 2022-03-02T05:07:39.000Z | #include <stdio.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/wait.h>
int main(){
int a=0, b=1, n=a+b,i;
printf("Enter the number of a Fibonacci Sequence:\n");
scanf("%d", &i);
pid_t pid = fork();
if (pid == 0){
printf("Child is make the Fibonacci\n");
printf("0 %d ",n);
while (i>0) {
n=a+b;
printf("%d ", n);
a=b;
b=n;
i--;
if (i == 0) {
printf("\nChild ends\n");
}
}
}
else{
printf("Parent is waiting for child to complete...\n");
waitpid(pid, NULL, 0);
printf("Parent ends\n");
}
return 0;
}
| 20.322581 | 63 | 0.488889 |
b154a9865437570437494ef8b4d9af2be0c20d95 | 290 | h | C | src/bin/monitor/batteries.h | haxworx/enigmatic | be62dbb0c8d4b0cd936ac90c3e20d6a82026dc6a | [
"0BSD"
] | null | null | null | src/bin/monitor/batteries.h | haxworx/enigmatic | be62dbb0c8d4b0cd936ac90c3e20d6a82026dc6a | [
"0BSD"
] | null | null | null | src/bin/monitor/batteries.h | haxworx/enigmatic | be62dbb0c8d4b0cd936ac90c3e20d6a82026dc6a | [
"0BSD"
] | null | null | null | #ifndef ENIGMATIC_MONITOR_BATTERIES_H
#define ENIGMATIC_MONITOR_BATTERIES_H
#include "Enigmatic.h"
Eina_Bool
enigmatic_monitor_batteries(Enigmatic *enigmatic, Eina_Hash **cache_hash);
void
enigmatic_monitor_batteries_init(void);
void
enigmatic_monitor_batteries_shutdown(void);
#endif
| 18.125 | 74 | 0.858621 |
1d557998087bc434092fb75a68a791e57bf0f11f | 10,324 | c | C | Chapter_14/TerrainRendering/TerrainRendering.c | biloba123/OpenGL-ES-3.0 | 6da5c33d1a4eaa802d93112ecaafe308fb275b00 | [
"MIT"
] | 1,642 | 2015-01-01T12:34:56.000Z | 2022-03-30T11:12:31.000Z | Chapter_14/TerrainRendering/TerrainRendering.c | biloba123/OpenGL-ES-3.0 | 6da5c33d1a4eaa802d93112ecaafe308fb275b00 | [
"MIT"
] | 43 | 2015-01-01T02:12:44.000Z | 2021-08-04T02:01:59.000Z | Chapter_14/TerrainRendering/TerrainRendering.c | biloba123/OpenGL-ES-3.0 | 6da5c33d1a4eaa802d93112ecaafe308fb275b00 | [
"MIT"
] | 725 | 2015-01-07T02:40:04.000Z | 2022-03-30T03:12:09.000Z | // The MIT License (MIT)
//
// Copyright (c) 2013 Dan Ginsburg, Budirijanto Purnomo
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
// Book: OpenGL(R) ES 3.0 Programming Guide, 2nd Edition
// Authors: Dan Ginsburg, Budirijanto Purnomo, Dave Shreiner, Aaftab Munshi
// ISBN-10: 0-321-93388-5
// ISBN-13: 978-0-321-93388-1
// Publisher: Addison-Wesley Professional
// URLs: http://www.opengles-book.com
// http://my.safaribooksonline.com/book/animation-and-3d/9780133440133
//
// TerrainRendering.c
//
// Demonstrates rendering a terrain with vertex texture fetch
//
#include <stdlib.h>
#include <math.h>
#include "esUtil.h"
#define POSITION_LOC 0
typedef struct
{
// Handle to a program object
GLuint programObject;
// Uniform locations
GLint mvpLoc;
GLint lightDirectionLoc;
// Sampler location
GLint samplerLoc;
// Texture handle
GLuint textureId;
// VBOs
GLuint positionVBO;
GLuint indicesIBO;
// Number of indices
int numIndices;
// dimension of grid
int gridSize;
// MVP matrix
ESMatrix mvpMatrix;
} UserData;
///
// Load texture from disk
//
GLuint LoadTexture ( void *ioContext, char *fileName )
{
int width,
height;
char *buffer = esLoadTGA ( ioContext, fileName, &width, &height );
GLuint texId;
if ( buffer == NULL )
{
esLogMessage ( "Error loading (%s) image.\n", fileName );
return 0;
}
glGenTextures ( 1, &texId );
glBindTexture ( GL_TEXTURE_2D, texId );
glTexImage2D ( GL_TEXTURE_2D, 0, GL_ALPHA, width, height, 0, GL_ALPHA, GL_UNSIGNED_BYTE, buffer );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
glTexParameteri ( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
free ( buffer );
return texId;
}
///
// Initialize the MVP matrix
//
int InitMVP ( ESContext *esContext )
{
ESMatrix perspective;
ESMatrix modelview;
float aspect;
UserData *userData = esContext->userData;
// Compute the window aspect ratio
aspect = ( GLfloat ) esContext->width / ( GLfloat ) esContext->height;
// Generate a perspective matrix with a 60 degree FOV
esMatrixLoadIdentity ( &perspective );
esPerspective ( &perspective, 60.0f, aspect, 0.1f, 20.0f );
// Generate a model view matrix to rotate/translate the terrain
esMatrixLoadIdentity ( &modelview );
// Center the terrain
esTranslate ( &modelview, -0.5f, -0.5f, -0.7f );
// Rotate
esRotate ( &modelview, 45.0f, 1.0, 0.0, 0.0 );
// Compute the final MVP by multiplying the
// modelview and perspective matrices together
esMatrixMultiply ( &userData->mvpMatrix, &modelview, &perspective );
return TRUE;
}
///
// Initialize the shader and program object
//
int Init ( ESContext *esContext )
{
GLfloat *positions;
GLuint *indices;
UserData *userData = esContext->userData;
const char vShaderStr[] =
"#version 300 es \n"
"uniform mat4 u_mvpMatrix; \n"
"uniform vec3 u_lightDirection; \n"
"layout(location = 0) in vec4 a_position; \n"
"uniform sampler2D s_texture; \n"
"out vec4 v_color; \n"
"void main() \n"
"{ \n"
" // compute vertex normal from height map \n"
" float hxl = textureOffset( s_texture, \n"
" a_position.xy, ivec2(-1, 0) ).w; \n"
" float hxr = textureOffset( s_texture, \n"
" a_position.xy, ivec2( 1, 0) ).w; \n"
" float hyl = textureOffset( s_texture, \n"
" a_position.xy, ivec2( 0, -1) ).w; \n"
" float hyr = textureOffset( s_texture, \n"
" a_position.xy, ivec2( 0, 1) ).w; \n"
" vec3 u = normalize( vec3(0.05, 0.0, hxr-hxl) ); \n"
" vec3 v = normalize( vec3(0.0, 0.05, hyr-hyl) ); \n"
" vec3 normal = cross( u, v ); \n"
" \n"
" // compute diffuse lighting \n"
" float diffuse = dot( normal, u_lightDirection ); \n"
" v_color = vec4( vec3(diffuse), 1.0 ); \n"
" \n"
" // get vertex position from height map \n"
" float h = texture ( s_texture, a_position.xy ).w; \n"
" vec4 v_position = vec4 ( a_position.xy, \n"
" h/2.5, \n"
" a_position.w ); \n"
" gl_Position = u_mvpMatrix * v_position; \n"
"} \n";
const char fShaderStr[] =
"#version 300 es \n"
"precision mediump float; \n"
"in vec4 v_color; \n"
"layout(location = 0) out vec4 outColor; \n"
"void main() \n"
"{ \n"
" outColor = v_color; \n"
"} \n";
// Load the shaders and get a linked program object
userData->programObject = esLoadProgram ( vShaderStr, fShaderStr );
// Get the uniform locations
userData->mvpLoc = glGetUniformLocation ( userData->programObject, "u_mvpMatrix" );
userData->lightDirectionLoc = glGetUniformLocation ( userData->programObject,
"u_lightDirection" );
// Get the sampler location
userData->samplerLoc = glGetUniformLocation ( userData->programObject, "s_texture" );
// Load the heightmap
userData->textureId = LoadTexture ( esContext->platformData, "heightmap.tga" );
if ( userData->textureId == 0 )
{
return FALSE;
}
// Generate the position and indices of a square grid for the base terrain
userData->gridSize = 200;
userData->numIndices = esGenSquareGrid ( userData->gridSize, &positions, &indices );
// Index buffer for base terrain
glGenBuffers ( 1, &userData->indicesIBO );
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO );
glBufferData ( GL_ELEMENT_ARRAY_BUFFER, userData->numIndices * sizeof ( GLuint ),
indices, GL_STATIC_DRAW );
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, 0 );
free ( indices );
// Position VBO for base terrain
glGenBuffers ( 1, &userData->positionVBO );
glBindBuffer ( GL_ARRAY_BUFFER, userData->positionVBO );
glBufferData ( GL_ARRAY_BUFFER,
userData->gridSize * userData->gridSize * sizeof ( GLfloat ) * 3,
positions, GL_STATIC_DRAW );
free ( positions );
glClearColor ( 1.0f, 1.0f, 1.0f, 0.0f );
return TRUE;
}
///
// Draw a flat grid
//
void Draw ( ESContext *esContext )
{
UserData *userData = esContext->userData;
InitMVP ( esContext );
// Set the viewport
glViewport ( 0, 0, esContext->width, esContext->height );
// Clear the color buffer
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
// Use the program object
glUseProgram ( userData->programObject );
// Load the vertex position
glBindBuffer ( GL_ARRAY_BUFFER, userData->positionVBO );
glVertexAttribPointer ( POSITION_LOC, 3, GL_FLOAT,
GL_FALSE, 3 * sizeof ( GLfloat ), ( const void * ) NULL );
glEnableVertexAttribArray ( POSITION_LOC );
// Bind the index buffer
glBindBuffer ( GL_ELEMENT_ARRAY_BUFFER, userData->indicesIBO );
// Bind the height map
glActiveTexture ( GL_TEXTURE0 );
glBindTexture ( GL_TEXTURE_2D, userData->textureId );
// Load the MVP matrix
glUniformMatrix4fv ( userData->mvpLoc, 1, GL_FALSE, ( GLfloat * ) &userData->mvpMatrix.m[0][0] );
// Load the light direction
glUniform3f ( userData->lightDirectionLoc, 0.86f, 0.14f, 0.49f );
// Set the height map sampler to texture unit to 0
glUniform1i ( userData->samplerLoc, 0 );
// Draw the grid
glDrawElements ( GL_TRIANGLES, userData->numIndices, GL_UNSIGNED_INT, ( const void * ) NULL );
}
///
// Cleanup
//
void Shutdown ( ESContext *esContext )
{
UserData *userData = esContext->userData;
glDeleteBuffers ( 1, &userData->positionVBO );
glDeleteBuffers ( 1, &userData->indicesIBO );
// Delete program object
glDeleteProgram ( userData->programObject );
}
int esMain ( ESContext *esContext )
{
esContext->userData = malloc ( sizeof ( UserData ) );
esCreateWindow ( esContext, "TerrainRendering", 640, 480, ES_WINDOW_RGB | ES_WINDOW_DEPTH );
if ( !Init ( esContext ) )
{
return GL_FALSE;
}
esRegisterShutdownFunc ( esContext, Shutdown );
esRegisterDrawFunc ( esContext, Draw );
return GL_TRUE;
}
| 33.519481 | 101 | 0.595215 |
e1c7790812f65cb304a7203685d342a8a9a54438 | 162 | h | C | Example/Pods/Target Support Files/Pods-MHCUtil_Example/Pods-MHCUtil_Example-umbrella.h | fengxing1/MHCUtility | d2bcec2d65455fdaff61434b23d806ff82372607 | [
"MIT"
] | null | null | null | Example/Pods/Target Support Files/Pods-MHCUtil_Example/Pods-MHCUtil_Example-umbrella.h | fengxing1/MHCUtility | d2bcec2d65455fdaff61434b23d806ff82372607 | [
"MIT"
] | null | null | null | Example/Pods/Target Support Files/Pods-MHCUtil_Example/Pods-MHCUtil_Example-umbrella.h | fengxing1/MHCUtility | d2bcec2d65455fdaff61434b23d806ff82372607 | [
"MIT"
] | null | null | null | #import <UIKit/UIKit.h>
FOUNDATION_EXPORT double Pods_MHCUtil_ExampleVersionNumber;
FOUNDATION_EXPORT const unsigned char Pods_MHCUtil_ExampleVersionString[];
| 23.142857 | 74 | 0.864198 |
6dadbba9150148855d5c013501d942ff81cacec5 | 1,676 | c | C | Docs/References/Ref_codes/Lidar/lidar_slam/coreslam/random.c | crawlerufsc/crawler_hardware | 25d342c91e1e5beb79b695bed83fd860cee55b6b | [
"MIT"
] | 11 | 2019-02-19T03:51:30.000Z | 2022-01-09T05:44:38.000Z | Docs/References/Ref_codes/Lidar/lidar_slam/coreslam/random.c | crawlerufsc/crawler_hardware | 25d342c91e1e5beb79b695bed83fd860cee55b6b | [
"MIT"
] | null | null | null | Docs/References/Ref_codes/Lidar/lidar_slam/coreslam/random.c | crawlerufsc/crawler_hardware | 25d342c91e1e5beb79b695bed83fd860cee55b6b | [
"MIT"
] | 3 | 2020-05-16T03:00:05.000Z | 2020-07-28T02:38:55.000Z | /*
random.c - Glue code for BreezySLAM pseudorandom number generator
Copyright (C) 2014 Simon D. Levy
This code is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as
published by the Free Software Foundation, either version 3 of the
License, or (at your option) any later version.
This code 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 General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with this code. If not, see <http:#www.gnu.org/licenses/>.
*/
#include "ziggurat.h"
#include "random.h"
#include <stdlib.h>
#include <string.h>
typedef struct random_t
{
float fn[128];
uint32_t kn[128];
float wn[128];
uint32_t seed;
} random_t;
size_t random_size(void)
{
return sizeof(random_t);
}
void * random_new(int seed)
{
random_t * r = (random_t *)malloc(sizeof(random_t));
random_init(r, seed);
return r;
}
void random_init(void * v, int seed)
{
random_t * r = (random_t *)v;
r->seed = seed;
r4_nor_setup (r->kn, r->fn, r->wn );
}
double random_normal(void * v, double mu, double sigma)
{
random_t * r = (random_t *)v;
return mu + sigma * r4_nor ( &r->seed, r->kn, r->fn, r->wn );
}
void random_free(void * v)
{
free(v);
}
void * random_copy(void * v)
{
random_t * r = (random_t *)malloc(sizeof(random_t));
memcpy(r, v, sizeof(random_t));
return r;
}
| 19.952381 | 73 | 0.657518 |
d428b82283c3c8032c455bb0e37dc6c132fe79d2 | 417 | c | C | test/testcases/contracts/misc_01.c | vorpal-research/borealis | 247ca1bb26690e2d605ffc57785151e86dccd5bb | [
"MIT"
] | null | null | null | test/testcases/contracts/misc_01.c | vorpal-research/borealis | 247ca1bb26690e2d605ffc57785151e86dccd5bb | [
"MIT"
] | null | null | null | test/testcases/contracts/misc_01.c | vorpal-research/borealis | 247ca1bb26690e2d605ffc57785151e86dccd5bb | [
"MIT"
] | 1 | 2019-09-02T12:56:27.000Z | 2019-09-02T12:56:27.000Z | // this file is here only for testing annotation parsing
#include <stdlib.h>
int main(int argc, char* argv[]) {
// @assume argv != 0
// @assume *argv != 0
int* val = (int*)malloc(sizeof(int));
// @assume val != 0
int* e0x = val;
// @assume (e0x != 0) == true
// @stack-depth 0x0
// @stack-depth 010
// @stack-depth 890
// @assert (2.15 == 2.15) && (.0 == 0.)
*val = 2 + argv[0][0];
return *val+1;
}
| 18.130435 | 56 | 0.558753 |
d461c7b45c103198cb4f702907f2934383933237 | 74 | h | C | report/report 2/memory.h | Doommius/Compiler | 015e62e6c914cdfff3d77998ea937bd8adb8104b | [
"MIT"
] | null | null | null | report/report 2/memory.h | Doommius/Compiler | 015e62e6c914cdfff3d77998ea937bd8adb8104b | [
"MIT"
] | null | null | null | report/report 2/memory.h | Doommius/Compiler | 015e62e6c914cdfff3d77998ea937bd8adb8104b | [
"MIT"
] | null | null | null | void *Malloc(unsigned n);
#define NEW(type) (type *)Malloc(sizeof(type))
| 18.5 | 46 | 0.702703 |
98704d079da26d52975709c33be7d45fa7dfce49 | 6,373 | h | C | include/rapidassist/timing.h | end2endzone/RapidAssist | 1e35aefb77bf3e15191e8b00e11b215066a51a20 | [
"MIT-0",
"MIT"
] | 2 | 2018-05-26T13:58:21.000Z | 2019-08-18T19:15:18.000Z | include/rapidassist/timing.h | end2endzone/RapidAssist | 1e35aefb77bf3e15191e8b00e11b215066a51a20 | [
"MIT-0",
"MIT"
] | 74 | 2018-05-12T18:52:58.000Z | 2021-10-03T11:53:18.000Z | include/rapidassist/timing.h | end2endzone/RapidAssist | 1e35aefb77bf3e15191e8b00e11b215066a51a20 | [
"MIT-0",
"MIT"
] | 2 | 2018-09-04T20:02:13.000Z | 2020-09-15T04:05:14.000Z | /**********************************************************************************
* MIT License
*
* Copyright (c) 2018 Antoine Beauchamp
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*********************************************************************************/
#ifndef RA_TIMING_H
#define RA_TIMING_H
#include <stdint.h>
#include <ctime> //for struct tm
#include "rapidassist/config.h"
namespace ra { namespace timing {
/// <summary>
/// DateTime stucture with human readable values
/// </summary>
struct DateTime {
uint16_t year; // year - [0, 65000]
uint16_t month; // month of the year - [1,12]
uint16_t day; // day of the month - [1,31]
uint16_t hour; // hours since midnight - [0,23]
uint16_t min; // minutes after the hour - [0,59]
uint16_t sec; // seconds after the minute - [0,59]
uint16_t wday; // week day - [0,6]
uint16_t yday; // year day - [0,365]
bool isdst; // daylight savings time flag
};
/// <summary>
/// Converts a std::tm structure to a DateTime structure.
/// </summary>
/// <param name="time_info">The given std::tm value.</param>
/// <returns>Returns a DateTime structure matching the given std::tm info.</returns>
DateTime ToDateTime(const std::tm & time_info);
/// <summary>
/// Converts a DateTime structure to a std::tm structure.
/// </summary>
/// <param name="date_time">The given DateTime value.</param>
/// <returns>Returns a std::tm structure matching the given DateTime info.</returns>
std::tm ToTimeInfo(const DateTime & date_time);
/// <summary>
/// Wait for the clock to jump to the next second. Synchronize the time clock to a new second.
/// </summary>
void WaitNextSecond();
/// <summary>
/// Returns the system local time.
/// </summary>
/// <returns>Returns the system local time.</returns>
std::tm GetLocalTime();
/// <summary>
/// Returns the system utc time.
/// </summary>
/// <returns>Returns the system utc time.</returns>
std::tm GetUtcTime();
/// <summary>
/// Sleep the current thread for the given amount of milliseconds
/// </summary>
/// <param name="milliseconds">The time in milliseconds where the thread must sleep.</param>
/// <returns>On successfully sleeping for the requested interval, function returns 0.
/// If the call is interrupted or encounters an error, then it returns -1</returns>
int Millisleep(uint32_t milliseconds);
/// <summary>
/// Get the year from the compilation date string expanded by the __DATE__ macro.
/// </summary>
/// <returns>Returns the year from the compilation date string.</returns>
int GetYearFromCompilationDate(const char * compilation_date);
/// <summary>
/// Returns the year at the time the code was build.
/// Usefull for copyright messages.
/// </summary>
/// <returns>Returns the year when the function was compiled.</returns>
inline int GetCopyrightYear() { return GetYearFromCompilationDate(__DATE__); }
/// <summary>
/// Portable function to calculate the elapsed time with microseconds resolution.
/// </summary>
/// <remarks>The function query the internal high resolution clock/timer to calculate the elapsed time.</remarks>
/// <returns>Returns the elapsed time in seconds since an arbitrary starting point with microseconds resolution. Returns -1.0 on error.</returns>
double GetMicrosecondsTimer();
/// <summary>
/// Portable function to calculate the elapsed time with milliseconds resolution.
/// </summary>
/// <remarks>The function uses the internal clock to calculate the elapsed time.</remarks>
/// <returns>Returns the elapsed time in seconds since an arbitrary starting point with milliseconds resolution. Returns -1.0 on error.</returns>
double GetMillisecondsTimer();
/// <summary>
/// Returns the elapsed time in milliseconds since an arbitrary starting point.
/// </summary>
/// <remarks>
/// The function should be used to calculate the elapsed time between two events.
/// It should not be used for getting the current calendar time.
/// </remarks>
/// <returns>Returns the elapsed time in milliseconds since an arbitrary starting point with up to milliseconds resolution. Returns 0 on error.</returns>
uint64_t GetMillisecondsCounterU64();
/// <summary>
/// Returns the elapsed time in microseconds since an arbitrary starting point.
/// </summary>
/// <remarks>
/// The function should be used to calculate the elapsed time between two events.
/// It should not be used for getting the current calendar time.
/// </remarks>
/// <returns>Returns the elapsed time in microseconds since an arbitrary starting point with up to microseconds resolution. Returns 0 on error.</returns>
uint64_t GetMicrosecondsCounterU64();
/// <summary>
/// Returns the elapsed time in nanoseconds since an arbitrary starting point.
/// </summary>
/// <remarks>
/// The function should be used to calculate the elapsed time between two events.
/// It should not be used for getting the current calendar time.
/// </remarks>
/// <returns>Returns the elapsed time in nanoseconds since an arbitrary starting point with up to nanoseconds resolution. Returns 0 on error.</returns>
uint64_t GetNanosecondsCounterU64();
} //namespace timing
} //namespace ra
#endif //RA_TIMING_H
| 42.486667 | 155 | 0.691825 |
b0d8920b44f11c127049a42f2dac674c990e1894 | 4,259 | h | C | engine/src/Loaders/AssimpModelInfo.h | kyle-piddington/MoonEngine | 243cce7988ee089d0fc51d817e2736501e019702 | [
"MIT",
"BSD-3-Clause"
] | 5 | 2017-01-20T00:23:23.000Z | 2018-07-17T07:48:04.000Z | engine/src/Loaders/AssimpModelInfo.h | kyle-piddington/MoonEngine | 243cce7988ee089d0fc51d817e2736501e019702 | [
"MIT",
"BSD-3-Clause"
] | null | null | null | engine/src/Loaders/AssimpModelInfo.h | kyle-piddington/MoonEngine | 243cce7988ee089d0fc51d817e2736501e019702 | [
"MIT",
"BSD-3-Clause"
] | 2 | 2017-01-24T05:09:37.000Z | 2021-02-18T14:42:00.000Z | #pragma once
#include "GLWrapper/GLVertexArrayObject.h"
#include "Collision/BoundingBox.h"
#include "BasicMeshInfo.h"
#include <string>
#include <unordered_map>
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
//AssimpInfo contains all
//data imported by assimp, metadata
//about the mesh, and a meshInfo
//for binding later.
namespace MoonEngine
{
struct AssimpBoneInfo
{
AssimpBoneInfo():
parentBoneIndex(-1),
boneName(""),
offsetMatrix(1.0),
childBones(){}
int parentBoneIndex;
std::string boneName;
glm::mat4 offsetMatrix;
std::vector<int>childBones;
};
struct AssimpPositionKeyFrame
{
AssimpPositionKeyFrame(glm::vec3 position, float time):
position(position),
mTime(time){}
glm::vec3 position;
float mTime;
};
struct AssimpRotationKeyFrame
{
AssimpRotationKeyFrame(glm::quat rotation, float time):
rotation(rotation),
mTime(time){}
glm::quat rotation;
float mTime;
};
struct AssimpScaleKeyFrame
{
AssimpScaleKeyFrame(glm::vec3 scale, float time):
scale(scale),
mTime(time){}
glm::vec3 scale;
float mTime;
};
struct AssimpBoneAnimInfo
{
std::string boneName;
std::vector<AssimpPositionKeyFrame> translationKeys;
std::vector<AssimpRotationKeyFrame> rotationKeys;
std::vector<AssimpScaleKeyFrame> scaleKeys;
};
struct AssimpAnimationInfo
{
std::string name;
double duration;
double ticksPerSecond;
std::vector<AssimpBoneAnimInfo> boneAnimData;
};
struct AssimpMeshInfo
{
std::unordered_map<std::string, std::string> textures;
BasicMeshInfo meshInfo;
BoundingBox box;
glm::mat4 M;
//Mat4 offsets for binding matricies.
std::vector<glm::mat4> boneOffsets;
void bind() const
{
meshInfo.bind();
}
};
/**
* Contains all information about a model loaded by Assimp
* (+ Textures, full mesh info, bone and armature data (Eventually!))
*/
struct AssimpModelInfo
{
//Bounding min and max vertices
BoundingBox boundingBox;
bool hasNormals() const;
bool hasTangentBitangent() const;
bool hasTextureCoordinates() const;
bool hasBones() const;
const std::vector<AssimpMeshInfo> & getMeshInfo() const;
int stride() const;
//const MeshInfo & getFullMeshInfo() const;
std::vector<std::string> getAllTextures() const;
void addMeshInfo(AssimpMeshInfo & meshInfo);
void setVertexArrayObject(GLVertexArrayObject * vao)
{
vertexObjectPtr = vao;
}
//VAO contains full mesh information.
inline GLVertexArrayObject * getVAO()
{
return this->vertexObjectPtr;
}
void setHasNormals(bool normals)
{
_hasNormals = normals;
}
void setHasTangentBitangent(bool tbt)
{
_hasTangentBitangent = tbt;
}
void setHasTextureCoordinates(bool txCoord)
{
_hasTextureCoordinates = txCoord;
}
/**
* Add a bone and return it's index
* @param boneInfo new bone info to add
* @return index in the array of bones (for parent)
*/
int addBone(const AssimpBoneInfo & boneInfo);
int getBoneId(const std::string & string);
AssimpBoneInfo & getBoneInfo(int id)
{
assert(id < _boneInfo.size());
return _boneInfo[id];
}
int getNumBones(){return _boneInfo.size();}
//Mesh info avaliable if no other
//transformations / information is needed.
//(Useful for basic mesh display)
void setRootInverseTransform(const glm::mat4 & rootInverseTransform)
{
_rootInverseTransform = rootInverseTransform;
}
glm::mat4 getRootInverseTransform() const
{
return _rootInverseTransform;
}
void addAnimation(const AssimpAnimationInfo & info)
{
_animations.push_back(info);
}
const std::vector<AssimpAnimationInfo> & getAnimations()
{
return _animations;
}
private:
//Pointer to the vertex array object that contains the mesh.
//Most meshes are saved in MeshLibrary, but not all.
std::vector<AssimpAnimationInfo> _animations;
std::vector<AssimpMeshInfo> _meshInfo;
std::vector<AssimpBoneInfo> _boneInfo;
std::unordered_map<std::string, int> _boneToIndexMap;
glm::mat4 _rootInverseTransform;
BasicMeshInfo fullMeshInfo;
GLVertexArrayObject * vertexObjectPtr;
bool _hasNormals;
bool _hasTangentBitangent;
bool _hasBones;
bool _hasTextureCoordinates;
};
}
| 21.40201 | 70 | 0.714252 |
da3053f2a9e48274c29b29f0dda6a852f592859a | 2,159 | h | C | source/SimpletonVST.h | eatingbits/simpleton | a52b32d22eed6064fe66979ca6c204d156dc841d | [
"OLDAP-2.4"
] | 2 | 2016-05-09T11:30:10.000Z | 2016-07-13T07:02:45.000Z | source/SimpletonVST.h | eatingbits/simpleton | a52b32d22eed6064fe66979ca6c204d156dc841d | [
"OLDAP-2.4"
] | null | null | null | source/SimpletonVST.h | eatingbits/simpleton | a52b32d22eed6064fe66979ca6c204d156dc841d | [
"OLDAP-2.4"
] | null | null | null | #ifndef __Simpleton_VST_h__
#define __Simpleton_VST_h__
#include "audioeffectx.h"
static const unsigned long kUniqueId = 'SIMP';
static const int kNumPrograms = 0;
static const int kNumInputs = 0;
static const int kNumOutputs = 2;
class Parameters;
class Simpleton;
class SimpletonVST : public AudioEffectX {
public:
SimpletonVST(audioMasterCallback audioMaster, Simpleton *simpleton, Parameters *parameters);
virtual VstInt32 canDo(char *text);
virtual bool copyProgram(long destination);
virtual VstInt32 getCurrentMidiProgram(VstInt32 channel, MidiProgramName *currentProgram);
virtual bool getEffectName(char *name);
virtual bool getMidiKeyName(VstInt32 channel, MidiKeyName *keyName);
virtual VstInt32 getMidiProgramCategory(VstInt32 channel, MidiProgramCategory *category);
virtual VstInt32 getMidiProgramName(VstInt32 channel, MidiProgramName *midiProgramName);
virtual VstInt32 getNumMidiInputChannels();
virtual VstInt32 getNumMidiOutputChannels();
virtual bool getOutputProperties(VstInt32 index, VstPinProperties *properties);
virtual float getParameter(VstInt32 index);
virtual void getParameterDisplay(VstInt32 index, char *text);
virtual void getParameterLabel(VstInt32 index, char *label);
virtual void getParameterName(VstInt32 index, char *text);
virtual VstPlugCategory getPlugCategory();
virtual void getProgramName(char *name);
virtual bool getProgramNameIndexed(VstInt32 category, VstInt32 index, char *text);
virtual bool getProductString(char *text);
virtual bool getVendorString(char *text);
virtual VstInt32 getVendorVersion();
virtual bool hasMidiProgramsChanged(VstInt32 channel);
virtual VstInt32 processEvents(VstEvents *events);
virtual void processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames);
virtual void setSampleRate(float sampleRate);
virtual void setParameter(VstInt32 index, float value);
virtual void setProgram(VstInt32 index);
virtual void setProgramName(char *name);
virtual void setBlockSize(VstInt32 blockSize);
private:
void init();
Simpleton *mSimpleton;
Parameters *mParameters;
bool mInitialized;
};
#endif | 37.224138 | 93 | 0.799444 |
f72962bdf6695e4d458fe1b916b6cd0656beb348 | 777 | h | C | Altair101/Altair101f/frontPanel.h | tigerfarm/arduino | e51f111a092fe6737646b146a825f4eecbd05d44 | [
"OLDAP-2.4",
"OLDAP-2.7"
] | 2 | 2021-12-12T23:27:10.000Z | 2022-02-17T14:01:21.000Z | Altair101/Altair101f/frontPanel.h | tigerfarm/arduino | e51f111a092fe6737646b146a825f4eecbd05d44 | [
"OLDAP-2.4",
"OLDAP-2.7"
] | null | null | null | Altair101/Altair101f/frontPanel.h | tigerfarm/arduino | e51f111a092fe6737646b146a825f4eecbd05d44 | [
"OLDAP-2.4",
"OLDAP-2.7"
] | 4 | 2021-08-29T19:55:49.000Z | 2022-02-15T08:30:15.000Z | // -------------------------------------------------------------------------------
// From frontPanel.cpp for use in other programs.
// In other programs, include the following line:
// #include "frontPanel.h"
void lightsStatusAddressData( byte status8bits, unsigned int address16bits, byte data8bits);
byte fpToggleSense();
byte fpToggleData();
uint16_t fpToggleAddress();
void setPcfControlinterrupted(boolean theTruth);
boolean getPcfControlinterrupted();
void checkRunningButtons();
byte fpWaitControlSwitches();
void fpCheckAux1();
byte fpCheckProtectSetVolume();
void playerControlSwitches();
byte fpCheckAux2();
byte fpTimerControlSwitches();
boolean setupFrontPanel();
// -------------------------------------------------------------------------------
// eof
| 28.777778 | 92 | 0.622909 |
20e328b3e4843cf8144aa17f9068c3b24790f93c | 4,129 | h | C | examples/zolertia/tutorial/99-apps/mqtt-node/internals/mqtt-sensors.h | CEABARCA/contiki-ngCeAP | bb0eeede17f1ef0f2f3e577713ca7d994c9c5d31 | [
"BSD-3-Clause"
] | 3 | 2018-08-09T06:57:49.000Z | 2020-07-01T15:46:10.000Z | examples/zolertia/tutorial/99-apps/mqtt-node/internals/mqtt-sensors.h | CEABARCA/contiki-ngCeAP | bb0eeede17f1ef0f2f3e577713ca7d994c9c5d31 | [
"BSD-3-Clause"
] | null | null | null | examples/zolertia/tutorial/99-apps/mqtt-node/internals/mqtt-sensors.h | CEABARCA/contiki-ngCeAP | bb0eeede17f1ef0f2f3e577713ca7d994c9c5d31 | [
"BSD-3-Clause"
] | 3 | 2020-12-10T17:57:38.000Z | 2022-03-11T10:05:15.000Z | /*
* Copyright (c) 2016, Antonio Lignan - antonio.lignan@gmail.com
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the Institute nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*/
/*---------------------------------------------------------------------------*/
#ifndef MQTT_SENSORS_H_
#define MQTT_SENSORS_H_
/*---------------------------------------------------------------------------*/
#if DEFAULT_SENSORS_NUM
#define SENSOR_NAME_STRING 20
typedef struct sensor_val {
int16_t value; /* Sensor value */
int16_t over_threshold; /* Threshold (over) */
int16_t below_threshold; /* Threshold (below) */
int16_t min; /* Minimum allowed value */
int16_t max; /* Maximum allowed value */
int16_t fail_value; /* Value to send if erroneous */
uint16_t pres; /* Number of precision digits */
char sensor_name[SENSOR_NAME_STRING]; /* Sensor name (string) */
char alarm_name[SENSOR_NAME_STRING]; /* Alarm name (string) */
char sensor_config[SENSOR_NAME_STRING]; /* Configuration name (string) */
} sensor_val_t;
typedef struct sensors_values {
uint8_t num; /* Number of sensors */
sensor_val_t sensor[DEFAULT_SENSORS_NUM]; /* Array of sensor_val_t */
} sensor_values_t;
#endif /* DEFAULT_SENSORS_NUM */
/*---------------------------------------------------------------------------*/
#if DEFAULT_COMMANDS_NUM
#define COMMAND_NAME_STRING 20
typedef struct command_val {
int (* cmd) (int arg);
char command_name[COMMAND_NAME_STRING]; /* Command name (string) */
} command_val_t;
typedef struct command_values {
uint8_t num; /* Number of commands */
command_val_t command[DEFAULT_COMMANDS_NUM]; /* Array of command_val_t */
} command_values_t;
#endif /* DEFAULT_COMMANDS_NUM */
/*---------------------------------------------------------------------------*/
/* Auxiliary function to fill the sensor_values_t structure */
#if DEFAULT_SENSORS_NUM
int mqtt_sensor_register(sensor_values_t *reg, uint8_t i, uint16_t val,
char *name, char *alarm, char *config, int16_t min,
int16_t max, int16_t thres, int16_t thresl,
uint16_t pres);
/* Auxiliary function to check the sensor values and send alarms or publish
* periodic sensor events */
void mqtt_sensor_check(sensor_values_t *reg, process_event_t alarm,
process_event_t data);
#endif
/*---------------------------------------------------------------------------*/
#endif /* MQTT_SENSORS_H_ */
/** @} */
| 48.011628 | 79 | 0.622185 |
1f78f457d35ea1f3faa07bd82b6863a0698e449a | 4,192 | h | C | src/lasertowerspp/AttackController.h | Duffycola/lasertowerspp | f62df31f8afe707a135da62d8c3e5e071361fa46 | [
"MIT"
] | 1 | 2015-03-09T02:42:14.000Z | 2015-03-09T02:42:14.000Z | src/lasertowerspp/AttackController.h | Duffycola/lasertowerspp | f62df31f8afe707a135da62d8c3e5e071361fa46 | [
"MIT"
] | null | null | null | src/lasertowerspp/AttackController.h | Duffycola/lasertowerspp | f62df31f8afe707a135da62d8c3e5e071361fa46 | [
"MIT"
] | null | null | null | //
// AttackController.h
// lasertowerspp
//
// Created by Eduard Feicho <eduard.feicho@rwth-aachen.de> on 27.05.12.
//
//
// The MIT License (MIT)
//
// Copyright (c) 2012 Eduard Feicho
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//
//
#ifndef lasertowerspp_AttackController_h
#define lasertowerspp_AttackController_h
#include "Attack.h"
/**
* class AttackController contains the logic of an attack.
* Basically, a figure can have more than one guns,
* thus, the attack controller checks if there is a free slot for an attack
* and controlls all of these.
*/
class AttackController
{
public:
AttackController(int num_attacks = 1)
: _attacks(NULL) {
setNumAttacks( num_attacks );
}
Attack* getAttacks() {
return _attacks;
}
/**
* Count the number of active attacks.
* An attack can be active more than a single moment, because
* the particle (like a canon) needs to reach the target and the
* moment an attack is over is when the energy of the attack has
* reduced the stamina of the target figure.
*/
int countActiveAttacks() {
int activeAttacks = 0;
for (int i=0; i<_num_attacks; i++) {
Attack* attack = &_attacks[i];
if (attack->_target == NULL) {
continue;
}
activeAttacks++;
}
return activeAttacks;
}
void continueActiveAttacks(float delta)
{
for (int i=0; i<_num_attacks; i++) {
Attack* attack = &_attacks[i];
if (attack->_target == NULL) {
continue;
}
attack->_ttl -= delta;
if (attack->_ttl < 0) {
attack->_target->attack_hit( attack->_power );
attack->_target = NULL;
attack->_ttl = -1;
}
}
}
Attack* createAttack(GameFigureModel* source, GameFigureModel* target, float target_distance)
{
for (int i=0; i<_num_attacks; i++) {
Attack* attack = &_attacks[i];
if (attack->_target != NULL) {
continue;
}
attack->_target = NULL;
// TODO calcualte correctly and find a good value for the fixed constant that
// reflects the time the attack particle needs to arrive at the enemy
attack->_ttl_total = 1000.0;// * dist_enemy * 1.0 / speed;
attack->_ttl = attack->_ttl_total;
attack->_speed = source->getSpeed();
attack->_power = _attack_power;
attack->_target = target;
attack->_pos_source = cv::Vec3f(0,0,0);
attack->_pos_target = target->getPosition() - source->getPosition();
return attack;
}
return NULL;
}
void removeAttack( GameFigureModel* target )
{
for (int i=0; i<_num_attacks; i++) {
Attack* state = &_attacks[i];
if (state->_target == target) {
state->_target = NULL;
}
}
}
unsigned int getAttackPower() {
return _attack_power;
}
void setAttackPower(int attack_power) {
_attack_power = attack_power;
}
unsigned int getNumAttacks() {
return _num_attacks;
}
void setNumAttacks(int num_attacks) {
_num_attacks = num_attacks;
if (_num_attacks == 0) {
_attacks = NULL;
return;
}
if (_attacks != NULL) {
delete[] _attacks;
}
_attacks = new Attack[_num_attacks];
}
private:
unsigned int _attack_power;
Attack* _attacks;
unsigned int _num_attacks;
};
#endif
| 23.418994 | 94 | 0.683922 |
d338aa398f5ca08fff33d5ad44195fea126b63e3 | 1,080 | h | C | lib/sk/io/unix/test/PtyTest.h | stemkit-collection/stemkit-cpp | dfa77d831f49916ba6d134f407a4dcd0983328f6 | [
"MIT"
] | 4 | 2019-02-19T16:48:41.000Z | 2022-01-31T07:57:54.000Z | lib/sk/io/unix/test/PtyTest.h | stemkit-collection/stemkit-cpp | dfa77d831f49916ba6d134f407a4dcd0983328f6 | [
"MIT"
] | 1 | 2019-01-30T04:48:35.000Z | 2019-01-30T04:48:35.000Z | lib/sk/io/unix/test/PtyTest.h | stemkit-collection/stemkit-cpp | dfa77d831f49916ba6d134f407a4dcd0983328f6 | [
"MIT"
] | null | null | null | /* Copyright (c) 2006, Gennady Bystritsky <bystr@mac.com>
*
* Distributed under the MIT Licence.
* This is free software. See 'LICENSE' for details.
* You must read and accept the license prior to use.
*/
#ifndef _SK_IO_TEST_PTYTEST_
#define _SK_IO_TEST_PTYTEST_
#include <cppunit/TestFixture.h>
#include <cppunit/extensions/HelperMacros.h>
namespace sk {
namespace io {
namespace test {
class PtyTest
: public CppUnit::TestFixture
{
CPPUNIT_TEST_SUITE(sk::io::test::PtyTest);
CPPUNIT_TEST(testMasterSlavePipe);
CPPUNIT_TEST(testSlaveMasterPipe);
CPPUNIT_TEST(testSlaveTty);
CPPUNIT_TEST_SUITE_END();
public:
PtyTest();
virtual ~PtyTest();
void setUp();
void tearDown();
void testMasterSlavePipe();
void testSlaveMasterPipe();
void testSlaveTty();
private:
PtyTest(const PtyTest& other);
PtyTest& operator = (const PtyTest& other);
};
}
}
}
#endif /* _SK_IO_TEST_PTYTEST_ */
| 24 | 58 | 0.624074 |
dd1533c750c82b643888b25b86be692e18c3ca7b | 29,665 | h | C | src/renamevsx.h | TheMartianObserver/nsimd | 702f4d179ff012b60d34c2773cd3d8d1dca45487 | [
"MIT"
] | 247 | 2019-04-05T15:01:12.000Z | 2022-03-20T19:19:11.000Z | src/renamevsx.h | TheMartianObserver/nsimd | 702f4d179ff012b60d34c2773cd3d8d1dca45487 | [
"MIT"
] | 69 | 2019-04-05T14:37:32.000Z | 2022-02-17T20:55:59.000Z | src/renamevsx.h | TheMartianObserver/nsimd | 702f4d179ff012b60d34c2773cd3d8d1dca45487 | [
"MIT"
] | 23 | 2019-07-07T02:19:44.000Z | 2021-11-02T09:16:59.000Z | #ifndef RENAMEVSX_H
#define RENAMEVSX_H
/* ------------------------------------------------------------------------- */
/* Naming of functions vmx */
#ifdef NSIMD_VMX
#ifdef DETERMINISTIC
#define xsin nsimd_sleef_sin_u35d_vmx_f64
#define xsinf nsimd_sleef_sin_u35d_vmx_f32
#define xcos nsimd_sleef_cos_u35d_vmx_f64
#define xcosf nsimd_sleef_cos_u35d_vmx_f32
#define xsincos nsimd_sleef_sincos_u35d_vmx_f64
#define xsincosf nsimd_sleef_sincos_u35d_vmx_f32
#define xtan nsimd_sleef_tan_u35d_vmx_f64
#define xtanf nsimd_sleef_tan_u35d_vmx_f32
#define xasin nsimd_sleef_asin_u35d_vmx_f64
#define xasinf nsimd_sleef_asin_u35d_vmx_f32
#define xacos nsimd_sleef_acos_u35d_vmx_f64
#define xacosf nsimd_sleef_acos_u35d_vmx_f32
#define xatan nsimd_sleef_atan_u35d_vmx_f64
#define xatanf nsimd_sleef_atan_u35d_vmx_f32
#define xatan2 nsimd_sleef_atan2_u35d_vmx_f64
#define xatan2f nsimd_sleef_atan2_u35d_vmx_f32
#define xlog nsimd_sleef_log_u35d_vmx_f64
#define xlogf nsimd_sleef_log_u35d_vmx_f32
#define xcbrt nsimd_sleef_cbrt_u35d_vmx_f64
#define xcbrtf nsimd_sleef_cbrt_u35d_vmx_f32
#define xsin_u1 nsimd_sleef_sin_u10d_vmx_f64
#define xsinf_u1 nsimd_sleef_sin_u10d_vmx_f32
#define xcos_u1 nsimd_sleef_cos_u10d_vmx_f64
#define xcosf_u1 nsimd_sleef_cos_u10d_vmx_f32
#define xsincos_u1 nsimd_sleef_sincos_u10d_vmx_f64
#define xsincosf_u1 nsimd_sleef_sincos_u10d_vmx_f32
#define xtan_u1 nsimd_sleef_tan_u10d_vmx_f64
#define xtanf_u1 nsimd_sleef_tan_u10d_vmx_f32
#define xasin_u1 nsimd_sleef_asin_u10d_vmx_f64
#define xasinf_u1 nsimd_sleef_asin_u10d_vmx_f32
#define xacos_u1 nsimd_sleef_acos_u10d_vmx_f64
#define xacosf_u1 nsimd_sleef_acos_u10d_vmx_f32
#define xatan_u1 nsimd_sleef_atan_u10d_vmx_f64
#define xatanf_u1 nsimd_sleef_atan_u10d_vmx_f32
#define xatan2_u1 nsimd_sleef_atan2_u10d_vmx_f64
#define xatan2f_u1 nsimd_sleef_atan2_u10d_vmx_f32
#define xlog_u1 nsimd_sleef_log_u10d_vmx_f64
#define xlogf_u1 nsimd_sleef_log_u10d_vmx_f32
#define xcbrt_u1 nsimd_sleef_cbrt_u10d_vmx_f64
#define xcbrtf_u1 nsimd_sleef_cbrt_u10d_vmx_f32
#define xexp nsimd_sleef_exp_u10d_vmx_f64
#define xexpf nsimd_sleef_exp_u10d_vmx_f32
#define xpow nsimd_sleef_pow_u10d_vmx_f64
#define xpowf nsimd_sleef_pow_u10d_vmx_f32
#define xsinh nsimd_sleef_sinh_u10d_vmx_f64
#define xsinhf nsimd_sleef_sinh_u10d_vmx_f32
#define xcosh nsimd_sleef_cosh_u10d_vmx_f64
#define xcoshf nsimd_sleef_cosh_u10d_vmx_f32
#define xtanh nsimd_sleef_tanh_u10d_vmx_f64
#define xtanhf nsimd_sleef_tanh_u10d_vmx_f32
#define xsinh_u35 nsimd_sleef_sinh_u35d_vmx_f64
#define xsinhf_u35 nsimd_sleef_sinh_u35d_vmx_f32
#define xcosh_u35 nsimd_sleef_cosh_u35d_vmx_f64
#define xcoshf_u35 nsimd_sleef_cosh_u35d_vmx_f32
#define xtanh_u35 nsimd_sleef_tanh_u35d_vmx_f64
#define xtanhf_u35 nsimd_sleef_tanh_u35d_vmx_f32
#define xfastsin_u3500 nsimd_sleef_fastsin_u3500d_vmx_f64
#define xfastsinf_u3500 nsimd_sleef_fastsin_u3500d_vmx_f32
#define xfastcos_u3500 nsimd_sleef_fastcos_u3500d_vmx_f64
#define xfastcosf_u3500 nsimd_sleef_fastcos_u3500d_vmx_f32
#define xfastpow_u3500 nsimd_sleef_fastpow_u3500d_vmx_f64
#define xfastpowf_u3500 nsimd_sleef_fastpow_u3500d_vmx_f32
#define xasinh nsimd_sleef_asinh_u10d_vmx_f64
#define xasinhf nsimd_sleef_asinh_u10d_vmx_f32
#define xacosh nsimd_sleef_acosh_u10d_vmx_f64
#define xacoshf nsimd_sleef_acosh_u10d_vmx_f32
#define xatanh nsimd_sleef_atanh_u10d_vmx_f64
#define xatanhf nsimd_sleef_atanh_u10d_vmx_f32
#define xexp2 nsimd_sleef_exp2_u10d_vmx_f64
#define xexp2f nsimd_sleef_exp2_u10d_vmx_f32
#define xexp2_u35 nsimd_sleef_exp2_u35d_vmx_f64
#define xexp2f_u35 nsimd_sleef_exp2_u35d_vmx_f32
#define xexp10 nsimd_sleef_exp10_u10d_vmx_f64
#define xexp10f nsimd_sleef_exp10_u10d_vmx_f32
#define xexp10_u35 nsimd_sleef_exp10_u35d_vmx_f64
#define xexp10f_u35 nsimd_sleef_exp10_u35d_vmx_f32
#define xexpm1 nsimd_sleef_expm1_u10d_vmx_f64
#define xexpm1f nsimd_sleef_expm1_u10d_vmx_f32
#define xlog10 nsimd_sleef_log10_u10d_vmx_f64
#define xlog10f nsimd_sleef_log10_u10d_vmx_f32
#define xlog2 nsimd_sleef_log2_u10d_vmx_f64
#define xlog2f nsimd_sleef_log2_u10d_vmx_f32
#define xlog2_u35 nsimd_sleef_log2_u35d_vmx_f64
#define xlog2f_u35 nsimd_sleef_log2_u35d_vmx_f32
#define xlog1p nsimd_sleef_log1p_u10d_vmx_f64
#define xlog1pf nsimd_sleef_log1p_u10d_vmx_f32
#define xsincospi_u05 nsimd_sleef_sincospi_u05d_vmx_f64
#define xsincospif_u05 nsimd_sleef_sincospi_u05d_vmx_f32
#define xsincospi_u35 nsimd_sleef_sincospi_u35d_vmx_f64
#define xsincospif_u35 nsimd_sleef_sincospi_u35d_vmx_f32
#define xsinpi_u05 nsimd_sleef_sinpi_u05d_vmx_f64
#define xsinpif_u05 nsimd_sleef_sinpi_u05d_vmx_f32
#define xcospi_u05 nsimd_sleef_cospi_u05d_vmx_f64
#define xcospif_u05 nsimd_sleef_cospi_u05d_vmx_f32
#define xldexp nsimd_sleef_ldexp_vmx_f64
#define xldexpf nsimd_sleef_ldexp_vmx_f32
#define xilogb nsimd_sleef_ilogb_vmx_f64
#define xilogbf nsimd_sleef_ilogb_vmx_f32
#define xfma nsimd_sleef_fma_vmx_f64
#define xfmaf nsimd_sleef_fma_vmx_f32
#define xsqrt nsimd_sleef_sqrt_vmx_f64
#define xsqrtf nsimd_sleef_sqrt_vmx_f32
#define xsqrt_u05 nsimd_sleef_sqrt_u05d_vmx_f64
#define xsqrtf_u05 nsimd_sleef_sqrt_u05d_vmx_f32
#define xsqrt_u35 nsimd_sleef_sqrt_u35d_vmx_f64
#define xsqrtf_u35 nsimd_sleef_sqrt_u35d_vmx_f32
#define xhypot_u05 nsimd_sleef_hypot_u05d_vmx_f64
#define xhypotf_u05 nsimd_sleef_hypot_u05d_vmx_f32
#define xhypot_u35 nsimd_sleef_hypot_u35d_vmx_f64
#define xhypotf_u35 nsimd_sleef_hypot_u35d_vmx_f32
#define xfabs nsimd_sleef_fabs_vmx_f64
#define xfabsf nsimd_sleef_fabs_vmx_f32
#define xcopysign nsimd_sleef_copysign_vmx_f64
#define xcopysignf nsimd_sleef_copysign_vmx_f32
#define xfmax nsimd_sleef_fmax_vmx_f64
#define xfmaxf nsimd_sleef_fmax_vmx_f32
#define xfmin nsimd_sleef_fmin_vmx_f64
#define xfminf nsimd_sleef_fmin_vmx_f32
#define xfdim nsimd_sleef_fdim_vmx_f64
#define xfdimf nsimd_sleef_fdim_vmx_f32
#define xtrunc nsimd_sleef_trunc_vmx_f64
#define xtruncf nsimd_sleef_trunc_vmx_f32
#define xfloor nsimd_sleef_floor_vmx_f64
#define xfloorf nsimd_sleef_floor_vmx_f32
#define xceil nsimd_sleef_ceil_vmx_f64
#define xceilf nsimd_sleef_ceil_vmx_f32
#define xround nsimd_sleef_round_vmx_f64
#define xroundf nsimd_sleef_round_vmx_f32
#define xrint nsimd_sleef_rint_vmx_f64
#define xrintf nsimd_sleef_rint_vmx_f32
#define xnextafter nsimd_sleef_nextafter_vmx_f64
#define xnextafterf nsimd_sleef_nextafter_vmx_f32
#define xfrfrexp nsimd_sleef_frfrexp_vmx_f64
#define xfrfrexpf nsimd_sleef_frfrexp_vmx_f32
#define xexpfrexp nsimd_sleef_expfrexp_vmx_f64
#define xexpfrexpf nsimd_sleef_expfrexp_vmx_f32
#define xfmod nsimd_sleef_fmod_vmx_f64
#define xfmodf nsimd_sleef_fmod_vmx_f32
#define xremainder nsimd_sleef_remainder_vmx_f64
#define xremainderf nsimd_sleef_remainder_vmx_f32
#define xmodf nsimd_sleef_modf_vmx_f64
#define xmodff nsimd_sleef_modf_vmx_f32
#define xlgamma_u1 nsimd_sleef_lgamma_u10d_vmx_f64
#define xlgammaf_u1 nsimd_sleef_lgamma_u10d_vmx_f32
#define xtgamma_u1 nsimd_sleef_tgamma_u10d_vmx_f64
#define xtgammaf_u1 nsimd_sleef_tgamma_u10d_vmx_f32
#define xerf_u1 nsimd_sleef_erf_u10d_vmx_f64
#define xerff_u1 nsimd_sleef_erf_u10d_vmx_f32
#define xerfc_u15 nsimd_sleef_erfc_u15d_vmx_f64
#define xerfcf_u15 nsimd_sleef_erfc_u15d_vmx_f32
#define xgetInt nsimd_sleef_getInt_vmx_f64
#define xgetIntf nsimd_sleef_getInt_vmx_f32
#define xgetPtr nsimd_sleef_getPtr_vmx_f64
#define xgetPtrf nsimd_sleef_getPtr_vmx_f32
#else
#define xsin nsimd_sleef_sin_u35_vmx_f64
#define xsinf nsimd_sleef_sin_u35_vmx_f32
#define xcos nsimd_sleef_cos_u35_vmx_f64
#define xcosf nsimd_sleef_cos_u35_vmx_f32
#define xsincos nsimd_sleef_sincos_u35_vmx_f64
#define xsincosf nsimd_sleef_sincos_u35_vmx_f32
#define xtan nsimd_sleef_tan_u35_vmx_f64
#define xtanf nsimd_sleef_tan_u35_vmx_f32
#define xasin nsimd_sleef_asin_u35_vmx_f64
#define xasinf nsimd_sleef_asin_u35_vmx_f32
#define xacos nsimd_sleef_acos_u35_vmx_f64
#define xacosf nsimd_sleef_acos_u35_vmx_f32
#define xatan nsimd_sleef_atan_u35_vmx_f64
#define xatanf nsimd_sleef_atan_u35_vmx_f32
#define xatan2 nsimd_sleef_atan2_u35_vmx_f64
#define xatan2f nsimd_sleef_atan2_u35_vmx_f32
#define xlog nsimd_sleef_log_u35_vmx_f64
#define xlogf nsimd_sleef_log_u35_vmx_f32
#define xcbrt nsimd_sleef_cbrt_u35_vmx_f64
#define xcbrtf nsimd_sleef_cbrt_u35_vmx_f32
#define xsin_u1 nsimd_sleef_sin_u10_vmx_f64
#define xsinf_u1 nsimd_sleef_sin_u10_vmx_f32
#define xcos_u1 nsimd_sleef_cos_u10_vmx_f64
#define xcosf_u1 nsimd_sleef_cos_u10_vmx_f32
#define xsincos_u1 nsimd_sleef_sincos_u10_vmx_f64
#define xsincosf_u1 nsimd_sleef_sincos_u10_vmx_f32
#define xtan_u1 nsimd_sleef_tan_u10_vmx_f64
#define xtanf_u1 nsimd_sleef_tan_u10_vmx_f32
#define xasin_u1 nsimd_sleef_asin_u10_vmx_f64
#define xasinf_u1 nsimd_sleef_asin_u10_vmx_f32
#define xacos_u1 nsimd_sleef_acos_u10_vmx_f64
#define xacosf_u1 nsimd_sleef_acos_u10_vmx_f32
#define xatan_u1 nsimd_sleef_atan_u10_vmx_f64
#define xatanf_u1 nsimd_sleef_atan_u10_vmx_f32
#define xatan2_u1 nsimd_sleef_atan2_u10_vmx_f64
#define xatan2f_u1 nsimd_sleef_atan2_u10_vmx_f32
#define xlog_u1 nsimd_sleef_log_u10_vmx_f64
#define xlogf_u1 nsimd_sleef_log_u10_vmx_f32
#define xcbrt_u1 nsimd_sleef_cbrt_u10_vmx_f64
#define xcbrtf_u1 nsimd_sleef_cbrt_u10_vmx_f32
#define xexp nsimd_sleef_exp_u10_vmx_f64
#define xexpf nsimd_sleef_exp_u10_vmx_f32
#define xpow nsimd_sleef_pow_u10_vmx_f64
#define xpowf nsimd_sleef_pow_u10_vmx_f32
#define xsinh nsimd_sleef_sinh_u10_vmx_f64
#define xsinhf nsimd_sleef_sinh_u10_vmx_f32
#define xcosh nsimd_sleef_cosh_u10_vmx_f64
#define xcoshf nsimd_sleef_cosh_u10_vmx_f32
#define xtanh nsimd_sleef_tanh_u10_vmx_f64
#define xtanhf nsimd_sleef_tanh_u10_vmx_f32
#define xsinh_u35 nsimd_sleef_sinh_u35_vmx_f64
#define xsinhf_u35 nsimd_sleef_sinh_u35_vmx_f32
#define xcosh_u35 nsimd_sleef_cosh_u35_vmx_f64
#define xcoshf_u35 nsimd_sleef_cosh_u35_vmx_f32
#define xtanh_u35 nsimd_sleef_tanh_u35_vmx_f64
#define xtanhf_u35 nsimd_sleef_tanh_u35_vmx_f32
#define xfastsin_u3500 nsimd_sleef_fastsin_u3500_vmx_f64
#define xfastsinf_u3500 nsimd_sleef_fastsin_u3500_vmx_f32
#define xfastcos_u3500 nsimd_sleef_fastcos_u3500_vmx_f64
#define xfastcosf_u3500 nsimd_sleef_fastcos_u3500_vmx_f32
#define xfastpow_u3500 nsimd_sleef_fastpow_u3500_vmx_f64
#define xfastpowf_u3500 nsimd_sleef_fastpow_u3500_vmx_f32
#define xasinh nsimd_sleef_asinh_u10_vmx_f64
#define xasinhf nsimd_sleef_asinh_u10_vmx_f32
#define xacosh nsimd_sleef_acosh_u10_vmx_f64
#define xacoshf nsimd_sleef_acosh_u10_vmx_f32
#define xatanh nsimd_sleef_atanh_u10_vmx_f64
#define xatanhf nsimd_sleef_atanh_u10_vmx_f32
#define xexp2 nsimd_sleef_exp2_u10_vmx_f64
#define xexp2f nsimd_sleef_exp2_u10_vmx_f32
#define xexp2_u35 nsimd_sleef_exp2_u35_vmx_f64
#define xexp2f_u35 nsimd_sleef_exp2_u35_vmx_f32
#define xexp10 nsimd_sleef_exp10_u10_vmx_f64
#define xexp10f nsimd_sleef_exp10_u10_vmx_f32
#define xexp10_u35 nsimd_sleef_exp10_u35_vmx_f64
#define xexp10f_u35 nsimd_sleef_exp10_u35_vmx_f32
#define xexpm1 nsimd_sleef_expm1_u10_vmx_f64
#define xexpm1f nsimd_sleef_expm1_u10_vmx_f32
#define xlog10 nsimd_sleef_log10_u10_vmx_f64
#define xlog10f nsimd_sleef_log10_u10_vmx_f32
#define xlog2 nsimd_sleef_log2_u10_vmx_f64
#define xlog2f nsimd_sleef_log2_u10_vmx_f32
#define xlog2_u35 nsimd_sleef_log2_u35_vmx_f64
#define xlog2f_u35 nsimd_sleef_log2_u35_vmx_f32
#define xlog1p nsimd_sleef_log1p_u10_vmx_f64
#define xlog1pf nsimd_sleef_log1p_u10_vmx_f32
#define xsincospi_u05 nsimd_sleef_sincospi_u05_vmx_f64
#define xsincospif_u05 nsimd_sleef_sincospi_u05_vmx_f32
#define xsincospi_u35 nsimd_sleef_sincospi_u35_vmx_f64
#define xsincospif_u35 nsimd_sleef_sincospi_u35_vmx_f32
#define xsinpi_u05 nsimd_sleef_sinpi_u05_vmx_f64
#define xsinpif_u05 nsimd_sleef_sinpi_u05_vmx_f32
#define xcospi_u05 nsimd_sleef_cospi_u05_vmx_f64
#define xcospif_u05 nsimd_sleef_cospi_u05_vmx_f32
#define xldexp nsimd_sleef_ldexp_vmx_f64
#define xldexpf nsimd_sleef_ldexp_vmx_f32
#define xilogb nsimd_sleef_ilogb_vmx_f64
#define xilogbf nsimd_sleef_ilogb_vmx_f32
#define xfma nsimd_sleef_fma_vmx_f64
#define xfmaf nsimd_sleef_fma_vmx_f32
#define xsqrt nsimd_sleef_sqrt_vmx_f64
#define xsqrtf nsimd_sleef_sqrt_vmx_f32
#define xsqrt_u05 nsimd_sleef_sqrt_u05_vmx_f64
#define xsqrtf_u05 nsimd_sleef_sqrt_u05_vmx_f32
#define xsqrt_u35 nsimd_sleef_sqrt_u35_vmx_f64
#define xsqrtf_u35 nsimd_sleef_sqrt_u35_vmx_f32
#define xhypot_u05 nsimd_sleef_hypot_u05_vmx_f64
#define xhypotf_u05 nsimd_sleef_hypot_u05_vmx_f32
#define xhypot_u35 nsimd_sleef_hypot_u35_vmx_f64
#define xhypotf_u35 nsimd_sleef_hypot_u35_vmx_f32
#define xfabs nsimd_sleef_fabs_vmx_f64
#define xfabsf nsimd_sleef_fabs_vmx_f32
#define xcopysign nsimd_sleef_copysign_vmx_f64
#define xcopysignf nsimd_sleef_copysign_vmx_f32
#define xfmax nsimd_sleef_fmax_vmx_f64
#define xfmaxf nsimd_sleef_fmax_vmx_f32
#define xfmin nsimd_sleef_fmin_vmx_f64
#define xfminf nsimd_sleef_fmin_vmx_f32
#define xfdim nsimd_sleef_fdim_vmx_f64
#define xfdimf nsimd_sleef_fdim_vmx_f32
#define xtrunc nsimd_sleef_trunc_vmx_f64
#define xtruncf nsimd_sleef_trunc_vmx_f32
#define xfloor nsimd_sleef_floor_vmx_f64
#define xfloorf nsimd_sleef_floor_vmx_f32
#define xceil nsimd_sleef_ceil_vmx_f64
#define xceilf nsimd_sleef_ceil_vmx_f32
#define xround nsimd_sleef_round_vmx_f64
#define xroundf nsimd_sleef_round_vmx_f32
#define xrint nsimd_sleef_rint_vmx_f64
#define xrintf nsimd_sleef_rint_vmx_f32
#define xnextafter nsimd_sleef_nextafter_vmx_f64
#define xnextafterf nsimd_sleef_nextafter_vmx_f32
#define xfrfrexp nsimd_sleef_frfrexp_vmx_f64
#define xfrfrexpf nsimd_sleef_frfrexp_vmx_f32
#define xexpfrexp nsimd_sleef_expfrexp_vmx_f64
#define xexpfrexpf nsimd_sleef_expfrexp_vmx_f32
#define xfmod nsimd_sleef_fmod_vmx_f64
#define xfmodf nsimd_sleef_fmod_vmx_f32
#define xremainder nsimd_sleef_remainder_vmx_f64
#define xremainderf nsimd_sleef_remainder_vmx_f32
#define xmodf nsimd_sleef_modf_vmx_f64
#define xmodff nsimd_sleef_modf_vmx_f32
#define xlgamma_u1 nsimd_sleef_lgamma_u10_vmx_f64
#define xlgammaf_u1 nsimd_sleef_lgamma_u10_vmx_f32
#define xtgamma_u1 nsimd_sleef_tgamma_u10_vmx_f64
#define xtgammaf_u1 nsimd_sleef_tgamma_u10_vmx_f32
#define xerf_u1 nsimd_sleef_erf_u10_vmx_f64
#define xerff_u1 nsimd_sleef_erf_u10_vmx_f32
#define xerfc_u15 nsimd_sleef_erfc_u15_vmx_f64
#define xerfcf_u15 nsimd_sleef_erfc_u15_vmx_f32
#define xgetInt nsimd_sleef_getInt_vmx_f64
#define xgetIntf nsimd_sleef_getInt_vmx_f32
#define xgetPtr nsimd_sleef_getPtr_vmx_f64
#define xgetPtrf nsimd_sleef_getPtr_vmx_f32
#endif
#define rempi nsimd_sleef_rempi_vmx
#define rempif nsimd_sleef_rempif_vmx
#define rempisub nsimd_sleef_rempisub_vmx
#define rempisubf nsimd_sleef_rempisubf_vmx
#define gammak nsimd_gammak_vmx
#define gammafk nsimd_gammafk_vmx
#endif
/* ------------------------------------------------------------------------- */
/* Naming of functions vsx */
#ifdef NSIMD_VSX
#ifdef DETERMINISTIC
#define xsin nsimd_sleef_sin_u35d_vsx_f64
#define xsinf nsimd_sleef_sin_u35d_vsx_f32
#define xcos nsimd_sleef_cos_u35d_vsx_f64
#define xcosf nsimd_sleef_cos_u35d_vsx_f32
#define xsincos nsimd_sleef_sincos_u35d_vsx_f64
#define xsincosf nsimd_sleef_sincos_u35d_vsx_f32
#define xtan nsimd_sleef_tan_u35d_vsx_f64
#define xtanf nsimd_sleef_tan_u35d_vsx_f32
#define xasin nsimd_sleef_asin_u35d_vsx_f64
#define xasinf nsimd_sleef_asin_u35d_vsx_f32
#define xacos nsimd_sleef_acos_u35d_vsx_f64
#define xacosf nsimd_sleef_acos_u35d_vsx_f32
#define xatan nsimd_sleef_atan_u35d_vsx_f64
#define xatanf nsimd_sleef_atan_u35d_vsx_f32
#define xatan2 nsimd_sleef_atan2_u35d_vsx_f64
#define xatan2f nsimd_sleef_atan2_u35d_vsx_f32
#define xlog nsimd_sleef_log_u35d_vsx_f64
#define xlogf nsimd_sleef_log_u35d_vsx_f32
#define xcbrt nsimd_sleef_cbrt_u35d_vsx_f64
#define xcbrtf nsimd_sleef_cbrt_u35d_vsx_f32
#define xsin_u1 nsimd_sleef_sin_u10d_vsx_f64
#define xsinf_u1 nsimd_sleef_sin_u10d_vsx_f32
#define xcos_u1 nsimd_sleef_cos_u10d_vsx_f64
#define xcosf_u1 nsimd_sleef_cos_u10d_vsx_f32
#define xsincos_u1 nsimd_sleef_sincos_u10d_vsx_f64
#define xsincosf_u1 nsimd_sleef_sincos_u10d_vsx_f32
#define xtan_u1 nsimd_sleef_tan_u10d_vsx_f64
#define xtanf_u1 nsimd_sleef_tan_u10d_vsx_f32
#define xasin_u1 nsimd_sleef_asin_u10d_vsx_f64
#define xasinf_u1 nsimd_sleef_asin_u10d_vsx_f32
#define xacos_u1 nsimd_sleef_acos_u10d_vsx_f64
#define xacosf_u1 nsimd_sleef_acos_u10d_vsx_f32
#define xatan_u1 nsimd_sleef_atan_u10d_vsx_f64
#define xatanf_u1 nsimd_sleef_atan_u10d_vsx_f32
#define xatan2_u1 nsimd_sleef_atan2_u10d_vsx_f64
#define xatan2f_u1 nsimd_sleef_atan2_u10d_vsx_f32
#define xlog_u1 nsimd_sleef_log_u10d_vsx_f64
#define xlogf_u1 nsimd_sleef_log_u10d_vsx_f32
#define xcbrt_u1 nsimd_sleef_cbrt_u10d_vsx_f64
#define xcbrtf_u1 nsimd_sleef_cbrt_u10d_vsx_f32
#define xexp nsimd_sleef_exp_u10d_vsx_f64
#define xexpf nsimd_sleef_exp_u10d_vsx_f32
#define xpow nsimd_sleef_pow_u10d_vsx_f64
#define xpowf nsimd_sleef_pow_u10d_vsx_f32
#define xsinh nsimd_sleef_sinh_u10d_vsx_f64
#define xsinhf nsimd_sleef_sinh_u10d_vsx_f32
#define xcosh nsimd_sleef_cosh_u10d_vsx_f64
#define xcoshf nsimd_sleef_cosh_u10d_vsx_f32
#define xtanh nsimd_sleef_tanh_u10d_vsx_f64
#define xtanhf nsimd_sleef_tanh_u10d_vsx_f32
#define xsinh_u35 nsimd_sleef_sinh_u35d_vsx_f64
#define xsinhf_u35 nsimd_sleef_sinh_u35d_vsx_f32
#define xcosh_u35 nsimd_sleef_cosh_u35d_vsx_f64
#define xcoshf_u35 nsimd_sleef_cosh_u35d_vsx_f32
#define xtanh_u35 nsimd_sleef_tanh_u35d_vsx_f64
#define xtanhf_u35 nsimd_sleef_tanh_u35d_vsx_f32
#define xfastsin_u3500 nsimd_sleef_fastsin_u3500d_vsx_f64
#define xfastsinf_u3500 nsimd_sleef_fastsin_u3500d_vsx_f32
#define xfastcos_u3500 nsimd_sleef_fastcos_u3500d_vsx_f64
#define xfastcosf_u3500 nsimd_sleef_fastcos_u3500d_vsx_f32
#define xfastpow_u3500 nsimd_sleef_fastpow_u3500d_vsx_f64
#define xfastpowf_u3500 nsimd_sleef_fastpow_u3500d_vsx_f32
#define xasinh nsimd_sleef_asinh_u10d_vsx_f64
#define xasinhf nsimd_sleef_asinh_u10d_vsx_f32
#define xacosh nsimd_sleef_acosh_u10d_vsx_f64
#define xacoshf nsimd_sleef_acosh_u10d_vsx_f32
#define xatanh nsimd_sleef_atanh_u10d_vsx_f64
#define xatanhf nsimd_sleef_atanh_u10d_vsx_f32
#define xexp2 nsimd_sleef_exp2_u10d_vsx_f64
#define xexp2f nsimd_sleef_exp2_u10d_vsx_f32
#define xexp2_u35 nsimd_sleef_exp2_u35d_vsx_f64
#define xexp2f_u35 nsimd_sleef_exp2_u35d_vsx_f32
#define xexp10 nsimd_sleef_exp10_u10d_vsx_f64
#define xexp10f nsimd_sleef_exp10_u10d_vsx_f32
#define xexp10_u35 nsimd_sleef_exp10_u35d_vsx_f64
#define xexp10f_u35 nsimd_sleef_exp10_u35d_vsx_f32
#define xexpm1 nsimd_sleef_expm1_u10d_vsx_f64
#define xexpm1f nsimd_sleef_expm1_u10d_vsx_f32
#define xlog10 nsimd_sleef_log10_u10d_vsx_f64
#define xlog10f nsimd_sleef_log10_u10d_vsx_f32
#define xlog2 nsimd_sleef_log2_u10d_vsx_f64
#define xlog2f nsimd_sleef_log2_u10d_vsx_f32
#define xlog2_u35 nsimd_sleef_log2_u35d_vsx_f64
#define xlog2f_u35 nsimd_sleef_log2_u35d_vsx_f32
#define xlog1p nsimd_sleef_log1p_u10d_vsx_f64
#define xlog1pf nsimd_sleef_log1p_u10d_vsx_f32
#define xsincospi_u05 nsimd_sleef_sincospi_u05d_vsx_f64
#define xsincospif_u05 nsimd_sleef_sincospi_u05d_vsx_f32
#define xsincospi_u35 nsimd_sleef_sincospi_u35d_vsx_f64
#define xsincospif_u35 nsimd_sleef_sincospi_u35d_vsx_f32
#define xsinpi_u05 nsimd_sleef_sinpi_u05d_vsx_f64
#define xsinpif_u05 nsimd_sleef_sinpi_u05d_vsx_f32
#define xcospi_u05 nsimd_sleef_cospi_u05d_vsx_f64
#define xcospif_u05 nsimd_sleef_cospi_u05d_vsx_f32
#define xldexp nsimd_sleef_ldexp_vsx_f64
#define xldexpf nsimd_sleef_ldexp_vsx_f32
#define xilogb nsimd_sleef_ilogb_vsx_f64
#define xilogbf nsimd_sleef_ilogb_vsx_f32
#define xfma nsimd_sleef_fma_vsx_f64
#define xfmaf nsimd_sleef_fma_vsx_f32
#define xsqrt nsimd_sleef_sqrt_vsx_f64
#define xsqrtf nsimd_sleef_sqrt_vsx_f32
#define xsqrt_u05 nsimd_sleef_sqrt_u05d_vsx_f64
#define xsqrtf_u05 nsimd_sleef_sqrt_u05d_vsx_f32
#define xsqrt_u35 nsimd_sleef_sqrt_u35d_vsx_f64
#define xsqrtf_u35 nsimd_sleef_sqrt_u35d_vsx_f32
#define xhypot_u05 nsimd_sleef_hypot_u05d_vsx_f64
#define xhypotf_u05 nsimd_sleef_hypot_u05d_vsx_f32
#define xhypot_u35 nsimd_sleef_hypot_u35d_vsx_f64
#define xhypotf_u35 nsimd_sleef_hypot_u35d_vsx_f32
#define xfabs nsimd_sleef_fabs_vsx_f64
#define xfabsf nsimd_sleef_fabs_vsx_f32
#define xcopysign nsimd_sleef_copysign_vsx_f64
#define xcopysignf nsimd_sleef_copysign_vsx_f32
#define xfmax nsimd_sleef_fmax_vsx_f64
#define xfmaxf nsimd_sleef_fmax_vsx_f32
#define xfmin nsimd_sleef_fmin_vsx_f64
#define xfminf nsimd_sleef_fmin_vsx_f32
#define xfdim nsimd_sleef_fdim_vsx_f64
#define xfdimf nsimd_sleef_fdim_vsx_f32
#define xtrunc nsimd_sleef_trunc_vsx_f64
#define xtruncf nsimd_sleef_trunc_vsx_f32
#define xfloor nsimd_sleef_floor_vsx_f64
#define xfloorf nsimd_sleef_floor_vsx_f32
#define xceil nsimd_sleef_ceil_vsx_f64
#define xceilf nsimd_sleef_ceil_vsx_f32
#define xround nsimd_sleef_round_vsx_f64
#define xroundf nsimd_sleef_round_vsx_f32
#define xrint nsimd_sleef_rint_vsx_f64
#define xrintf nsimd_sleef_rint_vsx_f32
#define xnextafter nsimd_sleef_nextafter_vsx_f64
#define xnextafterf nsimd_sleef_nextafter_vsx_f32
#define xfrfrexp nsimd_sleef_frfrexp_vsx_f64
#define xfrfrexpf nsimd_sleef_frfrexp_vsx_f32
#define xexpfrexp nsimd_sleef_expfrexp_vsx_f64
#define xexpfrexpf nsimd_sleef_expfrexp_vsx_f32
#define xfmod nsimd_sleef_fmod_vsx_f64
#define xfmodf nsimd_sleef_fmod_vsx_f32
#define xremainder nsimd_sleef_remainder_vsx_f64
#define xremainderf nsimd_sleef_remainder_vsx_f32
#define xmodf nsimd_sleef_modf_vsx_f64
#define xmodff nsimd_sleef_modf_vsx_f32
#define xlgamma_u1 nsimd_sleef_lgamma_u10d_vsx_f64
#define xlgammaf_u1 nsimd_sleef_lgamma_u10d_vsx_f32
#define xtgamma_u1 nsimd_sleef_tgamma_u10d_vsx_f64
#define xtgammaf_u1 nsimd_sleef_tgamma_u10d_vsx_f32
#define xerf_u1 nsimd_sleef_erf_u10d_vsx_f64
#define xerff_u1 nsimd_sleef_erf_u10d_vsx_f32
#define xerfc_u15 nsimd_sleef_erfc_u15d_vsx_f64
#define xerfcf_u15 nsimd_sleef_erfc_u15d_vsx_f32
#define xgetInt nsimd_sleef_getInt_vsx_f64
#define xgetIntf nsimd_sleef_getInt_vsx_f32
#define xgetPtr nsimd_sleef_getPtr_vsx_f64
#define xgetPtrf nsimd_sleef_getPtr_vsx_f32
#else
#define xsin nsimd_sleef_sin_u35_vsx_f64
#define xsinf nsimd_sleef_sin_u35_vsx_f32
#define xcos nsimd_sleef_cos_u35_vsx_f64
#define xcosf nsimd_sleef_cos_u35_vsx_f32
#define xsincos nsimd_sleef_sincos_u35_vsx_f64
#define xsincosf nsimd_sleef_sincos_u35_vsx_f32
#define xtan nsimd_sleef_tan_u35_vsx_f64
#define xtanf nsimd_sleef_tan_u35_vsx_f32
#define xasin nsimd_sleef_asin_u35_vsx_f64
#define xasinf nsimd_sleef_asin_u35_vsx_f32
#define xacos nsimd_sleef_acos_u35_vsx_f64
#define xacosf nsimd_sleef_acos_u35_vsx_f32
#define xatan nsimd_sleef_atan_u35_vsx_f64
#define xatanf nsimd_sleef_atan_u35_vsx_f32
#define xatan2 nsimd_sleef_atan2_u35_vsx_f64
#define xatan2f nsimd_sleef_atan2_u35_vsx_f32
#define xlog nsimd_sleef_log_u35_vsx_f64
#define xlogf nsimd_sleef_log_u35_vsx_f32
#define xcbrt nsimd_sleef_cbrt_u35_vsx_f64
#define xcbrtf nsimd_sleef_cbrt_u35_vsx_f32
#define xsin_u1 nsimd_sleef_sin_u10_vsx_f64
#define xsinf_u1 nsimd_sleef_sin_u10_vsx_f32
#define xcos_u1 nsimd_sleef_cos_u10_vsx_f64
#define xcosf_u1 nsimd_sleef_cos_u10_vsx_f32
#define xsincos_u1 nsimd_sleef_sincos_u10_vsx_f64
#define xsincosf_u1 nsimd_sleef_sincos_u10_vsx_f32
#define xtan_u1 nsimd_sleef_tan_u10_vsx_f64
#define xtanf_u1 nsimd_sleef_tan_u10_vsx_f32
#define xasin_u1 nsimd_sleef_asin_u10_vsx_f64
#define xasinf_u1 nsimd_sleef_asin_u10_vsx_f32
#define xacos_u1 nsimd_sleef_acos_u10_vsx_f64
#define xacosf_u1 nsimd_sleef_acos_u10_vsx_f32
#define xatan_u1 nsimd_sleef_atan_u10_vsx_f64
#define xatanf_u1 nsimd_sleef_atan_u10_vsx_f32
#define xatan2_u1 nsimd_sleef_atan2_u10_vsx_f64
#define xatan2f_u1 nsimd_sleef_atan2_u10_vsx_f32
#define xlog_u1 nsimd_sleef_log_u10_vsx_f64
#define xlogf_u1 nsimd_sleef_log_u10_vsx_f32
#define xcbrt_u1 nsimd_sleef_cbrt_u10_vsx_f64
#define xcbrtf_u1 nsimd_sleef_cbrt_u10_vsx_f32
#define xexp nsimd_sleef_exp_u10_vsx_f64
#define xexpf nsimd_sleef_exp_u10_vsx_f32
#define xpow nsimd_sleef_pow_u10_vsx_f64
#define xpowf nsimd_sleef_pow_u10_vsx_f32
#define xsinh nsimd_sleef_sinh_u10_vsx_f64
#define xsinhf nsimd_sleef_sinh_u10_vsx_f32
#define xcosh nsimd_sleef_cosh_u10_vsx_f64
#define xcoshf nsimd_sleef_cosh_u10_vsx_f32
#define xtanh nsimd_sleef_tanh_u10_vsx_f64
#define xtanhf nsimd_sleef_tanh_u10_vsx_f32
#define xsinh_u35 nsimd_sleef_sinh_u35_vsx_f64
#define xsinhf_u35 nsimd_sleef_sinh_u35_vsx_f32
#define xcosh_u35 nsimd_sleef_cosh_u35_vsx_f64
#define xcoshf_u35 nsimd_sleef_cosh_u35_vsx_f32
#define xtanh_u35 nsimd_sleef_tanh_u35_vsx_f64
#define xtanhf_u35 nsimd_sleef_tanh_u35_vsx_f32
#define xfastsin_u3500 nsimd_sleef_fastsin_u3500_vsx_f64
#define xfastsinf_u3500 nsimd_sleef_fastsin_u3500_vsx_f32
#define xfastcos_u3500 nsimd_sleef_fastcos_u3500_vsx_f64
#define xfastcosf_u3500 nsimd_sleef_fastcos_u3500_vsx_f32
#define xfastpow_u3500 nsimd_sleef_fastpow_u3500_vsx_f64
#define xfastpowf_u3500 nsimd_sleef_fastpow_u3500_vsx_f32
#define xasinh nsimd_sleef_asinh_u10_vsx_f64
#define xasinhf nsimd_sleef_asinh_u10_vsx_f32
#define xacosh nsimd_sleef_acosh_u10_vsx_f64
#define xacoshf nsimd_sleef_acosh_u10_vsx_f32
#define xatanh nsimd_sleef_atanh_u10_vsx_f64
#define xatanhf nsimd_sleef_atanh_u10_vsx_f32
#define xexp2 nsimd_sleef_exp2_u10_vsx_f64
#define xexp2f nsimd_sleef_exp2_u10_vsx_f32
#define xexp2_u35 nsimd_sleef_exp2_u35_vsx_f64
#define xexp2f_u35 nsimd_sleef_exp2_u35_vsx_f32
#define xexp10 nsimd_sleef_exp10_u10_vsx_f64
#define xexp10f nsimd_sleef_exp10_u10_vsx_f32
#define xexp10_u35 nsimd_sleef_exp10_u35_vsx_f64
#define xexp10f_u35 nsimd_sleef_exp10_u35_vsx_f32
#define xexpm1 nsimd_sleef_expm1_u10_vsx_f64
#define xexpm1f nsimd_sleef_expm1_u10_vsx_f32
#define xlog10 nsimd_sleef_log10_u10_vsx_f64
#define xlog10f nsimd_sleef_log10_u10_vsx_f32
#define xlog2 nsimd_sleef_log2_u10_vsx_f64
#define xlog2f nsimd_sleef_log2_u10_vsx_f32
#define xlog2_u35 nsimd_sleef_log2_u35_vsx_f64
#define xlog2f_u35 nsimd_sleef_log2_u35_vsx_f32
#define xlog1p nsimd_sleef_log1p_u10_vsx_f64
#define xlog1pf nsimd_sleef_log1p_u10_vsx_f32
#define xsincospi_u05 nsimd_sleef_sincospi_u05_vsx_f64
#define xsincospif_u05 nsimd_sleef_sincospi_u05_vsx_f32
#define xsincospi_u35 nsimd_sleef_sincospi_u35_vsx_f64
#define xsincospif_u35 nsimd_sleef_sincospi_u35_vsx_f32
#define xsinpi_u05 nsimd_sleef_sinpi_u05_vsx_f64
#define xsinpif_u05 nsimd_sleef_sinpi_u05_vsx_f32
#define xcospi_u05 nsimd_sleef_cospi_u05_vsx_f64
#define xcospif_u05 nsimd_sleef_cospi_u05_vsx_f32
#define xldexp nsimd_sleef_ldexp_vsx_f64
#define xldexpf nsimd_sleef_ldexp_vsx_f32
#define xilogb nsimd_sleef_ilogb_vsx_f64
#define xilogbf nsimd_sleef_ilogb_vsx_f32
#define xfma nsimd_sleef_fma_vsx_f64
#define xfmaf nsimd_sleef_fma_vsx_f32
#define xsqrt nsimd_sleef_sqrt_vsx_f64
#define xsqrtf nsimd_sleef_sqrt_vsx_f32
#define xsqrt_u05 nsimd_sleef_sqrt_u05_vsx_f64
#define xsqrtf_u05 nsimd_sleef_sqrt_u05_vsx_f32
#define xsqrt_u35 nsimd_sleef_sqrt_u35_vsx_f64
#define xsqrtf_u35 nsimd_sleef_sqrt_u35_vsx_f32
#define xhypot_u05 nsimd_sleef_hypot_u05_vsx_f64
#define xhypotf_u05 nsimd_sleef_hypot_u05_vsx_f32
#define xhypot_u35 nsimd_sleef_hypot_u35_vsx_f64
#define xhypotf_u35 nsimd_sleef_hypot_u35_vsx_f32
#define xfabs nsimd_sleef_fabs_vsx_f64
#define xfabsf nsimd_sleef_fabs_vsx_f32
#define xcopysign nsimd_sleef_copysign_vsx_f64
#define xcopysignf nsimd_sleef_copysign_vsx_f32
#define xfmax nsimd_sleef_fmax_vsx_f64
#define xfmaxf nsimd_sleef_fmax_vsx_f32
#define xfmin nsimd_sleef_fmin_vsx_f64
#define xfminf nsimd_sleef_fmin_vsx_f32
#define xfdim nsimd_sleef_fdim_vsx_f64
#define xfdimf nsimd_sleef_fdim_vsx_f32
#define xtrunc nsimd_sleef_trunc_vsx_f64
#define xtruncf nsimd_sleef_trunc_vsx_f32
#define xfloor nsimd_sleef_floor_vsx_f64
#define xfloorf nsimd_sleef_floor_vsx_f32
#define xceil nsimd_sleef_ceil_vsx_f64
#define xceilf nsimd_sleef_ceil_vsx_f32
#define xround nsimd_sleef_round_vsx_f64
#define xroundf nsimd_sleef_round_vsx_f32
#define xrint nsimd_sleef_rint_vsx_f64
#define xrintf nsimd_sleef_rint_vsx_f32
#define xnextafter nsimd_sleef_nextafter_vsx_f64
#define xnextafterf nsimd_sleef_nextafter_vsx_f32
#define xfrfrexp nsimd_sleef_frfrexp_vsx_f64
#define xfrfrexpf nsimd_sleef_frfrexp_vsx_f32
#define xexpfrexp nsimd_sleef_expfrexp_vsx_f64
#define xexpfrexpf nsimd_sleef_expfrexp_vsx_f32
#define xfmod nsimd_sleef_fmod_vsx_f64
#define xfmodf nsimd_sleef_fmod_vsx_f32
#define xremainder nsimd_sleef_remainder_vsx_f64
#define xremainderf nsimd_sleef_remainder_vsx_f32
#define xmodf nsimd_sleef_modf_vsx_f64
#define xmodff nsimd_sleef_modf_vsx_f32
#define xlgamma_u1 nsimd_sleef_lgamma_u10_vsx_f64
#define xlgammaf_u1 nsimd_sleef_lgamma_u10_vsx_f32
#define xtgamma_u1 nsimd_sleef_tgamma_u10_vsx_f64
#define xtgammaf_u1 nsimd_sleef_tgamma_u10_vsx_f32
#define xerf_u1 nsimd_sleef_erf_u10_vsx_f64
#define xerff_u1 nsimd_sleef_erf_u10_vsx_f32
#define xerfc_u15 nsimd_sleef_erfc_u15_vsx_f64
#define xerfcf_u15 nsimd_sleef_erfc_u15_vsx_f32
#define xgetInt nsimd_sleef_getInt_vsx_f64
#define xgetIntf nsimd_sleef_getInt_vsx_f32
#define xgetPtr nsimd_sleef_getPtr_vsx_f64
#define xgetPtrf nsimd_sleef_getPtr_vsx_f32
#endif
#define rempi nsimd_sleef_rempi_vsx
#define rempif nsimd_sleef_rempif_vsx
#define rempisub nsimd_sleef_rempisub_vsx
#define rempisubf nsimd_sleef_rempisubf_vsx
#define gammak nsimd_gammak_vsx
#define gammafk nsimd_gammafk_vsx
#endif
#endif
| 44.408683 | 98 | 0.887207 |
dd28af5b6d160a5aec6755a9f7c3cc9fd5c2c4af | 703 | h | C | hpopt/include/dirhelper.h | ravimanumachu/hclmpifft | f97918312bd80ef2da64342660ee1265816f88ca | [
"BSD-3-Clause"
] | null | null | null | hpopt/include/dirhelper.h | ravimanumachu/hclmpifft | f97918312bd80ef2da64342660ee1265816f88ca | [
"BSD-3-Clause"
] | null | null | null | hpopt/include/dirhelper.h | ravimanumachu/hclmpifft | f97918312bd80ef2da64342660ee1265816f88ca | [
"BSD-3-Clause"
] | null | null | null | /*--------------------------------------------------------*/
/*
@file
@author Hamidreza Khaleghzadeh <hamidreza.khaleghzadeh@ucdconnect.ie>
@version 1.0
*/
/*--------------------------------------------------------*/
#ifndef _DIRECTORY_HELPER_H
#define _DIRECTORY_HELPER_H
/*--------------------------------------------------------*/
class DirOperations
{
public:
/*--------------------------------------------------------*/
// This function returns the number of all files existing in the path dPath
int countFiles (char *dPath);
// this function returns the names of all files in the path dPath
void fileNames (char *dPath, char **fNames);
};
#endif // _DIRECTORY_HELPER_H
| 23.433333 | 77 | 0.477952 |
f7b4a90ce51b1f5ec11e83237736628d30b14bf0 | 1,290 | h | C | code/include/tetromino.h | badeball/tetris-ea | 7b5b2480dd7672855822188bdee63f608720bee8 | [
"MIT"
] | 1 | 2017-05-13T13:53:07.000Z | 2017-05-13T13:53:07.000Z | code/include/tetromino.h | badeball/tetris-ea | 7b5b2480dd7672855822188bdee63f608720bee8 | [
"MIT"
] | null | null | null | code/include/tetromino.h | badeball/tetris-ea | 7b5b2480dd7672855822188bdee63f608720bee8 | [
"MIT"
] | null | null | null | #ifndef PIECE_H
#define PIECE_H
#include "structs.h"
#define N_TETROMINO(tetromino, n) \
if (n == 0) { \
*tetromino = 0; \
} else if(n == 1) { \
*tetromino = 1; \
} else if(n == 2) { \
*tetromino = 3; \
} else if(n == 3) { \
*tetromino = 5; \
} else if(n == 4) { \
*tetromino = 7; \
} else if(n == 5) { \
*tetromino = 11; \
} else if(n == 6) { \
*tetromino = 15; \
}
#define N_ROTATIONS(rotation, n) \
if (n == 0) { \
*rotation = 1; \
} else if(n == 1) { \
*rotation = 2; \
} else if(n == 3) { \
*rotation = 2; \
} else if(n == 5) { \
*rotation = 2; \
} else if(n == 7) { \
*rotation = 4; \
} else if(n == 11) { \
*rotation = 4; \
} else if(n == 15) { \
*rotation = 4; \
}
int place_tetromino (struct board * board, struct tetromino * tetromino, int position, int * placement);
int random_tetromino (struct options* opt);
#endif | 30 | 104 | 0.353488 |
e3ec64c87dccc2dae0403f02da754f587b6537f2 | 872 | c | C | lib/wizards/aarrgh/ship/parrot.c | vlehtola/questmud | 8bc3099b5ad00a9e0261faeb6637c76b521b6dbe | [
"MIT"
] | null | null | null | lib/wizards/aarrgh/ship/parrot.c | vlehtola/questmud | 8bc3099b5ad00a9e0261faeb6637c76b521b6dbe | [
"MIT"
] | null | null | null | lib/wizards/aarrgh/ship/parrot.c | vlehtola/questmud | 8bc3099b5ad00a9e0261faeb6637c76b521b6dbe | [
"MIT"
] | null | null | null | inherit "obj/monster";
reset(arg) {
string chat_str, a_chat_str;
object armour, weapon;
::reset(arg);
if (arg) { return; }
set_level(5);
set_name("parrot");
set_alias("parrot");
set_short("A multicoloured and wicked looking parrot.");
set_long("This parrot seems to be just a ordinary parrot, repeating things what \n"+
"it has been hearing.\n");
set_al(50);
set_move_at_random(0);
set_aggressive(0);
if (!chat_str) {
chat_str = allocate(3);
chat_str[0] ="Parrot says 'magnet...magnet'.\n";
chat_str[1] ="Parrot flaps its wings.\n";
chat_str[2] ="Parrot says 'damned captain...remove magnet..\n";
}
if (!a_chat_str) {
a_chat_str = allocate(1);
a_chat_str[0] = "Parrot screams 'Kraaah!\n";
}
load_chat(20, chat_str);
load_a_chat(20, a_chat_str);
}
| 29.066667 | 88 | 0.610092 |
2d4638e128f7cfc34b73bccab0d71f427fb65ff9 | 138,010 | h | C | jre_emul/android/platform/external/icu/data/_com_ibm_icu_impl_data_icudt58b_zone_ca_res.h | life-beam/j2objc | 471504a735b48d5d4ace51afa1542cc4790a921a | [
"Apache-2.0"
] | 1 | 2022-01-19T14:48:54.000Z | 2022-01-19T14:48:54.000Z | jre_emul/android/platform/external/icu/data/_com_ibm_icu_impl_data_icudt58b_zone_ca_res.h | FD-/j2objc | 316bb5a9e9986fa05106fd267da93b8ae60ca212 | [
"Apache-2.0"
] | null | null | null | jre_emul/android/platform/external/icu/data/_com_ibm_icu_impl_data_icudt58b_zone_ca_res.h | FD-/j2objc | 316bb5a9e9986fa05106fd267da93b8ae60ca212 | [
"Apache-2.0"
] | 1 | 2019-05-06T00:18:50.000Z | 2019-05-06T00:18:50.000Z | //
// Generated by gen_resource_source.py
//
#ifndef _COM_IBM_ICU_IMPL_DATA_ICUDT58B_ZONE_CA_RES_H
#define _COM_IBM_ICU_IMPL_DATA_ICUDT58B_ZONE_CA_RES_H
static jbyte _com_ibm_icu_impl_data_icudt58b_zone_ca_res[] = {
0x00, 0x20, 0xDA, 0x27, 0x00, 0x14, 0x00, 0x00, 0x01, 0x00,
0x02, 0x00, 0x52, 0x65, 0x73, 0x42, 0x03, 0x00, 0x00, 0x00,
0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x20, 0x00, 0x15, 0xA1, 0x00, 0x93, 0x19, 0x08,
0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x15, 0xA5, 0x00, 0x00,
0x15, 0xA5, 0x00, 0x00, 0x02, 0x43, 0x93, 0x19, 0x00, 0x04,
0x00, 0x00, 0x12, 0x3C, 0xF9, 0x85, 0x50, 0x53, 0x00, 0x00,
0x00, 0x4B, 0x00, 0xED, 0x00, 0x65, 0x00, 0x76, 0x00, 0x00,
0x00, 0x53, 0x00, 0x65, 0x00, 0xFC, 0x00, 0x6C, 0x00, 0x00,
0x00, 0x41, 0x00, 0x71, 0x00, 0x74, 0x00, 0x61, 0x01, 0x6B,
0x00, 0x00, 0x00, 0x4B, 0x01, 0x01, 0x00, 0x62, 0x00, 0x75,
0x00, 0x6C, 0x00, 0x00, 0x00, 0x54, 0x00, 0x78, 0x00, 0x69,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x5A, 0x00, 0x75,
0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x41,
0x00, 0x74, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73,
0x00, 0x00, 0x00, 0x42, 0x00, 0x69, 0x00, 0x78, 0x00, 0x6B,
0x00, 0x65, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x42, 0x00, 0x6F,
0x00, 0x67, 0x00, 0x6F, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x00,
0x00, 0x43, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6D, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x00, 0x00, 0x44, 0x00, 0x61, 0x00, 0x6D,
0x00, 0x61, 0x00, 0x73, 0x00, 0x63, 0x00, 0x00, 0x00, 0x4A,
0x00, 0x61, 0x00, 0x69, 0x00, 0x70, 0x00, 0x75, 0x00, 0x72,
0x00, 0x00, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x73, 0x00, 0x71,
0x00, 0x61, 0x00, 0x74, 0x00, 0x00, 0x00, 0x4D, 0x00, 0xF2,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x00,
0x00, 0x50, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6D,
0x00, 0xE0, 0x00, 0x00, 0x00, 0x54, 0x00, 0x68, 0x00, 0x69,
0x00, 0x6D, 0x00, 0x62, 0x00, 0x75, 0x00, 0x00, 0x00, 0x54,
0x00, 0xF2, 0x00, 0x71, 0x00, 0x75, 0x00, 0x69, 0x00, 0x6F,
0x00, 0x00, 0x00, 0x56, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69,
0x00, 0x63, 0x00, 0xE0, 0x00, 0x00, 0x00, 0x58, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x67, 0x00, 0x61, 0x00, 0x69, 0x00, 0x00,
0x00, 0x41, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x64, 0x00, 0x79,
0x00, 0x72, 0x20, 0x19, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x69,
0x00, 0x63, 0x00, 0xF2, 0x00, 0x73, 0x00, 0x69, 0x00, 0x61,
0x00, 0x00, 0x00, 0x55, 0x00, 0x72, 0x00, 0x75, 0x00, 0x6D,
0x00, 0x63, 0x00, 0x68, 0x00, 0x69, 0x00, 0x00, 0x00, 0x56,
0x00, 0xED, 0x00, 0x6C, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x75,
0x00, 0x73, 0x00, 0x00, 0x00, 0x41, 0x00, 0x6C, 0x00, 0x2D,
0x00, 0x52, 0x00, 0x69, 0x00, 0x79, 0x01, 0x01, 0x00, 0x64,
0x00, 0x00, 0x00, 0x41, 0x00, 0x6C, 0x00, 0x2D, 0x00, 0x61,
0x00, 0x61, 0x00, 0x69, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x42, 0x00, 0x65, 0x00, 0x72, 0x00, 0x6D, 0x00, 0x75,
0x00, 0x64, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x45,
0x00, 0x73, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x6F,
0x00, 0x6C, 0x00, 0x6D, 0x00, 0x00, 0x00, 0x48, 0x00, 0xE8,
0x00, 0x6C, 0x00, 0x73, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x6B,
0x00, 0x69, 0x00, 0x00, 0x00, 0x54, 0x00, 0x61, 0x00, 0x69,
0x00, 0x78, 0x00, 0x6B, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x00, 0x00, 0x56, 0x00, 0x61, 0x00, 0x72, 0x00, 0x73,
0x00, 0xF2, 0x00, 0x76, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x43, 0x00, 0x61, 0x00, 0x69, 0x00, 0x72, 0x00, 0x65,
0x00, 0x2C, 0x00, 0x20, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0xE0, 0x00, 0x72, 0x00, 0x61, 0x00, 0x62, 0x00, 0x00,
0x00, 0x4D, 0x00, 0x75, 0x00, 0x71, 0x00, 0x64, 0x00, 0x69,
0x00, 0x69, 0x00, 0x73, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x00,
0x00, 0x55, 0x00, 0x6C, 0x00, 0x69, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x00,
0x00, 0x5A, 0x00, 0x61, 0x00, 0x70, 0x00, 0x6F, 0x00, 0x72,
0x00, 0xED, 0x00, 0x6A, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x4B, 0x00, 0x69, 0x00, 0x7A, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x2D, 0x00, 0x4F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x61,
0x00, 0x00, 0x00, 0x42, 0x00, 0x72, 0x00, 0x75, 0x00, 0x73,
0x00, 0x73, 0x00, 0x65, 0x00, 0x6C, 0x00, 0xB7, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x49, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x49, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x46, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x65, 0x00, 0x00, 0x00, 0x42, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x63, 0x00, 0x20, 0x00, 0x53, 0x00, 0x61,
0x00, 0x62, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x57, 0x00, 0x61,
0x00, 0x6B, 0x00, 0x65, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x58, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x3A, 0x00, 0x20,
0x00, 0x7B, 0x00, 0x30, 0x00, 0x7D, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x47, 0x00, 0x6F,
0x00, 0x6C, 0x00, 0x66, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4A, 0x00, 0x61, 0x00, 0x70,
0x00, 0xF3, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x64, 0x00, 0x79, 0x00, 0x72,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x52,
0x00, 0x65, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x69, 0x00, 0xF3,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x42,
0x00, 0x68, 0x00, 0x75, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0x6F, 0x00, 0x73, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x75,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x53,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6D, 0x00, 0xF3,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x54,
0x00, 0x61, 0x00, 0x69, 0x00, 0x70, 0x00, 0x65, 0x00, 0x69,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x56,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x74, 0x00, 0x75,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x72,
0x00, 0x6D, 0x00, 0xE8, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x61,
0x00, 0x00, 0x00, 0x49, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x50,
0x00, 0x61, 0x00, 0x73, 0x00, 0x71, 0x00, 0x75, 0x00, 0x61,
0x00, 0x00, 0x00, 0x49, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6E,
0x00, 0xE0, 0x00, 0x72, 0x00, 0x69, 0x00, 0x65, 0x00, 0x73,
0x00, 0x00, 0x00, 0x43, 0x00, 0x69, 0x00, 0x75, 0x00, 0x74,
0x00, 0x61, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4D, 0x00, 0xE8, 0x00, 0x78, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x42, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0xED, 0x00, 0x76,
0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x47, 0x00, 0x65, 0x00, 0xF2, 0x00, 0x72,
0x00, 0x67, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x49, 0x00, 0x61, 0x00, 0x6B,
0x00, 0x75, 0x00, 0x74, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61,
0x00, 0x75, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x69,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x00, 0x61, 0x00, 0x20, 0x00, 0x58, 0x00, 0x69, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x49,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x78, 0x00, 0x69,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x70, 0x00, 0x20,
0x00, 0x56, 0x00, 0x65, 0x00, 0x72, 0x00, 0x64, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x68,
0x00, 0x61, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x72,
0x00, 0x6F, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0xF2, 0x00, 0x6D,
0x00, 0x62, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6C,
0x00, 0xE0, 0x00, 0x69, 0x00, 0x73, 0x00, 0x69, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x53,
0x00, 0x61, 0x00, 0x6B, 0x00, 0x68, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x69, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x53, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x67,
0x00, 0x61, 0x00, 0x70, 0x00, 0x75, 0x00, 0x72, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x50,
0x00, 0x61, 0x00, 0x63, 0x00, 0xED, 0x00, 0x66, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x4B, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x74, 0x00, 0x78,
0x00, 0x61, 0x00, 0x74, 0x00, 0x6B, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61,
0x00, 0x63, 0x00, 0x71, 0x00, 0x75, 0x00, 0x61, 0x00, 0x72,
0x00, 0x69, 0x00, 0x65, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x54, 0x00, 0x65, 0x00, 0x72, 0x00, 0x72,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x76, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x56,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x65, 0x00, 0xE7, 0x00, 0x75,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x56, 0x00, 0x6F, 0x00, 0x6C,
0x00, 0x67, 0x00, 0x6F, 0x00, 0x67, 0x00, 0x72, 0x00, 0x61,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x45, 0x00, 0x71, 0x00, 0x75,
0x00, 0x61, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x55, 0x00, 0x72, 0x00, 0x75, 0x00, 0x67, 0x00, 0x75,
0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x6B,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x50, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x67,
0x00, 0x75, 0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x55, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x20, 0x00, 0x42, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0xE0, 0x00, 0x72, 0x00, 0x61, 0x00, 0x62, 0x00, 0x00,
0x00, 0x62, 0x00, 0x61, 0x00, 0x68, 0x00, 0xED, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x42,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x65, 0x00, 0x72,
0x00, 0x61, 0x00, 0x73, 0x00, 0x00, 0x00, 0x43, 0x00, 0x69,
0x00, 0x75, 0x00, 0x74, 0x00, 0x61, 0x00, 0x74, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x73, 0x00, 0x63, 0x00, 0x6F,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x67, 0x00, 0x75, 0x00, 0x64,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x4B, 0x00, 0x69, 0x00, 0x72, 0x00, 0x69, 0x00, 0x74,
0x00, 0x69, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x74, 0x00, 0x69,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x41, 0x00, 0xE7,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x7A, 0x00, 0x6F,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x41,
0x00, 0x74, 0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x7A, 0x00, 0x65, 0x00, 0x72, 0x00, 0x62,
0x00, 0x61, 0x00, 0x69, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x42, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6C,
0x00, 0x61, 0x00, 0x20, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73,
0x00, 0x68, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x4B, 0x00, 0x72, 0x00, 0x61, 0x00, 0x73, 0x00, 0x6E,
0x00, 0x6F, 0x00, 0x69, 0x00, 0x61, 0x00, 0x72, 0x00, 0x73,
0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x41, 0x00, 0x72, 0x00, 0x67,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x45,
0x00, 0x6B, 0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72,
0x00, 0x69, 0x00, 0x6E, 0x00, 0x62, 0x00, 0x75, 0x00, 0x72,
0x00, 0x67, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x70, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x49, 0x00, 0x72, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0xE0, 0x00, 0x72, 0x00, 0x61,
0x00, 0x62, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x2C, 0x00, 0x20, 0x00, 0x7B, 0x00, 0x30,
0x00, 0x7D, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x72, 0x00, 0x69, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x2C, 0x00, 0x20, 0x00, 0x7B, 0x00, 0x30,
0x00, 0x7D, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x4D,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x64, 0x00, 0x69, 0x00, 0x76,
0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4C, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65,
0x00, 0x20, 0x00, 0x49, 0x00, 0x73, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x61, 0x00, 0x20, 0x00, 0x5A, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x55, 0x00, 0x7A, 0x00, 0x62, 0x00, 0x65, 0x00, 0x6B,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x65, 0x00, 0xE0,
0x00, 0x20, 0x00, 0xCD, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x54, 0x00, 0x61, 0x00, 0x64, 0x00, 0x6A,
0x00, 0x69, 0x00, 0x6B, 0x00, 0x69, 0x00, 0x73, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43,
0x00, 0x75, 0x00, 0x62, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x46, 0x00, 0x69, 0x00, 0x6A, 0x00, 0x69, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x76, 0x00, 0x64,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x58, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x4B, 0x00, 0x69, 0x00, 0x72, 0x00, 0x67,
0x00, 0x75, 0x00, 0x69, 0x00, 0x7A, 0x00, 0x69, 0x00, 0x73,
0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x54, 0x00, 0x75,
0x00, 0x72, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x65, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0x61, 0x00, 0x63, 0x00, 0x61, 0x00, 0x75, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x53, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x6F,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x54, 0x00, 0x6F,
0x00, 0x6E, 0x00, 0x67, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x4A, 0x00, 0x61, 0x00, 0x70, 0x00, 0xF3,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x50, 0x00, 0x65,
0x00, 0x72, 0x00, 0xFA, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x6C,
0x00, 0x61, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x49, 0x00, 0x73, 0x00, 0x72, 0x00, 0x61, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x70, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x49, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x4F, 0x00, 0x6D,
0x00, 0x73, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0x6F, 0x00, 0x73, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x75,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4E,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x61, 0x00, 0x20, 0x00, 0x43,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x64, 0x00, 0xF2,
0x00, 0x6E, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x53, 0x00, 0x65, 0x00, 0x79, 0x00, 0x63,
0x00, 0x68, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69,
0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
0x00, 0x43, 0x00, 0x6F, 0x00, 0x6F, 0x00, 0x6B, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x45, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x62, 0x00, 0x72, 0x00, 0x69, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x53, 0x00, 0x61, 0x00, 0x6D,
0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x54, 0x00, 0x61, 0x00, 0x69, 0x00, 0x70, 0x00, 0x65,
0x00, 0x69, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x56, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x74, 0x00, 0x75, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x72, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x6E,
0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x43, 0x00, 0x75, 0x00, 0x62, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46,
0x00, 0x69, 0x00, 0x6A, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x58, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47, 0x00, 0x65,
0x00, 0xF2, 0x00, 0x72, 0x00, 0x67, 0x00, 0x69, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x53, 0x00, 0x75, 0x00, 0x64, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x4D, 0x00, 0x61, 0x00, 0x75, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x69, 0x00, 0x00, 0x00, 0x42, 0x00, 0x65,
0x00, 0x75, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x68, 0x00, 0x2C,
0x00, 0x20, 0x00, 0x44, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x6F,
0x00, 0x74, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0x00, 0x43, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x2C, 0x00, 0x20,
0x00, 0x44, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x6F, 0x00, 0x74,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x43,
0x00, 0x6F, 0x00, 0x63, 0x00, 0x6F, 0x00, 0x73, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x4F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72,
0x00, 0x6F, 0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x43, 0x00, 0x68, 0x00, 0x61, 0x00, 0x74, 0x00, 0x68,
0x00, 0x61, 0x00, 0x6D, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47,
0x00, 0x65, 0x00, 0xF2, 0x00, 0x72, 0x00, 0x67, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x49, 0x00, 0x61,
0x00, 0x6B, 0x00, 0x75, 0x00, 0x74, 0x00, 0x73, 0x00, 0x6B,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x67,
0x00, 0x61, 0x00, 0x64, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x20, 0x00, 0x58,
0x00, 0x69, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x65, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x63, 0x00, 0x61,
0x00, 0x75, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x53, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x6F, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x54,
0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x4A,
0x00, 0x61, 0x00, 0x70, 0x00, 0xF3, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x50, 0x00, 0x65,
0x00, 0x72, 0x00, 0xFA, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x73, 0x00, 0x6B,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x64, 0x00, 0x79, 0x00, 0x72,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x49, 0x00, 0x73,
0x00, 0x72, 0x00, 0x61, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x72,
0x00, 0x69, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x6E, 0x00, 0x61,
0x00, 0x64, 0x00, 0x79, 0x00, 0x72, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x43, 0x00, 0x61, 0x00, 0x70, 0x00, 0x20, 0x00, 0x56,
0x00, 0x65, 0x00, 0x72, 0x00, 0x64, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x63,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x49,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0xE8,
0x00, 0x73, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x69,
0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x73,
0x00, 0x71, 0x00, 0x75, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0xC0,
0x00, 0x66, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61,
0x00, 0x20, 0x00, 0x43, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x72, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x43, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x72, 0x00, 0x65, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72,
0x00, 0x6F, 0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73, 0x00, 0x74,
0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61,
0x00, 0x20, 0x00, 0x43, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x72, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x42, 0x00, 0x72, 0x00, 0x61, 0x00, 0x73, 0x00, 0xED,
0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0xF2, 0x00, 0x6D,
0x00, 0x62, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x53, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x68, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x63, 0x00, 0xED,
0x00, 0x66, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x6F, 0x00, 0x73,
0x00, 0x63, 0x00, 0x6F, 0x00, 0x75, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x53, 0x00, 0x61, 0x00, 0x6D,
0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x54, 0x00, 0x61, 0x00, 0x69,
0x00, 0x70, 0x00, 0x65, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x56, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x74, 0x00, 0x75, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x72, 0x00, 0x6D, 0x00, 0xE8,
0x00, 0x6E, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x49, 0x00, 0x72, 0x00, 0x6B, 0x00, 0x75,
0x00, 0x74, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x49, 0x00, 0x72, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x42, 0x00, 0x72, 0x00, 0x75,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x69, 0x00, 0x20, 0x00, 0x44,
0x00, 0x61, 0x00, 0x72, 0x00, 0x75, 0x00, 0x73, 0x00, 0x73,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x6D, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x50, 0x00, 0x61,
0x00, 0x70, 0x00, 0x75, 0x00, 0x61, 0x00, 0x20, 0x00, 0x4E,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x61, 0x00, 0x20, 0x00, 0x47,
0x00, 0x75, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x47,
0x00, 0x69, 0x00, 0x6C, 0x00, 0x62, 0x00, 0x65, 0x00, 0x72,
0x00, 0x74, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69,
0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x66, 0x00, 0x6F,
0x00, 0x6C, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x50, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x69, 0x00, 0x78, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x49, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x6E,
0x00, 0xE8, 0x00, 0x73, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0xC0, 0x00, 0x66, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63,
0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x72, 0x00, 0x69,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x50, 0x00, 0x61, 0x00, 0x63, 0x00, 0xED, 0x00, 0x66,
0x00, 0x69, 0x00, 0x63, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4D, 0x00, 0xE8, 0x00, 0x78, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x75, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0xE0,
0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x20, 0x00, 0x4F,
0x00, 0x72, 0x00, 0x69, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46,
0x00, 0x69, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x70, 0x00, 0x69,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x20,
0x00, 0x4B, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x54, 0x00, 0x65, 0x00, 0x72, 0x00, 0x72,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x76, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x56, 0x00, 0x6F, 0x00, 0x6C,
0x00, 0x67, 0x00, 0x6F, 0x00, 0x67, 0x00, 0x72, 0x00, 0x61,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x55, 0x00, 0x72, 0x00, 0x75, 0x00, 0x67, 0x00, 0x75,
0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x50, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x69, 0x00, 0x73,
0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61,
0x00, 0x67, 0x00, 0x75, 0x00, 0x61, 0x00, 0x69, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x68,
0x00, 0x61, 0x00, 0x74, 0x00, 0x68, 0x00, 0x61, 0x00, 0x6D,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47,
0x00, 0x65, 0x00, 0xF2, 0x00, 0x72, 0x00, 0x67, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x49, 0x00, 0x61, 0x00, 0x6B, 0x00, 0x75, 0x00, 0x74,
0x00, 0x73, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x67, 0x00, 0x61,
0x00, 0x64, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x75,
0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x69, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x20, 0x00, 0x58, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0xCD, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x41, 0x00, 0xE7, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x76, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x4D,
0x00, 0x61, 0x00, 0x72, 0x00, 0x73, 0x00, 0x68, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x6F, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x49, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x6E,
0x00, 0xE8, 0x00, 0x73, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x43, 0x00, 0x68, 0x00, 0x6F, 0x00, 0x69,
0x00, 0x62, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x73, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0x61, 0x00, 0x7A, 0x00, 0x6F,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x41, 0x00, 0x74, 0x00, 0x6C,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x69, 0x00, 0x63,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x7A, 0x00, 0x65, 0x00, 0x72,
0x00, 0x62, 0x00, 0x61, 0x00, 0x69, 0x00, 0x64, 0x00, 0x6A,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x42, 0x00, 0x72, 0x00, 0x61, 0x00, 0x73,
0x00, 0xED, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61,
0x00, 0x70, 0x00, 0x20, 0x00, 0x56, 0x00, 0x65, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x43, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0xF2, 0x00, 0x6D,
0x00, 0x62, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x53, 0x00, 0x61, 0x00, 0x6B,
0x00, 0x68, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x50, 0x00, 0x61, 0x00, 0x63, 0x00, 0xED, 0x00, 0x66,
0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x4E, 0x00, 0x65,
0x00, 0x77, 0x00, 0x20, 0x00, 0x53, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x6D, 0x00, 0x2C, 0x00, 0x20, 0x00, 0x44,
0x00, 0x61, 0x00, 0x6B, 0x00, 0x6F, 0x00, 0x74, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4B, 0x00, 0x72, 0x00, 0x61, 0x00, 0x73,
0x00, 0x6E, 0x00, 0x6F, 0x00, 0x69, 0x00, 0x61, 0x00, 0x72,
0x00, 0x73, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x20, 0x00, 0x47,
0x00, 0x75, 0x00, 0x61, 0x00, 0x69, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x20, 0x00, 0x46, 0x00, 0x72, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x63, 0x00, 0x65, 0x00, 0x73, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x45, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0xC0,
0x00, 0x66, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61,
0x00, 0x20, 0x00, 0x4F, 0x00, 0x63, 0x00, 0x63, 0x00, 0x69,
0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64,
0x00, 0x2D, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0xE8, 0x00, 0x78, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73,
0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69,
0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x63, 0x00, 0x63,
0x00, 0x69, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x42,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x20, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x68,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x6F, 0x00, 0x73, 0x00, 0x69, 0x00, 0x62, 0x00, 0x69,
0x00, 0x72, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x56, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x64, 0x00, 0x69,
0x00, 0x76, 0x00, 0x6F, 0x00, 0x73, 0x00, 0x74, 0x00, 0x6F,
0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x41, 0x00, 0x72, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46, 0x00, 0x69,
0x00, 0x6C, 0x00, 0x69, 0x00, 0x70, 0x00, 0x69, 0x00, 0x6E,
0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67,
0x00, 0x20, 0x00, 0x4B, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x67,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4C,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x77, 0x00, 0x65, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x54, 0x00, 0x65, 0x00, 0x72,
0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x56, 0x00, 0x6F, 0x00, 0x6C, 0x00, 0x67, 0x00, 0x6F,
0x00, 0x67, 0x00, 0x72, 0x00, 0x61, 0x00, 0x64, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x55, 0x00, 0x72, 0x00, 0x75, 0x00, 0x67, 0x00, 0x75,
0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x6B,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x50, 0x00, 0x61, 0x00, 0x72, 0x00, 0x61, 0x00, 0x67,
0x00, 0x75, 0x00, 0x61, 0x00, 0x69, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x55, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x20, 0x00, 0x42, 0x00, 0x61, 0x00, 0x74, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x72, 0x00, 0x69, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x4C, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x77, 0x00, 0x65, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x4F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4B, 0x00, 0x61, 0x00, 0x7A,
0x00, 0x61, 0x00, 0x6B, 0x00, 0x68, 0x00, 0x73, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4E,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x61, 0x00, 0x20, 0x00, 0x5A,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x55, 0x00, 0x7A, 0x00, 0x62, 0x00, 0x65, 0x00, 0x6B,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43,
0x00, 0x68, 0x00, 0x6F, 0x00, 0x69, 0x00, 0x62, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x73, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x41, 0x00, 0xE7, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x41,
0x00, 0x6D, 0x00, 0x61, 0x00, 0x7A, 0x00, 0x6F, 0x00, 0x6E,
0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x41, 0x00, 0x74,
0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x7A, 0x00, 0x65, 0x00, 0x72, 0x00, 0x62, 0x00, 0x61,
0x00, 0x69, 0x00, 0x64, 0x00, 0x6A, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x41, 0x00, 0x72, 0x00, 0x67, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x4B, 0x00, 0x61, 0x00, 0x7A, 0x00, 0x61, 0x00, 0x6B,
0x00, 0x68, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x4D, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x64,
0x00, 0x69, 0x00, 0xE0, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x47, 0x00, 0x72, 0x00, 0x65, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x77, 0x00, 0x69, 0x00, 0x63, 0x00, 0x68,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x54, 0x00, 0x75,
0x00, 0x72, 0x00, 0x6B, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x69, 0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x42,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x67, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x20, 0x00, 0x44, 0x00, 0x65, 0x00, 0x73, 0x00, 0x68,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4B,
0x00, 0x72, 0x00, 0x61, 0x00, 0x73, 0x00, 0x6E, 0x00, 0x6F,
0x00, 0x69, 0x00, 0x61, 0x00, 0x72, 0x00, 0x73, 0x00, 0x6B,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4E,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x6F, 0x00, 0x73, 0x00, 0x69,
0x00, 0x62, 0x00, 0x69, 0x00, 0x72, 0x00, 0x73, 0x00, 0x6B,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x56,
0x00, 0x6C, 0x00, 0x61, 0x00, 0x64, 0x00, 0x69, 0x00, 0x76,
0x00, 0x6F, 0x00, 0x73, 0x00, 0x74, 0x00, 0x6F, 0x00, 0x6B,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x41, 0x00, 0x72, 0x00, 0x67, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x45, 0x00, 0x6B,
0x00, 0x61, 0x00, 0x74, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69,
0x00, 0x6E, 0x00, 0x62, 0x00, 0x75, 0x00, 0x72, 0x00, 0x67,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x61, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x64, 0x00, 0xF2, 0x00, 0x6E, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x45, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x76, 0x00, 0x61,
0x00, 0x20, 0x00, 0x5A, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x55,
0x00, 0x7A, 0x00, 0x62, 0x00, 0x65, 0x00, 0x6B, 0x00, 0x69,
0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x63, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x53, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x2D, 0x00, 0x50, 0x00, 0x69, 0x00, 0x65, 0x00, 0x72,
0x00, 0x72, 0x00, 0x65, 0x00, 0x20, 0x00, 0x69, 0x00, 0x20,
0x00, 0x4D, 0x00, 0x69, 0x00, 0x71, 0x00, 0x75, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x45,
0x00, 0x78, 0x00, 0x74, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6D,
0x00, 0x20, 0x00, 0x4F, 0x00, 0x72, 0x00, 0x69, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x20, 0x00, 0x45, 0x00, 0x75,
0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x65, 0x00, 0x75,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x4F,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x54, 0x00, 0x75, 0x00, 0x72,
0x00, 0x6B, 0x00, 0x6D, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x69,
0x00, 0x73, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x69, 0x00, 0x6C,
0x00, 0x6C, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x73, 0x00, 0x71,
0x00, 0x75, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x43, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72,
0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x45,
0x00, 0x75, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73, 0x00, 0x74,
0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61,
0x00, 0x20, 0x00, 0x43, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x72, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x76,
0x00, 0x61, 0x00, 0x20, 0x00, 0x43, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x64, 0x00, 0xF2, 0x00, 0x6E, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20, 0x00, 0x69,
0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
0x00, 0x43, 0x00, 0x6F, 0x00, 0x6F, 0x00, 0x6B, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19,
0x00, 0x45, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x45, 0x00, 0x75, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x70, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x69, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x6E,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x72, 0x00, 0x74, 0x00, 0x69,
0x00, 0x64, 0x00, 0x61, 0x00, 0x20, 0x00, 0x69, 0x00, 0x20,
0x00, 0x46, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6E, 0x00, 0xE7,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x53, 0x00, 0x75, 0x00, 0x64, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x48, 0x00, 0x61, 0x00, 0x77, 0x00, 0x61,
0x00, 0x69, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x41, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x75, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x50, 0x00, 0x61, 0x00, 0x63, 0x00, 0xED,
0x00, 0x66, 0x00, 0x69, 0x00, 0x63, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x4D, 0x00, 0xE8, 0x00, 0x78,
0x00, 0x69, 0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75,
0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C,
0x00, 0x69, 0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x72,
0x00, 0x69, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x4F, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x45,
0x00, 0x75, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75,
0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C,
0x00, 0x69, 0x00, 0x61, 0x00, 0x20, 0x00, 0x63, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x72, 0x00, 0x65, 0x00, 0x2D,
0x00, 0x6F, 0x00, 0x63, 0x00, 0x63, 0x00, 0x69, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x76, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x50,
0x00, 0x61, 0x00, 0x73, 0x00, 0x71, 0x00, 0x75, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x43, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72,
0x00, 0x65, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x45,
0x00, 0x75, 0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C, 0x00, 0x20,
0x00, 0x73, 0x00, 0x75, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0xC0,
0x00, 0x66, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75,
0x00, 0x73, 0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C,
0x00, 0x69, 0x00, 0x61, 0x00, 0x20, 0x00, 0x43, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6D,
0x00, 0x69, 0x00, 0x67, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65,
0x00, 0x73, 0x00, 0x20, 0x00, 0x43, 0x00, 0x6F, 0x00, 0x6F,
0x00, 0x6B, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6D, 0x00, 0x75, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x79, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72,
0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x46,
0x00, 0x65, 0x00, 0x72, 0x00, 0x6E, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x6F, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x6F,
0x00, 0x6E, 0x00, 0x68, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69,
0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x45, 0x00, 0x73, 0x00, 0x74,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47,
0x00, 0x72, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0xC0, 0x00, 0x66,
0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x20,
0x00, 0x4F, 0x00, 0x63, 0x00, 0x63, 0x00, 0x69, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x6E, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x64, 0x00, 0x2D, 0x00, 0x6F, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x4D, 0x00, 0xE8, 0x00, 0x78, 0x00, 0x69,
0x00, 0x63, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73,
0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69,
0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x63, 0x00, 0x63,
0x00, 0x69, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x48, 0x00, 0x61, 0x00, 0x77, 0x00, 0x61,
0x00, 0x69, 0x00, 0x69, 0x00, 0x2D, 0x00, 0x41, 0x00, 0x6C,
0x00, 0x65, 0x00, 0x75, 0x00, 0x74, 0x00, 0x69, 0x00, 0x61,
0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x50, 0x00, 0x61,
0x00, 0x63, 0x00, 0xED, 0x00, 0x66, 0x00, 0x69, 0x00, 0x63,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0xE8, 0x00, 0x78, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73,
0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69,
0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x72, 0x00, 0x69,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6C,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x4F,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
0x00, 0x69, 0x00, 0x6C, 0x00, 0x6C, 0x00, 0x65, 0x00, 0x73,
0x00, 0x20, 0x00, 0x4D, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x76,
0x00, 0x69, 0x00, 0x6E, 0x00, 0x65, 0x00, 0x73, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x6F, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x41, 0x00, 0x72,
0x00, 0x67, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x69,
0x00, 0x6E, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x46, 0x00, 0x65, 0x00, 0x72, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x6F, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x68, 0x00, 0x61,
0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6C,
0x20, 0x19, 0x00, 0x45, 0x00, 0x73, 0x00, 0x74, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x69, 0x00, 0x61, 0x00, 0x00, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0xC0,
0x00, 0x66, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61,
0x00, 0x20, 0x00, 0x4F, 0x00, 0x63, 0x00, 0x63, 0x00, 0x69,
0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x6E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64,
0x00, 0x2D, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4D,
0x00, 0xE8, 0x00, 0x78, 0x00, 0x69, 0x00, 0x63, 0x00, 0x00,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73,
0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69,
0x00, 0x61, 0x00, 0x20, 0x00, 0x4F, 0x00, 0x63, 0x00, 0x63,
0x00, 0x69, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61,
0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x6C, 0x20, 0x19, 0x00, 0x4F, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x47, 0x00, 0x72, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x6C, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x69,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x63, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x6F, 0x00, 0x65, 0x00, 0x73,
0x00, 0x74, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x6C, 0x20, 0x19, 0x00, 0x41, 0x00, 0x72, 0x00, 0x67,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x69, 0x00, 0x6E,
0x00, 0x61, 0x00, 0x00, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75, 0x00, 0x20,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x69, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x74, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x64,
0x20, 0x19, 0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72,
0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x64, 0x00, 0x00, 0xDC, 0x29, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x63,
0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72, 0x00, 0x61,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19, 0x00, 0x41,
0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63,
0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6C,
0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x64,
0x00, 0x00, 0xDC, 0x29, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x61, 0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72,
0x00, 0x64, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
0x00, 0x53, 0x00, 0x61, 0x00, 0x69, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x2D, 0x00, 0x50, 0x00, 0x69, 0x00, 0x65, 0x00, 0x72,
0x00, 0x72, 0x00, 0x65, 0x00, 0x20, 0x00, 0x69, 0x00, 0x20,
0x00, 0x4D, 0x00, 0x69, 0x00, 0x71, 0x00, 0x75, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x6F, 0x00, 0x6E, 0x00, 0x00, 0xDC, 0x2A,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x75, 0x00, 0x73, 0x00, 0x74, 0x00, 0x72,
0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69, 0x00, 0x61, 0x00, 0x20,
0x00, 0x63, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x72,
0x00, 0x65, 0x00, 0x2D, 0x00, 0x6F, 0x00, 0x63, 0x00, 0x63,
0x00, 0x69, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x00, 0xDC, 0x2A, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x69, 0x00, 0x65, 0x00, 0x6E, 0x00, 0x74,
0x00, 0x61, 0x00, 0x6C, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0xDC, 0x2B, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0x69, 0x00, 0x75,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6D,
0x00, 0x75, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x79, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0xDC, 0x2C, 0x00, 0x48, 0x00, 0x6F,
0x00, 0x72, 0x00, 0x61, 0x00, 0x72, 0x00, 0x69, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74,
0x00, 0x69, 0x00, 0x75, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x20, 0x00, 0x50, 0x00, 0x65, 0x00, 0x74, 0x00, 0x72,
0x00, 0x6F, 0x00, 0x70, 0x00, 0x61, 0x00, 0x76, 0x00, 0x6C,
0x00, 0x6F, 0x00, 0x76, 0x00, 0x73, 0x00, 0x6B, 0x00, 0x20,
0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4B, 0x00, 0x61,
0x00, 0x6D, 0x00, 0x74, 0x00, 0x78, 0x00, 0x61, 0x00, 0x74,
0x00, 0x6B, 0x00, 0x61, 0x00, 0x00, 0xDC, 0x2C, 0x00, 0x48,
0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20, 0x00, 0x65,
0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E, 0x00, 0x64,
0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20, 0x00, 0x64,
0x00, 0x65, 0x00, 0x20, 0x00, 0x50, 0x00, 0x65, 0x00, 0x74,
0x00, 0x72, 0x00, 0x6F, 0x00, 0x70, 0x00, 0x61, 0x00, 0x76,
0x00, 0x6C, 0x00, 0x6F, 0x00, 0x76, 0x00, 0x73, 0x00, 0x6B,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x4B,
0x00, 0x61, 0x00, 0x6D, 0x00, 0x74, 0x00, 0x78, 0x00, 0x61,
0x00, 0x74, 0x00, 0x6B, 0x00, 0x61, 0x00, 0x00, 0xDC, 0x2C,
0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61, 0x00, 0x20,
0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0, 0x00, 0x6E,
0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64, 0x00, 0x20,
0x00, 0x64, 0x20, 0x19, 0x00, 0x41, 0x00, 0x75, 0x00, 0x73,
0x00, 0x74, 0x00, 0x72, 0x00, 0xE0, 0x00, 0x6C, 0x00, 0x69,
0x00, 0x61, 0x00, 0x20, 0x00, 0x63, 0x00, 0x65, 0x00, 0x6E,
0x00, 0x74, 0x00, 0x72, 0x00, 0x65, 0x00, 0x2D, 0x00, 0x6F,
0x00, 0x63, 0x00, 0x63, 0x00, 0x69, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6C, 0x00, 0x00,
0xDC, 0x2D, 0x00, 0x48, 0x00, 0x6F, 0x00, 0x72, 0x00, 0x61,
0x00, 0x20, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00, 0xE0,
0x00, 0x6E, 0x00, 0x64, 0x00, 0x61, 0x00, 0x72, 0x00, 0x64,
0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x6D,
0x00, 0x75, 0x00, 0x6E, 0x00, 0x74, 0x00, 0x61, 0x00, 0x6E,
0x00, 0x79, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x20, 0x19,
0x00, 0x41, 0x00, 0x6D, 0x00, 0xE8, 0x00, 0x72, 0x00, 0x69,
0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
0x00, 0x6C, 0x00, 0x20, 0x00, 0x4E, 0x00, 0x6F, 0x00, 0x72,
0x00, 0x64, 0x00, 0x00, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x48,
0x00, 0x01, 0x00, 0x22, 0x0D, 0x5C, 0x00, 0x01, 0x00, 0x22,
0x30, 0xF0, 0x00, 0x01, 0x00, 0x22, 0x03, 0x4C, 0x00, 0x01,
0x00, 0x22, 0x13, 0x8D, 0x00, 0x01, 0x00, 0x22, 0x13, 0xBA,
0x00, 0x01, 0x00, 0x22, 0x13, 0xE7, 0x00, 0x01, 0x00, 0x22,
0x14, 0x0B, 0x00, 0x01, 0x00, 0x22, 0x14, 0x6E, 0x00, 0x01,
0x00, 0x22, 0x27, 0x8B, 0x00, 0x01, 0x00, 0x22, 0x3E, 0x71,
0x00, 0x01, 0x00, 0x22, 0x2F, 0xC6, 0x00, 0x01, 0x00, 0x22,
0x93, 0xF6, 0x00, 0x01, 0x00, 0x22, 0x37, 0x85, 0x00, 0x01,
0x00, 0x22, 0x0D, 0x4C, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x52,
0x00, 0x01, 0x00, 0x22, 0x0C, 0xEC, 0x00, 0x01, 0x00, 0x22,
0x49, 0xAC, 0x00, 0x01, 0x00, 0x22, 0x28, 0xB4, 0x00, 0x01,
0x00, 0x22, 0x14, 0x80, 0x00, 0x01, 0x00, 0x22, 0x93, 0xC0,
0x00, 0x01, 0x00, 0x22, 0x27, 0x33, 0x00, 0x01, 0x00, 0x22,
0x26, 0xFC, 0x00, 0x01, 0x00, 0x22, 0x13, 0xA8, 0x00, 0x01,
0x00, 0x22, 0x45, 0x70, 0x00, 0x01, 0x00, 0x22, 0x02, 0x99,
0x00, 0x01, 0x00, 0x22, 0x1C, 0x12, 0x00, 0x01, 0x00, 0x22,
0x0F, 0x02, 0x00, 0x01, 0x00, 0x22, 0x13, 0xB1, 0x00, 0x01,
0x00, 0x22, 0x27, 0xB7, 0x00, 0x01, 0x00, 0x22, 0x0C, 0xE4,
0x00, 0x01, 0x00, 0x22, 0x37, 0x44, 0x00, 0x01, 0x00, 0x22,
0x06, 0x78, 0x00, 0x01, 0x00, 0x22, 0x13, 0x96, 0x00, 0x01,
0x00, 0x22, 0x37, 0x03, 0x00, 0x01, 0x00, 0x22, 0x0C, 0xBB,
0x00, 0x01, 0x00, 0x22, 0x0C, 0xC3, 0x00, 0x01, 0x00, 0x22,
0x0C, 0xCB, 0x00, 0x01, 0x00, 0x22, 0x0C, 0xB3, 0x00, 0x01,
0x00, 0x22, 0x13, 0x83, 0x00, 0x01, 0x00, 0x22, 0x94, 0x0A,
0x00, 0x01, 0x00, 0x22, 0x27, 0x1D, 0x00, 0x01, 0x00, 0x22,
0x1C, 0x3A, 0x00, 0x01, 0x00, 0x22, 0x28, 0x88, 0x00, 0x01,
0x00, 0x22, 0x14, 0x65, 0x00, 0x01, 0x00, 0x22, 0x37, 0x9F,
0x00, 0x01, 0x00, 0x22, 0x3E, 0xEF, 0x00, 0x01, 0x00, 0x22,
0x37, 0x10, 0x00, 0x01, 0x00, 0x22, 0x28, 0x30, 0x00, 0x01,
0x00, 0x22, 0x10, 0x92, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x94,
0x00, 0x01, 0x00, 0x22, 0x27, 0x80, 0x00, 0x01, 0x00, 0x22,
0x06, 0x1D, 0x00, 0x01, 0x00, 0x22, 0x2F, 0xDE, 0x00, 0x01,
0x00, 0x22, 0x28, 0x25, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x20,
0x00, 0x01, 0x00, 0x22, 0x1E, 0xAE, 0x00, 0x01, 0x00, 0x22,
0x27, 0xC2, 0x00, 0x01, 0x00, 0x22, 0x38, 0x1F, 0x00, 0x01,
0x00, 0x22, 0x0C, 0xF4, 0x00, 0x01, 0x00, 0x22, 0x27, 0xAC,
0x00, 0x01, 0x00, 0x22, 0x27, 0x6A, 0x00, 0x01, 0x00, 0x22,
0x0D, 0xE2, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x3E, 0x00, 0x01,
0x00, 0x22, 0x0C, 0xDC, 0x00, 0x01, 0x00, 0x22, 0x27, 0x28,
0x00, 0x01, 0x00, 0x22, 0x0D, 0x84, 0x00, 0x01, 0x00, 0x22,
0x96, 0xE9, 0x00, 0x01, 0x00, 0x22, 0x27, 0x07, 0x00, 0x01,
0x00, 0x22, 0x02, 0xB0, 0x00, 0x01, 0x00, 0x22, 0x14, 0xBF,
0x00, 0x01, 0x00, 0x22, 0x94, 0x57, 0x00, 0x01, 0x00, 0x22,
0x2F, 0xEA, 0x00, 0x01, 0x00, 0x22, 0x93, 0x4A, 0x00, 0x01,
0x00, 0x22, 0x0D, 0x2C, 0x00, 0x01, 0x00, 0x22, 0x45, 0x34,
0x00, 0x01, 0x00, 0x22, 0x49, 0x9C, 0x00, 0x01, 0x00, 0x22,
0x45, 0x43, 0x00, 0x01, 0x00, 0x22, 0x15, 0x85, 0x00, 0x01,
0x00, 0x22, 0x1D, 0x0C, 0x00, 0x01, 0x00, 0x22, 0x30, 0x3E,
0x00, 0x01, 0x00, 0x22, 0x0A, 0xB3, 0x00, 0x01, 0x00, 0x22,
0x93, 0x51, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x6C, 0x00, 0x01,
0x00, 0x22, 0x2F, 0xF6, 0x00, 0x01, 0x00, 0x22, 0x26, 0xD0,
0x00, 0x01, 0x00, 0x22, 0x0D, 0xBA, 0x00, 0x01, 0x00, 0x22,
0x37, 0xE0, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x9E, 0x00, 0x01,
0x00, 0x22, 0x06, 0x92, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x16,
0x00, 0x01, 0x00, 0x22, 0x44, 0xF8, 0x00, 0x01, 0x00, 0x22,
0x14, 0x53, 0x00, 0x01, 0x00, 0x22, 0x45, 0x07, 0x00, 0x01,
0x00, 0x22, 0x13, 0x9F, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x76,
0x00, 0x01, 0x00, 0x22, 0x28, 0x67, 0x00, 0x01, 0x00, 0x22,
0x26, 0xF1, 0x00, 0x01, 0x00, 0x22, 0x15, 0xF8, 0x00, 0x01,
0x00, 0x22, 0x3E, 0x47, 0x00, 0x01, 0x00, 0x22, 0x3E, 0xA9,
0x00, 0x01, 0x00, 0x22, 0x2F, 0x7E, 0x00, 0x01, 0x00, 0x22,
0x30, 0x7A, 0x00, 0x01, 0x00, 0x22, 0x06, 0x16, 0x00, 0x01,
0x00, 0x22, 0x30, 0x62, 0x00, 0x01, 0x00, 0x22, 0x37, 0x1D,
0x00, 0x01, 0x00, 0x22, 0x1D, 0x5C, 0x00, 0x01, 0x00, 0x22,
0x37, 0xED, 0x00, 0x01, 0x00, 0x22, 0x30, 0xAA, 0x00, 0x01,
0x00, 0x22, 0x30, 0x6E, 0x00, 0x01, 0x00, 0x22, 0x16, 0x27,
0x00, 0x01, 0x00, 0x22, 0x1C, 0xA8, 0x00, 0x01, 0x00, 0x22,
0x14, 0xF5, 0x00, 0x01, 0x00, 0x22, 0x37, 0x2A, 0x00, 0x01,
0x00, 0x22, 0x49, 0x6C, 0x00, 0x01, 0x00, 0x22, 0x54, 0xAA,
0x00, 0x01, 0x00, 0x22, 0x5D, 0x11, 0x00, 0x01, 0x00, 0x22,
0x5A, 0x9B, 0x00, 0x01, 0x00, 0x22, 0x4D, 0xFC, 0x00, 0x01,
0x00, 0x22, 0x5A, 0xB0, 0x00, 0x01, 0x00, 0x22, 0x54, 0xE3,
0x00, 0x01, 0x00, 0x22, 0x44, 0xCB, 0x00, 0x01, 0x00, 0x22,
0x13, 0xD5, 0x00, 0x01, 0x00, 0x22, 0x1C, 0xB2, 0x00, 0x01,
0x00, 0x22, 0x1E, 0x74, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x3C,
0x00, 0x01, 0x00, 0x22, 0x14, 0x5C, 0x00, 0x01, 0x00, 0x22,
0x60, 0xD9, 0x00, 0x01, 0x00, 0x22, 0x36, 0xF6, 0x00, 0x01,
0x00, 0x22, 0x14, 0x1D, 0x00, 0x01, 0x00, 0x22, 0x06, 0x24,
0x00, 0x01, 0x00, 0x22, 0x3E, 0xC5, 0x00, 0x01, 0x00, 0x22,
0x37, 0x51, 0x00, 0x01, 0x00, 0x22, 0x6A, 0x05, 0x00, 0x01,
0x00, 0x22, 0x06, 0xA0, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x4E,
0x00, 0x01, 0x00, 0x22, 0x13, 0xF0, 0x00, 0x01, 0x00, 0x22,
0x1C, 0x8A, 0x00, 0x01, 0x00, 0x22, 0x38, 0xA4, 0x00, 0x01,
0x00, 0x22, 0x2F, 0x96, 0x00, 0x01, 0x00, 0x22, 0x15, 0xA7,
0x00, 0x01, 0x00, 0x22, 0x1C, 0x58, 0x00, 0x01, 0x00, 0x22,
0x30, 0x26, 0x00, 0x01, 0x00, 0x22, 0x06, 0x99, 0x00, 0x01,
0x00, 0x22, 0x36, 0xC2, 0x00, 0x01, 0x00, 0x22, 0x95, 0x3C,
0x00, 0x01, 0x00, 0x22, 0x8F, 0xE0, 0x00, 0x01, 0x00, 0x22,
0x1C, 0xD0, 0x00, 0x01, 0x00, 0x22, 0x2F, 0xD2, 0x00, 0x01,
0x00, 0x22, 0x36, 0xDC, 0x00, 0x01, 0x00, 0x22, 0x37, 0x5E,
0x00, 0x01, 0x00, 0x22, 0x13, 0xDE, 0x00, 0x01, 0x00, 0x22,
0x21, 0xC4, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x44, 0x00, 0x01,
0x00, 0x22, 0x06, 0x39, 0x00, 0x01, 0x00, 0x22, 0x1E, 0xA6,
0x00, 0x01, 0x00, 0x22, 0x9B, 0x83, 0x00, 0x01, 0x00, 0x22,
0x9B, 0x9B, 0x00, 0x01, 0x00, 0x22, 0xA2, 0xA9, 0x00, 0x01,
0x00, 0x22, 0x1C, 0xDA, 0x00, 0x01, 0x00, 0x22, 0x93, 0x74,
0x00, 0x01, 0x00, 0x22, 0x3E, 0x63, 0x00, 0x01, 0x00, 0x22,
0x36, 0xCF, 0x00, 0x01, 0x00, 0x22, 0x1D, 0xFC, 0x00, 0x01,
0x00, 0x22, 0x4E, 0x0D, 0x00, 0x01, 0x00, 0x22, 0x49, 0xBC,
0x00, 0x01, 0x00, 0x22, 0x3E, 0x7F, 0x00, 0x01, 0x00, 0x22,
0x3F, 0x19, 0x00, 0x01, 0x00, 0x22, 0x3E, 0xD3, 0x00, 0x01,
0x00, 0x22, 0x45, 0x52, 0x00, 0x01, 0x00, 0x22, 0x14, 0x02,
0x00, 0x01, 0x00, 0x22, 0x14, 0x38, 0x00, 0x01, 0x00, 0x22,
0x27, 0xA1, 0x00, 0x01, 0x00, 0x22, 0x2A, 0xA1, 0x00, 0x01,
0x00, 0x22, 0x45, 0x16, 0x00, 0x01, 0x00, 0x22, 0x16, 0x1C,
0x00, 0x01, 0x00, 0x22, 0x27, 0x75, 0x00, 0x01, 0x00, 0x22,
0x49, 0x8C, 0x00, 0x01, 0x00, 0x22, 0x1D, 0xB4, 0x00, 0x01,
0x00, 0x22, 0x3B, 0x38, 0x00, 0x01, 0x00, 0x22, 0x0C, 0xD4,
0x00, 0x01, 0x00, 0x22, 0x4E, 0x2D, 0x00, 0x01, 0x00, 0x22,
0x39, 0x23, 0x00, 0x01, 0x00, 0x22, 0x31, 0xE0, 0x00, 0x01,
0x00, 0x22, 0x32, 0x1C, 0x00, 0x01, 0x00, 0x22, 0x38, 0x2C,
0x00, 0x01, 0x00, 0x22, 0x3F, 0x95, 0x00, 0x01, 0x00, 0x22,
0x49, 0x7C, 0x00, 0x01, 0x00, 0x22, 0x3E, 0x8D, 0x00, 0x01,
0x00, 0x22, 0x0D, 0x74, 0x00, 0x01, 0x00, 0x22, 0x3E, 0xE1,
0x00, 0x01, 0x00, 0x22, 0x1C, 0xF8, 0x00, 0x01, 0x00, 0x22,
0x1C, 0x26, 0x00, 0x01, 0x00, 0x22, 0x1C, 0x94, 0x00, 0x01,
0x00, 0x22, 0x30, 0x0E, 0x00, 0x01, 0x00, 0x22, 0x37, 0x78,
0x00, 0x01, 0x00, 0x22, 0x27, 0x49, 0x00, 0x01, 0x00, 0x22,
0x1C, 0x62, 0x00, 0x01, 0x00, 0x22, 0x3E, 0x9B, 0x00, 0x01,
0x00, 0x22, 0x0D, 0x64, 0x00, 0x01, 0x00, 0x22, 0x0D, 0xF4,
0x00, 0x01, 0x00, 0x22, 0x54, 0xBD, 0x00, 0x01, 0x00, 0x22,
0x31, 0x5E, 0x00, 0x01, 0x00, 0x22, 0x15, 0x7C, 0x00, 0x01,
0x00, 0x22, 0x1C, 0xC6, 0x00, 0x01, 0x00, 0x22, 0x13, 0xC3,
0x00, 0x01, 0x00, 0x22, 0x1E, 0x38, 0x00, 0x01, 0x00, 0x22,
0x0E, 0x24, 0x00, 0x01, 0x00, 0x22, 0x0C, 0xFC, 0x00, 0x01,
0x00, 0x22, 0x15, 0xCD, 0x00, 0x01, 0x00, 0x22, 0x44, 0xDA,
0x00, 0x01, 0x00, 0x22, 0x06, 0x40, 0x00, 0x01, 0x00, 0x22,
0x61, 0x2C, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x9C, 0x00, 0x01,
0x00, 0x22, 0x93, 0x97, 0x00, 0x01, 0x00, 0x22, 0x93, 0x24,
0x00, 0x01, 0x00, 0x22, 0x61, 0x88, 0x00, 0x01, 0x00, 0x22,
0x28, 0xCA, 0x00, 0x01, 0x00, 0x22, 0x06, 0x30, 0x00, 0x01,
0x00, 0x22, 0x1E, 0x60, 0x00, 0x01, 0x00, 0x22, 0x01, 0x6C,
0x00, 0x01, 0x00, 0x22, 0x1C, 0x30, 0x00, 0x01, 0x00, 0x22,
0x1D, 0x02, 0x00, 0x01, 0x00, 0x22, 0x15, 0x34, 0x00, 0x01,
0x00, 0x22, 0x93, 0x43, 0x00, 0x01, 0x00, 0x22, 0x14, 0xEC,
0x00, 0x01, 0x00, 0x22, 0x11, 0x0A, 0x00, 0x01, 0x00, 0x22,
0x93, 0x30, 0x00, 0x01, 0x00, 0x22, 0x38, 0x55, 0x00, 0x01,
0x00, 0x22, 0x1D, 0x98, 0x00, 0x01, 0x00, 0x22, 0x93, 0x58,
0x00, 0x01, 0x00, 0x22, 0x03, 0xD6, 0x00, 0x01, 0x00, 0x22,
0x06, 0x0F, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x6C, 0x00, 0x01,
0x00, 0x22, 0x28, 0xA9, 0x00, 0x01, 0x00, 0x22, 0x02, 0x9F,
0x00, 0x01, 0x00, 0x22, 0x14, 0xC8, 0x00, 0x01, 0x00, 0x22,
0x31, 0xFA, 0x00, 0x01, 0x00, 0x22, 0x06, 0xB0, 0x00, 0x01,
0x00, 0x22, 0x61, 0x42, 0x00, 0x01, 0x00, 0x22, 0x1D, 0xDE,
0x00, 0x01, 0x00, 0x22, 0x93, 0x5F, 0x00, 0x01, 0x00, 0x22,
0x31, 0xA6, 0x00, 0x01, 0x00, 0x22, 0x93, 0x2A, 0x00, 0x01,
0x00, 0x22, 0xAE, 0xD9, 0x00, 0x01, 0x00, 0x22, 0x1D, 0xCA,
0x00, 0x01, 0x00, 0x22, 0x18, 0x14, 0x00, 0x01, 0x00, 0x22,
0x28, 0x93, 0x00, 0x01, 0x00, 0x22, 0xA2, 0xD4, 0x00, 0x01,
0x00, 0x22, 0x44, 0xBC, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x84,
0x00, 0x01, 0x00, 0x22, 0x15, 0x97, 0x00, 0x01, 0x00, 0x22,
0x0E, 0x9C, 0x00, 0x01, 0x00, 0x22, 0x1E, 0x24, 0x00, 0x01,
0x00, 0x22, 0x0F, 0x0A, 0x00, 0x01, 0x00, 0x22, 0x13, 0xF9,
0x00, 0x01, 0x00, 0x22, 0x93, 0x66, 0x00, 0x01, 0x00, 0x22,
0x93, 0x9F, 0x00, 0x01, 0x00, 0x22, 0x45, 0x7F, 0x00, 0x01,
0x00, 0x22, 0x3F, 0x27, 0x00, 0x01, 0x00, 0x22, 0x57, 0xC4,
0x00, 0x01, 0x00, 0x22, 0x06, 0x5C, 0x00, 0x01, 0x00, 0x22,
0x37, 0xC6, 0x00, 0x01, 0x00, 0x22, 0x2F, 0xBA, 0x00, 0x01,
0x00, 0x22, 0x31, 0xCA, 0x00, 0x01, 0x00, 0x22, 0x0D, 0xAC,
0x00, 0x01, 0x00, 0x22, 0x94, 0x28, 0x00, 0x01, 0x00, 0x22,
0x1E, 0x9C, 0x00, 0x01, 0x00, 0x22, 0x93, 0xB7, 0x00, 0x01,
0x00, 0x22, 0x57, 0x95, 0x00, 0x01, 0x00, 0x22, 0x29, 0x7A,
0x00, 0x01, 0x00, 0x22, 0x29, 0x62, 0x00, 0x01, 0x00, 0x22,
0x93, 0x1F, 0x00, 0x01, 0x00, 0x22, 0x93, 0x90, 0x00, 0x01,
0x00, 0x22, 0x7B, 0xA9, 0x00, 0x01, 0x00, 0x22, 0x3F, 0x79,
0x00, 0x01, 0x00, 0x22, 0x16, 0x30, 0x00, 0x01, 0x00, 0x22,
0x93, 0xE4, 0x00, 0x01, 0x00, 0x22, 0x1C, 0xEE, 0x00, 0x01,
0x00, 0x22, 0x0D, 0x7A, 0x00, 0x01, 0x00, 0x22, 0x93, 0x7B,
0x00, 0x01, 0x00, 0x22, 0x93, 0x82, 0x00, 0x01, 0x00, 0x22,
0x0D, 0x44, 0x00, 0x01, 0x00, 0x22, 0x3F, 0x43, 0x00, 0x01,
0x00, 0x22, 0x93, 0xA7, 0x00, 0x01, 0x00, 0x22, 0x23, 0xD6,
0x00, 0x01, 0x00, 0x22, 0x30, 0xDA, 0x00, 0x01, 0x00, 0x22,
0x3F, 0x35, 0x00, 0x01, 0x00, 0x22, 0x5A, 0xD0, 0x00, 0x01,
0x00, 0x22, 0x72, 0x86, 0x00, 0x01, 0x00, 0x22, 0x08, 0x8A,
0x00, 0x01, 0x00, 0x22, 0xA1, 0x5E, 0x00, 0x01, 0x00, 0x22,
0x93, 0xC9, 0x00, 0x01, 0x00, 0x22, 0x95, 0x2D, 0x00, 0x01,
0x00, 0x22, 0x9D, 0x5B, 0x00, 0x01, 0x00, 0x22, 0x94, 0x4B,
0x00, 0x01, 0x00, 0x22, 0x1C, 0x80, 0x00, 0x01, 0x00, 0x22,
0x31, 0x2E, 0x00, 0x01, 0x00, 0x22, 0x9B, 0x5B, 0x00, 0x01,
0x00, 0x22, 0x38, 0xBB, 0x00, 0x01, 0x00, 0x22, 0x1C, 0xE4,
0x00, 0x01, 0x00, 0x22, 0x27, 0xF9, 0x00, 0x01, 0x00, 0x22,
0x27, 0x5F, 0x00, 0x01, 0x00, 0x22, 0x3E, 0x55, 0x00, 0x01,
0x00, 0x22, 0x14, 0x4A, 0x00, 0x01, 0x00, 0x22, 0x14, 0x14,
0x00, 0x01, 0x00, 0x22, 0x0D, 0x34, 0x00, 0x01, 0x00, 0x22,
0x13, 0xCC, 0x00, 0x01, 0x00, 0x22, 0x27, 0x12, 0x00, 0x01,
0x00, 0x22, 0x31, 0x52, 0x00, 0x01, 0x00, 0x22, 0x30, 0x56,
0x00, 0x01, 0x00, 0x22, 0x0D, 0x24, 0x00, 0x01, 0x00, 0x22,
0x14, 0xDA, 0x00, 0x01, 0x00, 0x22, 0x96, 0xFB, 0x00, 0x01,
0x00, 0x22, 0x30, 0x32, 0x00, 0x01, 0x00, 0x22, 0x1D, 0x70,
0x00, 0x01, 0x00, 0x22, 0x31, 0x22, 0x00, 0x01, 0x00, 0x22,
0x93, 0x3C, 0x00, 0x01, 0x00, 0x22, 0x0E, 0x2A, 0x00, 0x01,
0x00, 0x22, 0x08, 0x36, 0x00, 0x01, 0x00, 0x22, 0x36, 0xE9,
0x00, 0x01, 0x00, 0x22, 0x94, 0x33, 0x00, 0x01, 0x00, 0x22,
0x17, 0x21, 0x00, 0x01, 0x00, 0x22, 0x28, 0x51, 0x00, 0x01,
0x00, 0x22, 0x28, 0x0F, 0x00, 0x01, 0x00, 0x22, 0x28, 0x7D,
0x00, 0x01, 0x00, 0x22, 0x38, 0x62, 0x00, 0x02, 0x00, 0x22,
0x15, 0xE6, 0x09, 0xD3, 0x9E, 0xDB, 0x00, 0x01, 0x00, 0x22,
0x30, 0x9E, 0x00, 0x01, 0x00, 0x22, 0x27, 0xD8, 0x00, 0x01,
0x00, 0x22, 0x93, 0xDB, 0x00, 0x01, 0x00, 0x22, 0x2B, 0xF2,
0x00, 0x01, 0x00, 0x22, 0x28, 0x04, 0x00, 0x01, 0x00, 0x22,
0x14, 0x9B, 0x00, 0x01, 0x00, 0x22, 0x3E, 0xFD, 0x00, 0x01,
0x00, 0x22, 0x93, 0x1A, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x54,
0x00, 0x01, 0x00, 0x22, 0x07, 0x6B, 0x00, 0x01, 0x00, 0x22,
0x30, 0xB6, 0x00, 0x02, 0x00, 0x22, 0x15, 0xE6, 0x0F, 0xC2,
0x9A, 0x84, 0x00, 0x01, 0x00, 0x22, 0x1E, 0x7C, 0x00, 0x01,
0x00, 0x22, 0x14, 0x26, 0x00, 0x01, 0x00, 0x22, 0x0D, 0x0C,
0x00, 0x01, 0x00, 0x22, 0x40, 0x59, 0x00, 0x01, 0x00, 0x22,
0x0D, 0x1C, 0x00, 0x01, 0x00, 0x22, 0x93, 0x6D, 0x00, 0x01,
0x00, 0x22, 0x9A, 0x21, 0x00, 0x01, 0x00, 0x22, 0x06, 0x2B,
0x00, 0x01, 0x00, 0x22, 0x03, 0xE8, 0x00, 0x01, 0x00, 0x22,
0x2F, 0xAE, 0x00, 0x01, 0x00, 0x22, 0x02, 0xC2, 0x00, 0x01,
0x00, 0x22, 0x06, 0x47, 0x00, 0x01, 0x00, 0x22, 0x00, 0x7C,
0x00, 0x01, 0x00, 0x22, 0x15, 0x19, 0x00, 0x01, 0x00, 0x22,
0x37, 0x92, 0x00, 0x01, 0x00, 0x22, 0x27, 0xEE, 0x00, 0x01,
0x00, 0x22, 0x37, 0xB9, 0x00, 0x01, 0x00, 0x22, 0x14, 0xAD,
0x00, 0x01, 0x00, 0x22, 0x0D, 0xB4, 0x00, 0x01, 0x00, 0x22,
0x93, 0xD2, 0x00, 0x01, 0x00, 0x22, 0x1D, 0xA2, 0x00, 0x01,
0x00, 0x22, 0x06, 0x06, 0x00, 0x01, 0x00, 0x22, 0x94, 0x14,
0x00, 0x01, 0x00, 0x22, 0x15, 0xB0, 0x00, 0x01, 0x00, 0x22,
0x0D, 0x14, 0x00, 0x01, 0x00, 0x22, 0x93, 0x89, 0x00, 0x01,
0x00, 0x22, 0x03, 0x58, 0x00, 0x01, 0x00, 0x22, 0x93, 0xAF,
0x00, 0x01, 0x00, 0x22, 0x31, 0x76, 0x00, 0x01, 0x00, 0x22,
0x93, 0xED, 0x00, 0x01, 0x00, 0x22, 0x14, 0xB6, 0x00, 0x01,
0x00, 0x22, 0x94, 0x1E, 0x00, 0x01, 0x00, 0x22, 0x93, 0x36,
0x00, 0x01, 0x00, 0x22, 0x44, 0xAD, 0x00, 0x01, 0x00, 0x22,
0x14, 0x77, 0x00, 0x01, 0x00, 0x22, 0x31, 0xBE, 0x00, 0x01,
0x00, 0x22, 0x0E, 0xF4, 0x00, 0x01, 0x00, 0x22, 0x15, 0xD6,
0x00, 0x01, 0x00, 0x22, 0x30, 0x92, 0x00, 0x01, 0x00, 0x22,
0x02, 0xA5, 0x00, 0x01, 0x00, 0x22, 0x98, 0x2D, 0x00, 0x01,
0x00, 0x22, 0x9B, 0x7B, 0x00, 0x01, 0x00, 0x22, 0x1C, 0xBC,
0x00, 0x01, 0x00, 0x22, 0x94, 0xBD, 0x00, 0x01, 0x00, 0x22,
0x55, 0x02, 0x00, 0x01, 0x00, 0x22, 0x27, 0x54, 0x00, 0x01,
0x00, 0x22, 0x45, 0x61, 0x00, 0x01, 0x00, 0x22, 0x1E, 0x92,
0x00, 0x01, 0x00, 0x22, 0x95, 0x1E, 0x00, 0x01, 0x00, 0x22,
0x0D, 0x04, 0x00, 0x01, 0x00, 0x22, 0x30, 0x1A, 0x00, 0x01,
0x00, 0x22, 0x1C, 0x1C, 0x00, 0x01, 0x00, 0x22, 0x08, 0x23,
0x00, 0x01, 0x00, 0x22, 0x26, 0xDB, 0x00, 0x01, 0x00, 0x22,
0x6A, 0x5D, 0x00, 0x01, 0x00, 0x22, 0x1E, 0x6A, 0x00, 0x01,
0x00, 0x22, 0x3E, 0xB7, 0x00, 0x01, 0x00, 0x22, 0x06, 0x55,
0x00, 0x01, 0x00, 0x22, 0x26, 0xE6, 0x00, 0x01, 0x00, 0x22,
0x27, 0x96, 0x00, 0x01, 0x00, 0x22, 0x37, 0x37, 0x00, 0x01,
0x00, 0x22, 0x15, 0xDF, 0x00, 0x01, 0x00, 0x22, 0x30, 0x4A,
0x00, 0x01, 0x00, 0x22, 0x14, 0x2F, 0x00, 0x01, 0x00, 0x22,
0x5D, 0xE1, 0x00, 0x01, 0x00, 0x22, 0x14, 0xA4, 0x00, 0x01,
0x00, 0x22, 0x0D, 0xDC, 0x00, 0x01, 0x00, 0x22, 0x06, 0x8D,
0x00, 0x01, 0x00, 0x22, 0x1E, 0x10, 0x00, 0x01, 0x00, 0x22,
0x06, 0xBC, 0x00, 0x01, 0x00, 0x22, 0x30, 0x02, 0x00, 0x01,
0x00, 0x22, 0x0D, 0xA4, 0x00, 0x01, 0x00, 0x22, 0x28, 0xEB,
0x00, 0x01, 0x00, 0x22, 0x1D, 0x2A, 0x00, 0x01, 0x00, 0x22,
0x44, 0xE9, 0x00, 0x01, 0x00, 0x22, 0x2F, 0xA2, 0x00, 0x01,
0x00, 0x22, 0x14, 0x41, 0x00, 0x01, 0x00, 0x22, 0x46, 0xA2,
0x00, 0x01, 0x00, 0x22, 0x14, 0x92, 0x00, 0x01, 0x00, 0x22,
0x2F, 0x8A, 0x00, 0x01, 0x00, 0x22, 0x0D, 0xCC, 0x00, 0x01,
0x00, 0x22, 0x06, 0xB7, 0x00, 0x01, 0x00, 0x22, 0x14, 0xD1,
0x00, 0x01, 0x15, 0x82, 0x5C, 0xFA, 0x00, 0x01, 0x15, 0x82,
0x9D, 0x96, 0x00, 0x01, 0x15, 0x82, 0x9F, 0x90, 0x00, 0x01,
0x15, 0x82, 0xAA, 0x5E, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xAB, 0x34, 0xA3, 0x18, 0xAC, 0xC8, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x99, 0xA3, 0x41, 0x71,
0x9C, 0xEB, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xA1, 0xD1, 0x97, 0x34, 0xA5, 0xA2, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0xAD, 0x61, 0xA7, 0xA1, 0xAD, 0xDA,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xAD, 0xB1,
0xA9, 0x07, 0xAE, 0x5C, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xAE, 0x88, 0xAA, 0xC8, 0xAF, 0x3F, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9E, 0x2C, 0x96, 0x12,
0xA2, 0x8E, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x9D, 0x33, 0x94, 0xA7, 0x9D, 0x03, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x97, 0xBD, 0x33, 0xB4, 0x99, 0xCF,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x96, 0xD7,
0x94, 0x00, 0x97, 0xE5, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA3, 0xC0, 0x97, 0x95, 0xA6, 0xE9, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xAC, 0x56, 0xA5, 0xF9,
0xAD, 0x89, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x9A, 0xE0, 0x95, 0x0F, 0x9E, 0xA9, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0xA1, 0xEC, 0x97, 0x47, 0xA5, 0xBF,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA8, 0x83,
0x9D, 0xC8, 0xAA, 0x81, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xAE, 0x30, 0xA9, 0xD2, 0xAF, 0x11, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA9, 0x8E, 0x9F, 0xC4,
0xAB, 0xE8, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xAB, 0x7C, 0xA3, 0x50, 0xAD, 0x14, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0xA2, 0x07, 0x97, 0x5A, 0xA5, 0xDC,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA1, 0x4A,
0x97, 0x21, 0xA5, 0x85, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA3, 0x6C, 0x97, 0x6D, 0xA6, 0x71, 0x00, 0x01,
0x15, 0x82, 0x94, 0xC4, 0x00, 0x01, 0x15, 0x82, 0x95, 0x4C,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9D, 0xE1,
0x4F, 0x0A, 0xA2, 0x22, 0x00, 0x01, 0x15, 0x82, 0x9E, 0xF4,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9D, 0x4B,
0x95, 0xAC, 0xA2, 0x3D, 0x00, 0x01, 0x15, 0x82, 0x95, 0xBD,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9B, 0xE3,
0x4A, 0x3A, 0xA0, 0x94, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x98, 0xDE, 0x94, 0x71, 0x9B, 0x3C, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9C, 0x43, 0x95, 0x8C,
0xA1, 0x16, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xA1, 0xB6, 0x55, 0x2D, 0xA5, 0x68, 0x00, 0x01, 0x15, 0x82,
0x97, 0x0E, 0x00, 0x01, 0x15, 0x82, 0x9B, 0xB3, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9D, 0xFA, 0x95, 0xCE,
0xA2, 0x58, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xAA, 0xA4, 0x9A, 0x56, 0xA8, 0xC5, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x98, 0x9F, 0x39, 0x7E, 0x9A, 0xF7,
0x00, 0x01, 0x15, 0x82, 0x40, 0x13, 0x00, 0x01, 0x15, 0x82,
0x6A, 0x35, 0x00, 0x01, 0x15, 0x82, 0x62, 0x02, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA8, 0x41, 0x9D, 0x7D,
0xAA, 0x18, 0x00, 0x01, 0x15, 0x82, 0x96, 0x7D, 0x00, 0x06,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x1B, 0xF5, 0x1B, 0xF8,
0x1B, 0xB2, 0xA8, 0x62, 0x9D, 0xAF, 0xAA, 0x3B, 0x00, 0x63,
0x00, 0x0D, 0x00, 0x0D, 0x00, 0x06, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x1B, 0xF5, 0x1B, 0xF8, 0x1B, 0xB2, 0xA7, 0x44,
0x9A, 0x6D, 0xA8, 0xE6, 0x00, 0x5E, 0x00, 0x09, 0x00, 0x09,
0x00, 0x01, 0x15, 0x82, 0xA7, 0xE1, 0x00, 0x06, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x1B, 0xF5, 0x1B, 0xF8, 0x1B, 0xB2,
0xA8, 0x01, 0x9B, 0xCB, 0xA9, 0xB0, 0x00, 0x59, 0x00, 0x05,
0x00, 0x05, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xA9, 0xF5, 0xA1, 0x65, 0xAC, 0x31, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x98, 0xB4, 0x3A, 0xC3, 0x9B, 0x0E,
0x00, 0x01, 0x15, 0x82, 0xA2, 0xE0, 0x00, 0x01, 0x15, 0x82,
0xA9, 0x28, 0x00, 0x02, 0x15, 0x82, 0x1B, 0xB2, 0xA6, 0x35,
0x00, 0x01, 0x00, 0x01, 0x15, 0x82, 0x51, 0xC6, 0x00, 0x01,
0x15, 0x82, 0x49, 0xFA, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9B, 0xFB, 0x95, 0x5C, 0xA0, 0xAE, 0x00, 0x01,
0x15, 0x82, 0x9F, 0x28, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xAB, 0x10, 0xA2, 0xFC, 0xAC, 0xA2, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xAC, 0x0C, 0xA4, 0xF4,
0xAD, 0x3A, 0x00, 0x01, 0x15, 0x82, 0x94, 0x8B, 0x00, 0x01,
0x15, 0x82, 0x46, 0x7C, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA9, 0x4A, 0x6E, 0xEB, 0xAB, 0xA0, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9F, 0xF8, 0x52, 0x32,
0xA3, 0xF8, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x98, 0xC9, 0x39, 0x8B, 0x9B, 0x25, 0x00, 0x01, 0x15, 0x82,
0xA1, 0x30, 0x00, 0x01, 0x15, 0x82, 0x98, 0x75, 0x00, 0x01,
0x15, 0x82, 0x95, 0x9C, 0x00, 0x01, 0x15, 0x82, 0x9D, 0x64,
0x00, 0x01, 0x15, 0x82, 0x9F, 0x76, 0x00, 0x01, 0x15, 0x82,
0xA1, 0x9B, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x97, 0xD1, 0x94, 0x3F, 0x99, 0xE5, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x61, 0x33, 0x46, 0xB8, 0x9E, 0xC2,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x99, 0xB9,
0x41, 0x7F, 0x9D, 0x1B, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x99, 0x77, 0x94, 0x99, 0x9C, 0xBB, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xAE, 0xB5, 0x96, 0x23,
0xAE, 0xE3, 0x00, 0x01, 0x15, 0x82, 0xA5, 0x11, 0x00, 0x01,
0x15, 0x82, 0xA6, 0x17, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x99, 0x1F, 0x41, 0x39, 0x9C, 0x5B, 0x00, 0x01,
0x15, 0x82, 0x45, 0xAA, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA2, 0xC4, 0x97, 0x81, 0xA6, 0x8F, 0x00, 0x01,
0x15, 0x82, 0x98, 0xF3, 0x00, 0x01, 0x15, 0x82, 0x98, 0x36,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA4, 0xD8,
0x51, 0xB4, 0xA4, 0x14, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x99, 0x35, 0x41, 0x47, 0x9C, 0x73, 0x00, 0x01,
0x15, 0x82, 0x96, 0x35, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9C, 0x2B, 0x4A, 0x9A, 0xA0, 0xE2, 0x00, 0x01,
0x15, 0x82, 0x95, 0xDF, 0x00, 0x01, 0x15, 0x82, 0x98, 0x21,
0x00, 0x01, 0x15, 0x82, 0x5D, 0xD5, 0x00, 0x01, 0x15, 0x82,
0xA1, 0x80, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x9B, 0x6B, 0x95, 0x7C, 0xA0, 0xFC, 0x00, 0x01, 0x15, 0x82,
0x45, 0xB9, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xAB, 0x58, 0xA3, 0x34, 0xAC, 0xEE, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0xA9, 0x6C, 0x9F, 0xAA, 0xAB, 0xC4,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x6E, 0x69,
0x96, 0xC5, 0xA4, 0xBC, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9A, 0x11, 0x94, 0xD3, 0x9E, 0x45, 0x00, 0x01,
0x15, 0x82, 0x4A, 0xBA, 0x00, 0x01, 0x15, 0x82, 0x40, 0x21,
0x00, 0x01, 0x15, 0x82, 0x46, 0xA9, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0xA7, 0x25, 0x9A, 0x28, 0xA8, 0xA4,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA5, 0x2E,
0x98, 0x4B, 0xA7, 0x63, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA0, 0x12, 0x96, 0x47, 0xA4, 0x30, 0x00, 0x01,
0x15, 0x82, 0x39, 0x16, 0x00, 0x01, 0x15, 0x82, 0x9F, 0x42,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xAA, 0xEC,
0x77, 0x89, 0xAC, 0x7C, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA3, 0x88, 0x57, 0xF1, 0xA6, 0xAD, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x57, 0xB5, 0x33, 0xC0,
0x99, 0xFB, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xA0, 0x60, 0x96, 0xA1, 0xA4, 0x84, 0x00, 0x01, 0x15, 0x82,
0x40, 0x91, 0x00, 0x01, 0x15, 0x82, 0x9F, 0x0E, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA0, 0x7A, 0x96, 0xB3,
0xA4, 0xA0, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0x99, 0x8D, 0x41, 0x63, 0x9C, 0xD3, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x9F, 0xDE, 0x52, 0x20, 0xA3, 0xDC,
0x00, 0x01, 0x15, 0x82, 0x9F, 0x5C, 0x00, 0x03, 0x15, 0xE6,
0x1B, 0xF2, 0x15, 0x82, 0x93, 0x18, 0xA7, 0xC1, 0xAE, 0x05,
0x00, 0x01, 0x15, 0x82, 0x4E, 0x4F, 0x00, 0x01, 0x15, 0x82,
0x45, 0xF5, 0x00, 0x01, 0x15, 0x82, 0x52, 0x44, 0x00, 0x01,
0x15, 0x82, 0x94, 0xB5, 0x00, 0x01, 0x15, 0x82, 0x4A, 0x0A,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9E, 0x13,
0x95, 0xF0, 0xA2, 0x73, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9A, 0x9B, 0x45, 0xC8, 0x9E, 0x5E, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x99, 0x4B, 0x40, 0x2F,
0x9C, 0x8B, 0x00, 0x01, 0x15, 0x82, 0x9A, 0x3F, 0x00, 0x01,
0x15, 0x82, 0x96, 0x01, 0x00, 0x01, 0x15, 0x82, 0x94, 0xE2,
0x00, 0x01, 0x15, 0x82, 0x9B, 0x53, 0x00, 0x01, 0x15, 0x82,
0x4A, 0xDA, 0x00, 0x01, 0x15, 0x82, 0x40, 0x3D, 0x00, 0x01,
0x15, 0x82, 0x46, 0x9A, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9A, 0xB2, 0x94, 0xF1, 0x9E, 0x77, 0x00, 0x01,
0x15, 0x82, 0x98, 0x8A, 0x00, 0x01, 0x15, 0x82, 0x4A, 0x1A,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x99, 0x61,
0x40, 0x4B, 0x9C, 0xA3, 0x00, 0x01, 0x15, 0x82, 0x40, 0x05,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA6, 0x53,
0x99, 0x09, 0xA8, 0x21, 0x00, 0x01, 0x15, 0x82, 0x45, 0xD7,
0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA0, 0x46,
0x96, 0x8F, 0xA4, 0x68, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0xA5, 0x4B, 0x98, 0x60, 0xA7, 0x82, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x9A, 0xC9, 0x95, 0x00,
0x9E, 0x90, 0x00, 0x01, 0x15, 0x82, 0x96, 0x59, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0xA3, 0xA4, 0x58, 0x05,
0xA6, 0xCB, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82,
0xA0, 0x2C, 0x96, 0x6B, 0xA4, 0x4C, 0x00, 0x01, 0x15, 0x82,
0x45, 0xE6, 0x00, 0x01, 0x15, 0x82, 0x94, 0x64, 0x00, 0x01,
0x15, 0x82, 0x69, 0xD3, 0x00, 0x03, 0x15, 0xE6, 0x1B, 0xF2,
0x15, 0x82, 0x9C, 0x13, 0x95, 0x6C, 0xA0, 0xC8, 0x00, 0x03,
0x15, 0xE6, 0x1B, 0xF2, 0x15, 0x82, 0x7B, 0x25, 0x97, 0xA9,
0xA7, 0x07, 0xAA, 0xAA, 0x02, 0x43, 0x02, 0xF7, 0x03, 0x06,
0x03, 0x13, 0x03, 0x26, 0x00, 0x14, 0x03, 0x35, 0x03, 0x43,
0x03, 0x51, 0x03, 0x5F, 0x03, 0x6D, 0x03, 0x7D, 0x03, 0x90,
0x03, 0xA1, 0x03, 0xAE, 0x03, 0xC0, 0x03, 0xCD, 0x03, 0xDC,
0x03, 0xE9, 0x03, 0xFE, 0x04, 0x0E, 0x04, 0x1C, 0x04, 0x2C,
0x04, 0x3C, 0x04, 0x4C, 0x04, 0x5A, 0x04, 0x6E, 0x04, 0x7A,
0x04, 0x89, 0x04, 0x99, 0x04, 0xA7, 0x04, 0xB7, 0x04, 0xC4,
0x04, 0xD6, 0x04, 0xE2, 0x04, 0xF0, 0x05, 0x02, 0x05, 0x10,
0x05, 0x1E, 0x05, 0x2C, 0x05, 0x3A, 0x05, 0x49, 0x05, 0x5A,
0x05, 0x6A, 0x05, 0x79, 0x05, 0x89, 0x05, 0x97, 0x05, 0xA9,
0x05, 0xBC, 0x05, 0xCE, 0x05, 0xDE, 0x05, 0xED, 0x05, 0xFA,
0x06, 0x0A, 0x06, 0x17, 0x06, 0x29, 0x06, 0x3A, 0x06, 0x4A,
0x06, 0x5C, 0x06, 0x77, 0x06, 0x96, 0x06, 0xAE, 0x06, 0xC9,
0x06, 0xE4, 0x06, 0xFE, 0x07, 0x18, 0x07, 0x26, 0x07, 0x37,
0x07, 0x45, 0x07, 0x5C, 0x07, 0x6D, 0x07, 0x7B, 0x07, 0x8A,
0x07, 0x9F, 0x07, 0xB1, 0x07, 0xC0, 0x07, 0xCE, 0x07, 0xE3,
0x07, 0xF9, 0x08, 0x0E, 0x08, 0x1D, 0x08, 0x2D, 0x08, 0x3F,
0x08, 0x4F, 0x08, 0x5E, 0x08, 0x6E, 0x00, 0x25, 0x08, 0x80,
0x08, 0x90, 0x08, 0xA3, 0x08, 0xB3, 0x08, 0xC2, 0x08, 0xD2,
0x08, 0xE7, 0x08, 0xF6, 0x09, 0x0B, 0x09, 0x1A, 0x09, 0x2A,
0x09, 0x3B, 0x09, 0x4C, 0x09, 0x5D, 0x09, 0x71, 0x09, 0x85,
0x09, 0x97, 0x00, 0x3B, 0x09, 0xA9, 0x09, 0xBB, 0x09, 0xCE,
0x09, 0xDE, 0x09, 0xF1, 0x0A, 0x03, 0x0A, 0x15, 0x0A, 0x24,
0x0A, 0x34, 0x0A, 0x43, 0x00, 0x4B, 0x00, 0x60, 0x00, 0x78,
0x00, 0x93, 0x00, 0xAD, 0x00, 0xC3, 0x00, 0xDD, 0x0A, 0x56,
0x0A, 0x6B, 0x0A, 0x7A, 0x0A, 0x8A, 0x0A, 0x9A, 0x0A, 0xA8,
0x00, 0xF5, 0x0A, 0xB7, 0x0A, 0xCA, 0x0A, 0xD9, 0x0A, 0xE6,
0x0A, 0xFA, 0x01, 0x11, 0x0B, 0x0D, 0x0B, 0x1C, 0x0B, 0x2C,
0x0B, 0x3B, 0x0B, 0x4B, 0x0B, 0x5E, 0x0B, 0x70, 0x0B, 0x81,
0x0B, 0x91, 0x0B, 0xA3, 0x0B, 0xB2, 0x0B, 0xC5, 0x0B, 0xD9,
0x0B, 0xEA, 0x0B, 0xFA, 0x0C, 0x0C, 0x0C, 0x1F, 0x0C, 0x32,
0x0C, 0x41, 0x0C, 0x52, 0x0C, 0x62, 0x0C, 0x6F, 0x01, 0x27,
0x01, 0x43, 0x01, 0x5F, 0x0C, 0x7F, 0x0C, 0x8F, 0x0C, 0x9E,
0x0C, 0xB2, 0x0C, 0xC5, 0x0C, 0xD5, 0x0C, 0xEC, 0x0D, 0x02,
0x0D, 0x16, 0x0D, 0x2A, 0x0D, 0x3E, 0x0D, 0x53, 0x0D, 0x62,
0x0D, 0x71, 0x0D, 0x82, 0x0D, 0x95, 0x0D, 0xAA, 0x0D, 0xBB,
0x0D, 0xCC, 0x0D, 0xE2, 0x01, 0x7E, 0x0D, 0xF4, 0x01, 0x93,
0x01, 0xA9, 0x01, 0xBA, 0x01, 0xCB, 0x01, 0xDC, 0x01, 0xEE,
0x0E, 0x02, 0x0E, 0x18, 0x0E, 0x2C, 0x0E, 0x3A, 0x0E, 0x4E,
0x0E, 0x5E, 0x0E, 0x6E, 0x0E, 0x7E, 0x0E, 0x90, 0x0E, 0xA3,
0x0E, 0xB4, 0x0E, 0xC4, 0x0E, 0xD8, 0x0E, 0xE9, 0x02, 0x01,
0x0E, 0xFA, 0x0F, 0x0F, 0x0F, 0x21, 0x0F, 0x34, 0x0F, 0x46,
0x0F, 0x59, 0x0F, 0x6A, 0x0F, 0x7B, 0x0F, 0x8D, 0x0F, 0xA1,
0x0F, 0xAB, 0x0F, 0xB7, 0x0F, 0xC2, 0x0F, 0xCE, 0x0F, 0xD9,
0x0F, 0xE5, 0x0F, 0xF3, 0x10, 0x00, 0x10, 0x0D, 0x10, 0x17,
0x10, 0x24, 0x10, 0x31, 0x10, 0x3D, 0x10, 0x4A, 0x02, 0x1B,
0x10, 0x56, 0x10, 0x61, 0x10, 0x71, 0x10, 0x7E, 0x10, 0x8C,
0x10, 0x97, 0x10, 0xA1, 0x10, 0xAC, 0x10, 0xBA, 0x10, 0xC4,
0x10, 0xD0, 0x10, 0xDF, 0x10, 0xE9, 0x10, 0xF6, 0x11, 0x03,
0x11, 0x11, 0x11, 0x20, 0x11, 0x2B, 0x11, 0x3A, 0x02, 0x29,
0x11, 0x47, 0x11, 0x55, 0x11, 0x66, 0x11, 0x78, 0x11, 0x85,
0x11, 0x91, 0x11, 0x9C, 0x11, 0xA9, 0x11, 0xB7, 0x11, 0xC3,
0x11, 0xCF, 0x11, 0xDC, 0x11, 0xEE, 0x11, 0xFF, 0x12, 0x09,
0x12, 0x13, 0x12, 0x23, 0x12, 0x32, 0x12, 0x41, 0x12, 0x4C,
0x12, 0x5B, 0x12, 0x68, 0x02, 0x37, 0x12, 0x74, 0x12, 0x82,
0x12, 0x91, 0x12, 0x9C, 0x12, 0xAA, 0x12, 0xB9, 0x12, 0xCC,
0x12, 0xD8, 0x12, 0xE6, 0x12, 0xF3, 0x12, 0xFF, 0x13, 0x0C,
0x13, 0x17, 0x13, 0x22, 0x13, 0x33, 0x13, 0x3F, 0x13, 0x4D,
0x13, 0x5C, 0x13, 0x6D, 0x13, 0x7A, 0x13, 0x8D, 0x13, 0x9A,
0x13, 0xAA, 0x13, 0xBB, 0x13, 0xCB, 0x02, 0x43, 0x13, 0xDF,
0x13, 0xF0, 0x14, 0x03, 0x02, 0x53, 0x14, 0x1A, 0x14, 0x2B,
0x14, 0x3E, 0x14, 0x51, 0x14, 0x67, 0x14, 0x78, 0x14, 0x89,
0x14, 0x99, 0x14, 0xAA, 0x14, 0xBD, 0x14, 0xD1, 0x14, 0xE5,
0x14, 0xF5, 0x02, 0x66, 0x15, 0x06, 0x15, 0x17, 0x15, 0x26,
0x15, 0x37, 0x15, 0x45, 0x15, 0x55, 0x15, 0x63, 0x15, 0x75,
0x15, 0x85, 0x15, 0x96, 0x15, 0xA6, 0x15, 0xB6, 0x15, 0xC6,
0x15, 0xD8, 0x15, 0xE9, 0x15, 0xFA, 0x16, 0x0A, 0x16, 0x1A,
0x16, 0x2D, 0x16, 0x3D, 0x16, 0x4B, 0x16, 0x5E, 0x16, 0x6A,
0x16, 0x77, 0x16, 0x85, 0x16, 0x96, 0x16, 0xA4, 0x16, 0xB6,
0x16, 0xC4, 0x16, 0xD1, 0x16, 0xE2, 0x16, 0xEF, 0x16, 0xFD,
0x17, 0x0B, 0x17, 0x17, 0x17, 0x24, 0x17, 0x35, 0x17, 0x43,
0x17, 0x4F, 0x17, 0x5B, 0x17, 0x69, 0x17, 0x7B, 0x17, 0x8B,
0x17, 0x9D, 0x17, 0xAB, 0x17, 0xB8, 0x17, 0xC9, 0x17, 0xD8,
0x17, 0xE6, 0x17, 0xF7, 0x18, 0x07, 0x18, 0x14, 0x18, 0x23,
0x18, 0x31, 0x18, 0x40, 0x18, 0x51, 0x18, 0x5F, 0x18, 0x6D,
0x18, 0x7F, 0x18, 0x8D, 0x18, 0xA1, 0x18, 0xAF, 0x18, 0xC0,
0x18, 0xCD, 0x18, 0xDB, 0x18, 0xEC, 0x18, 0xF8, 0x19, 0x08,
0x19, 0x19, 0x19, 0x28, 0x19, 0x37, 0x19, 0x44, 0x19, 0x55,
0x19, 0x6A, 0x19, 0x7A, 0x19, 0x89, 0x19, 0x97, 0x19, 0xA9,
0x19, 0xB9, 0x19, 0xC6, 0x19, 0xD7, 0x19, 0xE9, 0x19, 0xF9,
0x1A, 0x0D, 0x1A, 0x1A, 0x1A, 0x2B, 0x1A, 0x3C, 0x1A, 0x4F,
0x1A, 0x5E, 0x1A, 0x70, 0x1A, 0x7F, 0x1A, 0x91, 0x1A, 0xA0,
0x1A, 0xAE, 0x1A, 0xBB, 0x1A, 0xCB, 0x1A, 0xDA, 0x1A, 0xEC,
0x1A, 0xFA, 0x02, 0x72, 0x1B, 0x0B, 0x1B, 0x20, 0x1B, 0x32,
0x1B, 0x41, 0x1B, 0x50, 0x1B, 0x5F, 0x02, 0x81, 0x1B, 0x71,
0x1B, 0x7E, 0x02, 0x8E, 0x02, 0x9D, 0x02, 0xA7, 0x02, 0xB5,
0x1B, 0x8D, 0x1B, 0x9E, 0x1B, 0xB5, 0x1B, 0xC9, 0x1B, 0xDE,
0x1B, 0xFB, 0x1C, 0x07, 0x1C, 0x13, 0x1C, 0x28, 0x1C, 0x3D,
0x1C, 0x53, 0x1C, 0x68, 0x1C, 0x74, 0x1C, 0x7E, 0x1C, 0x8B,
0x1C, 0x9A, 0x1C, 0xB1, 0x1C, 0xBE, 0x1C, 0xCC, 0x1C, 0xE3,
0x1D, 0x01, 0x1D, 0x18, 0x1D, 0x2F, 0x1D, 0x3F, 0x1D, 0x4B,
0x1D, 0x5B, 0x1D, 0x67, 0x1D, 0x74, 0x1D, 0x82, 0x1D, 0x8E,
0x1D, 0x9E, 0x1D, 0xAC, 0x1D, 0xB9, 0x1D, 0xC4, 0x1D, 0xCF,
0x1D, 0xDF, 0x1D, 0xEE, 0x1D, 0xF9, 0x1E, 0x07, 0x1E, 0x11,
0x1E, 0x1B, 0x1E, 0x26, 0x1E, 0x3A, 0x1E, 0x4A, 0x1E, 0x56,
0x1E, 0x63, 0x1E, 0x77, 0x1E, 0x8B, 0x1E, 0xA7, 0x1E, 0xBB,
0x1E, 0xC9, 0x1E, 0xD3, 0x1E, 0xE6, 0x1E, 0xFB, 0x1F, 0x04,
0x1F, 0x13, 0x1F, 0x20, 0x1F, 0x2D, 0x1F, 0x42, 0x1F, 0x59,
0x1F, 0x70, 0x1F, 0x7A, 0x1F, 0x86, 0x1F, 0x9B, 0x1F, 0xAA,
0x1F, 0xB4, 0x1F, 0xBF, 0x1F, 0xD1, 0x1F, 0xE0, 0x1F, 0xF7,
0x20, 0x0E, 0x20, 0x25, 0x20, 0x2F, 0x20, 0x3C, 0x20, 0x48,
0x20, 0x53, 0x20, 0x62, 0x20, 0x7A, 0x20, 0x92, 0x20, 0x9D,
0x20, 0xA9, 0x20, 0xBA, 0x20, 0xC9, 0x20, 0xDB, 0x24, 0xE3,
0x20, 0xEA, 0x20, 0xF9, 0x21, 0x06, 0x21, 0x14, 0x21, 0x22,
0x21, 0x31, 0x21, 0x47, 0x21, 0x56, 0x21, 0x62, 0x21, 0x78,
0x21, 0x8C, 0x21, 0x9A, 0x21, 0xA6, 0x21, 0xB3, 0x21, 0xBE,
0x21, 0xC9, 0x21, 0xDC, 0x21, 0xED, 0x21, 0xFF, 0x22, 0x09,
0x22, 0x16, 0x22, 0x23, 0x22, 0x34, 0x22, 0x3E, 0x22, 0x4C,
0x22, 0x57, 0x22, 0x6D, 0x22, 0x7B, 0x22, 0x85, 0x22, 0x96,
0x22, 0xAB, 0x22, 0xC0, 0x22, 0xCE, 0x22, 0xDA, 0x22, 0xE9,
0x22, 0xF6, 0x23, 0x03, 0x23, 0x11, 0x23, 0x1D, 0x23, 0x28,
0x23, 0x38, 0x23, 0x47, 0x23, 0x54, 0x23, 0x67, 0x23, 0x75,
0x23, 0x80, 0x23, 0x8C, 0x23, 0x98, 0x23, 0xA8, 0x23, 0xB5,
0x23, 0xC0, 0x23, 0xCA, 0x23, 0xDC, 0x23, 0xE8, 0x23, 0xF5,
0x24, 0x05, 0x24, 0x12, 0x24, 0x21, 0x24, 0x32, 0x24, 0x41,
0x24, 0x4D, 0x24, 0x57, 0x24, 0x63, 0x24, 0x70, 0x02, 0xC0,
0x02, 0xCD, 0x02, 0xE2, 0x50, 0x00, 0x1C, 0x55, 0x50, 0x00,
0x1C, 0x58, 0x50, 0x00, 0x1C, 0x5B, 0x50, 0x00, 0x1C, 0x5E,
0x50, 0x00, 0x1C, 0x61, 0x50, 0x00, 0x1C, 0x64, 0x50, 0x00,
0x1C, 0x67, 0x50, 0x00, 0x1C, 0x6A, 0x50, 0x00, 0x1C, 0x6D,
0x50, 0x00, 0x1C, 0x70, 0x50, 0x00, 0x1C, 0x73, 0x50, 0x00,
0x1C, 0x76, 0x50, 0x00, 0x1C, 0x79, 0x50, 0x00, 0x1C, 0x7C,
0x50, 0x00, 0x1C, 0x7F, 0x50, 0x00, 0x1C, 0x82, 0x50, 0x00,
0x1C, 0x85, 0x50, 0x00, 0x1C, 0x88, 0x50, 0x00, 0x1C, 0x8B,
0x50, 0x00, 0x1C, 0x8E, 0x50, 0x00, 0x1C, 0x91, 0x50, 0x00,
0x1C, 0x94, 0x50, 0x00, 0x1C, 0x97, 0x50, 0x00, 0x1C, 0x9A,
0x50, 0x00, 0x1C, 0x9D, 0x50, 0x00, 0x1C, 0xA0, 0x50, 0x00,
0x1C, 0xA3, 0x50, 0x00, 0x1C, 0xA6, 0x50, 0x00, 0x1C, 0xA9,
0x50, 0x00, 0x1C, 0xAC, 0x50, 0x00, 0x1C, 0xAF, 0x50, 0x00,
0x1C, 0xB2, 0x50, 0x00, 0x1C, 0xB5, 0x50, 0x00, 0x1C, 0xB8,
0x50, 0x00, 0x1C, 0xBB, 0x50, 0x00, 0x1C, 0xBE, 0x50, 0x00,
0x1C, 0xC1, 0x50, 0x00, 0x1C, 0xC4, 0x50, 0x00, 0x1C, 0xC7,
0x50, 0x00, 0x1C, 0xCA, 0x50, 0x00, 0x1C, 0xCD, 0x50, 0x00,
0x1C, 0xD0, 0x50, 0x00, 0x1C, 0xD3, 0x50, 0x00, 0x1C, 0xD6,
0x50, 0x00, 0x1C, 0xD9, 0x50, 0x00, 0x1C, 0xDC, 0x50, 0x00,
0x1C, 0xDF, 0x50, 0x00, 0x1C, 0xE2, 0x50, 0x00, 0x1C, 0xE5,
0x50, 0x00, 0x1C, 0xE8, 0x50, 0x00, 0x1C, 0xEB, 0x50, 0x00,
0x1C, 0xEE, 0x50, 0x00, 0x1C, 0xF1, 0x50, 0x00, 0x1C, 0xF4,
0x50, 0x00, 0x1C, 0xF7, 0x50, 0x00, 0x1C, 0xFA, 0x50, 0x00,
0x1C, 0xFD, 0x50, 0x00, 0x1D, 0x00, 0x50, 0x00, 0x1D, 0x03,
0x50, 0x00, 0x1D, 0x06, 0x50, 0x00, 0x1D, 0x09, 0x50, 0x00,
0x1D, 0x0C, 0x50, 0x00, 0x1D, 0x0F, 0x50, 0x00, 0x1D, 0x12,
0x50, 0x00, 0x1D, 0x15, 0x50, 0x00, 0x1D, 0x18, 0x50, 0x00,
0x1D, 0x1B, 0x50, 0x00, 0x1D, 0x1E, 0x50, 0x00, 0x1D, 0x21,
0x50, 0x00, 0x1D, 0x24, 0x50, 0x00, 0x1D, 0x27, 0x50, 0x00,
0x1D, 0x2A, 0x50, 0x00, 0x1D, 0x2D, 0x50, 0x00, 0x1D, 0x30,
0x50, 0x00, 0x1D, 0x33, 0x50, 0x00, 0x1D, 0x36, 0x50, 0x00,
0x1D, 0x39, 0x50, 0x00, 0x1D, 0x3C, 0x50, 0x00, 0x1D, 0x3F,
0x50, 0x00, 0x1D, 0x42, 0x50, 0x00, 0x1D, 0x45, 0x50, 0x00,
0x1D, 0x48, 0x50, 0x00, 0x1D, 0x4B, 0x50, 0x00, 0x1D, 0x4E,
0x50, 0x00, 0x1D, 0x51, 0x50, 0x00, 0x1D, 0x54, 0x50, 0x00,
0x1D, 0x57, 0x50, 0x00, 0x1D, 0x5A, 0x50, 0x00, 0x1D, 0x5D,
0x50, 0x00, 0x1D, 0x60, 0x50, 0x00, 0x1D, 0x63, 0x50, 0x00,
0x1D, 0x66, 0x50, 0x00, 0x1D, 0x69, 0x50, 0x00, 0x1D, 0x6C,
0x50, 0x00, 0x1D, 0x6F, 0x50, 0x00, 0x1D, 0x72, 0x50, 0x00,
0x1D, 0x75, 0x50, 0x00, 0x1D, 0x78, 0x50, 0x00, 0x1D, 0x7B,
0x50, 0x00, 0x1D, 0x7E, 0x50, 0x00, 0x1D, 0x81, 0x50, 0x00,
0x1D, 0x84, 0x50, 0x00, 0x1D, 0x87, 0x50, 0x00, 0x1D, 0x8A,
0x50, 0x00, 0x1D, 0x8D, 0x50, 0x00, 0x1D, 0x90, 0x50, 0x00,
0x1D, 0x93, 0x50, 0x00, 0x1D, 0x96, 0x50, 0x00, 0x1D, 0x99,
0x50, 0x00, 0x1D, 0x9C, 0x50, 0x00, 0x1D, 0x9F, 0x50, 0x00,
0x1D, 0xA2, 0x50, 0x00, 0x1D, 0xA5, 0x50, 0x00, 0x1D, 0xA8,
0x50, 0x00, 0x1D, 0xAB, 0x50, 0x00, 0x1D, 0xAE, 0x50, 0x00,
0x1D, 0xB1, 0x50, 0x00, 0x1D, 0xB4, 0x50, 0x00, 0x1D, 0xB7,
0x50, 0x00, 0x1D, 0xBA, 0x50, 0x00, 0x1D, 0xBD, 0x50, 0x00,
0x1D, 0xC0, 0x50, 0x00, 0x1D, 0xC3, 0x50, 0x00, 0x1D, 0xC6,
0x50, 0x00, 0x1D, 0xC9, 0x50, 0x00, 0x1D, 0xCC, 0x50, 0x00,
0x1D, 0xCF, 0x50, 0x00, 0x1D, 0xD2, 0x50, 0x00, 0x1D, 0xD5,
0x50, 0x00, 0x1D, 0xD8, 0x50, 0x00, 0x1D, 0xDB, 0x50, 0x00,
0x1D, 0xDE, 0x50, 0x00, 0x1D, 0xE1, 0x50, 0x00, 0x1D, 0xE4,
0x50, 0x00, 0x1D, 0xE7, 0x50, 0x00, 0x1D, 0xEA, 0x50, 0x00,
0x1D, 0xED, 0x50, 0x00, 0x1D, 0xF0, 0x50, 0x00, 0x1D, 0xF3,
0x50, 0x00, 0x1D, 0xF6, 0x50, 0x00, 0x1D, 0xF9, 0x50, 0x00,
0x1D, 0xFC, 0x50, 0x00, 0x1D, 0xFF, 0x50, 0x00, 0x1E, 0x02,
0x50, 0x00, 0x1E, 0x05, 0x50, 0x00, 0x1E, 0x08, 0x50, 0x00,
0x1E, 0x0B, 0x50, 0x00, 0x1E, 0x0E, 0x50, 0x00, 0x1E, 0x11,
0x50, 0x00, 0x1E, 0x14, 0x50, 0x00, 0x1E, 0x17, 0x50, 0x00,
0x1E, 0x1A, 0x50, 0x00, 0x1E, 0x1D, 0x50, 0x00, 0x1E, 0x20,
0x50, 0x00, 0x1E, 0x23, 0x50, 0x00, 0x1E, 0x26, 0x50, 0x00,
0x1E, 0x29, 0x50, 0x00, 0x1E, 0x2C, 0x50, 0x00, 0x1E, 0x2F,
0x50, 0x00, 0x1E, 0x32, 0x50, 0x00, 0x1E, 0x35, 0x50, 0x00,
0x1E, 0x38, 0x50, 0x00, 0x1E, 0x3B, 0x50, 0x00, 0x1E, 0x3E,
0x50, 0x00, 0x1E, 0x41, 0x50, 0x00, 0x1E, 0x44, 0x50, 0x00,
0x1E, 0x47, 0x50, 0x00, 0x1E, 0x4A, 0x50, 0x00, 0x1E, 0x4D,
0x50, 0x00, 0x1E, 0x50, 0x50, 0x00, 0x1E, 0x53, 0x50, 0x00,
0x1E, 0x56, 0x50, 0x00, 0x1E, 0x59, 0x50, 0x00, 0x1E, 0x5C,
0x50, 0x00, 0x1E, 0x5F, 0x50, 0x00, 0x1E, 0x62, 0x50, 0x00,
0x1E, 0x65, 0x50, 0x00, 0x1E, 0x68, 0x50, 0x00, 0x1E, 0x6B,
0x50, 0x00, 0x1E, 0x6E, 0x50, 0x00, 0x1E, 0x71, 0x50, 0x00,
0x1E, 0x74, 0x50, 0x00, 0x1E, 0x77, 0x50, 0x00, 0x1E, 0x7A,
0x50, 0x00, 0x1E, 0x7D, 0x50, 0x00, 0x1E, 0x80, 0x50, 0x00,
0x1E, 0x83, 0x50, 0x00, 0x1E, 0x86, 0x50, 0x00, 0x1E, 0x89,
0x50, 0x00, 0x1E, 0x8C, 0x50, 0x00, 0x1E, 0x8F, 0x50, 0x00,
0x1E, 0x92, 0x50, 0x00, 0x1E, 0x95, 0x50, 0x00, 0x1E, 0x98,
0x50, 0x00, 0x1E, 0x9B, 0x50, 0x00, 0x1E, 0x9E, 0x50, 0x00,
0x1E, 0xA1, 0x50, 0x00, 0x1E, 0xA4, 0x50, 0x00, 0x1E, 0xA7,
0x50, 0x00, 0x1E, 0xAA, 0x50, 0x00, 0x1E, 0xAD, 0x50, 0x00,
0x1E, 0xB0, 0x50, 0x00, 0x1E, 0xB3, 0x50, 0x00, 0x1E, 0xB6,
0x50, 0x00, 0x1E, 0xB9, 0x50, 0x00, 0x1E, 0xBC, 0x50, 0x00,
0x1E, 0xBF, 0x50, 0x00, 0x1E, 0xC2, 0x50, 0x00, 0x1E, 0xC5,
0x50, 0x00, 0x1E, 0xC8, 0x50, 0x00, 0x1E, 0xCB, 0x50, 0x00,
0x1E, 0xCE, 0x50, 0x00, 0x1E, 0xD1, 0x50, 0x00, 0x1E, 0xD4,
0x50, 0x00, 0x1E, 0xD7, 0x50, 0x00, 0x1E, 0xDA, 0x50, 0x00,
0x1E, 0xDD, 0x50, 0x00, 0x1E, 0xE0, 0x50, 0x00, 0x1E, 0xE3,
0x50, 0x00, 0x1E, 0xE6, 0x50, 0x00, 0x1E, 0xE9, 0x50, 0x00,
0x1E, 0xEC, 0x50, 0x00, 0x1E, 0xEF, 0x50, 0x00, 0x1E, 0xF2,
0x50, 0x00, 0x1E, 0xF5, 0x50, 0x00, 0x1E, 0xF8, 0x50, 0x00,
0x1E, 0xFB, 0x50, 0x00, 0x1E, 0xFE, 0x50, 0x00, 0x1F, 0x01,
0x50, 0x00, 0x1F, 0x04, 0x50, 0x00, 0x1F, 0x07, 0x50, 0x00,
0x1F, 0x0A, 0x50, 0x00, 0x1F, 0x0D, 0x50, 0x00, 0x1F, 0x10,
0x50, 0x00, 0x1F, 0x13, 0x50, 0x00, 0x1F, 0x16, 0x50, 0x00,
0x1F, 0x19, 0x50, 0x00, 0x1F, 0x1C, 0x50, 0x00, 0x1F, 0x1F,
0x50, 0x00, 0x1F, 0x22, 0x50, 0x00, 0x1F, 0x25, 0x50, 0x00,
0x1F, 0x28, 0x50, 0x00, 0x1F, 0x2B, 0x50, 0x00, 0x1F, 0x2E,
0x50, 0x00, 0x1F, 0x31, 0x50, 0x00, 0x1F, 0x34, 0x50, 0x00,
0x1F, 0x37, 0x50, 0x00, 0x1F, 0x3A, 0x50, 0x00, 0x1F, 0x3D,
0x50, 0x00, 0x1F, 0x40, 0x50, 0x00, 0x1F, 0x43, 0x50, 0x00,
0x1F, 0x46, 0x50, 0x00, 0x1F, 0x49, 0x50, 0x00, 0x1F, 0x4C,
0x50, 0x00, 0x1F, 0x4F, 0x50, 0x00, 0x1F, 0x52, 0x50, 0x00,
0x1F, 0x55, 0x50, 0x00, 0x1F, 0x58, 0x50, 0x00, 0x1F, 0x5B,
0x50, 0x00, 0x1F, 0x5E, 0x50, 0x00, 0x1F, 0x61, 0x50, 0x00,
0x1F, 0x64, 0x50, 0x00, 0x1F, 0x67, 0x50, 0x00, 0x1F, 0x6A,
0x50, 0x00, 0x1F, 0x6D, 0x50, 0x00, 0x1F, 0x70, 0x50, 0x00,
0x1F, 0x73, 0x50, 0x00, 0x1F, 0x76, 0x50, 0x00, 0x1F, 0x79,
0x50, 0x00, 0x1F, 0x7C, 0x50, 0x00, 0x1F, 0x7F, 0x50, 0x00,
0x1F, 0x82, 0x50, 0x00, 0x1F, 0x85, 0x50, 0x00, 0x1F, 0x88,
0x50, 0x00, 0x1F, 0x8B, 0x50, 0x00, 0x1F, 0x8E, 0x50, 0x00,
0x1F, 0x91, 0x50, 0x00, 0x1F, 0x94, 0x50, 0x00, 0x1F, 0x97,
0x50, 0x00, 0x1F, 0x9A, 0x50, 0x00, 0x1F, 0x9D, 0x50, 0x00,
0x1F, 0xA0, 0x50, 0x00, 0x1F, 0xA3, 0x50, 0x00, 0x1F, 0xA6,
0x50, 0x00, 0x1F, 0xA9, 0x50, 0x00, 0x1F, 0xAC, 0x50, 0x00,
0x1F, 0xAF, 0x50, 0x00, 0x1F, 0xB2, 0x50, 0x00, 0x1F, 0xB5,
0x50, 0x00, 0x1F, 0xB8, 0x50, 0x00, 0x1F, 0xBB, 0x50, 0x00,
0x1F, 0xBE, 0x50, 0x00, 0x1F, 0xC1, 0x50, 0x00, 0x1F, 0xC4,
0x50, 0x00, 0x1F, 0xC7, 0x50, 0x00, 0x1F, 0xCA, 0x50, 0x00,
0x1F, 0xCD, 0x50, 0x00, 0x1F, 0xD0, 0x50, 0x00, 0x1F, 0xD3,
0x50, 0x00, 0x1F, 0xD6, 0x50, 0x00, 0x1F, 0xD9, 0x50, 0x00,
0x1F, 0xDC, 0x50, 0x00, 0x1F, 0xDF, 0x50, 0x00, 0x1F, 0xE2,
0x50, 0x00, 0x1F, 0xE5, 0x50, 0x00, 0x1F, 0xE8, 0x50, 0x00,
0x1F, 0xEB, 0x50, 0x00, 0x1F, 0xEE, 0x50, 0x00, 0x1F, 0xF1,
0x50, 0x00, 0x1F, 0xF4, 0x50, 0x00, 0x1F, 0xF7, 0x50, 0x00,
0x1F, 0xFA, 0x50, 0x00, 0x1F, 0xFD, 0x50, 0x00, 0x20, 0x00,
0x50, 0x00, 0x20, 0x03, 0x50, 0x00, 0x20, 0x06, 0x50, 0x00,
0x20, 0x09, 0x50, 0x00, 0x20, 0x0C, 0x50, 0x00, 0x20, 0x0F,
0x50, 0x00, 0x20, 0x12, 0x50, 0x00, 0x20, 0x15, 0x50, 0x00,
0x20, 0x18, 0x50, 0x00, 0x20, 0x1B, 0x50, 0x00, 0x20, 0x1E,
0x50, 0x00, 0x20, 0x21, 0x50, 0x00, 0x20, 0x24, 0x50, 0x00,
0x20, 0x27, 0x50, 0x00, 0x20, 0x2A, 0x50, 0x00, 0x20, 0x2F,
0x50, 0x00, 0x20, 0x32, 0x50, 0x00, 0x20, 0x35, 0x50, 0x00,
0x20, 0x38, 0x50, 0x00, 0x20, 0x3B, 0x50, 0x00, 0x20, 0x3E,
0x50, 0x00, 0x20, 0x41, 0x50, 0x00, 0x20, 0x44, 0x50, 0x00,
0x20, 0x47, 0x50, 0x00, 0x20, 0x4A, 0x50, 0x00, 0x20, 0x4D,
0x50, 0x00, 0x20, 0x50, 0x50, 0x00, 0x20, 0x55, 0x50, 0x00,
0x20, 0x58, 0x50, 0x00, 0x20, 0x5B, 0x50, 0x00, 0x20, 0x5E,
0x50, 0x00, 0x20, 0x61, 0x50, 0x00, 0x20, 0x64, 0x50, 0x00,
0x20, 0x67, 0x50, 0x00, 0x20, 0x6A, 0x50, 0x00, 0x20, 0x6D,
0x50, 0x00, 0x20, 0x70, 0x50, 0x00, 0x20, 0x73, 0x50, 0x00,
0x20, 0x76, 0x50, 0x00, 0x20, 0x79, 0x50, 0x00, 0x20, 0x7C,
0x50, 0x00, 0x20, 0x7F, 0x50, 0x00, 0x20, 0x82, 0x50, 0x00,
0x20, 0x85, 0x50, 0x00, 0x20, 0x88, 0x50, 0x00, 0x20, 0x8B,
0x50, 0x00, 0x20, 0x8E, 0x50, 0x00, 0x20, 0x91, 0x50, 0x00,
0x20, 0x94, 0x50, 0x00, 0x20, 0x97, 0x50, 0x00, 0x20, 0x9A,
0x50, 0x00, 0x20, 0x9D, 0x50, 0x00, 0x20, 0xA0, 0x50, 0x00,
0x20, 0xA3, 0x50, 0x00, 0x20, 0xA6, 0x50, 0x00, 0x20, 0xA9,
0x50, 0x00, 0x20, 0xAC, 0x50, 0x00, 0x20, 0xAF, 0x50, 0x00,
0x20, 0xB2, 0x50, 0x00, 0x20, 0xB5, 0x50, 0x00, 0x20, 0xB8,
0x50, 0x00, 0x20, 0xBB, 0x50, 0x00, 0x20, 0xBE, 0x50, 0x00,
0x20, 0xC1, 0x50, 0x00, 0x20, 0xC4, 0x50, 0x00, 0x20, 0xC7,
0x50, 0x00, 0x20, 0xCA, 0x50, 0x00, 0x20, 0xCD, 0x50, 0x00,
0x20, 0xD0, 0x50, 0x00, 0x20, 0xD3, 0x50, 0x00, 0x20, 0xD6,
0x50, 0x00, 0x20, 0xD9, 0x50, 0x00, 0x20, 0xDC, 0x50, 0x00,
0x20, 0xDF, 0x50, 0x00, 0x20, 0xE2, 0x50, 0x00, 0x20, 0xE5,
0x50, 0x00, 0x20, 0xE8, 0x50, 0x00, 0x20, 0xEB, 0x50, 0x00,
0x20, 0xEE, 0x50, 0x00, 0x20, 0xF1, 0x50, 0x00, 0x20, 0xF4,
0x50, 0x00, 0x20, 0xF7, 0x50, 0x00, 0x20, 0xFA, 0x50, 0x00,
0x20, 0xFD, 0x50, 0x00, 0x21, 0x00, 0x50, 0x00, 0x21, 0x03,
0x50, 0x00, 0x21, 0x06, 0x50, 0x00, 0x21, 0x09, 0x50, 0x00,
0x21, 0x0C, 0x50, 0x00, 0x21, 0x0F, 0x50, 0x00, 0x21, 0x12,
0x50, 0x00, 0x21, 0x15, 0x50, 0x00, 0x21, 0x18, 0x50, 0x00,
0x21, 0x1B, 0x50, 0x00, 0x21, 0x1E, 0x50, 0x00, 0x21, 0x21,
0x50, 0x00, 0x21, 0x24, 0x50, 0x00, 0x21, 0x27, 0x50, 0x00,
0x21, 0x2A, 0x50, 0x00, 0x21, 0x2D, 0x50, 0x00, 0x21, 0x30,
0x50, 0x00, 0x21, 0x33, 0x50, 0x00, 0x21, 0x36, 0x50, 0x00,
0x21, 0x39, 0x50, 0x00, 0x21, 0x3C, 0x50, 0x00, 0x21, 0x3F,
0x50, 0x00, 0x21, 0x42, 0x50, 0x00, 0x21, 0x45, 0x50, 0x00,
0x21, 0x48, 0x50, 0x00, 0x21, 0x4B, 0x60, 0x00, 0x1B, 0xFC,
0x60, 0x00, 0x05, 0xF8, 0x60, 0x00, 0x00, 0x01, 0x60, 0x00,
0x3E, 0x37, 0x50, 0x00, 0x21, 0x4E, 0x50, 0x00, 0x21, 0x51,
0x50, 0x00, 0x21, 0x54, 0x50, 0x00, 0x21, 0x57, 0x50, 0x00,
0x21, 0x5A, 0x50, 0x00, 0x21, 0x61, 0x50, 0x00, 0x21, 0x68,
0x50, 0x00, 0x21, 0x6F, 0x50, 0x00, 0x21, 0x76, 0x50, 0x00,
0x21, 0x7D, 0x50, 0x00, 0x21, 0x84, 0x50, 0x00, 0x21, 0x8B,
0x50, 0x00, 0x21, 0x92, 0x50, 0x00, 0x21, 0x99, 0x50, 0x00,
0x21, 0xA0, 0x50, 0x00, 0x21, 0xA7, 0x50, 0x00, 0x21, 0xAE,
0x50, 0x00, 0x21, 0xB5, 0x50, 0x00, 0x21, 0xBC, 0x50, 0x00,
0x21, 0xC3, 0x50, 0x00, 0x21, 0xCA, 0x50, 0x00, 0x21, 0xD1,
0x50, 0x00, 0x21, 0xD8, 0x50, 0x00, 0x21, 0xDF, 0x50, 0x00,
0x21, 0xE6, 0x50, 0x00, 0x21, 0xED, 0x50, 0x00, 0x21, 0xF0,
0x50, 0x00, 0x21, 0xF3, 0x50, 0x00, 0x21, 0xFA, 0x50, 0x00,
0x21, 0xFD, 0x50, 0x00, 0x22, 0x04, 0x50, 0x00, 0x22, 0x07,
0x50, 0x00, 0x22, 0x0E, 0x50, 0x00, 0x22, 0x15, 0x50, 0x00,
0x22, 0x1C, 0x50, 0x00, 0x22, 0x23, 0x50, 0x00, 0x22, 0x26,
0x50, 0x00, 0x22, 0x29, 0x50, 0x00, 0x22, 0x30, 0x50, 0x00,
0x22, 0x37, 0x50, 0x00, 0x22, 0x3E, 0x50, 0x00, 0x22, 0x41,
0x50, 0x00, 0x22, 0x44, 0x50, 0x00, 0x22, 0x47, 0x50, 0x00,
0x22, 0x4E, 0x50, 0x00, 0x22, 0x51, 0x50, 0x00, 0x22, 0x5E,
0x50, 0x00, 0x22, 0x6B, 0x50, 0x00, 0x22, 0x6E, 0x50, 0x00,
0x22, 0x7B, 0x50, 0x00, 0x22, 0x82, 0x50, 0x00, 0x22, 0x89,
0x50, 0x00, 0x22, 0x8C, 0x50, 0x00, 0x22, 0x8F, 0x50, 0x00,
0x22, 0x94, 0x50, 0x00, 0x22, 0x97, 0x50, 0x00, 0x22, 0x9A,
0x50, 0x00, 0x22, 0xA1, 0x50, 0x00, 0x22, 0xA4, 0x50, 0x00,
0x22, 0xAB, 0x50, 0x00, 0x22, 0xB2, 0x50, 0x00, 0x22, 0xB5,
0x50, 0x00, 0x22, 0xB8, 0x50, 0x00, 0x22, 0xBF, 0x50, 0x00,
0x22, 0xC6, 0x50, 0x00, 0x22, 0xCD, 0x50, 0x00, 0x22, 0xD0,
0x50, 0x00, 0x22, 0xD3, 0x50, 0x00, 0x22, 0xD6, 0x50, 0x00,
0x22, 0xD9, 0x50, 0x00, 0x22, 0xDC, 0x50, 0x00, 0x22, 0xDF,
0x50, 0x00, 0x22, 0xE6, 0x50, 0x00, 0x22, 0xED, 0x50, 0x00,
0x22, 0xF4, 0x50, 0x00, 0x22, 0xFB, 0x50, 0x00, 0x23, 0x02,
0x50, 0x00, 0x23, 0x05, 0x50, 0x00, 0x23, 0x08, 0x50, 0x00,
0x23, 0x0F, 0x50, 0x00, 0x23, 0x12, 0x50, 0x00, 0x23, 0x19,
0x50, 0x00, 0x23, 0x1C, 0x50, 0x00, 0x23, 0x1F, 0x50, 0x00,
0x23, 0x26, 0x50, 0x00, 0x23, 0x2D, 0x50, 0x00, 0x23, 0x30,
0x50, 0x00, 0x23, 0x37, 0x50, 0x00, 0x23, 0x3A, 0x50, 0x00,
0x23, 0x3D, 0x50, 0x00, 0x23, 0x40, 0x50, 0x00, 0x23, 0x43,
0x50, 0x00, 0x23, 0x4A, 0x50, 0x00, 0x23, 0x4D, 0x50, 0x00,
0x23, 0x54, 0x50, 0x00, 0x23, 0x5B, 0x50, 0x00, 0x23, 0x62,
0x50, 0x00, 0x23, 0x69, 0x50, 0x00, 0x23, 0x6C, 0x50, 0x00,
0x23, 0x6F, 0x50, 0x00, 0x23, 0x72, 0x50, 0x00, 0x23, 0x79,
0x50, 0x00, 0x23, 0x80, 0x50, 0x00, 0x23, 0x87, 0x50, 0x00,
0x23, 0x8A, 0x50, 0x00, 0x23, 0x8D, 0x50, 0x00, 0x23, 0x94,
0x50, 0x00, 0x23, 0x9B, 0x50, 0x00, 0x23, 0xA2, 0x50, 0x00,
0x23, 0xA9, 0x50, 0x00, 0x23, 0xAC, 0x50, 0x00, 0x23, 0xAF,
0x50, 0x00, 0x23, 0xB6, 0x50, 0x00, 0x23, 0xBD, 0x50, 0x00,
0x23, 0xC4, 0x50, 0x00, 0x23, 0xC7, 0x50, 0x00, 0x23, 0xCE,
0x50, 0x00, 0x23, 0xD1, 0x50, 0x00, 0x23, 0xD4, 0x50, 0x00,
0x23, 0xD7, 0x50, 0x00, 0x23, 0xDA, 0x50, 0x00, 0x23, 0xDD,
0x50, 0x00, 0x23, 0xE4, 0x50, 0x00, 0x23, 0xEB, 0x50, 0x00,
0x23, 0xF2, 0x50, 0x00, 0x23, 0xF5, 0x50, 0x00, 0x23, 0xF8,
0x50, 0x00, 0x23, 0xFB, 0x50, 0x00, 0x23, 0xFE, 0x50, 0x00,
0x24, 0x01, 0x50, 0x00, 0x24, 0x04, 0x50, 0x00, 0x24, 0x07,
0x50, 0x00, 0x24, 0x0E, 0x50, 0x00, 0x24, 0x11, 0x50, 0x00,
0x24, 0x14, 0x50, 0x00, 0x24, 0x1B, 0x50, 0x00, 0x24, 0x1E,
0x50, 0x00, 0x24, 0x25, 0x50, 0x00, 0x24, 0x28, 0x50, 0x00,
0x24, 0x2F, 0x50, 0x00, 0x24, 0x36, 0x50, 0x00, 0x24, 0x3D,
0x50, 0x00, 0x24, 0x40, 0x50, 0x00, 0x24, 0x47, 0x50, 0x00,
0x24, 0x4E, 0x50, 0x00, 0x24, 0x51, 0x50, 0x00, 0x24, 0x54,
0x50, 0x00, 0x24, 0x57, 0x50, 0x00, 0x24, 0x5E, 0x60, 0x00,
0x94, 0x7E, 0x60, 0x00, 0x98, 0x0D, 0x60, 0x00, 0x97, 0xF9,
0x00, 0x02, 0x00, 0x00, 0x00, 0x08, 0xAA, 0xAA, 0x60, 0x00,
0x1C, 0x06, 0x20, 0x00, 0x12, 0x3C, 0xAA, 0xAA, 0xAA, 0xAA,
0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
};
J2OBJC_RESOURCE(\
_com_ibm_icu_impl_data_icudt58b_zone_ca_res, \
22208, \
0x4f0e7c8);
#endif
| 61.721825 | 62 | 0.645584 |
ee1c7b794b712b27318da030474a767d2ee6faae | 432 | h | C | RZPlotView/RZPlotView/RZBaseStreamingPlotView.h | armcknight/RZPlotView | 791a91585f5ad9e261fd3dafe51a0ddc40306ffa | [
"MIT"
] | 1 | 2015-04-21T05:01:22.000Z | 2015-04-21T05:01:22.000Z | RZPlotView/RZPlotView/RZBaseStreamingPlotView.h | armcknight/RZPlotView | 791a91585f5ad9e261fd3dafe51a0ddc40306ffa | [
"MIT"
] | null | null | null | RZPlotView/RZPlotView/RZBaseStreamingPlotView.h | armcknight/RZPlotView | 791a91585f5ad9e261fd3dafe51a0ddc40306ffa | [
"MIT"
] | null | null | null | //
// GraphView.h
// AccelerometerPlot
//
// Created by andrew mcknight on 10/25/13.
// Copyright (c) 2013 andrew mcknight. All rights reserved.
//
#import "RZStaticPlotView.h"
typedef enum {
RZStreamingPlotDrawingModeShift,
RZStreamingPlotDrawingModeWrap
} RZStreamingPlotDrawingMode;
@interface RZBaseStreamingPlotView : RZStaticPlotView
@property (assign, nonatomic) RZStreamingPlotDrawingMode drawingMode;
@end
| 20.571429 | 69 | 0.775463 |
eeaf1a6604f35c1a665e394e28cf0838fb6fe34f | 5,705 | h | C | amt/RepositoryCompareView.h | dehilsterlexis/eclide-1 | 0c1685cc7165191b5033d450c59aec479f01010a | [
"Apache-2.0"
] | 8 | 2016-08-29T13:34:18.000Z | 2020-12-04T15:20:36.000Z | amt/RepositoryCompareView.h | dehilsterlexis/eclide-1 | 0c1685cc7165191b5033d450c59aec479f01010a | [
"Apache-2.0"
] | 221 | 2016-06-20T19:51:48.000Z | 2022-03-29T20:46:46.000Z | amt/RepositoryCompareView.h | dehilsterlexis/eclide-1 | 0c1685cc7165191b5033d450c59aec479f01010a | [
"Apache-2.0"
] | 13 | 2016-06-24T15:59:31.000Z | 2022-01-01T11:48:20.000Z | #pragma once
#include "global.h"
#include "TreePairNode.h"
#include "Selection.h"
#include "Dali.h"
#include "Combo.h"
#include "MultiTreeNode.h"
#include "Migration.h"
#include "Filter.h"
#include <LoginDlg.h> //wlib
enum UM
{
UM_FIRST = CWM_LAST + 1,
UM_INITIALIZE,
UM_MODULESLOADED,
UM_ATTRIBUTESLOADED,
UM_ATTRIBUTEHISTORIESLOADED,
UM_ITEMCLICKED,
UM_PASTE,
UM_INVALIDATE,
// Frame Messages
UM_CLEAR_DIFF,
UM_NEWSELECTION,
//UM_NEWCHECK,
UM_PROGRESSUPDATE,
UM_LAST
};
struct STRUCT_ATTRIBUTEHISTORIESLOADED
{
CAttributePairNode * treeItem;
IAttributeHistoryVector m_lhs;
IAttribute * m_rhs;
};
struct STRUCT_ITEMCLICKED
{
CTreeNode * m_item;
IAttributeVector m_attrs;
IAttributeVector m_depAttrs;
};
struct STRUCT_PASTE
{
IAttributeVector m_attrs;
std::_tstring m_errors;
};
#define NSUPPORT_WORKSPACE
class CRepositoryCompareView :
public CMultiTreeNodeViewCtrl,
public WTL::CCustomDraw<CRepositoryCompareView>,
//public WTL::CThemeImpl<CRepositoryCompareView>,
public CUnknown,
public IMigrationCallback
{
typedef CRepositoryCompareView thisClass;
typedef CMultiTreeNodeViewCtrl baseClass;
typedef WTL::CCustomDraw<CRepositoryCompareView> customClass;
//typedef WTL::CThemeImpl<CRepositoryCompareView> themeClass;
#ifdef _SUPPORT_WORKSPACE
friend void thread_LoadWorkspaceItems(CRepositoryCompareView * self, CWorkspacePairNode * ws);
#endif
friend void thread_LoadAttributes(CRepositoryCompareView * self, CModulePairNode * mod);
friend void thread_LoadWorkspacesAndModules(CRepositoryCompareView * self, bool noRefresh);
friend void thread_ItemClicked(CRepositoryCompareView * self, CTreeNode * tn, bool shiftKey);
friend void thread_Paste(CRepositoryCompareView * self, IRepository * rep, std::_tstring attrStrings);
public:
WTL::CImageList m_ilNormal;
WTL::CImageList m_ilCheck;
WTL::CImageList m_ilState;
LONG m_loadingModules;
int m_filter;
CSelection m_sel;
CComPtr<IMigration> m_migrator;
clib::CThreadQueue m_selectThreads;
clib::CThreadQueue m_expandThreads;
int m_jobCount;
public:
BEGIN_CUNKNOWN
END_CUNKNOWN(CUnknown)
STRUCT_DALI m_daliLHS;
CComPtr<IRepository> m_repLHS;
CComPtr<IRepository> m_repRHS;
DECLARE_WND_SUPERCLASS(NULL, CMultiTreeNodeViewCtrl::GetWndClassName())
CRepositoryCompareView();
BOOL PreTranslateMessage(MSG* pMsg);
void CreateData(); //For Testing Only
void Init(IRepository * repLHS, IRepository * repRHS, const STRUCT_DALI & dali);
void Kill();
void Load(CTreeNode * item, bool noRefresh);
void SelectAll();
void Clear();
void ClearSelection();
void ExpandAll();
bool SetFilter(int filter = AMT_SHOW_MATCHING & AMT_SHOW_NOT_MATCHING & AMT_SHOW_ORPHANS);
void SupressModuleChecksum(bool supressModuleChecksum);
bool CanCopy() const;
bool CanPaste() const;
void DoCopy() const;
void DoPaste(const std::_tstring & attributes);
bool DoMigration();
int GetMigrationCount() const;
BEGIN_MSG_MAP(thisClass)
MSG_WM_CREATE(OnCreate)
MESSAGE_HANDLER(UM_INITIALIZE, OnInitialize)
MSG_WM_SIZE(OnSize)
MSG_WM_TIMER(OnTimer)
MSG_WM_LBUTTONDOWN(OnLButtonDown)
MSG_WM_RBUTTONDOWN(OnRButtonDown)
//MSG_WM_CONTEXTMENU(OnContextMenu)
MESSAGE_HANDLER(UM_MODULESLOADED, OnModulesLoaded)
MESSAGE_HANDLER(UM_ATTRIBUTESLOADED, OnAttributesLoaded)
MESSAGE_HANDLER(UM_ATTRIBUTEHISTORIESLOADED, OnAttributeHistoriesLoaded)
MESSAGE_HANDLER(UM_ITEMCLICKED, OnItemClicked)
MESSAGE_HANDLER(UM_PASTE, OnPaste)
MESSAGE_HANDLER(UM_INVALIDATE, OnInvalidate)
REFLECTED_NOTIFY_CODE_HANDLER(TVN_SELCHANGED, OnSelChanged)
REFLECTED_NOTIFY_CODE_HANDLER(TVN_ITEMEXPANDING, OnItemExpanding)
REFLECTED_NOTIFY_CODE_HANDLER(TVN_DELETEITEM, OnDeleteItem)
CHAIN_MSG_MAP_ALT(customClass, 1)
CHAIN_MSG_MAP(baseClass)
END_MSG_MAP()
int OnCreate(LPCREATESTRUCT lpCreateStruct);
LRESULT OnInitialize(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
void OnSize(UINT nType, CSize size);
void OnTimer(UINT_PTR nIDEvent);
void OnLButtonDown(UINT nFlags, CPoint point);
void OnRButtonDown(UINT nFlags, CPoint point);
void OnContextMenu(CWindow wnd, CPoint point);
LRESULT OnModulesLoaded(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnAttributesLoaded(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnAttributeHistoriesLoaded(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnItemClicked(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnPaste(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnInvalidate(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/);
LRESULT OnSelChanged(WPARAM wParam, LPNMHDR pNMHDR, BOOL& bHandled);
LRESULT OnItemExpanding(WPARAM wParam, LPNMHDR pNMHDR, BOOL& bHandled);
LRESULT OnDeleteItem(WPARAM wParam, LPNMHDR pNMHDR, BOOL& bHandled);
DWORD OnPrePaint(int idCtrl, LPNMCUSTOMDRAW lpNMCustomDraw);
DWORD OnItemPrePaint(int idCtrl, LPNMCUSTOMDRAW lpNMCustomDraw);
DWORD OnItemPostPaint(int idCtrl, LPNMCUSTOMDRAW lpNMCustomDraw);
// IMigrationCallback
BOOL Invalidate(BOOL bErase = TRUE) throw();
void LogMsg(const std::_tstring & msg);
void PostStatus(const TCHAR* pStr);
void PostProgress(int progress);
};
| 32.6 | 112 | 0.731639 |
05154e25721b9098f951ec454523a6bf77bb5d8a | 371 | c | C | gcc-gcc-7_3_0-release/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c | best08618/asylo | 5a520a9f5c461ede0f32acc284017b737a43898c | [
"Apache-2.0"
] | 7 | 2020-05-02T17:34:05.000Z | 2021-10-17T10:15:18.000Z | gcc-gcc-7_3_0-release/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c | best08618/asylo | 5a520a9f5c461ede0f32acc284017b737a43898c | [
"Apache-2.0"
] | null | null | null | gcc-gcc-7_3_0-release/gcc/testsuite/gcc.dg/cpp/Wmissingdirs.c | best08618/asylo | 5a520a9f5c461ede0f32acc284017b737a43898c | [
"Apache-2.0"
] | 2 | 2020-07-27T00:22:36.000Z | 2021-04-01T09:41:02.000Z | /* { dg-do preprocess } */
/* { dg-options "-std=gnu99 -I /jolly/well/better/not/exist -Wmissing-include-dirs" } */
/* Test that -Wmissing-include-dirs issues a warning when a specified
directory does not exist. Source Ben Elliston, 2004-05-13. */
/* { dg-warning "No such file or directory.*Wmissing-include-dirs" "-Wmissing-include-dirs" { target *-*-* } 0 } */
| 46.375 | 115 | 0.673854 |
8cdae362d89a826e515cc17ac5f678484801abe9 | 722 | h | C | external/Winamp SDK/Wasabi/api/service/svcs/svc_scriptobj.h | jamesdsmith/gen_discordrpc | fb1ea7f281857448cb93f4bdbd95abd983c7c43d | [
"MIT"
] | null | null | null | external/Winamp SDK/Wasabi/api/service/svcs/svc_scriptobj.h | jamesdsmith/gen_discordrpc | fb1ea7f281857448cb93f4bdbd95abd983c7c43d | [
"MIT"
] | null | null | null | external/Winamp SDK/Wasabi/api/service/svcs/svc_scriptobj.h | jamesdsmith/gen_discordrpc | fb1ea7f281857448cb93f4bdbd95abd983c7c43d | [
"MIT"
] | null | null | null | #ifndef _SVC_SCRIPTOBJECT_H
#define _SVC_SCRIPTOBJECT_H
#include <bfc/dispatch.h>
#include <api/service/services.h>
class ScriptObjectController;
class svc_scriptObject : public Dispatchable {
public:
static FOURCC getServiceType() { return WaSvc::SCRIPTOBJECT; }
ScriptObjectController *getController(int n);
void onRegisterClasses(ScriptObjectController *rootController);
enum {
GETCONTROLLER=10,
ONREGISTER=20,
};
};
inline ScriptObjectController *svc_scriptObject::getController(int n) {
return _call(GETCONTROLLER, (ScriptObjectController *)0, n);
}
inline void svc_scriptObject::onRegisterClasses(ScriptObjectController *rootController) {
_voidcall(ONREGISTER, rootController);
}
#endif
| 24.066667 | 89 | 0.788089 |
4c05c9b9c613bc23520348743ff3408145d27736 | 5,631 | h | C | include/rw/_heap.h | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | include/rw/_heap.h | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | include/rw/_heap.h | Hower91/Apache-C-Standard-Library-4.2.x | 4d9011d60dbb38b3ff80dcfe54dccd3a4647d9d3 | [
"Apache-2.0"
] | null | null | null | // -*- C++ -*-
/***************************************************************************
*
* _heap.h - declarations and inline definitions of the C++ Standard
* Library Heap operations
*
* This is an internal header file used to implement the C++ Standard
* Library. It should never be #included directly by a program.
*
* $Id: //stdlib/dev/include/rw/_heap.h#3 $
*
***************************************************************************
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
***************************************************************************
*
* Copyright (c) 1994-2005 Quovadx, Inc., acting through its Rogue Wave
* Software division. 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.
*
**************************************************************************/
#ifndef _RWSTD_HEAP_H_INCLUDED
#define _RWSTD_HEAP_H_INCLUDED
#include <rw/_algobase.h>
#include <rw/_iterbase.h>
#include <rw/_defs.h>
_RWSTD_NAMESPACE (std) {
// 25.3.6 - Heap operations
// helper to work around the lack of iterator_traits
_EXPORT
template <class _RandomAccessIter, class _Dist, class _TypeT,
class _Compare>
void __push_heap (_RandomAccessIter, _Dist, _Dist, _TypeT, _Compare);
template <class _RandomAccessIter, class _Dist, class _Compare>
inline void
__push_heap (_RandomAccessIter __first, _RandomAccessIter __last,
_Dist*, _Compare __comp)
{
__push_heap (__first, _Dist (__last - __first), _Dist (), *__last, __comp);
}
// 25.3.6.1
template <class _RandomAccessIter, class _Compare>
inline void push_heap (_RandomAccessIter __first, _RandomAccessIter __last,
_Compare __comp)
{
_RWSTD_ASSERT_RANGE (__first, __last);
if (!(__first == __last))
__push_heap (__first, --__last,
_RWSTD_DIFFERENCE_TYPE (_RandomAccessIter), __comp);
}
// 25.3.6.1
template <class _RandomAccessIter>
inline void push_heap (_RandomAccessIter __first, _RandomAccessIter __last)
{
_STD::push_heap (__first, __last, _RWSTD_LESS (_RandomAccessIter));
}
_EXPORT
template <class _RandomAccessIter, class _Dist, class _TypeT,
class _Compare>
void __adjust_heap (_RandomAccessIter, _Dist, _Dist, _TypeT, _Compare);
// helper to work around the lack of iterator_traits
template <class _RandomAccessIter, class _TypeT, class _Compare, class _Dist>
inline void
__pop_heap (_RandomAccessIter __first, _RandomAccessIter __last,
_RandomAccessIter __res, _TypeT __val, _Compare __cmp, _Dist*)
{
*__res = *__first;
__adjust_heap (__first, _Dist (), _Dist (__last - __first), __val, __cmp);
}
// 25.3.6.2
template <class _RandomAccessIter, class _Compare>
inline void
pop_heap (_RandomAccessIter __first, _RandomAccessIter __last, _Compare __comp)
{
_RWSTD_ASSERT_RANGE (__first, __last);
if (!(__first == __last)) {
--__last;
__pop_heap (__first, __last, __last, *__last, __comp,
_RWSTD_DIFFERENCE_TYPE (_RandomAccessIter));
}
}
// 25.3.6.2
template <class _RandomAccessIter>
inline void pop_heap (_RandomAccessIter __first, _RandomAccessIter __last)
{
_STD::pop_heap (__first, __last, _RWSTD_LESS (_RandomAccessIter));
}
_EXPORT
template <class _RandomAccessIter, class _Compare, class _Dist>
void __make_heap (_RandomAccessIter, _RandomAccessIter, _Compare, _Dist*);
// 25.3.6.3
template <class _RandomAccessIter, class _Compare>
inline void make_heap (_RandomAccessIter __first, _RandomAccessIter __last,
_Compare __comp)
{
_RWSTD_ASSERT_RANGE (__first, __last);
if (!(__last - __first < 2))
__make_heap (__first, __last, __comp,
_RWSTD_DIFFERENCE_TYPE (_RandomAccessIter));
}
// 25.3.6.3
template <class _RandomAccessIter>
inline void make_heap (_RandomAccessIter __first, _RandomAccessIter __last)
{
_STD::make_heap (__first, __last, _RWSTD_LESS (_RandomAccessIter));
}
// 25.3.6.4
template <class _RandomAccessIter, class _Compare>
inline void sort_heap (_RandomAccessIter __first, _RandomAccessIter __last,
_Compare __comp)
{
_RWSTD_ASSERT_RANGE (__first, __last);
for (; __last - __first > 1; --__last)
_STD::pop_heap (__first, __last, __comp);
}
// 25.3.6.4
template <class _RandomAccessIter>
inline void sort_heap (_RandomAccessIter __first, _RandomAccessIter __last)
{
_STD::sort_heap (__first, __last, _RWSTD_LESS (_RandomAccessIter));
}
} // namespace std
#ifdef _RWSTD_NO_IMPLICIT_INCLUSION
# include <rw/_heap.cc>
#endif
#endif // _RWSTD_HEAP_H_INCLUDED
| 30.437838 | 79 | 0.679631 |
a70bc309737502119e7b6f0b0d5320c573e8c903 | 407 | h | C | ObjcExample/ObjcExample/Demo/GKPageScrollView/微博/GKWBListViewController.h | QuintGao/GKPageScrollView | b2e61c7e188234b3ce8b080535ad02191cae093a | [
"MIT"
] | 1,341 | 2018-10-28T12:42:22.000Z | 2022-03-30T11:35:15.000Z | ObjcExample/ObjcExample/Demo/GKPageScrollView/微博/GKWBListViewController.h | QuintGao/GKPageScrollView | b2e61c7e188234b3ce8b080535ad02191cae093a | [
"MIT"
] | 95 | 2018-12-07T17:08:33.000Z | 2022-03-22T08:06:53.000Z | ObjcExample/ObjcExample/Demo/GKPageScrollView/微博/GKWBListViewController.h | QuintGao/GKPageScrollView | b2e61c7e188234b3ce8b080535ad02191cae093a | [
"MIT"
] | 251 | 2018-10-29T05:54:37.000Z | 2022-03-19T19:31:54.000Z | //
// GKWBListViewController.h
// GKPageScrollView
//
// Created by QuintGao on 2018/10/27.
// Copyright © 2018 QuintGao. All rights reserved.
//
#import "GKDemoBaseViewController.h"
#import "GKPageScrollView.h"
NS_ASSUME_NONNULL_BEGIN
@interface GKWBListViewController : GKDemoBaseViewController<GKPageListViewDelegate>
@property (nonatomic, assign) BOOL isCanScroll;
@end
NS_ASSUME_NONNULL_END
| 19.380952 | 84 | 0.786241 |
a73e7369aa87b199f554e37b62c76621b10e1894 | 16,543 | h | C | Tacent/Modules/Math/Inc/Math/tColour.h | bluescan/dyndns46 | c2f9aa29dedf078c10939a0f26e4886b83f802ba | [
"0BSD"
] | 3 | 2020-09-02T23:10:19.000Z | 2021-01-29T14:02:03.000Z | Tacent/Modules/Math/Inc/Math/tColour.h | bluescan/tacit-dyndns | c2f9aa29dedf078c10939a0f26e4886b83f802ba | [
"0BSD"
] | null | null | null | Tacent/Modules/Math/Inc/Math/tColour.h | bluescan/tacit-dyndns | c2f9aa29dedf078c10939a0f26e4886b83f802ba | [
"0BSD"
] | 1 | 2020-09-02T23:05:23.000Z | 2020-09-02T23:05:23.000Z | // tColour.h
//
// Colour and pixel classes. Both a 32 bit integral representation as well as a 4 component floating point one can be
// found in this file.
//
// Copyright (c) 2006, 2011, 2017 Tristan Grimmer.
// Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby
// granted, provided that the above copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
// AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.
#pragma once
#include "Math/tFundamentals.h"
#include "Math/tVector3.h"
#include "Math/tVector4.h"
class tColourf;
// Colour space conversions. The integer versions accept angle modes of Degrees and Norm256 only. The angle mode
// determines the range of the hue. Degrees means angles are in [0, 360). Norm256 means angles are in [0, 256).
// Saturation and value are both in [0, 256) for the integer conversion functions.
void tRGBToHSV(int& h, int& s, int& v, int r, int g, int b, tMath::tAngleMode = tMath::tAngleMode::Degrees);
void tHSVToRGB(int& r, int& g, int& b, int h, int s, int v, tMath::tAngleMode = tMath::tAngleMode::Degrees);
// The floating point colour space conversion functions accept any angle mode. Radians mean angles are in [0.0, 2Pi).
// Degrees means angles are in [0.0, 360.0). Norm256 means angles are in [0.0, 256.0). NormOne means angles are
// in [0.0, 1.0].
void tRGBToHSV(float& h, float& s, float& v, float r, float g, float b, tMath::tAngleMode = tMath::tAngleMode::Radians);
void tHSVToRGB(float& r, float& g, float& b, float h, float s, float v, tMath::tAngleMode = tMath::tAngleMode::Radians);
// The tColouri class represents a colour in 32 bits and is made of 4 unsigned byte-size integers in the order RGBA.
class tColouri
{
public:
tColouri() /* Does NOT set the colour values. */ { }
tColouri(const tColouri& c) : BP(c.BP) { }
tColouri(int r, int g, int b, int a = 0xFF) { R = tMath::tGetClamp(r, 0, 0xFF); G = tMath::tGetClamp(g, 0, 0xFF); B = tMath::tGetClamp(b, 0, 0xFF); A = tMath::tGetClamp(a, 0, 0xFF); }
tColouri(uint8 r, uint8 g, uint8 b, uint8 a = 0xFF) : R(r), G(g), B(b), A(a) { }
tColouri(uint32 bits) : BP(bits) { }
tColouri(const tColourf& c) { Set(c); }
tColouri(float r, float g, float b, float a = 1.0f) { Set(r, g, b, a); }
tColouri(const float* src) { Set(src); }
void Set(const tColouri& c) { BP = c.BP; }
void Set(int r, int g, int b, int a = 255) { R = uint8(r); G = uint8(g); B = uint8(b); A = uint8(a); }
void Set(const tColourf& c);
void Set(const float* src) { SetR(src[0]); SetG(src[1]); SetB(src[2]); SetA(src[3]); }
void Set(float r, float g, float b, float a = 1.0f) { SetR(r); SetG(g); SetB(b); SetA(a); }
void SetR(float r) { R = tMath::tGetClamp( tMath::tFloatToInt(r*255.0f), 0, 0xFF ); }
void SetG(float g) { G = tMath::tGetClamp( tMath::tFloatToInt(g*255.0f), 0, 0xFF ); }
void SetB(float b) { B = tMath::tGetClamp( tMath::tFloatToInt(b*255.0f), 0, 0xFF ); }
void SetA(float a) { A = tMath::tGetClamp( tMath::tFloatToInt(a*255.0f), 0, 0xFF ); }
// The floating point get and set methods use a range of [0.0, 1.0] for each component.
float GetR() const { return float(R) / 255.0f; }
float GetG() const { return float(G) / 255.0f; }
float GetB() const { return float(B) / 255.0f; }
float GetA() const { return float(A) / 255.0f; }
void Get(float* dest) const { dest[0] = GetR(); dest[1] = GetG(); dest[2] = GetB(); dest[3] = GetA(); }
void Get(tMath::tVector3& dest) const { dest.x = GetR(); dest.y = GetG(); dest.z = GetB(); }
void Get(tMath::tVector4& dest) const { dest.x = GetR(); dest.y = GetG(); dest.z = GetB(); dest.w = GetA(); }
void Get(float& r, float&g, float& b, float& a) const { r = GetR(); g = GetG(); b = GetB(); a = GetA(); }
void Get(tColouri& c) const { c.BP = BP; }
void MakeBlack() { R = 0x00; G = 0x00; B = 0x00; A = 0xFF; }
void MakeWhite() { R = 0xFF; G = 0xFF; B = 0xFF; A = 0xFF; }
void MakePink() { R = 0xFF; G = 0x80; B = 0x80; A = 0xFF; }
void MakeRed() { R = 0xFF; G = 0x00; B = 0x00; A = 0xFF; }
void MakeGreen() { R = 0x00; G = 0xFF; B = 0x00; A = 0xFF; }
void MakeBlue() { R = 0x00; G = 0x00; B = 0xFF; A = 0xFF; }
void MakeGrey() { R = 0x80; G = 0x80; B = 0x80; A = 0xFF; }
void MakeLightGrey() { R = 0xC0; G = 0xC0; B = 0xC0; A = 0xFF; }
void MakeDarkGrey() { R = 0x40; G = 0x40; B = 0x40; A = 0xFF;}
void MakeCyan() { R = 0x00; G = 0xFF; B = 0xFF; A = 0xFF; }
void MakeMagenta() { R = 0xFF; G = 0x00; B = 0xFF; A = 0xFF; }
void MakeYellow() { R = 0xFF; G = 0xFF; B = 0x00; A = 0xFF; }
// These querying calls ignore alpha.
bool IsBlack() const { return ((R == 0x00) && (G == 0x00) && (B == 0x00)) ? true : false; }
bool IsWhite() const { return ((R == 0xFF) && (G == 0xFF) && (B == 0xFF)) ? true : false; }
bool IsRed() const { return ((R == 0xFF) && (G == 0x00) && (B == 0x00)) ? true : false; }
bool IsGreen() const { return ((R == 0x00) && (G == 0xFF) && (B == 0x00)) ? true : false; }
bool IsBlue() const { return ((R == 0x00) && (G == 0x00) && (B == 0xFF)) ? true : false; }
// When using the HSV representation of a tColouri, the hue is in normalized angle units. See tAngleMode::Norm256.
// Since only one byte is used, we divide the circle into 256 equal parts. All 4 values will be E [0, 255].
// Consider using a tColoutf object when working in HSV space. It can more accurately represent the hue value
// without as much loss in precision. See the tRGBToHSV function for retrieval of hue in different angle units.
// Both of the functions below leave the alpha unchanged.
void RGBToHSV(); // Assumes current values are RGB.
void HSVToRGB(); // Assumes current values are HSV.
bool operator==(const tColouri& c) const { return (BP == c.BP); }
bool operator!=(const tColouri& c) const { return (BP != c.BP); }
tColouri& operator=(const tColouri& c) { BP = c.BP; return *this; }
// Predefined colours. Initialized using the C++11 aggregate initializer syntax. These may be used before main()
// in normally (non-aggregate syntax) constructed objects.
const static tColouri black;
const static tColouri white;
const static tColouri pink;
const static tColouri red;
const static tColouri green;
const static tColouri blue;
const static tColouri grey;
const static tColouri lightgrey;
const static tColouri darkgrey;
const static tColouri cyan;
const static tColouri magenta;
const static tColouri yellow;
const static tColouri transparent;
union
{
struct { uint8 R, G, B, A; };
struct { uint8 H, S, V, A; };
// Bit Pattern member.
// Accessing the colour as a 32 bit value using the BP member means you must take the machine's endianness into
// account. This explains why the member isn't named something like RGBA. For example, in memory it's always in the
// RGBA no matter what endianness, but on a little endian machine you'd access the blue component with something
// like (colour.BP >> 16) % 0xFF
uint32 BP;
// Individual elements. Makes it easy to submit colours to OpenGL using glColor3ubv.
uint8 E[4];
};
};
typedef tColouri tPixel;
// The tColourf class represents a colour in 4 floats and is made of 4 unsigned bytes in the order RGBA.
// The values of each float component are E [0.0, 1.0].
class tColourf
{
public:
tColourf() { }
tColourf(const tColourf& src) { Set(src); }
tColourf(float r, float g, float b, float a = 1.0f) { Set(r, g, b, a); }
tColourf(const tMath::tVector3& c, float a = 1.0f) { Set(c, a); }
tColourf(const tMath::tVector4& ca) { Set(ca); }
tColourf(const tColouri& src) { Set(src); }
tColourf(uint8 r, uint8 g, uint8 b, uint8 a = 0xFF) { Set(r, g, b, a); }
tColourf(int r, int g, int b, int a = 255) { Set(r, g, b, a); }
void Unset() { R = -1.0f; G = -1.0f; B = -1.0f; A = -1.0f; } // An unset colour has value (-1.0f, -1.0f, -1.0f, -1.0f).
bool IsSet() const { if ((R != -1.0f) || (G != -1.0f) || (B != -1.0f) || (A != -1.0f)) return true; return false; } // Any set component means the whole colour is considered set.
void Set(const tColourf& c) { BP0 = c.BP0; BP1 = c.BP1; }
void Set(float r, float g, float b, float a = 1.0f) { R = r; G = g; B = b; A = a; }
void Set(const float* src) { R = src[0]; G = src[1]; B = src[2]; A = src[3]; }
void Set(const tMath::tVector3& c, float a = 1.0f) { R = c.x; G = c.y; B = c.z; A = a; }
void Set(const tMath::tVector4& ca) { R = ca.x; G = ca.y; B = ca.z; A = ca.w; }
void Set(const tColouri& c) { Set(float(c.R)/255.0f, float(c.G)/255.0f, float(c.B)/255.0f, float(c.A)/255.0f); }
void Set(int r, int g, int b, int a = 255) { Set(float(r)/255.0f, float(g)/255.0f, float(b)/255.0f, float(a)/255.0f); }
void SetR(int r) { R = float(r)/255.0f; }
void SetG(int g) { G = float(g)/255.0f; }
void SetB(int b) { B = float(b)/255.0f; }
void SetA(int a) { A = float(a)/255.0f; }
// The integer get and set methods use a range of [0, 255] for each component.
int GetR() const { return tMath::tFloatToInt(R * 255.0f); }
int GetG() const { return tMath::tFloatToInt(G * 255.0f); }
int GetB() const { return tMath::tFloatToInt(B * 255.0f); }
int GetA() const { return tMath::tFloatToInt(A * 255.0f); }
void Get(int* dest) const { dest[0] = GetR(); dest[1] = GetG(); dest[2] = GetB(); dest[3] = GetA(); }
void Get(tMath::tVector3& dest) const { dest.x = R; dest.y = G; dest.z = B; }
void Get(tMath::tVector4& dest) const { dest.x = R; dest.y = G; dest.z = B; dest.w = A; }
void Get(float& r, float&g, float& b, float& a) const { r = R; g = G; b = B; a = A; }
void Get(tColourf& c) const { c.BP0 = BP0; c.BP1 = BP1;}
void MakeBlack() { R = 0.0f; G = 0.0f; B = 0.0f; A = 1.0f; }
void MakeWhite() { R = 1.0f; G = 1.0f; B = 1.0f; A = 1.0f; }
void MakePink() { R = 1.0f; G = 0.5f; B = 0.5f; A = 1.0f; }
void MakeRed() { R = 1.0f; G = 0.0f; B = 0.0f; A = 1.0f; }
void MakeGreen() { R = 0.0f; G = 1.0f; B = 0.0f; A = 1.0f; }
void MakeBlue() { R = 0.0f; G = 0.0f; B = 1.0f; A = 1.0f; }
void MakeGrey() { R = 0.5f; G = 0.5f; B = 0.5f; A = 1.0f; }
void MakeLightGrey() { R = 0.75f; G = 0.75f; B = 0.75f; A = 1.0f; }
void MakeDarkGrey() { R = 0.25f; G = 0.25f; B = 0.25f; A = 1.0f;}
void MakeCyan() { R = 0.0f; G = 1.0f; B = 1.0f; A = 1.0f; }
void MakeMagenta() { R = 1.0f; G = 0.0f; B = 1.0f; A = 1.0f; }
void MakeYellow() { R = 1.0f; G = 1.0f; B = 0.0f; A = 1.0f; }
// These querying calls ignore alpha.
bool IsBlack() const { return ((R == 0.0f) && (G == 0.0f) && (B == 0.0f)) ? true : false; }
bool IsWhite() const { return ((R == 1.0f) && (G == 1.0f) && (B == 1.0f)) ? true : false; }
bool IsRed() const { return ((R == 1.0f) && (G == 0.0f) && (B == 0.0f)) ? true : false; }
bool IsGreen() const { return ((R == 0.0f) && (G == 1.0f) && (B == 0.0f)) ? true : false; }
bool IsBlue() const { return ((R == 0.0f) && (G == 0.0f) && (B == 1.0f)) ? true : false; }
// Colours in textures in files are usually in Gamma space and ought to be converted to linear space before
// lighting calculations are made. They should then be converted back to Gamma space before being displayed.
// Gamma-space here should really be sRGB but we're just using an approximation by squaring (gamma=2) when the
// average sRGB gamma should be 2.2. To do the conversion properly, the gamma varies with intensity from 1 to 2.4,
// but, again, we're only approximating here.
void ToLinearSpace() { R *= R; G *= G; B *= B; }
void ToGammaSpace() { R = tMath::tSqrt(R); G = tMath::tSqrt(G); B = tMath::tSqrt(B); }
// When using the HSV representation of a tColourf, the hue is in NormOne angle mode. See the tRGBToHSV and
// tHSVToRGB functions if you wish to use different angle units. All the components (h, s, v, r, g, b, a) are in
// [0.0, 1.0]. Both of the functions below leave the alpha unchanged.
void RGBToHSV(); // Assumes current values are RGB.
void HSVToRGB(); // Assumes current values are HSV.
bool operator==(const tColourf& c) const { return ((BP0 == c.BP0) && (BP1 == c.BP1)); }
bool operator!=(const tColourf& c) const { return ((BP0 != c.BP0) || (BP1 != c.BP1)); }
tColourf& operator=(const tColourf& c) { BP0 = c.BP0; BP1 = c.BP1; return *this; }
// Predefined colours. Initialized using the C++11 aggregate initializer syntax. These may be used before main()
// in normally (non-aggregate syntax) constructed objects.
const static tColourf invalid;
const static tColourf black;
const static tColourf white;
const static tColourf hotpink;
const static tColourf red;
const static tColourf green;
const static tColourf blue;
const static tColourf grey;
const static tColourf lightgrey;
const static tColourf darkgrey;
const static tColourf cyan;
const static tColourf magenta;
const static tColourf yellow;
const static tColourf transparent;
union
{
struct { float R, G, B, A; };
struct { float H, S, V, A; };
struct { uint64 BP0, BP1; }; // Bit Pattern.
float E[4];
};
};
typedef tColourf tColour;
// Implementation below this line.
inline void tColouri::Set(const tColourf& c)
{
Set(c.R, c.G, c.B, c.A);
}
inline void tColouri::RGBToHSV()
{
int r = R;
int g = G;
int b = B;
int h, s, v;
tRGBToHSV(h, s, v, r, g, b, tMath::tAngleMode::Norm256);
H = h;
S = s;
V = v;
}
inline void tColouri::HSVToRGB()
{
int h = H;
int s = S;
int v = V;
int r, g, b;
tHSVToRGB(r, g, b, h, s, v, tMath::tAngleMode::Norm256);
R = r;
G = g;
B = b;
}
inline void tColourf::RGBToHSV()
{
float r = R;
float g = G;
float b = B;
tRGBToHSV(H, S, V, r, g, b, tMath::tAngleMode::NormOne);
}
inline void tColourf::HSVToRGB()
{
float h = H;
float s = S;
float v = V;
tHSVToRGB(R, G, B, h, s, v, tMath::tAngleMode::NormOne);
}
| 53.711039 | 204 | 0.541679 |
4c85eb361a4d74b10c5ec40c0ec852e03e9ce623 | 8,143 | h | C | Source/Controls/TextEditorPackage/EditorCallback/GuiTextColorizer.h | cameled/GacUI | 939856c1045067dc7b78eb80cdb7174ae5c76799 | [
"RSA-MD"
] | 2,342 | 2015-04-01T22:12:53.000Z | 2022-03-31T07:00:33.000Z | Source/Controls/TextEditorPackage/EditorCallback/GuiTextColorizer.h | vczh2/GacUI | ce100ec13357bbf03ed3d2040c48d6b2b2fefd2f | [
"RSA-MD"
] | 68 | 2015-04-04T15:42:06.000Z | 2022-03-29T04:33:51.000Z | Source/Controls/TextEditorPackage/EditorCallback/GuiTextColorizer.h | vczh2/GacUI | ce100ec13357bbf03ed3d2040c48d6b2b2fefd2f | [
"RSA-MD"
] | 428 | 2015-04-02T00:25:48.000Z | 2022-03-25T16:37:56.000Z | /***********************************************************************
Vczh Library++ 3.0
Developer: Zihan Chen(vczh)
GacUI::Control System
Interfaces:
***********************************************************************/
#ifndef VCZH_PRESENTATION_CONTROLS_GUITEXTCOLORIZER
#define VCZH_PRESENTATION_CONTROLS_GUITEXTCOLORIZER
#include "GuiTextGeneralOperations.h"
namespace vl
{
namespace presentation
{
namespace controls
{
/***********************************************************************
GuiTextBoxColorizerBase
***********************************************************************/
/// <summary>The base class of text box colorizer.</summary>
class GuiTextBoxColorizerBase : public Object, public virtual ICommonTextEditCallback
{
public:
typedef collections::Array<elements::text::ColorEntry> ColorArray;
protected:
elements::GuiColorizedTextElement* element;
SpinLock* elementModifyLock;
volatile vint colorizedLineCount;
volatile bool isColorizerRunning;
volatile bool isFinalizing;
SpinLock colorizerRunningEvent;
static void ColorizerThreadProc(void* argument);
void StartColorizer();
void StopColorizer(bool forever);
void StopColorizerForever();
public:
/// <summary>Create a colorrizer.</summary>
GuiTextBoxColorizerBase();
~GuiTextBoxColorizerBase();
void Attach(elements::GuiColorizedTextElement* _element, SpinLock& _elementModifyLock, compositions::GuiGraphicsComposition* _ownerComposition, vuint editVersion)override;
void Detach()override;
void TextEditPreview(TextEditPreviewStruct& arguments)override;
void TextEditNotify(const TextEditNotifyStruct& arguments)override;
void TextCaretChanged(const TextCaretChangedStruct& arguments)override;
void TextEditFinished(vuint editVersion)override;
void RestartColorizer();
/// <summary>Get the lexical analyzer start state for the first line.</summary>
/// <returns>The lexical analyzer start state for the first line.</returns>
virtual vint GetLexerStartState()=0;
/// <summary>Get the context sensitive start state for the first line.</summary>
/// <returns>The context sensitive start state for the first line.</returns>
virtual vint GetContextStartState()=0;
/// <summary>Colorizer one line with a start state.</summary>
/// <param name="lineIndex">Line index.</param>
/// <param name="text">Text buffer.</param>
/// <param name="colors">Color index buffer. The index should be in [0 .. [M:vl.presentation.controls.GuiTextBoxColorizerBase.GetColors]()-1].</param>
/// <param name="length">The length of the buffer.</param>
/// <param name="lexerState">The lexical analyzer state for this line. After executing this function, the new value of this argument indicates the new state.</param>
/// <param name="contextState">The context sensitive state for this line. After executing this function, the new value of this argument indicates the new state.</param>
virtual void ColorizeLineWithCRLF(vint lineIndex, const wchar_t* text, vuint32_t* colors, vint length, vint& lexerState, vint& contextState)=0;
/// <summary>Get the supported colors ordered by their indices.</summary>
/// <returns>The supported colors ordered by their indices.</returns>
virtual const ColorArray& GetColors()=0;
};
/***********************************************************************
GuiTextBoxRegexColorizer
***********************************************************************/
/// <summary>Regex based colorizer.</summary>
class GuiTextBoxRegexColorizer : public GuiTextBoxColorizerBase
{
protected:
Ptr<regex::RegexLexer> lexer;
Ptr<regex::RegexLexerColorizer> colorizer;
void* colorizerArgument[1] { nullptr };
ColorArray colors;
elements::text::ColorEntry defaultColor;
collections::List<WString> tokenRegexes;
collections::List<elements::text::ColorEntry> tokenColors;
collections::List<elements::text::ColorEntry> extraTokenColors;
static void ColorizerProc(void* argument, vint start, vint length, vint token);
public:
/// <summary>Create the colorizer.</summary>
GuiTextBoxRegexColorizer();
~GuiTextBoxRegexColorizer();
/// <summary>Get the default color.</summary>
/// <returns>The default color.</returns>
elements::text::ColorEntry GetDefaultColor();
/// <summary>Get all regular expressions for tokens.</summary>
/// <returns>All regular expressions for tokens.</returns>
collections::List<WString>& GetTokenRegexes();
/// <summary>Get all colors for tokens.</summary>
/// <returns>All colors for tokens.</returns>
collections::List<elements::text::ColorEntry>& GetTokenColors();
/// <summary>Get all colors for extra tokens.</summary>
/// <returns>All colors for extra tokens.</returns>
collections::List<elements::text::ColorEntry>& GetExtraTokenColors();
/// <summary>Get the first token index for the first extra token.</summary>
/// <returns>The first token index for the first extra token. Returns -1 if this operation failed.</returns>
vint GetExtraTokenIndexStart();
/// <summary>Set the default color. Call [M:vl.presentation.controls.GuiTextBoxRegexColorizer.Setup] after finishing all configuration.</summary>
/// <returns>Returns the token index of this token. Returns -1 if this operation failed.</returns>
/// <param name="value">The default color.</param>
bool SetDefaultColor(elements::text::ColorEntry value);
/// <summary>Add a token type. Call [M:vl.presentation.controls.GuiTextBoxRegexColorizer.Setup] after finishing all configuration.</summary>
/// <returns>Returns the token index of this token. Returns -1 if this operation failed.</returns>
/// <param name="regex">The regular expression for this token type.</param>
/// <param name="color">The color for this token type.</param>
vint AddToken(const WString& regex, elements::text::ColorEntry color);
/// <summary>Add an extra token type. Call [M:vl.presentation.controls.GuiTextBoxRegexColorizer.Setup] after finishing all configuration.</summary>
/// <returns>Returns the extra token index of this token. The token index for this token is regex-token-count + extra-token-index Returns -1 if this operation failed.</returns>
/// <param name="color">The color for this token type.</param>
vint AddExtraToken(elements::text::ColorEntry color);
/// <summary>Clear all token color settings.</summary>
void ClearTokens();
/// <summary>Setup the colorizer. After that, the colorizer cannot be changed.</summary>
void Setup();
/// <summary>Callback function to set context sensitive state and change token accordingly.</summary>
/// <param name="lineIndex">Line index.</param>
/// <param name="text">Text buffer.</param>
/// <param name="start">The start position of the token.</param>
/// <param name="length">The length of the token.</param>
/// <param name="token">The token type. After executing this function, the new value of this argument indicates the new token type.</param>
/// <param name="contextState">The context sensitive state. After executing this function, the new value of this argument indicates the new state.</param>
virtual void ColorizeTokenContextSensitive(vint lineIndex, const wchar_t* text, vint start, vint length, vint& token, vint& contextState);
vint GetLexerStartState()override;
vint GetContextStartState()override;
void ColorizeLineWithCRLF(vint lineIndex, const wchar_t* text, vuint32_t* colors, vint length, vint& lexerState, vint& contextState)override;
const ColorArray& GetColors()override;
};
}
}
}
#endif | 54.286667 | 184 | 0.658725 |
73ede0a50f3730677517c1f14c7a8a062a50d2a8 | 821 | h | C | zipkin_opentracing/test/in_memory_reporter.h | sethalves/zipkin-cpp-opentracing | a134d5bb073392a0e2fe23c5fe5ef145c2ceb7ea | [
"Apache-2.0"
] | 43 | 2017-09-17T23:37:59.000Z | 2022-03-18T08:20:00.000Z | zipkin_opentracing/test/in_memory_reporter.h | sethalves/zipkin-cpp-opentracing | a134d5bb073392a0e2fe23c5fe5ef145c2ceb7ea | [
"Apache-2.0"
] | 31 | 2017-09-08T02:13:56.000Z | 2021-03-09T20:29:21.000Z | zipkin_opentracing/test/in_memory_reporter.h | sethalves/zipkin-cpp-opentracing | a134d5bb073392a0e2fe23c5fe5ef145c2ceb7ea | [
"Apache-2.0"
] | 38 | 2017-08-25T12:57:09.000Z | 2022-01-08T03:23:27.000Z | #pragma once
#include <mutex>
#include <vector>
#include <zipkin/tracer.h>
namespace zipkin {
// InMemoryReporter is used for testing only.
class InMemoryReporter : public Reporter {
public:
void reportSpan(const Span &span) override {
std::lock_guard<std::mutex> lock_guard(mutex_);
spans_.emplace_back(std::move(span));
}
std::vector<Span> spans() const {
std::lock_guard<std::mutex> lock_guard(mutex_);
return spans_;
}
size_t size() const {
std::lock_guard<std::mutex> lock_guard(mutex_);
return spans_.size();
}
Span top() const {
std::lock_guard<std::mutex> lock_guard(mutex_);
if (spans_.empty())
throw std::runtime_error("no spans");
return spans_.back();
}
private:
mutable std::mutex mutex_;
std::vector<Span> spans_;
};
} // namespace zipkin
| 21.605263 | 51 | 0.677223 |
42f1dd74766563ed452d45c00aad970039b501a7 | 31,927 | c | C | src/ngx_http_php_directive.c | rryqszq4/ngx_php7 | cb67b755ac1425490da27c57d41c5a33c0161954 | [
"BSD-2-Clause"
] | 381 | 2016-11-15T05:57:44.000Z | 2021-11-28T15:26:19.000Z | src/ngx_http_php_directive.c | rryqszq4/ngx_php7 | cb67b755ac1425490da27c57d41c5a33c0161954 | [
"BSD-2-Clause"
] | 49 | 2017-08-29T10:37:12.000Z | 2021-11-30T12:47:28.000Z | src/ngx_http_php_directive.c | rryqszq4/ngx_php7 | cb67b755ac1425490da27c57d41c5a33c0161954 | [
"BSD-2-Clause"
] | 49 | 2016-11-22T08:03:56.000Z | 2021-11-27T16:39:35.000Z | /*
==============================================================================
Copyright (c) 2016-2020, rryqszq4 <rryqszq@gmail.com>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
==============================================================================
*/
#include "ngx_http_php_module.h"
#include "ngx_http_php_core.h"
#include "ngx_php_conf_file.h"
#include "ngx_http_php_directive.h"
#include "ngx_http_php_variable.h"
#include "ngx_http_php_handler.h"
static char *ngx_http_php_init_worker_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_rewrite_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_access_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_content_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_log_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_header_filter_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *ngx_http_php_body_filter_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
static char *
ngx_http_php_init_worker_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
if (pmcf->init_worker_inline_code != NGX_CONF_UNSET_PTR){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
pmcf->init_worker_inline_code = code;
pmcf->enabled_init_worker_handler = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_rewrite_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->rewrite_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->rewrite_inline_code = code;
plcf->rewrite_handler = ngx_http_php_rewrite_inline_handler;
pmcf->enabled_rewrite_handler = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_access_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->access_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->access_inline_code = code;
plcf->access_handler = ngx_http_php_access_inline_handler;
pmcf->enabled_access_handler = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_content_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->content_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->content_inline_code = code;
plcf->content_handler = ngx_http_php_content_inline_handler;
pmcf->enabled_content_handler = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_log_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->log_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->log_code = code;
plcf->log_handler = ngx_http_php_log_inline_handler;
pmcf->enabled_log_handler = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_header_filter_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->header_filter_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->header_filter_inline_code = code;
plcf->header_filter_handler = ngx_http_php_header_filter_inline_handler;
pmcf->enabled_header_filter = 1;
return NGX_CONF_OK;
}
static char *
ngx_http_php_body_filter_block_phase_handler(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
/*if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}*/
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->body_filter_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[0]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->body_filter_inline_code = code;
plcf->body_filter_handler = ngx_http_php_body_filter_inline_handler;
pmcf->enabled_body_filter = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_ini_path(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf = conf;
ngx_str_t *value;
if (pmcf->ini_path.len != 0){
return "is duplicated";
}
value = cf->args->elts;
pmcf->ini_path.len = value[1].len;
pmcf->ini_path.data = value[1].data;
return NGX_CONF_OK;
}
char *
ngx_http_php_init_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
if (pmcf->init_inline_code != NGX_CONF_UNSET_PTR){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
pmcf->init_inline_code = code;
return NGX_CONF_OK;
}
char *
ngx_http_php_init_file_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
if (pmcf->init_code != NGX_CONF_UNSET_PTR){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
pmcf->init_code = code;
return NGX_CONF_OK;
}
char *
ngx_http_php_init_worker_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
if (pmcf->init_worker_inline_code != NGX_CONF_UNSET_PTR){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
pmcf->init_worker_inline_code = code;
pmcf->enabled_init_worker_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_rewrite_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->rewrite_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->rewrite_code = code;
plcf->rewrite_handler = cmd->post;
pmcf->enabled_rewrite_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_rewrite_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->rewrite_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->rewrite_inline_code = code;
plcf->rewrite_handler = cmd->post;
pmcf->enabled_rewrite_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_access_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->access_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->access_code = code;
plcf->access_handler = cmd->post;
pmcf->enabled_access_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_access_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->access_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->access_inline_code = code;
plcf->access_handler = cmd->post;
pmcf->enabled_access_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_content_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->content_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->content_code = code;
plcf->content_handler = cmd->post;
pmcf->enabled_content_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_content_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->content_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->content_inline_code = code;
plcf->content_handler = cmd->post;
pmcf->enabled_content_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_init_worker_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_init_worker_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_rewrite_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_rewrite_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_access_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_access_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_content_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_content_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_log_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_log_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_header_filter_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_header_filter_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_body_filter_block_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
char *rv;
ngx_conf_t save;
save = *cf;
cf->handler = ngx_http_php_body_filter_block_phase_handler;
cf->handler_conf = conf;
rv = ngx_php_conf_parse(cf, NULL);
*cf = save;
return rv;
}
char *
ngx_http_php_opcode_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->opcode_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->opcode_inline_code = code;
plcf->opcode_handler = cmd->post;
pmcf->enabled_opcode_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_stack_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->stack_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->stack_inline_code = code;
plcf->stack_handler = cmd->post;
pmcf->enabled_stack_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_log_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->log_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_file(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->log_code = code;
plcf->log_handler = cmd->post;
pmcf->enabled_log_handler = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_log_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->log_handler != NULL){
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
plcf->log_inline_code = code;
plcf->log_handler = cmd->post;
pmcf->enabled_log_handler = 1;
return NGX_CONF_OK;
}
static ngx_int_t
ngx_http_php_variable_handler(ngx_http_request_t *r, ngx_http_variable_value_t *v,
uintptr_t data)
{
ngx_http_php_variable_t *pv = (ngx_http_php_variable_t *) data;
ngx_http_php_var_set((char *)pv->key.data, pv->key.len, (char *)pv->handler.data, pv->handler.len);
return NGX_OK;
}
char *
ngx_http_php_set_inline2(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_int_t index;
ngx_str_t *value;
ngx_str_t handler;
ngx_http_variable_t *v;
ngx_http_php_variable_t *pv;
//ngx_http_php_main_conf_t *pmcf;
value = cf->args->elts;
if (value[1].data[0] != '$') {
ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
"invalid variable name \"%V\"", &value[1]);
return NGX_CONF_ERROR;
}
value[1].len--;
value[1].data++;
v = ngx_http_add_variable(cf, &value[1], NGX_HTTP_VAR_CHANGEABLE);
if (v == NULL) {
return NGX_CONF_ERROR;
}
pv = ngx_palloc(cf->pool, sizeof(ngx_http_php_variable_t));
if (pv == NULL) {
return NGX_CONF_ERROR;
}
index = ngx_http_get_variable_index(cf, &value[1]);
if (index == NGX_ERROR) {
return NGX_CONF_ERROR;
}
//pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
pv->code = ngx_http_php_code_from_string(cf->pool, &value[2]);
if (pv->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
php_ngx_module_init();
#if PHP_MAJOR_VERSION == 7 && PHP_MINOR_VERSION < 2
//zend_startup_module(&php_ngx_module_entry);
#else
EG(current_module) = &php_ngx_module_entry;
EG(current_module)->type = MODULE_PERSISTENT;
#endif
php_ngx_request_init();
zval retval;
zend_eval_string_ex(pv->code->code.string, &retval, "ngx_php run code return", 1 );
if (Z_TYPE(retval) == IS_TRUE ||
Z_TYPE(retval) == IS_FALSE ||
Z_TYPE(retval) == IS_LONG ||
Z_TYPE(retval) == IS_DOUBLE ||
Z_TYPE(retval) == IS_STRING ){
convert_to_string(&retval);
handler.data = ngx_pnalloc(cf->pool, Z_STRLEN(retval));
ngx_memcpy(handler.data, Z_STRVAL(retval), Z_STRLEN(retval));
handler.len = Z_STRLEN(retval);
} else {
handler.data = NULL;
handler.len = 0;
}
zval_dtor(&retval);
php_ngx_request_shutdown();
php_ngx_module_shutdown();
pv->key = value[1];
pv->handler = handler;
v->get_handler = ngx_http_php_variable_handler;
v->data = (uintptr_t) pv;
return NGX_CONF_OK;
}
#if defined(NDK) && NDK
char *
ngx_http_php_set_inline(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value;
ngx_str_t target;
ndk_set_var_t filter;
ngx_http_php_set_var_data_t *filter_data;
/*
value[0] = "php_set_code"
value[1] = target variable name
value[2] = php code
value[3..] = real params
*/
value = cf->args->elts;
target = value[1];
filter.type = NDK_SET_VAR_MULTI_VALUE_DATA;
filter.func = cmd->post;
filter.size = cf->args->nelts - 3;
filter_data = ngx_palloc(cf->pool, sizeof(ngx_http_php_set_var_data_t));
if (filter_data == NULL){
return NGX_CONF_ERROR;
}
filter_data->size = filter.size;
filter_data->var_name = value[1];
filter_data->script = value[2];
filter_data->code = ngx_http_php_code_from_string(cf->pool, &filter_data->script);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
filter.data = filter_data;
return ndk_set_var_multi_value_core(cf, &target, &value[3], &filter);
}
char *
ngx_http_php_set_run_inline(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value;
ngx_str_t target;
ndk_set_var_t filter;
ngx_http_php_set_var_data_t *filter_data;
/*
value[0] = "php_set_run_code"
value[1] = target variable name
value[2] = php code
value[3..] = real params
*/
value = cf->args->elts;
target = value[1];
filter.type = NDK_SET_VAR_MULTI_VALUE_DATA;
filter.func = cmd->post;
filter.size = cf->args->nelts - 3;
filter_data = ngx_palloc(cf->pool, sizeof(ngx_http_php_set_var_data_t));
if (filter_data == NULL){
return NGX_CONF_ERROR;
}
filter_data->size = filter.size;
filter_data->var_name = value[1];
filter_data->script = value[2];
filter_data->code = ngx_http_php_code_from_string(cf->pool, &filter_data->script);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
PHP_EMBED_START_BLOCK(0, NULL);
zval retval;
zend_eval_string_ex(filter_data->code->code.string, &retval, "ngx_php run code return", 1 );
if (Z_TYPE(retval) == IS_TRUE ||
Z_TYPE(retval) == IS_FALSE ||
Z_TYPE(retval) == IS_LONG ||
Z_TYPE(retval) == IS_DOUBLE ||
Z_TYPE(retval) == IS_STRING ){
convert_to_string(&retval);
filter_data->result.data = ngx_palloc(cf->pool, Z_STRLEN(retval));
ngx_memcpy(filter_data->result.data, Z_STRVAL(retval), Z_STRLEN(retval));
filter_data->result.len = Z_STRLEN(retval);
} else {
filter_data->result.data = NULL;
filter_data->result.len = 0;
}
zval_dtor(&retval);
PHP_EMBED_END_BLOCK();
if (filter_data->result.data != NULL){
filter_data->code = ngx_http_php_code_from_string(cf->pool, &filter_data->result);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
}
filter.data = filter_data;
return ndk_set_var_multi_value_core(cf, &target, &value[3], &filter);
}
char *
ngx_http_php_set_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf){
ngx_str_t *value;
ngx_str_t target;
ndk_set_var_t filter;
ngx_http_php_set_var_data_t *filter_data;
/*
value[0] = "php_set_file"
value[1] = target variable name
value[2] = php file
value[3..] = real params
*/
value = cf->args->elts;
target = value[1];
filter.type = NDK_SET_VAR_MULTI_VALUE_DATA;
filter.func = cmd->post;
filter.size = cf->args->nelts - 2;
filter_data = ngx_palloc(cf->pool, sizeof(ngx_http_php_set_var_data_t));
if (filter_data == NULL){
return NGX_CONF_ERROR;
}
filter_data->size = filter.size;
filter_data->var_name = value[1];
filter_data->script = value[2];
filter_data->code = ngx_http_php_code_from_file(cf->pool, &filter_data->script);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
filter.data = filter_data;
return ndk_set_var_multi_value_core(cf, &target, &value[2], &filter);
}
char *
ngx_http_php_set_run_file(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value;
ngx_str_t target;
ndk_set_var_t filter;
ngx_http_php_set_var_data_t *filter_data;
/*
value[0] = "php_set_file"
value[1] = target variable name
value[2] = php file
value[3..] = real params
*/
value = cf->args->elts;
target = value[1];
filter.type = NDK_SET_VAR_MULTI_VALUE_DATA;
filter.func = cmd->post;
filter.size = cf->args->nelts - 2;
filter_data = ngx_palloc(cf->pool, sizeof(ngx_http_php_set_var_data_t));
if (filter_data == NULL){
return NGX_CONF_ERROR;
}
filter_data->size = filter.size;
filter_data->var_name = value[1];
filter_data->script = value[2];
filter_data->code = ngx_http_php_code_from_file(cf->pool, &filter_data->script);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
PHP_EMBED_START_BLOCK(0, NULL);
zval *retval;
zend_file_handle file_handle;
retval = NULL;
file_handle.type = ZEND_HANDLE_FP;
file_handle.opened_path = NULL;
file_handle.free_filename = 0;
file_handle.filename = filter_data->code->code.file;
if (!(file_handle.handle.fp = VCWD_FOPEN(file_handle.filename, "rb"))) {
php_printf("Could not open input file: %s\n", file_handle.filename);
//return FAILURE;
return NGX_CONF_ERROR;
}
php_execute_simple_script(&file_handle, retval );
if (Z_TYPE_P(retval) == IS_TRUE ||
Z_TYPE_P(retval) == IS_FALSE ||
Z_TYPE_P(retval) == IS_LONG ||
Z_TYPE_P(retval) == IS_DOUBLE ||
Z_TYPE_P(retval) == IS_STRING ){
convert_to_string(retval);
filter_data->result.data = ngx_palloc(cf->pool, Z_STRLEN_P(retval));
ngx_memcpy(filter_data->result.data, Z_STRVAL_P(retval), Z_STRLEN_P(retval));
filter_data->result.len = Z_STRLEN_P(retval);
} else {
filter_data->result.data = NULL;
filter_data->result.len = 0;
}
zval_dtor(retval);
PHP_EMBED_END_BLOCK();
if (filter_data->result.data != NULL){
filter_data->code = ngx_http_php_code_from_string(cf->pool, &filter_data->result);
if (filter_data->code == NGX_CONF_UNSET_PTR){
return NGX_CONF_ERROR;
}
}
filter.data = filter_data;
return ndk_set_var_multi_value_core(cf, &target, &value[2], &filter);
}
#endif
char *
ngx_http_php_header_filter_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->header_filter_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->header_filter_inline_code = code;
plcf->header_filter_handler = cmd->post;
pmcf->enabled_header_filter = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_body_filter_inline_phase(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_http_php_main_conf_t *pmcf;
ngx_http_php_loc_conf_t *plcf;
ngx_str_t *value;
ngx_http_php_code_t *code;
if (cmd->post == NULL) {
return NGX_CONF_ERROR;
}
pmcf = ngx_http_conf_get_module_main_conf(cf, ngx_http_php_module);
plcf = conf;
if (plcf->body_filter_handler != NULL) {
return "is duplicated";
}
value = cf->args->elts;
code = ngx_http_php_code_from_string(cf->pool, &value[1]);
if (code == NGX_CONF_UNSET_PTR) {
return NGX_CONF_ERROR;
}
plcf->body_filter_inline_code = code;
plcf->body_filter_handler = cmd->post;
pmcf->enabled_body_filter = 1;
return NGX_CONF_OK;
}
char *
ngx_http_php_conf_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value = cf->args->elts;
ngx_http_php_srv_conf_t *pscf = conf;
ngx_int_t keepalive_size;
keepalive_size = ngx_atoi(value[1].data, value[1].len);
if (keepalive_size == NGX_ERROR) {
return "is duplicated";
}
if (pscf->keepalive_conf) {
pscf->keepalive_conf->max_cached = (ngx_uint_t)keepalive_size;
}
ngx_http_php_keepalive_init(cf->pool, pscf->keepalive_conf);
return NGX_CONF_OK;
}
char *
ngx_http_php_conf_socket_keepalive(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
ngx_str_t *value = cf->args->elts;
ngx_http_php_srv_conf_t *pscf = conf;
ngx_int_t keepalive_size;
keepalive_size = ngx_atoi(value[1].data, value[1].len);
if (keepalive_size == NGX_ERROR) {
return "is duplicated";
}
if (pscf->keepalive_conf) {
pscf->keepalive_conf->max_cached = (ngx_uint_t)keepalive_size;
}
ngx_http_php_keepalive_init(cf->pool, pscf->keepalive_conf);
return NGX_CONF_OK;
}
| 25.500799 | 108 | 0.664391 |
0950897fc6860e0cf0ab8920425ab0ecbaa2a84a | 4,387 | h | C | include/onnc/JSON/Value.h | LiuLeif/onnc | 3f69e46172a9c33cc04541ff7fd78d5d7b6bdbba | [
"BSD-3-Clause"
] | 450 | 2018-08-03T08:17:03.000Z | 2022-03-17T17:21:06.000Z | include/onnc/JSON/Value.h | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 104 | 2018-08-13T07:31:50.000Z | 2021-08-24T11:24:40.000Z | include/onnc/JSON/Value.h | ffk0716/onnc | 91e4955ade64b479db17aaeccacf4b7339fe44d2 | [
"BSD-3-Clause"
] | 100 | 2018-08-12T04:27:39.000Z | 2022-03-11T04:17:42.000Z | //===- Value.h ------------------------------------------------------------===//
//
// The ONNC Project
//
// See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#ifndef ONNC_JSON_VALUE_H
#define ONNC_JSON_VALUE_H
#include <onnc/ADT/StringRef.h>
#include <onnc/JSON/Notation.h>
#include <onnc/JSON/Array.h>
#include <onnc/Support/IndentOStream.h>
#include <string>
#include <cstring>
namespace onnc {
namespace json {
class Object;
/** \class Value
* \brief The json::Value class encapsulates a value in JSON.
*
* JSON is a format to store structured data. The support in Skymizer has 7
* basic data types @see json::Type:
* - bool
* - integral number
* - floating point number
* - string
* - object
* - array
* - null
*
* A value can represent any of the above data types. In addition, json::Value
* has a special flag to represent undefined values. This can be queried with
* @ref Notation::isUndefined().
*/
class Value : public Notation
{
public:
Value();
/// @name integral constructor
/// @{
explicit Value(long long int pN);
explicit Value(long int pN);
explicit Value(int pN);
explicit Value(unsigned long long int pN);
explicit Value(unsigned long int pN);
explicit Value(unsigned int pN);
/// @}
/// @name floating point constructor
/// @{
explicit Value(long double pF);
explicit Value(double pF);
explicit Value(float pF);
/// @}
/// boolean constructor
explicit Value(bool pB);
/// @name string constructor
/// @{
Value(StringRef pS);
Value(const char* pS);
/// @}
/// @name aggregative constructor
/// @{
/// Copy pObject to create a new Value.
Value(const Object& pObject);
/// Copy pArray to create a new Value.
Value(const Array& pArray);
/// @}
Value(const Value& pCopy);
Value(Value&& pOther);
~Value();
Value& operator=(const Value& pValue);
Value& operator=(Value&& pOther);
Value& assign(long long int pValue);
Value& assign(long int pValue);
Value& assign(int pValue);
Value& assign(long double pValue);
Value& assign(double pValue);
Value& assign(float pValue);
Value& assign(bool pValue);
Value& assign(StringRef pValue);
Value& assign(const char* pValue);
Value& assign(const std::string& pValue);
Value& append(const Value& pValue);
Value& delegate(json::Object& pObject);
Value& delegate(json::Array& pArray);
// convenient function for using Value as an Object object.
// call Object::insert
bool insert(StringRef pKey, const Value& pValue);
// convenient function for using Value as an Object object.
// call Value::write
bool write(StringRef pKey, const Value& pValue);
/// clear - reset Value to Unknown.
void clear();
void print(IndentOStream& pOS) const;
/// @name explicit_casting Explicit Casting Functions
/// @{
long long int toInteger() const { return m_Value.int_p; }
long double toFloating() const { return m_Value.float_p; }
bool toBool() const { return m_Value.bool_p; }
const char* toString() const { return m_Value.string_p; }
const Object& toObject() const { return *m_Value.object_p; }
const Array& toArray() const { return *m_Value.array_p; }
char* asString() { return m_Value.string_p; }
Object& asObject() { return *m_Value.object_p; }
Array& asArray() { return *m_Value.array_p; }
/// @}
private:
union Holder
{
public:
long double float_p;
long long int int_p;
bool bool_p;
char* string_p;
Object* object_p;
Array* array_p;
void* pointer;
public:
Holder() { reset(); }
~Holder() { }
void reset() { ::memset(this, 0, sizeof(Holder)); }
};
private:
Holder m_Value;
};
//===----------------------------------------------------------------------===//
// Template Helper
//===----------------------------------------------------------------------===//
template<typename> struct is_value_helper : public std::false_type { };
template<> struct is_value_helper<Value> : public std::true_type { };
template<typename TP>
struct is_value : public std::integral_constant<bool,(
is_value_helper<typename std::remove_cv<TP>::type>::value)> { };
} // namespace of json
} // namespace of onnc
#endif
| 25.805882 | 80 | 0.606109 |
098fbdbb9a11e5e7e9898f6508a69bba38bc65a1 | 145 | h | C | src/runner_cpu.h | hozuki/clray | 2fe2bc8b1b0bc092d1b20692c70b251ded6eba7b | [
"BSD-3-Clause"
] | null | null | null | src/runner_cpu.h | hozuki/clray | 2fe2bc8b1b0bc092d1b20692c70b251ded6eba7b | [
"BSD-3-Clause"
] | null | null | null | src/runner_cpu.h | hozuki/clray | 2fe2bc8b1b0bc092d1b20692c70b251ded6eba7b | [
"BSD-3-Clause"
] | null | null | null | //
// Created by MIC on 2019-02-19.
//
#ifndef CLRAY_RUNNER_CPU_H
#define CLRAY_RUNNER_CPU_H
void run_cpu_test();
#endif //CLRAY_RUNNER_CPU_H
| 13.181818 | 32 | 0.751724 |
4ef8fef1000ebb840f6abd53d1773e2463785629 | 652 | c | C | 209_min_size_sub_sum.c | wuzhouhui/leetcode | 80ae1f9209681ed12adf2f4a2783af8d1f9917e2 | [
"MIT"
] | 1 | 2019-09-24T14:23:42.000Z | 2019-09-24T14:23:42.000Z | 209_min_size_sub_sum.c | wuzhouhui/leetcode | 80ae1f9209681ed12adf2f4a2783af8d1f9917e2 | [
"MIT"
] | null | null | null | 209_min_size_sub_sum.c | wuzhouhui/leetcode | 80ae1f9209681ed12adf2f4a2783af8d1f9917e2 | [
"MIT"
] | 4 | 2017-03-18T11:31:08.000Z | 2021-12-12T03:28:44.000Z | int minSubArrayLen(int s, int *nums, int numsSize)
{
if (!numsSize)
return(0);
if (numsSize == 1)
return(nums[0] >= s ? 1 : 0);
int left, right, minlen, sum;
left = 0;
sum = 0;
right = -1;
minlen = numsSize;
while (right < numsSize) {
while (sum < s && ++right < numsSize)
sum += nums[right];
if (sum >= s) {
if ((right - left + 1) < minlen)
minlen = right - left + 1;
sum -= nums[left++];
}
if (left > right)
break;
}
return(minlen >= numsSize ? 0 : minlen);
}
#include <stdio.h>
int main(void)
{
int x[] = { 2, 3, 1, 2, 4, 3};
printf("%d\n", minSubArrayLen(7, x, sizeof(x) / sizeof(x[0])));
return(0);
}
| 18.111111 | 64 | 0.547546 |
ab45d222ecbfbd5a3d621bda57074f8bf5113fbe | 6,380 | c | C | +sl/+os/log_keyboard.c | JimHokanson/matlab_standard_library | b474cce3c70397f9695aa75cd293546734bd39ef | [
"MIT"
] | 4 | 2015-07-08T21:53:37.000Z | 2020-04-08T18:15:06.000Z | +sl/+os/log_keyboard.c | JimHokanson/matlab_standard_library | b474cce3c70397f9695aa75cd293546734bd39ef | [
"MIT"
] | 41 | 2015-02-19T12:45:57.000Z | 2020-03-29T18:29:49.000Z | +sl/+os/log_keyboard.c | JimHokanson/matlab_standard_library | b474cce3c70397f9695aa75cd293546734bd39ef | [
"MIT"
] | 5 | 2015-03-27T00:47:39.000Z | 2020-06-08T03:29:36.000Z | //http://stackoverflow.com/questions/1437158/c-win32-keyboard-events
//
//
// mex log_keyboard.c
#include "mex.h"
#include <windows.h>
char str[80];
bool shift_pressed;
bool ctrl_pressed;
bool caps_pressed;
LRESULT CALLBACK keyboard_hook_procedure(int code, WPARAM wParam, LPARAM lParam) {
//
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644985(v=vs.85).aspx
//
// code :
// Determines how to process the message. If less than zero
// you must call CallNextHookEx
// wParam :
// - WM_KEYDOWN
// - WM_KEYUP
// - WM_SYSKEYDOWN - alt key pressed
// - WM_SYSKEYUP
// lParam :
// pointer to a KBDLLHOOKSTRUCT structure
// Structure defined at:
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644967(v=vs.85).aspx
// typedef struct tagKBDLLHOOKSTRUCT {
// DWORD vkCode; - https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
// DWORD scanCode; - hardware scan code for key
// DWORD flags;
// DWORD time; - timestamp of the message
// ULONG_PTR dwExtraInfo; - Additional information associated with the message.
// } KBDLLHOOKSTRUCT, *PKBDLLHOOKSTRUCT, *LPKBDLLHOOKSTRUCT;
// short shift_pressed = GetKeyState(VK_SHIFT);
// short ctrl_pressed = GetKeyState(VK_CONTROL);
// short caps_pressed = GetKeyState(VK_CAPITAL);
KBDLLHOOKSTRUCT* kbd = (KBDLLHOOKSTRUCT*)lParam;
bool key_pressed;
DWORD vkcode = kbd->vkCode;
//WARNING:
//--------
//The hook procedure should process a message in less time than the data
//entry specified in the LowLevelHooksTimeout value in the following registry key:
// HKEY_CURRENT_USER\Control Panel\Desktop
// The value is in milliseconds. If the hook procedure times out, the system
// passes the message to the next hook. However, on Windows 7 and later,
// the hook is silently removed without being called. There is no way
// for the application to know whether the hook is removed.
// This hook must call the next one ...
// CallNextHookEx
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644974(v=vs.85).aspx
//
// 0 means, just call the next one ...
if (code < 0){
return CallNextHookEx(NULL, code, wParam, lParam);
}
//wParam
// if (wParam == WM_KEYUP){
// key_pressed = False;
// }else if (wParam == WM_KEYDOWN){
// key_pressed = True;
// }else
// {
// return CallNextHookEx(NULL, code, wParam, lParam);
// }
if (wParam == WM_KEYUP || wParam == WM_KEYDOWN){
//GetKeyState
//Shift
//Ctrl
//Caps Lock
key_pressed = !(wParam == WM_KEYUP);
//This doesn't handle sticky keys ...
//Added to ensure we don't miss capital letters ...
if (vkcode == VK_LSHIFT || vkcode == VK_RSHIFT){
shift_pressed = key_pressed;
}else if (vkcode == VK_LCONTROL || vkcode == VK_RCONTROL){
ctrl_pressed = key_pressed;
}else if (vkcode == VK_CAPITAL){
caps_pressed = key_pressed;
}
//I'm not sure of a better way to pass parameters ... :/
sprintf(str,"sl.os.keyboard_logger.keyboardEvent('%d:%d:%d:%d:%d:%d:%d')\0",
key_pressed,kbd->vkCode,kbd->scanCode,kbd->time,
shift_pressed,ctrl_pressed,caps_pressed);
mexEvalString(str);
}
// // // // //if (wParam == WM_KEYUP){
// // // // //sprintf should add a terminating null character to terminate the string
// // // // //thus I don't think we need to worry if the size of this string varies ...
// // // //
// // // // //Keys to know
// // // // //Shift
// // // // //Ctrl
// // // // //caps lock
// // // // //Alt
// // // //
// // // // BYTE keyState[256];
// // // //
// // // // GetKeyboardState((LPBYTE)&keyState);
// // // // wchar_t keyBuf[10];
// // // // int status = ToUnicodeEx(kbd->vkCode, kbd->scanCode, keyState, keyBuf, 10, 0 , hkl);
// // // //
// // // // if (status == 1 && keyBuf[0] > 0){
// // // // sprintf(str,"sl.os.keyboard_logger.keyboardEvent('%d:%d:%g')\0",wParam,keyBuf[0],kbd->time);
// // // // //This is a blocking call ...
// // // // //TODO: It would be better to not block ...
// // // // mexEvalString(str);
// // // // }
// // // // //}
return CallNextHookEx(NULL, code, wParam, lParam);
}
HHOOK keyboard_hook = 0;
static void CloseStream(void)
{
if (keyboard_hook != 0){
UnhookWindowsHookEx(keyboard_hook);
}
}
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
//Entry points
//------------
//1) Initialize
//2) Clear
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms644990(v=vs.85).aspx
// 1) WH_KEYBOARD_LL: Installs a hook procedure that monitors low-level keyboard input events.
// 2) HOOKPROC - pointer to the hook procedure
// 3) HINSTANCE - a handle to the dll containing the hook procedure - set
// to NULL if it comes from within code associated with the current
// process
// 4) DWORD = the identifier of the thread with which the hook
// procedure is to be associated
// => I think this allows you to be more specific as to what
// you are listening to
if (keyboard_hook == 0){
shift_pressed = GetKeyState(VK_SHIFT) < 0;
ctrl_pressed = GetKeyState(VK_CONTROL) < 0;
caps_pressed = GetKeyState(VK_CAPITAL) == 1;
keyboard_hook = SetWindowsHookEx(
WH_KEYBOARD_LL,
keyboard_hook_procedure,
NULL,
0);
}
mexAtExit(CloseStream);
}
| 36.25 | 121 | 0.542476 |
0682af00804f98ec7822a4f02100eff468c1cec1 | 12,541 | h | C | cpp/include/expected.h | KaMoKuMo/plain-old-data-mate | 2dc8a76d402f69a730230c46de4c5cecce8e2c2e | [
"MIT"
] | null | null | null | cpp/include/expected.h | KaMoKuMo/plain-old-data-mate | 2dc8a76d402f69a730230c46de4c5cecce8e2c2e | [
"MIT"
] | null | null | null | cpp/include/expected.h | KaMoKuMo/plain-old-data-mate | 2dc8a76d402f69a730230c46de4c5cecce8e2c2e | [
"MIT"
] | null | null | null | #pragma once
#include <exception>
#include <iostream>
#include <optional>
#include <type_traits>
#include <variant>
/** \addtogroup core
* @{
*/
/**
* \class Unexpected
*
* stores and provides some unexpected value. This class serves mainly the
* purpose of a helper class for the \see Expected
**/
template<typename E>
class Unexpected {
public:
static_assert(!std::is_same_v<E,void>, "E must not be void");
Unexpected() = delete;
//! constructs the Unexpected by copying the error
constexpr explicit Unexpected(E const& e) : error_(e) {}
//! constructs the Unexpected by moving the error
constexpr explicit Unexpected(E&& e) : error_(std::move(e)) {}
//! yields read access to the error
constexpr E const& error() const& noexcept {return error_;}
//! yields read and write access to the error
constexpr E & error() & noexcept {return error_;}
//! yields the contained error as a readable error
constexpr E const&& error() const&& noexcept {return std::move(error_);}
//! yields the contained error
constexpr E && error() && noexcept {return std::move(error_);}
//! Compares the error
constexpr bool operator==(Unexpected const& rRhs) const noexcept {
return error_ == rRhs;
}
//! Compares the error
constexpr bool operator!=(Unexpected const& rRhs) const noexcept {
return error_ != rRhs;
}
//! Compares the error
constexpr bool operator<(Unexpected const& rRhs) const noexcept {
return error_ < rRhs;
}
private:
E error_; //!< contained error
};
/**
* Exception thrown by an \see Expected::operator*(), or \see Expected::value(),
* if the expected value is demanded when the unexpected value is stored
**/
template<typename E>
class BadExpectedAccess : public std::exception {
public:
//! saves the error
explicit BadExpectedAccess(E e) : error_(std::move(e)) {}
//! yields the reason for the throw
virtual const char* what() const noexcept override {
return "Bad Expected access";
}
//! yields readable access to the error
constexpr E const& error() const& noexcept {return error_;}
//! yields read and write access to the error
constexpr E & error() & noexcept {return error_;}
//! yields the contained error as a readable error
constexpr E const&& error() const&& noexcept {return std::move(error_);}
//! yields the contained error
constexpr E && error() && noexcept {return std::move(error_);}
private:
E error_; //!< saved error
};
template<>
class BadExpectedAccess<void> : public std::exception {
public:
//! saves the error
explicit BadExpectedAccess() = default;
//! yields the reason for the throw
virtual const char* what() const noexcept override {
return "Bad Expected access";
}
};
/**
* Wrapper around a std::variant<Value, Error> carrying the meaning
* that the "Value" is expected, but the "Error" unexpected.
*
* There are two ways two construct an Expected. Either by implicitly
* converting an Unexpected<Error1> into some Expected storing the unexpected
* result, or by converting any number of arguments into the expected value_type.
* Notice that a default Expected will be initialized with a default
* initialized expected value.
*
* To check whether the expected value is stored the explicit operator bool()
* is supplied.
**/
template<typename T, typename E>
class [[nodiscard]] Expected {
public:
//! the expected value type
using value_type = T;
//! the unexpected type
using error_type = E;
/**
* Copies the data from the \see Unexpected object.
* Constructed with this c'tor the expected will yield false when asked
* about expected value.
*/
template<typename TError, std::enable_if_t< std::is_constructible_v<error_type, TError const&>, int > = 0>
constexpr Expected(Unexpected<TError> const& rE)
: data_(std::in_place_index_t<eT_error>{}, rE.error())
{
}
/**
* Moves the data from the \see Unexpected object.
* Constructed with this c'tor the expected will yield false when asked
* about expected value.
*/
template<typename TError, std::enable_if_t<std::is_constructible_v<error_type, TError&&>, int> = 0>
constexpr Expected(Unexpected<TError> && rE)
: data_(std::in_place_index_t<eT_error>{}, std::move(std::move(rE).error()))
{
}
/**
* Initializes an instance of the expected_type with given arguments.
* Constructed with this c'tor the expected will yield true when asked
* about the expected value.
**/
template<typename ...Args, std::enable_if_t<std::is_constructible_v<value_type, Args...>, int > = 0>
constexpr Expected(Args&& ...args)
: data_(std::in_place_index_t<eT_value>{}, std::forward<Args>(args)...)
{
}
//! true if the expected value is stored
explicit operator bool() const noexcept{
return std::get_if<eT_value>(&data_);
}
//! yields read access to the stored unexpected value, or throws if the expected value is contained
constexpr E const& error() const& noexcept(false) {
if (std::get_if<eT_value>(&data_))
throw BadExpectedAccess<T>(std::get<eT_value>(data_));
return std::get<eT_error>(data_);
}
//! yields read and write access to the stored unexpected value, or throws if the expected value is contained
constexpr E & error() & noexcept(false) {
if (std::get_if<eT_value>(&data_))
throw BadExpectedAccess<T>(std::get<eT_value>(data_));
return std::get<eT_error>(data_);
}
//! yields the stored unexpected value as read only, or throws if the expected value is contained
constexpr E const&& error() const&& noexcept(false) {
if (std::get_if<eT_value>(&data_))
throw BadExpectedAccess<T>(std::move(std::get<eT_value>(data_)));
return std::move(std::get<eT_error>(data_));
}
//! yields the stored unexpected value, or throws if the expected value is contained
constexpr E && error() && noexcept(false) {
if (std::get_if<eT_value>(&data_))
throw BadExpectedAccess<T>(std::move(std::get<eT_value>(data_)));
return std::move(std::get<eT_error>(data_));
}
//! yields read access to the stored expected value, or throws if the unexpected value is contained
constexpr T const& operator*() const& noexcept(false) {
if (std::get_if<eT_error>(&data_))
throw BadExpectedAccess<E>(std::get<eT_error>(data_));
return std::get<eT_value>(data_);
}
//! yields read and write access to the stored expected value, or throws if the unexpected value is contained
constexpr T & operator*() & noexcept(false) {
if (std::get_if<eT_error>(&data_))
throw BadExpectedAccess<E>(std::get<eT_error>(data_));
return std::get<eT_value>(data_);
}
//! yields the stored expected value as read only, or throws if the unexpected value is contained
constexpr T const&& operator*() const&& noexcept(false) {
if (std::get_if<eT_error>(&data_))
throw BadExpectedAccess<E>(std::move(std::get<eT_error>(data_)));
return std::move(std::get<eT_value>(data_));
}
//! yields the stored expected value, or throws if the unexpected value is contained
constexpr T && operator*() && noexcept(false) {
if (std::get_if<eT_error>(&data_))
throw BadExpectedAccess<E>(std::move(std::get<eT_error>(data_)));
return std::move(std::get<eT_value>(data_));
}
//! yields read and write access to the stored expected value, or throws if the unexpected value is contained
constexpr T* operator->() noexcept(false) {
if (auto* pData = std::get_if<eT_value>(&data_))
return pData;
throw BadExpectedAccess<E>(std::get<eT_error>(data_));
}
//! yields read access to the stored expected value, or throws if the unexpected value is contained
constexpr T const* operator->() const noexcept(false) {
if (auto* pData = std::get_if<eT_value>(&data_))
return pData;
throw BadExpectedAccess<E>(std::get<eT_error>(data_));
}
//! compares the state and the contained values
friend constexpr bool operator==(Expected const& lhs, Expected const& rhs) {
return lhs.data_ == rhs.data_;
}
//! streams the state and the corresponding value in a json format
friend std::ostream& operator<<(std::ostream& o, Expected<value_type, error_type> const& expectedValue) {
o << "{";
if (expectedValue) {
o << "\"expected value\" : " << *expectedValue;
} else {
o << "\"unexpected value\" : " << expectedValue.error();
}
return o << "}";
}
private:
enum Tag {
eT_value,
eT_error
};
std::variant<T, E> data_; //!< data storage
};
/**
* Partial specialization for the Expected<T, E> to allow T == void.
* Since no value is contained member functions for retrieving or accessing the
* value are omitted.
**/
template<typename E>
class [[nodiscard]] Expected<void, E> {
public:
//! the expected value type
using value_type = void;
//! the unexpected type
using error_type = E;
/**
* Copies the data from the \see Unexpected object.
* Constructed with this c'tor the expected will yield false when asked
* about expected value.
*/
template<typename TError, std::enable_if_t< std::is_constructible_v<error_type, TError const&>, int > = 0>
constexpr Expected(Unexpected<TError> const& rE)
: data_(rE.error())
{
}
/**
* Moves the data from the \see Unexpected object.
* Constructed with this c'tor the expected will yield false when asked
* about expected value.
*/
template<typename TError, std::enable_if_t<std::is_constructible_v<error_type, TError&&>, int> = 0>
constexpr Expected(Unexpected<TError> && rE)
: data_(std::move(std::move(rE).error()))
{
}
/**
* The default initialized expected is treated as the expected outcome.
**/
constexpr Expected() = default;
//! true if the expected value is stored
explicit operator bool() const noexcept{
return !data_;
}
//! yields read access to the stored unexpected value, or throws if the expected value is contained
constexpr E const& error() const& noexcept(false) {
if (*this)
throw BadExpectedAccess<void>();
return *data_;
}
//! yields read and write access to the stored unexpected value, or throws if the expected value is contained
constexpr E & error() & noexcept(false) {
if (*this)
throw BadExpectedAccess<void>();
return *data_;
}
//! yields the stored unexpected value as read only, or throws if the expected value is contained
constexpr E const&& error() const&& noexcept(false) {
if (*this)
throw BadExpectedAccess<void>();
return std::move(*data_);
}
//! yields the stored unexpected value, or throws if the expected value is contained
constexpr E && error() && noexcept(false) {
if (*this)
throw BadExpectedAccess<void>();
return std::move(*data_);
}
//! compares the state and the contained values
friend constexpr bool operator==(Expected const& lhs, Expected const& rhs) {
return lhs.data_ == rhs.data_;
}
//! streams the state and the corresponding value in a json format
friend std::ostream& operator<<(std::ostream& o, Expected<value_type, error_type> const& expectedValue) {
o << "{";
if (expectedValue) {
o << "\"expected value\" : void";
} else {
o << "\"unexpected value\" : " << expectedValue.error();
}
return o << "}";
}
private:
std::optional<error_type> data_; //!< data storage
};
//type trait to deduce whether a template parameter is of some "expected type"
template<typename, typename = void>
struct is_expected : std::false_type{};
template<typename T, typename E>
struct is_expected<Expected<T, E>> : std::true_type{};
template<typename T, typename E>
struct is_expected<Expected<T, E> const> : std::true_type{};
template<typename T, typename E>
struct is_expected<Expected<T, E> volatile> : std::true_type{};
template<typename T>
static constexpr bool is_expected_v = is_expected<T>::value;
/** @} */
| 36.037356 | 113 | 0.650666 |
6145d073555246d714a9f3fd6af528498b641e0c | 3,613 | c | C | grub-core/osdep/freebsd/hostdisk.c | dingjingmaster/graceful-grub | 7e57edc3cbd61774bbb57119c1893c77cb547d6a | [
"MIT"
] | null | null | null | grub-core/osdep/freebsd/hostdisk.c | dingjingmaster/graceful-grub | 7e57edc3cbd61774bbb57119c1893c77cb547d6a | [
"MIT"
] | null | null | null | grub-core/osdep/freebsd/hostdisk.c | dingjingmaster/graceful-grub | 7e57edc3cbd61774bbb57119c1893c77cb547d6a | [
"MIT"
] | null | null | null | /*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 1999,2000,2001,2002,2003,2004,2006,2007,2008,2009,2010,2011,2012,2013 Free Software Foundation, Inc.
*
* GRUB is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* GRUB 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with GRUB. If not, see <http://www.gnu.org/licenses/>.
*/
#include <config-util.h>
#include <grub/disk.h>
#include <grub/partition.h>
#include <grub/msdos_partition.h>
#include <grub/types.h>
#include <grub/err.h>
#include <grub/emu/misc.h>
#include <grub/emu/hostdisk.h>
#include <grub/emu/getroot.h>
#include <grub/misc.h>
#include <grub/i18n.h>
#include <grub/list.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <assert.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <limits.h>
# include <sys/disk.h> /* DIOCGMEDIASIZE */
# include <sys/param.h>
# include <sys/sysctl.h>
# include <sys/mount.h>
# include <libgeom.h>
grub_int64_t
grub_util_get_fd_size_os (grub_util_fd_t fd, const char *name, unsigned *log_secsize)
{
unsigned long long nr;
unsigned sector_size, log_sector_size;
if (ioctl (fd, DIOCGMEDIASIZE, &nr))
return -1;
if (ioctl (fd, DIOCGSECTORSIZE, §or_size))
return -1;
if (sector_size & (sector_size - 1) || !sector_size)
return -1;
for (log_sector_size = 0;
(1 << log_sector_size) < sector_size;
log_sector_size++);
if (log_secsize)
*log_secsize = log_sector_size;
if (nr & (sector_size - 1))
grub_util_error ("%s", _("unaligned device size"));
return nr;
}
void
grub_hostdisk_flush_initial_buffer (const char *os_dev __attribute__ ((unused)))
{
}
grub_util_fd_t
grub_util_fd_open (const char *os_dev, int flags)
{
grub_util_fd_t ret;
int sysctl_flags, sysctl_oldflags;
size_t sysctl_size = sizeof (sysctl_flags);
#ifdef O_LARGEFILE
flags |= O_LARGEFILE;
#endif
#ifdef O_BINARY
flags |= O_BINARY;
#endif
if (sysctlbyname ("kern.geom.debugflags", &sysctl_oldflags, &sysctl_size, NULL, 0))
{
grub_error (GRUB_ERR_BAD_DEVICE, "cannot get current flags of sysctl kern.geom.debugflags");
return GRUB_UTIL_FD_INVALID;
}
sysctl_flags = sysctl_oldflags | 0x10;
if (! (sysctl_oldflags & 0x10)
&& sysctlbyname ("kern.geom.debugflags", NULL , 0, &sysctl_flags, sysctl_size))
{
if (errno == EPERM)
/* Running as an unprivileged user; don't worry about restoring
flags, although if we try to write to anything interesting such
as the MBR then we may fail later. */
sysctl_oldflags = 0x10;
else
{
grub_error (GRUB_ERR_BAD_DEVICE, "cannot set flags of sysctl kern.geom.debugflags");
return GRUB_UTIL_FD_INVALID;
}
}
ret = open (os_dev, flags, S_IROTH | S_IRGRP | S_IRUSR | S_IWUSR);
if (! (sysctl_oldflags & 0x10)
&& sysctlbyname ("kern.geom.debugflags", NULL , 0, &sysctl_oldflags, sysctl_size))
{
grub_error (GRUB_ERR_BAD_DEVICE, "cannot set flags back to the old value for sysctl kern.geom.debugflags");
close (ret);
return GRUB_UTIL_FD_INVALID;
}
return ret;
}
| 28.007752 | 119 | 0.701356 |
39ae8a554ee8f6e3b5bc51ac1e2e74e56b210540 | 1,638 | h | C | src/main/include/commands/Autonomous/MainAutonomous.h | FIRSTTeam102/Robot2022 | 2a3224fd9bf7e4e9b469214fdf141a3d25d9094c | [
"BSD-3-Clause"
] | null | null | null | src/main/include/commands/Autonomous/MainAutonomous.h | FIRSTTeam102/Robot2022 | 2a3224fd9bf7e4e9b469214fdf141a3d25d9094c | [
"BSD-3-Clause"
] | null | null | null | src/main/include/commands/Autonomous/MainAutonomous.h | FIRSTTeam102/Robot2022 | 2a3224fd9bf7e4e9b469214fdf141a3d25d9094c | [
"BSD-3-Clause"
] | null | null | null | #pragma once
#include <frc/DoubleSolenoid.h>
#include <frc/XboxController.h>
#include <frc2/command/CommandHelper.h>
#include <frc2/command/FunctionalCommand.h>
#include <frc2/command/ParallelDeadlineGroup.h>
#include <frc2/command/PrintCommand.h>
#include <frc2/command/SequentialCommandGroup.h>
#include <frc2/command/WaitCommand.h>
#include <frc2/command/WaitUntilCommand.h>
#include "Utilities.h"
#include "commands/Indexer/SetIndexer.h"
#include "commands/Intake/SetArm.h"
#include "commands/Intake/SetRollers.h"
#include "commands/Limelight/LimelightShooter.h"
#include "commands/Limelight/YawToTarget.h"
#include "commands/Limelight/YawUntilTarget.h"
#include "commands/RumbleController.h"
#include "commands/Shooter/StartShooter.h"
#include "commands/Shooter/StopShooter.h"
#include "commands/SwerveDrive/MoveLinearTimed.h"
#include "commands/SwerveDrive/MoveVectorTimed.h"
#include "commands/SwerveDrive/SetAnglesCommand.h"
#include "commands/SwerveDrive/SetSpeedsTimed.h"
#include "commands/SwerveDrive/TurnDegreesGyro.h"
#include "subsystems/Indexer.h"
#include "subsystems/Intake.h"
#include "subsystems/Limelight.h"
#include "subsystems/Shooter.h"
#include "subsystems/ShooterHood.h"
#include "subsystems/SwerveDrive.h"
class MainAutonomous : public frc2::CommandHelper<frc2::SequentialCommandGroup, MainAutonomous> {
public:
MainAutonomous(Indexer* pIndexer, Intake* pIntake, Limelight* pLM, Shooter* pShooter, ShooterHood* pShooterHood, SwerveDrive* pSwerveDrive);
private:
Indexer* mpIndexer;
Intake* mpIntake;
Limelight* mpLM;
Shooter* mpShooter;
ShooterHood* mpShooterHood;
SwerveDrive* mpSwerve;
};
| 34.851064 | 142 | 0.801587 |
39bcbebc5145950a431c20e40bdd6e0750f02dad | 2,659 | c | C | qemu-kvm-0.14.1/qemu-kvm-ia64.c | MurphysChaos/VirtualFirmware | 829bfeb6bd37150a21170bc1033e50f30b9083b4 | [
"Intel",
"Unlicense"
] | 5 | 2015-07-01T13:27:45.000Z | 2021-02-05T15:17:18.000Z | qemu-kvm-0.14.1/qemu-kvm-ia64.c | MurphysChaos/VirtualFirmware | 829bfeb6bd37150a21170bc1033e50f30b9083b4 | [
"Intel",
"Unlicense"
] | null | null | null | qemu-kvm-0.14.1/qemu-kvm-ia64.c | MurphysChaos/VirtualFirmware | 829bfeb6bd37150a21170bc1033e50f30b9083b4 | [
"Intel",
"Unlicense"
] | 1 | 2015-08-03T10:00:38.000Z | 2015-08-03T10:00:38.000Z | #include "config.h"
#include "config-host.h"
#include <string.h>
#include "hw/hw.h"
#include "qemu-kvm.h"
#include <pthread.h>
#include <sys/utsname.h>
#include <sys/io.h>
int kvm_arch_qemu_create_context(void)
{
return 0;
}
void kvm_arch_load_regs(CPUState *env, int level)
{
}
void kvm_arch_save_regs(CPUState *env)
{
}
int kvm_arch_init_vcpu(CPUState *cenv)
{
return 0;
}
int kvm_arch_halt(kvm_vcpu_context_t vcpu)
{
CPUState *env = cpu_single_env;
env->hflags |= HF_HALTED_MASK;
return 1;
}
void kvm_arch_pre_kvm_run(void *opaque, CPUState *env)
{
}
void kvm_arch_post_kvm_run(void *opaque, CPUState *env)
{
}
int kvm_arch_has_work(CPUState *env)
{
return 1;
}
int kvm_arch_try_push_interrupts(void *opaque)
{
return 1;
}
int kvm_arch_insert_sw_breakpoint(CPUState *current_env,
struct kvm_sw_breakpoint *bp)
{
return -EINVAL;
}
int kvm_arch_remove_sw_breakpoint(CPUState *current_env,
struct kvm_sw_breakpoint *bp)
{
return -EINVAL;
}
int kvm_arch_insert_hw_breakpoint(target_ulong addr,
target_ulong len, int type)
{
return -ENOSYS;
}
int kvm_arch_remove_hw_breakpoint(target_ulong addr,
target_ulong len, int type)
{
return -ENOSYS;
}
void kvm_arch_remove_all_hw_breakpoints(void)
{
}
int kvm_arch_debug(struct kvm_debug_exit_arch *arch_info)
{
return 0;
}
void kvm_arch_update_guest_debug(CPUState *env, struct kvm_guest_debug *dbg)
{
}
void kvm_arch_save_mpstate(CPUState *env)
{
#ifdef KVM_CAP_MP_STATE
int r;
struct kvm_mp_state mp_state;
r = kvm_get_mpstate(env->kvm_cpu_state.vcpu_ctx, &mp_state);
if (r < 0)
env->mp_state = -1;
else
env->mp_state = mp_state.mp_state;
#endif
}
void kvm_arch_load_mpstate(CPUState *env)
{
#ifdef KVM_CAP_MP_STATE
struct kvm_mp_state mp_state = { .mp_state = env->mp_state };
/*
* -1 indicates that the host did not support GET_MP_STATE ioctl,
* so don't touch it.
*/
if (env->mp_state != -1)
kvm_set_mpstate(env->kvm_cpu_state.vcpu_ctx, &mp_state);
#endif
}
void kvm_arch_cpu_reset(CPUState *env)
{
if (kvm_irqchip_in_kernel(kvm_context)) {
#ifdef KVM_CAP_MP_STATE
struct kvm_mp_state mp_state = {.mp_state = KVM_MP_STATE_UNINITIALIZED
};
kvm_set_mpstate(env, &mp_state);
#endif
} else {
env->interrupt_request &= ~CPU_INTERRUPT_HARD;
env->halted = 1;
}
}
void kvm_arch_do_ioperm(void *_data)
{
struct ioperm_data *data = _data;
ioperm(data->start_port, data->num, data->turn_on);
}
void kvm_arch_process_irqchip_events(CPUState *env)
{
}
| 18.212329 | 78 | 0.692742 |
9f52fb4488288716988dc9d2707a31ef1ac35e9d | 1,247 | h | C | c_src/nifile.h | martinsumner/nifile | 9e956121412ab639770c019cc9030ec6e0107d4f | [
"Apache-2.0"
] | null | null | null | c_src/nifile.h | martinsumner/nifile | 9e956121412ab639770c019cc9030ec6e0107d4f | [
"Apache-2.0"
] | null | null | null | c_src/nifile.h | martinsumner/nifile | 9e956121412ab639770c019cc9030ec6e0107d4f | [
"Apache-2.0"
] | 1 | 2020-12-21T00:17:17.000Z | 2020-12-21T00:17:17.000Z | // 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.
#ifndef NIFILE_H
#define NIFILE_H
#include <unistd.h>
#include "erl_nif.h"
#ifndef ERL_NIF_DIRTY_SCHEDULER_SUPPORT
#error This NIF requires dirty scheduler support in the Erlang VM
#endif
#define ATOM_MAP(symname, defname, atomname) extern ERL_NIF_TERM ATOM_##defname;
#include "nifile_atoms.all"
#undef ATOM_MAP
void nifile_init_atoms(ErlNifEnv* env);
char* nifile_make_path(ErlNifBinary* path);
int nifile_open_oflags(ErlNifEnv* env, ERL_NIF_TERM oflags);
int nifile_open_modes(ErlNifEnv* env, ERL_NIF_TERM modes, int default_mode);
ERL_NIF_TERM nifile_errno_error(ErlNifEnv* env, int err);
ERL_NIF_TERM nifile_buffer(ErlNifEnv* env, ErlNifBinary* bin, ssize_t status);
#endif | 28.340909 | 80 | 0.779471 |
9f7b7c26e8e5baa6db5f39d1f026f68a61dffa56 | 3,204 | h | C | tensorflow/core/common_runtime/dml/dml_descriptor_pool.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 351 | 2020-09-01T08:36:28.000Z | 2022-03-29T06:54:29.000Z | tensorflow/core/common_runtime/dml/dml_descriptor_pool.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 80 | 2020-09-02T01:57:33.000Z | 2022-03-28T08:51:57.000Z | tensorflow/core/common_runtime/dml/dml_descriptor_pool.h | BenjaminWegener/tensorflow-directml | ecdbdbd2691e17dcc462fc49138fc7cc1536b7d5 | [
"Apache-2.0"
] | 29 | 2020-09-14T06:29:58.000Z | 2022-03-01T09:21:17.000Z | /* Copyright (c) Microsoft Corporation.
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.
==============================================================================*/
#pragma once
#include "dml_common.h"
#include "dml_gpu_event.h"
namespace tensorflow {
// A contiguous range of descriptors.
struct DmlDescriptorRange {
ID3D12DescriptorHeap* heap;
D3D12_CPU_DESCRIPTOR_HANDLE cpu_handle;
D3D12_GPU_DESCRIPTOR_HANDLE gpu_handle;
};
// Wraps an ID3D12DescriptorHeap to allocate descriptor ranges.
class DmlDescriptorHeap {
public:
// Wraps an existing heap.
explicit DmlDescriptorHeap(ID3D12DescriptorHeap* heap);
// Reserves descriptors from the end of the heap. Returns nullopt if there is
// no space left in the heap.
absl::optional<DmlDescriptorRange> TryAllocDescriptors(
uint32_t num_descriptors, DmlGpuEvent completion_event,
D3D12_DESCRIPTOR_HEAP_FLAGS heap_flags =
D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE);
DmlGpuEvent GetLastCompletionEvent() const { return completion_event_; }
uint32_t GetCapacity() const { return capacity_; }
private:
Microsoft::WRL::ComPtr<ID3D12DescriptorHeap> heap_;
uint32_t capacity_ = 0;
uint32_t size_ = 0;
uint32_t handle_increment_size_ = 0;
CD3DX12_CPU_DESCRIPTOR_HANDLE head_cpu_handle_;
CD3DX12_GPU_DESCRIPTOR_HANDLE head_gpu_handle_;
D3D12_DESCRIPTOR_HEAP_FLAGS heap_flags_ = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
// Most recent GPU completion event. Allocations are always done at the end,
// so there is no fragmentation of the heap.
DmlGpuEvent completion_event_;
};
// Manages a pool of CBV/SRV/UAV descriptors.
class DmlDescriptorPool {
public:
DmlDescriptorPool(ID3D12Device* device, uint32_t initial_capacity);
// Reserves a contiguous range of descriptors from a single descriptor heap.
// The lifetime of the referenced descriptor heap is managed by the
// DmlDescriptorPool class. The caller must supply a DmlGpuEvent that informs
// the pool when the reserved descriptors are no longer required.
DmlDescriptorRange AllocDescriptors(
uint32_t num_descriptors, DmlGpuEvent completion_event,
D3D12_DESCRIPTOR_HEAP_FLAGS heap_flags =
D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE);
// Releases all descriptor heaps that contain only descriptors which have
// completed their work on the GPU.
void Trim();
// Returns the total capacity of all heaps.
uint32_t GetTotalCapacity() const;
private:
Microsoft::WRL::ComPtr<ID3D12Device> device_;
std::vector<DmlDescriptorHeap> heaps_;
const uint32_t initial_heap_capacity_;
void CreateHeap(uint32_t num_descriptors,
D3D12_DESCRIPTOR_HEAP_FLAGS heap_flags);
};
} // namespace tensorflow | 35.208791 | 80 | 0.76186 |
c74b1dbed066696bd1f266da58dc9cfaa0e1b2aa | 157 | h | C | mp/src/game/server/mfs/MyBlockHandler.h | WorldGamers/Mobile-Forces-Source | fd188305e2690e193e17dba4cc6bcafa46dc34e3 | [
"CC-BY-4.0"
] | 3 | 2016-06-23T16:09:35.000Z | 2017-02-22T21:57:56.000Z | mp/src/game/server/mfs/MyBlockHandler.h | WorldGamers/Mobile-Forces-Source | fd188305e2690e193e17dba4cc6bcafa46dc34e3 | [
"CC-BY-4.0"
] | null | null | null | mp/src/game/server/mfs/MyBlockHandler.h | WorldGamers/Mobile-Forces-Source | fd188305e2690e193e17dba4cc6bcafa46dc34e3 | [
"CC-BY-4.0"
] | 1 | 2020-03-09T08:27:02.000Z | 2020-03-09T08:27:02.000Z | #ifndef MyBlockHandler_H
#define MyBlockHandler_H
#include "saverestore.h"
ISaveRestoreBlockHandler *GetMyBlockHandlerSaveRestoreBlockHandler();
#endif | 19.625 | 69 | 0.840764 |
b55c750f18d349535ef59be4c26e101ba7ee898b | 2,168 | c | C | nameMetaDat.c | Phil242/renameAtlasHD | ee0f5334cbb20b3a0144fb30de53691578aa4edf | [
"MIT"
] | 1 | 2015-12-08T08:58:20.000Z | 2015-12-08T08:58:20.000Z | nameMetaDat.c | Phil242/renameAtlasHD | ee0f5334cbb20b3a0144fb30de53691578aa4edf | [
"MIT"
] | null | null | null | nameMetaDat.c | Phil242/renameAtlasHD | ee0f5334cbb20b3a0144fb30de53691578aa4edf | [
"MIT"
] | null | null | null | // Auteur : Philippe Paget
// Lience : MIT
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct {
char pad1[0x15];
char chan[0x21];
char pad2;
char prov[0x21];
char pad3[0xA1];
char prog[0x3F];
unsigned char recHour; // UTC
unsigned char recMin;
char pad4[0x02];
unsigned char year1;
unsigned char year2;
unsigned char month;
unsigned char day;
char pad5[0x08];
unsigned char hour; // prog len
unsigned char min;
unsigned char sec;
char pad6[0x2D];
} DAT ;
char tolow(char car)
{
if ((car <= 'Z') && (car >= 'A'))
return (car + 0x20);
else
return (car);
}
void strlwr(char * buffer)
{
int i;
for(i = 0; buffer[i]; i++)
buffer[i] = tolow(buffer[i]);
}
int lenFile(char * nom)
{
FILE *fp;
int file_size=0;
if ((fp = fopen(nom, "rb" )) == NULL)
{
//printf("%s",nom);
printf("META.DAT");
exit(1);
}
if (fseek(fp, (long)(0), SEEK_END) != 0)
{
fclose(fp);
return(file_size);
}
file_size = (ftell(fp));
fclose(fp);
return(file_size);
}
int main(int argc, char *argv[])
{
DAT dat;
char fileName[10+0x21+1+0x3F+1+5+3*3+20];
char buff[100];
FILE * fd;
if (argc != 2 )
{
printf("Utilisation: nameMetaDat META.DAT\n");
exit(1);
}
memset(fileName,0,sizeof(fileName));
memset(buff,0,sizeof(buff));
if (lenFile(argv[1])!=376)
{
//printf("%s",argv[1]);
printf("META.DAT");
exit(1);
}
fd = fopen( argv[1], "rb");
fread(&dat,sizeof(DAT),1,fd);
fclose(fd);
if (dat.year2 != 0x07 )
{
printf("META.DAT");
exit(1);
}
sprintf(fileName,"%d-%02d-%02d - ",(dat.year2<<8)+dat.year1,dat.month,dat.day);
strncpy(buff,dat.chan,0x21);
strlwr(&buff[1]);
strcat(fileName,buff);
strcat(fileName," - ");
if(strcmp(dat.chan,dat.prog))
{
strncpy(buff,dat.prog,0x3F);
strlwr(&buff[1]);
strcat(fileName,buff);
strcat(fileName," - ");
}
else
{
}
sprintf(buff,"%dH%02d",dat.hour,dat.min);
strcat(fileName,buff);
printf("%s",fileName);
return 0;
}
| 17.917355 | 80 | 0.550738 |
ba090407e4dd133b7c0ca57f8a346f33ce9f7a73 | 14,521 | h | C | framework/PVRVk/PhysicalDeviceVk.h | jjYBdx4IL/Native_SDK | 5e1cdf579fd0a98c26935ebef098dd3f41829c86 | [
"MIT"
] | null | null | null | framework/PVRVk/PhysicalDeviceVk.h | jjYBdx4IL/Native_SDK | 5e1cdf579fd0a98c26935ebef098dd3f41829c86 | [
"MIT"
] | null | null | null | framework/PVRVk/PhysicalDeviceVk.h | jjYBdx4IL/Native_SDK | 5e1cdf579fd0a98c26935ebef098dd3f41829c86 | [
"MIT"
] | null | null | null | /*!
\brief The Physical Device class
\file PVRVk/PhysicalDeviceVk.h
\author PowerVR by Imagination, Developer Technology Team
\copyright Copyright (c) Imagination Technologies Limited.
*/
#pragma once
#include "PVRVk/ForwardDecObjectsVk.h"
#include "PVRVk/InstanceVk.h"
#include "PVRVk/PVRVkObjectBaseVk.h"
#include "PVRVk/TypesVk.h"
#include "PVRVk/DebugUtilsVk.h"
namespace pvrvk {
/// <summary>Defines a fragment shading rate as a fragment size and a bitmask of the MSAA sample counts that can be used with that fragment size.
/// Use pvrvk::PhysicalDevice::getAvailableFragmentShadingRates() to get the available fragment shading rates for a particular physical devices</summary>
class PhysicalDeviceFragmentShadingRate : private VkPhysicalDeviceFragmentShadingRateKHR
{
public:
PhysicalDeviceFragmentShadingRate()
{
sampleCounts = static_cast<VkSampleCountFlags>(SampleCountFlags::e_NONE);
fragmentSize = Extent2D().get();
}
PhysicalDeviceFragmentShadingRate(VkPhysicalDeviceFragmentShadingRateKHR vkType) : VkPhysicalDeviceFragmentShadingRateKHR(vkType) {}
PhysicalDeviceFragmentShadingRate(SampleCountFlags sampleCounts, Extent2D fragmentSize)
{
this->sampleCounts = static_cast<VkSampleCountFlags>(sampleCounts);
this->fragmentSize = fragmentSize.get();
}
/// <summary>Get the vulkan struct equivilent of this class.</summary>
/// <returns>VkPhysicalDeviceFragmentShadingRateKHR struct.</returns>
inline VkPhysicalDeviceFragmentShadingRateKHR& get() { return *this; }
/// <summary>Get the vulkan struct equivilent of this class.</summary>
/// <returns>Const VkPhysicalDeviceFragmentShadingRateKHR struct.</returns>
inline const VkPhysicalDeviceFragmentShadingRateKHR& get() const { return *this; }
/// <summary>Get the [x,y] fragment size that can be used for fragment shading rate functionality.</summary>
/// <returns>[x,y] integers corresponding to a fragment size.</returns>
inline Extent2D getFragmentSize() const { return static_cast<Extent2D>(fragmentSize); }
/// <summary>Get a bitmask of the possible MSAA sample counts that can be used with the associated fragment size.</summary>
/// <returns>Bitmask of sample counts.</returns>
inline SampleCountFlags getSampleCount() const { return static_cast<SampleCountFlags>(sampleCounts); }
};
namespace impl {
/// <summary>The representation of an entire actual, physical GPU device (as opposed to Device,
/// which is a local, logical part of it). A Physical device is "determined", or "found", or
/// "enumerated", (while a logical device is "created"). You can use the physical device to
/// create logical Devices, determine Extensions etc. See Vulkan spec.</summary>
class PhysicalDevice_ : public PVRVkInstanceObjectBase<VkPhysicalDevice, ObjectType::e_PHYSICAL_DEVICE>, public std::enable_shared_from_this<PhysicalDevice_>
{
private:
friend class Instance_;
/// <summary>A class which restricts the creation of a pvrvk::PhysicalDevice to children or friends of a pvrvk::impl::PhysicalDevice_.</summary>
class make_shared_enabler
{
protected:
/// <summary>Constructor for a make_shared_enabler.</summary>
make_shared_enabler() {}
friend class PhysicalDevice_;
};
/// <summary>Protected function used to create a pvrvk::PhysicalDevice. Note that this function shouldn't normally be called
/// directly and will be called by a friend of PhysicalDevice_ which will generally be a Instance.</summary>
/// <param name="instance">The instance used to retrieve the physical device.</param>
/// <param name="vkPhysicalDevice">The vulkan handle for this physical device.</param>
static PhysicalDevice constructShared(Instance& instance, const VkPhysicalDevice& vkPhysicalDevice)
{
return std::make_shared<PhysicalDevice_>(make_shared_enabler{}, instance, vkPhysicalDevice);
}
void updateDisplayPlaneProperties();
/// <summary>Retrieve and initialise the list of displays</summary>
void retrieveDisplays();
std::vector<QueueFamilyProperties> _queueFamilyPropeties;
PhysicalDeviceProperties _deviceProperties;
std::vector<Display> _displays;
std::vector<DisplayPlanePropertiesKHR> _displayPlaneProperties;
PhysicalDeviceMemoryProperties _deviceMemoryProperties;
PhysicalDeviceFeatures _deviceFeatures;
std::vector<FormatProperties> _supportedFormats;
std::vector<ExtensionProperties> _deviceExtensions;
uint32_t _graphicsQueueIndex;
uint32_t _universalQueueFamilyId;
public:
//!\cond NO_DOXYGEN
DECLARE_NO_COPY_SEMANTICS(PhysicalDevice_)
/// <summary>Constructor for a pvrvk::PhysicalDevice. This should not be called directly and instead constructShared should be called</summary>
/// <param name="instance">The Instance from which the physical device has been retrieved</param>
/// <param name="vkPhysicalDevice">The handle of the physical device retrieved from the given instance</param>
PhysicalDevice_(make_shared_enabler, Instance& instance, const VkPhysicalDevice& vkPhysicalDevice);
~PhysicalDevice_()
{
_vkHandle = VK_NULL_HANDLE;
_supportedFormats.clear();
_deviceExtensions.clear();
}
//!\endcond
/// <summary>Get device properties</summary>
/// <returns>Returns PhysicalDeviceProperties</returns>
const PhysicalDeviceProperties& getProperties() const { return _deviceProperties; }
/// <summary>Get the list of displays (const)</summary>
/// <returns>const std::vector<Display>&</returns>
const std::vector<Display>& getDisplays() const;
/// <summary>Get Display (const)</summary>
/// <param name="id">Display id</param>
/// <returns>const Display&</returns>
const Display& getDisplay(uint32_t id) const;
/// <summary>Get Display (const)</summary>
/// <param name="id">Display id</param>
/// <returns>const Display&</returns>
Display& getDisplay(uint32_t id);
/// <summary>Get the number of displays</summary>
/// <returns>Returns the number of supported displays</returns>
uint32_t getNumDisplays() const { return static_cast<uint32_t>(_displays.size()); }
/// <summary>Get supported memory properties (const)</summary>
/// <returns>PhysicalDeviceMemoryProperties</returns>
const PhysicalDeviceMemoryProperties& getMemoryProperties() const { return _deviceMemoryProperties; }
/// <summary>Determine whether the specified surface supports presentation</summary>
/// <param name="queueFamilyIndex">The queue family to check for WSI support</param>
/// <param name="surface">The surface to check for WSI support for the specified queue family index</param>
/// <returns>True if the specified queue family supports Window System Integration (WSI) with the specified surface</returns>
bool getSurfaceSupport(uint32_t queueFamilyIndex, Surface surface) const;
/// <summary>Get format properties</summary>
/// <param name="format">Format</param>
/// <returns>FormatProperties</returns>
FormatProperties getFormatProperties(pvrvk::Format format);
/// <summary>Get surface capabilities for a surface created using this physical device</summary>
/// <param name="surface">The surface to retrieve capabilities for</param>
/// <returns>SurfaceCapabilities</returns>
SurfaceCapabilitiesKHR getSurfaceCapabilities(const Surface& surface) const;
/// <summary>Get This physical device features</summary>
/// <returns>PhysicalDeviceFeatures</returns>
const PhysicalDeviceFeatures& getFeatures() const { return _deviceFeatures; }
/// <summary>Create a display mode</summary>
/// <param name="display">The display from which to create a display mode</param>
/// <param name="displayModeCreateInfo">Display Mode create info</param>
/// <returns>The created DisplayMode</returns>
DisplayMode createDisplayMode(pvrvk::Display& display, const pvrvk::DisplayModeCreateInfo& displayModeCreateInfo);
/// <summary>create gpu device.</summary>
/// <param name="deviceCreateInfo">Device create info</param>
/// <returns>Device</returns>
Device createDevice(const DeviceCreateInfo& deviceCreateInfo);
/// <summary>Get the list of queue family properties</summary>
/// <returns>A list of QueueFamilyProperties for the physical device</returns>
const std::vector<QueueFamilyProperties>& getQueueFamilyProperties() const { return _queueFamilyPropeties; }
/// <summary>Retrieves the set of supported surface presentation modes</summary>
/// <param name="surface">The surface to retrieve supported presentation modes for</param>
/// <returns>vector of pvrvk::PresentModeKHR</returns>
std::vector<PresentModeKHR> getSurfacePresentModes(const Surface& surface) const;
/// <summary>Retrieves the set of supported surface formats</summary>
/// <param name="surface">The surface to retrieve supported formats for</param>
/// <returns>vector of pvrvk::ExtensionProperties</returns>
std::vector<SurfaceFormatKHR> getSurfaceFormats(const Surface& surface) const;
/// <summary>Enumerate device extensions properties</summary>
/// <returns>vector of pvrvk::ExtensionProperties</returns>
std::vector<ExtensionProperties>& getDeviceExtensionsProperties();
/// <summary>Returns the image format properties for a given set of image creation parameters</summary>
/// <param name="format">The image format to get sparse image properties for.</param>
/// <param name="imageType">The image type to get sparse image properties for.</param>
/// <param name="tiling">The image tiling mode.</param>
/// <param name="usage">The image usage flags.</param>
/// <param name="flags">The image creation flags.</param>
/// <returns>An ImageFormatProperties structure</returns>
const ImageFormatProperties getImageFormatProperties(
pvrvk::Format format, pvrvk::ImageType imageType, pvrvk::ImageTiling tiling, pvrvk::ImageUsageFlags usage, pvrvk::ImageCreateFlags flags);
/// <summary>Returns the sparse image format properties for a given set of image creation parameters</summary>
/// <param name="format">The image format to get sparse image properties for.</param>
/// <param name="imageType">The image type to get sparse image properties for.</param>
/// <param name="sampleCount">The image sample count.</param>
/// <param name="usage">The image usage flags.</param>
/// <param name="tiling">The image tiling mode.</param>
/// <returns>A list of SparseImageFormatProperties structures</returns>
const std::vector<SparseImageFormatProperties> getSparseImageFormatProperties(
pvrvk::Format format, pvrvk::ImageType imageType, pvrvk::SampleCountFlags sampleCount, pvrvk::ImageUsageFlags usage, pvrvk::ImageTiling tiling);
/// <summary>Attempts to find the index for a suitable memory type supporting the memory type bits required from the set of memory type bits supported.</summary>
/// <param name="allowedMemoryTypeBits">The memory type bits allowed. The required memory type chosen must be one of those allowed.</param>
/// <param name="requiredMemoryProperties">The memory type property flags required.</param>
/// <param name="usedMemoryProperties">The memory type property flags found which support the memory type bits and memory property flags. Note that the use memory property
/// flags may be different to those that were provided as required although they will be a superset of those required.</param> <returns>The memory type index found supporting
/// the specified MemoryPropertyFlags.</returns>
uint32_t getMemoryTypeIndex(uint32_t allowedMemoryTypeBits, pvrvk::MemoryPropertyFlags requiredMemoryProperties, pvrvk::MemoryPropertyFlags& usedMemoryProperties) const;
/// <summary>Returns the number of supported display planes.</summary>
/// <returns>The number of supported display planes.</returns>
uint32_t getNumDisplayPlanes() { return static_cast<uint32_t>(_displayPlaneProperties.size()); }
/// <summary>Attempts to find the display plane properties for a given display.</summary>
/// <param name="displayPlaneIndex">The display plane index to get display plane properties for.</param>
/// <param name="currentStackIndex">The display to find display plane properties for.</param>
/// <returns>The DisplayPlanePropertiesKHR for the given display else VK_NULL_HANDLE if the display does not currently have an associated display plane.</returns>
Display getDisplayPlaneProperties(uint32_t displayPlaneIndex, uint32_t& currentStackIndex);
/// <summary>Attempts to find the supported displays for a given display plane.</summary>
/// <param name="planeIndex">The display plane index to check for supported displays.</param>
/// <returns>The list of supported displays for the given plane.</returns>
std::vector<Display> getDisplayPlaneSupportedDisplays(uint32_t planeIndex);
/// <summary>Attempts to find the supported displays for a given display plane.</summary>
/// <param name="mode">The display mode object to get display plane capabilities for.</param>
/// <param name="planeIndex">The display plane index to check for supported displays.</param>
/// <returns>The list of supported displays for the given plane.</returns>
DisplayPlaneCapabilitiesKHR getDisplayPlaneCapabilities(DisplayMode& mode, uint32_t planeIndex);
/// <summary>Populate an extension features class with the enabled features for this physical device.</summary>
/// <param name="extensionFeatures">A physical device extension features instance.</param>
void populateExtensionFeatures(ExtensionFeatures& extensionFeatures);
/// <summary>Populate an extension features struct with the enabled features for this physical device using vkGetPhysicalDeviceFeatures2KHR.
/// Make sure you set the sType parameter before passing the struct to this function!</summary>
/// <typeparam name="VkPhysicalDeviceExtensionFeatures">A vulkan physical device extension features structure that can be pointed to by the pNext member of
/// VkPhysicalDeviceFeatures2KHR.</typeparam>
/// <param name="featuresStruct">Physical device extension features struct to be put in the pNext chain of VkPhysicalDeviceFeatures2KHR.
/// Make sure you set the sType parameter before passing the struct to this function!</param>
template<typename VkPhysicalDeviceExtensionFeatures>
void populateExtensionFeaturesVk(VkPhysicalDeviceExtensionFeatures& featuresStruct);
/// <summary>Returns the possible fragment shading rate combinations for this physical device. Each member returned contains a possible fragment size and
/// a bitmask of the possible MSAA sample counts that can be used with that FSR fragment size.</summary>
/// <returns>Vector of available fragment shading rates.</returns>
std::vector<PhysicalDeviceFragmentShadingRate> getAvailableFragmentShadingRates();
};
} // namespace impl
} // namespace pvrvk
| 56.282946 | 175 | 0.781558 |
6899719463ecb9af977343b012e4399e6ed8dc9b | 6,150 | h | C | js/spidermonkey-ios/include/mozilla/Types.h | digitalhoax/fellz | cacf5cd57f00121bcb2a795021aed24c4164c418 | [
"Zlib",
"libtiff",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"Libpng",
"curl",
"BSD-3-Clause"
] | 2 | 2015-03-22T00:17:30.000Z | 2017-09-30T03:23:25.000Z | scripting/javascript/spidermonkey-win32/include/mozilla/Types.h | ReubenBond/cocos2d-x | e153902b2e123155c2beb098aa9fc00e659ff0d3 | [
"Zlib",
"libtiff",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"Libpng",
"curl",
"BSD-3-Clause"
] | null | null | null | scripting/javascript/spidermonkey-win32/include/mozilla/Types.h | ReubenBond/cocos2d-x | e153902b2e123155c2beb098aa9fc00e659ff0d3 | [
"Zlib",
"libtiff",
"BSD-2-Clause",
"Apache-2.0",
"MIT",
"Libpng",
"curl",
"BSD-3-Clause"
] | 1 | 2017-11-24T11:15:01.000Z | 2017-11-24T11:15:01.000Z | /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
* vim: set ts=8 sw=4 et tw=99 ft=cpp:
*
* ***** BEGIN LICENSE BLOCK *****
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
*
* The contents of this file are subject to the Mozilla Public License Version
* 1.1 (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.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
* for the specific language governing rights and limitations under the
* License.
*
* The Original Code is Mozilla Code.
*
* The Initial Developer of the Original Code is
* The Mozilla Foundation
* Portions created by the Initial Developer are Copyright (C) 2011
* the Initial Developer. All Rights Reserved.
*
* Contributor(s):
*
* Alternatively, the contents of this file may be used under the terms of
* either the GNU General Public License Version 2 or later (the "GPL"), or
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
* in which case the provisions of the GPL or the LGPL are applicable instead
* of those above. If you wish to allow use of your version of this file only
* under the terms of either the GPL or the LGPL, and not to allow others to
* use your version of this file under the terms of the MPL, indicate your
* decision by deleting the provisions above and replace them with the notice
* and other provisions required by the GPL or the LGPL. If you do not delete
* the provisions above, a recipient may use your version of this file under
* the terms of any one of the MPL, the GPL or the LGPL.
*
* ***** END LICENSE BLOCK ***** */
/* mfbt foundational types and macros. */
#ifndef mozilla_Types_h_
#define mozilla_Types_h_
/*
* This header must be valid C and C++, includable by code embedding either
* SpiderMonkey or Gecko.
*/
/*
* Expose all the integer types defined in C99's <stdint.h> (and the integer
* limit and constant macros, if compiling C code or if compiling C++ code and
* the right __STDC_*_MACRO has been defined for each). These are all usable
* throughout mfbt code, and throughout Mozilla code more generally.
*/
#include "mozilla/StandardInteger.h"
/* Also expose size_t. */
#include <stddef.h>
/* Implement compiler and linker macros needed for APIs. */
/*
* MOZ_EXPORT_API is used to declare and define a method which is externally
* visible to users of the current library. It encapsulates various decorations
* needed to properly export the method's symbol. MOZ_EXPORT_DATA serves the
* same purpose for data.
*
* api.h:
* extern MOZ_EXPORT_API(int) MeaningOfLife(void);
* extern MOZ_EXPORT_DATA(int) LuggageCombination;
*
* api.c:
* MOZ_EXPORT_API(int) MeaningOfLife(void) { return 42; }
* MOZ_EXPORT_DATA(int) LuggageCombination = 12345;
*
* If you are merely sharing a method across files, just use plain |extern|.
* These macros are designed for use by library interfaces -- not for normal
* methods or data used cross-file.
*/
#if defined(WIN32) || defined(XP_OS2)
# define MOZ_EXPORT_API(type) __declspec(dllexport) type
# define MOZ_EXPORT_DATA(type) __declspec(dllexport) type
#else /* Unix */
# ifdef HAVE_VISIBILITY_ATTRIBUTE
# define MOZ_EXTERNAL_VIS __attribute__((visibility("default")))
# elif defined(__SUNPRO_C) || defined(__SUNPRO_CC)
# define MOZ_EXTERNAL_VIS __global
# else
# define MOZ_EXTERNAL_VIS
# endif
# define MOZ_EXPORT_API(type) MOZ_EXTERNAL_VIS type
# define MOZ_EXPORT_DATA(type) MOZ_EXTERNAL_VIS type
#endif
/*
* Whereas implementers use MOZ_EXPORT_API and MOZ_EXPORT_DATA to declare and
* define library symbols, users use MOZ_IMPORT_API and MOZ_IMPORT_DATA to
* access them. Most often the implementer of the library will expose an API
* macro which expands to either the export or import version of the macro,
* depending upon the compilation mode.
*/
#ifdef _WIN32
# if defined(__MWERKS__)
# define MOZ_IMPORT_API(x) x
# else
# define MOZ_IMPORT_API(x) __declspec(dllimport) x
# endif
#elif defined(XP_OS2)
# define MOZ_IMPORT_API(x) __declspec(dllimport) x
#else
# define MOZ_IMPORT_API(x) MOZ_EXPORT_API(x)
#endif
#if defined(_WIN32) && !defined(__MWERKS__)
# define MOZ_IMPORT_DATA(x) __declspec(dllimport) x
#elif defined(XP_OS2)
# define MOZ_IMPORT_DATA(x) __declspec(dllimport) x
#else
# define MOZ_IMPORT_DATA(x) MOZ_EXPORT_DATA(x)
#endif
/*
* Consistent with the above comment, the MFBT_API and MFBT_DATA macros expose
* export mfbt declarations when building mfbt, and they expose import mfbt
* declarations when using mfbt.
*/
#if defined(IMPL_MFBT)
# define MFBT_API(type) MOZ_EXPORT_API(type)
# define MFBT_DATA(type) MOZ_EXPORT_DATA(type)
#else
/*
* When mozglue is linked in the program, we need the MFBT API symbols
* to be weak.
*/
# if defined(MOZ_GLUE_IN_PROGRAM)
# define MFBT_API(type) __attribute__((weak)) MOZ_IMPORT_API(type)
# define MFBT_DATA(type) __attribute__((weak)) MOZ_IMPORT_DATA(type)
# else
# define MFBT_API(type) MOZ_IMPORT_API(type)
# define MFBT_DATA(type) MOZ_IMPORT_DATA(type)
# endif
#endif
/*
* C symbols in C++ code must be declared immediately within |extern "C"|
* blocks. However, in C code, they need not be declared specially. This
* difference is abstracted behind the MOZ_BEGIN_EXTERN_C and MOZ_END_EXTERN_C
* macros, so that the user need not know whether he is being used in C or C++
* code.
*
* MOZ_BEGIN_EXTERN_C
*
* extern MOZ_EXPORT_API(int) MostRandomNumber(void);
* ...other declarations...
*
* MOZ_END_EXTERN_C
*
* This said, it is preferable to just use |extern "C"| in C++ header files for
* its greater clarity.
*/
#ifdef __cplusplus
# define MOZ_BEGIN_EXTERN_C extern "C" {
# define MOZ_END_EXTERN_C }
#else
# define MOZ_BEGIN_EXTERN_C
# define MOZ_END_EXTERN_C
#endif
#endif /* mozilla_Types_h_ */
| 35.964912 | 80 | 0.723252 |
d5badb5307a8b1d4a5b4066536bf24c27b9a4095 | 7,404 | h | C | lpcxpresso/freertos_holter/example/src/FatFs/SD_AJS.h | matiasld/holter-monitor | a06ba9798c6778769b02e15f9a88b9395fe36606 | [
"Apache-2.0"
] | 1 | 2019-09-15T21:14:55.000Z | 2019-09-15T21:14:55.000Z | lpcxpresso/freertos_holter/example/src/FatFs/SD_AJS.h | matiasld/holter-monitor | a06ba9798c6778769b02e15f9a88b9395fe36606 | [
"Apache-2.0"
] | null | null | null | lpcxpresso/freertos_holter/example/src/FatFs/SD_AJS.h | matiasld/holter-monitor | a06ba9798c6778769b02e15f9a88b9395fe36606 | [
"Apache-2.0"
] | null | null | null | /*
* SD_AJS.h
*
* Created on: 12 de jun. de 2016
* Author: Augusto
* @note: Header con las funciones y definiciones para manejar una tarjeta SD/MMC.
* Estas funciones estan pensadas como maquina de estado y deberan ser llamadas hasta que retornen
* el valor que indique que las mismas han terminado, el llamado erroneo de las funciones puede
* resultar en un malfuncionamiento del programa o la SD.
*/
#ifndef SD_AJS_H_
#define SD_AJS_H_
#include "chip.h"
#include "SSP.h"
/* Comandos para la SD */
#define GO_IDLE_STATE 0
#define SEND_OP_COND 1
#define SWITCH_FUNC 6
#define SEND_IF_COND 8
#define SEND_CSD 9
#define SEND_CID 10
#define STOP_TRANSMISSION 12
#define SEND_STATUS 13
#define SET_BLOCKLEN 16
#define READ_SINGLE_BLOCK 17
#define READ_MULTIPLE_BLOCK 18
#define WRITE_SINGLE_BLOCK 24
#define WRITE_MULTIPLE_BLOCK 25
#define APP_CMD 55
#define READ_OCR 58
#define CRC_ON_OFF 59
/* Application specific commands supported by SD.
All these commands shall be preceded with APP_CMD (CMD55). */
#define SD_STATUS 13
#define SD_SEND_OP_COND 41
/* R1 response bit flag definition */
#define R1_NO_ERROR 0x00
#define R1_IN_IDLE_STATE 0x01
#define R1_ERASE_RESET 0x02
#define R1_ILLEGAL_CMD 0x04
#define R1_COM_CRC_ERROR 0x08
#define R1_ERASE_SEQ_ERROR 0x10
#define R1_ADDRESS_ERROR 0x20
#define R1_PARA_ERROR 0x40
#define R1_MASK 0x7F
/*
* Defines para la maquina de estados de SendSDCMD
*/
typedef enum STATE_MACHINE_SENDSD {
SD_SEND_CMD_SENDING_CMD = 0,
SD_SEND_CMD_SENDING_ARG,
SD_SEND_CMD_SENDING_BUF,
SD_SEND_CMD_SENDING_CRC,
SD_SEND_CMD_RECVING_ANS_R1,
SD_SEND_CMD_RECVING_ANS_ARG,
SD_SEND_CMD_ENDING
} SD_CMD_MACHINE_T;
#define SD_CMD_SENT 1
#define SD_CMD_SENDING 0
/*
* Defines para la maquina de estados de SendSDCMD
*/
typedef enum STATE_MACHINE_SDINIT {
SD_INIT_SET_DELAY = 0,
SD_INIT_WAIT_DELAY,
SD_INIT_DUMMY_CLOCKS,
SD_INIT_CLEAN_RX_FIFO_1,
SD_INIT_SENDING_CMD0,
SD_INIT_RCVING_ANS_CMD0,
SD_INIT_SENDING_CMD8,
SD_INIT_RCVING_ANS_CMD8,
SD_INIT_SENDING_ACMD41_4,
SD_INIT_SENDING_ACMD41_0,
SD_INIT_SENDING_CMD1,
SD_INIT_SENDING_CMD58,
SD_INIT_CHECKING_CCS,
SD_INIT_SENDING_CMD16,
SD_INIT_RCVING_ANS_CMD16,
SD_INIT_FINISH,
SD_INIT_ERROR
} SD_INIT_MACHINE_T;
#define SD_INIT_SUCCESS 1
#define SD_INIT_FAILURE 2
#define SD_INIT_IN_PROGRESS 0
/*
* Maquina de estados SD_ReadConfiguration
*/
typedef enum STATE_MACHINE_SDCONFIG {
SD_CONFIG_INITIAL = 0,
SD_CONFIG_SENDING_CMD58,
SD_CONFIG_SENDING_CMD10,
SD_CONFIG_RCVING_CMD10,
SD_CONFIG_SENDING_CMD9,
SD_CONFIG_RCVING_CMD9,
SD_CONFIG_ERASE_BLOCK_SIZE,
SD_CONFIG_FINISH,
SD_CONFIG_ERROR
} SD_CONFIG_MACHINE_T;
#define SD_CONFIG_SUCCESS 1
#define SD_CONFIG_FAILURE 2
#define SD_CONFIG_IN_PROGRESS 0
/*
* Maquina de estados SD_ReadSector
*/
typedef enum STATE_MACHINE_SDRS {
SD_RS_INIT = 0,
SD_RS_READING_SINGLE,
SD_RS_READING_MULTIPLE,
SD_RS_STOP_CMD,
SD_RS_FINISH,
SD_RS_ERROR
} SD_RS_MACHINE_T;
#define SD_RS_SUCCESS 1
#define SD_RS_FAILURE 2
#define SD_RS_IN_PROGRESS 0
/*
* Maquina de estados SD_WriteSector
*/
typedef enum STATE_MACHINE_SDWS {
SD_WS_INIT = 0,
SD_WS_WRITING_SINGLE,
SD_WS_WRITING_MULTIPLE,
SD_WS_STOP_CMD,
SD_WS_FINISH,
SD_WS_ERROR
} SD_WS_MACHINE_T;
#define SD_WS_SUCCESS 1
#define SD_WS_FAILURE 2
#define SD_WS_IN_PROGRESS 0
/*
* Maquina de estados SD_RecvDataBlock
*/
typedef enum STATE_MACHINE_RCVB {
SD_RCV_B_RCVING_TOKEN = 0,
SD_RCV_B_RCVING_DATA,
SD_RCV_B_CRC,
SD_RCV_B_FINISH
} SD_RCV_BLOCK_MACHINE_T;
#define SD_RCV_B_SUCCESS 1
#define SD_RCV_B_FAILURE 2
#define SD_RCV_B_IN_PROGRESS 0
/*
* Maquina de estados SD_SendDataBlock
*/
typedef enum STATE_MACHINE_SENDB {
SD_SEND_B_SENDING_TOKEN = 0,
SD_SEND_B_SENDING_DATA,
SD_SEND_B_CRC,
SD_SEND_B_RCVING_ANS,
SD_SEND_B_WAITING,
SD_SEND_B_FINISH
} SD_SEND_BLOCK_MACHINE_T;
#define SD_SEND_B_SUCCESS 1
#define SD_SEND_B_FAILURE 2
#define SD_SEND_B_IN_PROGRESS 0
/** Select the card */
#define SD_Select() Chip_GPIO_SetPinOutLow(LPC_GPIO, SD_SEL_PINPORT)
/** DeSelect the card */
#define SD_DeSelect() Chip_GPIO_SetPinOutHigh(LPC_GPIO, SD_SEL_PINPORT)
/* Memory card type definitions */
#define CARDTYPE_UNKNOWN 0
#define CARDTYPE_MMC 1 /* MMC */
#define CARDTYPE_SDV1 2 /* V1.x Standard Capacity SD card */
#define CARDTYPE_SDV2_SC 3 /* V2.0 or later Standard Capacity SD card */
#define CARDTYPE_SDV2_HC 4 /* V2.0 or later High/eXtended Capacity SD card */
/* SD/MMC card configuration */
typedef struct tagCARDCONFIG
{
uint32_t sectorsize; /* size (in byte) of each sector, fixed to 512bytes */
uint32_t sectorcnt; /* total sector number */
uint32_t blocksize; /* erase block size in unit of sector */
uint8_t ocr[4]; /* OCR */
uint8_t cid[16]; /* CID */
uint8_t csd[16]; /* CSD */
uint8_t status[64]; /* Status */
} CARDCONFIG;
/* Public functions */
/**
* @brief Pone un dato en la Tx FIFO cuando puede, manejado por semaforos
* @param data : Dato a poner en la Tx FIFO
*/
void putDataSSP(uint8_t data);
/**
* @brief Inicializa una SD/MMC
* @return 1 si termino sin errores, 0 si no termino, o el error correspondiente
*/
uint8_t SD_Init (void);
/**
* @brief Lee un sector de la SD
* @param sect : Sector de la SD a leer
* @param buf : Puntero a donde se van a guardar los datos leidos
* @param cnt : Cantidad de sectores a leer
* @return 1 si leyo bien, 0 si no termino de leer, otros para error
*/
uint8_t SD_ReadSector (uint32_t sect, uint8_t *buf, uint32_t cnt);
/**
* @brief Escribe un sector de la SD
* @param sect : Sector de la SD a escribir
* @param buf : Puntero a donde estan los datos a escribir
* @param cnt : Cantidad de sectores a escribir
* @return 1 si escribio todo bien, 0 si no termino de escribir, otros para error
*/
uint8_t SD_WriteSector (uint32_t sect, const uint8_t *buf, uint32_t cnt);
/**
* @brief Lee la configuracion de la SD
* @return 1 si leyo bien, 0 si no termino de leer
* @note Guarda la info en la variable global CardConfig
*/
uint8_t SD_ReadConfiguration (void);
/**
* @brief Envia un comando hacia la SD por SPI (SSP1)
* @param cmd : Comando a enviar
* @param arg : Argumento del comando
* @param buf : Puntero al buffer donde se va a guardar la respuesta
* @param len : Cantidad de datos a recibir de la respuesta
*/
void SendSDCMD (uint8_t cmd, uint32_t arg, uint8_t *buf, uint32_t len, uint8_t *R1);
/**
* @brief Recibe un bloque de datos (sin tomar en cuenta el TOKENDATA ni el CRC)
* @param buf : Puntero al buffer donde se va a guardar el bloque
* @param len : Cantidad de datos a recibir del bloque
*/
void SD_RecvDataBlock (uint8_t *buf, uint32_t len);
/**
* @brief Envia un bloque de datos
* @param buf : Puntero al buffer donde estan los datos a enviar
* @param len : Cantidad de datos a enviar
* @return SD_DATABLOCK_SENT si lo termino de recibir, SD_DATABLOCK_SENDING si esta en proceso
*/
uint8_t SD_SendDataBlock (const uint8_t *buf, uint8_t tkn, uint32_t len) ;
uint8_t SD_WaitForReady (void);
uint8_t SD_IsInitialized(void);
#endif /* SD_AJS_H_ */
| 27.626866 | 99 | 0.72866 |
510d02f6de6c8d7b330638dddabf82970fbb8ead | 2,249 | h | C | paho_mqtt-sn_embedded_c/MQTTSNGateway/src/MQTTSNGWAdapterManager.h | unn4m3d/mbed-mqtt | c0cc24610a38b45608a54096d3ec08d24f2fdc46 | [
"Apache-2.0"
] | 30 | 2019-10-06T13:25:08.000Z | 2022-02-25T04:55:09.000Z | paho_mqtt-sn_embedded_c/MQTTSNGateway/src/MQTTSNGWAdapterManager.h | unn4m3d/mbed-mqtt | c0cc24610a38b45608a54096d3ec08d24f2fdc46 | [
"Apache-2.0"
] | 28 | 2019-09-30T13:47:47.000Z | 2022-01-24T19:56:21.000Z | paho_mqtt-sn_embedded_c/MQTTSNGateway/src/MQTTSNGWAdapterManager.h | unn4m3d/mbed-mqtt | c0cc24610a38b45608a54096d3ec08d24f2fdc46 | [
"Apache-2.0"
] | 24 | 2019-10-28T12:54:18.000Z | 2022-01-15T12:21:19.000Z | /**************************************************************************************
* Copyright (c) 2018, Tomoaki Yamaguchi
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* and Eclipse Distribution License v1.0 which accompany this distribution.
*
* The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Tomoaki Yamaguchi - initial API and implementation and/or initial documentation
**************************************************************************************/
#ifndef MQTTSNGATEWAY_SRC_MQTTSNGWADAPTERMANAGER_H_
#define MQTTSNGATEWAY_SRC_MQTTSNGWADAPTERMANAGER_H_
#include "MQTTSNGWAggregater.h"
#include "MQTTSNGWQoSm1Proxy.h"
namespace MQTTSNGW
{
class Gateway;
class Client;
class QoSm1Proxy;
class Aggregater;
class ForwarderList;
class Forwarder;
class MQTTSNPacket;
class MQTTSNGWPacket;
class ClientRecvTask;
class ClientSendTask;
/*=====================================
Class AdapterManager
=====================================*/
class AdapterManager
{
public:
AdapterManager(Gateway* gw);
~AdapterManager(void);
void initialize(void);
ForwarderList* getForwarderList(void);
QoSm1Proxy* getQoSm1Proxy(void);
Aggregater* getAggregater(void);
void checkConnection(void);
bool isAggregatedClient(Client* client);
Client* getClient(Client& client);
Client* convertClient(uint16_t msgId, uint16_t* clientMsgId);
int unicastToClient(Client* client, MQTTSNPacket* packet, ClientSendTask* task);
bool isAggregaterActive(void);
AggregateTopicElement* createClientList(Topic* topic);
int addAggregateTopic(Topic* topic, Client* client);
void removeAggregateTopic(Topic* topic, Client* client);
void removeAggregateTopicList(Topics* topics, Client* client);
private:
Gateway* _gateway {nullptr};
ForwarderList* _forwarders {nullptr};
QoSm1Proxy* _qosm1Proxy {nullptr};
Aggregater* _aggregater {nullptr};
};
}
#endif /* MQTTSNGATEWAY_SRC_MQTTSNGWADAPTERMANAGER_H_ */
| 31.676056 | 88 | 0.679858 |
7d0f1b02c6809e23e31c60ea73a1090e30b12cf8 | 1,664 | h | C | sxaccelerate/src/graph/SxGProps.h | ashtonmv/sphinx_vdw | 5896fee0d92c06e883b72725cb859d732b8b801f | [
"Apache-2.0"
] | 1 | 2020-02-29T03:26:32.000Z | 2020-02-29T03:26:32.000Z | sxaccelerate/src/graph/SxGProps.h | ashtonmv/sphinx_vdw | 5896fee0d92c06e883b72725cb859d732b8b801f | [
"Apache-2.0"
] | null | null | null | sxaccelerate/src/graph/SxGProps.h | ashtonmv/sphinx_vdw | 5896fee0d92c06e883b72725cb859d732b8b801f | [
"Apache-2.0"
] | null | null | null | // ---------------------------------------------------------------------------
//
// The general purpose cross platform C/C++ framework
//
// S x A c c e l e r a t e
//
// Home: https://www.sxlib.de
// License: Apache 2
// Authors: see src/AUTHORS
//
// ---------------------------------------------------------------------------
#ifndef _SX_G_PROPS_H_
#define _SX_G_PROPS_H_
#include <SxVariant.h>
#include <SxString.h>
#include <SxMap.h>
#include <SxHashFunction.h>
#include <SxPair.h>
/** \brief Graph Node for property graphs
\b SxGProps = SPHInX Properties storage Class
SxGProps class represents a graph
node for a property graph. A node
in a property graph can store multiple
key-value pairs called properties.
*/
class SxGProps
{
public:
SxGProps ();
SxGProps (ssize_t id_);
ssize_t getId () const;
SxVariant &getProperty (const SxString &key);
const SxVariant &getProperty (const SxString &key) const;
const SxMap<SxString,SxVariant> &getProperties () const;
bool operator== (const SxGProps &n1) const;
template<class T>
void setProperty (const SxString &key, const T &v)
{
props(key) = SxVariant(v);
}
bool hasProperty (const SxString &key) const;
operator ssize_t() const;
friend std::ostream &operator<< (std::ostream &os, const SxGProps &in)
{
os << in.getId ();
return os;
}
protected:
ssize_t id;
SxMap<SxString,SxVariant> props;
};
size_t sxHash (const SxGProps &in);
#endif /*_SX_G_PROPS_H_*/
| 24.470588 | 78 | 0.551683 |
e0cf273e977388787aecbc39f487fb5204a9d132 | 7,155 | h | C | software/baremetal/baremetal-libs/src/libmp/include/optimsoc-mp.h | QueenField/MPSoC-WB-OR1K | bf434f4d8184c5d214a95568d4cca9d83739902e | [
"MIT"
] | 48 | 2017-06-30T15:28:08.000Z | 2022-03-07T06:47:31.000Z | software/baremetal/baremetal-libs/src/libmp/include/optimsoc-mp.h | QueenField/MPSoC-WB-OR1K | bf434f4d8184c5d214a95568d4cca9d83739902e | [
"MIT"
] | 96 | 2017-06-20T19:51:03.000Z | 2022-03-16T20:22:36.000Z | software/baremetal/baremetal-libs/src/libmp/include/optimsoc-mp.h | QueenField/MPSoC-WB-OR1K | bf434f4d8184c5d214a95568d4cca9d83739902e | [
"MIT"
] | 20 | 2017-08-17T18:34:51.000Z | 2021-09-05T08:36:25.000Z | /* Copyright (c) 2014-2017 by the author(s)
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* Author(s):
* Stefan Wallentowitz <stefan.wallentowitz@tum.de>
*/
#ifndef __OPTIMSOC_MP_H__
#define __OPTIMSOC_MP_H__
#include <stdint.h>
/**
* \defgroup libmp Message passing library
*
* This is the message passing library for inter-tile communication in
* OpTiMSoC. It abstracts from the hardware and serves as a generic
* API. The implementation choses the best available hardware.
*
* Each communication is between two endpoints, which are a tuple:
* (tile, node, port). The application has to manage nodes and port by
* itself and tiles are denoted by rank of the compute tile.
*
* There are two types of communication: Connection-less communication
* with messages is best suited for adhoc communication between
* multiple communication partners. The protocol for
* connection-oriented channel is more efficient if the communication
* relations are fixed, such as in streaming applications. Here
* channels establish a fixed communication relation and flow control
* can be implemented more efficient.
*
* \{
*/
#ifndef __OPTIMSOC_INTERNAL__
/**
* This is the handle for an endpoint
*
* The endpoint is an opaque type to hide the implementaiton details.
*/
typedef uint32_t optimsoc_mp_endpoint_handle;
#endif
/**
* The endpoint types
*
* Each endpoint is of a certain type and can only be used in a subset
* of functions.
*/
typedef enum {
OPTIMSOC_MP_EP_CONNECTIONLESS = 0, /*!< Connection-less communication */
OPTIMSOC_MP_EP_CHANNEL = 1 /*!< Connection-oriented communication */
} optimsoc_endpoint_type;
#define OPTIMSOC_MP_CONF_DOMAINS 1
/**
* Configuration attributes
*
* Currently not used.
*/
struct optimsoc_mp_attributes {
uint32_t flags;
};
/**
* Initialize the message passing subsystem
*
* \param attr Configuration attributes (currently ignored)
* \return 0 on success, an error code otherwise
*/
int optimsoc_mp_initialize(struct optimsoc_mp_attributes* attr);
/**
* Create an endpoint
*
* Creates a message passing endpoint in this tile for a specific node on a
* port. Other endpoints can send messages or connect to the endpoint via the
* <tile, node, port> tuple.
*
* The buffer can either be connection-less or
* connection-oriented. When connection-oriented you need to connect
* two endpoints to a channel first using
* optimsoc_mp_channel_connect().
*
* The buffer_size is the number of messages or packets that can be used. If
* messages or packets are larger than the default size, the maximum element
* size can be overwritten for this endpoint.
*
* \param endpoint Pointer to the handle to initialize
* \param node Local node number
* \param port Local port number
* \param type Type of the endpoint
* \param buffer_size Number of messages the endpoint accepts
* \param overwrite_max_size Set the maximum message size or 0 for the default
* \return 0 if success, error code otherwise
*/
int optimsoc_mp_endpoint_create(optimsoc_mp_endpoint_handle *endpoint,
uint32_t node, uint32_t port,
optimsoc_endpoint_type type,
uint32_t buffer_size, int overwrite_max_size);
/**
* Retrieve a remote endpoint
*
* Before communicating with a remote endpoint, an endpoint handle
* must be configured. This function initializes the endpoint for the
* remote endpoint.
*
* The remote tile is the compute tile rank.
*
* This function blocks until the remote endpoint is available.
*
* \param endpoint Handle to initialize
* \param tile Remote compute tile rank
* \param node Node of the remote endpoint
* \param port Port of the remote endpoint
* \return Return 0 on success, an error code otherwise
*/
int optimsoc_mp_endpoint_get(optimsoc_mp_endpoint_handle *endpoint,
uint32_t tile, uint32_t node, uint32_t port);
/**
* Send a message to a remote endpoint
*
* A local endpoint is used to store the data locally for an
* asynchronous transfer if supported. The local endpoint must be
* created by optimsoc_mp_endpoint_create() with type
* OPTIMSOC_MP_EP_CONNECTIONLESS. The remote endpoint must be
* retrieved with optimsoc_mp_endpoint_get().
*
* The function blocks until the data is stored in another data
* structure or successfully transfer, i.e., the input buffer can be
* safely reused.
*
* \param from Local endpoint
* \param to Remote endpoint
* \param data Data to transfer
* \param size Size of the data to transfer
* \return 0 on success, an error code otherwise
*/
int optimsoc_mp_msg_send(optimsoc_mp_endpoint_handle from,
optimsoc_mp_endpoint_handle to, uint8_t *data,
uint32_t size);
/**
* Receive a message from a local endpoint
*
* Receive a message from the local endpoint. The endpoint must be
* configured by optimsoc_mp_endpoint_create() with type
* OPTIMSOC_MP_EP_CONNECTIONLESS.
*
* The function blocks until a message was received.
*
* \param ep Local endpoint to receive from
* \param buffer Output data buffer
* \param buffer_size Size of the buffer
* \param received_size The actual written data size
* \return 0 on success, an error code otherwise
*/
int optimsoc_mp_msg_recv(optimsoc_mp_endpoint_handle ep, uint8_t *buffer,
uint32_t buffer_size, uint32_t *received_size);
int optimsoc_mp_channel_connect(optimsoc_mp_endpoint_handle from,
optimsoc_mp_endpoint_handle to);
int optimsoc_mp_channel_send(optimsoc_mp_endpoint_handle from,
optimsoc_mp_endpoint_handle to,
uint8_t* buffer, uint32_t size);
int optimsoc_mp_channel_recv(optimsoc_mp_endpoint_handle ep,
uint8_t* buffer, uint32_t buffer_size,
uint32_t *received_size);
// Channel migration
int optimsoc_mp_channel_pause(optimsoc_mp_endpoint_handle ep);
int optimsoc_mp_channel_continue(optimsoc_mp_endpoint_handle ep);
#define OPTIMSOC_MP_ERROR_NOT_INITIALIZED -1
#define OPTIMSOC_MP_ERROR_DOMAINS_NOT_SUPPORTED -2
#define OPTIMSOC_MP_ERROR_BUFFEROVERFLOW -3
char* optimsoc_mp_error_string(int errno);
/**
* \}
*/
#endif
| 34.071429 | 80 | 0.754577 |
f1730b110bffb8acd261dc309380257a1e92e1f9 | 606 | h | C | System/Library/TextInput/libTextInputCore.dylib/TIKeyboardQuickTypeSpecialization.h | lechium/tvOS10Headers | f0c99993da6cc502d36fdc5cb4ff90d94b12bf67 | [
"MIT"
] | 4 | 2017-03-23T00:01:54.000Z | 2018-08-04T20:16:32.000Z | System/Library/TextInput/libTextInputCore.dylib/TIKeyboardQuickTypeSpecialization.h | lechium/tvOS10Headers | f0c99993da6cc502d36fdc5cb4ff90d94b12bf67 | [
"MIT"
] | null | null | null | System/Library/TextInput/libTextInputCore.dylib/TIKeyboardQuickTypeSpecialization.h | lechium/tvOS10Headers | f0c99993da6cc502d36fdc5cb4ff90d94b12bf67 | [
"MIT"
] | 4 | 2017-05-14T16:23:26.000Z | 2019-12-21T15:07:59.000Z | /*
* This header is generated by classdump-dyld 1.0
* on Wednesday, March 22, 2017 at 9:05:04 AM Mountain Standard Time
* Operating System: Version 10.1 (Build 14U593)
* Image Source: /System/Library/TextInput/libTextInputCore.dylib
* classdump-dyld is licensed under GPLv3, Copyright © 2013-2016 by Elias Limneos.
*/
#import <libTextInputCore.dylib/libTextInputCore.dylib-Structs.h>
#import <libTextInputCore.dylib/TIKeyboardFeatureSpecialization.h>
@interface TIKeyboardQuickTypeSpecialization : TIKeyboardFeatureSpecialization
-(TIInputManagerZephyr*)createInputManager;
-(BOOL)doesComposeText;
@end
| 35.647059 | 81 | 0.810231 |
2f66476895883fe8c4599903a504ef78876d4ce2 | 1,286 | h | C | cpp/Platform.Memory/FileArrayMemory.h | linksplatform/Memory | f761ebcccde9e7c5654a602cbc09967227556441 | [
"MIT"
] | 2 | 2021-05-13T12:23:34.000Z | 2022-03-18T08:21:56.000Z | cpp/Platform.Memory/FileArrayMemory.h | linksplatform/Memory | f761ebcccde9e7c5654a602cbc09967227556441 | [
"MIT"
] | 29 | 2019-07-20T18:29:44.000Z | 2022-03-01T10:12:40.000Z | cpp/Platform.Memory/FileArrayMemory.h | linksplatform/Memory | f761ebcccde9e7c5654a602cbc09967227556441 | [
"MIT"
] | 3 | 2019-07-27T16:13:12.000Z | 2021-08-03T17:24:59.000Z | namespace Platform::Memory
{
template <typename ...> class FileArrayMemory;
template <typename TElement> class FileArrayMemory<TElement> : public DisposableBase, IArrayMemory<TElement>
where TElement : struct
{
private: FileStream _file = 0;
public: std::int64_t Size()
{
return _file.Length;
}
public: TElement this[std::int64_t index]
{
get
{
_file.Seek(Structure<TElement>.Size * index, SeekOrigin.Begin);
return _file.ReadOrDefault<TElement>();
}
set
{
_file.Seek(Structure<TElement>.Size * index, SeekOrigin.Begin);
_file.Write(value);
}
}
protected: override std::string ObjectName
{
get => "File stored memory block at '{_file.Name}' path.";
}
public: FileArrayMemory(FileStream file) { _file = file; }
public: FileArrayMemory(std::string path) : this(File.Open(path, FileMode.OpenOrCreate)) { }
protected: void Dispose(bool manual, bool wasDisposed) override
{
if (!wasDisposed)
{
_file.DisposeIfPossible();
}
}
}
} | 28.577778 | 112 | 0.53888 |
00e70e32af877d66f889de538731bb2296492bdf | 216 | h | C | KS3YunSDK/KS3YunSDK/KSYS3/KSYModel/Service/KS3ListBucketsRequest.h | ks3sdk/-new_Ks3Sdk_ios | 6f2d59979d4cfee1997544a3a1f64f30c4c8fdcb | [
"Apache-2.0"
] | null | null | null | KS3YunSDK/KS3YunSDK/KSYS3/KSYModel/Service/KS3ListBucketsRequest.h | ks3sdk/-new_Ks3Sdk_ios | 6f2d59979d4cfee1997544a3a1f64f30c4c8fdcb | [
"Apache-2.0"
] | null | null | null | KS3YunSDK/KS3YunSDK/KSYS3/KSYModel/Service/KS3ListBucketsRequest.h | ks3sdk/-new_Ks3Sdk_ios | 6f2d59979d4cfee1997544a3a1f64f30c4c8fdcb | [
"Apache-2.0"
] | null | null | null | //
// S3ListBucketsRequest.h
// NEW_KSCSDK
//
// Created by ks3 on 2020/08/06.
// Copyright (c) 2020 kingsoft. All rights reserved.
//
#import "KS3Request.h"
@interface KS3ListBucketsRequest : KS3Request
@end
| 15.428571 | 53 | 0.703704 |
d8c1b0e397d52a812abd48f403f726d5b8ab95a8 | 2,274 | h | C | components/av/include/avcodec/ad.h | 1847123212/YoC-open | f4e20c67256472d863ea6d118e3ecbaa1e879d4a | [
"Apache-2.0"
] | 9 | 2020-05-12T03:01:55.000Z | 2021-08-12T10:22:31.000Z | components/av/include/avcodec/ad.h | 1847123212/YoC-open | f4e20c67256472d863ea6d118e3ecbaa1e879d4a | [
"Apache-2.0"
] | null | null | null | components/av/include/avcodec/ad.h | 1847123212/YoC-open | f4e20c67256472d863ea6d118e3ecbaa1e879d4a | [
"Apache-2.0"
] | 12 | 2020-04-15T11:37:33.000Z | 2021-09-13T13:19:04.000Z | /*
* Copyright (C) 2018-2020 Alibaba Group Holding Limited
*/
#ifndef __AD_H__
#define __AD_H__
#include "avutil/common.h"
#include "avutil/av_typedef.h"
#include "avcodec/ad_cls.h"
__BEGIN_DECLS__
#define REGISTER_DECODE(X, x) \
{ \
extern struct ad_ops ad_ops_##x; \
if (CONFIG_DECODE_##X) \
ad_ops_register(&ad_ops_##x); \
}
#define AD_OPS_MAX (16)
typedef struct ad_conf {
sf_t sf; ///< if needed
uint8_t *extradata; ///< extradata or frame header, if needed
int32_t extradata_size;
uint32_t block_align; ///< size of one frame, if needed
uint32_t bps; ///< bps, if needed
} ad_conf_t;
/**
* @brief regist ad ops
* @param [in] ops
* @return 0/-1
*/
int ad_ops_register(const struct ad_ops *ops);
/**
* @brief init the ad config param
* @param [in] ad_cnf
* @return 0/-1
*/
int ad_conf_init(ad_conf_t *ad_cnf);
/**
* @brief open/create one audio decoder
* @param [in] id
* @param [in] ad_cnf
* @return NULL on err
*/
ad_cls_t* ad_open(avcodec_id_t id, const ad_conf_t *ad_cnf);
/**
* @brief decode one audio frame
* @param [in] o
* @param [out] frame : frame of pcm
* @param [out] got_frame : whether decode one frame
* @param [in] pkt : data of encoded audio
* @return -1 when err happens, otherwise the number of bytes consumed from the
* input avpacket is returned
*/
int ad_decode(ad_cls_t *o, avframe_t *frame, int *got_frame, const avpacket_t *pkt);
/**
* @brief control a audio decoder
* @param [in] o
* @param [in] cmd : command
* @param [in] arg
* @param [in/out] arg_size
* @return 0/-1
*/
int ad_control(ad_cls_t *o, int cmd, void *arg, size_t *arg_size);
/**
* @brief reset the audio decoder
* @param [in] o
* @return 0/-1
*/
int ad_reset(ad_cls_t *o);
/**
* @brief close/destroy audio decoder
* @param [in] o
* @return 0/-1
*/
int ad_close(ad_cls_t *o);
__END_DECLS__
#endif /* __AD_H__ */
| 24.717391 | 87 | 0.551011 |
15163e44bdd30d7e20bf7d676ad958cebab7f77e | 9,451 | h | C | mechanism/Container/PreallocatedVector.h | katono/cppelib | bb2be96eaea2d0d742f65deafbe8cd33363f3003 | [
"MIT"
] | 8 | 2018-07-27T20:43:08.000Z | 2021-08-14T05:10:41.000Z | mechanism/Container/PreallocatedVector.h | katono/cppelib | bb2be96eaea2d0d742f65deafbe8cd33363f3003 | [
"MIT"
] | null | null | null | mechanism/Container/PreallocatedVector.h | katono/cppelib | bb2be96eaea2d0d742f65deafbe8cd33363f3003 | [
"MIT"
] | null | null | null | #ifndef CONTAINER_PREALLOCATED_VECTOR_H_INCLUDED
#define CONTAINER_PREALLOCATED_VECTOR_H_INCLUDED
#include <cstddef>
#ifndef NO_STD_ITERATOR
#include <iterator>
#endif
#include "ContainerException.h"
#include "private/TypeTraits.h"
#include "private/Construct.h"
#include "Assertion/Assertion.h"
namespace Container {
/*!
* @brief STL-like vector container using pre-allocated buffer
* @tparam T Type of element
*
* Almost all the method specification is similar as STL vector,
* but this container can not expand the capacity.
* Over capacity addition of element throws the exception derived from std::exception.
*/
template <typename T>
class PreallocatedVector {
public:
typedef T value_type;
typedef std::size_t size_type;
typedef std::ptrdiff_t difference_type;
typedef value_type* iterator;
typedef const value_type* const_iterator;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef value_type* pointer;
typedef const value_type* const_pointer;
#ifndef NO_STD_ITERATOR
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
#endif
private:
T* m_buf;
size_type m_buf_size;
size_type m_end;
class BadAlloc : public Container::BadAlloc {
public:
BadAlloc() : Container::BadAlloc() {}
const char* what() const throw()
{
return "PreallocatedVector::BadAlloc";
}
};
PreallocatedVector(const PreallocatedVector& x);
public:
/*!
* @brief Default constructor
* @attention If you use default constructor, you need to call init() before other method call.
*/
PreallocatedVector()
: m_buf(0), m_buf_size(0U), m_end(0U)
{
}
/*!
* @brief Constructor
* @param preallocated_buffer Pre-allocated buffer by caller
* @param buffer_size Size of preallocated_buffer
* @attention preallocated_buffer must be aligned on the boundary of type T.
*/
PreallocatedVector(void* preallocated_buffer, size_type buffer_size)
: m_buf(static_cast<T*>(preallocated_buffer)), m_buf_size(buffer_size), m_end(0U)
{
}
/*!
* @brief Destructor
* @note All elements are erased, but pre-allocated buffer is not released.
*/
~PreallocatedVector()
{
destroy_range(begin(), end());
}
/*!
* @brief Initialize
* @param preallocated_buffer Pre-allocated buffer by caller
* @param buffer_size Size of preallocated_buffer
* @attention preallocated_buffer must be aligned on the boundary of type T.
* @attention If you use default constructor, you need to call init() before other method call.
* @note Pre-allocated buffer can be set only one time.
*/
void init(void* preallocated_buffer, size_type buffer_size)
{
if (m_buf != 0) {
return;
}
m_buf = static_cast<T*>(preallocated_buffer);
m_buf_size = buffer_size;
}
PreallocatedVector& operator=(const PreallocatedVector& x)
{
if (this != &x) {
assign(x.begin(), x.end());
}
return *this;
}
size_type size() const
{
return m_end;
}
size_type max_size() const
{
return m_buf_size / sizeof(T);
}
size_type available_size() const
{
return max_size() - size();
}
bool empty() const
{
return size() == 0;
}
bool full() const
{
return size() == max_size();
}
void clear()
{
destroy_range(begin(), end());
m_end = 0U;
}
reference operator[](size_type idx)
{
return *(begin() + idx);
}
const_reference operator[](size_type idx) const
{
return *(begin() + idx);
}
reference at(size_type idx)
{
if (idx >= size()) {
throw OutOfRange("PreallocatedVector::at");
}
return *(begin() + idx);
}
const_reference at(size_type idx) const
{
if (idx >= size()) {
throw OutOfRange("PreallocatedVector::at");
}
return *(begin() + idx);
}
pointer data()
{
return begin();
}
const_pointer data() const
{
return begin();
}
iterator begin()
{
return &m_buf[0];
}
const_iterator begin() const
{
return &m_buf[0];
}
iterator end()
{
return begin() + m_end;
}
const_iterator end() const
{
return begin() + m_end;
}
#ifndef NO_STD_ITERATOR
reverse_iterator rbegin()
{
return reverse_iterator(end());
}
const_reverse_iterator rbegin() const
{
return const_reverse_iterator(end());
}
reverse_iterator rend()
{
return reverse_iterator(begin());
}
const_reverse_iterator rend() const
{
return const_reverse_iterator(begin());
}
#endif
reference front()
{
DEBUG_ASSERT(!empty());
return *begin();
}
const_reference front() const
{
DEBUG_ASSERT(!empty());
return *begin();
}
reference back()
{
DEBUG_ASSERT(!empty());
return *(end() - 1);
}
const_reference back() const
{
DEBUG_ASSERT(!empty());
return *(end() - 1);
}
void resize(size_type n, const T& data = T())
{
if (size() >= n) {
destroy_range(begin() + n, end());
m_end = n;
return;
}
if (max_size() < n) {
throw BadAlloc();
}
const size_type rest = n - size();
for (size_type i = 0U; i < rest; ++i) {
push_back(data);
}
}
void push_back(const T& data)
{
if (full()) {
throw BadAlloc();
}
construct(&*end(), data);
++m_end;
}
void pop_back()
{
DEBUG_ASSERT(!empty());
destroy(&*(end() - 1));
--m_end;
}
void assign(size_type n, const T& data)
{
if (max_size() < n) {
throw BadAlloc();
}
clear();
resize(n, data);
}
template <typename InputIterator>
void assign(InputIterator first, InputIterator last)
{
size_type n = 0U;
for (InputIterator i = first; i != last; ++i) {
++n;
}
if (max_size() < n) {
throw BadAlloc();
}
clear();
for (; first != last; ++first) {
push_back(*first);
}
}
iterator insert(iterator pos, const T& data)
{
DEBUG_ASSERT((begin() <= pos) && (pos <= end()));
insert_n(pos, 1U, data);
return pos;
}
void insert(iterator pos, size_type n, const T& data)
{
DEBUG_ASSERT((begin() <= pos) && (pos <= end()));
insert_n(pos, n, data);
}
template <typename InputIterator>
void insert(iterator pos, InputIterator first, InputIterator last)
{
DEBUG_ASSERT((begin() <= pos) && (pos <= end()));
typedef typename IsInteger<InputIterator>::Integral Integral;
insert_dispatch(pos, first, last, Integral());
}
iterator erase(iterator pos)
{
DEBUG_ASSERT((begin() <= pos) && (pos < end()));
return erase(pos, pos + 1);
}
iterator erase(iterator first, iterator last)
{
DEBUG_ASSERT(first < last);
DEBUG_ASSERT((begin() <= first) && (first < end()));
DEBUG_ASSERT((begin() <= last) && (last <= end()));
const difference_type n = last - first;
for (iterator i = last; i != end(); ++i) {
*(i - n) = *i;
}
destroy_range(end() - n, end());
m_end -= n;
return first;
}
private:
template <typename U>
friend bool operator==(const PreallocatedVector<U>& x, const PreallocatedVector<U>& y);
template <typename Integer>
void insert_dispatch(iterator pos, Integer n, Integer data, TrueType)
{
insert_n(pos, static_cast<size_type>(n), static_cast<T>(data));
}
template <typename InputIterator>
void insert_dispatch(iterator pos, InputIterator first, InputIterator last, FalseType)
{
insert_range(pos, first, last);
}
void insert_n(iterator pos, size_type n, const T& data)
{
if (available_size() < n) {
throw BadAlloc();
}
const size_type num_elems_pos_to_end = end() - pos;
iterator old_end = end();
if (num_elems_pos_to_end > n) {
for (size_type i = 0U; i < n; ++i) {
construct(&*end());
++m_end;
}
for (iterator it = old_end - 1; it != pos - 1; --it) {
*(it + n) = *it;
}
for (iterator it = pos; it != pos + n; ++it) {
*it = data;
}
} else {
for (size_type i = 0U; i < n - num_elems_pos_to_end; ++i) {
construct(&*end(), data);
++m_end;
}
for (iterator it = pos; it != pos + num_elems_pos_to_end; ++it) {
construct(&*end(), *it);
++m_end;
}
for (iterator it = pos; it != old_end; ++it) {
*it = data;
}
}
}
template <typename InputIterator>
void insert_range(iterator pos, InputIterator first, InputIterator last)
{
size_type n = 0U;
for (InputIterator i = first; i != last; ++i) {
++n;
}
if (available_size() < n) {
throw BadAlloc();
}
const size_type num_elems_pos_to_end = end() - pos;
iterator old_end = end();
if (num_elems_pos_to_end > n) {
for (size_type i = 0U; i < n; ++i) {
construct(&*end());
++m_end;
}
for (iterator it = old_end - 1; it != pos - 1; --it) {
*(it + n) = *it;
}
for (; first != last; ++pos, ++first) {
*pos = *first;
}
} else {
InputIterator mid = first;
for (size_type i = 0U; i < num_elems_pos_to_end; ++i) {
++mid;
}
for (size_type i = 0U; i < n - num_elems_pos_to_end; ++i) {
construct(&*end(), *mid);
++mid;
++m_end;
}
for (iterator it = pos; it != pos + num_elems_pos_to_end; ++it) {
construct(&*end(), *it);
++m_end;
}
for (iterator it = pos; it != old_end; ++it, ++first) {
*it = *first;
}
}
}
};
template <typename T>
bool operator==(const PreallocatedVector<T>& x, const PreallocatedVector<T>& y)
{
if (x.max_size() != y.max_size()) {
return false;
}
if (x.size() != y.size()) {
return false;
}
for (std::size_t i = 0U; i < x.size(); ++i) {
if (!(x[i] == y[i])) {
return false;
}
}
return true;
}
template <typename T>
bool operator!=(const PreallocatedVector<T>& x, const PreallocatedVector<T>& y)
{
return !(x == y);
}
}
#endif // CONTAINER_PREALLOCATED_VECTOR_H_INCLUDED
| 20.324731 | 96 | 0.642683 |
4da210b2673a44b24f1cebfda72f56ad7320af80 | 809 | h | C | include/fcs-genome/workers/DepthCombineWorker.h | FCS-holding/falcon-genome | bbba762ec54139392be843e9edff21766d5d7f5b | [
"Apache-2.0"
] | null | null | null | include/fcs-genome/workers/DepthCombineWorker.h | FCS-holding/falcon-genome | bbba762ec54139392be843e9edff21766d5d7f5b | [
"Apache-2.0"
] | null | null | null | include/fcs-genome/workers/DepthCombineWorker.h | FCS-holding/falcon-genome | bbba762ec54139392be843e9edff21766d5d7f5b | [
"Apache-2.0"
] | null | null | null | #ifndef FCSGENOME_WORKERS_DEPTHCOMBINEWORKER_H
#define FCSGENOME_WORKERS_DEPTHCOMBINEWORKER_H
#include <string>
#include "fcs-genome/Worker.h"
namespace fcsgenome {
class DepthCombineWorker : public Worker {
public:
DepthCombineWorker(
std::vector<std::string> &input_files,
std::string output_path,
bool &flag_baseCoverage,
bool &flag_intervalCoverage,
bool &flag_sampleSummary,
bool &flag_genes,
bool &flag_f);
void check();
void merge_outputs(std::string file_type);
void concatenate_outputs(std::string file_type);
void setup();
private:
std::vector<std::string> input_files_;
std::string output_file_;
bool flag_baseCoverage_;
bool flag_intervalCoverage_;
bool flag_sampleSummary_;
bool flag_genes_;
};
} //namespace fcsgenome
#endif
| 23.794118 | 50 | 0.745365 |
7f54eea3988c6bb22a88c28f1f5ddb9faf0a98f8 | 2,610 | h | C | lite/backends/arm/math/gemm_prepacked_int8.h | tensor-tang/Paddle-Lite | d60b8d611bdf7c377dbe239954c60f25f70c9a75 | [
"Apache-2.0"
] | null | null | null | lite/backends/arm/math/gemm_prepacked_int8.h | tensor-tang/Paddle-Lite | d60b8d611bdf7c377dbe239954c60f25f70c9a75 | [
"Apache-2.0"
] | null | null | null | lite/backends/arm/math/gemm_prepacked_int8.h | tensor-tang/Paddle-Lite | d60b8d611bdf7c377dbe239954c60f25f70c9a75 | [
"Apache-2.0"
] | null | null | null | // Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
//
// 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.
#pragma once
#include <cmath>
#include "lite/core/context.h"
#include "lite/core/device_info.h"
#include "lite/core/tensor.h"
namespace paddle {
namespace lite {
namespace arm {
namespace math {
const int KBLOCK_INT8 = 4;
#ifdef __aarch64__
// for int7/int8 gemm
// const int HBLOCK = 4;
// const int NBLOCK = 16;
const int MBLOCK_INT8_OTH = 4;
const int NBLOCK_INT8_OTH = 16;
const int MBLOCK_INT8_DOT = 8;
const int NBLOCK_INT8_DOT = 12;
inline int get_hblock_int8(const ARMContext* ctx) {
#ifdef WITH_ARM_DOTPROD
if (ctx->has_dot()) {
return MBLOCK_INT8_DOT;
} else {
return MBLOCK_INT8_OTH;
}
#else
return MBLOCK_INT8_OTH;
#endif
}
#else
// const int HBLOCK = 4;
// const int WBLOCK = 8;
const int MBLOCK_INT8_OTH = 4;
const int NBLOCK_INT8_OTH = 8;
inline int get_hblock_int8(const ARMContext* ctx) { return 4; }
#endif // __aarch64__
void prepackA_int8(void* out,
const void* in,
int ldin,
int m0,
int mmax,
int k0,
int kmax,
bool is_trans,
ARMContext* ctx);
void prepackA_int8(TensorLite* tout,
const TensorLite& tin,
int m,
int k,
int group,
bool is_trans,
ARMContext* ctx);
template <typename dtype>
void gemm_prepack_int8(const int8_t* A_packed,
const int8_t* B,
const int* bias,
dtype* C,
int M,
int N,
int K,
bool is_bias,
bool is_relu,
bool is_transB,
const float* scale,
ARMContext* ctx);
#define ROUNDUP(a, b) ((((a) + (b)-1) / (b)) * (b))
} // namespace math
} // namespace arm
} // namespace lite
} // namespace paddle
| 27.473684 | 75 | 0.578927 |
cfdbfa7e0edb0db9fe6650b3df836e0f04f1ff91 | 13,148 | c | C | FreeRTOS/Demo/PPC440_DP_FPU_Xilinx_Virtex5_GCC/RTOSDemo/flop/flop.c | TakayukiMatsuo/FreeRTOS | 6550f5120045c7a7272131ce143436d3ec560678 | [
"MIT"
] | 7 | 2019-02-28T12:40:43.000Z | 2020-02-29T07:48:14.000Z | FreeRTOS/Demo/PPC440_DP_FPU_Xilinx_Virtex5_GCC/RTOSDemo/flop/flop.c | TakayukiMatsuo/FreeRTOS | 6550f5120045c7a7272131ce143436d3ec560678 | [
"MIT"
] | 1 | 2020-07-02T06:31:57.000Z | 2020-07-02T06:31:57.000Z | FreeRTOS/Demo/PPC440_DP_FPU_Xilinx_Virtex5_GCC/RTOSDemo/flop/flop.c | TakayukiMatsuo/FreeRTOS | 6550f5120045c7a7272131ce143436d3ec560678 | [
"MIT"
] | 6 | 2017-04-01T23:43:34.000Z | 2019-09-01T07:31:52.000Z | /*
* FreeRTOS V202011.00
* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
* this software and associated documentation files (the "Software"), to deal in
* the Software without restriction, including without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all
* copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* http://www.FreeRTOS.org
* http://aws.amazon.com/freertos
*
* 1 tab == 4 spaces!
*/
/*
* Creates eight tasks, each of which loops continuously performing a
* floating point calculation.
*
* All the tasks run at the idle priority and never block or yield. This causes
* all eight tasks to time slice with the idle task. Running at the idle priority
* means that these tasks will get pre-empted any time another task is ready to run
* or a time slice occurs. More often than not the pre-emption will occur mid
* calculation, creating a good test of the schedulers context switch mechanism - a
* calculation producing an unexpected result could be a symptom of a corruption in
* the context of a task.
*
* This file demonstrates the use of the task tag and traceTASK_SWITCHED_IN and
* traceTASK_SWITCHED_OUT macros to save and restore the floating point context.
*/
#include <stdlib.h>
#include <math.h>
/* Scheduler include files. */
#include "FreeRTOS.h"
#include "task.h"
/* Demo program include files. */
#include "flop.h"
/* Misc. definitions. */
#define mathSTACK_SIZE configMINIMAL_STACK_SIZE
#define mathNUMBER_OF_TASKS ( 8 )
/* Four tasks, each of which performs a different floating point calculation.
Each of the four is created twice. */
static portTASK_FUNCTION_PROTO( vCompetingMathTask1, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask2, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask3, pvParameters );
static portTASK_FUNCTION_PROTO( vCompetingMathTask4, pvParameters );
/* These variables are used to check that all the tasks are still running. If a
task gets a calculation wrong it will stop incrementing its check variable. */
static volatile unsigned short usTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 };
/* Buffers into which the flop registers will be saved. There is a buffer for
each task created within this file. Zeroing out this array is the normal and
safe option as this will cause the task to start with all zeros in its flop
context. */
static portDOUBLE dFlopRegisters[ mathNUMBER_OF_TASKS ][ portNO_FLOP_REGISTERS_TO_SAVE ];
/*-----------------------------------------------------------*/
void vStartMathTasks( unsigned portBASE_TYPE uxPriority )
{
TaskHandle_t xTaskJustCreated;
portBASE_TYPE x, y;
/* Place known values into the buffers into which the flop registers are
to be saved. This is for debug purposes only, it is not normally
required. The last position in each array is left at zero as the status
register will be loaded from there.
It is intended that these values can be viewed being loaded into the
flop registers when a task is started - however the Insight debugger
does not seem to want to show the flop register values. */
for( x = 0; x < mathNUMBER_OF_TASKS; x++ )
{
for( y = 0; y < ( portNO_FLOP_REGISTERS_TO_SAVE - 1 ); y++ )
{
dFlopRegisters[ x ][ y ] = ( x + 1 );
}
}
/* Create the first task - passing it the address of the check variable
that it is going to increment. This check variable is used as an
indication that the task is still running. */
xTaskCreate( vCompetingMathTask1, "Math1", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 0 ] ), uxPriority, &xTaskJustCreated );
/* The task tag value is a value that can be associated with a task, but
is not used by the scheduler itself. Its use is down to the application so
it makes a convenient place in this case to store the pointer to the buffer
into which the flop context of the task will be stored. The first created
task uses dFlopRegisters[ 0 ], the second dFlopRegisters[ 1 ], etc. */
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 0 ][ 0 ] ) );
/* Create another 7 tasks, allocating a buffer for each. */
xTaskCreate( vCompetingMathTask2, "Math2", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 1 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 1 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask3, "Math3", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 2 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 2 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask4, "Math4", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 3 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 3 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask1, "Math5", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 4 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 4 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask2, "Math6", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 5 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 5 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask3, "Math7", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 6 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 6 ][ 0 ] ) );
xTaskCreate( vCompetingMathTask4, "Math8", mathSTACK_SIZE, ( void * ) &( usTaskCheck[ 7 ] ), uxPriority, &xTaskJustCreated );
vTaskSetApplicationTaskTag( xTaskJustCreated, ( void * ) &( dFlopRegisters[ 7 ][ 0 ] ) );
}
/*-----------------------------------------------------------*/
static portTASK_FUNCTION( vCompetingMathTask1, pvParameters )
{
volatile portDOUBLE df1, df2, df3, df4;
volatile unsigned short *pusTaskCheckVariable;
volatile portDOUBLE dAnswer;
short sError = pdFALSE;
df1 = 123.4567;
df2 = 2345.6789;
df3 = -918.222;
dAnswer = ( df1 + df2 ) * df3;
/* The variable this task increments to show it is still running is passed in
as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters;
/* Keep performing a calculation and checking the result against a constant. */
for(;;)
{
df1 = 123.4567;
df2 = 2345.6789;
df3 = -918.222;
df4 = ( df1 + df2 ) * df3;
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* If the calculation does not match the expected constant, stop the
increment of the check variable. */
if( fabs( df4 - dAnswer ) > 0.001 )
{
sError = pdTRUE;
}
if( sError == pdFALSE )
{
/* If the calculation has always been correct, increment the check
variable so we know this task is still running okay. */
( *pusTaskCheckVariable )++;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
}
}
/*-----------------------------------------------------------*/
static portTASK_FUNCTION( vCompetingMathTask2, pvParameters )
{
volatile portDOUBLE df1, df2, df3, df4;
volatile unsigned short *pusTaskCheckVariable;
volatile portDOUBLE dAnswer;
short sError = pdFALSE;
df1 = -389.38;
df2 = 32498.2;
df3 = -2.0001;
dAnswer = ( df1 / df2 ) * df3;
/* The variable this task increments to show it is still running is passed in
as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters;
/* Keep performing a calculation and checking the result against a constant. */
for( ;; )
{
df1 = -389.38;
df2 = 32498.2;
df3 = -2.0001;
df4 = ( df1 / df2 ) * df3;
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
/* If the calculation does not match the expected constant, stop the
increment of the check variable. */
if( fabs( df4 - dAnswer ) > 0.001 )
{
sError = pdTRUE;
}
if( sError == pdFALSE )
{
/* If the calculation has always been correct, increment the check
variable so we know
this task is still running okay. */
( *pusTaskCheckVariable )++;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
}
}
/*-----------------------------------------------------------*/
static portTASK_FUNCTION( vCompetingMathTask3, pvParameters )
{
volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;
volatile unsigned short *pusTaskCheckVariable;
const size_t xArraySize = 10;
size_t xPosition;
short sError = pdFALSE;
/* The variable this task increments to show it is still running is passed in
as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters;
pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );
/* Keep filling an array, keeping a running total of the values placed in the
array. Then run through the array adding up all the values. If the two totals
do not match, stop the check variable from incrementing. */
for( ;; )
{
dTotal1 = 0.0;
dTotal2 = 0.0;
for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{
pdArray[ xPosition ] = ( portDOUBLE ) xPosition + 5.5;
dTotal1 += ( portDOUBLE ) xPosition + 5.5;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{
dTotal2 += pdArray[ xPosition ];
}
dDifference = dTotal1 - dTotal2;
if( fabs( dDifference ) > 0.001 )
{
sError = pdTRUE;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
if( sError == pdFALSE )
{
/* If the calculation has always been correct, increment the check
variable so we know this task is still running okay. */
( *pusTaskCheckVariable )++;
}
}
}
/*-----------------------------------------------------------*/
static portTASK_FUNCTION( vCompetingMathTask4, pvParameters )
{
volatile portDOUBLE *pdArray, dTotal1, dTotal2, dDifference;
volatile unsigned short *pusTaskCheckVariable;
const size_t xArraySize = 10;
size_t xPosition;
short sError = pdFALSE;
/* The variable this task increments to show it is still running is passed in
as the parameter. */
pusTaskCheckVariable = ( unsigned short * ) pvParameters;
pdArray = ( portDOUBLE * ) pvPortMalloc( xArraySize * sizeof( portDOUBLE ) );
/* Keep filling an array, keeping a running total of the values placed in the
array. Then run through the array adding up all the values. If the two totals
do not match, stop the check variable from incrementing. */
for( ;; )
{
dTotal1 = 0.0;
dTotal2 = 0.0;
for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{
pdArray[ xPosition ] = ( portDOUBLE ) xPosition * 12.123;
dTotal1 += ( portDOUBLE ) xPosition * 12.123;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
for( xPosition = 0; xPosition < xArraySize; xPosition++ )
{
dTotal2 += pdArray[ xPosition ];
}
dDifference = dTotal1 - dTotal2;
if( fabs( dDifference ) > 0.001 )
{
sError = pdTRUE;
}
#if configUSE_PREEMPTION == 0
taskYIELD();
#endif
if( sError == pdFALSE )
{
/* If the calculation has always been correct, increment the check
variable so we know this task is still running okay. */
( *pusTaskCheckVariable )++;
}
}
}
/*-----------------------------------------------------------*/
/* This is called to check that all the created tasks are still running. */
portBASE_TYPE xAreMathsTaskStillRunning( void )
{
/* Keep a history of the check variables so we know if they have been incremented
since the last call. */
static unsigned short usLastTaskCheck[ mathNUMBER_OF_TASKS ] = { ( unsigned short ) 0 };
portBASE_TYPE xReturn = pdTRUE, xTask;
/* Check the maths tasks are still running by ensuring their check variables
are still incrementing. */
for( xTask = 0; xTask < mathNUMBER_OF_TASKS; xTask++ )
{
if( usTaskCheck[ xTask ] == usLastTaskCheck[ xTask ] )
{
/* The check has not incremented so an error exists. */
xReturn = pdFALSE;
}
usLastTaskCheck[ xTask ] = usTaskCheck[ xTask ];
}
return xReturn;
}
| 34.691293 | 128 | 0.669836 |
2cd4c4c6ceace64954baff05545db2d593f26331 | 371 | h | C | KRProduct/KRProduct/Classes/Store/ChainStoreList/View/KRChainStoreView.h | KinRainModulization/KRProduct | c9469a9493e62a045e134a320c1c8741180ebee3 | [
"MIT"
] | null | null | null | KRProduct/KRProduct/Classes/Store/ChainStoreList/View/KRChainStoreView.h | KinRainModulization/KRProduct | c9469a9493e62a045e134a320c1c8741180ebee3 | [
"MIT"
] | null | null | null | KRProduct/KRProduct/Classes/Store/ChainStoreList/View/KRChainStoreView.h | KinRainModulization/KRProduct | c9469a9493e62a045e134a320c1c8741180ebee3 | [
"MIT"
] | null | null | null | //
// KRChainStoreView.h
// KRProduct
//
// Created by LX on 2018/1/18.
// Copyright © 2018年 Ace. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface KRChainStoreView : UITableView
@property (nonatomic, strong) NSArray *stores;
@property (nonatomic, copy) void (^storeHotlineBlock)(void);
@property (nonatomic, copy) void (^storeDetailBlock)(void);
@end
| 18.55 | 60 | 0.708895 |
d62a30fb47bcf310df3a63aaec84caf5943473c7 | 47,427 | h | C | cudd/cuddInt.h | prismmodelchecker/cudd | 786ed4ec2be9ad1e9b8373057fb8b0d38945f35b | [
"BSD-3-Clause"
] | 1 | 2021-09-18T00:27:50.000Z | 2021-09-18T00:27:50.000Z | cudd/cuddInt.h | prismmodelchecker/cudd | 786ed4ec2be9ad1e9b8373057fb8b0d38945f35b | [
"BSD-3-Clause"
] | 4 | 2018-01-11T16:58:04.000Z | 2019-04-20T23:06:22.000Z | cudd/cuddInt.h | prismmodelchecker/cudd | 786ed4ec2be9ad1e9b8373057fb8b0d38945f35b | [
"BSD-3-Clause"
] | null | null | null | /**
@file
@ingroup cudd
@brief Internal data structures of the CUDD package.
@author Fabio Somenzi
@copyright@parblock
Copyright (c) 1995-2015, Regents of the University of Colorado
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
Neither the name of the University of Colorado nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
@endparblock
*/
#ifndef CUDD_INT_H_
#define CUDD_INT_H_
/*---------------------------------------------------------------------------*/
/* Nested includes */
/*---------------------------------------------------------------------------*/
#include <math.h>
#include "config.h"
#include "st.h"
#include "mtr.h"
#include "epd.h"
#include "cudd.h"
/*---------------------------------------------------------------------------*/
/* Constant declarations */
/*---------------------------------------------------------------------------*/
#define CUDD_VERSION PACKAGE_VERSION
#define DD_MAXREF ((DdHalfWord) ~0)
#define DD_DEFAULT_RESIZE 10 /* how many extra variables */
/* should be added when resizing */
#define DD_MEM_CHUNK 1022
/* These definitions work for CUDD_VALUE_TYPE == double */
#define DD_ONE_VAL (1.0)
#define DD_ZERO_VAL (0.0)
#define DD_EPSILON (1.0e-12)
/* The definitions of +/- infinity in terms of HUGE_VAL work on
** the DECstations and on many other combinations of OS/compiler.
*/
#ifdef HAVE_IEEE_754
# define DD_PLUS_INF_VAL (HUGE_VAL)
#else
# define DD_PLUS_INF_VAL (10e301)
# define DD_CRI_HI_MARK (10e150)
# define DD_CRI_LO_MARK (-(DD_CRI_HI_MARK))
#endif
#define DD_MINUS_INF_VAL (-(DD_PLUS_INF_VAL))
#define DD_NON_CONSTANT ((DdNode *) 1) /* for Cudd_bddIteConstant */
/* Unique table and cache management constants. */
#define DD_MAX_SUBTABLE_DENSITY 4 /* tells when to resize a subtable */
/* gc when this percent are dead (measured w.r.t. slots, not keys)
** The first limit (LO) applies normally. The second limit applies when
** the package believes more space for the unique table (i.e., more dead
** nodes) would improve performance, and the unique table is not already
** too large. The third limit applies when memory is low.
*/
#define DD_GC_FRAC_LO DD_MAX_SUBTABLE_DENSITY * 0.25
#define DD_GC_FRAC_HI DD_MAX_SUBTABLE_DENSITY * 1.0
#define DD_GC_FRAC_MIN 0.2
#define DD_MIN_HIT 30 /* resize cache when hit ratio
above this percentage (default) */
#define DD_MAX_LOOSE_FRACTION 5 /* 1 / (max fraction of memory used for
unique table in fast growth mode) */
#define DD_MAX_CACHE_FRACTION 3 /* 1 / (max fraction of memory used for
computed table if resizing enabled) */
#define DD_STASH_FRACTION 64 /* 1 / (fraction of memory set
aside for emergencies) */
#define DD_MAX_CACHE_TO_SLOTS_RATIO 4 /* used to limit the cache size */
/* Variable ordering default parameter values. */
#define DD_SIFT_MAX_VAR 1000
#define DD_SIFT_MAX_SWAPS 2000000
#define DD_DEFAULT_RECOMB 0
#define DD_MAX_REORDER_GROWTH 1.2
#define DD_FIRST_REORDER 4004 /* 4 for the constants */
#define DD_DYN_RATIO 2 /* when to dynamically reorder */
/* Primes for cache hash functions. */
#define DD_P1 12582917
#define DD_P2 4256249
#define DD_P3 741457
#define DD_P4 1618033999
/* Cache tags for 3-operand operators. These tags are stored in the
** least significant bits of the cache operand pointers according to
** the following scheme. The tag consists of two hex digits. Both digits
** must be even, so that they do not interfere with complementation bits.
** The least significant one is stored in Bits 3:1 of the f operand in the
** cache entry. Bit 1 is always 1, so that we can differentiate
** three-operand operations from one- and two-operand operations.
** Therefore, the least significant digit is one of {2,6,a,e}. The most
** significant digit occupies Bits 3:1 of the g operand in the cache
** entry. It can by any even digit between 0 and e. This gives a total
** of 5 bits for the tag proper, which means a maximum of 32 three-operand
** operations. */
#define DD_ADD_ITE_TAG 0x02
#define DD_BDD_AND_ABSTRACT_TAG 0x06
#define DD_BDD_XOR_EXIST_ABSTRACT_TAG 0x0a
#define DD_BDD_ITE_TAG 0x0e
#define DD_ADD_BDD_DO_INTERVAL_TAG 0x22
#define DD_BDD_CLIPPING_AND_ABSTRACT_UP_TAG 0x26
#define DD_BDD_CLIPPING_AND_ABSTRACT_DOWN_TAG 0x2a
#define DD_BDD_COMPOSE_RECUR_TAG 0x2e
#define DD_ADD_COMPOSE_RECUR_TAG 0x42
#define DD_ADD_NON_SIM_COMPOSE_TAG 0x46
#define DD_EQUIV_DC_TAG 0x4a
#define DD_ZDD_ITE_TAG 0x4e
#define DD_ADD_ITE_CONSTANT_TAG 0x62
#define DD_ADD_EVAL_CONST_TAG 0x66
#define DD_BDD_ITE_CONSTANT_TAG 0x6a
#define DD_ADD_OUT_SUM_TAG 0x6e
#define DD_BDD_LEQ_UNLESS_TAG 0x82
#define DD_ADD_TRIANGLE_TAG 0x86
#define DD_BDD_MAX_EXP_TAG 0x8a
#define DD_VARS_SYMM_BEFORE_TAG 0x8e
#define DD_VARS_SYMM_BETWEEN_TAG 0xa2
/* Generator constants. */
#define CUDD_GEN_CUBES 0
#define CUDD_GEN_PRIMES 1
#define CUDD_GEN_NODES 2
#define CUDD_GEN_ZDD_PATHS 3
#define CUDD_GEN_EMPTY 0
#define CUDD_GEN_NONEMPTY 1
/**
** @brief Maximum variable index.
**
** @details CUDD_MAXINDEX is defined in such a way that on 32-bit and
** 64-bit machines one can cast an index to (int) without generating
** a negative number.
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define CUDD_MAXINDEX (((DdHalfWord) ~0) >> 1)
#else
#define CUDD_MAXINDEX ((DdHalfWord) ~0)
#endif
/**
** @brief The index of constant nodes.
**
** @details This is a synonim for CUDD_MAXINDEX.
*/
#define CUDD_CONST_INDEX CUDD_MAXINDEX
/**
** @brief Size of the random number generator shuffle table.
*/
#define STAB_SIZE 64
/**
** @brief Mask for periodic check of termination and timeout.
**
** @see checkWhetherToGiveUp
*/
#define CUDD_CHECK_MASK 0x7ff
/*---------------------------------------------------------------------------*/
/* Type declarations */
/*---------------------------------------------------------------------------*/
/**
@brief Type that is half the size of a pointer.
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
typedef uint32_t DdHalfWord;
#else
typedef uint16_t DdHalfWord;
#endif
/**
* @brief Signed integer that is the size of a pointer.
*
* @details The only platforms on which CUDD has been tested define
* intptr_t and uintptr_t in inttypes.h and satisfy the condition
*
* sizeof(intptr_t) == sizeof(uintptr_t) == sizeof(void *)
*
* Neither of these is guaranteed by the C standard.
*/
typedef intptr_t ptrint;
/**
* @brief Unsigned integer that is the size of a pointer.
*
* @see ptrint
*/
typedef uintptr_t ptruint;
typedef struct DdChildren DdChildren;
typedef struct DdHook DdHook;
typedef struct DdSubtable DdSubtable;
typedef struct DdCache DdCache;
typedef struct DdLocalCacheItem DdLocalCacheItem;
typedef struct DdLocalCache DdLocalCache;
typedef struct DdHashItem DdHashItem;
typedef struct DdHashTable DdHashTable;
typedef struct Move Move;
typedef struct IndexKey IndexKey;
typedef struct DdQueueItem DdQueueItem;
typedef struct DdLevelQueue DdLevelQueue;
/*---------------------------------------------------------------------------*/
/* Stucture declarations */
/*---------------------------------------------------------------------------*/
/**
* @brief The two children of a non-terminal node.
*/
struct DdChildren {
struct DdNode *T; /**< then (true) child */
struct DdNode *E; /**< else (false) child */
};
/**
* @brief Decision diagram node.
*/
struct DdNode {
DdHalfWord index; /**< variable index */
DdHalfWord ref; /**< reference count */
DdNode *next; /**< next pointer for unique table */
union {
CUDD_VALUE_TYPE value; /**< for constant (terminal) nodes */
DdChildren kids; /**< for internal nodes */
} type; /**< terminal or internal */
};
/**
* @brief CUDD generator.
*/
struct DdGen {
DdManager *manager;
int type;
int status;
union {
struct {
int *cube;
CUDD_VALUE_TYPE value;
} cubes;
struct {
int *cube;
DdNode *ub;
} primes;
struct {
int size;
} nodes;
} gen;
struct {
int sp;
DdNode **stack;
} stack;
DdNode *node;
};
/**
** @brief CUDD hook
**
** Hooks in CUDD are functions that the application registers with the
** manager so that they are called at appropriate times. The functions
** are passed the manager as argument; they should return 1 if
** successful and 0 otherwise.
*/
struct DdHook {
DD_HFP f; /**< function to be called */
struct DdHook *next; /**< next element in the list */
};
/**
* @brief Generic local cache item.
*/
struct DdLocalCacheItem {
DdNode *value;
#ifdef DD_CACHE_PROFILE
ptrint count;
#endif
DdNode *key[1];
};
/**
* @brief Local cache.
*/
struct DdLocalCache {
DdLocalCacheItem *item;
unsigned int itemsize;
unsigned int keysize;
unsigned int slots;
int shift;
double lookUps;
double minHit;
double hits;
unsigned int maxslots;
DdManager *manager;
struct DdLocalCache *next;
};
/**
* @brief Local hash table item.
*/
struct DdHashItem {
struct DdHashItem *next; /**< collision list link */
ptrint count; /**< reference count of item */
DdNode *value; /**< value %DD */
DdNode *key[1]; /**< key pointers */
};
/**
* @brief Local hash table.
*/
struct DdHashTable {
unsigned int keysize; /**< number of pointers in the key */
unsigned int itemsize; /**< size of hash table item in bytes */
DdHashItem **bucket; /**< array of buckets */
DdHashItem *nextFree; /**< item free list */
DdHashItem **memoryList; /**< list of memory blocks for items */
unsigned int numBuckets; /**< number of buckets in array */
int shift; /**< shift used in hash function */
unsigned int size; /**< number of items stored in table */
unsigned int maxsize; /**< threshold for table resizing */
DdManager *manager; /**< %DD manager */
};
/**
* @brief Computed table.
*/
struct DdCache {
DdNode *f,*g; /**< DDs */
ptruint h; /**< either operator or %DD */
DdNode *data; /**< already constructed %DD */
#ifdef DD_CACHE_PROFILE
ptrint count; /**< statistical counter */
#endif
};
/**
* @brief Subtable for one index.
*/
struct DdSubtable {
DdNode **nodelist; /**< hash table */
int shift; /**< shift for hash function */
unsigned int slots; /**< size of the hash table */
unsigned int keys; /**< number of nodes stored in this table */
unsigned int maxKeys; /**< slots * DD_MAX_SUBTABLE_DENSITY */
unsigned int dead; /**< number of dead nodes in this table */
unsigned int next; /**< index of next variable in group */
int bindVar; /**< flag to bind this variable to its level */
/* Fields for lazy sifting. */
Cudd_VariableType varType; /**< variable type (ps, ns, pi) */
int pairIndex; /**< corresponding variable index (ps <-> ns) */
int varHandled; /**< flag: 1 means variable is already handled */
Cudd_LazyGroupType varToBeGrouped; /**< tells what grouping to apply */
};
/**
* @brief Specialized %DD symbol table.
*/
struct DdManager {
/* Constants */
DdNode sentinel; /**< for collision lists */
DdNode *one; /**< constant 1 */
DdNode *zero; /**< constant 0 */
DdNode *plusinfinity; /**< plus infinity */
DdNode *minusinfinity; /**< minus infinity */
DdNode *background; /**< background value */
/* Computed Table */
DdCache *acache; /**< address of allocated memory for cache */
DdCache *cache; /**< the cache-based computed table */
unsigned int cacheSlots; /**< total number of cache entries */
int cacheShift; /**< shift value for cache hash function */
double cacheMisses; /**< number of cache misses (since resizing) */
double cacheHits; /**< number of cache hits (since resizing) */
double minHit; /**< hit percentage above which to resize */
int cacheSlack; /**< slots still available for resizing */
unsigned int maxCacheHard; /**< hard limit for cache size */
/* Unique Table */
int size; /**< number of unique subtables */
int sizeZ; /**< for %ZDD */
int maxSize; /**< max number of subtables before resizing */
int maxSizeZ; /**< for %ZDD */
DdSubtable *subtables; /**< array of unique subtables */
DdSubtable *subtableZ; /**< for %ZDD */
DdSubtable constants; /**< unique subtable for the constants */
unsigned int slots; /**< total number of hash buckets */
unsigned int keys; /**< total number of %BDD and %ADD nodes */
unsigned int keysZ; /**< total number of %ZDD nodes */
unsigned int dead; /**< total number of dead %BDD and %ADD nodes */
unsigned int deadZ; /**< total number of dead %ZDD nodes */
unsigned int maxLive; /**< maximum number of live nodes */
unsigned int minDead; /**< do not GC if fewer than these dead */
int gcEnabled; /**< gc is enabled */
double gcFrac; /**< gc when this fraction is dead */
unsigned int looseUpTo; /**< slow growth beyond this limit */
/**< (measured w.r.t. slots, not keys) */
unsigned int initSlots; /**< initial size of a subtable */
DdNode **stack; /**< stack for iterative procedures */
double allocated; /**< number of nodes allocated */
/**< (not during reordering) */
double reclaimed; /**< number of nodes brought back from the dead */
int *perm; /**< current variable perm. (index to level) */
int *permZ; /**< for %ZDD */
int *invperm; /**< current inv. var. perm. (level to index) */
int *invpermZ; /**< for %ZDD */
DdNode **vars; /**< projection functions */
int *map; /**< variable map for fast swap */
DdNode **univ; /**< %ZDD 1 for each variable */
unsigned int isolated; /**< isolated projection functions */
unsigned int originalSize; /**< used by lazy sifting */
int linearSize; /**< number of rows and columns of linear */
ptruint *interact; /**< interacting variable matrix */
ptruint *linear; /**< linear transform matrix */
/* Memory Management */
DdNode **memoryList; /**< memory manager for symbol table */
DdNode *nextFree; /**< list of free nodes */
char *stash; /**< memory reserve */
#ifndef DD_NO_DEATH_ROW
DdNode **deathRow; /**< queue for dereferencing */
int deathRowDepth; /**< number of slots in the queue */
int nextDead; /**< index in the queue */
unsigned deadMask; /**< mask for circular index update */
#endif
/* General Parameters */
CUDD_VALUE_TYPE epsilon; /**< tolerance on comparisons */
/* Dynamic Reordering Parameters */
int reordered; /**< flag set at the end of reordering */
unsigned int reorderings; /**< number of calls to Cudd_ReduceHeap */
unsigned int maxReorderings;/**< maximum number of calls to Cudd_ReduceHeap */
int siftMaxVar; /**< maximum number of vars sifted */
int siftMaxSwap; /**< maximum number of swaps per sifting */
int ddTotalNumberSwapping; /**< number of %BDD/%ADD swaps completed */
int zddTotalNumberSwapping; /**< number of %ZDD swaps completed */
int reordCycle; /**< how often to apply alternate threshold */
double maxGrowth; /**< maximum growth during reordering */
double maxGrowthAlt; /**< alternate maximum growth for reordering */
int autoDyn; /**< automatic dynamic reordering flag (BDD) */
int autoDynZ; /**< automatic dynamic reordering flag (ZDD) */
Cudd_ReorderingType autoMethod; /**< default reordering method */
Cudd_ReorderingType autoMethodZ; /**< default reordering method (ZDD) */
int realign; /**< realign %ZDD order after %BDD reordering */
int realignZ; /**< realign %BDD order after %ZDD reordering */
unsigned int nextDyn; /**< reorder if this size is reached */
unsigned int countDead; /**< if 0, count deads to trigger reordering */
MtrNode *tree; /**< variable group tree (BDD) */
MtrNode *treeZ; /**< variable group tree (ZDD) */
Cudd_AggregationType groupcheck; /**< used during group sifting */
int recomb; /**< used during group sifting */
int symmviolation; /**< used during group sifting */
int arcviolation; /**< used during group sifting */
int populationSize; /**< population size for GA */
int numberXovers; /**< number of crossovers for GA */
unsigned int randomizeOrder; /**< perturb the next reordering threshold */
DdLocalCache *localCaches; /**< local caches currently in existence */
void *hooks; /**< application-specific field (used by vis) */
DdHook *preGCHook; /**< hooks to be called before GC */
DdHook *postGCHook; /**< hooks to be called after GC */
DdHook *preReorderingHook; /**< hooks to be called before reordering */
DdHook *postReorderingHook; /**< hooks to be called after reordering */
FILE *out; /**< stdout for this manager */
FILE *err; /**< stderr for this manager */
Cudd_ErrorType errorCode; /**< info on last error */
unsigned long startTime; /**< start time in milliseconds */
unsigned long timeLimit; /**< CPU time limit */
DD_THFP terminationCallback; /**< termination callback */
void * tcbArg; /**< second argument passed to termination handler */
DD_OOMFP outOfMemCallback; /**< out-of-memory callback */
DD_TOHFP timeoutHandler; /**< timeout handler */
void * tohArg; /**< second argument passed to timeout handler */
/* Statistical counters. */
size_t memused; /**< total memory allocated for the manager */
size_t maxmem; /**< target maximum memory */
size_t maxmemhard; /**< hard limit for maximum memory */
int garbageCollections; /**< number of garbage collections */
unsigned long GCTime; /**< total time spent in garbage collection */
unsigned long reordTime; /**< total time spent in reordering */
double totCachehits; /**< total number of cache hits */
double totCacheMisses; /**< total number of cache misses */
double cachecollisions; /**< number of cache collisions */
double cacheinserts; /**< number of cache insertions */
double cacheLastInserts; /**< insertions at the last cache resizing */
double cachedeletions; /**< number of deletions during garbage coll. */
unsigned int peakLiveNodes; /**< maximum number of live nodes */
/* Random number generator. */
int32_t cuddRand; /**< state of the random number generator */
int32_t cuddRand2; /**< state of the random number generator */
int32_t shuffleSelect; /**< state of the random number generator */
int32_t shuffleTable[STAB_SIZE]; /**< state of the random number generator */
#ifdef DD_STATS
double nodesFreed; /**< number of nodes returned to the free list */
double nodesDropped; /**< number of nodes killed by dereferencing */
int totalNISwaps; /**< number of non-interacting (cheap) swaps */
int extsymmcalls; /**< number of calls to symmetry check fn */
int extsymm; /**< number of successful symmetry checks */
int secdiffcalls; /**< number of calls to second difference fn */
int secdiff; /**< number of successful second diff. checks */
int secdiffmisfire; /**< number of misfired second diff. checks */
int tosses; /**< number of coin tosses in annealing */
int acceptances; /**< number of acceptances in annealing */
int totalShuffles; /**< number of shuffles in exact reordering */
int totalNumberLinearTr; /**< number of linear transformations */
int num_calls; /**< should equal 2n-1 (n is the # of nodes) */
#endif
#ifdef DD_UNIQUE_PROFILE
double uniqueLookUps; /**< number of unique table lookups */
double uniqueLinks; /**< total distance traveled in coll. chains */
#endif
#ifdef DD_COUNT
double recursiveCalls; /**< number of recursive calls */
#ifdef DD_STATS
double nextSample; /**< when to write next line of stats */
#endif
double swapSteps; /**< number of elementary reordering steps */
#endif
#ifdef DD_DEBUG
int addPermuteRecurHits; /**< debug variable for variable permutation */
int bddPermuteRecurHits; /**< debug variable for variable permutation */
int bddVectorComposeHits; /**< debug variable for vector composition */
int addVectorComposeHits; /**< debug variable for vector composition */
int addGeneralVectorComposeHits; /**< debug var. for vector composition */
int enableExtraDebug; /**< deposit a 1 here to enable more debugging */
#endif
};
/**
* @brief Reordering move record.
*/
struct Move {
DdHalfWord x;
DdHalfWord y;
unsigned int flags;
int size;
struct Move *next;
};
/**
* @brief Used to sort variables for reordering.
*/
struct IndexKey {
int index;
int keys;
};
/**
* @brief Generic level queue item.
*/
struct DdQueueItem {
struct DdQueueItem *next;
struct DdQueueItem *cnext;
void *key;
};
/**
* @brief Level queue.
*/
struct DdLevelQueue {
void *first;
DdQueueItem **last;
DdQueueItem *freelist;
DdQueueItem **buckets;
int levels;
int itemsize;
int size;
int maxsize;
int numBuckets;
int shift;
DdManager *manager;
};
/*---------------------------------------------------------------------------*/
/* Variable declarations */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/* Macro declarations */
/*---------------------------------------------------------------------------*/
/**
@brief Adds node to the head of the free list.
@details Does not deallocate memory chunks that become free. This
function is also used by the dynamic reordering functions.
@sideeffect None
@see cuddAllocNode cuddDynamicAllocNode cuddDeallocMove
*/
#define cuddDeallocNode(unique,node) \
(node)->next = (unique)->nextFree; \
(unique)->nextFree = node;
/**
@brief Adds node to the head of the free list.
@details Does not deallocate memory chunks that become free. This
function is also used by the dynamic reordering functions.
@sideeffect None
@see cuddDeallocNode cuddDynamicAllocNode
*/
#define cuddDeallocMove(unique,node) \
((DdNode *)(node))->ref = 0; \
((DdNode *)(node))->next = (unique)->nextFree; \
(unique)->nextFree = (DdNode *)(node);
/**
@brief Increases the reference count of a node, if it is not
saturated.
@details This being a macro, it is faster than Cudd_Ref, but it
cannot be used in constructs like cuddRef(a = b()).
@sideeffect none
@see Cudd_Ref
*/
#define cuddRef(n) cuddSatInc(Cudd_Regular(n)->ref)
/**
@brief Decreases the reference count of a node, if it is not
saturated.
@details It is primarily used in recursive procedures to decrease
the ref count of a result node before returning it. This
accomplishes the goal of removing the protection applied by a
previous cuddRef. This being a macro, it is faster than Cudd_Deref,
but it cannot be used in constructs like cuddDeref(a = b()).
@sideeffect none
@see Cudd_Deref
*/
#define cuddDeref(n) cuddSatDec(Cudd_Regular(n)->ref)
/**
@brief Returns 1 if the node is a constant node.
@details Returns 1 if the node is a constant node (rather than an
internal node). All constant nodes have the same index
(CUDD_CONST_INDEX). The pointer passed to Cudd_IsConstantInt may be either
regular or complemented.
@sideeffect none
@see cuddIsConstant Cudd_IsConstant
*/
#define Cudd_IsConstantInt(node) ((Cudd_Regular(node))->index == CUDD_CONST_INDEX)
/**
@brief Returns 1 if the node is a constant node.
@details Returns 1 if the node is a constant node (rather than an
internal node). All constant nodes have the same index
(CUDD_CONST_INDEX). The pointer passed to cuddIsConstant must be regular.
@sideeffect none
@see Cudd_IsConstant Cudd_IsConstantInt
*/
#define cuddIsConstant(node) ((node)->index == CUDD_CONST_INDEX)
/**
@brief Returns the then child of an internal node.
@details If <code>node</code> is a constant node, the result is
unpredictable. The pointer passed to cuddT must be regular.
@sideeffect none
@see Cudd_T
*/
#define cuddT(node) ((node)->type.kids.T)
/**
@brief Returns the else child of an internal node.
@details If <code>node</code> is a constant node, the result is
unpredictable. The pointer passed to cuddE must be regular.
@sideeffect none
@see Cudd_E
*/
#define cuddE(node) ((node)->type.kids.E)
/**
@brief Returns the value of a constant node.
@details If <code>node</code> is an internal node, the result is
unpredictable. The pointer passed to cuddV must be regular.
@sideeffect none
@see Cudd_V
*/
#define cuddV(node) ((node)->type.value)
/**
@brief Finds the current position of variable index in the
order.
@details This macro duplicates the functionality of Cudd_ReadPerm,
but it does not check for out-of-bounds indices and it is more
efficient.
@sideeffect none
@see Cudd_ReadPerm
*/
#define cuddI(dd,index) (((index)==CUDD_CONST_INDEX)?(int)(index):(dd)->perm[(index)])
/**
@brief Finds the current position of %ZDD variable index in the
order.
@details This macro duplicates the functionality of
Cudd_ReadPermZdd, but it does not check for out-of-bounds indices
and it is more efficient.
@sideeffect none
@see Cudd_ReadPermZdd
*/
#define cuddIZ(dd,index) (((index)==CUDD_CONST_INDEX)?(int)(index):(dd)->permZ[(index)])
/**
@brief Hash function for the unique table.
@details
@sideeffect none
@see ddCHash ddCHash2
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define ddHash(f,g,s) \
((((unsigned)(ptruint)(f) * DD_P1 + \
(unsigned)(ptruint)(g)) * DD_P2) >> (s))
#else
#define ddHash(f,g,s) \
((((unsigned)(f) * DD_P1 + (unsigned)(g)) * DD_P2) >> (s))
#endif
/**
@brief Hash function for the cache.
@sideeffect none
@see ddHash ddCHash2
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define ddCHash(o,f,g,h,s) \
((((((unsigned)(ptruint)(f) + (unsigned)(ptruint)(o)) * DD_P1 + \
(unsigned)(ptruint)(g)) * DD_P2 + \
(unsigned)(ptruint)(h)) * DD_P3) >> (s))
#else
#define ddCHash(o,f,g,h,s) \
((((((unsigned)(f) + (unsigned)(o)) * DD_P1 + (unsigned)(g)) * DD_P2 + \
(unsigned)(h)) * DD_P3) >> (s))
#endif
/**
@brief Hash function for the cache for functions with two operands.
@sideeffect none
@see ddHash ddCHash
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define ddCHash2(o,f,g,s) \
(((((unsigned)(ptruint)(f) + (unsigned)(ptruint)(o)) * DD_P1 + \
(unsigned)(ptruint)(g)) * DD_P2) >> (s))
#else
#define ddCHash2(o,f,g,s) \
(((((unsigned)(f) + (unsigned)(o)) * DD_P1 + (unsigned)(g)) * DD_P2) >> (s))
#endif
/**
@brief Clears the 4 least significant bits of a pointer.
@sideeffect none
*/
#define cuddClean(p) ((DdNode *)((ptruint)(p) & ~ (ptruint) 0xf))
/**
@brief Computes the minimum of two numbers.
@sideeffect none
@see ddMax
*/
#define ddMin(x,y) (((y) < (x)) ? (y) : (x))
/**
@brief Computes the maximum of two numbers.
@sideeffect none
@see ddMin
*/
#define ddMax(x,y) (((y) > (x)) ? (y) : (x))
/**
@brief Computes the absolute value of a number.
@sideeffect none
*/
#define ddAbs(x) (((x)<0) ? -(x) : (x))
/**
@brief Returns 1 if the absolute value of the difference of the two
arguments x and y is less than e.
@sideeffect none
*/
#define ddEqualVal(x,y,e) (ddAbs((x)-(y))<(e))
/**
@brief Saturating increment operator.
@details Saturation is only necessary on 32-bit machines, where the
reference count is only 16-bit wide.
@sideeffect none
@see cuddSatDec
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define cuddSatInc(x) ((x)++)
#else
#define cuddSatInc(x) ((x) += (x) != (DdHalfWord)DD_MAXREF)
#endif
/**
@brief Saturating decrement operator.
@details Saturation is only necessary on 32-bit machines, where the
reference count is only 16-bit wide.
@sideeffect none
@see cuddSatInc
*/
#if SIZEOF_VOID_P == 8 && SIZEOF_INT == 4
#define cuddSatDec(x) ((x)--)
#else
#define cuddSatDec(x) ((x) -= (x) != (DdHalfWord)DD_MAXREF)
#endif
/**
@brief Returns the constant 1 node.
@sideeffect none
@see DD_ZERO DD_PLUS_INFINITY DD_MINUS_INFINITY
*/
#define DD_ONE(dd) ((dd)->one)
/**
@brief Returns the arithmetic 0 constant node.
@details This is different from the logical zero. The latter is
obtained by Cudd_Not(DD_ONE(dd)).
@sideeffect none
@see DD_ONE Cudd_Not DD_PLUS_INFINITY DD_MINUS_INFINITY
*/
#define DD_ZERO(dd) ((dd)->zero)
/**
@brief Returns the plus infinity constant node.
@sideeffect none
@see DD_ONE DD_ZERO DD_MINUS_INFINITY
*/
#define DD_PLUS_INFINITY(dd) ((dd)->plusinfinity)
/**
@brief Returns the minus infinity constant node.
@sideeffect none
@see DD_ONE DD_ZERO DD_PLUS_INFINITY
*/
#define DD_MINUS_INFINITY(dd) ((dd)->minusinfinity)
/**
@brief Enforces DD_MINUS_INF_VAL <= x <= DD_PLUS_INF_VAL.
@details Furthermore, if x <= DD_MINUS_INF_VAL/2, x is set to
DD_MINUS_INF_VAL. Similarly, if DD_PLUS_INF_VAL/2 <= x, x is set to
DD_PLUS_INF_VAL. Normally this macro is a NOOP. However, if
HAVE_IEEE_754 is not defined, it makes sure that a value does not
get larger than infinity in absolute value, and once it gets to
infinity, stays there. If the value overflows before this macro is
applied, no recovery is possible.
@sideeffect none
*/
#ifdef HAVE_IEEE_754
#define cuddAdjust(x)
#else
#define cuddAdjust(x) ((x) = ((x) >= DD_CRI_HI_MARK) ? DD_PLUS_INF_VAL : (((x) <= DD_CRI_LO_MARK) ? DD_MINUS_INF_VAL : (x)))
#endif
/**
@brief Outputs a line of stats.
@details Outputs a line of stats if DD_COUNT and DD_STATS are
defined. Increments the number of recursive calls if DD_COUNT is
defined.
@sideeffect None
*/
#ifdef DD_COUNT
#ifdef DD_STATS
#define statLine(dd) \
do { \
(dd)->recursiveCalls++; \
if ((dd)->recursiveCalls == (dd)->nextSample) { \
(void) fprintf((dd)->err, \
"@%.0f: %u nodes %u live %.0f dropped" \
" %.0f reclaimed\n", \
(dd)->recursiveCalls, (dd)->keys, \
(dd)->keys - (dd)->dead, \
(dd)->nodesDropped, (dd)->reclaimed); \
(dd)->nextSample += 250000;} \
} while (0)
#else
#define statLine(dd) (dd)->recursiveCalls++
#endif
#else
#define statLine(dd)
#endif
/**
@brief Checks for termination or timeout.
*/
#define checkWhetherToGiveUp(dd) \
do { \
if (((int64_t) CUDD_CHECK_MASK & (int64_t) (dd)->cacheMisses) == 0) { \
if ((dd)->terminationCallback != NULL && \
(dd)->terminationCallback((dd)->tcbArg)) { \
(dd)->errorCode = CUDD_TERMINATION; \
return(NULL); \
} \
if (util_cpu_time() - (dd)->startTime > (dd)->timeLimit) { \
(dd)->errorCode = CUDD_TIMEOUT_EXPIRED; \
return(NULL); \
} \
} \
} while (0)
/** \cond */
/*---------------------------------------------------------------------------*/
/* Function prototypes */
/*---------------------------------------------------------------------------*/
#ifdef __cplusplus
extern "C" {
#endif
extern DdNode * cuddAddExistAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddUnivAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddOrAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddMinAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddMaxAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddFirstFilterRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddAddApplyRecur(DdManager *dd, DdNode * (*)(DdManager *, DdNode **, DdNode **), DdNode *f, DdNode *g);
extern DdNode * cuddAddMonadicApplyRecur(DdManager * dd, DdNode * (*op)(DdManager *, DdNode *), DdNode * f);
extern DdNode * cuddAddScalarInverseRecur(DdManager *dd, DdNode *f, DdNode *epsilon);
extern DdNode * cuddAddIteRecur(DdManager *dd, DdNode *f, DdNode *g, DdNode *h);
extern DdNode * cuddAddCmplRecur(DdManager *dd, DdNode *f);
extern DdNode * cuddAddNegateRecur(DdManager *dd, DdNode *f);
extern DdNode * cuddAddRoundOffRecur(DdManager *dd, DdNode *f, double trunc);
extern DdNode * cuddUnderApprox(DdManager *dd, DdNode *f, int numVars, int threshold, int safe, double quality);
extern DdNode * cuddRemapUnderApprox(DdManager *dd, DdNode *f, int numVars, int threshold, double quality);
extern DdNode * cuddBiasedUnderApprox(DdManager *dd, DdNode *f, DdNode *b, int numVars, int threshold, double quality1, double quality0);
extern DdNode * cuddBddAndAbstractRecur(DdManager *manager, DdNode *f, DdNode *g, DdNode *cube);
extern int cuddAnnealing(DdManager *table, int lower, int upper);
extern DdNode * cuddBddExistAbstractRecur(DdManager *manager, DdNode *f, DdNode *cube);
extern DdNode * cuddBddXorExistAbstractRecur(DdManager *manager, DdNode *f, DdNode *g, DdNode *cube);
extern DdNode * cuddBddBooleanDiffRecur(DdManager *manager, DdNode *f, DdNode *var);
extern DdNode * cuddBddIteRecur(DdManager *dd, DdNode *f, DdNode *g, DdNode *h);
extern DdNode * cuddBddIntersectRecur(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddBddAndRecur(DdManager *manager, DdNode *f, DdNode *g);
extern DdNode * cuddBddXorRecur(DdManager *manager, DdNode *f, DdNode *g);
extern DdNode * cuddBddTransfer(DdManager *ddS, DdManager *ddD, DdNode *f);
extern DdNode * cuddAddBddDoPattern(DdManager *dd, DdNode *f);
extern int cuddInitCache(DdManager *unique, unsigned int cacheSize, unsigned int maxCacheSize);
extern void cuddCacheInsert(DdManager *table, ptruint op, DdNode *f, DdNode *g, DdNode *h, DdNode *data);
extern void cuddCacheInsert2(DdManager *table, DdNode * (*)(DdManager *, DdNode *, DdNode *), DdNode *f, DdNode *g, DdNode *data);
extern void cuddCacheInsert1(DdManager *table, DdNode * (*)(DdManager *, DdNode *), DdNode *f, DdNode *data);
extern DdNode * cuddCacheLookup(DdManager *table, ptruint op, DdNode *f, DdNode *g, DdNode *h);
extern DdNode * cuddCacheLookupZdd(DdManager *table, ptruint op, DdNode *f, DdNode *g, DdNode *h);
extern DdNode * cuddCacheLookup2(DdManager *table, DdNode * (*)(DdManager *, DdNode *, DdNode *), DdNode *f, DdNode *g);
extern DdNode * cuddCacheLookup1(DdManager *table, DdNode * (*)(DdManager *, DdNode *), DdNode *f);
extern DdNode * cuddCacheLookup2Zdd(DdManager *table, DdNode * (*)(DdManager *, DdNode *, DdNode *), DdNode *f, DdNode *g);
extern DdNode * cuddCacheLookup1Zdd(DdManager *table, DdNode * (*)(DdManager *, DdNode *), DdNode *f);
extern DdNode * cuddConstantLookup(DdManager *table, ptruint op, DdNode *f, DdNode *g, DdNode *h);
extern int cuddCacheProfile(DdManager *table, FILE *fp);
extern void cuddCacheResize(DdManager *table);
extern void cuddCacheFlush(DdManager *table);
extern int cuddComputeFloorLog2(unsigned int value);
extern int cuddHeapProfile(DdManager *dd);
extern void cuddPrintNode(DdNode *f, FILE *fp);
extern void cuddPrintVarGroups(DdManager * dd, MtrNode * root, int zdd, int silent);
extern DdNode * cuddBddClippingAnd(DdManager *dd, DdNode *f, DdNode *g, int maxDepth, int direction);
extern DdNode * cuddBddClippingAndAbstract(DdManager *dd, DdNode *f, DdNode *g, DdNode *cube, int maxDepth, int direction);
extern void cuddGetBranches(DdNode *g, DdNode **g1, DdNode **g0);
extern DdNode * cuddCofactorRecur(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddBddComposeRecur(DdManager *dd, DdNode *f, DdNode *g, DdNode *proj);
extern DdNode * cuddAddComposeRecur(DdManager *dd, DdNode *f, DdNode *g, DdNode *proj);
extern int cuddExact(DdManager *table, int lower, int upper);
extern DdNode * cuddBddConstrainRecur(DdManager *dd, DdNode *f, DdNode *c);
extern DdNode * cuddBddRestrictRecur(DdManager *dd, DdNode *f, DdNode *c);
extern DdNode * cuddBddNPAndRecur(DdManager *dd, DdNode *f, DdNode *c);
extern DdNode * cuddAddConstrainRecur(DdManager *dd, DdNode *f, DdNode *c);
extern DdNode * cuddAddRestrictRecur(DdManager *dd, DdNode *f, DdNode *c);
extern DdNode * cuddBddLICompaction(DdManager *dd, DdNode *f, DdNode *c);
extern int cuddGa(DdManager *table, int lower, int upper);
extern int cuddTreeSifting(DdManager *table, Cudd_ReorderingType method);
extern int cuddZddInitUniv(DdManager *zdd);
extern void cuddZddFreeUniv(DdManager *zdd);
extern void cuddSetInteract(DdManager *table, int x, int y);
extern int cuddTestInteract(DdManager *table, int x, int y);
extern int cuddInitInteract(DdManager *table);
extern DdLocalCache * cuddLocalCacheInit(DdManager *manager, unsigned int keySize, unsigned int cacheSize, unsigned int maxCacheSize);
extern void cuddLocalCacheQuit(DdLocalCache *cache);
extern void cuddLocalCacheInsert(DdLocalCache *cache, DdNodePtr *key, DdNode *value);
extern DdNode * cuddLocalCacheLookup(DdLocalCache *cache, DdNodePtr *key);
extern void cuddLocalCacheClearDead(DdManager *manager);
extern int cuddIsInDeathRow(DdManager *dd, DdNode *f);
extern int cuddTimesInDeathRow(DdManager *dd, DdNode *f);
extern void cuddLocalCacheClearAll(DdManager *manager);
#ifdef DD_CACHE_PROFILE
extern int cuddLocalCacheProfile(DdLocalCache *cache);
#endif
extern DdHashTable * cuddHashTableInit(DdManager *manager, unsigned int keySize, unsigned int initSize);
extern void cuddHashTableQuit(DdHashTable *hash);
extern void cuddHashTableGenericQuit(DdHashTable *hash);
extern int cuddHashTableInsert(DdHashTable *hash, DdNodePtr *key, DdNode *value, ptrint count);
extern DdNode * cuddHashTableLookup(DdHashTable *hash, DdNodePtr *key);
extern int cuddHashTableInsert1(DdHashTable *hash, DdNode *f, DdNode *value, ptrint count);
extern DdNode * cuddHashTableLookup1(DdHashTable *hash, DdNode *f);
extern int cuddHashTableInsert2(DdHashTable *hash, DdNode *f, DdNode *g, DdNode *value, ptrint count);
extern DdNode * cuddHashTableLookup2(DdHashTable *hash, DdNode *f, DdNode *g);
extern int cuddHashTableInsert3(DdHashTable *hash, DdNode *f, DdNode *g, DdNode *h, DdNode *value, ptrint count);
extern DdNode * cuddHashTableLookup3(DdHashTable *hash, DdNode *f, DdNode *g, DdNode *h);
extern int cuddHashTableGenericInsert(DdHashTable * hash, DdNode * f, void * value);
extern void * cuddHashTableGenericLookup(DdHashTable * hash, DdNode * f);
extern DdLevelQueue * cuddLevelQueueInit(int levels, int itemSize, int numBuckets, DdManager * manager);
extern void cuddLevelQueueQuit(DdLevelQueue *queue);
extern void * cuddLevelQueueFirst(DdLevelQueue * queue, void * key, int level);
extern void * cuddLevelQueueEnqueue(DdLevelQueue *queue, void *key, int level);
extern void cuddLevelQueueDequeue(DdLevelQueue *queue, int level);
extern int cuddLinearAndSifting(DdManager *table, int lower, int upper);
extern int cuddLinearInPlace(DdManager * table, int x, int y);
extern void cuddUpdateInteractionMatrix(DdManager * table, int xindex, int yindex);
extern int cuddInitLinear(DdManager *table);
extern int cuddResizeLinear(DdManager *table);
extern DdNode * cuddBddLiteralSetIntersectionRecur(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddCProjectionRecur(DdManager *dd, DdNode *R, DdNode *Y, DdNode *Ysupp);
extern DdNode * cuddBddClosestCube(DdManager *dd, DdNode *f, DdNode *g, CUDD_VALUE_TYPE bound);
extern void cuddReclaim(DdManager *table, DdNode *n);
extern void cuddReclaimZdd(DdManager *table, DdNode *n);
extern void cuddClearDeathRow(DdManager *table);
extern void cuddShrinkDeathRow(DdManager *table);
extern DdNode * cuddDynamicAllocNode(DdManager *table);
extern int cuddSifting(DdManager *table, int lower, int upper);
extern int cuddSwapping(DdManager *table, int lower, int upper, Cudd_ReorderingType heuristic);
extern int cuddNextHigh(DdManager *table, int x);
extern int cuddNextLow(DdManager *table, int x);
extern int cuddSwapInPlace(DdManager *table, int x, int y);
extern int cuddBddAlignToZdd(DdManager *table);
extern DdNode * cuddBddMakePrime(DdManager *dd, DdNode *cube, DdNode *f);
extern DdNode * cuddSolveEqnRecur(DdManager *bdd, DdNode *F, DdNode *Y, DdNode **G, int n, int *yIndex, int i);
extern DdNode * cuddVerifySol(DdManager *bdd, DdNode *F, DdNode **G, int *yIndex, int n);
#ifdef ST_H_
extern DdNode* cuddSplitSetRecur(DdManager *manager, st_table *mtable, int *varSeen, DdNode *p, double n, double max, int index);
#endif
extern DdNode * cuddSubsetHeavyBranch(DdManager *dd, DdNode *f, int numVars, int threshold);
extern DdNode * cuddSubsetShortPaths(DdManager *dd, DdNode *f, int numVars, int threshold, int hardlimit);
extern int cuddSymmCheck(DdManager *table, int x, int y);
extern int cuddSymmSifting(DdManager *table, int lower, int upper);
extern int cuddSymmSiftingConv(DdManager *table, int lower, int upper);
extern DdNode * cuddAllocNode(DdManager *unique);
extern DdManager * cuddInitTable(unsigned int numVars, unsigned int numVarsZ, unsigned int numSlots, unsigned int looseUpTo);
extern void cuddFreeTable(DdManager *unique);
extern int cuddGarbageCollect(DdManager *unique, int clearCache);
extern DdNode * cuddZddGetNode(DdManager *zdd, int id, DdNode *T, DdNode *E);
extern DdNode * cuddZddGetNodeIVO(DdManager *dd, int index, DdNode *g, DdNode *h);
extern DdNode * cuddUniqueInter(DdManager *unique, int index, DdNode *T, DdNode *E);
extern DdNode * cuddUniqueInterIVO(DdManager *unique, int index, DdNode *T, DdNode *E);
extern DdNode * cuddUniqueInterZdd(DdManager *unique, int index, DdNode *T, DdNode *E);
extern DdNode * cuddUniqueConst(DdManager *unique, CUDD_VALUE_TYPE value);
extern void cuddRehash(DdManager *unique, int i);
extern void cuddShrinkSubtable(DdManager *unique, int i);
extern int cuddInsertSubtables(DdManager *unique, int n, int level);
extern int cuddDestroySubtables(DdManager *unique, int n);
extern int cuddResizeTableZdd(DdManager *unique, int index);
extern void cuddSlowTableGrowth(DdManager *unique);
extern int cuddP(DdManager *dd, DdNode *f);
#ifdef ST_H_
extern enum st_retval cuddStCountfree(void *key, void *value, void *arg);
extern int cuddCollectNodes(DdNode *f, st_table *visited);
#endif
extern DdNodePtr * cuddNodeArray(DdNode *f, int *n);
extern int cuddWindowReorder(DdManager *table, int low, int high, Cudd_ReorderingType submethod);
extern DdNode * cuddZddProduct(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddZddUnateProduct(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddZddWeakDiv(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddZddWeakDivF(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddZddDivide(DdManager *dd, DdNode *f, DdNode *g);
extern DdNode * cuddZddDivideF(DdManager *dd, DdNode *f, DdNode *g);
extern int cuddZddGetCofactors3(DdManager *dd, DdNode *f, int v, DdNode **f1, DdNode **f0, DdNode **fd);
extern int cuddZddGetCofactors2(DdManager *dd, DdNode *f, int v, DdNode **f1, DdNode **f0);
extern DdNode * cuddZddComplement(DdManager *dd, DdNode *node);
extern int cuddZddGetPosVarIndex(DdManager * dd, int index);
extern int cuddZddGetNegVarIndex(DdManager * dd, int index);
extern int cuddZddGetPosVarLevel(DdManager * dd, int index);
extern int cuddZddGetNegVarLevel(DdManager * dd, int index);
extern int cuddZddTreeSifting(DdManager *table, Cudd_ReorderingType method);
extern DdNode * cuddZddIsop(DdManager *dd, DdNode *L, DdNode *U, DdNode **zdd_I);
extern DdNode * cuddBddIsop(DdManager *dd, DdNode *L, DdNode *U);
extern DdNode * cuddMakeBddFromZddCover(DdManager *dd, DdNode *node);
extern int cuddZddLinearSifting(DdManager *table, int lower, int upper);
extern int cuddZddAlignToBdd(DdManager *table);
extern int cuddZddNextHigh(DdManager *table, int x);
extern int cuddZddNextLow(DdManager *table, int x);
extern int cuddZddUniqueCompare(void const *ptr_x, void const *ptr_y);
extern int cuddZddSwapInPlace(DdManager *table, int x, int y);
extern int cuddZddSwapping(DdManager *table, int lower, int upper, Cudd_ReorderingType heuristic);
extern int cuddZddSifting(DdManager *table, int lower, int upper);
extern DdNode * cuddZddIte(DdManager *dd, DdNode *f, DdNode *g, DdNode *h);
extern DdNode * cuddZddUnion(DdManager *zdd, DdNode *P, DdNode *Q);
extern DdNode * cuddZddIntersect(DdManager *zdd, DdNode *P, DdNode *Q);
extern DdNode * cuddZddDiff(DdManager *zdd, DdNode *P, DdNode *Q);
extern DdNode * cuddZddChangeAux(DdManager *zdd, DdNode *P, DdNode *zvar);
extern DdNode * cuddZddSubset1(DdManager *dd, DdNode *P, int var);
extern DdNode * cuddZddSubset0(DdManager *dd, DdNode *P, int var);
extern DdNode * cuddZddChange(DdManager *dd, DdNode *P, int var);
extern int cuddZddSymmCheck(DdManager *table, int x, int y);
extern int cuddZddSymmSifting(DdManager *table, int lower, int upper);
extern int cuddZddSymmSiftingConv(DdManager *table, int lower, int upper);
extern int cuddZddP(DdManager *zdd, DdNode *f);
#ifdef __cplusplus
} /* end of extern "C" */
#endif
/** \endcond */
#endif /* CUDD_INT_H_ */
| 37.850758 | 137 | 0.673498 |
1904fa05cc8ca38ae7ef77d969bacd1ad9386d24 | 1,082 | h | C | Extend/DotNetBridge/DotNetBridge.h | paintdream/paintsnow | 3a1cbc9e571eaa2e62a3a2d60f75817b45f0c781 | [
"MIT"
] | null | null | null | Extend/DotNetBridge/DotNetBridge.h | paintdream/paintsnow | 3a1cbc9e571eaa2e62a3a2d60f75817b45f0c781 | [
"MIT"
] | null | null | null | Extend/DotNetBridge/DotNetBridge.h | paintdream/paintsnow | 3a1cbc9e571eaa2e62a3a2d60f75817b45f0c781 | [
"MIT"
] | null | null | null | #pragma once
using namespace System;
#include "../../Source/Core/Interface/IScript.h"
namespace DotNetBridge {
ref class LeavesBridge;
public ref class ScriptReference
{
private:
size_t handle;
LeavesBridge^ bridge;
public:
ScriptReference(LeavesBridge^ bridge, size_t h);
~ScriptReference();
property bool Valid { bool get() { return handle != 0; } };
property size_t Handle { size_t get() { return handle; } };
int AsInteger();
double AsDouble();
float AsFloat();
System::IntPtr AsHandle();
System::String^ AsString();
Object^ AsObject();
Object^ Call(... array<Object^>^ args);
};
public ref class LeavesBridge
{
public:
LeavesBridge();
public:
array<Type^>^ emptyTypeArray;
public:
void Initialize(PaintsNow::IScript::Request& request);
void Uninitialize(PaintsNow::IScript::Request& request);
UIntPtr GetScriptHandle();
ScriptReference^ GetGlobal(System::String^ name);
ScriptReference^ Load(System::String^ code);
PaintsNow::IScript* script = nullptr;
PaintsNow::IScript::RequestPool* requestPool = nullptr;
};
}
| 23.021277 | 61 | 0.708872 |
c5e5b87a13cfd5981469e5d7e750a64da85b05f6 | 2,236 | h | C | Model2CoxlLoader/TerrainDataSaver/Structures.h | KyleBCox/Direct3d12-Engine | eab9791bdb00a2ff3103e6b83c1c8a2ccb280241 | [
"MIT"
] | 11 | 2018-04-14T12:10:19.000Z | 2020-12-31T08:58:47.000Z | Model2CoxlLoader/TerrainDataSaver/Structures.h | KyleBCox/Direct3d-12-Engine- | eab9791bdb00a2ff3103e6b83c1c8a2ccb280241 | [
"MIT"
] | null | null | null | Model2CoxlLoader/TerrainDataSaver/Structures.h | KyleBCox/Direct3d-12-Engine- | eab9791bdb00a2ff3103e6b83c1c8a2ccb280241 | [
"MIT"
] | 3 | 2019-01-29T14:03:59.000Z | 2019-10-09T13:21:31.000Z | #pragma once
#include "stdafx.h"
#include <vector>
#include <map>
#include <assimp/mesh.h>
using namespace DirectX;
namespace Structures
{
struct AnimFrameBone
{
std::string name;
DirectX::XMFLOAT4X4 MATRIX;
int index;
};
struct AnimTransforms {
XMVECTOR pos;
XMVECTOR rot;
XMVECTOR scale;
};
struct AnimBone
{
std::string name;
std::vector<XMMATRIX> transforms;
std::vector<float> times;
std::vector<XMMATRIX> mappedTransforms;
std::vector<XMMATRIX> finalTransforms = std::vector<XMMATRIX>();
XMMATRIX offsetMatrix;
XMMATRIX mtrans;
XMMATRIX toRoot;
};
struct assimpVertexWeight {
unsigned int mVertexId;
float mWeight;
};
struct assimpBone {
std::string mName;
unsigned int mNumWeights;
std::vector<assimpVertexWeight> mWeights;
};
struct Animation
{
std::vector<AnimBone> bonesWithKeys;
UINT frameCount;
std::vector<assimpBone> bones;
int numBones;
};
struct Bone
{
UINT boneIndex;
float weight;
};
struct VertexTexCoordNormalBones
{
DirectX::XMFLOAT3 pos;
DirectX::XMFLOAT2 texCoord;
DirectX::XMFLOAT3 normal;
std::vector<Bone> bones;
};
struct VertexTexCoordNormal
{
DirectX::XMFLOAT3 pos;
DirectX::XMFLOAT2 texCoord;
DirectX::XMFLOAT3 normal;
XMFLOAT4 weights1;
XMFLOAT4 weights2;
XMFLOAT4 bones1;
XMFLOAT4 bones2;
int isAnimated;
};
struct AnimationForExport {
std::vector<std::vector<std::vector<XMMATRIX>>> perBoneAnims;
};
struct VerticesIndices
{
std::shared_ptr<std::vector<VertexTexCoordNormal>> vertices;
std::shared_ptr<std::vector<unsigned long>> indices;
std::shared_ptr<Structures::AnimationForExport> animations;
};
struct ShaderData
{
byte* shader;
UINT size;
};
struct ModelViewProjectionConstantBuffer
{
DirectX::XMFLOAT4X4 model;
DirectX::XMFLOAT4X4 view;
DirectX::XMFLOAT4X4 projection;
};
struct HeightMapInfo { // Heightmap structure
int terrainWidth; // Width of heightmap
int terrainHeight; // Height (Length) of heightmap
XMFLOAT3* heightMap; // Array to store terrain's vertex positions
};
struct VertexThreadParemeter {
aiMesh* mesh;
UINT vertexStart;
UINT vertexEnd;
std::vector<Structures::VertexTexCoordNormalBones> vertices;
};
}
| 21.5 | 70 | 0.725403 |
65b9f3e22e4ac7336fba7c61cdc5bad5faa2e3c4 | 1,249 | h | C | one/arcus/internal/accumulator.h | i3D-net/ONE-GameHosting-SDK | 060473173136b2c8d9bc43aaad0eb487870dc115 | [
"BSD-3-Clause"
] | 6 | 2020-07-03T09:18:04.000Z | 2021-01-07T17:50:06.000Z | one/arcus/internal/accumulator.h | i3D-net/ONE-GameHosting-SDK | 060473173136b2c8d9bc43aaad0eb487870dc115 | [
"BSD-3-Clause"
] | null | null | null | one/arcus/internal/accumulator.h | i3D-net/ONE-GameHosting-SDK | 060473173136b2c8d9bc43aaad0eb487870dc115 | [
"BSD-3-Clause"
] | null | null | null | #pragma once
#include <stddef.h>
namespace i3d {
namespace one {
// Accumulator is fixed-size buffer for accumulating byte data.
// It adds new data to the end, and removes data from the front.
class Accumulator final {
public:
Accumulator(size_t capacity);
~Accumulator();
size_t capacity() const {
return _capacity;
}
size_t size() const {
return _size;
}
void clear() {
trim(size());
};
// Copies the given data and adds it to the stream. length must be less than
// or equal to capacity - size.
void put(const void *data, size_t length);
// Provides a pointer to data from the beginning of the stream. Sets the
// given data pointer to the data. length must be <= size.
void peek(size_t length, void **data);
// Drops the number of given bytes from the beginning of the stream, freeing
// capacity at the end. length must be less than size.
void trim(size_t length);
// Get is a util equivalent to peek + trim.
void get(size_t length, void **data);
private:
Accumulator() = delete;
Accumulator(Accumulator &other) = delete;
char *_buffer;
size_t _capacity;
size_t _size;
};
} // namespace one
} // namespace i3d | 24.490196 | 80 | 0.654123 |
a9410b554f16c99c3f2b90acb94fea24f81866d3 | 1,967 | h | C | Modules/clinic/_lsprof.c.h | Krrishdhaneja/cpython | 9ae9ad8ba35cdcece7ded73cd2207e4f8cb85578 | [
"0BSD"
] | 1 | 2020-10-25T16:33:22.000Z | 2020-10-25T16:33:22.000Z | Modules/clinic/_lsprof.c.h | Krrishdhaneja/cpython | 9ae9ad8ba35cdcece7ded73cd2207e4f8cb85578 | [
"0BSD"
] | null | null | null | Modules/clinic/_lsprof.c.h | Krrishdhaneja/cpython | 9ae9ad8ba35cdcece7ded73cd2207e4f8cb85578 | [
"0BSD"
] | null | null | null | /*[clinic input]
preserve
[clinic start generated code]*/
PyDoc_STRVAR(_lsprof_Profiler_getstats__doc__,
"getstats($self, /)\n"
"--\n"
"\n"
"list of profiler_entry objects.\n"
"\n"
"getstats() -> list of profiler_entry objects\n"
"\n"
"Return all information collected by the profiler.\n"
"Each profiler_entry is a tuple-like object with the\n"
"following attributes:\n"
"\n"
" code code object\n"
" callcount how many times this was called\n"
" reccallcount how many times called recursively\n"
" totaltime total time in this entry\n"
" inlinetime inline time in this entry (not in subcalls)\n"
" calls details of the calls\n"
"\n"
"The calls attribute is either None or a list of\n"
"profiler_subentry objects:\n"
"\n"
" code called code object\n"
" callcount how many times this is called\n"
" reccallcount how many times this is called recursively\n"
" totaltime total time spent in this call\n"
" inlinetime inline time (not in further subcalls)");
#define _LSPROF_PROFILER_GETSTATS_METHODDEF \
{"getstats", (PyCFunction)(void(*)(void))_lsprof_Profiler_getstats, METH_METHOD|METH_FASTCALL|METH_KEYWORDS, _lsprof_Profiler_getstats__doc__},
static PyObject *
_lsprof_Profiler_getstats_impl(ProfilerObject *self, PyTypeObject *cls);
static PyObject *
_lsprof_Profiler_getstats(ProfilerObject *self, PyTypeObject *cls, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames)
{
PyObject *return_value = NULL;
static const char * const _keywords[] = { NULL};
static _PyArg_Parser _parser = {":getstats", _keywords, 0};
if (!_PyArg_ParseStackAndKeywords(args, nargs, kwnames, &_parser
)) {
goto exit;
}
return_value = _lsprof_Profiler_getstats_impl(self, cls);
exit:
return return_value;
}
/*[clinic end generated code: output=b4727cfebecdd22d input=a9049054013a1b77]*/
| 35.125 | 148 | 0.69395 |
457fb9ecd073ac7a2249a23c985bf331e77307c1 | 1,976 | h | C | cabocha-0.69/src/string_buffer.h | ymmt1089/morph | 9f6e957c8b293c9cc288dbc80adad14e651d1641 | [
"Unlicense"
] | null | null | null | cabocha-0.69/src/string_buffer.h | ymmt1089/morph | 9f6e957c8b293c9cc288dbc80adad14e651d1641 | [
"Unlicense"
] | 23 | 2019-10-14T10:43:17.000Z | 2020-03-04T18:57:37.000Z | cabocha-0.69/src/string_buffer.h | yamamoto1089/morph | 9f6e957c8b293c9cc288dbc80adad14e651d1641 | [
"Unlicense"
] | null | null | null | // CaboCha -- Yet Another Japanese Dependency Parser
//
// $Id: string_buffer.h 41 2008-01-20 09:31:34Z taku-ku $;
//
// Copyright(C) 2001-2008 Taku Kudo <taku@chasen.org>
#ifndef CABOCHA_STRINGBUFFER_H_
#define CABOCHA_STRINGBUFFER_H_
#include <string>
#include "common.h"
#include "utils.h"
namespace CaboCha {
#define _ITOA(n) char fbuf[64]; itoa(n, fbuf); return this->write(fbuf);
#define _UITOA(n) char fbuf[64]; uitoa(n, fbuf); return this->write(fbuf);
#define _DTOA(n) char fbuf[64]; dtoa(n, fbuf); return this->write(fbuf);
class StringBuffer {
private:
size_t size_;
size_t alloc_size_;
char *ptr_;
bool is_delete_;
bool error_;
bool reserve(size_t size);
public:
explicit StringBuffer(): size_(0), alloc_size_(0),
ptr_(0), is_delete_(true), error_(false) {}
explicit StringBuffer(char *_s, size_t _l):
size_(0), alloc_size_(_l), ptr_(_s), is_delete_(false), error_(false) {}
virtual ~StringBuffer();
StringBuffer& write(char);
StringBuffer& write(const char*, size_t);
StringBuffer& write(const char* );
StringBuffer& operator<< (double n) { _DTOA(n); }
StringBuffer& operator<< (short int n) { _ITOA(n); }
StringBuffer& operator<< (int n) { _ITOA(n); }
StringBuffer& operator<< (long int n) { _ITOA(n); }
StringBuffer& operator<< (unsigned short int n) { _UITOA(n); }
StringBuffer& operator<< (unsigned int n) { _UITOA(n); }
StringBuffer& operator<< (unsigned long int n) { _UITOA(n); }
StringBuffer& operator<< (char n) { return this->write(n); }
StringBuffer& operator<< (unsigned char n) { return this->write(n); }
StringBuffer& operator<< (const char* n) { return this->write(n); }
StringBuffer& operator<< (const std::string& n) { return this->write(n.c_str()); }
void clear() { size_ = 0; }
const char *str() { return error_ ? 0 : const_cast<const char*> (ptr_); }
};
}
#endif
| 35.285714 | 84 | 0.640182 |
ca634fdb60f7aa793f3a8cbfbed661721c9a88cc | 330 | h | C | JWStudyRealm/JWStudyRealmOC/JWStudyRealmOC/JWStudyRealmOC/Classes/Account/JWLoginController.h | junwangInChina/JWStudyNotes | 3eb1fd0d62998b067af3ee5836f18b49eef72293 | [
"MIT"
] | null | null | null | JWStudyRealm/JWStudyRealmOC/JWStudyRealmOC/JWStudyRealmOC/Classes/Account/JWLoginController.h | junwangInChina/JWStudyNotes | 3eb1fd0d62998b067af3ee5836f18b49eef72293 | [
"MIT"
] | null | null | null | JWStudyRealm/JWStudyRealmOC/JWStudyRealmOC/JWStudyRealmOC/Classes/Account/JWLoginController.h | junwangInChina/JWStudyNotes | 3eb1fd0d62998b067af3ee5836f18b49eef72293 | [
"MIT"
] | null | null | null | //
// JWLoginController.h
// JWStudyRealmOC
//
// Created by wangjun on 16/8/18.
// Copyright © 2016年 wangjun. All rights reserved.
//
#import "JWBaseViewController.h"
typedef void(^LoginComplete)(BOOL success);
@interface JWLoginController : JWBaseViewController
@property (nonatomic, copy) LoginComplete complete;
@end
| 18.333333 | 51 | 0.745455 |
ecebf8a475de7596faa7dbd03e274beb9bae3d38 | 696 | h | C | NEChatroom-iOS-ObjC/NEChatroom-iOS-ObjC/Classes/Sections/Chatroom/View/NTESTextInputView/NTESTextInputView.h | Luc-netease/NEChatroom | 06f9d50e1696809ca4884d22e0249c156f2a01eb | [
"MIT"
] | 29 | 2020-10-20T09:05:50.000Z | 2021-03-17T11:25:18.000Z | NEChatroom-iOS-ObjC/NEChatroom-iOS-ObjC/Classes/Sections/Chatroom/View/NTESTextInputView/NTESTextInputView.h | Luc-netease/NEChatroom | 06f9d50e1696809ca4884d22e0249c156f2a01eb | [
"MIT"
] | 2 | 2021-04-01T08:50:55.000Z | 2021-12-28T07:55:51.000Z | NEChatroom-iOS-ObjC/NEChatroom-iOS-ObjC/Classes/Sections/Chatroom/View/NTESTextInputView/NTESTextInputView.h | Luc-netease/NEChatroom | 06f9d50e1696809ca4884d22e0249c156f2a01eb | [
"MIT"
] | 14 | 2020-08-31T06:09:13.000Z | 2021-02-23T09:27:13.000Z | //
// NTESTextInputView.h
// NIMLiveDemo
//
// Created by chris on 16/3/28.
// Copyright © 2016年 Netease. All rights reserved.
//
#import "NTESGrowingTextView.h"
typedef NS_ENUM(NSUInteger, NTESDisableType){
NTESDisableTypeMute = 0,
NTESDisableTypeMuteAll,
};
@protocol NTESTextInputViewDelegate <NSObject>
@optional
- (void)didSendText:(NSString *)text;
- (void)willChangeHeight:(CGFloat)height;
- (void)didChangeHeight:(CGFloat)height;
- (void)topDidChange:(CGFloat)offset;
@end
@interface NTESTextInputView : UIView
@property (nonatomic,assign) id<NTESTextInputViewDelegate> delegate;
- (void)setEnableMuteWithType:(NTESDisableType)type;
- (void)setDisableMute;
@end
| 17.846154 | 68 | 0.751437 |
10adae51bc4d1684db147eb20629d2619856dec2 | 232 | h | C | Example/CBZSplashView/Classes/CBZViewController.h | dank-1/CBZSplashView | 2b3b7d12380b6d191468632ed206ebf37b75d494 | [
"MIT"
] | 971 | 2015-01-02T12:01:46.000Z | 2021-11-07T20:17:53.000Z | Example/CBZSplashView/Classes/CBZViewController.h | rvi/CBZSplashView | e65f60cd69a23ddb274345cc45805b8f7afc077e | [
"MIT"
] | 8 | 2015-01-18T23:13:48.000Z | 2020-11-03T15:11:14.000Z | Example/CBZSplashView/Classes/CBZViewController.h | rvi/CBZSplashView | e65f60cd69a23ddb274345cc45805b8f7afc077e | [
"MIT"
] | 101 | 2015-01-04T02:57:32.000Z | 2021-04-08T08:19:33.000Z | //
// CBZViewController.h
// CBZSplashView
//
// Created by Callum Boddy on 07/22/2014.
// Copyright (c) 2014 Callum Boddy. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface CBZViewController : UIViewController
@end
| 16.571429 | 57 | 0.711207 |
2ec3bf115d28e85e088f47d2c47b6d3c3c1c4559 | 362 | h | C | firmware/Temperature/include/Terminal.h | hedrickbt/TempSensor | e2bbc0d85f8efddbc00893aa91724995a9f234c3 | [
"MIT"
] | null | null | null | firmware/Temperature/include/Terminal.h | hedrickbt/TempSensor | e2bbc0d85f8efddbc00893aa91724995a9f234c3 | [
"MIT"
] | null | null | null | firmware/Temperature/include/Terminal.h | hedrickbt/TempSensor | e2bbc0d85f8efddbc00893aa91724995a9f234c3 | [
"MIT"
] | null | null | null | ///////////////////////////////////////////////////////////////////////////////
/// \file Terminal.h
///
/// \author Ronald Sousa @Opticalworm
///////////////////////////////////////////////////////////////////////////////
#ifndef __TERMINAL_H__
#define __TERMINAL_H__
void Terminal_Init(void);
uint_fast8_t Terminal_Process(void);
#endif // __TERMINAL_H__
| 25.857143 | 79 | 0.422652 |
08f1a32f91cb09b2b0dc2d983560f75ab1cc3bf7 | 795 | h | C | svn_sensor/sensor/tension_test/trunk/tension_param.h | GliderWinchItems/embed | cc72aa7d8208db3871a15e38185e1e125fa7de47 | [
"MIT"
] | 1 | 2019-07-18T07:22:19.000Z | 2019-07-18T07:22:19.000Z | svn_sensor/sensor/tension_test/trunk/tension_param.h | GliderWinchItems/embed | cc72aa7d8208db3871a15e38185e1e125fa7de47 | [
"MIT"
] | null | null | null | svn_sensor/sensor/tension_test/trunk/tension_param.h | GliderWinchItems/embed | cc72aa7d8208db3871a15e38185e1e125fa7de47 | [
"MIT"
] | 2 | 2019-04-03T01:44:46.000Z | 2020-04-01T07:41:41.000Z | /******************************************************************************
* File Name : tension_param.h
* Date First Issued : 04/08/2015
* Board : f103
* Description : Initialize tension function struct with default values
*******************************************************************************/
#ifndef __TENSION_PARAM_Q
#define __TENSION_PARAM_Q
#include <stdint.h>
#include "common_misc.h"
#include "common_can.h"
#include "tension_function.h"
/* **************************************************************************************/
void tension_param_default_init(struct TENSIONLC* pten);
/* @brief : Initialize struct with default values
* ************************************************************************************** */
#endif
| 36.136364 | 92 | 0.410063 |
265cfd80f4cfb846d6e72b14673bc147a408375f | 2,542 | c | C | ext/phalcon/mvc/collection/managerinterface.zep.c | stokes-php/phalcon | b152cacdacedaa5c67798c800bb6eb99068c377b | [
"PHP-3.01",
"Zend-2.0",
"BSD-3-Clause"
] | 1 | 2018-01-19T10:37:17.000Z | 2018-01-19T10:37:17.000Z | ext/phalcon/mvc/collection/managerinterface.zep.c | stokes-php/phalcon | b152cacdacedaa5c67798c800bb6eb99068c377b | [
"PHP-3.01",
"Zend-2.0",
"BSD-3-Clause"
] | null | null | null | ext/phalcon/mvc/collection/managerinterface.zep.c | stokes-php/phalcon | b152cacdacedaa5c67798c800bb6eb99068c377b | [
"PHP-3.01",
"Zend-2.0",
"BSD-3-Clause"
] | 1 | 2018-01-19T10:37:17.000Z | 2018-01-19T10:37:17.000Z |
#ifdef HAVE_CONFIG_H
#include "../../../ext_config.h"
#endif
#include <php.h>
#include "../../../php_ext.h"
#include "../../../ext.h"
#include <Zend/zend_exceptions.h>
#include "kernel/main.h"
/**
* Phalcon\Mvc\Collection\Manager
*
* This components controls the initialization of models, keeping record of relations
* between the different models of the application.
*
* A CollectionManager is injected to a model via a Dependency Injector Container such as Phalcon\Di.
*
* <code>
* $di = new \Phalcon\Di();
*
* $di->set(
* "collectionManager",
* function() {
* return new \Phalcon\Mvc\Collection\Manager();
* }
* );
*
* $robot = new Robots(di);
* </code>
*/
ZEPHIR_INIT_CLASS(Phalcon_Mvc_Collection_ManagerInterface) {
ZEPHIR_REGISTER_INTERFACE(Phalcon\\Mvc\\Collection, ManagerInterface, phalcon, mvc_collection_managerinterface, phalcon_mvc_collection_managerinterface_method_entry);
return SUCCESS;
}
/**
* Sets a custom events manager for a specific model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, setCustomEventsManager);
/**
* Returns a custom events manager related to a model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, getCustomEventsManager);
/**
* Initializes a model in the models manager
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, initialize);
/**
* Check whether a model is already initialized
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, isInitialized);
/**
* Get the latest initialized model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, getLastInitialized);
/**
* Sets a connection service for a specific model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, setConnectionService);
/**
* Sets if a model must use implicit objects ids
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, useImplicitObjectIds);
/**
* Checks if a model is using implicit object ids
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, isUsingImplicitObjectIds);
/**
* Returns the connection related to a model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, getConnection);
/**
* Receives events generated in the models and dispatches them to an events-manager if available
* Notify the behaviors that are listening in the model
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, notifyEvent);
/**
* Binds a behavior to a collection
*/
ZEPHIR_DOC_METHOD(Phalcon_Mvc_Collection_ManagerInterface, addBehavior);
| 25.42 | 167 | 0.767506 |
b7f803051a34ceab7ca053527ac1ff275b3082aa | 7,882 | c | C | src/test/SDL_test_memory.c | slime73/SDL | b7885abc449250fc733a756239d670394d01fe62 | [
"Zlib"
] | 2,967 | 2021-01-20T08:21:50.000Z | 2022-03-31T21:04:30.000Z | love/src/jni/SDL2/src/test/SDL_test_memory.c | flamendless/love-android-extensions | 14bcd8ef92dadb82ae8de9de4015b018b5e7023e | [
"Apache-2.0"
] | 5,122 | 2021-02-10T21:56:28.000Z | 2022-03-31T23:05:15.000Z | love/src/jni/SDL2/src/test/SDL_test_memory.c | flamendless/love-android-extensions | 14bcd8ef92dadb82ae8de9de4015b018b5e7023e | [
"Apache-2.0"
] | 714 | 2021-02-01T16:59:20.000Z | 2022-03-30T19:14:13.000Z | /*
Simple DirectMedia Layer
Copyright (C) 1997-2021 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_config.h"
#include "SDL_assert.h"
#include "SDL_stdinc.h"
#include "SDL_log.h"
#include "SDL_test_crc32.h"
#include "SDL_test_memory.h"
#ifdef HAVE_LIBUNWIND_H
#define UNW_LOCAL_ONLY
#include <libunwind.h>
#endif
/* This is a simple tracking allocator to demonstrate the use of SDL's
memory allocation replacement functionality.
It gets slow with large numbers of allocations and shouldn't be used
for production code.
*/
typedef struct SDL_tracked_allocation
{
void *mem;
size_t size;
Uint64 stack[10];
char stack_names[10][256];
struct SDL_tracked_allocation *next;
} SDL_tracked_allocation;
static SDLTest_Crc32Context s_crc32_context;
static SDL_malloc_func SDL_malloc_orig = NULL;
static SDL_calloc_func SDL_calloc_orig = NULL;
static SDL_realloc_func SDL_realloc_orig = NULL;
static SDL_free_func SDL_free_orig = NULL;
static int s_previous_allocations = 0;
static SDL_tracked_allocation *s_tracked_allocations[256];
static unsigned int get_allocation_bucket(void *mem)
{
CrcUint32 crc_value;
unsigned int index;
SDLTest_Crc32Calc(&s_crc32_context, (CrcUint8 *)&mem, sizeof(mem), &crc_value);
index = (crc_value & (SDL_arraysize(s_tracked_allocations) - 1));
return index;
}
static SDL_bool SDL_IsAllocationTracked(void *mem)
{
SDL_tracked_allocation *entry;
int index = get_allocation_bucket(mem);
for (entry = s_tracked_allocations[index]; entry; entry = entry->next) {
if (mem == entry->mem) {
return SDL_TRUE;
}
}
return SDL_FALSE;
}
static void SDL_TrackAllocation(void *mem, size_t size)
{
SDL_tracked_allocation *entry;
int index = get_allocation_bucket(mem);
if (SDL_IsAllocationTracked(mem)) {
return;
}
entry = (SDL_tracked_allocation *)SDL_malloc_orig(sizeof(*entry));
if (!entry) {
return;
}
entry->mem = mem;
entry->size = size;
/* Generate the stack trace for the allocation */
SDL_zeroa(entry->stack);
#ifdef HAVE_LIBUNWIND_H
{
int stack_index;
unw_cursor_t cursor;
unw_context_t context;
unw_getcontext(&context);
unw_init_local(&cursor, &context);
stack_index = 0;
while (unw_step(&cursor) > 0) {
unw_word_t offset, pc;
char sym[236];
unw_get_reg(&cursor, UNW_REG_IP, &pc);
entry->stack[stack_index] = pc;
if (unw_get_proc_name(&cursor, sym, sizeof(sym), &offset) == 0) {
SDL_snprintf(entry->stack_names[stack_index], sizeof(entry->stack_names[stack_index]), "%s+0x%llx", sym, (unsigned long long)offset);
}
++stack_index;
if (stack_index == SDL_arraysize(entry->stack)) {
break;
}
}
}
#endif /* HAVE_LIBUNWIND_H */
entry->next = s_tracked_allocations[index];
s_tracked_allocations[index] = entry;
}
static void SDL_UntrackAllocation(void *mem)
{
SDL_tracked_allocation *entry, *prev;
int index = get_allocation_bucket(mem);
prev = NULL;
for (entry = s_tracked_allocations[index]; entry; entry = entry->next) {
if (mem == entry->mem) {
if (prev) {
prev->next = entry->next;
} else {
s_tracked_allocations[index] = entry->next;
}
SDL_free_orig(entry);
return;
}
prev = entry;
}
}
static void * SDLCALL SDLTest_TrackedMalloc(size_t size)
{
void *mem;
mem = SDL_malloc_orig(size);
if (mem) {
SDL_TrackAllocation(mem, size);
}
return mem;
}
static void * SDLCALL SDLTest_TrackedCalloc(size_t nmemb, size_t size)
{
void *mem;
mem = SDL_calloc_orig(nmemb, size);
if (mem) {
SDL_TrackAllocation(mem, nmemb * size);
}
return mem;
}
static void * SDLCALL SDLTest_TrackedRealloc(void *ptr, size_t size)
{
void *mem;
SDL_assert(!ptr || SDL_IsAllocationTracked(ptr));
mem = SDL_realloc_orig(ptr, size);
if (mem && mem != ptr) {
if (ptr) {
SDL_UntrackAllocation(ptr);
}
SDL_TrackAllocation(mem, size);
}
return mem;
}
static void SDLCALL SDLTest_TrackedFree(void *ptr)
{
if (!ptr) {
return;
}
if (!s_previous_allocations) {
SDL_assert(SDL_IsAllocationTracked(ptr));
}
SDL_UntrackAllocation(ptr);
SDL_free_orig(ptr);
}
int SDLTest_TrackAllocations()
{
if (SDL_malloc_orig) {
return 0;
}
SDLTest_Crc32Init(&s_crc32_context);
s_previous_allocations = SDL_GetNumAllocations();
if (s_previous_allocations != 0) {
SDL_Log("SDLTest_TrackAllocations(): There are %d previous allocations, disabling free() validation", s_previous_allocations);
}
SDL_GetMemoryFunctions(&SDL_malloc_orig,
&SDL_calloc_orig,
&SDL_realloc_orig,
&SDL_free_orig);
SDL_SetMemoryFunctions(SDLTest_TrackedMalloc,
SDLTest_TrackedCalloc,
SDLTest_TrackedRealloc,
SDLTest_TrackedFree);
return 0;
}
void SDLTest_LogAllocations()
{
char *message = NULL;
size_t message_size = 0;
char line[128], *tmp;
SDL_tracked_allocation *entry;
int index, count, stack_index;
Uint64 total_allocated;
if (!SDL_malloc_orig) {
return;
}
#define ADD_LINE() \
message_size += (SDL_strlen(line) + 1); \
tmp = (char *)SDL_realloc_orig(message, message_size); \
if (!tmp) { \
return; \
} \
message = tmp; \
SDL_strlcat(message, line, message_size)
SDL_strlcpy(line, "Memory allocations:\n", sizeof(line));
ADD_LINE();
SDL_strlcpy(line, "Expect 2 allocations from within SDL_GetErrBuf()\n", sizeof(line));
ADD_LINE();
count = 0;
total_allocated = 0;
for (index = 0; index < SDL_arraysize(s_tracked_allocations); ++index) {
for (entry = s_tracked_allocations[index]; entry; entry = entry->next) {
SDL_snprintf(line, sizeof(line), "Allocation %d: %d bytes\n", count, (int)entry->size);
ADD_LINE();
/* Start at stack index 1 to skip our tracking functions */
for (stack_index = 1; stack_index < SDL_arraysize(entry->stack); ++stack_index) {
if (!entry->stack[stack_index]) {
break;
}
SDL_snprintf(line, sizeof(line), "\t0x%"SDL_PRIx64": %s\n", entry->stack[stack_index], entry->stack_names[stack_index]);
ADD_LINE();
}
total_allocated += entry->size;
++count;
}
}
SDL_snprintf(line, sizeof(line), "Total: %.2f Kb in %d allocations\n", (float)total_allocated / 1024, count);
ADD_LINE();
#undef ADD_LINE
SDL_Log("%s", message);
}
/* vi: set ts=4 sw=4 expandtab: */
| 28.557971 | 149 | 0.639558 |
d3f75d1efdf517e583abdb6ac31ecdc439114850 | 586 | h | C | AgataEngine/Renderer/IndexBuffer.h | Prz-Ellam/AgataEngine | 3f4f7ad642ac1a8ceee97e8f02f22f792e009e23 | [
"ADSL"
] | null | null | null | AgataEngine/Renderer/IndexBuffer.h | Prz-Ellam/AgataEngine | 3f4f7ad642ac1a8ceee97e8f02f22f792e009e23 | [
"ADSL"
] | null | null | null | AgataEngine/Renderer/IndexBuffer.h | Prz-Ellam/AgataEngine | 3f4f7ad642ac1a8ceee97e8f02f22f792e009e23 | [
"ADSL"
] | null | null | null | #ifndef AGATA_INDEX_BUFFER_H
#define AGATA_INDEX_BUFFER_H
#include <stdint.h>
namespace Agata {
class IndexBuffer {
public:
IndexBuffer(const void* data, size_t size);
IndexBuffer(size_t size);
IndexBuffer(const IndexBuffer& other) = delete;
IndexBuffer(IndexBuffer&& other) noexcept;
IndexBuffer& operator=(const IndexBuffer& other) = delete;
IndexBuffer& operator=(IndexBuffer&& other) noexcept;
~IndexBuffer();
void bind() const;
void unbind() const;
void sendData(const void* data, size_t size, int64_t offset = 0);
private:
uint32_t m_ID;
};
}
#endif | 22.538462 | 67 | 0.735495 |
23216d84c61b58725e7a3ff54a7ecad013503500 | 1,266 | h | C | Artinx_ProfFan/bsp/include/bsp/imu.h | Sustech-Artinx/ArtinxRM | b08cc5bd86dc2ac1f6b2d1fa2d3c36436b5f78ff | [
"MIT"
] | null | null | null | Artinx_ProfFan/bsp/include/bsp/imu.h | Sustech-Artinx/ArtinxRM | b08cc5bd86dc2ac1f6b2d1fa2d3c36436b5f78ff | [
"MIT"
] | null | null | null | Artinx_ProfFan/bsp/include/bsp/imu.h | Sustech-Artinx/ArtinxRM | b08cc5bd86dc2ac1f6b2d1fa2d3c36436b5f78ff | [
"MIT"
] | null | null | null | //
// Created by Fan Jiang on 2017/5/2.
//
#ifndef CHASSIS_IMU_H
#define CHASSIS_IMU_H
#include <stdint.h>
#include "bsp/mpu6500.h"
#ifndef M_PI
#define M_PI 3.14159265358979323846f
#endif
#ifdef __cplusplus
extern "C" {
#endif
void StartIMUTask(void const *argument);
#ifdef __cplusplus
}
#endif
#define DEGREES_TO_RADIANS(angle) ((angle) * 0.0174532925f)
#ifdef __cplusplus
class AHRS {
public:
void
MadgwickQuaternionUpdate(float ax, float ay, float az, float gx, float gy, float gz, float mx, float my, float mz);
void MahonyAHRSUpdate(float gx, float gy, float gz,
bool useAcc, float ax, float ay, float az,
bool useMag, float mx, float my, float mz,
bool useYaw, float yawError);
void ComputeRotationMatrix(void);
void UpdateRPY();
AHRS();
uint64_t lastUpdate, currentUpdate;
float q[4] = {1.0f, 0.0f, 0.0f, 0.0f};
float rMat[3][3];
float dcm_kp = 1;
float dcm_ki = 0.0;
bool healthy = false;
float beta = 1.753340;
float roll = 0, pitch = 0, yaw = 0;
private:
float integralFBx = 0.0f, integralFBy = 0.0f, integralFBz = 0.0f; // integral error terms scaled by Ki
};
extern AHRS *ahrs;
extern MPU6500 *mpu;
#endif
#endif //CHASSIS_IMU_H
| 19.78125 | 117 | 0.661137 |
d6c914886a6e4fed3b1d663d3ad1e34b833dd1e9 | 587 | c | C | stmhal/systick.c | lurch/micropython | 28dfbc2ba2ef41a7810e4e39290031eb2207a0a9 | [
"MIT"
] | 1 | 2015-06-15T11:52:01.000Z | 2015-06-15T11:52:01.000Z | stmhal/systick.c | lurch/micropython | 28dfbc2ba2ef41a7810e4e39290031eb2207a0a9 | [
"MIT"
] | null | null | null | stmhal/systick.c | lurch/micropython | 28dfbc2ba2ef41a7810e4e39290031eb2207a0a9 | [
"MIT"
] | null | null | null | #include <stm32f4xx_hal.h>
#include "misc.h"
#include "systick.h"
bool sys_tick_has_passed(uint32_t start_tick, uint32_t delay_ms) {
return HAL_GetTick() - start_tick >= delay_ms;
}
// waits until at least delay_ms milliseconds have passed from the sampling of
// startTick. Handles overflow properly. Assumes stc was taken from
// HAL_GetTick() some time before calling this function.
void sys_tick_wait_at_least(uint32_t start_tick, uint32_t delay_ms) {
while (!sys_tick_has_passed(start_tick, delay_ms)) {
__WFI(); // enter sleep mode, waiting for interrupt
}
}
| 34.529412 | 78 | 0.752981 |
26b7a7468be61e61ce52626e39e6d4887379ef35 | 1,466 | h | C | src/utils/structs.h | ninocapipoca/Platal-Game-1 | dd62d9b78261ffa09cc61b9a78b1c96ae027c487 | [
"MIT"
] | null | null | null | src/utils/structs.h | ninocapipoca/Platal-Game-1 | dd62d9b78261ffa09cc61b9a78b1c96ae027c487 | [
"MIT"
] | null | null | null | src/utils/structs.h | ninocapipoca/Platal-Game-1 | dd62d9b78261ffa09cc61b9a78b1c96ae027c487 | [
"MIT"
] | null | null | null | #pragma once
#include "SDL2/SDL.h"
#include <string>
#include <vector>
struct Position {
int x, y;
bool operator<(const Position& other) const {
return ((x < other.x) && (y < other.y));
}
bool operator<=(const Position& other) const {
return ((x <= other.x) && (y <= other.y));
}
bool operator>(const Position& other) const {
return ((x > other.x) && (y > other.y));
}
bool operator>=(const Position& other) const {
return ((x >= other.x) && (y >= other.y));
}
bool operator==(const Position& other) const {
return ((x == other.x) && (y == other.y));
}
};
struct Velocity {
int xVel, yVel;
};
struct Accel {
int terminalVelocity, speedUp, sloDown;
};
struct Event {
unsigned event_id = 0; // default: null event
std::string title; // "Cours magistral: MAA205".
std::string description; // "Tous les étudiants."
unsigned start_time; // in absolute_minute, 930 (15:30)
unsigned end_time; // in absolute_minute, 1050 (17:30)
};
struct Day {
unsigned day_id;
std::vector<Event> events;
// TODO: Tasks.
// TODO: Map modifications.
};
struct SDLRectCompare {
bool operator()(const SDL_Rect& r1, const SDL_Rect& r2) const {
if (r1.x != r2.x)
{
return r1.x < r2.x;
}
if (r1.y != r2.y)
{
return r1.y < r2.y;
}
if (r1.w != r2.w)
{
return r1.w < r2.w;
}
return r1.h < r2.h;
}
};
| 19.810811 | 64 | 0.560709 |
b32024ada7733bcafa7c73c0f618b69c7c74106c | 4,266 | h | C | cocos2dx/CCConfiguration.h | CBE7F1F65/fb43b70cb3d36ad8b8ee3a9aed9c6493 | da25260dc8128ed66b48d391c738eb15134d7d4f | [
"Zlib",
"MIT-0",
"MIT"
] | null | null | null | cocos2dx/CCConfiguration.h | CBE7F1F65/fb43b70cb3d36ad8b8ee3a9aed9c6493 | da25260dc8128ed66b48d391c738eb15134d7d4f | [
"Zlib",
"MIT-0",
"MIT"
] | null | null | null | cocos2dx/CCConfiguration.h | CBE7F1F65/fb43b70cb3d36ad8b8ee3a9aed9c6493 | da25260dc8128ed66b48d391c738eb15134d7d4f | [
"Zlib",
"MIT-0",
"MIT"
] | null | null | null | /****************************************************************************
Copyright (c) 2010-2011 cocos2d-x.org
Copyright (c) 2010 Ricardo Quesada
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#ifndef __CCCONFIGURATION_H__
#define __CCCONFIGURATION_H__
#include "CCObject.h"
#include <string>
#include "CCGL.h"
namespace cocos2d {
/** OS version definitions. Includes both iOS and Mac OS versions
*/
enum {
kCCiOSVersion_3_0 = 0x03000000,
kCCiOSVersion_3_1 = 0x03010000,
kCCiOSVersion_3_1_1 = 0x03010100,
kCCiOSVersion_3_1_2 = 0x03010200,
kCCiOSVersion_3_1_3 = 0x03010300,
kCCiOSVersion_3_2 = 0x03020000,
kCCiOSVersion_3_2_1 = 0x03020100,
kCCiOSVersion_4_0 = 0x04000000,
kCCiOSVersion_4_0_1 = 0x04000100,
kCCiOSVersion_4_1 = 0x04010000,
kCCMacVersion_10_5 = 0x0a050000,
kCCMacVersion_10_6 = 0x0a060000,
kCCMacVersion_10_7 = 0x0a070000,
};
typedef enum
{
GLES_VER_INVALID,
GLES_VER_1_0,
GLES_VER_1_1,
GLES_VER_2_0
} CCGlesVersion;
/**
@brief CCConfiguration contains some openGL variables
@since v0.99.0
*/
class CC_DLL CCConfiguration : public CCObject
{
protected:
GLint m_nMaxTextureSize;
GLint m_nMaxModelviewStackDepth;
bool m_bSupportsPVRTC;
bool m_bSupportsNPOT;
bool m_bSupportsBGRA8888;
bool m_bSupportsDiscardFramebuffer;
bool m_bInited;
unsigned int m_uOSVersion;
GLint m_nMaxSamplesAllowed;
char * m_pGlExtensions;
private:
CCConfiguration(void);
public:
CCGlesVersion getGlesVersion();
/** OpenGL Max texture size. */
inline int getMaxTextureSize(void)
{
return m_nMaxTextureSize;
}
/** OpenGL Max Modelview Stack Depth */
inline int getMaxModelviewStackDepth(void)
{
return m_nMaxModelviewStackDepth;
}
/** Whether or not the GPU supports NPOT (Non Power Of Two) textures.
NPOT textures have the following limitations:
- They can't have mipmaps
- They only accept GL_CLAMP_TO_EDGE in GL_TEXTURE_WRAP_{S,T}
@since v0.99.2
*/
inline bool isSupportsNPOT(void)
{
return m_bSupportsNPOT;
}
/** Whether or not PVR Texture Compressed is supported */
inline bool isSupportsPVRTC(void)
{
return m_bSupportsPVRTC;
}
/** Whether or not BGRA8888 textures are supported.
@since v0.99.2
*/
inline bool isSupportsBGRA8888(void)
{
return m_bSupportsBGRA8888;
}
/** Whether or not glDiscardFramebufferEXT is supported
@since v0.99.2
*/
inline bool isSupportsDiscardFramebuffer(void)
{
return m_bSupportsDiscardFramebuffer;
}
/** returns the OS version.
- On iOS devices it returns the firmware version.
- On Mac returns the OS version
@since v0.99.5
*/
inline unsigned int getOSVersion() { return m_uOSVersion; }
/** returns whether or not an OpenGL is supported */
bool checkForGLExtension(const std::string &searchName);
bool init(void);
public:
/** returns a shared instance of the CCConfiguration */
static CCConfiguration *sharedConfiguration(void);
};
}//namespace cocos2d
#endif // __CCCONFIGURATION_H__
| 27.701299 | 78 | 0.701125 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.